Merge pull request #6 from platform9/feat/compute

feat(compute): Nova keypair/flavor/servergroup/instance and data sources

Author: PF9-pushkar

CHANGELOG.md

@@ -31,6 +31,10 @@ All notable changes to this project are documented here. The format is based on
 - Networking (Neutron v2): resources `pcd_networking_network`, `_subnet`, `_secgroup`,
   `_secgroup_rule`, `_router`, `_router_interface`; data sources `pcd_networking_network`,
   `_subnet`, `_secgroup`. (Floating IPs, ports, and remaining data sources to follow.)
+- Compute (Nova v2): resources `pcd_compute_keypair`, `pcd_compute_flavor`,
+  `pcd_compute_servergroup` (acceptance-tested); `pcd_compute_instance` (code-complete —
+  boot verification is blocked on a lab image-library issue, see DECISIONS.md); data
+  sources `pcd_compute_flavor`, `pcd_compute_keypair`, `pcd_compute_availability_zones`.
 
 ### Known gaps
 - `cloud` (clouds.yaml) is declared but not yet implemented; it errors if set.

internal/clients/config.go

@@ -213,6 +213,17 @@ func (c *Config) NetworkV2Client() (*gophercloud.ServiceClient, error) {
 	return client, nil
 }
 
+// ComputeV2Client returns a Nova v2 service client, honoring an endpoint_overrides
+// entry for the "compute" service type if present.
+func (c *Config) ComputeV2Client() (*gophercloud.ServiceClient, error) {
+	client, err := openstack.NewComputeV2(c.Provider, c.endpointOpts())
+	if err != nil {
+		return nil, fmt.Errorf("pcd: creating compute v2 client: %w", err)
+	}
+	c.applyOverride(client, "compute")
+	return client, nil
+}
+
 // applyOverride points a service client at an operator-supplied endpoint when
 // endpoint_overrides names its service type.
 func (c *Config) applyOverride(client *gophercloud.ServiceClient, serviceType string) {

internal/provider/provider.go

@@ -10,6 +10,7 @@ import (
 	"github.com/hashicorp/terraform-plugin-framework/provider"
 	"github.com/hashicorp/terraform-plugin-framework/resource"
 
+	"github.com/platform9/terraform-provider-pcd/internal/services/compute"
 	"github.com/platform9/terraform-provider-pcd/internal/services/identity"
 	"github.com/platform9/terraform-provider-pcd/internal/services/images"
 	"github.com/platform9/terraform-provider-pcd/internal/services/networking"
@@ -51,6 +52,10 @@ func (p *pcdProvider) Resources(_ context.Context) []func() resource.Resource {
 		networking.NewSecgroupRuleResource,
 		networking.NewRouterResource,
 		networking.NewRouterInterfaceResource,
+		compute.NewKeypairResource,
+		compute.NewInstanceResource,
+		compute.NewFlavorResource,
+		compute.NewServergroupResource,
 	}
 }
 
@@ -65,5 +70,8 @@ func (p *pcdProvider) DataSources(_ context.Context) []func() datasource.DataSou
 		networking.NewNetworkDataSource,
 		networking.NewSubnetDataSource,
 		networking.NewSecgroupDataSource,
+		compute.NewFlavorDataSource,
+		compute.NewKeypairDataSource,
+		compute.NewAvailabilityZonesDataSource,
 	}
 }

internal/services/compute/availability_zones_data_source.go

