initial. doesn't build yet

internal/config/config.go

@@ -0,0 +1,99 @@
+package config
+
+import (
+	"fmt"
+
+	"github.com/rs/zerolog"
+	"github.com/spf13/viper"
+	"go.uber.org/fx"
+	"sneak.berlin/go/directory/internal/globals"
+	"sneak.berlin/go/directory/internal/logger"
+
+	// spooky action at a distance!
+	// this populates the environment
+	// from a ./.env file automatically
+	// for development configuration.
+	// .env contents should be things like
+	// `DBURL=postgres://user:pass@.../`
+	// (without the backticks, of course)
+	_ "github.com/joho/godotenv/autoload"
+)
+
+type ConfigParams struct {
+	fx.In
+	Globals *globals.Globals
+	Logger  *logger.Logger
+}
+
+type Config struct {
+	DBURL            string
+	Debug            bool
+	MaintenanceMode  bool
+	DevelopmentMode  bool
+	DevAdminUsername string
+	DevAdminPassword string
+	MetricsPassword  string
+	MetricsUsername  string
+	Port             int
+	SentryDSN        string
+	params           *ConfigParams
+	log              *zerolog.Logger
+}
+
+func New(lc fx.Lifecycle, params ConfigParams) (*Config, error) {
+	log := params.Logger.Get()
+	name := params.Globals.Appname
+
+	viper.SetConfigName(name)
+	viper.SetConfigType("yaml")
+	// path to look for the config file in:
+	viper.AddConfigPath(fmt.Sprintf("/etc/%s", name))
+	// call multiple times to add many search paths:
+	viper.AddConfigPath(fmt.Sprintf("$HOME/.config/%s", name))
+	// viper.SetEnvPrefix(strings.ToUpper(s.appname))
+	viper.AutomaticEnv()
+
+	viper.SetDefault("DEBUG", "false")
+	viper.SetDefault("MAINTENANCE_MODE", "false")
+	viper.SetDefault("DEVELOPMENT_MODE", "false")
+	viper.SetDefault("DEV_ADMIN_USERNAME", "")
+	viper.SetDefault("DEV_ADMIN_PASSWORD", "")
+	viper.SetDefault("PORT", "8080")
+	viper.SetDefault("DBURL", "")
+	viper.SetDefault("SENTRY_DSN", "")
+	viper.SetDefault("METRICS_USERNAME", "")
+	viper.SetDefault("METRICS_PASSWORD", "")
+
+	if err := viper.ReadInConfig(); err != nil {
+		if _, ok := err.(viper.ConfigFileNotFoundError); ok {
+			// Config file not found; ignore error if desired
+		} else {
+			// Config file was found but another error was produced
+			log.Panic().
+				Err(err).
+				Msg("config file malformed")
+		}
+	}
+
+	s := &Config{
+		DBURL:            viper.GetString("DBURL"),
+		Debug:            viper.GetBool("debug"),
+		Port:             viper.GetInt("PORT"),
+		SentryDSN:        viper.GetString("SENTRY_DSN"),
+		MaintenanceMode:  viper.GetBool("MAINTENANCE_MODE"),
+		DevelopmentMode:  viper.GetBool("DEVELOPMENT_MODE"),
+		DevAdminUsername: viper.GetString("DEV_ADMIN_USERNAME"),
+		DevAdminPassword: viper.GetString("DEV_ADMIN_PASSWORD"),
+		MetricsUsername:  viper.GetString("METRICS_USERNAME"),
+		MetricsPassword:  viper.GetString("METRICS_PASSWORD"),
+		log:              log,
+		params:           &params,
+	}
+
+	if s.Debug {
+		params.Logger.EnableDebugLogging()
+		s.log = params.Logger.Get()
+	}
+
+	return s, nil
+}

internal/database/database.go

