package main import ( "fmt" "hash/fnv" "io" "io/fs" "log" "log/slog" "mime" "net" "net/http" "os" "path/filepath" "strings" "time" cfg "website/internal/config" "github.com/ardanlabs/conf/v3" "github.com/getsentry/sentry-go" sentryhttp "github.com/getsentry/sentry-go/http" "github.com/pkg/errors" "github.com/shengyanli1982/law" ) type Config struct { Production bool `conf:"default:false"` ListenAddress string `conf:"default:localhost"` Port uint16 `conf:"default:3000,short:p"` BaseURL cfg.URL `conf:"default:http://localhost:3000,short:b"` RedirectOtherHostnames bool `conf:"default:false"` } var Commit string var config *cfg.Config type File struct { filename string etag string } var files = map[string]File{} func hashFile(filename string) (string, error) { f, err := os.Open(filename) if err != nil { return "", err } defer f.Close() hash := fnv.New64a() if _, err := io.Copy(hash, f); err != nil { return "", err } return fmt.Sprintf(`W/"%x"`, hash.Sum(nil)), nil } func registerFile(urlpath string, filepath string) error { if files[urlpath] != (File{}) { log.Printf("registerFile called with duplicate file, urlPath: %s", urlpath) return nil } hash, err := hashFile(filepath) if err != nil { return err } files[urlpath] = File{ filename: filepath, etag: hash, } return nil } func registerContentFiles(root string) error { err := filepath.WalkDir(root, func(filePath string, f fs.DirEntry, err error) error { if err != nil { return errors.WithMessagef(err, "failed to access path %s", filePath) } relPath, err := filepath.Rel(root, filePath) if err != nil { return errors.WithMessagef(err, "failed to make path relative, path: %s", filePath) } urlPath, _ := strings.CutSuffix(relPath, "index.html") if !f.IsDir() { slog.Debug("registering file", "urlpath", "/"+urlPath) return registerFile("/"+urlPath, filePath) } return nil }) if err != nil { return err } return nil } type HTTPError struct { Error error Message string Code int } func canonicalisePath(path string) (cPath string, differs bool) { cPath = path if strings.HasSuffix(path, "/index.html") { cPath, differs = strings.CutSuffix(path, "index.html") } else if !strings.HasSuffix(path, "/") && files[path+"/"] != (File{}) { cPath, differs = path+"/", true } return cPath, differs } func serveFile(w http.ResponseWriter, r *http.Request) *HTTPError { urlPath, shouldRedirect := canonicalisePath(r.URL.Path) if shouldRedirect { http.Redirect(w, r, urlPath, 302) return nil } file := files[urlPath] if file == (File{}) { return &HTTPError{ Message: "File not found", Code: http.StatusNotFound, } } w.Header().Add("ETag", file.etag) w.Header().Add("Vary", "Accept-Encoding") for k, v := range config.Extra.Headers { w.Header().Add(k, v) } http.ServeFile(w, r, files[urlPath].filename) return nil } type webHandler func(http.ResponseWriter, *http.Request) *HTTPError func (fn webHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { defer func() { if fail := recover(); fail != nil { w.WriteHeader(http.StatusInternalServerError) slog.Error("runtime panic!", "error", fail) } }() w.Header().Set("Server", fmt.Sprintf("website (%s)", Commit)) if err := fn(w, r); err != nil { if strings.Contains(r.Header.Get("Accept"), "text/html") { w.WriteHeader(err.Code) notFoundPage := "website/private/404.html" http.ServeFile(w, r, notFoundPage) } else { http.Error(w, err.Message, err.Code) } } } var newMIMEs = map[string]string{ ".xsl": "text/xsl", } func fixupMIMETypes() { for ext, newType := range newMIMEs { if err := mime.AddExtensionType(ext, newType); err != nil { slog.Error("could not update mime type", "ext", ext, "mime", newType) } } } type loggingResponseWriter struct { http.ResponseWriter statusCode int } func (lrw *loggingResponseWriter) WriteHeader(code int) { lrw.statusCode = code // avoids warning: superfluous response.WriteHeader call if lrw.statusCode != http.StatusOK { lrw.ResponseWriter.WriteHeader(code) } } func NewLoggingResponseWriter(w http.ResponseWriter) *loggingResponseWriter { return &loggingResponseWriter{w, http.StatusOK} } type wrappedHandlerOptions struct { defaultHostname string logger io.Writer } func wrapHandlerWithLogging(wrappedHandler http.Handler, opts wrappedHandlerOptions) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { scheme := r.Header.Get("X-Forwarded-Proto") if scheme == "" { scheme = "http" } host := r.Header.Get("Host") if host == "" { host = opts.defaultHostname } lw := NewLoggingResponseWriter(w) wrappedHandler.ServeHTTP(lw, r) statusCode := lw.statusCode fmt.Fprintf( opts.logger, "%s %s %d %s %s %s\n", scheme, r.Method, statusCode, host, r.URL.Path, lw.Header().Get("Location"), ) }) } func main() { if os.Getenv("DEBUG") != "" { slog.SetLogLoggerLevel(slog.LevelDebug) } fixupMIMETypes() runtimeConfig := Config{} help, err := conf.Parse("", &runtimeConfig) if err != nil { if errors.Is(err, conf.ErrHelpWanted) { fmt.Println(help) os.Exit(1) } log.Panicf("parsing runtime configuration: %v", err) } config, err = cfg.GetConfig() if err != nil { log.Panicf("parsing configuration file: %v", err) } cwd, err := os.Getwd() if err != nil { log.Panicf("don't know where I am") } slog.Debug("starting at", "wd", cwd) prefix := "website/public" slog.Debug("registering content files", "prefix", prefix) err = registerContentFiles(prefix) if err != nil { log.Panicf("registering content files: %v", err) } env := "development" if runtimeConfig.Production { env = "production" } err = sentry.Init(sentry.ClientOptions{ EnableTracing: true, TracesSampleRate: 1.0, Dsn: os.Getenv("SENTRY_DSN"), Release: Commit, Environment: env, }) if err != nil { log.Panic("could not set up sentry") } defer sentry.Flush(2 * time.Second) sentryHandler := sentryhttp.New(sentryhttp.Options{ Repanic: true, }) mux := http.NewServeMux() slog.Debug("binding main handler to", "host", runtimeConfig.BaseURL.Hostname()+"/") mux.Handle(runtimeConfig.BaseURL.Hostname()+"/", webHandler(serveFile)) mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { newURL := runtimeConfig.BaseURL.String() + r.URL.String() http.Redirect(w, r, newURL, 301) }) var logWriter io.Writer if runtimeConfig.Production { logWriter = law.NewWriteAsyncer(os.Stdout, nil) } else { logWriter = os.Stdout } http.Handle("/", sentryHandler.Handle( wrapHandlerWithLogging(mux, wrappedHandlerOptions{ defaultHostname: runtimeConfig.BaseURL.Hostname(), logger: logWriter, }), ), ) // no logging, no sentry http.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) }) listenAddress := net.JoinHostPort(runtimeConfig.ListenAddress, fmt.Sprint(runtimeConfig.Port)) log.Fatal(http.ListenAndServe(listenAddress, nil)) }