feat: Add automatic package label management and Package-to-Function mapping (#201)

### Motivation

This PR addresses the need for better relationship management between Functions and Packages in the FunctionStream operator. Previously, there was no automatic way to track which Functions depend on which Packages, making it difficult to:

1. Automatically trigger Function reconciliations when their referenced Packages are updated
2. Maintain consistent labeling for Functions based on their Package dependencies
3. Efficiently query Functions that depend on a specific Package

The changes also remove the overly restrictive validation that prevented Package updates when Functions referenced them, replacing it with a more flexible approach that automatically handles Package updates.

### Modifications

1. **Automatic Package Label Management**: 
   - Functions now automatically receive a `package` label that matches their `spec.package` field
   - Labels are updated when the Package reference changes
   - Existing labels are preserved when adding the package label

2. **Package-to-Function Mapping**:
   - Added `mapPackageToFunctions` function that finds all Functions referencing a specific Package using label selectors
   - Added Package watcher in the Function controller to trigger reconciliations when Packages are updated
   - This enables automatic deployment updates when Package images change

3. **Enhanced Testing**:
   - Added comprehensive test cases for automatic label management
   - Added tests for Package-to-Function mapping functionality
   - Added tests for cross-namespace Package updates
   - Added tests for Package change propagation to multiple Functions

4. **Deployment Improvements**:
   - Removed redundant `ImagePullPolicy` settings that were causing issues
   - Streamlined container configuration

These changes provide a more robust and maintainable way to manage Function-Package relationships while enabling automatic updates when Package configurations change.

---------

Signed-off-by: EvanWave <[email protected]>

Author: evanwave

.github/workflows/lint.yml

@@ -0,0 +1,37 @@
+# Copyright 2024 Function Stream Org.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+name: Lint
+
+on:
+  pull_request:
+
+jobs:
+  lint:
+    name: Run on Ubuntu
+    runs-on: ubuntu-latest
+    steps:
+      - name: Clone the code
+        uses: actions/checkout@v4
+
+      - name: Setup Go
+        uses: actions/setup-go@v5
+        with:
+          go-version-file: ./operator/go.mod
+
+      - name: Run linter
+        uses: golangci/golangci-lint-action@v6
+        working-directory: ./operator/
+        with:
+          version: v1.63.4

.gitignore

@@ -108,4 +108,6 @@ dist
 bin/
 .DS_Store
 
-benchmark/*.pprof
+benchmark/*.pprof
+
+operator/vendor/

operator/examples/function.yaml

@@ -19,9 +19,10 @@ package controller
 import (
 	"context"
 	"fmt"
+	"reflect"
+
 	"github.com/FunctionStream/function-stream/operator/utils"
 	"k8s.io/apimachinery/pkg/util/json"
-	"reflect"
 
 	"gopkg.in/yaml.v3"
 	appsv1 "k8s.io/api/apps/v1"
@@ -33,8 +34,10 @@ import (
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/builder"
 	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/handler"
 	logf "sigs.k8s.io/controller-runtime/pkg/log"
 	"sigs.k8s.io/controller-runtime/pkg/predicate"
+	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 
 	fsv1alpha1 "github.com/FunctionStream/function-stream/operator/api/v1alpha1"
 )
@@ -81,7 +84,17 @@ func (r *FunctionReconciler) Reconcile(ctx context.Context, req ctrl.Request) (c
 		return ctrl.Result{}, err
 	}
 
-	// 2. Get Package
+	// 2. Ensure Function has package label
+	if fn.Labels == nil {
+		fn.Labels = make(map[string]string)
+	}
+	labelUpdated := false
+	if fn.Labels["package"] != fn.Spec.Package {
+		fn.Labels["package"] = fn.Spec.Package
+		labelUpdated = true
+	}
+
+	// 3. Get Package
 	var pkg fsv1alpha1.Package
 	if err := r.Get(ctx, types.NamespacedName{Name: fn.Spec.Package, Namespace: req.Namespace}, &pkg); err != nil {
 		log.Error(err, "Failed to get Package", "package", fn.Spec.Package)
@@ -95,14 +108,14 @@ func (r *FunctionReconciler) Reconcile(ctx context.Context, req ctrl.Request) (c
 		return ctrl.Result{}, fmt.Errorf("package %s has no image", fn.Spec.Package)
 	}
 
-	// 3. Build config yaml content
+	// 4. Build config yaml content
 	configYaml, err := buildFunctionConfigYaml(&fn, r.Config)
 	if err != nil {
 		log.Error(err, "Failed to marshal config yaml")
 		return ctrl.Result{}, err
 	}
 
-	// 4. Build Deployment
+	// 5. Build Deployment
 	deployName := fmt.Sprintf("function-%s", fn.Name)
 	var replicas int32 = 1
 	labels := map[string]string{
@@ -132,19 +145,17 @@ EOF
 				},
 				Spec: corev1.PodSpec{
 					InitContainers: []corev1.Container{{
-						Name:            "init-config",
-						Image:           image,
-						ImagePullPolicy: corev1.PullIfNotPresent,
-						Command:         []string{"/bin/sh", "-c", initCommand},
+						Name:    "init-config",
+						Image:   image,
+						Command: []string{"/bin/sh", "-c", initCommand},
 						VolumeMounts: []corev1.VolumeMount{{
 							Name:      "function-config",
 							MountPath: "/config",
 						}},
 					}},
 					Containers: []corev1.Container{{
-						Name:            "function",
-						Image:           image,
-						ImagePullPolicy: corev1.PullIfNotPresent,
+						Name:  "function",
+						Image: image,
 						VolumeMounts: []corev1.VolumeMount{{
 							Name:      "function-config",
 							MountPath: "/config",
@@ -168,7 +179,7 @@ EOF
 		return ctrl.Result{}, err
 	}
 
-	// 5. Create or Update Deployment
+	// 6. Create or Update Deployment
 	var existingDeploy appsv1.Deployment
 	deployErr := r.Get(ctx, types.NamespacedName{Name: deployName, Namespace: fn.Namespace}, &existingDeploy)
 	if deployErr == nil {
@@ -199,6 +210,24 @@ EOF
 		}
 	}
 
+	// 8. Update Function labels if needed
+	if labelUpdated {
+		// Re-fetch the Function to ensure we have the latest version
+		var latestFn fsv1alpha1.Function
+		if err := r.Get(ctx, req.NamespacedName, &latestFn); err != nil {
+			log.Error(err, "Failed to get latest Function for label update")
+			return ctrl.Result{}, err
+		}
+		// Apply our label changes to the latest version
+		if latestFn.Labels == nil {
+			latestFn.Labels = make(map[string]string)
+		}
+		latestFn.Labels["package"] = fn.Spec.Package
+		if err := r.Update(ctx, &latestFn); err != nil {
+			return utils.HandleReconcileError(log, err, "Conflict when updating Function labels, will retry automatically")
+		}
+	}
+
 	return ctrl.Result{}, nil
 }
 
@@ -280,6 +309,38 @@ func (r *FunctionReconciler) SetupWithManager(mgr ctrl.Manager) error {
 	return ctrl.NewControllerManagedBy(mgr).
 		For(&fsv1alpha1.Function{}).
 		Owns(&appsv1.Deployment{}, builder.WithPredicates(functionLabelPredicate)).
+		Watches(
+			&fsv1alpha1.Package{},
+			handler.EnqueueRequestsFromMapFunc(r.mapPackageToFunctions),
+		).
 		Named("function").
 		Complete(r)
 }
+
+// mapPackageToFunctions maps Package changes to related Functions
+func (r *FunctionReconciler) mapPackageToFunctions(ctx context.Context, obj client.Object) []reconcile.Request {
+	packageObj, ok := obj.(*fsv1alpha1.Package)
+	if !ok {
+		return nil
+	}
+
+	// Get Functions that reference this Package using label selector
+	var functions fsv1alpha1.FunctionList
+	if err := r.List(ctx, &functions,
+		client.InNamespace(packageObj.Namespace),
+		client.MatchingLabels(map[string]string{"package": packageObj.Name})); err != nil {
+		return nil
+	}
+
+	var requests []reconcile.Request
+	for _, function := range functions.Items {
+		requests = append(requests, reconcile.Request{
+			NamespacedName: types.NamespacedName{
+				Name:      function.Name,
+				Namespace: function.Namespace,
+			},
+		})
+	}
+
+	return requests
+}