feat: user service

user/internal/adminapi/server.go

@@ -0,0 +1,133 @@
+// Package adminapi exposes the optional private admin HTTP listener used for
+// operational endpoints such as Prometheus metrics.
+package adminapi
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log/slog"
+	"net"
+	"net/http"
+	"sync"
+
+	"galaxy/user/internal/config"
+)
+
+// Server owns the optional admin HTTP listener exposed by the user service.
+type Server struct {
+	cfg     config.AdminHTTPConfig
+	handler http.Handler
+	logger  *slog.Logger
+
+	stateMu  sync.RWMutex
+	server   *http.Server
+	listener net.Listener
+}
+
+// NewServer constructs an admin HTTP server for cfg and handler.
+func NewServer(cfg config.AdminHTTPConfig, handler http.Handler, logger *slog.Logger) *Server {
+	if handler == nil {
+		handler = http.NotFoundHandler()
+	}
+	if logger == nil {
+		logger = slog.Default()
+	}
+	mux := http.NewServeMux()
+	mux.Handle("GET /metrics", handler)
+
+	return &Server{
+		cfg:     cfg,
+		handler: mux,
+		logger:  logger.With("component", "admin_http"),
+	}
+}
+
+// Enabled reports whether the admin listener should run.
+func (server *Server) Enabled() bool {
+	return server != nil && server.cfg.Addr != ""
+}
+
+// Run binds the configured listener and serves the admin HTTP surface until
+// Shutdown closes the server. A disabled admin server returns when ctx is
+// canceled.
+func (server *Server) Run(ctx context.Context) error {
+	if ctx == nil {
+		return errors.New("run admin HTTP server: nil context")
+	}
+	if err := ctx.Err(); err != nil {
+		return err
+	}
+	if !server.Enabled() {
+		<-ctx.Done()
+		return nil
+	}
+
+	listener, err := net.Listen("tcp", server.cfg.Addr)
+	if err != nil {
+		return fmt.Errorf("run admin HTTP server: listen on %q: %w", server.cfg.Addr, err)
+	}
+
+	httpServer := &http.Server{
+		Handler:           server.handler,
+		ReadHeaderTimeout: server.cfg.ReadHeaderTimeout,
+		ReadTimeout:       server.cfg.ReadTimeout,
+		IdleTimeout:       server.cfg.IdleTimeout,
+	}
+
+	server.stateMu.Lock()
+	server.server = httpServer
+	server.listener = listener
+	server.stateMu.Unlock()
+
+	server.logger.Info("admin HTTP server started", "addr", listener.Addr().String())
+
+	shutdownDone := make(chan struct{})
+	go func() {
+		defer close(shutdownDone)
+		<-ctx.Done()
+		shutdownCtx, cancel := context.WithTimeout(context.Background(), server.cfg.ReadTimeout)
+		defer cancel()
+		_ = server.Shutdown(shutdownCtx)
+	}()
+
+	defer func() {
+		server.stateMu.Lock()
+		server.server = nil
+		server.listener = nil
+		server.stateMu.Unlock()
+		<-shutdownDone
+	}()
+
+	err = httpServer.Serve(listener)
+	switch {
+	case err == nil:
+		return nil
+	case errors.Is(err, http.ErrServerClosed):
+		server.logger.Info("admin HTTP server stopped")
+		return nil
+	default:
+		return fmt.Errorf("run admin HTTP server: serve on %q: %w", server.cfg.Addr, err)
+	}
+}
+
+// Shutdown gracefully stops the admin HTTP server within ctx.
+func (server *Server) Shutdown(ctx context.Context) error {
+	if ctx == nil {
+		return errors.New("shutdown admin HTTP server: nil context")
+	}
+
+	server.stateMu.RLock()
+	httpServer := server.server
+	server.stateMu.RUnlock()
+
+	if httpServer == nil {
+		return nil
+	}
+
+	if err := httpServer.Shutdown(ctx); err != nil && !errors.Is(err, http.ErrServerClosed) {
+		return fmt.Errorf("shutdown admin HTTP server: %w", err)
+	}
+
+	return nil
+}

user/internal/adminapi/server_test.go

@@ -0,0 +1,98 @@
+package adminapi
+
+import (
+	"context"
+	"net/http"
+	"testing"
+	"time"
+
+	"galaxy/user/internal/config"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestServerRunDisabledWaitsForContext(t *testing.T) {
+	t.Parallel()
+
+	server := NewServer(config.AdminHTTPConfig{}, http.HandlerFunc(func(http.ResponseWriter, *http.Request) {
+		t.Fatal("disabled admin server must not serve requests")
+	}), nil)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	errCh := make(chan error, 1)
+	go func() {
+		errCh <- server.Run(ctx)
+	}()
+
+	cancel()
+
+	select {
+	case err := <-errCh:
+		require.ErrorIs(t, err, context.Canceled)
+	case <-time.After(2 * time.Second):
+		t.Fatal("disabled admin server did not stop after context cancellation")
+	}
+}
+
+func TestServerRunServesMetricsOnly(t *testing.T) {
+	t.Parallel()
+
+	server := NewServer(config.AdminHTTPConfig{
+		Addr:              "127.0.0.1:0",
+		ReadHeaderTimeout: 2 * time.Second,
+		ReadTimeout:       10 * time.Second,
+		IdleTimeout:       time.Minute,
+	}, http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		_, _ = w.Write([]byte("sample_metric 1\n"))
+	}), nil)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	errCh := make(chan error, 1)
+	go func() {
+		errCh <- server.Run(ctx)
+	}()
+
+	addr := waitForListener(t, server)
+
+	metricsResponse, err := http.Get("http://" + addr + "/metrics")
+	require.NoError(t, err)
+	t.Cleanup(func() { _ = metricsResponse.Body.Close() })
+	require.Equal(t, http.StatusOK, metricsResponse.StatusCode)
+
+	rootResponse, err := http.Get("http://" + addr + "/")
+	require.NoError(t, err)
+	t.Cleanup(func() { _ = rootResponse.Body.Close() })
+	require.Equal(t, http.StatusNotFound, rootResponse.StatusCode)
+
+	cancel()
+
+	select {
+	case err := <-errCh:
+		require.NoError(t, err)
+	case <-time.After(2 * time.Second):
+		t.Fatal("admin server did not stop after context cancellation")
+	}
+}
+
+func waitForListener(t *testing.T, server *Server) string {
+	t.Helper()
+
+	deadline := time.Now().Add(2 * time.Second)
+	for time.Now().Before(deadline) {
+		server.stateMu.RLock()
+		listener := server.listener
+		server.stateMu.RUnlock()
+		if listener != nil {
+			return listener.Addr().String()
+		}
+
+		time.Sleep(10 * time.Millisecond)
+	}
+
+	t.Fatal("admin server listener did not start")
+	return ""
+}