fixup! fixup! fixup! fixup! fixup! Network: gateway routes

Author: cheina97

apis/networking/v1alpha1/routeconfiguration_types.go

@@ -15,6 +15,7 @@
 package v1alpha1
 
 import (
+	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 )
@@ -46,6 +47,9 @@ type Route struct {
 	Dev *string `json:"dev,omitempty"`
 	// Onlink enables the onlink falg inside the route.
 	Onlink *bool `json:"onlink,omitempty"`
+	// TargetRef is the reference to the target object of the route.
+	// It is optional and it can be used for custom purposes.
+	TargetRef *corev1.ObjectReference `json:"targetRef,omitempty"`
 }
 
 // Rule is the rule of the RouteConfiguration.
@@ -61,6 +65,9 @@ type Rule struct {
 	// Routes is the list of routes of the Rule.
 	// +kubebuilder:validation:MinItems=1
 	Routes []Route `json:"routes"`
+	// TargetRef is the reference to the target object of the route.
+	// It is optional and it can be used for custom purposes.
+	TargetRef *corev1.ObjectReference `json:"targetRef,omitempty"`
 }
 
 // Table is the table of the RouteConfiguration.
@@ -70,6 +77,9 @@ type Table struct {
 	// Rules is the list of rules of the RouteConfiguration.
 	// +kubebuilder:validation:MinItems=1
 	Rules []Rule `json:"rules"`
+	// TargetRef is the reference to the target object of the route.
+	// It is optional and it can be used for custom purposes.
+	TargetRef *corev1.ObjectReference `json:"targetRef,omitempty"`
 }
 
 // RouteConfigurationSpec defines the desired state of RouteConfiguration.

apis/networking/v1alpha1/zz_generated.deepcopy.go

@@ -91,6 +91,53 @@ spec:
                                 description: Src is the source of the RouteConfiguration.
                                 pattern: ^(([1-9]{0,1}[0-9]{0,2}|2[0-4][0-9]|25[0-5])\.){3}([1-9]{0,1}[0-9]{0,2}|2[0-4][0-9]|25[0-5])$
                                 type: string
+                              targetRef:
+                                description: TargetRef is the reference to the target
+                                  object of the route. It is optional and it can be
+                                  used for custom purposes.
+                                properties:
+                                  apiVersion:
+                                    description: API version of the referent.
+                                    type: string
+                                  fieldPath:
+                                    description: 'If referring to a piece of an object
+                                      instead of an entire object, this string should
+                                      contain a valid JSON/Go field access statement,
+                                      such as desiredState.manifest.containers[2].
+                                      For example, if the object reference is to a
+                                      container within a pod, this would take on a
+                                      value like: "spec.containers{name}" (where "name"
+                                      refers to the name of the container that triggered
+                                      the event) or if no container name is specified
+                                      "spec.containers[2]" (container with index 2
+                                      in this pod). This syntax is chosen only to
+                                      have some well-defined way of referencing a
+                                      part of an object. TODO: this design is not
+                                      final and this field is subject to change in
+                                      the future.'
+                                    type: string
+                                  kind:
+                                    description: 'Kind of the referent. More info:
+                                      https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds'
+                                    type: string
+                                  name:
+                                    description: 'Name of the referent. More info:
+                                      https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names'
+                                    type: string
+                                  namespace:
+                                    description: 'Namespace of the referent. More
+                                      info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/'
+                                    type: string
+                                  resourceVersion:
+                                    description: 'Specific resourceVersion to which
+                                      this reference is made, if any. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency'
+                                    type: string
+                                  uid:
+                                    description: 'UID of the referent. More info:
+                                      https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids'
+                                    type: string
+                                type: object
+                                x-kubernetes-map-type: atomic
                             required:
                             - dst
                             type: object
