Runtime controls and repository boundaries

internal/api/admin/request.go

@@ -0,0 +1,13 @@
+package admin
+
+import (
+	"net/http"
+
+	"github.com/JSYoo5B/SandStack/internal/api/respond"
+)
+
+func (h Handler) listRequests(w http.ResponseWriter, _ *http.Request) {
+	respond.JSON(w, http.StatusOK, requestListResponse{
+		Requests: toRequestDocuments(h.requests.List()),
+	})
+}

internal/api/admin/request_dto.go

@@ -0,0 +1,28 @@
+package admin
+
+import "github.com/JSYoo5B/SandStack/internal/app/requestlog"
+
+type requestListResponse struct {
+	Requests []requestDocument `json:"requests"`
+}
+
+type requestDocument struct {
+	ID     string `json:"id"`
+	Method string `json:"method"`
+	Path   string `json:"path"`
+	Status int    `json:"status"`
+}
+
+func toRequestDocuments(records []requestlog.Record) []requestDocument {
+	documents := make([]requestDocument, 0, len(records))
+	for _, record := range records {
+		documents = append(documents, requestDocument{
+			ID:     record.ID,
+			Method: record.Method,
+			Path:   record.Path,
+			Status: record.Status,
+		})
+	}
+
+	return documents
+}

internal/api/admin/reset.go

@@ -0,0 +1,8 @@
+package admin
+
+import "net/http"
+
+func (h Handler) resetState(w http.ResponseWriter, _ *http.Request) {
+	h.reset()
+	w.WriteHeader(http.StatusNoContent)
+}

internal/api/admin/router.go

@@ -3,13 +3,36 @@ package admin
 import (
 	"net/http"
 
+	"github.com/JSYoo5B/SandStack/internal/app/requestlog"
 	"github.com/go-chi/chi/v5"
 )
 
 func NewRouter() http.Handler {
+	return NewRouterWithReset(func() {})
+}
+
+func NewRouterWithReset(reset func()) http.Handler {
+	return NewRouterWithState(reset, requestlog.NewService())
+}
+
+func NewRouterWithState(
+	reset func(),
+	requests *requestlog.Service,
+) http.Handler {
+	handler := Handler{
+		reset:    reset,
+		requests: requests,
+	}
 	router := chi.NewRouter()
 	router.Get("/health", status)
 	router.Get("/ready", status)
+	router.Post("/reset", handler.resetState)
+	router.Get("/requests", handler.listRequests)
 
 	return router
 }
+
+type Handler struct {
+	reset    func()
+	requests *requestlog.Service
+}

internal/api/compute/router.go

@@ -17,10 +17,24 @@ func NewRouter(cfg config.Config) http.Handler {
 	return NewHandler(cfg).Router()
 }
 
+func NewRouterWithService(
+	cfg config.Config,
+	service *appcompute.Service,
+) http.Handler {
+	return NewHandlerWithService(cfg, service).Router()
+}
+
 func NewHandler(cfg config.Config) Handler {
+	return NewHandlerWithService(cfg, appcompute.NewService())
+}
+
+func NewHandlerWithService(
+	cfg config.Config,
+	service *appcompute.Service,
+) Handler {
 	return Handler{
 		config:  cfg,
-		service: appcompute.NewService(),
+		service: service,
 	}
 }
 

internal/api/image/router.go

@@ -17,10 +17,24 @@ func NewRouter(cfg config.Config) http.Handler {
 	return NewHandler(cfg).Router()
 }
 
+func NewRouterWithService(
+	cfg config.Config,
+	service *appimage.Service,
+) http.Handler {
+	return NewHandlerWithService(cfg, service).Router()
+}
+
 func NewHandler(cfg config.Config) Handler {
+	return NewHandlerWithService(cfg, appimage.NewService())
+}
+
+func NewHandlerWithService(
+	cfg config.Config,
+	service *appimage.Service,
+) Handler {
 	return Handler{
 		config:  cfg,
-		service: appimage.NewService(),
+		service: service,
 	}
 }
 

internal/api/middleware.go

