| // Copyright (c) HashiCorp, Inc. |
| |
| package provider |
| |
| import ( |
| "context" |
| "fmt" |
| "strconv" |
| "strings" |
| "time" |
| |
| "terraform-provider-devlake/internal/client" |
| |
| "github.com/hashicorp/terraform-plugin-framework/path" |
| "github.com/hashicorp/terraform-plugin-framework/resource" |
| "github.com/hashicorp/terraform-plugin-framework/resource/schema" |
| "github.com/hashicorp/terraform-plugin-framework/resource/schema/planmodifier" |
| "github.com/hashicorp/terraform-plugin-framework/resource/schema/stringplanmodifier" |
| "github.com/hashicorp/terraform-plugin-framework/types" |
| ) |
| |
| // Ensure the implementation satisfies the expected interfaces. |
| var ( |
| _ resource.Resource = &bitbucketServerConnectionScopeResource{} |
| _ resource.ResourceWithConfigure = &bitbucketServerConnectionScopeResource{} |
| _ resource.ResourceWithImportState = &bitbucketServerConnectionScopeResource{} |
| ) |
| |
| // NewBitbucketServerConnectionScopeResource is a helper function to simplify the provider implementation. |
| func NewBitbucketServerConnectionScopeResource() resource.Resource { |
| return &bitbucketServerConnectionScopeResource{} |
| } |
| |
| // bitbucketServerConnectionScopeResource is the resource implementation. |
| type bitbucketServerConnectionScopeResource struct { |
| client *client.Client |
| } |
| |
| // bitbucketServerConnectionScopeResourceModel maps the resource schema data. |
| type bitbucketServerConnectionScopeResourceModel struct { |
| ID types.String `tfsdk:"id"` |
| LastUpdated types.String `tfsdk:"last_updated"` |
| CloneUrl types.String `tfsdk:"clone_url"` |
| ConnectionId types.String `tfsdk:"connection_id"` |
| CreatedAt types.String `tfsdk:"created_at"` |
| Description types.String `tfsdk:"description"` |
| HTMLUrl types.String `tfsdk:"html_url"` |
| Name types.String `tfsdk:"name"` |
| ScopeConfigId types.String `tfsdk:"scope_config_id"` |
| } |
| |
| // Metadata returns the resource type name. |
| func (r *bitbucketServerConnectionScopeResource) Metadata(_ context.Context, req resource.MetadataRequest, resp *resource.MetadataResponse) { |
| resp.TypeName = req.ProviderTypeName + "_bitbucketserver_connection_scope" |
| } |
| |
| // Schema defines the schema for the resource. |
| func (r *bitbucketServerConnectionScopeResource) Schema(_ context.Context, _ resource.SchemaRequest, resp *resource.SchemaResponse) { |
| resp.Schema = schema.Schema{ |
| Attributes: map[string]schema.Attribute{ |
| "id": schema.StringAttribute{ |
| Required: true, |
| Description: "The Bitbucket project and repository in the format '<PROJECT>/repos/<REPOSITORY>'.", |
| PlanModifiers: []planmodifier.String{ |
| stringplanmodifier.UseStateForUnknown(), |
| }, |
| }, |
| "last_updated": schema.StringAttribute{ |
| Computed: true, |
| Description: "Timestamp of the last Terraform update of the connection scope.", |
| PlanModifiers: []planmodifier.String{ |
| stringplanmodifier.UseStateForUnknown(), |
| }, |
| }, |
| "clone_url": schema.StringAttribute{ |
| Description: "The Bitbucket https clone url.", |
| Required: true, |
| }, |
| "connection_id": schema.StringAttribute{ |
| Description: "The Connection this scope is part of.", |
| Required: true, |
| }, |
| "created_at": schema.StringAttribute{ |
| Computed: true, |
| Description: "When the scope was created in devlake.", |
| PlanModifiers: []planmodifier.String{ |
| stringplanmodifier.UseStateForUnknown(), |
| }, |
| }, |
| "description": schema.StringAttribute{ |
| Description: "A description for the connection scope.", |
| Required: true, |
| }, |
| "html_url": schema.StringAttribute{ |
| Description: "The Bitbucket HTML browse url.", |
| Required: true, |
| }, |
| "name": schema.StringAttribute{ |
| Description: "A name for the connection scope.", |
| Required: true, |
| }, |
| "scope_config_id": schema.StringAttribute{ |
| Description: "The config used for the scope. Needs to be created first.", |
| Required: true, |
| }, |
| }, |
| } |
| } |
| |
| // Create a new resource. |
| func (r *bitbucketServerConnectionScopeResource) Create(ctx context.Context, req resource.CreateRequest, resp *resource.CreateResponse) { |
| // Retrieve values from plan |
| var plan bitbucketServerConnectionScopeResourceModel |
| diags := req.Plan.Get(ctx, &plan) |
| resp.Diagnostics.Append(diags...) |
| if resp.Diagnostics.HasError() { |
| return |
| } |
| |
| // Generate API request body from plan |
| connectionId, err := strconv.Atoi(plan.ConnectionId.ValueString()) |
| if err != nil { |
| resp.Diagnostics.AddError( |
| "Error creating devlake bitbucket server connection scope", |
| "Could not create devlake bitbucket server connection scope, unexpected error: "+err.Error(), |
| ) |
| return |
| } |
| scopeConfigId, err := strconv.Atoi(plan.ScopeConfigId.ValueString()) |
| if err != nil { |
| resp.Diagnostics.AddError( |
| "Error creating devlake bitbucket server connection scope", |
| "Could not create devlake bitbucket server connection scope, unexpected error: "+err.Error(), |
| ) |
| return |
| } |
| now := time.Now().Format(time.RFC3339) |
| var bitbucketServerConnectionScopeCreate = client.BitbucketServerConnectionScope{ |
| BitbucketId: plan.ID.ValueString(), |
| CloneUrl: plan.CloneUrl.ValueString(), |
| ConnectionId: connectionId, |
| CreatedAt: now, |
| Description: plan.Description.ValueString(), |
| HTMLUrl: plan.HTMLUrl.ValueString(), |
| Name: plan.Name.ValueString(), |
| ScopeConfigId: scopeConfigId, |
| UpdatedAt: now, |
| } |
| |
| // Create new bitbucketserverconnectionscope |
| bitbucketServerConnectionScope, err := r.client.CreateBitbucketServerConnectionScope(plan.ConnectionId.ValueString(), bitbucketServerConnectionScopeCreate) |
| if err != nil { |
| resp.Diagnostics.AddError( |
| "Error creating devlake bitbucket server connection scope", |
| "Could not create devlake bitbucket server connection scope, unexpected error: "+err.Error(), |
| ) |
| return |
| } |
| |
| // Map response body to schema and populate Computed attribute values |
| plan.ID = types.StringValue(bitbucketServerConnectionScope.BitbucketId) |
| plan.LastUpdated = types.StringValue(time.Now().Format(time.RFC3339)) |
| plan.CloneUrl = types.StringValue(bitbucketServerConnectionScope.CloneUrl) |
| plan.ConnectionId = types.StringValue(strconv.Itoa(bitbucketServerConnectionScope.ConnectionId)) |
| plan.CreatedAt = types.StringValue(bitbucketServerConnectionScope.CreatedAt) |
| plan.Description = types.StringValue(bitbucketServerConnectionScope.Description) |
| plan.HTMLUrl = types.StringValue(bitbucketServerConnectionScope.HTMLUrl) |
| plan.Name = types.StringValue(bitbucketServerConnectionScope.Name) |
| plan.ScopeConfigId = types.StringValue(strconv.Itoa(bitbucketServerConnectionScope.ScopeConfigId)) |
| |
| // Set state to fully populated data |
| diags = resp.State.Set(ctx, plan) |
| resp.Diagnostics.Append(diags...) |
| if resp.Diagnostics.HasError() { |
| return |
| } |
| } |
| |
| // Read refreshes the Terraform state with the latest data. |
| func (r *bitbucketServerConnectionScopeResource) Read(ctx context.Context, req resource.ReadRequest, resp *resource.ReadResponse) { |
| // Get current state |
| var state bitbucketServerConnectionScopeResourceModel |
| diags := req.State.Get(ctx, &state) |
| resp.Diagnostics.Append(diags...) |
| if resp.Diagnostics.HasError() { |
| return |
| } |
| |
| // Get refreshed bitbucket server connection scope value from Devlake |
| bitbucketServerConnectionScope, err := r.client.ReadBitbucketServerConnectionScope(state.ConnectionId.ValueString(), state.ID.ValueString()) |
| if err != nil { |
| resp.Diagnostics.AddError( |
| "Unable to read devlake bitbucket server connection scope", |
| err.Error(), |
| ) |
| return |
| } |
| |
| // Overwrite connection with refreshed state |
| state.ID = types.StringValue(bitbucketServerConnectionScope.BitbucketId) |
| state.CloneUrl = types.StringValue(bitbucketServerConnectionScope.CloneUrl) |
| state.ConnectionId = types.StringValue(strconv.Itoa(bitbucketServerConnectionScope.ConnectionId)) |
| state.CreatedAt = types.StringValue(bitbucketServerConnectionScope.CreatedAt) |
| state.Description = types.StringValue(bitbucketServerConnectionScope.Description) |
| state.HTMLUrl = types.StringValue(bitbucketServerConnectionScope.HTMLUrl) |
| state.Name = types.StringValue(bitbucketServerConnectionScope.Name) |
| state.ScopeConfigId = types.StringValue(strconv.Itoa(bitbucketServerConnectionScope.ScopeConfigId)) |
| |
| // Set refreshed state |
| diags = resp.State.Set(ctx, &state) |
| resp.Diagnostics.Append(diags...) |
| if resp.Diagnostics.HasError() { |
| return |
| } |
| } |
| |
| // Update fetches the resource and sets the updated Terraform state on success. |
| func (r *bitbucketServerConnectionScopeResource) Update(ctx context.Context, req resource.UpdateRequest, resp *resource.UpdateResponse) { |
| // Retrieve values from plan |
| var plan bitbucketServerConnectionScopeResourceModel |
| diags := req.Plan.Get(ctx, &plan) |
| resp.Diagnostics.Append(diags...) |
| if resp.Diagnostics.HasError() { |
| return |
| } |
| |
| // Generate API request body from plan |
| connectionId, err := strconv.Atoi(plan.ConnectionId.ValueString()) |
| if err != nil { |
| resp.Diagnostics.AddError( |
| "Error updating devlake bitbucket server connection scope", |
| "Could not update devlake bitbucket server connection scope, unexpected error: "+err.Error(), |
| ) |
| return |
| } |
| scopeConfigId, err := strconv.Atoi(plan.ScopeConfigId.ValueString()) |
| if err != nil { |
| resp.Diagnostics.AddError( |
| "Error creating devlake bitbucket server connection scope", |
| "Could not create devlake bitbucket server connection scope, unexpected error: "+err.Error(), |
| ) |
| return |
| } |
| var bitbucketServerConnectionScopeUpdate = client.BitbucketServerConnectionScope{ |
| BitbucketId: plan.ID.ValueString(), |
| CloneUrl: plan.CloneUrl.ValueString(), |
| ConnectionId: connectionId, |
| CreatedAt: plan.CreatedAt.ValueString(), |
| Description: plan.Description.ValueString(), |
| HTMLUrl: plan.HTMLUrl.ValueString(), |
| Name: plan.Name.ValueString(), |
| ScopeConfigId: scopeConfigId, |
| UpdatedAt: time.Now().Format(time.RFC3339), |
| } |
| |
| // Update existing connection scope |
| updatedBitbucketServerConnectionScope, err := r.client.UpdateBitbucketServerConnectionScope(plan.ConnectionId.ValueString(), plan.ID.ValueString(), bitbucketServerConnectionScopeUpdate) |
| if err != nil { |
| resp.Diagnostics.AddError( |
| "Error updating devlake bitbucket server connection scope", |
| "Could not update devlake bitbucket server connection scope, unexpected error: "+err.Error(), |
| ) |
| return |
| } |
| plan.ID = types.StringValue(updatedBitbucketServerConnectionScope.BitbucketId) |
| plan.CloneUrl = types.StringValue(updatedBitbucketServerConnectionScope.CloneUrl) |
| plan.ConnectionId = types.StringValue(strconv.Itoa(updatedBitbucketServerConnectionScope.ConnectionId)) |
| plan.CreatedAt = types.StringValue(updatedBitbucketServerConnectionScope.CreatedAt) |
| plan.Description = types.StringValue(updatedBitbucketServerConnectionScope.Description) |
| plan.HTMLUrl = types.StringValue(updatedBitbucketServerConnectionScope.HTMLUrl) |
| plan.Name = types.StringValue(updatedBitbucketServerConnectionScope.Name) |
| plan.ScopeConfigId = types.StringValue(strconv.Itoa(updatedBitbucketServerConnectionScope.ScopeConfigId)) |
| |
| diags = resp.State.Set(ctx, plan) |
| resp.Diagnostics.Append(diags...) |
| if resp.Diagnostics.HasError() { |
| return |
| } |
| } |
| |
| // Delete deletes the resource and removes the Terraform state on success. |
| func (r *bitbucketServerConnectionScopeResource) Delete(ctx context.Context, req resource.DeleteRequest, resp *resource.DeleteResponse) { |
| // Retrieve values from state |
| var state bitbucketServerConnectionScopeResourceModel |
| diags := req.State.Get(ctx, &state) |
| resp.Diagnostics.Append(diags...) |
| if resp.Diagnostics.HasError() { |
| return |
| } |
| |
| // Delete existing apikey |
| err := r.client.DeleteBitbucketServerConnectionScope(state.ConnectionId.ValueString(), state.ID.ValueString()) |
| if err != nil { |
| resp.Diagnostics.AddError( |
| "Error deleting devlake bitbucket server connection scope", |
| "Could not delete devlake bitbucket server connection scope, unexpected error: "+err.Error(), |
| ) |
| return |
| } |
| } |
| |
| func (r *bitbucketServerConnectionScopeResource) ImportState(ctx context.Context, req resource.ImportStateRequest, resp *resource.ImportStateResponse) { |
| // Retrieve import ID and connection id and save to attribute |
| idParts := strings.Split(req.ID, ",") |
| |
| if len(idParts) != 2 || idParts[0] == "" || idParts[1] == "" { |
| resp.Diagnostics.AddError( |
| "Unexpected Import Identifier", |
| fmt.Sprintf("Expected import identifier with format: connection_id,scope_id. Got: %q", req.ID), |
| ) |
| return |
| } |
| |
| resp.Diagnostics.Append(resp.State.SetAttribute(ctx, path.Root("connection_id"), idParts[0])...) |
| resp.Diagnostics.Append(resp.State.SetAttribute(ctx, path.Root("id"), idParts[1])...) |
| } |
| |
| // Configure adds the provider configured client to the resource. |
| func (r *bitbucketServerConnectionScopeResource) Configure(_ context.Context, req resource.ConfigureRequest, resp *resource.ConfigureResponse) { |
| // Add a nil check when handling ProviderData because Terraform |
| // sets that data after it calls the ConfigureProvider RPC. |
| if req.ProviderData == nil { |
| return |
| } |
| |
| client, ok := req.ProviderData.(*client.Client) |
| if !ok { |
| resp.Diagnostics.AddError( |
| "Unexpected Resource Configure Type", |
| fmt.Sprintf("Expected *client.Client, got: %T. Please report this issue to the provider developers.", req.ProviderData), |
| ) |
| |
| return |
| } |
| |
| r.client = client |
| } |
