package server import ( "context" "crypto/tls" "fmt" "net" "net/http" "net/url" "go.uber.org/zap" ) type Server struct { isRunning bool server *http.Server logger *zap.Logger cert *tls.Certificate hostname string handlers HandlerPatternMap portManger *timeoutManager } func NewServer(cert *tls.Certificate, hostname string, afterPortChanged func(int), logger *zap.Logger) Server { return Server{ logger: logger, cert: cert, hostname: hostname, portManger: newPortManager(logger.Named("Server"), afterPortChanged), timeoutManager: newTimeoutManager(), } } func (s *Server) getHost() string { return fmt.Sprintf("%s:%d", s.hostname, s.GetPort()) } func (s *Server) GetHostname() string { return s.hostname } func (s *Server) GetCert() *tls.Certificate { return s.cert } func (s *Server) GetLogger() *zap.Logger { return s.logger } func (s *Server) mustGetHost() string { return fmt.Sprintf("%s:%d", s.hostname, s.MustGetPort()) } func (s *Server) listenAndServe() { cfg := &tls.Config{Certificates: []tls.Certificate{*s.cert}, ServerName: s.hostname, MinVersion: tls.VersionTLS12} // in case of restart, we should use the same port as the first start in order not to break existing links listener, err := tls.Listen("tcp", s.getHost(), cfg) if err != nil { s.logger.Error("failed to start server, retrying", zap.Error(err)) s.ResetPort() err = s.Start() if err != nil { s.logger.Error("server start failed, giving up", zap.Error(err)) } return } err = s.SetPort(listener.Addr().(*net.TCPAddr).Port) if err != nil { s.logger.Error("failed to set Server.port", zap.Error(err)) return } s.isRunning = true s.StartTimeout(func() { err := s.Stop() if err != nil { s.logger.Error("PairingServer termination fail", zap.Error(err)) } }) err = s.server.Serve(listener) if err != http.ErrServerClosed { s.logger.Error("server failed unexpectedly, restarting", zap.Error(err)) err = s.Start() if err != nil { s.logger.Error("server start failed, giving up", zap.Error(err)) } return } s.isRunning = false } func (s *Server) resetServer() { s.StopTimeout() s.server = new(http.Server) s.ResetPort() } func (s *Server) applyHandlers() { if s.server == nil { s.server = new(http.Server) } mux := http.NewServeMux() for p, h := range s.handlers { mux.HandleFunc(p, h) } s.server.Handler = mux } func (s *Server) Start() error { // Once Shutdown has been called on a server, it may not be reused; s.resetServer() s.applyHandlers() go s.listenAndServe() return nil } func (s *Server) Stop() error { s.StopTimeout() if s.server != nil { return s.server.Shutdown(context.Background()) } return nil } func (s *Server) IsRunning() bool { return s.isRunning } func (s *Server) ToForeground() { if !s.isRunning && (s.server != nil) { err := s.Start() if err != nil { s.logger.Error("server start failed during foreground transition", zap.Error(err)) } } } func (s *Server) ToBackground() { if s.isRunning { err := s.Stop() if err != nil { s.logger.Error("server stop failed during background transition", zap.Error(err)) } } } func (s *Server) SetHandlers(handlers HandlerPatternMap) { s.handlers = handlers } func (s *Server) AddHandlers(handlers HandlerPatternMap) { if s.handlers == nil { s.handlers = make(HandlerPatternMap) } for name := range handlers { s.handlers[name] = handlers[name] } } func (s *Server) MakeBaseURL() *url.URL { return &url.URL{ Scheme: "https", Host: s.mustGetHost(), } }