@@ -0,0 +1,115 @@
+package database
+
+import (
+	"context"
+	"os"
+
+	"database/sql"
+
+	"github.com/rs/zerolog"
+	"github.com/rs/zerolog/log"
+	"go.uber.org/fx"
+	"gorm.io/driver/sqlite"
+	"gorm.io/gorm"
+	"sneak.berlin/go/directory/internal/config"
+	"sneak.berlin/go/directory/internal/globals"
+	"sneak.berlin/go/directory/internal/logger"
+	"sneak.berlin/go/util"
+
+	// spooky action at a distance!
+	// this populates the environment
+	// from a ./.env file automatically
+	// for development configuration.
+	// .env contents should be things like
+	// `DBURL=postgres://user:pass@.../`
+	// (without the backticks, of course)
+	_ "github.com/joho/godotenv/autoload"
+)
+
+type DatabaseParams struct {
+	fx.In
+	Logger  *logger.Logger
+	Config  *config.Config
+	Globals *globals.Globals
+}
+
+type Database struct {
+	URL    string
+	log    *zerolog.Logger
+	params *DatabaseParams
+	DB     *gorm.DB
+	SQLDB  *sql.DB
+	dbdir  string
+	dbfn   string
+}
+
+func New(lc fx.Lifecycle, params DatabaseParams) (*Database, error) {
+	s := new(Database)
+	s.params = &params
+	s.log = params.Logger.Get()
+
+	s.log.Info().Msg("Database instantiated")
+
+	lc.Append(fx.Hook{
+		OnStart: func(ctx context.Context) error {
+			s.log.Info().Msg("Database OnStart Hook")
+			// FIXME connect to db
+			return nil
+		},
+		OnStop: func(ctx context.Context) error {
+			// FIXME disconnect from db
+			return nil
+		},
+	})
+	return s, nil
+}
+
+func (d *Database) Close() {
+	d.log.Info().Msg("Database Close()")
+}
+
+func (d *Database) Get() (*gorm.DB, error) {
+	if d.DB == nil {
+		err := d.Connect()
+		if err != nil {
+			d.log.Error().Err(err).Msg("failed to connect to database")
+			return nil, err
+		}
+	}
+	return d.DB, nil
+}
+
+func (d *Database) Connect() error {
+	// FIXME make this get the data dir path from config
+	d.dbdir = os.Getenv("HOME")
+	err := util.Mkdirp(d.dbdir)
+	if err != nil {
+		d.log.Error().
+			Err(err).
+			Str("dbdir", d.dbdir).
+			Msg("unable to create directory")
+		return err
+	}
+	d.dbfn = d.dbdir + "/" + d.params.Globals.Appname + ".db"
+	d.log.Info().
+		Str("file", d.dbfn).
+		Msg("opening store db")
+
+	// Open the database using the pure Go SQLite driver
+	sqlDB, err := sql.Open("sqlite", d.dbfn+"?_pragma=foreign_keys(1)&_pragma=journal_mode(WAL)")
+	if err != nil {
+		d.log.Error().Err(err).Msg("failed to open database")
+		return err
+	}
+	d.SQLDB = sqlDB
+
+	// Use the generic Gorm SQL driver to integrate it
+	db, err := gorm.Open(sqlite.Dialector{Conn: d.SQLDB}, &gorm.Config{})
+	if err != nil {
+		log.Error().Err(err).Msg("failed to connect database")
+		return err
+	}
+	d.DB = db
+
+	return nil
+}

internal/globals/globals.go

@@ -0,0 +1,27 @@
+package globals
+
+import (
+	"go.uber.org/fx"
+)
+
+// these get populated from main() and copied into the Globals object.
+var (
+	Appname   string
+	Version   string
+	Buildarch string
+)
+
+type Globals struct {
+	Appname   string
+	Version   string
+	Buildarch string
+}
+
+func New(lc fx.Lifecycle) (*Globals, error) {
+	n := &Globals{
+		Appname:   Appname,
+		Buildarch: Buildarch,
+		Version:   Version,
+	}
+	return n, nil
+}

internal/handlers/handlers.go

