func()

in pkg/trait/builder.go [210:330]

• 103 lines of code
• 15 McCabe index (conditional complexity)

func (t *builderTrait) Apply(e *Environment) error {
	// local pipeline tasks
	var pipelineTasks []v1.Task

	// task configuration resources
	defaultBuildConf := &v1.BuildConfiguration{}
	if e.Platform != nil {
		defaultBuildConf = &e.Platform.Status.Build.BuildConfiguration
	}
	tasksConf, err := t.parseTasksConf(defaultBuildConf)
	if err != nil {
		return err
	}

	imageName := getImageName(e)
	// Building task
	builderTask, err := t.builderTask(e, taskConfOrDefault(tasksConf, "builder"))
	if err != nil {
		if err := failIntegrationKit(
			e,
			"IntegrationKitPropertiesFormatValid",
			corev1.ConditionFalse,
			"IntegrationKitPropertiesFormatValid",
			fmt.Sprintf("One or more properties where not formatted as expected: %s", err.Error()),
		); err != nil {
			return err
		}
		return nil
	}
	builderTask.Configuration.NodeSelector = t.NodeSelector
	builderTask.Configuration.Annotations = t.Annotations
	pipelineTasks = append(pipelineTasks, v1.Task{Builder: builderTask})

	// Custom tasks
	if t.Tasks != nil {
		ct, err := t.determineCustomTasks(e, builderTask, tasksConf)
		if err != nil {
			return err
		}
		if ct == nil {
			return nil
		}

		pipelineTasks = append(pipelineTasks, ct...)
	}

	// Packaging task
	// It's the same builder configuration, but with different steps and conf
	packageTask := builderTask.DeepCopy()
	packageTask.Name = "package"
	packageTask.Configuration = *taskConfOrDefault(tasksConf, "package")
	packageTask.Steps = make([]string, 0)
	pipelineTasks = append(pipelineTasks, v1.Task{Package: packageTask})

	// Publishing task
	tag := getTag(e)
	switch e.Platform.Status.Build.PublishStrategy {
	case v1.IntegrationPlatformBuildPublishStrategySpectrum:
		pipelineTasks = append(pipelineTasks, v1.Task{Spectrum: &v1.SpectrumTask{
			BaseTask: v1.BaseTask{
				Name:          "spectrum",
				Configuration: *taskConfOrDefault(tasksConf, "spectrum"),
			},
			PublishTask: v1.PublishTask{
				BaseImage: t.getBaseImage(e),
				Image:     imageName,
				Registry:  e.Platform.Status.Build.Registry,
			},
		}})

	case v1.IntegrationPlatformBuildPublishStrategyJib:
		jibTask := v1.Task{Jib: &v1.JibTask{
			BaseTask: v1.BaseTask{
				Name:          "jib",
				Configuration: *taskConfOrDefault(tasksConf, "jib"),
			},
			PublishTask: v1.PublishTask{
				BaseImage: t.getBaseImage(e),
				Image:     imageName,
				Registry:  e.Platform.Status.Build.Registry,
			},
		}}
		if t.ImagePlatforms != nil {
			jibTask.Jib.Configuration.ImagePlatforms = t.ImagePlatforms
		}
		pipelineTasks = append(pipelineTasks, jibTask)

	case v1.IntegrationPlatformBuildPublishStrategyS2I:
		pipelineTasks = append(pipelineTasks, v1.Task{S2i: &v1.S2iTask{
			BaseTask: v1.BaseTask{
				Name:          "s2i",
				Configuration: *taskConfOrDefault(tasksConf, "s2i"),
			},
			PublishTask: v1.PublishTask{
				BaseImage: t.getBaseImage(e),
				Image:     imageName,
			},
			Tag: tag,
		}})
	}

	// filter only those tasks required by the user
	if t.TasksFilter != "" {
		flt := strings.Split(t.TasksFilter, ",")
		if pipelineTasks, err = filter(pipelineTasks, flt); err != nil {
			if err := failIntegrationKit(
				e,
				"IntegrationKitTasksValid",
				corev1.ConditionFalse,
				"IntegrationKitTasksValid",
				err.Error(),
			); err != nil {
				return err
			}
			return err
		}
	}
	// add local pipeline tasks to env pipeline
	e.Pipeline = append(e.Pipeline, pipelineTasks...)
	return nil
}