Add get events command to irictl-machine

broker/machinebroker/apiutils/apiutils.go

@@ -167,19 +167,3 @@ func IsManagedBy(o metav1.Object, manager string) bool {
 	actual, ok := o.GetLabels()[machinebrokerv1alpha1.ManagerLabel]
 	return ok && actual == manager
 }
-
-func GetIRIObjectMetadata(o metav1.Object) *irimeta.ObjectMetadata {
-	var deletedAt int64
-	if !o.GetDeletionTimestamp().IsZero() {
-		deletedAt = o.GetDeletionTimestamp().UnixNano()
-	}
-
-	return &irimeta.ObjectMetadata{
-		Id:          o.GetName(),
-		Annotations: o.GetAnnotations(),
-		Labels:      o.GetLabels(),
-		Generation:  o.GetGeneration(),
-		CreatedAt:   o.GetCreationTimestamp().UnixNano(),
-		DeletedAt:   deletedAt,
-	}
-}

broker/machinebroker/server/event_list.go

@@ -12,35 +12,56 @@ import (
 	"k8s.io/apimachinery/pkg/labels"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 
+	computev1alpha1 "github.com/ironcore-dev/ironcore/api/compute/v1alpha1"
 	"github.com/ironcore-dev/ironcore/broker/machinebroker/apiutils"
 	iri "github.com/ironcore-dev/ironcore/iri/apis/machine/v1alpha1"
 )
 
-const InvolvedObjectName = "involvedObject.name"
+const (
+	InvolvedObjectKind               = "Machine"
+	InvolvedObjectKindSelector       = "involvedObject.kind"
+	InvolvedObjectAPIversionSelector = "involvedObject.apiVersion"
+)
 
