Ilia Denisov
134 lines
3.1 KiB
Go
134 lines
3.1 KiB
Go
// 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
|
|
}
|