@@ -0,0 +1,102 @@
+// Copyright (c) Platform9 Systems, Inc.
+// SPDX-License-Identifier: MPL-2.0
+//
+// Ported from terraform-provider-openstack v3.4.0
+// (openstack/data_source_openstack_compute_availability_zones_v2.go), adapted
+// for the terraform-plugin-framework and PCD.
+
+package compute
+
+import (
+	"context"
+
+	"github.com/gophercloud/gophercloud/v2/openstack/compute/v2/availabilityzones"
+	"github.com/hashicorp/terraform-plugin-framework/datasource"
+	"github.com/hashicorp/terraform-plugin-framework/datasource/schema"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+
+	"github.com/platform9/terraform-provider-pcd/internal/clients"
+)
+
+var (
+	_ datasource.DataSource              = (*azDataSource)(nil)
+	_ datasource.DataSourceWithConfigure = (*azDataSource)(nil)
+)
+
+// NewAvailabilityZonesDataSource is the factory registered with the provider.
+func NewAvailabilityZonesDataSource() datasource.DataSource {
+	return &azDataSource{}
+}
+
+type azDataSource struct {
+	config *clients.Config
+}
+
+type azDataSourceModel struct {
+	ID     types.String `tfsdk:"id"`
+	State  types.String `tfsdk:"state"`
+	Names  types.List   `tfsdk:"names"`
+	Region types.String `tfsdk:"region"`
+}
+
+func (d *azDataSource) Metadata(_ context.Context, req datasource.MetadataRequest, resp *datasource.MetadataResponse) {
+	resp.TypeName = req.ProviderTypeName + "_compute_availability_zones"
+}
+
+func (d *azDataSource) Schema(_ context.Context, _ datasource.SchemaRequest, resp *datasource.SchemaResponse) {
+	resp.Schema = schema.Schema{
+		MarkdownDescription: "Return the compute availability zones.",
+		Attributes: map[string]schema.Attribute{
+			"id":     schema.StringAttribute{Computed: true, MarkdownDescription: "Data source identifier."},
+			"state":  schema.StringAttribute{Optional: true, MarkdownDescription: "Filter by state: available (default) or unavailable."},
+			"names":  schema.ListAttribute{Computed: true, ElementType: types.StringType, MarkdownDescription: "The matching availability zone names."},
+			"region": schema.StringAttribute{Optional: true, Computed: true, MarkdownDescription: "The region. Defaults to the provider's region."},
+		},
+	}
+}
+
+func (d *azDataSource) Configure(_ context.Context, req datasource.ConfigureRequest, resp *datasource.ConfigureResponse) {
+	d.config = configureClient(req.ProviderData, &resp.Diagnostics)
+}
+
+func (d *azDataSource) Read(ctx context.Context, req datasource.ReadRequest, resp *datasource.ReadResponse) {
+	var data azDataSourceModel
+	resp.Diagnostics.Append(req.Config.Get(ctx, &data)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	client, err := d.config.ComputeV2Client()
+	if err != nil {
+		resp.Diagnostics.AddError("compute: building v2 client", err.Error())
+		return
+	}
+
+	pages, err := availabilityzones.List(client).AllPages(ctx)
+	if err != nil {
+		resp.Diagnostics.AddError("compute: listing availability zones", err.Error())
+		return
+	}
+	zones, err := availabilityzones.ExtractAvailabilityZones(pages)
+	if err != nil {
+		resp.Diagnostics.AddError("compute: extracting availability zones", err.Error())
+		return
+	}
+
+	wantAvailable := data.State.ValueString() != "unavailable"
+	names := make([]string, 0, len(zones))
+	for _, z := range zones {
+		if z.ZoneState.Available == wantAvailable {
+			names = append(names, z.ZoneName)
+		}
+	}
+
+	nameList, diags := types.ListValueFrom(ctx, types.StringType, names)
+	resp.Diagnostics.Append(diags...)
+	data.Names = nameList
+	if data.Region.IsNull() || data.Region.IsUnknown() {
+		data.Region = types.StringValue(d.config.Region)
+	}
+	data.ID = types.StringValue(d.config.Region + ":azs")
+	resp.Diagnostics.Append(resp.State.Set(ctx, &data)...)
+}

internal/services/compute/compute.go

@@ -0,0 +1,30 @@
+// Copyright (c) Platform9 Systems, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+// Package compute implements the pcd_compute_* resources and data sources
+// (Nova v2), ported from terraform-provider-openstack v3.4.0.
+package compute
+
+import (
+	"fmt"
+
+	"github.com/hashicorp/terraform-plugin-framework/diag"
+
+	"github.com/platform9/terraform-provider-pcd/internal/clients"
+)
+
+// configureClient extracts the shared *clients.Config from ProviderData.
+func configureClient(providerData any, diags *diag.Diagnostics) *clients.Config {
+	if providerData == nil {
+		return nil
+	}
+	config, ok := providerData.(*clients.Config)
+	if !ok {
+		diags.AddError(
+			"Unexpected provider data type",
+			fmt.Sprintf("Expected *clients.Config, got %T. This is a bug in the provider.", providerData),
+		)
+		return nil
+	}
+	return config
+}

internal/services/compute/datasources_test.go

@@ -0,0 +1,53 @@
+// Copyright (c) Platform9 Systems, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+package compute_test
+
+import (
+	"testing"
+
+	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
+
+	"github.com/platform9/terraform-provider-pcd/internal/acctest"
+)
+
+func TestAccComputeAvailabilityZones_basic(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck:                 func() { acctest.PreCheck(t) },
+		ProtoV6ProviderFactories: acctest.ProtoV6ProviderFactories,
+		Steps: []resource.TestStep{
+			{
+				Config: `data "pcd_compute_availability_zones" "zones" {}`,
+				Check: resource.ComposeAggregateTestCheckFunc(
+					resource.TestCheckResourceAttrSet("data.pcd_compute_availability_zones.zones", "names.0"),
+				),
+			},
+		},
+	})
+}
+
+func TestAccComputeKeypairDataSource_basic(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck:                 func() { acctest.PreCheck(t) },
+		ProtoV6ProviderFactories: acctest.ProtoV6ProviderFactories,
+		CheckDestroy:             testAccCheckKeypairDestroy(t),
+		Steps: []resource.TestStep{
+			{
+				Config: `
+resource "pcd_compute_keypair" "test" {
+  name = "tf-acc-kp-ds"
+}
+
+data "pcd_compute_keypair" "by_name" {
+  name = pcd_compute_keypair.test.name
+}
+`,
+				Check: resource.ComposeAggregateTestCheckFunc(
+					resource.TestCheckResourceAttrPair("data.pcd_compute_keypair.by_name", "id", "pcd_compute_keypair.test", "name"),
+					resource.TestCheckResourceAttrSet("data.pcd_compute_keypair.by_name", "public_key"),
+					resource.TestCheckResourceAttrSet("data.pcd_compute_keypair.by_name", "fingerprint"),
+				),
+			},
+		},
+	})
+}

