Merge pull request OpenFunction#470 from wanjunlei/main

Add support for event record

config/bundle.yaml

@@ -17618,6 +17618,18 @@ rules:
   - patch
   - update
   - watch
+- apiGroups:
+  - events.k8s.io
+  resources:
+  - events
+  verbs:
+  - create
+  - delete
+  - get
+  - list
+  - patch
+  - update
+  - watch
 - apiGroups:
   - events.openfunction.io
   resources:

config/rbac/role.yaml

@@ -138,6 +138,18 @@ rules:
   - patch
   - update
   - watch
+- apiGroups:
+  - events.k8s.io
+  resources:
+  - events
+  verbs:
+  - create
+  - delete
+  - get
+  - list
+  - patch
+  - update
+  - watch
 - apiGroups:
   - events.openfunction.io
   resources:

controllers/core/builder_controller.go

@@ -23,8 +23,10 @@ import (
 	"time"
 
 	"github.com/go-logr/logr"
+	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/client-go/tools/events"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/manager"
@@ -42,15 +44,18 @@ type BuilderReconciler struct {
 	Scheme *runtime.Scheme
 	ctx    context.Context
 	timers map[string]*time.Timer
+
+	eventRecorder events.EventRecorder
 }
 
-func NewBuilderReconciler(mgr manager.Manager) *BuilderReconciler {
+func NewBuilderReconciler(mgr manager.Manager, eventRecorder events.EventRecorder) *BuilderReconciler {
 
 	r := &BuilderReconciler{
-		Client: mgr.GetClient(),
-		Scheme: mgr.GetScheme(),
-		Log:    ctrl.Log.WithName("controllers").WithName("Builder"),
-		timers: make(map[string]*time.Timer),
+		Client:        mgr.GetClient(),
+		Scheme:        mgr.GetScheme(),
+		Log:           ctrl.Log.WithName("controllers").WithName("Builder"),
+		timers:        make(map[string]*time.Timer),
+		eventRecorder: eventRecorder,
 	}
 
 	return r
@@ -112,6 +117,8 @@ func (r *BuilderReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 			return ctrl.Result{}, err
 		}
 
+		r.recordEvent(builder)
+
 		return ctrl.Result{}, nil
 	}
 
@@ -146,6 +153,8 @@ func (r *BuilderReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 		return ctrl.Result{}, err
 	}
 
+	r.recordEvent(builder)
+
 	log.V(1).Info("Builder is running")
 
 	return ctrl.Result{}, nil
@@ -187,6 +196,8 @@ func (r *BuilderReconciler) getBuilderResult(builder *openfunction.Builder, buil
 			return err
 		}
 
+		r.recordEvent(builder)
+
 		r.stopTimer(fmt.Sprintf("%s/%s", builder.Namespace, builder.Name))
 		log.V(1).Info("Update builder status", "state", res)
 	}
@@ -258,7 +269,12 @@ func (r *BuilderReconciler) buildTimeout(builder *openfunction.Builder) error {
 		b.Status.Reason = openfunction.Timeout
 		b.Status.Message = openfunction.Timeout
 		b.Status.BuildDuration = builder.Spec.Timeout
-		return r.Status().Update(r.ctx, b)
+		err := r.Status().Update(r.ctx, b)
+		if err == nil {
+			r.recordEvent(builder)
+		}
+
+		return err
 	}
 
 	return nil
@@ -274,6 +290,37 @@ func (r *BuilderReconciler) stopTimer(key string) {
 	}
 }
 
