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.

DECISIONS.md

@@ -3,6 +3,22 @@
 Records deviations from the PCD-1070 implementation plan and material findings that
 change scope. The plan's Section 3 decisions remain locked unless noted here.
 
+## 2026-07-11 — BLOCKER: hypervisor pcd-iso-test cannot spawn instances
+
+Nova boots fail: an instance goes BUILD → ERROR with *"Exceeded maximum number of
+retries. Exhausted all hosts available for retrying build failures"*
+(`nova.exception.MaxRetriesExceeded`). Ruled out via the API and libvirt on
+cannon-ubuntu: nested virtualization (CPU mode is `host-passthrough`), capacity
+(4 vCPU / 7 GB / 131 GB free), image (reaches `active` via web-download), and
+network (created fine). The real `nova-compute` spawn error lives on the host, but
+SSH to `pcd-iso-test` (172.16.122.232) is rejected — the `pcd_automation` key is not
+authorized there (it is the repurposed "iso-test" VM). Most likely an OVN
+port-binding failure or a `pf9-hostagent`/nova-compute issue on the freshly-onboarded
+host. **Needs the owner** to check `nova-compute.log` on the host (or grant SSH
+access). `pcd_compute_instance` code is complete and correct up to the boot; its boot
+acceptance test will pass once the host can spawn a VM. keypair/flavor/servergroup and
+the compute data sources are testable without a boot and continue.
+
 ## 2026-07-11 — networking: floating IPs and extras deferred
 
 The CE lab has no external Neutron network, so `pcd_networking_floatingip` (which

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"),
+				),
+			},
+		},
+	})
+}