Implement read-only Dynu Terraform provider skeleton

2026-04-21 13:02:42 +10:00
parent 0889d83a0a
commit b268d7a6aa
16 changed files with 1041 additions and 0 deletions
@@ -0,0 +1,142 @@
+package provider
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/hashicorp/terraform-plugin-framework-validators/stringvalidator"
+	"github.com/hashicorp/terraform-plugin-framework/attr"
+	"github.com/hashicorp/terraform-plugin-framework/datasource"
+	"github.com/hashicorp/terraform-plugin-framework/datasource/schema"
+	"github.com/hashicorp/terraform-plugin-framework/path"
+	"github.com/hashicorp/terraform-plugin-framework/schema/validator"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+)
+
+var (
+	_ datasource.DataSource              = &domainDataSource{}
+	_ datasource.DataSourceWithConfigure = &domainDataSource{}
+)
+
+type domainDataSource struct {
+	clientProvider *providerData
+}
+
+type domainDataSourceModel struct {
+	Hostname types.String `tfsdk:"hostname"`
+	Domain   types.Object `tfsdk:"domain"`
+}
+
+func NewDomainDataSource() datasource.DataSource {
+	return &domainDataSource{}
+}
+
+func (d *domainDataSource) Metadata(_ context.Context, req datasource.MetadataRequest, resp *datasource.MetadataResponse) {
+	resp.TypeName = req.ProviderTypeName + "_domain"
+}
+
+func (d *domainDataSource) Schema(_ context.Context, _ datasource.SchemaRequest, resp *datasource.SchemaResponse) {
+	resp.Schema = schema.Schema{
+		Description: "Get a Dynu DNS domain by hostname.",
+		Attributes: map[string]schema.Attribute{
+			"hostname": schema.StringAttribute{
+				Required:    true,
+				Description: "Hostname to resolve to a root domain.",
+				Validators:  []validator.String{stringvalidator.LengthAtLeast(1)},
+			},
+			"domain": schema.SingleNestedAttribute{
+				Computed:    true,
+				Description: "Resolved Dynu DNS domain details.",
+				Attributes:  domainAttributes(),
+			},
+		},
+	}
+}
+
+func (d *domainDataSource) Configure(_ context.Context, req datasource.ConfigureRequest, resp *datasource.ConfigureResponse) {
+	if req.ProviderData == nil {
+		return
+	}
+
+	providerData, ok := req.ProviderData.(*providerData)
+	if !ok {
+		resp.Diagnostics.AddError("Unexpected data source configure type", fmt.Sprintf("Expected *providerData, got %T", req.ProviderData))
+		return
+	}
+
+	d.clientProvider = providerData
+}
+
+func (d *domainDataSource) Read(ctx context.Context, req datasource.ReadRequest, resp *datasource.ReadResponse) {
+	var state domainDataSourceModel
+	resp.Diagnostics.Append(req.Config.Get(ctx, &state)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	if state.Hostname.IsUnknown() || state.Hostname.IsNull() {
+		resp.Diagnostics.AddAttributeError(path.Root("hostname"), "Invalid hostname", "hostname must be known and non-null.")
+		return
+	}
+
+	domainID, _, err := d.clientProvider.client.GetRootDomain(ctx, state.Hostname.ValueString())
+	if err != nil {
+		resp.Diagnostics.AddError("Unable to resolve Dynu domain from hostname", err.Error())
+		return
+	}
+
+	domain, err := d.clientProvider.client.GetDomainByID(ctx, domainID)
+	if err != nil {
+		resp.Diagnostics.AddError("Unable to get Dynu domain", err.Error())
+		return
+	}
+
+	domainValue := mapDomain(*domain)
+	domainObject, diags := types.ObjectValue(
+		map[string]attr.Type{
+			"id":                  types.Int64Type,
+			"name":                types.StringType,
+			"unicode_name":        types.StringType,
+			"token":               types.StringType,
+			"state":               types.StringType,
+			"group":               types.StringType,
+			"ipv4_address":        types.StringType,
+			"ipv6_address":        types.StringType,
+			"ttl":                 types.Int64Type,
+			"ipv4":                types.BoolType,
+			"ipv6":                types.BoolType,
+			"ipv4_wildcard_alias": types.BoolType,
+			"ipv6_wildcard_alias": types.BoolType,
+			"allow_zone_transfer": types.BoolType,
+			"dnssec":              types.BoolType,
+			"created_on":          types.StringType,
+			"updated_on":          types.StringType,
+		},
+		map[string]attr.Value{
+			"id":                  domainValue.ID,
+			"name":                domainValue.Name,
+			"unicode_name":        domainValue.UnicodeName,
+			"token":               domainValue.Token,
+			"state":               domainValue.State,
+			"group":               domainValue.Group,
+			"ipv4_address":        domainValue.IPv4Address,
+			"ipv6_address":        domainValue.IPv6Address,
+			"ttl":                 domainValue.TTL,
+			"ipv4":                domainValue.IPv4,
+			"ipv6":                domainValue.IPv6,
+			"ipv4_wildcard_alias": domainValue.IPv4WildcardAlias,
+			"ipv6_wildcard_alias": domainValue.IPv6WildcardAlias,
+			"allow_zone_transfer": domainValue.AllowZoneTransfer,
+			"dnssec":              domainValue.DNSSEC,
+			"created_on":          domainValue.CreatedOn,
+			"updated_on":          domainValue.UpdatedOn,
+		},
+	)
+	resp.Diagnostics.Append(diags...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+	state.Domain = domainObject
+
+	resp.Diagnostics.Append(resp.State.Set(ctx, &state)...)
+}