internal/services/compute/flavor_data_source.go

@@ -0,0 +1,138 @@
+// Copyright (c) Platform9 Systems, Inc.
+// SPDX-License-Identifier: MPL-2.0
+//
+// Ported from terraform-provider-openstack v3.4.0
+// (openstack/data_source_openstack_compute_flavor_v2.go), adapted for the
+// terraform-plugin-framework and PCD.
+
+package compute
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/gophercloud/gophercloud/v2/openstack/compute/v2/flavors"
+	"github.com/hashicorp/terraform-plugin-framework/datasource"
+	"github.com/hashicorp/terraform-plugin-framework/datasource/schema"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+
+	"github.com/platform9/terraform-provider-pcd/internal/clients"
+)
+
+var (
+	_ datasource.DataSource              = (*flavorDataSource)(nil)
+	_ datasource.DataSourceWithConfigure = (*flavorDataSource)(nil)
+)
+
+// NewFlavorDataSource is the factory registered with the provider.
+func NewFlavorDataSource() datasource.DataSource {
+	return &flavorDataSource{}
+}
+
+type flavorDataSource struct {
+	config *clients.Config
+}
+
+type flavorDataSourceModel struct {
+	ID         types.String  `tfsdk:"id"`
+	FlavorID   types.String  `tfsdk:"flavor_id"`
+	Name       types.String  `tfsdk:"name"`
+	RAM        types.Int64   `tfsdk:"ram"`
+	VCPUs      types.Int64   `tfsdk:"vcpus"`
+	Disk       types.Int64   `tfsdk:"disk"`
+	Swap       types.Int64   `tfsdk:"swap"`
+	RxTxFactor types.Float64 `tfsdk:"rx_tx_factor"`
+	IsPublic   types.Bool    `tfsdk:"is_public"`
+	Region     types.String  `tfsdk:"region"`
+}
+
+func (d *flavorDataSource) Metadata(_ context.Context, req datasource.MetadataRequest, resp *datasource.MetadataResponse) {
+	resp.TypeName = req.ProviderTypeName + "_compute_flavor"
+}
+
+func (d *flavorDataSource) Schema(_ context.Context, _ datasource.SchemaRequest, resp *datasource.SchemaResponse) {
+	resp.Schema = schema.Schema{
+		MarkdownDescription: "Look up a compute flavor by name or ID.",
+		Attributes: map[string]schema.Attribute{
+			"id":           schema.StringAttribute{Computed: true, MarkdownDescription: "The flavor ID."},
+			"flavor_id":    schema.StringAttribute{Optional: true, MarkdownDescription: "Look up by flavor ID (takes precedence over name)."},
+			"name":         schema.StringAttribute{Optional: true, MarkdownDescription: "Look up by exact name."},
+			"ram":          schema.Int64Attribute{Computed: true, MarkdownDescription: "Memory in MB."},
+			"vcpus":        schema.Int64Attribute{Computed: true, MarkdownDescription: "Number of vCPUs."},
+			"disk":         schema.Int64Attribute{Computed: true, MarkdownDescription: "Root disk in GB."},
+			"swap":         schema.Int64Attribute{Computed: true, MarkdownDescription: "Swap in MB."},
+			"rx_tx_factor": schema.Float64Attribute{Computed: true, MarkdownDescription: "RX/TX factor."},
+			"is_public":    schema.BoolAttribute{Computed: true, MarkdownDescription: "Whether the flavor is public."},
+			"region":       schema.StringAttribute{Optional: true, Computed: true, MarkdownDescription: "The region. Defaults to the provider's region."},
+		},
+	}
+}
+
+func (d *flavorDataSource) Configure(_ context.Context, req datasource.ConfigureRequest, resp *datasource.ConfigureResponse) {
+	d.config = configureClient(req.ProviderData, &resp.Diagnostics)
+}
+
+func (d *flavorDataSource) Read(ctx context.Context, req datasource.ReadRequest, resp *datasource.ReadResponse) {
+	var data flavorDataSourceModel
+	resp.Diagnostics.Append(req.Config.Get(ctx, &data)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	client, err := d.config.ComputeV2Client()
+	if err != nil {
+		resp.Diagnostics.AddError("compute: building v2 client", err.Error())
+		return
+	}
+
+	var flavor *flavors.Flavor
+	if v := data.FlavorID.ValueString(); v != "" {
+		flavor, err = flavors.Get(ctx, client, v).Extract()
+		if err != nil {
+			resp.Diagnostics.AddError("compute: getting flavor by id", err.Error())
+			return
+		}
+	} else {
+		pages, err := flavors.ListDetail(client, flavors.ListOpts{}).AllPages(ctx)
+		if err != nil {
+			resp.Diagnostics.AddError("compute: listing flavors", err.Error())
+			return
+		}
+		all, err := flavors.ExtractFlavors(pages)
+		if err != nil {
+			resp.Diagnostics.AddError("compute: extracting flavors", err.Error())
+			return
+		}
+		name := data.Name.ValueString()
+		var matches []flavors.Flavor
+		for _, f := range all {
+			if f.Name == name {
+				matches = append(matches, f)
+			}
+		}
+		switch len(matches) {
+		case 0:
+			resp.Diagnostics.AddError("No flavor found", fmt.Sprintf("No flavor named %q.", name))
+			return
+		case 1:
+			flavor = &matches[0]
+		default:
+			resp.Diagnostics.AddError("Multiple flavors found", fmt.Sprintf("%d flavors named %q.", len(matches), name))
+			return
+		}
+	}
+
+	data.ID = types.StringValue(flavor.ID)
+	data.FlavorID = types.StringValue(flavor.ID)
+	data.Name = types.StringValue(flavor.Name)
+	data.RAM = types.Int64Value(int64(flavor.RAM))
+	data.VCPUs = types.Int64Value(int64(flavor.VCPUs))
+	data.Disk = types.Int64Value(int64(flavor.Disk))
+	data.Swap = types.Int64Value(int64(flavor.Swap))
+	data.RxTxFactor = types.Float64Value(flavor.RxTxFactor)
+	data.IsPublic = types.BoolValue(flavor.IsPublic)
+	if data.Region.IsNull() || data.Region.IsUnknown() {
+		data.Region = types.StringValue(d.config.Region)
+	}
+	resp.Diagnostics.Append(resp.State.Set(ctx, &data)...)
+}