2d07357a75
Prevents full server initialization and activation on broken connections and when Corteza can not listen for HTTP requests.
126 lines
2.5 KiB
Go
126 lines
2.5 KiB
Go
package server
|
|
|
|
import (
|
|
"context"
|
|
"net"
|
|
"net/http"
|
|
|
|
"github.com/cortezaproject/corteza-server/pkg/options"
|
|
"github.com/go-chi/chi/v5"
|
|
"go.uber.org/zap"
|
|
)
|
|
|
|
type (
|
|
server struct {
|
|
log *zap.Logger
|
|
opts *options.Options
|
|
endpoints []func(r chi.Router)
|
|
|
|
// last error
|
|
err error
|
|
|
|
demux *demux
|
|
}
|
|
)
|
|
|
|
const (
|
|
waiting uint32 = iota
|
|
active
|
|
shutdown
|
|
)
|
|
|
|
// New initializes new HTTP server with special powers
|
|
// Server is started as early as possible and with a special request handler
|
|
// that demultiplexes request to one of the configured routers according to the server state.
|
|
//
|
|
// Waiting state
|
|
// This is initial state with the ofllowing route handlers:
|
|
// - /version
|
|
// - /healthcheck
|
|
|
|
func New(log *zap.Logger, opts *options.Options) *server {
|
|
s := &server{
|
|
endpoints: make([]func(r chi.Router), 0),
|
|
log: log.Named("http"),
|
|
|
|
opts: opts,
|
|
}
|
|
|
|
s.demux = Demux(waiting, waitingRoutes(s.log.Named("waiting"), s.opts.HTTPServer))
|
|
s.demux.Router(shutdown, shutdownRoutes())
|
|
|
|
return s
|
|
}
|
|
|
|
func (s *server) LastError() error {
|
|
return s.err
|
|
}
|
|
|
|
func Test(o *options.Options) error {
|
|
listener, err := net.Listen("tcp", o.HTTPServer.Addr)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if err = listener.Close(); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// Activate reconfigures server to use active routes
|
|
func (s *server) Activate(mm ...func(chi.Router)) {
|
|
s.demux.Router(active, activeRoutes(s.log, mm, s.opts))
|
|
|
|
s.log.Debug("entering active state")
|
|
s.demux.State(active)
|
|
}
|
|
|
|
// Shutdown reconfigures server to use shutdown routes
|
|
func (s *server) Shutdown() {
|
|
s.log.Debug("entering shutdown state")
|
|
s.demux.State(shutdown)
|
|
}
|
|
|
|
func (s server) Serve(ctx context.Context) {
|
|
var (
|
|
listener net.Listener
|
|
)
|
|
|
|
s.log.Info(
|
|
"starting HTTP server",
|
|
|
|
zap.String("path-prefix", s.opts.HTTPServer.BaseUrl),
|
|
zap.String("address", s.opts.HTTPServer.Addr),
|
|
)
|
|
|
|
listener, s.err = net.Listen("tcp", s.opts.HTTPServer.Addr)
|
|
if s.err != nil {
|
|
s.log.Error("cannot start server", zap.Error(s.err))
|
|
return
|
|
}
|
|
|
|
go func() {
|
|
srv := http.Server{
|
|
Handler: s.demux,
|
|
|
|
// use root context as server's base context and as a basis for
|
|
// context for all requests
|
|
// this enables us to send cancellation down to every request
|
|
BaseContext: func(listener net.Listener) context.Context { return ctx },
|
|
}
|
|
s.err = srv.Serve(listener)
|
|
}()
|
|
<-ctx.Done()
|
|
|
|
if s.err == nil {
|
|
s.err = ctx.Err()
|
|
if s.err == context.Canceled {
|
|
s.err = nil
|
|
}
|
|
}
|
|
|
|
s.log.Info("HTTP server stopped", zap.Error(s.err))
|
|
}
|