+func (r *BuilderReconciler) recordEvent(builder *openfunction.Builder) {
+	log := r.Log.WithName("RecordEvent").
+		WithValues("Builder", fmt.Sprintf("%s/%s", builder.Namespace, builder.Name))
+
+	eventType := corev1.EventTypeNormal
+	if builder.Status.State != openfunction.Building &&
+		builder.Status.State != openfunction.Succeeded {
+		eventType = corev1.EventTypeWarning
+	}
+
+	reason := builder.Status.State
+	note := ""
+	switch builder.Status.State {
+	case openfunction.Building:
+		reason = "Started"
+		note = "Build started"
+	case openfunction.Succeeded:
+		reason = "Completed"
+		note = "Build completed"
+	case openfunction.Failed:
+		note = fmt.Sprintf("Build failed: %s", builder.Status.Message)
+	case openfunction.Timeout:
+		note = "Build timeout"
+	case openfunction.Canceled:
+		note = "Build canceled"
+	}
+
+	r.eventRecorder.Eventf(builder, nil, eventType, reason, buildAction, note)
+	log.V(1).Info("Record Event", "Reason", reason)
+}
+
 // SetupWithManager sets up the controller with the Manager.
 func (r *BuilderReconciler) SetupWithManager(mgr ctrl.Manager, owns []client.Object) error {
 

controllers/core/function_controller.go

@@ -27,12 +27,6 @@ import (
 	"text/template"
 	"time"
 
-	ctrlbuilder "sigs.k8s.io/controller-runtime/pkg/builder"
-	"sigs.k8s.io/controller-runtime/pkg/event"
-	"sigs.k8s.io/controller-runtime/pkg/handler"
-	"sigs.k8s.io/controller-runtime/pkg/predicate"
-	"sigs.k8s.io/controller-runtime/pkg/source"
-
 	"github.com/go-logr/logr"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/equality"
@@ -41,12 +35,18 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/apimachinery/pkg/util/intstr"
+	"k8s.io/client-go/tools/events"
 	kservingv1 "knative.dev/serving/pkg/apis/serving/v1"
 	ctrl "sigs.k8s.io/controller-runtime"
+	ctrlbuilder "sigs.k8s.io/controller-runtime/pkg/builder"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
+	"sigs.k8s.io/controller-runtime/pkg/event"
+	"sigs.k8s.io/controller-runtime/pkg/handler"
 	"sigs.k8s.io/controller-runtime/pkg/manager"
+	"sigs.k8s.io/controller-runtime/pkg/predicate"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
+	"sigs.k8s.io/controller-runtime/pkg/source"
 	k8sgatewayapiv1alpha2 "sigs.k8s.io/gateway-api/apis/v1alpha2"
 
 	openfunction "github.com/openfunction/apis/core/v1beta2"
@@ -56,7 +56,12 @@ import (
 	"github.com/openfunction/pkg/util"
 )
 
-const GatewayField = ".spec.route.gatewayRef"
+const (
+	GatewayField = ".spec.route.gatewayRef"
+
+	buildAction   = "Build"
+	servingAction = "Serving"
+)
 
 // FunctionReconciler reconciles a Function object
 type FunctionReconciler struct {
@@ -65,15 +70,18 @@ type FunctionReconciler struct {
 	Scheme   *runtime.Scheme
 	ctx      context.Context
 	interval time.Duration
+
+	eventRecorder events.EventRecorder
 }
 
-func NewFunctionReconciler(mgr manager.Manager, interval time.Duration) *FunctionReconciler {
+func NewFunctionReconciler(mgr manager.Manager, interval time.Duration, eventRecorder events.EventRecorder) *FunctionReconciler {
 
 	r := &FunctionReconciler{
-		Client:   mgr.GetClient(),
-		Scheme:   mgr.GetScheme(),
-		Log:      ctrl.Log.WithName("controllers").WithName("Function"),
-		interval: interval,
+		Client:        mgr.GetClient(),
+		Scheme:        mgr.GetScheme(),
+		Log:           ctrl.Log.WithName("controllers").WithName("Function"),
+		interval:      interval,
+		eventRecorder: eventRecorder,
 	}
 
 	r.startFunctionWatcher()
@@ -88,6 +96,7 @@ func NewFunctionReconciler(mgr manager.Manager, interval time.Duration) *Functio
 //+kubebuilder:rbac:groups=gateway.networking.k8s.io,resources=httproutes,verbs=get;list;watch;create;update;patch;delete
 //+kubebuilder:rbac:groups=networking.openfunction.io,resources=gateways,verbs=get;list;watch
 //+kubebuilder:rbac:groups=core,resources=services,verbs=get;list;watch;create;update;patch;delete
+//+kubebuilder:rbac:groups=events.k8s.io,resources=events,verbs=get;list;watch;create;update;patch;delete
 
 // Reconcile is part of the main kubernetes reconciliation loop which aims to
 // move the current state of the cluster closer to the desired state.
@@ -281,6 +290,8 @@ func (r *FunctionReconciler) updateFuncWithBuilderStatus(fn *openfunction.Functi
 			log.Error(err, "Failed to update function status")
 			return err
 		}
+
+		r.recordEvent(fn, &builder, buildAction, fn.Status.Build.State, fn.Status.Build.Message)
 	}
 
 	return r.pruneBuilder(fn)
@@ -517,11 +528,13 @@ func (r *FunctionReconciler) updateFuncWithServingStatus(fn *openfunction.Functi
 			}
 			log.V(1).Info("Serving is running", "serving", serving.Name)
 		}
-	}
 
-	if err := r.Status().Update(r.ctx, fn); err != nil {
-		log.Error(err, "Failed to update function status")
-		return err
+		if err := r.Status().Update(r.ctx, fn); err != nil {
+			log.Error(err, "Failed to update function status")
+			return err
+		}
+
+		r.recordEvent(fn, &serving, servingAction, fn.Status.Serving.State, fn.Status.Serving.Message)
 	}
 
 	return nil
@@ -972,6 +985,10 @@ func (r *FunctionReconciler) updateFuncWithHTTPRouteStatus(
 	if len(httpRoute.Status.RouteStatus.Parents) != 0 {
 		fn.Status.Route.Conditions = httpRoute.Status.Parents[0].Conditions
 	}
+	// Set a fixed value to prevent the Status of the Function from being updated frequently when the traffic is heavy.
+	for index := 0; index < len(fn.Status.Route.Conditions); index++ {
+		fn.Status.Route.Conditions[index].LastTransitionTime = fn.CreationTimestamp
+	}
 	fn.Status.Route.Hosts = httpRoute.Spec.Hostnames
 	for _, httpRule := range httpRoute.Spec.Rules {
 		for _, match := range httpRule.Matches {
@@ -1079,6 +1096,56 @@ func (r *FunctionReconciler) cleanExpiredBuilder() {
 	}
 }
 
+func (r *FunctionReconciler) recordEvent(fn *openfunction.Function, related runtime.Object, action, state, message string) {
+	log := r.Log.WithName("RecordEvent").
+		WithValues("Function", fmt.Sprintf("%s/%s", fn.Namespace, fn.Name))
+
+	eventType := corev1.EventTypeNormal
+	if state == openfunction.Timeout ||
+		state == openfunction.Failed ||
+		state == openfunction.Canceled {
+		eventType = corev1.EventTypeWarning
+	}
+
+	reason := ""
+	note := ""
+	switch action {
+	case buildAction:
+		switch state {
+		case openfunction.Building:
+			reason = "BuildStarted"
+			note = "Build started"
+		case openfunction.Succeeded:
+			reason = "BuildCompleted"
+			note = "Build completed"
+		case openfunction.Failed:
+			reason = "BuildFailed"
+			note = fmt.Sprintf("Build failed: %s", message)
+		case openfunction.Timeout:
+			reason = "BuildTimeout"
+			note = "Build timeout"
+		case openfunction.Canceled:
+			reason = "BuildCanceled"
+			note = "Build cancelled"
+		}
+	case servingAction:
+		switch state {
+		case openfunction.Starting:
+			reason = "Starting"
+			note = "Serving is starting"
+		case openfunction.Running:
+			reason = "Running"
+			note = "Serving is running"
+		case openfunction.Failed:
+			reason = "ServingFailed"
+			note = fmt.Sprintf("Serving start failed: %s", message)
+		}
+	}
+
+	r.eventRecorder.Eventf(fn, related, eventType, reason, action, note)
+	log.V(1).Info("Record Event", "Reason", reason)
+}
+
 // SetupWithManager sets up the controller with the Manager.
 func (r *FunctionReconciler) SetupWithManager(mgr ctrl.Manager) error {
 	if err := mgr.GetFieldIndexer().IndexField(context.Background(), &openfunction.Function{}, GatewayField, func(rawObj client.Object) []string {