From e3379d7c88e5d0d6252461c91427d1cf8d5018c5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Palet?= Date: Tue, 16 Apr 2024 15:25:21 +0100 Subject: [PATCH 01/17] Add `argus grafana describe` command (#221) * Add `argus grafana config describe` command * Extend command to also show dashboard URL * Generate docs * Improve command descriptions * Adjust function names * Show initial Grafana credentials in output * Add example for showing password * Change to hide-password flag --- docs/stackit.md | 13 - docs/stackit_argus.md | 1 + docs/stackit_argus_grafana.md | 33 +++ docs/stackit_argus_grafana_describe.md | 49 ++++ internal/cmd/argus/argus.go | 4 +- .../cmd/argus/grafana/describe/describe.go | 148 ++++++++++ .../argus/grafana/describe/describe_test.go | 263 ++++++++++++++++++ internal/cmd/argus/grafana/grafana.go | 26 ++ 8 files changed, 523 insertions(+), 14 deletions(-) create mode 100644 docs/stackit_argus_grafana.md create mode 100644 docs/stackit_argus_grafana_describe.md create mode 100644 internal/cmd/argus/grafana/describe/describe.go create mode 100644 internal/cmd/argus/grafana/describe/describe_test.go create mode 100644 internal/cmd/argus/grafana/grafana.go diff --git a/docs/stackit.md b/docs/stackit.md index eaa87cd07..7dacfde65 100644 --- a/docs/stackit.md +++ b/docs/stackit.md @@ -26,35 +26,22 @@ stackit [flags] ### SEE ALSO -* [stackit argus](./stackit_argus.md) - Provides functionality for Argus * [stackit argus](./stackit_argus.md) - Provides functionality for Argus * [stackit auth](./stackit_auth.md) - Provides authentication functionality * [stackit config](./stackit_config.md) - Provides functionality for CLI configuration options * [stackit curl](./stackit_curl.md) - Executes an authenticated HTTP request to an endpoint * [stackit dns](./stackit_dns.md) - Provides functionality for DNS * [stackit logme](./stackit_logme.md) - Provides functionality for LogMe -* [stackit logme](./stackit_logme.md) - Provides functionality for LogMe * [stackit mariadb](./stackit_mariadb.md) - Provides functionality for MariaDB -* [stackit mariadb](./stackit_mariadb.md) - Provides functionality for MariaDB -* [stackit mongodbflex](./stackit_mongodbflex.md) - Provides functionality for MongoDB Flex * [stackit mongodbflex](./stackit_mongodbflex.md) - Provides functionality for MongoDB Flex * [stackit object-storage](./stackit_object-storage.md) - Provides functionality regarding Object Storage -* [stackit object-storage](./stackit_object-storage.md) - Provides functionality regarding Object Storage -* [stackit opensearch](./stackit_opensearch.md) - Provides functionality for OpenSearch * [stackit opensearch](./stackit_opensearch.md) - Provides functionality for OpenSearch * [stackit organization](./stackit_organization.md) - Provides functionality regarding organizations -* [stackit organization](./stackit_organization.md) - Provides functionality regarding organizations -* [stackit postgresflex](./stackit_postgresflex.md) - Provides functionality for PostgreSQL Flex * [stackit postgresflex](./stackit_postgresflex.md) - Provides functionality for PostgreSQL Flex * [stackit project](./stackit_project.md) - Provides functionality regarding projects * [stackit rabbitmq](./stackit_rabbitmq.md) - Provides functionality for RabbitMQ -* [stackit rabbitmq](./stackit_rabbitmq.md) - Provides functionality for RabbitMQ -* [stackit redis](./stackit_redis.md) - Provides functionality for Redis * [stackit redis](./stackit_redis.md) - Provides functionality for Redis * [stackit secrets-manager](./stackit_secrets-manager.md) - Provides functionality for Secrets Manager -* [stackit secrets-manager](./stackit_secrets-manager.md) - Provides functionality for Secrets Manager -* [stackit service-account](./stackit_service-account.md) - Provides functionality for service accounts * [stackit service-account](./stackit_service-account.md) - Provides functionality for service accounts * [stackit ske](./stackit_ske.md) - Provides functionality for SKE -* [stackit ske](./stackit_ske.md) - Provides functionality for SKE diff --git a/docs/stackit_argus.md b/docs/stackit_argus.md index 659b1dc36..99585f43a 100644 --- a/docs/stackit_argus.md +++ b/docs/stackit_argus.md @@ -29,6 +29,7 @@ stackit argus [flags] ### SEE ALSO * [stackit](./stackit.md) - Manage STACKIT resources using the command line +* [stackit argus grafana](./stackit_argus_grafana.md) - Provides functionality for the Grafana configuration of Argus instances * [stackit argus instance](./stackit_argus_instance.md) - Provides functionality for Argus instances * [stackit argus plans](./stackit_argus_plans.md) - Lists all Argus service plans diff --git a/docs/stackit_argus_grafana.md b/docs/stackit_argus_grafana.md new file mode 100644 index 000000000..9d6714075 --- /dev/null +++ b/docs/stackit_argus_grafana.md @@ -0,0 +1,33 @@ +## stackit argus grafana + +Provides functionality for the Grafana configuration of Argus instances + +### Synopsis + +Provides functionality for the Grafana configuration of Argus instances. + +``` +stackit argus grafana [flags] +``` + +### Options + +``` + -h, --help Help for "stackit argus grafana" +``` + +### Options inherited from parent commands + +``` + -y, --assume-yes If set, skips all confirmation prompts + --async If set, runs the command asynchronously + -o, --output-format string Output format, one of ["json" "pretty"] + -p, --project-id string Project ID + --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") +``` + +### SEE ALSO + +* [stackit argus](./stackit_argus.md) - Provides functionality for Argus +* [stackit argus grafana describe](./stackit_argus_grafana_describe.md) - Shows details of the Grafana configuration of an Argus instance + diff --git a/docs/stackit_argus_grafana_describe.md b/docs/stackit_argus_grafana_describe.md new file mode 100644 index 000000000..086d30a42 --- /dev/null +++ b/docs/stackit_argus_grafana_describe.md @@ -0,0 +1,49 @@ +## stackit argus grafana describe + +Shows details of the Grafana configuration of an Argus instance + +### Synopsis + +Shows details of the Grafana configuration of an Argus instance. +The Grafana dashboard URL and initial credentials (admin user and password) will be shown in the "pretty" output format. These credentials are only valid for first login. Please change the password after first login. After changing, the initial password is no longer valid. +The initial password is shown by default, if you want to hide it use the "--hide-password" flag. + +``` +stackit argus grafana describe [flags] +``` + +### Examples + +``` + Get details of the Grafana configuration of an Argus instance with ID "xxx" + $ stackit argus credentials describe --instance-id xxx + + Get details of the Grafana configuration of an Argus instance with ID "xxx" in a table format + $ stackit argus credentials describe --instance-id xxx --output-format pretty + + Get details of the Grafana configuration of an Argus instance with ID "xxx" and hide the initial admin password + $ stackit argus credentials describe --instance-id xxx --output-format pretty --hide-password +``` + +### Options + +``` + -h, --help Help for "stackit argus grafana describe" + --hide-password Show the initial admin password in the "pretty" output format + --instance-id string Instance ID +``` + +### Options inherited from parent commands + +``` + -y, --assume-yes If set, skips all confirmation prompts + --async If set, runs the command asynchronously + -o, --output-format string Output format, one of ["json" "pretty"] + -p, --project-id string Project ID + --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") +``` + +### SEE ALSO + +* [stackit argus grafana](./stackit_argus_grafana.md) - Provides functionality for the Grafana configuration of Argus instances + diff --git a/internal/cmd/argus/argus.go b/internal/cmd/argus/argus.go index 38dc77321..4454a1c02 100644 --- a/internal/cmd/argus/argus.go +++ b/internal/cmd/argus/argus.go @@ -1,6 +1,7 @@ package argus import ( + "github.com/stackitcloud/stackit-cli/internal/cmd/argus/grafana" "github.com/stackitcloud/stackit-cli/internal/cmd/argus/instance" "github.com/stackitcloud/stackit-cli/internal/cmd/argus/plans" "github.com/stackitcloud/stackit-cli/internal/pkg/args" @@ -23,6 +24,7 @@ func NewCmd(p *print.Printer) *cobra.Command { } func addSubcommands(cmd *cobra.Command, p *print.Printer) { - cmd.AddCommand(plans.NewCmd(p)) + cmd.AddCommand(grafana.NewCmd(p)) cmd.AddCommand(instance.NewCmd(p)) + cmd.AddCommand(plans.NewCmd(p)) } diff --git a/internal/cmd/argus/grafana/describe/describe.go b/internal/cmd/argus/grafana/describe/describe.go new file mode 100644 index 000000000..a950591c0 --- /dev/null +++ b/internal/cmd/argus/grafana/describe/describe.go @@ -0,0 +1,148 @@ +package describe + +import ( + "context" + "encoding/json" + "fmt" + + "github.com/stackitcloud/stackit-cli/internal/pkg/args" + "github.com/stackitcloud/stackit-cli/internal/pkg/errors" + "github.com/stackitcloud/stackit-cli/internal/pkg/examples" + "github.com/stackitcloud/stackit-cli/internal/pkg/flags" + "github.com/stackitcloud/stackit-cli/internal/pkg/globalflags" + "github.com/stackitcloud/stackit-cli/internal/pkg/print" + "github.com/stackitcloud/stackit-cli/internal/pkg/services/argus/client" + "github.com/stackitcloud/stackit-cli/internal/pkg/tables" + + "github.com/spf13/cobra" + "github.com/stackitcloud/stackit-sdk-go/services/argus" +) + +const ( + instanceIdFlag = "instance-id" + hidePasswordFlag = "hide-password" +) + +type inputModel struct { + *globalflags.GlobalFlagModel + InstanceId string + HidePassword bool +} + +func NewCmd(p *print.Printer) *cobra.Command { + cmd := &cobra.Command{ + Use: "describe", + Short: "Shows details of the Grafana configuration of an Argus instance", + Long: fmt.Sprintf("%s\n%s\n%s", + "Shows details of the Grafana configuration of an Argus instance.", + `The Grafana dashboard URL and initial credentials (admin user and password) will be shown in the "pretty" output format. These credentials are only valid for first login. Please change the password after first login. After changing, the initial password is no longer valid.`, + `The initial password is shown by default, if you want to hide it use the "--hide-password" flag.`, + ), + Args: args.NoArgs, + Example: examples.Build( + examples.NewExample( + `Get details of the Grafana configuration of an Argus instance with ID "xxx"`, + "$ stackit argus credentials describe --instance-id xxx"), + examples.NewExample( + `Get details of the Grafana configuration of an Argus instance with ID "xxx" in a table format`, + "$ stackit argus credentials describe --instance-id xxx --output-format pretty"), + examples.NewExample( + `Get details of the Grafana configuration of an Argus instance with ID "xxx" and hide the initial admin password`, + "$ stackit argus credentials describe --instance-id xxx --output-format pretty --hide-password"), + ), + RunE: func(cmd *cobra.Command, args []string) error { + ctx := context.Background() + model, err := parseInput(cmd) + if err != nil { + return err + } + // Configure API client + apiClient, err := client.ConfigureClient(p) + if err != nil { + return err + } + + // Call API + grafanaConfigsReq := buildGetGrafanaConfigRequest(ctx, model, apiClient) + grafanaConfigsResp, err := grafanaConfigsReq.Execute() + if err != nil { + return fmt.Errorf("get Grafana configs: %w", err) + } + instanceReq := buildGetInstanceRequest(ctx, model, apiClient) + instanceResp, err := instanceReq.Execute() + if err != nil { + return fmt.Errorf("get instance: %w", err) + } + + return outputResult(p, model, grafanaConfigsResp, instanceResp) + }, + } + configureFlags(cmd) + return cmd +} + +func configureFlags(cmd *cobra.Command) { + cmd.Flags().Var(flags.UUIDFlag(), instanceIdFlag, "Instance ID") + cmd.Flags().Bool(hidePasswordFlag, false, `Show the initial admin password in the "pretty" output format`) + + err := flags.MarkFlagsRequired(cmd, instanceIdFlag) + cobra.CheckErr(err) +} + +func parseInput(cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(cmd) + if globalFlags.ProjectId == "" { + return nil, &errors.ProjectIdError{} + } + + return &inputModel{ + GlobalFlagModel: globalFlags, + InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + HidePassword: flags.FlagToBoolValue(cmd, hidePasswordFlag), + }, nil +} + +func buildGetGrafanaConfigRequest(ctx context.Context, model *inputModel, apiClient *argus.APIClient) argus.ApiGetGrafanaConfigsRequest { + req := apiClient.GetGrafanaConfigs(ctx, model.InstanceId, model.ProjectId) + return req +} + +func buildGetInstanceRequest(ctx context.Context, model *inputModel, apiClient *argus.APIClient) argus.ApiGetInstanceRequest { + req := apiClient.GetInstance(ctx, model.InstanceId, model.ProjectId) + return req +} + +func outputResult(p *print.Printer, inputModel *inputModel, grafanaConfigs *argus.GrafanaConfigs, instance *argus.GetInstanceResponse) error { + switch inputModel.OutputFormat { + case globalflags.PrettyOutputFormat: + initialAdminPassword := *instance.Instance.GrafanaAdminPassword + if inputModel.HidePassword { + initialAdminPassword = "" + } + + table := tables.NewTable() + table.AddRow("GRAFANA DASHBOARD", *instance.Instance.GrafanaUrl) + table.AddSeparator() + table.AddRow("PUBLIC READ ACCESS", *grafanaConfigs.PublicReadAccess) + table.AddSeparator() + table.AddRow("SINGLE SIGN-ON", *grafanaConfigs.UseStackitSso) + table.AddSeparator() + table.AddRow("INITIAL ADMIN USER (DEFAULT)", *instance.Instance.GrafanaAdminUser) + table.AddSeparator() + table.AddRow("INITIAL ADMIN PASSWORD (DEFAULT)", initialAdminPassword) + err := table.Display(p) + if err != nil { + return fmt.Errorf("render table: %w", err) + } + + return nil + default: + details, err := json.MarshalIndent(grafanaConfigs, "", " ") + if err != nil { + return fmt.Errorf("marshal Grafana configs: %w", err) + } + p.Outputln(string(details)) + + return nil + } +} diff --git a/internal/cmd/argus/grafana/describe/describe_test.go b/internal/cmd/argus/grafana/describe/describe_test.go new file mode 100644 index 000000000..b380f5257 --- /dev/null +++ b/internal/cmd/argus/grafana/describe/describe_test.go @@ -0,0 +1,263 @@ +package describe + +import ( + "context" + "testing" + + "github.com/stackitcloud/stackit-cli/internal/pkg/globalflags" + + "github.com/google/go-cmp/cmp" + "github.com/google/go-cmp/cmp/cmpopts" + "github.com/google/uuid" + "github.com/stackitcloud/stackit-sdk-go/services/argus" +) + +var projectIdFlag = globalflags.ProjectIdFlag + +type testCtxKey struct{} + +var testCtx = context.WithValue(context.Background(), testCtxKey{}, "foo") +var testClient = &argus.APIClient{} +var testProjectId = uuid.NewString() +var testInstanceId = uuid.NewString() + +func fixtureFlagValues(mods ...func(flagValues map[string]string)) map[string]string { + flagValues := map[string]string{ + projectIdFlag: testProjectId, + instanceIdFlag: testInstanceId, + } + for _, mod := range mods { + mod(flagValues) + } + return flagValues +} + +func fixtureInputModel(mods ...func(model *inputModel)) *inputModel { + model := &inputModel{ + GlobalFlagModel: &globalflags.GlobalFlagModel{ + ProjectId: testProjectId, + Verbosity: globalflags.VerbosityDefault, + }, + InstanceId: testInstanceId, + } + for _, mod := range mods { + mod(model) + } + return model +} + +func fixtureGetGrafanaConfigsRequest(mods ...func(request *argus.ApiGetGrafanaConfigsRequest)) argus.ApiGetGrafanaConfigsRequest { + request := testClient.GetGrafanaConfigs(testCtx, testInstanceId, testProjectId) + for _, mod := range mods { + mod(&request) + } + return request +} + +func fixtureGetInstanceRequest(mods ...func(request *argus.ApiGetInstanceRequest)) argus.ApiGetInstanceRequest { + request := testClient.GetInstance(testCtx, testInstanceId, testProjectId) + for _, mod := range mods { + mod(&request) + } + return request +} + +func TestParseInput(t *testing.T) { + tests := []struct { + description string + argValues []string + flagValues map[string]string + isValid bool + expectedModel *inputModel + }{ + { + description: "base", + flagValues: fixtureFlagValues(), + isValid: true, + expectedModel: fixtureInputModel(), + }, + { + description: "hide password", + flagValues: fixtureFlagValues(func(flagValues map[string]string) { + flagValues[hidePasswordFlag] = "true" + }), + isValid: true, + expectedModel: fixtureInputModel(func(model *inputModel) { + model.HidePassword = true + }), + }, + { + description: "no values", + argValues: []string{}, + flagValues: map[string]string{}, + isValid: false, + }, + { + description: "no flag values", + flagValues: map[string]string{}, + isValid: false, + }, + { + description: "project id missing", + flagValues: fixtureFlagValues(func(flagValues map[string]string) { + delete(flagValues, projectIdFlag) + }), + isValid: false, + }, + { + description: "project id invalid 1", + flagValues: fixtureFlagValues(func(flagValues map[string]string) { + flagValues[projectIdFlag] = "" + }), + isValid: false, + }, + { + description: "project id invalid 2", + flagValues: fixtureFlagValues(func(flagValues map[string]string) { + flagValues[projectIdFlag] = "invalid-uuid" + }), + isValid: false, + }, + { + description: "instance id missing", + flagValues: fixtureFlagValues(func(flagValues map[string]string) { + delete(flagValues, instanceIdFlag) + }), + isValid: false, + }, + { + description: "instance id invalid 1", + flagValues: fixtureFlagValues(func(flagValues map[string]string) { + flagValues[instanceIdFlag] = "" + }), + isValid: false, + }, + { + description: "instance id invalid 2", + flagValues: fixtureFlagValues(func(flagValues map[string]string) { + flagValues[instanceIdFlag] = "invalid-uuid" + }), + isValid: false, + }, + { + description: "credentials id invalid 1", + argValues: []string{""}, + flagValues: fixtureFlagValues(), + isValid: false, + }, + { + description: "credentials id invalid 2", + argValues: []string{"invalid-uuid"}, + flagValues: fixtureFlagValues(), + isValid: false, + }, + } + + for _, tt := range tests { + t.Run(tt.description, func(t *testing.T) { + cmd := NewCmd(nil) + err := globalflags.Configure(cmd.Flags()) + if err != nil { + t.Fatalf("configure global flags: %v", err) + } + + for flag, value := range tt.flagValues { + err := cmd.Flags().Set(flag, value) + if err != nil { + if !tt.isValid { + return + } + t.Fatalf("setting flag --%s=%s: %v", flag, value, err) + } + } + + err = cmd.ValidateArgs(tt.argValues) + if err != nil { + if !tt.isValid { + return + } + t.Fatalf("error validating args: %v", err) + } + + err = cmd.ValidateRequiredFlags() + if err != nil { + if !tt.isValid { + return + } + t.Fatalf("error validating flags: %v", err) + } + + model, err := parseInput(cmd) + if err != nil { + if !tt.isValid { + return + } + t.Fatalf("error parsing input: %v", err) + } + + if !tt.isValid { + t.Fatalf("did not fail on invalid input") + } + diff := cmp.Diff(model, tt.expectedModel) + if diff != "" { + t.Fatalf("Data does not match: %s", diff) + } + }) + } +} + +func TestBuildGetGrafanaConfigsRequest(t *testing.T) { + tests := []struct { + description string + model *inputModel + expectedRequest argus.ApiGetGrafanaConfigsRequest + }{ + { + description: "base", + model: fixtureInputModel(), + expectedRequest: fixtureGetGrafanaConfigsRequest(), + }, + } + + for _, tt := range tests { + t.Run(tt.description, func(t *testing.T) { + request := buildGetGrafanaConfigRequest(testCtx, tt.model, testClient) + + diff := cmp.Diff(request, tt.expectedRequest, + cmp.AllowUnexported(tt.expectedRequest), + cmpopts.EquateComparable(testCtx), + ) + if diff != "" { + t.Fatalf("Data does not match: %s", diff) + } + }) + } +} + +func TestBuildGetInstanceRequest(t *testing.T) { + tests := []struct { + description string + model *inputModel + expectedRequest argus.ApiGetInstanceRequest + }{ + { + description: "base", + model: fixtureInputModel(), + expectedRequest: fixtureGetInstanceRequest(), + }, + } + + for _, tt := range tests { + t.Run(tt.description, func(t *testing.T) { + request := buildGetInstanceRequest(testCtx, tt.model, testClient) + + diff := cmp.Diff(request, tt.expectedRequest, + cmp.AllowUnexported(tt.expectedRequest), + cmpopts.EquateComparable(testCtx), + ) + if diff != "" { + t.Fatalf("Data does not match: %s", diff) + } + }) + } +} diff --git a/internal/cmd/argus/grafana/grafana.go b/internal/cmd/argus/grafana/grafana.go new file mode 100644 index 000000000..e1a77a9ce --- /dev/null +++ b/internal/cmd/argus/grafana/grafana.go @@ -0,0 +1,26 @@ +package grafana + +import ( + "github.com/stackitcloud/stackit-cli/internal/cmd/argus/grafana/describe" + "github.com/stackitcloud/stackit-cli/internal/pkg/args" + "github.com/stackitcloud/stackit-cli/internal/pkg/print" + "github.com/stackitcloud/stackit-cli/internal/pkg/utils" + + "github.com/spf13/cobra" +) + +func NewCmd(p *print.Printer) *cobra.Command { + cmd := &cobra.Command{ + Use: "grafana", + Short: "Provides functionality for the Grafana configuration of Argus instances", + Long: "Provides functionality for the Grafana configuration of Argus instances.", + Args: args.NoArgs, + Run: utils.CmdHelp, + } + addSubcommands(cmd, p) + return cmd +} + +func addSubcommands(cmd *cobra.Command, p *print.Printer) { + cmd.AddCommand(describe.NewCmd(p)) +} From 36e1c3360d71a2ec869811e91e749062282a0a37 Mon Sep 17 00:00:00 2001 From: GokceGK <161626272+GokceGK@users.noreply.github.com> Date: Wed, 17 Apr 2024 08:11:35 +0200 Subject: [PATCH 02/17] Update GitHub actions (#223) --- .github/workflows/renovate.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/renovate.yaml b/.github/workflows/renovate.yaml index 38c802a65..c8819c5e6 100644 --- a/.github/workflows/renovate.yaml +++ b/.github/workflows/renovate.yaml @@ -13,7 +13,7 @@ jobs: - name: Checkout uses: actions/checkout@v4 - name: Self-hosted Renovate - uses: renovatebot/github-action@v40.1.0 + uses: renovatebot/github-action@v40.1.9 with: configurationFile: .github/renovate.json token: ${{ secrets.RENOVATE_TOKEN }} From bf75e9f819955ab81a328f049f3f061db0afaa25 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Palet?= Date: Wed, 17 Apr 2024 09:48:17 +0100 Subject: [PATCH 03/17] Implemnt util for Argus grafana configuration commands (#224) --- internal/pkg/services/argus/utils/utils.go | 73 ++++- .../pkg/services/argus/utils/utils_test.go | 276 +++++++++++++++++- 2 files changed, 343 insertions(+), 6 deletions(-) diff --git a/internal/pkg/services/argus/utils/utils.go b/internal/pkg/services/argus/utils/utils.go index e530c187b..396aa84fb 100644 --- a/internal/pkg/services/argus/utils/utils.go +++ b/internal/pkg/services/argus/utils/utils.go @@ -14,6 +14,11 @@ const ( service = "argus" ) +type ArgusClient interface { + GetInstanceExecute(ctx context.Context, instanceId, projectId string) (*argus.GetInstanceResponse, error) + GetGrafanaConfigsExecute(ctx context.Context, instanceId, projectId string) (*argus.GrafanaConfigs, error) +} + func ValidatePlanId(planId string, resp *argus.PlansResponse) error { if resp == nil { return fmt.Errorf("no Argus plans provided") @@ -56,10 +61,6 @@ func LoadPlanId(planName string, resp *argus.PlansResponse) (*string, error) { } } -type ArgusClient interface { - GetInstanceExecute(ctx context.Context, instanceId, projectId string) (*argus.GetInstanceResponse, error) -} - func GetInstanceName(ctx context.Context, apiClient ArgusClient, instanceId, projectId string) (string, error) { resp, err := apiClient.GetInstanceExecute(ctx, instanceId, projectId) if err != nil { @@ -67,3 +68,67 @@ func GetInstanceName(ctx context.Context, apiClient ArgusClient, instanceId, pro } return *resp.Name, nil } + +func toPayloadGenericOAuth(response *argus.GrafanaOauth) *argus.UpdateGrafanaConfigsPayloadGenericOauth { + if response == nil { + return nil + } + return &argus.UpdateGrafanaConfigsPayloadGenericOauth{ + ApiUrl: response.ApiUrl, + AuthUrl: response.AuthUrl, + Enabled: response.Enabled, + Name: response.Name, + OauthClientId: response.OauthClientId, + OauthClientSecret: response.OauthClientSecret, + RoleAttributePath: response.RoleAttributePath, + RoleAttributeStrict: response.RoleAttributeStrict, + Scopes: response.Scopes, + TokenUrl: response.TokenUrl, + UsePkce: response.UsePkce, + } +} + +func toRespGenericOAuth(payloadModel *argus.UpdateGrafanaConfigsPayloadGenericOauth) *argus.GrafanaOauth { + if payloadModel == nil { + return nil + } + return &argus.GrafanaOauth{ + ApiUrl: payloadModel.ApiUrl, + AuthUrl: payloadModel.AuthUrl, + Enabled: payloadModel.Enabled, + Name: payloadModel.Name, + OauthClientId: payloadModel.OauthClientId, + OauthClientSecret: payloadModel.OauthClientSecret, + RoleAttributePath: payloadModel.RoleAttributePath, + RoleAttributeStrict: payloadModel.RoleAttributeStrict, + Scopes: payloadModel.Scopes, + TokenUrl: payloadModel.TokenUrl, + UsePkce: payloadModel.UsePkce, + } +} + +func GetPartialUpdateGrafanaConfigsPayload(ctx context.Context, apiClient ArgusClient, instanceId, projectId string, singleSignOn, publicReadAccess *bool) (*argus.UpdateGrafanaConfigsPayload, error) { + currentConfigs, err := apiClient.GetGrafanaConfigsExecute(ctx, instanceId, projectId) + if err != nil { + return nil, fmt.Errorf("get current Grafana configs: %w", err) + } + + if currentConfigs == nil || currentConfigs.GenericOauth == nil { + return nil, fmt.Errorf("no Grafana configs found for instance %q", instanceId) + } + + payload := &argus.UpdateGrafanaConfigsPayload{ + GenericOauth: toPayloadGenericOAuth(currentConfigs.GenericOauth), + PublicReadAccess: currentConfigs.PublicReadAccess, + UseStackitSso: currentConfigs.UseStackitSso, + } + + if singleSignOn != nil { + payload.UseStackitSso = singleSignOn + } + if publicReadAccess != nil { + payload.PublicReadAccess = publicReadAccess + } + + return payload, nil +} diff --git a/internal/pkg/services/argus/utils/utils_test.go b/internal/pkg/services/argus/utils/utils_test.go index 8adf5de1b..911eb061c 100644 --- a/internal/pkg/services/argus/utils/utils_test.go +++ b/internal/pkg/services/argus/utils/utils_test.go @@ -8,6 +8,7 @@ import ( "github.com/stackitcloud/stackit-cli/internal/pkg/utils" + "github.com/google/go-cmp/cmp" "github.com/google/uuid" "github.com/stackitcloud/stackit-sdk-go/services/argus" ) @@ -33,8 +34,10 @@ var testPlansResponse = argus.PlansResponse{ } type argusClientMocked struct { - getInstanceFails bool - getInstanceResp *argus.GetInstanceResponse + getInstanceFails bool + getInstanceResp *argus.GetInstanceResponse + getGrafanaConfigsFails bool + getGrafanaConfigsResp *argus.GrafanaConfigs } func (m *argusClientMocked) GetInstanceExecute(_ context.Context, _, _ string) (*argus.GetInstanceResponse, error) { @@ -43,6 +46,38 @@ func (m *argusClientMocked) GetInstanceExecute(_ context.Context, _, _ string) ( } return m.getInstanceResp, nil } + +func (m *argusClientMocked) GetGrafanaConfigsExecute(_ context.Context, _, _ string) (*argus.GrafanaConfigs, error) { + if m.getGrafanaConfigsFails { + return nil, fmt.Errorf("could not get grafana configs") + } + return m.getGrafanaConfigsResp, nil +} + +func fixtureGrafanaConfigs(mods ...func(gc *argus.GrafanaConfigs)) *argus.GrafanaConfigs { + gc := argus.GrafanaConfigs{ + GenericOauth: &argus.GrafanaOauth{ + ApiUrl: utils.Ptr("apiUrl"), + AuthUrl: utils.Ptr("authUrl"), + Enabled: utils.Ptr(true), + Name: utils.Ptr("name"), + OauthClientId: utils.Ptr("oauthClientId"), + OauthClientSecret: utils.Ptr("oauthClientSecret"), + RoleAttributePath: utils.Ptr("roleAttributePath"), + RoleAttributeStrict: utils.Ptr(true), + Scopes: utils.Ptr("scopes"), + TokenUrl: utils.Ptr("tokenUrl"), + UsePkce: utils.Ptr(true), + }, + PublicReadAccess: utils.Ptr(false), + UseStackitSso: utils.Ptr(false), + } + for _, mod := range mods { + mod(&gc) + } + return &gc +} + func TestGetInstanceName(t *testing.T) { tests := []struct { description string @@ -220,3 +255,240 @@ func TestValidatePlanId(t *testing.T) { }) } } + +func TestToPayloadGenericOAuth(t *testing.T) { + tests := []struct { + description string + response *argus.GrafanaOauth + expected *argus.UpdateGrafanaConfigsPayloadGenericOauth + }{ + { + description: "base", + response: &argus.GrafanaOauth{ + ApiUrl: utils.Ptr("apiUrl"), + AuthUrl: utils.Ptr("authUrl"), + Enabled: utils.Ptr(true), + Name: utils.Ptr("name"), + OauthClientId: utils.Ptr("oauthClientId"), + OauthClientSecret: utils.Ptr("oauthClientSecret"), + RoleAttributePath: utils.Ptr("roleAttributePath"), + RoleAttributeStrict: utils.Ptr(true), + Scopes: utils.Ptr("scopes"), + TokenUrl: utils.Ptr("tokenUrl"), + UsePkce: utils.Ptr(true), + }, + expected: &argus.UpdateGrafanaConfigsPayloadGenericOauth{ + ApiUrl: utils.Ptr("apiUrl"), + AuthUrl: utils.Ptr("authUrl"), + Enabled: utils.Ptr(true), + Name: utils.Ptr("name"), + OauthClientId: utils.Ptr("oauthClientId"), + OauthClientSecret: utils.Ptr("oauthClientSecret"), + RoleAttributePath: utils.Ptr("roleAttributePath"), + RoleAttributeStrict: utils.Ptr(true), + Scopes: utils.Ptr("scopes"), + TokenUrl: utils.Ptr("tokenUrl"), + UsePkce: utils.Ptr(true), + }, + }, + { + description: "nil response", + response: nil, + expected: nil, + }, + } + + for _, tt := range tests { + t.Run(tt.description, func(t *testing.T) { + output := toPayloadGenericOAuth(tt.response) + + diff := cmp.Diff(output, tt.expected) + if diff != "" { + t.Errorf("expected output to be %+v, got %+v", tt.expected, output) + } + }) + } +} + +func TestToRespGenericOAuth(t *testing.T) { + tests := []struct { + description string + payload *argus.UpdateGrafanaConfigsPayloadGenericOauth + expected *argus.GrafanaOauth + }{ + { + description: "base", + payload: &argus.UpdateGrafanaConfigsPayloadGenericOauth{ + ApiUrl: utils.Ptr("apiUrl"), + AuthUrl: utils.Ptr("authUrl"), + Enabled: utils.Ptr(true), + Name: utils.Ptr("name"), + OauthClientId: utils.Ptr("oauthClientId"), + OauthClientSecret: utils.Ptr("oauthClientSecret"), + RoleAttributePath: utils.Ptr("roleAttributePath"), + RoleAttributeStrict: utils.Ptr(true), + Scopes: utils.Ptr("scopes"), + TokenUrl: utils.Ptr("tokenUrl"), + UsePkce: utils.Ptr(true), + }, + expected: &argus.GrafanaOauth{ + ApiUrl: utils.Ptr("apiUrl"), + AuthUrl: utils.Ptr("authUrl"), + Enabled: utils.Ptr(true), + Name: utils.Ptr("name"), + OauthClientId: utils.Ptr("oauthClientId"), + OauthClientSecret: utils.Ptr("oauthClientSecret"), + RoleAttributePath: utils.Ptr("roleAttributePath"), + RoleAttributeStrict: utils.Ptr(true), + Scopes: utils.Ptr("scopes"), + TokenUrl: utils.Ptr("tokenUrl"), + UsePkce: utils.Ptr(true), + }, + }, + { + description: "nil payload", + payload: nil, + expected: nil, + }, + } + + for _, tt := range tests { + t.Run(tt.description, func(t *testing.T) { + output := toRespGenericOAuth(tt.payload) + + diff := cmp.Diff(output, tt.expected) + if diff != "" { + t.Errorf("expected output to be %+v, got %+v", tt.expected, output) + } + }) + } +} + +func TestGetPartialUpdateGrafanaConfigsPayload(t *testing.T) { + tests := []struct { + description string + singleSignOn *bool + publicReadAccess *bool + getGrafanaConfigsFails bool + getGrafanaConfigsResp *argus.GrafanaConfigs + isValid bool + expectedPayload *argus.UpdateGrafanaConfigsPayload + }{ + { + description: "enable both", + singleSignOn: utils.Ptr(true), + publicReadAccess: utils.Ptr(true), + getGrafanaConfigsResp: fixtureGrafanaConfigs(), + isValid: true, + expectedPayload: &argus.UpdateGrafanaConfigsPayload{ + GenericOauth: toPayloadGenericOAuth(fixtureGrafanaConfigs().GenericOauth), + UseStackitSso: utils.Ptr(true), + PublicReadAccess: utils.Ptr(true), + }, + }, + { + description: "disable both", + singleSignOn: utils.Ptr(false), + publicReadAccess: utils.Ptr(false), + getGrafanaConfigsResp: fixtureGrafanaConfigs(), + isValid: true, + expectedPayload: &argus.UpdateGrafanaConfigsPayload{ + GenericOauth: toPayloadGenericOAuth(fixtureGrafanaConfigs().GenericOauth), + UseStackitSso: utils.Ptr(false), + PublicReadAccess: utils.Ptr(false), + }, + }, + { + description: "enable single sign on", + singleSignOn: utils.Ptr(true), + publicReadAccess: nil, + getGrafanaConfigsResp: fixtureGrafanaConfigs(), + isValid: true, + expectedPayload: &argus.UpdateGrafanaConfigsPayload{ + GenericOauth: toPayloadGenericOAuth(fixtureGrafanaConfigs().GenericOauth), + UseStackitSso: utils.Ptr(true), + PublicReadAccess: fixtureGrafanaConfigs().PublicReadAccess, + }, + }, + { + description: "enable public read access", + singleSignOn: nil, + publicReadAccess: utils.Ptr(true), + getGrafanaConfigsResp: fixtureGrafanaConfigs(), + isValid: true, + expectedPayload: &argus.UpdateGrafanaConfigsPayload{ + GenericOauth: toPayloadGenericOAuth(fixtureGrafanaConfigs().GenericOauth), + UseStackitSso: fixtureGrafanaConfigs().UseStackitSso, + PublicReadAccess: utils.Ptr(true), + }, + }, + { + description: "disable single sign on", + singleSignOn: utils.Ptr(false), + publicReadAccess: nil, + getGrafanaConfigsResp: fixtureGrafanaConfigs(func(gc *argus.GrafanaConfigs) { + gc.UseStackitSso = utils.Ptr(true) + }), + isValid: true, + expectedPayload: &argus.UpdateGrafanaConfigsPayload{ + GenericOauth: toPayloadGenericOAuth(fixtureGrafanaConfigs().GenericOauth), + UseStackitSso: utils.Ptr(false), + PublicReadAccess: fixtureGrafanaConfigs().PublicReadAccess, + }, + }, + { + description: "disable public read access", + singleSignOn: nil, + publicReadAccess: utils.Ptr(false), + getGrafanaConfigsResp: fixtureGrafanaConfigs(func(gc *argus.GrafanaConfigs) { + gc.PublicReadAccess = utils.Ptr(true) + }), + isValid: true, + expectedPayload: &argus.UpdateGrafanaConfigsPayload{ + GenericOauth: toPayloadGenericOAuth(fixtureGrafanaConfigs().GenericOauth), + UseStackitSso: fixtureGrafanaConfigs().UseStackitSso, + PublicReadAccess: utils.Ptr(false), + }, + }, + { + description: "get grafana configs fails", + singleSignOn: utils.Ptr(true), + publicReadAccess: utils.Ptr(true), + getGrafanaConfigsFails: true, + isValid: false, + }, + { + description: "no grafana configs", + singleSignOn: utils.Ptr(true), + publicReadAccess: utils.Ptr(true), + getGrafanaConfigsResp: &argus.GrafanaConfigs{}, + isValid: false, + }, + } + + for _, tt := range tests { + t.Run(tt.description, func(t *testing.T) { + client := &argusClientMocked{ + getGrafanaConfigsFails: tt.getGrafanaConfigsFails, + getGrafanaConfigsResp: tt.getGrafanaConfigsResp, + } + + payload, err := GetPartialUpdateGrafanaConfigsPayload(context.Background(), client, testInstanceId, testProjectId, tt.singleSignOn, tt.publicReadAccess) + + if tt.isValid && err != nil { + t.Errorf("failed on valid input") + } + if !tt.isValid && err == nil { + t.Errorf("did not fail on invalid input") + } + if !tt.isValid { + return + } + + diff := cmp.Diff(payload, tt.expectedPayload) + if diff != "" { + t.Errorf("expected output payload to be %+v, got %+v", tt.expectedPayload, payload) + } + }) + } +} From 0758f905f408f02a5bc6aa3eb2b032077e747990 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Palet?= Date: Wed, 17 Apr 2024 13:06:11 +0100 Subject: [PATCH 04/17] Add `argus grafana single-sign-on` commands (#228) * Add argus grafana single-sign-on enable command * Add argus grafana single-sign-on disable command * Update docs * Register disable command and update docs * Improvements after review --- docs/stackit_argus_grafana.md | 1 + docs/stackit_argus_grafana_single-sign-on.md | 35 +++ ...it_argus_grafana_single-sign-on_disable.md | 41 +++ ...kit_argus_grafana_single-sign-on_enable.md | 41 +++ internal/cmd/argus/grafana/grafana.go | 2 + .../grafana/single-sign-on/disable/disable.go | 115 ++++++++ .../single-sign-on/disable/disable_test.go | 269 ++++++++++++++++++ .../grafana/single-sign-on/enable/enable.go | 115 ++++++++ .../single-sign-on/enable/enable_test.go | 269 ++++++++++++++++++ .../grafana/single-sign-on/single_sign_on.go | 33 +++ internal/pkg/services/argus/utils/utils.go | 51 ++-- .../pkg/services/argus/utils/utils_test.go | 89 ++---- 12 files changed, 963 insertions(+), 98 deletions(-) create mode 100644 docs/stackit_argus_grafana_single-sign-on.md create mode 100644 docs/stackit_argus_grafana_single-sign-on_disable.md create mode 100644 docs/stackit_argus_grafana_single-sign-on_enable.md create mode 100644 internal/cmd/argus/grafana/single-sign-on/disable/disable.go create mode 100644 internal/cmd/argus/grafana/single-sign-on/disable/disable_test.go create mode 100644 internal/cmd/argus/grafana/single-sign-on/enable/enable.go create mode 100644 internal/cmd/argus/grafana/single-sign-on/enable/enable_test.go create mode 100644 internal/cmd/argus/grafana/single-sign-on/single_sign_on.go diff --git a/docs/stackit_argus_grafana.md b/docs/stackit_argus_grafana.md index 9d6714075..c1ce6b5b5 100644 --- a/docs/stackit_argus_grafana.md +++ b/docs/stackit_argus_grafana.md @@ -30,4 +30,5 @@ stackit argus grafana [flags] * [stackit argus](./stackit_argus.md) - Provides functionality for Argus * [stackit argus grafana describe](./stackit_argus_grafana_describe.md) - Shows details of the Grafana configuration of an Argus instance +* [stackit argus grafana single-sign-on](./stackit_argus_grafana_single-sign-on.md) - Enable or disable single sign-on for Grafana in Argus instances diff --git a/docs/stackit_argus_grafana_single-sign-on.md b/docs/stackit_argus_grafana_single-sign-on.md new file mode 100644 index 000000000..48f0960a2 --- /dev/null +++ b/docs/stackit_argus_grafana_single-sign-on.md @@ -0,0 +1,35 @@ +## stackit argus grafana single-sign-on + +Enable or disable single sign-on for Grafana in Argus instances + +### Synopsis + +Enable or disable single sign-on for Grafana in Argus instances. +When enabled for an instance, overwrites the generic OAuth2 authentication and configures STACKIT single sign-on for that instance. + +``` +stackit argus grafana single-sign-on [flags] +``` + +### Options + +``` + -h, --help Help for "stackit argus grafana single-sign-on" +``` + +### Options inherited from parent commands + +``` + -y, --assume-yes If set, skips all confirmation prompts + --async If set, runs the command asynchronously + -o, --output-format string Output format, one of ["json" "pretty"] + -p, --project-id string Project ID + --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") +``` + +### SEE ALSO + +* [stackit argus grafana](./stackit_argus_grafana.md) - Provides functionality for the Grafana configuration of Argus instances +* [stackit argus grafana single-sign-on disable](./stackit_argus_grafana_single-sign-on_disable.md) - Disables single sign-on for Grafana on Argus instances +* [stackit argus grafana single-sign-on enable](./stackit_argus_grafana_single-sign-on_enable.md) - Enables single sign-on for Grafana on Argus instances + diff --git a/docs/stackit_argus_grafana_single-sign-on_disable.md b/docs/stackit_argus_grafana_single-sign-on_disable.md new file mode 100644 index 000000000..143273e20 --- /dev/null +++ b/docs/stackit_argus_grafana_single-sign-on_disable.md @@ -0,0 +1,41 @@ +## stackit argus grafana single-sign-on disable + +Disables single sign-on for Grafana on Argus instances + +### Synopsis + +Disables single sign-on for Grafana on Argus instances. +When disabled for an instance, the generic OAuth2 authentication is used for that instance. + +``` +stackit argus grafana single-sign-on disable [flags] +``` + +### Examples + +``` + Disable single sign-on for Grafana on an Argus instance with ID "xxx" + $ stackit argus grafana single-sign-on disable --instance-id xxx +``` + +### Options + +``` + -h, --help Help for "stackit argus grafana single-sign-on disable" + --instance-id string Instance ID +``` + +### Options inherited from parent commands + +``` + -y, --assume-yes If set, skips all confirmation prompts + --async If set, runs the command asynchronously + -o, --output-format string Output format, one of ["json" "pretty"] + -p, --project-id string Project ID + --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") +``` + +### SEE ALSO + +* [stackit argus grafana single-sign-on](./stackit_argus_grafana_single-sign-on.md) - Enable or disable single sign-on for Grafana in Argus instances + diff --git a/docs/stackit_argus_grafana_single-sign-on_enable.md b/docs/stackit_argus_grafana_single-sign-on_enable.md new file mode 100644 index 000000000..ad83abb99 --- /dev/null +++ b/docs/stackit_argus_grafana_single-sign-on_enable.md @@ -0,0 +1,41 @@ +## stackit argus grafana single-sign-on enable + +Enables single sign-on for Grafana on Argus instances + +### Synopsis + +Enables single sign-on for Grafana on Argus instances. +When enabled for an instance, overwrites the generic OAuth2 authentication and configures STACKIT single sign-on for that instance. + +``` +stackit argus grafana single-sign-on enable [flags] +``` + +### Examples + +``` + Enable single sign-on for Grafana on an Argus instance with ID "xxx" + $ stackit argus grafana single-sign-on enable --instance-id xxx +``` + +### Options + +``` + -h, --help Help for "stackit argus grafana single-sign-on enable" + --instance-id string Instance ID +``` + +### Options inherited from parent commands + +``` + -y, --assume-yes If set, skips all confirmation prompts + --async If set, runs the command asynchronously + -o, --output-format string Output format, one of ["json" "pretty"] + -p, --project-id string Project ID + --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") +``` + +### SEE ALSO + +* [stackit argus grafana single-sign-on](./stackit_argus_grafana_single-sign-on.md) - Enable or disable single sign-on for Grafana in Argus instances + diff --git a/internal/cmd/argus/grafana/grafana.go b/internal/cmd/argus/grafana/grafana.go index e1a77a9ce..0ce98f4c8 100644 --- a/internal/cmd/argus/grafana/grafana.go +++ b/internal/cmd/argus/grafana/grafana.go @@ -2,6 +2,7 @@ package grafana import ( "github.com/stackitcloud/stackit-cli/internal/cmd/argus/grafana/describe" + singlesignon "github.com/stackitcloud/stackit-cli/internal/cmd/argus/grafana/single-sign-on" "github.com/stackitcloud/stackit-cli/internal/pkg/args" "github.com/stackitcloud/stackit-cli/internal/pkg/print" "github.com/stackitcloud/stackit-cli/internal/pkg/utils" @@ -23,4 +24,5 @@ func NewCmd(p *print.Printer) *cobra.Command { func addSubcommands(cmd *cobra.Command, p *print.Printer) { cmd.AddCommand(describe.NewCmd(p)) + cmd.AddCommand(singlesignon.NewCmd(p)) } diff --git a/internal/cmd/argus/grafana/single-sign-on/disable/disable.go b/internal/cmd/argus/grafana/single-sign-on/disable/disable.go new file mode 100644 index 000000000..090320e4c --- /dev/null +++ b/internal/cmd/argus/grafana/single-sign-on/disable/disable.go @@ -0,0 +1,115 @@ +package disable + +import ( + "context" + "fmt" + + "github.com/stackitcloud/stackit-cli/internal/pkg/args" + "github.com/stackitcloud/stackit-cli/internal/pkg/errors" + "github.com/stackitcloud/stackit-cli/internal/pkg/examples" + "github.com/stackitcloud/stackit-cli/internal/pkg/flags" + "github.com/stackitcloud/stackit-cli/internal/pkg/globalflags" + "github.com/stackitcloud/stackit-cli/internal/pkg/print" + "github.com/stackitcloud/stackit-cli/internal/pkg/services/argus/client" + argusUtils "github.com/stackitcloud/stackit-cli/internal/pkg/services/argus/utils" + "github.com/stackitcloud/stackit-cli/internal/pkg/utils" + + "github.com/spf13/cobra" + "github.com/stackitcloud/stackit-sdk-go/services/argus" +) + +const ( + instanceIdFlag = "instance-id" +) + +type inputModel struct { + *globalflags.GlobalFlagModel + InstanceId string +} + +func NewCmd(p *print.Printer) *cobra.Command { + cmd := &cobra.Command{ + Use: "disable", + Short: "Disables single sign-on for Grafana on Argus instances", + Long: fmt.Sprintf("%s\n%s", + "Disables single sign-on for Grafana on Argus instances.", + "When disabled for an instance, the generic OAuth2 authentication is used for that instance.", + ), + Args: args.NoArgs, + Example: examples.Build( + examples.NewExample( + `Disable single sign-on for Grafana on an Argus instance with ID "xxx"`, + "$ stackit argus grafana single-sign-on disable --instance-id xxx"), + ), + RunE: func(cmd *cobra.Command, args []string) error { + ctx := context.Background() + model, err := parseInput(cmd) + if err != nil { + return err + } + + // Configure API client + apiClient, err := client.ConfigureClient(p) + if err != nil { + return err + } + + instanceLabel, err := argusUtils.GetInstanceName(ctx, apiClient, model.InstanceId, model.ProjectId) + if err != nil || instanceLabel == "" { + instanceLabel = model.InstanceId + } + + if !model.AssumeYes { + prompt := fmt.Sprintf("Are you sure you want to disable single sign-on for instance %q?", instanceLabel) + err = p.PromptForConfirmation(prompt) + if err != nil { + return err + } + } + + // Call API + req, err := buildRequest(ctx, model, apiClient) + if err != nil { + return fmt.Errorf("build request: %w", err) + } + _, err = req.Execute() + if err != nil { + return fmt.Errorf("disable single sign-on: %w", err) + } + + p.Info("Disabled single sign-on for instance %q\n", instanceLabel) + return nil + }, + } + configureFlags(cmd) + return cmd +} + +func configureFlags(cmd *cobra.Command) { + cmd.Flags().Var(flags.UUIDFlag(), instanceIdFlag, "Instance ID") + + err := flags.MarkFlagsRequired(cmd, instanceIdFlag) + cobra.CheckErr(err) +} + +func parseInput(cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(cmd) + if globalFlags.ProjectId == "" { + return nil, &errors.ProjectIdError{} + } + + return &inputModel{ + GlobalFlagModel: globalFlags, + InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + }, nil +} + +func buildRequest(ctx context.Context, model *inputModel, apiClient argusUtils.ArgusClient) (argus.ApiUpdateGrafanaConfigsRequest, error) { + req := apiClient.UpdateGrafanaConfigs(ctx, model.InstanceId, model.ProjectId) + payload, err := argusUtils.GetPartialUpdateGrafanaConfigsPayload(ctx, apiClient, model.InstanceId, model.ProjectId, utils.Ptr(false), nil) + if err != nil { + return req, fmt.Errorf("build request payload: %w", err) + } + req = req.UpdateGrafanaConfigsPayload(*payload) + return req, nil +} diff --git a/internal/cmd/argus/grafana/single-sign-on/disable/disable_test.go b/internal/cmd/argus/grafana/single-sign-on/disable/disable_test.go new file mode 100644 index 000000000..b654bbb32 --- /dev/null +++ b/internal/cmd/argus/grafana/single-sign-on/disable/disable_test.go @@ -0,0 +1,269 @@ +package disable + +import ( + "context" + "fmt" + "testing" + + "github.com/stackitcloud/stackit-cli/internal/pkg/globalflags" + argusUtils "github.com/stackitcloud/stackit-cli/internal/pkg/services/argus/utils" + "github.com/stackitcloud/stackit-cli/internal/pkg/utils" + + "github.com/google/go-cmp/cmp" + "github.com/google/go-cmp/cmp/cmpopts" + "github.com/google/uuid" + "github.com/stackitcloud/stackit-sdk-go/services/argus" +) + +var projectIdFlag = globalflags.ProjectIdFlag + +type testCtxKey struct{} + +var testCtx = context.WithValue(context.Background(), testCtxKey{}, "foo") +var testClient = &argus.APIClient{} +var testProjectId = uuid.NewString() +var testInstanceId = uuid.NewString() + +type argusClientMocked struct { + getGrafanaConfigsFails bool + getGrafanaConfigsResp *argus.GrafanaConfigs +} + +func (c *argusClientMocked) GetInstanceExecute(ctx context.Context, instanceId, projectId string) (*argus.GetInstanceResponse, error) { + return testClient.GetInstanceExecute(ctx, instanceId, projectId) +} + +func (c *argusClientMocked) UpdateGrafanaConfigs(ctx context.Context, instanceId, projectId string) argus.ApiUpdateGrafanaConfigsRequest { + return testClient.UpdateGrafanaConfigs(ctx, instanceId, projectId) +} + +func (c *argusClientMocked) GetGrafanaConfigsExecute(_ context.Context, _, _ string) (*argus.GrafanaConfigs, error) { + if c.getGrafanaConfigsFails { + return nil, fmt.Errorf("get payload failed") + } + return c.getGrafanaConfigsResp, nil +} + +func fixtureFlagValues(mods ...func(flagValues map[string]string)) map[string]string { + flagValues := map[string]string{ + projectIdFlag: testProjectId, + instanceIdFlag: testInstanceId, + } + for _, mod := range mods { + mod(flagValues) + } + return flagValues +} + +func fixtureInputModel(mods ...func(model *inputModel)) *inputModel { + model := &inputModel{ + GlobalFlagModel: &globalflags.GlobalFlagModel{ + ProjectId: testProjectId, + Verbosity: globalflags.VerbosityDefault, + }, + InstanceId: testInstanceId, + } + for _, mod := range mods { + mod(model) + } + return model +} + +func fixtureGrafanaConfigs(mods ...func(gc *argus.GrafanaConfigs)) *argus.GrafanaConfigs { + gc := argus.GrafanaConfigs{ + GenericOauth: &argus.GrafanaOauth{ + ApiUrl: utils.Ptr("apiUrl"), + AuthUrl: utils.Ptr("authUrl"), + Enabled: utils.Ptr(true), + Name: utils.Ptr("name"), + OauthClientId: utils.Ptr("oauthClientId"), + OauthClientSecret: utils.Ptr("oauthClientSecret"), + RoleAttributePath: utils.Ptr("roleAttributePath"), + RoleAttributeStrict: utils.Ptr(true), + Scopes: utils.Ptr("scopes"), + TokenUrl: utils.Ptr("tokenUrl"), + UsePkce: utils.Ptr(true), + }, + PublicReadAccess: utils.Ptr(false), + UseStackitSso: utils.Ptr(false), + } + for _, mod := range mods { + mod(&gc) + } + return &gc +} + +func fixturePayload(mods ...func(payload *argus.UpdateGrafanaConfigsPayload)) *argus.UpdateGrafanaConfigsPayload { + payload := &argus.UpdateGrafanaConfigsPayload{ + GenericOauth: argusUtils.ToPayloadGenericOAuth(fixtureGrafanaConfigs().GenericOauth), + PublicReadAccess: fixtureGrafanaConfigs().PublicReadAccess, + UseStackitSso: utils.Ptr(false), + } + for _, mod := range mods { + mod(payload) + } + return payload +} + +func fixtureRequest(mods ...func(request *argus.ApiUpdateGrafanaConfigsRequest)) argus.ApiUpdateGrafanaConfigsRequest { + request := testClient.UpdateGrafanaConfigs(testCtx, testInstanceId, testProjectId) + request = request.UpdateGrafanaConfigsPayload(*fixturePayload()) + for _, mod := range mods { + mod(&request) + } + return request +} + +func TestParseInput(t *testing.T) { + tests := []struct { + description string + flagValues map[string]string + isValid bool + expectedModel *inputModel + }{ + { + description: "base", + flagValues: fixtureFlagValues(), + isValid: true, + expectedModel: fixtureInputModel(), + }, + { + description: "no values", + flagValues: map[string]string{}, + isValid: false, + }, + { + description: "project id missing", + flagValues: fixtureFlagValues(func(flagValues map[string]string) { + delete(flagValues, projectIdFlag) + }), + isValid: false, + }, + { + description: "project id invalid 1", + flagValues: fixtureFlagValues(func(flagValues map[string]string) { + flagValues[projectIdFlag] = "" + }), + isValid: false, + }, + { + description: "project id invalid 2", + flagValues: fixtureFlagValues(func(flagValues map[string]string) { + flagValues[projectIdFlag] = "invalid-uuid" + }), + isValid: false, + }, + } + + for _, tt := range tests { + t.Run(tt.description, func(t *testing.T) { + cmd := NewCmd(nil) + err := globalflags.Configure(cmd.Flags()) + if err != nil { + t.Fatalf("configure global flags: %v", err) + } + + for flag, value := range tt.flagValues { + err := cmd.Flags().Set(flag, value) + if err != nil { + if !tt.isValid { + return + } + t.Fatalf("setting flag --%s=%s: %v", flag, value, err) + } + } + + err = cmd.ValidateRequiredFlags() + if err != nil { + if !tt.isValid { + return + } + t.Fatalf("error validating flags: %v", err) + } + + model, err := parseInput(cmd) + if err != nil { + if !tt.isValid { + return + } + t.Fatalf("error parsing flags: %v", err) + } + + if !tt.isValid { + t.Fatalf("did not fail on invalid input") + } + diff := cmp.Diff(model, tt.expectedModel) + if diff != "" { + t.Fatalf("Data does not match: %s", diff) + } + }) + } +} + +func TestBuildRequest(t *testing.T) { + tests := []struct { + description string + model *inputModel + getGrafanaConfigsFails bool + getGrafanaConfigsResp *argus.GrafanaConfigs + isValid bool + expectedRequest argus.ApiUpdateGrafanaConfigsRequest + }{ + { + description: "base", + model: fixtureInputModel(), + getGrafanaConfigsResp: fixtureGrafanaConfigs(), + isValid: true, + expectedRequest: fixtureRequest(), + }, + { + description: "nil generic oauth", + model: fixtureInputModel(), + getGrafanaConfigsResp: fixtureGrafanaConfigs(func(gc *argus.GrafanaConfigs) { + gc.GenericOauth = nil + }), + isValid: true, + expectedRequest: fixtureRequest(func(request *argus.ApiUpdateGrafanaConfigsRequest) { + *request = request.UpdateGrafanaConfigsPayload(*fixturePayload(func(payload *argus.UpdateGrafanaConfigsPayload) { + payload.GenericOauth = nil + })) + }), + }, + { + description: "get grafana configs fails", + model: fixtureInputModel(), + getGrafanaConfigsFails: true, + isValid: false, + }, + { + description: "no grafana configs", + model: fixtureInputModel(), + getGrafanaConfigsResp: nil, + isValid: false, + }, + } + + for _, tt := range tests { + t.Run(tt.description, func(t *testing.T) { + client := &argusClientMocked{ + getGrafanaConfigsFails: tt.getGrafanaConfigsFails, + getGrafanaConfigsResp: tt.getGrafanaConfigsResp, + } + request, err := buildRequest(testCtx, tt.model, client) + if err != nil { + if !tt.isValid { + return + } + t.Fatalf("error building request: %v", err) + } + + diff := cmp.Diff(request, tt.expectedRequest, + cmp.AllowUnexported(tt.expectedRequest), + cmpopts.EquateComparable(testCtx), + ) + if diff != "" { + t.Fatalf("Data does not match: %s", diff) + } + }) + } +} diff --git a/internal/cmd/argus/grafana/single-sign-on/enable/enable.go b/internal/cmd/argus/grafana/single-sign-on/enable/enable.go new file mode 100644 index 000000000..711e68fb1 --- /dev/null +++ b/internal/cmd/argus/grafana/single-sign-on/enable/enable.go @@ -0,0 +1,115 @@ +package enable + +import ( + "context" + "fmt" + + "github.com/stackitcloud/stackit-cli/internal/pkg/args" + "github.com/stackitcloud/stackit-cli/internal/pkg/errors" + "github.com/stackitcloud/stackit-cli/internal/pkg/examples" + "github.com/stackitcloud/stackit-cli/internal/pkg/flags" + "github.com/stackitcloud/stackit-cli/internal/pkg/globalflags" + "github.com/stackitcloud/stackit-cli/internal/pkg/print" + "github.com/stackitcloud/stackit-cli/internal/pkg/services/argus/client" + argusUtils "github.com/stackitcloud/stackit-cli/internal/pkg/services/argus/utils" + "github.com/stackitcloud/stackit-cli/internal/pkg/utils" + + "github.com/spf13/cobra" + "github.com/stackitcloud/stackit-sdk-go/services/argus" +) + +const ( + instanceIdFlag = "instance-id" +) + +type inputModel struct { + *globalflags.GlobalFlagModel + InstanceId string +} + +func NewCmd(p *print.Printer) *cobra.Command { + cmd := &cobra.Command{ + Use: "enable", + Short: "Enables single sign-on for Grafana on Argus instances", + Long: fmt.Sprintf("%s\n%s", + "Enables single sign-on for Grafana on Argus instances.", + "When enabled for an instance, overwrites the generic OAuth2 authentication and configures STACKIT single sign-on for that instance.", + ), + Args: args.NoArgs, + Example: examples.Build( + examples.NewExample( + `Enable single sign-on for Grafana on an Argus instance with ID "xxx"`, + "$ stackit argus grafana single-sign-on enable --instance-id xxx"), + ), + RunE: func(cmd *cobra.Command, args []string) error { + ctx := context.Background() + model, err := parseInput(cmd) + if err != nil { + return err + } + + // Configure API client + apiClient, err := client.ConfigureClient(p) + if err != nil { + return err + } + + instanceLabel, err := argusUtils.GetInstanceName(ctx, apiClient, model.InstanceId, model.ProjectId) + if err != nil || instanceLabel == "" { + instanceLabel = model.InstanceId + } + + if !model.AssumeYes { + prompt := fmt.Sprintf("Are you sure you want to enable single sign-on for instance %q?", instanceLabel) + err = p.PromptForConfirmation(prompt) + if err != nil { + return err + } + } + + // Call API + req, err := buildRequest(ctx, model, apiClient) + if err != nil { + return fmt.Errorf("build request: %w", err) + } + _, err = req.Execute() + if err != nil { + return fmt.Errorf("enable single sign-on: %w", err) + } + + p.Info("Enabled single sign-on for instance %q\n", instanceLabel) + return nil + }, + } + configureFlags(cmd) + return cmd +} + +func configureFlags(cmd *cobra.Command) { + cmd.Flags().Var(flags.UUIDFlag(), instanceIdFlag, "Instance ID") + + err := flags.MarkFlagsRequired(cmd, instanceIdFlag) + cobra.CheckErr(err) +} + +func parseInput(cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(cmd) + if globalFlags.ProjectId == "" { + return nil, &errors.ProjectIdError{} + } + + return &inputModel{ + GlobalFlagModel: globalFlags, + InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + }, nil +} + +func buildRequest(ctx context.Context, model *inputModel, apiClient argusUtils.ArgusClient) (argus.ApiUpdateGrafanaConfigsRequest, error) { + req := apiClient.UpdateGrafanaConfigs(ctx, model.InstanceId, model.ProjectId) + payload, err := argusUtils.GetPartialUpdateGrafanaConfigsPayload(ctx, apiClient, model.InstanceId, model.ProjectId, utils.Ptr(true), nil) + if err != nil { + return req, fmt.Errorf("build request payload: %w", err) + } + req = req.UpdateGrafanaConfigsPayload(*payload) + return req, nil +} diff --git a/internal/cmd/argus/grafana/single-sign-on/enable/enable_test.go b/internal/cmd/argus/grafana/single-sign-on/enable/enable_test.go new file mode 100644 index 000000000..7544b81b4 --- /dev/null +++ b/internal/cmd/argus/grafana/single-sign-on/enable/enable_test.go @@ -0,0 +1,269 @@ +package enable + +import ( + "context" + "fmt" + "testing" + + "github.com/stackitcloud/stackit-cli/internal/pkg/globalflags" + argusUtils "github.com/stackitcloud/stackit-cli/internal/pkg/services/argus/utils" + "github.com/stackitcloud/stackit-cli/internal/pkg/utils" + + "github.com/google/go-cmp/cmp" + "github.com/google/go-cmp/cmp/cmpopts" + "github.com/google/uuid" + "github.com/stackitcloud/stackit-sdk-go/services/argus" +) + +var projectIdFlag = globalflags.ProjectIdFlag + +type testCtxKey struct{} + +var testCtx = context.WithValue(context.Background(), testCtxKey{}, "foo") +var testClient = &argus.APIClient{} +var testProjectId = uuid.NewString() +var testInstanceId = uuid.NewString() + +type argusClientMocked struct { + getGrafanaConfigsFails bool + getGrafanaConfigsResp *argus.GrafanaConfigs +} + +func (c *argusClientMocked) GetInstanceExecute(ctx context.Context, instanceId, projectId string) (*argus.GetInstanceResponse, error) { + return testClient.GetInstanceExecute(ctx, instanceId, projectId) +} + +func (c *argusClientMocked) UpdateGrafanaConfigs(ctx context.Context, instanceId, projectId string) argus.ApiUpdateGrafanaConfigsRequest { + return testClient.UpdateGrafanaConfigs(ctx, instanceId, projectId) +} + +func (c *argusClientMocked) GetGrafanaConfigsExecute(_ context.Context, _, _ string) (*argus.GrafanaConfigs, error) { + if c.getGrafanaConfigsFails { + return nil, fmt.Errorf("get payload failed") + } + return c.getGrafanaConfigsResp, nil +} + +func fixtureFlagValues(mods ...func(flagValues map[string]string)) map[string]string { + flagValues := map[string]string{ + projectIdFlag: testProjectId, + instanceIdFlag: testInstanceId, + } + for _, mod := range mods { + mod(flagValues) + } + return flagValues +} + +func fixtureInputModel(mods ...func(model *inputModel)) *inputModel { + model := &inputModel{ + GlobalFlagModel: &globalflags.GlobalFlagModel{ + ProjectId: testProjectId, + Verbosity: globalflags.VerbosityDefault, + }, + InstanceId: testInstanceId, + } + for _, mod := range mods { + mod(model) + } + return model +} + +func fixtureGrafanaConfigs(mods ...func(gc *argus.GrafanaConfigs)) *argus.GrafanaConfigs { + gc := argus.GrafanaConfigs{ + GenericOauth: &argus.GrafanaOauth{ + ApiUrl: utils.Ptr("apiUrl"), + AuthUrl: utils.Ptr("authUrl"), + Enabled: utils.Ptr(true), + Name: utils.Ptr("name"), + OauthClientId: utils.Ptr("oauthClientId"), + OauthClientSecret: utils.Ptr("oauthClientSecret"), + RoleAttributePath: utils.Ptr("roleAttributePath"), + RoleAttributeStrict: utils.Ptr(true), + Scopes: utils.Ptr("scopes"), + TokenUrl: utils.Ptr("tokenUrl"), + UsePkce: utils.Ptr(true), + }, + PublicReadAccess: utils.Ptr(false), + UseStackitSso: utils.Ptr(false), + } + for _, mod := range mods { + mod(&gc) + } + return &gc +} + +func fixturePayload(mods ...func(payload *argus.UpdateGrafanaConfigsPayload)) *argus.UpdateGrafanaConfigsPayload { + payload := &argus.UpdateGrafanaConfigsPayload{ + GenericOauth: argusUtils.ToPayloadGenericOAuth(fixtureGrafanaConfigs().GenericOauth), + PublicReadAccess: fixtureGrafanaConfigs().PublicReadAccess, + UseStackitSso: utils.Ptr(true), + } + for _, mod := range mods { + mod(payload) + } + return payload +} + +func fixtureRequest(mods ...func(request *argus.ApiUpdateGrafanaConfigsRequest)) argus.ApiUpdateGrafanaConfigsRequest { + request := testClient.UpdateGrafanaConfigs(testCtx, testInstanceId, testProjectId) + request = request.UpdateGrafanaConfigsPayload(*fixturePayload()) + for _, mod := range mods { + mod(&request) + } + return request +} + +func TestParseInput(t *testing.T) { + tests := []struct { + description string + flagValues map[string]string + isValid bool + expectedModel *inputModel + }{ + { + description: "base", + flagValues: fixtureFlagValues(), + isValid: true, + expectedModel: fixtureInputModel(), + }, + { + description: "no values", + flagValues: map[string]string{}, + isValid: false, + }, + { + description: "project id missing", + flagValues: fixtureFlagValues(func(flagValues map[string]string) { + delete(flagValues, projectIdFlag) + }), + isValid: false, + }, + { + description: "project id invalid 1", + flagValues: fixtureFlagValues(func(flagValues map[string]string) { + flagValues[projectIdFlag] = "" + }), + isValid: false, + }, + { + description: "project id invalid 2", + flagValues: fixtureFlagValues(func(flagValues map[string]string) { + flagValues[projectIdFlag] = "invalid-uuid" + }), + isValid: false, + }, + } + + for _, tt := range tests { + t.Run(tt.description, func(t *testing.T) { + cmd := NewCmd(nil) + err := globalflags.Configure(cmd.Flags()) + if err != nil { + t.Fatalf("configure global flags: %v", err) + } + + for flag, value := range tt.flagValues { + err := cmd.Flags().Set(flag, value) + if err != nil { + if !tt.isValid { + return + } + t.Fatalf("setting flag --%s=%s: %v", flag, value, err) + } + } + + err = cmd.ValidateRequiredFlags() + if err != nil { + if !tt.isValid { + return + } + t.Fatalf("error validating flags: %v", err) + } + + model, err := parseInput(cmd) + if err != nil { + if !tt.isValid { + return + } + t.Fatalf("error parsing flags: %v", err) + } + + if !tt.isValid { + t.Fatalf("did not fail on invalid input") + } + diff := cmp.Diff(model, tt.expectedModel) + if diff != "" { + t.Fatalf("Data does not match: %s", diff) + } + }) + } +} + +func TestBuildRequest(t *testing.T) { + tests := []struct { + description string + model *inputModel + getGrafanaConfigsFails bool + getGrafanaConfigsResp *argus.GrafanaConfigs + isValid bool + expectedRequest argus.ApiUpdateGrafanaConfigsRequest + }{ + { + description: "base", + model: fixtureInputModel(), + getGrafanaConfigsResp: fixtureGrafanaConfigs(), + isValid: true, + expectedRequest: fixtureRequest(), + }, + { + description: "nil generic oauth", + model: fixtureInputModel(), + getGrafanaConfigsResp: fixtureGrafanaConfigs(func(gc *argus.GrafanaConfigs) { + gc.GenericOauth = nil + }), + isValid: true, + expectedRequest: fixtureRequest(func(request *argus.ApiUpdateGrafanaConfigsRequest) { + *request = request.UpdateGrafanaConfigsPayload(*fixturePayload(func(payload *argus.UpdateGrafanaConfigsPayload) { + payload.GenericOauth = nil + })) + }), + }, + { + description: "get grafana configs fails", + model: fixtureInputModel(), + getGrafanaConfigsFails: true, + isValid: false, + }, + { + description: "no grafana configs", + model: fixtureInputModel(), + getGrafanaConfigsResp: nil, + isValid: false, + }, + } + + for _, tt := range tests { + t.Run(tt.description, func(t *testing.T) { + client := &argusClientMocked{ + getGrafanaConfigsFails: tt.getGrafanaConfigsFails, + getGrafanaConfigsResp: tt.getGrafanaConfigsResp, + } + request, err := buildRequest(testCtx, tt.model, client) + if err != nil { + if !tt.isValid { + return + } + t.Fatalf("error building request: %v", err) + } + + diff := cmp.Diff(request, tt.expectedRequest, + cmp.AllowUnexported(tt.expectedRequest), + cmpopts.EquateComparable(testCtx), + ) + if diff != "" { + t.Fatalf("Data does not match: %s", diff) + } + }) + } +} diff --git a/internal/cmd/argus/grafana/single-sign-on/single_sign_on.go b/internal/cmd/argus/grafana/single-sign-on/single_sign_on.go new file mode 100644 index 000000000..6b2cf37cb --- /dev/null +++ b/internal/cmd/argus/grafana/single-sign-on/single_sign_on.go @@ -0,0 +1,33 @@ +package singlesignon + +import ( + "fmt" + + "github.com/stackitcloud/stackit-cli/internal/cmd/argus/grafana/single-sign-on/disable" + "github.com/stackitcloud/stackit-cli/internal/cmd/argus/grafana/single-sign-on/enable" + "github.com/stackitcloud/stackit-cli/internal/pkg/args" + "github.com/stackitcloud/stackit-cli/internal/pkg/print" + "github.com/stackitcloud/stackit-cli/internal/pkg/utils" + + "github.com/spf13/cobra" +) + +func NewCmd(p *print.Printer) *cobra.Command { + cmd := &cobra.Command{ + Use: "single-sign-on", + Short: "Enable or disable single sign-on for Grafana in Argus instances", + Long: fmt.Sprintf("%s\n%s", + "Enable or disable single sign-on for Grafana in Argus instances.", + "When enabled for an instance, overwrites the generic OAuth2 authentication and configures STACKIT single sign-on for that instance.", + ), + Args: args.NoArgs, + Run: utils.CmdHelp, + } + addSubcommands(cmd, p) + return cmd +} + +func addSubcommands(cmd *cobra.Command, p *print.Printer) { + cmd.AddCommand(enable.NewCmd(p)) + cmd.AddCommand(disable.NewCmd(p)) +} diff --git a/internal/pkg/services/argus/utils/utils.go b/internal/pkg/services/argus/utils/utils.go index 396aa84fb..9024817d4 100644 --- a/internal/pkg/services/argus/utils/utils.go +++ b/internal/pkg/services/argus/utils/utils.go @@ -17,6 +17,7 @@ const ( type ArgusClient interface { GetInstanceExecute(ctx context.Context, instanceId, projectId string) (*argus.GetInstanceResponse, error) GetGrafanaConfigsExecute(ctx context.Context, instanceId, projectId string) (*argus.GrafanaConfigs, error) + UpdateGrafanaConfigs(ctx context.Context, instanceId string, projectId string) argus.ApiUpdateGrafanaConfigsRequest } func ValidatePlanId(planId string, resp *argus.PlansResponse) error { @@ -69,41 +70,22 @@ func GetInstanceName(ctx context.Context, apiClient ArgusClient, instanceId, pro return *resp.Name, nil } -func toPayloadGenericOAuth(response *argus.GrafanaOauth) *argus.UpdateGrafanaConfigsPayloadGenericOauth { - if response == nil { +func ToPayloadGenericOAuth(respOAuth *argus.GrafanaOauth) *argus.UpdateGrafanaConfigsPayloadGenericOauth { + if respOAuth == nil { return nil } return &argus.UpdateGrafanaConfigsPayloadGenericOauth{ - ApiUrl: response.ApiUrl, - AuthUrl: response.AuthUrl, - Enabled: response.Enabled, - Name: response.Name, - OauthClientId: response.OauthClientId, - OauthClientSecret: response.OauthClientSecret, - RoleAttributePath: response.RoleAttributePath, - RoleAttributeStrict: response.RoleAttributeStrict, - Scopes: response.Scopes, - TokenUrl: response.TokenUrl, - UsePkce: response.UsePkce, - } -} - -func toRespGenericOAuth(payloadModel *argus.UpdateGrafanaConfigsPayloadGenericOauth) *argus.GrafanaOauth { - if payloadModel == nil { - return nil - } - return &argus.GrafanaOauth{ - ApiUrl: payloadModel.ApiUrl, - AuthUrl: payloadModel.AuthUrl, - Enabled: payloadModel.Enabled, - Name: payloadModel.Name, - OauthClientId: payloadModel.OauthClientId, - OauthClientSecret: payloadModel.OauthClientSecret, - RoleAttributePath: payloadModel.RoleAttributePath, - RoleAttributeStrict: payloadModel.RoleAttributeStrict, - Scopes: payloadModel.Scopes, - TokenUrl: payloadModel.TokenUrl, - UsePkce: payloadModel.UsePkce, + ApiUrl: respOAuth.ApiUrl, + AuthUrl: respOAuth.AuthUrl, + Enabled: respOAuth.Enabled, + Name: respOAuth.Name, + OauthClientId: respOAuth.OauthClientId, + OauthClientSecret: respOAuth.OauthClientSecret, + RoleAttributePath: respOAuth.RoleAttributePath, + RoleAttributeStrict: respOAuth.RoleAttributeStrict, + Scopes: respOAuth.Scopes, + TokenUrl: respOAuth.TokenUrl, + UsePkce: respOAuth.UsePkce, } } @@ -112,13 +94,12 @@ func GetPartialUpdateGrafanaConfigsPayload(ctx context.Context, apiClient ArgusC if err != nil { return nil, fmt.Errorf("get current Grafana configs: %w", err) } - - if currentConfigs == nil || currentConfigs.GenericOauth == nil { + if currentConfigs == nil { return nil, fmt.Errorf("no Grafana configs found for instance %q", instanceId) } payload := &argus.UpdateGrafanaConfigsPayload{ - GenericOauth: toPayloadGenericOAuth(currentConfigs.GenericOauth), + GenericOauth: ToPayloadGenericOAuth(currentConfigs.GenericOauth), PublicReadAccess: currentConfigs.PublicReadAccess, UseStackitSso: currentConfigs.UseStackitSso, } diff --git a/internal/pkg/services/argus/utils/utils_test.go b/internal/pkg/services/argus/utils/utils_test.go index 911eb061c..66ca7fa2d 100644 --- a/internal/pkg/services/argus/utils/utils_test.go +++ b/internal/pkg/services/argus/utils/utils_test.go @@ -14,6 +14,7 @@ import ( ) var ( + testClient = &argus.APIClient{} testProjectId = uuid.NewString() testInstanceId = uuid.NewString() testPlanId = uuid.NewString() @@ -54,6 +55,10 @@ func (m *argusClientMocked) GetGrafanaConfigsExecute(_ context.Context, _, _ str return m.getGrafanaConfigsResp, nil } +func (c *argusClientMocked) UpdateGrafanaConfigs(ctx context.Context, instanceId, projectId string) argus.ApiUpdateGrafanaConfigsRequest { + return testClient.UpdateGrafanaConfigs(ctx, instanceId, projectId) +} + func fixtureGrafanaConfigs(mods ...func(gc *argus.GrafanaConfigs)) *argus.GrafanaConfigs { gc := argus.GrafanaConfigs{ GenericOauth: &argus.GrafanaOauth{ @@ -292,7 +297,7 @@ func TestToPayloadGenericOAuth(t *testing.T) { }, }, { - description: "nil response", + description: "nil response oauth", response: nil, expected: nil, }, @@ -300,61 +305,7 @@ func TestToPayloadGenericOAuth(t *testing.T) { for _, tt := range tests { t.Run(tt.description, func(t *testing.T) { - output := toPayloadGenericOAuth(tt.response) - - diff := cmp.Diff(output, tt.expected) - if diff != "" { - t.Errorf("expected output to be %+v, got %+v", tt.expected, output) - } - }) - } -} - -func TestToRespGenericOAuth(t *testing.T) { - tests := []struct { - description string - payload *argus.UpdateGrafanaConfigsPayloadGenericOauth - expected *argus.GrafanaOauth - }{ - { - description: "base", - payload: &argus.UpdateGrafanaConfigsPayloadGenericOauth{ - ApiUrl: utils.Ptr("apiUrl"), - AuthUrl: utils.Ptr("authUrl"), - Enabled: utils.Ptr(true), - Name: utils.Ptr("name"), - OauthClientId: utils.Ptr("oauthClientId"), - OauthClientSecret: utils.Ptr("oauthClientSecret"), - RoleAttributePath: utils.Ptr("roleAttributePath"), - RoleAttributeStrict: utils.Ptr(true), - Scopes: utils.Ptr("scopes"), - TokenUrl: utils.Ptr("tokenUrl"), - UsePkce: utils.Ptr(true), - }, - expected: &argus.GrafanaOauth{ - ApiUrl: utils.Ptr("apiUrl"), - AuthUrl: utils.Ptr("authUrl"), - Enabled: utils.Ptr(true), - Name: utils.Ptr("name"), - OauthClientId: utils.Ptr("oauthClientId"), - OauthClientSecret: utils.Ptr("oauthClientSecret"), - RoleAttributePath: utils.Ptr("roleAttributePath"), - RoleAttributeStrict: utils.Ptr(true), - Scopes: utils.Ptr("scopes"), - TokenUrl: utils.Ptr("tokenUrl"), - UsePkce: utils.Ptr(true), - }, - }, - { - description: "nil payload", - payload: nil, - expected: nil, - }, - } - - for _, tt := range tests { - t.Run(tt.description, func(t *testing.T) { - output := toRespGenericOAuth(tt.payload) + output := ToPayloadGenericOAuth(tt.response) diff := cmp.Diff(output, tt.expected) if diff != "" { @@ -381,7 +332,7 @@ func TestGetPartialUpdateGrafanaConfigsPayload(t *testing.T) { getGrafanaConfigsResp: fixtureGrafanaConfigs(), isValid: true, expectedPayload: &argus.UpdateGrafanaConfigsPayload{ - GenericOauth: toPayloadGenericOAuth(fixtureGrafanaConfigs().GenericOauth), + GenericOauth: ToPayloadGenericOAuth(fixtureGrafanaConfigs().GenericOauth), UseStackitSso: utils.Ptr(true), PublicReadAccess: utils.Ptr(true), }, @@ -393,7 +344,7 @@ func TestGetPartialUpdateGrafanaConfigsPayload(t *testing.T) { getGrafanaConfigsResp: fixtureGrafanaConfigs(), isValid: true, expectedPayload: &argus.UpdateGrafanaConfigsPayload{ - GenericOauth: toPayloadGenericOAuth(fixtureGrafanaConfigs().GenericOauth), + GenericOauth: ToPayloadGenericOAuth(fixtureGrafanaConfigs().GenericOauth), UseStackitSso: utils.Ptr(false), PublicReadAccess: utils.Ptr(false), }, @@ -405,7 +356,7 @@ func TestGetPartialUpdateGrafanaConfigsPayload(t *testing.T) { getGrafanaConfigsResp: fixtureGrafanaConfigs(), isValid: true, expectedPayload: &argus.UpdateGrafanaConfigsPayload{ - GenericOauth: toPayloadGenericOAuth(fixtureGrafanaConfigs().GenericOauth), + GenericOauth: ToPayloadGenericOAuth(fixtureGrafanaConfigs().GenericOauth), UseStackitSso: utils.Ptr(true), PublicReadAccess: fixtureGrafanaConfigs().PublicReadAccess, }, @@ -417,7 +368,7 @@ func TestGetPartialUpdateGrafanaConfigsPayload(t *testing.T) { getGrafanaConfigsResp: fixtureGrafanaConfigs(), isValid: true, expectedPayload: &argus.UpdateGrafanaConfigsPayload{ - GenericOauth: toPayloadGenericOAuth(fixtureGrafanaConfigs().GenericOauth), + GenericOauth: ToPayloadGenericOAuth(fixtureGrafanaConfigs().GenericOauth), UseStackitSso: fixtureGrafanaConfigs().UseStackitSso, PublicReadAccess: utils.Ptr(true), }, @@ -431,7 +382,7 @@ func TestGetPartialUpdateGrafanaConfigsPayload(t *testing.T) { }), isValid: true, expectedPayload: &argus.UpdateGrafanaConfigsPayload{ - GenericOauth: toPayloadGenericOAuth(fixtureGrafanaConfigs().GenericOauth), + GenericOauth: ToPayloadGenericOAuth(fixtureGrafanaConfigs().GenericOauth), UseStackitSso: utils.Ptr(false), PublicReadAccess: fixtureGrafanaConfigs().PublicReadAccess, }, @@ -445,11 +396,23 @@ func TestGetPartialUpdateGrafanaConfigsPayload(t *testing.T) { }), isValid: true, expectedPayload: &argus.UpdateGrafanaConfigsPayload{ - GenericOauth: toPayloadGenericOAuth(fixtureGrafanaConfigs().GenericOauth), + GenericOauth: ToPayloadGenericOAuth(fixtureGrafanaConfigs().GenericOauth), UseStackitSso: fixtureGrafanaConfigs().UseStackitSso, PublicReadAccess: utils.Ptr(false), }, }, + { + description: "nil generic oauth", + singleSignOn: utils.Ptr(true), + publicReadAccess: utils.Ptr(true), + getGrafanaConfigsResp: &argus.GrafanaConfigs{}, + isValid: true, + expectedPayload: &argus.UpdateGrafanaConfigsPayload{ + GenericOauth: nil, + UseStackitSso: utils.Ptr(true), + PublicReadAccess: utils.Ptr(true), + }, + }, { description: "get grafana configs fails", singleSignOn: utils.Ptr(true), @@ -461,7 +424,7 @@ func TestGetPartialUpdateGrafanaConfigsPayload(t *testing.T) { description: "no grafana configs", singleSignOn: utils.Ptr(true), publicReadAccess: utils.Ptr(true), - getGrafanaConfigsResp: &argus.GrafanaConfigs{}, + getGrafanaConfigsResp: nil, isValid: false, }, } From b89639cec392f189eb9be3a311b09f856235ce0f Mon Sep 17 00:00:00 2001 From: Kumm-Kai <70690427+Kumm-Kai@users.noreply.github.com> Date: Wed, 17 Apr 2024 13:49:37 +0000 Subject: [PATCH 05/17] Add repology packaging status badge to INSTALLATION docs (#215) --- INSTALLATION.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/INSTALLATION.md b/INSTALLATION.md index 7d79bf20c..68fe8a102 100644 --- a/INSTALLATION.md +++ b/INSTALLATION.md @@ -2,6 +2,8 @@ ## Package managers +[![Packaging status](https://repology.org/badge/vertical-allrepos/stackit-cli.svg?columns=3)](https://repology.org/project/stackit-cli/versions) + ### macOS The STACKIT CLI can be installed through the [Homebrew](https://brew.sh/) package manager. From 3de5783d1bf217d8ba146eb6617b3aa8d475b731 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Palet?= Date: Wed, 17 Apr 2024 16:00:57 +0100 Subject: [PATCH 06/17] Add argus grafana `public-read-access` commands (#229) * Copy files from single sign-on * Adaptations for the public-read-access commands * Update docs * Improvements after review * Move instance ID to argument * Adapt examples --- docs/stackit_argus_grafana.md | 1 + ...tackit_argus_grafana_public-read-access.md | 35 ++ ...rgus_grafana_public-read-access_disable.md | 40 +++ ...argus_grafana_public-read-access_enable.md | 40 +++ ...it_argus_grafana_single-sign-on_disable.md | 7 +- ...kit_argus_grafana_single-sign-on_enable.md | 7 +- internal/cmd/argus/grafana/grafana.go | 2 + .../public-read-access/disable/disable.go | 108 +++++++ .../disable/disable_test.go | 304 ++++++++++++++++++ .../public-read-access/enable/enable.go | 108 +++++++ .../public-read-access/enable/enable_test.go | 304 ++++++++++++++++++ .../public-read-access/public_read_access.go | 33 ++ .../grafana/single-sign-on/disable/disable.go | 29 +- .../single-sign-on/disable/disable_test.go | 45 ++- .../grafana/single-sign-on/enable/enable.go | 29 +- .../single-sign-on/enable/enable_test.go | 45 ++- 16 files changed, 1083 insertions(+), 54 deletions(-) create mode 100644 docs/stackit_argus_grafana_public-read-access.md create mode 100644 docs/stackit_argus_grafana_public-read-access_disable.md create mode 100644 docs/stackit_argus_grafana_public-read-access_enable.md create mode 100644 internal/cmd/argus/grafana/public-read-access/disable/disable.go create mode 100644 internal/cmd/argus/grafana/public-read-access/disable/disable_test.go create mode 100644 internal/cmd/argus/grafana/public-read-access/enable/enable.go create mode 100644 internal/cmd/argus/grafana/public-read-access/enable/enable_test.go create mode 100644 internal/cmd/argus/grafana/public-read-access/public_read_access.go diff --git a/docs/stackit_argus_grafana.md b/docs/stackit_argus_grafana.md index c1ce6b5b5..c6743ac86 100644 --- a/docs/stackit_argus_grafana.md +++ b/docs/stackit_argus_grafana.md @@ -30,5 +30,6 @@ stackit argus grafana [flags] * [stackit argus](./stackit_argus.md) - Provides functionality for Argus * [stackit argus grafana describe](./stackit_argus_grafana_describe.md) - Shows details of the Grafana configuration of an Argus instance +* [stackit argus grafana public-read-access](./stackit_argus_grafana_public-read-access.md) - Enable or disable public read access for Grafana in Argus instances * [stackit argus grafana single-sign-on](./stackit_argus_grafana_single-sign-on.md) - Enable or disable single sign-on for Grafana in Argus instances diff --git a/docs/stackit_argus_grafana_public-read-access.md b/docs/stackit_argus_grafana_public-read-access.md new file mode 100644 index 000000000..bc0f7791e --- /dev/null +++ b/docs/stackit_argus_grafana_public-read-access.md @@ -0,0 +1,35 @@ +## stackit argus grafana public-read-access + +Enable or disable public read access for Grafana in Argus instances + +### Synopsis + +Enable or disable public read access for Grafana in Argus instances. +When enabled, anyone can access the Grafana dashboards of the instance without logging in. Otherwise, a login is required. + +``` +stackit argus grafana public-read-access [flags] +``` + +### Options + +``` + -h, --help Help for "stackit argus grafana public-read-access" +``` + +### Options inherited from parent commands + +``` + -y, --assume-yes If set, skips all confirmation prompts + --async If set, runs the command asynchronously + -o, --output-format string Output format, one of ["json" "pretty"] + -p, --project-id string Project ID + --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") +``` + +### SEE ALSO + +* [stackit argus grafana](./stackit_argus_grafana.md) - Provides functionality for the Grafana configuration of Argus instances +* [stackit argus grafana public-read-access disable](./stackit_argus_grafana_public-read-access_disable.md) - Disables public read access for Grafana on Argus instances +* [stackit argus grafana public-read-access enable](./stackit_argus_grafana_public-read-access_enable.md) - Enables public read access for Grafana on Argus instances + diff --git a/docs/stackit_argus_grafana_public-read-access_disable.md b/docs/stackit_argus_grafana_public-read-access_disable.md new file mode 100644 index 000000000..9f1b821f3 --- /dev/null +++ b/docs/stackit_argus_grafana_public-read-access_disable.md @@ -0,0 +1,40 @@ +## stackit argus grafana public-read-access disable + +Disables public read access for Grafana on Argus instances + +### Synopsis + +Disables public read access for Grafana on Argus instances. +When disabled, a login is required to access the Grafana dashboards of the instance. Otherwise, anyone can access the dashboards. + +``` +stackit argus grafana public-read-access disable INSTANCE_ID [flags] +``` + +### Examples + +``` + Disable public read access for Grafana on an Argus instance with ID "xxx" + $ stackit argus grafana public-read-access disable xxx +``` + +### Options + +``` + -h, --help Help for "stackit argus grafana public-read-access disable" +``` + +### Options inherited from parent commands + +``` + -y, --assume-yes If set, skips all confirmation prompts + --async If set, runs the command asynchronously + -o, --output-format string Output format, one of ["json" "pretty"] + -p, --project-id string Project ID + --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") +``` + +### SEE ALSO + +* [stackit argus grafana public-read-access](./stackit_argus_grafana_public-read-access.md) - Enable or disable public read access for Grafana in Argus instances + diff --git a/docs/stackit_argus_grafana_public-read-access_enable.md b/docs/stackit_argus_grafana_public-read-access_enable.md new file mode 100644 index 000000000..b66012713 --- /dev/null +++ b/docs/stackit_argus_grafana_public-read-access_enable.md @@ -0,0 +1,40 @@ +## stackit argus grafana public-read-access enable + +Enables public read access for Grafana on Argus instances + +### Synopsis + +Enables public read access for Grafana on Argus instances. +When enabled, anyone can access the Grafana dashboards of the instance without logging in. Otherwise, a login is required. + +``` +stackit argus grafana public-read-access enable INSTANCE_ID [flags] +``` + +### Examples + +``` + Enable public read access for Grafana on an Argus instance with ID "xxx" + $ stackit argus grafana public-read-access enable xxx +``` + +### Options + +``` + -h, --help Help for "stackit argus grafana public-read-access enable" +``` + +### Options inherited from parent commands + +``` + -y, --assume-yes If set, skips all confirmation prompts + --async If set, runs the command asynchronously + -o, --output-format string Output format, one of ["json" "pretty"] + -p, --project-id string Project ID + --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") +``` + +### SEE ALSO + +* [stackit argus grafana public-read-access](./stackit_argus_grafana_public-read-access.md) - Enable or disable public read access for Grafana in Argus instances + diff --git a/docs/stackit_argus_grafana_single-sign-on_disable.md b/docs/stackit_argus_grafana_single-sign-on_disable.md index 143273e20..0baf8e753 100644 --- a/docs/stackit_argus_grafana_single-sign-on_disable.md +++ b/docs/stackit_argus_grafana_single-sign-on_disable.md @@ -8,21 +8,20 @@ Disables single sign-on for Grafana on Argus instances. When disabled for an instance, the generic OAuth2 authentication is used for that instance. ``` -stackit argus grafana single-sign-on disable [flags] +stackit argus grafana single-sign-on disable INSTANCE_ID [flags] ``` ### Examples ``` Disable single sign-on for Grafana on an Argus instance with ID "xxx" - $ stackit argus grafana single-sign-on disable --instance-id xxx + $ stackit argus grafana single-sign-on disable xxx ``` ### Options ``` - -h, --help Help for "stackit argus grafana single-sign-on disable" - --instance-id string Instance ID + -h, --help Help for "stackit argus grafana single-sign-on disable" ``` ### Options inherited from parent commands diff --git a/docs/stackit_argus_grafana_single-sign-on_enable.md b/docs/stackit_argus_grafana_single-sign-on_enable.md index ad83abb99..34bb9c6a6 100644 --- a/docs/stackit_argus_grafana_single-sign-on_enable.md +++ b/docs/stackit_argus_grafana_single-sign-on_enable.md @@ -8,21 +8,20 @@ Enables single sign-on for Grafana on Argus instances. When enabled for an instance, overwrites the generic OAuth2 authentication and configures STACKIT single sign-on for that instance. ``` -stackit argus grafana single-sign-on enable [flags] +stackit argus grafana single-sign-on enable INSTANCE_ID [flags] ``` ### Examples ``` Enable single sign-on for Grafana on an Argus instance with ID "xxx" - $ stackit argus grafana single-sign-on enable --instance-id xxx + $ stackit argus grafana single-sign-on enable xxx ``` ### Options ``` - -h, --help Help for "stackit argus grafana single-sign-on enable" - --instance-id string Instance ID + -h, --help Help for "stackit argus grafana single-sign-on enable" ``` ### Options inherited from parent commands diff --git a/internal/cmd/argus/grafana/grafana.go b/internal/cmd/argus/grafana/grafana.go index 0ce98f4c8..19ed4368a 100644 --- a/internal/cmd/argus/grafana/grafana.go +++ b/internal/cmd/argus/grafana/grafana.go @@ -2,6 +2,7 @@ package grafana import ( "github.com/stackitcloud/stackit-cli/internal/cmd/argus/grafana/describe" + publicreadaccess "github.com/stackitcloud/stackit-cli/internal/cmd/argus/grafana/public-read-access" singlesignon "github.com/stackitcloud/stackit-cli/internal/cmd/argus/grafana/single-sign-on" "github.com/stackitcloud/stackit-cli/internal/pkg/args" "github.com/stackitcloud/stackit-cli/internal/pkg/print" @@ -24,5 +25,6 @@ func NewCmd(p *print.Printer) *cobra.Command { func addSubcommands(cmd *cobra.Command, p *print.Printer) { cmd.AddCommand(describe.NewCmd(p)) + cmd.AddCommand(publicreadaccess.NewCmd(p)) cmd.AddCommand(singlesignon.NewCmd(p)) } diff --git a/internal/cmd/argus/grafana/public-read-access/disable/disable.go b/internal/cmd/argus/grafana/public-read-access/disable/disable.go new file mode 100644 index 000000000..e06157372 --- /dev/null +++ b/internal/cmd/argus/grafana/public-read-access/disable/disable.go @@ -0,0 +1,108 @@ +package disable + +import ( + "context" + "fmt" + + "github.com/stackitcloud/stackit-cli/internal/pkg/args" + "github.com/stackitcloud/stackit-cli/internal/pkg/errors" + "github.com/stackitcloud/stackit-cli/internal/pkg/examples" + "github.com/stackitcloud/stackit-cli/internal/pkg/globalflags" + "github.com/stackitcloud/stackit-cli/internal/pkg/print" + "github.com/stackitcloud/stackit-cli/internal/pkg/services/argus/client" + argusUtils "github.com/stackitcloud/stackit-cli/internal/pkg/services/argus/utils" + "github.com/stackitcloud/stackit-cli/internal/pkg/utils" + + "github.com/spf13/cobra" + "github.com/stackitcloud/stackit-sdk-go/services/argus" +) + +const ( + instanceIdArg = "INSTANCE_ID" +) + +type inputModel struct { + *globalflags.GlobalFlagModel + InstanceId string +} + +func NewCmd(p *print.Printer) *cobra.Command { + cmd := &cobra.Command{ + Use: fmt.Sprintf("disable %s", instanceIdArg), + Short: "Disables public read access for Grafana on Argus instances", + Long: fmt.Sprintf("%s\n%s", + "Disables public read access for Grafana on Argus instances.", + "When disabled, a login is required to access the Grafana dashboards of the instance. Otherwise, anyone can access the dashboards.", + ), + Args: args.SingleArg(instanceIdArg, utils.ValidateUUID), + Example: examples.Build( + examples.NewExample( + `Disable public read access for Grafana on an Argus instance with ID "xxx"`, + "$ stackit argus grafana public-read-access disable xxx"), + ), + RunE: func(cmd *cobra.Command, args []string) error { + ctx := context.Background() + model, err := parseInput(cmd, args) + if err != nil { + return err + } + + // Configure API client + apiClient, err := client.ConfigureClient(p) + if err != nil { + return err + } + + instanceLabel, err := argusUtils.GetInstanceName(ctx, apiClient, model.InstanceId, model.ProjectId) + if err != nil || instanceLabel == "" { + instanceLabel = model.InstanceId + } + + if !model.AssumeYes { + prompt := fmt.Sprintf("Are you sure you want to disable Grafana public read access for instance %q?", instanceLabel) + err = p.PromptForConfirmation(prompt) + if err != nil { + return err + } + } + + // Call API + req, err := buildRequest(ctx, model, apiClient) + if err != nil { + return fmt.Errorf("build request: %w", err) + } + _, err = req.Execute() + if err != nil { + return fmt.Errorf("disable grafana public read access: %w", err) + } + + p.Info("Disabled Grafana public read access for instance %q\n", instanceLabel) + return nil + }, + } + return cmd +} + +func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { + instanceId := inputArgs[0] + + globalFlags := globalflags.Parse(cmd) + if globalFlags.ProjectId == "" { + return nil, &errors.ProjectIdError{} + } + + return &inputModel{ + GlobalFlagModel: globalFlags, + InstanceId: instanceId, + }, nil +} + +func buildRequest(ctx context.Context, model *inputModel, apiClient argusUtils.ArgusClient) (argus.ApiUpdateGrafanaConfigsRequest, error) { + req := apiClient.UpdateGrafanaConfigs(ctx, model.InstanceId, model.ProjectId) + payload, err := argusUtils.GetPartialUpdateGrafanaConfigsPayload(ctx, apiClient, model.InstanceId, model.ProjectId, nil, utils.Ptr(false)) + if err != nil { + return req, fmt.Errorf("build request payload: %w", err) + } + req = req.UpdateGrafanaConfigsPayload(*payload) + return req, nil +} diff --git a/internal/cmd/argus/grafana/public-read-access/disable/disable_test.go b/internal/cmd/argus/grafana/public-read-access/disable/disable_test.go new file mode 100644 index 000000000..9ef2296f9 --- /dev/null +++ b/internal/cmd/argus/grafana/public-read-access/disable/disable_test.go @@ -0,0 +1,304 @@ +package disable + +import ( + "context" + "fmt" + "testing" + + "github.com/stackitcloud/stackit-cli/internal/pkg/globalflags" + argusUtils "github.com/stackitcloud/stackit-cli/internal/pkg/services/argus/utils" + "github.com/stackitcloud/stackit-cli/internal/pkg/utils" + + "github.com/google/go-cmp/cmp" + "github.com/google/go-cmp/cmp/cmpopts" + "github.com/google/uuid" + "github.com/stackitcloud/stackit-sdk-go/services/argus" +) + +var projectIdFlag = globalflags.ProjectIdFlag + +type testCtxKey struct{} + +var testCtx = context.WithValue(context.Background(), testCtxKey{}, "foo") +var testClient = &argus.APIClient{} +var testProjectId = uuid.NewString() +var testInstanceId = uuid.NewString() + +type argusClientMocked struct { + getGrafanaConfigsFails bool + getGrafanaConfigsResp *argus.GrafanaConfigs +} + +func (c *argusClientMocked) GetInstanceExecute(ctx context.Context, instanceId, projectId string) (*argus.GetInstanceResponse, error) { + return testClient.GetInstanceExecute(ctx, instanceId, projectId) +} + +func (c *argusClientMocked) UpdateGrafanaConfigs(ctx context.Context, instanceId, projectId string) argus.ApiUpdateGrafanaConfigsRequest { + return testClient.UpdateGrafanaConfigs(ctx, instanceId, projectId) +} + +func (c *argusClientMocked) GetGrafanaConfigsExecute(_ context.Context, _, _ string) (*argus.GrafanaConfigs, error) { + if c.getGrafanaConfigsFails { + return nil, fmt.Errorf("get payload failed") + } + return c.getGrafanaConfigsResp, nil +} + +func fixtureArgValues(mods ...func(argValues []string)) []string { + argValues := []string{ + testInstanceId, + } + for _, mod := range mods { + mod(argValues) + } + return argValues +} + +func fixtureFlagValues(mods ...func(flagValues map[string]string)) map[string]string { + flagValues := map[string]string{ + projectIdFlag: testProjectId, + } + for _, mod := range mods { + mod(flagValues) + } + return flagValues +} + +func fixtureInputModel(mods ...func(model *inputModel)) *inputModel { + model := &inputModel{ + GlobalFlagModel: &globalflags.GlobalFlagModel{ + ProjectId: testProjectId, + Verbosity: globalflags.VerbosityDefault, + }, + InstanceId: testInstanceId, + } + for _, mod := range mods { + mod(model) + } + return model +} + +func fixtureGrafanaConfigs(mods ...func(gc *argus.GrafanaConfigs)) *argus.GrafanaConfigs { + gc := argus.GrafanaConfigs{ + GenericOauth: &argus.GrafanaOauth{ + ApiUrl: utils.Ptr("apiUrl"), + AuthUrl: utils.Ptr("authUrl"), + Enabled: utils.Ptr(true), + Name: utils.Ptr("name"), + OauthClientId: utils.Ptr("oauthClientId"), + OauthClientSecret: utils.Ptr("oauthClientSecret"), + RoleAttributePath: utils.Ptr("roleAttributePath"), + RoleAttributeStrict: utils.Ptr(true), + Scopes: utils.Ptr("scopes"), + TokenUrl: utils.Ptr("tokenUrl"), + UsePkce: utils.Ptr(true), + }, + PublicReadAccess: utils.Ptr(false), + UseStackitSso: utils.Ptr(false), + } + for _, mod := range mods { + mod(&gc) + } + return &gc +} + +func fixturePayload(mods ...func(payload *argus.UpdateGrafanaConfigsPayload)) *argus.UpdateGrafanaConfigsPayload { + payload := &argus.UpdateGrafanaConfigsPayload{ + GenericOauth: argusUtils.ToPayloadGenericOAuth(fixtureGrafanaConfigs().GenericOauth), + PublicReadAccess: utils.Ptr(false), + UseStackitSso: fixtureGrafanaConfigs().UseStackitSso, + } + for _, mod := range mods { + mod(payload) + } + return payload +} + +func fixtureRequest(mods ...func(request *argus.ApiUpdateGrafanaConfigsRequest)) argus.ApiUpdateGrafanaConfigsRequest { + request := testClient.UpdateGrafanaConfigs(testCtx, testInstanceId, testProjectId) + request = request.UpdateGrafanaConfigsPayload(*fixturePayload()) + for _, mod := range mods { + mod(&request) + } + return request +} + +func TestParseInput(t *testing.T) { + tests := []struct { + description string + argValues []string + flagValues map[string]string + isValid bool + expectedModel *inputModel + }{ + { + description: "base", + argValues: fixtureArgValues(), + flagValues: fixtureFlagValues(), + isValid: true, + expectedModel: fixtureInputModel(), + }, + { + description: "no arg values", + argValues: []string{}, + flagValues: fixtureFlagValues(), + isValid: false, + }, + { + description: "project id missing", + argValues: fixtureArgValues(), + flagValues: fixtureFlagValues(func(flagValues map[string]string) { + delete(flagValues, projectIdFlag) + }), + isValid: false, + }, + { + description: "project id invalid 1", + argValues: fixtureArgValues(), + flagValues: fixtureFlagValues(func(flagValues map[string]string) { + flagValues[projectIdFlag] = "" + }), + isValid: false, + }, + { + description: "project id invalid 2", + argValues: fixtureArgValues(), + flagValues: fixtureFlagValues(func(flagValues map[string]string) { + flagValues[projectIdFlag] = "invalid-uuid" + }), + isValid: false, + }, + { + description: "instance id invalid 1", + argValues: []string{""}, + flagValues: fixtureFlagValues(), + isValid: false, + }, + { + description: "instance id invalid 2", + argValues: []string{"invalid-uuid"}, + flagValues: fixtureFlagValues(), + isValid: false, + }, + } + + for _, tt := range tests { + t.Run(tt.description, func(t *testing.T) { + cmd := NewCmd(nil) + err := globalflags.Configure(cmd.Flags()) + if err != nil { + t.Fatalf("configure global flags: %v", err) + } + + for flag, value := range tt.flagValues { + err := cmd.Flags().Set(flag, value) + if err != nil { + if !tt.isValid { + return + } + t.Fatalf("setting flag --%s=%s: %v", flag, value, err) + } + } + + err = cmd.ValidateArgs(tt.argValues) + if err != nil { + if !tt.isValid { + return + } + t.Fatalf("error validating args: %v", err) + } + + err = cmd.ValidateRequiredFlags() + if err != nil { + if !tt.isValid { + return + } + t.Fatalf("error validating flags: %v", err) + } + + model, err := parseInput(cmd, tt.argValues) + if err != nil { + if !tt.isValid { + return + } + t.Fatalf("error parsing flags: %v", err) + } + + if !tt.isValid { + t.Fatalf("did not fail on invalid input") + } + diff := cmp.Diff(model, tt.expectedModel) + if diff != "" { + t.Fatalf("Data does not match: %s", diff) + } + }) + } +} + +func TestBuildRequest(t *testing.T) { + tests := []struct { + description string + model *inputModel + getGrafanaConfigsFails bool + getGrafanaConfigsResp *argus.GrafanaConfigs + isValid bool + expectedRequest argus.ApiUpdateGrafanaConfigsRequest + }{ + { + description: "base", + model: fixtureInputModel(), + getGrafanaConfigsResp: fixtureGrafanaConfigs(), + isValid: true, + expectedRequest: fixtureRequest(), + }, + { + description: "nil generic oauth", + model: fixtureInputModel(), + getGrafanaConfigsResp: fixtureGrafanaConfigs(func(gc *argus.GrafanaConfigs) { + gc.GenericOauth = nil + }), + isValid: true, + expectedRequest: fixtureRequest(func(request *argus.ApiUpdateGrafanaConfigsRequest) { + *request = request.UpdateGrafanaConfigsPayload(*fixturePayload(func(payload *argus.UpdateGrafanaConfigsPayload) { + payload.GenericOauth = nil + })) + }), + }, + { + description: "get grafana configs fails", + model: fixtureInputModel(), + getGrafanaConfigsFails: true, + isValid: false, + }, + { + description: "no grafana configs", + model: fixtureInputModel(), + getGrafanaConfigsResp: nil, + isValid: false, + }, + } + + for _, tt := range tests { + t.Run(tt.description, func(t *testing.T) { + client := &argusClientMocked{ + getGrafanaConfigsFails: tt.getGrafanaConfigsFails, + getGrafanaConfigsResp: tt.getGrafanaConfigsResp, + } + request, err := buildRequest(testCtx, tt.model, client) + if err != nil { + if !tt.isValid { + return + } + t.Fatalf("error building request: %v", err) + } + + diff := cmp.Diff(request, tt.expectedRequest, + cmp.AllowUnexported(tt.expectedRequest), + cmpopts.EquateComparable(testCtx), + ) + if diff != "" { + t.Fatalf("Data does not match: %s", diff) + } + }) + } +} diff --git a/internal/cmd/argus/grafana/public-read-access/enable/enable.go b/internal/cmd/argus/grafana/public-read-access/enable/enable.go new file mode 100644 index 000000000..df0ccbd3b --- /dev/null +++ b/internal/cmd/argus/grafana/public-read-access/enable/enable.go @@ -0,0 +1,108 @@ +package enable + +import ( + "context" + "fmt" + + "github.com/stackitcloud/stackit-cli/internal/pkg/args" + "github.com/stackitcloud/stackit-cli/internal/pkg/errors" + "github.com/stackitcloud/stackit-cli/internal/pkg/examples" + "github.com/stackitcloud/stackit-cli/internal/pkg/globalflags" + "github.com/stackitcloud/stackit-cli/internal/pkg/print" + "github.com/stackitcloud/stackit-cli/internal/pkg/services/argus/client" + argusUtils "github.com/stackitcloud/stackit-cli/internal/pkg/services/argus/utils" + "github.com/stackitcloud/stackit-cli/internal/pkg/utils" + + "github.com/spf13/cobra" + "github.com/stackitcloud/stackit-sdk-go/services/argus" +) + +const ( + instanceIdArg = "INSTANCE_ID" +) + +type inputModel struct { + *globalflags.GlobalFlagModel + InstanceId string +} + +func NewCmd(p *print.Printer) *cobra.Command { + cmd := &cobra.Command{ + Use: fmt.Sprintf("enable %s", instanceIdArg), + Short: "Enables public read access for Grafana on Argus instances", + Long: fmt.Sprintf("%s\n%s", + "Enables public read access for Grafana on Argus instances.", + "When enabled, anyone can access the Grafana dashboards of the instance without logging in. Otherwise, a login is required.", + ), + Args: args.SingleArg(instanceIdArg, utils.ValidateUUID), + Example: examples.Build( + examples.NewExample( + `Enable public read access for Grafana on an Argus instance with ID "xxx"`, + "$ stackit argus grafana public-read-access enable xxx"), + ), + RunE: func(cmd *cobra.Command, args []string) error { + ctx := context.Background() + model, err := parseInput(cmd, args) + if err != nil { + return err + } + + // Configure API client + apiClient, err := client.ConfigureClient(p) + if err != nil { + return err + } + + instanceLabel, err := argusUtils.GetInstanceName(ctx, apiClient, model.InstanceId, model.ProjectId) + if err != nil || instanceLabel == "" { + instanceLabel = model.InstanceId + } + + if !model.AssumeYes { + prompt := fmt.Sprintf("Are you sure you want to enable Grafana public read access for instance %q?", instanceLabel) + err = p.PromptForConfirmation(prompt) + if err != nil { + return err + } + } + + // Call API + req, err := buildRequest(ctx, model, apiClient) + if err != nil { + return fmt.Errorf("build request: %w", err) + } + _, err = req.Execute() + if err != nil { + return fmt.Errorf("enable grafana public read access: %w", err) + } + + p.Info("Enabled Grafana public read access for instance %q\n", instanceLabel) + return nil + }, + } + return cmd +} + +func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { + instanceId := inputArgs[0] + + globalFlags := globalflags.Parse(cmd) + if globalFlags.ProjectId == "" { + return nil, &errors.ProjectIdError{} + } + + return &inputModel{ + GlobalFlagModel: globalFlags, + InstanceId: instanceId, + }, nil +} + +func buildRequest(ctx context.Context, model *inputModel, apiClient argusUtils.ArgusClient) (argus.ApiUpdateGrafanaConfigsRequest, error) { + req := apiClient.UpdateGrafanaConfigs(ctx, model.InstanceId, model.ProjectId) + payload, err := argusUtils.GetPartialUpdateGrafanaConfigsPayload(ctx, apiClient, model.InstanceId, model.ProjectId, nil, utils.Ptr(true)) + if err != nil { + return req, fmt.Errorf("build request payload: %w", err) + } + req = req.UpdateGrafanaConfigsPayload(*payload) + return req, nil +} diff --git a/internal/cmd/argus/grafana/public-read-access/enable/enable_test.go b/internal/cmd/argus/grafana/public-read-access/enable/enable_test.go new file mode 100644 index 000000000..1e0794bdd --- /dev/null +++ b/internal/cmd/argus/grafana/public-read-access/enable/enable_test.go @@ -0,0 +1,304 @@ +package enable + +import ( + "context" + "fmt" + "testing" + + "github.com/stackitcloud/stackit-cli/internal/pkg/globalflags" + argusUtils "github.com/stackitcloud/stackit-cli/internal/pkg/services/argus/utils" + "github.com/stackitcloud/stackit-cli/internal/pkg/utils" + + "github.com/google/go-cmp/cmp" + "github.com/google/go-cmp/cmp/cmpopts" + "github.com/google/uuid" + "github.com/stackitcloud/stackit-sdk-go/services/argus" +) + +var projectIdFlag = globalflags.ProjectIdFlag + +type testCtxKey struct{} + +var testCtx = context.WithValue(context.Background(), testCtxKey{}, "foo") +var testClient = &argus.APIClient{} +var testProjectId = uuid.NewString() +var testInstanceId = uuid.NewString() + +type argusClientMocked struct { + getGrafanaConfigsFails bool + getGrafanaConfigsResp *argus.GrafanaConfigs +} + +func (c *argusClientMocked) GetInstanceExecute(ctx context.Context, instanceId, projectId string) (*argus.GetInstanceResponse, error) { + return testClient.GetInstanceExecute(ctx, instanceId, projectId) +} + +func (c *argusClientMocked) UpdateGrafanaConfigs(ctx context.Context, instanceId, projectId string) argus.ApiUpdateGrafanaConfigsRequest { + return testClient.UpdateGrafanaConfigs(ctx, instanceId, projectId) +} + +func (c *argusClientMocked) GetGrafanaConfigsExecute(_ context.Context, _, _ string) (*argus.GrafanaConfigs, error) { + if c.getGrafanaConfigsFails { + return nil, fmt.Errorf("get payload failed") + } + return c.getGrafanaConfigsResp, nil +} + +func fixtureArgValues(mods ...func(argValues []string)) []string { + argValues := []string{ + testInstanceId, + } + for _, mod := range mods { + mod(argValues) + } + return argValues +} + +func fixtureFlagValues(mods ...func(flagValues map[string]string)) map[string]string { + flagValues := map[string]string{ + projectIdFlag: testProjectId, + } + for _, mod := range mods { + mod(flagValues) + } + return flagValues +} + +func fixtureInputModel(mods ...func(model *inputModel)) *inputModel { + model := &inputModel{ + GlobalFlagModel: &globalflags.GlobalFlagModel{ + ProjectId: testProjectId, + Verbosity: globalflags.VerbosityDefault, + }, + InstanceId: testInstanceId, + } + for _, mod := range mods { + mod(model) + } + return model +} + +func fixtureGrafanaConfigs(mods ...func(gc *argus.GrafanaConfigs)) *argus.GrafanaConfigs { + gc := argus.GrafanaConfigs{ + GenericOauth: &argus.GrafanaOauth{ + ApiUrl: utils.Ptr("apiUrl"), + AuthUrl: utils.Ptr("authUrl"), + Enabled: utils.Ptr(true), + Name: utils.Ptr("name"), + OauthClientId: utils.Ptr("oauthClientId"), + OauthClientSecret: utils.Ptr("oauthClientSecret"), + RoleAttributePath: utils.Ptr("roleAttributePath"), + RoleAttributeStrict: utils.Ptr(true), + Scopes: utils.Ptr("scopes"), + TokenUrl: utils.Ptr("tokenUrl"), + UsePkce: utils.Ptr(true), + }, + PublicReadAccess: utils.Ptr(false), + UseStackitSso: utils.Ptr(false), + } + for _, mod := range mods { + mod(&gc) + } + return &gc +} + +func fixturePayload(mods ...func(payload *argus.UpdateGrafanaConfigsPayload)) *argus.UpdateGrafanaConfigsPayload { + payload := &argus.UpdateGrafanaConfigsPayload{ + GenericOauth: argusUtils.ToPayloadGenericOAuth(fixtureGrafanaConfigs().GenericOauth), + PublicReadAccess: utils.Ptr(true), + UseStackitSso: fixtureGrafanaConfigs().UseStackitSso, + } + for _, mod := range mods { + mod(payload) + } + return payload +} + +func fixtureRequest(mods ...func(request *argus.ApiUpdateGrafanaConfigsRequest)) argus.ApiUpdateGrafanaConfigsRequest { + request := testClient.UpdateGrafanaConfigs(testCtx, testInstanceId, testProjectId) + request = request.UpdateGrafanaConfigsPayload(*fixturePayload()) + for _, mod := range mods { + mod(&request) + } + return request +} + +func TestParseInput(t *testing.T) { + tests := []struct { + description string + argValues []string + flagValues map[string]string + isValid bool + expectedModel *inputModel + }{ + { + description: "base", + argValues: fixtureArgValues(), + flagValues: fixtureFlagValues(), + isValid: true, + expectedModel: fixtureInputModel(), + }, + { + description: "no arg values", + argValues: []string{}, + flagValues: fixtureFlagValues(), + isValid: false, + }, + { + description: "project id missing", + argValues: fixtureArgValues(), + flagValues: fixtureFlagValues(func(flagValues map[string]string) { + delete(flagValues, projectIdFlag) + }), + isValid: false, + }, + { + description: "project id invalid 1", + argValues: fixtureArgValues(), + flagValues: fixtureFlagValues(func(flagValues map[string]string) { + flagValues[projectIdFlag] = "" + }), + isValid: false, + }, + { + description: "project id invalid 2", + argValues: fixtureArgValues(), + flagValues: fixtureFlagValues(func(flagValues map[string]string) { + flagValues[projectIdFlag] = "invalid-uuid" + }), + isValid: false, + }, + { + description: "instance id invalid 1", + argValues: []string{""}, + flagValues: fixtureFlagValues(), + isValid: false, + }, + { + description: "instance id invalid 2", + argValues: []string{"invalid-uuid"}, + flagValues: fixtureFlagValues(), + isValid: false, + }, + } + + for _, tt := range tests { + t.Run(tt.description, func(t *testing.T) { + cmd := NewCmd(nil) + err := globalflags.Configure(cmd.Flags()) + if err != nil { + t.Fatalf("configure global flags: %v", err) + } + + for flag, value := range tt.flagValues { + err := cmd.Flags().Set(flag, value) + if err != nil { + if !tt.isValid { + return + } + t.Fatalf("setting flag --%s=%s: %v", flag, value, err) + } + } + + err = cmd.ValidateArgs(tt.argValues) + if err != nil { + if !tt.isValid { + return + } + t.Fatalf("error validating args: %v", err) + } + + err = cmd.ValidateRequiredFlags() + if err != nil { + if !tt.isValid { + return + } + t.Fatalf("error validating flags: %v", err) + } + + model, err := parseInput(cmd, tt.argValues) + if err != nil { + if !tt.isValid { + return + } + t.Fatalf("error parsing flags: %v", err) + } + + if !tt.isValid { + t.Fatalf("did not fail on invalid input") + } + diff := cmp.Diff(model, tt.expectedModel) + if diff != "" { + t.Fatalf("Data does not match: %s", diff) + } + }) + } +} + +func TestBuildRequest(t *testing.T) { + tests := []struct { + description string + model *inputModel + getGrafanaConfigsFails bool + getGrafanaConfigsResp *argus.GrafanaConfigs + isValid bool + expectedRequest argus.ApiUpdateGrafanaConfigsRequest + }{ + { + description: "base", + model: fixtureInputModel(), + getGrafanaConfigsResp: fixtureGrafanaConfigs(), + isValid: true, + expectedRequest: fixtureRequest(), + }, + { + description: "nil generic oauth", + model: fixtureInputModel(), + getGrafanaConfigsResp: fixtureGrafanaConfigs(func(gc *argus.GrafanaConfigs) { + gc.GenericOauth = nil + }), + isValid: true, + expectedRequest: fixtureRequest(func(request *argus.ApiUpdateGrafanaConfigsRequest) { + *request = request.UpdateGrafanaConfigsPayload(*fixturePayload(func(payload *argus.UpdateGrafanaConfigsPayload) { + payload.GenericOauth = nil + })) + }), + }, + { + description: "get grafana configs fails", + model: fixtureInputModel(), + getGrafanaConfigsFails: true, + isValid: false, + }, + { + description: "no grafana configs", + model: fixtureInputModel(), + getGrafanaConfigsResp: nil, + isValid: false, + }, + } + + for _, tt := range tests { + t.Run(tt.description, func(t *testing.T) { + client := &argusClientMocked{ + getGrafanaConfigsFails: tt.getGrafanaConfigsFails, + getGrafanaConfigsResp: tt.getGrafanaConfigsResp, + } + request, err := buildRequest(testCtx, tt.model, client) + if err != nil { + if !tt.isValid { + return + } + t.Fatalf("error building request: %v", err) + } + + diff := cmp.Diff(request, tt.expectedRequest, + cmp.AllowUnexported(tt.expectedRequest), + cmpopts.EquateComparable(testCtx), + ) + if diff != "" { + t.Fatalf("Data does not match: %s", diff) + } + }) + } +} diff --git a/internal/cmd/argus/grafana/public-read-access/public_read_access.go b/internal/cmd/argus/grafana/public-read-access/public_read_access.go new file mode 100644 index 000000000..736a6e265 --- /dev/null +++ b/internal/cmd/argus/grafana/public-read-access/public_read_access.go @@ -0,0 +1,33 @@ +package publicreadaccess + +import ( + "fmt" + + "github.com/stackitcloud/stackit-cli/internal/cmd/argus/grafana/public-read-access/disable" + "github.com/stackitcloud/stackit-cli/internal/cmd/argus/grafana/public-read-access/enable" + "github.com/stackitcloud/stackit-cli/internal/pkg/args" + "github.com/stackitcloud/stackit-cli/internal/pkg/print" + "github.com/stackitcloud/stackit-cli/internal/pkg/utils" + + "github.com/spf13/cobra" +) + +func NewCmd(p *print.Printer) *cobra.Command { + cmd := &cobra.Command{ + Use: "public-read-access", + Short: "Enable or disable public read access for Grafana in Argus instances", + Long: fmt.Sprintf("%s\n%s", + "Enable or disable public read access for Grafana in Argus instances.", + "When enabled, anyone can access the Grafana dashboards of the instance without logging in. Otherwise, a login is required.", + ), + Args: args.NoArgs, + Run: utils.CmdHelp, + } + addSubcommands(cmd, p) + return cmd +} + +func addSubcommands(cmd *cobra.Command, p *print.Printer) { + cmd.AddCommand(enable.NewCmd(p)) + cmd.AddCommand(disable.NewCmd(p)) +} diff --git a/internal/cmd/argus/grafana/single-sign-on/disable/disable.go b/internal/cmd/argus/grafana/single-sign-on/disable/disable.go index 090320e4c..1a69a516c 100644 --- a/internal/cmd/argus/grafana/single-sign-on/disable/disable.go +++ b/internal/cmd/argus/grafana/single-sign-on/disable/disable.go @@ -7,7 +7,6 @@ import ( "github.com/stackitcloud/stackit-cli/internal/pkg/args" "github.com/stackitcloud/stackit-cli/internal/pkg/errors" "github.com/stackitcloud/stackit-cli/internal/pkg/examples" - "github.com/stackitcloud/stackit-cli/internal/pkg/flags" "github.com/stackitcloud/stackit-cli/internal/pkg/globalflags" "github.com/stackitcloud/stackit-cli/internal/pkg/print" "github.com/stackitcloud/stackit-cli/internal/pkg/services/argus/client" @@ -19,7 +18,7 @@ import ( ) const ( - instanceIdFlag = "instance-id" + instanceIdArg = "INSTANCE_ID" ) type inputModel struct { @@ -29,21 +28,21 @@ type inputModel struct { func NewCmd(p *print.Printer) *cobra.Command { cmd := &cobra.Command{ - Use: "disable", + Use: fmt.Sprintf("disable %s", instanceIdArg), Short: "Disables single sign-on for Grafana on Argus instances", Long: fmt.Sprintf("%s\n%s", "Disables single sign-on for Grafana on Argus instances.", "When disabled for an instance, the generic OAuth2 authentication is used for that instance.", ), - Args: args.NoArgs, + Args: args.SingleArg(instanceIdArg, utils.ValidateUUID), Example: examples.Build( examples.NewExample( `Disable single sign-on for Grafana on an Argus instance with ID "xxx"`, - "$ stackit argus grafana single-sign-on disable --instance-id xxx"), + "$ stackit argus grafana single-sign-on disable xxx"), ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(cmd, args) if err != nil { return err } @@ -60,7 +59,7 @@ func NewCmd(p *print.Printer) *cobra.Command { } if !model.AssumeYes { - prompt := fmt.Sprintf("Are you sure you want to disable single sign-on for instance %q?", instanceLabel) + prompt := fmt.Sprintf("Are you sure you want to disable single sign-on for Grafana for instance %q?", instanceLabel) err = p.PromptForConfirmation(prompt) if err != nil { return err @@ -74,25 +73,19 @@ func NewCmd(p *print.Printer) *cobra.Command { } _, err = req.Execute() if err != nil { - return fmt.Errorf("disable single sign-on: %w", err) + return fmt.Errorf("disable single sign-on for grafana: %w", err) } - p.Info("Disabled single sign-on for instance %q\n", instanceLabel) + p.Info("Disabled single sign-on for Grafana for instance %q\n", instanceLabel) return nil }, } - configureFlags(cmd) return cmd } -func configureFlags(cmd *cobra.Command) { - cmd.Flags().Var(flags.UUIDFlag(), instanceIdFlag, "Instance ID") +func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { + instanceId := inputArgs[0] - err := flags.MarkFlagsRequired(cmd, instanceIdFlag) - cobra.CheckErr(err) -} - -func parseInput(cmd *cobra.Command) (*inputModel, error) { globalFlags := globalflags.Parse(cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} @@ -100,7 +93,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + InstanceId: instanceId, }, nil } diff --git a/internal/cmd/argus/grafana/single-sign-on/disable/disable_test.go b/internal/cmd/argus/grafana/single-sign-on/disable/disable_test.go index b654bbb32..32cdd0449 100644 --- a/internal/cmd/argus/grafana/single-sign-on/disable/disable_test.go +++ b/internal/cmd/argus/grafana/single-sign-on/disable/disable_test.go @@ -44,10 +44,19 @@ func (c *argusClientMocked) GetGrafanaConfigsExecute(_ context.Context, _, _ str return c.getGrafanaConfigsResp, nil } +func fixtureArgValues(mods ...func(argValues []string)) []string { + argValues := []string{ + testInstanceId, + } + for _, mod := range mods { + mod(argValues) + } + return argValues +} + func fixtureFlagValues(mods ...func(flagValues map[string]string)) map[string]string { flagValues := map[string]string{ - projectIdFlag: testProjectId, - instanceIdFlag: testInstanceId, + projectIdFlag: testProjectId, } for _, mod := range mods { mod(flagValues) @@ -117,23 +126,27 @@ func fixtureRequest(mods ...func(request *argus.ApiUpdateGrafanaConfigsRequest)) func TestParseInput(t *testing.T) { tests := []struct { description string + argValues []string flagValues map[string]string isValid bool expectedModel *inputModel }{ { description: "base", + argValues: fixtureArgValues(), flagValues: fixtureFlagValues(), isValid: true, expectedModel: fixtureInputModel(), }, { - description: "no values", - flagValues: map[string]string{}, + description: "no arg values", + argValues: []string{}, + flagValues: fixtureFlagValues(), isValid: false, }, { description: "project id missing", + argValues: fixtureArgValues(), flagValues: fixtureFlagValues(func(flagValues map[string]string) { delete(flagValues, projectIdFlag) }), @@ -141,6 +154,7 @@ func TestParseInput(t *testing.T) { }, { description: "project id invalid 1", + argValues: fixtureArgValues(), flagValues: fixtureFlagValues(func(flagValues map[string]string) { flagValues[projectIdFlag] = "" }), @@ -148,11 +162,24 @@ func TestParseInput(t *testing.T) { }, { description: "project id invalid 2", + argValues: fixtureArgValues(), flagValues: fixtureFlagValues(func(flagValues map[string]string) { flagValues[projectIdFlag] = "invalid-uuid" }), isValid: false, }, + { + description: "instance id invalid 1", + argValues: []string{""}, + flagValues: fixtureFlagValues(), + isValid: false, + }, + { + description: "instance id invalid 2", + argValues: []string{"invalid-uuid"}, + flagValues: fixtureFlagValues(), + isValid: false, + }, } for _, tt := range tests { @@ -173,6 +200,14 @@ func TestParseInput(t *testing.T) { } } + err = cmd.ValidateArgs(tt.argValues) + if err != nil { + if !tt.isValid { + return + } + t.Fatalf("error validating args: %v", err) + } + err = cmd.ValidateRequiredFlags() if err != nil { if !tt.isValid { @@ -181,7 +216,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/argus/grafana/single-sign-on/enable/enable.go b/internal/cmd/argus/grafana/single-sign-on/enable/enable.go index 711e68fb1..7c6c1179f 100644 --- a/internal/cmd/argus/grafana/single-sign-on/enable/enable.go +++ b/internal/cmd/argus/grafana/single-sign-on/enable/enable.go @@ -7,7 +7,6 @@ import ( "github.com/stackitcloud/stackit-cli/internal/pkg/args" "github.com/stackitcloud/stackit-cli/internal/pkg/errors" "github.com/stackitcloud/stackit-cli/internal/pkg/examples" - "github.com/stackitcloud/stackit-cli/internal/pkg/flags" "github.com/stackitcloud/stackit-cli/internal/pkg/globalflags" "github.com/stackitcloud/stackit-cli/internal/pkg/print" "github.com/stackitcloud/stackit-cli/internal/pkg/services/argus/client" @@ -19,7 +18,7 @@ import ( ) const ( - instanceIdFlag = "instance-id" + instanceIdArg = "INSTANCE_ID" ) type inputModel struct { @@ -29,21 +28,21 @@ type inputModel struct { func NewCmd(p *print.Printer) *cobra.Command { cmd := &cobra.Command{ - Use: "enable", + Use: fmt.Sprintf("enable %s", instanceIdArg), Short: "Enables single sign-on for Grafana on Argus instances", Long: fmt.Sprintf("%s\n%s", "Enables single sign-on for Grafana on Argus instances.", "When enabled for an instance, overwrites the generic OAuth2 authentication and configures STACKIT single sign-on for that instance.", ), - Args: args.NoArgs, + Args: args.SingleArg(instanceIdArg, utils.ValidateUUID), Example: examples.Build( examples.NewExample( `Enable single sign-on for Grafana on an Argus instance with ID "xxx"`, - "$ stackit argus grafana single-sign-on enable --instance-id xxx"), + "$ stackit argus grafana single-sign-on enable xxx"), ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(cmd, args) if err != nil { return err } @@ -60,7 +59,7 @@ func NewCmd(p *print.Printer) *cobra.Command { } if !model.AssumeYes { - prompt := fmt.Sprintf("Are you sure you want to enable single sign-on for instance %q?", instanceLabel) + prompt := fmt.Sprintf("Are you sure you want to enable single sign-on for Grafana for instance %q?", instanceLabel) err = p.PromptForConfirmation(prompt) if err != nil { return err @@ -74,25 +73,19 @@ func NewCmd(p *print.Printer) *cobra.Command { } _, err = req.Execute() if err != nil { - return fmt.Errorf("enable single sign-on: %w", err) + return fmt.Errorf("enable single sign-on for grafana: %w", err) } - p.Info("Enabled single sign-on for instance %q\n", instanceLabel) + p.Info("Enabled single sign-on for Grafana for instance %q\n", instanceLabel) return nil }, } - configureFlags(cmd) return cmd } -func configureFlags(cmd *cobra.Command) { - cmd.Flags().Var(flags.UUIDFlag(), instanceIdFlag, "Instance ID") +func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { + instanceId := inputArgs[0] - err := flags.MarkFlagsRequired(cmd, instanceIdFlag) - cobra.CheckErr(err) -} - -func parseInput(cmd *cobra.Command) (*inputModel, error) { globalFlags := globalflags.Parse(cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} @@ -100,7 +93,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + InstanceId: instanceId, }, nil } diff --git a/internal/cmd/argus/grafana/single-sign-on/enable/enable_test.go b/internal/cmd/argus/grafana/single-sign-on/enable/enable_test.go index 7544b81b4..c95378136 100644 --- a/internal/cmd/argus/grafana/single-sign-on/enable/enable_test.go +++ b/internal/cmd/argus/grafana/single-sign-on/enable/enable_test.go @@ -44,10 +44,19 @@ func (c *argusClientMocked) GetGrafanaConfigsExecute(_ context.Context, _, _ str return c.getGrafanaConfigsResp, nil } +func fixtureArgValues(mods ...func(argValues []string)) []string { + argValues := []string{ + testInstanceId, + } + for _, mod := range mods { + mod(argValues) + } + return argValues +} + func fixtureFlagValues(mods ...func(flagValues map[string]string)) map[string]string { flagValues := map[string]string{ - projectIdFlag: testProjectId, - instanceIdFlag: testInstanceId, + projectIdFlag: testProjectId, } for _, mod := range mods { mod(flagValues) @@ -117,23 +126,27 @@ func fixtureRequest(mods ...func(request *argus.ApiUpdateGrafanaConfigsRequest)) func TestParseInput(t *testing.T) { tests := []struct { description string + argValues []string flagValues map[string]string isValid bool expectedModel *inputModel }{ { description: "base", + argValues: fixtureArgValues(), flagValues: fixtureFlagValues(), isValid: true, expectedModel: fixtureInputModel(), }, { - description: "no values", - flagValues: map[string]string{}, + description: "no arg values", + argValues: []string{}, + flagValues: fixtureFlagValues(), isValid: false, }, { description: "project id missing", + argValues: fixtureArgValues(), flagValues: fixtureFlagValues(func(flagValues map[string]string) { delete(flagValues, projectIdFlag) }), @@ -141,6 +154,7 @@ func TestParseInput(t *testing.T) { }, { description: "project id invalid 1", + argValues: fixtureArgValues(), flagValues: fixtureFlagValues(func(flagValues map[string]string) { flagValues[projectIdFlag] = "" }), @@ -148,11 +162,24 @@ func TestParseInput(t *testing.T) { }, { description: "project id invalid 2", + argValues: fixtureArgValues(), flagValues: fixtureFlagValues(func(flagValues map[string]string) { flagValues[projectIdFlag] = "invalid-uuid" }), isValid: false, }, + { + description: "instance id invalid 1", + argValues: []string{""}, + flagValues: fixtureFlagValues(), + isValid: false, + }, + { + description: "instance id invalid 2", + argValues: []string{"invalid-uuid"}, + flagValues: fixtureFlagValues(), + isValid: false, + }, } for _, tt := range tests { @@ -173,6 +200,14 @@ func TestParseInput(t *testing.T) { } } + err = cmd.ValidateArgs(tt.argValues) + if err != nil { + if !tt.isValid { + return + } + t.Fatalf("error validating args: %v", err) + } + err = cmd.ValidateRequiredFlags() if err != nil { if !tt.isValid { @@ -181,7 +216,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(cmd, tt.argValues) if err != nil { if !tt.isValid { return From ef0fa193536fb5486040e0f202ff5e463186e582 Mon Sep 17 00:00:00 2001 From: Kumm-Kai <70690427+Kumm-Kai@users.noreply.github.com> Date: Wed, 17 Apr 2024 15:50:38 +0000 Subject: [PATCH 07/17] Change config handling: only create config file & directory if needed (#214) * Change config handling: only create config file & directory if needed * Changes from code review * Fix config read * correctly handle f.Close error --- internal/cmd/config/list/list.go | 7 +--- internal/cmd/config/set/set.go | 4 +- internal/cmd/config/unset/unset.go | 4 +- internal/pkg/auth/storage.go | 2 +- internal/pkg/config/config.go | 47 ++++++++++++++---------- internal/pkg/projectname/project_name.go | 2 +- 6 files changed, 34 insertions(+), 32 deletions(-) diff --git a/internal/cmd/config/list/list.go b/internal/cmd/config/list/list.go index b6bdf48e2..0f6974703 100644 --- a/internal/cmd/config/list/list.go +++ b/internal/cmd/config/list/list.go @@ -37,11 +37,6 @@ func NewCmd(p *print.Printer) *cobra.Command { "$ stackit config list"), ), RunE: func(cmd *cobra.Command, args []string) error { - err := viper.ReadInConfig() - if err != nil { - return fmt.Errorf("read config file: %w", err) - } - configData := viper.AllSettings() // Sort the config options by key @@ -84,7 +79,7 @@ func NewCmd(p *print.Printer) *cobra.Command { table.AddRow(key, valueString) table.AddSeparator() } - err = table.Display(p) + err := table.Display(p) if err != nil { return fmt.Errorf("render table: %w", err) } diff --git a/internal/cmd/config/set/set.go b/internal/cmd/config/set/set.go index 36e9c06d4..459f3a3b4 100644 --- a/internal/cmd/config/set/set.go +++ b/internal/cmd/config/set/set.go @@ -80,9 +80,9 @@ func NewCmd(p *print.Printer) *cobra.Command { viper.Set(config.ProjectNameKey, "") } - err = viper.WriteConfig() + err = config.Write() if err != nil { - return fmt.Errorf("write new config to file: %w", err) + return fmt.Errorf("write config to file: %w", err) } return nil }, diff --git a/internal/cmd/config/unset/unset.go b/internal/cmd/config/unset/unset.go index ff4e4d665..7f6bc8449 100644 --- a/internal/cmd/config/unset/unset.go +++ b/internal/cmd/config/unset/unset.go @@ -144,9 +144,9 @@ func NewCmd() *cobra.Command { viper.Set(config.SKECustomEndpointKey, "") } - err := viper.WriteConfig() + err := config.Write() if err != nil { - return fmt.Errorf("write updated config to file: %w", err) + return fmt.Errorf("write config to file: %w", err) } return nil }, diff --git a/internal/pkg/auth/storage.go b/internal/pkg/auth/storage.go index 3a2031fff..1bcb6e784 100644 --- a/internal/pkg/auth/storage.go +++ b/internal/pkg/auth/storage.go @@ -136,7 +136,7 @@ func GetAuthField(key authFieldKey) (string, error) { var errFallback error value, errFallback = getAuthFieldFromEncodedTextFile(key) if errFallback != nil { - return "", fmt.Errorf("write to keyring failed (%w), tried write to encoded text file: %w", err, errFallback) + return "", fmt.Errorf("read from keyring: %w, read from encoded file as fallback: %w", err, errFallback) } } return value, nil diff --git a/internal/pkg/config/config.go b/internal/pkg/config/config.go index 08eac0b98..4077c1d3a 100644 --- a/internal/pkg/config/config.go +++ b/internal/pkg/config/config.go @@ -70,30 +70,42 @@ var ConfigKeys = []string{ SKECustomEndpointKey, } +var folderPath string + func InitConfig() { home, err := os.UserHomeDir() cobra.CheckErr(err) configFolderPath := filepath.Join(home, configFolder) configFilePath := filepath.Join(configFolderPath, fmt.Sprintf("%s.%s", configFileName, configFileExtension)) - viper.SetConfigName(configFileName) - viper.SetConfigType(configFileExtension) - viper.AddConfigPath(configFolderPath) + // Write config dir path to global variable + folderPath = configFolderPath - err = createFolderIfNotExists(configFolderPath) - cobra.CheckErr(err) - err = createFileIfNotExists(configFilePath) - cobra.CheckErr(err) + // This hack is required to allow creating the config file with `viper.WriteConfig` + // see https://github.com/spf13/viper/issues/851#issuecomment-789393451 + viper.SetConfigFile(configFilePath) + + f, err := os.Open(configFilePath) + if !os.IsNotExist(err) { + if err := viper.ReadConfig(f); err != nil { + cobra.CheckErr(err) + } + } + defer func() { + if f != nil { + if err := f.Close(); err != nil { + cobra.CheckErr(err) + } + } + }() - err = viper.ReadInConfig() - cobra.CheckErr(err) setConfigDefaults() viper.AutomaticEnv() viper.SetEnvPrefix("stackit") } -func createFolderIfNotExists(folderPath string) error { +func createFolderIfNotExists() error { _, err := os.Stat(folderPath) if os.IsNotExist(err) { err := os.MkdirAll(folderPath, os.ModePerm) @@ -106,17 +118,12 @@ func createFolderIfNotExists(folderPath string) error { return nil } -func createFileIfNotExists(filePath string) error { - _, err := os.Stat(filePath) - if os.IsNotExist(err) { - err := viper.SafeWriteConfigAs(filePath) - if err != nil { - return err - } - } else if err != nil { - return err +// Write saves the config file (wrapping `viper.WriteConfig`) and ensures that its directory exists +func Write() error { + if err := createFolderIfNotExists(); err != nil { + return fmt.Errorf("create config directory: %w", err) } - return nil + return viper.WriteConfig() } // All config keys should be set to a default value so that they can be set as an environment variable diff --git a/internal/pkg/projectname/project_name.go b/internal/pkg/projectname/project_name.go index d2a54ff0a..9f80da8ab 100644 --- a/internal/pkg/projectname/project_name.go +++ b/internal/pkg/projectname/project_name.go @@ -43,7 +43,7 @@ func GetProjectName(ctx context.Context, cmd *cobra.Command, p *print.Printer) ( // (So next time we can just pull it from there) if !isProjectIdSetInFlags(cmd) { viper.Set(config.ProjectNameKey, projectName) - err = viper.WriteConfig() + err = config.Write() if err != nil { return "", fmt.Errorf("write new config to file: %w", err) } From 37de4395f2b26dddc57493b937ce78196754ff12 Mon Sep 17 00:00:00 2001 From: stackit-pipeline <142982727+stackit-pipeline@users.noreply.github.com> Date: Thu, 18 Apr 2024 09:51:10 +0200 Subject: [PATCH 08/17] chore(deps): update renovatebot/github-action action to v40.1.9 (#225) Co-authored-by: Renovate Bot From f7cc6eabaf95f433bfb7aa0d5da0b0d3d4548ad6 Mon Sep 17 00:00:00 2001 From: stackit-pipeline <142982727+stackit-pipeline@users.noreply.github.com> Date: Thu, 18 Apr 2024 09:51:25 +0200 Subject: [PATCH 09/17] fix(deps): update module github.com/stackitcloud/stackit-sdk-go/services/ske to v0.13.0 (#226) Co-authored-by: Renovate Bot --- go.mod | 2 +- go.sum | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/go.mod b/go.mod index f1aff7178..86c2321c6 100644 --- a/go.mod +++ b/go.mod @@ -19,7 +19,7 @@ require ( github.com/stackitcloud/stackit-sdk-go/services/resourcemanager v0.8.0 github.com/stackitcloud/stackit-sdk-go/services/secretsmanager v0.7.0 github.com/stackitcloud/stackit-sdk-go/services/serviceaccount v0.4.0 - github.com/stackitcloud/stackit-sdk-go/services/ske v0.12.0 + github.com/stackitcloud/stackit-sdk-go/services/ske v0.13.0 github.com/zalando/go-keyring v0.2.4 golang.org/x/mod v0.17.0 golang.org/x/oauth2 v0.19.0 diff --git a/go.sum b/go.sum index 5044f8a6c..361137000 100644 --- a/go.sum +++ b/go.sum @@ -98,8 +98,8 @@ github.com/stackitcloud/stackit-sdk-go/services/secretsmanager v0.7.0 h1:1Ho+M4D github.com/stackitcloud/stackit-sdk-go/services/secretsmanager v0.7.0/go.mod h1:LX0Mcyr7/QP77zf7e05fHCJO38RMuTxr7nEDUDZ3oPQ= github.com/stackitcloud/stackit-sdk-go/services/serviceaccount v0.4.0 h1:JB1O0E9+L50ZaO36uz7azurvUuB5JdX5s2ZXuIdb9t8= github.com/stackitcloud/stackit-sdk-go/services/serviceaccount v0.4.0/go.mod h1:Ni9RBJvcaXRIrDIuQBpJcuQvCQSj27crQSyc+WM4p0c= -github.com/stackitcloud/stackit-sdk-go/services/ske v0.12.0 h1:sG45CkR+v8BUQBREROjTbJV/ZK5Xg+Rd6ulzM25UoGw= -github.com/stackitcloud/stackit-sdk-go/services/ske v0.12.0/go.mod h1:0fFs4R7kg+gU7FNAIzzFvlCZJz6gyZ8CFhbK3eSrAwQ= +github.com/stackitcloud/stackit-sdk-go/services/ske v0.13.0 h1:fL7vll37c1Wv8LM1/F/vcyhyUKSL2UqkXd44x1J/6OU= +github.com/stackitcloud/stackit-sdk-go/services/ske v0.13.0/go.mod h1:0fFs4R7kg+gU7FNAIzzFvlCZJz6gyZ8CFhbK3eSrAwQ= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= github.com/stretchr/objx v0.5.0 h1:1zr/of2m5FGMsad5YfcqgdqdWrIhu+EBEJRhR1U7z/c= From e400797382c269a5ea8010ac956e18edd08779d6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Palet?= Date: Thu, 18 Apr 2024 13:26:10 +0100 Subject: [PATCH 10/17] Improvements for argus grafana commands (#230) --- docs/stackit_argus_grafana_describe.md | 13 +++-- .../cmd/argus/grafana/describe/describe.go | 25 +++++----- .../argus/grafana/describe/describe_test.go | 48 ++++++++++++------- .../grafana/single-sign-on/single_sign_on.go | 5 +- 4 files changed, 51 insertions(+), 40 deletions(-) diff --git a/docs/stackit_argus_grafana_describe.md b/docs/stackit_argus_grafana_describe.md index 086d30a42..f9027cbc5 100644 --- a/docs/stackit_argus_grafana_describe.md +++ b/docs/stackit_argus_grafana_describe.md @@ -9,28 +9,27 @@ The Grafana dashboard URL and initial credentials (admin user and password) will The initial password is shown by default, if you want to hide it use the "--hide-password" flag. ``` -stackit argus grafana describe [flags] +stackit argus grafana describe INSTANCE_ID [flags] ``` ### Examples ``` Get details of the Grafana configuration of an Argus instance with ID "xxx" - $ stackit argus credentials describe --instance-id xxx + $ stackit argus credentials describe xxx Get details of the Grafana configuration of an Argus instance with ID "xxx" in a table format - $ stackit argus credentials describe --instance-id xxx --output-format pretty + $ stackit argus credentials describe xxx --output-format pretty Get details of the Grafana configuration of an Argus instance with ID "xxx" and hide the initial admin password - $ stackit argus credentials describe --instance-id xxx --output-format pretty --hide-password + $ stackit argus credentials describe xxx --output-format pretty --hide-password ``` ### Options ``` - -h, --help Help for "stackit argus grafana describe" - --hide-password Show the initial admin password in the "pretty" output format - --instance-id string Instance ID + -h, --help Help for "stackit argus grafana describe" + --hide-password Show the initial admin password in the "pretty" output format ``` ### Options inherited from parent commands diff --git a/internal/cmd/argus/grafana/describe/describe.go b/internal/cmd/argus/grafana/describe/describe.go index a950591c0..1ec3c65bc 100644 --- a/internal/cmd/argus/grafana/describe/describe.go +++ b/internal/cmd/argus/grafana/describe/describe.go @@ -13,13 +13,14 @@ import ( "github.com/stackitcloud/stackit-cli/internal/pkg/print" "github.com/stackitcloud/stackit-cli/internal/pkg/services/argus/client" "github.com/stackitcloud/stackit-cli/internal/pkg/tables" + "github.com/stackitcloud/stackit-cli/internal/pkg/utils" "github.com/spf13/cobra" "github.com/stackitcloud/stackit-sdk-go/services/argus" ) const ( - instanceIdFlag = "instance-id" + instanceIdArg = "INSTANCE_ID" hidePasswordFlag = "hide-password" ) @@ -31,28 +32,28 @@ type inputModel struct { func NewCmd(p *print.Printer) *cobra.Command { cmd := &cobra.Command{ - Use: "describe", + Use: fmt.Sprintf("describe %s", instanceIdArg), Short: "Shows details of the Grafana configuration of an Argus instance", Long: fmt.Sprintf("%s\n%s\n%s", "Shows details of the Grafana configuration of an Argus instance.", `The Grafana dashboard URL and initial credentials (admin user and password) will be shown in the "pretty" output format. These credentials are only valid for first login. Please change the password after first login. After changing, the initial password is no longer valid.`, `The initial password is shown by default, if you want to hide it use the "--hide-password" flag.`, ), - Args: args.NoArgs, + Args: args.SingleArg(instanceIdArg, utils.ValidateUUID), Example: examples.Build( examples.NewExample( `Get details of the Grafana configuration of an Argus instance with ID "xxx"`, - "$ stackit argus credentials describe --instance-id xxx"), + "$ stackit argus credentials describe xxx"), examples.NewExample( `Get details of the Grafana configuration of an Argus instance with ID "xxx" in a table format`, - "$ stackit argus credentials describe --instance-id xxx --output-format pretty"), + "$ stackit argus credentials describe xxx --output-format pretty"), examples.NewExample( `Get details of the Grafana configuration of an Argus instance with ID "xxx" and hide the initial admin password`, - "$ stackit argus credentials describe --instance-id xxx --output-format pretty --hide-password"), + "$ stackit argus credentials describe xxx --output-format pretty --hide-password"), ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(cmd, args) if err != nil { return err } @@ -82,14 +83,12 @@ func NewCmd(p *print.Printer) *cobra.Command { } func configureFlags(cmd *cobra.Command) { - cmd.Flags().Var(flags.UUIDFlag(), instanceIdFlag, "Instance ID") cmd.Flags().Bool(hidePasswordFlag, false, `Show the initial admin password in the "pretty" output format`) - - err := flags.MarkFlagsRequired(cmd, instanceIdFlag) - cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { +func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { + instanceId := inputArgs[0] + globalFlags := globalflags.Parse(cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} @@ -97,7 +96,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + InstanceId: instanceId, HidePassword: flags.FlagToBoolValue(cmd, hidePasswordFlag), }, nil } diff --git a/internal/cmd/argus/grafana/describe/describe_test.go b/internal/cmd/argus/grafana/describe/describe_test.go index b380f5257..5b0eae7ed 100644 --- a/internal/cmd/argus/grafana/describe/describe_test.go +++ b/internal/cmd/argus/grafana/describe/describe_test.go @@ -21,10 +21,19 @@ var testClient = &argus.APIClient{} var testProjectId = uuid.NewString() var testInstanceId = uuid.NewString() +func fixtureArgValues(mods ...func(argValues []string)) []string { + argValues := []string{ + testInstanceId, + } + for _, mod := range mods { + mod(argValues) + } + return argValues +} + func fixtureFlagValues(mods ...func(flagValues map[string]string)) map[string]string { flagValues := map[string]string{ - projectIdFlag: testProjectId, - instanceIdFlag: testInstanceId, + projectIdFlag: testProjectId, } for _, mod := range mods { mod(flagValues) @@ -72,12 +81,20 @@ func TestParseInput(t *testing.T) { }{ { description: "base", + argValues: fixtureArgValues(), flagValues: fixtureFlagValues(), isValid: true, expectedModel: fixtureInputModel(), }, + { + description: "no arg values", + argValues: []string{}, + flagValues: fixtureFlagValues(), + isValid: false, + }, { description: "hide password", + argValues: fixtureArgValues(), flagValues: fixtureFlagValues(func(flagValues map[string]string) { flagValues[hidePasswordFlag] = "true" }), @@ -94,11 +111,13 @@ func TestParseInput(t *testing.T) { }, { description: "no flag values", + argValues: fixtureArgValues(), flagValues: map[string]string{}, isValid: false, }, { description: "project id missing", + argValues: fixtureArgValues(), flagValues: fixtureFlagValues(func(flagValues map[string]string) { delete(flagValues, projectIdFlag) }), @@ -106,6 +125,7 @@ func TestParseInput(t *testing.T) { }, { description: "project id invalid 1", + argValues: fixtureArgValues(), flagValues: fixtureFlagValues(func(flagValues map[string]string) { flagValues[projectIdFlag] = "" }), @@ -113,31 +133,23 @@ func TestParseInput(t *testing.T) { }, { description: "project id invalid 2", + argValues: fixtureArgValues(), flagValues: fixtureFlagValues(func(flagValues map[string]string) { flagValues[projectIdFlag] = "invalid-uuid" }), isValid: false, }, - { - description: "instance id missing", - flagValues: fixtureFlagValues(func(flagValues map[string]string) { - delete(flagValues, instanceIdFlag) - }), - isValid: false, - }, { description: "instance id invalid 1", - flagValues: fixtureFlagValues(func(flagValues map[string]string) { - flagValues[instanceIdFlag] = "" - }), - isValid: false, + argValues: []string{""}, + flagValues: fixtureFlagValues(), + isValid: false, }, { description: "instance id invalid 2", - flagValues: fixtureFlagValues(func(flagValues map[string]string) { - flagValues[instanceIdFlag] = "invalid-uuid" - }), - isValid: false, + argValues: []string{"invalid-uuid"}, + flagValues: fixtureFlagValues(), + isValid: false, }, { description: "credentials id invalid 1", @@ -187,7 +199,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/argus/grafana/single-sign-on/single_sign_on.go b/internal/cmd/argus/grafana/single-sign-on/single_sign_on.go index 6b2cf37cb..c19147473 100644 --- a/internal/cmd/argus/grafana/single-sign-on/single_sign_on.go +++ b/internal/cmd/argus/grafana/single-sign-on/single_sign_on.go @@ -14,8 +14,9 @@ import ( func NewCmd(p *print.Printer) *cobra.Command { cmd := &cobra.Command{ - Use: "single-sign-on", - Short: "Enable or disable single sign-on for Grafana in Argus instances", + Use: "single-sign-on", + Aliases: []string{"sso"}, + Short: "Enable or disable single sign-on for Grafana in Argus instances", Long: fmt.Sprintf("%s\n%s", "Enable or disable single sign-on for Grafana in Argus instances.", "When enabled for an instance, overwrites the generic OAuth2 authentication and configures STACKIT single sign-on for that instance.", From 459214261507b14683f39a25c9adacd5ea0b7e54 Mon Sep 17 00:00:00 2001 From: GokceGK <161626272+GokceGK@users.noreply.github.com> Date: Fri, 19 Apr 2024 13:00:07 +0200 Subject: [PATCH 11/17] Add debug error logs (#217) * add error debug logs to clients * add error debug logs to refreshToken * add error debug logs to label fetching * Update internal/pkg/services/argus/client/client.go Co-authored-by: Vicente Pinto * Update internal/pkg/services/argus/client/client.go Co-authored-by: Vicente Pinto * add error debug logs to flag conversions * add printer to argus grafana commands * add debug log to getBearerToken function * fix debug messages on clients * Update internal/pkg/flags/flag_to_value.go Co-authored-by: Vicente Pinto * remove obsolete err from the debug messages * make printer first parameter * add printer to new argus commands * Update internal/pkg/auth/user_token_flow.go Co-authored-by: Vicente Pinto * Update internal/cmd/root.go Co-authored-by: Vicente Pinto * fix linting problem * add string formatting to the printer debug function * set source in log handler to false --------- Co-authored-by: Vicente Pinto --- .../cmd/argus/grafana/describe/describe.go | 9 ++-- .../argus/grafana/describe/describe_test.go | 3 +- .../public-read-access/disable/disable.go | 6 +-- .../disable/disable_test.go | 2 +- .../public-read-access/enable/enable.go | 6 +-- .../public-read-access/enable/enable_test.go | 2 +- .../grafana/single-sign-on/disable/disable.go | 6 +-- .../single-sign-on/disable/disable_test.go | 2 +- .../grafana/single-sign-on/enable/enable.go | 6 +-- .../single-sign-on/enable/enable_test.go | 2 +- internal/cmd/argus/instance/create/create.go | 15 +++--- .../cmd/argus/instance/create/create_test.go | 2 +- internal/cmd/argus/instance/delete/delete.go | 7 +-- .../cmd/argus/instance/delete/delete_test.go | 2 +- .../cmd/argus/instance/describe/describe.go | 6 +-- .../argus/instance/describe/describe_test.go | 2 +- internal/cmd/argus/instance/list/list.go | 13 ++--- internal/cmd/argus/instance/list/list_test.go | 2 +- internal/cmd/argus/instance/update/update.go | 13 ++--- .../cmd/argus/instance/update/update_test.go | 2 +- internal/cmd/argus/plans/plans.go | 11 +++-- internal/cmd/argus/plans/plans_test.go | 2 +- .../activate_service_account.go | 14 +++--- .../activate_service_account_test.go | 2 +- internal/cmd/config/config.go | 2 +- internal/cmd/config/set/set.go | 12 ++--- internal/cmd/config/set/set_test.go | 2 +- internal/cmd/config/unset/unset.go | 49 ++++++++++--------- internal/cmd/config/unset/unset_test.go | 4 +- internal/cmd/curl/curl.go | 17 ++++--- internal/cmd/curl/curl_test.go | 2 +- internal/cmd/dns/record-set/create/create.go | 19 +++---- .../cmd/dns/record-set/create/create_test.go | 2 +- internal/cmd/dns/record-set/delete/delete.go | 10 ++-- .../cmd/dns/record-set/delete/delete_test.go | 2 +- .../cmd/dns/record-set/describe/describe.go | 8 +-- .../dns/record-set/describe/describe_test.go | 2 +- internal/cmd/dns/record-set/list/list.go | 25 +++++----- internal/cmd/dns/record-set/list/list_test.go | 2 +- internal/cmd/dns/record-set/update/update.go | 18 ++++--- .../cmd/dns/record-set/update/update_test.go | 2 +- internal/cmd/dns/zone/create/create.go | 35 ++++++------- internal/cmd/dns/zone/create/create_test.go | 2 +- internal/cmd/dns/zone/delete/delete.go | 7 +-- internal/cmd/dns/zone/delete/delete_test.go | 2 +- internal/cmd/dns/zone/describe/describe.go | 6 +-- .../cmd/dns/zone/describe/describe_test.go | 2 +- internal/cmd/dns/zone/list/list.go | 23 ++++----- internal/cmd/dns/zone/list/list_test.go | 2 +- internal/cmd/dns/zone/update/update.go | 27 +++++----- internal/cmd/dns/zone/update/update_test.go | 2 +- .../cmd/logme/credentials/create/create.go | 11 +++-- .../logme/credentials/create/create_test.go | 2 +- .../cmd/logme/credentials/delete/delete.go | 10 ++-- .../logme/credentials/delete/delete_test.go | 2 +- .../logme/credentials/describe/describe.go | 8 +-- .../credentials/describe/describe_test.go | 2 +- internal/cmd/logme/credentials/list/list.go | 11 +++-- .../cmd/logme/credentials/list/list_test.go | 2 +- internal/cmd/logme/instance/create/create.go | 31 ++++++------ .../cmd/logme/instance/create/create_test.go | 2 +- internal/cmd/logme/instance/delete/delete.go | 7 +-- .../cmd/logme/instance/delete/delete_test.go | 2 +- .../cmd/logme/instance/describe/describe.go | 6 +-- .../logme/instance/describe/describe_test.go | 2 +- internal/cmd/logme/instance/list/list.go | 13 ++--- internal/cmd/logme/instance/list/list_test.go | 2 +- internal/cmd/logme/instance/update/update.go | 27 +++++----- .../cmd/logme/instance/update/update_test.go | 2 +- internal/cmd/logme/plans/plans.go | 11 +++-- internal/cmd/logme/plans/plans_test.go | 2 +- .../cmd/mariadb/credentials/create/create.go | 11 +++-- .../mariadb/credentials/create/create_test.go | 2 +- .../cmd/mariadb/credentials/delete/delete.go | 10 ++-- .../mariadb/credentials/delete/delete_test.go | 2 +- .../mariadb/credentials/describe/describe.go | 8 +-- .../credentials/describe/describe_test.go | 2 +- internal/cmd/mariadb/credentials/list/list.go | 11 +++-- .../cmd/mariadb/credentials/list/list_test.go | 2 +- .../cmd/mariadb/instance/create/create.go | 31 ++++++------ .../mariadb/instance/create/create_test.go | 2 +- .../cmd/mariadb/instance/delete/delete.go | 7 +-- .../mariadb/instance/delete/delete_test.go | 2 +- .../cmd/mariadb/instance/describe/describe.go | 6 +-- .../instance/describe/describe_test.go | 2 +- internal/cmd/mariadb/instance/list/list.go | 13 ++--- .../cmd/mariadb/instance/list/list_test.go | 2 +- .../cmd/mariadb/instance/update/update.go | 27 +++++----- .../mariadb/instance/update/update_test.go | 2 +- internal/cmd/mariadb/plans/plans.go | 11 +++-- internal/cmd/mariadb/plans/plans_test.go | 2 +- .../cmd/mongodbflex/instance/create/create.go | 29 +++++------ .../instance/create/create_test.go | 2 +- .../cmd/mongodbflex/instance/delete/delete.go | 7 +-- .../instance/delete/delete_test.go | 2 +- .../mongodbflex/instance/describe/describe.go | 6 +-- .../instance/describe/describe_test.go | 2 +- .../cmd/mongodbflex/instance/list/list.go | 11 +++-- .../mongodbflex/instance/list/list_test.go | 2 +- .../cmd/mongodbflex/instance/update/update.go | 27 +++++----- .../instance/update/update_test.go | 2 +- internal/cmd/mongodbflex/options/options.go | 16 +++--- .../cmd/mongodbflex/options/options_test.go | 2 +- .../cmd/mongodbflex/user/create/create.go | 15 +++--- .../mongodbflex/user/create/create_test.go | 2 +- .../cmd/mongodbflex/user/delete/delete.go | 10 ++-- .../mongodbflex/user/delete/delete_test.go | 2 +- .../cmd/mongodbflex/user/describe/describe.go | 8 +-- .../user/describe/describe_test.go | 2 +- internal/cmd/mongodbflex/user/list/list.go | 13 ++--- .../cmd/mongodbflex/user/list/list_test.go | 2 +- .../user/reset-password/reset_password.go | 10 ++-- .../reset-password/reset_password_test.go | 2 +- .../cmd/mongodbflex/user/update/update.go | 14 +++--- .../mongodbflex/user/update/update_test.go | 2 +- .../object-storage/bucket/create/create.go | 6 +-- .../bucket/create/create_test.go | 2 +- .../object-storage/bucket/delete/delete.go | 6 +-- .../bucket/delete/delete_test.go | 2 +- .../bucket/describe/describe.go | 6 +-- .../bucket/describe/describe_test.go | 2 +- .../cmd/object-storage/bucket/list/list.go | 13 ++--- .../object-storage/bucket/list/list_test.go | 2 +- .../credentials-group/create/create.go | 8 +-- .../credentials-group/create/create_test.go | 2 +- .../credentials-group/delete/delete.go | 7 +-- .../credentials-group/delete/delete_test.go | 2 +- .../credentials-group/list/list.go | 8 +-- .../credentials-group/list/list_test.go | 2 +- .../credentials/create/create.go | 11 +++-- .../credentials/create/create_test.go | 2 +- .../credentials/delete/delete.go | 10 ++-- .../credentials/delete/delete_test.go | 2 +- .../object-storage/credentials/list/list.go | 11 +++-- .../credentials/list/list_test.go | 2 +- .../cmd/object-storage/disable/disable.go | 9 ++-- .../object-storage/disable/disable_test.go | 2 +- internal/cmd/object-storage/enable/enable.go | 9 ++-- .../cmd/object-storage/enable/enable_test.go | 2 +- .../opensearch/credentials/create/create.go | 11 +++-- .../credentials/create/create_test.go | 2 +- .../opensearch/credentials/delete/delete.go | 10 ++-- .../credentials/delete/delete_test.go | 2 +- .../credentials/describe/describe.go | 8 +-- .../credentials/describe/describe_test.go | 2 +- .../cmd/opensearch/credentials/list/list.go | 11 +++-- .../opensearch/credentials/list/list_test.go | 2 +- .../cmd/opensearch/instance/create/create.go | 33 +++++++------ .../opensearch/instance/create/create_test.go | 2 +- .../cmd/opensearch/instance/delete/delete.go | 7 +-- .../opensearch/instance/delete/delete_test.go | 2 +- .../opensearch/instance/describe/describe.go | 6 +-- .../instance/describe/describe_test.go | 2 +- internal/cmd/opensearch/instance/list/list.go | 13 ++--- .../cmd/opensearch/instance/list/list_test.go | 2 +- .../cmd/opensearch/instance/update/update.go | 29 +++++------ .../opensearch/instance/update/update_test.go | 2 +- internal/cmd/opensearch/plans/plans.go | 11 +++-- internal/cmd/opensearch/plans/plans_test.go | 2 +- internal/cmd/organization/member/add/add.go | 10 ++-- .../cmd/organization/member/add/add_test.go | 2 +- internal/cmd/organization/member/list/list.go | 16 +++--- .../cmd/organization/member/list/list_test.go | 2 +- .../cmd/organization/member/remove/remove.go | 12 ++--- .../organization/member/remove/remove_test.go | 2 +- internal/cmd/organization/role/list/list.go | 12 ++--- .../cmd/organization/role/list/list_test.go | 2 +- .../cmd/postgresflex/instance/clone/clone.go | 13 ++--- .../postgresflex/instance/clone/clone_test.go | 2 +- .../postgresflex/instance/create/create.go | 29 +++++------ .../instance/create/create_test.go | 2 +- .../postgresflex/instance/delete/delete.go | 9 ++-- .../instance/delete/delete_test.go | 2 +- .../instance/describe/describe.go | 6 +-- .../instance/describe/describe_test.go | 2 +- .../cmd/postgresflex/instance/list/list.go | 13 ++--- .../postgresflex/instance/list/list_test.go | 2 +- .../postgresflex/instance/update/update.go | 27 +++++----- .../instance/update/update_test.go | 2 +- internal/cmd/postgresflex/options/options.go | 16 +++--- .../cmd/postgresflex/options/options_test.go | 2 +- .../cmd/postgresflex/user/create/create.go | 13 ++--- .../postgresflex/user/create/create_test.go | 2 +- .../cmd/postgresflex/user/delete/delete.go | 10 ++-- .../postgresflex/user/delete/delete_test.go | 2 +- .../postgresflex/user/describe/describe.go | 8 +-- .../user/describe/describe_test.go | 2 +- internal/cmd/postgresflex/user/list/list.go | 13 ++--- .../cmd/postgresflex/user/list/list_test.go | 2 +- .../user/reset-password/reset_password.go | 10 ++-- .../reset-password/reset_password_test.go | 2 +- .../cmd/postgresflex/user/update/update.go | 12 +++-- .../postgresflex/user/update/update_test.go | 2 +- internal/cmd/project/create/create.go | 12 ++--- internal/cmd/project/create/create_test.go | 2 +- internal/cmd/project/delete/delete.go | 9 ++-- internal/cmd/project/delete/delete_test.go | 2 +- internal/cmd/project/describe/describe.go | 8 +-- .../cmd/project/describe/describe_test.go | 2 +- internal/cmd/project/list/list.go | 18 +++---- internal/cmd/project/list/list_test.go | 2 +- internal/cmd/project/member/add/add.go | 11 +++-- internal/cmd/project/member/add/add_test.go | 2 +- internal/cmd/project/member/list/list.go | 17 ++++--- internal/cmd/project/member/list/list_test.go | 2 +- internal/cmd/project/member/remove/remove.go | 13 ++--- .../cmd/project/member/remove/remove_test.go | 2 +- internal/cmd/project/role/list/list.go | 13 ++--- internal/cmd/project/role/list/list_test.go | 2 +- internal/cmd/project/update/update.go | 15 +++--- internal/cmd/project/update/update_test.go | 2 +- .../cmd/rabbitmq/credentials/create/create.go | 11 +++-- .../credentials/create/create_test.go | 2 +- .../cmd/rabbitmq/credentials/delete/delete.go | 10 ++-- .../credentials/delete/delete_test.go | 2 +- .../rabbitmq/credentials/describe/describe.go | 8 +-- .../credentials/describe/describe_test.go | 2 +- .../cmd/rabbitmq/credentials/list/list.go | 11 +++-- .../rabbitmq/credentials/list/list_test.go | 2 +- .../cmd/rabbitmq/instance/create/create.go | 33 +++++++------ .../rabbitmq/instance/create/create_test.go | 2 +- .../cmd/rabbitmq/instance/delete/delete.go | 7 +-- .../rabbitmq/instance/delete/delete_test.go | 2 +- .../rabbitmq/instance/describe/describe.go | 6 +-- .../instance/describe/describe_test.go | 2 +- internal/cmd/rabbitmq/instance/list/list.go | 13 ++--- .../cmd/rabbitmq/instance/list/list_test.go | 2 +- .../cmd/rabbitmq/instance/update/update.go | 29 +++++------ .../rabbitmq/instance/update/update_test.go | 2 +- internal/cmd/rabbitmq/plans/plans.go | 11 +++-- internal/cmd/rabbitmq/plans/plans_test.go | 2 +- .../cmd/redis/credentials/create/create.go | 11 +++-- .../redis/credentials/create/create_test.go | 2 +- .../cmd/redis/credentials/delete/delete.go | 10 ++-- .../redis/credentials/delete/delete_test.go | 2 +- .../redis/credentials/describe/describe.go | 8 +-- .../credentials/describe/describe_test.go | 2 +- internal/cmd/redis/credentials/list/list.go | 11 +++-- .../cmd/redis/credentials/list/list_test.go | 2 +- internal/cmd/redis/instance/create/create.go | 31 ++++++------ .../cmd/redis/instance/create/create_test.go | 2 +- internal/cmd/redis/instance/delete/delete.go | 7 +-- .../cmd/redis/instance/delete/delete_test.go | 2 +- .../cmd/redis/instance/describe/describe.go | 6 +-- .../redis/instance/describe/describe_test.go | 2 +- internal/cmd/redis/instance/list/list.go | 13 ++--- internal/cmd/redis/instance/list/list_test.go | 2 +- internal/cmd/redis/instance/update/update.go | 27 +++++----- .../cmd/redis/instance/update/update_test.go | 2 +- internal/cmd/redis/plans/plans.go | 11 +++-- internal/cmd/redis/plans/plans_test.go | 2 +- internal/cmd/root.go | 5 +- .../secrets-manager/instance/create/create.go | 13 ++--- .../instance/create/create_test.go | 2 +- .../secrets-manager/instance/delete/delete.go | 7 +-- .../instance/delete/delete_test.go | 2 +- .../instance/describe/describe.go | 6 +-- .../instance/describe/describe_test.go | 2 +- .../cmd/secrets-manager/instance/list/list.go | 11 +++-- .../instance/list/list_test.go | 2 +- .../secrets-manager/instance/update/update.go | 9 ++-- .../instance/update/update_test.go | 2 +- .../cmd/secrets-manager/user/create/create.go | 13 ++--- .../user/create/create_test.go | 2 +- .../cmd/secrets-manager/user/delete/delete.go | 10 ++-- .../user/delete/delete_test.go | 2 +- .../secrets-manager/user/describe/describe.go | 8 +-- .../user/describe/describe_test.go | 2 +- .../cmd/secrets-manager/user/list/list.go | 13 ++--- .../secrets-manager/user/list/list_test.go | 2 +- .../cmd/secrets-manager/user/update/update.go | 14 +++--- .../user/update/update_test.go | 2 +- internal/cmd/service-account/create/create.go | 11 +++-- .../cmd/service-account/create/create_test.go | 2 +- internal/cmd/service-account/delete/delete.go | 6 +-- .../cmd/service-account/delete/delete_test.go | 2 +- .../cmd/service-account/key/create/create.go | 12 ++--- .../service-account/key/create/create_test.go | 2 +- .../cmd/service-account/key/delete/delete.go | 8 +-- .../service-account/key/delete/delete_test.go | 2 +- .../service-account/key/describe/describe.go | 8 +-- .../key/describe/describe_test.go | 2 +- internal/cmd/service-account/key/list/list.go | 10 ++-- .../cmd/service-account/key/list/list_test.go | 2 +- .../cmd/service-account/key/update/update.go | 14 +++--- .../service-account/key/update/update_test.go | 2 +- internal/cmd/service-account/list/list.go | 13 ++--- .../cmd/service-account/list/list_test.go | 2 +- .../service-account/token/create/create.go | 10 ++-- .../token/create/create_test.go | 2 +- .../cmd/service-account/token/list/list.go | 10 ++-- .../service-account/token/list/list_test.go | 2 +- .../service-account/token/revoke/revoke.go | 8 +-- .../token/revoke/revoke_test.go | 2 +- internal/cmd/ske/cluster/create/create.go | 11 +++-- .../cmd/ske/cluster/create/create_test.go | 2 +- internal/cmd/ske/cluster/delete/delete.go | 6 +-- .../cmd/ske/cluster/delete/delete_test.go | 2 +- internal/cmd/ske/cluster/describe/describe.go | 6 +-- .../cmd/ske/cluster/describe/describe_test.go | 2 +- .../generate-payload/generate_payload.go | 8 +-- .../generate-payload/generate_payload_test.go | 2 +- internal/cmd/ske/cluster/list/list.go | 13 ++--- internal/cmd/ske/cluster/list/list_test.go | 2 +- internal/cmd/ske/cluster/update/update.go | 8 +-- .../cmd/ske/cluster/update/update_test.go | 2 +- .../complete-rotation/complete_rotation.go | 6 +-- .../complete_rotation_test.go | 2 +- .../cmd/ske/credentials/describe/describe.go | 6 +-- .../ske/credentials/describe/describe_test.go | 2 +- internal/cmd/ske/credentials/rotate/rotate.go | 6 +-- .../cmd/ske/credentials/rotate/rotate_test.go | 2 +- .../start-rotation/start_rotation.go | 6 +-- .../start-rotation/start_rotation_test.go | 2 +- internal/cmd/ske/describe/describe.go | 6 +-- internal/cmd/ske/describe/describe_test.go | 2 +- internal/cmd/ske/disable/disable.go | 9 ++-- internal/cmd/ske/disable/disable_test.go | 2 +- internal/cmd/ske/enable/enable.go | 9 ++-- internal/cmd/ske/enable/enable_test.go | 2 +- internal/cmd/ske/kubeconfig/create/create.go | 10 ++-- .../cmd/ske/kubeconfig/create/create_test.go | 2 +- internal/cmd/ske/options/options.go | 16 +++--- internal/cmd/ske/options/options_test.go | 2 +- internal/pkg/auth/user_token_flow.go | 2 + internal/pkg/flags/flag_to_value.go | 37 +++++++++----- internal/pkg/flags/flags_test.go | 12 ++--- internal/pkg/globalflags/global_flags.go | 4 +- internal/pkg/print/print.go | 11 +++-- internal/pkg/projectname/project_name.go | 14 +++--- internal/pkg/services/argus/client/client.go | 2 + .../services/authorization/client/client.go | 2 + internal/pkg/services/dns/client/client.go | 2 + internal/pkg/services/logme/client/client.go | 2 + .../pkg/services/mariadb/client/client.go | 2 + .../pkg/services/mongodbflex/client/client.go | 2 + .../services/object-storage/client/client.go | 2 + .../pkg/services/opensearch/client/client.go | 2 + .../services/postgresflex/client/client.go | 2 + .../pkg/services/rabbitmq/client/client.go | 2 + internal/pkg/services/redis/client/client.go | 2 + .../services/resourcemanager/client/client.go | 2 + .../services/secrets-manager/client/client.go | 2 + .../services/service-account/client/client.go | 2 + internal/pkg/services/ske/client/client.go | 2 + 345 files changed, 1307 insertions(+), 1141 deletions(-) diff --git a/internal/cmd/argus/grafana/describe/describe.go b/internal/cmd/argus/grafana/describe/describe.go index 1ec3c65bc..d73e1e7c8 100644 --- a/internal/cmd/argus/grafana/describe/describe.go +++ b/internal/cmd/argus/grafana/describe/describe.go @@ -53,7 +53,8 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) + if err != nil { return err } @@ -86,10 +87,10 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().Bool(hidePasswordFlag, false, `Show the initial admin password in the "pretty" output format`) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { instanceId := inputArgs[0] + globalFlags := globalflags.Parse(p, cmd) - globalFlags := globalflags.Parse(cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } @@ -97,7 +98,7 @@ func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, InstanceId: instanceId, - HidePassword: flags.FlagToBoolValue(cmd, hidePasswordFlag), + HidePassword: flags.FlagToBoolValue(p, cmd, hidePasswordFlag), }, nil } diff --git a/internal/cmd/argus/grafana/describe/describe_test.go b/internal/cmd/argus/grafana/describe/describe_test.go index 5b0eae7ed..9295e1152 100644 --- a/internal/cmd/argus/grafana/describe/describe_test.go +++ b/internal/cmd/argus/grafana/describe/describe_test.go @@ -199,7 +199,8 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) + if err != nil { if !tt.isValid { return diff --git a/internal/cmd/argus/grafana/public-read-access/disable/disable.go b/internal/cmd/argus/grafana/public-read-access/disable/disable.go index e06157372..11b32e583 100644 --- a/internal/cmd/argus/grafana/public-read-access/disable/disable.go +++ b/internal/cmd/argus/grafana/public-read-access/disable/disable.go @@ -42,7 +42,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -83,10 +83,10 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { instanceId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/argus/grafana/public-read-access/disable/disable_test.go b/internal/cmd/argus/grafana/public-read-access/disable/disable_test.go index 9ef2296f9..7642ff1ab 100644 --- a/internal/cmd/argus/grafana/public-read-access/disable/disable_test.go +++ b/internal/cmd/argus/grafana/public-read-access/disable/disable_test.go @@ -216,7 +216,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/argus/grafana/public-read-access/enable/enable.go b/internal/cmd/argus/grafana/public-read-access/enable/enable.go index df0ccbd3b..edae29e13 100644 --- a/internal/cmd/argus/grafana/public-read-access/enable/enable.go +++ b/internal/cmd/argus/grafana/public-read-access/enable/enable.go @@ -42,7 +42,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -83,10 +83,10 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { instanceId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/argus/grafana/public-read-access/enable/enable_test.go b/internal/cmd/argus/grafana/public-read-access/enable/enable_test.go index 1e0794bdd..1e4e49e57 100644 --- a/internal/cmd/argus/grafana/public-read-access/enable/enable_test.go +++ b/internal/cmd/argus/grafana/public-read-access/enable/enable_test.go @@ -216,7 +216,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/argus/grafana/single-sign-on/disable/disable.go b/internal/cmd/argus/grafana/single-sign-on/disable/disable.go index 1a69a516c..78d5a2742 100644 --- a/internal/cmd/argus/grafana/single-sign-on/disable/disable.go +++ b/internal/cmd/argus/grafana/single-sign-on/disable/disable.go @@ -42,7 +42,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -83,10 +83,10 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { instanceId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/argus/grafana/single-sign-on/disable/disable_test.go b/internal/cmd/argus/grafana/single-sign-on/disable/disable_test.go index 32cdd0449..7af273fae 100644 --- a/internal/cmd/argus/grafana/single-sign-on/disable/disable_test.go +++ b/internal/cmd/argus/grafana/single-sign-on/disable/disable_test.go @@ -216,7 +216,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/argus/grafana/single-sign-on/enable/enable.go b/internal/cmd/argus/grafana/single-sign-on/enable/enable.go index 7c6c1179f..f2c3e1e99 100644 --- a/internal/cmd/argus/grafana/single-sign-on/enable/enable.go +++ b/internal/cmd/argus/grafana/single-sign-on/enable/enable.go @@ -42,7 +42,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -83,10 +83,10 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { instanceId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/argus/grafana/single-sign-on/enable/enable_test.go b/internal/cmd/argus/grafana/single-sign-on/enable/enable_test.go index c95378136..a85918cff 100644 --- a/internal/cmd/argus/grafana/single-sign-on/enable/enable_test.go +++ b/internal/cmd/argus/grafana/single-sign-on/enable/enable_test.go @@ -216,7 +216,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/argus/instance/create/create.go b/internal/cmd/argus/instance/create/create.go index a850a48b2..245097b49 100644 --- a/internal/cmd/argus/instance/create/create.go +++ b/internal/cmd/argus/instance/create/create.go @@ -51,7 +51,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -62,8 +62,9 @@ func NewCmd(p *print.Printer) *cobra.Command { return err } - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } @@ -122,14 +123,14 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &cliErr.ProjectIdError{} } - planId := flags.FlagToStringPointer(cmd, planIdFlag) - planName := flags.FlagToStringValue(cmd, planNameFlag) + planId := flags.FlagToStringPointer(p, cmd, planIdFlag) + planName := flags.FlagToStringValue(p, cmd, planNameFlag) if planId == nil && (planName == "") { return nil, &cliErr.ArgusInputPlanError{ @@ -144,7 +145,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - InstanceName: flags.FlagToStringPointer(cmd, instanceNameFlag), + InstanceName: flags.FlagToStringPointer(p, cmd, instanceNameFlag), PlanId: planId, PlanName: planName, }, nil diff --git a/internal/cmd/argus/instance/create/create_test.go b/internal/cmd/argus/instance/create/create_test.go index 9dd6cd436..708d12719 100644 --- a/internal/cmd/argus/instance/create/create_test.go +++ b/internal/cmd/argus/instance/create/create_test.go @@ -197,7 +197,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/argus/instance/delete/delete.go b/internal/cmd/argus/instance/delete/delete.go index 4812c7bce..e934f156f 100644 --- a/internal/cmd/argus/instance/delete/delete.go +++ b/internal/cmd/argus/instance/delete/delete.go @@ -41,7 +41,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -54,6 +54,7 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := argusUtils.GetInstanceName(ctx, apiClient, model.InstanceId, model.ProjectId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } @@ -94,10 +95,10 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { instanceId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/argus/instance/delete/delete_test.go b/internal/cmd/argus/instance/delete/delete_test.go index 502431d5e..f95802240 100644 --- a/internal/cmd/argus/instance/delete/delete_test.go +++ b/internal/cmd/argus/instance/delete/delete_test.go @@ -168,7 +168,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/argus/instance/describe/describe.go b/internal/cmd/argus/instance/describe/describe.go index 7574e1a77..b8daa10ff 100644 --- a/internal/cmd/argus/instance/describe/describe.go +++ b/internal/cmd/argus/instance/describe/describe.go @@ -43,7 +43,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -66,10 +66,10 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { instanceId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/argus/instance/describe/describe_test.go b/internal/cmd/argus/instance/describe/describe_test.go index ac060428a..2ea538deb 100644 --- a/internal/cmd/argus/instance/describe/describe_test.go +++ b/internal/cmd/argus/instance/describe/describe_test.go @@ -168,7 +168,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/argus/instance/list/list.go b/internal/cmd/argus/instance/list/list.go index 167ee90e8..4e3fc4eae 100644 --- a/internal/cmd/argus/instance/list/list.go +++ b/internal/cmd/argus/instance/list/list.go @@ -47,7 +47,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -66,8 +66,9 @@ func NewCmd(p *print.Printer) *cobra.Command { } instances := *resp.Instances if len(instances) == 0 { - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } p.Info("No instances found for project %q\n", projectLabel) @@ -91,13 +92,13 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().Int64(limitFlag, 0, "Maximum number of entries to list") } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, @@ -107,7 +108,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - Limit: flags.FlagToInt64Pointer(cmd, limitFlag), + Limit: flags.FlagToInt64Pointer(p, cmd, limitFlag), }, nil } diff --git a/internal/cmd/argus/instance/list/list_test.go b/internal/cmd/argus/instance/list/list_test.go index f9a0a0e7c..93eb76955 100644 --- a/internal/cmd/argus/instance/list/list_test.go +++ b/internal/cmd/argus/instance/list/list_test.go @@ -138,7 +138,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/argus/instance/update/update.go b/internal/cmd/argus/instance/update/update.go index 2faec24a7..f974cdca8 100644 --- a/internal/cmd/argus/instance/update/update.go +++ b/internal/cmd/argus/instance/update/update.go @@ -57,7 +57,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -70,6 +70,7 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := argusUtils.GetInstanceName(ctx, apiClient, model.InstanceId, model.ProjectId) if err != nil || instanceLabel == "" { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } @@ -126,17 +127,17 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().StringP(instanceNameFlag, "n", "", "Instance name") } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { instanceId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &cliErr.ProjectIdError{} } - planId := flags.FlagToStringPointer(cmd, planIdFlag) - planName := flags.FlagToStringValue(cmd, planNameFlag) - instanceName := flags.FlagToStringPointer(cmd, instanceNameFlag) + planId := flags.FlagToStringPointer(p, cmd, planIdFlag) + planName := flags.FlagToStringValue(p, cmd, planNameFlag) + instanceName := flags.FlagToStringPointer(p, cmd, instanceNameFlag) if planId != nil && (planName != "") { return nil, &cliErr.ArgusInputPlanError{ diff --git a/internal/cmd/argus/instance/update/update_test.go b/internal/cmd/argus/instance/update/update_test.go index 330e6943f..a32795512 100644 --- a/internal/cmd/argus/instance/update/update_test.go +++ b/internal/cmd/argus/instance/update/update_test.go @@ -270,7 +270,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/argus/plans/plans.go b/internal/cmd/argus/plans/plans.go index ff6d9a1d2..a90d7d483 100644 --- a/internal/cmd/argus/plans/plans.go +++ b/internal/cmd/argus/plans/plans.go @@ -47,7 +47,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -66,8 +66,9 @@ func NewCmd(p *print.Printer) *cobra.Command { } plans := *resp.Plans if len(plans) == 0 { - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } p.Info("No plans found for project %q\n", projectLabel) @@ -91,13 +92,13 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().Int64(limitFlag, 0, "Maximum number of entries to list") } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, diff --git a/internal/cmd/argus/plans/plans_test.go b/internal/cmd/argus/plans/plans_test.go index 2e6364416..1f961a7fe 100644 --- a/internal/cmd/argus/plans/plans_test.go +++ b/internal/cmd/argus/plans/plans_test.go @@ -138,7 +138,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/auth/activate-service-account/activate_service_account.go b/internal/cmd/auth/activate-service-account/activate_service_account.go index 6f2c5b9db..872877daf 100644 --- a/internal/cmd/auth/activate-service-account/activate_service_account.go +++ b/internal/cmd/auth/activate-service-account/activate_service_account.go @@ -54,7 +54,7 @@ func NewCmd(p *print.Printer) *cobra.Command { "$ stackit auth activate-service-account --service-account-token my-service-account-token"), ), RunE: func(cmd *cobra.Command, args []string) error { - model := parseInput(cmd) + model := parseInput(p, cmd) err := storeFlags(model) if err != nil { @@ -104,13 +104,13 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().String(jwksCustomEndpointFlag, "", "Custom endpoint for the jwks API, which is used to get the json web key sets (jwks) to validate tokens when the service-account authentication is activated") } -func parseInput(cmd *cobra.Command) *inputModel { +func parseInput(p *print.Printer, cmd *cobra.Command) *inputModel { return &inputModel{ - ServiceAccountToken: flags.FlagToStringValue(cmd, serviceAccountTokenFlag), - ServiceAccountKeyPath: flags.FlagToStringValue(cmd, serviceAccountKeyPathFlag), - PrivateKeyPath: flags.FlagToStringValue(cmd, privateKeyPathFlag), - TokenCustomEndpoint: flags.FlagToStringValue(cmd, tokenCustomEndpointFlag), - JwksCustomEndpoint: flags.FlagToStringValue(cmd, jwksCustomEndpointFlag), + ServiceAccountToken: flags.FlagToStringValue(p, cmd, serviceAccountTokenFlag), + ServiceAccountKeyPath: flags.FlagToStringValue(p, cmd, serviceAccountKeyPathFlag), + PrivateKeyPath: flags.FlagToStringValue(p, cmd, privateKeyPathFlag), + TokenCustomEndpoint: flags.FlagToStringValue(p, cmd, tokenCustomEndpointFlag), + JwksCustomEndpoint: flags.FlagToStringValue(p, cmd, jwksCustomEndpointFlag), } } diff --git a/internal/cmd/auth/activate-service-account/activate_service_account_test.go b/internal/cmd/auth/activate-service-account/activate_service_account_test.go index 04f7a9084..cdf1b5294 100644 --- a/internal/cmd/auth/activate-service-account/activate_service_account_test.go +++ b/internal/cmd/auth/activate-service-account/activate_service_account_test.go @@ -106,7 +106,7 @@ func TestParseInput(t *testing.T) { } } - model := parseInput(cmd) + model := parseInput(nil, cmd) if !tt.isValid { t.Fatalf("did not fail on invalid input") diff --git a/internal/cmd/config/config.go b/internal/cmd/config/config.go index ee650f765..e02153fb0 100644 --- a/internal/cmd/config/config.go +++ b/internal/cmd/config/config.go @@ -26,5 +26,5 @@ func NewCmd(p *print.Printer) *cobra.Command { func addSubcommands(cmd *cobra.Command, p *print.Printer) { cmd.AddCommand(list.NewCmd(p)) cmd.AddCommand(set.NewCmd(p)) - cmd.AddCommand(unset.NewCmd()) + cmd.AddCommand(unset.NewCmd(p)) } diff --git a/internal/cmd/config/set/set.go b/internal/cmd/config/set/set.go index 459f3a3b4..d3a29ee6a 100644 --- a/internal/cmd/config/set/set.go +++ b/internal/cmd/config/set/set.go @@ -65,7 +65,7 @@ func NewCmd(p *print.Printer) *cobra.Command { "$ stackit config set --dns-custom-endpoint https://dns.stackit.cloud"), ), RunE: func(cmd *cobra.Command, args []string) error { - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -142,8 +142,8 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - sessionTimeLimit, err := parseSessionTimeLimit(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + sessionTimeLimit, err := parseSessionTimeLimit(p, cmd) if err != nil { return nil, &errors.FlagValidationError{ Flag: sessionTimeLimitFlag, @@ -154,7 +154,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { // values.FlagToStringPointer pulls the projectId from passed flags // globalflags.Parse uses the flags, and fallsback to config file // To check if projectId was passed, we use the first rather than the second - projectIdFromFlag := flags.FlagToStringPointer(cmd, globalflags.ProjectIdFlag) + projectIdFromFlag := flags.FlagToStringPointer(p, cmd, globalflags.ProjectIdFlag) projectIdSet := false if projectIdFromFlag != nil { projectIdSet = true @@ -166,8 +166,8 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { }, nil } -func parseSessionTimeLimit(cmd *cobra.Command) (*string, error) { - sessionTimeLimit := flags.FlagToStringPointer(cmd, sessionTimeLimitFlag) +func parseSessionTimeLimit(p *print.Printer, cmd *cobra.Command) (*string, error) { + sessionTimeLimit := flags.FlagToStringPointer(p, cmd, sessionTimeLimitFlag) if sessionTimeLimit == nil { return nil, nil } diff --git a/internal/cmd/config/set/set_test.go b/internal/cmd/config/set/set_test.go index e3b6c972b..18055f76b 100644 --- a/internal/cmd/config/set/set_test.go +++ b/internal/cmd/config/set/set_test.go @@ -144,7 +144,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/config/unset/unset.go b/internal/cmd/config/unset/unset.go index 7f6bc8449..61a97680a 100644 --- a/internal/cmd/config/unset/unset.go +++ b/internal/cmd/config/unset/unset.go @@ -8,6 +8,7 @@ import ( "github.com/stackitcloud/stackit-cli/internal/pkg/examples" "github.com/stackitcloud/stackit-cli/internal/pkg/flags" "github.com/stackitcloud/stackit-cli/internal/pkg/globalflags" + "github.com/stackitcloud/stackit-cli/internal/pkg/print" "github.com/spf13/cobra" "github.com/spf13/viper" @@ -62,7 +63,7 @@ type inputModel struct { SKECustomEndpoint bool } -func NewCmd() *cobra.Command { +func NewCmd(p *print.Printer) *cobra.Command { cmd := &cobra.Command{ Use: "unset", Short: "Unsets CLI configuration options", @@ -80,7 +81,7 @@ func NewCmd() *cobra.Command { "$ stackit config unset --dns-custom-endpoint"), ), RunE: func(cmd *cobra.Command, args []string) error { - model := parseInput(cmd) + model := parseInput(p, cmd) if model.Async { viper.Set(config.AsyncKey, config.AsyncDefault) @@ -179,28 +180,28 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().Bool(skeCustomEndpointFlag, false, "SKE API base URL. If unset, uses the default base URL") } -func parseInput(cmd *cobra.Command) *inputModel { +func parseInput(p *print.Printer, cmd *cobra.Command) *inputModel { return &inputModel{ - Async: flags.FlagToBoolValue(cmd, asyncFlag), - OutputFormat: flags.FlagToBoolValue(cmd, outputFormatFlag), - ProjectId: flags.FlagToBoolValue(cmd, projectIdFlag), - SessionTimeLimit: flags.FlagToBoolValue(cmd, sessionTimeLimitFlag), - Verbosity: flags.FlagToBoolValue(cmd, verbosityFlag), - - ArgusCustomEndpoint: flags.FlagToBoolValue(cmd, argusCustomEndpointFlag), - AuthorizationCustomEndpoint: flags.FlagToBoolValue(cmd, authorizationCustomEndpointFlag), - DNSCustomEndpoint: flags.FlagToBoolValue(cmd, dnsCustomEndpointFlag), - LogMeCustomEndpoint: flags.FlagToBoolValue(cmd, logMeCustomEndpointFlag), - MariaDBCustomEndpoint: flags.FlagToBoolValue(cmd, mariaDBCustomEndpointFlag), - MongoDBFlexCustomEndpoint: flags.FlagToBoolValue(cmd, mongoDBFlexCustomEndpointFlag), - ObjectStorageCustomEndpoint: flags.FlagToBoolValue(cmd, objectStorageCustomEndpointFlag), - OpenSearchCustomEndpoint: flags.FlagToBoolValue(cmd, openSearchCustomEndpointFlag), - PostgresFlexCustomEndpoint: flags.FlagToBoolValue(cmd, postgresFlexCustomEndpointFlag), - RabbitMQCustomEndpoint: flags.FlagToBoolValue(cmd, rabbitMQCustomEndpointFlag), - RedisCustomEndpoint: flags.FlagToBoolValue(cmd, redisCustomEndpointFlag), - ResourceManagerCustomEndpoint: flags.FlagToBoolValue(cmd, resourceManagerCustomEndpointFlag), - SecretsManagerCustomEndpoint: flags.FlagToBoolValue(cmd, secretsManagerCustomEndpointFlag), - ServiceAccountCustomEndpoint: flags.FlagToBoolValue(cmd, serviceAccountCustomEndpointFlag), - SKECustomEndpoint: flags.FlagToBoolValue(cmd, skeCustomEndpointFlag), + Async: flags.FlagToBoolValue(p, cmd, asyncFlag), + OutputFormat: flags.FlagToBoolValue(p, cmd, outputFormatFlag), + ProjectId: flags.FlagToBoolValue(p, cmd, projectIdFlag), + SessionTimeLimit: flags.FlagToBoolValue(p, cmd, sessionTimeLimitFlag), + Verbosity: flags.FlagToBoolValue(p, cmd, verbosityFlag), + + ArgusCustomEndpoint: flags.FlagToBoolValue(p, cmd, argusCustomEndpointFlag), + AuthorizationCustomEndpoint: flags.FlagToBoolValue(p, cmd, authorizationCustomEndpointFlag), + DNSCustomEndpoint: flags.FlagToBoolValue(p, cmd, dnsCustomEndpointFlag), + LogMeCustomEndpoint: flags.FlagToBoolValue(p, cmd, logMeCustomEndpointFlag), + MariaDBCustomEndpoint: flags.FlagToBoolValue(p, cmd, mariaDBCustomEndpointFlag), + MongoDBFlexCustomEndpoint: flags.FlagToBoolValue(p, cmd, mongoDBFlexCustomEndpointFlag), + ObjectStorageCustomEndpoint: flags.FlagToBoolValue(p, cmd, objectStorageCustomEndpointFlag), + OpenSearchCustomEndpoint: flags.FlagToBoolValue(p, cmd, openSearchCustomEndpointFlag), + PostgresFlexCustomEndpoint: flags.FlagToBoolValue(p, cmd, postgresFlexCustomEndpointFlag), + RabbitMQCustomEndpoint: flags.FlagToBoolValue(p, cmd, rabbitMQCustomEndpointFlag), + RedisCustomEndpoint: flags.FlagToBoolValue(p, cmd, redisCustomEndpointFlag), + ResourceManagerCustomEndpoint: flags.FlagToBoolValue(p, cmd, resourceManagerCustomEndpointFlag), + SecretsManagerCustomEndpoint: flags.FlagToBoolValue(p, cmd, secretsManagerCustomEndpointFlag), + ServiceAccountCustomEndpoint: flags.FlagToBoolValue(p, cmd, serviceAccountCustomEndpointFlag), + SKECustomEndpoint: flags.FlagToBoolValue(p, cmd, skeCustomEndpointFlag), } } diff --git a/internal/cmd/config/unset/unset_test.go b/internal/cmd/config/unset/unset_test.go index 738bbbdb5..86d12d7ba 100644 --- a/internal/cmd/config/unset/unset_test.go +++ b/internal/cmd/config/unset/unset_test.go @@ -185,7 +185,7 @@ func TestParseInput(t *testing.T) { } for _, tt := range tests { t.Run(tt.description, func(t *testing.T) { - cmd := NewCmd() + cmd := NewCmd(nil) for flag, value := range tt.flagValues { stringBool := fmt.Sprintf("%v", value) @@ -206,7 +206,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model := parseInput(cmd) + model := parseInput(nil, cmd) if !tt.isValid { t.Fatalf("did not fail on invalid input") diff --git a/internal/cmd/curl/curl.go b/internal/cmd/curl/curl.go index 8454cb0ce..694261d4e 100644 --- a/internal/cmd/curl/curl.go +++ b/internal/cmd/curl/curl.go @@ -69,7 +69,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), Args: args.SingleArg(urlArg, validateURL), RunE: func(cmd *cobra.Command, args []string) (err error) { - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -150,9 +150,9 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().String(outputFileFlag, "", "Writes output to provided file instead of printing to console") } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { urlString := inputArgs[0] - requestMethod := flags.FlagToStringValue(cmd, requestMethodFlag) + requestMethod := flags.FlagToStringValue(p, cmd, requestMethodFlag) if requestMethod == "" { requestMethod = http.MethodGet } @@ -160,17 +160,18 @@ func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { return &inputModel{ URL: urlString, RequestMethod: strings.ToUpper(requestMethod), - Headers: flags.FlagToStringSliceValue(cmd, headerFlag), - Data: flags.FlagToStringPointer(cmd, dataFlag), - IncludeResponseHeaders: flags.FlagToBoolValue(cmd, includeResponseHeadersFlag), - FailOnHTTPError: flags.FlagToBoolValue(cmd, failOnHTTPErrorFlag), - OutputFile: flags.FlagToStringPointer(cmd, outputFileFlag), + Headers: flags.FlagToStringSliceValue(p, cmd, headerFlag), + Data: flags.FlagToStringPointer(p, cmd, dataFlag), + IncludeResponseHeaders: flags.FlagToBoolValue(p, cmd, includeResponseHeadersFlag), + FailOnHTTPError: flags.FlagToBoolValue(p, cmd, failOnHTTPErrorFlag), + OutputFile: flags.FlagToStringPointer(p, cmd, outputFileFlag), }, nil } func getBearerToken(p *print.Printer) (string, error) { _, err := auth.AuthenticationConfig(p, auth.AuthorizeUser) if err != nil { + p.Debug(print.ErrorLevel, "configure authentication: %v", err) return "", &errors.AuthError{} } token, err := auth.GetAuthField(auth.ACCESS_TOKEN) diff --git a/internal/cmd/curl/curl_test.go b/internal/cmd/curl/curl_test.go index da57f3d04..122ac6b35 100644 --- a/internal/cmd/curl/curl_test.go +++ b/internal/cmd/curl/curl_test.go @@ -247,7 +247,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/dns/record-set/create/create.go b/internal/cmd/dns/record-set/create/create.go index f144a59ca..7d3fbbd4e 100644 --- a/internal/cmd/dns/record-set/create/create.go +++ b/internal/cmd/dns/record-set/create/create.go @@ -54,7 +54,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -67,6 +67,7 @@ func NewCmd(p *print.Printer) *cobra.Command { zoneLabel, err := dnsUtils.GetZoneName(ctx, apiClient, model.ProjectId, model.ZoneId) if err != nil { + p.Debug(print.ErrorLevel, "get zone name: %v", err) zoneLabel = model.ZoneId } @@ -123,20 +124,20 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } return &inputModel{ GlobalFlagModel: globalFlags, - ZoneId: flags.FlagToStringValue(cmd, zoneIdFlag), - Comment: flags.FlagToStringPointer(cmd, commentFlag), - Name: flags.FlagToStringPointer(cmd, nameFlag), - Records: flags.FlagToStringSliceValue(cmd, recordFlag), - TTL: flags.FlagToInt64Pointer(cmd, ttlFlag), - Type: flags.FlagWithDefaultToStringValue(cmd, typeFlag), + ZoneId: flags.FlagToStringValue(p, cmd, zoneIdFlag), + Comment: flags.FlagToStringPointer(p, cmd, commentFlag), + Name: flags.FlagToStringPointer(p, cmd, nameFlag), + Records: flags.FlagToStringSliceValue(p, cmd, recordFlag), + TTL: flags.FlagToInt64Pointer(p, cmd, ttlFlag), + Type: flags.FlagWithDefaultToStringValue(p, cmd, typeFlag), }, nil } diff --git a/internal/cmd/dns/record-set/create/create_test.go b/internal/cmd/dns/record-set/create/create_test.go index c8d095748..3290f19e4 100644 --- a/internal/cmd/dns/record-set/create/create_test.go +++ b/internal/cmd/dns/record-set/create/create_test.go @@ -273,7 +273,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/dns/record-set/delete/delete.go b/internal/cmd/dns/record-set/delete/delete.go index b85a68149..ea11d98be 100644 --- a/internal/cmd/dns/record-set/delete/delete.go +++ b/internal/cmd/dns/record-set/delete/delete.go @@ -45,7 +45,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -58,11 +58,13 @@ func NewCmd(p *print.Printer) *cobra.Command { zoneLabel, err := dnsUtils.GetZoneName(ctx, apiClient, model.ProjectId, model.ZoneId) if err != nil { + p.Debug(print.ErrorLevel, "get zone name: %v", err) zoneLabel = model.ZoneId } recordSetLabel, err := dnsUtils.GetRecordSetName(ctx, apiClient, model.ProjectId, model.ZoneId, model.RecordSetId) if err != nil { + p.Debug(print.ErrorLevel, "get record set name: %v", err) recordSetLabel = model.RecordSetId } @@ -114,17 +116,17 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { recordSetId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } return &inputModel{ GlobalFlagModel: globalFlags, - ZoneId: flags.FlagToStringValue(cmd, zoneIdFlag), + ZoneId: flags.FlagToStringValue(p, cmd, zoneIdFlag), RecordSetId: recordSetId, }, nil } diff --git a/internal/cmd/dns/record-set/delete/delete_test.go b/internal/cmd/dns/record-set/delete/delete_test.go index a60e5b63b..272b23247 100644 --- a/internal/cmd/dns/record-set/delete/delete_test.go +++ b/internal/cmd/dns/record-set/delete/delete_test.go @@ -195,7 +195,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/dns/record-set/describe/describe.go b/internal/cmd/dns/record-set/describe/describe.go index c392d2f06..d2e74f37c 100644 --- a/internal/cmd/dns/record-set/describe/describe.go +++ b/internal/cmd/dns/record-set/describe/describe.go @@ -48,7 +48,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -81,17 +81,17 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { recordSetId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } return &inputModel{ GlobalFlagModel: globalFlags, - ZoneId: flags.FlagToStringValue(cmd, zoneIdFlag), + ZoneId: flags.FlagToStringValue(p, cmd, zoneIdFlag), RecordSetId: recordSetId, }, nil } diff --git a/internal/cmd/dns/record-set/describe/describe_test.go b/internal/cmd/dns/record-set/describe/describe_test.go index c3dd68d55..8ee9c6551 100644 --- a/internal/cmd/dns/record-set/describe/describe_test.go +++ b/internal/cmd/dns/record-set/describe/describe_test.go @@ -195,7 +195,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/dns/record-set/list/list.go b/internal/cmd/dns/record-set/list/list.go index 182d4ca29..8567377b1 100644 --- a/internal/cmd/dns/record-set/list/list.go +++ b/internal/cmd/dns/record-set/list/list.go @@ -72,7 +72,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -91,6 +91,7 @@ func NewCmd(p *print.Printer) *cobra.Command { if len(recordSets) == 0 { zoneLabel, err := dnsUtils.GetZoneName(ctx, apiClient, model.ProjectId, model.ZoneId) if err != nil { + p.Debug(print.ErrorLevel, "get zone name: %v", err) zoneLabel = model.ZoneId } p.Info("No record sets found for zone %s matching the criteria\n", zoneLabel) @@ -120,13 +121,13 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, @@ -134,7 +135,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { } } - pageSize := flags.FlagWithDefaultToInt64Value(cmd, pageSizeFlag) + pageSize := flags.FlagWithDefaultToInt64Value(p, cmd, pageSizeFlag) if pageSize < 1 { return nil, &errors.FlagValidationError{ Flag: pageSizeFlag, @@ -142,21 +143,21 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { } } - active := flags.FlagToBoolValue(cmd, activeFlag) - inactive := flags.FlagToBoolValue(cmd, inactiveFlag) + active := flags.FlagToBoolValue(p, cmd, activeFlag) + inactive := flags.FlagToBoolValue(p, cmd, inactiveFlag) if active && inactive { return nil, fmt.Errorf("only one of %s and %s can be set", activeFlag, inactiveFlag) } return &inputModel{ GlobalFlagModel: globalFlags, - ZoneId: flags.FlagToStringValue(cmd, zoneIdFlag), + ZoneId: flags.FlagToStringValue(p, cmd, zoneIdFlag), Active: active, Inactive: inactive, - Deleted: flags.FlagToBoolValue(cmd, deletedFlag), - NameLike: flags.FlagToStringPointer(cmd, nameLikeFlag), - OrderByName: flags.FlagToStringPointer(cmd, orderByNameFlag), - Limit: flags.FlagToInt64Pointer(cmd, limitFlag), + Deleted: flags.FlagToBoolValue(p, cmd, deletedFlag), + NameLike: flags.FlagToStringPointer(p, cmd, nameLikeFlag), + OrderByName: flags.FlagToStringPointer(p, cmd, orderByNameFlag), + Limit: flags.FlagToInt64Pointer(p, cmd, limitFlag), PageSize: pageSize, }, nil } diff --git a/internal/cmd/dns/record-set/list/list_test.go b/internal/cmd/dns/record-set/list/list_test.go index e647eb819..5cf9a9292 100644 --- a/internal/cmd/dns/record-set/list/list_test.go +++ b/internal/cmd/dns/record-set/list/list_test.go @@ -237,7 +237,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/dns/record-set/update/update.go b/internal/cmd/dns/record-set/update/update.go index 702e16712..1163ced8e 100644 --- a/internal/cmd/dns/record-set/update/update.go +++ b/internal/cmd/dns/record-set/update/update.go @@ -53,7 +53,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -66,11 +66,13 @@ func NewCmd(p *print.Printer) *cobra.Command { zoneLabel, err := dnsUtils.GetZoneName(ctx, apiClient, model.ProjectId, model.ZoneId) if err != nil { + p.Debug(print.ErrorLevel, "get zone name: %v", err) zoneLabel = model.ZoneId } recordSetLabel, err := dnsUtils.GetRecordSetName(ctx, apiClient, model.ProjectId, model.ZoneId, model.RecordSetId) if err != nil { + p.Debug(print.ErrorLevel, "get record set name: %v", err) recordSetLabel = model.RecordSetId } @@ -123,19 +125,19 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { recordSetId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - zoneId := flags.FlagToStringValue(cmd, zoneIdFlag) - comment := flags.FlagToStringPointer(cmd, commentFlag) - name := flags.FlagToStringPointer(cmd, nameFlag) - records := flags.FlagToStringSlicePointer(cmd, recordFlag) - ttl := flags.FlagToInt64Pointer(cmd, ttlFlag) + zoneId := flags.FlagToStringValue(p, cmd, zoneIdFlag) + comment := flags.FlagToStringPointer(p, cmd, commentFlag) + name := flags.FlagToStringPointer(p, cmd, nameFlag) + records := flags.FlagToStringSlicePointer(p, cmd, recordFlag) + ttl := flags.FlagToInt64Pointer(p, cmd, ttlFlag) if comment == nil && name == nil && records == nil && ttl == nil { return nil, &errors.EmptyUpdateError{} diff --git a/internal/cmd/dns/record-set/update/update_test.go b/internal/cmd/dns/record-set/update/update_test.go index 087ce4158..1107bf5ba 100644 --- a/internal/cmd/dns/record-set/update/update_test.go +++ b/internal/cmd/dns/record-set/update/update_test.go @@ -285,7 +285,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/dns/zone/create/create.go b/internal/cmd/dns/zone/create/create.go index f07f72ced..abe905bee 100644 --- a/internal/cmd/dns/zone/create/create.go +++ b/internal/cmd/dns/zone/create/create.go @@ -68,7 +68,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -79,8 +79,9 @@ func NewCmd(p *print.Printer) *cobra.Command { return err } - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } @@ -142,27 +143,27 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } return &inputModel{ GlobalFlagModel: globalFlags, - Name: flags.FlagToStringPointer(cmd, nameFlag), - DnsName: flags.FlagToStringPointer(cmd, dnsNameFlag), - DefaultTTL: flags.FlagToInt64Pointer(cmd, defaultTTLFlag), - Primaries: flags.FlagToStringSlicePointer(cmd, primaryFlag), - Acl: flags.FlagToStringPointer(cmd, aclFlag), - Type: flags.FlagToStringPointer(cmd, typeFlag), - RetryTime: flags.FlagToInt64Pointer(cmd, retryTimeFlag), - RefreshTime: flags.FlagToInt64Pointer(cmd, refreshTimeFlag), - NegativeCache: flags.FlagToInt64Pointer(cmd, negativeCacheFlag), - IsReverseZone: flags.FlagToBoolPointer(cmd, isReverseZoneFlag), - ExpireTime: flags.FlagToInt64Pointer(cmd, expireTimeFlag), - Description: flags.FlagToStringPointer(cmd, descriptionFlag), - ContactEmail: flags.FlagToStringPointer(cmd, contactEmailFlag), + Name: flags.FlagToStringPointer(p, cmd, nameFlag), + DnsName: flags.FlagToStringPointer(p, cmd, dnsNameFlag), + DefaultTTL: flags.FlagToInt64Pointer(p, cmd, defaultTTLFlag), + Primaries: flags.FlagToStringSlicePointer(p, cmd, primaryFlag), + Acl: flags.FlagToStringPointer(p, cmd, aclFlag), + Type: flags.FlagToStringPointer(p, cmd, typeFlag), + RetryTime: flags.FlagToInt64Pointer(p, cmd, retryTimeFlag), + RefreshTime: flags.FlagToInt64Pointer(p, cmd, refreshTimeFlag), + NegativeCache: flags.FlagToInt64Pointer(p, cmd, negativeCacheFlag), + IsReverseZone: flags.FlagToBoolPointer(p, cmd, isReverseZoneFlag), + ExpireTime: flags.FlagToInt64Pointer(p, cmd, expireTimeFlag), + Description: flags.FlagToStringPointer(p, cmd, descriptionFlag), + ContactEmail: flags.FlagToStringPointer(p, cmd, contactEmailFlag), }, nil } diff --git a/internal/cmd/dns/zone/create/create_test.go b/internal/cmd/dns/zone/create/create_test.go index 75a43ae75..c2599a1a4 100644 --- a/internal/cmd/dns/zone/create/create_test.go +++ b/internal/cmd/dns/zone/create/create_test.go @@ -249,7 +249,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/dns/zone/delete/delete.go b/internal/cmd/dns/zone/delete/delete.go index e36f4dd56..80f68bda3 100644 --- a/internal/cmd/dns/zone/delete/delete.go +++ b/internal/cmd/dns/zone/delete/delete.go @@ -41,7 +41,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -54,6 +54,7 @@ func NewCmd(p *print.Printer) *cobra.Command { zoneLabel, err := dnsUtils.GetZoneName(ctx, apiClient, model.ProjectId, model.ZoneId) if err != nil { + p.Debug(print.ErrorLevel, "get zone name: %v", err) zoneLabel = model.ZoneId } if !model.AssumeYes { @@ -96,9 +97,9 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { zoneId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/dns/zone/delete/delete_test.go b/internal/cmd/dns/zone/delete/delete_test.go index a2bd86748..135f91ea1 100644 --- a/internal/cmd/dns/zone/delete/delete_test.go +++ b/internal/cmd/dns/zone/delete/delete_test.go @@ -168,7 +168,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/dns/zone/describe/describe.go b/internal/cmd/dns/zone/describe/describe.go index 3503fac06..9c028490b 100644 --- a/internal/cmd/dns/zone/describe/describe.go +++ b/internal/cmd/dns/zone/describe/describe.go @@ -43,7 +43,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -67,10 +67,10 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { zoneId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/dns/zone/describe/describe_test.go b/internal/cmd/dns/zone/describe/describe_test.go index 2b402efab..4d4302c8b 100644 --- a/internal/cmd/dns/zone/describe/describe_test.go +++ b/internal/cmd/dns/zone/describe/describe_test.go @@ -168,7 +168,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/dns/zone/list/list.go b/internal/cmd/dns/zone/list/list.go index 08a5edd23..e87e7a760 100644 --- a/internal/cmd/dns/zone/list/list.go +++ b/internal/cmd/dns/zone/list/list.go @@ -67,7 +67,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -84,8 +84,9 @@ func NewCmd(p *print.Printer) *cobra.Command { return err } if len(zones) == 0 { - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } p.Info("No zones found for project %q matching the criteria\n", projectLabel) @@ -111,13 +112,13 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().Int64(pageSizeFlag, pageSizeDefault, "Number of items fetched in each API call. Does not affect the number of items in the command output") } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, @@ -125,7 +126,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { } } - pageSize := flags.FlagWithDefaultToInt64Value(cmd, pageSizeFlag) + pageSize := flags.FlagWithDefaultToInt64Value(p, cmd, pageSizeFlag) if pageSize < 1 { return nil, &errors.FlagValidationError{ Flag: pageSizeFlag, @@ -133,8 +134,8 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { } } - active := flags.FlagToBoolValue(cmd, activeFlag) - inactive := flags.FlagToBoolValue(cmd, inactiveFlag) + active := flags.FlagToBoolValue(p, cmd, activeFlag) + inactive := flags.FlagToBoolValue(p, cmd, inactiveFlag) if active && inactive { return nil, fmt.Errorf("only one of %s and %s can be set", activeFlag, inactiveFlag) } @@ -143,9 +144,9 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { GlobalFlagModel: globalFlags, Active: active, Inactive: inactive, - IncludeDeleted: flags.FlagToBoolValue(cmd, includeDeletedFlag), - NameLike: flags.FlagToStringPointer(cmd, nameLikeFlag), - OrderByName: flags.FlagToStringPointer(cmd, orderByNameFlag), + IncludeDeleted: flags.FlagToBoolValue(p, cmd, includeDeletedFlag), + NameLike: flags.FlagToStringPointer(p, cmd, nameLikeFlag), + OrderByName: flags.FlagToStringPointer(p, cmd, orderByNameFlag), Limit: limit, PageSize: pageSize, }, nil diff --git a/internal/cmd/dns/zone/list/list_test.go b/internal/cmd/dns/zone/list/list_test.go index 9a3b6c011..b5e17bf3c 100644 --- a/internal/cmd/dns/zone/list/list_test.go +++ b/internal/cmd/dns/zone/list/list_test.go @@ -232,7 +232,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/dns/zone/update/update.go b/internal/cmd/dns/zone/update/update.go index 5b3e20ec4..940cb3d00 100644 --- a/internal/cmd/dns/zone/update/update.go +++ b/internal/cmd/dns/zone/update/update.go @@ -63,7 +63,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -76,6 +76,7 @@ func NewCmd(p *print.Printer) *cobra.Command { zoneLabel, err := dnsUtils.GetZoneName(ctx, apiClient, model.ProjectId, model.ZoneId) if err != nil { + p.Debug(print.ErrorLevel, "get zone name: %v", err) zoneLabel = model.ZoneId } @@ -133,24 +134,24 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().String(contactEmailFlag, "", "Contact email for the zone") } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { zoneId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - name := flags.FlagToStringPointer(cmd, nameFlag) - defaultTTL := flags.FlagToInt64Pointer(cmd, defaultTTLFlag) - primaries := flags.FlagToStringSlicePointer(cmd, primaryFlag) - acl := flags.FlagToStringPointer(cmd, aclFlag) - retryTime := flags.FlagToInt64Pointer(cmd, retryTimeFlag) - refreshTime := flags.FlagToInt64Pointer(cmd, refreshTimeFlag) - negativeCache := flags.FlagToInt64Pointer(cmd, negativeCacheFlag) - expireTime := flags.FlagToInt64Pointer(cmd, expireTimeFlag) - description := flags.FlagToStringPointer(cmd, descriptionFlag) - contactEmail := flags.FlagToStringPointer(cmd, contactEmailFlag) + name := flags.FlagToStringPointer(p, cmd, nameFlag) + defaultTTL := flags.FlagToInt64Pointer(p, cmd, defaultTTLFlag) + primaries := flags.FlagToStringSlicePointer(p, cmd, primaryFlag) + acl := flags.FlagToStringPointer(p, cmd, aclFlag) + retryTime := flags.FlagToInt64Pointer(p, cmd, retryTimeFlag) + refreshTime := flags.FlagToInt64Pointer(p, cmd, refreshTimeFlag) + negativeCache := flags.FlagToInt64Pointer(p, cmd, negativeCacheFlag) + expireTime := flags.FlagToInt64Pointer(p, cmd, expireTimeFlag) + description := flags.FlagToStringPointer(p, cmd, descriptionFlag) + contactEmail := flags.FlagToStringPointer(p, cmd, contactEmailFlag) if name == nil && defaultTTL == nil && primaries == nil && acl == nil && retryTime == nil && refreshTime == nil && diff --git a/internal/cmd/dns/zone/update/update_test.go b/internal/cmd/dns/zone/update/update_test.go index 1be550af6..7b69c632c 100644 --- a/internal/cmd/dns/zone/update/update_test.go +++ b/internal/cmd/dns/zone/update/update_test.go @@ -286,7 +286,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/logme/credentials/create/create.go b/internal/cmd/logme/credentials/create/create.go index a07ad997e..7120d721f 100644 --- a/internal/cmd/logme/credentials/create/create.go +++ b/internal/cmd/logme/credentials/create/create.go @@ -44,7 +44,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -57,6 +57,7 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := logmeUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } @@ -104,16 +105,16 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), - HidePassword: flags.FlagToBoolValue(cmd, hidePasswordFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), + HidePassword: flags.FlagToBoolValue(p, cmd, hidePasswordFlag), }, nil } diff --git a/internal/cmd/logme/credentials/create/create_test.go b/internal/cmd/logme/credentials/create/create_test.go index 504c90265..2c9f98043 100644 --- a/internal/cmd/logme/credentials/create/create_test.go +++ b/internal/cmd/logme/credentials/create/create_test.go @@ -142,7 +142,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/logme/credentials/delete/delete.go b/internal/cmd/logme/credentials/delete/delete.go index d6d5f0b8c..8bd9c1796 100644 --- a/internal/cmd/logme/credentials/delete/delete.go +++ b/internal/cmd/logme/credentials/delete/delete.go @@ -43,7 +43,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -56,11 +56,13 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := logmeUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } credentialsLabel, err := logmeUtils.GetCredentialsUsername(ctx, apiClient, model.ProjectId, model.InstanceId, model.CredentialsId) if err != nil { + p.Debug(print.ErrorLevel, "get credentials username: %v", err) credentialsLabel = model.CredentialsId } @@ -94,17 +96,17 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { credentialsId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), CredentialsId: credentialsId, }, nil } diff --git a/internal/cmd/logme/credentials/delete/delete_test.go b/internal/cmd/logme/credentials/delete/delete_test.go index 0ed08ed98..e4f34b0d9 100644 --- a/internal/cmd/logme/credentials/delete/delete_test.go +++ b/internal/cmd/logme/credentials/delete/delete_test.go @@ -195,7 +195,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/logme/credentials/describe/describe.go b/internal/cmd/logme/credentials/describe/describe.go index c9715adf7..9db1d99eb 100644 --- a/internal/cmd/logme/credentials/describe/describe.go +++ b/internal/cmd/logme/credentials/describe/describe.go @@ -47,7 +47,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -79,17 +79,17 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { credentialsId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), CredentialsId: credentialsId, }, nil } diff --git a/internal/cmd/logme/credentials/describe/describe_test.go b/internal/cmd/logme/credentials/describe/describe_test.go index 4cecdaad2..50bd2d768 100644 --- a/internal/cmd/logme/credentials/describe/describe_test.go +++ b/internal/cmd/logme/credentials/describe/describe_test.go @@ -195,7 +195,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/logme/credentials/list/list.go b/internal/cmd/logme/credentials/list/list.go index d40810424..9ed4d0e33 100644 --- a/internal/cmd/logme/credentials/list/list.go +++ b/internal/cmd/logme/credentials/list/list.go @@ -49,7 +49,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -70,6 +70,7 @@ func NewCmd(p *print.Printer) *cobra.Command { if len(credentials) == 0 { instanceLabel, err := logmeUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } p.Info("No credentials found for instance %q\n", instanceLabel) @@ -95,13 +96,13 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, @@ -111,7 +112,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), Limit: limit, }, nil } diff --git a/internal/cmd/logme/credentials/list/list_test.go b/internal/cmd/logme/credentials/list/list_test.go index 5b6737330..2d37db4cb 100644 --- a/internal/cmd/logme/credentials/list/list_test.go +++ b/internal/cmd/logme/credentials/list/list_test.go @@ -159,7 +159,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/logme/instance/create/create.go b/internal/cmd/logme/instance/create/create.go index 95f54ce97..472eb4f0e 100644 --- a/internal/cmd/logme/instance/create/create.go +++ b/internal/cmd/logme/instance/create/create.go @@ -72,7 +72,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -83,8 +83,9 @@ func NewCmd(p *print.Printer) *cobra.Command { return err } - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } @@ -151,15 +152,15 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &cliErr.ProjectIdError{} } - planId := flags.FlagToStringPointer(cmd, planIdFlag) - planName := flags.FlagToStringValue(cmd, planNameFlag) - version := flags.FlagToStringValue(cmd, versionFlag) + planId := flags.FlagToStringPointer(p, cmd, planIdFlag) + planName := flags.FlagToStringValue(p, cmd, planNameFlag) + version := flags.FlagToStringValue(p, cmd, versionFlag) if planId == nil && (planName == "" || version == "") { return nil, &cliErr.DSAInputPlanError{ @@ -174,14 +175,14 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - InstanceName: flags.FlagToStringPointer(cmd, instanceNameFlag), - EnableMonitoring: flags.FlagToBoolPointer(cmd, enableMonitoringFlag), - MonitoringInstanceId: flags.FlagToStringPointer(cmd, monitoringInstanceIdFlag), - Graphite: flags.FlagToStringPointer(cmd, graphiteFlag), - MetricsFrequency: flags.FlagToInt64Pointer(cmd, metricsFrequencyFlag), - MetricsPrefix: flags.FlagToStringPointer(cmd, metricsPrefixFlag), - SgwAcl: flags.FlagToStringSlicePointer(cmd, sgwAclFlag), - Syslog: flags.FlagToStringSlicePointer(cmd, syslogFlag), + InstanceName: flags.FlagToStringPointer(p, cmd, instanceNameFlag), + EnableMonitoring: flags.FlagToBoolPointer(p, cmd, enableMonitoringFlag), + MonitoringInstanceId: flags.FlagToStringPointer(p, cmd, monitoringInstanceIdFlag), + Graphite: flags.FlagToStringPointer(p, cmd, graphiteFlag), + MetricsFrequency: flags.FlagToInt64Pointer(p, cmd, metricsFrequencyFlag), + MetricsPrefix: flags.FlagToStringPointer(p, cmd, metricsPrefixFlag), + SgwAcl: flags.FlagToStringSlicePointer(p, cmd, sgwAclFlag), + Syslog: flags.FlagToStringSlicePointer(p, cmd, syslogFlag), PlanId: planId, PlanName: planName, Version: version, diff --git a/internal/cmd/logme/instance/create/create_test.go b/internal/cmd/logme/instance/create/create_test.go index edd375e45..992fe1cf1 100644 --- a/internal/cmd/logme/instance/create/create_test.go +++ b/internal/cmd/logme/instance/create/create_test.go @@ -304,7 +304,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/logme/instance/delete/delete.go b/internal/cmd/logme/instance/delete/delete.go index c3b7cd837..9c1c2529d 100644 --- a/internal/cmd/logme/instance/delete/delete.go +++ b/internal/cmd/logme/instance/delete/delete.go @@ -41,7 +41,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -54,6 +54,7 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := logmeUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } @@ -94,10 +95,10 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { instanceId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/logme/instance/delete/delete_test.go b/internal/cmd/logme/instance/delete/delete_test.go index 82ae2cb94..ae3003792 100644 --- a/internal/cmd/logme/instance/delete/delete_test.go +++ b/internal/cmd/logme/instance/delete/delete_test.go @@ -168,7 +168,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/logme/instance/describe/describe.go b/internal/cmd/logme/instance/describe/describe.go index 28dd148ef..234e57789 100644 --- a/internal/cmd/logme/instance/describe/describe.go +++ b/internal/cmd/logme/instance/describe/describe.go @@ -45,7 +45,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -68,10 +68,10 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { instanceId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/logme/instance/describe/describe_test.go b/internal/cmd/logme/instance/describe/describe_test.go index 2dd60d3ce..c2b754501 100644 --- a/internal/cmd/logme/instance/describe/describe_test.go +++ b/internal/cmd/logme/instance/describe/describe_test.go @@ -168,7 +168,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/logme/instance/list/list.go b/internal/cmd/logme/instance/list/list.go index 12f85d8e1..b736e2f77 100644 --- a/internal/cmd/logme/instance/list/list.go +++ b/internal/cmd/logme/instance/list/list.go @@ -47,7 +47,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -66,8 +66,9 @@ func NewCmd(p *print.Printer) *cobra.Command { } instances := *resp.Instances if len(instances) == 0 { - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } p.Info("No instances found for project %q\n", projectLabel) @@ -91,13 +92,13 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().Int64(limitFlag, 0, "Maximum number of entries to list") } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, @@ -107,7 +108,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - Limit: flags.FlagToInt64Pointer(cmd, limitFlag), + Limit: flags.FlagToInt64Pointer(p, cmd, limitFlag), }, nil } diff --git a/internal/cmd/logme/instance/list/list_test.go b/internal/cmd/logme/instance/list/list_test.go index a2be6bda6..87f13143f 100644 --- a/internal/cmd/logme/instance/list/list_test.go +++ b/internal/cmd/logme/instance/list/list_test.go @@ -138,7 +138,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/logme/instance/update/update.go b/internal/cmd/logme/instance/update/update.go index b997f22ae..f87e343f8 100644 --- a/internal/cmd/logme/instance/update/update.go +++ b/internal/cmd/logme/instance/update/update.go @@ -71,7 +71,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -84,6 +84,7 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := logmeUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } @@ -146,24 +147,24 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().String(versionFlag, "", "Instance LogMe version") } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { instanceId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &cliErr.ProjectIdError{} } - enableMonitoring := flags.FlagToBoolPointer(cmd, enableMonitoringFlag) - monitoringInstanceId := flags.FlagToStringPointer(cmd, monitoringInstanceIdFlag) - graphite := flags.FlagToStringPointer(cmd, graphiteFlag) - metricsFrequency := flags.FlagToInt64Pointer(cmd, metricsFrequencyFlag) - metricsPrefix := flags.FlagToStringPointer(cmd, metricsPrefixFlag) - sgwAcl := flags.FlagToStringSlicePointer(cmd, sgwAclFlag) - syslog := flags.FlagToStringSlicePointer(cmd, syslogFlag) - planId := flags.FlagToStringPointer(cmd, planIdFlag) - planName := flags.FlagToStringValue(cmd, planNameFlag) - version := flags.FlagToStringValue(cmd, versionFlag) + enableMonitoring := flags.FlagToBoolPointer(p, cmd, enableMonitoringFlag) + monitoringInstanceId := flags.FlagToStringPointer(p, cmd, monitoringInstanceIdFlag) + graphite := flags.FlagToStringPointer(p, cmd, graphiteFlag) + metricsFrequency := flags.FlagToInt64Pointer(p, cmd, metricsFrequencyFlag) + metricsPrefix := flags.FlagToStringPointer(p, cmd, metricsPrefixFlag) + sgwAcl := flags.FlagToStringSlicePointer(p, cmd, sgwAclFlag) + syslog := flags.FlagToStringSlicePointer(p, cmd, syslogFlag) + planId := flags.FlagToStringPointer(p, cmd, planIdFlag) + planName := flags.FlagToStringValue(p, cmd, planNameFlag) + version := flags.FlagToStringValue(p, cmd, versionFlag) if planId != nil && (planName != "" || version != "") { return nil, &cliErr.DSAInputPlanError{ diff --git a/internal/cmd/logme/instance/update/update_test.go b/internal/cmd/logme/instance/update/update_test.go index 2ecb84564..42071149a 100644 --- a/internal/cmd/logme/instance/update/update_test.go +++ b/internal/cmd/logme/instance/update/update_test.go @@ -317,7 +317,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/logme/plans/plans.go b/internal/cmd/logme/plans/plans.go index 652178444..c1ac1b2d5 100644 --- a/internal/cmd/logme/plans/plans.go +++ b/internal/cmd/logme/plans/plans.go @@ -47,7 +47,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -66,8 +66,9 @@ func NewCmd(p *print.Printer) *cobra.Command { } plans := *resp.Offerings if len(plans) == 0 { - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } p.Info("No plans found for project %q\n", projectLabel) @@ -91,13 +92,13 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().Int64(limitFlag, 0, "Maximum number of entries to list") } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, diff --git a/internal/cmd/logme/plans/plans_test.go b/internal/cmd/logme/plans/plans_test.go index 032fac61c..93c8998ca 100644 --- a/internal/cmd/logme/plans/plans_test.go +++ b/internal/cmd/logme/plans/plans_test.go @@ -138,7 +138,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/mariadb/credentials/create/create.go b/internal/cmd/mariadb/credentials/create/create.go index 0df6ea069..122bef421 100644 --- a/internal/cmd/mariadb/credentials/create/create.go +++ b/internal/cmd/mariadb/credentials/create/create.go @@ -44,7 +44,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -57,6 +57,7 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := mariadbUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } @@ -104,16 +105,16 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), - HidePassword: flags.FlagToBoolValue(cmd, hidePasswordFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), + HidePassword: flags.FlagToBoolValue(p, cmd, hidePasswordFlag), }, nil } diff --git a/internal/cmd/mariadb/credentials/create/create_test.go b/internal/cmd/mariadb/credentials/create/create_test.go index 3676ee551..2e19c4481 100644 --- a/internal/cmd/mariadb/credentials/create/create_test.go +++ b/internal/cmd/mariadb/credentials/create/create_test.go @@ -142,7 +142,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/mariadb/credentials/delete/delete.go b/internal/cmd/mariadb/credentials/delete/delete.go index d1df164d0..281cd58dd 100644 --- a/internal/cmd/mariadb/credentials/delete/delete.go +++ b/internal/cmd/mariadb/credentials/delete/delete.go @@ -43,7 +43,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -56,11 +56,13 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := mariadbUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } credentialsLabel, err := mariadbUtils.GetCredentialsUsername(ctx, apiClient, model.ProjectId, model.InstanceId, model.CredentialsId) if err != nil { + p.Debug(print.ErrorLevel, "get credentials username: %v", err) credentialsLabel = model.CredentialsId } @@ -94,17 +96,17 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { credentialsId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), CredentialsId: credentialsId, }, nil } diff --git a/internal/cmd/mariadb/credentials/delete/delete_test.go b/internal/cmd/mariadb/credentials/delete/delete_test.go index 8834de487..a9cd5d494 100644 --- a/internal/cmd/mariadb/credentials/delete/delete_test.go +++ b/internal/cmd/mariadb/credentials/delete/delete_test.go @@ -195,7 +195,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/mariadb/credentials/describe/describe.go b/internal/cmd/mariadb/credentials/describe/describe.go index 13b3ee2be..12c4634a4 100644 --- a/internal/cmd/mariadb/credentials/describe/describe.go +++ b/internal/cmd/mariadb/credentials/describe/describe.go @@ -47,7 +47,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -79,17 +79,17 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { credentialsId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), CredentialsId: credentialsId, }, nil } diff --git a/internal/cmd/mariadb/credentials/describe/describe_test.go b/internal/cmd/mariadb/credentials/describe/describe_test.go index 717238033..a77a1cf1b 100644 --- a/internal/cmd/mariadb/credentials/describe/describe_test.go +++ b/internal/cmd/mariadb/credentials/describe/describe_test.go @@ -195,7 +195,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/mariadb/credentials/list/list.go b/internal/cmd/mariadb/credentials/list/list.go index b394e7720..9c211102a 100644 --- a/internal/cmd/mariadb/credentials/list/list.go +++ b/internal/cmd/mariadb/credentials/list/list.go @@ -49,7 +49,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -70,6 +70,7 @@ func NewCmd(p *print.Printer) *cobra.Command { if len(credentials) == 0 { instanceLabel, err := mariadbUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } p.Info("No credentials found for instance %q\n", instanceLabel) @@ -95,13 +96,13 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, @@ -111,7 +112,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), Limit: limit, }, nil } diff --git a/internal/cmd/mariadb/credentials/list/list_test.go b/internal/cmd/mariadb/credentials/list/list_test.go index 5531af98b..920c7ad0e 100644 --- a/internal/cmd/mariadb/credentials/list/list_test.go +++ b/internal/cmd/mariadb/credentials/list/list_test.go @@ -159,7 +159,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/mariadb/instance/create/create.go b/internal/cmd/mariadb/instance/create/create.go index 5a4a84455..2b0b4e3ef 100644 --- a/internal/cmd/mariadb/instance/create/create.go +++ b/internal/cmd/mariadb/instance/create/create.go @@ -72,7 +72,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -83,8 +83,9 @@ func NewCmd(p *print.Printer) *cobra.Command { return err } - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } @@ -151,15 +152,15 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &cliErr.ProjectIdError{} } - planId := flags.FlagToStringPointer(cmd, planIdFlag) - planName := flags.FlagToStringValue(cmd, planNameFlag) - version := flags.FlagToStringValue(cmd, versionFlag) + planId := flags.FlagToStringPointer(p, cmd, planIdFlag) + planName := flags.FlagToStringValue(p, cmd, planNameFlag) + version := flags.FlagToStringValue(p, cmd, versionFlag) if planId == nil && (planName == "" || version == "") { return nil, &cliErr.DSAInputPlanError{ @@ -174,14 +175,14 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - InstanceName: flags.FlagToStringPointer(cmd, instanceNameFlag), - EnableMonitoring: flags.FlagToBoolPointer(cmd, enableMonitoringFlag), - MonitoringInstanceId: flags.FlagToStringPointer(cmd, monitoringInstanceIdFlag), - Graphite: flags.FlagToStringPointer(cmd, graphiteFlag), - MetricsFrequency: flags.FlagToInt64Pointer(cmd, metricsFrequencyFlag), - MetricsPrefix: flags.FlagToStringPointer(cmd, metricsPrefixFlag), - SgwAcl: flags.FlagToStringSlicePointer(cmd, sgwAclFlag), - Syslog: flags.FlagToStringSlicePointer(cmd, syslogFlag), + InstanceName: flags.FlagToStringPointer(p, cmd, instanceNameFlag), + EnableMonitoring: flags.FlagToBoolPointer(p, cmd, enableMonitoringFlag), + MonitoringInstanceId: flags.FlagToStringPointer(p, cmd, monitoringInstanceIdFlag), + Graphite: flags.FlagToStringPointer(p, cmd, graphiteFlag), + MetricsFrequency: flags.FlagToInt64Pointer(p, cmd, metricsFrequencyFlag), + MetricsPrefix: flags.FlagToStringPointer(p, cmd, metricsPrefixFlag), + SgwAcl: flags.FlagToStringSlicePointer(p, cmd, sgwAclFlag), + Syslog: flags.FlagToStringSlicePointer(p, cmd, syslogFlag), PlanId: planId, PlanName: planName, Version: version, diff --git a/internal/cmd/mariadb/instance/create/create_test.go b/internal/cmd/mariadb/instance/create/create_test.go index e6c370f88..7cf5f71c9 100644 --- a/internal/cmd/mariadb/instance/create/create_test.go +++ b/internal/cmd/mariadb/instance/create/create_test.go @@ -304,7 +304,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/mariadb/instance/delete/delete.go b/internal/cmd/mariadb/instance/delete/delete.go index c52138e67..32d479bb5 100644 --- a/internal/cmd/mariadb/instance/delete/delete.go +++ b/internal/cmd/mariadb/instance/delete/delete.go @@ -41,7 +41,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -54,6 +54,7 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := mariadbUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } @@ -94,10 +95,10 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { instanceId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/mariadb/instance/delete/delete_test.go b/internal/cmd/mariadb/instance/delete/delete_test.go index f1b99b143..d6dcab972 100644 --- a/internal/cmd/mariadb/instance/delete/delete_test.go +++ b/internal/cmd/mariadb/instance/delete/delete_test.go @@ -168,7 +168,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/mariadb/instance/describe/describe.go b/internal/cmd/mariadb/instance/describe/describe.go index 6a93d6a3d..33b691e2a 100644 --- a/internal/cmd/mariadb/instance/describe/describe.go +++ b/internal/cmd/mariadb/instance/describe/describe.go @@ -45,7 +45,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -68,10 +68,10 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { instanceId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/mariadb/instance/describe/describe_test.go b/internal/cmd/mariadb/instance/describe/describe_test.go index db3aa4ac7..78318a869 100644 --- a/internal/cmd/mariadb/instance/describe/describe_test.go +++ b/internal/cmd/mariadb/instance/describe/describe_test.go @@ -168,7 +168,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/mariadb/instance/list/list.go b/internal/cmd/mariadb/instance/list/list.go index 5bf143ec5..d2dc0db0a 100644 --- a/internal/cmd/mariadb/instance/list/list.go +++ b/internal/cmd/mariadb/instance/list/list.go @@ -47,7 +47,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -66,8 +66,9 @@ func NewCmd(p *print.Printer) *cobra.Command { } instances := *resp.Instances if len(instances) == 0 { - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } p.Info("No instances found for project %q\n", projectLabel) @@ -91,13 +92,13 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().Int64(limitFlag, 0, "Maximum number of entries to list") } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, @@ -107,7 +108,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - Limit: flags.FlagToInt64Pointer(cmd, limitFlag), + Limit: flags.FlagToInt64Pointer(p, cmd, limitFlag), }, nil } diff --git a/internal/cmd/mariadb/instance/list/list_test.go b/internal/cmd/mariadb/instance/list/list_test.go index 10dd9fd94..eb0dbba72 100644 --- a/internal/cmd/mariadb/instance/list/list_test.go +++ b/internal/cmd/mariadb/instance/list/list_test.go @@ -138,7 +138,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/mariadb/instance/update/update.go b/internal/cmd/mariadb/instance/update/update.go index d2ac7ae8b..f22ae7863 100644 --- a/internal/cmd/mariadb/instance/update/update.go +++ b/internal/cmd/mariadb/instance/update/update.go @@ -70,7 +70,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -83,6 +83,7 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := mariadbUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } @@ -145,24 +146,24 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().String(versionFlag, "", "Instance MariaDB version") } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { instanceId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &cliErr.ProjectIdError{} } - enableMonitoring := flags.FlagToBoolPointer(cmd, enableMonitoringFlag) - monitoringInstanceId := flags.FlagToStringPointer(cmd, monitoringInstanceIdFlag) - graphite := flags.FlagToStringPointer(cmd, graphiteFlag) - metricsFrequency := flags.FlagToInt64Pointer(cmd, metricsFrequencyFlag) - metricsPrefix := flags.FlagToStringPointer(cmd, metricsPrefixFlag) - sgwAcl := flags.FlagToStringSlicePointer(cmd, sgwAclFlag) - syslog := flags.FlagToStringSlicePointer(cmd, syslogFlag) - planId := flags.FlagToStringPointer(cmd, planIdFlag) - planName := flags.FlagToStringValue(cmd, planNameFlag) - version := flags.FlagToStringValue(cmd, versionFlag) + enableMonitoring := flags.FlagToBoolPointer(p, cmd, enableMonitoringFlag) + monitoringInstanceId := flags.FlagToStringPointer(p, cmd, monitoringInstanceIdFlag) + graphite := flags.FlagToStringPointer(p, cmd, graphiteFlag) + metricsFrequency := flags.FlagToInt64Pointer(p, cmd, metricsFrequencyFlag) + metricsPrefix := flags.FlagToStringPointer(p, cmd, metricsPrefixFlag) + sgwAcl := flags.FlagToStringSlicePointer(p, cmd, sgwAclFlag) + syslog := flags.FlagToStringSlicePointer(p, cmd, syslogFlag) + planId := flags.FlagToStringPointer(p, cmd, planIdFlag) + planName := flags.FlagToStringValue(p, cmd, planNameFlag) + version := flags.FlagToStringValue(p, cmd, versionFlag) if planId != nil && (planName != "" || version != "") { return nil, &cliErr.DSAInputPlanError{ diff --git a/internal/cmd/mariadb/instance/update/update_test.go b/internal/cmd/mariadb/instance/update/update_test.go index 28ffe9200..66b7367cc 100644 --- a/internal/cmd/mariadb/instance/update/update_test.go +++ b/internal/cmd/mariadb/instance/update/update_test.go @@ -328,7 +328,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/mariadb/plans/plans.go b/internal/cmd/mariadb/plans/plans.go index a567c0b51..5e3c3ae3e 100644 --- a/internal/cmd/mariadb/plans/plans.go +++ b/internal/cmd/mariadb/plans/plans.go @@ -47,7 +47,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -66,8 +66,9 @@ func NewCmd(p *print.Printer) *cobra.Command { } plans := *resp.Offerings if len(plans) == 0 { - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } p.Info("No plans found for project %q\n", projectLabel) @@ -91,13 +92,13 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().Int64(limitFlag, 0, "Maximum number of entries to list") } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, diff --git a/internal/cmd/mariadb/plans/plans_test.go b/internal/cmd/mariadb/plans/plans_test.go index fe38082b0..55922c28c 100644 --- a/internal/cmd/mariadb/plans/plans_test.go +++ b/internal/cmd/mariadb/plans/plans_test.go @@ -138,7 +138,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/mongodbflex/instance/create/create.go b/internal/cmd/mongodbflex/instance/create/create.go index 3f28f243b..91b2178f8 100644 --- a/internal/cmd/mongodbflex/instance/create/create.go +++ b/internal/cmd/mongodbflex/instance/create/create.go @@ -75,7 +75,7 @@ func NewCmd(p *print.Printer) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -86,8 +86,9 @@ func NewCmd(p *print.Printer) *cobra.Command { return err } - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } @@ -160,17 +161,17 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &cliErr.ProjectIdError{} } - storageSize := flags.FlagWithDefaultToInt64Value(cmd, storageSizeFlag) + storageSize := flags.FlagWithDefaultToInt64Value(p, cmd, storageSizeFlag) - flavorId := flags.FlagToStringPointer(cmd, flavorIdFlag) - cpu := flags.FlagToInt64Pointer(cmd, cpuFlag) - ram := flags.FlagToInt64Pointer(cmd, ramFlag) + flavorId := flags.FlagToStringPointer(p, cmd, flavorIdFlag) + cpu := flags.FlagToInt64Pointer(p, cmd, cpuFlag) + ram := flags.FlagToInt64Pointer(p, cmd, ramFlag) if flavorId == nil && (cpu == nil || ram == nil) { return nil, &cliErr.DatabaseInputFlavorError{ @@ -185,16 +186,16 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - InstanceName: flags.FlagToStringPointer(cmd, instanceNameFlag), - ACL: flags.FlagToStringSlicePointer(cmd, aclFlag), - BackupSchedule: utils.Ptr(flags.FlagWithDefaultToStringValue(cmd, backupScheduleFlag)), + InstanceName: flags.FlagToStringPointer(p, cmd, instanceNameFlag), + ACL: flags.FlagToStringSlicePointer(p, cmd, aclFlag), + BackupSchedule: utils.Ptr(flags.FlagWithDefaultToStringValue(p, cmd, backupScheduleFlag)), FlavorId: flavorId, CPU: cpu, RAM: ram, - StorageClass: utils.Ptr(flags.FlagWithDefaultToStringValue(cmd, storageClassFlag)), + StorageClass: utils.Ptr(flags.FlagWithDefaultToStringValue(p, cmd, storageClassFlag)), StorageSize: &storageSize, - Version: flags.FlagToStringPointer(cmd, versionFlag), - Type: utils.Ptr(flags.FlagWithDefaultToStringValue(cmd, typeFlag)), + Version: flags.FlagToStringPointer(p, cmd, versionFlag), + Type: utils.Ptr(flags.FlagWithDefaultToStringValue(p, cmd, typeFlag)), }, nil } diff --git a/internal/cmd/mongodbflex/instance/create/create_test.go b/internal/cmd/mongodbflex/instance/create/create_test.go index d3dfacad3..ac3c1191e 100644 --- a/internal/cmd/mongodbflex/instance/create/create_test.go +++ b/internal/cmd/mongodbflex/instance/create/create_test.go @@ -282,7 +282,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/mongodbflex/instance/delete/delete.go b/internal/cmd/mongodbflex/instance/delete/delete.go index 9a832524d..aa06c298d 100644 --- a/internal/cmd/mongodbflex/instance/delete/delete.go +++ b/internal/cmd/mongodbflex/instance/delete/delete.go @@ -41,7 +41,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -54,6 +54,7 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := mongodbflexUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } @@ -94,10 +95,10 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { instanceId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/mongodbflex/instance/delete/delete_test.go b/internal/cmd/mongodbflex/instance/delete/delete_test.go index 2a2d3f2e2..7eb0205e6 100644 --- a/internal/cmd/mongodbflex/instance/delete/delete_test.go +++ b/internal/cmd/mongodbflex/instance/delete/delete_test.go @@ -168,7 +168,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/mongodbflex/instance/describe/describe.go b/internal/cmd/mongodbflex/instance/describe/describe.go index f45ef1466..09406fdcd 100644 --- a/internal/cmd/mongodbflex/instance/describe/describe.go +++ b/internal/cmd/mongodbflex/instance/describe/describe.go @@ -45,7 +45,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -68,10 +68,10 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { instanceId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/mongodbflex/instance/describe/describe_test.go b/internal/cmd/mongodbflex/instance/describe/describe_test.go index bbc76890e..a1e1a1441 100644 --- a/internal/cmd/mongodbflex/instance/describe/describe_test.go +++ b/internal/cmd/mongodbflex/instance/describe/describe_test.go @@ -168,7 +168,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/mongodbflex/instance/list/list.go b/internal/cmd/mongodbflex/instance/list/list.go index 8a25f6c0d..b452ea592 100644 --- a/internal/cmd/mongodbflex/instance/list/list.go +++ b/internal/cmd/mongodbflex/instance/list/list.go @@ -47,7 +47,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -65,8 +65,9 @@ func NewCmd(p *print.Printer) *cobra.Command { return fmt.Errorf("get MongoDB Flex instances: %w", err) } if resp.Items == nil || len(*resp.Items) == 0 { - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } p.Info("No instances found for project %q\n", projectLabel) @@ -91,13 +92,13 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().Int64(limitFlag, 0, "Maximum number of entries to list") } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, diff --git a/internal/cmd/mongodbflex/instance/list/list_test.go b/internal/cmd/mongodbflex/instance/list/list_test.go index eef3a67b0..d124e9906 100644 --- a/internal/cmd/mongodbflex/instance/list/list_test.go +++ b/internal/cmd/mongodbflex/instance/list/list_test.go @@ -138,7 +138,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/mongodbflex/instance/update/update.go b/internal/cmd/mongodbflex/instance/update/update.go index c7cd7040b..69ae210d5 100644 --- a/internal/cmd/mongodbflex/instance/update/update.go +++ b/internal/cmd/mongodbflex/instance/update/update.go @@ -69,7 +69,7 @@ func NewCmd(p *print.Printer) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -82,6 +82,7 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := mongodbflexUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } @@ -142,24 +143,24 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().Var(flags.EnumFlag(false, "", typeFlagOptions...), typeFlag, fmt.Sprintf("Instance type, one of %q", typeFlagOptions)) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { instanceId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &cliErr.ProjectIdError{} } - instanceName := flags.FlagToStringPointer(cmd, instanceNameFlag) - flavorId := flags.FlagToStringPointer(cmd, flavorIdFlag) - cpu := flags.FlagToInt64Pointer(cmd, cpuFlag) - ram := flags.FlagToInt64Pointer(cmd, ramFlag) - acl := flags.FlagToStringSlicePointer(cmd, aclFlag) - backupSchedule := flags.FlagToStringPointer(cmd, backupScheduleFlag) - storageClass := flags.FlagToStringPointer(cmd, storageClassFlag) - storageSize := flags.FlagToInt64Pointer(cmd, storageSizeFlag) - version := flags.FlagToStringPointer(cmd, versionFlag) - instanceType := flags.FlagToStringPointer(cmd, typeFlag) + instanceName := flags.FlagToStringPointer(p, cmd, instanceNameFlag) + flavorId := flags.FlagToStringPointer(p, cmd, flavorIdFlag) + cpu := flags.FlagToInt64Pointer(p, cmd, cpuFlag) + ram := flags.FlagToInt64Pointer(p, cmd, ramFlag) + acl := flags.FlagToStringSlicePointer(p, cmd, aclFlag) + backupSchedule := flags.FlagToStringPointer(p, cmd, backupScheduleFlag) + storageClass := flags.FlagToStringPointer(p, cmd, storageClassFlag) + storageSize := flags.FlagToInt64Pointer(p, cmd, storageSizeFlag) + version := flags.FlagToStringPointer(p, cmd, versionFlag) + instanceType := flags.FlagToStringPointer(p, cmd, typeFlag) if instanceName == nil && flavorId == nil && cpu == nil && ram == nil && acl == nil && backupSchedule == nil && storageClass == nil && storageSize == nil && version == nil && instanceType == nil { diff --git a/internal/cmd/mongodbflex/instance/update/update_test.go b/internal/cmd/mongodbflex/instance/update/update_test.go index 9fc3670a4..6046ebf16 100644 --- a/internal/cmd/mongodbflex/instance/update/update_test.go +++ b/internal/cmd/mongodbflex/instance/update/update_test.go @@ -320,7 +320,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/mongodbflex/options/options.go b/internal/cmd/mongodbflex/options/options.go index 23bb7f1e1..d590cc8e9 100644 --- a/internal/cmd/mongodbflex/options/options.go +++ b/internal/cmd/mongodbflex/options/options.go @@ -64,7 +64,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -95,12 +95,12 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().String(flavorIdFlag, "", `The flavor ID to show storages for. Only relevant when "--storages" is passed`) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) - flavors := flags.FlagToBoolValue(cmd, flavorsFlag) - versions := flags.FlagToBoolValue(cmd, versionsFlag) - storages := flags.FlagToBoolValue(cmd, storagesFlag) - flavorId := flags.FlagToStringPointer(cmd, flavorIdFlag) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) + flavors := flags.FlagToBoolValue(p, cmd, flavorsFlag) + versions := flags.FlagToBoolValue(p, cmd, versionsFlag) + storages := flags.FlagToBoolValue(p, cmd, storagesFlag) + flavorId := flags.FlagToStringPointer(p, cmd, flavorIdFlag) if !flavors && !versions && !storages { return nil, fmt.Errorf("%s\n\n%s", @@ -120,7 +120,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { Flavors: flavors, Versions: versions, Storages: storages, - FlavorId: flags.FlagToStringPointer(cmd, flavorIdFlag), + FlavorId: flags.FlagToStringPointer(p, cmd, flavorIdFlag), }, nil } diff --git a/internal/cmd/mongodbflex/options/options_test.go b/internal/cmd/mongodbflex/options/options_test.go index 812ee8359..465d72845 100644 --- a/internal/cmd/mongodbflex/options/options_test.go +++ b/internal/cmd/mongodbflex/options/options_test.go @@ -190,7 +190,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/mongodbflex/user/create/create.go b/internal/cmd/mongodbflex/user/create/create.go index 5540487cf..27825a5f0 100644 --- a/internal/cmd/mongodbflex/user/create/create.go +++ b/internal/cmd/mongodbflex/user/create/create.go @@ -58,7 +58,7 @@ func NewCmd(p *print.Printer) *cobra.Command { Args: args.NoArgs, RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -71,6 +71,7 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := mongodbflexUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } @@ -119,18 +120,18 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), - Username: flags.FlagToStringPointer(cmd, usernameFlag), - Database: flags.FlagToStringPointer(cmd, databaseFlag), - Roles: flags.FlagWithDefaultToStringSlicePointer(cmd, roleFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), + Username: flags.FlagToStringPointer(p, cmd, usernameFlag), + Database: flags.FlagToStringPointer(p, cmd, databaseFlag), + Roles: flags.FlagWithDefaultToStringSlicePointer(p, cmd, roleFlag), }, nil } diff --git a/internal/cmd/mongodbflex/user/create/create_test.go b/internal/cmd/mongodbflex/user/create/create_test.go index 2165b3b77..dc39200d1 100644 --- a/internal/cmd/mongodbflex/user/create/create_test.go +++ b/internal/cmd/mongodbflex/user/create/create_test.go @@ -186,7 +186,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/mongodbflex/user/delete/delete.go b/internal/cmd/mongodbflex/user/delete/delete.go index 84d31d7cb..75a04ad57 100644 --- a/internal/cmd/mongodbflex/user/delete/delete.go +++ b/internal/cmd/mongodbflex/user/delete/delete.go @@ -47,7 +47,7 @@ func NewCmd(p *print.Printer) *cobra.Command { Args: args.SingleArg(userIdArg, utils.ValidateUUID), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -60,11 +60,13 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := mongodbflexUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } userLabel, err := mongodbflexUtils.GetUserName(ctx, apiClient, model.ProjectId, model.InstanceId, model.UserId) if err != nil { + p.Debug(print.ErrorLevel, "get user name: %v", err) userLabel = model.UserId } @@ -98,17 +100,17 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { userId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), UserId: userId, }, nil } diff --git a/internal/cmd/mongodbflex/user/delete/delete_test.go b/internal/cmd/mongodbflex/user/delete/delete_test.go index 7fd731c07..39661d8cc 100644 --- a/internal/cmd/mongodbflex/user/delete/delete_test.go +++ b/internal/cmd/mongodbflex/user/delete/delete_test.go @@ -195,7 +195,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/mongodbflex/user/describe/describe.go b/internal/cmd/mongodbflex/user/describe/describe.go index 24b3eefc7..12f694d02 100644 --- a/internal/cmd/mongodbflex/user/describe/describe.go +++ b/internal/cmd/mongodbflex/user/describe/describe.go @@ -52,7 +52,7 @@ func NewCmd(p *print.Printer) *cobra.Command { Args: args.SingleArg(userIdArg, utils.ValidateUUID), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -85,17 +85,17 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { userId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), UserId: userId, }, nil } diff --git a/internal/cmd/mongodbflex/user/describe/describe_test.go b/internal/cmd/mongodbflex/user/describe/describe_test.go index 47a913f80..5af263323 100644 --- a/internal/cmd/mongodbflex/user/describe/describe_test.go +++ b/internal/cmd/mongodbflex/user/describe/describe_test.go @@ -195,7 +195,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/mongodbflex/user/list/list.go b/internal/cmd/mongodbflex/user/list/list.go index 43288df6c..6f4082375 100644 --- a/internal/cmd/mongodbflex/user/list/list.go +++ b/internal/cmd/mongodbflex/user/list/list.go @@ -50,7 +50,7 @@ func NewCmd(p *print.Printer) *cobra.Command { Args: args.NoArgs, RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -70,6 +70,7 @@ func NewCmd(p *print.Printer) *cobra.Command { if resp.Items == nil || len(*resp.Items) == 0 { instanceLabel, err := mongodbflexUtils.GetInstanceName(ctx, apiClient, model.ProjectId, *model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = *model.InstanceId } p.Info("No users found for instance %q\n", instanceLabel) @@ -98,13 +99,13 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, @@ -114,8 +115,8 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringPointer(cmd, instanceIdFlag), - Limit: flags.FlagToInt64Pointer(cmd, limitFlag), + InstanceId: flags.FlagToStringPointer(p, cmd, instanceIdFlag), + Limit: flags.FlagToInt64Pointer(p, cmd, limitFlag), }, nil } diff --git a/internal/cmd/mongodbflex/user/list/list_test.go b/internal/cmd/mongodbflex/user/list/list_test.go index c4ac29db8..d574dd6cd 100644 --- a/internal/cmd/mongodbflex/user/list/list_test.go +++ b/internal/cmd/mongodbflex/user/list/list_test.go @@ -155,7 +155,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/mongodbflex/user/reset-password/reset_password.go b/internal/cmd/mongodbflex/user/reset-password/reset_password.go index f1faa7240..c9e60ec13 100644 --- a/internal/cmd/mongodbflex/user/reset-password/reset_password.go +++ b/internal/cmd/mongodbflex/user/reset-password/reset_password.go @@ -47,7 +47,7 @@ func NewCmd(p *print.Printer) *cobra.Command { Args: args.SingleArg(userIdArg, utils.ValidateUUID), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -60,11 +60,13 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := mongodbflexUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } userLabel, err := mongodbflexUtils.GetUserName(ctx, apiClient, model.ProjectId, model.InstanceId, model.UserId) if err != nil { + p.Debug(print.ErrorLevel, "get user name: %v", err) userLabel = model.UserId } @@ -102,17 +104,17 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { userId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), UserId: userId, }, nil } diff --git a/internal/cmd/mongodbflex/user/reset-password/reset_password_test.go b/internal/cmd/mongodbflex/user/reset-password/reset_password_test.go index 20c1fbff9..8b8fe5396 100644 --- a/internal/cmd/mongodbflex/user/reset-password/reset_password_test.go +++ b/internal/cmd/mongodbflex/user/reset-password/reset_password_test.go @@ -195,7 +195,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/mongodbflex/user/update/update.go b/internal/cmd/mongodbflex/user/update/update.go index a42abd00f..4fb202a74 100644 --- a/internal/cmd/mongodbflex/user/update/update.go +++ b/internal/cmd/mongodbflex/user/update/update.go @@ -48,7 +48,7 @@ func NewCmd(p *print.Printer) *cobra.Command { Args: args.SingleArg(userIdArg, utils.ValidateUUID), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -61,11 +61,13 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := mongodbflexUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } userLabel, err := mongodbflexUtils.GetUserName(ctx, apiClient, model.ProjectId, model.InstanceId, model.UserId) if err != nil { + p.Debug(print.ErrorLevel, "get user name: %v", err) userLabel = model.UserId } @@ -104,16 +106,16 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { userId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - database := flags.FlagToStringPointer(cmd, databaseFlag) - roles := flags.FlagToStringSlicePointer(cmd, roleFlag) + database := flags.FlagToStringPointer(p, cmd, databaseFlag) + roles := flags.FlagToStringSlicePointer(p, cmd, roleFlag) if database == nil && roles == nil { return nil, &errors.EmptyUpdateError{} @@ -121,7 +123,7 @@ func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), UserId: userId, Database: database, Roles: roles, diff --git a/internal/cmd/mongodbflex/user/update/update_test.go b/internal/cmd/mongodbflex/user/update/update_test.go index 6d4029141..74cb6b0c3 100644 --- a/internal/cmd/mongodbflex/user/update/update_test.go +++ b/internal/cmd/mongodbflex/user/update/update_test.go @@ -227,7 +227,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/object-storage/bucket/create/create.go b/internal/cmd/object-storage/bucket/create/create.go index 32aeb74dd..9409f257f 100644 --- a/internal/cmd/object-storage/bucket/create/create.go +++ b/internal/cmd/object-storage/bucket/create/create.go @@ -39,7 +39,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -87,10 +87,10 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { bucketName := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/object-storage/bucket/create/create_test.go b/internal/cmd/object-storage/bucket/create/create_test.go index 524091713..7cc4c915e 100644 --- a/internal/cmd/object-storage/bucket/create/create_test.go +++ b/internal/cmd/object-storage/bucket/create/create_test.go @@ -162,7 +162,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/object-storage/bucket/delete/delete.go b/internal/cmd/object-storage/bucket/delete/delete.go index 2b98854b0..53455aa93 100644 --- a/internal/cmd/object-storage/bucket/delete/delete.go +++ b/internal/cmd/object-storage/bucket/delete/delete.go @@ -39,7 +39,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -87,10 +87,10 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { bucketName := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/object-storage/bucket/delete/delete_test.go b/internal/cmd/object-storage/bucket/delete/delete_test.go index 3b2037735..f375e2931 100644 --- a/internal/cmd/object-storage/bucket/delete/delete_test.go +++ b/internal/cmd/object-storage/bucket/delete/delete_test.go @@ -162,7 +162,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/object-storage/bucket/describe/describe.go b/internal/cmd/object-storage/bucket/describe/describe.go index 9d95041b5..0fd768835 100644 --- a/internal/cmd/object-storage/bucket/describe/describe.go +++ b/internal/cmd/object-storage/bucket/describe/describe.go @@ -42,7 +42,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -65,10 +65,10 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { bucketName := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/object-storage/bucket/describe/describe_test.go b/internal/cmd/object-storage/bucket/describe/describe_test.go index e23245368..a852d16df 100644 --- a/internal/cmd/object-storage/bucket/describe/describe_test.go +++ b/internal/cmd/object-storage/bucket/describe/describe_test.go @@ -162,7 +162,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/object-storage/bucket/list/list.go b/internal/cmd/object-storage/bucket/list/list.go index e2f79f87a..678652fd3 100644 --- a/internal/cmd/object-storage/bucket/list/list.go +++ b/internal/cmd/object-storage/bucket/list/list.go @@ -47,7 +47,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -65,8 +65,9 @@ func NewCmd(p *print.Printer) *cobra.Command { return fmt.Errorf("get Object Storage buckets: %w", err) } if resp.Buckets == nil || len(*resp.Buckets) == 0 { - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } p.Info("No buckets found for project %s\n", projectLabel) @@ -91,13 +92,13 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().Int64(limitFlag, 0, "Maximum number of entries to list") } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, @@ -107,7 +108,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - Limit: flags.FlagToInt64Pointer(cmd, limitFlag), + Limit: flags.FlagToInt64Pointer(p, cmd, limitFlag), }, nil } diff --git a/internal/cmd/object-storage/bucket/list/list_test.go b/internal/cmd/object-storage/bucket/list/list_test.go index 7d83b76e0..d73f2e722 100644 --- a/internal/cmd/object-storage/bucket/list/list_test.go +++ b/internal/cmd/object-storage/bucket/list/list_test.go @@ -138,7 +138,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/object-storage/credentials-group/create/create.go b/internal/cmd/object-storage/credentials-group/create/create.go index 2dd24a759..1400289b5 100644 --- a/internal/cmd/object-storage/credentials-group/create/create.go +++ b/internal/cmd/object-storage/credentials-group/create/create.go @@ -39,7 +39,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -81,15 +81,15 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } return &inputModel{ GlobalFlagModel: globalFlags, - CredentialsGroupName: flags.FlagToStringValue(cmd, credentialsGroupNameFlag), + CredentialsGroupName: flags.FlagToStringValue(p, cmd, credentialsGroupNameFlag), }, nil } diff --git a/internal/cmd/object-storage/credentials-group/create/create_test.go b/internal/cmd/object-storage/credentials-group/create/create_test.go index 5b5fbc95a..2e014fe93 100644 --- a/internal/cmd/object-storage/credentials-group/create/create_test.go +++ b/internal/cmd/object-storage/credentials-group/create/create_test.go @@ -140,7 +140,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/object-storage/credentials-group/delete/delete.go b/internal/cmd/object-storage/credentials-group/delete/delete.go index d0ecf5fd5..fe71186c9 100644 --- a/internal/cmd/object-storage/credentials-group/delete/delete.go +++ b/internal/cmd/object-storage/credentials-group/delete/delete.go @@ -39,7 +39,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -52,6 +52,7 @@ func NewCmd(p *print.Printer) *cobra.Command { credentialsGroupLabel, err := objectStorageUtils.GetCredentialsGroupName(ctx, apiClient, model.ProjectId, model.CredentialsGroupId) if err != nil { + p.Debug(print.ErrorLevel, "get credentials group name: %v", err) credentialsGroupLabel = model.CredentialsGroupId } @@ -77,10 +78,10 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { credentialsGroupId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/object-storage/credentials-group/delete/delete_test.go b/internal/cmd/object-storage/credentials-group/delete/delete_test.go index d29e79f99..37c41a2b6 100644 --- a/internal/cmd/object-storage/credentials-group/delete/delete_test.go +++ b/internal/cmd/object-storage/credentials-group/delete/delete_test.go @@ -168,7 +168,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/object-storage/credentials-group/list/list.go b/internal/cmd/object-storage/credentials-group/list/list.go index 789a407b9..27e7a72fc 100644 --- a/internal/cmd/object-storage/credentials-group/list/list.go +++ b/internal/cmd/object-storage/credentials-group/list/list.go @@ -46,7 +46,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -84,13 +84,13 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().Int64(limitFlag, 0, "Maximum number of entries to list") } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, diff --git a/internal/cmd/object-storage/credentials-group/list/list_test.go b/internal/cmd/object-storage/credentials-group/list/list_test.go index a8058e24e..ea222b0eb 100644 --- a/internal/cmd/object-storage/credentials-group/list/list_test.go +++ b/internal/cmd/object-storage/credentials-group/list/list_test.go @@ -135,7 +135,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/object-storage/credentials/create/create.go b/internal/cmd/object-storage/credentials/create/create.go index db2118384..d9b26ab47 100644 --- a/internal/cmd/object-storage/credentials/create/create.go +++ b/internal/cmd/object-storage/credentials/create/create.go @@ -47,7 +47,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -60,6 +60,7 @@ func NewCmd(p *print.Printer) *cobra.Command { credentialsGroupLabel, err := objectStorageUtils.GetCredentialsGroupName(ctx, apiClient, model.ProjectId, model.CredentialsGroupId) if err != nil { + p.Debug(print.ErrorLevel, "get credentials group name: %v", err) credentialsGroupLabel = model.CredentialsGroupId } @@ -103,13 +104,13 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - expireDate, err := flags.FlagToDateTimePointer(cmd, expireDateFlag, expirationTimeFormat) + expireDate, err := flags.FlagToDateTimePointer(p, cmd, expireDateFlag, expirationTimeFormat) if err != nil { return nil, &errors.FlagValidationError{ Flag: expireDateFlag, @@ -120,7 +121,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, ExpireDate: expireDate, - CredentialsGroupId: flags.FlagToStringValue(cmd, credentialsGroupIdFlag), + CredentialsGroupId: flags.FlagToStringValue(p, cmd, credentialsGroupIdFlag), }, nil } diff --git a/internal/cmd/object-storage/credentials/create/create_test.go b/internal/cmd/object-storage/credentials/create/create_test.go index b13fa63e5..3f100fd55 100644 --- a/internal/cmd/object-storage/credentials/create/create_test.go +++ b/internal/cmd/object-storage/credentials/create/create_test.go @@ -199,7 +199,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/object-storage/credentials/delete/delete.go b/internal/cmd/object-storage/credentials/delete/delete.go index 5836e5373..9fd64a915 100644 --- a/internal/cmd/object-storage/credentials/delete/delete.go +++ b/internal/cmd/object-storage/credentials/delete/delete.go @@ -40,7 +40,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -53,11 +53,13 @@ func NewCmd(p *print.Printer) *cobra.Command { credentialsGroupLabel, err := objectStorageUtils.GetCredentialsGroupName(ctx, apiClient, model.ProjectId, model.CredentialsGroupId) if err != nil { + p.Debug(print.ErrorLevel, "get credentials group name: %v", err) credentialsGroupLabel = model.CredentialsGroupId } credentialsLabel, err := objectStorageUtils.GetCredentialsName(ctx, apiClient, model.ProjectId, model.CredentialsGroupId, model.CredentialsId) if err != nil { + p.Debug(print.ErrorLevel, "get credentials name: %v", err) credentialsLabel = model.CredentialsId } @@ -91,17 +93,17 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { credentialsId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } return &inputModel{ GlobalFlagModel: globalFlags, - CredentialsGroupId: flags.FlagToStringValue(cmd, credentialsGroupIdFlag), + CredentialsGroupId: flags.FlagToStringValue(p, cmd, credentialsGroupIdFlag), CredentialsId: credentialsId, }, nil } diff --git a/internal/cmd/object-storage/credentials/delete/delete_test.go b/internal/cmd/object-storage/credentials/delete/delete_test.go index bc023ebf2..4b108f4d7 100644 --- a/internal/cmd/object-storage/credentials/delete/delete_test.go +++ b/internal/cmd/object-storage/credentials/delete/delete_test.go @@ -187,7 +187,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/object-storage/credentials/list/list.go b/internal/cmd/object-storage/credentials/list/list.go index b38ee23cb..212a24df9 100644 --- a/internal/cmd/object-storage/credentials/list/list.go +++ b/internal/cmd/object-storage/credentials/list/list.go @@ -50,7 +50,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -71,6 +71,7 @@ func NewCmd(p *print.Printer) *cobra.Command { if len(credentials) == 0 { credentialsGroupLabel, err := objectStorageUtils.GetCredentialsGroupName(ctx, apiClient, model.ProjectId, model.CredentialsGroupId) if err != nil { + p.Debug(print.ErrorLevel, "get credentials group name: %v", err) credentialsGroupLabel = model.CredentialsGroupId } @@ -97,13 +98,13 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, @@ -113,7 +114,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - CredentialsGroupId: flags.FlagToStringValue(cmd, credentialsGroupIdFlag), + CredentialsGroupId: flags.FlagToStringValue(p, cmd, credentialsGroupIdFlag), Limit: limit, }, nil } diff --git a/internal/cmd/object-storage/credentials/list/list_test.go b/internal/cmd/object-storage/credentials/list/list_test.go index 32feb5457..7b103cd85 100644 --- a/internal/cmd/object-storage/credentials/list/list_test.go +++ b/internal/cmd/object-storage/credentials/list/list_test.go @@ -160,7 +160,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/object-storage/disable/disable.go b/internal/cmd/object-storage/disable/disable.go index 8c5f91adf..a37f63811 100644 --- a/internal/cmd/object-storage/disable/disable.go +++ b/internal/cmd/object-storage/disable/disable.go @@ -33,7 +33,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -44,8 +44,9 @@ func NewCmd(p *print.Printer) *cobra.Command { return err } - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } @@ -75,8 +76,8 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command) (*InputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*InputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/object-storage/disable/disable_test.go b/internal/cmd/object-storage/disable/disable_test.go index 8a52bbf27..26f1ea5fc 100644 --- a/internal/cmd/object-storage/disable/disable_test.go +++ b/internal/cmd/object-storage/disable/disable_test.go @@ -119,7 +119,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/object-storage/enable/enable.go b/internal/cmd/object-storage/enable/enable.go index 1f77a6b06..27e104fd7 100644 --- a/internal/cmd/object-storage/enable/enable.go +++ b/internal/cmd/object-storage/enable/enable.go @@ -33,7 +33,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -44,8 +44,9 @@ func NewCmd(p *print.Printer) *cobra.Command { return err } - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } @@ -75,8 +76,8 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command) (*InputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*InputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/object-storage/enable/enable_test.go b/internal/cmd/object-storage/enable/enable_test.go index 1c12bd918..df59c3868 100644 --- a/internal/cmd/object-storage/enable/enable_test.go +++ b/internal/cmd/object-storage/enable/enable_test.go @@ -119,7 +119,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/opensearch/credentials/create/create.go b/internal/cmd/opensearch/credentials/create/create.go index 824ba135f..1a6affef6 100644 --- a/internal/cmd/opensearch/credentials/create/create.go +++ b/internal/cmd/opensearch/credentials/create/create.go @@ -44,7 +44,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -57,6 +57,7 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := opensearchUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } @@ -103,16 +104,16 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), - HidePassword: flags.FlagToBoolValue(cmd, hidePasswordFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), + HidePassword: flags.FlagToBoolValue(p, cmd, hidePasswordFlag), }, nil } diff --git a/internal/cmd/opensearch/credentials/create/create_test.go b/internal/cmd/opensearch/credentials/create/create_test.go index 5ec06a4ae..47aba4795 100644 --- a/internal/cmd/opensearch/credentials/create/create_test.go +++ b/internal/cmd/opensearch/credentials/create/create_test.go @@ -142,7 +142,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/opensearch/credentials/delete/delete.go b/internal/cmd/opensearch/credentials/delete/delete.go index 13c4d8065..5992f5088 100644 --- a/internal/cmd/opensearch/credentials/delete/delete.go +++ b/internal/cmd/opensearch/credentials/delete/delete.go @@ -43,7 +43,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -56,11 +56,13 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := opensearchUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } credentialsLabel, err := opensearchUtils.GetCredentialsUsername(ctx, apiClient, model.ProjectId, model.InstanceId, model.CredentialsId) if err != nil { + p.Debug(print.ErrorLevel, "get credentials user name: %v", err) credentialsLabel = model.CredentialsId } @@ -94,17 +96,17 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { credentialsId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), CredentialsId: credentialsId, }, nil } diff --git a/internal/cmd/opensearch/credentials/delete/delete_test.go b/internal/cmd/opensearch/credentials/delete/delete_test.go index 276e68eaa..76fd83cb9 100644 --- a/internal/cmd/opensearch/credentials/delete/delete_test.go +++ b/internal/cmd/opensearch/credentials/delete/delete_test.go @@ -195,7 +195,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/opensearch/credentials/describe/describe.go b/internal/cmd/opensearch/credentials/describe/describe.go index 4b8c35cb6..9a79dab7f 100644 --- a/internal/cmd/opensearch/credentials/describe/describe.go +++ b/internal/cmd/opensearch/credentials/describe/describe.go @@ -47,7 +47,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -79,17 +79,17 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { credentialsId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), CredentialsId: credentialsId, }, nil } diff --git a/internal/cmd/opensearch/credentials/describe/describe_test.go b/internal/cmd/opensearch/credentials/describe/describe_test.go index 5b1354aeb..fe646774c 100644 --- a/internal/cmd/opensearch/credentials/describe/describe_test.go +++ b/internal/cmd/opensearch/credentials/describe/describe_test.go @@ -195,7 +195,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/opensearch/credentials/list/list.go b/internal/cmd/opensearch/credentials/list/list.go index ccb2dbfe3..036122719 100644 --- a/internal/cmd/opensearch/credentials/list/list.go +++ b/internal/cmd/opensearch/credentials/list/list.go @@ -49,7 +49,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -70,6 +70,7 @@ func NewCmd(p *print.Printer) *cobra.Command { if len(credentials) == 0 { instanceLabel, err := opensearchUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } p.Info("No credentials found for instance %q\n", instanceLabel) @@ -95,13 +96,13 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, @@ -111,7 +112,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), Limit: limit, }, nil } diff --git a/internal/cmd/opensearch/credentials/list/list_test.go b/internal/cmd/opensearch/credentials/list/list_test.go index 3cd807c35..563f20068 100644 --- a/internal/cmd/opensearch/credentials/list/list_test.go +++ b/internal/cmd/opensearch/credentials/list/list_test.go @@ -159,7 +159,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/opensearch/instance/create/create.go b/internal/cmd/opensearch/instance/create/create.go index fec307f1f..b3cb95b18 100644 --- a/internal/cmd/opensearch/instance/create/create.go +++ b/internal/cmd/opensearch/instance/create/create.go @@ -74,7 +74,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -85,8 +85,9 @@ func NewCmd(p *print.Printer) *cobra.Command { return err } - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } @@ -154,15 +155,15 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &cliErr.ProjectIdError{} } - planId := flags.FlagToStringPointer(cmd, planIdFlag) - planName := flags.FlagToStringValue(cmd, planNameFlag) - version := flags.FlagToStringValue(cmd, versionFlag) + planId := flags.FlagToStringPointer(p, cmd, planIdFlag) + planName := flags.FlagToStringValue(p, cmd, planNameFlag) + version := flags.FlagToStringValue(p, cmd, versionFlag) if planId == nil && (planName == "" || version == "") { return nil, &cliErr.DSAInputPlanError{ @@ -177,15 +178,15 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - InstanceName: flags.FlagToStringPointer(cmd, instanceNameFlag), - EnableMonitoring: flags.FlagToBoolPointer(cmd, enableMonitoringFlag), - MonitoringInstanceId: flags.FlagToStringPointer(cmd, monitoringInstanceIdFlag), - Graphite: flags.FlagToStringPointer(cmd, graphiteFlag), - MetricsFrequency: flags.FlagToInt64Pointer(cmd, metricsFrequencyFlag), - MetricsPrefix: flags.FlagToStringPointer(cmd, metricsPrefixFlag), - Plugin: flags.FlagToStringSlicePointer(cmd, pluginFlag), - SgwAcl: flags.FlagToStringSlicePointer(cmd, sgwAclFlag), - Syslog: flags.FlagToStringSlicePointer(cmd, syslogFlag), + InstanceName: flags.FlagToStringPointer(p, cmd, instanceNameFlag), + EnableMonitoring: flags.FlagToBoolPointer(p, cmd, enableMonitoringFlag), + MonitoringInstanceId: flags.FlagToStringPointer(p, cmd, monitoringInstanceIdFlag), + Graphite: flags.FlagToStringPointer(p, cmd, graphiteFlag), + MetricsFrequency: flags.FlagToInt64Pointer(p, cmd, metricsFrequencyFlag), + MetricsPrefix: flags.FlagToStringPointer(p, cmd, metricsPrefixFlag), + Plugin: flags.FlagToStringSlicePointer(p, cmd, pluginFlag), + SgwAcl: flags.FlagToStringSlicePointer(p, cmd, sgwAclFlag), + Syslog: flags.FlagToStringSlicePointer(p, cmd, syslogFlag), PlanId: planId, PlanName: planName, Version: version, diff --git a/internal/cmd/opensearch/instance/create/create_test.go b/internal/cmd/opensearch/instance/create/create_test.go index e123fdaf4..83497bbef 100644 --- a/internal/cmd/opensearch/instance/create/create_test.go +++ b/internal/cmd/opensearch/instance/create/create_test.go @@ -329,7 +329,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/opensearch/instance/delete/delete.go b/internal/cmd/opensearch/instance/delete/delete.go index a4ee8cff2..212e18377 100644 --- a/internal/cmd/opensearch/instance/delete/delete.go +++ b/internal/cmd/opensearch/instance/delete/delete.go @@ -41,7 +41,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -54,6 +54,7 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := opensearchUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } @@ -94,10 +95,10 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { instanceId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/opensearch/instance/delete/delete_test.go b/internal/cmd/opensearch/instance/delete/delete_test.go index 4ef2fc8a8..2992d4974 100644 --- a/internal/cmd/opensearch/instance/delete/delete_test.go +++ b/internal/cmd/opensearch/instance/delete/delete_test.go @@ -168,7 +168,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/opensearch/instance/describe/describe.go b/internal/cmd/opensearch/instance/describe/describe.go index 30063cf8f..540e9d9e8 100644 --- a/internal/cmd/opensearch/instance/describe/describe.go +++ b/internal/cmd/opensearch/instance/describe/describe.go @@ -45,7 +45,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -68,10 +68,10 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { instanceId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/opensearch/instance/describe/describe_test.go b/internal/cmd/opensearch/instance/describe/describe_test.go index f93c14d58..8d6ffd430 100644 --- a/internal/cmd/opensearch/instance/describe/describe_test.go +++ b/internal/cmd/opensearch/instance/describe/describe_test.go @@ -168,7 +168,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/opensearch/instance/list/list.go b/internal/cmd/opensearch/instance/list/list.go index 61eebea26..f2a5553a2 100644 --- a/internal/cmd/opensearch/instance/list/list.go +++ b/internal/cmd/opensearch/instance/list/list.go @@ -47,7 +47,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -66,8 +66,9 @@ func NewCmd(p *print.Printer) *cobra.Command { } instances := *resp.Instances if len(instances) == 0 { - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } p.Info("No instances found for project %q\n", projectLabel) @@ -91,13 +92,13 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().Int64(limitFlag, 0, "Maximum number of entries to list") } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, @@ -107,7 +108,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - Limit: flags.FlagToInt64Pointer(cmd, limitFlag), + Limit: flags.FlagToInt64Pointer(p, cmd, limitFlag), }, nil } diff --git a/internal/cmd/opensearch/instance/list/list_test.go b/internal/cmd/opensearch/instance/list/list_test.go index fad552b73..ae86f0791 100644 --- a/internal/cmd/opensearch/instance/list/list_test.go +++ b/internal/cmd/opensearch/instance/list/list_test.go @@ -138,7 +138,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/opensearch/instance/update/update.go b/internal/cmd/opensearch/instance/update/update.go index 82ff1ce5b..45fff824f 100644 --- a/internal/cmd/opensearch/instance/update/update.go +++ b/internal/cmd/opensearch/instance/update/update.go @@ -72,7 +72,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -85,6 +85,7 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := opensearchUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } @@ -148,25 +149,25 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().String(versionFlag, "", "Instance OpenSearch version") } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { instanceId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &cliErr.ProjectIdError{} } - enableMonitoring := flags.FlagToBoolPointer(cmd, enableMonitoringFlag) - monitoringInstanceId := flags.FlagToStringPointer(cmd, monitoringInstanceIdFlag) - graphite := flags.FlagToStringPointer(cmd, graphiteFlag) - metricsFrequency := flags.FlagToInt64Pointer(cmd, metricsFrequencyFlag) - metricsPrefix := flags.FlagToStringPointer(cmd, metricsPrefixFlag) - plugin := flags.FlagToStringSlicePointer(cmd, pluginFlag) - sgwAcl := flags.FlagToStringSlicePointer(cmd, sgwAclFlag) - syslog := flags.FlagToStringSlicePointer(cmd, syslogFlag) - planId := flags.FlagToStringPointer(cmd, planIdFlag) - planName := flags.FlagToStringValue(cmd, planNameFlag) - version := flags.FlagToStringValue(cmd, versionFlag) + enableMonitoring := flags.FlagToBoolPointer(p, cmd, enableMonitoringFlag) + monitoringInstanceId := flags.FlagToStringPointer(p, cmd, monitoringInstanceIdFlag) + graphite := flags.FlagToStringPointer(p, cmd, graphiteFlag) + metricsFrequency := flags.FlagToInt64Pointer(p, cmd, metricsFrequencyFlag) + metricsPrefix := flags.FlagToStringPointer(p, cmd, metricsPrefixFlag) + plugin := flags.FlagToStringSlicePointer(p, cmd, pluginFlag) + sgwAcl := flags.FlagToStringSlicePointer(p, cmd, sgwAclFlag) + syslog := flags.FlagToStringSlicePointer(p, cmd, syslogFlag) + planId := flags.FlagToStringPointer(p, cmd, planIdFlag) + planName := flags.FlagToStringValue(p, cmd, planNameFlag) + version := flags.FlagToStringValue(p, cmd, versionFlag) if planId != nil && (planName != "" || version != "") { return nil, &cliErr.DSAInputPlanError{ diff --git a/internal/cmd/opensearch/instance/update/update_test.go b/internal/cmd/opensearch/instance/update/update_test.go index 628f898ea..506d60ad2 100644 --- a/internal/cmd/opensearch/instance/update/update_test.go +++ b/internal/cmd/opensearch/instance/update/update_test.go @@ -354,7 +354,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/opensearch/plans/plans.go b/internal/cmd/opensearch/plans/plans.go index 3c3f8d7ac..6cd981d8e 100644 --- a/internal/cmd/opensearch/plans/plans.go +++ b/internal/cmd/opensearch/plans/plans.go @@ -47,7 +47,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -66,8 +66,9 @@ func NewCmd(p *print.Printer) *cobra.Command { } plans := *resp.Offerings if len(plans) == 0 { - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } p.Info("No plans found for project %q\n", projectLabel) @@ -91,13 +92,13 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().Int64(limitFlag, 0, "Maximum number of entries to list") } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, diff --git a/internal/cmd/opensearch/plans/plans_test.go b/internal/cmd/opensearch/plans/plans_test.go index dbd843a56..90ad23aca 100644 --- a/internal/cmd/opensearch/plans/plans_test.go +++ b/internal/cmd/opensearch/plans/plans_test.go @@ -138,7 +138,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/organization/member/add/add.go b/internal/cmd/organization/member/add/add.go index 2afc5e32b..035a25f7b 100644 --- a/internal/cmd/organization/member/add/add.go +++ b/internal/cmd/organization/member/add/add.go @@ -52,7 +52,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -94,16 +94,16 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { subject := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) return &inputModel{ GlobalFlagModel: globalFlags, - OrganizationId: flags.FlagToStringPointer(cmd, organizationIdFlag), + OrganizationId: flags.FlagToStringPointer(p, cmd, organizationIdFlag), Subject: subject, - Role: flags.FlagToStringPointer(cmd, roleFlag), + Role: flags.FlagToStringPointer(p, cmd, roleFlag), }, nil } diff --git a/internal/cmd/organization/member/add/add_test.go b/internal/cmd/organization/member/add/add_test.go index dae68d183..157941441 100644 --- a/internal/cmd/organization/member/add/add_test.go +++ b/internal/cmd/organization/member/add/add_test.go @@ -155,7 +155,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/organization/member/list/list.go b/internal/cmd/organization/member/list/list.go index 46af0d0ab..9126d4b57 100644 --- a/internal/cmd/organization/member/list/list.go +++ b/internal/cmd/organization/member/list/list.go @@ -56,7 +56,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -103,10 +103,10 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, @@ -116,10 +116,10 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - OrganizationId: flags.FlagToStringPointer(cmd, organizationIdFlag), - Subject: flags.FlagToStringPointer(cmd, subjectFlag), - Limit: flags.FlagToInt64Pointer(cmd, limitFlag), - SortBy: flags.FlagWithDefaultToStringValue(cmd, sortByFlag), + OrganizationId: flags.FlagToStringPointer(p, cmd, organizationIdFlag), + Subject: flags.FlagToStringPointer(p, cmd, subjectFlag), + Limit: flags.FlagToInt64Pointer(p, cmd, limitFlag), + SortBy: flags.FlagWithDefaultToStringValue(p, cmd, sortByFlag), }, nil } diff --git a/internal/cmd/organization/member/list/list_test.go b/internal/cmd/organization/member/list/list_test.go index 48800ae1c..d2cc51779 100644 --- a/internal/cmd/organization/member/list/list_test.go +++ b/internal/cmd/organization/member/list/list_test.go @@ -149,7 +149,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/organization/member/remove/remove.go b/internal/cmd/organization/member/remove/remove.go index 2a3dad778..bea4e3fb8 100644 --- a/internal/cmd/organization/member/remove/remove.go +++ b/internal/cmd/organization/member/remove/remove.go @@ -55,7 +55,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -101,17 +101,17 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { subject := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) return &inputModel{ GlobalFlagModel: globalFlags, - OrganizationId: flags.FlagToStringPointer(cmd, organizationIdFlag), + OrganizationId: flags.FlagToStringPointer(p, cmd, organizationIdFlag), Subject: subject, - Role: flags.FlagToStringPointer(cmd, roleFlag), - Force: flags.FlagToBoolValue(cmd, forceFlag), + Role: flags.FlagToStringPointer(p, cmd, roleFlag), + Force: flags.FlagToBoolValue(p, cmd, forceFlag), }, nil } diff --git a/internal/cmd/organization/member/remove/remove_test.go b/internal/cmd/organization/member/remove/remove_test.go index 4befba92a..6e21ad6e8 100644 --- a/internal/cmd/organization/member/remove/remove_test.go +++ b/internal/cmd/organization/member/remove/remove_test.go @@ -168,7 +168,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/organization/role/list/list.go b/internal/cmd/organization/role/list/list.go index e0af5e6cd..708f43eec 100644 --- a/internal/cmd/organization/role/list/list.go +++ b/internal/cmd/organization/role/list/list.go @@ -51,7 +51,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -94,10 +94,10 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, @@ -107,8 +107,8 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - OrganizationId: flags.FlagToStringPointer(cmd, organizationIdFlag), - Limit: flags.FlagToInt64Pointer(cmd, limitFlag), + OrganizationId: flags.FlagToStringPointer(p, cmd, organizationIdFlag), + Limit: flags.FlagToInt64Pointer(p, cmd, limitFlag), }, nil } diff --git a/internal/cmd/organization/role/list/list_test.go b/internal/cmd/organization/role/list/list_test.go index 413a3d072..3304e69ef 100644 --- a/internal/cmd/organization/role/list/list_test.go +++ b/internal/cmd/organization/role/list/list_test.go @@ -119,7 +119,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/postgresflex/instance/clone/clone.go b/internal/cmd/postgresflex/instance/clone/clone.go index 68d248cb8..1007bf548 100644 --- a/internal/cmd/postgresflex/instance/clone/clone.go +++ b/internal/cmd/postgresflex/instance/clone/clone.go @@ -60,7 +60,7 @@ func NewCmd(p *print.Printer) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -73,6 +73,7 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := postgresflexUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } @@ -128,15 +129,15 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { instanceId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &cliErr.ProjectIdError{} } - recoveryTimestamp, err := flags.FlagToDateTimePointer(cmd, recoveryTimestampFlag, recoveryDateFormat) + recoveryTimestamp, err := flags.FlagToDateTimePointer(p, cmd, recoveryTimestampFlag, recoveryDateFormat) if err != nil { return nil, &cliErr.FlagValidationError{ Flag: recoveryTimestampFlag, @@ -148,8 +149,8 @@ func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, InstanceId: instanceId, - StorageClass: flags.FlagToStringPointer(cmd, storageClassFlag), - StorageSize: flags.FlagToInt64Pointer(cmd, storageSizeFlag), + StorageClass: flags.FlagToStringPointer(p, cmd, storageClassFlag), + StorageSize: flags.FlagToInt64Pointer(p, cmd, storageSizeFlag), RecoveryDate: utils.Ptr(recoveryTimestampString), }, nil } diff --git a/internal/cmd/postgresflex/instance/clone/clone_test.go b/internal/cmd/postgresflex/instance/clone/clone_test.go index f84f42f40..7b9c83167 100644 --- a/internal/cmd/postgresflex/instance/clone/clone_test.go +++ b/internal/cmd/postgresflex/instance/clone/clone_test.go @@ -330,7 +330,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/postgresflex/instance/create/create.go b/internal/cmd/postgresflex/instance/create/create.go index 6d8696eb3..c9141c17f 100644 --- a/internal/cmd/postgresflex/instance/create/create.go +++ b/internal/cmd/postgresflex/instance/create/create.go @@ -75,7 +75,7 @@ func NewCmd(p *print.Printer) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -86,8 +86,9 @@ func NewCmd(p *print.Printer) *cobra.Command { return err } - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } @@ -160,17 +161,17 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &cliErr.ProjectIdError{} } - storageSize := flags.FlagWithDefaultToInt64Value(cmd, storageSizeFlag) + storageSize := flags.FlagWithDefaultToInt64Value(p, cmd, storageSizeFlag) - flavorId := flags.FlagToStringPointer(cmd, flavorIdFlag) - cpu := flags.FlagToInt64Pointer(cmd, cpuFlag) - ram := flags.FlagToInt64Pointer(cmd, ramFlag) + flavorId := flags.FlagToStringPointer(p, cmd, flavorIdFlag) + cpu := flags.FlagToInt64Pointer(p, cmd, cpuFlag) + ram := flags.FlagToInt64Pointer(p, cmd, ramFlag) if flavorId == nil && (cpu == nil || ram == nil) { return nil, &cliErr.DatabaseInputFlavorError{ @@ -185,16 +186,16 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - InstanceName: flags.FlagToStringPointer(cmd, instanceNameFlag), - ACL: flags.FlagToStringSlicePointer(cmd, aclFlag), - BackupSchedule: utils.Ptr(flags.FlagWithDefaultToStringValue(cmd, backupScheduleFlag)), + InstanceName: flags.FlagToStringPointer(p, cmd, instanceNameFlag), + ACL: flags.FlagToStringSlicePointer(p, cmd, aclFlag), + BackupSchedule: utils.Ptr(flags.FlagWithDefaultToStringValue(p, cmd, backupScheduleFlag)), FlavorId: flavorId, CPU: cpu, RAM: ram, - StorageClass: utils.Ptr(flags.FlagWithDefaultToStringValue(cmd, storageClassFlag)), + StorageClass: utils.Ptr(flags.FlagWithDefaultToStringValue(p, cmd, storageClassFlag)), StorageSize: &storageSize, - Version: flags.FlagToStringPointer(cmd, versionFlag), - Type: utils.Ptr(flags.FlagWithDefaultToStringValue(cmd, typeFlag)), + Version: flags.FlagToStringPointer(p, cmd, versionFlag), + Type: utils.Ptr(flags.FlagWithDefaultToStringValue(p, cmd, typeFlag)), }, nil } diff --git a/internal/cmd/postgresflex/instance/create/create_test.go b/internal/cmd/postgresflex/instance/create/create_test.go index 69e348237..71508c435 100644 --- a/internal/cmd/postgresflex/instance/create/create_test.go +++ b/internal/cmd/postgresflex/instance/create/create_test.go @@ -282,7 +282,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/postgresflex/instance/delete/delete.go b/internal/cmd/postgresflex/instance/delete/delete.go index bf98e4464..321df48e5 100644 --- a/internal/cmd/postgresflex/instance/delete/delete.go +++ b/internal/cmd/postgresflex/instance/delete/delete.go @@ -52,7 +52,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -65,6 +65,7 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := postgresflexUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } @@ -143,10 +144,10 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().BoolP(forceDeleteFlag, "f", false, "Force deletion of a delayed deleted instance") } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { instanceId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } @@ -154,7 +155,7 @@ func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, InstanceId: instanceId, - ForceDelete: flags.FlagToBoolValue(cmd, forceDeleteFlag), + ForceDelete: flags.FlagToBoolValue(p, cmd, forceDeleteFlag), }, nil } diff --git a/internal/cmd/postgresflex/instance/delete/delete_test.go b/internal/cmd/postgresflex/instance/delete/delete_test.go index 60b1fd00a..23a4d9f2b 100644 --- a/internal/cmd/postgresflex/instance/delete/delete_test.go +++ b/internal/cmd/postgresflex/instance/delete/delete_test.go @@ -200,7 +200,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/postgresflex/instance/describe/describe.go b/internal/cmd/postgresflex/instance/describe/describe.go index 4836bc0cb..651499967 100644 --- a/internal/cmd/postgresflex/instance/describe/describe.go +++ b/internal/cmd/postgresflex/instance/describe/describe.go @@ -47,7 +47,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -70,10 +70,10 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { instanceId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/postgresflex/instance/describe/describe_test.go b/internal/cmd/postgresflex/instance/describe/describe_test.go index bcff29fa6..079f8a0c7 100644 --- a/internal/cmd/postgresflex/instance/describe/describe_test.go +++ b/internal/cmd/postgresflex/instance/describe/describe_test.go @@ -168,7 +168,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/postgresflex/instance/list/list.go b/internal/cmd/postgresflex/instance/list/list.go index a9f6b5e25..c8af818e3 100644 --- a/internal/cmd/postgresflex/instance/list/list.go +++ b/internal/cmd/postgresflex/instance/list/list.go @@ -49,7 +49,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -67,8 +67,9 @@ func NewCmd(p *print.Printer) *cobra.Command { return fmt.Errorf("get PostgreSQL Flex instances: %w", err) } if resp.Items == nil || len(*resp.Items) == 0 { - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } p.Info("No instances found for project %q\n", projectLabel) @@ -93,13 +94,13 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().Int64(limitFlag, 0, "Maximum number of entries to list") } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, @@ -109,7 +110,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - Limit: flags.FlagToInt64Pointer(cmd, limitFlag), + Limit: flags.FlagToInt64Pointer(p, cmd, limitFlag), }, nil } diff --git a/internal/cmd/postgresflex/instance/list/list_test.go b/internal/cmd/postgresflex/instance/list/list_test.go index c8aede301..4a57f0e98 100644 --- a/internal/cmd/postgresflex/instance/list/list_test.go +++ b/internal/cmd/postgresflex/instance/list/list_test.go @@ -138,7 +138,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/postgresflex/instance/update/update.go b/internal/cmd/postgresflex/instance/update/update.go index 5a61ff14e..118e0a640 100644 --- a/internal/cmd/postgresflex/instance/update/update.go +++ b/internal/cmd/postgresflex/instance/update/update.go @@ -69,7 +69,7 @@ func NewCmd(p *print.Printer) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -82,6 +82,7 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := postgresflexUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } @@ -142,24 +143,24 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().Var(flags.EnumFlag(false, "", typeFlagOptions...), typeFlag, fmt.Sprintf("Instance type, one of %q", typeFlagOptions)) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { instanceId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &cliErr.ProjectIdError{} } - instanceName := flags.FlagToStringPointer(cmd, instanceNameFlag) - flavorId := flags.FlagToStringPointer(cmd, flavorIdFlag) - cpu := flags.FlagToInt64Pointer(cmd, cpuFlag) - ram := flags.FlagToInt64Pointer(cmd, ramFlag) - acl := flags.FlagToStringSlicePointer(cmd, aclFlag) - backupSchedule := flags.FlagToStringPointer(cmd, backupScheduleFlag) - storageClass := flags.FlagToStringPointer(cmd, storageClassFlag) - storageSize := flags.FlagToInt64Pointer(cmd, storageSizeFlag) - version := flags.FlagToStringPointer(cmd, versionFlag) - instanceType := flags.FlagToStringPointer(cmd, typeFlag) + instanceName := flags.FlagToStringPointer(p, cmd, instanceNameFlag) + flavorId := flags.FlagToStringPointer(p, cmd, flavorIdFlag) + cpu := flags.FlagToInt64Pointer(p, cmd, cpuFlag) + ram := flags.FlagToInt64Pointer(p, cmd, ramFlag) + acl := flags.FlagToStringSlicePointer(p, cmd, aclFlag) + backupSchedule := flags.FlagToStringPointer(p, cmd, backupScheduleFlag) + storageClass := flags.FlagToStringPointer(p, cmd, storageClassFlag) + storageSize := flags.FlagToInt64Pointer(p, cmd, storageSizeFlag) + version := flags.FlagToStringPointer(p, cmd, versionFlag) + instanceType := flags.FlagToStringPointer(p, cmd, typeFlag) if instanceName == nil && flavorId == nil && cpu == nil && ram == nil && acl == nil && backupSchedule == nil && storageClass == nil && storageSize == nil && version == nil && instanceType == nil { diff --git a/internal/cmd/postgresflex/instance/update/update_test.go b/internal/cmd/postgresflex/instance/update/update_test.go index 16f6d3769..97dd19c4c 100644 --- a/internal/cmd/postgresflex/instance/update/update_test.go +++ b/internal/cmd/postgresflex/instance/update/update_test.go @@ -320,7 +320,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/postgresflex/options/options.go b/internal/cmd/postgresflex/options/options.go index 998c18d87..0ce14bc02 100644 --- a/internal/cmd/postgresflex/options/options.go +++ b/internal/cmd/postgresflex/options/options.go @@ -64,7 +64,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -95,12 +95,12 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().String(flavorIdFlag, "", `The flavor ID to show storages for. Only relevant when "--storages" is passed`) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) - flavors := flags.FlagToBoolValue(cmd, flavorsFlag) - versions := flags.FlagToBoolValue(cmd, versionsFlag) - storages := flags.FlagToBoolValue(cmd, storagesFlag) - flavorId := flags.FlagToStringPointer(cmd, flavorIdFlag) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) + flavors := flags.FlagToBoolValue(p, cmd, flavorsFlag) + versions := flags.FlagToBoolValue(p, cmd, versionsFlag) + storages := flags.FlagToBoolValue(p, cmd, storagesFlag) + flavorId := flags.FlagToStringPointer(p, cmd, flavorIdFlag) if !flavors && !versions && !storages { return nil, fmt.Errorf("%s\n\n%s", @@ -120,7 +120,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { Flavors: flavors, Versions: versions, Storages: storages, - FlavorId: flags.FlagToStringPointer(cmd, flavorIdFlag), + FlavorId: flags.FlagToStringPointer(p, cmd, flavorIdFlag), }, nil } diff --git a/internal/cmd/postgresflex/options/options_test.go b/internal/cmd/postgresflex/options/options_test.go index c9905cd20..e26ea4fc2 100644 --- a/internal/cmd/postgresflex/options/options_test.go +++ b/internal/cmd/postgresflex/options/options_test.go @@ -190,7 +190,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/postgresflex/user/create/create.go b/internal/cmd/postgresflex/user/create/create.go index a0758c12b..10f57edf1 100644 --- a/internal/cmd/postgresflex/user/create/create.go +++ b/internal/cmd/postgresflex/user/create/create.go @@ -56,7 +56,7 @@ func NewCmd(p *print.Printer) *cobra.Command { Args: args.NoArgs, RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -69,6 +69,7 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := postgresflexUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } @@ -115,17 +116,17 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), - Username: flags.FlagToStringPointer(cmd, usernameFlag), - Roles: flags.FlagWithDefaultToStringSlicePointer(cmd, roleFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), + Username: flags.FlagToStringPointer(p, cmd, usernameFlag), + Roles: flags.FlagWithDefaultToStringSlicePointer(p, cmd, roleFlag), }, nil } diff --git a/internal/cmd/postgresflex/user/create/create_test.go b/internal/cmd/postgresflex/user/create/create_test.go index f12b20b89..cb48a98f5 100644 --- a/internal/cmd/postgresflex/user/create/create_test.go +++ b/internal/cmd/postgresflex/user/create/create_test.go @@ -173,7 +173,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/postgresflex/user/delete/delete.go b/internal/cmd/postgresflex/user/delete/delete.go index c4bb11f24..8affbe99b 100644 --- a/internal/cmd/postgresflex/user/delete/delete.go +++ b/internal/cmd/postgresflex/user/delete/delete.go @@ -47,7 +47,7 @@ func NewCmd(p *print.Printer) *cobra.Command { Args: args.SingleArg(userIdArg, nil), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -60,11 +60,13 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := postgresflexUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } userLabel, err := postgresflexUtils.GetUserName(ctx, apiClient, model.ProjectId, model.InstanceId, model.UserId) if err != nil { + p.Debug(print.ErrorLevel, "get user name: %v", err) userLabel = model.UserId } @@ -98,17 +100,17 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { userId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), UserId: userId, }, nil } diff --git a/internal/cmd/postgresflex/user/delete/delete_test.go b/internal/cmd/postgresflex/user/delete/delete_test.go index 1a7bb7d94..546555723 100644 --- a/internal/cmd/postgresflex/user/delete/delete_test.go +++ b/internal/cmd/postgresflex/user/delete/delete_test.go @@ -189,7 +189,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/postgresflex/user/describe/describe.go b/internal/cmd/postgresflex/user/describe/describe.go index acfa5d5d2..f846320ad 100644 --- a/internal/cmd/postgresflex/user/describe/describe.go +++ b/internal/cmd/postgresflex/user/describe/describe.go @@ -51,7 +51,7 @@ func NewCmd(p *print.Printer) *cobra.Command { Args: args.SingleArg(userIdArg, nil), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -84,17 +84,17 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { userId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), UserId: userId, }, nil } diff --git a/internal/cmd/postgresflex/user/describe/describe_test.go b/internal/cmd/postgresflex/user/describe/describe_test.go index 4bc121ee7..f6ebcbbd7 100644 --- a/internal/cmd/postgresflex/user/describe/describe_test.go +++ b/internal/cmd/postgresflex/user/describe/describe_test.go @@ -189,7 +189,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/postgresflex/user/list/list.go b/internal/cmd/postgresflex/user/list/list.go index 785fc473a..fb1ef6065 100644 --- a/internal/cmd/postgresflex/user/list/list.go +++ b/internal/cmd/postgresflex/user/list/list.go @@ -50,7 +50,7 @@ func NewCmd(p *print.Printer) *cobra.Command { Args: args.NoArgs, RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -70,6 +70,7 @@ func NewCmd(p *print.Printer) *cobra.Command { if resp.Items == nil || len(*resp.Items) == 0 { instanceLabel, err := postgresflexUtils.GetInstanceName(ctx, apiClient, model.ProjectId, *model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = *model.InstanceId } p.Info("No users found for instance %q\n", instanceLabel) @@ -98,13 +99,13 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, @@ -114,8 +115,8 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringPointer(cmd, instanceIdFlag), - Limit: flags.FlagToInt64Pointer(cmd, limitFlag), + InstanceId: flags.FlagToStringPointer(p, cmd, instanceIdFlag), + Limit: flags.FlagToInt64Pointer(p, cmd, limitFlag), }, nil } diff --git a/internal/cmd/postgresflex/user/list/list_test.go b/internal/cmd/postgresflex/user/list/list_test.go index 58f5c7434..d4d97e6a7 100644 --- a/internal/cmd/postgresflex/user/list/list_test.go +++ b/internal/cmd/postgresflex/user/list/list_test.go @@ -155,7 +155,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/postgresflex/user/reset-password/reset_password.go b/internal/cmd/postgresflex/user/reset-password/reset_password.go index ba0ab2b26..b18ad672b 100644 --- a/internal/cmd/postgresflex/user/reset-password/reset_password.go +++ b/internal/cmd/postgresflex/user/reset-password/reset_password.go @@ -46,7 +46,7 @@ func NewCmd(p *print.Printer) *cobra.Command { Args: args.SingleArg(userIdArg, nil), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -59,11 +59,13 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := postgresflexUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } userLabel, err := postgresflexUtils.GetUserName(ctx, apiClient, model.ProjectId, model.InstanceId, model.UserId) if err != nil { + p.Debug(print.ErrorLevel, "get user name: %v", err) userLabel = model.UserId } @@ -101,17 +103,17 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { userId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), UserId: userId, }, nil } diff --git a/internal/cmd/postgresflex/user/reset-password/reset_password_test.go b/internal/cmd/postgresflex/user/reset-password/reset_password_test.go index b312e5867..4eaf6f1ae 100644 --- a/internal/cmd/postgresflex/user/reset-password/reset_password_test.go +++ b/internal/cmd/postgresflex/user/reset-password/reset_password_test.go @@ -189,7 +189,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/postgresflex/user/update/update.go b/internal/cmd/postgresflex/user/update/update.go index 0b39a8eef..1331ed7db 100644 --- a/internal/cmd/postgresflex/user/update/update.go +++ b/internal/cmd/postgresflex/user/update/update.go @@ -45,7 +45,7 @@ func NewCmd(p *print.Printer) *cobra.Command { Args: args.SingleArg(userIdArg, nil), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -58,11 +58,13 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := postgresflexUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } userLabel, err := postgresflexUtils.GetUserName(ctx, apiClient, model.ProjectId, model.InstanceId, model.UserId) if err != nil { + p.Debug(print.ErrorLevel, "get user name: %v", err) userLabel = model.UserId } @@ -100,22 +102,22 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { userId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - roles := flags.FlagToStringSlicePointer(cmd, roleFlag) + roles := flags.FlagToStringSlicePointer(p, cmd, roleFlag) if roles == nil { return nil, &errors.EmptyUpdateError{} } return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), UserId: userId, Roles: roles, }, nil diff --git a/internal/cmd/postgresflex/user/update/update_test.go b/internal/cmd/postgresflex/user/update/update_test.go index 7f5f50092..01ac94cc2 100644 --- a/internal/cmd/postgresflex/user/update/update_test.go +++ b/internal/cmd/postgresflex/user/update/update_test.go @@ -198,7 +198,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/project/create/create.go b/internal/cmd/project/create/create.go index e1fbc397b..cfcbf1c06 100644 --- a/internal/cmd/project/create/create.go +++ b/internal/cmd/project/create/create.go @@ -52,7 +52,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -98,10 +98,10 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) - labels := flags.FlagToStringToStringPointer(cmd, labelFlag) + labels := flags.FlagToStringToStringPointer(p, cmd, labelFlag) if labels != nil { labelKeyRegex := regexp.MustCompile(labelKeyRegex) labelValueRegex := regexp.MustCompile(labelValueRegex) @@ -124,8 +124,8 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - ParentId: flags.FlagToStringPointer(cmd, parentIdFlag), - Name: flags.FlagToStringPointer(cmd, nameFlag), + ParentId: flags.FlagToStringPointer(p, cmd, parentIdFlag), + Name: flags.FlagToStringPointer(p, cmd, nameFlag), Labels: labels, }, nil } diff --git a/internal/cmd/project/create/create_test.go b/internal/cmd/project/create/create_test.go index b7e051328..510935d63 100644 --- a/internal/cmd/project/create/create_test.go +++ b/internal/cmd/project/create/create_test.go @@ -173,7 +173,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/project/delete/delete.go b/internal/cmd/project/delete/delete.go index 1709736f3..cb8fde898 100644 --- a/internal/cmd/project/delete/delete.go +++ b/internal/cmd/project/delete/delete.go @@ -36,7 +36,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -47,8 +47,9 @@ func NewCmd(p *print.Printer) *cobra.Command { return err } - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } @@ -78,8 +79,8 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/project/delete/delete_test.go b/internal/cmd/project/delete/delete_test.go index 2bb0b63c6..7514c8fc8 100644 --- a/internal/cmd/project/delete/delete_test.go +++ b/internal/cmd/project/delete/delete_test.go @@ -97,7 +97,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/project/describe/describe.go b/internal/cmd/project/describe/describe.go index 9208fe081..a2e60535d 100644 --- a/internal/cmd/project/describe/describe.go +++ b/internal/cmd/project/describe/describe.go @@ -49,7 +49,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -78,13 +78,13 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().Bool(includeParentsFlag, false, "When true, the details of the parent resources will be included in the output") } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { var projectId string if len(inputArgs) > 0 { projectId = inputArgs[0] } - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" && projectId == "" { return nil, fmt.Errorf("Project ID needs to be provided either as an argument or as a flag") } @@ -96,7 +96,7 @@ func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, ArgProjectId: projectId, - IncludeParents: flags.FlagToBoolValue(cmd, includeParentsFlag), + IncludeParents: flags.FlagToBoolValue(p, cmd, includeParentsFlag), }, nil } diff --git a/internal/cmd/project/describe/describe_test.go b/internal/cmd/project/describe/describe_test.go index cd60acf0a..76a6d6abf 100644 --- a/internal/cmd/project/describe/describe_test.go +++ b/internal/cmd/project/describe/describe_test.go @@ -166,7 +166,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/project/list/list.go b/internal/cmd/project/list/list.go index 1dd26e492..6e4eadf39 100644 --- a/internal/cmd/project/list/list.go +++ b/internal/cmd/project/list/list.go @@ -64,7 +64,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -101,10 +101,10 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().Int64(pageSizeFlag, pageSizeDefault, "Number of items fetched in each API call. Does not affect the number of items in the command output") } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) - creationTimeAfter, err := flags.FlagToDateTimePointer(cmd, creationTimeAfterFlag, creationTimeAfterFormat) + creationTimeAfter, err := flags.FlagToDateTimePointer(p, cmd, creationTimeAfterFlag, creationTimeAfterFormat) if err != nil { return nil, &errors.FlagValidationError{ Flag: creationTimeAfterFlag, @@ -112,7 +112,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { } } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, @@ -120,7 +120,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { } } - pageSize := flags.FlagWithDefaultToInt64Value(cmd, pageSizeFlag) + pageSize := flags.FlagWithDefaultToInt64Value(p, cmd, pageSizeFlag) if pageSize < 1 { return nil, &errors.FlagValidationError{ Flag: pageSizeFlag, @@ -130,9 +130,9 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - ParentId: flags.FlagToStringPointer(cmd, parentIdFlag), - ProjectIdLike: flags.FlagToStringSliceValue(cmd, projectIdLikeFlag), - Member: flags.FlagToStringPointer(cmd, memberFlag), + ParentId: flags.FlagToStringPointer(p, cmd, parentIdFlag), + ProjectIdLike: flags.FlagToStringSliceValue(p, cmd, projectIdLikeFlag), + Member: flags.FlagToStringPointer(p, cmd, memberFlag), CreationTimeAfter: creationTimeAfter, Limit: limit, PageSize: pageSize, diff --git a/internal/cmd/project/list/list_test.go b/internal/cmd/project/list/list_test.go index b89adca73..a4d02b78e 100644 --- a/internal/cmd/project/list/list_test.go +++ b/internal/cmd/project/list/list_test.go @@ -237,7 +237,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating one of required flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/project/member/add/add.go b/internal/cmd/project/member/add/add.go index f0bc1ec05..c44bfd6b2 100644 --- a/internal/cmd/project/member/add/add.go +++ b/internal/cmd/project/member/add/add.go @@ -52,7 +52,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -63,8 +63,9 @@ func NewCmd(p *print.Printer) *cobra.Command { return err } - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } @@ -98,10 +99,10 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { subject := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } @@ -109,7 +110,7 @@ func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, Subject: subject, - Role: flags.FlagToStringPointer(cmd, roleFlag), + Role: flags.FlagToStringPointer(p, cmd, roleFlag), }, nil } diff --git a/internal/cmd/project/member/add/add_test.go b/internal/cmd/project/member/add/add_test.go index e59825633..97763b3e5 100644 --- a/internal/cmd/project/member/add/add_test.go +++ b/internal/cmd/project/member/add/add_test.go @@ -154,7 +154,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/project/member/list/list.go b/internal/cmd/project/member/list/list.go index be2f80471..4d3b98dd7 100644 --- a/internal/cmd/project/member/list/list.go +++ b/internal/cmd/project/member/list/list.go @@ -55,7 +55,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -74,8 +74,9 @@ func NewCmd(p *print.Printer) *cobra.Command { } members := *resp.Members if len(members) == 0 { - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } p.Info("No members found for project %q\n", projectLabel) @@ -102,13 +103,13 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().Var(flags.EnumFlag(false, "subject", sortByFlagOptions...), sortByFlag, fmt.Sprintf("Sort entries by a specific field, one of %q", sortByFlagOptions)) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, @@ -118,9 +119,9 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - Subject: flags.FlagToStringPointer(cmd, subjectFlag), - Limit: flags.FlagToInt64Pointer(cmd, limitFlag), - SortBy: flags.FlagWithDefaultToStringValue(cmd, sortByFlag), + Subject: flags.FlagToStringPointer(p, cmd, subjectFlag), + Limit: flags.FlagToInt64Pointer(p, cmd, limitFlag), + SortBy: flags.FlagWithDefaultToStringValue(p, cmd, sortByFlag), }, nil } diff --git a/internal/cmd/project/member/list/list_test.go b/internal/cmd/project/member/list/list_test.go index 469ce2eb0..c741fbac0 100644 --- a/internal/cmd/project/member/list/list_test.go +++ b/internal/cmd/project/member/list/list_test.go @@ -154,7 +154,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/project/member/remove/remove.go b/internal/cmd/project/member/remove/remove.go index 46d5015c2..dbca7d4ad 100644 --- a/internal/cmd/project/member/remove/remove.go +++ b/internal/cmd/project/member/remove/remove.go @@ -55,7 +55,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -66,8 +66,9 @@ func NewCmd(p *print.Printer) *cobra.Command { return err } - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } @@ -105,10 +106,10 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { subject := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } @@ -116,8 +117,8 @@ func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, Subject: subject, - Role: flags.FlagToStringPointer(cmd, roleFlag), - Force: flags.FlagToBoolValue(cmd, forceFlag), + Role: flags.FlagToStringPointer(p, cmd, roleFlag), + Force: flags.FlagToBoolValue(p, cmd, forceFlag), }, nil } diff --git a/internal/cmd/project/member/remove/remove_test.go b/internal/cmd/project/member/remove/remove_test.go index c39df7e82..540d57a08 100644 --- a/internal/cmd/project/member/remove/remove_test.go +++ b/internal/cmd/project/member/remove/remove_test.go @@ -167,7 +167,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/project/role/list/list.go b/internal/cmd/project/role/list/list.go index 5605f3ddb..103cad108 100644 --- a/internal/cmd/project/role/list/list.go +++ b/internal/cmd/project/role/list/list.go @@ -50,7 +50,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -69,8 +69,9 @@ func NewCmd(p *print.Printer) *cobra.Command { } roles := *resp.Roles if len(roles) == 0 { - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } p.Info("No roles found for project %q\n", projectLabel) @@ -93,13 +94,13 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().Int64(limitFlag, 0, "Maximum number of entries to list") } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, @@ -109,7 +110,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - Limit: flags.FlagToInt64Pointer(cmd, limitFlag), + Limit: flags.FlagToInt64Pointer(p, cmd, limitFlag), }, nil } diff --git a/internal/cmd/project/role/list/list_test.go b/internal/cmd/project/role/list/list_test.go index 80ee22574..60a1080f0 100644 --- a/internal/cmd/project/role/list/list_test.go +++ b/internal/cmd/project/role/list/list_test.go @@ -124,7 +124,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/project/update/update.go b/internal/cmd/project/update/update.go index fe553cf0a..f80edc5c2 100644 --- a/internal/cmd/project/update/update.go +++ b/internal/cmd/project/update/update.go @@ -55,7 +55,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -66,8 +66,9 @@ func NewCmd(p *print.Printer) *cobra.Command { return err } - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } @@ -100,15 +101,15 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().StringToString(labelFlag, nil, "Labels are key-value string pairs which can be attached to a project. A label can be provided with the format key=value and the flag can be used multiple times to provide a list of labels") } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - labels := flags.FlagToStringToStringPointer(cmd, labelFlag) - parentId := flags.FlagToStringPointer(cmd, parentIdFlag) - name := flags.FlagToStringPointer(cmd, nameFlag) + labels := flags.FlagToStringToStringPointer(p, cmd, labelFlag) + parentId := flags.FlagToStringPointer(p, cmd, parentIdFlag) + name := flags.FlagToStringPointer(p, cmd, nameFlag) if labels == nil && parentId == nil && name == nil { return nil, &errors.EmptyUpdateError{} diff --git a/internal/cmd/project/update/update_test.go b/internal/cmd/project/update/update_test.go index 7a7f0454e..75873a964 100644 --- a/internal/cmd/project/update/update_test.go +++ b/internal/cmd/project/update/update_test.go @@ -163,7 +163,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/rabbitmq/credentials/create/create.go b/internal/cmd/rabbitmq/credentials/create/create.go index ee75a5aa3..bb7c21ae9 100644 --- a/internal/cmd/rabbitmq/credentials/create/create.go +++ b/internal/cmd/rabbitmq/credentials/create/create.go @@ -44,7 +44,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -57,6 +57,7 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := rabbitmqUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } @@ -104,16 +105,16 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), - HidePassword: flags.FlagToBoolValue(cmd, hidePasswordFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), + HidePassword: flags.FlagToBoolValue(p, cmd, hidePasswordFlag), }, nil } diff --git a/internal/cmd/rabbitmq/credentials/create/create_test.go b/internal/cmd/rabbitmq/credentials/create/create_test.go index c68535494..732e94540 100644 --- a/internal/cmd/rabbitmq/credentials/create/create_test.go +++ b/internal/cmd/rabbitmq/credentials/create/create_test.go @@ -142,7 +142,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/rabbitmq/credentials/delete/delete.go b/internal/cmd/rabbitmq/credentials/delete/delete.go index b469f92b0..76f2265c5 100644 --- a/internal/cmd/rabbitmq/credentials/delete/delete.go +++ b/internal/cmd/rabbitmq/credentials/delete/delete.go @@ -43,7 +43,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -56,11 +56,13 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := rabbitmqUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } credentialsLabel, err := rabbitmqUtils.GetCredentialsUsername(ctx, apiClient, model.ProjectId, model.InstanceId, model.CredentialsId) if err != nil { + p.Debug(print.ErrorLevel, "get credentials user name: %v", err) credentialsLabel = model.CredentialsId } @@ -94,17 +96,17 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { credentialsId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), CredentialsId: credentialsId, }, nil } diff --git a/internal/cmd/rabbitmq/credentials/delete/delete_test.go b/internal/cmd/rabbitmq/credentials/delete/delete_test.go index ecf10d176..bbfb59819 100644 --- a/internal/cmd/rabbitmq/credentials/delete/delete_test.go +++ b/internal/cmd/rabbitmq/credentials/delete/delete_test.go @@ -195,7 +195,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/rabbitmq/credentials/describe/describe.go b/internal/cmd/rabbitmq/credentials/describe/describe.go index c70489746..d4b0efbb3 100644 --- a/internal/cmd/rabbitmq/credentials/describe/describe.go +++ b/internal/cmd/rabbitmq/credentials/describe/describe.go @@ -47,7 +47,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -79,17 +79,17 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { credentialsId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), CredentialsId: credentialsId, }, nil } diff --git a/internal/cmd/rabbitmq/credentials/describe/describe_test.go b/internal/cmd/rabbitmq/credentials/describe/describe_test.go index b3bc93579..196808e04 100644 --- a/internal/cmd/rabbitmq/credentials/describe/describe_test.go +++ b/internal/cmd/rabbitmq/credentials/describe/describe_test.go @@ -195,7 +195,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/rabbitmq/credentials/list/list.go b/internal/cmd/rabbitmq/credentials/list/list.go index 047f0b1db..ffb8c88b4 100644 --- a/internal/cmd/rabbitmq/credentials/list/list.go +++ b/internal/cmd/rabbitmq/credentials/list/list.go @@ -49,7 +49,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -70,6 +70,7 @@ func NewCmd(p *print.Printer) *cobra.Command { if len(credentials) == 0 { instanceLabel, err := rabbitmqUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } p.Info("No credentials found for instance %q\n", instanceLabel) @@ -95,13 +96,13 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, @@ -111,7 +112,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), Limit: limit, }, nil } diff --git a/internal/cmd/rabbitmq/credentials/list/list_test.go b/internal/cmd/rabbitmq/credentials/list/list_test.go index ba398c659..a09f19010 100644 --- a/internal/cmd/rabbitmq/credentials/list/list_test.go +++ b/internal/cmd/rabbitmq/credentials/list/list_test.go @@ -159,7 +159,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/rabbitmq/instance/create/create.go b/internal/cmd/rabbitmq/instance/create/create.go index 6ed1cead5..d931f44fc 100644 --- a/internal/cmd/rabbitmq/instance/create/create.go +++ b/internal/cmd/rabbitmq/instance/create/create.go @@ -74,7 +74,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -85,8 +85,9 @@ func NewCmd(p *print.Printer) *cobra.Command { return err } - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } @@ -154,15 +155,15 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &cliErr.ProjectIdError{} } - planId := flags.FlagToStringPointer(cmd, planIdFlag) - planName := flags.FlagToStringValue(cmd, planNameFlag) - version := flags.FlagToStringValue(cmd, versionFlag) + planId := flags.FlagToStringPointer(p, cmd, planIdFlag) + planName := flags.FlagToStringValue(p, cmd, planNameFlag) + version := flags.FlagToStringValue(p, cmd, versionFlag) if planId == nil && (planName == "" || version == "") { return nil, &cliErr.DSAInputPlanError{ @@ -177,15 +178,15 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - InstanceName: flags.FlagToStringPointer(cmd, instanceNameFlag), - EnableMonitoring: flags.FlagToBoolPointer(cmd, enableMonitoringFlag), - MonitoringInstanceId: flags.FlagToStringPointer(cmd, monitoringInstanceIdFlag), - Graphite: flags.FlagToStringPointer(cmd, graphiteFlag), - MetricsFrequency: flags.FlagToInt64Pointer(cmd, metricsFrequencyFlag), - MetricsPrefix: flags.FlagToStringPointer(cmd, metricsPrefixFlag), - Plugin: flags.FlagToStringSlicePointer(cmd, pluginFlag), - SgwAcl: flags.FlagToStringSlicePointer(cmd, sgwAclFlag), - Syslog: flags.FlagToStringSlicePointer(cmd, syslogFlag), + InstanceName: flags.FlagToStringPointer(p, cmd, instanceNameFlag), + EnableMonitoring: flags.FlagToBoolPointer(p, cmd, enableMonitoringFlag), + MonitoringInstanceId: flags.FlagToStringPointer(p, cmd, monitoringInstanceIdFlag), + Graphite: flags.FlagToStringPointer(p, cmd, graphiteFlag), + MetricsFrequency: flags.FlagToInt64Pointer(p, cmd, metricsFrequencyFlag), + MetricsPrefix: flags.FlagToStringPointer(p, cmd, metricsPrefixFlag), + Plugin: flags.FlagToStringSlicePointer(p, cmd, pluginFlag), + SgwAcl: flags.FlagToStringSlicePointer(p, cmd, sgwAclFlag), + Syslog: flags.FlagToStringSlicePointer(p, cmd, syslogFlag), PlanId: planId, PlanName: planName, Version: version, diff --git a/internal/cmd/rabbitmq/instance/create/create_test.go b/internal/cmd/rabbitmq/instance/create/create_test.go index 535db19fd..ab6dded0f 100644 --- a/internal/cmd/rabbitmq/instance/create/create_test.go +++ b/internal/cmd/rabbitmq/instance/create/create_test.go @@ -329,7 +329,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/rabbitmq/instance/delete/delete.go b/internal/cmd/rabbitmq/instance/delete/delete.go index 64411ddb8..fdaee44cf 100644 --- a/internal/cmd/rabbitmq/instance/delete/delete.go +++ b/internal/cmd/rabbitmq/instance/delete/delete.go @@ -41,7 +41,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -54,6 +54,7 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := rabbitmqUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } @@ -94,10 +95,10 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { instanceId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/rabbitmq/instance/delete/delete_test.go b/internal/cmd/rabbitmq/instance/delete/delete_test.go index f9c2f565a..998cd2488 100644 --- a/internal/cmd/rabbitmq/instance/delete/delete_test.go +++ b/internal/cmd/rabbitmq/instance/delete/delete_test.go @@ -168,7 +168,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/rabbitmq/instance/describe/describe.go b/internal/cmd/rabbitmq/instance/describe/describe.go index 3b4f0b200..8b07f8952 100644 --- a/internal/cmd/rabbitmq/instance/describe/describe.go +++ b/internal/cmd/rabbitmq/instance/describe/describe.go @@ -45,7 +45,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -68,10 +68,10 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { instanceId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/rabbitmq/instance/describe/describe_test.go b/internal/cmd/rabbitmq/instance/describe/describe_test.go index 616b7731a..16b688a46 100644 --- a/internal/cmd/rabbitmq/instance/describe/describe_test.go +++ b/internal/cmd/rabbitmq/instance/describe/describe_test.go @@ -168,7 +168,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/rabbitmq/instance/list/list.go b/internal/cmd/rabbitmq/instance/list/list.go index 3258a5444..4e0eb3b2b 100644 --- a/internal/cmd/rabbitmq/instance/list/list.go +++ b/internal/cmd/rabbitmq/instance/list/list.go @@ -47,7 +47,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -66,8 +66,9 @@ func NewCmd(p *print.Printer) *cobra.Command { } instances := *resp.Instances if len(instances) == 0 { - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } p.Info("No instances found for project %q\n", projectLabel) @@ -91,13 +92,13 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().Int64(limitFlag, 0, "Maximum number of entries to list") } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, @@ -107,7 +108,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - Limit: flags.FlagToInt64Pointer(cmd, limitFlag), + Limit: flags.FlagToInt64Pointer(p, cmd, limitFlag), }, nil } diff --git a/internal/cmd/rabbitmq/instance/list/list_test.go b/internal/cmd/rabbitmq/instance/list/list_test.go index e940eb894..19058b50e 100644 --- a/internal/cmd/rabbitmq/instance/list/list_test.go +++ b/internal/cmd/rabbitmq/instance/list/list_test.go @@ -138,7 +138,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/rabbitmq/instance/update/update.go b/internal/cmd/rabbitmq/instance/update/update.go index da36b8663..80183f2bc 100644 --- a/internal/cmd/rabbitmq/instance/update/update.go +++ b/internal/cmd/rabbitmq/instance/update/update.go @@ -72,7 +72,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -85,6 +85,7 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := rabbitmqUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } @@ -148,25 +149,25 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().String(versionFlag, "", "Instance RabbitMQ version") } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { instanceId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &cliErr.ProjectIdError{} } - enableMonitoring := flags.FlagToBoolPointer(cmd, enableMonitoringFlag) - monitoringInstanceId := flags.FlagToStringPointer(cmd, monitoringInstanceIdFlag) - graphite := flags.FlagToStringPointer(cmd, graphiteFlag) - metricsFrequency := flags.FlagToInt64Pointer(cmd, metricsFrequencyFlag) - metricsPrefix := flags.FlagToStringPointer(cmd, metricsPrefixFlag) - plugin := flags.FlagToStringSlicePointer(cmd, pluginFlag) - sgwAcl := flags.FlagToStringSlicePointer(cmd, sgwAclFlag) - syslog := flags.FlagToStringSlicePointer(cmd, syslogFlag) - planId := flags.FlagToStringPointer(cmd, planIdFlag) - planName := flags.FlagToStringValue(cmd, planNameFlag) - version := flags.FlagToStringValue(cmd, versionFlag) + enableMonitoring := flags.FlagToBoolPointer(p, cmd, enableMonitoringFlag) + monitoringInstanceId := flags.FlagToStringPointer(p, cmd, monitoringInstanceIdFlag) + graphite := flags.FlagToStringPointer(p, cmd, graphiteFlag) + metricsFrequency := flags.FlagToInt64Pointer(p, cmd, metricsFrequencyFlag) + metricsPrefix := flags.FlagToStringPointer(p, cmd, metricsPrefixFlag) + plugin := flags.FlagToStringSlicePointer(p, cmd, pluginFlag) + sgwAcl := flags.FlagToStringSlicePointer(p, cmd, sgwAclFlag) + syslog := flags.FlagToStringSlicePointer(p, cmd, syslogFlag) + planId := flags.FlagToStringPointer(p, cmd, planIdFlag) + planName := flags.FlagToStringValue(p, cmd, planNameFlag) + version := flags.FlagToStringValue(p, cmd, versionFlag) if planId != nil && (planName != "" || version != "") { return nil, &cliErr.DSAInputPlanError{ diff --git a/internal/cmd/rabbitmq/instance/update/update_test.go b/internal/cmd/rabbitmq/instance/update/update_test.go index aa169639d..239c5304f 100644 --- a/internal/cmd/rabbitmq/instance/update/update_test.go +++ b/internal/cmd/rabbitmq/instance/update/update_test.go @@ -354,7 +354,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/rabbitmq/plans/plans.go b/internal/cmd/rabbitmq/plans/plans.go index 610533e8b..27ee06607 100644 --- a/internal/cmd/rabbitmq/plans/plans.go +++ b/internal/cmd/rabbitmq/plans/plans.go @@ -47,7 +47,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -66,8 +66,9 @@ func NewCmd(p *print.Printer) *cobra.Command { } plans := *resp.Offerings if len(plans) == 0 { - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } p.Info("No plans found for project %q\n", projectLabel) @@ -91,13 +92,13 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().Int64(limitFlag, 0, "Maximum number of entries to list") } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, diff --git a/internal/cmd/rabbitmq/plans/plans_test.go b/internal/cmd/rabbitmq/plans/plans_test.go index 87319bf6d..ec90c2eb0 100644 --- a/internal/cmd/rabbitmq/plans/plans_test.go +++ b/internal/cmd/rabbitmq/plans/plans_test.go @@ -138,7 +138,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/redis/credentials/create/create.go b/internal/cmd/redis/credentials/create/create.go index 273d1a7c1..db39a1e72 100644 --- a/internal/cmd/redis/credentials/create/create.go +++ b/internal/cmd/redis/credentials/create/create.go @@ -44,7 +44,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -57,6 +57,7 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := redisUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } @@ -104,16 +105,16 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), - HidePassword: flags.FlagToBoolValue(cmd, hidePasswordFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), + HidePassword: flags.FlagToBoolValue(p, cmd, hidePasswordFlag), }, nil } diff --git a/internal/cmd/redis/credentials/create/create_test.go b/internal/cmd/redis/credentials/create/create_test.go index 5f1a247f1..cea83002a 100644 --- a/internal/cmd/redis/credentials/create/create_test.go +++ b/internal/cmd/redis/credentials/create/create_test.go @@ -142,7 +142,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/redis/credentials/delete/delete.go b/internal/cmd/redis/credentials/delete/delete.go index 875d73243..fb7998212 100644 --- a/internal/cmd/redis/credentials/delete/delete.go +++ b/internal/cmd/redis/credentials/delete/delete.go @@ -43,7 +43,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -56,11 +56,13 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := redisUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } credentialsLabel, err := redisUtils.GetCredentialsUsername(ctx, apiClient, model.ProjectId, model.InstanceId, model.CredentialsId) if err != nil { + p.Debug(print.ErrorLevel, "get credentials user name: %v", err) credentialsLabel = model.CredentialsId } @@ -94,17 +96,17 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { credentialsId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), CredentialsId: credentialsId, }, nil } diff --git a/internal/cmd/redis/credentials/delete/delete_test.go b/internal/cmd/redis/credentials/delete/delete_test.go index 575dac9f0..f43d60560 100644 --- a/internal/cmd/redis/credentials/delete/delete_test.go +++ b/internal/cmd/redis/credentials/delete/delete_test.go @@ -195,7 +195,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/redis/credentials/describe/describe.go b/internal/cmd/redis/credentials/describe/describe.go index 848813908..fd19846a3 100644 --- a/internal/cmd/redis/credentials/describe/describe.go +++ b/internal/cmd/redis/credentials/describe/describe.go @@ -47,7 +47,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -79,17 +79,17 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { credentialsId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), CredentialsId: credentialsId, }, nil } diff --git a/internal/cmd/redis/credentials/describe/describe_test.go b/internal/cmd/redis/credentials/describe/describe_test.go index 45f2fa6f5..783ceb69e 100644 --- a/internal/cmd/redis/credentials/describe/describe_test.go +++ b/internal/cmd/redis/credentials/describe/describe_test.go @@ -195,7 +195,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/redis/credentials/list/list.go b/internal/cmd/redis/credentials/list/list.go index d3972638e..f1dda3102 100644 --- a/internal/cmd/redis/credentials/list/list.go +++ b/internal/cmd/redis/credentials/list/list.go @@ -49,7 +49,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -70,6 +70,7 @@ func NewCmd(p *print.Printer) *cobra.Command { if len(credentials) == 0 { instanceLabel, err := redisUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } p.Info("No credentials found for instance %q\n", instanceLabel) @@ -95,13 +96,13 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, @@ -111,7 +112,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), Limit: limit, }, nil } diff --git a/internal/cmd/redis/credentials/list/list_test.go b/internal/cmd/redis/credentials/list/list_test.go index 749a288d3..0dba8e057 100644 --- a/internal/cmd/redis/credentials/list/list_test.go +++ b/internal/cmd/redis/credentials/list/list_test.go @@ -159,7 +159,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/redis/instance/create/create.go b/internal/cmd/redis/instance/create/create.go index 01a2635da..0843bcbdf 100644 --- a/internal/cmd/redis/instance/create/create.go +++ b/internal/cmd/redis/instance/create/create.go @@ -72,7 +72,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -83,8 +83,9 @@ func NewCmd(p *print.Printer) *cobra.Command { return err } - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } @@ -151,15 +152,15 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &cliErr.ProjectIdError{} } - planId := flags.FlagToStringPointer(cmd, planIdFlag) - planName := flags.FlagToStringValue(cmd, planNameFlag) - version := flags.FlagToStringValue(cmd, versionFlag) + planId := flags.FlagToStringPointer(p, cmd, planIdFlag) + planName := flags.FlagToStringValue(p, cmd, planNameFlag) + version := flags.FlagToStringValue(p, cmd, versionFlag) if planId == nil && (planName == "" || version == "") { return nil, &cliErr.DSAInputPlanError{ @@ -174,14 +175,14 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - InstanceName: flags.FlagToStringPointer(cmd, instanceNameFlag), - EnableMonitoring: flags.FlagToBoolPointer(cmd, enableMonitoringFlag), - MonitoringInstanceId: flags.FlagToStringPointer(cmd, monitoringInstanceIdFlag), - Graphite: flags.FlagToStringPointer(cmd, graphiteFlag), - MetricsFrequency: flags.FlagToInt64Pointer(cmd, metricsFrequencyFlag), - MetricsPrefix: flags.FlagToStringPointer(cmd, metricsPrefixFlag), - SgwAcl: flags.FlagToStringSlicePointer(cmd, sgwAclFlag), - Syslog: flags.FlagToStringSlicePointer(cmd, syslogFlag), + InstanceName: flags.FlagToStringPointer(p, cmd, instanceNameFlag), + EnableMonitoring: flags.FlagToBoolPointer(p, cmd, enableMonitoringFlag), + MonitoringInstanceId: flags.FlagToStringPointer(p, cmd, monitoringInstanceIdFlag), + Graphite: flags.FlagToStringPointer(p, cmd, graphiteFlag), + MetricsFrequency: flags.FlagToInt64Pointer(p, cmd, metricsFrequencyFlag), + MetricsPrefix: flags.FlagToStringPointer(p, cmd, metricsPrefixFlag), + SgwAcl: flags.FlagToStringSlicePointer(p, cmd, sgwAclFlag), + Syslog: flags.FlagToStringSlicePointer(p, cmd, syslogFlag), PlanId: planId, PlanName: planName, Version: version, diff --git a/internal/cmd/redis/instance/create/create_test.go b/internal/cmd/redis/instance/create/create_test.go index b96d6a5f7..924460cd4 100644 --- a/internal/cmd/redis/instance/create/create_test.go +++ b/internal/cmd/redis/instance/create/create_test.go @@ -304,7 +304,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/redis/instance/delete/delete.go b/internal/cmd/redis/instance/delete/delete.go index 9f424d480..01ca6a7f7 100644 --- a/internal/cmd/redis/instance/delete/delete.go +++ b/internal/cmd/redis/instance/delete/delete.go @@ -41,7 +41,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -54,6 +54,7 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := redisUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } @@ -94,10 +95,10 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { instanceId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/redis/instance/delete/delete_test.go b/internal/cmd/redis/instance/delete/delete_test.go index e1e637428..9bd8fb11d 100644 --- a/internal/cmd/redis/instance/delete/delete_test.go +++ b/internal/cmd/redis/instance/delete/delete_test.go @@ -168,7 +168,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/redis/instance/describe/describe.go b/internal/cmd/redis/instance/describe/describe.go index 29631c017..238672eb2 100644 --- a/internal/cmd/redis/instance/describe/describe.go +++ b/internal/cmd/redis/instance/describe/describe.go @@ -45,7 +45,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -68,10 +68,10 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { instanceId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/redis/instance/describe/describe_test.go b/internal/cmd/redis/instance/describe/describe_test.go index d19561e30..d0a69f98d 100644 --- a/internal/cmd/redis/instance/describe/describe_test.go +++ b/internal/cmd/redis/instance/describe/describe_test.go @@ -168,7 +168,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/redis/instance/list/list.go b/internal/cmd/redis/instance/list/list.go index eac41d481..da0542071 100644 --- a/internal/cmd/redis/instance/list/list.go +++ b/internal/cmd/redis/instance/list/list.go @@ -47,7 +47,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -66,8 +66,9 @@ func NewCmd(p *print.Printer) *cobra.Command { } instances := *resp.Instances if len(instances) == 0 { - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } p.Info("No instances found for project %q\n", projectLabel) @@ -91,13 +92,13 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().Int64(limitFlag, 0, "Maximum number of entries to list") } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, @@ -107,7 +108,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - Limit: flags.FlagToInt64Pointer(cmd, limitFlag), + Limit: flags.FlagToInt64Pointer(p, cmd, limitFlag), }, nil } diff --git a/internal/cmd/redis/instance/list/list_test.go b/internal/cmd/redis/instance/list/list_test.go index 9a8ffc30b..f04edf436 100644 --- a/internal/cmd/redis/instance/list/list_test.go +++ b/internal/cmd/redis/instance/list/list_test.go @@ -138,7 +138,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/redis/instance/update/update.go b/internal/cmd/redis/instance/update/update.go index 3857e6fd3..076222ea2 100644 --- a/internal/cmd/redis/instance/update/update.go +++ b/internal/cmd/redis/instance/update/update.go @@ -69,7 +69,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -82,6 +82,7 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := redisUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } @@ -144,24 +145,24 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().String(versionFlag, "", "Instance Redis version") } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { instanceId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &cliErr.ProjectIdError{} } - enableMonitoring := flags.FlagToBoolPointer(cmd, enableMonitoringFlag) - monitoringInstanceId := flags.FlagToStringPointer(cmd, monitoringInstanceIdFlag) - graphite := flags.FlagToStringPointer(cmd, graphiteFlag) - metricsFrequency := flags.FlagToInt64Pointer(cmd, metricsFrequencyFlag) - metricsPrefix := flags.FlagToStringPointer(cmd, metricsPrefixFlag) - sgwAcl := flags.FlagToStringSlicePointer(cmd, sgwAclFlag) - syslog := flags.FlagToStringSlicePointer(cmd, syslogFlag) - planId := flags.FlagToStringPointer(cmd, planIdFlag) - planName := flags.FlagToStringValue(cmd, planNameFlag) - version := flags.FlagToStringValue(cmd, versionFlag) + enableMonitoring := flags.FlagToBoolPointer(p, cmd, enableMonitoringFlag) + monitoringInstanceId := flags.FlagToStringPointer(p, cmd, monitoringInstanceIdFlag) + graphite := flags.FlagToStringPointer(p, cmd, graphiteFlag) + metricsFrequency := flags.FlagToInt64Pointer(p, cmd, metricsFrequencyFlag) + metricsPrefix := flags.FlagToStringPointer(p, cmd, metricsPrefixFlag) + sgwAcl := flags.FlagToStringSlicePointer(p, cmd, sgwAclFlag) + syslog := flags.FlagToStringSlicePointer(p, cmd, syslogFlag) + planId := flags.FlagToStringPointer(p, cmd, planIdFlag) + planName := flags.FlagToStringValue(p, cmd, planNameFlag) + version := flags.FlagToStringValue(p, cmd, versionFlag) if planId != nil && (planName != "" || version != "") { return nil, &cliErr.DSAInputPlanError{ diff --git a/internal/cmd/redis/instance/update/update_test.go b/internal/cmd/redis/instance/update/update_test.go index 732158cd4..07eb331e3 100644 --- a/internal/cmd/redis/instance/update/update_test.go +++ b/internal/cmd/redis/instance/update/update_test.go @@ -328,7 +328,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/redis/plans/plans.go b/internal/cmd/redis/plans/plans.go index 18c043710..5834ebb0f 100644 --- a/internal/cmd/redis/plans/plans.go +++ b/internal/cmd/redis/plans/plans.go @@ -47,7 +47,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -66,8 +66,9 @@ func NewCmd(p *print.Printer) *cobra.Command { } plans := *resp.Offerings if len(plans) == 0 { - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } p.Info("No plans found for project %q\n", projectLabel) @@ -91,13 +92,13 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().Int64(limitFlag, 0, "Maximum number of entries to list") } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, diff --git a/internal/cmd/redis/plans/plans_test.go b/internal/cmd/redis/plans/plans_test.go index 43b6f9577..872386f44 100644 --- a/internal/cmd/redis/plans/plans_test.go +++ b/internal/cmd/redis/plans/plans_test.go @@ -138,7 +138,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/root.go b/internal/cmd/root.go index f7885bfb6..d72c61eac 100644 --- a/internal/cmd/root.go +++ b/internal/cmd/root.go @@ -44,10 +44,10 @@ func NewRootCmd(version, date string, p *print.Printer) *cobra.Command { DisableAutoGenTag: true, PersistentPreRun: func(cmd *cobra.Command, args []string) { p.Cmd = cmd - p.Verbosity = print.Level(globalflags.Parse(cmd).Verbosity) + p.Verbosity = print.Level(globalflags.Parse(p, cmd).Verbosity) }, RunE: func(cmd *cobra.Command, args []string) error { - if flags.FlagToBoolValue(cmd, "version") { + if flags.FlagToBoolValue(p, cmd, "version") { p.Outputf("STACKIT CLI (BETA)\n") parsedDate, err := time.Parse(time.RFC3339, date) @@ -131,6 +131,7 @@ func Execute(version, date string) { if err != nil { err := beautifyUnknownAndMissingCommandsError(cmd, err) p.Error(err.Error()) + p.Debug(print.ErrorLevel, "execute command: %v", err) os.Exit(1) } } diff --git a/internal/cmd/secrets-manager/instance/create/create.go b/internal/cmd/secrets-manager/instance/create/create.go index 7a6d80886..8d0539d33 100644 --- a/internal/cmd/secrets-manager/instance/create/create.go +++ b/internal/cmd/secrets-manager/instance/create/create.go @@ -47,7 +47,7 @@ func NewCmd(p *print.Printer) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -58,8 +58,9 @@ func NewCmd(p *print.Printer) *cobra.Command { return err } - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } @@ -107,16 +108,16 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &cliErr.ProjectIdError{} } return &inputModel{ GlobalFlagModel: globalFlags, - InstanceName: flags.FlagToStringPointer(cmd, instanceNameFlag), - Acls: flags.FlagToStringSlicePointer(cmd, aclFlag), + InstanceName: flags.FlagToStringPointer(p, cmd, instanceNameFlag), + Acls: flags.FlagToStringSlicePointer(p, cmd, aclFlag), }, nil } diff --git a/internal/cmd/secrets-manager/instance/create/create_test.go b/internal/cmd/secrets-manager/instance/create/create_test.go index 76375bc58..a0c683046 100644 --- a/internal/cmd/secrets-manager/instance/create/create_test.go +++ b/internal/cmd/secrets-manager/instance/create/create_test.go @@ -216,7 +216,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/secrets-manager/instance/delete/delete.go b/internal/cmd/secrets-manager/instance/delete/delete.go index 42fff7fb4..71056b0ef 100644 --- a/internal/cmd/secrets-manager/instance/delete/delete.go +++ b/internal/cmd/secrets-manager/instance/delete/delete.go @@ -38,7 +38,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -51,6 +51,7 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := secretsmanagerUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } @@ -76,10 +77,10 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { instanceId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/secrets-manager/instance/delete/delete_test.go b/internal/cmd/secrets-manager/instance/delete/delete_test.go index 3fa907dfe..76cb22186 100644 --- a/internal/cmd/secrets-manager/instance/delete/delete_test.go +++ b/internal/cmd/secrets-manager/instance/delete/delete_test.go @@ -168,7 +168,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/secrets-manager/instance/describe/describe.go b/internal/cmd/secrets-manager/instance/describe/describe.go index bcfe42cbb..f54046574 100644 --- a/internal/cmd/secrets-manager/instance/describe/describe.go +++ b/internal/cmd/secrets-manager/instance/describe/describe.go @@ -44,7 +44,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -74,10 +74,10 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { instanceId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/secrets-manager/instance/describe/describe_test.go b/internal/cmd/secrets-manager/instance/describe/describe_test.go index 6ec20eb30..f6a20ffd5 100644 --- a/internal/cmd/secrets-manager/instance/describe/describe_test.go +++ b/internal/cmd/secrets-manager/instance/describe/describe_test.go @@ -176,7 +176,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/secrets-manager/instance/list/list.go b/internal/cmd/secrets-manager/instance/list/list.go index 57e6a5fe3..6a2481253 100644 --- a/internal/cmd/secrets-manager/instance/list/list.go +++ b/internal/cmd/secrets-manager/instance/list/list.go @@ -47,7 +47,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -66,8 +66,9 @@ func NewCmd(p *print.Printer) *cobra.Command { } if resp.Instances == nil || len(*resp.Instances) == 0 { - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } p.Info("No instances found for project %q\n", projectLabel) @@ -92,13 +93,13 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().Int64(limitFlag, 0, "Maximum number of entries to list") } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, diff --git a/internal/cmd/secrets-manager/instance/list/list_test.go b/internal/cmd/secrets-manager/instance/list/list_test.go index bc27b6ae4..fac95fa11 100644 --- a/internal/cmd/secrets-manager/instance/list/list_test.go +++ b/internal/cmd/secrets-manager/instance/list/list_test.go @@ -148,7 +148,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/secrets-manager/instance/update/update.go b/internal/cmd/secrets-manager/instance/update/update.go index 365477ea3..864afa60d 100644 --- a/internal/cmd/secrets-manager/instance/update/update.go +++ b/internal/cmd/secrets-manager/instance/update/update.go @@ -45,7 +45,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -58,6 +58,7 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := secretsManagerUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } @@ -88,15 +89,15 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().Var(flags.CIDRSliceFlag(), aclFlag, "List of IP networks in CIDR notation which are allowed to access this instance") } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { instanceId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &cliErr.ProjectIdError{} } - acls := flags.FlagToStringSlicePointer(cmd, aclFlag) + acls := flags.FlagToStringSlicePointer(p, cmd, aclFlag) if acls == nil { return nil, &cliErr.EmptyUpdateError{} diff --git a/internal/cmd/secrets-manager/instance/update/update_test.go b/internal/cmd/secrets-manager/instance/update/update_test.go index fb858ebdc..6348a423a 100644 --- a/internal/cmd/secrets-manager/instance/update/update_test.go +++ b/internal/cmd/secrets-manager/instance/update/update_test.go @@ -238,7 +238,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/secrets-manager/user/create/create.go b/internal/cmd/secrets-manager/user/create/create.go index 35ea18110..da9d4597f 100644 --- a/internal/cmd/secrets-manager/user/create/create.go +++ b/internal/cmd/secrets-manager/user/create/create.go @@ -52,7 +52,7 @@ func NewCmd(p *print.Printer) *cobra.Command { Args: args.NoArgs, RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -65,6 +65,7 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := secretsManagerUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } @@ -106,17 +107,17 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), - Description: utils.Ptr(flags.FlagToStringValue(cmd, descriptionFlag)), - Write: utils.Ptr(flags.FlagToBoolValue(cmd, writeFlag)), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), + Description: utils.Ptr(flags.FlagToStringValue(p, cmd, descriptionFlag)), + Write: utils.Ptr(flags.FlagToBoolValue(p, cmd, writeFlag)), }, nil } diff --git a/internal/cmd/secrets-manager/user/create/create_test.go b/internal/cmd/secrets-manager/user/create/create_test.go index d88b94e2a..f4fa06f4c 100644 --- a/internal/cmd/secrets-manager/user/create/create_test.go +++ b/internal/cmd/secrets-manager/user/create/create_test.go @@ -177,7 +177,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/secrets-manager/user/delete/delete.go b/internal/cmd/secrets-manager/user/delete/delete.go index c2967c96b..3348e15b4 100644 --- a/internal/cmd/secrets-manager/user/delete/delete.go +++ b/internal/cmd/secrets-manager/user/delete/delete.go @@ -47,7 +47,7 @@ func NewCmd(p *print.Printer) *cobra.Command { Args: args.SingleArg(userIdArg, utils.ValidateUUID), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -60,11 +60,13 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := secretsManagerUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } userLabel, err := secretsManagerUtils.GetUserLabel(ctx, apiClient, model.ProjectId, model.InstanceId, model.UserId) if err != nil { + p.Debug(print.ErrorLevel, "get user label: %v", err) userLabel = fmt.Sprintf("%q", model.UserId) } @@ -98,17 +100,17 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { userId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), UserId: userId, }, nil } diff --git a/internal/cmd/secrets-manager/user/delete/delete_test.go b/internal/cmd/secrets-manager/user/delete/delete_test.go index 0b4605d6d..40d597efb 100644 --- a/internal/cmd/secrets-manager/user/delete/delete_test.go +++ b/internal/cmd/secrets-manager/user/delete/delete_test.go @@ -183,7 +183,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/secrets-manager/user/describe/describe.go b/internal/cmd/secrets-manager/user/describe/describe.go index c43fe6f08..ff6763c74 100644 --- a/internal/cmd/secrets-manager/user/describe/describe.go +++ b/internal/cmd/secrets-manager/user/describe/describe.go @@ -48,7 +48,7 @@ func NewCmd(p *print.Printer) *cobra.Command { Args: args.SingleArg(userIdArg, utils.ValidateUUID), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -81,17 +81,17 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { userId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), UserId: userId, }, nil } diff --git a/internal/cmd/secrets-manager/user/describe/describe_test.go b/internal/cmd/secrets-manager/user/describe/describe_test.go index e9c055f93..c694d672e 100644 --- a/internal/cmd/secrets-manager/user/describe/describe_test.go +++ b/internal/cmd/secrets-manager/user/describe/describe_test.go @@ -195,7 +195,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/secrets-manager/user/list/list.go b/internal/cmd/secrets-manager/user/list/list.go index d5d9440ca..6dc0c64a9 100644 --- a/internal/cmd/secrets-manager/user/list/list.go +++ b/internal/cmd/secrets-manager/user/list/list.go @@ -50,7 +50,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -70,6 +70,7 @@ func NewCmd(p *print.Printer) *cobra.Command { if resp.Users == nil || len(*resp.Users) == 0 { instanceLabel, err := secretsManagerUtils.GetInstanceName(ctx, apiClient, model.ProjectId, *model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = *model.InstanceId } p.Info("No users found for instance %q\n", instanceLabel) @@ -98,13 +99,13 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, @@ -114,8 +115,8 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringPointer(cmd, instanceIdFlag), - Limit: flags.FlagToInt64Pointer(cmd, limitFlag), + InstanceId: flags.FlagToStringPointer(p, cmd, instanceIdFlag), + Limit: flags.FlagToInt64Pointer(p, cmd, limitFlag), }, nil } diff --git a/internal/cmd/secrets-manager/user/list/list_test.go b/internal/cmd/secrets-manager/user/list/list_test.go index b3e764903..8a8bbb08f 100644 --- a/internal/cmd/secrets-manager/user/list/list_test.go +++ b/internal/cmd/secrets-manager/user/list/list_test.go @@ -155,7 +155,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/secrets-manager/user/update/update.go b/internal/cmd/secrets-manager/user/update/update.go index 53a711592..8f8bcb824 100644 --- a/internal/cmd/secrets-manager/user/update/update.go +++ b/internal/cmd/secrets-manager/user/update/update.go @@ -51,7 +51,7 @@ func NewCmd(p *print.Printer) *cobra.Command { Args: args.SingleArg(userIdArg, utils.ValidateUUID), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -64,11 +64,13 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := secretsManagerUtils.GetInstanceName(ctx, apiClient, model.ProjectId, model.InstanceId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } userLabel, err := secretsManagerUtils.GetUserLabel(ctx, apiClient, model.ProjectId, model.InstanceId, model.UserId) if err != nil { + p.Debug(print.ErrorLevel, "get user label: %v", err) userLabel = fmt.Sprintf("%q", model.UserId) } @@ -111,16 +113,16 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { userId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - enableWrite := flags.FlagToBoolPointer(cmd, enableWriteFlag) - disableWrite := flags.FlagToBoolPointer(cmd, disableWriteFlag) + enableWrite := flags.FlagToBoolPointer(p, cmd, enableWriteFlag) + disableWrite := flags.FlagToBoolPointer(p, cmd, disableWriteFlag) if enableWrite == nil && disableWrite == nil { return nil, &errors.EmptyUpdateError{} @@ -128,7 +130,7 @@ func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), EnableWrite: enableWrite, DisableWrite: disableWrite, UserId: userId, diff --git a/internal/cmd/secrets-manager/user/update/update_test.go b/internal/cmd/secrets-manager/user/update/update_test.go index 8d39b9c36..412e86dd7 100644 --- a/internal/cmd/secrets-manager/user/update/update_test.go +++ b/internal/cmd/secrets-manager/user/update/update_test.go @@ -227,7 +227,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flag groups: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/service-account/create/create.go b/internal/cmd/service-account/create/create.go index 39931160e..aa622af30 100644 --- a/internal/cmd/service-account/create/create.go +++ b/internal/cmd/service-account/create/create.go @@ -39,7 +39,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -50,8 +50,9 @@ func NewCmd(p *print.Printer) *cobra.Command { return err } - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } @@ -85,15 +86,15 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } return &inputModel{ GlobalFlagModel: globalFlags, - Name: flags.FlagToStringPointer(cmd, nameFlag), + Name: flags.FlagToStringPointer(p, cmd, nameFlag), }, nil } diff --git a/internal/cmd/service-account/create/create_test.go b/internal/cmd/service-account/create/create_test.go index 66c3da314..76880105e 100644 --- a/internal/cmd/service-account/create/create_test.go +++ b/internal/cmd/service-account/create/create_test.go @@ -139,7 +139,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/service-account/delete/delete.go b/internal/cmd/service-account/delete/delete.go index cb8b525c7..55b458e23 100644 --- a/internal/cmd/service-account/delete/delete.go +++ b/internal/cmd/service-account/delete/delete.go @@ -37,7 +37,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -73,10 +73,10 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { email := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/service-account/delete/delete_test.go b/internal/cmd/service-account/delete/delete_test.go index 8653abe86..0635db4e3 100644 --- a/internal/cmd/service-account/delete/delete_test.go +++ b/internal/cmd/service-account/delete/delete_test.go @@ -156,7 +156,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/service-account/key/create/create.go b/internal/cmd/service-account/key/create/create.go index d2efaa40f..a04b519e5 100644 --- a/internal/cmd/service-account/key/create/create.go +++ b/internal/cmd/service-account/key/create/create.go @@ -56,7 +56,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -110,13 +110,13 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - email := flags.FlagToStringValue(cmd, serviceAccountEmailFlag) + email := flags.FlagToStringValue(p, cmd, serviceAccountEmailFlag) if email == "" { return nil, &errors.FlagValidationError{ Flag: serviceAccountEmailFlag, @@ -124,7 +124,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { } } - expriresInDays := flags.FlagToInt64Pointer(cmd, expiredInDaysFlag) + expriresInDays := flags.FlagToInt64Pointer(p, cmd, expiredInDaysFlag) if expriresInDays != nil && *expriresInDays < 1 { return nil, &errors.FlagValidationError{ Flag: expiredInDaysFlag, @@ -136,7 +136,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { GlobalFlagModel: globalFlags, ServiceAccountEmail: email, ExpiresInDays: expriresInDays, - PublicKey: flags.FlagToStringPointer(cmd, publicKeyFlag), + PublicKey: flags.FlagToStringPointer(p, cmd, publicKeyFlag), }, nil } diff --git a/internal/cmd/service-account/key/create/create_test.go b/internal/cmd/service-account/key/create/create_test.go index 1a621d14b..33f0adf5e 100644 --- a/internal/cmd/service-account/key/create/create_test.go +++ b/internal/cmd/service-account/key/create/create_test.go @@ -164,7 +164,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/service-account/key/delete/delete.go b/internal/cmd/service-account/key/delete/delete.go index b438fc13d..a90e83e19 100644 --- a/internal/cmd/service-account/key/delete/delete.go +++ b/internal/cmd/service-account/key/delete/delete.go @@ -43,7 +43,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -85,15 +85,15 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { keyId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - email := flags.FlagToStringValue(cmd, serviceAccountEmailFlag) + email := flags.FlagToStringValue(p, cmd, serviceAccountEmailFlag) if email == "" { return nil, &errors.FlagValidationError{ Flag: serviceAccountEmailFlag, diff --git a/internal/cmd/service-account/key/delete/delete_test.go b/internal/cmd/service-account/key/delete/delete_test.go index 056e8c04c..50ae43fa2 100644 --- a/internal/cmd/service-account/key/delete/delete_test.go +++ b/internal/cmd/service-account/key/delete/delete_test.go @@ -179,7 +179,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/service-account/key/describe/describe.go b/internal/cmd/service-account/key/describe/describe.go index 18280e676..1d746437a 100644 --- a/internal/cmd/service-account/key/describe/describe.go +++ b/internal/cmd/service-account/key/describe/describe.go @@ -44,7 +44,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -75,15 +75,15 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { keyId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - email := flags.FlagToStringValue(cmd, serviceAccountEmailFlag) + email := flags.FlagToStringValue(p, cmd, serviceAccountEmailFlag) if email == "" { return nil, &errors.FlagValidationError{ Flag: serviceAccountEmailFlag, diff --git a/internal/cmd/service-account/key/describe/describe_test.go b/internal/cmd/service-account/key/describe/describe_test.go index 06797196d..f070a7efc 100644 --- a/internal/cmd/service-account/key/describe/describe_test.go +++ b/internal/cmd/service-account/key/describe/describe_test.go @@ -179,7 +179,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/service-account/key/list/list.go b/internal/cmd/service-account/key/list/list.go index 69c2b3667..e148f615e 100644 --- a/internal/cmd/service-account/key/list/list.go +++ b/internal/cmd/service-account/key/list/list.go @@ -49,7 +49,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -93,13 +93,13 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - email := flags.FlagToStringValue(cmd, serviceAccountEmailFlag) + email := flags.FlagToStringValue(p, cmd, serviceAccountEmailFlag) if email == "" { return nil, &errors.FlagValidationError{ Flag: serviceAccountEmailFlag, @@ -107,7 +107,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { } } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, diff --git a/internal/cmd/service-account/key/list/list_test.go b/internal/cmd/service-account/key/list/list_test.go index 574480c63..7750cc17a 100644 --- a/internal/cmd/service-account/key/list/list_test.go +++ b/internal/cmd/service-account/key/list/list_test.go @@ -148,7 +148,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/service-account/key/update/update.go b/internal/cmd/service-account/key/update/update.go index 2aeda0da6..b39cca63c 100644 --- a/internal/cmd/service-account/key/update/update.go +++ b/internal/cmd/service-account/key/update/update.go @@ -60,7 +60,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -109,15 +109,15 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { keyId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - email := flags.FlagToStringValue(cmd, serviceAccountEmailFlag) + email := flags.FlagToStringValue(p, cmd, serviceAccountEmailFlag) if email == "" { return nil, &errors.FlagValidationError{ Flag: serviceAccountEmailFlag, @@ -125,7 +125,7 @@ func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { } } - expriresInDays := flags.FlagToInt64Pointer(cmd, expiredInDaysFlag) + expriresInDays := flags.FlagToInt64Pointer(p, cmd, expiredInDaysFlag) if expriresInDays != nil && *expriresInDays < 1 { return nil, &errors.FlagValidationError{ Flag: expiredInDaysFlag, @@ -133,8 +133,8 @@ func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { } } - activate := flags.FlagToBoolValue(cmd, activateFlag) - deactivate := flags.FlagToBoolValue(cmd, deactivateFlag) + activate := flags.FlagToBoolValue(p, cmd, activateFlag) + deactivate := flags.FlagToBoolValue(p, cmd, deactivateFlag) if activate && deactivate { return nil, fmt.Errorf("only one of %q and %q can be set", activateFlag, deactivateFlag) } diff --git a/internal/cmd/service-account/key/update/update_test.go b/internal/cmd/service-account/key/update/update_test.go index 9e15d4d14..8e94fe764 100644 --- a/internal/cmd/service-account/key/update/update_test.go +++ b/internal/cmd/service-account/key/update/update_test.go @@ -226,7 +226,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/service-account/list/list.go b/internal/cmd/service-account/list/list.go index b9f3377c5..d41304913 100644 --- a/internal/cmd/service-account/list/list.go +++ b/internal/cmd/service-account/list/list.go @@ -41,7 +41,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -60,8 +60,9 @@ func NewCmd(p *print.Printer) *cobra.Command { } serviceAccounts := *resp.Items if len(serviceAccounts) == 0 { - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } p.Info("No service accounts found for project %q\n", projectLabel) @@ -85,13 +86,13 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().Int64(limitFlag, 0, "Maximum number of entries to list") } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, @@ -101,7 +102,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - Limit: flags.FlagToInt64Pointer(cmd, limitFlag), + Limit: flags.FlagToInt64Pointer(p, cmd, limitFlag), }, nil } diff --git a/internal/cmd/service-account/list/list_test.go b/internal/cmd/service-account/list/list_test.go index e853aad3d..37ccd4bc6 100644 --- a/internal/cmd/service-account/list/list_test.go +++ b/internal/cmd/service-account/list/list_test.go @@ -138,7 +138,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/service-account/token/create/create.go b/internal/cmd/service-account/token/create/create.go index 66f0ab53c..351f1544e 100644 --- a/internal/cmd/service-account/token/create/create.go +++ b/internal/cmd/service-account/token/create/create.go @@ -50,7 +50,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -95,13 +95,13 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - email := flags.FlagToStringValue(cmd, serviceAccountEmailFlag) + email := flags.FlagToStringValue(p, cmd, serviceAccountEmailFlag) if email == "" { return nil, &errors.FlagValidationError{ Flag: serviceAccountEmailFlag, @@ -109,7 +109,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { } } - ttlDays := flags.FlagWithDefaultToInt64Value(cmd, ttlDaysFlag) + ttlDays := flags.FlagWithDefaultToInt64Value(p, cmd, ttlDaysFlag) if ttlDays < 1 { return nil, &errors.FlagValidationError{ Flag: serviceAccountEmailFlag, diff --git a/internal/cmd/service-account/token/create/create_test.go b/internal/cmd/service-account/token/create/create_test.go index edaeca401..76c9d2a84 100644 --- a/internal/cmd/service-account/token/create/create_test.go +++ b/internal/cmd/service-account/token/create/create_test.go @@ -143,7 +143,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/service-account/token/list/list.go b/internal/cmd/service-account/token/list/list.go index cf9323ee0..d9162c679 100644 --- a/internal/cmd/service-account/token/list/list.go +++ b/internal/cmd/service-account/token/list/list.go @@ -53,7 +53,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -97,13 +97,13 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - email := flags.FlagToStringValue(cmd, serviceAccountEmailFlag) + email := flags.FlagToStringValue(p, cmd, serviceAccountEmailFlag) if email == "" { return nil, &errors.FlagValidationError{ Flag: serviceAccountEmailFlag, @@ -111,7 +111,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { } } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, diff --git a/internal/cmd/service-account/token/list/list_test.go b/internal/cmd/service-account/token/list/list_test.go index 2f577572f..472a23dac 100644 --- a/internal/cmd/service-account/token/list/list_test.go +++ b/internal/cmd/service-account/token/list/list_test.go @@ -148,7 +148,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/service-account/token/revoke/revoke.go b/internal/cmd/service-account/token/revoke/revoke.go index 3ce6f0ef7..5572eefaa 100644 --- a/internal/cmd/service-account/token/revoke/revoke.go +++ b/internal/cmd/service-account/token/revoke/revoke.go @@ -46,7 +46,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -88,15 +88,15 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { tokenId := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - email := flags.FlagToStringValue(cmd, serviceAccountEmailFlag) + email := flags.FlagToStringValue(p, cmd, serviceAccountEmailFlag) if email == "" { return nil, &errors.FlagValidationError{ Flag: serviceAccountEmailFlag, diff --git a/internal/cmd/service-account/token/revoke/revoke_test.go b/internal/cmd/service-account/token/revoke/revoke_test.go index 824f210d5..1bc62f194 100644 --- a/internal/cmd/service-account/token/revoke/revoke_test.go +++ b/internal/cmd/service-account/token/revoke/revoke_test.go @@ -179,7 +179,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/ske/cluster/create/create.go b/internal/cmd/ske/cluster/create/create.go index 26ced6182..05c5af178 100644 --- a/internal/cmd/ske/cluster/create/create.go +++ b/internal/cmd/ske/cluster/create/create.go @@ -61,7 +61,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -72,8 +72,9 @@ func NewCmd(p *print.Printer) *cobra.Command { return err } - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } @@ -147,15 +148,15 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().Var(flags.ReadFromFileFlag(), payloadFlag, `Request payload (JSON). Can be a string or a file path, if prefixed with "@" (example: @./payload.json). If unset, will use a default payload (you can check it by running "stackit ske cluster generate-payload")`) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { clusterName := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - payloadValue := flags.FlagToStringPointer(cmd, payloadFlag) + payloadValue := flags.FlagToStringPointer(p, cmd, payloadFlag) var payload *ske.CreateOrUpdateClusterPayload if payloadValue != nil { payload = &ske.CreateOrUpdateClusterPayload{} diff --git a/internal/cmd/ske/cluster/create/create_test.go b/internal/cmd/ske/cluster/create/create_test.go index 2583bb864..9cddc018c 100644 --- a/internal/cmd/ske/cluster/create/create_test.go +++ b/internal/cmd/ske/cluster/create/create_test.go @@ -265,7 +265,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/ske/cluster/delete/delete.go b/internal/cmd/ske/cluster/delete/delete.go index 83e3c574e..e131f667c 100644 --- a/internal/cmd/ske/cluster/delete/delete.go +++ b/internal/cmd/ske/cluster/delete/delete.go @@ -39,7 +39,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -87,10 +87,10 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { clusterName := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/ske/cluster/delete/delete_test.go b/internal/cmd/ske/cluster/delete/delete_test.go index cb2d3aca0..ff54db6c2 100644 --- a/internal/cmd/ske/cluster/delete/delete_test.go +++ b/internal/cmd/ske/cluster/delete/delete_test.go @@ -156,7 +156,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/ske/cluster/describe/describe.go b/internal/cmd/ske/cluster/describe/describe.go index 0f6804914..3283fb706 100644 --- a/internal/cmd/ske/cluster/describe/describe.go +++ b/internal/cmd/ske/cluster/describe/describe.go @@ -42,7 +42,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -65,10 +65,10 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { clusterName := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/ske/cluster/describe/describe_test.go b/internal/cmd/ske/cluster/describe/describe_test.go index 833db3b0e..a2d468d44 100644 --- a/internal/cmd/ske/cluster/describe/describe_test.go +++ b/internal/cmd/ske/cluster/describe/describe_test.go @@ -156,7 +156,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/ske/cluster/generate-payload/generate_payload.go b/internal/cmd/ske/cluster/generate-payload/generate_payload.go index 195255455..f3e3cc87d 100644 --- a/internal/cmd/ske/cluster/generate-payload/generate_payload.go +++ b/internal/cmd/ske/cluster/generate-payload/generate_payload.go @@ -50,7 +50,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -94,10 +94,10 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().StringP(clusterNameFlag, "n", "", "If set, generates the payload with the current state of the given cluster. If unset, generates the payload with default values") } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) - clusterName := flags.FlagToStringPointer(cmd, clusterNameFlag) + clusterName := flags.FlagToStringPointer(p, cmd, clusterNameFlag) // If clusterName is provided, projectId is needed as well if clusterName != nil && globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} diff --git a/internal/cmd/ske/cluster/generate-payload/generate_payload_test.go b/internal/cmd/ske/cluster/generate-payload/generate_payload_test.go index 0b5500dcd..da4fca653 100644 --- a/internal/cmd/ske/cluster/generate-payload/generate_payload_test.go +++ b/internal/cmd/ske/cluster/generate-payload/generate_payload_test.go @@ -142,7 +142,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/ske/cluster/list/list.go b/internal/cmd/ske/cluster/list/list.go index d9baa2dec..22d0043c2 100644 --- a/internal/cmd/ske/cluster/list/list.go +++ b/internal/cmd/ske/cluster/list/list.go @@ -48,7 +48,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -76,8 +76,9 @@ func NewCmd(p *print.Printer) *cobra.Command { } clusters := *resp.Items if len(clusters) == 0 { - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } p.Info("No clusters found for project %q\n", projectLabel) @@ -101,13 +102,13 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().Int64(limitFlag, 0, "Maximum number of entries to list") } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, @@ -117,7 +118,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - Limit: flags.FlagToInt64Pointer(cmd, limitFlag), + Limit: flags.FlagToInt64Pointer(p, cmd, limitFlag), }, nil } diff --git a/internal/cmd/ske/cluster/list/list_test.go b/internal/cmd/ske/cluster/list/list_test.go index 898de77e0..73bed5fcb 100644 --- a/internal/cmd/ske/cluster/list/list_test.go +++ b/internal/cmd/ske/cluster/list/list_test.go @@ -138,7 +138,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/ske/cluster/update/update.go b/internal/cmd/ske/cluster/update/update.go index cac74ea15..e7551accb 100644 --- a/internal/cmd/ske/cluster/update/update.go +++ b/internal/cmd/ske/cluster/update/update.go @@ -57,7 +57,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -123,15 +123,15 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { clusterName := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - payloadString := flags.FlagToStringValue(cmd, payloadFlag) + payloadString := flags.FlagToStringValue(p, cmd, payloadFlag) var payload ske.CreateOrUpdateClusterPayload err := json.Unmarshal([]byte(payloadString), &payload) if err != nil { diff --git a/internal/cmd/ske/cluster/update/update_test.go b/internal/cmd/ske/cluster/update/update_test.go index 74e98972c..938a62308 100644 --- a/internal/cmd/ske/cluster/update/update_test.go +++ b/internal/cmd/ske/cluster/update/update_test.go @@ -245,7 +245,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/ske/credentials/complete-rotation/complete_rotation.go b/internal/cmd/ske/credentials/complete-rotation/complete_rotation.go index 335488e53..f5eb4a76d 100644 --- a/internal/cmd/ske/credentials/complete-rotation/complete_rotation.go +++ b/internal/cmd/ske/credentials/complete-rotation/complete_rotation.go @@ -56,7 +56,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -105,10 +105,10 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { clusterName := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/ske/credentials/complete-rotation/complete_rotation_test.go b/internal/cmd/ske/credentials/complete-rotation/complete_rotation_test.go index d90046e38..fb92f8750 100644 --- a/internal/cmd/ske/credentials/complete-rotation/complete_rotation_test.go +++ b/internal/cmd/ske/credentials/complete-rotation/complete_rotation_test.go @@ -156,7 +156,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/ske/credentials/describe/describe.go b/internal/cmd/ske/credentials/describe/describe.go index e53a8ca67..8f079496d 100644 --- a/internal/cmd/ske/credentials/describe/describe.go +++ b/internal/cmd/ske/credentials/describe/describe.go @@ -49,7 +49,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -82,10 +82,10 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { clusterName := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/ske/credentials/describe/describe_test.go b/internal/cmd/ske/credentials/describe/describe_test.go index 35dc8b801..b7e216874 100644 --- a/internal/cmd/ske/credentials/describe/describe_test.go +++ b/internal/cmd/ske/credentials/describe/describe_test.go @@ -156,7 +156,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/ske/credentials/rotate/rotate.go b/internal/cmd/ske/credentials/rotate/rotate.go index 652349336..78a933ddc 100644 --- a/internal/cmd/ske/credentials/rotate/rotate.go +++ b/internal/cmd/ske/credentials/rotate/rotate.go @@ -46,7 +46,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -94,10 +94,10 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { clusterName := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/ske/credentials/rotate/rotate_test.go b/internal/cmd/ske/credentials/rotate/rotate_test.go index e7d5713be..72af69428 100644 --- a/internal/cmd/ske/credentials/rotate/rotate_test.go +++ b/internal/cmd/ske/credentials/rotate/rotate_test.go @@ -156,7 +156,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/ske/credentials/start-rotation/start_rotation.go b/internal/cmd/ske/credentials/start-rotation/start_rotation.go index 154f15468..9fa12b7b6 100644 --- a/internal/cmd/ske/credentials/start-rotation/start_rotation.go +++ b/internal/cmd/ske/credentials/start-rotation/start_rotation.go @@ -59,7 +59,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -108,10 +108,10 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { clusterName := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/ske/credentials/start-rotation/start_rotation_test.go b/internal/cmd/ske/credentials/start-rotation/start_rotation_test.go index 763fb93b2..1170a35f9 100644 --- a/internal/cmd/ske/credentials/start-rotation/start_rotation_test.go +++ b/internal/cmd/ske/credentials/start-rotation/start_rotation_test.go @@ -156,7 +156,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/ske/describe/describe.go b/internal/cmd/ske/describe/describe.go index 5daff4193..9775418cc 100644 --- a/internal/cmd/ske/describe/describe.go +++ b/internal/cmd/ske/describe/describe.go @@ -34,7 +34,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -57,8 +57,8 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/ske/describe/describe_test.go b/internal/cmd/ske/describe/describe_test.go index 9f2407d44..c8fa3fa9c 100644 --- a/internal/cmd/ske/describe/describe_test.go +++ b/internal/cmd/ske/describe/describe_test.go @@ -119,7 +119,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/ske/disable/disable.go b/internal/cmd/ske/disable/disable.go index 4001ad275..c7380317a 100644 --- a/internal/cmd/ske/disable/disable.go +++ b/internal/cmd/ske/disable/disable.go @@ -35,7 +35,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -46,8 +46,9 @@ func NewCmd(p *print.Printer) *cobra.Command { return err } - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } @@ -88,8 +89,8 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command) (*InputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*InputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/ske/disable/disable_test.go b/internal/cmd/ske/disable/disable_test.go index 1d2831e0d..01b3de6e1 100644 --- a/internal/cmd/ske/disable/disable_test.go +++ b/internal/cmd/ske/disable/disable_test.go @@ -119,7 +119,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/ske/enable/enable.go b/internal/cmd/ske/enable/enable.go index 74b0cbd37..62a6302cd 100644 --- a/internal/cmd/ske/enable/enable.go +++ b/internal/cmd/ske/enable/enable.go @@ -35,7 +35,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -46,8 +46,9 @@ func NewCmd(p *print.Printer) *cobra.Command { return err } - projectLabel, err := projectname.GetProjectName(ctx, cmd, p) + projectLabel, err := projectname.GetProjectName(ctx, p, cmd) if err != nil { + p.Debug(print.ErrorLevel, "get project name: %v", err) projectLabel = model.ProjectId } @@ -88,8 +89,8 @@ func NewCmd(p *print.Printer) *cobra.Command { return cmd } -func parseInput(cmd *cobra.Command) (*InputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*InputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } diff --git a/internal/cmd/ske/enable/enable_test.go b/internal/cmd/ske/enable/enable_test.go index 57505d7a0..1a7025295 100644 --- a/internal/cmd/ske/enable/enable_test.go +++ b/internal/cmd/ske/enable/enable_test.go @@ -119,7 +119,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/ske/kubeconfig/create/create.go b/internal/cmd/ske/kubeconfig/create/create.go index ed4eee242..3e8d29e38 100644 --- a/internal/cmd/ske/kubeconfig/create/create.go +++ b/internal/cmd/ske/kubeconfig/create/create.go @@ -58,7 +58,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -121,15 +121,15 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().String(filepathFlag, "", "Path to create the kubeconfig file. By default, the kubeconfig is created as 'config' in the .kube folder, in the user's home directory.") } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { clusterName := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - expTime := flags.FlagToStringPointer(cmd, expirationFlag) + expTime := flags.FlagToStringPointer(p, cmd, expirationFlag) if expTime != nil { var err error @@ -145,7 +145,7 @@ func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, ClusterName: clusterName, - Filepath: flags.FlagToStringPointer(cmd, filepathFlag), + Filepath: flags.FlagToStringPointer(p, cmd, filepathFlag), ExpirationTime: expTime, }, nil } diff --git a/internal/cmd/ske/kubeconfig/create/create_test.go b/internal/cmd/ske/kubeconfig/create/create_test.go index 6326ed3b3..6700d528a 100644 --- a/internal/cmd/ske/kubeconfig/create/create_test.go +++ b/internal/cmd/ske/kubeconfig/create/create_test.go @@ -181,7 +181,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/ske/options/options.go b/internal/cmd/ske/options/options.go index 57e02c19f..f1657a9e4 100644 --- a/internal/cmd/ske/options/options.go +++ b/internal/cmd/ske/options/options.go @@ -58,7 +58,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -91,13 +91,13 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().Bool(volumeTypesFlag, false, "Lists supported volume types") } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) - availabilityZones := flags.FlagToBoolValue(cmd, availabilityZonesFlag) - kubernetesVersions := flags.FlagToBoolValue(cmd, kubernetesVersionsFlag) - machineImages := flags.FlagToBoolValue(cmd, machineImagesFlag) - machineTypes := flags.FlagToBoolValue(cmd, machineTypesFlag) - volumeTypes := flags.FlagToBoolValue(cmd, volumeTypesFlag) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) + availabilityZones := flags.FlagToBoolValue(p, cmd, availabilityZonesFlag) + kubernetesVersions := flags.FlagToBoolValue(p, cmd, kubernetesVersionsFlag) + machineImages := flags.FlagToBoolValue(p, cmd, machineImagesFlag) + machineTypes := flags.FlagToBoolValue(p, cmd, machineTypesFlag) + volumeTypes := flags.FlagToBoolValue(p, cmd, volumeTypesFlag) // If no flag was passed, take it as if every flag were passed if !availabilityZones && !kubernetesVersions && !machineImages && !machineTypes && !volumeTypes { diff --git a/internal/cmd/ske/options/options_test.go b/internal/cmd/ske/options/options_test.go index 05b1a50e0..f8df5cc06 100644 --- a/internal/cmd/ske/options/options_test.go +++ b/internal/cmd/ske/options/options_test.go @@ -140,7 +140,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/pkg/auth/user_token_flow.go b/internal/pkg/auth/user_token_flow.go index 6c8ee0305..ab450d6f0 100644 --- a/internal/pkg/auth/user_token_flow.go +++ b/internal/pkg/auth/user_token_flow.go @@ -53,6 +53,8 @@ func (utf *userTokenFlow) RoundTrip(req *http.Request) (*http.Response, error) { err = refreshTokens(utf) if err == nil { accessTokenValid = true + } else { + utf.printer.Debug(print.ErrorLevel, "refresh access token: %v", err) } } diff --git a/internal/pkg/flags/flag_to_value.go b/internal/pkg/flags/flag_to_value.go index 15c3beea5..6385ba65a 100644 --- a/internal/pkg/flags/flag_to_value.go +++ b/internal/pkg/flags/flag_to_value.go @@ -5,13 +5,15 @@ import ( "time" "github.com/spf13/cobra" + "github.com/stackitcloud/stackit-cli/internal/pkg/print" ) // Returns the flag's value as a string. // Returns "" if the flag is not set, if its value can not be converted to string, or if the flag does not exist. -func FlagToStringValue(cmd *cobra.Command, flag string) string { +func FlagToStringValue(p *print.Printer, cmd *cobra.Command, flag string) string { value, err := cmd.Flags().GetString(flag) if err != nil { + p.Debug(print.ErrorLevel, "convert flag to string value: %v", err) return "" } if cmd.Flag(flag).Changed { @@ -22,9 +24,10 @@ func FlagToStringValue(cmd *cobra.Command, flag string) string { // Returns the flag's value as a bool. // Returns false if its value can not be converted to bool, or if the flag does not exist. -func FlagToBoolValue(cmd *cobra.Command, flag string) bool { +func FlagToBoolValue(p *print.Printer, cmd *cobra.Command, flag string) bool { value, err := cmd.Flags().GetBool(flag) if err != nil { + p.Debug(print.ErrorLevel, "convert flag to bool value: %v", err) return false } return value @@ -32,9 +35,10 @@ func FlagToBoolValue(cmd *cobra.Command, flag string) bool { // Returns the flag's value as a []string. // Returns nil if the flag is not set, if its value can not be converted to []string, or if the flag does not exist. -func FlagToStringSliceValue(cmd *cobra.Command, flag string) []string { +func FlagToStringSliceValue(p *print.Printer, cmd *cobra.Command, flag string) []string { value, err := cmd.Flags().GetStringSlice(flag) if err != nil { + p.Debug(print.ErrorLevel, "convert flag to string slice value: %v", err) return nil } if cmd.Flag(flag).Changed { @@ -45,9 +49,10 @@ func FlagToStringSliceValue(cmd *cobra.Command, flag string) []string { // Returns a pointer to the flag's value. // Returns nil if the flag is not set, if its value can not be converted to map[string]string, or if the flag does not exist. -func FlagToStringToStringPointer(cmd *cobra.Command, flag string) *map[string]string { //nolint:gocritic //convenient for setting the SDK payload +func FlagToStringToStringPointer(p *print.Printer, cmd *cobra.Command, flag string) *map[string]string { //nolint:gocritic //convenient for setting the SDK payload value, err := cmd.Flags().GetStringToString(flag) if err != nil { + p.Debug(print.ErrorLevel, "convert flag to string to string pointer: %v", err) return nil } if cmd.Flag(flag).Changed { @@ -58,9 +63,10 @@ func FlagToStringToStringPointer(cmd *cobra.Command, flag string) *map[string]st // Returns a pointer to the flag's value. // Returns nil if the flag is not set, if its value can not be converted to int64, or if the flag does not exist. -func FlagToInt64Pointer(cmd *cobra.Command, flag string) *int64 { +func FlagToInt64Pointer(p *print.Printer, cmd *cobra.Command, flag string) *int64 { value, err := cmd.Flags().GetInt64(flag) if err != nil { + p.Debug(print.ErrorLevel, "convert flag to Int64 pointer: %v", err) return nil } if cmd.Flag(flag).Changed { @@ -71,9 +77,10 @@ func FlagToInt64Pointer(cmd *cobra.Command, flag string) *int64 { // Returns a pointer to the flag's value. // Returns nil if the flag is not set, if its value can not be converted to string, or if the flag does not exist. -func FlagToStringPointer(cmd *cobra.Command, flag string) *string { +func FlagToStringPointer(p *print.Printer, cmd *cobra.Command, flag string) *string { value, err := cmd.Flags().GetString(flag) if err != nil { + p.Debug(print.ErrorLevel, "convert flag to string pointer: %v", err) return nil } if cmd.Flag(flag).Changed { @@ -84,9 +91,10 @@ func FlagToStringPointer(cmd *cobra.Command, flag string) *string { // Returns a pointer to the flag's value. // Returns nil if the flag is not set, if its value can not be converted to []string, or if the flag does not exist. -func FlagToStringSlicePointer(cmd *cobra.Command, flag string) *[]string { +func FlagToStringSlicePointer(p *print.Printer, cmd *cobra.Command, flag string) *[]string { value, err := cmd.Flags().GetStringSlice(flag) if err != nil { + p.Debug(print.ErrorLevel, "convert flag to string slice pointer: %v", err) return nil } if cmd.Flag(flag).Changed { @@ -97,9 +105,10 @@ func FlagToStringSlicePointer(cmd *cobra.Command, flag string) *[]string { // Returns a pointer to the flag's value. // Returns nil if the flag is not set, if its value can not be converted to bool, or if the flag does not exist. -func FlagToBoolPointer(cmd *cobra.Command, flag string) *bool { +func FlagToBoolPointer(p *print.Printer, cmd *cobra.Command, flag string) *bool { value, err := cmd.Flags().GetBool(flag) if err != nil { + p.Debug(print.ErrorLevel, "convert flag to bool pointer: %v", err) return nil } if cmd.Flag(flag).Changed { @@ -111,9 +120,10 @@ func FlagToBoolPointer(cmd *cobra.Command, flag string) *bool { // Returns a pointer to the flag's value. // Returns nil if the flag is not set, or if the flag does not exist. // Returns an error if its value can not be converted to a date time with the provided format. -func FlagToDateTimePointer(cmd *cobra.Command, flag, format string) (*time.Time, error) { +func FlagToDateTimePointer(p *print.Printer, cmd *cobra.Command, flag, format string) (*time.Time, error) { value, err := cmd.Flags().GetString(flag) if err != nil { + p.Debug(print.ErrorLevel, "convert flag to date-time pointer: %v", err) return nil, nil } @@ -129,9 +139,10 @@ func FlagToDateTimePointer(cmd *cobra.Command, flag, format string) (*time.Time, // Returns the int64 value set on the flag. If no value is set, returns the flag's default value. // Returns 0 if the flag value can not be converted to int64 or if the flag does not exist. -func FlagWithDefaultToInt64Value(cmd *cobra.Command, flag string) int64 { +func FlagWithDefaultToInt64Value(p *print.Printer, cmd *cobra.Command, flag string) int64 { value, err := cmd.Flags().GetInt64(flag) if err != nil { + p.Debug(print.ErrorLevel, "convert flag with default to Int64 value: %v", err) return 0 } return value @@ -139,9 +150,10 @@ func FlagWithDefaultToInt64Value(cmd *cobra.Command, flag string) int64 { // Returns the string value set on the flag. If no value is set, returns the flag's default value. // Returns nil if the flag value can not be converted to string or if the flag does not exist. -func FlagWithDefaultToStringValue(cmd *cobra.Command, flag string) string { +func FlagWithDefaultToStringValue(p *print.Printer, cmd *cobra.Command, flag string) string { value, err := cmd.Flags().GetString(flag) if err != nil { + p.Debug(print.ErrorLevel, "convert flag with default to string value: %v", err) return "" } return value @@ -149,9 +161,10 @@ func FlagWithDefaultToStringValue(cmd *cobra.Command, flag string) string { // Returns a pointer to the flag's value. If no value is set, returns the flag's default value. // Returns nil if the flag value can't be converted to []string or if the flag does not exist. -func FlagWithDefaultToStringSlicePointer(cmd *cobra.Command, flag string) *[]string { +func FlagWithDefaultToStringSlicePointer(p *print.Printer, cmd *cobra.Command, flag string) *[]string { value, err := cmd.Flags().GetStringSlice(flag) if err != nil { + p.Debug(print.ErrorLevel, "convert flag with default to string slice pointer: %v", err) return nil } return &value diff --git a/internal/pkg/flags/flags_test.go b/internal/pkg/flags/flags_test.go index 1e77f616b..982f300b6 100644 --- a/internal/pkg/flags/flags_test.go +++ b/internal/pkg/flags/flags_test.go @@ -101,7 +101,7 @@ func TestEnumFlag(t *testing.T) { if err != nil { t.Fatalf("failed on valid input: %v", err) } - value := FlagToStringValue(cmd, "test-flag") + value := FlagToStringValue(nil, cmd, "test-flag") if !tt.ignoreCase && value != tt.value { t.Fatalf("flag did not return set value") } @@ -320,7 +320,7 @@ func TestUUIDFlag(t *testing.T) { if err != nil { t.Fatalf("failed on valid input: %v", err) } - value := FlagToStringValue(cmd, "test-flag") + value := FlagToStringValue(nil, cmd, "test-flag") if value != tt.value { t.Fatalf("flag did not return set value") } @@ -427,7 +427,7 @@ func TestUUIDSliceFlag(t *testing.T) { if err2 != nil { t.Fatalf("failed on valid input: %v", err2) } - value := FlagToStringSliceValue(cmd, "test-flag") + value := FlagToStringSliceValue(nil, cmd, "test-flag") if !reflect.DeepEqual(tt.expectedValue, value) { t.Fatalf("flag did not return set value (expected %s, got %s)", tt.expectedValue, value) } @@ -531,7 +531,7 @@ func TestCIDRFlag(t *testing.T) { if err != nil { t.Fatalf("failed on valid input: %v", err) } - value := FlagToStringValue(cmd, "test-flag") + value := FlagToStringValue(nil, cmd, "test-flag") if value != tt.value { t.Fatalf("flag did not return set value") } @@ -642,7 +642,7 @@ func TestCIDRSliceFlag(t *testing.T) { if err2 != nil { t.Fatalf("failed on valid input: %v", err2) } - value := FlagToStringSliceValue(cmd, "test-flag") + value := FlagToStringSliceValue(nil, cmd, "test-flag") if !reflect.DeepEqual(tt.expectedValue, value) { t.Fatalf("flag did not return set value (expected %s, got %s)", tt.expectedValue, value) } @@ -741,7 +741,7 @@ func TestReadFromFileFlag(t *testing.T) { if err != nil { t.Fatalf("failed on valid input: %v", err) } - value := FlagToStringValue(cmd, "test-flag") + value := FlagToStringValue(nil, cmd, "test-flag") if value != tt.expectedValue { t.Fatalf("flag returned %q, expected %q", value, tt.expectedValue) } diff --git a/internal/pkg/globalflags/global_flags.go b/internal/pkg/globalflags/global_flags.go index 6a6aef335..786ddceba 100644 --- a/internal/pkg/globalflags/global_flags.go +++ b/internal/pkg/globalflags/global_flags.go @@ -71,10 +71,10 @@ func Configure(flagSet *pflag.FlagSet) error { return nil } -func Parse(cmd *cobra.Command) *GlobalFlagModel { +func Parse(p *print.Printer, cmd *cobra.Command) *GlobalFlagModel { return &GlobalFlagModel{ Async: viper.GetBool(config.AsyncKey), - AssumeYes: flags.FlagToBoolValue(cmd, AssumeYesFlag), + AssumeYes: flags.FlagToBoolValue(p, cmd, AssumeYesFlag), OutputFormat: viper.GetString(config.OutputFormatKey), ProjectId: viper.GetString(config.ProjectIdKey), Verbosity: viper.GetString(config.VerbosityKey), diff --git a/internal/pkg/print/print.go b/internal/pkg/print/print.go index 7cf7b0571..74b912ada 100644 --- a/internal/pkg/print/print.go +++ b/internal/pkg/print/print.go @@ -29,7 +29,7 @@ type Printer struct { // Creates a new printer, including setting up the default logger. func NewPrinter() *Printer { - logger := slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{AddSource: true, Level: slog.LevelDebug})) + logger := slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{AddSource: false, Level: slog.LevelDebug})) slog.SetDefault(logger) return &Printer{} @@ -51,15 +51,16 @@ func (p *Printer) Debug(level Level, msg string, args ...any) { if p.Verbosity != DebugLevel { return } + msg = fmt.Sprintf(msg, args...) switch level { case DebugLevel: - slog.Debug(msg, args...) + slog.Debug(msg) case InfoLevel: - slog.Info(msg, args...) + slog.Info(msg) case WarningLevel: - slog.Warn(msg, args...) + slog.Warn(msg) case ErrorLevel: - slog.Error(msg, args...) + slog.Error(msg) } } diff --git a/internal/pkg/projectname/project_name.go b/internal/pkg/projectname/project_name.go index 9f80da8ab..a258df6e1 100644 --- a/internal/pkg/projectname/project_name.go +++ b/internal/pkg/projectname/project_name.go @@ -17,9 +17,9 @@ import ( // Returns the project name associated to the project ID set in config // // Uses the one stored in config if it's valid, otherwise gets it from the API -func GetProjectName(ctx context.Context, cmd *cobra.Command, p *print.Printer) (string, error) { +func GetProjectName(ctx context.Context, p *print.Printer, cmd *cobra.Command) (string, error) { // If we can use the project name from config, return it - if useProjectNameFromConfig(cmd) { + if useProjectNameFromConfig(p, cmd) { return viper.GetString(config.ProjectNameKey), nil } @@ -41,7 +41,7 @@ func GetProjectName(ctx context.Context, cmd *cobra.Command, p *print.Printer) ( // If project ID is set in config, we store the project name in config // (So next time we can just pull it from there) - if !isProjectIdSetInFlags(cmd) { + if !isProjectIdSetInFlags(p, cmd) { viper.Set(config.ProjectNameKey, projectName) err = config.Write() if err != nil { @@ -53,11 +53,11 @@ func GetProjectName(ctx context.Context, cmd *cobra.Command, p *print.Printer) ( } // Returns True if project name from config should be used, False otherwise -func useProjectNameFromConfig(cmd *cobra.Command) bool { +func useProjectNameFromConfig(p *print.Printer, cmd *cobra.Command) bool { // We use the project name from the config file, if: // - Project id is not set to a different value than the one in the config file // - Project name in the config file is not empty - projectIdSet := isProjectIdSetInFlags(cmd) + projectIdSet := isProjectIdSetInFlags(p, cmd) projectName := viper.GetString(config.ProjectNameKey) projectNameSet := false if projectName != "" { @@ -66,11 +66,11 @@ func useProjectNameFromConfig(cmd *cobra.Command) bool { return !projectIdSet && projectNameSet } -func isProjectIdSetInFlags(cmd *cobra.Command) bool { +func isProjectIdSetInFlags(p *print.Printer, cmd *cobra.Command) bool { // FlagToStringPointer pulls the projectId from passed flags // viper.GetString uses the flags, and fallsback to config file // To check if projectId was passed, we use the first rather than the second - projectIdFromFlag := flags.FlagToStringPointer(cmd, globalflags.ProjectIdFlag) + projectIdFromFlag := flags.FlagToStringPointer(p, cmd, globalflags.ProjectIdFlag) projectIdSetInFlag := false if projectIdFromFlag != nil { projectIdSetInFlag = true diff --git a/internal/pkg/services/argus/client/client.go b/internal/pkg/services/argus/client/client.go index 44125b4ea..cf852d45f 100644 --- a/internal/pkg/services/argus/client/client.go +++ b/internal/pkg/services/argus/client/client.go @@ -18,6 +18,7 @@ func ConfigureClient(p *print.Printer) (*argus.APIClient, error) { authCfgOption, err := auth.AuthenticationConfig(p, auth.AuthorizeUser) if err != nil { + p.Debug(print.ErrorLevel, "configure authentication: %v", err) return nil, &errors.AuthError{} } cfgOptions = append(cfgOptions, authCfgOption, sdkConfig.WithRegion("eu01")) @@ -30,6 +31,7 @@ func ConfigureClient(p *print.Printer) (*argus.APIClient, error) { apiClient, err = argus.NewAPIClient(cfgOptions...) if err != nil { + p.Debug(print.ErrorLevel, "create new API client: %v", err) return nil, &errors.AuthError{} } diff --git a/internal/pkg/services/authorization/client/client.go b/internal/pkg/services/authorization/client/client.go index 41f268c94..b4f475da7 100644 --- a/internal/pkg/services/authorization/client/client.go +++ b/internal/pkg/services/authorization/client/client.go @@ -18,6 +18,7 @@ func ConfigureClient(p *print.Printer) (*authorization.APIClient, error) { authCfgOption, err := auth.AuthenticationConfig(p, auth.AuthorizeUser) if err != nil { + p.Debug(print.ErrorLevel, "configure authentication: %v", err) return nil, &errors.AuthError{} } cfgOptions = append(cfgOptions, authCfgOption) @@ -30,6 +31,7 @@ func ConfigureClient(p *print.Printer) (*authorization.APIClient, error) { apiClient, err = authorization.NewAPIClient(cfgOptions...) if err != nil { + p.Debug(print.ErrorLevel, "create new API client: %v", err) return nil, &errors.AuthError{} } diff --git a/internal/pkg/services/dns/client/client.go b/internal/pkg/services/dns/client/client.go index 9440f939c..6555222dd 100644 --- a/internal/pkg/services/dns/client/client.go +++ b/internal/pkg/services/dns/client/client.go @@ -18,6 +18,7 @@ func ConfigureClient(p *print.Printer) (*dns.APIClient, error) { authCfgOption, err := auth.AuthenticationConfig(p, auth.AuthorizeUser) if err != nil { + p.Debug(print.ErrorLevel, "configure authentication: %v", err) return nil, &errors.AuthError{} } cfgOptions = append(cfgOptions, authCfgOption) @@ -30,6 +31,7 @@ func ConfigureClient(p *print.Printer) (*dns.APIClient, error) { apiClient, err = dns.NewAPIClient(cfgOptions...) if err != nil { + p.Debug(print.ErrorLevel, "create new API client: %v", err) return nil, &errors.AuthError{} } diff --git a/internal/pkg/services/logme/client/client.go b/internal/pkg/services/logme/client/client.go index d701f1b10..36bcd8a15 100644 --- a/internal/pkg/services/logme/client/client.go +++ b/internal/pkg/services/logme/client/client.go @@ -18,6 +18,7 @@ func ConfigureClient(p *print.Printer) (*logme.APIClient, error) { authCfgOption, err := auth.AuthenticationConfig(p, auth.AuthorizeUser) if err != nil { + p.Debug(print.ErrorLevel, "configure authentication: %v", err) return nil, &errors.AuthError{} } cfgOptions = append(cfgOptions, authCfgOption, sdkConfig.WithRegion("eu01")) @@ -30,6 +31,7 @@ func ConfigureClient(p *print.Printer) (*logme.APIClient, error) { apiClient, err = logme.NewAPIClient(cfgOptions...) if err != nil { + p.Debug(print.ErrorLevel, "create new API client: %v", err) return nil, &errors.AuthError{} } diff --git a/internal/pkg/services/mariadb/client/client.go b/internal/pkg/services/mariadb/client/client.go index 01baa5193..06046a36d 100644 --- a/internal/pkg/services/mariadb/client/client.go +++ b/internal/pkg/services/mariadb/client/client.go @@ -18,6 +18,7 @@ func ConfigureClient(p *print.Printer) (*mariadb.APIClient, error) { authCfgOption, err := auth.AuthenticationConfig(p, auth.AuthorizeUser) if err != nil { + p.Debug(print.ErrorLevel, "configure authentication: %v", err) return nil, &errors.AuthError{} } cfgOptions = append(cfgOptions, authCfgOption, sdkConfig.WithRegion("eu01")) @@ -30,6 +31,7 @@ func ConfigureClient(p *print.Printer) (*mariadb.APIClient, error) { apiClient, err = mariadb.NewAPIClient(cfgOptions...) if err != nil { + p.Debug(print.ErrorLevel, "create new API client: %v", err) return nil, &errors.AuthError{} } diff --git a/internal/pkg/services/mongodbflex/client/client.go b/internal/pkg/services/mongodbflex/client/client.go index 4291cf753..77bec7c9b 100644 --- a/internal/pkg/services/mongodbflex/client/client.go +++ b/internal/pkg/services/mongodbflex/client/client.go @@ -18,6 +18,7 @@ func ConfigureClient(p *print.Printer) (*mongodbflex.APIClient, error) { authCfgOption, err := auth.AuthenticationConfig(p, auth.AuthorizeUser) if err != nil { + p.Debug(print.ErrorLevel, "configure authentication: %v", err) return nil, &errors.AuthError{} } cfgOptions = append(cfgOptions, authCfgOption, sdkConfig.WithRegion("eu01")) @@ -30,6 +31,7 @@ func ConfigureClient(p *print.Printer) (*mongodbflex.APIClient, error) { apiClient, err = mongodbflex.NewAPIClient(cfgOptions...) if err != nil { + p.Debug(print.ErrorLevel, "create new API client: %v", err) return nil, &errors.AuthError{} } diff --git a/internal/pkg/services/object-storage/client/client.go b/internal/pkg/services/object-storage/client/client.go index 8f7de8ed0..100db6111 100644 --- a/internal/pkg/services/object-storage/client/client.go +++ b/internal/pkg/services/object-storage/client/client.go @@ -18,6 +18,7 @@ func ConfigureClient(p *print.Printer) (*objectstorage.APIClient, error) { authCfgOption, err := auth.AuthenticationConfig(p, auth.AuthorizeUser) if err != nil { + p.Debug(print.ErrorLevel, "configure authentication: %v", err) return nil, &errors.AuthError{} } cfgOptions = append(cfgOptions, authCfgOption, sdkConfig.WithRegion("eu01")) @@ -30,6 +31,7 @@ func ConfigureClient(p *print.Printer) (*objectstorage.APIClient, error) { apiClient, err = objectstorage.NewAPIClient(cfgOptions...) if err != nil { + p.Debug(print.ErrorLevel, "create new API client: %v", err) return nil, &errors.AuthError{} } diff --git a/internal/pkg/services/opensearch/client/client.go b/internal/pkg/services/opensearch/client/client.go index f5679a88c..e18dc4d70 100644 --- a/internal/pkg/services/opensearch/client/client.go +++ b/internal/pkg/services/opensearch/client/client.go @@ -18,6 +18,7 @@ func ConfigureClient(p *print.Printer) (*opensearch.APIClient, error) { authCfgOption, err := auth.AuthenticationConfig(p, auth.AuthorizeUser) if err != nil { + p.Debug(print.ErrorLevel, "configure authentication: %v", err) return nil, &errors.AuthError{} } cfgOptions = append(cfgOptions, authCfgOption, sdkConfig.WithRegion("eu01")) @@ -30,6 +31,7 @@ func ConfigureClient(p *print.Printer) (*opensearch.APIClient, error) { apiClient, err = opensearch.NewAPIClient(cfgOptions...) if err != nil { + p.Debug(print.ErrorLevel, "create new API client: %v", err) return nil, &errors.AuthError{} } diff --git a/internal/pkg/services/postgresflex/client/client.go b/internal/pkg/services/postgresflex/client/client.go index c37181bf3..eb4d52960 100644 --- a/internal/pkg/services/postgresflex/client/client.go +++ b/internal/pkg/services/postgresflex/client/client.go @@ -18,6 +18,7 @@ func ConfigureClient(p *print.Printer) (*postgresflex.APIClient, error) { authCfgOption, err := auth.AuthenticationConfig(p, auth.AuthorizeUser) if err != nil { + p.Debug(print.ErrorLevel, "configure authentication: %v", err) return nil, &errors.AuthError{} } cfgOptions = append(cfgOptions, authCfgOption, sdkConfig.WithRegion("eu01")) @@ -30,6 +31,7 @@ func ConfigureClient(p *print.Printer) (*postgresflex.APIClient, error) { apiClient, err = postgresflex.NewAPIClient(cfgOptions...) if err != nil { + p.Debug(print.ErrorLevel, "create new API client: %v", err) return nil, &errors.AuthError{} } diff --git a/internal/pkg/services/rabbitmq/client/client.go b/internal/pkg/services/rabbitmq/client/client.go index 84e9fa583..0c82aa2cd 100644 --- a/internal/pkg/services/rabbitmq/client/client.go +++ b/internal/pkg/services/rabbitmq/client/client.go @@ -18,6 +18,7 @@ func ConfigureClient(p *print.Printer) (*rabbitmq.APIClient, error) { authCfgOption, err := auth.AuthenticationConfig(p, auth.AuthorizeUser) if err != nil { + p.Debug(print.ErrorLevel, "configure authentication: %v", err) return nil, &errors.AuthError{} } cfgOptions = append(cfgOptions, authCfgOption, sdkConfig.WithRegion("eu01")) @@ -30,6 +31,7 @@ func ConfigureClient(p *print.Printer) (*rabbitmq.APIClient, error) { apiClient, err = rabbitmq.NewAPIClient(cfgOptions...) if err != nil { + p.Debug(print.ErrorLevel, "create new API client: %v", err) return nil, &errors.AuthError{} } diff --git a/internal/pkg/services/redis/client/client.go b/internal/pkg/services/redis/client/client.go index e376cd150..58113d565 100644 --- a/internal/pkg/services/redis/client/client.go +++ b/internal/pkg/services/redis/client/client.go @@ -18,6 +18,7 @@ func ConfigureClient(p *print.Printer) (*redis.APIClient, error) { authCfgOption, err := auth.AuthenticationConfig(p, auth.AuthorizeUser) if err != nil { + p.Debug(print.ErrorLevel, "configure authentication: %v", err) return nil, &errors.AuthError{} } cfgOptions = append(cfgOptions, authCfgOption, sdkConfig.WithRegion("eu01")) @@ -30,6 +31,7 @@ func ConfigureClient(p *print.Printer) (*redis.APIClient, error) { apiClient, err = redis.NewAPIClient(cfgOptions...) if err != nil { + p.Debug(print.ErrorLevel, "create new API client: %v", err) return nil, &errors.AuthError{} } diff --git a/internal/pkg/services/resourcemanager/client/client.go b/internal/pkg/services/resourcemanager/client/client.go index 6e0158b07..a250411ba 100644 --- a/internal/pkg/services/resourcemanager/client/client.go +++ b/internal/pkg/services/resourcemanager/client/client.go @@ -18,6 +18,7 @@ func ConfigureClient(p *print.Printer) (*resourcemanager.APIClient, error) { authCfgOption, err := auth.AuthenticationConfig(p, auth.AuthorizeUser) if err != nil { + p.Debug(print.ErrorLevel, "configure authentication: %v", err) return nil, &errors.AuthError{} } cfgOptions = append(cfgOptions, authCfgOption) @@ -30,6 +31,7 @@ func ConfigureClient(p *print.Printer) (*resourcemanager.APIClient, error) { apiClient, err = resourcemanager.NewAPIClient(cfgOptions...) if err != nil { + p.Debug(print.ErrorLevel, "create new API client: %v", err) return nil, &errors.AuthError{} } diff --git a/internal/pkg/services/secrets-manager/client/client.go b/internal/pkg/services/secrets-manager/client/client.go index 712ead723..c5a380803 100644 --- a/internal/pkg/services/secrets-manager/client/client.go +++ b/internal/pkg/services/secrets-manager/client/client.go @@ -18,6 +18,7 @@ func ConfigureClient(p *print.Printer) (*secretsmanager.APIClient, error) { authCfgOption, err := auth.AuthenticationConfig(p, auth.AuthorizeUser) if err != nil { + p.Debug(print.ErrorLevel, "configure authentication: %v", err) return nil, &errors.AuthError{} } cfgOptions = append(cfgOptions, authCfgOption, sdkConfig.WithRegion("eu01")) @@ -30,6 +31,7 @@ func ConfigureClient(p *print.Printer) (*secretsmanager.APIClient, error) { apiClient, err = secretsmanager.NewAPIClient(cfgOptions...) if err != nil { + p.Debug(print.ErrorLevel, "create new API client: %v", err) return nil, &errors.AuthError{} } diff --git a/internal/pkg/services/service-account/client/client.go b/internal/pkg/services/service-account/client/client.go index a348cc896..984394f03 100644 --- a/internal/pkg/services/service-account/client/client.go +++ b/internal/pkg/services/service-account/client/client.go @@ -18,6 +18,7 @@ func ConfigureClient(p *print.Printer) (*serviceaccount.APIClient, error) { authCfgOption, err := auth.AuthenticationConfig(p, auth.AuthorizeUser) if err != nil { + p.Debug(print.ErrorLevel, "configure authentication: %v", err) return nil, &errors.AuthError{} } cfgOptions = append(cfgOptions, authCfgOption) @@ -30,6 +31,7 @@ func ConfigureClient(p *print.Printer) (*serviceaccount.APIClient, error) { apiClient, err = serviceaccount.NewAPIClient(cfgOptions...) if err != nil { + p.Debug(print.ErrorLevel, "create new API client: %v", err) return nil, &errors.AuthError{} } diff --git a/internal/pkg/services/ske/client/client.go b/internal/pkg/services/ske/client/client.go index 4397cdba7..9d5c26eb6 100644 --- a/internal/pkg/services/ske/client/client.go +++ b/internal/pkg/services/ske/client/client.go @@ -18,6 +18,7 @@ func ConfigureClient(p *print.Printer) (*ske.APIClient, error) { authCfgOption, err := auth.AuthenticationConfig(p, auth.AuthorizeUser) if err != nil { + p.Debug(print.ErrorLevel, "configure authentication: %v", err) return nil, &errors.AuthError{} } cfgOptions = append(cfgOptions, authCfgOption) @@ -31,6 +32,7 @@ func ConfigureClient(p *print.Printer) (*ske.APIClient, error) { apiClient, err = ske.NewAPIClient(cfgOptions...) if err != nil { + p.Debug(print.ErrorLevel, "create new API client: %v", err) return nil, &errors.AuthError{} } From 65f93864f2d1b7040dde1340058c14d1d3996ef5 Mon Sep 17 00:00:00 2001 From: GokceGK <161626272+GokceGK@users.noreply.github.com> Date: Mon, 22 Apr 2024 10:34:09 +0200 Subject: [PATCH 12/17] change order of debug and error logs (#232) --- internal/cmd/root.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/internal/cmd/root.go b/internal/cmd/root.go index d72c61eac..64d318427 100644 --- a/internal/cmd/root.go +++ b/internal/cmd/root.go @@ -130,8 +130,8 @@ func Execute(version, date string) { err := cmd.Execute() if err != nil { err := beautifyUnknownAndMissingCommandsError(cmd, err) - p.Error(err.Error()) p.Debug(print.ErrorLevel, "execute command: %v", err) + p.Error(err.Error()) os.Exit(1) } } From 4b36af5a4f7420214aa24f10b1b884c2ec833aa9 Mon Sep 17 00:00:00 2001 From: Vicente Pinto Date: Mon, 22 Apr 2024 14:59:52 +0100 Subject: [PATCH 13/17] Output format none (#234) * Output format none * Add unit test, move const to print pkg * Switch usage of const --- .../cmd/argus/grafana/describe/describe.go | 2 +- .../cmd/argus/instance/describe/describe.go | 2 +- internal/cmd/argus/instance/list/list.go | 2 +- internal/cmd/argus/plans/plans.go | 2 +- .../cmd/dns/record-set/describe/describe.go | 2 +- internal/cmd/dns/record-set/list/list.go | 2 +- internal/cmd/dns/zone/describe/describe.go | 2 +- internal/cmd/dns/zone/list/list.go | 2 +- .../logme/credentials/describe/describe.go | 2 +- internal/cmd/logme/credentials/list/list.go | 2 +- .../cmd/logme/instance/describe/describe.go | 2 +- internal/cmd/logme/instance/list/list.go | 2 +- internal/cmd/logme/plans/plans.go | 2 +- .../mariadb/credentials/describe/describe.go | 2 +- internal/cmd/mariadb/credentials/list/list.go | 2 +- .../cmd/mariadb/instance/describe/describe.go | 2 +- internal/cmd/mariadb/instance/list/list.go | 2 +- internal/cmd/mariadb/plans/plans.go | 2 +- .../mongodbflex/instance/describe/describe.go | 2 +- .../cmd/mongodbflex/instance/list/list.go | 2 +- internal/cmd/mongodbflex/options/options.go | 5 +- .../cmd/mongodbflex/user/describe/describe.go | 2 +- internal/cmd/mongodbflex/user/list/list.go | 2 +- .../bucket/describe/describe.go | 2 +- .../cmd/object-storage/bucket/list/list.go | 2 +- .../credentials-group/list/list.go | 2 +- .../object-storage/credentials/list/list.go | 2 +- .../credentials/describe/describe.go | 2 +- .../cmd/opensearch/credentials/list/list.go | 2 +- .../opensearch/instance/describe/describe.go | 2 +- internal/cmd/opensearch/instance/list/list.go | 2 +- internal/cmd/opensearch/plans/plans.go | 2 +- internal/cmd/organization/member/list/list.go | 2 +- internal/cmd/organization/role/list/list.go | 2 +- .../instance/describe/describe.go | 2 +- .../cmd/postgresflex/instance/list/list.go | 2 +- internal/cmd/postgresflex/options/options.go | 5 +- .../postgresflex/user/describe/describe.go | 2 +- internal/cmd/postgresflex/user/list/list.go | 2 +- internal/cmd/project/describe/describe.go | 2 +- internal/cmd/project/list/list.go | 2 +- internal/cmd/project/member/list/list.go | 2 +- internal/cmd/project/role/list/list.go | 2 +- .../rabbitmq/credentials/describe/describe.go | 2 +- .../cmd/rabbitmq/credentials/list/list.go | 2 +- .../rabbitmq/instance/describe/describe.go | 2 +- internal/cmd/rabbitmq/instance/list/list.go | 2 +- internal/cmd/rabbitmq/plans/plans.go | 2 +- .../redis/credentials/describe/describe.go | 2 +- internal/cmd/redis/credentials/list/list.go | 2 +- .../cmd/redis/instance/describe/describe.go | 2 +- internal/cmd/redis/instance/list/list.go | 2 +- internal/cmd/redis/plans/plans.go | 2 +- .../instance/describe/describe.go | 2 +- .../cmd/secrets-manager/instance/list/list.go | 2 +- .../secrets-manager/user/describe/describe.go | 2 +- .../cmd/secrets-manager/user/list/list.go | 2 +- internal/cmd/service-account/key/list/list.go | 2 +- internal/cmd/service-account/list/list.go | 2 +- .../cmd/service-account/token/list/list.go | 2 +- internal/cmd/ske/cluster/describe/describe.go | 2 +- internal/cmd/ske/cluster/list/list.go | 2 +- .../cmd/ske/credentials/describe/describe.go | 2 +- internal/cmd/ske/describe/describe.go | 2 +- internal/cmd/ske/options/options.go | 5 +- internal/pkg/globalflags/global_flags.go | 5 +- internal/pkg/pager/pager.go | 22 ---- internal/pkg/print/print.go | 35 +++++ internal/pkg/print/print_test.go | 122 ++++++++++++++++-- internal/pkg/tables/tables.go | 3 +- 70 files changed, 216 insertions(+), 110 deletions(-) delete mode 100644 internal/pkg/pager/pager.go diff --git a/internal/cmd/argus/grafana/describe/describe.go b/internal/cmd/argus/grafana/describe/describe.go index d73e1e7c8..9e6dc0755 100644 --- a/internal/cmd/argus/grafana/describe/describe.go +++ b/internal/cmd/argus/grafana/describe/describe.go @@ -114,7 +114,7 @@ func buildGetInstanceRequest(ctx context.Context, model *inputModel, apiClient * func outputResult(p *print.Printer, inputModel *inputModel, grafanaConfigs *argus.GrafanaConfigs, instance *argus.GetInstanceResponse) error { switch inputModel.OutputFormat { - case globalflags.PrettyOutputFormat: + case print.PrettyOutputFormat: initialAdminPassword := *instance.Instance.GrafanaAdminPassword if inputModel.HidePassword { initialAdminPassword = "" diff --git a/internal/cmd/argus/instance/describe/describe.go b/internal/cmd/argus/instance/describe/describe.go index b8daa10ff..0361272cf 100644 --- a/internal/cmd/argus/instance/describe/describe.go +++ b/internal/cmd/argus/instance/describe/describe.go @@ -87,7 +87,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *argus.APICl func outputResult(p *print.Printer, outputFormat string, instance *argus.GetInstanceResponse) error { switch outputFormat { - case globalflags.PrettyOutputFormat: + case print.PrettyOutputFormat: table := tables.NewTable() table.AddRow("ID", *instance.Id) diff --git a/internal/cmd/argus/instance/list/list.go b/internal/cmd/argus/instance/list/list.go index 4e3fc4eae..ca1548a00 100644 --- a/internal/cmd/argus/instance/list/list.go +++ b/internal/cmd/argus/instance/list/list.go @@ -119,7 +119,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *argus.APICl func outputResult(p *print.Printer, outputFormat string, instances []argus.ProjectInstanceFull) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(instances, "", " ") if err != nil { return fmt.Errorf("marshal Argus instance list: %w", err) diff --git a/internal/cmd/argus/plans/plans.go b/internal/cmd/argus/plans/plans.go index a90d7d483..d68ceecb5 100644 --- a/internal/cmd/argus/plans/plans.go +++ b/internal/cmd/argus/plans/plans.go @@ -119,7 +119,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *argus.APICl func outputResult(p *print.Printer, outputFormat string, plans []argus.Plan) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(plans, "", " ") if err != nil { return fmt.Errorf("marshal Argus plans: %w", err) diff --git a/internal/cmd/dns/record-set/describe/describe.go b/internal/cmd/dns/record-set/describe/describe.go index d2e74f37c..092052053 100644 --- a/internal/cmd/dns/record-set/describe/describe.go +++ b/internal/cmd/dns/record-set/describe/describe.go @@ -103,7 +103,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *dns.APIClie func outputResult(p *print.Printer, outputFormat string, recordSet *dns.RecordSet) error { switch outputFormat { - case globalflags.PrettyOutputFormat: + case print.PrettyOutputFormat: recordsData := make([]string, 0, len(*recordSet.Records)) for _, r := range *recordSet.Records { recordsData = append(recordsData, *r.Content) diff --git a/internal/cmd/dns/record-set/list/list.go b/internal/cmd/dns/record-set/list/list.go index 8567377b1..70041cf19 100644 --- a/internal/cmd/dns/record-set/list/list.go +++ b/internal/cmd/dns/record-set/list/list.go @@ -224,7 +224,7 @@ func fetchRecordSets(ctx context.Context, model *inputModel, apiClient dnsClient func outputResult(p *print.Printer, outputFormat string, recordSets []dns.RecordSet) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(recordSets, "", " ") if err != nil { return fmt.Errorf("marshal DNS record set list: %w", err) diff --git a/internal/cmd/dns/zone/describe/describe.go b/internal/cmd/dns/zone/describe/describe.go index 9c028490b..840c9ffdc 100644 --- a/internal/cmd/dns/zone/describe/describe.go +++ b/internal/cmd/dns/zone/describe/describe.go @@ -88,7 +88,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *dns.APIClie func outputResult(p *print.Printer, outputFormat string, zone *dns.Zone) error { switch outputFormat { - case globalflags.PrettyOutputFormat: + case print.PrettyOutputFormat: table := tables.NewTable() table.AddRow("ID", *zone.Id) table.AddSeparator() diff --git a/internal/cmd/dns/zone/list/list.go b/internal/cmd/dns/zone/list/list.go index e87e7a760..220e3972f 100644 --- a/internal/cmd/dns/zone/list/list.go +++ b/internal/cmd/dns/zone/list/list.go @@ -212,7 +212,7 @@ func fetchZones(ctx context.Context, model *inputModel, apiClient dnsClient) ([] func outputResult(p *print.Printer, outputFormat string, zones []dns.Zone) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: // Show details details, err := json.MarshalIndent(zones, "", " ") if err != nil { diff --git a/internal/cmd/logme/credentials/describe/describe.go b/internal/cmd/logme/credentials/describe/describe.go index 9db1d99eb..ff89f1c58 100644 --- a/internal/cmd/logme/credentials/describe/describe.go +++ b/internal/cmd/logme/credentials/describe/describe.go @@ -101,7 +101,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *logme.APICl func outputResult(p *print.Printer, outputFormat string, credentials *logme.CredentialsResponse) error { switch outputFormat { - case globalflags.PrettyOutputFormat: + case print.PrettyOutputFormat: table := tables.NewTable() table.AddRow("ID", *credentials.Id) table.AddSeparator() diff --git a/internal/cmd/logme/credentials/list/list.go b/internal/cmd/logme/credentials/list/list.go index 9ed4d0e33..697ab8120 100644 --- a/internal/cmd/logme/credentials/list/list.go +++ b/internal/cmd/logme/credentials/list/list.go @@ -124,7 +124,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *logme.APICl func outputResult(p *print.Printer, outputFormat string, credentials []logme.CredentialsListItem) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(credentials, "", " ") if err != nil { return fmt.Errorf("marshal LogMe credentials list: %w", err) diff --git a/internal/cmd/logme/instance/describe/describe.go b/internal/cmd/logme/instance/describe/describe.go index 234e57789..4c00818f9 100644 --- a/internal/cmd/logme/instance/describe/describe.go +++ b/internal/cmd/logme/instance/describe/describe.go @@ -89,7 +89,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *logme.APICl func outputResult(p *print.Printer, outputFormat string, instance *logme.Instance) error { switch outputFormat { - case globalflags.PrettyOutputFormat: + case print.PrettyOutputFormat: table := tables.NewTable() table.AddRow("ID", *instance.InstanceId) table.AddSeparator() diff --git a/internal/cmd/logme/instance/list/list.go b/internal/cmd/logme/instance/list/list.go index b736e2f77..1784fa8b1 100644 --- a/internal/cmd/logme/instance/list/list.go +++ b/internal/cmd/logme/instance/list/list.go @@ -119,7 +119,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *logme.APICl func outputResult(p *print.Printer, outputFormat string, instances []logme.Instance) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(instances, "", " ") if err != nil { return fmt.Errorf("marshal LogMe instance list: %w", err) diff --git a/internal/cmd/logme/plans/plans.go b/internal/cmd/logme/plans/plans.go index c1ac1b2d5..956961106 100644 --- a/internal/cmd/logme/plans/plans.go +++ b/internal/cmd/logme/plans/plans.go @@ -119,7 +119,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *logme.APICl func outputResult(p *print.Printer, outputFormat string, plans []logme.Offering) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(plans, "", " ") if err != nil { return fmt.Errorf("marshal LogMe plans: %w", err) diff --git a/internal/cmd/mariadb/credentials/describe/describe.go b/internal/cmd/mariadb/credentials/describe/describe.go index 12c4634a4..79a01b1df 100644 --- a/internal/cmd/mariadb/credentials/describe/describe.go +++ b/internal/cmd/mariadb/credentials/describe/describe.go @@ -101,7 +101,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *mariadb.API func outputResult(p *print.Printer, outputFormat string, credentials *mariadb.CredentialsResponse) error { switch outputFormat { - case globalflags.PrettyOutputFormat: + case print.PrettyOutputFormat: table := tables.NewTable() table.AddRow("ID", *credentials.Id) table.AddSeparator() diff --git a/internal/cmd/mariadb/credentials/list/list.go b/internal/cmd/mariadb/credentials/list/list.go index 9c211102a..7572c4739 100644 --- a/internal/cmd/mariadb/credentials/list/list.go +++ b/internal/cmd/mariadb/credentials/list/list.go @@ -124,7 +124,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *mariadb.API func outputResult(p *print.Printer, outputFormat string, credentials []mariadb.CredentialsListItem) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(credentials, "", " ") if err != nil { return fmt.Errorf("marshal MariaDB credentials list: %w", err) diff --git a/internal/cmd/mariadb/instance/describe/describe.go b/internal/cmd/mariadb/instance/describe/describe.go index 33b691e2a..ea605ec77 100644 --- a/internal/cmd/mariadb/instance/describe/describe.go +++ b/internal/cmd/mariadb/instance/describe/describe.go @@ -89,7 +89,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *mariadb.API func outputResult(p *print.Printer, outputFormat string, instance *mariadb.Instance) error { switch outputFormat { - case globalflags.PrettyOutputFormat: + case print.PrettyOutputFormat: table := tables.NewTable() table.AddRow("ID", *instance.InstanceId) table.AddSeparator() diff --git a/internal/cmd/mariadb/instance/list/list.go b/internal/cmd/mariadb/instance/list/list.go index d2dc0db0a..9b40b10c5 100644 --- a/internal/cmd/mariadb/instance/list/list.go +++ b/internal/cmd/mariadb/instance/list/list.go @@ -119,7 +119,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *mariadb.API func outputResult(p *print.Printer, outputFormat string, instances []mariadb.Instance) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(instances, "", " ") if err != nil { return fmt.Errorf("marshal MariaDB instance list: %w", err) diff --git a/internal/cmd/mariadb/plans/plans.go b/internal/cmd/mariadb/plans/plans.go index 5e3c3ae3e..2247ac65a 100644 --- a/internal/cmd/mariadb/plans/plans.go +++ b/internal/cmd/mariadb/plans/plans.go @@ -119,7 +119,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *mariadb.API func outputResult(p *print.Printer, outputFormat string, plans []mariadb.Offering) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(plans, "", " ") if err != nil { return fmt.Errorf("marshal MariaDB plans: %w", err) diff --git a/internal/cmd/mongodbflex/instance/describe/describe.go b/internal/cmd/mongodbflex/instance/describe/describe.go index 09406fdcd..8122917da 100644 --- a/internal/cmd/mongodbflex/instance/describe/describe.go +++ b/internal/cmd/mongodbflex/instance/describe/describe.go @@ -89,7 +89,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *mongodbflex func outputResult(p *print.Printer, outputFormat string, instance *mongodbflex.Instance) error { switch outputFormat { - case globalflags.PrettyOutputFormat: + case print.PrettyOutputFormat: aclsArray := *instance.Acl.Items acls := strings.Join(aclsArray, ",") diff --git a/internal/cmd/mongodbflex/instance/list/list.go b/internal/cmd/mongodbflex/instance/list/list.go index b452ea592..135e23a3d 100644 --- a/internal/cmd/mongodbflex/instance/list/list.go +++ b/internal/cmd/mongodbflex/instance/list/list.go @@ -119,7 +119,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *mongodbflex func outputResult(p *print.Printer, outputFormat string, instances []mongodbflex.InstanceListInstance) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(instances, "", " ") if err != nil { return fmt.Errorf("marshal MongoDB Flex instance list: %w", err) diff --git a/internal/cmd/mongodbflex/options/options.go b/internal/cmd/mongodbflex/options/options.go index d590cc8e9..691aafdb1 100644 --- a/internal/cmd/mongodbflex/options/options.go +++ b/internal/cmd/mongodbflex/options/options.go @@ -9,7 +9,6 @@ import ( "github.com/stackitcloud/stackit-cli/internal/pkg/examples" "github.com/stackitcloud/stackit-cli/internal/pkg/flags" "github.com/stackitcloud/stackit-cli/internal/pkg/globalflags" - "github.com/stackitcloud/stackit-cli/internal/pkg/pager" "github.com/stackitcloud/stackit-cli/internal/pkg/print" "github.com/stackitcloud/stackit-cli/internal/pkg/services/mongodbflex/client" "github.com/stackitcloud/stackit-cli/internal/pkg/tables" @@ -174,7 +173,7 @@ func outputResult(p *print.Printer, model *inputModel, flavors *mongodbflex.List } switch model.OutputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(options, "", " ") if err != nil { return fmt.Errorf("marshal MongoDB Flex options: %w", err) @@ -198,7 +197,7 @@ func outputResultAsTable(p *print.Printer, model *inputModel, options *options) content += renderStorages(options.Storages.Storages) } - err := pager.Display(p, content) + err := p.PagerDisplay(content) if err != nil { return fmt.Errorf("display output: %w", err) } diff --git a/internal/cmd/mongodbflex/user/describe/describe.go b/internal/cmd/mongodbflex/user/describe/describe.go index 12f694d02..73989484c 100644 --- a/internal/cmd/mongodbflex/user/describe/describe.go +++ b/internal/cmd/mongodbflex/user/describe/describe.go @@ -107,7 +107,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *mongodbflex func outputResult(p *print.Printer, outputFormat string, user mongodbflex.InstanceResponseUser) error { switch outputFormat { - case globalflags.PrettyOutputFormat: + case print.PrettyOutputFormat: table := tables.NewTable() table.AddRow("ID", *user.Id) table.AddSeparator() diff --git a/internal/cmd/mongodbflex/user/list/list.go b/internal/cmd/mongodbflex/user/list/list.go index 6f4082375..e5dc0737e 100644 --- a/internal/cmd/mongodbflex/user/list/list.go +++ b/internal/cmd/mongodbflex/user/list/list.go @@ -127,7 +127,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *mongodbflex func outputResult(p *print.Printer, outputFormat string, users []mongodbflex.ListUser) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(users, "", " ") if err != nil { return fmt.Errorf("marshal MongoDB Flex user list: %w", err) diff --git a/internal/cmd/object-storage/bucket/describe/describe.go b/internal/cmd/object-storage/bucket/describe/describe.go index 0fd768835..afb6588bc 100644 --- a/internal/cmd/object-storage/bucket/describe/describe.go +++ b/internal/cmd/object-storage/bucket/describe/describe.go @@ -86,7 +86,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *objectstora func outputResult(p *print.Printer, outputFormat string, bucket *objectstorage.Bucket) error { switch outputFormat { - case globalflags.PrettyOutputFormat: + case print.PrettyOutputFormat: table := tables.NewTable() table.AddRow("Name", *bucket.Name) table.AddSeparator() diff --git a/internal/cmd/object-storage/bucket/list/list.go b/internal/cmd/object-storage/bucket/list/list.go index 678652fd3..f925aed48 100644 --- a/internal/cmd/object-storage/bucket/list/list.go +++ b/internal/cmd/object-storage/bucket/list/list.go @@ -119,7 +119,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *objectstora func outputResult(p *print.Printer, outputFormat string, buckets []objectstorage.Bucket) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(buckets, "", " ") if err != nil { return fmt.Errorf("marshal Object Storage bucket list: %w", err) diff --git a/internal/cmd/object-storage/credentials-group/list/list.go b/internal/cmd/object-storage/credentials-group/list/list.go index 27e7a72fc..5a6f40896 100644 --- a/internal/cmd/object-storage/credentials-group/list/list.go +++ b/internal/cmd/object-storage/credentials-group/list/list.go @@ -111,7 +111,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *objectstora func outputResult(p *print.Printer, outputFormat string, credentialsGroups []objectstorage.CredentialsGroup) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(credentialsGroups, "", " ") if err != nil { return fmt.Errorf("marshal Object Storage credentials group list: %w", err) diff --git a/internal/cmd/object-storage/credentials/list/list.go b/internal/cmd/object-storage/credentials/list/list.go index 212a24df9..46d8f7b9a 100644 --- a/internal/cmd/object-storage/credentials/list/list.go +++ b/internal/cmd/object-storage/credentials/list/list.go @@ -127,7 +127,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *objectstora func outputResult(p *print.Printer, outputFormat string, credentials []objectstorage.AccessKey) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(credentials, "", " ") if err != nil { return fmt.Errorf("marshal Object Storage credentials list: %w", err) diff --git a/internal/cmd/opensearch/credentials/describe/describe.go b/internal/cmd/opensearch/credentials/describe/describe.go index 9a79dab7f..51dc223e8 100644 --- a/internal/cmd/opensearch/credentials/describe/describe.go +++ b/internal/cmd/opensearch/credentials/describe/describe.go @@ -101,7 +101,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *opensearch. func outputResult(p *print.Printer, outputFormat string, credentials *opensearch.CredentialsResponse) error { switch outputFormat { - case globalflags.PrettyOutputFormat: + case print.PrettyOutputFormat: table := tables.NewTable() table.AddRow("ID", *credentials.Id) table.AddSeparator() diff --git a/internal/cmd/opensearch/credentials/list/list.go b/internal/cmd/opensearch/credentials/list/list.go index 036122719..0ff93c567 100644 --- a/internal/cmd/opensearch/credentials/list/list.go +++ b/internal/cmd/opensearch/credentials/list/list.go @@ -124,7 +124,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *opensearch. func outputResult(p *print.Printer, outputFormat string, credentials []opensearch.CredentialsListItem) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(credentials, "", " ") if err != nil { return fmt.Errorf("marshal OpenSearch credentials list: %w", err) diff --git a/internal/cmd/opensearch/instance/describe/describe.go b/internal/cmd/opensearch/instance/describe/describe.go index 540e9d9e8..67af16a4d 100644 --- a/internal/cmd/opensearch/instance/describe/describe.go +++ b/internal/cmd/opensearch/instance/describe/describe.go @@ -89,7 +89,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *opensearch. func outputResult(p *print.Printer, outputFormat string, instance *opensearch.Instance) error { switch outputFormat { - case globalflags.PrettyOutputFormat: + case print.PrettyOutputFormat: table := tables.NewTable() table.AddRow("ID", *instance.InstanceId) table.AddSeparator() diff --git a/internal/cmd/opensearch/instance/list/list.go b/internal/cmd/opensearch/instance/list/list.go index f2a5553a2..41c38859a 100644 --- a/internal/cmd/opensearch/instance/list/list.go +++ b/internal/cmd/opensearch/instance/list/list.go @@ -119,7 +119,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *opensearch. func outputResult(p *print.Printer, outputFormat string, instances []opensearch.Instance) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(instances, "", " ") if err != nil { return fmt.Errorf("marshal OpenSearch instance list: %w", err) diff --git a/internal/cmd/opensearch/plans/plans.go b/internal/cmd/opensearch/plans/plans.go index 6cd981d8e..c71bf2d39 100644 --- a/internal/cmd/opensearch/plans/plans.go +++ b/internal/cmd/opensearch/plans/plans.go @@ -119,7 +119,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *opensearch. func outputResult(p *print.Printer, outputFormat string, plans []opensearch.Offering) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(plans, "", " ") if err != nil { return fmt.Errorf("marshal OpenSearch plans: %w", err) diff --git a/internal/cmd/organization/member/list/list.go b/internal/cmd/organization/member/list/list.go index 9126d4b57..903ece456 100644 --- a/internal/cmd/organization/member/list/list.go +++ b/internal/cmd/organization/member/list/list.go @@ -145,7 +145,7 @@ func outputResult(p *print.Printer, model *inputModel, members []authorization.M sort.SliceStable(members, sortFn) switch model.OutputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: // Show details details, err := json.MarshalIndent(members, "", " ") if err != nil { diff --git a/internal/cmd/organization/role/list/list.go b/internal/cmd/organization/role/list/list.go index 708f43eec..a67e56258 100644 --- a/internal/cmd/organization/role/list/list.go +++ b/internal/cmd/organization/role/list/list.go @@ -118,7 +118,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *authorizati func outputRolesResult(p *print.Printer, outputFormat string, roles []authorization.Role) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: // Show details details, err := json.MarshalIndent(roles, "", " ") if err != nil { diff --git a/internal/cmd/postgresflex/instance/describe/describe.go b/internal/cmd/postgresflex/instance/describe/describe.go index 651499967..00be72fbe 100644 --- a/internal/cmd/postgresflex/instance/describe/describe.go +++ b/internal/cmd/postgresflex/instance/describe/describe.go @@ -91,7 +91,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *postgresfle func outputResult(p *print.Printer, outputFormat string, instance *postgresflex.Instance) error { switch outputFormat { - case globalflags.PrettyOutputFormat: + case print.PrettyOutputFormat: aclsArray := *instance.Acl.Items acls := strings.Join(aclsArray, ",") diff --git a/internal/cmd/postgresflex/instance/list/list.go b/internal/cmd/postgresflex/instance/list/list.go index c8af818e3..b6772c525 100644 --- a/internal/cmd/postgresflex/instance/list/list.go +++ b/internal/cmd/postgresflex/instance/list/list.go @@ -121,7 +121,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *postgresfle func outputResult(p *print.Printer, outputFormat string, instances []postgresflex.InstanceListInstance) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(instances, "", " ") if err != nil { return fmt.Errorf("marshal PostgreSQL Flex instance list: %w", err) diff --git a/internal/cmd/postgresflex/options/options.go b/internal/cmd/postgresflex/options/options.go index 0ce14bc02..25e33cbee 100644 --- a/internal/cmd/postgresflex/options/options.go +++ b/internal/cmd/postgresflex/options/options.go @@ -9,7 +9,6 @@ import ( "github.com/stackitcloud/stackit-cli/internal/pkg/examples" "github.com/stackitcloud/stackit-cli/internal/pkg/flags" "github.com/stackitcloud/stackit-cli/internal/pkg/globalflags" - "github.com/stackitcloud/stackit-cli/internal/pkg/pager" "github.com/stackitcloud/stackit-cli/internal/pkg/print" "github.com/stackitcloud/stackit-cli/internal/pkg/services/postgresflex/client" "github.com/stackitcloud/stackit-cli/internal/pkg/tables" @@ -174,7 +173,7 @@ func outputResult(p *print.Printer, model *inputModel, flavors *postgresflex.Lis } switch model.OutputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(options, "", " ") if err != nil { return fmt.Errorf("marshal PostgreSQL Flex options: %w", err) @@ -198,7 +197,7 @@ func outputResultAsTable(p *print.Printer, model *inputModel, options *options) content += renderStorages(options.Storages.Storages) } - err := pager.Display(p, content) + err := p.PagerDisplay(content) if err != nil { return fmt.Errorf("display output: %w", err) } diff --git a/internal/cmd/postgresflex/user/describe/describe.go b/internal/cmd/postgresflex/user/describe/describe.go index f846320ad..465ed6258 100644 --- a/internal/cmd/postgresflex/user/describe/describe.go +++ b/internal/cmd/postgresflex/user/describe/describe.go @@ -106,7 +106,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *postgresfle func outputResult(p *print.Printer, outputFormat string, user postgresflex.UserResponse) error { switch outputFormat { - case globalflags.PrettyOutputFormat: + case print.PrettyOutputFormat: table := tables.NewTable() table.AddRow("ID", *user.Id) table.AddSeparator() diff --git a/internal/cmd/postgresflex/user/list/list.go b/internal/cmd/postgresflex/user/list/list.go index fb1ef6065..3a018769d 100644 --- a/internal/cmd/postgresflex/user/list/list.go +++ b/internal/cmd/postgresflex/user/list/list.go @@ -127,7 +127,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *postgresfle func outputResult(p *print.Printer, outputFormat string, users []postgresflex.ListUsersResponseItem) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(users, "", " ") if err != nil { return fmt.Errorf("marshal PostgreSQL Flex user list: %w", err) diff --git a/internal/cmd/project/describe/describe.go b/internal/cmd/project/describe/describe.go index a2e60535d..8e08a5327 100644 --- a/internal/cmd/project/describe/describe.go +++ b/internal/cmd/project/describe/describe.go @@ -108,7 +108,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *resourceman func outputResult(p *print.Printer, outputFormat string, project *resourcemanager.ProjectResponseWithParents) error { switch outputFormat { - case globalflags.PrettyOutputFormat: + case print.PrettyOutputFormat: table := tables.NewTable() table.AddRow("ID", *project.ProjectId) table.AddSeparator() diff --git a/internal/cmd/project/list/list.go b/internal/cmd/project/list/list.go index 6e4eadf39..bd521dce6 100644 --- a/internal/cmd/project/list/list.go +++ b/internal/cmd/project/list/list.go @@ -209,7 +209,7 @@ func fetchProjects(ctx context.Context, model *inputModel, apiClient resourceMan func outputResult(p *print.Printer, outputFormat string, projects []resourcemanager.ProjectResponse) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(projects, "", " ") if err != nil { return fmt.Errorf("marshal projects list: %w", err) diff --git a/internal/cmd/project/member/list/list.go b/internal/cmd/project/member/list/list.go index 4d3b98dd7..3dac8d770 100644 --- a/internal/cmd/project/member/list/list.go +++ b/internal/cmd/project/member/list/list.go @@ -147,7 +147,7 @@ func outputResult(p *print.Printer, model *inputModel, members []authorization.M sort.SliceStable(members, sortFn) switch model.OutputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: // Show details details, err := json.MarshalIndent(members, "", " ") if err != nil { diff --git a/internal/cmd/project/role/list/list.go b/internal/cmd/project/role/list/list.go index 103cad108..269136000 100644 --- a/internal/cmd/project/role/list/list.go +++ b/internal/cmd/project/role/list/list.go @@ -120,7 +120,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *authorizati func outputRolesResult(p *print.Printer, outputFormat string, roles []authorization.Role) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: // Show details details, err := json.MarshalIndent(roles, "", " ") if err != nil { diff --git a/internal/cmd/rabbitmq/credentials/describe/describe.go b/internal/cmd/rabbitmq/credentials/describe/describe.go index d4b0efbb3..afd0e2c5e 100644 --- a/internal/cmd/rabbitmq/credentials/describe/describe.go +++ b/internal/cmd/rabbitmq/credentials/describe/describe.go @@ -101,7 +101,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *rabbitmq.AP func outputResult(p *print.Printer, outputFormat string, credentials *rabbitmq.CredentialsResponse) error { switch outputFormat { - case globalflags.PrettyOutputFormat: + case print.PrettyOutputFormat: table := tables.NewTable() table.AddRow("ID", *credentials.Id) table.AddSeparator() diff --git a/internal/cmd/rabbitmq/credentials/list/list.go b/internal/cmd/rabbitmq/credentials/list/list.go index ffb8c88b4..67d953e42 100644 --- a/internal/cmd/rabbitmq/credentials/list/list.go +++ b/internal/cmd/rabbitmq/credentials/list/list.go @@ -124,7 +124,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *rabbitmq.AP func outputResult(p *print.Printer, outputFormat string, credentials []rabbitmq.CredentialsListItem) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(credentials, "", " ") if err != nil { return fmt.Errorf("marshal RabbitMQ credentials list: %w", err) diff --git a/internal/cmd/rabbitmq/instance/describe/describe.go b/internal/cmd/rabbitmq/instance/describe/describe.go index 8b07f8952..95c94dc04 100644 --- a/internal/cmd/rabbitmq/instance/describe/describe.go +++ b/internal/cmd/rabbitmq/instance/describe/describe.go @@ -89,7 +89,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *rabbitmq.AP func outputResult(p *print.Printer, outputFormat string, instance *rabbitmq.Instance) error { switch outputFormat { - case globalflags.PrettyOutputFormat: + case print.PrettyOutputFormat: table := tables.NewTable() table.AddRow("ID", *instance.InstanceId) table.AddSeparator() diff --git a/internal/cmd/rabbitmq/instance/list/list.go b/internal/cmd/rabbitmq/instance/list/list.go index 4e0eb3b2b..ff0d66243 100644 --- a/internal/cmd/rabbitmq/instance/list/list.go +++ b/internal/cmd/rabbitmq/instance/list/list.go @@ -119,7 +119,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *rabbitmq.AP func outputResult(p *print.Printer, outputFormat string, instances []rabbitmq.Instance) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(instances, "", " ") if err != nil { return fmt.Errorf("marshal RabbitMQ instance list: %w", err) diff --git a/internal/cmd/rabbitmq/plans/plans.go b/internal/cmd/rabbitmq/plans/plans.go index 27ee06607..e0d9a3bd0 100644 --- a/internal/cmd/rabbitmq/plans/plans.go +++ b/internal/cmd/rabbitmq/plans/plans.go @@ -119,7 +119,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *rabbitmq.AP func outputResult(p *print.Printer, outputFormat string, plans []rabbitmq.Offering) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(plans, "", " ") if err != nil { return fmt.Errorf("marshal RabbitMQ plans: %w", err) diff --git a/internal/cmd/redis/credentials/describe/describe.go b/internal/cmd/redis/credentials/describe/describe.go index fd19846a3..fb48acc3b 100644 --- a/internal/cmd/redis/credentials/describe/describe.go +++ b/internal/cmd/redis/credentials/describe/describe.go @@ -101,7 +101,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *redis.APICl func outputResult(p *print.Printer, outputFormat string, credentials *redis.CredentialsResponse) error { switch outputFormat { - case globalflags.PrettyOutputFormat: + case print.PrettyOutputFormat: table := tables.NewTable() table.AddRow("ID", *credentials.Id) table.AddSeparator() diff --git a/internal/cmd/redis/credentials/list/list.go b/internal/cmd/redis/credentials/list/list.go index f1dda3102..8a048bfcd 100644 --- a/internal/cmd/redis/credentials/list/list.go +++ b/internal/cmd/redis/credentials/list/list.go @@ -124,7 +124,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *redis.APICl func outputResult(p *print.Printer, outputFormat string, credentials []redis.CredentialsListItem) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(credentials, "", " ") if err != nil { return fmt.Errorf("marshal Redis credentials list: %w", err) diff --git a/internal/cmd/redis/instance/describe/describe.go b/internal/cmd/redis/instance/describe/describe.go index 238672eb2..273a58069 100644 --- a/internal/cmd/redis/instance/describe/describe.go +++ b/internal/cmd/redis/instance/describe/describe.go @@ -89,7 +89,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *redis.APICl func outputResult(p *print.Printer, outputFormat string, instance *redis.Instance) error { switch outputFormat { - case globalflags.PrettyOutputFormat: + case print.PrettyOutputFormat: table := tables.NewTable() table.AddRow("ID", *instance.InstanceId) table.AddSeparator() diff --git a/internal/cmd/redis/instance/list/list.go b/internal/cmd/redis/instance/list/list.go index da0542071..6225d050a 100644 --- a/internal/cmd/redis/instance/list/list.go +++ b/internal/cmd/redis/instance/list/list.go @@ -119,7 +119,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *redis.APICl func outputResult(p *print.Printer, outputFormat string, instances []redis.Instance) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(instances, "", " ") if err != nil { return fmt.Errorf("marshal Redis instance list: %w", err) diff --git a/internal/cmd/redis/plans/plans.go b/internal/cmd/redis/plans/plans.go index 5834ebb0f..55ac63f29 100644 --- a/internal/cmd/redis/plans/plans.go +++ b/internal/cmd/redis/plans/plans.go @@ -119,7 +119,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *redis.APICl func outputResult(p *print.Printer, outputFormat string, plans []redis.Offering) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(plans, "", " ") if err != nil { return fmt.Errorf("marshal Redis plans: %w", err) diff --git a/internal/cmd/secrets-manager/instance/describe/describe.go b/internal/cmd/secrets-manager/instance/describe/describe.go index f54046574..b7e566c78 100644 --- a/internal/cmd/secrets-manager/instance/describe/describe.go +++ b/internal/cmd/secrets-manager/instance/describe/describe.go @@ -100,7 +100,7 @@ func buildListACLsRequest(ctx context.Context, model *inputModel, apiClient *sec func outputResult(p *print.Printer, outputFormat string, instance *secretsmanager.Instance, aclList *secretsmanager.AclList) error { switch outputFormat { - case globalflags.PrettyOutputFormat: + case print.PrettyOutputFormat: table := tables.NewTable() table.AddRow("ID", *instance.Id) diff --git a/internal/cmd/secrets-manager/instance/list/list.go b/internal/cmd/secrets-manager/instance/list/list.go index 6a2481253..1b4d969d2 100644 --- a/internal/cmd/secrets-manager/instance/list/list.go +++ b/internal/cmd/secrets-manager/instance/list/list.go @@ -120,7 +120,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *secretsmana func outputResult(p *print.Printer, outputFormat string, instances []secretsmanager.Instance) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(instances, "", " ") if err != nil { return fmt.Errorf("marshal Secrets Manager instance list: %w", err) diff --git a/internal/cmd/secrets-manager/user/describe/describe.go b/internal/cmd/secrets-manager/user/describe/describe.go index ff6763c74..a4eae4965 100644 --- a/internal/cmd/secrets-manager/user/describe/describe.go +++ b/internal/cmd/secrets-manager/user/describe/describe.go @@ -103,7 +103,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *secretsmana func outputResult(p *print.Printer, outputFormat string, user secretsmanager.User) error { switch outputFormat { - case globalflags.PrettyOutputFormat: + case print.PrettyOutputFormat: table := tables.NewTable() table.AddRow("ID", *user.Id) table.AddSeparator() diff --git a/internal/cmd/secrets-manager/user/list/list.go b/internal/cmd/secrets-manager/user/list/list.go index 6dc0c64a9..f16c1bc34 100644 --- a/internal/cmd/secrets-manager/user/list/list.go +++ b/internal/cmd/secrets-manager/user/list/list.go @@ -127,7 +127,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *secretsmana func outputResult(p *print.Printer, outputFormat string, users []secretsmanager.User) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(users, "", " ") if err != nil { return fmt.Errorf("marshal Secrets Manager user list: %w", err) diff --git a/internal/cmd/service-account/key/list/list.go b/internal/cmd/service-account/key/list/list.go index e148f615e..adda9d26a 100644 --- a/internal/cmd/service-account/key/list/list.go +++ b/internal/cmd/service-account/key/list/list.go @@ -129,7 +129,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *serviceacco func outputResult(p *print.Printer, outputFormat string, keys []serviceaccount.ServiceAccountKeyListResponse) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(keys, "", " ") if err != nil { return fmt.Errorf("marshal keys metadata: %w", err) diff --git a/internal/cmd/service-account/list/list.go b/internal/cmd/service-account/list/list.go index d41304913..eac9c94ee 100644 --- a/internal/cmd/service-account/list/list.go +++ b/internal/cmd/service-account/list/list.go @@ -113,7 +113,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *serviceacco func outputResult(p *print.Printer, outputFormat string, serviceAccounts []serviceaccount.ServiceAccount) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(serviceAccounts, "", " ") if err != nil { return fmt.Errorf("marshal service accounts list: %w", err) diff --git a/internal/cmd/service-account/token/list/list.go b/internal/cmd/service-account/token/list/list.go index d9162c679..c3aee60aa 100644 --- a/internal/cmd/service-account/token/list/list.go +++ b/internal/cmd/service-account/token/list/list.go @@ -133,7 +133,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *serviceacco func outputResult(p *print.Printer, outputFormat string, tokensMetadata []serviceaccount.AccessTokenMetadata) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(tokensMetadata, "", " ") if err != nil { return fmt.Errorf("marshal tokens metadata: %w", err) diff --git a/internal/cmd/ske/cluster/describe/describe.go b/internal/cmd/ske/cluster/describe/describe.go index 3283fb706..cdd7f7e9c 100644 --- a/internal/cmd/ske/cluster/describe/describe.go +++ b/internal/cmd/ske/cluster/describe/describe.go @@ -86,7 +86,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *ske.APIClie func outputResult(p *print.Printer, outputFormat string, cluster *ske.Cluster) error { switch outputFormat { - case globalflags.PrettyOutputFormat: + case print.PrettyOutputFormat: acl := []string{} if cluster.Extensions != nil && cluster.Extensions.Acl != nil { diff --git a/internal/cmd/ske/cluster/list/list.go b/internal/cmd/ske/cluster/list/list.go index 22d0043c2..6855b2f18 100644 --- a/internal/cmd/ske/cluster/list/list.go +++ b/internal/cmd/ske/cluster/list/list.go @@ -129,7 +129,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *ske.APIClie func outputResult(p *print.Printer, outputFormat string, clusters []ske.Cluster) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(clusters, "", " ") if err != nil { return fmt.Errorf("marshal SKE cluster list: %w", err) diff --git a/internal/cmd/ske/credentials/describe/describe.go b/internal/cmd/ske/credentials/describe/describe.go index 8f079496d..5c85577e1 100644 --- a/internal/cmd/ske/credentials/describe/describe.go +++ b/internal/cmd/ske/credentials/describe/describe.go @@ -103,7 +103,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *ske.APIClie func outputResult(p *print.Printer, outputFormat string, credentials *ske.Credentials) error { switch outputFormat { - case globalflags.PrettyOutputFormat: + case print.PrettyOutputFormat: table := tables.NewTable() table.AddRow("SERVER", *credentials.Server) table.AddSeparator() diff --git a/internal/cmd/ske/describe/describe.go b/internal/cmd/ske/describe/describe.go index 9775418cc..e52d98158 100644 --- a/internal/cmd/ske/describe/describe.go +++ b/internal/cmd/ske/describe/describe.go @@ -75,7 +75,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *ske.APIClie func outputResult(p *print.Printer, outputFormat string, project *ske.ProjectResponse) error { switch outputFormat { - case globalflags.PrettyOutputFormat: + case print.PrettyOutputFormat: table := tables.NewTable() table.AddRow("ID", *project.ProjectId) table.AddSeparator() diff --git a/internal/cmd/ske/options/options.go b/internal/cmd/ske/options/options.go index f1657a9e4..4945d0877 100644 --- a/internal/cmd/ske/options/options.go +++ b/internal/cmd/ske/options/options.go @@ -10,7 +10,6 @@ import ( "github.com/stackitcloud/stackit-cli/internal/pkg/examples" "github.com/stackitcloud/stackit-cli/internal/pkg/flags" "github.com/stackitcloud/stackit-cli/internal/pkg/globalflags" - "github.com/stackitcloud/stackit-cli/internal/pkg/pager" "github.com/stackitcloud/stackit-cli/internal/pkg/print" "github.com/stackitcloud/stackit-cli/internal/pkg/services/ske/client" "github.com/stackitcloud/stackit-cli/internal/pkg/tables" @@ -125,7 +124,7 @@ func buildRequest(ctx context.Context, apiClient *ske.APIClient) ske.ApiListProv func outputResult(p *print.Printer, model *inputModel, options *ske.ProviderOptions) error { switch model.OutputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(options, "", " ") if err != nil { return fmt.Errorf("marshal SKE options: %w", err) @@ -159,7 +158,7 @@ func outputResultAsTable(p *print.Printer, model *inputModel, options *ske.Provi content += renderVolumeTypes(options) } - err := pager.Display(p, content) + err := p.PagerDisplay(content) if err != nil { return fmt.Errorf("display output: %w", err) } diff --git a/internal/pkg/globalflags/global_flags.go b/internal/pkg/globalflags/global_flags.go index 786ddceba..aca895991 100644 --- a/internal/pkg/globalflags/global_flags.go +++ b/internal/pkg/globalflags/global_flags.go @@ -19,9 +19,6 @@ const ( ProjectIdFlag = "project-id" VerbosityFlag = "verbosity" - JSONOutputFormat = "json" - PrettyOutputFormat = "pretty" - DebugVerbosity = string(print.DebugLevel) InfoVerbosity = string(print.InfoLevel) WarningVerbosity = string(print.WarningLevel) @@ -30,7 +27,7 @@ const ( VerbosityDefault = InfoVerbosity ) -var outputFormatFlagOptions = []string{JSONOutputFormat, PrettyOutputFormat} +var outputFormatFlagOptions = []string{print.JSONOutputFormat, print.PrettyOutputFormat, print.NoneOutputFormat} var verbosityFlagOptions = []string{DebugVerbosity, InfoVerbosity, WarningVerbosity, ErrorVerbosity} type GlobalFlagModel struct { diff --git a/internal/pkg/pager/pager.go b/internal/pkg/pager/pager.go deleted file mode 100644 index b3b89104c..000000000 --- a/internal/pkg/pager/pager.go +++ /dev/null @@ -1,22 +0,0 @@ -package pager - -import ( - "fmt" - "os/exec" - "strings" - - "github.com/stackitcloud/stackit-cli/internal/pkg/print" -) - -// Shows the content in the command's stdout using the "less" command -func Display(p *print.Printer, content string) error { - lessCmd := exec.Command("less", "-F", "-S", "-w") - lessCmd.Stdin = strings.NewReader(content) - lessCmd.Stdout = p.Cmd.OutOrStdout() - - err := lessCmd.Run() - if err != nil { - return fmt.Errorf("run less command: %w", err) - } - return nil -} diff --git a/internal/pkg/print/print.go b/internal/pkg/print/print.go index 74b912ada..aadb64bed 100644 --- a/internal/pkg/print/print.go +++ b/internal/pkg/print/print.go @@ -6,9 +6,12 @@ import ( "fmt" "log/slog" "os" + "os/exec" "strings" "github.com/spf13/cobra" + "github.com/spf13/viper" + "github.com/stackitcloud/stackit-cli/internal/pkg/config" ) type Level string @@ -18,6 +21,10 @@ const ( InfoLevel Level = "info" WarningLevel Level = "warning" ErrorLevel Level = "error" + + JSONOutputFormat = "json" + PrettyOutputFormat = "pretty" + NoneOutputFormat = "none" ) var errAborted = errors.New("operation aborted") @@ -36,12 +43,22 @@ func NewPrinter() *Printer { } // Print an output using Printf to the defined output (falling back to Stderr if not set). +// If output format is set to none, it does nothing func (p *Printer) Outputf(msg string, args ...any) { + outputFormat := viper.GetString(config.OutputFormatKey) + if outputFormat == NoneOutputFormat { + return + } p.Cmd.Printf(msg, args...) } // Print an output using Println to the defined output (falling back to Stderr if not set). +// If output format is set to none, it does nothing func (p *Printer) Outputln(msg string) { + outputFormat := viper.GetString(config.OutputFormatKey) + if outputFormat == NoneOutputFormat { + return + } p.Cmd.Println(msg) } @@ -112,3 +129,21 @@ func (p *Printer) PromptForConfirmation(prompt string) error { } return fmt.Errorf("max number of wrong inputs") } + +// Shows the content in the command's stdout using the "less" command +// If output format is set to none, it does nothing +func (p *Printer) PagerDisplay(content string) error { + outputFormat := viper.GetString(config.OutputFormatKey) + if outputFormat == NoneOutputFormat { + return nil + } + lessCmd := exec.Command("less", "-F", "-S", "-w") + lessCmd.Stdin = strings.NewReader(content) + lessCmd.Stdout = p.Cmd.OutOrStdout() + + err := lessCmd.Run() + if err != nil { + return fmt.Errorf("run less command: %w", err) + } + return nil +} diff --git a/internal/pkg/print/print_test.go b/internal/pkg/print/print_test.go index ac277cc97..89c06a697 100644 --- a/internal/pkg/print/print_test.go +++ b/internal/pkg/print/print_test.go @@ -9,14 +9,17 @@ import ( "testing" "github.com/spf13/cobra" + "github.com/spf13/viper" + "github.com/stackitcloud/stackit-cli/internal/pkg/config" ) func TestOutputf(t *testing.T) { tests := []struct { - description string - message string - args []any - verbosity Level + description string + message string + args []any + verbosity Level + outputFormatNone bool }{ { description: "debug verbosity", @@ -44,6 +47,12 @@ func TestOutputf(t *testing.T) { message: "Test message", verbosity: ErrorLevel, }, + { + description: "output format none", + message: "Test message", + verbosity: InfoLevel, + outputFormatNone: true, + }, } for _, tt := range tests { t.Run(tt.description, func(t *testing.T) { @@ -54,6 +63,11 @@ func TestOutputf(t *testing.T) { Cmd: cmd, Verbosity: tt.verbosity, } + viper.Reset() + + if tt.outputFormatNone { + viper.Set(config.OutputFormatKey, NoneOutputFormat) + } if len(tt.args) == 0 { p.Outputf(tt.message) @@ -61,10 +75,14 @@ func TestOutputf(t *testing.T) { p.Outputf(tt.message, tt.args...) } - expectedOutput := tt.message - if len(tt.args) > 0 { - expectedOutput = fmt.Sprintf(tt.message, tt.args...) + var expectedOutput string + if !tt.outputFormatNone { + expectedOutput = tt.message + if len(tt.args) > 0 { + expectedOutput = fmt.Sprintf(tt.message, tt.args...) + } } + output := buf.String() if output != expectedOutput { t.Errorf("unexpected output: got %q, want %q", output, expectedOutput) @@ -75,9 +93,10 @@ func TestOutputf(t *testing.T) { func TestOutputln(t *testing.T) { tests := []struct { - description string - message string - verbosity Level + description string + message string + verbosity Level + outputFormatNone bool }{ { description: "debug verbosity", @@ -99,6 +118,12 @@ func TestOutputln(t *testing.T) { message: "Test message", verbosity: ErrorLevel, }, + { + description: "output format none", + message: "Test message", + verbosity: InfoLevel, + outputFormatNone: true, + }, } for _, tt := range tests { t.Run(tt.description, func(t *testing.T) { @@ -109,10 +134,85 @@ func TestOutputln(t *testing.T) { Cmd: cmd, Verbosity: tt.verbosity, } + viper.Reset() + + if tt.outputFormatNone { + viper.Set(config.OutputFormatKey, NoneOutputFormat) + } p.Outputln(tt.message) - expectedOutput := fmt.Sprintf("%s\n", tt.message) + var expectedOutput string + if !tt.outputFormatNone { + expectedOutput = fmt.Sprintf("%s\n", tt.message) + } + + output := buf.String() + if output != expectedOutput { + t.Errorf("unexpected output: got %q, want %q", output, expectedOutput) + } + }) + } +} + +func TestPagerDisplay(t *testing.T) { + tests := []struct { + description string + content string + verbosity Level + outputFormatNone bool + }{ + { + description: "debug verbosity", + content: "Test message", + verbosity: DebugLevel, + }, + { + description: "info verbosity", + content: "Test message", + verbosity: InfoLevel, + }, + { + description: "warning verbosity", + content: "Test message", + verbosity: WarningLevel, + }, + { + description: "error verbosity", + content: "Test message", + verbosity: ErrorLevel, + }, + { + description: "output format none", + content: "Test message", + verbosity: InfoLevel, + outputFormatNone: true, + }, + } + for _, tt := range tests { + t.Run(tt.description, func(t *testing.T) { + var buf bytes.Buffer + cmd := &cobra.Command{} + cmd.SetOutput(&buf) + p := &Printer{ + Cmd: cmd, + Verbosity: tt.verbosity, + } + viper.Reset() + + if tt.outputFormatNone { + viper.Set(config.OutputFormatKey, NoneOutputFormat) + } + + err := p.PagerDisplay(tt.content) + if err != nil { + t.Fatalf("unexpected error: %s", err.Error()) + } + var expectedOutput string + if !tt.outputFormatNone { + expectedOutput = tt.content + } + output := buf.String() if output != expectedOutput { t.Errorf("unexpected output: got %q, want %q", output, expectedOutput) diff --git a/internal/pkg/tables/tables.go b/internal/pkg/tables/tables.go index 45ea21efb..a60de1fc8 100644 --- a/internal/pkg/tables/tables.go +++ b/internal/pkg/tables/tables.go @@ -3,7 +3,6 @@ package tables import ( "fmt" - "github.com/stackitcloud/stackit-cli/internal/pkg/pager" "github.com/stackitcloud/stackit-cli/internal/pkg/print" "github.com/jedib0t/go-pretty/v6/table" @@ -58,5 +57,5 @@ func (t *Table) Render() string { // Displays the table in the command's stdout func (t *Table) Display(p *print.Printer) error { - return pager.Display(p, t.Render()) + return p.PagerDisplay(t.Render()) } From dd1309fec0dd2f8bece7ce5578fe5fe56fa1e10a Mon Sep 17 00:00:00 2001 From: stackit-pipeline <142982727+stackit-pipeline@users.noreply.github.com> Date: Mon, 22 Apr 2024 21:34:17 +0200 Subject: [PATCH 14/17] Signature (#237) From 9fcbc2da1a21898e2dd509b5efdb34084e2a5b9a Mon Sep 17 00:00:00 2001 From: GokceGK <161626272+GokceGK@users.noreply.github.com> Date: Tue, 23 Apr 2024 11:35:41 +0200 Subject: [PATCH 15/17] update docs for output format none addition (#239) --- docs/stackit.md | 2 +- docs/stackit_argus.md | 2 +- docs/stackit_argus_grafana.md | 2 +- docs/stackit_argus_grafana_describe.md | 2 +- docs/stackit_argus_grafana_public-read-access.md | 2 +- docs/stackit_argus_grafana_public-read-access_disable.md | 2 +- docs/stackit_argus_grafana_public-read-access_enable.md | 2 +- docs/stackit_argus_grafana_single-sign-on.md | 2 +- docs/stackit_argus_grafana_single-sign-on_disable.md | 2 +- docs/stackit_argus_grafana_single-sign-on_enable.md | 2 +- docs/stackit_argus_instance.md | 2 +- docs/stackit_argus_instance_create.md | 2 +- docs/stackit_argus_instance_delete.md | 2 +- docs/stackit_argus_instance_describe.md | 2 +- docs/stackit_argus_instance_list.md | 2 +- docs/stackit_argus_instance_update.md | 2 +- docs/stackit_argus_plans.md | 2 +- docs/stackit_auth.md | 2 +- docs/stackit_auth_activate-service-account.md | 2 +- docs/stackit_auth_login.md | 2 +- docs/stackit_config.md | 2 +- docs/stackit_config_list.md | 2 +- docs/stackit_config_set.md | 2 +- docs/stackit_curl.md | 2 +- docs/stackit_dns.md | 2 +- docs/stackit_dns_record-set.md | 2 +- docs/stackit_dns_record-set_create.md | 2 +- docs/stackit_dns_record-set_delete.md | 2 +- docs/stackit_dns_record-set_describe.md | 2 +- docs/stackit_dns_record-set_list.md | 2 +- docs/stackit_dns_record-set_update.md | 2 +- docs/stackit_dns_zone.md | 2 +- docs/stackit_dns_zone_create.md | 2 +- docs/stackit_dns_zone_delete.md | 2 +- docs/stackit_dns_zone_describe.md | 2 +- docs/stackit_dns_zone_list.md | 2 +- docs/stackit_dns_zone_update.md | 2 +- docs/stackit_logme.md | 2 +- docs/stackit_logme_credentials.md | 2 +- docs/stackit_logme_credentials_create.md | 2 +- docs/stackit_logme_credentials_delete.md | 2 +- docs/stackit_logme_credentials_describe.md | 2 +- docs/stackit_logme_credentials_list.md | 2 +- docs/stackit_logme_instance.md | 2 +- docs/stackit_logme_instance_create.md | 2 +- docs/stackit_logme_instance_delete.md | 2 +- docs/stackit_logme_instance_describe.md | 2 +- docs/stackit_logme_instance_list.md | 2 +- docs/stackit_logme_instance_update.md | 2 +- docs/stackit_logme_plans.md | 2 +- docs/stackit_mariadb.md | 2 +- docs/stackit_mariadb_credentials.md | 2 +- docs/stackit_mariadb_credentials_create.md | 2 +- docs/stackit_mariadb_credentials_delete.md | 2 +- docs/stackit_mariadb_credentials_describe.md | 2 +- docs/stackit_mariadb_credentials_list.md | 2 +- docs/stackit_mariadb_instance.md | 2 +- docs/stackit_mariadb_instance_create.md | 2 +- docs/stackit_mariadb_instance_delete.md | 2 +- docs/stackit_mariadb_instance_describe.md | 2 +- docs/stackit_mariadb_instance_list.md | 2 +- docs/stackit_mariadb_instance_update.md | 2 +- docs/stackit_mariadb_plans.md | 2 +- docs/stackit_mongodbflex.md | 2 +- docs/stackit_mongodbflex_instance.md | 2 +- docs/stackit_mongodbflex_instance_create.md | 2 +- docs/stackit_mongodbflex_instance_delete.md | 2 +- docs/stackit_mongodbflex_instance_describe.md | 2 +- docs/stackit_mongodbflex_instance_list.md | 2 +- docs/stackit_mongodbflex_instance_update.md | 2 +- docs/stackit_mongodbflex_options.md | 2 +- docs/stackit_mongodbflex_user.md | 2 +- docs/stackit_mongodbflex_user_create.md | 2 +- docs/stackit_mongodbflex_user_delete.md | 2 +- docs/stackit_mongodbflex_user_describe.md | 2 +- docs/stackit_mongodbflex_user_list.md | 2 +- docs/stackit_mongodbflex_user_reset-password.md | 2 +- docs/stackit_mongodbflex_user_update.md | 2 +- docs/stackit_object-storage.md | 2 +- docs/stackit_object-storage_bucket.md | 2 +- docs/stackit_object-storage_bucket_create.md | 2 +- docs/stackit_object-storage_bucket_delete.md | 2 +- docs/stackit_object-storage_bucket_describe.md | 2 +- docs/stackit_object-storage_bucket_list.md | 2 +- docs/stackit_object-storage_credentials-group.md | 2 +- docs/stackit_object-storage_credentials-group_create.md | 2 +- docs/stackit_object-storage_credentials-group_delete.md | 2 +- docs/stackit_object-storage_credentials-group_list.md | 2 +- docs/stackit_object-storage_credentials.md | 2 +- docs/stackit_object-storage_credentials_create.md | 2 +- docs/stackit_object-storage_credentials_delete.md | 2 +- docs/stackit_object-storage_credentials_list.md | 2 +- docs/stackit_object-storage_disable.md | 2 +- docs/stackit_object-storage_enable.md | 2 +- docs/stackit_opensearch.md | 2 +- docs/stackit_opensearch_credentials.md | 2 +- docs/stackit_opensearch_credentials_create.md | 2 +- docs/stackit_opensearch_credentials_delete.md | 2 +- docs/stackit_opensearch_credentials_describe.md | 2 +- docs/stackit_opensearch_credentials_list.md | 2 +- docs/stackit_opensearch_instance.md | 2 +- docs/stackit_opensearch_instance_create.md | 2 +- docs/stackit_opensearch_instance_delete.md | 2 +- docs/stackit_opensearch_instance_describe.md | 2 +- docs/stackit_opensearch_instance_list.md | 2 +- docs/stackit_opensearch_instance_update.md | 2 +- docs/stackit_opensearch_plans.md | 2 +- docs/stackit_organization.md | 2 +- docs/stackit_organization_member.md | 2 +- docs/stackit_organization_member_add.md | 2 +- docs/stackit_organization_member_list.md | 2 +- docs/stackit_organization_member_remove.md | 2 +- docs/stackit_organization_role.md | 2 +- docs/stackit_organization_role_list.md | 2 +- docs/stackit_postgresflex.md | 2 +- docs/stackit_postgresflex_instance.md | 2 +- docs/stackit_postgresflex_instance_clone.md | 2 +- docs/stackit_postgresflex_instance_create.md | 2 +- docs/stackit_postgresflex_instance_delete.md | 2 +- docs/stackit_postgresflex_instance_describe.md | 2 +- docs/stackit_postgresflex_instance_list.md | 2 +- docs/stackit_postgresflex_instance_update.md | 2 +- docs/stackit_postgresflex_options.md | 2 +- docs/stackit_postgresflex_user.md | 2 +- docs/stackit_postgresflex_user_create.md | 2 +- docs/stackit_postgresflex_user_delete.md | 2 +- docs/stackit_postgresflex_user_describe.md | 2 +- docs/stackit_postgresflex_user_list.md | 2 +- docs/stackit_postgresflex_user_reset-password.md | 2 +- docs/stackit_postgresflex_user_update.md | 2 +- docs/stackit_project.md | 2 +- docs/stackit_project_create.md | 2 +- docs/stackit_project_delete.md | 2 +- docs/stackit_project_describe.md | 2 +- docs/stackit_project_list.md | 2 +- docs/stackit_project_member.md | 2 +- docs/stackit_project_member_add.md | 2 +- docs/stackit_project_member_list.md | 2 +- docs/stackit_project_member_remove.md | 2 +- docs/stackit_project_role.md | 2 +- docs/stackit_project_role_list.md | 2 +- docs/stackit_project_update.md | 2 +- docs/stackit_rabbitmq.md | 2 +- docs/stackit_rabbitmq_credentials.md | 2 +- docs/stackit_rabbitmq_credentials_create.md | 2 +- docs/stackit_rabbitmq_credentials_delete.md | 2 +- docs/stackit_rabbitmq_credentials_describe.md | 2 +- docs/stackit_rabbitmq_credentials_list.md | 2 +- docs/stackit_rabbitmq_instance.md | 2 +- docs/stackit_rabbitmq_instance_create.md | 2 +- docs/stackit_rabbitmq_instance_delete.md | 2 +- docs/stackit_rabbitmq_instance_describe.md | 2 +- docs/stackit_rabbitmq_instance_list.md | 2 +- docs/stackit_rabbitmq_instance_update.md | 2 +- docs/stackit_rabbitmq_plans.md | 2 +- docs/stackit_redis.md | 2 +- docs/stackit_redis_credentials.md | 2 +- docs/stackit_redis_credentials_create.md | 2 +- docs/stackit_redis_credentials_delete.md | 2 +- docs/stackit_redis_credentials_describe.md | 2 +- docs/stackit_redis_credentials_list.md | 2 +- docs/stackit_redis_instance.md | 2 +- docs/stackit_redis_instance_create.md | 2 +- docs/stackit_redis_instance_delete.md | 2 +- docs/stackit_redis_instance_describe.md | 2 +- docs/stackit_redis_instance_list.md | 2 +- docs/stackit_redis_instance_update.md | 2 +- docs/stackit_redis_plans.md | 2 +- docs/stackit_secrets-manager.md | 2 +- docs/stackit_secrets-manager_instance.md | 2 +- docs/stackit_secrets-manager_instance_create.md | 2 +- docs/stackit_secrets-manager_instance_delete.md | 2 +- docs/stackit_secrets-manager_instance_describe.md | 2 +- docs/stackit_secrets-manager_instance_list.md | 2 +- docs/stackit_secrets-manager_instance_update.md | 2 +- docs/stackit_secrets-manager_user.md | 2 +- docs/stackit_secrets-manager_user_create.md | 2 +- docs/stackit_secrets-manager_user_delete.md | 2 +- docs/stackit_secrets-manager_user_describe.md | 2 +- docs/stackit_secrets-manager_user_list.md | 2 +- docs/stackit_secrets-manager_user_update.md | 2 +- docs/stackit_service-account.md | 2 +- docs/stackit_service-account_create.md | 2 +- docs/stackit_service-account_delete.md | 2 +- docs/stackit_service-account_get-jwks.md | 2 +- docs/stackit_service-account_key.md | 2 +- docs/stackit_service-account_key_create.md | 2 +- docs/stackit_service-account_key_delete.md | 2 +- docs/stackit_service-account_key_describe.md | 2 +- docs/stackit_service-account_key_list.md | 2 +- docs/stackit_service-account_key_update.md | 2 +- docs/stackit_service-account_list.md | 2 +- docs/stackit_service-account_token.md | 2 +- docs/stackit_service-account_token_create.md | 2 +- docs/stackit_service-account_token_list.md | 2 +- docs/stackit_service-account_token_revoke.md | 2 +- docs/stackit_ske.md | 2 +- docs/stackit_ske_cluster.md | 2 +- docs/stackit_ske_cluster_create.md | 2 +- docs/stackit_ske_cluster_delete.md | 2 +- docs/stackit_ske_cluster_describe.md | 2 +- docs/stackit_ske_cluster_generate-payload.md | 2 +- docs/stackit_ske_cluster_list.md | 2 +- docs/stackit_ske_cluster_update.md | 2 +- docs/stackit_ske_credentials.md | 2 +- docs/stackit_ske_credentials_complete-rotation.md | 2 +- docs/stackit_ske_credentials_start-rotation.md | 2 +- docs/stackit_ske_describe.md | 2 +- docs/stackit_ske_disable.md | 2 +- docs/stackit_ske_enable.md | 2 +- docs/stackit_ske_kubeconfig.md | 2 +- docs/stackit_ske_kubeconfig_create.md | 2 +- docs/stackit_ske_options.md | 2 +- 213 files changed, 213 insertions(+), 213 deletions(-) diff --git a/docs/stackit.md b/docs/stackit.md index 7dacfde65..d493751b7 100644 --- a/docs/stackit.md +++ b/docs/stackit.md @@ -18,7 +18,7 @@ stackit [flags] -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously -h, --help Help for "stackit" - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") -v, --version Show "stackit" version diff --git a/docs/stackit_argus.md b/docs/stackit_argus.md index 99585f43a..213ae01be 100644 --- a/docs/stackit_argus.md +++ b/docs/stackit_argus.md @@ -21,7 +21,7 @@ stackit argus [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_argus_grafana.md b/docs/stackit_argus_grafana.md index c6743ac86..dbfb5d0e4 100644 --- a/docs/stackit_argus_grafana.md +++ b/docs/stackit_argus_grafana.md @@ -21,7 +21,7 @@ stackit argus grafana [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_argus_grafana_describe.md b/docs/stackit_argus_grafana_describe.md index f9027cbc5..a9c2c3fa2 100644 --- a/docs/stackit_argus_grafana_describe.md +++ b/docs/stackit_argus_grafana_describe.md @@ -37,7 +37,7 @@ stackit argus grafana describe INSTANCE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_argus_grafana_public-read-access.md b/docs/stackit_argus_grafana_public-read-access.md index bc0f7791e..00a09e974 100644 --- a/docs/stackit_argus_grafana_public-read-access.md +++ b/docs/stackit_argus_grafana_public-read-access.md @@ -22,7 +22,7 @@ stackit argus grafana public-read-access [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_argus_grafana_public-read-access_disable.md b/docs/stackit_argus_grafana_public-read-access_disable.md index 9f1b821f3..da7f21453 100644 --- a/docs/stackit_argus_grafana_public-read-access_disable.md +++ b/docs/stackit_argus_grafana_public-read-access_disable.md @@ -29,7 +29,7 @@ stackit argus grafana public-read-access disable INSTANCE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_argus_grafana_public-read-access_enable.md b/docs/stackit_argus_grafana_public-read-access_enable.md index b66012713..096620a41 100644 --- a/docs/stackit_argus_grafana_public-read-access_enable.md +++ b/docs/stackit_argus_grafana_public-read-access_enable.md @@ -29,7 +29,7 @@ stackit argus grafana public-read-access enable INSTANCE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_argus_grafana_single-sign-on.md b/docs/stackit_argus_grafana_single-sign-on.md index 48f0960a2..f78be2f10 100644 --- a/docs/stackit_argus_grafana_single-sign-on.md +++ b/docs/stackit_argus_grafana_single-sign-on.md @@ -22,7 +22,7 @@ stackit argus grafana single-sign-on [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_argus_grafana_single-sign-on_disable.md b/docs/stackit_argus_grafana_single-sign-on_disable.md index 0baf8e753..d90f5e761 100644 --- a/docs/stackit_argus_grafana_single-sign-on_disable.md +++ b/docs/stackit_argus_grafana_single-sign-on_disable.md @@ -29,7 +29,7 @@ stackit argus grafana single-sign-on disable INSTANCE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_argus_grafana_single-sign-on_enable.md b/docs/stackit_argus_grafana_single-sign-on_enable.md index 34bb9c6a6..e3bc43627 100644 --- a/docs/stackit_argus_grafana_single-sign-on_enable.md +++ b/docs/stackit_argus_grafana_single-sign-on_enable.md @@ -29,7 +29,7 @@ stackit argus grafana single-sign-on enable INSTANCE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_argus_instance.md b/docs/stackit_argus_instance.md index 3d20a2787..26ffa10bb 100644 --- a/docs/stackit_argus_instance.md +++ b/docs/stackit_argus_instance.md @@ -21,7 +21,7 @@ stackit argus instance [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_argus_instance_create.md b/docs/stackit_argus_instance_create.md index 3e5057767..12728f040 100644 --- a/docs/stackit_argus_instance_create.md +++ b/docs/stackit_argus_instance_create.md @@ -34,7 +34,7 @@ stackit argus instance create [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_argus_instance_delete.md b/docs/stackit_argus_instance_delete.md index b8a250569..6a9432f57 100644 --- a/docs/stackit_argus_instance_delete.md +++ b/docs/stackit_argus_instance_delete.md @@ -28,7 +28,7 @@ stackit argus instance delete INSTANCE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_argus_instance_describe.md b/docs/stackit_argus_instance_describe.md index 17ea60e21..4a36f0f87 100644 --- a/docs/stackit_argus_instance_describe.md +++ b/docs/stackit_argus_instance_describe.md @@ -31,7 +31,7 @@ stackit argus instance describe INSTANCE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_argus_instance_list.md b/docs/stackit_argus_instance_list.md index 0929847ec..f93235105 100644 --- a/docs/stackit_argus_instance_list.md +++ b/docs/stackit_argus_instance_list.md @@ -35,7 +35,7 @@ stackit argus instance list [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_argus_instance_update.md b/docs/stackit_argus_instance_update.md index 96ad284b9..c2db5047b 100644 --- a/docs/stackit_argus_instance_update.md +++ b/docs/stackit_argus_instance_update.md @@ -37,7 +37,7 @@ stackit argus instance update INSTANCE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_argus_plans.md b/docs/stackit_argus_plans.md index 2e6a0d1b8..33dfa4e79 100644 --- a/docs/stackit_argus_plans.md +++ b/docs/stackit_argus_plans.md @@ -35,7 +35,7 @@ stackit argus plans [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_auth.md b/docs/stackit_auth.md index fa4410b72..726a902dd 100644 --- a/docs/stackit_auth.md +++ b/docs/stackit_auth.md @@ -21,7 +21,7 @@ stackit auth [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_auth_activate-service-account.md b/docs/stackit_auth_activate-service-account.md index 2d43479ae..f0a3b8578 100644 --- a/docs/stackit_auth_activate-service-account.md +++ b/docs/stackit_auth_activate-service-account.md @@ -41,7 +41,7 @@ stackit auth activate-service-account [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_auth_login.md b/docs/stackit_auth_login.md index 4b6de3dc0..fabd45362 100644 --- a/docs/stackit_auth_login.md +++ b/docs/stackit_auth_login.md @@ -28,7 +28,7 @@ stackit auth login [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_config.md b/docs/stackit_config.md index caa3cb4d5..d37248faa 100644 --- a/docs/stackit_config.md +++ b/docs/stackit_config.md @@ -21,7 +21,7 @@ stackit config [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_config_list.md b/docs/stackit_config_list.md index bec7341ff..5fa47d4ce 100644 --- a/docs/stackit_config_list.md +++ b/docs/stackit_config_list.md @@ -34,7 +34,7 @@ stackit config list [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_config_set.md b/docs/stackit_config_set.md index a6aaf0c4a..306ceb45a 100644 --- a/docs/stackit_config_set.md +++ b/docs/stackit_config_set.md @@ -53,7 +53,7 @@ stackit config set [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_curl.md b/docs/stackit_curl.md index 6a9a20839..32c0aa110 100644 --- a/docs/stackit_curl.md +++ b/docs/stackit_curl.md @@ -43,7 +43,7 @@ stackit curl URL [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_dns.md b/docs/stackit_dns.md index 9303cf1b7..c4868f149 100644 --- a/docs/stackit_dns.md +++ b/docs/stackit_dns.md @@ -21,7 +21,7 @@ stackit dns [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_dns_record-set.md b/docs/stackit_dns_record-set.md index 2d139fead..45856f397 100644 --- a/docs/stackit_dns_record-set.md +++ b/docs/stackit_dns_record-set.md @@ -21,7 +21,7 @@ stackit dns record-set [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_dns_record-set_create.md b/docs/stackit_dns_record-set_create.md index 188fd7fff..341fe3cf3 100644 --- a/docs/stackit_dns_record-set_create.md +++ b/docs/stackit_dns_record-set_create.md @@ -34,7 +34,7 @@ stackit dns record-set create [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_dns_record-set_delete.md b/docs/stackit_dns_record-set_delete.md index 20efa762c..3621c8ae2 100644 --- a/docs/stackit_dns_record-set_delete.md +++ b/docs/stackit_dns_record-set_delete.md @@ -29,7 +29,7 @@ stackit dns record-set delete RECORD_SET_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_dns_record-set_describe.md b/docs/stackit_dns_record-set_describe.md index 460fcef18..387381ca5 100644 --- a/docs/stackit_dns_record-set_describe.md +++ b/docs/stackit_dns_record-set_describe.md @@ -32,7 +32,7 @@ stackit dns record-set describe RECORD_SET_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_dns_record-set_list.md b/docs/stackit_dns_record-set_list.md index d3022de88..f69026510 100644 --- a/docs/stackit_dns_record-set_list.md +++ b/docs/stackit_dns_record-set_list.md @@ -48,7 +48,7 @@ stackit dns record-set list [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_dns_record-set_update.md b/docs/stackit_dns_record-set_update.md index 02a46c259..8b55c3fec 100644 --- a/docs/stackit_dns_record-set_update.md +++ b/docs/stackit_dns_record-set_update.md @@ -33,7 +33,7 @@ stackit dns record-set update RECORD_SET_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_dns_zone.md b/docs/stackit_dns_zone.md index 8ec757d39..e6f0280e8 100644 --- a/docs/stackit_dns_zone.md +++ b/docs/stackit_dns_zone.md @@ -21,7 +21,7 @@ stackit dns zone [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_dns_zone_create.md b/docs/stackit_dns_zone_create.md index 2b8f6c52e..2ef4da873 100644 --- a/docs/stackit_dns_zone_create.md +++ b/docs/stackit_dns_zone_create.md @@ -44,7 +44,7 @@ stackit dns zone create [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_dns_zone_delete.md b/docs/stackit_dns_zone_delete.md index 6828c9af5..c5605b826 100644 --- a/docs/stackit_dns_zone_delete.md +++ b/docs/stackit_dns_zone_delete.md @@ -28,7 +28,7 @@ stackit dns zone delete ZONE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_dns_zone_describe.md b/docs/stackit_dns_zone_describe.md index f25be20a4..2715208b8 100644 --- a/docs/stackit_dns_zone_describe.md +++ b/docs/stackit_dns_zone_describe.md @@ -31,7 +31,7 @@ stackit dns zone describe ZONE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_dns_zone_list.md b/docs/stackit_dns_zone_list.md index 9c5dfa8bb..324110b6a 100644 --- a/docs/stackit_dns_zone_list.md +++ b/docs/stackit_dns_zone_list.md @@ -44,7 +44,7 @@ stackit dns zone list [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_dns_zone_update.md b/docs/stackit_dns_zone_update.md index 35d6d91c5..d09e8cec6 100644 --- a/docs/stackit_dns_zone_update.md +++ b/docs/stackit_dns_zone_update.md @@ -38,7 +38,7 @@ stackit dns zone update ZONE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_logme.md b/docs/stackit_logme.md index 7e5f8358f..4d11081b6 100644 --- a/docs/stackit_logme.md +++ b/docs/stackit_logme.md @@ -21,7 +21,7 @@ stackit logme [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_logme_credentials.md b/docs/stackit_logme_credentials.md index 231a0c710..6fdc82ba1 100644 --- a/docs/stackit_logme_credentials.md +++ b/docs/stackit_logme_credentials.md @@ -21,7 +21,7 @@ stackit logme credentials [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_logme_credentials_create.md b/docs/stackit_logme_credentials_create.md index 305170c26..40b1e9489 100644 --- a/docs/stackit_logme_credentials_create.md +++ b/docs/stackit_logme_credentials_create.md @@ -33,7 +33,7 @@ stackit logme credentials create [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_logme_credentials_delete.md b/docs/stackit_logme_credentials_delete.md index 5fef29f7e..9da8d2e23 100644 --- a/docs/stackit_logme_credentials_delete.md +++ b/docs/stackit_logme_credentials_delete.md @@ -29,7 +29,7 @@ stackit logme credentials delete CREDENTIALS_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_logme_credentials_describe.md b/docs/stackit_logme_credentials_describe.md index e7b25c6b5..1d14f86c3 100644 --- a/docs/stackit_logme_credentials_describe.md +++ b/docs/stackit_logme_credentials_describe.md @@ -32,7 +32,7 @@ stackit logme credentials describe CREDENTIALS_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_logme_credentials_list.md b/docs/stackit_logme_credentials_list.md index 9eeaa1917..3bb6cfc44 100644 --- a/docs/stackit_logme_credentials_list.md +++ b/docs/stackit_logme_credentials_list.md @@ -36,7 +36,7 @@ stackit logme credentials list [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_logme_instance.md b/docs/stackit_logme_instance.md index 2ea19539f..edaa09f89 100644 --- a/docs/stackit_logme_instance.md +++ b/docs/stackit_logme_instance.md @@ -21,7 +21,7 @@ stackit logme instance [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_logme_instance_create.md b/docs/stackit_logme_instance_create.md index 07bbe1b7d..5b6d78082 100644 --- a/docs/stackit_logme_instance_create.md +++ b/docs/stackit_logme_instance_create.md @@ -45,7 +45,7 @@ stackit logme instance create [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_logme_instance_delete.md b/docs/stackit_logme_instance_delete.md index 5cb5f98e0..f1c45b4d6 100644 --- a/docs/stackit_logme_instance_delete.md +++ b/docs/stackit_logme_instance_delete.md @@ -28,7 +28,7 @@ stackit logme instance delete INSTANCE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_logme_instance_describe.md b/docs/stackit_logme_instance_describe.md index 4aa4e2c65..8ef8bc2d6 100644 --- a/docs/stackit_logme_instance_describe.md +++ b/docs/stackit_logme_instance_describe.md @@ -31,7 +31,7 @@ stackit logme instance describe INSTANCE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_logme_instance_list.md b/docs/stackit_logme_instance_list.md index ab637f5db..ded2abe71 100644 --- a/docs/stackit_logme_instance_list.md +++ b/docs/stackit_logme_instance_list.md @@ -35,7 +35,7 @@ stackit logme instance list [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_logme_instance_update.md b/docs/stackit_logme_instance_update.md index 5e255ab90..f29639948 100644 --- a/docs/stackit_logme_instance_update.md +++ b/docs/stackit_logme_instance_update.md @@ -41,7 +41,7 @@ stackit logme instance update INSTANCE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_logme_plans.md b/docs/stackit_logme_plans.md index 28b848cc4..aafe53e00 100644 --- a/docs/stackit_logme_plans.md +++ b/docs/stackit_logme_plans.md @@ -35,7 +35,7 @@ stackit logme plans [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_mariadb.md b/docs/stackit_mariadb.md index 2b7709a60..42dff9880 100644 --- a/docs/stackit_mariadb.md +++ b/docs/stackit_mariadb.md @@ -21,7 +21,7 @@ stackit mariadb [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_mariadb_credentials.md b/docs/stackit_mariadb_credentials.md index e8f0285e2..2a4950db2 100644 --- a/docs/stackit_mariadb_credentials.md +++ b/docs/stackit_mariadb_credentials.md @@ -21,7 +21,7 @@ stackit mariadb credentials [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_mariadb_credentials_create.md b/docs/stackit_mariadb_credentials_create.md index 315fca3fd..f6ad6d7c8 100644 --- a/docs/stackit_mariadb_credentials_create.md +++ b/docs/stackit_mariadb_credentials_create.md @@ -33,7 +33,7 @@ stackit mariadb credentials create [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_mariadb_credentials_delete.md b/docs/stackit_mariadb_credentials_delete.md index 22975aaa7..5cf28431d 100644 --- a/docs/stackit_mariadb_credentials_delete.md +++ b/docs/stackit_mariadb_credentials_delete.md @@ -29,7 +29,7 @@ stackit mariadb credentials delete CREDENTIALS_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_mariadb_credentials_describe.md b/docs/stackit_mariadb_credentials_describe.md index 6e0875f03..1fc65c0be 100644 --- a/docs/stackit_mariadb_credentials_describe.md +++ b/docs/stackit_mariadb_credentials_describe.md @@ -32,7 +32,7 @@ stackit mariadb credentials describe CREDENTIALS_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_mariadb_credentials_list.md b/docs/stackit_mariadb_credentials_list.md index 6aa015e99..0ff725526 100644 --- a/docs/stackit_mariadb_credentials_list.md +++ b/docs/stackit_mariadb_credentials_list.md @@ -36,7 +36,7 @@ stackit mariadb credentials list [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_mariadb_instance.md b/docs/stackit_mariadb_instance.md index 1c2c698e2..5ba8366ad 100644 --- a/docs/stackit_mariadb_instance.md +++ b/docs/stackit_mariadb_instance.md @@ -21,7 +21,7 @@ stackit mariadb instance [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_mariadb_instance_create.md b/docs/stackit_mariadb_instance_create.md index 34e6e2b7f..db1898f61 100644 --- a/docs/stackit_mariadb_instance_create.md +++ b/docs/stackit_mariadb_instance_create.md @@ -45,7 +45,7 @@ stackit mariadb instance create [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_mariadb_instance_delete.md b/docs/stackit_mariadb_instance_delete.md index 4d2bb23f9..32a5e786f 100644 --- a/docs/stackit_mariadb_instance_delete.md +++ b/docs/stackit_mariadb_instance_delete.md @@ -28,7 +28,7 @@ stackit mariadb instance delete INSTANCE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_mariadb_instance_describe.md b/docs/stackit_mariadb_instance_describe.md index 55ebbe66e..0984445f6 100644 --- a/docs/stackit_mariadb_instance_describe.md +++ b/docs/stackit_mariadb_instance_describe.md @@ -31,7 +31,7 @@ stackit mariadb instance describe INSTANCE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_mariadb_instance_list.md b/docs/stackit_mariadb_instance_list.md index d4619f56f..b0e0fbab5 100644 --- a/docs/stackit_mariadb_instance_list.md +++ b/docs/stackit_mariadb_instance_list.md @@ -35,7 +35,7 @@ stackit mariadb instance list [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_mariadb_instance_update.md b/docs/stackit_mariadb_instance_update.md index 884382cda..aa1fc35e2 100644 --- a/docs/stackit_mariadb_instance_update.md +++ b/docs/stackit_mariadb_instance_update.md @@ -41,7 +41,7 @@ stackit mariadb instance update INSTANCE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_mariadb_plans.md b/docs/stackit_mariadb_plans.md index 7b1093f29..cc179c71d 100644 --- a/docs/stackit_mariadb_plans.md +++ b/docs/stackit_mariadb_plans.md @@ -35,7 +35,7 @@ stackit mariadb plans [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_mongodbflex.md b/docs/stackit_mongodbflex.md index ace82c1e0..d44688246 100644 --- a/docs/stackit_mongodbflex.md +++ b/docs/stackit_mongodbflex.md @@ -21,7 +21,7 @@ stackit mongodbflex [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_mongodbflex_instance.md b/docs/stackit_mongodbflex_instance.md index c83b6df65..5c470ac76 100644 --- a/docs/stackit_mongodbflex_instance.md +++ b/docs/stackit_mongodbflex_instance.md @@ -21,7 +21,7 @@ stackit mongodbflex instance [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_mongodbflex_instance_create.md b/docs/stackit_mongodbflex_instance_create.md index b17228451..141b5c73a 100644 --- a/docs/stackit_mongodbflex_instance_create.md +++ b/docs/stackit_mongodbflex_instance_create.md @@ -44,7 +44,7 @@ stackit mongodbflex instance create [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_mongodbflex_instance_delete.md b/docs/stackit_mongodbflex_instance_delete.md index ef97025ed..1486979ae 100644 --- a/docs/stackit_mongodbflex_instance_delete.md +++ b/docs/stackit_mongodbflex_instance_delete.md @@ -28,7 +28,7 @@ stackit mongodbflex instance delete INSTANCE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_mongodbflex_instance_describe.md b/docs/stackit_mongodbflex_instance_describe.md index a59b2eb36..70a6e757c 100644 --- a/docs/stackit_mongodbflex_instance_describe.md +++ b/docs/stackit_mongodbflex_instance_describe.md @@ -31,7 +31,7 @@ stackit mongodbflex instance describe INSTANCE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_mongodbflex_instance_list.md b/docs/stackit_mongodbflex_instance_list.md index d3312d8e2..d3027c649 100644 --- a/docs/stackit_mongodbflex_instance_list.md +++ b/docs/stackit_mongodbflex_instance_list.md @@ -35,7 +35,7 @@ stackit mongodbflex instance list [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_mongodbflex_instance_update.md b/docs/stackit_mongodbflex_instance_update.md index 3eecbfd0f..e6c1c1b3d 100644 --- a/docs/stackit_mongodbflex_instance_update.md +++ b/docs/stackit_mongodbflex_instance_update.md @@ -41,7 +41,7 @@ stackit mongodbflex instance update INSTANCE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_mongodbflex_options.md b/docs/stackit_mongodbflex_options.md index dbbeeacd1..d1bab2db1 100644 --- a/docs/stackit_mongodbflex_options.md +++ b/docs/stackit_mongodbflex_options.md @@ -39,7 +39,7 @@ stackit mongodbflex options [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_mongodbflex_user.md b/docs/stackit_mongodbflex_user.md index 51827aef3..2cfcf5ea4 100644 --- a/docs/stackit_mongodbflex_user.md +++ b/docs/stackit_mongodbflex_user.md @@ -21,7 +21,7 @@ stackit mongodbflex user [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_mongodbflex_user_create.md b/docs/stackit_mongodbflex_user_create.md index 94621555f..71fa36df5 100644 --- a/docs/stackit_mongodbflex_user_create.md +++ b/docs/stackit_mongodbflex_user_create.md @@ -38,7 +38,7 @@ stackit mongodbflex user create [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_mongodbflex_user_delete.md b/docs/stackit_mongodbflex_user_delete.md index 03a7c53bf..da9383752 100644 --- a/docs/stackit_mongodbflex_user_delete.md +++ b/docs/stackit_mongodbflex_user_delete.md @@ -30,7 +30,7 @@ stackit mongodbflex user delete USER_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_mongodbflex_user_describe.md b/docs/stackit_mongodbflex_user_describe.md index 569a874d7..48b4102a7 100644 --- a/docs/stackit_mongodbflex_user_describe.md +++ b/docs/stackit_mongodbflex_user_describe.md @@ -34,7 +34,7 @@ stackit mongodbflex user describe USER_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_mongodbflex_user_list.md b/docs/stackit_mongodbflex_user_list.md index 80fad69cd..1cfa7a703 100644 --- a/docs/stackit_mongodbflex_user_list.md +++ b/docs/stackit_mongodbflex_user_list.md @@ -36,7 +36,7 @@ stackit mongodbflex user list [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_mongodbflex_user_reset-password.md b/docs/stackit_mongodbflex_user_reset-password.md index 7bbafa059..339cd6a8d 100644 --- a/docs/stackit_mongodbflex_user_reset-password.md +++ b/docs/stackit_mongodbflex_user_reset-password.md @@ -30,7 +30,7 @@ stackit mongodbflex user reset-password USER_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_mongodbflex_user_update.md b/docs/stackit_mongodbflex_user_update.md index 88569af79..011c0220b 100644 --- a/docs/stackit_mongodbflex_user_update.md +++ b/docs/stackit_mongodbflex_user_update.md @@ -31,7 +31,7 @@ stackit mongodbflex user update USER_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_object-storage.md b/docs/stackit_object-storage.md index 99334ff5b..6f13ef1e4 100644 --- a/docs/stackit_object-storage.md +++ b/docs/stackit_object-storage.md @@ -21,7 +21,7 @@ stackit object-storage [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_object-storage_bucket.md b/docs/stackit_object-storage_bucket.md index 5dfeb2779..138d6afcf 100644 --- a/docs/stackit_object-storage_bucket.md +++ b/docs/stackit_object-storage_bucket.md @@ -21,7 +21,7 @@ stackit object-storage bucket [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_object-storage_bucket_create.md b/docs/stackit_object-storage_bucket_create.md index dc871a85c..95851f1f0 100644 --- a/docs/stackit_object-storage_bucket_create.md +++ b/docs/stackit_object-storage_bucket_create.md @@ -28,7 +28,7 @@ stackit object-storage bucket create BUCKET_NAME [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_object-storage_bucket_delete.md b/docs/stackit_object-storage_bucket_delete.md index c8ab145cb..d93981f09 100644 --- a/docs/stackit_object-storage_bucket_delete.md +++ b/docs/stackit_object-storage_bucket_delete.md @@ -28,7 +28,7 @@ stackit object-storage bucket delete BUCKET_NAME [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_object-storage_bucket_describe.md b/docs/stackit_object-storage_bucket_describe.md index ae222de14..286d54ae7 100644 --- a/docs/stackit_object-storage_bucket_describe.md +++ b/docs/stackit_object-storage_bucket_describe.md @@ -31,7 +31,7 @@ stackit object-storage bucket describe BUCKET_NAME [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_object-storage_bucket_list.md b/docs/stackit_object-storage_bucket_list.md index c81b231ae..b9ec5faee 100644 --- a/docs/stackit_object-storage_bucket_list.md +++ b/docs/stackit_object-storage_bucket_list.md @@ -35,7 +35,7 @@ stackit object-storage bucket list [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_object-storage_credentials-group.md b/docs/stackit_object-storage_credentials-group.md index 3ac563bd6..958b29bd3 100644 --- a/docs/stackit_object-storage_credentials-group.md +++ b/docs/stackit_object-storage_credentials-group.md @@ -21,7 +21,7 @@ stackit object-storage credentials-group [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_object-storage_credentials-group_create.md b/docs/stackit_object-storage_credentials-group_create.md index 78cc1622f..37ff1c105 100644 --- a/docs/stackit_object-storage_credentials-group_create.md +++ b/docs/stackit_object-storage_credentials-group_create.md @@ -29,7 +29,7 @@ stackit object-storage credentials-group create [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_object-storage_credentials-group_delete.md b/docs/stackit_object-storage_credentials-group_delete.md index c5911f62d..5c36b6299 100644 --- a/docs/stackit_object-storage_credentials-group_delete.md +++ b/docs/stackit_object-storage_credentials-group_delete.md @@ -28,7 +28,7 @@ stackit object-storage credentials-group delete CREDENTIALS_GROUP_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_object-storage_credentials-group_list.md b/docs/stackit_object-storage_credentials-group_list.md index f8f46bad0..f66df9fc5 100644 --- a/docs/stackit_object-storage_credentials-group_list.md +++ b/docs/stackit_object-storage_credentials-group_list.md @@ -35,7 +35,7 @@ stackit object-storage credentials-group list [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_object-storage_credentials.md b/docs/stackit_object-storage_credentials.md index 90756eb17..d135bc8b5 100644 --- a/docs/stackit_object-storage_credentials.md +++ b/docs/stackit_object-storage_credentials.md @@ -21,7 +21,7 @@ stackit object-storage credentials [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_object-storage_credentials_create.md b/docs/stackit_object-storage_credentials_create.md index 155eb44f5..92a45a3c1 100644 --- a/docs/stackit_object-storage_credentials_create.md +++ b/docs/stackit_object-storage_credentials_create.md @@ -33,7 +33,7 @@ stackit object-storage credentials create [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_object-storage_credentials_delete.md b/docs/stackit_object-storage_credentials_delete.md index 9d001664a..e44f350b5 100644 --- a/docs/stackit_object-storage_credentials_delete.md +++ b/docs/stackit_object-storage_credentials_delete.md @@ -29,7 +29,7 @@ stackit object-storage credentials delete CREDENTIALS_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_object-storage_credentials_list.md b/docs/stackit_object-storage_credentials_list.md index d826dfa11..be0b501ec 100644 --- a/docs/stackit_object-storage_credentials_list.md +++ b/docs/stackit_object-storage_credentials_list.md @@ -36,7 +36,7 @@ stackit object-storage credentials list [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_object-storage_disable.md b/docs/stackit_object-storage_disable.md index 99ba5da28..7cf45af0b 100644 --- a/docs/stackit_object-storage_disable.md +++ b/docs/stackit_object-storage_disable.md @@ -28,7 +28,7 @@ stackit object-storage disable [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_object-storage_enable.md b/docs/stackit_object-storage_enable.md index a602d4c10..d9eee4bfb 100644 --- a/docs/stackit_object-storage_enable.md +++ b/docs/stackit_object-storage_enable.md @@ -28,7 +28,7 @@ stackit object-storage enable [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_opensearch.md b/docs/stackit_opensearch.md index d2f78e396..d20efcea2 100644 --- a/docs/stackit_opensearch.md +++ b/docs/stackit_opensearch.md @@ -21,7 +21,7 @@ stackit opensearch [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_opensearch_credentials.md b/docs/stackit_opensearch_credentials.md index e288e9381..deed441c6 100644 --- a/docs/stackit_opensearch_credentials.md +++ b/docs/stackit_opensearch_credentials.md @@ -21,7 +21,7 @@ stackit opensearch credentials [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_opensearch_credentials_create.md b/docs/stackit_opensearch_credentials_create.md index c69f3b34b..3ca1ce306 100644 --- a/docs/stackit_opensearch_credentials_create.md +++ b/docs/stackit_opensearch_credentials_create.md @@ -33,7 +33,7 @@ stackit opensearch credentials create [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_opensearch_credentials_delete.md b/docs/stackit_opensearch_credentials_delete.md index c752aad12..e144a0ce6 100644 --- a/docs/stackit_opensearch_credentials_delete.md +++ b/docs/stackit_opensearch_credentials_delete.md @@ -29,7 +29,7 @@ stackit opensearch credentials delete CREDENTIALS_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_opensearch_credentials_describe.md b/docs/stackit_opensearch_credentials_describe.md index b34b9c49a..7ed5b4acf 100644 --- a/docs/stackit_opensearch_credentials_describe.md +++ b/docs/stackit_opensearch_credentials_describe.md @@ -32,7 +32,7 @@ stackit opensearch credentials describe CREDENTIALS_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_opensearch_credentials_list.md b/docs/stackit_opensearch_credentials_list.md index 5ebc46f3e..41d5b9ff0 100644 --- a/docs/stackit_opensearch_credentials_list.md +++ b/docs/stackit_opensearch_credentials_list.md @@ -36,7 +36,7 @@ stackit opensearch credentials list [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_opensearch_instance.md b/docs/stackit_opensearch_instance.md index d29b9ea95..968d343af 100644 --- a/docs/stackit_opensearch_instance.md +++ b/docs/stackit_opensearch_instance.md @@ -21,7 +21,7 @@ stackit opensearch instance [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_opensearch_instance_create.md b/docs/stackit_opensearch_instance_create.md index 8711afd6d..45f32f32c 100644 --- a/docs/stackit_opensearch_instance_create.md +++ b/docs/stackit_opensearch_instance_create.md @@ -46,7 +46,7 @@ stackit opensearch instance create [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_opensearch_instance_delete.md b/docs/stackit_opensearch_instance_delete.md index ce69edff2..ba6c0e571 100644 --- a/docs/stackit_opensearch_instance_delete.md +++ b/docs/stackit_opensearch_instance_delete.md @@ -28,7 +28,7 @@ stackit opensearch instance delete INSTANCE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_opensearch_instance_describe.md b/docs/stackit_opensearch_instance_describe.md index e7412f39d..2a0363796 100644 --- a/docs/stackit_opensearch_instance_describe.md +++ b/docs/stackit_opensearch_instance_describe.md @@ -31,7 +31,7 @@ stackit opensearch instance describe INSTANCE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_opensearch_instance_list.md b/docs/stackit_opensearch_instance_list.md index 4b87294ad..27b622e58 100644 --- a/docs/stackit_opensearch_instance_list.md +++ b/docs/stackit_opensearch_instance_list.md @@ -35,7 +35,7 @@ stackit opensearch instance list [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_opensearch_instance_update.md b/docs/stackit_opensearch_instance_update.md index 82f67acee..e50f7f7a7 100644 --- a/docs/stackit_opensearch_instance_update.md +++ b/docs/stackit_opensearch_instance_update.md @@ -42,7 +42,7 @@ stackit opensearch instance update INSTANCE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_opensearch_plans.md b/docs/stackit_opensearch_plans.md index a8a3d26ce..97925f34a 100644 --- a/docs/stackit_opensearch_plans.md +++ b/docs/stackit_opensearch_plans.md @@ -35,7 +35,7 @@ stackit opensearch plans [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_organization.md b/docs/stackit_organization.md index 1cfb74417..643b64f8d 100644 --- a/docs/stackit_organization.md +++ b/docs/stackit_organization.md @@ -22,7 +22,7 @@ stackit organization [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_organization_member.md b/docs/stackit_organization_member.md index 6d4cc4708..accffe572 100644 --- a/docs/stackit_organization_member.md +++ b/docs/stackit_organization_member.md @@ -21,7 +21,7 @@ stackit organization member [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_organization_member_add.md b/docs/stackit_organization_member_add.md index c70ae9ca6..fa75db1a5 100644 --- a/docs/stackit_organization_member_add.md +++ b/docs/stackit_organization_member_add.md @@ -34,7 +34,7 @@ stackit organization member add SUBJECT [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_organization_member_list.md b/docs/stackit_organization_member_list.md index bfc63fa69..13e6112f3 100644 --- a/docs/stackit_organization_member_list.md +++ b/docs/stackit_organization_member_list.md @@ -38,7 +38,7 @@ stackit organization member list [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_organization_member_remove.md b/docs/stackit_organization_member_remove.md index 0b0882fbe..745cd22c4 100644 --- a/docs/stackit_organization_member_remove.md +++ b/docs/stackit_organization_member_remove.md @@ -36,7 +36,7 @@ stackit organization member remove SUBJECT [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_organization_role.md b/docs/stackit_organization_role.md index 3eab71957..9f7675ffb 100644 --- a/docs/stackit_organization_role.md +++ b/docs/stackit_organization_role.md @@ -21,7 +21,7 @@ stackit organization role [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_organization_role_list.md b/docs/stackit_organization_role_list.md index 2497c821b..bb8690e3e 100644 --- a/docs/stackit_organization_role_list.md +++ b/docs/stackit_organization_role_list.md @@ -36,7 +36,7 @@ stackit organization role list [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_postgresflex.md b/docs/stackit_postgresflex.md index 689ffe638..8751b5394 100644 --- a/docs/stackit_postgresflex.md +++ b/docs/stackit_postgresflex.md @@ -21,7 +21,7 @@ stackit postgresflex [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_postgresflex_instance.md b/docs/stackit_postgresflex_instance.md index 0dee862d2..1376ac743 100644 --- a/docs/stackit_postgresflex_instance.md +++ b/docs/stackit_postgresflex_instance.md @@ -21,7 +21,7 @@ stackit postgresflex instance [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_postgresflex_instance_clone.md b/docs/stackit_postgresflex_instance_clone.md index a972a4f9d..8f257791d 100644 --- a/docs/stackit_postgresflex_instance_clone.md +++ b/docs/stackit_postgresflex_instance_clone.md @@ -37,7 +37,7 @@ stackit postgresflex instance clone INSTANCE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_postgresflex_instance_create.md b/docs/stackit_postgresflex_instance_create.md index 4df9a23c6..112307adf 100644 --- a/docs/stackit_postgresflex_instance_create.md +++ b/docs/stackit_postgresflex_instance_create.md @@ -44,7 +44,7 @@ stackit postgresflex instance create [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_postgresflex_instance_delete.md b/docs/stackit_postgresflex_instance_delete.md index b4b6bb94d..2461854dd 100644 --- a/docs/stackit_postgresflex_instance_delete.md +++ b/docs/stackit_postgresflex_instance_delete.md @@ -34,7 +34,7 @@ stackit postgresflex instance delete INSTANCE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_postgresflex_instance_describe.md b/docs/stackit_postgresflex_instance_describe.md index 974ba30b3..bf59b5d32 100644 --- a/docs/stackit_postgresflex_instance_describe.md +++ b/docs/stackit_postgresflex_instance_describe.md @@ -31,7 +31,7 @@ stackit postgresflex instance describe INSTANCE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_postgresflex_instance_list.md b/docs/stackit_postgresflex_instance_list.md index 76ad9d20d..295baca57 100644 --- a/docs/stackit_postgresflex_instance_list.md +++ b/docs/stackit_postgresflex_instance_list.md @@ -35,7 +35,7 @@ stackit postgresflex instance list [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_postgresflex_instance_update.md b/docs/stackit_postgresflex_instance_update.md index 85b627689..3a8980d7d 100644 --- a/docs/stackit_postgresflex_instance_update.md +++ b/docs/stackit_postgresflex_instance_update.md @@ -41,7 +41,7 @@ stackit postgresflex instance update INSTANCE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_postgresflex_options.md b/docs/stackit_postgresflex_options.md index 93733c35f..57cc6ed9b 100644 --- a/docs/stackit_postgresflex_options.md +++ b/docs/stackit_postgresflex_options.md @@ -39,7 +39,7 @@ stackit postgresflex options [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_postgresflex_user.md b/docs/stackit_postgresflex_user.md index 01c2e3556..720c85cd0 100644 --- a/docs/stackit_postgresflex_user.md +++ b/docs/stackit_postgresflex_user.md @@ -21,7 +21,7 @@ stackit postgresflex user [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_postgresflex_user_create.md b/docs/stackit_postgresflex_user_create.md index c8e592906..1a33e4ae4 100644 --- a/docs/stackit_postgresflex_user_create.md +++ b/docs/stackit_postgresflex_user_create.md @@ -37,7 +37,7 @@ stackit postgresflex user create [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_postgresflex_user_delete.md b/docs/stackit_postgresflex_user_delete.md index fc717667a..7f75f6dc3 100644 --- a/docs/stackit_postgresflex_user_delete.md +++ b/docs/stackit_postgresflex_user_delete.md @@ -31,7 +31,7 @@ stackit postgresflex user delete USER_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_postgresflex_user_describe.md b/docs/stackit_postgresflex_user_describe.md index 5467a1cdf..dbf92c660 100644 --- a/docs/stackit_postgresflex_user_describe.md +++ b/docs/stackit_postgresflex_user_describe.md @@ -34,7 +34,7 @@ stackit postgresflex user describe USER_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_postgresflex_user_list.md b/docs/stackit_postgresflex_user_list.md index 5be02d3af..23e84a491 100644 --- a/docs/stackit_postgresflex_user_list.md +++ b/docs/stackit_postgresflex_user_list.md @@ -36,7 +36,7 @@ stackit postgresflex user list [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_postgresflex_user_reset-password.md b/docs/stackit_postgresflex_user_reset-password.md index 6198470a5..4bf83d21a 100644 --- a/docs/stackit_postgresflex_user_reset-password.md +++ b/docs/stackit_postgresflex_user_reset-password.md @@ -30,7 +30,7 @@ stackit postgresflex user reset-password USER_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_postgresflex_user_update.md b/docs/stackit_postgresflex_user_update.md index ddc9b3156..dd027426e 100644 --- a/docs/stackit_postgresflex_user_update.md +++ b/docs/stackit_postgresflex_user_update.md @@ -30,7 +30,7 @@ stackit postgresflex user update USER_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_project.md b/docs/stackit_project.md index cd1633b15..698df8078 100644 --- a/docs/stackit_project.md +++ b/docs/stackit_project.md @@ -22,7 +22,7 @@ stackit project [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_project_create.md b/docs/stackit_project_create.md index f2eaa69b4..582d1f29a 100644 --- a/docs/stackit_project_create.md +++ b/docs/stackit_project_create.md @@ -34,7 +34,7 @@ stackit project create [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_project_delete.md b/docs/stackit_project_delete.md index 42df806c0..ca90cedb0 100644 --- a/docs/stackit_project_delete.md +++ b/docs/stackit_project_delete.md @@ -31,7 +31,7 @@ stackit project delete [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_project_describe.md b/docs/stackit_project_describe.md index 807f653e3..c9d746c94 100644 --- a/docs/stackit_project_describe.md +++ b/docs/stackit_project_describe.md @@ -35,7 +35,7 @@ stackit project describe [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_project_list.md b/docs/stackit_project_list.md index fb84eee4f..a182923c0 100644 --- a/docs/stackit_project_list.md +++ b/docs/stackit_project_list.md @@ -43,7 +43,7 @@ stackit project list [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_project_member.md b/docs/stackit_project_member.md index 2625419cd..6835a6d59 100644 --- a/docs/stackit_project_member.md +++ b/docs/stackit_project_member.md @@ -21,7 +21,7 @@ stackit project member [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_project_member_add.md b/docs/stackit_project_member_add.md index fa67b1094..9ef13b064 100644 --- a/docs/stackit_project_member_add.md +++ b/docs/stackit_project_member_add.md @@ -33,7 +33,7 @@ stackit project member add SUBJECT [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_project_member_list.md b/docs/stackit_project_member_list.md index 811b9f9c4..1d91e8886 100644 --- a/docs/stackit_project_member_list.md +++ b/docs/stackit_project_member_list.md @@ -37,7 +37,7 @@ stackit project member list [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_project_member_remove.md b/docs/stackit_project_member_remove.md index 12ba9e232..0a8dd80d4 100644 --- a/docs/stackit_project_member_remove.md +++ b/docs/stackit_project_member_remove.md @@ -35,7 +35,7 @@ stackit project member remove SUBJECT [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_project_role.md b/docs/stackit_project_role.md index 641f0462b..3294413f9 100644 --- a/docs/stackit_project_role.md +++ b/docs/stackit_project_role.md @@ -21,7 +21,7 @@ stackit project role [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_project_role_list.md b/docs/stackit_project_role_list.md index f4b4cfe8f..e9770999e 100644 --- a/docs/stackit_project_role_list.md +++ b/docs/stackit_project_role_list.md @@ -35,7 +35,7 @@ stackit project role list [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_project_update.md b/docs/stackit_project_update.md index b5ba23cbd..784041f14 100644 --- a/docs/stackit_project_update.md +++ b/docs/stackit_project_update.md @@ -37,7 +37,7 @@ stackit project update [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_rabbitmq.md b/docs/stackit_rabbitmq.md index fd8ada24d..8855b6463 100644 --- a/docs/stackit_rabbitmq.md +++ b/docs/stackit_rabbitmq.md @@ -21,7 +21,7 @@ stackit rabbitmq [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_rabbitmq_credentials.md b/docs/stackit_rabbitmq_credentials.md index 004fc8a06..48e9342af 100644 --- a/docs/stackit_rabbitmq_credentials.md +++ b/docs/stackit_rabbitmq_credentials.md @@ -21,7 +21,7 @@ stackit rabbitmq credentials [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_rabbitmq_credentials_create.md b/docs/stackit_rabbitmq_credentials_create.md index ed14d65ab..512ee227b 100644 --- a/docs/stackit_rabbitmq_credentials_create.md +++ b/docs/stackit_rabbitmq_credentials_create.md @@ -33,7 +33,7 @@ stackit rabbitmq credentials create [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_rabbitmq_credentials_delete.md b/docs/stackit_rabbitmq_credentials_delete.md index 42827f8d0..3046a6da2 100644 --- a/docs/stackit_rabbitmq_credentials_delete.md +++ b/docs/stackit_rabbitmq_credentials_delete.md @@ -29,7 +29,7 @@ stackit rabbitmq credentials delete CREDENTIALS_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_rabbitmq_credentials_describe.md b/docs/stackit_rabbitmq_credentials_describe.md index 34b10e786..00f2d03c9 100644 --- a/docs/stackit_rabbitmq_credentials_describe.md +++ b/docs/stackit_rabbitmq_credentials_describe.md @@ -32,7 +32,7 @@ stackit rabbitmq credentials describe CREDENTIALS_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_rabbitmq_credentials_list.md b/docs/stackit_rabbitmq_credentials_list.md index 2d68213ab..44208eb88 100644 --- a/docs/stackit_rabbitmq_credentials_list.md +++ b/docs/stackit_rabbitmq_credentials_list.md @@ -36,7 +36,7 @@ stackit rabbitmq credentials list [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_rabbitmq_instance.md b/docs/stackit_rabbitmq_instance.md index 15d248621..d56d4b9fb 100644 --- a/docs/stackit_rabbitmq_instance.md +++ b/docs/stackit_rabbitmq_instance.md @@ -21,7 +21,7 @@ stackit rabbitmq instance [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_rabbitmq_instance_create.md b/docs/stackit_rabbitmq_instance_create.md index 01172ee58..ee83c5f28 100644 --- a/docs/stackit_rabbitmq_instance_create.md +++ b/docs/stackit_rabbitmq_instance_create.md @@ -46,7 +46,7 @@ stackit rabbitmq instance create [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_rabbitmq_instance_delete.md b/docs/stackit_rabbitmq_instance_delete.md index e30f84c02..66b30a589 100644 --- a/docs/stackit_rabbitmq_instance_delete.md +++ b/docs/stackit_rabbitmq_instance_delete.md @@ -28,7 +28,7 @@ stackit rabbitmq instance delete INSTANCE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_rabbitmq_instance_describe.md b/docs/stackit_rabbitmq_instance_describe.md index c292508c1..fb04b9cc9 100644 --- a/docs/stackit_rabbitmq_instance_describe.md +++ b/docs/stackit_rabbitmq_instance_describe.md @@ -31,7 +31,7 @@ stackit rabbitmq instance describe INSTANCE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_rabbitmq_instance_list.md b/docs/stackit_rabbitmq_instance_list.md index f587a78a6..335db3700 100644 --- a/docs/stackit_rabbitmq_instance_list.md +++ b/docs/stackit_rabbitmq_instance_list.md @@ -35,7 +35,7 @@ stackit rabbitmq instance list [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_rabbitmq_instance_update.md b/docs/stackit_rabbitmq_instance_update.md index c1cf77130..1208bc817 100644 --- a/docs/stackit_rabbitmq_instance_update.md +++ b/docs/stackit_rabbitmq_instance_update.md @@ -42,7 +42,7 @@ stackit rabbitmq instance update INSTANCE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_rabbitmq_plans.md b/docs/stackit_rabbitmq_plans.md index c6c910167..b801e281f 100644 --- a/docs/stackit_rabbitmq_plans.md +++ b/docs/stackit_rabbitmq_plans.md @@ -35,7 +35,7 @@ stackit rabbitmq plans [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_redis.md b/docs/stackit_redis.md index 253130e76..b8fff49e6 100644 --- a/docs/stackit_redis.md +++ b/docs/stackit_redis.md @@ -21,7 +21,7 @@ stackit redis [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_redis_credentials.md b/docs/stackit_redis_credentials.md index f4eaae021..12508a4bc 100644 --- a/docs/stackit_redis_credentials.md +++ b/docs/stackit_redis_credentials.md @@ -21,7 +21,7 @@ stackit redis credentials [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_redis_credentials_create.md b/docs/stackit_redis_credentials_create.md index deabb8888..377791b5b 100644 --- a/docs/stackit_redis_credentials_create.md +++ b/docs/stackit_redis_credentials_create.md @@ -33,7 +33,7 @@ stackit redis credentials create [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_redis_credentials_delete.md b/docs/stackit_redis_credentials_delete.md index 73e7aa22d..f8f304bee 100644 --- a/docs/stackit_redis_credentials_delete.md +++ b/docs/stackit_redis_credentials_delete.md @@ -29,7 +29,7 @@ stackit redis credentials delete CREDENTIALS_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_redis_credentials_describe.md b/docs/stackit_redis_credentials_describe.md index 313c9895a..84fb0efd7 100644 --- a/docs/stackit_redis_credentials_describe.md +++ b/docs/stackit_redis_credentials_describe.md @@ -32,7 +32,7 @@ stackit redis credentials describe CREDENTIALS_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_redis_credentials_list.md b/docs/stackit_redis_credentials_list.md index c417a5c16..7ed152e24 100644 --- a/docs/stackit_redis_credentials_list.md +++ b/docs/stackit_redis_credentials_list.md @@ -36,7 +36,7 @@ stackit redis credentials list [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_redis_instance.md b/docs/stackit_redis_instance.md index 2876a15f0..a9fd3ba5b 100644 --- a/docs/stackit_redis_instance.md +++ b/docs/stackit_redis_instance.md @@ -21,7 +21,7 @@ stackit redis instance [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_redis_instance_create.md b/docs/stackit_redis_instance_create.md index 40cd3abfe..3935f3638 100644 --- a/docs/stackit_redis_instance_create.md +++ b/docs/stackit_redis_instance_create.md @@ -45,7 +45,7 @@ stackit redis instance create [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_redis_instance_delete.md b/docs/stackit_redis_instance_delete.md index 589af2424..46b0cdf08 100644 --- a/docs/stackit_redis_instance_delete.md +++ b/docs/stackit_redis_instance_delete.md @@ -28,7 +28,7 @@ stackit redis instance delete INSTANCE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_redis_instance_describe.md b/docs/stackit_redis_instance_describe.md index 50f305096..b80f6f18a 100644 --- a/docs/stackit_redis_instance_describe.md +++ b/docs/stackit_redis_instance_describe.md @@ -31,7 +31,7 @@ stackit redis instance describe INSTANCE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_redis_instance_list.md b/docs/stackit_redis_instance_list.md index b29669d2e..05ee3442b 100644 --- a/docs/stackit_redis_instance_list.md +++ b/docs/stackit_redis_instance_list.md @@ -35,7 +35,7 @@ stackit redis instance list [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_redis_instance_update.md b/docs/stackit_redis_instance_update.md index e87aaf399..bebe8f631 100644 --- a/docs/stackit_redis_instance_update.md +++ b/docs/stackit_redis_instance_update.md @@ -41,7 +41,7 @@ stackit redis instance update INSTANCE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_redis_plans.md b/docs/stackit_redis_plans.md index de76d3d88..1926b02a8 100644 --- a/docs/stackit_redis_plans.md +++ b/docs/stackit_redis_plans.md @@ -35,7 +35,7 @@ stackit redis plans [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_secrets-manager.md b/docs/stackit_secrets-manager.md index f1e9d3cff..e2e61f6f5 100644 --- a/docs/stackit_secrets-manager.md +++ b/docs/stackit_secrets-manager.md @@ -21,7 +21,7 @@ stackit secrets-manager [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_secrets-manager_instance.md b/docs/stackit_secrets-manager_instance.md index 44caf0afa..66dde69b3 100644 --- a/docs/stackit_secrets-manager_instance.md +++ b/docs/stackit_secrets-manager_instance.md @@ -21,7 +21,7 @@ stackit secrets-manager instance [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_secrets-manager_instance_create.md b/docs/stackit_secrets-manager_instance_create.md index 36d046d11..e55be6683 100644 --- a/docs/stackit_secrets-manager_instance_create.md +++ b/docs/stackit_secrets-manager_instance_create.md @@ -33,7 +33,7 @@ stackit secrets-manager instance create [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_secrets-manager_instance_delete.md b/docs/stackit_secrets-manager_instance_delete.md index 99f4a70ae..fd615bfaa 100644 --- a/docs/stackit_secrets-manager_instance_delete.md +++ b/docs/stackit_secrets-manager_instance_delete.md @@ -28,7 +28,7 @@ stackit secrets-manager instance delete INSTANCE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_secrets-manager_instance_describe.md b/docs/stackit_secrets-manager_instance_describe.md index 2fdf41ac9..4e987fce9 100644 --- a/docs/stackit_secrets-manager_instance_describe.md +++ b/docs/stackit_secrets-manager_instance_describe.md @@ -31,7 +31,7 @@ stackit secrets-manager instance describe INSTANCE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_secrets-manager_instance_list.md b/docs/stackit_secrets-manager_instance_list.md index 296b321ee..76dc7031e 100644 --- a/docs/stackit_secrets-manager_instance_list.md +++ b/docs/stackit_secrets-manager_instance_list.md @@ -35,7 +35,7 @@ stackit secrets-manager instance list [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_secrets-manager_instance_update.md b/docs/stackit_secrets-manager_instance_update.md index 9fa66aa18..8393e1c9e 100644 --- a/docs/stackit_secrets-manager_instance_update.md +++ b/docs/stackit_secrets-manager_instance_update.md @@ -29,7 +29,7 @@ stackit secrets-manager instance update INSTANCE_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_secrets-manager_user.md b/docs/stackit_secrets-manager_user.md index 0cacab143..a284739db 100644 --- a/docs/stackit_secrets-manager_user.md +++ b/docs/stackit_secrets-manager_user.md @@ -21,7 +21,7 @@ stackit secrets-manager user [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_secrets-manager_user_create.md b/docs/stackit_secrets-manager_user_create.md index c797958de..6fc635628 100644 --- a/docs/stackit_secrets-manager_user_create.md +++ b/docs/stackit_secrets-manager_user_create.md @@ -36,7 +36,7 @@ stackit secrets-manager user create [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_secrets-manager_user_delete.md b/docs/stackit_secrets-manager_user_delete.md index 539e103b3..15e1f9df3 100644 --- a/docs/stackit_secrets-manager_user_delete.md +++ b/docs/stackit_secrets-manager_user_delete.md @@ -30,7 +30,7 @@ stackit secrets-manager user delete USER_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_secrets-manager_user_describe.md b/docs/stackit_secrets-manager_user_describe.md index 6b10164fd..898623a6c 100644 --- a/docs/stackit_secrets-manager_user_describe.md +++ b/docs/stackit_secrets-manager_user_describe.md @@ -32,7 +32,7 @@ stackit secrets-manager user describe USER_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_secrets-manager_user_list.md b/docs/stackit_secrets-manager_user_list.md index f0e727808..ac502af4c 100644 --- a/docs/stackit_secrets-manager_user_list.md +++ b/docs/stackit_secrets-manager_user_list.md @@ -36,7 +36,7 @@ stackit secrets-manager user list [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_secrets-manager_user_update.md b/docs/stackit_secrets-manager_user_update.md index b1572b00a..dedbd24a9 100644 --- a/docs/stackit_secrets-manager_user_update.md +++ b/docs/stackit_secrets-manager_user_update.md @@ -34,7 +34,7 @@ stackit secrets-manager user update USER_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_service-account.md b/docs/stackit_service-account.md index c5ec6bb1e..17726dcec 100644 --- a/docs/stackit_service-account.md +++ b/docs/stackit_service-account.md @@ -21,7 +21,7 @@ stackit service-account [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_service-account_create.md b/docs/stackit_service-account_create.md index 2ee156ba4..c3a5c3fd9 100644 --- a/docs/stackit_service-account_create.md +++ b/docs/stackit_service-account_create.md @@ -29,7 +29,7 @@ stackit service-account create [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_service-account_delete.md b/docs/stackit_service-account_delete.md index f45a6fd31..5b0723b71 100644 --- a/docs/stackit_service-account_delete.md +++ b/docs/stackit_service-account_delete.md @@ -28,7 +28,7 @@ stackit service-account delete EMAIL [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_service-account_get-jwks.md b/docs/stackit_service-account_get-jwks.md index 11e299671..34837edea 100644 --- a/docs/stackit_service-account_get-jwks.md +++ b/docs/stackit_service-account_get-jwks.md @@ -28,7 +28,7 @@ stackit service-account get-jwks EMAIL [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_service-account_key.md b/docs/stackit_service-account_key.md index 437bb14d8..d07f25588 100644 --- a/docs/stackit_service-account_key.md +++ b/docs/stackit_service-account_key.md @@ -21,7 +21,7 @@ stackit service-account key [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_service-account_key_create.md b/docs/stackit_service-account_key_create.md index 93e137657..1c9cb9f6b 100644 --- a/docs/stackit_service-account_key_create.md +++ b/docs/stackit_service-account_key_create.md @@ -39,7 +39,7 @@ stackit service-account key create [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_service-account_key_delete.md b/docs/stackit_service-account_key_delete.md index a114a37f0..44cac0374 100644 --- a/docs/stackit_service-account_key_delete.md +++ b/docs/stackit_service-account_key_delete.md @@ -29,7 +29,7 @@ stackit service-account key delete KEY_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_service-account_key_describe.md b/docs/stackit_service-account_key_describe.md index b7d319aca..469deee4e 100644 --- a/docs/stackit_service-account_key_describe.md +++ b/docs/stackit_service-account_key_describe.md @@ -29,7 +29,7 @@ stackit service-account key describe KEY_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_service-account_key_list.md b/docs/stackit_service-account_key_list.md index 86e1ad141..66d71702d 100644 --- a/docs/stackit_service-account_key_list.md +++ b/docs/stackit_service-account_key_list.md @@ -36,7 +36,7 @@ stackit service-account key list [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_service-account_key_update.md b/docs/stackit_service-account_key_update.md index cec87b91d..af95f84fa 100644 --- a/docs/stackit_service-account_key_update.md +++ b/docs/stackit_service-account_key_update.md @@ -39,7 +39,7 @@ stackit service-account key update KEY_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_service-account_list.md b/docs/stackit_service-account_list.md index ad5672095..649aa3500 100644 --- a/docs/stackit_service-account_list.md +++ b/docs/stackit_service-account_list.md @@ -29,7 +29,7 @@ stackit service-account list [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_service-account_token.md b/docs/stackit_service-account_token.md index fffcf30eb..f59414260 100644 --- a/docs/stackit_service-account_token.md +++ b/docs/stackit_service-account_token.md @@ -21,7 +21,7 @@ stackit service-account token [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_service-account_token_create.md b/docs/stackit_service-account_token_create.md index 687f6ddfb..3ecf567f9 100644 --- a/docs/stackit_service-account_token_create.md +++ b/docs/stackit_service-account_token_create.md @@ -35,7 +35,7 @@ stackit service-account token create [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_service-account_token_list.md b/docs/stackit_service-account_token_list.md index 1ca82934c..21478fbb2 100644 --- a/docs/stackit_service-account_token_list.md +++ b/docs/stackit_service-account_token_list.md @@ -38,7 +38,7 @@ stackit service-account token list [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_service-account_token_revoke.md b/docs/stackit_service-account_token_revoke.md index c45bf208e..794c0c1ff 100644 --- a/docs/stackit_service-account_token_revoke.md +++ b/docs/stackit_service-account_token_revoke.md @@ -31,7 +31,7 @@ stackit service-account token revoke TOKEN_ID [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_ske.md b/docs/stackit_ske.md index 746ad86bc..117baca74 100644 --- a/docs/stackit_ske.md +++ b/docs/stackit_ske.md @@ -21,7 +21,7 @@ stackit ske [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_ske_cluster.md b/docs/stackit_ske_cluster.md index 6f411f89f..79e768ef3 100644 --- a/docs/stackit_ske_cluster.md +++ b/docs/stackit_ske_cluster.md @@ -21,7 +21,7 @@ stackit ske cluster [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_ske_cluster_create.md b/docs/stackit_ske_cluster_create.md index d75092c03..e27566c41 100644 --- a/docs/stackit_ske_cluster_create.md +++ b/docs/stackit_ske_cluster_create.md @@ -42,7 +42,7 @@ stackit ske cluster create CLUSTER_NAME [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_ske_cluster_delete.md b/docs/stackit_ske_cluster_delete.md index a14214b9d..e496aa242 100644 --- a/docs/stackit_ske_cluster_delete.md +++ b/docs/stackit_ske_cluster_delete.md @@ -28,7 +28,7 @@ stackit ske cluster delete CLUSTER_NAME [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_ske_cluster_describe.md b/docs/stackit_ske_cluster_describe.md index 6c94e14a0..c87d1220b 100644 --- a/docs/stackit_ske_cluster_describe.md +++ b/docs/stackit_ske_cluster_describe.md @@ -31,7 +31,7 @@ stackit ske cluster describe CLUSTER_NAME [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_ske_cluster_generate-payload.md b/docs/stackit_ske_cluster_generate-payload.md index 28b31e269..127be6ef2 100644 --- a/docs/stackit_ske_cluster_generate-payload.md +++ b/docs/stackit_ske_cluster_generate-payload.md @@ -37,7 +37,7 @@ stackit ske cluster generate-payload [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_ske_cluster_list.md b/docs/stackit_ske_cluster_list.md index 2af049bad..1a9c25ef6 100644 --- a/docs/stackit_ske_cluster_list.md +++ b/docs/stackit_ske_cluster_list.md @@ -35,7 +35,7 @@ stackit ske cluster list [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_ske_cluster_update.md b/docs/stackit_ske_cluster_update.md index 362dc4678..2cb4f65bb 100644 --- a/docs/stackit_ske_cluster_update.md +++ b/docs/stackit_ske_cluster_update.md @@ -39,7 +39,7 @@ stackit ske cluster update CLUSTER_NAME [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_ske_credentials.md b/docs/stackit_ske_credentials.md index 41920d19a..70b584bc8 100644 --- a/docs/stackit_ske_credentials.md +++ b/docs/stackit_ske_credentials.md @@ -21,7 +21,7 @@ stackit ske credentials [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_ske_credentials_complete-rotation.md b/docs/stackit_ske_credentials_complete-rotation.md index 583232472..255187290 100644 --- a/docs/stackit_ske_credentials_complete-rotation.md +++ b/docs/stackit_ske_credentials_complete-rotation.md @@ -43,7 +43,7 @@ stackit ske credentials complete-rotation CLUSTER_NAME [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_ske_credentials_start-rotation.md b/docs/stackit_ske_credentials_start-rotation.md index 2ae5f6837..12d47d5f1 100644 --- a/docs/stackit_ske_credentials_start-rotation.md +++ b/docs/stackit_ske_credentials_start-rotation.md @@ -47,7 +47,7 @@ stackit ske credentials start-rotation CLUSTER_NAME [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_ske_describe.md b/docs/stackit_ske_describe.md index 0220938fc..3037f6362 100644 --- a/docs/stackit_ske_describe.md +++ b/docs/stackit_ske_describe.md @@ -28,7 +28,7 @@ stackit ske describe [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_ske_disable.md b/docs/stackit_ske_disable.md index cb5bcfd7f..f6cc385c5 100644 --- a/docs/stackit_ske_disable.md +++ b/docs/stackit_ske_disable.md @@ -28,7 +28,7 @@ stackit ske disable [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_ske_enable.md b/docs/stackit_ske_enable.md index 23e07a2a9..44f4256d2 100644 --- a/docs/stackit_ske_enable.md +++ b/docs/stackit_ske_enable.md @@ -28,7 +28,7 @@ stackit ske enable [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_ske_kubeconfig.md b/docs/stackit_ske_kubeconfig.md index d42c1eaf7..306184110 100644 --- a/docs/stackit_ske_kubeconfig.md +++ b/docs/stackit_ske_kubeconfig.md @@ -21,7 +21,7 @@ stackit ske kubeconfig [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_ske_kubeconfig_create.md b/docs/stackit_ske_kubeconfig_create.md index bbd33fa1a..d1ef0883d 100644 --- a/docs/stackit_ske_kubeconfig_create.md +++ b/docs/stackit_ske_kubeconfig_create.md @@ -44,7 +44,7 @@ stackit ske kubeconfig create CLUSTER_NAME [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_ske_options.md b/docs/stackit_ske_options.md index 7398a83ad..e243ca30f 100644 --- a/docs/stackit_ske_options.md +++ b/docs/stackit_ske_options.md @@ -40,7 +40,7 @@ stackit ske options [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` From 85e56e6a5142173534141c0316cf6f09a2ce7824 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Diogo=20Ferr=C3=A3o?= Date: Tue, 23 Apr 2024 14:58:10 +0200 Subject: [PATCH 16/17] merge main --- internal/pkg/services/argus/utils/utils.go | 2 -- 1 file changed, 2 deletions(-) diff --git a/internal/pkg/services/argus/utils/utils.go b/internal/pkg/services/argus/utils/utils.go index 61d7ad0a4..556c3b7d2 100644 --- a/internal/pkg/services/argus/utils/utils.go +++ b/internal/pkg/services/argus/utils/utils.go @@ -198,8 +198,6 @@ func mapStaticConfigLabels(labels map[string]string) map[string]interface{} { return labelsMap } -======= ->>>>>>> main func GetInstanceName(ctx context.Context, apiClient ArgusClient, instanceId, projectId string) (string, error) { resp, err := apiClient.GetInstanceExecute(ctx, instanceId, projectId) if err != nil { From e9d8070614b5d23ead9725e91d98ab1ce689868e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Diogo=20Ferr=C3=A3o?= Date: Tue, 23 Apr 2024 15:17:29 +0200 Subject: [PATCH 17/17] add error level debug logs to scrape config commands --- docs/stackit_argus_scrape-config.md | 2 +- docs/stackit_argus_scrape-config_create.md | 2 +- docs/stackit_argus_scrape-config_delete.md | 2 +- docs/stackit_argus_scrape-config_describe.md | 2 +- ...tackit_argus_scrape-config_generate-payload.md | 2 +- docs/stackit_argus_scrape-config_list.md | 2 +- docs/stackit_argus_scrape-config_update.md | 2 +- internal/cmd/argus/scrape-config/create/create.go | 11 ++++++----- .../cmd/argus/scrape-config/create/create_test.go | 2 +- internal/cmd/argus/scrape-config/delete/delete.go | 9 +++++---- .../cmd/argus/scrape-config/delete/delete_test.go | 2 +- .../cmd/argus/scrape-config/describe/describe.go | 10 +++++----- .../argus/scrape-config/describe/describe_test.go | 2 +- .../generate-payload/generate_payload.go | 12 ++++++------ .../generate-payload/generate_payload_test.go | 2 +- internal/cmd/argus/scrape-config/list/list.go | 15 ++++++++------- .../cmd/argus/scrape-config/list/list_test.go | 2 +- internal/cmd/argus/scrape-config/update/update.go | 10 +++++----- .../cmd/argus/scrape-config/update/update_test.go | 2 +- 19 files changed, 48 insertions(+), 45 deletions(-) diff --git a/docs/stackit_argus_scrape-config.md b/docs/stackit_argus_scrape-config.md index a04d07494..15dea4a7f 100644 --- a/docs/stackit_argus_scrape-config.md +++ b/docs/stackit_argus_scrape-config.md @@ -21,7 +21,7 @@ stackit argus scrape-config [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_argus_scrape-config_create.md b/docs/stackit_argus_scrape-config_create.md index 9f0f3e13b..cf1dfec34 100644 --- a/docs/stackit_argus_scrape-config_create.md +++ b/docs/stackit_argus_scrape-config_create.md @@ -44,7 +44,7 @@ stackit argus scrape-config create [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_argus_scrape-config_delete.md b/docs/stackit_argus_scrape-config_delete.md index 75a2d43d6..8264d85fc 100644 --- a/docs/stackit_argus_scrape-config_delete.md +++ b/docs/stackit_argus_scrape-config_delete.md @@ -29,7 +29,7 @@ stackit argus scrape-config delete JOB_NAME [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_argus_scrape-config_describe.md b/docs/stackit_argus_scrape-config_describe.md index 567b14e85..0a608a4d9 100644 --- a/docs/stackit_argus_scrape-config_describe.md +++ b/docs/stackit_argus_scrape-config_describe.md @@ -32,7 +32,7 @@ stackit argus scrape-config describe JOB_NAME [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_argus_scrape-config_generate-payload.md b/docs/stackit_argus_scrape-config_generate-payload.md index eb2831d23..94da2ec8d 100644 --- a/docs/stackit_argus_scrape-config_generate-payload.md +++ b/docs/stackit_argus_scrape-config_generate-payload.md @@ -43,7 +43,7 @@ stackit argus scrape-config generate-payload [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_argus_scrape-config_list.md b/docs/stackit_argus_scrape-config_list.md index 10a7fd368..45dc232d6 100644 --- a/docs/stackit_argus_scrape-config_list.md +++ b/docs/stackit_argus_scrape-config_list.md @@ -36,7 +36,7 @@ stackit argus scrape-config list [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/docs/stackit_argus_scrape-config_update.md b/docs/stackit_argus_scrape-config_update.md index 253e1732e..a3b523377 100644 --- a/docs/stackit_argus_scrape-config_update.md +++ b/docs/stackit_argus_scrape-config_update.md @@ -40,7 +40,7 @@ stackit argus scrape-config update JOB_NAME [flags] ``` -y, --assume-yes If set, skips all confirmation prompts --async If set, runs the command asynchronously - -o, --output-format string Output format, one of ["json" "pretty"] + -o, --output-format string Output format, one of ["json" "pretty" "none"] -p, --project-id string Project ID --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") ``` diff --git a/internal/cmd/argus/scrape-config/create/create.go b/internal/cmd/argus/scrape-config/create/create.go index 329d59e1a..a779ae375 100644 --- a/internal/cmd/argus/scrape-config/create/create.go +++ b/internal/cmd/argus/scrape-config/create/create.go @@ -60,7 +60,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -73,6 +73,7 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := argusUtils.GetInstanceName(ctx, apiClient, model.InstanceId, model.ProjectId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } @@ -133,13 +134,13 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - payloadValue := flags.FlagToStringPointer(cmd, payloadFlag) + payloadValue := flags.FlagToStringPointer(p, cmd, payloadFlag) var payload *argus.CreateScrapeConfigPayload if payloadValue != nil { payload = &argus.CreateScrapeConfigPayload{} @@ -152,7 +153,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, Payload: payload, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), }, nil } diff --git a/internal/cmd/argus/scrape-config/create/create_test.go b/internal/cmd/argus/scrape-config/create/create_test.go index 181862653..a9ca561b4 100644 --- a/internal/cmd/argus/scrape-config/create/create_test.go +++ b/internal/cmd/argus/scrape-config/create/create_test.go @@ -261,7 +261,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/argus/scrape-config/delete/delete.go b/internal/cmd/argus/scrape-config/delete/delete.go index 0e7085f7b..31cc6d855 100644 --- a/internal/cmd/argus/scrape-config/delete/delete.go +++ b/internal/cmd/argus/scrape-config/delete/delete.go @@ -44,7 +44,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -57,6 +57,7 @@ func NewCmd(p *print.Printer) *cobra.Command { instanceLabel, err := argusUtils.GetInstanceName(ctx, apiClient, model.InstanceId, model.ProjectId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } @@ -105,10 +106,10 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { jobName := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } @@ -116,7 +117,7 @@ func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, JobName: jobName, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), }, nil } diff --git a/internal/cmd/argus/scrape-config/delete/delete_test.go b/internal/cmd/argus/scrape-config/delete/delete_test.go index f6f7ae5b6..21d1b79c9 100644 --- a/internal/cmd/argus/scrape-config/delete/delete_test.go +++ b/internal/cmd/argus/scrape-config/delete/delete_test.go @@ -183,7 +183,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/argus/scrape-config/describe/describe.go b/internal/cmd/argus/scrape-config/describe/describe.go index 9d9af74cf..5792f9986 100644 --- a/internal/cmd/argus/scrape-config/describe/describe.go +++ b/internal/cmd/argus/scrape-config/describe/describe.go @@ -47,7 +47,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -78,10 +78,10 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { jobName := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } @@ -89,7 +89,7 @@ func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, JobName: jobName, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), }, nil } @@ -100,7 +100,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *argus.APICl func outputResult(p *print.Printer, outputFormat string, config *argus.Job) error { switch outputFormat { - case globalflags.PrettyOutputFormat: + case print.PrettyOutputFormat: saml2Enabled := "Enabled" if config.Params != nil { diff --git a/internal/cmd/argus/scrape-config/describe/describe_test.go b/internal/cmd/argus/scrape-config/describe/describe_test.go index ab2217f3e..962d373a9 100644 --- a/internal/cmd/argus/scrape-config/describe/describe_test.go +++ b/internal/cmd/argus/scrape-config/describe/describe_test.go @@ -183,7 +183,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/argus/scrape-config/generate-payload/generate_payload.go b/internal/cmd/argus/scrape-config/generate-payload/generate_payload.go index 53d47fc53..310ac67f3 100644 --- a/internal/cmd/argus/scrape-config/generate-payload/generate_payload.go +++ b/internal/cmd/argus/scrape-config/generate-payload/generate_payload.go @@ -55,7 +55,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -94,11 +94,11 @@ func configureFlags(cmd *cobra.Command) { cmd.Flags().StringP(jobNameFlag, "n", "", "If set, generates an update payload with the current state of the given scrape config. If unset, generates a create payload with default values") } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) - jobName := flags.FlagToStringPointer(cmd, jobNameFlag) - instanceId := flags.FlagToStringValue(cmd, instanceIdFlag) + jobName := flags.FlagToStringPointer(p, cmd, jobNameFlag) + instanceId := flags.FlagToStringValue(p, cmd, instanceIdFlag) if jobName != nil && (globalFlags.ProjectId == "" || instanceId == "") { return nil, fmt.Errorf("if a job-name is provided then instance-id and project-id must be provided") @@ -107,7 +107,7 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, JobName: jobName, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), }, nil } diff --git a/internal/cmd/argus/scrape-config/generate-payload/generate_payload_test.go b/internal/cmd/argus/scrape-config/generate-payload/generate_payload_test.go index afb663f08..3c1fafd38 100644 --- a/internal/cmd/argus/scrape-config/generate-payload/generate_payload_test.go +++ b/internal/cmd/argus/scrape-config/generate-payload/generate_payload_test.go @@ -186,7 +186,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/argus/scrape-config/list/list.go b/internal/cmd/argus/scrape-config/list/list.go index 385a20597..c726b53aa 100644 --- a/internal/cmd/argus/scrape-config/list/list.go +++ b/internal/cmd/argus/scrape-config/list/list.go @@ -50,7 +50,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd) + model, err := parseInput(p, cmd) if err != nil { return err } @@ -71,6 +71,7 @@ func NewCmd(p *print.Printer) *cobra.Command { if len(configs) == 0 { instanceLabel, err := argusUtils.GetInstanceName(ctx, apiClient, model.InstanceId, model.ProjectId) if err != nil { + p.Debug(print.ErrorLevel, "get instance name: %v", err) instanceLabel = model.InstanceId } p.Info("No scrape configurations found for instance %q\n", instanceLabel) @@ -98,13 +99,13 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command) (*inputModel, error) { - globalFlags := globalflags.Parse(cmd) +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - limit := flags.FlagToInt64Pointer(cmd, limitFlag) + limit := flags.FlagToInt64Pointer(p, cmd, limitFlag) if limit != nil && *limit < 1 { return nil, &errors.FlagValidationError{ Flag: limitFlag, @@ -114,8 +115,8 @@ func parseInput(cmd *cobra.Command) (*inputModel, error) { return &inputModel{ GlobalFlagModel: globalFlags, - Limit: flags.FlagToInt64Pointer(cmd, limitFlag), - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + Limit: flags.FlagToInt64Pointer(p, cmd, limitFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), }, nil } @@ -126,7 +127,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *argus.APICl func outputResult(p *print.Printer, outputFormat string, configs []argus.Job) error { switch outputFormat { - case globalflags.JSONOutputFormat: + case print.JSONOutputFormat: details, err := json.MarshalIndent(configs, "", " ") if err != nil { return fmt.Errorf("marshal scrape configurations list: %w", err) diff --git a/internal/cmd/argus/scrape-config/list/list_test.go b/internal/cmd/argus/scrape-config/list/list_test.go index 9a5952a32..a62605da2 100644 --- a/internal/cmd/argus/scrape-config/list/list_test.go +++ b/internal/cmd/argus/scrape-config/list/list_test.go @@ -162,7 +162,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd) + model, err := parseInput(nil, cmd) if err != nil { if !tt.isValid { return diff --git a/internal/cmd/argus/scrape-config/update/update.go b/internal/cmd/argus/scrape-config/update/update.go index 25bdeb908..ef92943ce 100644 --- a/internal/cmd/argus/scrape-config/update/update.go +++ b/internal/cmd/argus/scrape-config/update/update.go @@ -56,7 +56,7 @@ func NewCmd(p *print.Printer) *cobra.Command { ), RunE: func(cmd *cobra.Command, args []string) error { ctx := context.Background() - model, err := parseInput(cmd, args) + model, err := parseInput(p, cmd, args) if err != nil { return err } @@ -99,15 +99,15 @@ func configureFlags(cmd *cobra.Command) { cobra.CheckErr(err) } -func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { +func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) { clusterName := inputArgs[0] - globalFlags := globalflags.Parse(cmd) + globalFlags := globalflags.Parse(p, cmd) if globalFlags.ProjectId == "" { return nil, &errors.ProjectIdError{} } - payloadString := flags.FlagToStringValue(cmd, payloadFlag) + payloadString := flags.FlagToStringValue(p, cmd, payloadFlag) var payload argus.UpdateScrapeConfigPayload err := json.Unmarshal([]byte(payloadString), &payload) if err != nil { @@ -118,7 +118,7 @@ func parseInput(cmd *cobra.Command, inputArgs []string) (*inputModel, error) { GlobalFlagModel: globalFlags, JobName: clusterName, Payload: payload, - InstanceId: flags.FlagToStringValue(cmd, instanceIdFlag), + InstanceId: flags.FlagToStringValue(p, cmd, instanceIdFlag), }, nil } diff --git a/internal/cmd/argus/scrape-config/update/update_test.go b/internal/cmd/argus/scrape-config/update/update_test.go index c89bc2db1..232d798c5 100644 --- a/internal/cmd/argus/scrape-config/update/update_test.go +++ b/internal/cmd/argus/scrape-config/update/update_test.go @@ -251,7 +251,7 @@ func TestParseInput(t *testing.T) { t.Fatalf("error validating flags: %v", err) } - model, err := parseInput(cmd, tt.argValues) + model, err := parseInput(nil, cmd, tt.argValues) if err != nil { if !tt.isValid { return