Init local storage for manifests

Signed-off-by: Stefan Prodan <[email protected]>

.gitignore

@@ -19,4 +19,5 @@
 
 # Go workspace file
 go.work
-bin/
+bin/
+data/

Dockerfile

@@ -28,6 +28,7 @@ RUN CGO_ENABLED=0 GOOS=${TARGETOS:-linux} GOARCH=${TARGETARCH} go build -a -o fl
 FROM gcr.io/distroless/static:nonroot
 WORKDIR /
 COPY --from=builder /workspace/fluxcd-operator .
+COPY data/ /data/
 USER 65532:65532
 
 ENTRYPOINT ["/fluxcd-operator"]

Makefile

@@ -90,6 +90,10 @@ build: manifests generate fmt vet ## Build manager binary.
 run: manifests generate fmt vet ## Run a controller from your host.
 	go run ./cmd/main.go
 
+.PHONY: data
+data: ## Download Flux manifests to data dir.
+	hack/data.sh v2.3.0 v2.2.3
+
 # If you wish to build the manager image targeting other platforms you can use the --platform flag.
 # (i.e. docker build --platform linux/arm64). However, you must enable docker buildKit for it.
 # More info: https://docs.docker.com/develop/develop-images/build_enhancements/

cmd/main.go

@@ -6,6 +6,7 @@ package main
 import (
 	"os"
 
+	"github.com/fluxcd/cli-utils/pkg/kstatus/polling"
 	runtimeCtrl "github.com/fluxcd/pkg/runtime/controller"
 	"github.com/fluxcd/pkg/runtime/logger"
 	"github.com/fluxcd/pkg/runtime/pprof"
@@ -49,11 +50,13 @@ func main() {
 		enableLeaderElection bool
 		logOptions           logger.Options
 		rateLimiterOptions   runtimeCtrl.RateLimiterOptions
+		storagePath          string
 	)
 
 	flag.IntVar(&concurrent, "concurrent", 4, "The number of concurrent kustomize reconciles.")
 	flag.StringVar(&metricsAddr, "metrics-addr", ":8080", "The address the metric endpoint binds to.")
 	flag.StringVar(&healthAddr, "health-addr", ":8081", "The address the health endpoint binds to.")
+	flag.StringVar(&storagePath, "storage-path", "/data", "The local storage path.")
 	flag.BoolVar(&enableLeaderElection, "enable-leader-election", false,
 		"Enable leader election for controller manager. "+
 			"Enabling this will ensure there is only one active controller manager.")
@@ -93,6 +96,8 @@ func main() {
 	if err = (&controller.FluxInstanceReconciler{
 		Client:        mgr.GetClient(),
 		Scheme:        mgr.GetScheme(),
+		StatusPoller:  polling.NewStatusPoller(mgr.GetClient(), mgr.GetRESTMapper(), polling.Options{}),
+		StoragePath:   storagePath,
 		StatusManager: controllerName,
 		EventRecorder: mgr.GetEventRecorderFor(controllerName),
 	}).SetupWithManager(mgr,

go.mod

@@ -3,6 +3,7 @@ module github.com/controlplaneio-fluxcd/fluxcd-operator
 go 1.22.0
 
 require (
+	github.com/fluxcd/cli-utils v0.36.0-flux.7
 	github.com/fluxcd/pkg/apis/kustomize v1.5.0
 	github.com/fluxcd/pkg/apis/meta v1.5.0
 	github.com/fluxcd/pkg/kustomize v1.11.0
@@ -33,7 +34,6 @@ require (
 	github.com/evanphx/json-patch v5.7.0+incompatible // indirect
 	github.com/evanphx/json-patch/v5 v5.9.0 // indirect
 	github.com/exponent-io/jsonpath v0.0.0-20210407135951-1de76d718b3f // indirect
-	github.com/fluxcd/cli-utils v0.36.0-flux.7 // indirect
 	github.com/fluxcd/pkg/envsubst v1.1.0 // indirect
 	github.com/fluxcd/pkg/sourceignore v0.7.0 // indirect
 	github.com/fsnotify/fsnotify v1.7.0 // indirect

hack/data.sh

@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+REPOSITORY_ROOT=$(git rev-parse --show-toplevel)
+
+info() {
+    echo '[INFO] ' "$@"
+}
+
+fatal() {
+    echo '[ERROR] ' "$@" >&2
+    exit 1
+}
+
+build() {
+  info "extracting manifests for Flux ${1}"
+  curl -sLO https://github.com/fluxcd/flux2/releases/download/${1}/manifests.tar.gz
+  mkdir -p "${REPOSITORY_ROOT}/data/flux/${1}"
+  tar xzf manifests.tar.gz -C "${REPOSITORY_ROOT}/data/flux/${1}"
+  rm -rf manifests.tar.gz
+}
+
+if ! [ -x "$(command -v flux)" ]; then
+  fatal 'flux is not installed'
+fi
+
+for var in "$@"
+do
+    build "$var"
+done
+
+info "all manifests extracted to ${REPOSITORY_ROOT}/data/flux/"

internal/builder/build_test.go

@@ -17,15 +17,16 @@ import (
 
 func TestBuild_Defaults(t *testing.T) {
 	g := NewWithT(t)
-	srcDir := filepath.Join("testdata", "v1.3.0")
-	goldenFile := filepath.Join("testdata", "v1.3.0-golden", "default.kustomization.yaml")
+	const version = "v1.3.0"
+	options := MakeDefaultOptions()
+	options.Version = version
+
+	srcDir := filepath.Join("testdata", version)
+	goldenFile := filepath.Join("testdata", version+"-golden", "default.kustomization.yaml")
 
 	dstDir, err := testTempDir(t)
 	g.Expect(err).NotTo(HaveOccurred())
 
-	options := MakeDefaultOptions()
-	options.Version = "v1.3.0"
-
 	objects, err := Build(srcDir, dstDir, options)
 	g.Expect(err).NotTo(HaveOccurred())
 	g.Expect(objects).NotTo(BeEmpty())
@@ -46,14 +47,16 @@ func TestBuild_Defaults(t *testing.T) {
 
 func TestBuild_Patches(t *testing.T) {
 	g := NewWithT(t)
-	srcDir := filepath.Join("testdata", "v1.3.0")
-	goldenFile := filepath.Join("testdata", "v1.3.0-golden", "patches.kustomization.yaml")
+	const version = "v1.3.0"
+	options := MakeDefaultOptions()
+	options.Version = version
+
+	srcDir := filepath.Join("testdata", version)
+	goldenFile := filepath.Join("testdata", version+"-golden", "patches.kustomization.yaml")
 
 	dstDir, err := testTempDir(t)
 	g.Expect(err).NotTo(HaveOccurred())
 
-	options := MakeDefaultOptions()
-	options.Version = "v1.3.0"
 	patches := []kustomize.Patch{
 		{
 			Patch: `
@@ -103,13 +106,14 @@ func TestBuild_Patches(t *testing.T) {
 
 func TestBuild_InvalidPatches(t *testing.T) {
 	g := NewWithT(t)
-	srcDir := filepath.Join("testdata", "v1.3.0")
+	const version = "v1.3.0"
+	options := MakeDefaultOptions()
+	options.Version = version
+	srcDir := filepath.Join("testdata", version)
 
 	dstDir, err := testTempDir(t)
 	g.Expect(err).NotTo(HaveOccurred())
 
-	options := MakeDefaultOptions()
-	options.Version = "v1.3.0"
 	patches := []kustomize.Patch{
 		{
 			Patch: `

internal/controller/fluxinstance_controller.go

@@ -6,8 +6,10 @@ package controller
 import (
 	"context"
 	"fmt"
+	"os"
 	"time"
 
+	"github.com/fluxcd/cli-utils/pkg/kstatus/polling"
 	"github.com/fluxcd/pkg/apis/meta"
 	"github.com/fluxcd/pkg/runtime/conditions"
 	"github.com/fluxcd/pkg/runtime/patch"
@@ -29,7 +31,9 @@ type FluxInstanceReconciler struct {
 	kuberecorder.EventRecorder
 
 	Scheme        *runtime.Scheme
+	StatusPoller  *polling.StatusPoller
 	StatusManager string
+	StoragePath   string
 }
 
 // +kubebuilder:rbac:groups=fluxcd.controlplane.io,resources=fluxinstances,verbs=get;list;watch;create;update;patch;delete
@@ -93,6 +97,23 @@ func (r *FluxInstanceReconciler) reconcile(ctx context.Context,
 	}
 	r.EventRecorder.Event(obj, corev1.EventTypeNormal, meta.ProgressingReason, msg)
 
+	// Verify the storage path exists.
+	if _, err := os.Stat(r.StoragePath); os.IsNotExist(err) {
+		msg := fmt.Sprintf("Storage path %s does not exist", r.StoragePath)
+		conditions.MarkFalse(obj,
+			meta.ReadyCondition,
+			meta.BuildFailedReason,
+			msg)
+		conditions.MarkTrue(obj,
+			meta.StalledCondition,
+			meta.BuildFailedReason,
+			msg)
+		log.Error(err, msg)
+		r.EventRecorder.Event(obj, corev1.EventTypeWarning, meta.BuildFailedReason, msg)
+		return ctrl.Result{}, nil
+	}
+
+	// Mark the object as ready.
 	msg = fmt.Sprintf("Reconciliation finished in %s", time.Since(reconcileStart).String())
 	conditions.MarkTrue(obj,
 		meta.ReadyCondition,
@@ -101,6 +122,7 @@ func (r *FluxInstanceReconciler) reconcile(ctx context.Context,
 	log.Info(msg, "generation", obj.GetGeneration())
 	r.EventRecorder.Event(obj, corev1.EventTypeNormal, meta.ReconciliationSucceededReason, msg)
 
+	// Requeue the reconciliation if the interval is set in annotations.
 	result := ctrl.Result{}
 	if obj.GetInterval() > 0 {
 		result.RequeueAfter = obj.GetInterval()
@@ -120,7 +142,7 @@ func (r *FluxInstanceReconciler) finalize(ctx context.Context,
 	msg := fmt.Sprintf("Uninstallation completed in %v", time.Since(reconcileStart).String())
 	log.Info(msg)
 
-	// Stop reconciliation as the object is being deleted
+	// Stop reconciliation as the object is being deleted.
 	return ctrl.Result{}, nil
 }
 
@@ -132,12 +154,6 @@ func (r *FluxInstanceReconciler) finalizeStatus(ctx context.Context,
 		obj.Status.LastHandledReconcileAt = v
 	}
 
-	// Remove the Reconciling condition if the reconciliation was successful.
-	if conditions.IsTrue(obj, meta.ReadyCondition) {
-		conditions.Delete(obj, meta.ReconcilingCondition)
-		obj.Status.ObservedGeneration = obj.Generation
-	}
-
 	// Set the Reconciling reason to ProgressingWithRetry if the
 	// reconciliation has failed.
 	if conditions.IsFalse(obj, meta.ReadyCondition) &&
@@ -147,6 +163,11 @@ func (r *FluxInstanceReconciler) finalizeStatus(ctx context.Context,
 		conditions.Set(obj, rc)
 	}
 
+	// Remove the Reconciling condition.
+	if conditions.IsTrue(obj, meta.ReadyCondition) || conditions.IsTrue(obj, meta.StalledCondition) {
+		conditions.Delete(obj, meta.ReconcilingCondition)
+	}
+
 	// Patch finalizers, status and conditions.
 	return r.patch(ctx, obj, patcher)
 }
@@ -166,7 +187,7 @@ func (r *FluxInstanceReconciler) patch(ctx context.Context,
 		patch.WithFieldOwner(r.StatusManager),
 	}
 
-	if conditions.IsTrue(obj, meta.ReadyCondition) {
+	if conditions.IsTrue(obj, meta.ReadyCondition) || conditions.IsTrue(obj, meta.StalledCondition) {
 		patchOpts = append(patchOpts, patch.WithStatusObservedGeneration{})
 	}
 

internal/controller/fluxinstance_controller_test.go

@@ -104,3 +104,70 @@ func TestFluxInstanceReconciler_Install(t *testing.T) {
 	g.Expect(err).To(HaveOccurred())
 	g.Expect(apierrors.IsNotFound(err)).To(BeTrue())
 }
+
+func TestFluxInstanceReconciler_InstallFail(t *testing.T) {
+	g := NewWithT(t)
+	reconciler := getFluxInstanceReconciler()
+	reconciler.StoragePath = "notfound"
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
+
+	ns, err := testEnv.CreateNamespace(ctx, "test")
+	g.Expect(err).ToNot(HaveOccurred())
+
+	obj := &fluxcdv1alpha1.FluxInstance{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      ns.Name,
+			Namespace: ns.Name,
+		},
+	}
+
+	err = testEnv.Create(ctx, obj)
+	g.Expect(err).ToNot(HaveOccurred())
+
+	// Initialize the instance.
+	r, err := reconciler.Reconcile(ctx, reconcile.Request{
+		NamespacedName: client.ObjectKeyFromObject(obj),
+	})
+	g.Expect(err).ToNot(HaveOccurred())
+	g.Expect(r.Requeue).To(BeTrue())
+
+	// Try to install the instance.
+	r, err = reconciler.Reconcile(ctx, reconcile.Request{
+		NamespacedName: client.ObjectKeyFromObject(obj),
+	})
+	g.Expect(err).ToNot(HaveOccurred())
+	g.Expect(r.IsZero()).To(BeTrue())
+
+	// Check if the instance was marked as failed.
+	result := &fluxcdv1alpha1.FluxInstance{}
+	err = testEnv.Get(ctx, client.ObjectKeyFromObject(obj), result)
+	g.Expect(err).ToNot(HaveOccurred())
+
+	logObjectStatus(t, result)
+	g.Expect(conditions.IsStalled(result)).To(BeTrue())
+	g.Expect(conditions.GetReason(result, meta.ReadyCondition)).To(BeIdenticalTo(meta.BuildFailedReason))
+	g.Expect(conditions.GetMessage(result, meta.ReadyCondition)).To(ContainSubstring("Storage path"))
+
+	// Check if events were recorded for each step.
+	events := getEvents(result.Name)
+	g.Expect(events).To(HaveLen(2))
+	g.Expect(events[0].Reason).To(Equal(meta.ProgressingReason))
+	g.Expect(events[1].Reason).To(Equal(meta.BuildFailedReason))
+	g.Expect(events[1].Message).To(ContainSubstring(reconciler.StoragePath))
+
+	err = testClient.Delete(ctx, obj)
+	g.Expect(err).ToNot(HaveOccurred())
+
+	r, err = reconciler.Reconcile(ctx, reconcile.Request{
+		NamespacedName: client.ObjectKeyFromObject(obj),
+	})
+	g.Expect(err).ToNot(HaveOccurred())
+	g.Expect(r.IsZero()).To(BeTrue())
+
+	// Check if the instance was uninstalled.
+	result = &fluxcdv1alpha1.FluxInstance{}
+	err = testEnv.Get(ctx, client.ObjectKeyFromObject(obj), result)
+	g.Expect(err).To(HaveOccurred())
+	g.Expect(apierrors.IsNotFound(err)).To(BeTrue())
+}

internal/controller/suite_test.go

@@ -11,6 +11,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/fluxcd/cli-utils/pkg/kstatus/polling"
 	"github.com/fluxcd/pkg/apis/meta"
 	"github.com/fluxcd/pkg/runtime/conditions"
 	kcheck "github.com/fluxcd/pkg/runtime/conditions/check"
@@ -83,6 +84,8 @@ func getFluxInstanceReconciler() *FluxInstanceReconciler {
 	return &FluxInstanceReconciler{
 		Client:        testClient,
 		Scheme:        NewTestScheme(),
+		StatusPoller:  polling.NewStatusPoller(testClient, testEnv.GetRESTMapper(), polling.Options{}),
+		StoragePath:   filepath.Join("..", "..", "data"),
 		StatusManager: controllerName,
 		EventRecorder: testEnv.GetEventRecorderFor(controllerName),
 	}