@@ -0,0 +1,50 @@
+package api
+
+import (
+	"net/http"
+	"strings"
+
+	"github.com/JSYoo5B/SandStack/internal/app/requestlog"
+	"github.com/JSYoo5B/SandStack/internal/platform/idgen"
+)
+
+func requestID(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("X-Openstack-Request-Id", "req-"+idgen.RandomHex(16))
+		next.ServeHTTP(w, r)
+	})
+}
+
+func recordRequests(requests *requestlog.Service) func(http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			recorder := &statusRecorder{
+				ResponseWriter: w,
+				status:         http.StatusOK,
+			}
+
+			next.ServeHTTP(recorder, r)
+
+			if strings.HasPrefix(r.URL.Path, "/_sandstack") {
+				return
+			}
+
+			requests.Add(requestlog.Record{
+				ID:     w.Header().Get("X-Openstack-Request-Id"),
+				Method: r.Method,
+				Path:   r.URL.Path,
+				Status: recorder.status,
+			})
+		})
+	}
+}
+
+type statusRecorder struct {
+	http.ResponseWriter
+	status int
+}
+
+func (r *statusRecorder) WriteHeader(status int) {
+	r.status = status
+	r.ResponseWriter.WriteHeader(status)
+}

internal/api/network/router.go

@@ -17,10 +17,24 @@ func NewRouter(cfg config.Config) http.Handler {
 	return NewHandler(cfg).Router()
 }
 
+func NewRouterWithService(
+	cfg config.Config,
+	service *appnetwork.Service,
+) http.Handler {
+	return NewHandlerWithService(cfg, service).Router()
+}
+
 func NewHandler(cfg config.Config) Handler {
+	return NewHandlerWithService(cfg, appnetwork.NewService())
+}
+
+func NewHandlerWithService(
+	cfg config.Config,
+	service *appnetwork.Service,
+) Handler {
 	return Handler{
 		config:  cfg,
-		service: appnetwork.NewService(),
+		service: service,
 	}
 }
 

internal/api/router.go

@@ -10,34 +10,43 @@ import (
 	"github.com/JSYoo5B/SandStack/internal/api/network"
 	"github.com/JSYoo5B/SandStack/internal/api/placement"
 	"github.com/JSYoo5B/SandStack/internal/api/volume"
+	appcompute "github.com/JSYoo5B/SandStack/internal/app/compute"
+	appimage "github.com/JSYoo5B/SandStack/internal/app/image"
+	appnetwork "github.com/JSYoo5B/SandStack/internal/app/network"
+	"github.com/JSYoo5B/SandStack/internal/app/requestlog"
+	appvolume "github.com/JSYoo5B/SandStack/internal/app/volume"
 	"github.com/JSYoo5B/SandStack/internal/platform/config"
-	"github.com/JSYoo5B/SandStack/internal/platform/idgen"
 	"github.com/go-chi/chi/v5"
 )
 
 func NewRouter(cfg config.Config) http.Handler {
 	router := chi.NewRouter()
 	router.Use(requestID)
+	requests := requestlog.NewService()
+	router.Use(recordRequests(requests))
 	identityHandler := identity.NewHandler(cfg)
-
-	router.Mount("/_sandstack", admin.NewRouter())
+	computeService := appcompute.NewService()
+	imageService := appimage.NewService()
+	networkService := appnetwork.NewService()
+	volumeService := appvolume.NewService()
+
+	router.Mount("/_sandstack", admin.NewRouterWithState(func() {
+		computeService.Reset()
+		imageService.Reset()
+		networkService.Reset()
+		volumeService.Reset()
+		requests.Reset()
+	}, requests))
 
 	router.Get("/identity", identityHandler.Discovery())
 	router.Get("/identity/", identityHandler.Discovery())
 	router.Mount("/identity/v3", identityHandler.Router())
 
-	router.Mount("/compute/v2.1", compute.NewRouter(cfg))
-	router.Mount("/image/v2", image.NewRouter(cfg))
-	router.Mount("/network/v2.0", network.NewRouter(cfg))
+	router.Mount("/compute/v2.1", compute.NewRouterWithService(cfg, computeService))
+	router.Mount("/image/v2", image.NewRouterWithService(cfg, imageService))
+	router.Mount("/network/v2.0", network.NewRouterWithService(cfg, networkService))
 	router.Mount("/placement", placement.NewRouter(cfg))
-	router.Mount("/volume/v3", volume.NewRouter(cfg))
+	router.Mount("/volume/v3", volume.NewRouterWithService(cfg, volumeService))
 
 	return router
 }