@@ -0,0 +1,60 @@
+package handlers
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"github.com/rs/zerolog"
+	"go.uber.org/fx"
+	"sneak.berlin/go/directory/internal/database"
+	"sneak.berlin/go/directory/internal/globals"
+	"sneak.berlin/go/directory/internal/healthcheck"
+	"sneak.berlin/go/directory/internal/logger"
+)
+
+type HandlersParams struct {
+	fx.In
+	Logger      *logger.Logger
+	Globals     *globals.Globals
+	Database    *database.Database
+	Healthcheck *healthcheck.Healthcheck
+}
+
+type Handlers struct {
+	params *HandlersParams
+	log    *zerolog.Logger
+	hc     *healthcheck.Healthcheck
+}
+
+func New(lc fx.Lifecycle, params HandlersParams) (*Handlers, error) {
+	s := new(Handlers)
+	s.params = &params
+	s.log = params.Logger.Get()
+	s.hc = params.Healthcheck
+	lc.Append(fx.Hook{
+		OnStart: func(ctx context.Context) error {
+			// FIXME compile some templates here or something
+			return nil
+		},
+	})
+	return s, nil
+}
+
+const jsonContentType = "application/json; charset=utf-8"
+
+func (s *Handlers) respondJSON(w http.ResponseWriter, r *http.Request, data interface{}, status int) {
+	w.WriteHeader(status)
+	w.Header().Set("Content-Type", jsonContentType)
+	if data != nil {
+		err := json.NewEncoder(w).Encode(data)
+		if err != nil {
+			s.log.Error().Err(err).Msg("json encode error")
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+		}
+	}
+}
+
+func (s *Handlers) decodeJSON(w http.ResponseWriter, r *http.Request, v interface{}) error { // nolint
+	return json.NewDecoder(r.Body).Decode(v)
+}

internal/healthcheck/healthcheck.go

@@ -0,0 +1,82 @@
+package healthcheck
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"time"
+
+	"github.com/rs/zerolog"
+	"go.uber.org/fx"
+	"sneak.berlin/go/directory/internal/config"
+	"sneak.berlin/go/directory/internal/database"
+	"sneak.berlin/go/directory/internal/globals"
+	"sneak.berlin/go/directory/internal/logger"
+)
+
+type HealthcheckParams struct {
+	fx.In
+	Globals  *globals.Globals
+	Config   *config.Config
+	Logger   *logger.Logger
+	Database *database.Database
+}
+
+type Healthcheck struct {
+	StartupTime time.Time
+	log         *zerolog.Logger
+	params      *HealthcheckParams
+}
+
+func New(lc fx.Lifecycle, params HealthcheckParams) (*Healthcheck, error) {
+	s := new(Healthcheck)
+	s.params = &params
+	s.log = params.Logger.Get()
+
+	lc.Append(fx.Hook{
+		OnStart: func(ctx context.Context) error {
+			s.StartupTime = time.Now()
+			return nil
+		},
+		OnStop: func(ctx context.Context) error {
+			// FIXME do server shutdown here
+			return nil
+		},
+	})
+	return s, nil
+}
+
+func (s *Healthcheck) uptime() time.Duration {
+	return time.Since(s.StartupTime)
+}
+
+type HealthcheckResponse struct {
+	Status        string `json:"status"`
+	Now           string `json:"now"`
+	UptimeSeconds int64  `json:"uptime_seconds"`
+	UptimeHuman   string `json:"uptime_human"`
+	Version       string `json:"version"`
+	Appname       string `json:"appname"`
+	Maintenance   bool   `json:"maintenance_mode"`
+}
+
+func (s *Healthcheck) Healthcheck() *HealthcheckResponse {
+
+	resp := &HealthcheckResponse{
+		Status:        "ok",
+		Now:           time.Now().UTC().Format(time.RFC3339Nano),
+		UptimeSeconds: int64(s.uptime().Seconds()),
+		UptimeHuman:   s.uptime().String(),
+		Appname:       s.params.Globals.Appname,
+		Version:       s.params.Globals.Version,
+	}
+	return resp
+}
+
+func (s *Healthcheck) HealthcheckHandler() http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		resp := s.Healthcheck()
+		w.Header().Set("Content-Type", "application/json; charset=utf-8")
+		json.NewEncoder(w).Encode(resp)
+	}
+}

internal/logger/logger.go

