Adding committed resource usage API

cmd/main.go

@@ -323,11 +323,8 @@ func main() {
 		}
 		nova.NewAPI(filterWeigherController).Init(mux)
 
-		// Initialize commitments API for LIQUID interface
-		commitmentsAPI := commitments.NewAPI(multiclusterClient)
-		commitmentsAPI.Init(mux)
-
 		// Detector pipeline controller setup.
+		// Nova client is created first so it can be passed to the commitments API
 		novaClient := nova.NewNovaClient()
 		novaClientConfig := conf.GetConfigOrDie[nova.NovaClientConfig]()
 		if err := mgr.Add(manager.RunnableFunc(func(ctx context.Context) error {
@@ -336,6 +333,12 @@ func main() {
 			setupLog.Error(err, "unable to initialize nova client")
 			os.Exit(1)
 		}
+
+		// Initialize commitments API for LIQUID interface (with Nova client for usage reporting)
+		commitmentsConfig := conf.GetConfigOrDie[commitments.Config]()
+		commitmentsAPI := commitments.NewAPIWithConfig(multiclusterClient, commitmentsConfig, novaClient)
+		commitmentsAPI.Init(mux)
+
 		deschedulingsController := &nova.DetectorPipelineController{
 			Monitor: detectorPipelineMonitor,
 			Breaker: &nova.DetectorCycleBreaker{NovaClient: novaClient},

internal/scheduling/nova/deschedulings_executor_test.go

@@ -72,6 +72,10 @@ func (m *mockExecutorNovaClient) GetServerMigrations(ctx context.Context, id str
 	return []migration{}, nil
 }
 
+func (m *mockExecutorNovaClient) ListProjectServers(ctx context.Context, projectID string) ([]ServerDetail, error) {
+	return []ServerDetail{}, nil
+}
+
 func TestExecutor_Reconcile(t *testing.T) {
 	scheme := runtime.NewScheme()
 	err := v1alpha1.AddToScheme(scheme)

internal/scheduling/nova/detector_cycle_breaker_test.go

@@ -39,6 +39,10 @@ func (m *mockDetectorCycleBreakerNovaClient) GetServerMigrations(ctx context.Con
 	return []migration{}, nil
 }
 
+func (m *mockDetectorCycleBreakerNovaClient) ListProjectServers(ctx context.Context, projectID string) ([]ServerDetail, error) {
+	return []ServerDetail{}, nil
+}
+
 func TestDetectorCycleBreaker_Filter(t *testing.T) {
 	tests := []struct {
 		name       string

internal/scheduling/nova/nova_client.go

@@ -38,6 +38,21 @@ type migration struct {
 	DestCompute   string `json:"dest_compute"`
 }
 
+// ServerDetail contains extended server information for usage reporting.
+type ServerDetail struct {
+	ID               string `json:"id"`
+	Name             string `json:"name"`
+	Status           string `json:"status"`
+	TenantID         string `json:"tenant_id"`
+	Created          string `json:"created"`
+	AvailabilityZone string `json:"OS-EXT-AZ:availability_zone"`
+	Hypervisor       string `json:"OS-EXT-SRV-ATTR:hypervisor_hostname"`
+	FlavorName       string // Populated from nested flavor.original_name
+	FlavorRAM        uint64 // Populated from nested flavor.ram
+	FlavorVCPUs      uint64 // Populated from nested flavor.vcpus
+	FlavorDisk       uint64 // Populated from nested flavor.disk
+}
+
 type NovaClient interface {
 	// Initialize the Nova API with the Keystone authentication.
 	Init(ctx context.Context, client client.Client, conf NovaClientConfig) error
@@ -47,6 +62,8 @@ type NovaClient interface {
 	LiveMigrate(ctx context.Context, id string) error
 	// Get migrations for a server by ID.
 	GetServerMigrations(ctx context.Context, id string) ([]migration, error)
+	// List all servers for a project with detailed info.
+	ListProjectServers(ctx context.Context, projectID string) ([]ServerDetail, error)
 }
 
 type novaClient struct {
@@ -160,3 +177,86 @@ func (api *novaClient) GetServerMigrations(ctx context.Context, id string) ([]mi
 	slog.Info("fetched migrations for vm", "id", id, "count", len(migrations))
 	return migrations, nil
 }
+
+// ListProjectServers retrieves all servers for a project with detailed info.
+func (api *novaClient) ListProjectServers(ctx context.Context, projectID string) ([]ServerDetail, error) {
+	// Build URL with pagination support
+	initialURL := api.sc.Endpoint + "servers/detail?all_tenants=true&tenant_id=" + projectID
+	var nextURL = &initialURL
+	var result []ServerDetail
+
+	for nextURL != nil {
+		req, err := http.NewRequestWithContext(ctx, http.MethodGet, *nextURL, http.NoBody)
+		if err != nil {
+			return nil, err
+		}
+		req.Header.Set("X-Auth-Token", api.sc.Token())
+		req.Header.Set("X-OpenStack-Nova-API-Version", api.sc.Microversion)
+
+		resp, err := api.sc.HTTPClient.Do(req)
+		if err != nil {
+			return nil, err
+		}
+		defer resp.Body.Close()
+
+		if resp.StatusCode != http.StatusOK {
+			return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+		}
+
+		// Response structure with nested flavor
+		var list struct {
+			Servers []struct {
+				ID               string `json:"id"`
+				Name             string `json:"name"`
+				Status           string `json:"status"`
+				TenantID         string `json:"tenant_id"`
+				Created          string `json:"created"`
+				AvailabilityZone string `json:"OS-EXT-AZ:availability_zone"`
+				Hypervisor       string `json:"OS-EXT-SRV-ATTR:hypervisor_hostname"`
+				Flavor           struct {
+					OriginalName string `json:"original_name"`
+					RAM          uint64 `json:"ram"`
+					VCPUs        uint64 `json:"vcpus"`
+					Disk         uint64 `json:"disk"`
+				} `json:"flavor"`
+			} `json:"servers"`
+			Links []struct {
+				Rel  string `json:"rel"`
+				Href string `json:"href"`
+			} `json:"servers_links"`
+		}
+
+		if err := json.NewDecoder(resp.Body).Decode(&list); err != nil {
+			return nil, err
+		}
+
+		// Convert to ServerDetail
+		for _, s := range list.Servers {
+			result = append(result, ServerDetail{
+				ID:               s.ID,
+				Name:             s.Name,
+				Status:           s.Status,
+				TenantID:         s.TenantID,
+				Created:          s.Created,
+				AvailabilityZone: s.AvailabilityZone,
+				Hypervisor:       s.Hypervisor,
+				FlavorName:       s.Flavor.OriginalName,
+				FlavorRAM:        s.Flavor.RAM,
+				FlavorVCPUs:      s.Flavor.VCPUs,
+				FlavorDisk:       s.Flavor.Disk,
+			})
+		}
+
+		// Check for next page
+		nextURL = nil
+		for _, link := range list.Links {
+			if link.Rel == "next" {
+				nextURL = &link.Href
+				break
+			}
+		}
+	}
+
+	slog.Info("fetched servers for project", "projectID", projectID, "count", len(result))
+	return result, nil
+}

internal/scheduling/reservations/commitments/api.go

@@ -4,36 +4,47 @@
 package commitments
 
 import (
+	"context"
 	"net/http"
 	"sync"
 
+	"github.com/cobaltcore-dev/cortex/internal/scheduling/nova"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 )
 
+// UsageNovaClient is a minimal interface for the Nova client needed by the usage API.
+// This allows for easy mocking in tests without implementing the full NovaClient interface.
+type UsageNovaClient interface {
+	ListProjectServers(ctx context.Context, projectID string) ([]nova.ServerDetail, error)
+}
+
 // HTTPAPI implements Limes LIQUID commitment validation endpoints.
 type HTTPAPI struct {
-	client client.Client
-	config Config
+	client     client.Client
+	config     Config
+	novaClient UsageNovaClient
 	// Mutex to serialize change-commitments requests
 	changeMutex sync.Mutex
 }
 
 func NewAPI(client client.Client) *HTTPAPI {
-	return NewAPIWithConfig(client, DefaultConfig())
+	return NewAPIWithConfig(client, DefaultConfig(), nil)
 }
 
-func NewAPIWithConfig(client client.Client, config Config) *HTTPAPI {
+func NewAPIWithConfig(client client.Client, config Config, novaClient UsageNovaClient) *HTTPAPI {
 	return &HTTPAPI{
-		client: client,
-		config: config,
+		client:     client,
+		config:     config,
+		novaClient: novaClient,
 	}
 }
 
 func (api *HTTPAPI) Init(mux *http.ServeMux) {
 	mux.HandleFunc("/v1/commitments/change-commitments", api.HandleChangeCommitments)
 	// mux.HandleFunc("/v1/report-capacity", api.HandleReportCapacity)
 	mux.HandleFunc("/v1/commitments/info", api.HandleInfo)
+	mux.HandleFunc("/v1/commitments/projects/", api.HandleReportUsage) // matches /v1/commitments/projects/:project_id/report-usage
 }
 
 var commitmentApiLog = ctrl.Log.WithName("commitment_api")

internal/scheduling/reservations/commitments/api_change_commitments_test.go

@@ -964,7 +964,7 @@ func newCommitmentTestEnv(
 	// Use custom config if provided, otherwise use default
 	var api *HTTPAPI
 	if customConfig != nil {
-		api = NewAPIWithConfig(wrappedClient, *customConfig)
+		api = NewAPIWithConfig(wrappedClient, *customConfig, nil)
 	} else {
 		api = NewAPI(wrappedClient)
 	}

internal/scheduling/reservations/commitments/api_report_usage.go

@@ -0,0 +1,84 @@
+// Copyright SAP SE
+// SPDX-License-Identifier: Apache-2.0
+
+package commitments
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/sapcc/go-api-declarations/liquid"
+)
+
+// HandleReportUsage implements POST /v1/commitments/projects/:project_id/report-usage from Limes LIQUID API.
+// See: https://github.com/sapcc/go-api-declarations/blob/main/liquid/report_usage.go
+// See: https://pkg.go.dev/github.com/sapcc/go-api-declarations/liquid
+//
+// This endpoint reports usage information for a specific project's committed resources,
+// including per-AZ usage, physical usage, and detailed VM subresources.
+func (api *HTTPAPI) HandleReportUsage(w http.ResponseWriter, r *http.Request) {
+	requestID := r.Header.Get("X-Request-ID")
+	if requestID == "" {
+		requestID = fmt.Sprintf("req-%d", time.Now().UnixNano())
+	}
+	log := commitmentApiLog.WithValues("requestID", requestID, "endpoint", "report-usage")
+
+	if r.Method != http.MethodPost {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	// Extract project UUID from URL path
+	// URL pattern: /v1/commitments/projects/:project_id/report-usage
+	projectID, err := extractProjectIDFromPath(r.URL.Path)
+	if err != nil {
+		log.Error(err, "failed to extract project ID from path")
+		http.Error(w, "Invalid URL path: "+err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	// Parse request body
+	var req liquid.ServiceUsageRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		log.Error(err, "failed to decode request body")
+		http.Error(w, "Invalid request body: "+err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	// Use UsageCalculator to build usage report
+	calculator := NewUsageCalculator(api.client, api.novaClient)
+	report, err := calculator.CalculateUsage(r.Context(), log, projectID, req.AllAZs)
+	if err != nil {
+		log.Error(err, "failed to calculate usage report", "projectID", projectID)
+		http.Error(w, "Failed to generate usage report: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusOK)
+	if err := json.NewEncoder(w).Encode(report); err != nil {
+		log.Error(err, "failed to encode usage report")
+	}
+}
+
+// extractProjectIDFromPath extracts the project UUID from the URL path.
+// Expected path format: /v1/commitments/projects/:project_id/report-usage
+func extractProjectIDFromPath(path string) (string, error) {
+	// Path: /v1/commitments/projects/<uuid>/report-usage
+	parts := strings.Split(strings.Trim(path, "/"), "/")
+	// Expected: ["v1", "commitments", "projects", "<uuid>", "report-usage"]
+	if len(parts) < 5 {
+		return "", fmt.Errorf("path too short: %s", path)
+	}
+	if parts[2] != "projects" || parts[4] != "report-usage" {
+		return "", fmt.Errorf("unexpected path format: %s", path)
+	}
+	projectID := parts[3]
+	if projectID == "" {
+		return "", fmt.Errorf("empty project ID in path: %s", path)
+	}
+	return projectID, nil
+}