feat: port apply command from influxdb (#160)

2021-06-30 14:47:23 -04:00
parent d7b2983dd4
commit a3f36a9821
8 changed files with 1037 additions and 8 deletions
--- a/cmd/influx/apply.go
+++ b/cmd/influx/apply.go
@ -0,0 +1,273 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"net/url"
+	"os"
+	"strings"
+
+	"github.com/influxdata/influx-cli/v2/clients/apply"
+	"github.com/influxdata/influx-cli/v2/pkg/cli/middleware"
+	"github.com/mattn/go-isatty"
+	"github.com/urfave/cli"
+)
+
+func newApplyCmd() cli.Command {
+	var params struct {
+		orgId          string
+		orgName        string
+		stackId        string
+		inPaths        cli.StringSlice
+		inUrls         cli.StringSlice
+		recursive      bool
+		encoding       apply.TemplateEncoding
+		noColor        bool
+		noTableBorders bool
+		quiet          bool
+		force          string
+		secrets        cli.StringSlice
+		envVars        cli.StringSlice
+		filters        cli.StringSlice
+	}
+	return cli.Command{
+		Name:  "apply",
+		Usage: "Apply a template to manage resources",
+		Description: `The apply command applies InfluxDB template(s). Use the command to create new
+resources via a declarative template. The apply command can consume templates
+via file(s), url(s), stdin, or any combination of the 3. Each run of the apply
+command ensures that all templates applied are applied in unison as a transaction.
+If any unexpected errors are discovered then all side effects are rolled back.
+
+Examples:
+	# Apply a template via a file
+	influx apply -f $PATH_TO_TEMPLATE/template.json
+
+	# Apply a stack that has associated templates. In this example the stack has a remote
+	# template associated with it.
+	influx apply --stack-id $STACK_ID
+
+	# Apply a template associated with a stack. Stacks make template application idempotent.
+	influx apply -f $PATH_TO_TEMPLATE/template.json --stack-id $STACK_ID
+
+	# Apply multiple template files together (mix of yaml and json)
+	influx apply \
+		-f $PATH_TO_TEMPLATE/template_1.json \
+		-f $PATH_TO_TEMPLATE/template_2.yml
+
+	# Apply a template from a url
+	influx apply -u https://raw.githubusercontent.com/influxdata/community-templates/master/docker/docker.yml
+
+	# Apply a template from STDIN
+	cat $TEMPLATE.json | influx apply --encoding json
+
+	# Applying a directory of templates, takes everything from provided directory
+	influx apply -f $PATH_TO_TEMPLATE_DIR
+
+	# Applying a directory of templates, recursively descending into child directories
+	influx apply -R -f $PATH_TO_TEMPLATE_DIR
+
+	# Applying directories from many sources, file and URL
+	influx apply -f $PATH_TO_TEMPLATE/template.yml -f $URL_TO_TEMPLATE
+
+	# Applying a template with actions to skip resources applied. The
+	# following example skips all buckets and the dashboard whose 
+	# metadata.name field matches the provided $DASHBOARD_TMPL_NAME.
+	# format for filters:
+	#	--filter=kind=Bucket
+	#	--filter=resource=Label:$Label_TMPL_NAME
+	influx apply \
+		-f $PATH_TO_TEMPLATE/template.yml \
+		--filter kind=Bucket \
+		--filter resource=Dashboard:$DASHBOARD_TMPL_NAME
+
+For information about finding and using InfluxDB templates, see
+https://docs.influxdata.com/influxdb/latest/reference/cli/influx/apply/.
+
+For more templates created by the community, see
+https://github.com/influxdata/community-templates.
+`,
+		Flags: append(
+			commonFlags(),
+			&cli.StringFlag{
+				Name:        "org-id",
+				Usage:       "The ID of the organization",
+				EnvVar:      "INFLUX_ORG_ID",
+				Destination: &params.orgId,
+			},
+			&cli.StringFlag{
+				Name:        "org, o",
+				Usage:       "The name of the organization",
+				EnvVar:      "INFLUX_ORG",
+				Destination: &params.orgName,
+			},
+			&cli.StringFlag{
+				Name:        "stack-id",
+				Usage:       "Stack ID to associate with template application",
+				Destination: &params.stackId,
+			},
+			&cli.StringSliceFlag{
+				Name:      "file, f",
+				Usage:     "Path to template file; Supports file paths or (deprecated) HTTP(S) URLs",
+				TakesFile: true,
+				Value:     &params.inPaths,
+			},
+			&cli.StringSliceFlag{
+				Name:  "template-url, u",
+				Usage: "HTTP(S) URL to template file",
+				Value: &params.inUrls,
+			},
+			&cli.BoolFlag{
+				Name:        "recurse, R",
+				Usage:       "Process the directory used in -f, --file recursively. Useful when you want to manage related templates organized within the same directory.",
+				Destination: &params.recursive,
+			},
+			&cli.GenericFlag{
+				Name:  "encoding, e",
+				Usage: "Encoding for the input stream. If a file is provided will gather encoding type from file extension. If extension provided will override.",
+				Value: &params.encoding,
+			},
+			&cli.BoolFlag{
+				Name:        "disable-color",
+				Usage:       "Disable color in output",
+				Destination: &params.noColor,
+			},
+			&cli.BoolFlag{
+				Name:        "disable-table-borders",
+				Usage:       "Disable table borders",
+				Destination: &params.noTableBorders,
+			},
+			&cli.BoolFlag{
+				Name:        "quiet, q",
+				Usage:       "Disable output printing",
+				Destination: &params.quiet,
+			},
+			&cli.StringFlag{
+				Name:        "force",
+				Usage:       "Set to 'true' to skip confirmation before applying changes. Set to 'conflict' to skip confirmation and overwrite existing resources",
+				Destination: &params.force,
+			},
+			&cli.StringSliceFlag{
+				Name:  "secret",
+				Usage: "Secrets to provide alongside the template; format --secret SECRET_KEY=SECRET_VALUE --secret SECRET_KEY_2=SECRET_VALUE_2",
+				Value: &params.secrets,
+			},
+			&cli.StringSliceFlag{
+				Name:  "env-ref",
+				Usage: "Environment references to provide alongside the template; format --env-ref REF_KEY=REF_VALUE --env-ref REF_KEY_2=REF_VALUE_2",
+				Value: &params.envVars,
+			},
+			&cli.StringSliceFlag{
+				Name:  "filter",
+				Usage: "Resources to skip when applying the template. Filter out by `kind` or by `resource`",
+				Value: &params.filters,
+			},
+		),
+		Before: middleware.WithBeforeFns(withCli(), withApi(true)),
+		Action: func(ctx *cli.Context) error {
+			parsedParams := apply.Params{
+				OrgId:              params.orgId,
+				OrgName:            params.orgName,
+				StackId:            params.stackId,
+				Recursive:          params.recursive,
+				Quiet:              params.quiet,
+				RenderTableBorders: !params.noTableBorders,
+				RenderTableColors:  !params.noColor,
+				Secrets:            make(map[string]string, len(params.secrets.Value())),
+				EnvVars:            make(map[string]string, len(params.envVars.Value())),
+				Filters:            make([]apply.ResourceFilter, len(params.filters.Value())),
+			}
+
+			// Collect all the sources the CLI needs to read templates from.
+			var deprecationShown bool
+			for _, in := range params.inPaths.Value() {
+				// Heuristic to guess what's a URL and what's a local file.
+				// TODO: Remove this once we stop supporting URLs in the --file arg.
+				u, err := url.Parse(in)
+				if err != nil {
+					return fmt.Errorf("failed to parse input path %q: %w", in, err)
+				}
+				if strings.HasPrefix(u.Scheme, "http") {
+					if !deprecationShown {
+						log.Println("WARN: Passing URLs via -f/--file is deprecated, please use -u/--template-url instead")
+						deprecationShown = true
+					}
+					parsedParams.Sources = append(parsedParams.Sources, apply.SourceFromURL(u, params.encoding))
+				} else {
+					fileSources, err := apply.SourcesFromPath(in, params.recursive, params.encoding)
+					if err != nil {
+						return err
+					}
+					parsedParams.Sources = append(parsedParams.Sources, fileSources...)
+				}
+			}
+			for _, in := range params.inUrls.Value() {
+				u, err := url.Parse(in)
+				if err != nil {
+					return fmt.Errorf("failed to parse input URL %q: %w", in, err)
+				}
+				parsedParams.Sources = append(parsedParams.Sources, apply.SourceFromURL(u, params.encoding))
+			}
+			if !isatty.IsTerminal(os.Stdin.Fd()) {
+				parsedParams.Sources = append(parsedParams.Sources, apply.SourceFromReader(os.Stdin, params.encoding))
+			}
+
+			// Parse env and secret values.
+			for _, e := range params.envVars.Value() {
+				pieces := strings.Split(e, "=")
+				if len(pieces) != 2 {
+					return fmt.Errorf("env-ref %q has invalid format, must be `REF_KEY=REF_VALUE`", e)
+				}
+				parsedParams.EnvVars[pieces[0]] = pieces[1]
+			}
+			for _, s := range params.secrets.Value() {
+				pieces := strings.Split(s, "=")
+				if len(pieces) != 2 {
+					return fmt.Errorf("secret %q has invalid format, must be `SECRET_KEY=SECRET_VALUE`", s)
+				}
+				parsedParams.Secrets[pieces[0]] = pieces[1]
+			}
+
+			// Parse filters.
+			for i, f := range params.filters.Value() {
+				pieces := strings.Split(f, "=")
+				if len(pieces) != 2 {
+					return fmt.Errorf("filter %q has invalid format, expected `resource=KIND:NAME` or `kind=KIND`", f)
+				}
+				key, val := pieces[0], pieces[1]
+				switch strings.ToLower(key) {
+				case "kind":
+					parsedParams.Filters[i] = apply.ResourceFilter{Kind: val}
+				case "resource":
+					valPieces := strings.Split(val, ":")
+					if len(valPieces) != 2 {
+						return fmt.Errorf("resource filter %q has invalid format, expected `resource=KIND:NAME", val)
+					}
+					kind, name := valPieces[0], valPieces[1]
+					parsedParams.Filters[i] = apply.ResourceFilter{Kind: kind, Name: &name}
+				default:
+					return fmt.Errorf("invalid filter type %q, supported values are `resource` and `kind`", key)
+				}
+			}
+
+			// Parse our strange way of passing 'force'
+			switch params.force {
+			case "conflict":
+				parsedParams.Force = true
+				parsedParams.OverwriteConflicts = true
+			case "true":
+				parsedParams.Force = true
+			default:
+			}
+
+			api := getAPI(ctx)
+			client := apply.Client{
+				CLI:              getCLI(ctx),
+				TemplatesApi:     api.TemplatesApi,
+				OrganizationsApi: api.OrganizationsApi,
+			}
+
+			return client.Apply(getContext(ctx), &parsedParams)
+		},
+	}
+}