@@ -0,0 +1,97 @@
+package logger
+
+import (
+	"io"
+	"os"
+	"time"
+
+	"github.com/rs/zerolog"
+	"go.uber.org/fx"
+	"sneak.berlin/go/directory/internal/globals"
+)
+
+type LoggerParams struct {
+	fx.In
+	Globals *globals.Globals
+}
+
+type Logger struct {
+	log    *zerolog.Logger
+	params LoggerParams
+}
+
+func New(lc fx.Lifecycle, params LoggerParams) (*Logger, error) {
+	l := new(Logger)
+
+	// always log in UTC
+	zerolog.TimestampFunc = func() time.Time {
+		return time.Now().UTC()
+	}
+	zerolog.SetGlobalLevel(zerolog.InfoLevel)
+
+	tty := false
+	if fileInfo, _ := os.Stdout.Stat(); (fileInfo.Mode() & os.ModeCharDevice) != 0 {
+		tty = true
+	}
+
+	var writers []io.Writer
+
+	if tty {
+		// this does cool colorization for console/dev
+		consoleWriter := zerolog.NewConsoleWriter(
+			func(w *zerolog.ConsoleWriter) {
+				// Customize time format
+				w.TimeFormat = time.RFC3339Nano
+			},
+		)
+
+		writers = append(writers, consoleWriter)
+	} else {
+		// log json in prod for the machines
+		writers = append(writers, os.Stdout)
+	}
+
+	/*
+		// this is how you log to a file, if you do that
+		// sort of thing still
+		logfile := viper.GetString("Logfile")
+		if logfile != "" {
+		    logfileDir := filepath.Dir(logfile)
+		    err := goutil.Mkdirp(logfileDir)
+		    if err != nil {
+			    log.Error().Err(err).Msg("unable to create log dir")
+		    }
+
+		    hp.logfh, err = os.OpenFile(logfile, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0644)
+		    if err != nil {
+			    panic("unable to open logfile: " + err.Error())
+		    }
+
+		    writers = append(writers, hp.logfh)
+	*/
+
+	multi := zerolog.MultiLevelWriter(writers...)
+	logger := zerolog.New(multi).With().Timestamp().Logger().With().Caller().Logger()
+
+	l.log = &logger
+	// log.Logger = logger
+
+	return l, nil
+}
+
+func (l *Logger) EnableDebugLogging() {
+	zerolog.SetGlobalLevel(zerolog.DebugLevel)
+	l.log.Debug().Bool("debug", true).Send()
+}
+
+func (l *Logger) Get() *zerolog.Logger {
+	return l.log
+}
+
+func (l *Logger) Identify() {
+	l.log.Info().
+		Str("appname", l.params.Globals.Appname).
+		Str("version", l.params.Globals.Version).
+		Str("buildarch", l.params.Globals.Buildarch).
+		Msg("starting")
+}

internal/middleware/middleware.go