-
-func requestID(next http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("X-Openstack-Request-Id", "req-"+idgen.RandomHex(16))
-		next.ServeHTTP(w, r)
-	})
-}

internal/api/router_test.go

@@ -1,6 +1,7 @@
 package api_test
 
 import (
+	"encoding/json"
 	"net/http"
 	"net/http/httptest"
 	"testing"
@@ -9,6 +10,7 @@ import (
 	"github.com/JSYoo5B/SandStack/internal/platform/config"
 	"github.com/JSYoo5B/SandStack/internal/testhelper"
 	"github.com/gophercloud/gophercloud/v2/openstack"
+	"github.com/gophercloud/gophercloud/v2/openstack/image/v2/images"
 	"github.com/stretchr/testify/suite"
 )
 
@@ -49,3 +51,70 @@ func (s *RouterSuite) TestMountedIdentityPasswordAuth() {
 
 	s.Assert().NotEmpty(provider.TokenID)
 }
+
+func (s *RouterSuite) TestMountedSandstackResetClearsState() {
+	created, err := images.Create(
+		s.T().Context(),
+		testhelper.ServiceClient(s.server.URL+"/image/v2"),
+		images.CreateOpts{
+			Name:            "ubuntu",
+			ContainerFormat: "bare",
+			DiskFormat:      "qcow2",
+		},
+	).Extract()
+	s.Require().NoError(err)
+	s.Require().NotNil(created)
+
+	response, err := http.Post(
+		s.server.URL+"/_sandstack/reset",
+		"application/json",
+		nil,
+	)
+	s.Require().NoError(err)
+	defer response.Body.Close()
+
+	pages, err := images.List(
+		testhelper.ServiceClient(s.server.URL+"/image/v2"),
+		nil,
+	).AllPages(s.T().Context())
+	s.Require().NoError(err)
+
+	list, err := images.ExtractImages(pages)
+	s.Require().NoError(err)
+
+	s.Assert().Equal(http.StatusNoContent, response.StatusCode)
+	s.Assert().Empty(list)
+}
+
+func (s *RouterSuite) TestMountedSandstackRequestsRecordsOpenStackAPI() {
+	response, err := http.Get(s.server.URL + "/image/v2/images")
+	s.Require().NoError(err)
+	defer response.Body.Close()
+
+	requestsResponse, err := http.Get(s.server.URL + "/_sandstack/requests")
+	s.Require().NoError(err)
+	defer requestsResponse.Body.Close()
+
+	var body requestListResponse
+	err = json.NewDecoder(requestsResponse.Body).Decode(&body)
+	s.Require().NoError(err)
+
+	s.Assert().Equal(http.StatusOK, response.StatusCode)
+	s.Assert().Equal(http.StatusOK, requestsResponse.StatusCode)
+	s.Require().Len(body.Requests, 1)
+	s.Assert().NotEmpty(body.Requests[0].ID)
+	s.Assert().Equal(http.MethodGet, body.Requests[0].Method)
+	s.Assert().Equal("/image/v2/images", body.Requests[0].Path)
+	s.Assert().Equal(http.StatusOK, body.Requests[0].Status)
+}
+
+type requestListResponse struct {
+	Requests []requestDocument `json:"requests"`
+}
+
+type requestDocument struct {
+	ID     string `json:"id"`
+	Method string `json:"method"`
+	Path   string `json:"path"`
+	Status int    `json:"status"`
+}

internal/api/volume/router.go

@@ -17,10 +17,24 @@ func NewRouter(cfg config.Config) http.Handler {
 	return NewHandler(cfg).Router()
 }
 
+func NewRouterWithService(
+	cfg config.Config,
+	service *appvolume.Service,
+) http.Handler {
+	return NewHandlerWithService(cfg, service).Router()
+}
+
 func NewHandler(cfg config.Config) Handler {
+	return NewHandlerWithService(cfg, appvolume.NewService())
+}
+
+func NewHandlerWithService(
+	cfg config.Config,
+	service *appvolume.Service,
+) Handler {
 	return Handler{
 		config:  cfg,
-		service: appvolume.NewService(),
+		service: service,
 	}
 }