[3.1.4] Service Tags support added (#21)

Author: vasiliyskysql

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## [3.1.4] - 2025-07-17
+### Features
+- service `tags` support added.
+
 ## [3.1.3] - 2024-07-25
 ### Package Updates
 - upgraded go 1.19 => 1.21

docs/resources/skysql_service.md

@@ -29,6 +29,10 @@ resource "skysql_service" "default" {
   volume_type       = "gp3"
   volume_iops       = 3000
   volume_throughput = 125
+  tags = {
+    name        = "myservice"  # API will overwrite this with service name
+    environment = "production" # Optional additional tags
+  }
   # The service create is an asynchronous operation.
   # if you want to wait for the service to be created set wait_for_creation to true
   wait_for_creation = true
@@ -65,6 +69,7 @@ resource "skysql_service" "default" {
 - `size` (String) The size of the service. Valid values are: sky-2x4, sky-2x8 etc
 - `ssl_enabled` (Boolean) Whether to enable SSL. Valid values are: true or false
 - `storage` (Number) The storage size in GB. Valid values are: 100, 200, 300, 400, 500, 600, 700, 800, 900, 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000
+- `tags` (Map of String) Tags associated with the service. Note: The API will automatically overwrite 'tags.name' with the service name.
 - `timeouts` (Block, Optional) (see [below for nested schema](#nestedblock--timeouts))
 - `version` (String) The software version
 - `volume_iops` (Number) The volume IOPS. This is only applicable for AWS

examples/main.tf

@@ -29,6 +29,11 @@ resource "skysql_service" "default" {
   volume_type       = "gp3"
   volume_iops       = 3000
   volume_throughput = 125
+  tags = {
+    environment = "production"
+    team        = "backend"
+    # Note: tags.name is automatically set to match the service name
+  }
   allow_list = [
     {
       "ip" : "127.0.0.1/32",

examples/resources/skysql_service.tf

@@ -15,6 +15,10 @@ resource "skysql_service" "default" {
   volume_type       = "gp3"
   volume_iops       = 3000
   volume_throughput = 125
+  tags = {
+    name        = "myservice"  # API will overwrite this with service name
+    environment = "production" # Optional additional tags
+  }
   # The service create is an asynchronous operation.
   # if you want to wait for the service to be created set wait_for_creation to true
   wait_for_creation = true

internal/provider/service_resource.go

@@ -98,6 +98,7 @@ type ServiceResourceModel struct {
 	MaxscaleSize       types.String   `tfsdk:"maxscale_size"`
 	FQDN               types.String   `tfsdk:"fqdn"`
 	AvailabilityZone   types.String   `tfsdk:"availability_zone"`
+	Tags               types.Map      `tfsdk:"tags"`
 }
 
 // ServiceResourceNamedPortModel is an endpoint port
@@ -133,9 +134,6 @@ var serviceResourceSchemaV0 = schema.Schema{
 					"must start from a lowercase letter and contain only lowercase letters, numbers and hyphens",
 				),
 			},
-			PlanModifiers: []planmodifier.String{
-				stringplanmodifier.RequiresReplace(),
-			},
 		},
 		"project_id": schema.StringAttribute{
 			Required:    false,
@@ -403,6 +401,15 @@ var serviceResourceSchemaV0 = schema.Schema{
 				stringplanmodifier.RequiresReplace(),
 			},
 		},
+		"tags": schema.MapAttribute{
+			Optional:    true,
+			Computed:    true,
+			ElementType: types.StringType,
+			Description: "Tags associated with the service. Note: The API will automatically overwrite 'tags.name' with the service name.",
+			PlanModifiers: []planmodifier.Map{
+				&tagsNamePlanModifier{},
+			},
+		},
 	},
 	Blocks: map[string]schema.Block{
 		"timeouts": timeouts.Block(context.Background(), timeouts.Opts{
@@ -471,6 +478,17 @@ func (r *ServiceResource) Create(ctx context.Context, req resource.CreateRequest
 		AvailabilityZone:   state.AvailabilityZone.ValueString(),
 	}
 
+	// Convert Tags from Terraform to map[string]string
+	if !state.Tags.IsNull() && !state.Tags.IsUnknown() {
+		var tags map[string]string
+		diags := state.Tags.ElementsAs(ctx, &tags, false)
+		if diags.HasError() {
+			resp.Diagnostics.Append(diags...)
+			return
+		}
+		createServiceRequest.Tags = tags
+	}
+
 	if !Contains[string]([]string{"gcp", "aws", "azure"}, createServiceRequest.Provider) {
 		resp.Diagnostics.AddAttributeError(path.Root("provider"),
 			"Invalid provider value",
@@ -721,6 +739,11 @@ func (r *ServiceResource) readServiceState(ctx context.Context, data *ServiceRes
 	if !(data.MaxscaleNodes.IsUnknown() || data.MaxscaleSize.IsNull()) {
 		data.MaxscaleNodes = types.Int64Value(int64(service.MaxscaleNodes))
 	}
+	if service.Tags != nil {
+		data.Tags, _ = types.MapValueFrom(ctx, types.StringType, service.Tags)
+	} else {
+		data.Tags = types.MapNull(types.StringType)
+	}
 	return nil
 }
 
@@ -783,6 +806,11 @@ func (r *ServiceResource) Update(ctx context.Context, req resource.UpdateRequest
 		return
 	}
 
+	r.updateServiceTags(ctx, plan, state, resp)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
 	err := r.readServiceState(ctx, state)
 	if err != nil {
 		if errors.Is(err, skysql.ErrorServiceNotFound) {
@@ -1035,6 +1063,63 @@ func (r *ServiceResource) updateServicePowerState(ctx context.Context, plan *Ser
 	}
 }
 
+func (r *ServiceResource) updateServiceTags(ctx context.Context, plan *ServiceResourceModel, state *ServiceResourceModel, resp *resource.UpdateResponse) {
+	if !plan.Tags.IsUnknown() {
+		var planTags map[string]string
+		diags := plan.Tags.ElementsAs(ctx, &planTags, false)
+		if diags.HasError() {
+			// Log warning but don't fail the update to protect against state incompatibility
+			tflog.Warn(ctx, "Failed to parse plan tags, skipping tag update", map[string]interface{}{
+				"id":    state.ID.ValueString(),
+				"error": diags.Errors(),
+			})
+			return
+		}
+
+		var stateTags map[string]string
+		diags = state.Tags.ElementsAs(ctx, &stateTags, false)
+		if diags.HasError() {
+			// For backward compatibility, if state tags can't be parsed (e.g., from older provider version),
+			// treat as empty map and continue with the update
+			tflog.Warn(ctx, "Failed to parse state tags, treating as empty", map[string]interface{}{
+				"id":    state.ID.ValueString(),
+				"error": diags.Errors(),
+			})
+			stateTags = make(map[string]string)
+		}
+
+		if !reflect.DeepEqual(planTags, stateTags) {
+			tflog.Info(ctx, "Updating service tags", map[string]interface{}{
+				"id": state.ID.ValueString(),
+			})
+
+			err := r.client.UpdateServiceTags(ctx, state.ID.ValueString(), planTags)
+			if err != nil {
+				if errors.Is(err, skysql.ErrorServiceNotFound) {
+					tflog.Warn(ctx, "SkySQL service not found, removing from state", map[string]interface{}{
+						"id": state.ID.ValueString(),
+					})
+					resp.State.RemoveResource(ctx)
+					return
+				}
+				// Log warning but don't fail the update to protect against tag API errors
+				tflog.Warn(ctx, "Failed to update service tags, continuing with other updates", map[string]interface{}{
+					"id":    state.ID.ValueString(),
+					"error": err.Error(),
+				})
+				return
+			}
+
+			state.Tags = plan.Tags
+			resp.Diagnostics.Append(resp.State.Set(ctx, &state)...)
+			if resp.Diagnostics.HasError() {
+				return
+			}
+			r.waitForUpdate(ctx, state, resp)
+		}
+	}
+}
+
 var serviceUpdateWaitStates = []string{"ready", "failed", "stopped"}
 
 func (r *ServiceResource) waitForUpdate(ctx context.Context, state *ServiceResourceModel, resp *resource.UpdateResponse) {
@@ -1344,9 +1429,16 @@ func (r *ServiceResource) ModifyPlan(ctx context.Context, req resource.ModifyPla
 		resp.Plan.SetAttribute(ctx, path.Root("endpoint_allowed_accounts"), types.ListNull(types.StringType))
 	}
 
-	if state != nil && !state.AllowList.IsUnknown() && plan.AllowList.IsNull() {
+	// Preserve allow_list from state when it's computed or null in plan
+	if state != nil && !state.AllowList.IsUnknown() && (plan.AllowList.IsNull() || plan.AllowList.IsUnknown()) {
 		resp.Plan.SetAttribute(ctx, path.Root("allow_list"), state.AllowList)
 	}
+
+	// Preserve endpoint_service from state when it's computed, but only if mechanism isn't changing
+	if state != nil && !state.EndpointService.IsUnknown() && plan.EndpointService.IsUnknown() &&
+		plan.Mechanism.ValueString() == state.Mechanism.ValueString() {
+		resp.Plan.SetAttribute(ctx, path.Root("endpoint_service"), state.EndpointService)
+	}
 }
 
 func (r *ServiceResource) UpgradeState(ctx context.Context) map[int64]resource.StateUpgrader {
@@ -1369,3 +1461,52 @@ func (r *ServiceResource) UpgradeState(ctx context.Context) map[int64]resource.S
 		},
 	}
 }
+
+// tagsNamePlanModifier ensures tags.name always matches the service name
+type tagsNamePlanModifier struct{}
+
+func (m *tagsNamePlanModifier) Description(_ context.Context) string {
+	return "Ensures tags.name matches the service name since the API overwrites it"
+}
+
+func (m *tagsNamePlanModifier) MarkdownDescription(ctx context.Context) string {
+	return m.Description(ctx)
+}
+
+func (m *tagsNamePlanModifier) PlanModifyMap(ctx context.Context, req planmodifier.MapRequest, resp *planmodifier.MapResponse) {
+	// Don't modify plan during destroy
+	if req.Plan.Raw.IsNull() {
+		return
+	}
+
+	// Get the planned service name
+	var plannedName types.String
+	resp.Diagnostics.Append(req.Plan.GetAttribute(ctx, path.Root("name"), &plannedName)...)
+	if resp.Diagnostics.HasError() || plannedName.IsNull() || plannedName.IsUnknown() {
+		return
+	}
+
+	// If tags are planned, ensure tags.name matches service name
+	if !req.PlanValue.IsNull() && !req.PlanValue.IsUnknown() {
+		var plannedTags map[string]string
+		resp.Diagnostics.Append(req.PlanValue.ElementsAs(ctx, &plannedTags, false)...)
+		if resp.Diagnostics.HasError() {
+			return
+		}
+
+		// Set tags.name to match service name (API behavior)
+		if plannedTags == nil {
+			plannedTags = make(map[string]string)
+		}
+		plannedTags["name"] = plannedName.ValueString()
+
+		// Update the planned value
+		correctedTags, diags := types.MapValueFrom(ctx, types.StringType, plannedTags)
+		resp.Diagnostics.Append(diags...)
+		if resp.Diagnostics.HasError() {
+			return
+		}
+
+		resp.PlanValue = correctedTags
+	}
+}