init

internal/server/config.go

@@ -0,0 +1,40 @@
+package server
+
+import (
+	"flag"
+	"fmt"
+)
+
+type config struct {
+	baseURL  string
+	httpAddr string
+	dsn      string
+	logLevel string
+}
+
+const (
+	version         = "0.0.1"
+	defaultBaseURL  = "https://localhost"
+	defaultHTTPAddr = "localhost:6300"
+	//defaultDSN      = "mysql://gopics2:gopics2@/gopics2?parseTime=true"
+	defaultDSN = "sqlite://gopics.db"
+)
+
+//TODO : create load from file, load order : file -> flags
+
+func parseCfg() (config, error) {
+	var cfg config
+	flag.StringVar(&cfg.baseURL, "base-url", defaultBaseURL, "base URL for the application")
+	flag.StringVar(&cfg.httpAddr, "http-address", defaultHTTPAddr, "IP:PORT to listen on for HTTP requests")
+	flag.StringVar(&cfg.dsn, "dsn", defaultDSN, "MySQL data source name")
+	showVersion := flag.Bool("version", false, "display version and exit")
+
+	flag.Parse()
+
+	if *showVersion {
+		fmt.Printf("version: %s\n", version)
+		return cfg, nil
+	}
+	cfg.logLevel = "Debug"
+	return cfg, nil
+}

internal/server/errors.go

@@ -0,0 +1,31 @@
+package server
+
+import (
+	"net/http"
+)
+
+func (srv *server) serverError(w http.ResponseWriter, r *http.Request, err error) {
+	var (
+		method = r.Method
+		uri    = r.URL.RequestURI()
+		trace  = "" //string(debug.Stack())
+	)
+
+	srv.logger.Error(err.Error(), "method", method, "uri", uri, "trace", trace)
+	http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+}
+
+// Logs server errors silently (without generating http:50x)
+func (srv *server) serverErrorSilent(w http.ResponseWriter, r *http.Request, err error) {
+	var (
+		method = r.Method
+		uri    = r.URL.RequestURI()
+		trace  = "" //string(debug.Stack())
+	)
+
+	srv.logger.Error(err.Error(), "method", method, "uri", uri, "trace", trace)
+}
+
+func (srv *server) clientError(w http.ResponseWriter, status int) {
+	http.Error(w, http.StatusText(status), status)
+}

internal/server/handlers.go

@@ -0,0 +1,8 @@
+package server
+
+import (
+	"net/http"
+)
+
+func (srv *server) home(w http.ResponseWriter, r *http.Request) {
+}

internal/server/helpers.go

@@ -0,0 +1,83 @@
+package server
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+
+	"github.com/a-h/templ"
+	"github.com/go-playground/validator/v10"
+
+	"gopics.develent.net/internal/components"
+)
+
+// Extract form and validate fields
+func (srv *server) bindAndValidate(r *http.Request, form any) (map[string]string, error) {
+
+	err := r.ParseForm()
+	if err != nil {
+		return nil, err
+	}
+
+	err = srv.formDecoder.Decode(form, r.PostForm)
+	if err != nil {
+		return nil, err
+	}
+
+	err = srv.validate.Struct(form)
+	if err != nil {
+		ve, ok := err.(validator.ValidationErrors)
+		srv.logger.Info("BnV Validation", "ok", ok, "ve", ve)
+		if ok {
+			return mapValidationErrors(ve), nil // validation failed
+		}
+		return nil, err // something else went wrong
+
+	}
+
+	return nil, nil // valid
+}
+
+// Render TEMPL pages
+func (srv *server) RenderPage(w http.ResponseWriter, r *http.Request, status int, page templ.Component, title string) {
+	w.WriteHeader(status)
+	flash := srv.sessionManager.PopString(r.Context(), "flash")
+	components.Base(page, title, flash).Render(r.Context(), w)
+}
+
+// Inject flash messages into context
+func (srv *server) PutFlash(ctx context.Context, msg string) {
+	srv.sessionManager.Put(ctx, "flash", msg)
+}
+
+// Pop flash messages from context
+func (srv *server) PopFlash(ctx context.Context) string {
+	srv.logger.Info("Pre-Pop", "flash", srv.sessionManager.GetString(ctx, "flash"))
+	flash := srv.sessionManager.PopString(ctx, "flash")
+	srv.logger.Info("Post-Pop", "flash", srv.sessionManager.GetString(ctx, "flash"))
+	return flash
+}
+
+// Map validator errors to user presentable errors
+func mapValidationErrors(errs validator.ValidationErrors) map[string]string {
+	errors := make(map[string]string)
+	for _, fe := range errs {
+		field := fe.Field()
+		tag := fe.Tag()
+		var msg string
+
+		switch tag {
+		case "required":
+			msg = fmt.Sprintf("%s is required", field)
+		case "email":
+			msg = "Invalid email format"
+		case "gte":
+			msg = fmt.Sprintf("%s must be %s or greater", field, fe.Param())
+		default:
+			msg = fmt.Sprintf("%s is not valid", field)
+		}
+		errors[field] = msg
+	}
+
+	return errors
+}

internal/server/middleware.go

@@ -0,0 +1 @@
+package server

internal/server/routes.go

@@ -0,0 +1,24 @@
+package server
+
+import (
+	"net/http"
+)
+
+func (srv *server) routes() http.Handler {
+	mux := http.NewServeMux()
+
+	fileServer := http.FileServer(http.Dir("./ui/static/"))
+	mux.Handle("GET /static/", http.StripPrefix("/static", fileServer))
+	//mux.Handle("GET /static/", http.FileServerFS(ui.Files))
+
+	//Configure Middleware chains
+
+	//Add routes and handlers to map
+	routes := map[string]http.Handler{}
+
+	for path, handler := range routes {
+		mux.Handle(path, handler)
+	}
+
+	return mux
+}

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
+}