@@ -0,0 +1,134 @@
+package middleware
+
+import (
+	"net"
+	"net/http"
+	"time"
+
+	basicauth "github.com/99designs/basicauth-go"
+	"github.com/go-chi/chi/middleware"
+	"github.com/go-chi/cors"
+	"github.com/rs/zerolog"
+	"sneak.berlin/go/directory/internal/config"
+	"sneak.berlin/go/directory/internal/globals"
+	"sneak.berlin/go/directory/internal/logger"
+
+	metrics "github.com/slok/go-http-metrics/metrics/prometheus"
+	ghmm "github.com/slok/go-http-metrics/middleware"
+	"github.com/slok/go-http-metrics/middleware/std"
+	"github.com/spf13/viper"
+	"go.uber.org/fx"
+)
+
+type MiddlewareParams struct {
+	fx.In
+	Logger  *logger.Logger
+	Globals *globals.Globals
+	Config  *config.Config
+}
+
+type Middleware struct {
+	log    *zerolog.Logger
+	params *MiddlewareParams
+}
+
+func New(lc fx.Lifecycle, params MiddlewareParams) (*Middleware, error) {
+	s := new(Middleware)
+	s.params = &params
+	s.log = params.Logger.Get()
+	return s, nil
+}
+
+// the following is from
+// https://learning-cloud-native-go.github.io/docs/a6.adding_zerolog_logger/
+
+func ipFromHostPort(hp string) string {
+	h, _, err := net.SplitHostPort(hp)
+	if err != nil {
+		return ""
+	}
+	if len(h) > 0 && h[0] == '[' {
+		return h[1 : len(h)-1]
+	}
+	return h
+}
+
+type loggingResponseWriter struct {
+	http.ResponseWriter
+	statusCode int
+}
+
+func NewLoggingResponseWriter(w http.ResponseWriter) *loggingResponseWriter {
+	return &loggingResponseWriter{w, http.StatusOK}
+}
+
+func (lrw *loggingResponseWriter) WriteHeader(code int) {
+	lrw.statusCode = code
+	lrw.ResponseWriter.WriteHeader(code)
+}
+
+// type Middleware func(http.Handler) http.Handler
+// this returns a Middleware that is designed to do every request through the
+// mux, note the signature:
+func (s *Middleware) Logging() func(http.Handler) http.Handler {
+	// FIXME this should use https://github.com/google/go-cloud/blob/master/server/requestlog/requestlog.go
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			start := time.Now()
+			lrw := NewLoggingResponseWriter(w)
+			ctx := r.Context()
+			defer func() {
+				latency := time.Since(start)
+				s.log.Info().
+					Time("request_start", start).
+					Str("method", r.Method).
+					Str("url", r.URL.String()).
+					Str("useragent", r.UserAgent()).
+					Str("request_id", ctx.Value(middleware.RequestIDKey).(string)).
+					Str("referer", r.Referer()).
+					Str("proto", r.Proto).
+					Str("remoteIP", ipFromHostPort(r.RemoteAddr)).
+					Int("status", lrw.statusCode).
+					Int("latency_ms", int(latency.Milliseconds())).
+					Send()
+			}()
+
+			next.ServeHTTP(lrw, r)
+		})
+	}
+}
+
+func (s *Middleware) CORS() func(http.Handler) http.Handler {
+	return cors.Handler(cors.Options{
+		// CHANGEME! these are defaults, change them to suit your needs or
+		// read from environment/viper.
+		// AllowedOrigins: []string{"https://foo.com"}, // Use this to allow specific origin hosts
+		AllowedOrigins: []string{"*"},
+		// AllowOriginFunc:  func(r *http.Request, origin string) bool { return true },
+		AllowedMethods:   []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
+		AllowedHeaders:   []string{"Accept", "Authorization", "Content-Type", "X-CSRF-Token"},
+		ExposedHeaders:   []string{"Link"},
+		AllowCredentials: false,
+		MaxAge:           300, // Maximum value not ignored by any of major browsers
+	})
+}
+
+func (s *Middleware) Metrics() func(http.Handler) http.Handler {
+	mdlw := ghmm.New(ghmm.Config{
+		Recorder: metrics.NewRecorder(metrics.Config{}),
+	})
+	return func(next http.Handler) http.Handler {
+		return std.Handler("", mdlw, next)
+	}
+}
+
+func (s *Middleware) MetricsAuth() func(http.Handler) http.Handler {
+	return basicauth.New(
+		"metrics",
+		map[string][]string{
+			viper.GetString("METRICS_USERNAME"): {
+				viper.GetString("METRICS_PASSWORD"),
+			},
+		},
+	)
+}

internal/server/http.go

@@ -0,0 +1,34 @@
+package server
+
+import (
+	"fmt"
+	"net/http"
+	"time"
+)
+
+func (s *Server) serveUntilShutdown() {
+	listenAddr := fmt.Sprintf(":%d", s.params.Config.Port)
+	s.httpServer = &http.Server{
+		Addr:           listenAddr,
+		ReadTimeout:    10 * time.Second,
+		WriteTimeout:   10 * time.Second,
+		MaxHeaderBytes: 1 << 20,
+		Handler:        s,
+	}
+
+	// add routes
+	// this does any necessary setup in each handler
+	s.SetupRoutes()
+
+	s.log.Info().Str("listenaddr", listenAddr).Msg("http begin listen")
+	if err := s.httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+		s.log.Error().Msgf("listen:%+s\n", err)
+		if s.cancelFunc != nil {
+			s.cancelFunc()
+		}
+	}
+}
+
+func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	s.router.ServeHTTP(w, r)
+}

internal/server/routes.go