@@ -100,11 +147,90 @@ spec:
                           description: Src is the source of the Rule.
                           pattern: ^(([1-9]{0,1}[0-9]{0,2}|2[0-4][0-9]|25[0-5])\.){3}([1-9]{0,1}[0-9]{0,2}|2[0-4][0-9]|25[0-5])\/([0-9]|[1-2][0-9]|3[0-2])$
                           type: string
+                        targetRef:
+                          description: TargetRef is the reference to the target object
+                            of the route. It is optional and it can be used for custom
+                            purposes.
+                          properties:
+                            apiVersion:
+                              description: API version of the referent.
+                              type: string
+                            fieldPath:
+                              description: 'If referring to a piece of an object instead
+                                of an entire object, this string should contain a
+                                valid JSON/Go field access statement, such as desiredState.manifest.containers[2].
+                                For example, if the object reference is to a container
+                                within a pod, this would take on a value like: "spec.containers{name}"
+                                (where "name" refers to the name of the container
+                                that triggered the event) or if no container name
+                                is specified "spec.containers[2]" (container with
+                                index 2 in this pod). This syntax is chosen only to
+                                have some well-defined way of referencing a part of
+                                an object. TODO: this design is not final and this
+                                field is subject to change in the future.'
+                              type: string
+                            kind:
+                              description: 'Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds'
+                              type: string
+                            name:
+                              description: 'Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names'
+                              type: string
+                            namespace:
+                              description: 'Namespace of the referent. More info:
+                                https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/'
+                              type: string
+                            resourceVersion:
+                              description: 'Specific resourceVersion to which this
+                                reference is made, if any. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency'
+                              type: string
+                            uid:
+                              description: 'UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids'
+                              type: string
+                          type: object
+                          x-kubernetes-map-type: atomic
                       required:
                       - routes
                       type: object
                     minItems: 1
                     type: array
+                  targetRef:
+                    description: TargetRef is the reference to the target object of
+                      the route. It is optional and it can be used for custom purposes.
+                    properties:
+                      apiVersion:
+                        description: API version of the referent.
+                        type: string
+                      fieldPath:
+                        description: 'If referring to a piece of an object instead
+                          of an entire object, this string should contain a valid
+                          JSON/Go field access statement, such as desiredState.manifest.containers[2].
+                          For example, if the object reference is to a container within
+                          a pod, this would take on a value like: "spec.containers{name}"
+                          (where "name" refers to the name of the container that triggered
+                          the event) or if no container name is specified "spec.containers[2]"
+                          (container with index 2 in this pod). This syntax is chosen
+                          only to have some well-defined way of referencing a part
+                          of an object. TODO: this design is not final and this field
+                          is subject to change in the future.'
+                        type: string
+                      kind:
+                        description: 'Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds'
+                        type: string
+                      name:
+                        description: 'Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names'
+                        type: string
+                      namespace:
+                        description: 'Namespace of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/'
+                        type: string
+                      resourceVersion:
+                        description: 'Specific resourceVersion to which this reference
+                          is made, if any. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency'
+                        type: string
+                      uid:
+                        description: 'UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids'
+                        type: string
+                    type: object
+                    x-kubernetes-map-type: atomic
                 required:
                 - name
                 - rules

deployments/liqo/charts/liqo-crds/crds/networking.liqo.io_routeconfigurations.yaml

@@ -92,6 +92,12 @@ func addPodToRoute(pod *corev1.Pod, internalnode *networkingv1alpha1.InternalNod
 		Dev:    &internalnode.Spec.Interface.Gateway.Name,
 		Gw:     ptr.To(networkingv1alpha1.IP(fabric.GeneveNodeInterfaceIP)),
 		Onlink: ptr.To(true),
+		TargetRef: &corev1.ObjectReference{
+			Kind:      pod.GetObjectKind().GroupVersionKind().Kind,
+			Name:      pod.GetName(),
+			Namespace: pod.GetNamespace(),
+			UID:       pod.GetUID(),
+		},
 	}
 	rule.Routes = append(rule.Routes, route)
 }

