Initial commit

main.go

@@ -0,0 +1,174 @@
+// Command send is a small self-hosted file drop: uploads land in a flat data
+// directory, expire on their own, and are served back as inert attachments.
+package main
+
+import (
+	"context"
+	"errors"
+	"flag"
+	"fmt"
+	"log/slog"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"send/internal/auth"
+	"send/internal/config"
+	"send/internal/server"
+	"send/internal/store"
+)
+
+func main() {
+	if err := run(os.Args[1:]); err != nil {
+		if errors.Is(err, flag.ErrHelp) {
+			os.Exit(0)
+		}
+		fmt.Fprintln(os.Stderr, "send: "+err.Error())
+		os.Exit(1)
+	}
+}
+
+func run(args []string) error {
+	if len(args) > 0 && args[0] == "token" {
+		return tokenCommand(args[1:])
+	}
+	return serve(args)
+}
+
+const serveUsage = `send - a small self-hosted file drop
+
+Usage:
+  send [options]                 run the server
+  send token add <name> [opts]   mint a token, printing it once
+  send token list                list tokens
+  send token rm <name>           remove a token
+
+Options take one hyphen with a single letter (-s) and two with a full
+word (--max-size). Every option can also be set from the environment.
+
+Options:
+`
+
+func serve(args []string) error {
+	var cfg config.Config
+	fs := config.NewSet("send", config.EnvPrefix)
+	fs.SetOutput(os.Stderr)
+	cfg.Register(fs)
+
+	if err := fs.Parse(args); err != nil {
+		if errors.Is(err, flag.ErrHelp) {
+			fs.PrintUsage(os.Stdout, serveUsage)
+			return flag.ErrHelp
+		}
+		return err
+	}
+	if err := cfg.Normalise(); err != nil {
+		return err
+	}
+
+	setUmask()
+	log := slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: slog.LevelInfo}))
+
+	st, err := store.Open(cfg.DataDir)
+	if err != nil {
+		return fmt.Errorf("opening data directory: %w", err)
+	}
+	defer st.Close()
+
+	tokens, err := auth.Load(cfg.TokensPath)
+	if err != nil {
+		return fmt.Errorf("loading tokens: %w", err)
+	}
+	srv, err := server.New(&cfg, st, tokens, log)
+	if err != nil {
+		return err
+	}
+
+	httpSrv := &http.Server{
+		Addr:    cfg.Listen,
+		Handler: srv,
+		// ReadTimeout and WriteTimeout are deliberately left unset: a
+		// legitimate multi-gigabyte upload on a slow line would trip any value
+		// large enough to be safe. Stalled connections are dropped by the
+		// per-read deadline the upload handler maintains instead.
+		ReadHeaderTimeout: 20 * time.Second,
+		IdleTimeout:       2 * time.Minute,
+		MaxHeaderBytes:    1 << 16,
+		ErrorLog:          slog.NewLogLogger(log.Handler(), slog.LevelWarn),
+	}
+
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
+	defer stop()
+
+	go sweep(ctx, st, cfg.SweepInterval, log)
+	go reloadOnHUP(ctx, tokens, log)
+
+	log.Info("listening",
+		"addr", cfg.Listen, "data", cfg.DataDir, "base", cfg.BasePath,
+		"objects", st.Count(), "stored", config.FormatBytes(st.Total()),
+		"max_size", config.FormatSize(cfg.MaxSize),
+		"max_expiry", config.FormatDuration(cfg.MaxExpiry))
+
+	errc := make(chan error, 1)
+	go func() {
+		err := httpSrv.ListenAndServe()
+		if errors.Is(err, http.ErrServerClosed) {
+			err = nil
+		}
+		errc <- err
+	}()
+
+	select {
+	case err := <-errc:
+		return err
+	case <-ctx.Done():
+		log.Info("shutting down")
+		// Uploads in flight get a moment to finish; the store's own crash
+		// recovery handles whatever does not.
+		shutdownCtx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
+		defer cancel()
+		return httpSrv.Shutdown(shutdownCtx)
+	}
+}
+
+// sweep removes expired objects on a timer. Reads check expiry independently,
+// so this is about reclaiming disk, not about correctness.
+func sweep(ctx context.Context, st *store.Store, every time.Duration, log *slog.Logger) {
+	if n := st.Sweep(time.Now()); n > 0 {
+		log.Info("swept expired objects", "count", n)
+	}
+	t := time.NewTicker(every)
+	defer t.Stop()
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case now := <-t.C:
+			if n := st.Sweep(now); n > 0 {
+				log.Info("swept expired objects", "count", n)
+			}
+		}
+	}
+}
+
+// reloadOnHUP re-reads the token file on SIGHUP, so credentials can be changed
+// without dropping uploads in flight.
+func reloadOnHUP(ctx context.Context, tokens *auth.File, log *slog.Logger) {
+	ch := make(chan os.Signal, 1)
+	signal.Notify(ch, syscall.SIGHUP)
+	defer signal.Stop(ch)
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-ch:
+			if err := tokens.Reload(); err != nil {
+				log.Error("reloading tokens", "err", err)
+				continue
+			}
+			log.Info("reloaded tokens", "count", len(tokens.List()))
+		}
+	}
+}