159 lines
3.5 KiB
Go
159 lines
3.5 KiB
Go
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
|
|
}
|