-func (s *Server) listEvents(ctx context.Context, machineID string) ([]*iri.Event, error) {
+func (s *Server) listEvents(ctx context.Context) ([]*iri.Event, error) {
 	machineEventList := &v1.EventList{}
 	selectorField := fields.Set{}
-	selectorField[InvolvedObjectName] = machineID
+	selectorField[InvolvedObjectKindSelector] = InvolvedObjectKind
+	selectorField[InvolvedObjectAPIversionSelector] = computev1alpha1.SchemeGroupVersion.String()
 
 	if err := s.cluster.Client().List(ctx, machineEventList,
 		client.InNamespace(s.cluster.Namespace()), client.MatchingFieldsSelector{Selector: selectorField.AsSelector()},
 	); err != nil {
-		return nil, fmt.Errorf("error listing machine events: %w", err)
+		return nil, err
 	}
 
 	var iriEvents []*iri.Event
+	var eventTime int64
 	for _, machineEvent := range machineEventList.Items {
-		iriEvent := &iri.Event{
-			Metadata: apiutils.GetIRIObjectMetadata(&machineEvent.ObjectMeta),
-			Spec: &iri.EventSpec{
-				Reason:    machineEvent.Reason,
-				Message:   machineEvent.Message,
-				Type:      machineEvent.Type,
-				EventTime: machineEvent.FirstTimestamp.Unix(),
-			},
+		ironcoreMachine, err := s.getIronCoreMachine(ctx, machineEvent.InvolvedObject.Name)
+		if err != nil {
+			continue
+		} else {
+			machineObjectMetadata, err := apiutils.GetObjectMetadata(&ironcoreMachine.ObjectMeta)
+			if err != nil {
+				continue
+			} else {
+				eventTime = machineEvent.LastTimestamp.Unix()
+				if eventTime < 0 {
+					eventTime = machineEvent.FirstTimestamp.Unix()
+				}
+				iriEvent := &iri.Event{
+					Spec: &iri.EventSpec{
+						InvolvedObjectMeta: machineObjectMetadata,
+						Reason:             machineEvent.Reason,
+						Message:            machineEvent.Message,
+						Type:               machineEvent.Type,
+						EventTime:          eventTime,
+					},
+				}
+				iriEvents = append(iriEvents, iriEvent)
+			}
 		}
-		iriEvents = append(iriEvents, iriEvent)
 	}
 	return iriEvents, nil
 }
@@ -55,10 +76,14 @@ func (s *Server) filterEvents(events []*iri.Event, filter *iri.EventFilter) []*i
 		sel = labels.SelectorFromSet(filter.LabelSelector)
 	)
 	for _, iriEvent := range events {
-		if !sel.Matches(labels.Set(iriEvent.Metadata.Labels)) {
+		if !sel.Matches(labels.Set(iriEvent.Spec.InvolvedObjectMeta.Labels)) {
 			continue
 		}
-		if (filter.EventsFromTime >= 0 && iriEvent.Spec.EventTime >= filter.EventsFromTime) && (filter.EventsToTime >= 0 && iriEvent.Spec.EventTime <= filter.EventsToTime) {
+		if filter.EventsFromTime > 0 && filter.EventsToTime > 0 {
+			if iriEvent.Spec.EventTime >= filter.EventsFromTime && iriEvent.Spec.EventTime <= filter.EventsToTime {
+				res = append(res, iriEvent)
+			}
+		} else {
 			res = append(res, iriEvent)
 		}
 
@@ -67,27 +92,14 @@ func (s *Server) filterEvents(events []*iri.Event, filter *iri.EventFilter) []*i
 }
 
 func (s *Server) ListEvents(ctx context.Context, req *iri.ListEventsRequest) (*iri.ListEventsResponse, error) {
-	ironcoreMachineList, err := s.listIroncoreMachines(ctx)
+	iriEvents, err := s.listEvents(ctx)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("error listing machine events : %w", err)
 	}
-	var machineEvents []*iri.MachineEvents
-	for i := range ironcoreMachineList.Items {
-		ironcoreMachine := &ironcoreMachineList.Items[i]
-		iriEvents, err := s.listEvents(ctx, ironcoreMachine.Name)
-		if err != nil {
-			return nil, err
-		}
 
-		iriEvents = s.filterEvents(iriEvents, req.Filter)
-		ironcoreMachineMeta, err := apiutils.GetObjectMetadata(&ironcoreMachine.ObjectMeta)
-		if err != nil {
-			return nil, fmt.Errorf("error listing machine events: %w", err)
-		}
-		machineEvents = append(machineEvents, &iri.MachineEvents{InvolvedObjectMeta: ironcoreMachineMeta, Events: iriEvents})
-	}
+	iriEvents = s.filterEvents(iriEvents, req.Filter)
 
 	return &iri.ListEventsResponse{
-		MachineEvents: machineEvents,
+		Events: iriEvents,
 	}, nil
 }

broker/machinebroker/server/event_list_test.go

@@ -72,15 +72,14 @@ var _ = Describe("ListEvents", func() {
 
 		Expect(err).NotTo(HaveOccurred())
 
-		Expect(resp.MachineEvents).To(ConsistOf(SatisfyAll(
-			HaveField("InvolvedObjectMeta.Id", Equal(ironcoreMachine.Name)),
-			HaveField("Events", ConsistOf(SatisfyAll(
-				HaveField("Spec", SatisfyAll(
-					HaveField("Reason", Equal("testing")),
-					HaveField("Message", Equal("this is test event")),
-					HaveField("Type", Equal(corev1.EventTypeNormal)),
-				)),
-			))),
-		)))
+		Expect(resp.Events).To(ConsistOf(
+			HaveField("Spec", SatisfyAll(
+				HaveField("InvolvedObjectMeta.Id", Equal(ironcoreMachine.Name)),
+				HaveField("Reason", Equal("testing")),
+				HaveField("Message", Equal("this is test event")),
+				HaveField("Type", Equal(corev1.EventTypeNormal)),
+			)),
+		),
+		)
 	})
 })