diff --git a/cmd/gotk/bootstrap.go b/cmd/gotk/bootstrap.go
index 970275730d35283b9bc475e9ed11d3930b40bbf1..2dce249aa985ccc01ec1aee38ded69e5d2a902f5 100644
--- a/cmd/gotk/bootstrap.go
+++ b/cmd/gotk/bootstrap.go
@@ -246,13 +246,15 @@ func applySyncManifests(ctx context.Context, kubeClient client.Client, name, nam
logger.Waitingf("waiting for cluster sync")
+ var gitRepository sourcev1.GitRepository
if err := wait.PollImmediate(pollInterval, timeout,
- isGitRepositoryReady(ctx, kubeClient, name, namespace)); err != nil {
+ isGitRepositoryReady(ctx, kubeClient, types.NamespacedName{Name: name, Namespace: namespace}, &gitRepository)); err != nil {
return err
}
+ var kustomization kustomizev1.Kustomization
if err := wait.PollImmediate(pollInterval, timeout,
- isKustomizationReady(ctx, kubeClient, name, namespace)); err != nil {
+ isKustomizationReady(ctx, kubeClient, types.NamespacedName{Name: name, Namespace: namespace}, &kustomization)); err != nil {
return err
}
diff --git a/cmd/gotk/create_alert.go b/cmd/gotk/create_alert.go
index 6e7cbd535abec66bd4e945d201f02d97169ffdee..9a943b210e6eefc08ffef3749c32fa6e1f589469 100644
--- a/cmd/gotk/create_alert.go
+++ b/cmd/gotk/create_alert.go
@@ -61,7 +61,7 @@ func init() {
func createAlertCmdRun(cmd *cobra.Command, args []string) error {
if len(args) < 1 {
- return fmt.Errorf("alert name is required")
+ return fmt.Errorf("Alert name is required")
}
name := args[0]
@@ -92,7 +92,7 @@ func createAlertCmdRun(cmd *cobra.Command, args []string) error {
}
if !export {
- logger.Generatef("generating alert")
+ logger.Generatef("generating Alert")
}
alert := notificationv1.Alert{
@@ -123,23 +123,23 @@ func createAlertCmdRun(cmd *cobra.Command, args []string) error {
return err
}
- logger.Actionf("applying alert")
- if err := upsertAlert(ctx, kubeClient, alert); err != nil {
+ logger.Actionf("applying Alert")
+ namespacedName, err := upsertAlert(ctx, kubeClient, &alert)
+ if err != nil {
return err
}
- logger.Waitingf("waiting for reconciliation")
+ logger.Waitingf("waiting for Alert reconciliation")
if err := wait.PollImmediate(pollInterval, timeout,
- isAlertReady(ctx, kubeClient, name, namespace)); err != nil {
+ isAlertReady(ctx, kubeClient, namespacedName, &alert)); err != nil {
return err
}
-
- logger.Successf("alert %s is ready", name)
-
+ logger.Successf("Alert %s is ready", name)
return nil
}
-func upsertAlert(ctx context.Context, kubeClient client.Client, alert notificationv1.Alert) error {
+func upsertAlert(ctx context.Context, kubeClient client.Client,
+ alert *notificationv1.Alert) (types.NamespacedName, error) {
namespacedName := types.NamespacedName{
Namespace: alert.GetNamespace(),
Name: alert.GetName(),
@@ -149,35 +149,30 @@ func upsertAlert(ctx context.Context, kubeClient client.Client, alert notificati
err := kubeClient.Get(ctx, namespacedName, &existing)
if err != nil {
if errors.IsNotFound(err) {
- if err := kubeClient.Create(ctx, &alert); err != nil {
- return err
+ if err := kubeClient.Create(ctx, alert); err != nil {
+ return namespacedName, err
} else {
- logger.Successf("alert created")
- return nil
+ logger.Successf("Alert created")
+ return namespacedName, nil
}
}
- return err
+ return namespacedName, err
}
existing.Labels = alert.Labels
existing.Spec = alert.Spec
if err := kubeClient.Update(ctx, &existing); err != nil {
- return err
+ return namespacedName, err
}
-
- logger.Successf("alert updated")
- return nil
+ alert = &existing
+ logger.Successf("Alert updated")
+ return namespacedName, nil
}
-func isAlertReady(ctx context.Context, kubeClient client.Client, name, namespace string) wait.ConditionFunc {
+func isAlertReady(ctx context.Context, kubeClient client.Client,
+ namespacedName types.NamespacedName, alert *notificationv1.Alert) wait.ConditionFunc {
return func() (bool, error) {
- var alert notificationv1.Alert
- namespacedName := types.NamespacedName{
- Namespace: namespace,
- Name: name,
- }
-
- err := kubeClient.Get(ctx, namespacedName, &alert)
+ err := kubeClient.Get(ctx, namespacedName, alert)
if err != nil {
return false, err
}
diff --git a/cmd/gotk/create_alertprovider.go b/cmd/gotk/create_alertprovider.go
index a5e8b5318bf3611562bf116592d45a85a8d15634..9c28782ea6e931f12d32be85a2baba9289472913 100644
--- a/cmd/gotk/create_alertprovider.go
+++ b/cmd/gotk/create_alertprovider.go
@@ -71,12 +71,12 @@ func init() {
func createAlertProviderCmdRun(cmd *cobra.Command, args []string) error {
if len(args) < 1 {
- return fmt.Errorf("provider name is required")
+ return fmt.Errorf("Provider name is required")
}
name := args[0]
if apType == "" {
- return fmt.Errorf("type is required")
+ return fmt.Errorf("Provider type is required")
}
sourceLabels, err := parseLabels()
@@ -85,10 +85,10 @@ func createAlertProviderCmdRun(cmd *cobra.Command, args []string) error {
}
if !export {
- logger.Generatef("generating provider")
+ logger.Generatef("generating Provider")
}
- alertProvider := notificationv1.Provider{
+ provider := notificationv1.Provider{
ObjectMeta: metav1.ObjectMeta{
Name: name,
Namespace: namespace,
@@ -103,13 +103,13 @@ func createAlertProviderCmdRun(cmd *cobra.Command, args []string) error {
}
if apSecretRef != "" {
- alertProvider.Spec.SecretRef = &corev1.LocalObjectReference{
+ provider.Spec.SecretRef = &corev1.LocalObjectReference{
Name: apSecretRef,
}
}
if export {
- return exportAlertProvider(alertProvider)
+ return exportAlertProvider(provider)
}
ctx, cancel := context.WithTimeout(context.Background(), timeout)
@@ -120,66 +120,63 @@ func createAlertProviderCmdRun(cmd *cobra.Command, args []string) error {
return err
}
- logger.Actionf("applying provider")
- if err := upsertAlertProvider(ctx, kubeClient, alertProvider); err != nil {
+ logger.Actionf("applying Provider")
+ namespacedName, err := upsertAlertProvider(ctx, kubeClient, &provider)
+ if err != nil {
return err
}
- logger.Waitingf("waiting for reconciliation")
+ logger.Waitingf("waiting for Provider reconciliation")
if err := wait.PollImmediate(pollInterval, timeout,
- isAlertProviderReady(ctx, kubeClient, name, namespace)); err != nil {
+ isAlertProviderReady(ctx, kubeClient, namespacedName, &provider)); err != nil {
return err
}
- logger.Successf("provider %s is ready", name)
+ logger.Successf("Provider %s is ready", name)
return nil
}
-func upsertAlertProvider(ctx context.Context, kubeClient client.Client, alertProvider notificationv1.Provider) error {
+func upsertAlertProvider(ctx context.Context, kubeClient client.Client,
+ provider *notificationv1.Provider) (types.NamespacedName, error) {
namespacedName := types.NamespacedName{
- Namespace: alertProvider.GetNamespace(),
- Name: alertProvider.GetName(),
+ Namespace: provider.GetNamespace(),
+ Name: provider.GetName(),
}
var existing notificationv1.Provider
err := kubeClient.Get(ctx, namespacedName, &existing)
if err != nil {
if errors.IsNotFound(err) {
- if err := kubeClient.Create(ctx, &alertProvider); err != nil {
- return err
+ if err := kubeClient.Create(ctx, provider); err != nil {
+ return namespacedName, err
} else {
- logger.Successf("provider created")
- return nil
+ logger.Successf("Provider created")
+ return namespacedName, nil
}
}
- return err
+ return namespacedName, err
}
- existing.Labels = alertProvider.Labels
- existing.Spec = alertProvider.Spec
+ existing.Labels = provider.Labels
+ existing.Spec = provider.Spec
if err := kubeClient.Update(ctx, &existing); err != nil {
- return err
+ return namespacedName, err
}
-
- logger.Successf("provider updated")
- return nil
+ provider = &existing
+ logger.Successf("Provider updated")
+ return namespacedName, nil
}
-func isAlertProviderReady(ctx context.Context, kubeClient client.Client, name, namespace string) wait.ConditionFunc {
+func isAlertProviderReady(ctx context.Context, kubeClient client.Client,
+ namespacedName types.NamespacedName, provider *notificationv1.Provider) wait.ConditionFunc {
return func() (bool, error) {
- var alertProvider notificationv1.Provider
- namespacedName := types.NamespacedName{
- Namespace: namespace,
- Name: name,
- }
-
- err := kubeClient.Get(ctx, namespacedName, &alertProvider)
+ err := kubeClient.Get(ctx, namespacedName, provider)
if err != nil {
return false, err
}
- if c := meta.GetCondition(alertProvider.Status.Conditions, meta.ReadyCondition); c != nil {
+ if c := meta.GetCondition(provider.Status.Conditions, meta.ReadyCondition); c != nil {
switch c.Status {
case corev1.ConditionTrue:
return true, nil
diff --git a/cmd/gotk/create_helmrelease.go b/cmd/gotk/create_helmrelease.go
index 7dd6cbeabf2714c64ddc2ff029891592d0e03f5c..8d77ad312a011e1c08a7f9b468ea4ab32e110425 100644
--- a/cmd/gotk/create_helmrelease.go
+++ b/cmd/gotk/create_helmrelease.go
@@ -19,14 +19,13 @@ package main
import (
"context"
"fmt"
- "github.com/fluxcd/pkg/apis/meta"
"io/ioutil"
+ "github.com/fluxcd/pkg/apis/meta"
+
"github.com/spf13/cobra"
- corev1 "k8s.io/api/core/v1"
apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
"k8s.io/apimachinery/pkg/api/errors"
- apierrors "k8s.io/apimachinery/pkg/api/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/types"
"k8s.io/apimachinery/pkg/util/wait"
@@ -34,7 +33,6 @@ import (
"sigs.k8s.io/yaml"
helmv2 "github.com/fluxcd/helm-controller/api/v2beta1"
- sourcev1 "github.com/fluxcd/source-controller/api/v1beta1"
)
var createHelmReleaseCmd = &cobra.Command{
@@ -100,7 +98,7 @@ var (
)
func init() {
- createHelmReleaseCmd.Flags().StringVar(&hrName, "release-name", "", "name used for the Helm release, defaults to a composition of '[<target-namespace>-]<hr-name>'")
+ createHelmReleaseCmd.Flags().StringVar(&hrName, "release-name", "", "name used for the Helm release, defaults to a composition of '[<target-namespace>-]<HelmRelease-name>'")
createHelmReleaseCmd.Flags().StringVar(&hrSource, "source", "", "source that contains the chart (<kind>/<name>)")
createHelmReleaseCmd.Flags().StringVar(&hrChart, "chart", "", "Helm chart name or path")
createHelmReleaseCmd.Flags().StringVar(&hrChartVersion, "chart-version", "", "Helm chart version, accepts a semver range (ignored for charts from GitRepository sources)")
@@ -112,7 +110,7 @@ func init() {
func createHelmReleaseCmdRun(cmd *cobra.Command, args []string) error {
if len(args) < 1 {
- return fmt.Errorf("release name is required")
+ return fmt.Errorf("HelmRelease name is required")
}
name := args[0]
@@ -137,7 +135,7 @@ func createHelmReleaseCmdRun(cmd *cobra.Command, args []string) error {
}
if !export {
- logger.Generatef("generating release")
+ logger.Generatef("generating HelmRelease")
}
helmRelease := helmv2.HelmRelease{
@@ -193,43 +191,25 @@ func createHelmReleaseCmdRun(cmd *cobra.Command, args []string) error {
return err
}
- logger.Actionf("applying release")
- if err := upsertHelmRelease(ctx, kubeClient, helmRelease); err != nil {
+ logger.Actionf("applying HelmRelease")
+ namespacedName, err := upsertHelmRelease(ctx, kubeClient, &helmRelease)
+ if err != nil {
return err
}
- logger.Waitingf("waiting for reconciliation")
- chartName := fmt.Sprintf("%s-%s", namespace, name)
- if err := wait.PollImmediate(pollInterval, timeout,
- isHelmChartReady(ctx, kubeClient, chartName, namespace)); err != nil {
- return err
- }
+ logger.Waitingf("waiting for HelmRelease reconciliation")
if err := wait.PollImmediate(pollInterval, timeout,
- isHelmReleaseReady(ctx, kubeClient, name, namespace)); err != nil {
+ isHelmReleaseReady(ctx, kubeClient, namespacedName, &helmRelease)); err != nil {
return err
}
+ logger.Successf("HelmRelease %s is ready", name)
- logger.Successf("release %s is ready", name)
-
- namespacedName := types.NamespacedName{
- Namespace: namespace,
- Name: name,
- }
- err = kubeClient.Get(ctx, namespacedName, &helmRelease)
- if err != nil {
- return fmt.Errorf("release failed: %w", err)
- }
-
- if helmRelease.Status.LastAppliedRevision != "" {
- logger.Successf("applied revision %s", helmRelease.Status.LastAppliedRevision)
- } else {
- return fmt.Errorf("reconciliation failed")
- }
-
+ logger.Successf("applied revision %s", helmRelease.Status.LastAppliedRevision)
return nil
}
-func upsertHelmRelease(ctx context.Context, kubeClient client.Client, helmRelease helmv2.HelmRelease) error {
+func upsertHelmRelease(ctx context.Context, kubeClient client.Client,
+ helmRelease *helmv2.HelmRelease) (types.NamespacedName, error) {
namespacedName := types.NamespacedName{
Namespace: helmRelease.GetNamespace(),
Name: helmRelease.GetName(),
@@ -239,75 +219,39 @@ func upsertHelmRelease(ctx context.Context, kubeClient client.Client, helmReleas
err := kubeClient.Get(ctx, namespacedName, &existing)
if err != nil {
if errors.IsNotFound(err) {
- if err := kubeClient.Create(ctx, &helmRelease); err != nil {
- return err
+ if err := kubeClient.Create(ctx, helmRelease); err != nil {
+ return namespacedName, err
} else {
- logger.Successf("release created")
- return nil
+ logger.Successf("HelmRelease created")
+ return namespacedName, nil
}
}
- return err
+ return namespacedName, err
}
existing.Labels = helmRelease.Labels
existing.Spec = helmRelease.Spec
if err := kubeClient.Update(ctx, &existing); err != nil {
- return err
+ return namespacedName, err
}
-
- logger.Successf("release updated")
- return nil
+ helmRelease = &existing
+ logger.Successf("HelmRelease updated")
+ return namespacedName, nil
}
-func isHelmChartReady(ctx context.Context, kubeClient client.Client, name, namespace string) wait.ConditionFunc {
+func isHelmReleaseReady(ctx context.Context, kubeClient client.Client,
+ namespacedName types.NamespacedName, helmRelease *helmv2.HelmRelease) wait.ConditionFunc {
return func() (bool, error) {
- var helmChart sourcev1.HelmChart
- namespacedName := types.NamespacedName{
- Namespace: namespace,
- Name: name,
- }
-
- err := kubeClient.Get(ctx, namespacedName, &helmChart)
+ err := kubeClient.Get(ctx, namespacedName, helmRelease)
if err != nil {
- if apierrors.IsNotFound(err) {
- return false, nil
- }
return false, err
}
- if c := meta.GetCondition(helmChart.Status.Conditions, meta.ReadyCondition); c != nil {
- switch c.Status {
- case corev1.ConditionTrue:
- return true, nil
- case corev1.ConditionFalse:
- return false, fmt.Errorf(c.Message)
- }
+ // Confirm the state we are observing is for the current generation
+ if helmRelease.Generation != helmRelease.Status.ObservedGeneration {
+ return false, nil
}
- return false, nil
- }
-}
-func isHelmReleaseReady(ctx context.Context, kubeClient client.Client, name, namespace string) wait.ConditionFunc {
- return func() (bool, error) {
- var helmRelease helmv2.HelmRelease
- namespacedName := types.NamespacedName{
- Namespace: namespace,
- Name: name,
- }
-
- err := kubeClient.Get(ctx, namespacedName, &helmRelease)
- if err != nil {
- return false, err
- }
-
- if c := meta.GetCondition(helmRelease.Status.Conditions, meta.ReadyCondition); c != nil {
- switch c.Status {
- case corev1.ConditionTrue:
- return true, nil
- case corev1.ConditionFalse:
- return false, fmt.Errorf(c.Message)
- }
- }
- return false, nil
+ return meta.HasReadyCondition(helmRelease.Status.Conditions), nil
}
}
diff --git a/cmd/gotk/create_kustomization.go b/cmd/gotk/create_kustomization.go
index e4df9b767f36ba8577c79d5b81eee24280f8e903..d3fdd0c6be30606094765cbedc82a1a98578aa96 100644
--- a/cmd/gotk/create_kustomization.go
+++ b/cmd/gotk/create_kustomization.go
@@ -102,7 +102,7 @@ func init() {
func createKsCmdRun(cmd *cobra.Command, args []string) error {
if len(args) < 1 {
- return fmt.Errorf("kustomization name is required")
+ return fmt.Errorf("Kustomization name is required")
}
name := args[0]
@@ -127,7 +127,7 @@ func createKsCmdRun(cmd *cobra.Command, args []string) error {
}
if !export {
- logger.Generatef("generating kustomization")
+ logger.Generatef("generating Kustomization")
}
ksLabels, err := parseLabels()
@@ -232,38 +232,25 @@ func createKsCmdRun(cmd *cobra.Command, args []string) error {
return err
}
- logger.Actionf("applying kustomization")
- if err := upsertKustomization(ctx, kubeClient, kustomization); err != nil {
+ logger.Actionf("applying Kustomization")
+ namespacedName, err := upsertKustomization(ctx, kubeClient, &kustomization)
+ if err != nil {
return err
}
- logger.Waitingf("waiting for kustomization sync")
+ logger.Waitingf("waiting for Kustomization reconciliation")
if err := wait.PollImmediate(pollInterval, timeout,
- isKustomizationReady(ctx, kubeClient, name, namespace)); err != nil {
+ isKustomizationReady(ctx, kubeClient, namespacedName, &kustomization)); err != nil {
return err
}
+ logger.Successf("Kustomization %s is ready", name)
- logger.Successf("kustomization %s is ready", name)
-
- namespacedName := types.NamespacedName{
- Namespace: namespace,
- Name: name,
- }
- err = kubeClient.Get(ctx, namespacedName, &kustomization)
- if err != nil {
- return fmt.Errorf("kustomization sync failed: %w", err)
- }
-
- if kustomization.Status.LastAppliedRevision != "" {
- logger.Successf("applied revision %s", kustomization.Status.LastAppliedRevision)
- } else {
- return fmt.Errorf("kustomization sync failed")
- }
-
+ logger.Successf("applied revision %s", kustomization.Status.LastAppliedRevision)
return nil
}
-func upsertKustomization(ctx context.Context, kubeClient client.Client, kustomization kustomizev1.Kustomization) error {
+func upsertKustomization(ctx context.Context, kubeClient client.Client,
+ kustomization *kustomizev1.Kustomization) (types.NamespacedName, error) {
namespacedName := types.NamespacedName{
Namespace: kustomization.GetNamespace(),
Name: kustomization.GetName(),
@@ -273,39 +260,39 @@ func upsertKustomization(ctx context.Context, kubeClient client.Client, kustomiz
err := kubeClient.Get(ctx, namespacedName, &existing)
if err != nil {
if errors.IsNotFound(err) {
- if err := kubeClient.Create(ctx, &kustomization); err != nil {
- return err
+ if err := kubeClient.Create(ctx, kustomization); err != nil {
+ return namespacedName, err
} else {
- logger.Successf("kustomization created")
- return nil
+ logger.Successf("Kustomization created")
+ return namespacedName, nil
}
}
- return err
+ return namespacedName, err
}
existing.Labels = kustomization.Labels
existing.Spec = kustomization.Spec
if err := kubeClient.Update(ctx, &existing); err != nil {
- return err
+ return namespacedName, err
}
-
- logger.Successf("kustomization updated")
- return nil
+ kustomization = &existing
+ logger.Successf("Kustomization updated")
+ return namespacedName, nil
}
-func isKustomizationReady(ctx context.Context, kubeClient client.Client, name, namespace string) wait.ConditionFunc {
+func isKustomizationReady(ctx context.Context, kubeClient client.Client,
+ namespacedName types.NamespacedName, kustomization *kustomizev1.Kustomization) wait.ConditionFunc {
return func() (bool, error) {
- var kustomization kustomizev1.Kustomization
- namespacedName := types.NamespacedName{
- Namespace: namespace,
- Name: name,
- }
-
- err := kubeClient.Get(ctx, namespacedName, &kustomization)
+ err := kubeClient.Get(ctx, namespacedName, kustomization)
if err != nil {
return false, err
}
+ // Confirm the state we are observing is for the current generation
+ if kustomization.Generation != kustomization.Status.ObservedGeneration {
+ return false, nil
+ }
+
if c := meta.GetCondition(kustomization.Status.Conditions, meta.ReadyCondition); c != nil {
switch c.Status {
case corev1.ConditionTrue:
diff --git a/cmd/gotk/create_receiver.go b/cmd/gotk/create_receiver.go
index 367cd6a520108d4016aa3ea394b8f36b824c3422..08595bfe0206bf9f8b78f256e753f55cef152c2d 100644
--- a/cmd/gotk/create_receiver.go
+++ b/cmd/gotk/create_receiver.go
@@ -65,12 +65,12 @@ func init() {
func createReceiverCmdRun(cmd *cobra.Command, args []string) error {
if len(args) < 1 {
- return fmt.Errorf("receiver name is required")
+ return fmt.Errorf("Receiver name is required")
}
name := args[0]
if rcvType == "" {
- return fmt.Errorf("type is required")
+ return fmt.Errorf("Receiver type is required")
}
if rcvSecretRef == "" {
@@ -100,7 +100,7 @@ func createReceiverCmdRun(cmd *cobra.Command, args []string) error {
}
if !export {
- logger.Generatef("generating receiver")
+ logger.Generatef("generating Receiver")
}
receiver := notificationv1.Receiver{
@@ -132,34 +132,25 @@ func createReceiverCmdRun(cmd *cobra.Command, args []string) error {
return err
}
- logger.Actionf("applying receiver")
- if err := upsertReceiver(ctx, kubeClient, receiver); err != nil {
+ logger.Actionf("applying Receiver")
+ namespacedName, err := upsertReceiver(ctx, kubeClient, &receiver)
+ if err != nil {
return err
}
- logger.Waitingf("waiting for reconciliation")
+ logger.Waitingf("waiting for Receiver reconciliation")
if err := wait.PollImmediate(pollInterval, timeout,
- isReceiverReady(ctx, kubeClient, name, namespace)); err != nil {
+ isReceiverReady(ctx, kubeClient, namespacedName, &receiver)); err != nil {
return err
}
-
- logger.Successf("receiver %s is ready", name)
-
- namespacedName := types.NamespacedName{
- Namespace: namespace,
- Name: name,
- }
- err = kubeClient.Get(ctx, namespacedName, &receiver)
- if err != nil {
- return fmt.Errorf("receiver sync failed: %w", err)
- }
+ logger.Successf("Receiver %s is ready", name)
logger.Successf("generated webhook URL %s", receiver.Status.URL)
-
return nil
}
-func upsertReceiver(ctx context.Context, kubeClient client.Client, receiver notificationv1.Receiver) error {
+func upsertReceiver(ctx context.Context, kubeClient client.Client,
+ receiver *notificationv1.Receiver) (types.NamespacedName, error) {
namespacedName := types.NamespacedName{
Namespace: receiver.GetNamespace(),
Name: receiver.GetName(),
@@ -169,35 +160,30 @@ func upsertReceiver(ctx context.Context, kubeClient client.Client, receiver noti
err := kubeClient.Get(ctx, namespacedName, &existing)
if err != nil {
if errors.IsNotFound(err) {
- if err := kubeClient.Create(ctx, &receiver); err != nil {
- return err
+ if err := kubeClient.Create(ctx, receiver); err != nil {
+ return namespacedName, err
} else {
- logger.Successf("receiver created")
- return nil
+ logger.Successf("Receiver created")
+ return namespacedName, nil
}
}
- return err
+ return namespacedName, err
}
existing.Labels = receiver.Labels
existing.Spec = receiver.Spec
if err := kubeClient.Update(ctx, &existing); err != nil {
- return err
+ return namespacedName, err
}
-
- logger.Successf("receiver updated")
- return nil
+ receiver = &existing
+ logger.Successf("Receiver updated")
+ return namespacedName, nil
}
-func isReceiverReady(ctx context.Context, kubeClient client.Client, name, namespace string) wait.ConditionFunc {
+func isReceiverReady(ctx context.Context, kubeClient client.Client,
+ namespacedName types.NamespacedName, receiver *notificationv1.Receiver) wait.ConditionFunc {
return func() (bool, error) {
- var receiver notificationv1.Receiver
- namespacedName := types.NamespacedName{
- Namespace: namespace,
- Name: name,
- }
-
- err := kubeClient.Get(ctx, namespacedName, &receiver)
+ err := kubeClient.Get(ctx, namespacedName, receiver)
if err != nil {
return false, err
}
diff --git a/cmd/gotk/create_source_bucket.go b/cmd/gotk/create_source_bucket.go
index 254bd5849cd5b7ad4db6cb91d8203300a040fc6d..32a06ea100902ee38bc7e4bd8cfec651724e45fd 100644
--- a/cmd/gotk/create_source_bucket.go
+++ b/cmd/gotk/create_source_bucket.go
@@ -83,13 +83,13 @@ func init() {
func createSourceBucketCmdRun(cmd *cobra.Command, args []string) error {
if len(args) < 1 {
- return fmt.Errorf("source name is required")
+ return fmt.Errorf("Bucket source name is required")
}
name := args[0]
secretName := fmt.Sprintf("bucket-%s", name)
if !utils.containsItemString(supportedSourceBucketProviders, sourceBucketProvider) {
- return fmt.Errorf("bucket provider %s is not supported, can be %v",
+ return fmt.Errorf("Bucket provider %s is not supported, can be %v",
sourceBucketProvider, supportedSourceBucketProviders)
}
@@ -112,7 +112,7 @@ func createSourceBucketCmdRun(cmd *cobra.Command, args []string) error {
}
defer os.RemoveAll(tmpDir)
- bucket := sourcev1.Bucket{
+ bucket := &sourcev1.Bucket{
ObjectMeta: metav1.ObjectMeta{
Name: name,
Namespace: namespace,
@@ -131,7 +131,7 @@ func createSourceBucketCmdRun(cmd *cobra.Command, args []string) error {
}
if export {
- return exportBucket(bucket)
+ return exportBucket(*bucket)
}
ctx, cancel := context.WithTimeout(context.Background(), timeout)
@@ -142,7 +142,7 @@ func createSourceBucketCmdRun(cmd *cobra.Command, args []string) error {
return err
}
- logger.Generatef("generating source")
+ logger.Generatef("generating Bucket source")
secret := corev1.Secret{
ObjectMeta: metav1.ObjectMeta{
@@ -168,38 +168,28 @@ func createSourceBucketCmdRun(cmd *cobra.Command, args []string) error {
logger.Successf("authentication configured")
}
- logger.Actionf("applying source")
- if err := upsertBucket(ctx, kubeClient, bucket); err != nil {
+ logger.Actionf("applying Bucket source")
+ namespacedName, err := upsertBucket(ctx, kubeClient, bucket)
+ if err != nil {
return err
}
- logger.Waitingf("waiting for download")
+ logger.Waitingf("waiting for Bucket source reconciliation")
if err := wait.PollImmediate(pollInterval, timeout,
- isBucketReady(ctx, kubeClient, name, namespace)); err != nil {
+ isBucketReady(ctx, kubeClient, namespacedName, bucket)); err != nil {
return err
}
+ logger.Successf("Bucket source reconciliation completed")
- logger.Successf("download completed")
-
- namespacedName := types.NamespacedName{
- Namespace: namespace,
- Name: name,
- }
- err = kubeClient.Get(ctx, namespacedName, &bucket)
- if err != nil {
- return fmt.Errorf("could not retrieve bucket: %w", err)
- }
-
- if bucket.Status.Artifact != nil {
- logger.Successf("fetched revision: %s", bucket.Status.Artifact.Revision)
- } else {
- return fmt.Errorf("download failed, artifact not found")
+ if bucket.Status.Artifact == nil {
+ return fmt.Errorf("Bucket source reconciliation but no artifact was found")
}
-
+ logger.Successf("fetched revision: %s", bucket.Status.Artifact.Revision)
return nil
}
-func upsertBucket(ctx context.Context, kubeClient client.Client, bucket sourcev1.Bucket) error {
+func upsertBucket(ctx context.Context, kubeClient client.Client,
+ bucket *sourcev1.Bucket) (types.NamespacedName, error) {
namespacedName := types.NamespacedName{
Namespace: bucket.GetNamespace(),
Name: bucket.GetName(),
@@ -209,22 +199,22 @@ func upsertBucket(ctx context.Context, kubeClient client.Client, bucket sourcev1
err := kubeClient.Get(ctx, namespacedName, &existing)
if err != nil {
if errors.IsNotFound(err) {
- if err := kubeClient.Create(ctx, &bucket); err != nil {
- return err
+ if err := kubeClient.Create(ctx, bucket); err != nil {
+ return namespacedName, err
} else {
- logger.Successf("source created")
- return nil
+ logger.Successf("Bucket source created")
+ return namespacedName, nil
}
}
- return err
+ return namespacedName, err
}
existing.Labels = bucket.Labels
existing.Spec = bucket.Spec
if err := kubeClient.Update(ctx, &existing); err != nil {
- return err
+ return namespacedName, err
}
-
- logger.Successf("source updated")
- return nil
+ bucket = &existing
+ logger.Successf("Bucket source updated")
+ return namespacedName, nil
}
diff --git a/cmd/gotk/create_source_git.go b/cmd/gotk/create_source_git.go
index 86831ec90fded788a0460cdce859325ffbdd40b3..ad78484134345632e14832a7c979814c25df55eb 100644
--- a/cmd/gotk/create_source_git.go
+++ b/cmd/gotk/create_source_git.go
@@ -111,7 +111,7 @@ func init() {
func createSourceGitCmdRun(cmd *cobra.Command, args []string) error {
if len(args) < 1 {
- return fmt.Errorf("source name is required")
+ return fmt.Errorf("GitRepository source name is required")
}
name := args[0]
@@ -234,7 +234,7 @@ func createSourceGitCmdRun(cmd *cobra.Command, args []string) error {
logger.Successf("authentication configured")
}
- logger.Generatef("generating source")
+ logger.Generatef("generating GitRepository source")
if withAuth {
gitRepository.Spec.SecretRef = &corev1.LocalObjectReference{
@@ -242,34 +242,23 @@ func createSourceGitCmdRun(cmd *cobra.Command, args []string) error {
}
}
- logger.Actionf("applying source")
- if err := upsertGitRepository(ctx, kubeClient, gitRepository); err != nil {
+ logger.Actionf("applying GitRepository source")
+ namespacedName, err := upsertGitRepository(ctx, kubeClient, &gitRepository)
+ if err != nil {
return err
}
- logger.Waitingf("waiting for git sync")
+ logger.Waitingf("waiting for GitRepository source reconciliation")
if err := wait.PollImmediate(pollInterval, timeout,
- isGitRepositoryReady(ctx, kubeClient, name, namespace)); err != nil {
+ isGitRepositoryReady(ctx, kubeClient, namespacedName, &gitRepository)); err != nil {
return err
}
+ logger.Successf("GitRepository source reconciliation completed")
- logger.Successf("git sync completed")
-
- namespacedName := types.NamespacedName{
- Namespace: namespace,
- Name: name,
- }
- err = kubeClient.Get(ctx, namespacedName, &gitRepository)
- if err != nil {
- return fmt.Errorf("git sync failed: %w", err)
- }
-
- if gitRepository.Status.Artifact != nil {
- logger.Successf("fetched revision: %s", gitRepository.Status.Artifact.Revision)
- } else {
- return fmt.Errorf("git sync failed, artifact not found")
+ if gitRepository.Status.Artifact == nil {
+ return fmt.Errorf("GitRepository source reconciliation completed but no artifact was found")
}
-
+ logger.Successf("fetched revision: %s", gitRepository.Status.Artifact.Revision)
return nil
}
@@ -330,7 +319,8 @@ func upsertSecret(ctx context.Context, kubeClient client.Client, secret corev1.S
return nil
}
-func upsertGitRepository(ctx context.Context, kubeClient client.Client, gitRepository sourcev1.GitRepository) error {
+func upsertGitRepository(ctx context.Context, kubeClient client.Client,
+ gitRepository *sourcev1.GitRepository) (types.NamespacedName, error) {
namespacedName := types.NamespacedName{
Namespace: gitRepository.GetNamespace(),
Name: gitRepository.GetName(),
@@ -340,35 +330,30 @@ func upsertGitRepository(ctx context.Context, kubeClient client.Client, gitRepos
err := kubeClient.Get(ctx, namespacedName, &existing)
if err != nil {
if errors.IsNotFound(err) {
- if err := kubeClient.Create(ctx, &gitRepository); err != nil {
- return err
+ if err := kubeClient.Create(ctx, gitRepository); err != nil {
+ return namespacedName, err
} else {
- logger.Successf("source created")
- return nil
+ logger.Successf("GitRepository source created")
+ return namespacedName, nil
}
}
- return err
+ return namespacedName, err
}
existing.Labels = gitRepository.Labels
existing.Spec = gitRepository.Spec
if err := kubeClient.Update(ctx, &existing); err != nil {
- return err
+ return namespacedName, err
}
-
- logger.Successf("source updated")
- return nil
+ gitRepository = &existing
+ logger.Successf("GitRepository source updated")
+ return namespacedName, nil
}
-func isGitRepositoryReady(ctx context.Context, kubeClient client.Client, name, namespace string) wait.ConditionFunc {
+func isGitRepositoryReady(ctx context.Context, kubeClient client.Client,
+ namespacedName types.NamespacedName, gitRepository *sourcev1.GitRepository) wait.ConditionFunc {
return func() (bool, error) {
- var gitRepository sourcev1.GitRepository
- namespacedName := types.NamespacedName{
- Namespace: namespace,
- Name: name,
- }
-
- err := kubeClient.Get(ctx, namespacedName, &gitRepository)
+ err := kubeClient.Get(ctx, namespacedName, gitRepository)
if err != nil {
return false, err
}
diff --git a/cmd/gotk/create_source_helm.go b/cmd/gotk/create_source_helm.go
index 4ebf81bf371fa872544db7d5ed25b97ff46d9db2..bc6c9a081f28cd1fa3f8d4b6d5c71cf7d070512e 100644
--- a/cmd/gotk/create_source_helm.go
+++ b/cmd/gotk/create_source_helm.go
@@ -83,7 +83,7 @@ func init() {
func createSourceHelmCmdRun(cmd *cobra.Command, args []string) error {
if len(args) < 1 {
- return fmt.Errorf("source name is required")
+ return fmt.Errorf("HelmRepository source name is required")
}
name := args[0]
secretName := fmt.Sprintf("helm-%s", name)
@@ -107,7 +107,7 @@ func createSourceHelmCmdRun(cmd *cobra.Command, args []string) error {
return fmt.Errorf("url parse failed: %w", err)
}
- helmRepository := sourcev1.HelmRepository{
+ helmRepository := &sourcev1.HelmRepository{
ObjectMeta: metav1.ObjectMeta{
Name: name,
Namespace: namespace,
@@ -122,7 +122,7 @@ func createSourceHelmCmdRun(cmd *cobra.Command, args []string) error {
}
if export {
- return exportHelmRepository(helmRepository)
+ return exportHelmRepository(*helmRepository)
}
ctx, cancel := context.WithTimeout(context.Background(), timeout)
@@ -133,7 +133,7 @@ func createSourceHelmCmdRun(cmd *cobra.Command, args []string) error {
return err
}
- logger.Generatef("generating source")
+ logger.Generatef("generating HelmRepository source")
secret := corev1.Secret{
ObjectMeta: metav1.ObjectMeta{
@@ -181,38 +181,28 @@ func createSourceHelmCmdRun(cmd *cobra.Command, args []string) error {
logger.Successf("authentication configured")
}
- logger.Actionf("applying source")
- if err := upsertHelmRepository(ctx, kubeClient, helmRepository); err != nil {
+ logger.Actionf("applying HelmRepository source")
+ namespacedName, err := upsertHelmRepository(ctx, kubeClient, helmRepository)
+ if err != nil {
return err
}
- logger.Waitingf("waiting for index download")
+ logger.Waitingf("waiting for HelmRepository source reconciliation")
if err := wait.PollImmediate(pollInterval, timeout,
- isHelmRepositoryReady(ctx, kubeClient, name, namespace)); err != nil {
+ isHelmRepositoryReady(ctx, kubeClient, namespacedName, helmRepository)); err != nil {
return err
}
+ logger.Successf("HelmRepository source reconciliation completed")
- logger.Successf("index download completed")
-
- namespacedName := types.NamespacedName{
- Namespace: namespace,
- Name: name,
- }
- err = kubeClient.Get(ctx, namespacedName, &helmRepository)
- if err != nil {
- return fmt.Errorf("helm index failed: %w", err)
- }
-
- if helmRepository.Status.Artifact != nil {
- logger.Successf("fetched revision: %s", helmRepository.Status.Artifact.Revision)
- } else {
- return fmt.Errorf("index download failed, artifact not found")
+ if helmRepository.Status.Artifact == nil {
+ return fmt.Errorf("HelmRepository source reconciliation completed but no artifact was found")
}
-
+ logger.Successf("fetched revision: %s", helmRepository.Status.Artifact.Revision)
return nil
}
-func upsertHelmRepository(ctx context.Context, kubeClient client.Client, helmRepository sourcev1.HelmRepository) error {
+func upsertHelmRepository(ctx context.Context, kubeClient client.Client,
+ helmRepository *sourcev1.HelmRepository) (types.NamespacedName, error) {
namespacedName := types.NamespacedName{
Namespace: helmRepository.GetNamespace(),
Name: helmRepository.GetName(),
@@ -222,22 +212,22 @@ func upsertHelmRepository(ctx context.Context, kubeClient client.Client, helmRep
err := kubeClient.Get(ctx, namespacedName, &existing)
if err != nil {
if errors.IsNotFound(err) {
- if err := kubeClient.Create(ctx, &helmRepository); err != nil {
- return err
+ if err := kubeClient.Create(ctx, helmRepository); err != nil {
+ return namespacedName, err
} else {
logger.Successf("source created")
- return nil
+ return namespacedName, nil
}
}
- return err
+ return namespacedName, err
}
existing.Labels = helmRepository.Labels
existing.Spec = helmRepository.Spec
if err := kubeClient.Update(ctx, &existing); err != nil {
- return err
+ return namespacedName, err
}
-
+ helmRepository = &existing
logger.Successf("source updated")
- return nil
+ return namespacedName, nil
}
diff --git a/cmd/gotk/reconcile_alert.go b/cmd/gotk/reconcile_alert.go
index 6d29afda623781dd1661d92a798b35c0198b6396..fc6e56db0eab2f00854946b1b582fc4dfbd568d4 100644
--- a/cmd/gotk/reconcile_alert.go
+++ b/cmd/gotk/reconcile_alert.go
@@ -45,7 +45,7 @@ func init() {
func reconcileAlertCmdRun(cmd *cobra.Command, args []string) error {
if len(args) < 1 {
- return fmt.Errorf("alert name is required")
+ return fmt.Errorf("Alert name is required")
}
name := args[0]
@@ -62,7 +62,7 @@ func reconcileAlertCmdRun(cmd *cobra.Command, args []string) error {
Name: name,
}
- logger.Actionf("annotating alert %s in %s namespace", name, namespace)
+ logger.Actionf("annotating Alert %s in %s namespace", name, namespace)
var alert notificationv1.Alert
err = kubeClient.Get(ctx, namespacedName, &alert)
if err != nil {
@@ -79,15 +79,13 @@ func reconcileAlertCmdRun(cmd *cobra.Command, args []string) error {
if err := kubeClient.Update(ctx, &alert); err != nil {
return err
}
- logger.Successf("alert annotated")
+ logger.Successf("Alert annotated")
logger.Waitingf("waiting for reconciliation")
if err := wait.PollImmediate(pollInterval, timeout,
- isAlertReady(ctx, kubeClient, name, namespace)); err != nil {
+ isAlertReady(ctx, kubeClient, namespacedName, &alert)); err != nil {
return err
}
-
- logger.Successf("alert reconciliation completed")
-
+ logger.Successf("Alert reconciliation completed")
return nil
}
diff --git a/cmd/gotk/reconcile_alertprovider.go b/cmd/gotk/reconcile_alertprovider.go
index 15194f79f28b5f2c117b4f1d65aed77cdbc5365d..c8f4e9efed935d7d327af0d22369827d93e5c700 100644
--- a/cmd/gotk/reconcile_alertprovider.go
+++ b/cmd/gotk/reconcile_alertprovider.go
@@ -45,7 +45,7 @@ func init() {
func reconcileAlertProviderCmdRun(cmd *cobra.Command, args []string) error {
if len(args) < 1 {
- return fmt.Errorf("provider name is required")
+ return fmt.Errorf("Provider name is required")
}
name := args[0]
@@ -62,7 +62,7 @@ func reconcileAlertProviderCmdRun(cmd *cobra.Command, args []string) error {
Name: name,
}
- logger.Actionf("annotating provider %s in %s namespace", name, namespace)
+ logger.Actionf("annotating Provider %s in %s namespace", name, namespace)
var alertProvider notificationv1.Provider
err = kubeClient.Get(ctx, namespacedName, &alertProvider)
if err != nil {
@@ -79,15 +79,13 @@ func reconcileAlertProviderCmdRun(cmd *cobra.Command, args []string) error {
if err := kubeClient.Update(ctx, &alertProvider); err != nil {
return err
}
- logger.Successf("provider annotated")
+ logger.Successf("Provider annotated")
logger.Waitingf("waiting for reconciliation")
if err := wait.PollImmediate(pollInterval, timeout,
- isAlertProviderReady(ctx, kubeClient, name, namespace)); err != nil {
+ isAlertProviderReady(ctx, kubeClient, namespacedName, &alertProvider)); err != nil {
return err
}
-
- logger.Successf("provider reconciliation completed")
-
+ logger.Successf("Provider reconciliation completed")
return nil
}
diff --git a/cmd/gotk/reconcile_helmrelease.go b/cmd/gotk/reconcile_helmrelease.go
index 398bb40dcffff5e072951cde4655dc677a15653a..af4273ce0ec1e5559c1e67acd31e8508965c799c 100644
--- a/cmd/gotk/reconcile_helmrelease.go
+++ b/cmd/gotk/reconcile_helmrelease.go
@@ -98,19 +98,19 @@ func reconcileHrCmdRun(cmd *cobra.Command, args []string) error {
}
}
+ lastHandledReconcileAt := helmRelease.Status.LastHandledReconcileAt
logger.Actionf("annotating HelmRelease %s in %s namespace", name, namespace)
- if err := requestHelmReleaseReconciliation(ctx, kubeClient, namespacedName); err != nil {
+ if err := requestHelmReleaseReconciliation(ctx, kubeClient, namespacedName, &helmRelease); err != nil {
return err
}
logger.Successf("HelmRelease annotated")
logger.Waitingf("waiting for HelmRelease reconciliation")
if err := wait.PollImmediate(pollInterval, timeout,
- helmReleaseReconciliationHandled(ctx, kubeClient, name, namespace, helmRelease.Status.LastHandledReconcileAt),
+ helmReleaseReconciliationHandled(ctx, kubeClient, namespacedName, &helmRelease, lastHandledReconcileAt),
); err != nil {
return err
}
-
logger.Successf("HelmRelease reconciliation completed")
err = kubeClient.Get(ctx, namespacedName, &helmRelease)
@@ -120,7 +120,7 @@ func reconcileHrCmdRun(cmd *cobra.Command, args []string) error {
if c := meta.GetCondition(helmRelease.Status.Conditions, meta.ReadyCondition); c != nil {
switch c.Status {
case corev1.ConditionFalse:
- return fmt.Errorf("HelmRelease reconciliation failed")
+ return fmt.Errorf("HelmRelease reconciliation failed: %s", c.Message)
default:
logger.Successf("reconciled revision %s", helmRelease.Status.LastAppliedRevision)
}
@@ -129,39 +129,29 @@ func reconcileHrCmdRun(cmd *cobra.Command, args []string) error {
}
func helmReleaseReconciliationHandled(ctx context.Context, kubeClient client.Client,
- name, namespace, lastHandledReconcileAt string) wait.ConditionFunc {
+ namespacedName types.NamespacedName, helmRelease *helmv2.HelmRelease, lastHandledReconcileAt string) wait.ConditionFunc {
return func() (bool, error) {
- var helmRelease helmv2.HelmRelease
- namespacedName := types.NamespacedName{
- Namespace: namespace,
- Name: name,
- }
-
- err := kubeClient.Get(ctx, namespacedName, &helmRelease)
+ err := kubeClient.Get(ctx, namespacedName, helmRelease)
if err != nil {
return false, err
}
-
return helmRelease.Status.LastHandledReconcileAt != lastHandledReconcileAt, nil
}
}
-func requestHelmReleaseReconciliation(ctx context.Context, kubeClient client.Client, namespacedName types.NamespacedName) error {
- var release helmv2.HelmRelease
+func requestHelmReleaseReconciliation(ctx context.Context, kubeClient client.Client,
+ namespacedName types.NamespacedName, helmRelease *helmv2.HelmRelease) error {
return retry.RetryOnConflict(retry.DefaultBackoff, func() (err error) {
- if err := kubeClient.Get(ctx, namespacedName, &release); err != nil {
+ if err := kubeClient.Get(ctx, namespacedName, helmRelease); err != nil {
return err
}
-
- if release.Annotations == nil {
- release.Annotations = map[string]string{
+ if helmRelease.Annotations == nil {
+ helmRelease.Annotations = map[string]string{
meta.ReconcileAtAnnotation: time.Now().Format(time.RFC3339Nano),
}
} else {
- release.Annotations[meta.ReconcileAtAnnotation] = time.Now().Format(time.RFC3339Nano)
+ helmRelease.Annotations[meta.ReconcileAtAnnotation] = time.Now().Format(time.RFC3339Nano)
}
-
- err = kubeClient.Update(ctx, &release)
- return
+ return kubeClient.Update(ctx, helmRelease)
})
}
diff --git a/cmd/gotk/reconcile_kustomization.go b/cmd/gotk/reconcile_kustomization.go
index b31bc7062df3589b82c1d2ca4d5d2d1831cc006f..ff4e5586703e52fed33b190f84891a65b1b8a9d2 100644
--- a/cmd/gotk/reconcile_kustomization.go
+++ b/cmd/gotk/reconcile_kustomization.go
@@ -54,14 +54,14 @@ var (
)
func init() {
- reconcileKsCmd.Flags().BoolVar(&syncKsWithSource, "with-source", false, "reconcile kustomization source")
+ reconcileKsCmd.Flags().BoolVar(&syncKsWithSource, "with-source", false, "reconcile Kustomization source")
reconcileCmd.AddCommand(reconcileKsCmd)
}
func reconcileKsCmdRun(cmd *cobra.Command, args []string) error {
if len(args) < 1 {
- return fmt.Errorf("kustomization name is required")
+ return fmt.Errorf("Kustomization name is required")
}
name := args[0]
@@ -77,7 +77,6 @@ func reconcileKsCmdRun(cmd *cobra.Command, args []string) error {
Namespace: namespace,
Name: name,
}
-
var kustomization kustomizev1.Kustomization
err = kubeClient.Get(ctx, namespacedName, &kustomization)
if err != nil {
@@ -96,30 +95,26 @@ func reconcileKsCmdRun(cmd *cobra.Command, args []string) error {
}
}
- logger.Actionf("annotating kustomization %s in %s namespace", name, namespace)
- if err := requestKustomizeReconciliation(ctx, kubeClient, namespacedName); err != nil {
+ lastHandledReconcileAt := kustomization.Status.LastHandledReconcileAt
+ logger.Actionf("annotating Kustomization %s in %s namespace", name, namespace)
+ if err := requestKustomizeReconciliation(ctx, kubeClient, namespacedName, &kustomization); err != nil {
return err
}
- logger.Successf("kustomization annotated")
+ logger.Successf("Kustomization annotated")
- logger.Waitingf("waiting for kustomization reconciliation")
+ logger.Waitingf("waiting for Kustomization reconciliation")
if err := wait.PollImmediate(
pollInterval, timeout,
- kustomizeReconciliationHandled(ctx, kubeClient, name, namespace, kustomization.Status.LastHandledReconcileAt),
+ kustomizeReconciliationHandled(ctx, kubeClient, namespacedName, &kustomization, lastHandledReconcileAt),
); err != nil {
return err
}
+ logger.Successf("Kustomization reconciliation completed")
- logger.Successf("kustomization reconciliation completed")
-
- err = kubeClient.Get(ctx, namespacedName, &kustomization)
- if err != nil {
- return err
- }
if c := meta.GetCondition(kustomization.Status.Conditions, meta.ReadyCondition); c != nil {
switch c.Status {
case corev1.ConditionFalse:
- return fmt.Errorf("kustomization reconciliation failed")
+ return fmt.Errorf("Kustomization reconciliation failed")
default:
logger.Successf("reconciled revision %s", kustomization.Status.LastAppliedRevision)
}
@@ -128,30 +123,22 @@ func reconcileKsCmdRun(cmd *cobra.Command, args []string) error {
}
func kustomizeReconciliationHandled(ctx context.Context, kubeClient client.Client,
- name, namespace, lastHandledReconcileAt string) wait.ConditionFunc {
+ namespacedName types.NamespacedName, kustomization *kustomizev1.Kustomization, lastHandledReconcileAt string) wait.ConditionFunc {
return func() (bool, error) {
- var kustomize kustomizev1.Kustomization
- namespacedName := types.NamespacedName{
- Namespace: namespace,
- Name: name,
- }
-
- err := kubeClient.Get(ctx, namespacedName, &kustomize)
+ err := kubeClient.Get(ctx, namespacedName, kustomization)
if err != nil {
return false, err
}
-
- return kustomize.Status.LastHandledReconcileAt != lastHandledReconcileAt, nil
+ return kustomization.Status.LastHandledReconcileAt != lastHandledReconcileAt, nil
}
}
-func requestKustomizeReconciliation(ctx context.Context, kubeClient client.Client, namespacedName types.NamespacedName) error {
- var kustomization kustomizev1.Kustomization
+func requestKustomizeReconciliation(ctx context.Context, kubeClient client.Client,
+ namespacedName types.NamespacedName, kustomization *kustomizev1.Kustomization) error {
return retry.RetryOnConflict(retry.DefaultBackoff, func() (err error) {
- if err := kubeClient.Get(ctx, namespacedName, &kustomization); err != nil {
+ if err := kubeClient.Get(ctx, namespacedName, kustomization); err != nil {
return err
}
-
if kustomization.Annotations == nil {
kustomization.Annotations = map[string]string{
meta.ReconcileAtAnnotation: time.Now().Format(time.RFC3339Nano),
@@ -159,8 +146,6 @@ func requestKustomizeReconciliation(ctx context.Context, kubeClient client.Clien
} else {
kustomization.Annotations[meta.ReconcileAtAnnotation] = time.Now().Format(time.RFC3339Nano)
}
-
- err = kubeClient.Update(ctx, &kustomization)
- return
+ return kubeClient.Update(ctx, kustomization)
})
}
diff --git a/cmd/gotk/reconcile_receiver.go b/cmd/gotk/reconcile_receiver.go
index 7a7f6a863e8d2c841952e9636074eec1eb5b0b16..9b151ab7d5ba4705faee688f6a151036cd52d29d 100644
--- a/cmd/gotk/reconcile_receiver.go
+++ b/cmd/gotk/reconcile_receiver.go
@@ -62,7 +62,7 @@ func reconcileReceiverCmdRun(cmd *cobra.Command, args []string) error {
Name: name,
}
- logger.Actionf("annotating receiver %s in %s namespace", name, namespace)
+ logger.Actionf("annotating Receiver %s in %s namespace", name, namespace)
var receiver notificationv1.Receiver
err = kubeClient.Get(ctx, namespacedName, &receiver)
if err != nil {
@@ -79,15 +79,15 @@ func reconcileReceiverCmdRun(cmd *cobra.Command, args []string) error {
if err := kubeClient.Update(ctx, &receiver); err != nil {
return err
}
- logger.Successf("receiver annotated")
+ logger.Successf("Receiver annotated")
- logger.Waitingf("waiting for reconciliation")
+ logger.Waitingf("waiting for Receiver reconciliation")
if err := wait.PollImmediate(pollInterval, timeout,
- isReceiverReady(ctx, kubeClient, name, namespace)); err != nil {
+ isReceiverReady(ctx, kubeClient, namespacedName, &receiver)); err != nil {
return err
}
- logger.Successf("receiver reconciliation completed")
+ logger.Successf("Receiver reconciliation completed")
return nil
}
diff --git a/cmd/gotk/reconcile_source_bucket.go b/cmd/gotk/reconcile_source_bucket.go
index 5ac0c1568924a11bcd4d4ed453345b47f9f08ba0..c823806f5d3b33a9fa6e043011511c391b9a8202 100644
--- a/cmd/gotk/reconcile_source_bucket.go
+++ b/cmd/gotk/reconcile_source_bucket.go
@@ -64,7 +64,7 @@ func reconcileSourceBucketCmdRun(cmd *cobra.Command, args []string) error {
Name: name,
}
- logger.Actionf("annotating source %s in %s namespace", name, namespace)
+ logger.Actionf("annotating Bucket source %s in %s namespace", name, namespace)
var bucket sourcev1.Bucket
err = kubeClient.Get(ctx, namespacedName, &bucket)
if err != nil {
@@ -81,42 +81,35 @@ func reconcileSourceBucketCmdRun(cmd *cobra.Command, args []string) error {
if err := kubeClient.Update(ctx, &bucket); err != nil {
return err
}
- logger.Successf("source annotated")
+ logger.Successf("Bucket source annotated")
- logger.Waitingf("waiting for reconciliation")
+ logger.Waitingf("waiting for Bucket source reconciliation")
if err := wait.PollImmediate(pollInterval, timeout,
- isBucketReady(ctx, kubeClient, name, namespace)); err != nil {
+ isBucketReady(ctx, kubeClient, namespacedName, &bucket)); err != nil {
return err
}
+ logger.Successf("Bucket source reconciliation completed")
- logger.Successf("bucket reconciliation completed")
-
- err = kubeClient.Get(ctx, namespacedName, &bucket)
- if err != nil {
- return err
- }
-
- if bucket.Status.Artifact != nil {
- logger.Successf("fetched revision %s", bucket.Status.Artifact.Revision)
- } else {
- return fmt.Errorf("bucket reconciliation failed, artifact not found")
+ if bucket.Status.Artifact == nil {
+ return fmt.Errorf("Bucket source reconciliation completed but no artifact was found")
}
+ logger.Successf("fetched revision %s", bucket.Status.Artifact.Revision)
return nil
}
-func isBucketReady(ctx context.Context, kubeClient client.Client, name, namespace string) wait.ConditionFunc {
+func isBucketReady(ctx context.Context, kubeClient client.Client,
+ namespacedName types.NamespacedName, bucket *sourcev1.Bucket) wait.ConditionFunc {
return func() (bool, error) {
- var bucket sourcev1.Bucket
- namespacedName := types.NamespacedName{
- Namespace: namespace,
- Name: name,
- }
-
- err := kubeClient.Get(ctx, namespacedName, &bucket)
+ err := kubeClient.Get(ctx, namespacedName, bucket)
if err != nil {
return false, err
}
+ // Confirm the state we are observing is for the current generation
+ if bucket.Generation != bucket.Status.ObservedGeneration {
+ return false, nil
+ }
+
if c := meta.GetCondition(bucket.Status.Conditions, meta.ReadyCondition); c != nil {
switch c.Status {
case corev1.ConditionTrue:
diff --git a/cmd/gotk/reconcile_source_git.go b/cmd/gotk/reconcile_source_git.go
index 5a79f2bd86b3e5e5792a2639c5bdedaffb9fe198..b586861ffb3fde0fb700f805982c48cba3a0baea 100644
--- a/cmd/gotk/reconcile_source_git.go
+++ b/cmd/gotk/reconcile_source_git.go
@@ -62,7 +62,7 @@ func reconcileSourceGitCmdRun(cmd *cobra.Command, args []string) error {
Name: name,
}
- logger.Actionf("annotating source %s in %s namespace", name, namespace)
+ logger.Actionf("annotating GitRepository source %s in %s namespace", name, namespace)
var gitRepository sourcev1.GitRepository
err = kubeClient.Get(ctx, namespacedName, &gitRepository)
if err != nil {
@@ -79,25 +79,18 @@ func reconcileSourceGitCmdRun(cmd *cobra.Command, args []string) error {
if err := kubeClient.Update(ctx, &gitRepository); err != nil {
return err
}
- logger.Successf("source annotated")
+ logger.Successf("GitRepository source annotated")
- logger.Waitingf("waiting for reconciliation")
+ logger.Waitingf("waiting for GitRepository source reconciliation")
if err := wait.PollImmediate(pollInterval, timeout,
- isGitRepositoryReady(ctx, kubeClient, name, namespace)); err != nil {
+ isGitRepositoryReady(ctx, kubeClient, namespacedName, &gitRepository)); err != nil {
return err
}
+ logger.Successf("GitRepository source reconciliation completed")
- logger.Successf("git reconciliation completed")
-
- err = kubeClient.Get(ctx, namespacedName, &gitRepository)
- if err != nil {
- return err
- }
-
- if gitRepository.Status.Artifact != nil {
- logger.Successf("fetched revision %s", gitRepository.Status.Artifact.Revision)
- } else {
- return fmt.Errorf("git reconciliation failed, artifact not found")
+ if gitRepository.Status.Artifact == nil {
+ return fmt.Errorf("GitRepository source reconciliation completed but no artifact was found")
}
+ logger.Successf("fetched revision %s", gitRepository.Status.Artifact.Revision)
return nil
}
diff --git a/cmd/gotk/reconcile_source_helm.go b/cmd/gotk/reconcile_source_helm.go
index ea1ad3b8995aa3b7d4647c05a510774fa3d6c1af..3f1fe13a631963cf8bb1130817ea55276b8c94a5 100644
--- a/cmd/gotk/reconcile_source_helm.go
+++ b/cmd/gotk/reconcile_source_helm.go
@@ -47,7 +47,7 @@ func init() {
func reconcileSourceHelmCmdRun(cmd *cobra.Command, args []string) error {
if len(args) < 1 {
- return fmt.Errorf("source name is required")
+ return fmt.Errorf("HelmRepository source name is required")
}
name := args[0]
@@ -64,7 +64,7 @@ func reconcileSourceHelmCmdRun(cmd *cobra.Command, args []string) error {
Name: name,
}
- logger.Actionf("annotating source %s in %s namespace", name, namespace)
+ logger.Actionf("annotating HelmRepository source %s in %s namespace", name, namespace)
var helmRepository sourcev1.HelmRepository
err = kubeClient.Get(ctx, namespacedName, &helmRepository)
if err != nil {
@@ -81,42 +81,35 @@ func reconcileSourceHelmCmdRun(cmd *cobra.Command, args []string) error {
if err := kubeClient.Update(ctx, &helmRepository); err != nil {
return err
}
- logger.Successf("source annotated")
+ logger.Successf("HelmRepository source annotated")
- logger.Waitingf("waiting for reconciliation")
+ logger.Waitingf("waiting for HelmRepository source reconciliation")
if err := wait.PollImmediate(pollInterval, timeout,
- isHelmRepositoryReady(ctx, kubeClient, name, namespace)); err != nil {
+ isHelmRepositoryReady(ctx, kubeClient, namespacedName, &helmRepository)); err != nil {
return err
}
+ logger.Successf("HelmRepository source reconciliation completed")
- logger.Successf("helm reconciliation completed")
-
- err = kubeClient.Get(ctx, namespacedName, &helmRepository)
- if err != nil {
- return err
- }
-
- if helmRepository.Status.Artifact != nil {
- logger.Successf("fetched revision %s", helmRepository.Status.Artifact.Revision)
- } else {
- return fmt.Errorf("helm reconciliation failed, artifact not found")
+ if helmRepository.Status.Artifact == nil {
+ return fmt.Errorf("HelmRepository source reconciliation completed but no artifact was found")
}
+ logger.Successf("fetched revision %s", helmRepository.Status.Artifact.Revision)
return nil
}
-func isHelmRepositoryReady(ctx context.Context, kubeClient client.Client, name, namespace string) wait.ConditionFunc {
+func isHelmRepositoryReady(ctx context.Context, kubeClient client.Client,
+ namespacedName types.NamespacedName, helmRepository *sourcev1.HelmRepository) wait.ConditionFunc {
return func() (bool, error) {
- var helmRepository sourcev1.HelmRepository
- namespacedName := types.NamespacedName{
- Namespace: namespace,
- Name: name,
- }
-
- err := kubeClient.Get(ctx, namespacedName, &helmRepository)
+ err := kubeClient.Get(ctx, namespacedName, helmRepository)
if err != nil {
return false, err
}
+ // Confirm the state we are observing is for the current generation
+ if helmRepository.Generation != helmRepository.Status.ObservedGeneration {
+ return false, nil
+ }
+
if c := meta.GetCondition(helmRepository.Status.Conditions, meta.ReadyCondition); c != nil {
switch c.Status {
case corev1.ConditionTrue:
diff --git a/cmd/gotk/resume_alert.go b/cmd/gotk/resume_alert.go
index 30190cb340ebfa7b6a59ddd4afcbef8a618a1b3a..7624a45c76c12f3c34d2c911aae9932a19d5f83b 100644
--- a/cmd/gotk/resume_alert.go
+++ b/cmd/gotk/resume_alert.go
@@ -78,24 +78,17 @@ func resumeAlertCmdRun(cmd *cobra.Command, args []string) error {
logger.Waitingf("waiting for Alert reconciliation")
if err := wait.PollImmediate(pollInterval, timeout,
- isAlertResumed(ctx, kubeClient, name, namespace)); err != nil {
+ isAlertResumed(ctx, kubeClient, namespacedName, &alert)); err != nil {
return err
}
-
logger.Successf("Alert reconciliation completed")
-
return nil
}
-func isAlertResumed(ctx context.Context, kubeClient client.Client, name, namespace string) wait.ConditionFunc {
+func isAlertResumed(ctx context.Context, kubeClient client.Client,
+ namespacedName types.NamespacedName, alert *notificationv1.Alert) wait.ConditionFunc {
return func() (bool, error) {
- var alert notificationv1.Alert
- namespacedName := types.NamespacedName{
- Namespace: namespace,
- Name: name,
- }
-
- err := kubeClient.Get(ctx, namespacedName, &alert)
+ err := kubeClient.Get(ctx, namespacedName, alert)
if err != nil {
return false, err
}
diff --git a/cmd/gotk/resume_helmrelease.go b/cmd/gotk/resume_helmrelease.go
index 2484b0dde0e4b56354450e29ff0661749a9a3fb1..46f9c4ba99cc4514ad266e44bd12d4fae05bc376 100644
--- a/cmd/gotk/resume_helmrelease.go
+++ b/cmd/gotk/resume_helmrelease.go
@@ -79,36 +79,25 @@ func resumeHrCmdRun(cmd *cobra.Command, args []string) error {
logger.Waitingf("waiting for HelmRelease reconciliation")
if err := wait.PollImmediate(pollInterval, timeout,
- isHelmReleaseResumed(ctx, kubeClient, name, namespace)); err != nil {
+ isHelmReleaseResumed(ctx, kubeClient, namespacedName, &helmRelease)); err != nil {
return err
}
-
logger.Successf("HelmRelease reconciliation completed")
- err = kubeClient.Get(ctx, namespacedName, &helmRelease)
- if err != nil {
- return err
- }
-
- if helmRelease.Status.LastAppliedRevision != "" {
- logger.Successf("applied revision %s", helmRelease.Status.LastAppliedRevision)
- } else {
- return fmt.Errorf("HelmRelease reconciliation failed")
- }
-
+ logger.Successf("applied revision %s", helmRelease.Status.LastAppliedRevision)
return nil
}
-func isHelmReleaseResumed(ctx context.Context, kubeClient client.Client, name, namespace string) wait.ConditionFunc {
+func isHelmReleaseResumed(ctx context.Context, kubeClient client.Client,
+ namespacedName types.NamespacedName, helmRelease *helmv2.HelmRelease) wait.ConditionFunc {
return func() (bool, error) {
- var helmRelease helmv2.HelmRelease
- namespacedName := types.NamespacedName{
- Namespace: namespace,
- Name: name,
+ err := kubeClient.Get(ctx, namespacedName, helmRelease)
+ if err != nil {
+ return false, err
}
- err := kubeClient.Get(ctx, namespacedName, &helmRelease)
- if err != nil {
+ // Confirm the state we are observing is for the current generation
+ if helmRelease.Generation != helmRelease.Status.ObservedGeneration {
return false, err
}
diff --git a/cmd/gotk/resume_kustomization.go b/cmd/gotk/resume_kustomization.go
index faef0e6420125e8efebe1f28286d8b38620d1fa6..b683defbe4035160eb49a38d643f2735a76145cf 100644
--- a/cmd/gotk/resume_kustomization.go
+++ b/cmd/gotk/resume_kustomization.go
@@ -47,7 +47,7 @@ func init() {
func resumeKsCmdRun(cmd *cobra.Command, args []string) error {
if len(args) < 1 {
- return fmt.Errorf("kustomization name is required")
+ return fmt.Errorf("Kustomization name is required")
}
name := args[0]
@@ -69,48 +69,37 @@ func resumeKsCmdRun(cmd *cobra.Command, args []string) error {
return err
}
- logger.Actionf("resuming kustomization %s in %s namespace", name, namespace)
+ logger.Actionf("resuming Kustomization %s in %s namespace", name, namespace)
kustomization.Spec.Suspend = false
if err := kubeClient.Update(ctx, &kustomization); err != nil {
return err
}
- logger.Successf("kustomization resumed")
+ logger.Successf("Kustomization resumed")
- logger.Waitingf("waiting for kustomization sync")
+ logger.Waitingf("waiting for Kustomization reconciliation")
if err := wait.PollImmediate(pollInterval, timeout,
- isKustomizationResumed(ctx, kubeClient, name, namespace)); err != nil {
+ isKustomizationResumed(ctx, kubeClient, namespacedName, &kustomization)); err != nil {
return err
}
+ logger.Successf("Kustomization reconciliation completed")
- logger.Successf("kustomization sync completed")
-
- err = kubeClient.Get(ctx, namespacedName, &kustomization)
- if err != nil {
- return err
- }
-
- if kustomization.Status.LastAppliedRevision != "" {
- logger.Successf("applied revision %s", kustomization.Status.LastAppliedRevision)
- } else {
- return fmt.Errorf("kustomization sync failed")
- }
-
+ logger.Successf("applied revision %s", kustomization.Status.LastAppliedRevision)
return nil
}
-func isKustomizationResumed(ctx context.Context, kubeClient client.Client, name, namespace string) wait.ConditionFunc {
+func isKustomizationResumed(ctx context.Context, kubeClient client.Client,
+ namespacedName types.NamespacedName, kustomization *kustomizev1.Kustomization) wait.ConditionFunc {
return func() (bool, error) {
- var kustomization kustomizev1.Kustomization
- namespacedName := types.NamespacedName{
- Namespace: namespace,
- Name: name,
- }
-
- err := kubeClient.Get(ctx, namespacedName, &kustomization)
+ err := kubeClient.Get(ctx, namespacedName, kustomization)
if err != nil {
return false, err
}
+ // Confirm the state we are observing is for the current generation
+ if kustomization.Generation != kustomization.Status.ObservedGeneration {
+ return false, nil
+ }
+
if c := meta.GetCondition(kustomization.Status.Conditions, meta.ReadyCondition); c != nil {
switch c.Status {
case corev1.ConditionTrue:
diff --git a/cmd/gotk/resume_receiver.go b/cmd/gotk/resume_receiver.go
index 14f30e70f817069591613096403224b81b7c2cd6..25c40daa61c1a8ca36a0e463bc612bd4249c9585 100644
--- a/cmd/gotk/resume_receiver.go
+++ b/cmd/gotk/resume_receiver.go
@@ -78,24 +78,18 @@ func resumeReceiverCmdRun(cmd *cobra.Command, args []string) error {
logger.Waitingf("waiting for Receiver reconciliation")
if err := wait.PollImmediate(pollInterval, timeout,
- isReceiverResumed(ctx, kubeClient, name, namespace)); err != nil {
+ isReceiverResumed(ctx, kubeClient, namespacedName, &receiver)); err != nil {
return err
}
logger.Successf("Receiver reconciliation completed")
-
return nil
}
-func isReceiverResumed(ctx context.Context, kubeClient client.Client, name, namespace string) wait.ConditionFunc {
+func isReceiverResumed(ctx context.Context, kubeClient client.Client,
+ namespacedName types.NamespacedName, receiver *notificationv1.Receiver) wait.ConditionFunc {
return func() (bool, error) {
- var receiver notificationv1.Receiver
- namespacedName := types.NamespacedName{
- Namespace: namespace,
- Name: name,
- }
-
- err := kubeClient.Get(ctx, namespacedName, &receiver)
+ err := kubeClient.Get(ctx, namespacedName, receiver)
if err != nil {
return false, err
}
diff --git a/docs/cmd/gotk_create_helmrelease.md b/docs/cmd/gotk_create_helmrelease.md
index 06eec7313c209317cfec35ff81d0d2e5fe254291..9a831bec885fd6dc7705d4d1a1ea766d8e61abf4 100644
--- a/docs/cmd/gotk_create_helmrelease.md
+++ b/docs/cmd/gotk_create_helmrelease.md
@@ -66,7 +66,7 @@ gotk create helmrelease [name] [flags]
--chart-version string Helm chart version, accepts a semver range (ignored for charts from GitRepository sources)
--depends-on stringArray HelmReleases that must be ready before this release can be installed, supported formats '<name>' and '<namespace>/<name>'
-h, --help help for helmrelease
- --release-name string name used for the Helm release, defaults to a composition of '[<target-namespace>-]<hr-name>'
+ --release-name string name used for the Helm release, defaults to a composition of '[<target-namespace>-]<HelmRelease-name>'
--source string source that contains the chart (<kind>/<name>)
--target-namespace string namespace to install this release, defaults to the HelmRelease namespace
--values string local path to the values.yaml file
diff --git a/docs/cmd/gotk_reconcile_kustomization.md b/docs/cmd/gotk_reconcile_kustomization.md
index d455e02b914d31191af9f613f87047f63f91f69b..b9aa6dd823b01c466c104c31fd65b752da22b4f7 100644
--- a/docs/cmd/gotk_reconcile_kustomization.md
+++ b/docs/cmd/gotk_reconcile_kustomization.md
@@ -26,7 +26,7 @@ gotk reconcile kustomization [name] [flags]
```
-h, --help help for kustomization
- --with-source reconcile kustomization source
+ --with-source reconcile Kustomization source
```
### Options inherited from parent commands