Add event subscription management for server events and metrics

api/v1alpha1/bmc_types.go

@@ -210,6 +210,14 @@ type BMCStatus struct {
 	// +optional
 	LastResetTime *metav1.Time `json:"lastResetTime,omitempty"`
 
+	// MetricsReportSubscriptionLink is the link to the metrics report subscription of the bmc.
+	// +optional
+	MetricsReportSubscriptionLink string `json:"metricsReportSubscriptionLink,omitempty"`
+
+	// EventsSubscriptionLink is the link to the events subscription of the bmc.
+	// +optional
+	EventsSubscriptionLink string `json:"eventsSubscriptionLink,omitempty"`
+
 	// Conditions represents the latest available observations of the BMC's current state.
 	// +patchStrategy=merge
 	// +patchMergeKey=type

bmc/bmc.go

@@ -120,6 +120,12 @@ type BMC interface {
 
 	// GetBMCUpgradeTask retrieves the task for the BMC upgrade.
 	GetBMCUpgradeTask(ctx context.Context, manufacturer string, taskURI string) (*redfish.Task, error)
+
+	// CreateEventSubscription creates an event subscription for the manager.q
+	CreateEventSubscription(ctx context.Context, destination string, eventType redfish.EventFormatType, protocol redfish.DeliveryRetryPolicy) (string, error)
+
+	// DeleteEventSubscription deletes an event subscription for the manager.
+	DeleteEventSubscription(ctx context.Context, uri string) error
 }
 
 type Entity struct {

bmc/mock/server/data/Managers/BMC/index.json

@@ -4,6 +4,7 @@
     "Name": "Manager",
     "ManagerType": "BMC",
     "Description": "Contoso BMC",
+    "Manufacturer": "Contoso",
     "ServiceEntryPointUUID": "92384634-2938-2342-8820-489239905423",
     "UUID": "58893887-8974-2487-2389-841168418919",
     "Model": "Joo Janta 200",
@@ -96,4 +97,4 @@
     },
     "@odata.id": "/redfish/v1/Managers/BMC",
     "@Redfish.Copyright": "Copyright 2014-2023 DMTF. For the full DMTF copyright policy, see http://www.dmtf.org/about/policies/copyright."
-}
+}

bmc/mock/server/server.go

@@ -25,6 +25,14 @@ var (
 	dataFS embed.FS
 )
 
