constellation/cli/internal/helm/backup.go

/*
Copyright (c) Edgeless Systems GmbH

SPDX-License-Identifier: AGPL-3.0-only
*/

package helm

import (
	"context"
	"fmt"
	"path/filepath"

	"github.com/edgelesssys/constellation/v2/internal/constants"
	apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
	k8serrors "k8s.io/apimachinery/pkg/api/errors"
	"k8s.io/apimachinery/pkg/runtime/schema"
	"sigs.k8s.io/yaml"
)

func (c *UpgradeClient) backupCRDs(ctx context.Context, upgradeID string) ([]apiextensionsv1.CustomResourceDefinition, error) {
	c.log.Debugf("Starting CRD backup")
	crds, err := c.kubectl.GetCRDs(ctx)
	if err != nil {
		return nil, fmt.Errorf("getting CRDs: %w", err)
	}

	crdBackupFolder := c.crdBackupFolder(upgradeID)
	if err := c.fs.MkdirAll(crdBackupFolder); err != nil {
		return nil, fmt.Errorf("creating backup dir: %w", err)
	}
	for i := range crds {
		path := filepath.Join(crdBackupFolder, crds[i].Name+".yaml")

		c.log.Debugf("Creating CRD backup: %s", path)

		// We have to manually set kind/apiversion because of a long-standing limitation of the API:
		// https://github.com/kubernetes/kubernetes/issues/3030#issuecomment-67543738
		// The comment states that kind/version are encoded in the type.
		// The package holding the CRD type encodes the version.
		crds[i].Kind = "CustomResourceDefinition"
		crds[i].APIVersion = "apiextensions.k8s.io/v1"

		yamlBytes, err := yaml.Marshal(crds[i])
		if err != nil {
			return nil, err
		}
		if err := c.fs.Write(path, yamlBytes); err != nil {
			return nil, err
		}
	}
	c.log.Debugf("CRD backup complete")
	return crds, nil
}

func (c *UpgradeClient) backupCRs(ctx context.Context, crds []apiextensionsv1.CustomResourceDefinition, upgradeID string) error {
	c.log.Debugf("Starting CR backup")
	for _, crd := range crds {
		c.log.Debugf("Creating backup for resource type: %s", crd.Name)

		// Iterate over all versions of the CRD
		// TODO: Consider iterating over crd.Status.StoredVersions instead
		// Currently, we have to ignore not-found errors, because a CRD might define
		// a version that is not installed in the cluster.
		// With the StoredVersions field, we could only iterate over the installed versions.
		for _, version := range crd.Spec.Versions {
			c.log.Debugf("Creating backup of CRs for %q at version %q", crd.Name, version.Name)

			gvr := schema.GroupVersionResource{Group: crd.Spec.Group, Version: version.Name, Resource: crd.Spec.Names.Plural}
			crs, err := c.kubectl.GetCRs(ctx, gvr)
			if err != nil {
				if !k8serrors.IsNotFound(err) {
					return fmt.Errorf("retrieving CR %s: %w", crd.Name, err)
				}
				c.log.Debugf("No CRs found for %q at version %q, skipping...", crd.Name, version.Name)
				continue
			}

			backupFolder := c.backupFolder(upgradeID)
			for _, cr := range crs {
				targetFolder := filepath.Join(backupFolder, gvr.Group, gvr.Version, cr.GetNamespace(), cr.GetKind())
				if err := c.fs.MkdirAll(targetFolder); err != nil {
					return fmt.Errorf("creating resource dir: %w", err)
				}
				path := filepath.Join(targetFolder, cr.GetName()+".yaml")
				yamlBytes, err := yaml.Marshal(cr.Object)
				if err != nil {
					return err
				}
				if err := c.fs.Write(path, yamlBytes); err != nil {
					return err
				}
			}
		}

		c.log.Debugf("Backup for resource type %q complete", crd.Name)
	}
	c.log.Debugf("CR backup complete")
	return nil
}

func (c *UpgradeClient) backupFolder(upgradeID string) string {
	return filepath.Join(constants.UpgradeDir, upgradeID, "backups") + string(filepath.Separator)
}

func (c *UpgradeClient) crdBackupFolder(upgradeID string) string {
	return filepath.Join(c.backupFolder(upgradeID), "crds") + string(filepath.Separator)
}