func()

in pkg/controller/integrationkit/build.go [70:178]
87 lines of code
24 McCabe index (conditional complexity)

func (action *buildAction) handleBuildSubmitted(ctx context.Context, kit *v1.IntegrationKit) (*v1.IntegrationKit, error) {
	build, err := kubernetes.GetBuild(ctx, action.client, kit.Name, kit.Namespace)
	if err != nil && !k8serrors.IsNotFound(err) {
		return nil, err
	}

	if err != nil && k8serrors.IsNotFound(err) ||
		build.Status.Phase == v1.BuildPhaseError ||
		build.Status.Phase == v1.BuildPhaseInterrupted ||
		build.Status.Phase == v1.BuildPhaseSucceeded {

		env, err := trait.Apply(ctx, action.client, nil, kit)
		if err != nil {
			return nil, err
		}

		if env.CamelCatalog == nil {
			return nil, errors.New("undefined camel catalog")
		}

		labels := kubernetes.FilterCamelCreatorLabels(kit.Labels)
		labels[v1.IntegrationKitLayoutLabel] = kit.Labels[v1.IntegrationKitLayoutLabel]

		annotations := make(map[string]string)
		if v, ok := kit.Annotations[v1.PlatformSelectorAnnotation]; ok {
			annotations[v1.PlatformSelectorAnnotation] = v
		}
		operatorID := defaults.OperatorID()
		if operatorID != "" {
			annotations[v1.OperatorIDAnnotation] = operatorID
		}

		timeout := env.Platform.Status.Build.GetTimeout()
		if layout := labels[v1.IntegrationKitLayoutLabel]; env.Platform.Spec.Build.Timeout == nil && layout == v1.IntegrationKitLayoutNative {
			// Increase the timeout to a sensible default
			timeout = metav1.Duration{
				Duration: 10 * time.Minute,
			}
		}

		// We may need to change certain builder configuration values
		operatorNamespace := platform.GetOperatorNamespace()
		buildConfig := v1.BuilderConfigurationTasks(env.Pipeline)
		if buildConfig.IsEmpty() {
			// default to IntegrationPlatform configuration
			buildConfig = &env.Platform.Status.Build.BuildConfiguration
		} else {
			if buildConfig.Strategy == "" {
				// we always need to define a strategy, so we default to platform if none
				buildConfig.Strategy = env.Platform.Status.Build.BuildConfiguration.Strategy
			}

			if buildConfig.OrderStrategy == "" {
				// we always need to define an order strategy, so we default to platform if none
				buildConfig.OrderStrategy = env.Platform.Status.Build.BuildConfiguration.OrderStrategy
			}
		}

		// nolint: contextcheck
		if buildConfig.Strategy == v1.BuildStrategyPod {
			err = platform.CreateBuilderServiceAccount(env.Ctx, env.Client, env.Platform)
			if err != nil {
				return nil, fmt.Errorf("error while creating Camel K Builder service account: %w", err)
			}
		}
		buildConfig.ToolImage = env.CamelCatalog.Image
		buildConfig.BuilderPodNamespace = operatorNamespace
		v1.SetBuilderConfigurationTasks(env.Pipeline, buildConfig)

		build = &v1.Build{
			TypeMeta: metav1.TypeMeta{
				APIVersion: v1.SchemeGroupVersion.String(),
				Kind:       v1.BuildKind,
			},
			ObjectMeta: metav1.ObjectMeta{
				Namespace:   kit.Namespace,
				Name:        kit.Name,
				Labels:      labels,
				Annotations: annotations,
			},
			Spec: v1.BuildSpec{
				Tasks:   env.Pipeline,
				Timeout: timeout,
			},
		}

		// Set the integration kit instance as the owner and controller
		if err := controllerutil.SetControllerReference(kit, build, action.client.GetScheme()); err != nil {
			return nil, err
		}

		err = action.client.Delete(ctx, build)
		if err != nil && !k8serrors.IsNotFound(err) {
			return nil, fmt.Errorf("cannot delete build: %w", err)
		}

		err = action.client.Create(ctx, build)
		if err != nil {
			return nil, fmt.Errorf("cannot create build: %w", err)
		}
	}

	if build.Status.Phase == v1.BuildPhaseRunning {
		kit.Status.Phase = v1.IntegrationKitPhaseBuildRunning
		return kit, nil
	}

	return nil, nil
}