@@ -0,0 +1,104 @@
+package server
+
+import (
+	"net/http"
+	"time"
+
+	sentryhttp "github.com/getsentry/sentry-go/http"
+	"github.com/go-chi/chi"
+	"github.com/go-chi/chi/middleware"
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+	"github.com/spf13/viper"
+)
+
+func (s *Server) SetupRoutes() {
+	s.router = chi.NewRouter()
+
+	// the mux .Use() takes a http.Handler wrapper func, like most
+	// things that deal with "middlewares" like alice et c, and will
+	// call ServeHTTP on it.  These middlewares applied by the mux (you
+	// can .Use() more than one) will be applied to every request into
+	// the service.
+
+	s.router.Use(middleware.Recoverer)
+	s.router.Use(middleware.RequestID)
+	s.router.Use(s.mw.Logging())
+
+	// add metrics middleware only if we can serve them behind auth
+	if viper.GetString("METRICS_USERNAME") != "" {
+		s.router.Use(s.mw.Metrics())
+	}
+
+	// set up CORS headers. you'll probably want to configure that
+	// in middlewares.go.
+	s.router.Use(s.mw.CORS())
+
+	// CHANGEME to suit your needs, or pull from config.
+	// timeout for request context; your handlers must finish within
+	// this window:
+	s.router.Use(middleware.Timeout(60 * time.Second))
+
+	// this adds a sentry reporting middleware if and only if sentry is
+	// enabled via setting of SENTRY_DSN in env.
+	if s.sentryEnabled {
+		// Options docs at
+		// https://docs.sentry.io/platforms/go/guides/http/
+		// we set sentry to repanic so that all panics bubble up to the
+		// Recoverer chi middleware above.
+		sentryHandler := sentryhttp.New(sentryhttp.Options{
+			Repanic: true,
+		})
+		s.router.Use(sentryHandler.Handle)
+	}
+
+	////////////////////////////////////////////////////////////////////////
+	// ROUTES
+	// complete docs: https://github.com/go-chi/chi
+	////////////////////////////////////////////////////////////////////////
+
+	s.router.Get("/", s.h.HandleIndex())
+
+	s.router.Mount("/s", http.StripPrefix("/s", http.FileServer(http.FS(static.Static))))
+
+	s.router.Route("/api/v1", func(r chi.Router) {
+		r.Get("/now", s.h.HandleNow())
+	})
+
+	// if you want to use a general purpose middleware (http.Handler
+	// wrapper) on a specific HandleFunc route, you need to take the
+	// .ServeHTTP of the http.Handler to get its HandleFunc, viz:
+	auth := s.mw.Auth()
+	s.router.Get(
+		"/login",
+		auth(s.h.HandleLoginGET()).ServeHTTP,
+	)
+
+	s.router.Get(
+		"/signup",
+		auth(s.h.HandleSignupGET()).ServeHTTP,
+	)
+
+	s.router.Post(
+		"/signup",
+		auth(s.h.HandleSignupPOST()).ServeHTTP,
+	)
+	// route that panics for testing
+	// CHANGEME remove this
+	s.router.Get(
+		"/panic",
+		s.h.HandlePanic(),
+	)
+
+	s.router.Get(
+		"/.well-known/healthcheck.json",
+		s.h.HandleHealthCheck(),
+	)
+
+	// set up authenticated /metrics route:
+	if viper.GetString("METRICS_USERNAME") != "" {
+		s.router.Group(func(r chi.Router) {
+			r.Use(s.mw.MetricsAuth())
+			r.Get("/metrics", http.HandlerFunc(promhttp.Handler().ServeHTTP))
+		})
+	}
+}

internal/server/server.go

