github.com/openshift/installer@v1.4.17/pkg/asset/agent/manifests/clusterimageset.go

package manifests

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

	"github.com/pkg/errors"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/util/validation/field"
	"sigs.k8s.io/yaml"

	hivev1 "github.com/openshift/hive/apis/hive/v1"
	"github.com/openshift/installer/pkg/asset"
	"github.com/openshift/installer/pkg/asset/agent"
	"github.com/openshift/installer/pkg/asset/agent/joiner"
	"github.com/openshift/installer/pkg/asset/agent/workflow"
	"github.com/openshift/installer/pkg/asset/releaseimage"
	"github.com/openshift/installer/pkg/version"
)

var (
	clusterImageSetFilename = filepath.Join(clusterManifestDir, "cluster-image-set.yaml")
)

// ClusterImageSet generates the cluster-image-set.yaml file.
type ClusterImageSet struct {
	File   *asset.File
	Config *hivev1.ClusterImageSet
}

var _ asset.WritableAsset = (*ClusterImageSet)(nil)

// Name returns a human friendly name for the asset.
func (*ClusterImageSet) Name() string {
	return "ClusterImageSet Config"
}

// Dependencies returns all of the dependencies directly needed to generate
// the asset.
func (*ClusterImageSet) Dependencies() []asset.Asset {
	return []asset.Asset{
		&workflow.AgentWorkflow{},
		&joiner.ClusterInfo{},
		&releaseimage.Image{},
		&agent.OptionalInstallConfig{},
	}
}

// Generate generates the ClusterImageSet manifest.
func (a *ClusterImageSet) Generate(ctx context.Context, dependencies asset.Parents) error {
	agentWorkflow := &workflow.AgentWorkflow{}
	clusterInfo := &joiner.ClusterInfo{}
	releaseImage := &releaseimage.Image{}
	installConfig := &agent.OptionalInstallConfig{}
	dependencies.Get(releaseImage, installConfig, agentWorkflow, clusterInfo)

	switch agentWorkflow.Workflow {
	case workflow.AgentWorkflowTypeInstall:
		currentVersion, err := version.Version()
		if err != nil {
			return err
		}

		clusterNamespace := ""
		if installConfig.Config != nil {
			clusterNamespace = installConfig.ClusterNamespace()
		}
		err = a.generateManifest(currentVersion, releaseImage.PullSpec, clusterNamespace)
		if err != nil {
			return err
		}
	case workflow.AgentWorkflowTypeAddNodes:
		return a.generateManifest(clusterInfo.Version, clusterInfo.ReleaseImage, clusterInfo.Namespace)

	default:
		return fmt.Errorf("AgentWorkflowType value not supported: %s", agentWorkflow.Workflow)
	}

	return a.finish(ctx, agentWorkflow.Workflow)
}

func (a *ClusterImageSet) generateManifest(version, releaseImage, clusterNamespace string) error {
	clusterImageSet := &hivev1.ClusterImageSet{
		TypeMeta: metav1.TypeMeta{
			Kind:       "ClusterImageSet",
			APIVersion: hivev1.SchemeGroupVersion.String(),
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:      fmt.Sprintf("openshift-%s", version),
			Namespace: clusterNamespace,
		},
		Spec: hivev1.ClusterImageSetSpec{
			ReleaseImage: releaseImage,
		},
	}

	configData, err := yaml.Marshal(clusterImageSet)
	if err != nil {
		return errors.Wrap(err, "failed to marshal agent cluster image set")
	}

	a.Config = clusterImageSet
	a.File = &asset.File{
		Filename: clusterImageSetFilename,
		Data:     configData,
	}

	return nil
}

// Files returns the files generated by the asset.
func (a *ClusterImageSet) Files() []*asset.File {
	if a.File != nil {
		return []*asset.File{a.File}
	}
	return []*asset.File{}
}

// Load returns ClusterImageSet asset from the disk.
func (a *ClusterImageSet) Load(f asset.FileFetcher) (bool, error) {
	ctx := context.TODO()

	agentWorkflow := &workflow.AgentWorkflow{}
	_, err := agentWorkflow.Load(f)
	if err != nil {
		return false, err
	}

	clusterImageSetFile, err := f.FetchByName(clusterImageSetFilename)
	if err != nil {
		if os.IsNotExist(err) {
			return false, nil
		}
		return false, errors.Wrap(err, fmt.Sprintf("failed to load %s file", clusterImageSetFilename))
	}

	a.File = clusterImageSetFile

	clusterImageSet := &hivev1.ClusterImageSet{}
	if err := yaml.UnmarshalStrict(clusterImageSetFile.Data, clusterImageSet); err != nil {
		err = errors.Wrapf(err, "failed to unmarshal %s", clusterImageSetFilename)
		return false, err
	}
	a.Config = clusterImageSet

	if err = a.finish(ctx, agentWorkflow.Workflow); err != nil {
		return false, err
	}
	return true, nil
}

func (a *ClusterImageSet) finish(ctx context.Context, workflowType workflow.AgentWorkflowType) error {
	if a.Config == nil {
		return errors.New("missing configuration or manifest file")
	}

	if err := a.validateClusterImageSet(ctx, workflowType).ToAggregate(); err != nil {
		return errors.Wrapf(err, "invalid ClusterImageSet configuration")
	}

	return nil
}

func (a *ClusterImageSet) validateClusterImageSet(ctx context.Context, workflowType workflow.AgentWorkflowType) field.ErrorList {
	allErrs := field.ErrorList{}

	if err := a.validateReleaseVersion(ctx, workflowType); err != nil {
		allErrs = append(allErrs, err...)
	}

	return allErrs
}

func (a *ClusterImageSet) validateReleaseVersion(ctx context.Context, workflowType workflow.AgentWorkflowType) field.ErrorList {
	// skip release version check in case of add nodes workflow
	if workflowType == workflow.AgentWorkflowTypeAddNodes {
		return nil
	}

	var allErrs field.ErrorList

	fieldPath := field.NewPath("Spec", "ReleaseImage")

	releaseImage := &releaseimage.Image{}
	if err := releaseImage.Generate(ctx, asset.Parents{}); err != nil {
		return append(allErrs, field.InternalError(fieldPath, fmt.Errorf("failed to generate the release image asset: %w", err)))
	}

	if a.Config.Spec.ReleaseImage != releaseImage.PullSpec {
		allErrs = append(allErrs, field.Forbidden(fieldPath, fmt.Sprintf("value must be equal to %s", releaseImage.PullSpec)))
	}

	return allErrs
}