113 lines
3.3 KiB
Go
113 lines
3.3 KiB
Go
package app
|
|
|
|
import (
|
|
"context"
|
|
"crypto/tls"
|
|
"errors"
|
|
"fmt"
|
|
"net"
|
|
"strings"
|
|
"time"
|
|
|
|
"git.yuntuo.hk/k2safe/go-omni/config"
|
|
"git.yuntuo.hk/k2safe/go-omni/internal/httplimits"
|
|
h2transport "git.yuntuo.hk/k2safe/go-omni/transport/http2"
|
|
"git.yuntuo.hk/k2safe/go-omni/transport/native"
|
|
)
|
|
|
|
// ServeContext serves a caller-created listener using the configured transport
|
|
// and TLS. App takes ownership of the listener, including on startup failure,
|
|
// and runs resource cleanup only after admitted handlers have returned.
|
|
func (a *App) ServeContext(ctx context.Context, listener net.Listener) (runErr error) {
|
|
defer func() { runErr = shutdownResult(ctx, runErr) }()
|
|
if listener == nil {
|
|
return errors.Join(errors.New("go-omni: nil listener"), a.Close())
|
|
}
|
|
defer listener.Close()
|
|
if ctx == nil {
|
|
ctx = context.Background()
|
|
}
|
|
if ctx.Err() != nil {
|
|
_ = listener.Close()
|
|
return a.Close()
|
|
}
|
|
stopWatching := a.watchShutdown(ctx)
|
|
defer stopWatching()
|
|
serve, err := a.prepareTransport()
|
|
if err != nil {
|
|
_ = listener.Close()
|
|
return errors.Join(err, a.Close())
|
|
}
|
|
return errors.Join(serve(ctx, listener), a.Close())
|
|
}
|
|
|
|
func (a *App) prepareTransport() (func(context.Context, net.Listener) error, error) {
|
|
if err := a.ValidateHTTP(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := a.config.ValidateTransport(); err != nil {
|
|
return nil, err
|
|
}
|
|
shutdownTimeout := a.config.ShutdownTimeout
|
|
if shutdownTimeout <= 0 {
|
|
shutdownTimeout = 10 * time.Second
|
|
}
|
|
var tlsConfig *tls.Config
|
|
if strings.TrimSpace(a.config.TLS.CertFile) != "" {
|
|
certificate, err := tls.LoadX509KeyPair(a.config.TLS.CertFile, a.config.TLS.KeyFile)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("go-omni: load TLS certificate: %w", err)
|
|
}
|
|
tlsConfig = &tls.Config{Certificates: []tls.Certificate{certificate}, MinVersion: tls.VersionTLS12}
|
|
}
|
|
switch a.config.Transport {
|
|
case config.TransportNative:
|
|
server := native.New(a)
|
|
// App enforces the service/route policy after routing. Keep only the
|
|
// supported framing ceiling here, never a hidden smaller transport cap.
|
|
server.MaxBodyBytes = httplimits.MaxBodyBytes
|
|
server.ShutdownTimeout = shutdownTimeout
|
|
cfg := a.config.HTTP
|
|
if cfg.ReadHeaderTimeout > 0 {
|
|
server.ReadHeaderTimeout = cfg.ReadHeaderTimeout
|
|
}
|
|
if cfg.ReadTimeout > 0 {
|
|
server.ReadTimeout = cfg.ReadTimeout
|
|
}
|
|
if cfg.WriteTimeout > 0 {
|
|
server.WriteTimeout = cfg.WriteTimeout
|
|
}
|
|
if cfg.IdleTimeout > 0 {
|
|
server.IdleTimeout = cfg.IdleTimeout
|
|
}
|
|
if cfg.MaxHeaderBytes > 0 {
|
|
server.MaxHeaderBytes = cfg.MaxHeaderBytes
|
|
}
|
|
if tlsConfig != nil {
|
|
return func(ctx context.Context, listener net.Listener) error {
|
|
return server.ServeTLS(ctx, listener, tlsConfig)
|
|
}, nil
|
|
}
|
|
return server.Serve, nil
|
|
case config.TransportHTTP2:
|
|
server := h2transport.New(a)
|
|
server.MaxBodyBytes = httplimits.MaxBodyBytes
|
|
server.ShutdownTimeout = shutdownTimeout
|
|
if a.config.HTTP.IdleTimeout > 0 {
|
|
server.IdleTimeout = a.config.HTTP.IdleTimeout
|
|
}
|
|
if a.config.HTTP.MaxHeaderBytes > 0 {
|
|
server.MaxHeaderBytes = a.config.HTTP.MaxHeaderBytes
|
|
}
|
|
return func(ctx context.Context, listener net.Listener) error {
|
|
return server.ServeTLS(ctx, listener, tlsConfig)
|
|
}, nil
|
|
default:
|
|
server := a.NewServer("")
|
|
server.TLSConfig = tlsConfig
|
|
return func(ctx context.Context, listener net.Listener) error {
|
|
return a.serveContext(ctx, server, listener)
|
|
}, nil
|
|
}
|
|
}
|