feat: edge gateway service

gateway/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"
+	"net"
+	"net/http"
+	"sync"
+
+	"galaxy/gateway/internal/config"
+
+	"go.uber.org/zap"
+)
+
+// Server owns the optional admin HTTP listener exposed by the gateway.
+type Server struct {
+	cfg     config.AdminHTTPConfig
+	handler http.Handler
+	logger  *zap.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 *zap.Logger) *Server {
+	if handler == nil {
+		handler = http.NotFoundHandler()
+	}
+	if logger == nil {
+		logger = zap.NewNop()
+	}
+
+	return &Server{
+		cfg:     cfg,
+		handler: handler,
+		logger:  logger.Named("admin_http"),
+	}
+}
+
+// Enabled reports whether the admin listener should run.
+func (s *Server) Enabled() bool {
+	return s != nil && s.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 (s *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 !s.Enabled() {
+		<-ctx.Done()
+		return nil
+	}
+
+	listener, err := net.Listen("tcp", s.cfg.Addr)
+	if err != nil {
+		return fmt.Errorf("run admin HTTP server: listen on %q: %w", s.cfg.Addr, err)
+	}
+
+	server := &http.Server{
+		Handler:           s.handler,
+		ReadHeaderTimeout: s.cfg.ReadHeaderTimeout,
+		ReadTimeout:       s.cfg.ReadTimeout,
+		IdleTimeout:       s.cfg.IdleTimeout,
+	}
+
+	s.stateMu.Lock()
+	s.server = server
+	s.listener = listener
+	s.stateMu.Unlock()
+
+	s.logger.Info("admin HTTP server started", zap.String("addr", listener.Addr().String()))
+
+	defer func() {
+		s.stateMu.Lock()
+		s.server = nil
+		s.listener = nil
+		s.stateMu.Unlock()
+	}()
+
+	err = server.Serve(listener)
+	switch {
+	case err == nil:
+		return nil
+	case errors.Is(err, http.ErrServerClosed):
+		s.logger.Info("admin HTTP server stopped")
+		return nil
+	default:
+		return fmt.Errorf("run admin HTTP server: serve on %q: %w", s.cfg.Addr, err)
+	}
+}
+
+// Shutdown gracefully stops the admin HTTP server within ctx.
+func (s *Server) Shutdown(ctx context.Context) error {
+	if ctx == nil {
+		return errors.New("shutdown admin HTTP server: nil context")
+	}
+
+	s.stateMu.RLock()
+	server := s.server
+	s.stateMu.RUnlock()
+
+	if server == nil {
+		return nil
+	}
+
+	if err := server.Shutdown(ctx); err != nil && !errors.Is(err, http.ErrServerClosed) {
+		return fmt.Errorf("shutdown admin HTTP server: %w", err)
+	}
+
+	return nil
+}
+
+func (s *Server) listenAddr() string {
+	s.stateMu.RLock()
+	defer s.stateMu.RUnlock()
+
+	if s.listener == nil {
+		return ""
+	}
+
+	return s.listener.Addr().String()
+}

gateway/internal/adminapi/server_test.go

@@ -0,0 +1,102 @@
+package adminapi
+
+import (
+	"context"
+	"net"
+	"net/http"
+	"testing"
+	"time"
+
+	"galaxy/gateway/internal/app"
+	"galaxy/gateway/internal/config"
+	"galaxy/gateway/internal/restapi"
+	"galaxy/gateway/internal/testutil"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestMetricsAreReachableOnlyOnAdminListener(t *testing.T) {
+	t.Parallel()
+
+	logger, _ := testutil.NewObservedLogger(t)
+	telemetryRuntime := testutil.NewTelemetryRuntime(t, logger)
+
+	publicAddr := unusedTCPAddr(t)
+	adminAddr := unusedTCPAddr(t)
+
+	publicCfg := config.DefaultPublicHTTPConfig()
+	publicCfg.Addr = publicAddr
+	adminCfg := config.DefaultAdminHTTPConfig()
+	adminCfg.Addr = adminAddr
+
+	restServer := restapi.NewServer(publicCfg, restapi.ServerDependencies{
+		Logger:    logger,
+		Telemetry: telemetryRuntime,
+	})
+	adminServer := NewServer(adminCfg, telemetryRuntime.Handler(), logger)
+
+	application := app.New(
+		config.Config{
+			ShutdownTimeout:   time.Second,
+			PublicHTTP:        publicCfg,
+			AdminHTTP:         adminCfg,
+			AuthenticatedGRPC: config.DefaultAuthenticatedGRPCConfig(),
+		},
+		restServer,
+		adminServer,
+	)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	resultCh := make(chan error, 1)
+	go func() {
+		resultCh <- application.Run(ctx)
+	}()
+	defer func() {
+		cancel()
+		select {
+		case err := <-resultCh:
+			require.NoError(t, err)
+		case <-time.After(time.Second):
+			require.FailNow(t, "application did not stop")
+		}
+	}()
+
+	waitForHTTPStatus(t, "http://"+publicAddr+"/healthz", http.StatusOK)
+	waitForHTTPStatus(t, "http://"+adminAddr+"/metrics", http.StatusOK)
+
+	publicMetricsResp, err := http.Get("http://" + publicAddr + "/metrics")
+	require.NoError(t, err)
+	defer func() {
+		require.NoError(t, publicMetricsResp.Body.Close())
+	}()
+	assert.Equal(t, http.StatusNotFound, publicMetricsResp.StatusCode)
+}
+
+func waitForHTTPStatus(t *testing.T, rawURL string, wantStatus int) {
+	t.Helper()
+
+	require.Eventually(t, func() bool {
+		resp, err := http.Get(rawURL)
+		if err != nil {
+			return false
+		}
+		defer func() {
+			_ = resp.Body.Close()
+		}()
+
+		return resp.StatusCode == wantStatus
+	}, time.Second, 10*time.Millisecond)
+}
+
+func unusedTCPAddr(t *testing.T) string {
+	t.Helper()
+
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	require.NoError(t, err)
+
+	addr := listener.Addr().String()
+	require.NoError(t, listener.Close())
+
+	return addr
+}