Code Generation: Sort resources and imports

cmd/generate/main.go

@@ -1,12 +1,163 @@
 package main
 
 import (
+	"fmt"
 	"log"
+	"os"
+	"strings"
+
+	"github.com/grafana/terraform-provider-grafana/v2/pkg/generate"
+
+	"github.com/fatih/color"
+	"github.com/urfave/cli/v2"
 )
 
+var version = "" // set by ldflags
+
 func main() {
 	err := run()
 	if err != nil {
 		log.Fatal(err)
 	}
 }
+
+func run() error {
+	msg := "WARNING: This tool is highly experimental and comes with no support or guarantees."
+	lines := strings.Repeat("-", len(msg))
+	color.New(color.FgRed, color.Bold).Fprintf(os.Stderr, "%[2]s\n%[1]s\n%[2]s\n", msg, lines)
+	app := &cli.App{
+		Name:      "terraform-provider-grafana-generate",
+		Usage:     "Generate `terraform-provider-grafana` resources from your Grafana instance or Grafana Cloud account.",
+		UsageText: "terraform-provider-grafana-generate [options]",
+		Flags: []cli.Flag{
+			&cli.StringFlag{
+				Name:     "output-dir",
+				Aliases:  []string{"o"},
+				Usage:    "Output directory for generated resources",
+				Required: true,
+				EnvVars:  []string{"TFGEN_OUTPUT_DIR"},
+			},
+			&cli.BoolFlag{
+				Name:    "clobber",
+				Aliases: []string{"c"},
+				Usage:   "Delete all files in the output directory before generating resources",
+				EnvVars: []string{"TFGEN_CLOBBER"},
+			},
+			&cli.StringFlag{
+				Name:    "output-format",
+				Aliases: []string{"f"},
+				Usage: fmt.Sprintf("Output format for generated resources. "+
+					"Supported formats are: %v", generate.OutputFormats),
+				Value:   string(generate.OutputFormatHCL),
+				EnvVars: []string{"TFGEN_OUTPUT_FORMAT"},
+			},
+			&cli.StringFlag{
+				Name:    "terraform-provider-version",
+				Usage:   "Version of the Grafana provider to generate resources for. Defaults to the release version (same as the generator version).",
+				EnvVars: []string{"TFGEN_TERRAFORM_PROVIDER_VERSION"},
+				Value:   version,
+			},
+
+			// Grafana OSS flags
+			&cli.StringFlag{
+				Name:     "grafana-url",
+				Usage:    "URL of the Grafana instance to generate resources from",
+				Category: "Grafana",
+				EnvVars:  []string{"TF_GEN_GRAFANA_URL"},
+			},
+			&cli.StringFlag{
+				Name:     "grafana-auth",
+				Usage:    "Service account token or username:password for the Grafana instance",
+				Category: "Grafana",
+				EnvVars:  []string{"TFGEN_GRAFANA_AUTH"},
+			},
+
+			// Grafana Cloud flags
+			&cli.StringFlag{
+				Name:     "cloud-access-policy-token",
+				Usage:    "Access policy token for Grafana Cloud",
+				Category: "Grafana Cloud",
+				EnvVars:  []string{"TFGEN_CLOUD_ACCESS_POLICY_TOKEN"},
+			},
+			&cli.StringFlag{
+				Name:     "cloud-org",
+				Usage:    "Organization ID or name for Grafana Cloud",
+				Category: "Grafana Cloud",
+				EnvVars:  []string{"TFGEN_CLOUD_ORG"},
+			},
+			&cli.BoolFlag{
+				Name:     "cloud-create-stack-service-account",
+				Usage:    "Create a service account for each Grafana Cloud stack, allowing generation and management of resources in that stack.",
+				Category: "Grafana Cloud",
+				EnvVars:  []string{"TFGEN_CLOUD_CREATE_STACK_SERVICE_ACCOUNT"},
+			},
+			&cli.StringFlag{
+				Name:     "cloud-stack-service-account-name",
+				Usage:    "Name of the service account to create for each Grafana Cloud stack.",
+				Category: "Grafana Cloud",
+				EnvVars:  []string{"TFGEN_CLOUD_STACK_SERVICE_ACCOUNT_NAME"},
+				Value:    "tfgen-management",
+			},
+		},
+		InvalidFlagAccessHandler: func(ctx *cli.Context, s string) {
+			panic(fmt.Errorf("invalid flag access: %s", s))
+		},
+		Action: func(ctx *cli.Context) error {
+			cfg, err := parseFlags(ctx)
+			if err != nil {
+				return fmt.Errorf("failed to parse flags: %w", err)
+			}
+			return generate.Generate(ctx.Context, cfg)
+		},
+	}
+
+	return app.Run(os.Args)
+}
+
+func parseFlags(ctx *cli.Context) (*generate.Config, error) {
+	config := &generate.Config{
+		OutputDir:       ctx.String("output-dir"),
+		Clobber:         ctx.Bool("clobber"),
+		Format:          generate.OutputFormat(ctx.String("output-format")),
+		ProviderVersion: ctx.String("terraform-provider-version"),
+		Grafana: &generate.GrafanaConfig{
+			URL:  ctx.String("grafana-url"),
+			Auth: ctx.String("grafana-auth"),
+		},
+		Cloud: &generate.CloudConfig{
+			AccessPolicyToken:         ctx.String("cloud-access-policy-token"),
+			Org:                       ctx.String("cloud-org"),
+			CreateStackServiceAccount: ctx.Bool("cloud-create-stack-service-account"),
+			StackServiceAccountName:   ctx.String("cloud-stack-service-account-name"),
+		},
+	}
+
+	if config.ProviderVersion == "" {
+		return nil, fmt.Errorf("terraform-provider-version must be set")
+	}
+
+	// Validate flags
+	err := newFlagValidations().
+		atLeastOne("grafana-url", "cloud-access-policy-token").
+		conflicting(
+			[]string{"grafana-url", "grafana-auth"},
+			[]string{"cloud-access-policy-token", "cloud-org", "cloud-create-stack-service-account", "cloud-stack-service-account-name"},
+		).
+		requiredWhenSet("grafana-url", "grafana-auth").
+		requiredWhenSet("cloud-access-policy-token", "cloud-org").
+		requiredWhenSet("cloud-stack-service-account-name", "cloud-create-stack-service-account").
+		validate(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	if config.Grafana.Auth == "" {
+		config.Grafana = nil
+	}
+
+	if config.Cloud.AccessPolicyToken == "" {
+		config.Cloud = nil
+	}
+
+	return config, nil
+}

cmd/generate/cloud.go → pkg/generate/cloud.go

@@ -1,4 +1,4 @@
-package main
+package generate
 
 import (
 	"context"
@@ -26,18 +26,18 @@ type stack struct {
 	smToken       string
 }
 
-func generateCloudResources(ctx context.Context, cfg *config) ([]stack, error) {
+func generateCloudResources(ctx context.Context, cfg *Config) ([]stack, error) {
 	// Gen provider
 	providerBlock := hclwrite.NewBlock("provider", []string{"grafana"})
 	providerBlock.Body().SetAttributeValue("alias", cty.StringVal("cloud"))
-	providerBlock.Body().SetAttributeValue("cloud_access_policy_token", cty.StringVal(cfg.cloudAccessPolicyToken))
-	if err := writeBlocks(filepath.Join(cfg.outputDir, "cloud-provider.tf"), providerBlock); err != nil {
+	providerBlock.Body().SetAttributeValue("cloud_access_policy_token", cty.StringVal(cfg.Cloud.AccessPolicyToken))
+	if err := writeBlocks(filepath.Join(cfg.OutputDir, "cloud-provider.tf"), providerBlock); err != nil {
 		return nil, err
 	}
 
 	// Generate imports
 	config := provider.ProviderConfig{
-		CloudAccessPolicyToken: types.StringValue(cfg.cloudAccessPolicyToken),
+		CloudAccessPolicyToken: types.StringValue(cfg.Cloud.AccessPolicyToken),
 	}
 	if err := config.SetDefaults(); err != nil {
 		return nil, err
@@ -55,30 +55,30 @@ func generateCloudResources(ctx context.Context, cfg *config) ([]stack, error) {
 	}
 
 	// Cleanup SAs
-	managementServiceAccountName := cfg.cloudStackServiceAccountName
+	managementServiceAccountName := cfg.Cloud.StackServiceAccountName
 
-	if cfg.cloudCreateStackServiceAccount {
+	if cfg.Cloud.CreateStackServiceAccount {
 		for _, stack := range stacks.Items {
 			if err := createManagementStackServiceAccount(ctx, cloudClient, stack, managementServiceAccountName); err != nil {
 				return nil, err
 			}
 		}
 	}
 
-	data := cloud.NewListerData(cfg.cloudOrg)
-	if err := generateImportBlocks(ctx, client, data, cloud.Resources, cfg.outputDir, "cloud"); err != nil {
+	data := cloud.NewListerData(cfg.Cloud.Org)
+	if err := generateImportBlocks(ctx, client, data, cloud.Resources, cfg.OutputDir, "cloud"); err != nil {
 		return nil, err
 	}
 
 	log.Println("Post-processing for cloud")
-	if err := stripDefaults(filepath.Join(cfg.outputDir, "cloud-resources.tf"), map[string]string{}); err != nil {
+	if err := stripDefaults(filepath.Join(cfg.OutputDir, "cloud-resources.tf"), map[string]string{}); err != nil {
 		return nil, err
 	}
-	if err := wrapJSONFieldsInFunction(filepath.Join(cfg.outputDir, "cloud-resources.tf")); err != nil {
+	if err := wrapJSONFieldsInFunction(filepath.Join(cfg.OutputDir, "cloud-resources.tf")); err != nil {
 		return nil, err
 	}
 
-	if !cfg.cloudCreateStackServiceAccount {
+	if !cfg.Cloud.CreateStackServiceAccount {
 		return nil, nil
 	}
 
@@ -135,12 +135,12 @@ func generateCloudResources(ctx context.Context, cfg *config) ([]stack, error) {
 		providerBlock.Body().SetAttributeTraversal("sm_access_token", traversal("grafana_synthetic_monitoring_installation", stack.Slug, "sm_access_token"))
 		providerBlock.Body().SetAttributeTraversal("sm_url", traversal("grafana_synthetic_monitoring_installation", stack.Slug, "stack_sm_api_url"))
 
-		if err := writeBlocks(filepath.Join(cfg.outputDir, fmt.Sprintf("stack-%s-provider.tf", stack.Slug)), saBlock, saTokenBlock, smInstallationMetricsPublishBlock, smInstallationTokenBlock, smInstallationBlock, providerBlock); err != nil {
+		if err := writeBlocks(filepath.Join(cfg.OutputDir, fmt.Sprintf("stack-%s-provider.tf", stack.Slug)), saBlock, saTokenBlock, smInstallationMetricsPublishBlock, smInstallationTokenBlock, smInstallationBlock, providerBlock); err != nil {
 			return nil, fmt.Errorf("failed to write management service account blocks for stack %q: %w", stack.Slug, err)
 		}
 
 		// Apply then go into the state and find the management key
-		err := runTerraform(cfg.outputDir, "apply", "-auto-approve",
+		err := runTerraform(cfg.OutputDir, "apply", "-auto-approve",
 			"-target=grafana_cloud_stack_service_account."+stack.Slug,
 			"-target=grafana_cloud_stack_service_account_token."+stack.Slug,
 			"-target=grafana_cloud_access_policy."+policyResourceName,
@@ -153,7 +153,7 @@ func generateCloudResources(ctx context.Context, cfg *config) ([]stack, error) {
 	}
 
 	managedStacks := []stack{}
-	state, err := getState(cfg.outputDir)
+	state, err := getState(cfg.OutputDir)
 	if err != nil {
 		return nil, err
 	}