config.go

package flagparser

import (
	"fmt"
	"strings"

	"github.com/moby/swarmkit/swarmd/cmd/swarmctl/common"
	"github.com/moby/swarmkit/v2/api"
	"github.com/spf13/cobra"
)

// expects configs in the format CONFIG_NAME:TARGET_NAME
func parseConfigString(configString string) (configName, presentName string, err error) {
	tokens := strings.Split(configString, ":")

	configName = strings.TrimSpace(tokens[0])

	if configName == "" {
		err = fmt.Errorf("invalid config name provided")
		return
	}

	if len(tokens) > 1 {
		presentName = strings.TrimSpace(tokens[1])
		if presentName == "" {
			err = fmt.Errorf("invalid presentation name provided")
			return
		}
	} else {
		presentName = configName
	}
	return
}

// ParseAddConfig validates configs passed on the command line
func ParseAddConfig(cmd *cobra.Command, spec *api.ServiceSpec, flagName string) error {
	flags := cmd.Flags()

	if flags.Changed(flagName) {
		configs, err := flags.GetStringSlice(flagName)
		if err != nil {
			return err
		}

		container := spec.Task.GetContainer()
		if container == nil {
			spec.Task.Runtime = &api.TaskSpec_Container{
				Container: &api.ContainerSpec{},
			}
		}

		lookupConfigNames := []string{}
		var needConfigs []*api.ConfigReference

		for _, config := range configs {
			n, p, err := parseConfigString(config)
			if err != nil {
				return err
			}

			// TODO(diogo): defaults to File targets, but in the future will take different types
			configRef := &api.ConfigReference{
				ConfigName: n,
				Target: &api.ConfigReference_File{
					File: &api.FileTarget{
						Name: p,
						Mode: 0444,
					},
				},
			}

			lookupConfigNames = append(lookupConfigNames, n)
			needConfigs = append(needConfigs, configRef)
		}

		client, err := common.Dial(cmd)
		if err != nil {
			return err
		}

		r, err := client.ListConfigs(common.Context(cmd),
			&api.ListConfigsRequest{Filters: &api.ListConfigsRequest_Filters{Names: lookupConfigNames}})
		if err != nil {
			return err
		}

		foundConfigs := make(map[string]*api.Config)
		for _, config := range r.Configs {
			foundConfigs[config.Spec.Annotations.Name] = config
		}

		for _, configRef := range needConfigs {
			config, ok := foundConfigs[configRef.ConfigName]
			if !ok {
				return fmt.Errorf("config not found: %s", configRef.ConfigName)
			}

			configRef.ConfigID = config.ID
			container.Configs = append(container.Configs, configRef)
		}
	}

	return nil
}

// ParseRemoveConfig removes a set of configs from the task spec's config references
func ParseRemoveConfig(cmd *cobra.Command, spec *api.ServiceSpec, flagName string) error {
	flags := cmd.Flags()

	if flags.Changed(flagName) {
		configs, err := flags.GetStringSlice(flagName)
		if err != nil {
			return err
		}

		container := spec.Task.GetContainer()
		if container == nil {
			return nil
		}

		wantToDelete := make(map[string]struct{})

		for _, config := range configs {
			n, _, err := parseConfigString(config)
			if err != nil {
				return err
			}

			wantToDelete[n] = struct{}{}
		}

		configRefs := []*api.ConfigReference{}

		for _, configRef := range container.Configs {
			if _, ok := wantToDelete[configRef.ConfigName]; ok {
				continue
			}
			configRefs = append(configRefs, configRef)
		}

		container.Configs = configRefs
	}
	return nil
}