func()

in ec/provider.go [190:357]

• 132 lines of code
• 20 McCabe index (conditional complexity)

func (p *Provider) Configure(ctx context.Context, req provider.ConfigureRequest, resp *provider.ConfigureResponse) {
	if p.client != nil {
		data := internal.ProviderClients{
			Stateful:   p.client,
			Serverless: p.slsClient,
		}
		// Required for unit tests, because a mock client is pre-created there.
		resp.DataSourceData = data
		resp.ResourceData = data
		return
	}

	var config providerConfig

	diags := req.Config.Get(ctx, &config)

	resp.Diagnostics.Append(diags...)

	if resp.Diagnostics.HasError() {
		return
	}

	endpoint := config.Endpoint.ValueString()

	if config.Endpoint.ValueString() == "" {
		endpoint = util.MultiGetenvOrDefault([]string{"EC_ENDPOINT", "EC_HOST"}, api.ESSEndpoint)

		diags := validateEndpoint(ctx, endpoint)

		resp.Diagnostics.Append(diags...)

		if diags.HasError() {
			return
		}
	}

	apiKey := config.ApiKey.ValueString()

	if config.ApiKey.ValueString() == "" {
		apiKey = util.MultiGetenvOrDefault([]string{"EC_API_KEY"}, "")
	}

	username := config.Username.ValueString()

	if config.Username.ValueString() == "" {
		username = util.MultiGetenvOrDefault([]string{"EC_USER", "EC_USERNAME"}, "")
	}

	password := config.Password.ValueString()

	if config.Password.ValueString() == "" {
		password = util.MultiGetenvOrDefault([]string{"EC_PASS", "EC_PASSWORD"}, "")
	}

	timeoutStr := config.Timeout.ValueString()

	if config.Timeout.ValueString() == "" {
		timeoutStr = util.MultiGetenvOrDefault([]string{"EC_TIMEOUT"}, defaultTimeout.String())
	}

	timeout, err := time.ParseDuration(timeoutStr)

	if err != nil {
		resp.Diagnostics.AddError("Unable to create client", err.Error())
		return
	}

	insecure := config.Insecure.ValueBool()

	if config.Insecure.IsNull() {
		insecureStr := util.MultiGetenvOrDefault([]string{"EC_INSECURE", "EC_SKIP_TLS_VALIDATION"}, "")

		if insecure, err = util.StringToBool(insecureStr); err != nil {
			resp.Diagnostics.AddError(
				"Unable to create client",
				fmt.Sprintf("Invalid value '%v' in 'EC_INSECURE' or 'EC_SKIP_TLS_VALIDATION'", insecureStr),
			)
			return
		}
	}

	verbose := config.Verbose.ValueBool()

	if config.Verbose.IsNull() {
		verboseStr := util.MultiGetenvOrDefault([]string{"EC_VERBOSE"}, "")

		if verbose, err = util.StringToBool(verboseStr); err != nil {
			resp.Diagnostics.AddError(
				"Unable to create client",
				fmt.Sprintf("Invalid value '%v' in 'EC_VERBOSE'", verboseStr),
			)
			return
		}
	}

	verboseCredentials := config.VerboseCredentials.ValueBool()

	if config.VerboseCredentials.IsNull() {
		verboseCredentialsStr := util.MultiGetenvOrDefault([]string{"EC_VERBOSE_CREDENTIALS"}, "")

		if verboseCredentials, err = util.StringToBool(verboseCredentialsStr); err != nil {
			resp.Diagnostics.AddError(
				"Unable to create client",
				fmt.Sprintf("Invalid value '%v' in 'EC_VERBOSE_CREDENTIALS'", verboseCredentialsStr),
			)
			return
		}
	}

	verboseFile := config.VerboseFile.ValueString()

	if config.VerboseFile.IsNull() {
		verboseFile = util.MultiGetenvOrDefault([]string{"EC_VERBOSE_FILE"}, "request.log")
	}

	cfg, err := newAPIConfig(apiSetup{
		endpoint:           endpoint,
		apikey:             apiKey,
		username:           username,
		password:           password,
		insecure:           insecure,
		timeout:            timeout,
		verbose:            verbose,
		verboseCredentials: verboseCredentials,
		verboseFile:        verboseFile,
	})

	if err != nil {
		resp.Diagnostics.AddError(
			"Unable to create api Client config",
			err.Error(),
		)
		return
	}

	client, err := api.NewAPI(cfg)
	if err != nil {
		resp.Diagnostics.AddError(
			"Unable to create api Client",
			err.Error(),
		)
		return
	}

	serverlessClient, err := serverless.NewClientWithResponses(
		cfg.Host,
		serverless.WithHTTPClient(cfg.Client),
		serverless.WithRequestEditorFn(func(ctx context.Context, req *http.Request) error {
			cfg.AuthWriter.AuthRequest(req)
			return nil
		}),
	)
	if err != nil {
		resp.Diagnostics.AddError(
			"Unable to create serverless Client",
			err.Error(),
		)
	}

	p.client = client
	p.slsClient = serverlessClient
	data := internal.ProviderClients{
		Stateful:   client,
		Serverless: serverlessClient,
	}
	resp.DataSourceData = data
	resp.ResourceData = data
}