wip

Author: frewilhelm

api/v1alpha1/condition_types.go

@@ -39,6 +39,9 @@ const (
 	// RepositoryIsNotReadyReason is used when the referenced repository is not Ready yet.
 	RepositoryIsNotReadyReason = "RepositoryIsNotReady"
 
+	// ComponentNotFoundReason is used when the referenced component is not found.
+	ComponentNotFoundReason = "ComponentNotFound"
+
 	// ComponentIsNotReadyReason is used when the referenced component is not Ready yet.
 	ComponentIsNotReadyReason = "ComponentIsNotReady"
 

internal/controller/component/suite_test.go

@@ -51,7 +51,7 @@ import (
 
 const (
 	ARTIFACT_PATH   = "ocm-k8s-artifactstore--*"
-	ARTIFACT_SERVER = "localhost:8080"
+	ARTIFACT_SERVER = "localhost:0"
 )
 
 var cfg *rest.Config

internal/controller/configuration/configuration_controller.go

@@ -85,6 +85,7 @@ type Reconciler struct {
 // Reconcile is part of the main kubernetes reconciliation loop which aims to
 // move the current state of the cluster closer to the desired state.
 func (r *Reconciler) Reconcile(ctx context.Context, req ctrl.Request) (_ ctrl.Result, err error) {
+	log.FromContext(ctx).V(1).Info("reconciling")
 	configuration := &v1alpha1.ConfiguredResource{}
 	if err := r.Get(ctx, req.NamespacedName, configuration); err != nil {
 		return ctrl.Result{}, client.IgnoreNotFound(err)
@@ -228,6 +229,7 @@ func (r *Reconciler) reconcileExists(ctx context.Context, configuration *v1alpha
 		return ctrl.Result{}, fmt.Errorf("failed to reconcile artifact: %w", err)
 	}
 
+	logger.Info("updating")
 	logger.Info("configuration successful", "artifact", configuration.Status.ArtifactRef)
 	status.MarkReady(r.EventRecorder, configuration, "configured successfully")
 

internal/controller/resource/resource_controller.go

@@ -123,19 +123,16 @@ func (r *Reconciler) SetupWithManager(mgr ctrl.Manager) error {
 // +kubebuilder:rbac:groups=openfluxcd.mandelsoft.org,resources=artifacts/finalizers,verbs=update
 
 func (r *Reconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
+	log.FromContext(ctx).V(1).Info("starting reconciling resource")
+
 	resource := &v1alpha1.Resource{}
 	if err := r.Get(ctx, req.NamespacedName, resource); err != nil {
 		return ctrl.Result{}, client.IgnoreNotFound(err)
 	}
 
-	return r.reconcileWithStatusUpdate(ctx, resource)
-}
-
-func (r *Reconciler) reconcileWithStatusUpdate(ctx context.Context, resource *v1alpha1.Resource) (ctrl.Result, error) {
 	patchHelper := patch.NewSerialPatcher(resource, r.Client)
 
-	result, err := r.reconcileExists(ctx, resource)
-
+	result, err := r.reconcilePrerequisite(ctx, resource)
 	err = errors.Join(err, status.UpdateStatus(ctx, patchHelper, resource, r.EventRecorder, resource.GetRequeueAfter(), err))
 	if err != nil {
 		return ctrl.Result{}, err
@@ -144,9 +141,9 @@ func (r *Reconciler) reconcileWithStatusUpdate(ctx context.Context, resource *v1
 	return result, nil
 }
 
-func (r *Reconciler) reconcileExists(ctx context.Context, resource *v1alpha1.Resource) (ctrl.Result, error) {
+func (r *Reconciler) reconcilePrerequisite(ctx context.Context, resource *v1alpha1.Resource) (ctrl.Result, error) {
 	logger := log.FromContext(ctx)
-	logger.V(1).Info("preparing reconciling resource")
+	logger.V(1).Info("checking if resource is suspended or deleted")
 
 	if resource.Spec.Suspend {
 		return ctrl.Result{}, nil
@@ -159,6 +156,7 @@ func (r *Reconciler) reconcileExists(ctx context.Context, resource *v1alpha1.Res
 		}
 
 		if removed := controllerutil.RemoveFinalizer(resource, v1alpha1.ArtifactFinalizer); removed {
+			logger.V(1).Info("removing finalizer, restarting reconciler")
 			if err := r.Update(ctx, resource); err != nil {
 				return ctrl.Result{}, fmt.Errorf("failed to remove finalizer: %w", err)
 			}
@@ -168,19 +166,16 @@ func (r *Reconciler) reconcileExists(ctx context.Context, resource *v1alpha1.Res
 	}
 
 	if added := controllerutil.AddFinalizer(resource, v1alpha1.ArtifactFinalizer); added {
-		err := r.Update(ctx, resource)
-		if err != nil {
+		logger.V(1).Info("adding finalizer, restarting reconciler")
+		if err := r.Update(ctx, resource); err != nil {
 			return ctrl.Result{}, fmt.Errorf("failed to add finalizer: %w", err)
 		}
 
 		return ctrl.Result{Requeue: true}, nil
 	}
 
-	return r.reconcile(ctx, resource)
-}
+	logger.V(1).Info("checking if referenced component is ready")
 
-func (r *Reconciler) reconcile(ctx context.Context, resource *v1alpha1.Resource) (ctrl.Result, error) {
-	logger := log.FromContext(ctx)
 	// Get component to resolve resource from component descriptor and verify digest
 	component := &v1alpha1.Component{}
 	if err := r.Get(ctx, types.NamespacedName{
@@ -203,13 +198,9 @@ func (r *Reconciler) reconcile(ctx context.Context, resource *v1alpha1.Resource)
 		return ctrl.Result{}, errors.New("component is not ready")
 	}
 
-	return r.reconcileOCM(ctx, resource, component)
-}
-
-func (r *Reconciler) reconcileOCM(ctx context.Context, resource *v1alpha1.Resource, component *v1alpha1.Component) (ctrl.Result, error) {
 	octx := ocmctx.New(datacontext.MODE_EXTENDED)
 
-	result, err := r.reconcileResource(ctx, octx, resource, component)
+	result, err := r.reconcile(ctx, octx, resource, component)
 
 	// Always finalize ocm context after reconciliation
 	err = errors.Join(err, octx.Finalize())
@@ -223,7 +214,7 @@ func (r *Reconciler) reconcileOCM(ctx context.Context, resource *v1alpha1.Resour
 	return result, nil
 }
 
-func (r *Reconciler) reconcileResource(ctx context.Context, octx ocmctx.Context, resource *v1alpha1.Resource, component *v1alpha1.Component) (ctrl.Result, error) {
+func (r *Reconciler) reconcile(ctx context.Context, octx ocmctx.Context, resource *v1alpha1.Resource, component *v1alpha1.Component) (ctrl.Result, error) {
 	logger := log.FromContext(ctx)
 	logger.V(1).Info("reconciling resource")
 

internal/controller/resource/resource_controller_test.go

@@ -35,6 +35,7 @@ import (
 	artifactv1 "github.com/openfluxcd/artifact/api/v1alpha1"
 	corev1 "k8s.io/api/core/v1"
 	apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
+	"k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	. "ocm.software/ocm/api/helper/builder"
 	environment "ocm.software/ocm/api/helper/env"
@@ -65,11 +66,10 @@ const (
 
 var _ = Describe("Resource Controller", func() {
 	var (
-		ctx     context.Context
-		cancel  context.CancelFunc
 		env     *Builder
 		ctfPath string
 	)
+
 	BeforeEach(func() {
 		ctfPath = Must(os.MkdirTemp("", CTFPath))
 		DeferCleanup(func() error {
@@ -78,31 +78,29 @@ var _ = Describe("Resource Controller", func() {
 
 		env = NewBuilder(environment.FileSystem(osfs.OsFs))
 		DeferCleanup(env.Cleanup)
-
-		ctx, cancel = context.WithCancel(context.Background())
-		DeferCleanup(cancel)
 	})
 
 	Context("resource controller", func() {
 		var (
 			componentName string
+			resourceName  string
 			testNumber    int
-			//componentObj  *v1alpha1.Component
 		)
 
-		BeforeEach(func() {
+		BeforeEach(func(ctx SpecContext) {
 			By("mocking the component controller")
 			componentName = fmt.Sprintf("%s-%d", ComponentObj, testNumber)
+			resourceName = fmt.Sprintf("%s-%d", ResourceObj, testNumber)
 			mockComponentReconciler(ctx, env, ctfPath, componentName)
+			testNumber++
 		})
 
-		It("can reconcile a resource", func() {
-
+		FIt("can reconcile a resource", func(ctx SpecContext) {
 			By("creating a resource object")
 			resource := &v1alpha1.Resource{
 				ObjectMeta: metav1.ObjectMeta{
 					Namespace: Namespace,
-					Name:      ResourceObj,
+					Name:      resourceName,
 				},
 				Spec: v1alpha1.ResourceSpec{
 					ComponentRef: corev1.LocalObjectReference{
@@ -117,26 +115,23 @@ var _ = Describe("Resource Controller", func() {
 				},
 			}
 			Expect(k8sClient.Create(ctx, resource)).To(Succeed())
-			DeferCleanup(func(ctx SpecContext) {
-				Expect(k8sClient.Delete(ctx, resource, client.PropagationPolicy(metav1.DeletePropagationForeground))).To(Succeed())
-			})
 
 			By("checking that the resource has been reconciled successfully")
-			Eventually(komega.Object(resource), "5m").Should(
+			Eventually(komega.Object(resource), "15s", "100ms").Should(
 				HaveField("Status.ObservedGeneration", Equal(int64(1))))
 			Expect(resource).To(HaveField("Status.ArtifactRef.Name", Not(BeEmpty())))
 			Expect(resource).To(HaveField("Status.Resource.Name", Equal(ResourceObj)))
 			Expect(resource).To(HaveField("Status.Resource.Type", Equal(artifacttypes.PLAIN_TEXT)))
 			Expect(resource).To(HaveField("Status.Resource.Version", Equal(ResourceVersion)))
 
-			By("checking that the artifact has been created successfully")
+			By("checking that the resource artifact was created")
 			artifact := &artifactv1.Artifact{
 				ObjectMeta: metav1.ObjectMeta{
 					Namespace: resource.Namespace,
 					Name:      resource.Status.ArtifactRef.Name,
 				},
 			}
-			Eventually(komega.Get(artifact)).Should(Succeed())
+			Eventually(komega.Get(artifact), "15s", "100ms").Should(Succeed())
 
 			By("checking that the artifact server provides the resource")
 			r := Must(http.Get(artifact.Spec.URL))
@@ -152,11 +147,59 @@ var _ = Describe("Resource Controller", func() {
 			resourceContent := Must(io.ReadAll(reader))
 
 			Expect(string(resourceContent)).To(Equal(ResourceContent))
+
+			By("checking that the resource is deleted correctly")
+			Expect(k8sClient.Delete(ctx, resource)).To(Succeed())
+			Eventually(komega.Object(resource), "15s").Should(HaveField("Status.DeletionTimestamp", Not(BeNil())))
+			Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(resource), resource)).To(Succeed())
+
+			// Simulate ownerreference deletion
+			Expect(k8sClient.Delete(ctx, artifact)).To(Succeed())
+
+			Eventually(func(ctx SpecContext) error {
+				return k8sClient.Get(ctx, client.ObjectKeyFromObject(resource), resource)
+			}).WithContext(ctx).Should(Satisfy(errors.IsNotFound))
+		})
+
+		It("stops when requirements are not met: component not found", func(ctx SpecContext) {
+			By("creating a resource object")
+			resource := &v1alpha1.Resource{
+				ObjectMeta: metav1.ObjectMeta{
+					Namespace: Namespace,
+					Name:      resourceName,
+				},
+				Spec: v1alpha1.ResourceSpec{
+					ComponentRef: corev1.LocalObjectReference{
+						Name: "anotherName",
+					},
+					Resource: v1alpha1.ResourceID{
+						ByReference: v1alpha1.ResourceReference{
+							Resource: v1.NewIdentity(ResourceObj),
+						},
+					},
+					Interval: metav1.Duration{Duration: time.Minute * 5},
+				},
+			}
+			Expect(k8sClient.Create(ctx, resource)).To(Succeed())
+			DeferCleanup(func(ctx SpecContext) {
+				Expect(k8sClient.Delete(ctx, resource, client.PropagationPolicy(metav1.DeletePropagationForeground))).To(Succeed())
+			})
+
+			By("checking that the resource was not reconciled successfully")
+			Eventually(komega.Object(resource), "5m").Should(
+				HaveField("Status.ObservedGeneration", Equal(int64(1))))
+			Expect(resource).To(HaveField("Status.ArtifactRef.Name", Not(BeEmpty())))
+			Expect(resource).To(HaveField("Status.Resource.Name", Equal(ResourceObj)))
+			Expect(resource).To(HaveField("Status.Resource.Type", Equal(artifacttypes.PLAIN_TEXT)))
+			Expect(resource).To(HaveField("Status.Resource.Version", Equal(ResourceVersion)))
+
 		})
 	})
 })
 
 func mockComponentReconciler(ctx context.Context, env *Builder, ctfPath, name string) {
+	GinkgoHelper()
+
 	// Create a ctf storing a component-version with a blob data as content
 	env.OCMCommonTransport(ctfPath, accessio.FormatDirectory, func() {
 		env.Component(Component, func() {

internal/controller/resource/suite_test.go

@@ -32,6 +32,8 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/client-go/kubernetes/scheme"
 	"k8s.io/client-go/rest"
+	"k8s.io/client-go/tools/clientcmd"
+	"k8s.io/client-go/tools/clientcmd/api"
 	"k8s.io/client-go/tools/record"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
@@ -52,7 +54,7 @@ import (
 
 const (
 	ARTIFACT_PATH   = "ocm-k8s-artifactstore--*"
-	ARTIFACT_SERVER = "localhost:8081"
+	ARTIFACT_SERVER = "localhost:8085"
 )
 
 var cfg *rest.Config
@@ -91,6 +93,8 @@ var _ = BeforeSuite(func() {
 	Expect(cfg).NotTo(BeNil())
 	DeferCleanup(testEnv.Stop)
 
+	createKubeConfig(cfg)
+
 	Expect(v1alpha1.AddToScheme(scheme.Scheme)).Should(Succeed())
 	Expect(artifactv1.AddToScheme(scheme.Scheme)).Should(Succeed())
 	Expect(err).NotTo(HaveOccurred())
@@ -146,3 +150,35 @@ var _ = BeforeSuite(func() {
 		Expect(k8sManager.Start(ctx)).To(Succeed())
 	}()
 })
+
+func createKubeConfig(cfg *rest.Config) {
+	// Write the kubeconfig to the temporary file
+	kubeconfig := api.Config{
+		Clusters: map[string]*api.Cluster{
+			"test-cluster": {
+				Server:                   cfg.Host,
+				CertificateAuthorityData: cfg.CAData,
+			},
+		},
+		AuthInfos: map[string]*api.AuthInfo{
+			"test-user": {
+				ClientCertificateData: cfg.CertData,
+				ClientKeyData:         cfg.KeyData,
+			},
+		},
+		Contexts: map[string]*api.Context{
+			"test-context": {
+				Cluster:  "test-cluster",
+				AuthInfo: "test-user",
+			},
+		},
+		CurrentContext: "test-context",
+	}
+
+	kubeconfigFile, err := os.Create(filepath.Join(os.Getenv("HOME"), ".kubeconfig.env"))
+
+	kubeconfigBytes, err := clientcmd.Write(kubeconfig)
+	Expect(err).NotTo(HaveOccurred())
+	_, err = kubeconfigFile.Write(kubeconfigBytes)
+	Expect(err).NotTo(HaveOccurred())
+}