func()

in pkg/cmd/kit_create.go [86:185]
81 lines of code
19 McCabe index (conditional complexity)

func (command *kitCreateCommandOptions) run(cmd *cobra.Command, args []string) error {
	c, err := command.GetCmdClient()
	if err != nil {
		return err
	}
	catalog := trait.NewCatalog(c)
	kit := v1.NewIntegrationKit(command.Namespace, args[0])
	key := ctrl.ObjectKey{
		Namespace: command.Namespace,
		Name:      args[0],
	}
	if err := c.Get(command.Context, key, kit); err == nil {
		// the integration kit already exists, let's check that it is
		// not a platform one which is supposed to be "read only"

		if kit.Labels[v1.IntegrationKitTypeLabel] == v1.IntegrationKitTypePlatform {
			fmt.Fprintln(cmd.OutOrStdout(), `integration kit "`+kit.Name+`" is not editable`)
			return nil
		}
	}

	kit = v1.NewIntegrationKit(command.Namespace, kubernetes.SanitizeName(args[0]))

	if command.OperatorID != "" {
		// --operator-id={id} is a syntax sugar for '--annotation camel.apache.org/operator.id={id}'
		kit.SetOperatorID(strings.TrimSpace(command.OperatorID))
	}

	kit.Labels = map[string]string{
		v1.IntegrationKitTypeLabel: v1.IntegrationKitTypeUser,
	}
	kit.Spec = v1.IntegrationKitSpec{
		Dependencies:  make([]string, 0, len(command.Dependencies)),
		Configuration: make([]v1.ConfigurationSpec, 0),
		Repositories:  command.Repositories,
	}

	if command.Image != "" {
		// if the Image is set, the kit do not require any build but
		// is be marked as external as the information about the classpath
		// is missing so it cannot be used as base for other Kits
		kit.Labels[v1.IntegrationKitTypeLabel] = v1.IntegrationKitTypeExternal

		// Set the Image to be used by the kit
		kit.Spec.Image = command.Image
	}
	for _, item := range command.Dependencies {
		switch {
		case strings.HasPrefix(item, "camel-quarkus-"):
			kit.Spec.Dependencies = append(kit.Spec.Dependencies, "camel:"+strings.TrimPrefix(item, "camel-quarkus-"))
		case strings.HasPrefix(item, "camel-k-"):
			kit.Spec.Dependencies = append(kit.Spec.Dependencies, "camel-k:"+strings.TrimPrefix(item, "camel-k-"))
		case strings.HasPrefix(item, "camel-"):
			kit.Spec.Dependencies = append(kit.Spec.Dependencies, "camel:"+strings.TrimPrefix(item, "camel-"))
		default:
			kit.Spec.Dependencies = append(kit.Spec.Dependencies, item)
		}
	}

	if err := command.parseAndConvertToTrait(command.Properties, "camel.properties"); err != nil {
		return err
	}

	if err := command.parseAndConvertToTrait(command.Configmaps, "mount.config"); err != nil {
		return err
	}

	if err := command.parseAndConvertToTrait(command.Secrets, "mount.config"); err != nil {
		return err
	}
	if err := trait.ConfigureTraits(command.Traits, &kit.Spec.Traits, catalog); err != nil {
		return err
	}
	existed := false
	err = c.Create(command.Context, kit)
	if err != nil && k8serrors.IsAlreadyExists(err) {
		existed = true
		existing := v1.NewIntegrationKit(kit.Namespace, kit.Name)
		err = c.Get(command.Context, key, existing)
		if err != nil {
			fmt.Fprint(cmd.ErrOrStderr(), err.Error())
			return nil
		}
		kit.ResourceVersion = existing.ResourceVersion
		err = c.Update(command.Context, kit)
	}

	if err != nil {
		fmt.Fprint(cmd.ErrOrStderr(), err.Error())
		return nil
	}

	if !existed {
		fmt.Fprintln(cmd.OutOrStdout(), `integration kit "`+kit.Name+`" created`)
	} else {
		fmt.Fprintln(cmd.OutOrStdout(), `integration kit "`+kit.Name+`" updated`)
	}

	return nil
}