Chương 18 — Golang Patterns cho ứng dụng 12-Factor

// internal/service/order.go — service khai báo interface NÓ CẦN (consumer-side)
package service

type OrderRepo interface {
	Create(ctx context.Context, o *Order) error
	GetByID(ctx context.Context, id string) (*Order, error)
}

type EventPublisher interface {
	Publish(ctx context.Context, topic string, payload any) error
}

type OrderService struct {
	repo   OrderRepo
	events EventPublisher
	log    *slog.Logger
}

func NewOrderService(repo OrderRepo, events EventPublisher, log *slog.Logger) *OrderService {
	return &OrderService{repo: repo, events: events, log: log}
}

func (s *OrderService) Create(ctx context.Context, o *Order) error {
	if err := o.Validate(); err != nil {
		return fmt.Errorf("%w: %v", ErrInvalidOrder, err)
	}
	if err := s.repo.Create(ctx, o); err != nil {
		return fmt.Errorf("create order: %w", err)
	}
	// publish lỗi không làm fail order — quyết định nghiệp vụ tường minh
	if err := s.events.Publish(ctx, "orders.created", o); err != nil {
		s.log.Error("publish failed", "order_id", o.ID, "err", err)
	}
	return nil
}

// cmd/app/main.go — composition root: đồ thị phụ thuộc dựng Ở MỘT NƠI
pool := postgres.MustNewPool(ctx, cfg.DatabaseURL)
rdb := redisclient.MustNew(cfg.RedisURL)
producer := kafkaqueue.MustNewProducer(cfg.KafkaBrokers)

orderSvc := service.NewOrderService(
	postgres.NewOrderRepo(pool),
	producer,
	logger,
)
srv := server.New(cfg, logger, orderSvc)

// internal/server/health.go
package server

import (
	"context"
	"net/http"
	"sync/atomic"
	"time"
)

type Health struct {
	ready    atomic.Bool
	draining atomic.Bool
	checks   map[string]func(context.Context) error // dependency thiết yếu
}

func NewHealth() *Health {
	return &Health{checks: map[string]func(context.Context) error{}}
}

func (h *Health) AddReadinessCheck(name string, fn func(context.Context) error) {
	h.checks[name] = fn
}
func (h *Health) SetReady(v bool)  { h.ready.Store(v) }
func (h *Health) StartDraining()   { h.draining.Store(true) }

// Liveness: "tôi còn sống" — trả lời được là đủ
func (h *Health) LiveHandler(w http.ResponseWriter, r *http.Request) {
	w.WriteHeader(http.StatusOK)
}

// Readiness: "tôi phục vụ được ngay bây giờ"
func (h *Health) ReadyHandler(w http.ResponseWriter, r *http.Request) {
	if h.draining.Load() || !h.ready.Load() {
		http.Error(w, "not ready", http.StatusServiceUnavailable)
		return
	}
	ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second)
	defer cancel()
	for name, check := range h.checks {
		if err := check(ctx); err != nil {
			http.Error(w, name+": "+err.Error(), http.StatusServiceUnavailable)
			return
		}
	}
	w.WriteHeader(http.StatusOK)
}

// wiring: DB là dependency thiết yếu → vào readiness (KHÔNG vào liveness)
health := server.NewHealth()
health.AddReadinessCheck("postgres", func(ctx context.Context) error {
	return pool.Ping(ctx)
})

// cmd/app/main.go — khung server production-ready hoàn chỉnh
package main

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

	"golang.org/x/sync/errgroup"
)

func main() {
	if err := run(); err != nil {
		fmt.Fprintln(os.Stderr, "fatal:", err)
		os.Exit(1)
	}
}

// run tách khỏi main: trả error thay vì os.Exit rải rác → test được toàn bộ vòng đời
func run() error {
	// 1. Config trước tiên — fail fast (F3)
	cfg, err := config.Load()
	if err != nil {
		return fmt.Errorf("config: %w", err)
	}
	logger := logging.New(cfg.LogLevel) // F11
	slog.SetDefault(logger)

	// 2. Root context gắn với signal (F9)
	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGTERM, syscall.SIGINT)
	defer stop()

	// 3. Attach backing services — fail fast với resource thiết yếu (F4)
	pool, err := postgres.NewPool(ctx, cfg.DatabaseURL)
	if err != nil {
		return fmt.Errorf("attach postgres: %w", err)
	}
	defer pool.Close()

	// 4. Composition root — DI thủ công
	health := server.NewHealth()
	health.AddReadinessCheck("postgres", pool.Ping)
	orderSvc := service.NewOrderService(postgres.NewOrderRepo(pool), /*...*/ logger)
	handler := server.NewRouter(logger, health, orderSvc) // middleware: recover, request-id, access log

	srv := &http.Server{
		Addr:              ":" + cfg.Port, // F7
		Handler:           handler,
		ReadHeaderTimeout: 5 * time.Second,
		ReadTimeout:       10 * time.Second,
		WriteTimeout:      30 * time.Second,
		IdleTimeout:       120 * time.Second,
	}

	// 5. errgroup: các thành phần dài hạn sống chết cùng nhau
	g, gctx := errgroup.WithContext(ctx)

	g.Go(func() error { // HTTP server
		logger.Info("listening", "port", cfg.Port, "version", buildinfo.Version)
		health.SetReady(true)
		if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
			return fmt.Errorf("http server: %w", err)
		}
		return nil
	})

	g.Go(func() error { // vòng đời shutdown (F9 — mẫu 3 giai đoạn, chương 14)
		<-gctx.Done() // signal HOẶC thành phần khác chết
		logger.Info("shutting down")
		health.StartDraining()
		time.Sleep(cfg.DrainDelay) // đợi endpoint removal lan tỏa
		shCtx, cancel := context.WithTimeout(context.Background(), cfg.ShutdownTimeout)
		defer cancel()
		return srv.Shutdown(shCtx)
	})

	// (worker/consumer thêm g.Go tương tự — cùng vòng đời)

	if err := g.Wait(); err != nil {
		return err
	}
	logger.Info("stopped cleanly")
	return nil
}

// Recover: panic trong handler → 500 + log, KHÔNG chết process
// (panic ngoài handler thì cứ để chết — crash-only, nền tảng thay pod)
func Recover(log *slog.Logger) func(http.Handler) http.Handler {
	return func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			defer func() {
				if rec := recover(); rec != nil {
					log.Error("panic", "recover", rec, "stack", string(debug.Stack()),
						"path", r.URL.Path)
					http.Error(w, "internal error", http.StatusInternalServerError)
				}
			}()
			next.ServeHTTP(w, r)
		})
	}
}