G0 D1 ships: skeleton + chi + /health × 5 binaries · acceptance gate PASSED

Phase G0 Day 1 executed end-to-end after a third-pass review by qwen3-coder:480b consolidated all findings across Opus/Kimi/Qwen lineages. Cross-lineage review consolidation (3 model passes + 1 runtime pass): - Opus 4.7: 9 findings · 7 fixed inline · 2 deferred - Kimi K2.6: 2 BLOCKs (introduced by Opus fixes) · 2 fixed - Qwen3-coder:480b: 2 WARNs · 1 fixed (D2.4 256 MiB cap + 4-slot semaphore on PUTs) · 1 deferred (Q2 view refresh batching) - Runtime smoke: 1 finding (port 3100 collision with live Rust lakehouse) · fixed (Go dev ports shifted to 3110+) - Total: 14 findings · 11 fixed · 3 deferred to G2 What landed in code: - internal/shared/server.go — chi factory, slog JSON, /health, graceful shutdown via signal.NotifyContext - internal/shared/config.go — TOML loader, DefaultConfig, -config flag - cmd/{gateway,storaged,catalogd,ingestd,queryd}/main.go — five binaries, each ~30 lines using the shared factory - lakehouse.toml — G0 dev defaults (3110-3214) - scripts/d1_smoke.sh — repeatable smoke that exits 0 on PASS - go.mod / go.sum — chi v5.2.5, pelletier/go-toml/v2 v2.3.0 Verified end-to-end via scripts/d1_smoke.sh: - All 5 /health endpoints return 200 with correct service name - Gateway /v1/ingest + /v1/sql stubs return 501 with X-Lakehouse-Stub - Graceful shutdown logs cleanly on SIGTERM - DuckDB cgo path verified separately (sql.Open("duckdb","") + ping) D1 ACCEPTANCE GATE: PASSED. Next: D2 — storaged S3 GET/PUT/LIST against MinIO. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
2026-04-28 07:00:37 -05:00
parent a74fdb1204
commit 1142f54f23
12 changed files with 586 additions and 6 deletions
@@ -0,0 +1,90 @@
+// Package shared also provides the TOML config loader. Per ADR
+// equivalent of Rust ADR-006 (TOML config over env vars), every
+// service reads `lakehouse.toml` with sane defaults and env
+// overrides. Config is hot-reload-unaware in G0; reload-on-SIGHUP
+// is a G1+ concern.
+package shared
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/pelletier/go-toml/v2"
+)
+
+// Config is the unified Lakehouse config. Each service reads only
+// the section it cares about, but they all share the same file so
+// operators have one place to look.
+type Config struct {
+	Gateway  ServiceConfig `toml:"gateway"`
+	Storaged ServiceConfig `toml:"storaged"`
+	Catalogd ServiceConfig `toml:"catalogd"`
+	Ingestd  ServiceConfig `toml:"ingestd"`
+	Queryd   ServiceConfig `toml:"queryd"`
+	S3       S3Config      `toml:"s3"`
+	Log      LogConfig     `toml:"log"`
+}
+
+// ServiceConfig is the per-binary bind config. Default Bind ""
+// means "use the service's hardcoded G0 default" — see DefaultConfig.
+type ServiceConfig struct {
+	Bind string `toml:"bind"`
+}
+
+// S3Config holds S3-compatible storage settings. Endpoint blank →
+// AWS default. Bucket "" → "lakehouse-primary".
+type S3Config struct {
+	Endpoint        string `toml:"endpoint"`
+	Region          string `toml:"region"`
+	Bucket          string `toml:"bucket"`
+	AccessKeyID     string `toml:"access_key_id"`
+	SecretAccessKey string `toml:"secret_access_key"`
+	UsePathStyle    bool   `toml:"use_path_style"`
+}
+
+// LogConfig — slog level for now; structured fields land G1+.
+type LogConfig struct {
+	Level string `toml:"level"`
+}
+
+// DefaultConfig returns the G0 dev defaults. Ports are shifted to
+// 3110+ to coexist with the live Rust lakehouse on 3100/3201-3204
+// during the migration. G5 cutover flips gateway back to 3100.
+func DefaultConfig() Config {
+	return Config{
+		Gateway:  ServiceConfig{Bind: "127.0.0.1:3110"},
+		Storaged: ServiceConfig{Bind: "127.0.0.1:3211"},
+		Catalogd: ServiceConfig{Bind: "127.0.0.1:3212"},
+		Ingestd:  ServiceConfig{Bind: "127.0.0.1:3213"},
+		Queryd:   ServiceConfig{Bind: "127.0.0.1:3214"},
+		S3: S3Config{
+			Endpoint:     "http://localhost:9000",
+			Region:       "us-east-1",
+			Bucket:       "lakehouse-primary",
+			UsePathStyle: true,
+		},
+		Log: LogConfig{Level: "info"},
+	}
+}
+
+// LoadConfig reads `lakehouse.toml` from path; if path is empty or
+// the file doesn't exist, returns DefaultConfig. Any decode error is
+// fatal (we don't want a misconfigured service silently falling back
+// to defaults — that's the kind of bug you find at 2am).
+func LoadConfig(path string) (Config, error) {
+	cfg := DefaultConfig()
+	if path == "" {
+		return cfg, nil
+	}
+	b, err := os.ReadFile(path)
+	if os.IsNotExist(err) {
+		return cfg, nil
+	}
+	if err != nil {
+		return cfg, fmt.Errorf("read config: %w", err)
+	}
+	if err := toml.Unmarshal(b, &cfg); err != nil {
+		return cfg, fmt.Errorf("parse config: %w", err)
+	}
+	return cfg, nil
+}
@@ -0,0 +1,113 @@
+// Package shared provides common HTTP server bootstrap for every
+// Lakehouse-Go service. Each cmd/<service> calls Run with its name,
+// bind address, and a route-registration callback. The factory wires
+// chi, slog, /health, and graceful shutdown identically across all
+// five binaries — the place where uniformity beats per-service
+// flexibility.
+//
+// G1+ note: when queryd needs to drain a cgo DuckDB handle on
+// shutdown, the simple shared factory will need a per-service hook
+// (an io.Closer slice or an OnShutdown callback). For G0 a plain
+// chi.Router + http.Server.Shutdown(ctx) is sufficient.
+package shared
+
+import (
+	"context"
+	"encoding/json"
+	"log/slog"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/go-chi/chi/v5/middleware"
+)
+
+// HealthResponse is the JSON shape returned by /health on every
+// service. Service-specific status hooks can extend it post-G0.
+type HealthResponse struct {
+	Status  string `json:"status"`
+	Service string `json:"service"`
+}
+
+// RegisterRoutes is the per-service callback that wires its own
+// routes onto the shared router AFTER /health has been mounted.
+type RegisterRoutes func(r chi.Router)
+
+// Run boots a chi router with slog logging, the /health endpoint,
+// and graceful-shutdown handling. Blocks until SIGINT/SIGTERM.
+func Run(serviceName, addr string, register RegisterRoutes) error {
+	logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
+		Level: slog.LevelInfo,
+	}))
+	slog.SetDefault(logger)
+
+	r := chi.NewRouter()
+	r.Use(middleware.RequestID)
+	r.Use(middleware.RealIP)
+	r.Use(middleware.Recoverer)
+	r.Use(slogRequest(logger))
+
+	r.Get("/health", func(w http.ResponseWriter, _ *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		_ = json.NewEncoder(w).Encode(HealthResponse{
+			Status:  "ok",
+			Service: serviceName,
+		})
+	})
+
+	if register != nil {
+		register(r)
+	}
+
+	srv := &http.Server{
+		Addr:              addr,
+		Handler:           r,
+		ReadHeaderTimeout: 10 * time.Second,
+	}
+
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
+	defer stop()
+
+	errCh := make(chan error, 1)
+	go func() {
+		logger.Info("listening", "service", serviceName, "addr", addr)
+		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			errCh <- err
+		}
+	}()
+
+	select {
+	case <-ctx.Done():
+		logger.Info("shutdown signal received", "service", serviceName)
+	case err := <-errCh:
+		return err
+	}
+
+	shutdownCtx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
+	defer cancel()
+	return srv.Shutdown(shutdownCtx)
+}
+
+// slogRequest returns a chi middleware that logs each request via slog.
+// Replaces chi's default text logger so all log output stays JSON.
+func slogRequest(logger *slog.Logger) func(http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			start := time.Now()
+			ww := middleware.NewWrapResponseWriter(w, r.ProtoMajor)
+			defer func() {
+				logger.Info("http",
+					"method", r.Method,
+					"path", r.URL.Path,
+					"status", ww.Status(),
+					"dur_ms", time.Since(start).Milliseconds(),
+					"req_id", middleware.GetReqID(r.Context()),
+				)
+			}()
+			next.ServeHTTP(ww, r)
+		})
+	}
+}