EVEREST-107: config and secrets consistency via owner references

api/backup_storage.go

@@ -13,12 +13,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// Package api ...
-//
-//nolint:dupl
 package api
 
 import (
+	"context"
 	"fmt"
 	"net/http"
 
@@ -50,14 +48,15 @@
 			BucketName:  s.Spec.Bucket,
 			Region:      s.Spec.Region,
 			Url:         &s.Spec.EndpointURL,
+			Status:      s.Status.Status,
 		})
 	}
 
 	return ctx.JSON(http.StatusOK, result)
 }
 
 // CreateBackupStorage creates a new backup storage object.
-func (e *EverestServer) CreateBackupStorage(ctx echo.Context) error { //nolint:funlen
+func (e *EverestServer) CreateBackupStorage(ctx echo.Context) error {
 	params, err := validateCreateBackupStorageRequest(ctx, e.l)
 	if err != nil {
 		return ctx.JSON(http.StatusBadRequest, Error{Message: pointer.ToString(err.Error())})
@@ -74,41 +73,11 @@
 	// if s != nil passes
 	if s != nil && s.Name != "" {
 		return ctx.JSON(http.StatusConflict, Error{
-			Message: pointer.ToString(fmt.Sprintf("Storage %s already exists", params.Name)),
+			Message: pointer.ToString(fmt.Sprintf("Backup storage %s already exists", params.Name)),
 		})
 	}
-	_, err = e.kubeClient.CreateSecret(c, &corev1.Secret{
-		ObjectMeta: metav1.ObjectMeta{
-			Name:      params.Name,
-			Namespace: e.kubeClient.Namespace(),
-		},
-		Type:       corev1.SecretTypeOpaque,
-		StringData: e.backupSecretData(params.SecretKey, params.AccessKey),
-	})
-	if err != nil {
-		if k8serrors.IsAlreadyExists(err) {
-			_, err = e.kubeClient.UpdateSecret(c, &corev1.Secret{
-				ObjectMeta: metav1.ObjectMeta{
-					Name:      params.Name,
-					Namespace: e.kubeClient.Namespace(),
-				},
-				Type:       corev1.SecretTypeOpaque,
-				StringData: e.backupSecretData(params.SecretKey, params.AccessKey),
-			})
-			if err != nil {
-				e.l.Error(err)
-				return ctx.JSON(http.StatusInternalServerError, Error{
-					Message: pointer.ToString(fmt.Sprintf("Failed updating the secret %s", params.Name)),
-				})
-			}
-		} else {
-			e.l.Error(err)
-			return ctx.JSON(http.StatusInternalServerError, Error{
-				Message: pointer.ToString("Failed creating the secret for the backup storage"),
-			})
-		}
-	}
-	bs := &everestv1alpha1.BackupStorage{
+
+	bsData := &everestv1alpha1.BackupStorage{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      params.Name,
 			Namespace: e.kubeClient.Namespace(),
@@ -119,34 +88,68 @@
 			Region:                params.Region,
 			CredentialsSecretName: params.Name,
 		},
+		Status: {
+			Status: "Initializing",
+		},
 	}
 	if params.Url != nil {
-		bs.Spec.EndpointURL = *params.Url
+		bsData.Spec.EndpointURL = *params.Url
 	}
 	if params.Description != nil {
-		bs.Spec.Description = *params.Description
+		bsData.Spec.Description = *params.Description
 	}
-	err = e.kubeClient.CreateBackupStorage(c, bs)
+	bs, err := e.kubeClient.CreateBackupStorage(c, bsData)
 	if err != nil {
 		e.l.Error(err)
-		// TODO: Move this logic to the operator
-		dErr := e.kubeClient.DeleteSecret(c, params.Name)
-		if dErr != nil {
-			return ctx.JSON(http.StatusInternalServerError, Error{
-				Message: pointer.ToString("Failing cleaning up the secret because failed creating backup storage"),
-			})
+		return ctx.JSON(http.StatusInternalServerError, Error{
+			Message: pointer.ToString("Could not create a backup storage"),
+		})
+	}
+
+	secret, err := e.createBackupStorageSecret(c, bs, params.AccessKey, params.SecretKey)
+	if err != nil {
+		e.l.Error(err)
+
+		if err := e.kubeClient.DeleteBackupStorage(c, bs.Name); err != nil {
+			// TODO: We shall clean up the backup storage. Options:
+			// 1. Retry delete here
+			// 2. Backend to poll for not-ready storages and delete
+			// 3. Operator to poll for not-ready storages and delete
+			e.l.Errorf("Could not delete backup storage %s in initializing state", bs.Name)
 		}
+
 		return ctx.JSON(http.StatusInternalServerError, Error{
-			Message: pointer.ToString("Failed creating backup storage"),
+			Message: pointer.ToString("Could not create a secret for the backup storage"),
 		})
 	}
+
+	bs.Status.Status = "Ready"
+	bs.Spec.CredentialsSecretName = secret.Name
+
+	if err := e.kubeClient.UpdateBackupStorage(c, bs); err != nil {
+		e.l.Error(err)
+		if err := e.kubeClient.DeleteBackupStorage(c, bs.Name); err != nil {
+			// TODO: We shall clean up the backup storage. Options:
+			// 1. Retry delete here
+			// 2. Backend to poll for not-ready storages and delete
+			// 3. Operator to poll for not-ready storages and delete
+			e.l.Errorf("Could not delete backup storage %s in initializing state", bs.Name)
+		}
+
+		return ctx.JSON(http.StatusInternalServerError, Error{
+			Message: pointer.ToString("Could not finish backup storage configuration"),
+		})
+
+	}
+
 	result := BackupStorage{
-		Type:        BackupStorageType(params.Type),
-		Name:        params.Name,
-		Description: params.Description,
-		BucketName:  params.BucketName,
-		Region:      params.Region,
-		Url:         params.Url,
+		Type:        BackupStorageType(bs.Spec.Type),
+		Name:        bs.Name,
+		Description: &bs.Spec.Description,
+		BucketName:  bs.Spec.Bucket,
+		Region:      bs.Spec.Region,
+		Url:         &bs.Spec.EndpointURL,
+		Status:      bs.Status.Status,
 	}
 
 	return ctx.JSON(http.StatusOK, result)
@@ -158,7 +161,7 @@
 	if err != nil {
 		if k8serrors.IsNotFound(err) {
 			return ctx.JSON(http.StatusNotFound, Error{
-				Message: pointer.ToString("Backup storage is not found"),
+				Message: pointer.ToString("Backup storage not found"),
 			})
 		}
 		e.l.Error(err)
@@ -168,27 +171,16 @@
 	}
 	if used {
 		return ctx.JSON(http.StatusBadRequest, Error{
-			Message: pointer.ToString(fmt.Sprintf("Backup storage %s is used", backupStorageName)),
+			Message: pointer.ToString(fmt.Sprintf("Backup storage %s is in use", backupStorageName)),
 		})
 	}
 	if err := e.kubeClient.DeleteBackupStorage(ctx.Request().Context(), backupStorageName); err != nil {
-		if k8serrors.IsNotFound(err) {
-			return ctx.JSON(http.StatusNotFound, Error{
-				Message: pointer.ToString("Backup storage is not found"),
-			})
-		}
-		e.l.Error(err)
-		return ctx.JSON(http.StatusInternalServerError, Error{
-			Message: pointer.ToString("Failed to delete BackupStorage"),
-		})
-	}
-	if err := e.kubeClient.DeleteSecret(ctx.Request().Context(), backupStorageName); err != nil {
 		if k8serrors.IsNotFound(err) {
 			return ctx.NoContent(http.StatusNoContent)
 		}
 		e.l.Error(err)
 		return ctx.JSON(http.StatusInternalServerError, Error{
-			Message: pointer.ToString("Failed to delete the secret"),
+			Message: pointer.ToString("Failed to delete a backup storage"),
 		})
 	}
 
@@ -208,7 +200,7 @@
 	if err != nil {
 		if k8serrors.IsNotFound(err) {
 			return ctx.JSON(http.StatusNotFound, Error{
-				Message: pointer.ToString("Backup storage is not found"),
+				Message: pointer.ToString("Backup storage not found"),
 			})
 		}
 		e.l.Error(err)
@@ -223,6 +215,7 @@
 		BucketName:  s.Spec.Bucket,
 		Region:      s.Spec.Region,
 		Url:         &s.Spec.EndpointURL,
+		Status:      s.Status.Status,
 	})
 }
 
@@ -233,31 +226,32 @@
 	if err != nil {
 		if k8serrors.IsNotFound(err) {
 			return ctx.JSON(http.StatusNotFound, Error{
-				Message: pointer.ToString("Backup storage is not found"),
+				Message: pointer.ToString("Backup storage not found"),
 			})
 		}
 		e.l.Error(err)
 		return ctx.JSON(http.StatusInternalServerError, Error{
 			Message: pointer.ToString("Failed getting backup storage"),
 		})
 	}
+
+	if bs.Status.Status != "Ready" {
+		return ctx.JSON(http.StatusNotFound, Error{
+			Message: pointer.ToString("Backup storage is not ready"),
+		})
+	}
+
 	params, err := validateUpdateBackupStorageRequest(ctx, bs, e.l)
 	if err != nil {
 		return ctx.JSON(http.StatusBadRequest, Error{Message: pointer.ToString(err.Error())})
 	}
+	var secret *corev1.Secret
 	if params.AccessKey != nil && params.SecretKey != nil {
-		_, err = e.kubeClient.UpdateSecret(c, &corev1.Secret{
-			ObjectMeta: metav1.ObjectMeta{
-				Name:      backupStorageName,
-				Namespace: e.kubeClient.Namespace(),
-			},
-			Type:       corev1.SecretTypeOpaque,
-			StringData: e.backupSecretData(*params.SecretKey, *params.AccessKey),
-		})
+		secret, err = e.createBackupStorageSecret(c, bs, *params.AccessKey, *params.SecretKey)
 		if err != nil {
 			e.l.Error(err)
 			return ctx.JSON(http.StatusInternalServerError, Error{
-				Message: pointer.ToString(fmt.Sprintf("Failed updating the secret %s", backupStorageName)),
+				Message: pointer.ToString(fmt.Sprintf("Could not create secret for backup storage %s", backupStorageName)),
 			})
 		}
 	}
@@ -274,13 +268,29 @@
 		bs.Spec.Description = *params.Description
 	}
 
-	err = e.kubeClient.UpdateBackupStorage(c, bs)
-	if err != nil {
+	var prevSecretName string
+	if secret != nil {
+		prevSecretName = bs.Spec.CredentialsSecretName
+		bs.Spec.CredentialsSecretName = secret.Name
+	}
+
+	if err = e.kubeClient.UpdateBackupStorage(c, bs); err != nil {
 		e.l.Error(err)
 		return ctx.JSON(http.StatusInternalServerError, Error{
 			Message: pointer.ToString("Failed updating backup storage"),
 		})
 	}
+
+	if prevSecretName != "" {
+		if err := e.kubeClient.DeleteSecret(c, prevSecretName); err != nil {
+			// TODO: We shall clean up the old secret. Options:
+			// 1. Retry delete here
+			// 2. Backend to poll for not-used secrets and delete
+			// 3. Operator to poll for not-used secrets and delete
+			e.l.Errorf("Could not delete secret %s", prevSecretName)
+		}
+	}
+
 	result := BackupStorage{
 		Type:        BackupStorageType(bs.Spec.Type),
 		Name:        bs.Name,
@@ -292,3 +302,27 @@
 
 	return ctx.JSON(http.StatusOK, result)
 }
+
+func (e *EverestServer) createBackupStorageSecret(
+	ctx context.Context, bs *everestv1alpha1.BackupStorage,
+	accessKey, secretKey string,
+) (*corev1.Secret, error) {
+	secretData := &corev1.Secret{
+		ObjectMeta: metav1.ObjectMeta{
+			GenerateName: bs.Name + "-",
+			Namespace:    e.kubeClient.Namespace(),
+			OwnerReferences: []metav1.OwnerReference{
+				{
+					APIVersion: bs.APIVersion,
+					Kind:       bs.Kind,
+					Name:       bs.Name,
+					UID:        bs.UID,
+				},
+			},
+		},
+		Type:       corev1.SecretTypeOpaque,
+		StringData: e.backupSecretData(secretKey, accessKey),
+	}
+
+	return e.kubeClient.CreateSecret(ctx, secretData)
+}

api/monitoring_instance.go

@@ -13,9 +13,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// Package api ...
-//
-//nolint:dupl
 package api
 
 import (
@@ -71,24 +68,18 @@ func (e *EverestServer) CreateMonitoringInstance(ctx echo.Context) error { //nol
 			})
 		}
 	}
