Serveris — handlers, router, main

Dabar pats serveris — trys failai kaip skirtukai, priklausomybių tvarka: handlers.go → router.go → main.go (apdorotojas, tada maršrutizatorius, kuris jį prijungia, tada main, kuris paleidžia maršrutizatorių). Kurk iš viršaus į apačią; main nesikompiliuos, kol nėra apdorotojo ir maršrutizatoriaus.

1. internal/handlers/handlers.go — struktūra Handlers sujungia bendras priklausomybes (kol kas tik config + registratorių; duomenų bazės laukas prisideda 3 pamokoje). Home įrašo paprastą HTML eilutę — 2 pamoka pakeis ją Templ šablonu. Health atsako į /healthz reikšme "ok" — tašką, kurį Railway tikrins diegimo fazėje.

2. internal/handlers/router.go — Chi maršrutizatorius ir middleware rietuvė, nuo išoriausio:

r.Use(middleware.RequestID)
r.Use(middleware.RealIP)
r.Use(middleware.Logger)    // po vieną log eilutę kiekvienai užklausai
r.Use(middleware.Recoverer) // panika tampa 500, ne kritimu
r.Get("/", h.Home)
r.Get("/healthz", h.Health)

Recoverer — tas, kuris išgelbsti 2 val. nakties: panika bet kuriame apdorotojoje tampa švariu 500, o ne nugriauna visą serverį.

3. cmd/signflow/main.go — įėjimo taškas. Įkelia config, sukonstruoja maršrutizatorių ir aptarnauja su grakščiu išjungimu: gavus Ctrl-C (SIGINT) ar SIGTERM, nustoja priiminėti naujas užklausas ir iki 15 sekundžių užbaigia vykdomas prieš išeidamas. (cmd/ laiko paleidžiamą įėjimo tašką; visa kita — biblioteka po internal/.)

Patikrink. Paleisk:

go run ./cmd/signflow

Turi matyti struktūrizuotus log'us:

level=INFO msg="starting signflow" env=dev port=8080 base_url=http://localhost:8080
level=INFO msg=listening addr=:8080

Kitame terminale:

$ curl -s localhost:8080/healthz
ok
$ curl -s localhost:8080/
<!doctype html>
<title>SignFlow</title>
<h1>✍️ SignFlow</h1>
<p>The skeleton is up and serving.</p>

Atsidaryk http://localhost:8080 naršyklėje — štai tavo (be stiliaus) SignFlow. Paspausk Ctrl-C ir stebėk, kaip užrašo shutting down ir švariai išeina, ne su klaidų pėdsaku.

Spąstai (portas užimtas). Paleisk du kartus — antras nulūžta su:
level=ERROR msg="server error" err="listen tcp :8080: bind: address already in use"
Kažkas jau užėmė 8080 (dažnai pamirštas go run). Sustabdyk kitą procesą arba paleisk kitu portu: PORT=8081 go run ./cmd/signflow — konfigūracijos numatytoji reikšmė, kurią ką tik parašei, tai padaro savaime.

handlers.go SUKURTI

Sukurk šį failą kataloge internal/handlers/

// Package handlers holds the HTTP handlers. In this skeleton there is only the
// home page and a health check; later lessons add auth, documents, and signing.
package handlers

import (
	"fmt"
	"log/slog"
	"net/http"

	"github.com/programuoki/signflow/internal/config"
)

// Handlers bundles the dependencies every handler needs. Constructed once in
// main; its methods are registered on the router. It gains fields as the app
// grows (a database in lesson 3, sessions in lesson 4, ...).
type Handlers struct {
	Cfg config.Config
	Log *slog.Logger
}

func New(cfg config.Config, log *slog.Logger) *Handlers {
	return &Handlers{Cfg: cfg, Log: log}
}

// Home renders the landing page. For now it is a plain HTML string — lesson 2
// replaces it with a type-safe Templ template.
func (h *Handlers) Home(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "text/html; charset=utf-8")
	fmt.Fprint(w, `<!doctype html>
<title>SignFlow</title>
<h1>✍️ SignFlow</h1>
<p>The skeleton is up and serving.</p>`)
}

// Health is a plain-text liveness probe for Railway / uptime checks.
func (h *Handlers) Health(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "text/plain")
	_, _ = w.Write([]byte("ok"))
}

router.go SUKURTI

Sukurk šį failą kataloge internal/handlers/

package handlers

import (
	"net/http"

	"github.com/go-chi/chi/v5"
	"github.com/go-chi/chi/v5/middleware"
)

// Router builds the Chi router with the base middleware stack. Route groups for
// static assets (lesson 2) and auth-protected pages (lesson 5) are added later.
func (h *Handlers) Router() http.Handler {
	r := chi.NewRouter()

	// Base middleware, outermost first.
	r.Use(middleware.RequestID)
	r.Use(middleware.RealIP)
	r.Use(middleware.Logger)    // request logging
	r.Use(middleware.Recoverer) // turn panics into 500s instead of crashing

	r.Get("/", h.Home)
	r.Get("/healthz", h.Health)

	return r
}

main.go SUKURTI

Sukurk šį failą kataloge cmd/signflow/

// Command signflow is the HTTP server entrypoint. On startup it loads config,
// builds the Chi router, and serves with graceful shutdown. Lesson 3 adds the
// database (migrations + a connection pool) between config and serving.
package main

import (
	"context"
	"errors"
	"log/slog"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"

	"github.com/programuoki/signflow/internal/config"
	"github.com/programuoki/signflow/internal/handlers"
)

func main() {
	log := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelInfo}))
	if err := run(log); err != nil {
		log.Error("fatal", "err", err)
		os.Exit(1)
	}
}

func run(log *slog.Logger) error {
	cfg, err := config.Load()
	if err != nil {
		return err
	}
	log.Info("starting signflow", "env", cfg.Env, "port", cfg.Port, "base_url", cfg.BaseURL)

	h := handlers.New(cfg, log)

	srv := &http.Server{
		Addr:              ":" + cfg.Port,
		Handler:           h.Router(),
		ReadHeaderTimeout: 10 * time.Second,
	}

	// Graceful shutdown: stop accepting on SIGINT/SIGTERM, then drain in-flight
	// requests for up to 15s before exiting.
	shutdownCtx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
	defer stop()

	go func() {
		log.Info("listening", "addr", srv.Addr)
		if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
			log.Error("server error", "err", err)
			stop()
		}
	}()

	<-shutdownCtx.Done()
	log.Info("shutting down")

	timeout, cancel := context.WithTimeout(context.Background(), 15*time.Second)
	defer cancel()
	return srv.Shutdown(timeout)
}