pkg/liqo-controller-manager/internal-network/route/k8s.go

@@ -0,0 +1,116 @@
+// Copyright 2019-2024 The Liqo Authors
+//
+// 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.
+
+package route
+
+import (
+	"context"
+
+	corev1 "k8s.io/api/core/v1"
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/klog/v2"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/event"
+	"sigs.k8s.io/controller-runtime/pkg/handler"
+	"sigs.k8s.io/controller-runtime/pkg/reconcile"
+	"sigs.k8s.io/controller-runtime/pkg/source"
+
+	networkingv1alpha1 "github.com/liqotech/liqo/apis/networking/v1alpha1"
+	"github.com/liqotech/liqo/pkg/utils/getters"
+)
+
+// NewLeftoverPodsSource returns a new LeftoversPodSource.
+func NewLeftoverPodsSource(src <-chan event.GenericEvent) *source.Channel {
+	return &source.Channel{
+		Source: src,
+	}
+}
+
+// NewLeftoverPodsEventHandler returns a new LeftoverPodsEventHandler.
+func NewLeftoverPodsEventHandler(opts *Options) handler.EventHandler {
+	return handler.EnqueueRequestsFromMapFunc(func(ctx context.Context, o client.Object) []reconcile.Request {
+		pod, ok := o.(*corev1.Pod)
+		if !ok {
+			klog.Errorf("unable to cast object %s to pod", o.GetName())
+			return nil
+		}
+		return []reconcile.Request{
+			{
+				NamespacedName: client.ObjectKey{
+					Name:      pod.Spec.NodeName,
+					Namespace: opts.Namespace,
+				},
+			},
+		}
+	})
+}
+
+// CheckLeftoverRoutes lists all currently existing routeconfigurations and adds their
+// pod to the queue. This will detect routes that exist with no
+// corresponding pod; these routes need to be deleted. We only need to
+// do this once on startup, because in steady-state these are detected (but
+// some stragglers could have been left behind if this controller
+// reboots).
+func (r *PodReconciler) CheckLeftoverRoutes(ctx context.Context) error {
+	routecfglist, err := getters.ListRouteConfigurationsByLabel(ctx, r.Client, r.Options.Namespace, labels.Everything())
+	if err != nil {
+		return err
+	}
+	return r.processRouteConfigurations(ctx, routecfglist)
+}
+
+func (r *PodReconciler) processRouteConfigurations(ctx context.Context, routecfglist *networkingv1alpha1.RouteConfigurationList) error {
+	for i := range routecfglist.Items {
+		if routecfglist.Items[i].Spec.Table.Rules == nil || len(routecfglist.Items[i].Spec.Table.Rules) == 0 {
+			continue
+		}
+		if err := r.processRules(ctx, &routecfglist.Items[i]); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (r *PodReconciler) processRules(ctx context.Context, routecfg *networkingv1alpha1.RouteConfiguration) error {
+	for j := range routecfg.Spec.Table.Rules {
+		if err := r.processRoutes(ctx, &routecfg.Spec.Table.Rules[j]); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (r *PodReconciler) processRoutes(ctx context.Context, rule *networkingv1alpha1.Rule) error {
+	for k := range rule.Routes {
+		if rule.Routes[k].TargetRef == nil {
+			continue
+		}
+		if err := r.processRoute(ctx, &rule.Routes[k]); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (r *PodReconciler) processRoute(ctx context.Context, route *networkingv1alpha1.Route) error {
+	pod := &corev1.Pod{}
+	if err := r.Get(ctx, client.ObjectKey{Name: route.TargetRef.Name, Namespace: route.TargetRef.Namespace}, pod); err != nil {
+		if !apierrors.IsNotFound(err) {
+			return err
+		}
+		klog.Infof("pod %s not found, adding to queue", route.TargetRef.Name)
+	}
+	return nil
+}