init

internal/server/server.go

@@ -0,0 +1,158 @@
+package server
+
+import (
+	"context"
+	"crypto/tls"
+	"errors"
+	"go-template-webapp/internal/app"
+	"log/slog"
+	"net/http"
+	"os"
+	"os/signal"
+	"sync"
+	"syscall"
+	"time"
+
+	"github.com/alexedwards/scs/mysqlstore"
+	"github.com/alexedwards/scs/sqlite3store"
+	"github.com/alexedwards/scs/v2"
+	"github.com/go-playground/form/v4"
+	"github.com/go-playground/validator/v10"
+	"github.com/jmoiron/sqlx"
+)
+
+const (
+	defaultIdleTimeout    = time.Minute
+	defaultReadTimeout    = 5 * time.Second
+	defaultWriteTimeout   = 10 * time.Second
+	defaultShutdownPeriod = 30 * time.Second
+)
+
+type server struct {
+	logger         *slog.Logger
+	app            *app.Application
+	cfg            config
+	formDecoder    *form.Decoder
+	validate       *validator.Validate
+	sessionManager *scs.SessionManager
+	wg             sync.WaitGroup
+}
+
+func NewServer(logger *slog.Logger) (server, error) {
+	//parse config
+	cfg, err := parseCfg()
+	if err != nil {
+		logger.Error(err.Error())
+		return server{}, err
+	}
+
+	return server{logger: logger, cfg: cfg}, nil
+}
+
+func (srv *server) Run() error {
+	db, err := srv.newDBConnection()
+	if err != nil {
+		return err
+	}
+	defer db.Close()
+
+	srv.formDecoder = form.NewDecoder()
+	srv.validate = validator.New(validator.WithRequiredStructEnabled())
+	srv.sessionManager = newSessionManager(db.DriverName, db.DB)
+	srv.app = app.NewApp(srv.logger, db)
+
+	err = srv.initApp() //Makes sure required DB fields exist. May move move DB init code here as well
+	if err != nil {
+		return err
+	}
+
+	return srv.serveHTTP()
+}
+
+func (srv *server) serveHTTP() error {
+	tlsConfig := &tls.Config{
+		CurvePreferences: []tls.CurveID{tls.X25519, tls.CurveP256},
+	}
+
+	httpSrv := &http.Server{
+		Addr:         srv.cfg.httpAddr,
+		Handler:      srv.routes(),
+		ErrorLog:     slog.NewLogLogger(srv.logger.Handler(), slog.LevelError),
+		TLSConfig:    tlsConfig,
+		IdleTimeout:  defaultIdleTimeout,
+		ReadTimeout:  defaultReadTimeout,
+		WriteTimeout: defaultWriteTimeout,
+	}
+
+	shutdownErrorChan := make(chan error)
+
+	go func() {
+		quitChan := make(chan os.Signal, 1)
+		signal.Notify(quitChan, syscall.SIGINT, syscall.SIGTERM)
+		<-quitChan
+
+		ctx, cancel := context.WithTimeout(context.Background(), defaultShutdownPeriod)
+		defer cancel()
+
+		shutdownErrorChan <- httpSrv.Shutdown(ctx)
+	}()
+
+	srv.logger.Info("starting server", slog.Group("server", "addr", httpSrv.Addr))
+
+	err := httpSrv.ListenAndServeTLS("./tls/cert.pem", "./tls/key.pem")
+	if !errors.Is(err, http.ErrServerClosed) {
+		return err
+	}
+
+	err = <-shutdownErrorChan
+	if err != nil {
+		return err
+	}
+
+	srv.logger.Info("stopped server", slog.Group("server", "addr", httpSrv.Addr))
+
+	srv.wg.Wait()
+	return nil
+}
+
+func (srv *server) newDBConnection() (*database.DB, error) {
+	db := database.New(srv.logger)
+
+	err := db.Connect(srv.cfg.dsn)
+	if err != nil {
+		return nil, err
+	}
+
+	return db, nil
+}
+
+func newSessionManager(dbDriver string, db *sqlx.DB) *scs.SessionManager {
+	sm := scs.New()
+
+	if dbDriver == "mysql" {
+		sm.Store = mysqlstore.New(db.DB)
+	} else if dbDriver == "sqlite3" {
+		sm.Store = sqlite3store.New(db.DB)
+	}
+	sm.Lifetime = 12 * time.Hour
+	sm.Cookie.Secure = true
+
+	return sm
+}
+
+func redirectToTls(w http.ResponseWriter, r *http.Request) {
+	httpsUrl := "https://" + r.Host + ":6300" + r.URL.Path
+	if r.URL.RawQuery != "" {
+		httpsUrl += "?" + r.URL.RawQuery
+	}
+	http.Redirect(w, r, httpsUrl, http.StatusMovedPermanently)
+}
+
+// check DB tables and records, init if missing
+func (srv *server) initApp() error {
+	err := srv.app.UserService.InitDB()
+	if err != nil {
+		return nil
+	}
+	return nil
+}