+type Collection struct {
+	Members []Member `json:"Members"`
+}
+
+type Member struct {
+	OdataID string `json:"@odata.id"`
+}
+
 const (
 	LockedResourceState   = "Locked"
 	UnlockedResourceState = "Unlocked"
@@ -81,6 +89,8 @@ func (s *MockServer) redfishHandler(w http.ResponseWriter, r *http.Request) {
 		s.handleRedfishPOST(w, r)
 	case http.MethodPatch:
 		s.handleRedfishPATCH(w, r)
+	case http.MethodDelete:
+		s.handleRedfishDelete(w, r)
 	default:
 		http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
 	}
@@ -180,6 +190,47 @@ func resolvePath(urlPath string) string {
 	return path.Join("data", trimmed, "index.json")
 }
 
+func (s *MockServer) handleRedfishDelete(w http.ResponseWriter, r *http.Request) {
+	s.log.Info("Received request", "method", r.Method, "path", r.URL.Path)
+
+	urlPath := resolvePath(r.URL.Path)
+	s.mu.RLock()
+	defer s.mu.Unlock()
+	_, hasOverride := s.overrides[urlPath]
+	if hasOverride {
+		// remove the resource
+		delete(s.overrides, urlPath)
+	}
+	// get collection of the resource
+	collectionPath := path.Dir(urlPath)
+	cached, hasOverride := s.overrides[collectionPath]
+	var collection Collection
+	if hasOverride {
+		collection = cached.(Collection)
+	} else {
+		data, err := dataFS.ReadFile(collectionPath)
+		if err != nil {
+			http.NotFound(w, r)
+			return
+		}
+		if err := json.Unmarshal(data, &collection); err != nil {
+			http.Error(w, "Corrupt embedded JSON", http.StatusInternalServerError)
+			return
+		}
+	}
+	// remove member from collection
+	newMembers := make([]Member, 0)
+	for _, member := range collection.Members {
+		if member.OdataID != r.URL.Path {
+			newMembers = append(newMembers, member)
+		}
+	}
+	s.log.Info("Removing member from collection", "members", newMembers, "collection", collectionPath)
+	collection.Members = newMembers
+	s.overrides[collectionPath] = collection
+	w.WriteHeader(http.StatusNoContent)
+}
+
 func (s *MockServer) handleRedfishGET(w http.ResponseWriter, r *http.Request) {
 	urlPath := resolvePath(r.URL.Path)
 
@@ -239,9 +290,15 @@ func (s *MockServer) handleRedfishPOST(w http.ResponseWriter, r *http.Request) {
 		}
 	}(r.Body)
 
-	s.log.Info("POST body received", "body", string(body))
+	var update map[string]any
+	if err := json.Unmarshal(body, &update); err != nil {
+		http.Error(w, "Invalid JSON", http.StatusBadRequest)
+		return
+	}
 
+	s.log.Info("POST body received", "body", string(body))
 	urlPath := resolvePath(r.URL.Path)
+
 	switch {
 	case strings.Contains(urlPath, "Actions/ComputerSystem.Reset"):
 		// Simulate a system reset action
@@ -304,7 +361,55 @@ func (s *MockServer) handleRedfishPOST(w http.ResponseWriter, r *http.Request) {
 	case strings.Contains(urlPath, "UpdateService/Actions/UpdateService.SimpleUpdate"):
 		// Simulate a firmware update action
 	default:
-		s.log.Info("Unhandled POST request", "path", urlPath)
+		// Handle resource creation in collections
+		s.mu.Lock()
+		defer s.mu.Unlock()
+		cached, hasOverride := s.overrides[urlPath]
+		var base Collection
+		if hasOverride {
+			s.log.Info("Using overridden data for POST", "path", urlPath)
+			base = cached.(Collection)
+		} else {
+			s.log.Info("Using embedded data for POST", "path", urlPath)
+			data, err := dataFS.ReadFile(urlPath)
+			if err != nil {
+				s.log.Error(err, "Failed to read embedded data for POST", "path", urlPath)
+				http.NotFound(w, r)
+				return
+			}
+			if err := json.Unmarshal(data, &base); err != nil {
+				http.Error(w, "Corrupt embedded JSON", http.StatusInternalServerError)
+				return
+			}
+		}
+		// If resource collection (has "Members"), add a new member
+		if len(base.Members) > 0 {
+			newID := fmt.Sprintf("%d", len(base.Members)+1)
+			location := path.Join(r.URL.Path, newID)
+			newMemberPath := resolvePath(location)
+			base.Members = append(base.Members, Member{
+				OdataID: location,
+			})
+			s.log.Info("Adding new member", "id", newID, "location", location, "memberPath", newMemberPath)
+			if strings.HasSuffix(r.URL.Path, "/Subscriptions") {
+				w.Header().Set("Location", location)
+			}
+			s.overrides[urlPath] = base
+			s.overrides[newMemberPath] = update
+		} else {
+			base.Members = make([]Member, 0)
+			location := r.URL.JoinPath("1").String()
+			base.Members = []Member{
+				{
+					OdataID: r.URL.JoinPath("1").String(),
+				},
+			}
+			s.overrides[urlPath] = base
+			if strings.HasSuffix(r.URL.Path, "/Subscriptions") {
+				w.Header().Set("Location", location)
+			}
+		}
+		s.log.Info("Storing updated data for POST", "path", urlPath, "data", update)
 		w.Header().Set("Content-Type", "application/json")
 		w.WriteHeader(http.StatusCreated)
 		_, err = w.Write([]byte(`{"status": "created"}`))

bmc/redfish.go

@@ -10,6 +10,7 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"net/url"
 	"slices"
 	"strings"
 	"time"
@@ -996,3 +997,80 @@ func (r *RedfishBMC) GetBMCUpgradeTask(ctx context.Context, manufacturer string,
 
 	return oem.GetTaskMonitorDetails(ctx, respTask)
 }
+
+type subscriptionPayload struct {
+	Destination         string                           `json:"Destination,omitempty"`
+	EventTypes          []redfish.EventType              `json:"EventTypes,omitempty"`
+	EventFormatType     redfish.EventFormatType          `json:"EventFormatType,omitempty"`
+	RegistryPrefixes    []string                         `json:"RegistryPrefixes,omitempty"`
+	ResourceTypes       []string                         `json:"ResourceTypes,omitempty"`
+	DeliveryRetryPolicy redfish.DeliveryRetryPolicy      `json:"DeliveryRetryPolicy,omitempty"`
+	HTTPHeaders         map[string]string                `json:"HttpHeaders,omitempty"`
+	Oem                 interface{}                      `json:"Oem,omitempty"`
+	Protocol            redfish.EventDestinationProtocol `json:"Protocol,omitempty"`
+	Context             string                           `json:"Context,omitempty"`
+}
+
+func (r *RedfishBMC) CreateEventSubscription(
+	ctx context.Context,
+	destination string,
+	eventFormatType redfish.EventFormatType,
+	retry redfish.DeliveryRetryPolicy,
+) (string, error) {
+	service := r.client.GetService()
+	ev, err := service.EventService()
+	if err != nil {
+		return "", fmt.Errorf("failed to get event service: %w", err)
+	}
+	if !ev.ServiceEnabled {
+		return "", fmt.Errorf("event service is not enabled")
+	}
+	payload := &subscriptionPayload{
+		Destination:         destination,
+		EventFormatType:     eventFormatType, // event or metricreport
+		Protocol:            redfish.RedfishEventDestinationProtocol,
+		DeliveryRetryPolicy: retry,
+		Context:             "metal3-operator",
+	}
+	client := ev.GetClient()
+	// some implementations (like Dell) do not support ResourceTypes and RegistryPrefixes
+	if len(ev.ResourceTypes) == 0 {
+		payload.EventTypes = []redfish.EventType{}
+	} else {
+		payload.RegistryPrefixes = []string{""} // Filters by the prefix of the event's MessageId, which points to a Message Registry: [Base, ResourceEvent, iLOEvents]
+		payload.ResourceTypes = []string{""}    // Filters by the schema name (Resource Type) of the event's OriginOfCondition:	[Chassis, ComputerSystem, Power]
+	}
+	resp, err := client.Post(ev.Subscriptions, payload)
+	if err != nil {
+		return "", err
+	}
+	// return subscription link from returned location
+	subscriptionLink := resp.Header.Get("Location")
+	urlParser, err := url.ParseRequestURI(subscriptionLink)
+	if err == nil {
+		subscriptionLink = urlParser.RequestURI()
+	}
+	return subscriptionLink, nil
+}
+
+func (r RedfishBMC) DeleteEventSubscription(ctx context.Context, uri string) error {
+	service := r.client.GetService()
+	ev, err := service.EventService()
+	if err != nil {
+		return fmt.Errorf("failed to get event service: %w", err)
+	}
+	if !ev.ServiceEnabled {
+		return fmt.Errorf("event service is not enabled")
+	}
+	event, err := ev.GetEventSubscription(uri)
+	if err != nil {
+		return fmt.Errorf("failed to get event subscription: %w", err)
+	}
+	if event == nil {
+		return nil
+	}
+	if err := ev.DeleteEventSubscription(uri); err != nil {
+		return fmt.Errorf("failed to delete event subscription: %w", err)
+	}
+	return nil
+}

cmd/manager/main.go

@@ -13,6 +13,7 @@ import (
 	"time"
 
 	"github.com/ironcore-dev/controller-utils/conditionutils"
+	"github.com/ironcore-dev/metal-operator/internal/serverevents"
 	webhookmetalv1alpha1 "github.com/ironcore-dev/metal-operator/internal/webhook/v1alpha1"
 	"sigs.k8s.io/controller-runtime/pkg/manager"
 
@@ -73,6 +74,9 @@ func main() { // nolint: gocyclo
 		registryPort                       int
 		registryProtocol                   string
 		registryURL                        string
+		eventPort                          int
+		eventURL                           string
+		eventProtocol                      string
 		registryResyncInterval             time.Duration
 		webhookPort                        int
 		enforceFirstBoot                   bool
@@ -118,6 +122,10 @@ func main() { // nolint: gocyclo
 	flag.StringVar(&registryURL, "registry-url", "", "The URL of the registry.")
 	flag.StringVar(&registryProtocol, "registry-protocol", "http", "The protocol to use for the registry.")
 	flag.IntVar(&registryPort, "registry-port", 10000, "The port to use for the registry.")
+	flag.StringVar(&eventURL, "event-url", "", "The URL of the server events endpoint for alerts and metrics.")
+	flag.IntVar(&eventPort, "event-port", 10001, "The port to use for the server events endpoint for alerts and metrics.")
+	flag.StringVar(&eventProtocol, "event-protocol", "http",
+		"The protocol to use for the server events endpoint for alerts and metrics.")
 	flag.StringVar(&probeImage, "probe-image", "", "Image for the first boot probing of a Server.")
 	flag.StringVar(&probeOSImage, "probe-os-image", "", "OS image for the first boot probing of a Server.")
 	flag.StringVar(&managerNamespace, "manager-namespace", "default", "Namespace the manager is running in.")
@@ -189,6 +197,15 @@ func main() { // nolint: gocyclo
 		registryURL = fmt.Sprintf("%s://%s:%d", registryProtocol, registryAddr, registryPort)
 	}
 
+	// set the correct event URL by getting the address from the environment
+	var eventAddr string
+	if eventURL == "" {
+		eventAddr = os.Getenv("EVENT_ADDRESS")
+		if eventAddr != "" {
+			eventURL = fmt.Sprintf("%s://%s:%d", eventProtocol, eventAddr, eventPort)
+		}
+	}
+
 	// if the enable-http2 flag is false (the default), http/2 should be disabled
 	// due to its vulnerabilities. More specifically, disabling http/2 will
 	// prevent from being vulnerable to the HTTP/2 Stream Cancelation and
@@ -329,6 +346,7 @@ func main() { // nolint: gocyclo
 		BMCResetWaitTime:       bmcResetWaitingInterval,
 		BMCClientRetryInterval: bmcResetResyncInterval,
 		ManagerNamespace:       managerNamespace,
+		EventURL:               eventURL,
 		Conditions:             conditionutils.NewAccessor(conditionutils.AccessorOptions{}),
 		BMCOptions: bmc.Options{
 			BasicAuth: true,
@@ -554,6 +572,17 @@ func main() { // nolint: gocyclo
 		os.Exit(1)
 	}
 
+	if eventAddr != "" {
+		setupLog.Info("starting event server for alerts and metrics", "EventURL", eventURL)
+		eventServer := serverevents.NewServer(setupLog, fmt.Sprintf(":%d", eventPort))
+		go func() {
+			if err := eventServer.Start(ctx); err != nil {
+				setupLog.Error(err, "problem running event server")
+				os.Exit(1)
+			}
+		}()
+	}
+
 	setupLog.Info("starting manager")
 	if err := mgr.Start(ctx); err != nil {
 		setupLog.Error(err, "problem running manager")

config/crd/bases/metal.ironcore.dev_bmcs.yaml

@@ -255,6 +255,10 @@ spec:
                   - type
                   type: object
                 type: array
+              eventsSubscriptionLink:
+                description: EventsSubscriptionLink is the link to the events subscription
+                  of the bmc.
+                type: string
               firmwareVersion:
                 description: FirmwareVersion is the version of the firmware currently
                   running on the BMC.
@@ -278,6 +282,10 @@ spec:
               manufacturer:
                 description: Manufacturer is the name of the BMC manufacturer.
                 type: string
+              metricsReportSubscriptionLink:
+                description: MetricsReportSubscriptionLink is the link to the metrics
+                  report subscription of the bmc.
+                type: string
               model:
                 description: Model is the model number or name of the BMC.
                 type: string

dist/chart/templates/crd/metal.ironcore.dev_bmcs.yaml

@@ -261,6 +261,10 @@ spec:
                   - type
                   type: object
                 type: array
+              eventsSubscriptionLink:
+                description: EventsSubscriptionLink is the link to the events subscription
+                  of the bmc.
+                type: string
               firmwareVersion:
                 description: FirmwareVersion is the version of the firmware currently
                   running on the BMC.
@@ -284,6 +288,10 @@ spec:
               manufacturer:
                 description: Manufacturer is the name of the BMC manufacturer.
                 type: string
+              metricsReportSubscriptionLink:
+                description: MetricsReportSubscriptionLink is the link to the metrics
+                  report subscription of the bmc.
+                type: string
               model:
                 description: Model is the model number or name of the BMC.
                 type: string