package server import ( "context" "fmt" "net" "net/http" "net/url" "os" "slices" "time" cfg "website/internal/config" "website/internal/log" "website/internal/website" "github.com/getsentry/sentry-go" sentryhttp "github.com/getsentry/sentry-go/http" "github.com/pkg/errors" "golang.org/x/net/http2" "golang.org/x/net/http2/h2c" ) var ( CommitSHA = "local" ShortSHA = "local" serverHeader = fmt.Sprintf("website (%s)", ShortSHA) ) type Config struct { Production bool `conf:"default:false"` InDevServer bool `conf:"default:false"` Root string `conf:"default:website"` ListenAddress string `conf:"default:localhost"` Port string `conf:"default:3000,short:p"` } type Server struct { *http.Server } func applyDevModeOverrides(config *cfg.Config, listenAddress string) { config.CSP.ScriptSrc = slices.Insert(config.CSP.ScriptSrc, 0, "'unsafe-inline'") config.CSP.ConnectSrc = slices.Insert(config.CSP.ConnectSrc, 0, "'self'") config.BaseURL = cfg.URL{ URL: &url.URL{ Scheme: "http", Host: listenAddress, }, } } func serverHeaderHandler(wrappedHandler http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if r.ProtoMajor >= 2 && r.Header.Get("Host") != "" { // net/http does this for HTTP/1.1, but not h2c // TODO: check with HTTP/2.0 (i.e. with TLS) r.Host = r.Header.Get("Host") r.Header.Del("Host") } w.Header().Set("Server", serverHeader) wrappedHandler.ServeHTTP(w, r) }) } func New(runtimeConfig *Config) (*Server, error) { var err error config, err := cfg.GetConfig() if err != nil { return nil, errors.WithMessage(err, "error parsing configuration file") } listenAddress := net.JoinHostPort(runtimeConfig.ListenAddress, runtimeConfig.Port) env := "development" if runtimeConfig.Production { env = "production" } else { applyDevModeOverrides(config, listenAddress) } err = sentry.Init(sentry.ClientOptions{ EnableTracing: true, TracesSampleRate: 1.0, Dsn: os.Getenv("SENTRY_DSN"), Release: CommitSHA, Environment: env, }) if err != nil { return nil, errors.WithMessage(err, "could not set up sentry") } defer sentry.Flush(2 * time.Second) sentryHandler := sentryhttp.New(sentryhttp.Options{ Repanic: true, }) top := http.NewServeMux() mux, err := website.NewMux(config, runtimeConfig.Root) if err != nil { return nil, errors.Wrap(err, "could not create website mux") } log.Debug("binding main handler to", "host", listenAddress) hostname := config.BaseURL.Hostname() top.Handle(hostname+"/", mux) top.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { newURL := config.BaseURL.JoinPath(r.URL.String()) http.Redirect(w, r, newURL.String(), 301) }) top.HandleFunc("/health", func(w http.ResponseWriter, _ *http.Request) { w.WriteHeader(http.StatusNoContent) }) return &Server{ &http.Server{ Addr: listenAddress, ReadHeaderTimeout: 1 * time.Minute, Handler: http.MaxBytesHandler(h2c.NewHandler( sentryHandler.Handle( serverHeaderHandler( wrapHandlerWithLogging(top), ), ), &http2.Server{ IdleTimeout: 15 * time.Minute, }, ), 0), }, }, nil } func (s *Server) Start() error { if err := s.ListenAndServe(); err != http.ErrServerClosed { return errors.Wrap(err, "error creating/closing server") } return nil } func (s *Server) Stop() chan struct{} { log.Debug("stop called") idleConnsClosed := make(chan struct{}) go func() { log.Debug("shutting down server") ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) defer cancel() err := s.Server.Shutdown(ctx) log.Debug("server shut down") if err != nil { // Error from closing listeners, or context timeout: log.Warn("HTTP server Shutdown", "error", err) } close(idleConnsClosed) }() return idleConnsClosed }