@@ -0,0 +1,177 @@
+package server
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"github.com/rs/zerolog"
+	"go.uber.org/fx"
+	"sneak.berlin/go/directory/internal/config"
+	"sneak.berlin/go/directory/internal/globals"
+	"sneak.berlin/go/directory/internal/handlers"
+	"sneak.berlin/go/directory/internal/logger"
+	"sneak.berlin/go/directory/internal/middleware"
+
+	"github.com/getsentry/sentry-go"
+	"github.com/go-chi/chi"
+
+	// spooky action at a distance!
+	// this populates the environment
+	// from a ./.env file automatically
+	// for development configuration.
+	// .env contents should be things like
+	// `DBURL=postgres://user:pass@.../`
+	// (without the backticks, of course)
+	_ "github.com/joho/godotenv/autoload"
+)
+
+type ServerParams struct {
+	fx.In
+	Logger     *logger.Logger
+	Globals    *globals.Globals
+	Config     *config.Config
+	Middleware *middleware.Middleware
+	Handlers   *handlers.Handlers
+}
+
+type Server struct {
+	startupTime   time.Time
+	exitCode      int
+	sentryEnabled bool
+	log           *zerolog.Logger
+	ctx           context.Context
+	cancelFunc    context.CancelFunc
+	httpServer    *http.Server
+	router        *chi.Mux
+	params        ServerParams
+	mw            *middleware.Middleware
+	h             *handlers.Handlers
+}
+
+func New(lc fx.Lifecycle, params ServerParams) (*Server, error) {
+	s := new(Server)
+	s.params = params
+	s.mw = params.Middleware
+	s.h = params.Handlers
+	s.log = params.Logger.Get()
+
+	lc.Append(fx.Hook{
+		OnStart: func(ctx context.Context) error {
+			s.startupTime = time.Now()
+			go s.Run() // background FIXME
+			return nil
+		},
+		OnStop: func(ctx context.Context) error {
+			// FIXME do server shutdown here
+			return nil
+		},
+	})
+	return s, nil
+}
+
+// FIXME change this to use uber/fx DI and an Invoke()
+// this is where we come in from package main.
+func (s *Server) Run() {
+	// this does nothing if SENTRY_DSN is unset in env.
+	// TODO remove:
+	if s.sentryEnabled {
+		sentry.CaptureMessage("It works!")
+	}
+
+	s.configure()
+
+	// logging before sentry, because sentry logs
+	s.enableSentry()
+
+	s.serve() // FIXME deal with return value
+}
+
+func (s *Server) enableSentry() {
+	s.sentryEnabled = false
+
+	if s.params.Config.SentryDSN == "" {
+		return
+	}
+
+	err := sentry.Init(sentry.ClientOptions{
+		Dsn:     s.params.Config.SentryDSN,
+		Release: fmt.Sprintf("%s-%s", s.params.Globals.Appname, s.params.Globals.Version),
+	})
+	if err != nil {
+		s.log.Fatal().Err(err).Msg("sentry init failure")
+		return
+	}
+	s.log.Info().Msg("sentry error reporting activated")
+	s.sentryEnabled = true
+}
+
+func (s *Server) serve() int {
+	// FIXME fx will handle this for us
+	s.ctx, s.cancelFunc = context.WithCancel(context.Background())
+
+	// signal watcher
+	go func() {
+		c := make(chan os.Signal, 1)
+		signal.Ignore(syscall.SIGPIPE)
+		signal.Notify(c, os.Interrupt, syscall.SIGTERM)
+		// block and wait for signal
+		sig := <-c
+		s.log.Info().Msgf("signal received: %+v", sig)
+		if s.cancelFunc != nil {
+			// cancelling the main context will trigger a clean
+			// shutdown.
+			s.cancelFunc()
+		}
+	}()
+
+	go s.serveUntilShutdown()
+
+	for range s.ctx.Done() {
+		// aforementioned clean shutdown upon main context
+		// cancellation
+	}
+	s.cleanShutdown()
+	return s.exitCode
+}
+
+func (s *Server) cleanupForExit() {
+	s.log.Info().Msg("cleaning up")
+	// FIXME unimplemented
+	// close database connections or whatever
+}
+
+func (s *Server) cleanShutdown() {
+	// initiate clean shutdown
+	s.exitCode = 0
+	ctxShutdown, shutdownCancel := context.WithTimeout(context.Background(), 5*time.Second)
+	if err := s.httpServer.Shutdown(ctxShutdown); err != nil {
+		s.log.Error().
+			Err(err).
+			Msg("server clean shutdown failed")
+	}
+	if shutdownCancel != nil {
+		shutdownCancel()
+	}
+
+	s.cleanupForExit()
+
+	if s.sentryEnabled {
+		sentry.Flush(2 * time.Second)
+	}
+}
+
+func (s *Server) MaintenanceMode() bool {
+	return s.params.Config.MaintenanceMode
+}
+
+func (s *Server) configure() {
+	// FIXME move most of this to dedicated places
+	// if viper.GetBool("DEBUG") {
+	//      pp.Print(viper.AllSettings())
+	// }
+}