125 lines
2.7 KiB
Go
125 lines
2.7 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"os/signal"
|
|
"strings"
|
|
"syscall"
|
|
"time"
|
|
|
|
"github.com/joho/godotenv"
|
|
|
|
"plumber"
|
|
"plumber/internal/blob"
|
|
"plumber/internal/store"
|
|
"plumber/internal/web"
|
|
)
|
|
|
|
func main() {
|
|
_ = godotenv.Load()
|
|
|
|
st := openStore()
|
|
defer st.Close()
|
|
|
|
uploader := spacesUploader()
|
|
logSpaces(uploader)
|
|
|
|
handler := newHandler(st, uploader)
|
|
run(&http.Server{Addr: listenAddr(), Handler: handler})
|
|
}
|
|
|
|
func openStore() *store.Store {
|
|
databaseURL := strings.TrimSpace(os.Getenv("DATABASE_URL"))
|
|
if databaseURL == "" {
|
|
log.Fatal("DATABASE_URL is required")
|
|
}
|
|
st, err := store.OpenPostgres(databaseURL, plumber.SchemaSQL)
|
|
if err != nil {
|
|
log.Fatalf("database: %v", err)
|
|
}
|
|
log.Printf("database: postgres")
|
|
return st
|
|
}
|
|
|
|
func logSpaces(uploader blob.Uploader) {
|
|
if uploader.Enabled() {
|
|
log.Printf("avatars: digitalocean spaces")
|
|
return
|
|
}
|
|
log.Printf("avatars: uploads disabled (set SPACES_* to enable)")
|
|
}
|
|
|
|
func newHandler(st *store.Store, uploader blob.Uploader) http.Handler {
|
|
srv, err := web.New(st, st.SessionStore(), plumber.TemplateFS, plumber.StaticFS, web.Config{
|
|
AdminUsername: os.Getenv("ADMIN_USERNAME"),
|
|
SecureCookie: os.Getenv("SECURE_COOKIE") == "1",
|
|
Blob: uploader,
|
|
})
|
|
if err != nil {
|
|
log.Fatalf("server: %v", err)
|
|
}
|
|
return srv.Handler()
|
|
}
|
|
|
|
func run(httpSrv *http.Server) {
|
|
errCh := make(chan error, 1)
|
|
go func() {
|
|
log.Printf("listening on %s", httpSrv.Addr)
|
|
errCh <- httpSrv.ListenAndServe()
|
|
}()
|
|
|
|
sigCh := make(chan os.Signal, 1)
|
|
signal.Notify(sigCh, os.Interrupt, syscall.SIGTERM)
|
|
|
|
select {
|
|
case err := <-errCh:
|
|
if err != nil && !errors.Is(err, http.ErrServerClosed) {
|
|
log.Fatal(err)
|
|
}
|
|
case sig := <-sigCh:
|
|
log.Printf("shutdown signal: %v", sig)
|
|
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
|
defer cancel()
|
|
if err := httpSrv.Shutdown(ctx); err != nil {
|
|
log.Printf("shutdown: %v", err)
|
|
}
|
|
if err := <-errCh; err != nil && !errors.Is(err, http.ErrServerClosed) {
|
|
log.Fatal(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func spacesUploader() blob.Uploader {
|
|
return blob.NewSpaces(blob.SpacesConfig{
|
|
Key: os.Getenv("SPACES_KEY"),
|
|
Secret: os.Getenv("SPACES_SECRET"),
|
|
Region: os.Getenv("SPACES_REGION"),
|
|
Bucket: os.Getenv("SPACES_BUCKET"),
|
|
Endpoint: os.Getenv("SPACES_ENDPOINT"),
|
|
CDNBase: os.Getenv("SPACES_CDN_BASE"),
|
|
})
|
|
}
|
|
|
|
// listenAddr prefers PORT (App Platform / PaaS), then LISTEN, then :8080.
|
|
func listenAddr() string {
|
|
if p := strings.TrimSpace(os.Getenv("PORT")); p != "" {
|
|
if strings.HasPrefix(p, ":") {
|
|
return p
|
|
}
|
|
return ":" + p
|
|
}
|
|
return env("LISTEN", ":8080")
|
|
}
|
|
|
|
func env(key, fallback string) string {
|
|
v := strings.TrimSpace(os.Getenv(key))
|
|
if v == "" {
|
|
return fallback
|
|
}
|
|
return v
|
|
}
|