-	_, err = e.kubeClient.CreateSecret(c, &corev1.Secret{
+	secret := &corev1.Secret{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      params.Name,
 			Namespace: e.kubeClient.Namespace(),
 		},
 		Type:       corev1.SecretTypeOpaque,
 		StringData: e.monitoringConfigSecretData(apiKey),
-	})
+	}
+	_, err = e.kubeClient.CreateSecret(c, secret)
 	if err != nil {
 		if k8serrors.IsAlreadyExists(err) {
-			_, err = e.kubeClient.UpdateSecret(c, &corev1.Secret{
-				ObjectMeta: metav1.ObjectMeta{
-					Name:      params.Name,
-					Namespace: e.kubeClient.Namespace(),
-				},
-				Type:       corev1.SecretTypeOpaque,
-				StringData: e.monitoringConfigSecretData(apiKey),
-			})
+			_, err = e.kubeClient.UpdateSecret(c, secret)
 			if err != nil {
 				e.l.Error(err)
 				return ctx.JSON(http.StatusInternalServerError, Error{

pkg/kubernetes/backup_storage.go

@@ -40,7 +40,7 @@ func (k *Kubernetes) GetBackupStorage(ctx context.Context, name string) (*everes
 }
 
 // CreateBackupStorage returns backup storages by provided name.
-func (k *Kubernetes) CreateBackupStorage(ctx context.Context, storage *everestv1alpha1.BackupStorage) error {
+func (k *Kubernetes) CreateBackupStorage(ctx context.Context, storage *everestv1alpha1.BackupStorage) (*everestv1alpha1.BackupStorage, error) {
 	return k.client.CreateBackupStorage(ctx, storage)
 }
 

pkg/kubernetes/client/backup_storage.go

@@ -24,9 +24,8 @@ import (
 )
 
 // CreateBackupStorage creates an backupStorage.
-func (c *Client) CreateBackupStorage(ctx context.Context, storage *everestv1alpha1.BackupStorage) error {
-	_, err := c.customClientSet.BackupStorage(storage.Namespace).Create(ctx, storage, metav1.CreateOptions{})
-	return err
+func (c *Client) CreateBackupStorage(ctx context.Context, storage *everestv1alpha1.BackupStorage) (*everestv1alpha1.BackupStorage, error) {
+	return c.customClientSet.BackupStorage(storage.Namespace).Create(ctx, storage, metav1.CreateOptions{})
 }
 
 // UpdateBackupStorage updates an backupStorage.