Move a lot of stuff around

Author: chriskuehl

.gitignore

@@ -1,3 +1,3 @@
 /dist
-/server/static/app.css
-/server/static/app.css.map
+/server/assets/static/app.css
+/server/assets/static/app.css.map

Makefile

@@ -39,11 +39,11 @@ server/static/app.css: $(wildcard scss/*.scss)
 	sass scss/app.scss $@
 
 .PHONY: assets
-assets: server/static/app.css
+assets: server/assets/static/app.css
 
 .PHONY: watch-assets
 watch-assets:
-	sass --watch scss/app.scss:server/static/app.css
+	sass --watch scss/app.scss:server/assets/static/app.css
 
 .PHONY: test
 test:

cmd/server/main.go

@@ -10,34 +10,27 @@ import (
 	"net/http"
 	"os"
 	"os/signal"
+	"strconv"
 	"time"
 
 	"github.com/chriskuehl/fluffy/server"
+	"github.com/chriskuehl/fluffy/server/config"
 	"github.com/chriskuehl/fluffy/server/logging"
 )
 
 var Version = "(dev)"
 
-type config struct {
-	*server.Config
-
-	host string
-	port string
-}
-
-func newConfigFromArgs(args []string) (*config, error) {
-	c := config{
-		Config: server.NewConfig(),
-	}
+func newConfigFromArgs(args []string) (*config.Config, error) {
+	c := server.NewConfig()
 	fs := flag.NewFlagSet("fluffy", flag.ExitOnError)
-	fs.StringVar(&c.host, "host", "localhost", "host to listen on")
-	fs.StringVar(&c.port, "port", "8080", "port to listen on")
+	fs.StringVar(&c.Host, "host", "localhost", "host to listen on")
+	fs.UintVar(&c.Port, "port", 8080, "port to listen on")
 	fs.BoolVar(&c.DevMode, "dev", false, "enable dev mode")
 	if err := fs.Parse(args); err != nil {
 		return nil, err
 	}
 	c.Version = Version
-	return &c, nil
+	return c, nil
 }
 
 func run(ctx context.Context, w io.Writer, args []string) error {
@@ -51,13 +44,13 @@ func run(ctx context.Context, w io.Writer, args []string) error {
 
 	logger := logging.NewSlogLogger(slog.New(slog.NewTextHandler(w, nil)))
 
-	handler, err := server.NewServer(logger, config.Config)
+	handler, err := server.NewServer(logger, config)
 	if err != nil {
 		return fmt.Errorf("creating server: %w", err)
 	}
 
 	httpServer := &http.Server{
-		Addr:    net.JoinHostPort(config.host, config.port),
+		Addr:    net.JoinHostPort(config.Host, strconv.FormatUint(uint64(config.Port), 10)),
 		Handler: handler,
 	}
 	go func() {

server/assets.go

@@ -0,0 +1,99 @@
+package assets
+
+import (
+	"crypto/sha256"
+	"embed"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"io/fs"
+	"path/filepath"
+	"strings"
+
+	"github.com/chriskuehl/fluffy/server/config"
+)
+
+//go:embed static/*
+var assetsFS embed.FS
+var assetHash = make(map[string]string)
+
+var mimeExtensions = []string{}
+
+func init() {
+	if err := fs.WalkDir(assetsFS, "static", func(path string, d fs.DirEntry, err error) error {
+		if d.IsDir() {
+			return nil
+		}
+
+		f, err := assetsFS.Open(path)
+		if err != nil {
+			return fmt.Errorf("opening %q: %w", path, err)
+		}
+		defer f.Close()
+
+		h := sha256.New()
+		if _, err := io.Copy(h, f); err != nil {
+			return fmt.Errorf("hashing %q: %w", path, err)
+		}
+		assetHash[path] = hex.EncodeToString(h.Sum(nil))
+		return nil
+	}); err != nil {
+		panic("loading asset hashes: " + err.Error())
+	}
+
+	if err := fs.WalkDir(assetsFS, "static/img/mime/small", func(path string, d fs.DirEntry, err error) error {
+		if d.IsDir() {
+			return nil
+		}
+		if !strings.HasSuffix(path, ".png") {
+			return nil
+		}
+
+		name := filepath.Base(path)
+		mimeExtensions = append(mimeExtensions, name[:len(name)-len(".png")])
+		return nil
+	}); err != nil {
+		panic("loading mime extensions: " + err.Error())
+	}
+}
+
+// AssetObjectPath returns the path to the asset in the object store.
+//
+// Keep in mind the object may not exist yet depending on when this function is called.
+func assetObjectPath(path, hash string) string {
+	return filepath.Join("static", hash, path)
+}
+
+// AssetURL returns the URL to the asset.
+//
+// In development mode, this will return a URL served by the fluffy server itself. In production,
+// this will return a URL to the object store.
+func AssetURL(c *config.Config, path string) (string, error) {
+	if c.DevMode {
+		url := c.HomeURL
+		url.Path = "/dev/static/" + path
+		return url.String(), nil
+	}
+
+	hash, ok := assetHash[filepath.Join("static", path)]
+	if !ok {
+		return "", fmt.Errorf("asset not found: %s", path)
+	}
+	url := c.ObjectURLPattern
+	url.Path = fmt.Sprintf(url.Path, assetObjectPath(path, hash))
+	return url.String(), nil
+}
+
+// AssetAsString returns the contents of the asset as a string.
+func AssetAsString(path string) (string, error) {
+	data, err := fs.ReadFile(assetsFS, filepath.Join("static", path))
+	if err != nil {
+		return "", fmt.Errorf("reading asset: %w", err)
+	}
+	return string(data), nil
+}
+
+// MimeExtensions returns a list of all the mime extensions, without dot, e.g. "png", "jpg".
+func MimeExtensions() []string {
+	return mimeExtensions
+}

server/assets/assets.go

@@ -0,0 +1,25 @@
+package assets
+
+import (
+	"net/http"
+	"strings"
+
+	"github.com/chriskuehl/fluffy/server/config"
+	"github.com/chriskuehl/fluffy/server/logging"
+)
+
+func HandleDevStatic(config *config.Config, logger logging.Logger) http.HandlerFunc {
+	if !config.DevMode {
+		return func(w http.ResponseWriter, r *http.Request) {
+			logger.Warn(r.Context(), "assets cannot be served from the server in production")
+			w.WriteHeader(http.StatusNotFound)
+			w.Write([]byte("Assets cannot be served from the server in production.\n"))
+		}
+	}
+
+	return func(w http.ResponseWriter, r *http.Request) {
+		strippedReq := r.Clone(r.Context())
+		strippedReq.URL.Path = strings.TrimPrefix(strippedReq.URL.Path, "/dev")
+		http.FileServer(http.FS(assetsFS)).ServeHTTP(w, strippedReq)
+	}
+}

server/assets/dev.go

@@ -0,0 +1,70 @@
+package config
+
+import (
+	"context"
+	"html/template"
+	"net/url"
+	"strings"
+
+	"github.com/chriskuehl/fluffy/server/storage/storagedata"
+)
+
+type StorageBackend interface {
+	StoreObject(ctx context.Context, obj storagedata.Object) error
+	StoreHTML(ctx context.Context, obj storagedata.Object) error
+}
+
+type Config struct {
+
+	// Site configuration.
+	StorageBackend          StorageBackend
+	Branding                string
+	CustomFooterHTML        template.HTML
+	AbuseContactEmail       string
+	MaxUploadBytes          int64
+	MaxMultipartMemoryBytes int64
+	HomeURL                 url.URL
+	ObjectURLPattern        url.URL
+	HTMLURLPattern          url.URL
+	ForbiddenFileExtensions map[string]struct{}
+
+	// Runtime options.
+	Host    string
+	Port    uint
+	DevMode bool
+	Version string
+}
+
+func (c *Config) Validate() []string {
+	var errs []string
+	if c.Branding == "" {
+		errs = append(errs, "Branding must not be empty")
+	}
+	if c.AbuseContactEmail == "" {
+		errs = append(errs, "AbuseContactEmail must not be empty")
+	}
+	if c.MaxUploadBytes <= 0 {
+		errs = append(errs, "MaxUploadBytes must be greater than 0")
+	}
+	if c.MaxMultipartMemoryBytes <= 0 {
+		errs = append(errs, "MaxMultipartMemoryBytes must be greater than 0")
+	}
+	if strings.HasSuffix(c.HomeURL.Path, "/") {
+		errs = append(errs, "HomeURL must not end with a slash")
+	}
+	if !strings.Contains(c.ObjectURLPattern.Path, "%s") {
+		errs = append(errs, "ObjectURLPattern must contain a '%s' placeholder")
+	}
+	if !strings.Contains(c.HTMLURLPattern.Path, "%s") {
+		errs = append(errs, "HTMLURLPattern must contain a '%s' placeholder")
+	}
+	for ext := range c.ForbiddenFileExtensions {
+		if strings.HasPrefix(ext, ".") {
+			errs = append(errs, "ForbiddenFileExtensions should not start with a dot: "+ext)
+		}
+	}
+	if c.Version == "" {
+		errs = append(errs, "Version must not be empty")
+	}
+	return errs
+}