Add Forgejo namespace workflow stack

services/forgejo-nsc/internal/server/server.go

@@ -0,0 +1,151 @@
+package server
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"log/slog"
+	"net/http"
+	"time"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/go-chi/chi/v5/middleware"
+
+	"github.com/burrow/forgejo-nsc/internal/app"
+)
+
+type Server struct {
+	httpServer *http.Server
+	app        *app.Service
+	log        *slog.Logger
+}
+
+func New(listen string, svc *app.Service, logger *slog.Logger) *Server {
+	if logger == nil {
+		logger = slog.Default()
+	}
+
+	router := chi.NewRouter()
+	router.Use(middleware.RequestID)
+	router.Use(middleware.RealIP)
+	router.Use(middleware.Logger)
+	router.Use(middleware.Recoverer)
+
+	s := &Server{
+		app: svc,
+		log: logger,
+		httpServer: &http.Server{
+			Addr:        listen,
+			Handler:     router,
+			ReadTimeout: 30 * time.Second,
+			// Dispatch requests can legitimately run for the duration of a build.
+			// A short WriteTimeout will kill the request context mid-provisioning.
+			WriteTimeout: 2 * time.Hour,
+			IdleTimeout:  60 * time.Second,
+		},
+	}
+
+	router.Get("/healthz", s.handleHealthz)
+	router.Post("/api/v1/dispatch", s.handleDispatch)
+
+	return s
+}
+
+func (s *Server) ListenAndServe() error {
+	return s.httpServer.ListenAndServe()
+}
+
+func (s *Server) Shutdown(ctx context.Context) error {
+	return s.httpServer.Shutdown(ctx)
+}
+
+// Handler exposes the underlying HTTP handler for tests.
+func (s *Server) Handler() http.Handler {
+	return s.httpServer.Handler
+}
+
+type dispatchRequest struct {
+	Count   int               `json:"count"`
+	Labels  []string          `json:"labels"`
+	Scope   *dispatchScope    `json:"scope"`
+	TTL     string            `json:"ttl"`
+	Machine string            `json:"machine_type"`
+	Image   string            `json:"image"`
+	Env     map[string]string `json:"env"`
+}
+
+type dispatchScope struct {
+	Level string `json:"level"`
+	Owner string `json:"owner"`
+	Name  string `json:"name"`
+}
+
+func (s *Server) handleDispatch(w http.ResponseWriter, r *http.Request) {
+	var payload dispatchRequest
+	if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {
+		s.writeError(w, http.StatusBadRequest, err)
+		return
+	}
+
+	duration, err := parseDuration(payload.TTL)
+	if err != nil {
+		s.writeError(w, http.StatusBadRequest, err)
+		return
+	}
+
+	var scope *app.Scope
+	if payload.Scope != nil {
+		scope = &app.Scope{
+			Level: payload.Scope.Level,
+			Owner: payload.Scope.Owner,
+			Name:  payload.Scope.Name,
+		}
+	}
+
+	resp, err := s.app.Dispatch(r.Context(), app.DispatchRequest{
+		Count:    payload.Count,
+		Labels:   payload.Labels,
+		Scope:    scope,
+		TTL:      duration,
+		Machine:  payload.Machine,
+		Image:    payload.Image,
+		ExtraEnv: payload.Env,
+	})
+	if err != nil {
+		s.writeError(w, http.StatusInternalServerError, err)
+		return
+	}
+
+	s.writeJSON(w, http.StatusOK, resp)
+}
+
+func parseDuration(value string) (time.Duration, error) {
+	if value == "" {
+		return 0, nil
+	}
+	dur, err := time.ParseDuration(value)
+	if err != nil {
+		return 0, err
+	}
+	if dur <= 0 {
+		return 0, errors.New("ttl must be positive")
+	}
+	return dur, nil
+}
+
+func (s *Server) handleHealthz(w http.ResponseWriter, _ *http.Request) {
+	s.writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
+}
+
+func (s *Server) writeError(w http.ResponseWriter, code int, err error) {
+	s.log.Error("request failed", "err", err, "status", code)
+	s.writeJSON(w, code, map[string]string{
+		"error": err.Error(),
+	})
+}
+
+func (s *Server) writeJSON(w http.ResponseWriter, code int, payload any) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(code)
+	_ = json.NewEncoder(w).Encode(payload)
+}