package server import ( "context" "fmt" "net" "net/http" "net/url" "slices" "time" "website/internal/builder" cfg "website/internal/config" "website/internal/listenfd" "website/internal/log" "website/internal/website" "github.com/osdevisnot/sorvor/pkg/livereload" "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 { Development bool `conf:"default:false,flag:dev"` 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 updateCSPHashes(config *cfg.Config, r *builder.Result) { clear(config.CSP.StyleSrc) for i, h := range r.Hashes { config.CSP.StyleSrc[i] = fmt.Sprintf("'%s'", h) } } 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) top := http.NewServeMux() if runtimeConfig.Development { applyDevModeOverrides(config, listenAddress) builderConfig := builder.IOConfig{ Source: "content", Destination: runtimeConfig.Root, BaseURL: config.BaseURL, Development: true, } r, err := builder.BuildSite(builderConfig) if err != nil { return nil, errors.WithMessage(err, "could not build site") } updateCSPHashes(config, r) liveReload := livereload.New() top.Handle("/_/reload", liveReload) liveReload.Start() fw, err := NewFileWatcher() if err != nil { return nil, errors.WithMessage(err, "could not create file watcher") } for _, dir := range []string{"content", "static", "templates"} { err := fw.AddRecursive(dir) if err != nil { return nil, errors.WithMessagef( err, "could not add directory %s to file watcher", dir, ) } } go fw.Start(func(filename string) { log.Debug("file updated", "filename", filename) r, err := builder.BuildSite(builderConfig) if err != nil { log.Error("could not build site", "error", err) } updateCSPHashes(config, r) liveReload.Reload() }) } loggingMux := 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() loggingMux.Handle(hostname+"/", mux) loggingMux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { newURL := config.BaseURL.JoinPath(r.URL.String()) http.Redirect(w, r, newURL.String(), 301) }) top.Handle("/", serverHeaderHandler( wrapHandlerWithLogging(loggingMux), ), ) 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( top, &http2.Server{ IdleTimeout: 15 * time.Minute, }, ), 0), }, }, nil } func (s *Server) Start() error { l, err := listenfd.GetListener(0) if err != nil { log.Warn("could not create listener from listenfd", "error", err) } if l == nil { l, err = net.Listen("tcp", s.Addr) if err != nil { return errors.Wrap(err, "could not create listener") } } if err := http.Serve(l, s.Handler); 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 }