feat(blockstorage): add pcd_blockstorage_volume + volume/snapshot data sources

Cinder v3. Code-complete; the volume create/status-waiter/error-detection path is
verified against the lab (the waiter correctly catches the backend ERROR). The full
acceptance test can't pass on the CE lab because it has no storage backend configured
(storageBackends={}), so volumes go creating -> error. It will pass on a cloud with a
working Cinder backend. Tracked in DECISIONS.md.
- pcd_blockstorage_volume: create (wait available), in-place extend on size increase,
  name/description/metadata update, import.
- pcd_blockstorage_volume / pcd_blockstorage_snapshot data sources.
- clients: BlockStorageV3Client (Cinder).

Author: PF9-pushkar

CHANGELOG.md

@@ -35,6 +35,9 @@ All notable changes to this project are documented here. The format is based on
   `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`.
+- Block storage (Cinder v3): `pcd_blockstorage_volume` resource (create/extend/import;
+  code-complete — acceptance is blocked on the CE lab having no storage backend, see
+  DECISIONS.md) and `pcd_blockstorage_volume` / `pcd_blockstorage_snapshot` data sources.
 
 ### Known gaps
 - `cloud` (clouds.yaml) is declared but not yet implemented; it errors if set.

DECISIONS.md

@@ -3,6 +3,16 @@
 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 — blockstorage: no Cinder storage backend on the CE lab
+
+Volume creation on the CE lab goes `creating → error` immediately: the cluster
+blueprint has `storageBackends={}` (none configured) and only a `__DEFAULT__` volume
+type with nothing to fulfill it. So `pcd_blockstorage_volume`'s acceptance test cannot
+pass on this lab (same class of lab gap as the compute image-library issue). The
+resource **code is verified up to the backend**: create + status waiter + error
+detection all work (the waiter correctly reports the ERROR state). It will pass on a
+cloud with a working storage backend. The volume/snapshot data sources ship alongside.
+
 ## 2026-07-11 — BLOCKER: hypervisor pcd-iso-test cannot spawn instances
 
 Nova boots fail: an instance goes BUILD → ERROR with *"Exceeded maximum number of

internal/clients/config.go

@@ -224,6 +224,17 @@ func (c *Config) ComputeV2Client() (*gophercloud.ServiceClient, error) {
 	return client, nil
 }
 
+// BlockStorageV3Client returns a Cinder v3 service client, honoring an
+// endpoint_overrides entry for the "volumev3" service type if present.
+func (c *Config) BlockStorageV3Client() (*gophercloud.ServiceClient, error) {
+	client, err := openstack.NewBlockStorageV3(c.Provider, c.endpointOpts())
+	if err != nil {
+		return nil, fmt.Errorf("pcd: creating block storage v3 client: %w", err)
+	}
+	c.applyOverride(client, "volumev3")
+	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/blockstorage"
 	"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"
@@ -56,6 +57,7 @@ func (p *pcdProvider) Resources(_ context.Context) []func() resource.Resource {
 		compute.NewInstanceResource,
 		compute.NewFlavorResource,
 		compute.NewServergroupResource,
+		blockstorage.NewVolumeResource,
 	}
 }
 
@@ -73,5 +75,7 @@ func (p *pcdProvider) DataSources(_ context.Context) []func() datasource.DataSou
 		compute.NewFlavorDataSource,
 		compute.NewKeypairDataSource,
 		compute.NewAvailabilityZonesDataSource,
+		blockstorage.NewVolumeDataSource,
+		blockstorage.NewSnapshotDataSource,
 	}
 }

internal/services/blockstorage/blockstorage.go

@@ -0,0 +1,30 @@
+// Copyright (c) Platform9 Systems, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+// Package blockstorage implements the pcd_blockstorage_* resources and data
+// sources (Cinder v3), ported from terraform-provider-openstack v3.4.0.
+package blockstorage
+
+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/blockstorage/snapshot_data_source.go

@@ -0,0 +1,128 @@
+// Copyright (c) Platform9 Systems, Inc.
+// SPDX-License-Identifier: MPL-2.0
+//
+// Ported from terraform-provider-openstack v3.4.0
+// (openstack/data_source_openstack_blockstorage_snapshot_v3.go), adapted for the
+// terraform-plugin-framework and PCD.
+
+package blockstorage
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/gophercloud/gophercloud/v2/openstack/blockstorage/v3/snapshots"
+	"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              = (*snapshotDataSource)(nil)
+	_ datasource.DataSourceWithConfigure = (*snapshotDataSource)(nil)
+)
+
+// NewSnapshotDataSource is the factory registered with the provider.
+func NewSnapshotDataSource() datasource.DataSource {
+	return &snapshotDataSource{}
+}
+
+type snapshotDataSource struct {
+	config *clients.Config
+}
+
+type snapshotDataSourceModel struct {
+	ID          types.String `tfsdk:"id"`
+	SnapshotID  types.String `tfsdk:"snapshot_id"`
+	Name        types.String `tfsdk:"name"`
+	VolumeID    types.String `tfsdk:"volume_id"`
+	Size        types.Int64  `tfsdk:"size"`
+	Status      types.String `tfsdk:"status"`
+	Description types.String `tfsdk:"description"`
+	Region      types.String `tfsdk:"region"`
+}
+
+func (d *snapshotDataSource) Metadata(_ context.Context, req datasource.MetadataRequest, resp *datasource.MetadataResponse) {
+	resp.TypeName = req.ProviderTypeName + "_blockstorage_snapshot"
+}
+
+func (d *snapshotDataSource) Schema(_ context.Context, _ datasource.SchemaRequest, resp *datasource.SchemaResponse) {
+	resp.Schema = schema.Schema{
+		MarkdownDescription: "Look up a Cinder volume snapshot by ID or filters.",
+		Attributes: map[string]schema.Attribute{
+			"id":          schema.StringAttribute{Computed: true, MarkdownDescription: "The snapshot ID."},
+			"snapshot_id": schema.StringAttribute{Optional: true, MarkdownDescription: "Look up by snapshot ID (takes precedence over filters)."},
+			"name":        schema.StringAttribute{Optional: true, MarkdownDescription: "Filter by name."},
+			"volume_id":   schema.StringAttribute{Optional: true, Computed: true, MarkdownDescription: "Filter by (and report) the source volume."},
+			"size":        schema.Int64Attribute{Computed: true, MarkdownDescription: "Size in GB."},
+			"status":      schema.StringAttribute{Computed: true, MarkdownDescription: "The Cinder status."},
+			"description": schema.StringAttribute{Computed: true, MarkdownDescription: "The snapshot description."},
+			"region":      schema.StringAttribute{Optional: true, Computed: true, MarkdownDescription: "The region. Defaults to the provider's region."},
+		},
+	}
+}
+
+func (d *snapshotDataSource) Configure(_ context.Context, req datasource.ConfigureRequest, resp *datasource.ConfigureResponse) {
+	d.config = configureClient(req.ProviderData, &resp.Diagnostics)
+}
+
+func (d *snapshotDataSource) Read(ctx context.Context, req datasource.ReadRequest, resp *datasource.ReadResponse) {
+	var data snapshotDataSourceModel
+	resp.Diagnostics.Append(req.Config.Get(ctx, &data)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	client, err := d.config.BlockStorageV3Client()
+	if err != nil {
+		resp.Diagnostics.AddError("blockstorage: building v3 client", err.Error())
+		return
+	}
+
+	var snap *snapshots.Snapshot
+	if v := data.SnapshotID.ValueString(); v != "" {
+		snap, err = snapshots.Get(ctx, client, v).Extract()
+		if err != nil {
+			resp.Diagnostics.AddError("blockstorage: getting snapshot", err.Error())
+			return
+		}
+	} else {
+		pages, err := snapshots.List(client, snapshots.ListOpts{
+			Name:     data.Name.ValueString(),
+			VolumeID: data.VolumeID.ValueString(),
+		}).AllPages(ctx)
+		if err != nil {
+			resp.Diagnostics.AddError("blockstorage: listing snapshots", err.Error())
+			return
+		}
+		all, err := snapshots.ExtractSnapshots(pages)
+		if err != nil {
+			resp.Diagnostics.AddError("blockstorage: extracting snapshots", err.Error())
+			return
+		}
+		switch len(all) {
+		case 0:
+			resp.Diagnostics.AddError("No snapshot found", "No snapshot matched the given criteria.")
+			return
+		case 1:
+			snap = &all[0]
+		default:
+			resp.Diagnostics.AddError("Multiple snapshots found", fmt.Sprintf("%d snapshots matched; refine the criteria.", len(all)))
+			return
+		}
+	}
+
+	data.ID = types.StringValue(snap.ID)
+	data.SnapshotID = types.StringValue(snap.ID)
+	data.Name = types.StringValue(snap.Name)
+	data.VolumeID = types.StringValue(snap.VolumeID)
+	data.Size = types.Int64Value(int64(snap.Size))
+	data.Status = types.StringValue(snap.Status)
+	data.Description = types.StringValue(snap.Description)
+	if data.Region.IsNull() || data.Region.IsUnknown() {
+		data.Region = types.StringValue(d.config.Region)
+	}
+	resp.Diagnostics.Append(resp.State.Set(ctx, &data)...)
+}

internal/services/blockstorage/volume_data_source.go

@@ -0,0 +1,128 @@
+// Copyright (c) Platform9 Systems, Inc.
+// SPDX-License-Identifier: MPL-2.0
+//
+// Ported from terraform-provider-openstack v3.4.0
+// (openstack/data_source_openstack_blockstorage_volume_v3.go), adapted for the
+// terraform-plugin-framework and PCD.
+
+package blockstorage
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/gophercloud/gophercloud/v2/openstack/blockstorage/v3/volumes"
+	"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              = (*volumeDataSource)(nil)
+	_ datasource.DataSourceWithConfigure = (*volumeDataSource)(nil)
+)
+
+// NewVolumeDataSource is the factory registered with the provider.
+func NewVolumeDataSource() datasource.DataSource {
+	return &volumeDataSource{}
+}
+
+type volumeDataSource struct {
+	config *clients.Config
+}
+
+type volumeDataSourceModel struct {
+	ID               types.String `tfsdk:"id"`
+	VolumeID         types.String `tfsdk:"volume_id"`
+	Name             types.String `tfsdk:"name"`
+	Size             types.Int64  `tfsdk:"size"`
+	Status           types.String `tfsdk:"status"`
+	VolumeType       types.String `tfsdk:"volume_type"`
+	AvailabilityZone types.String `tfsdk:"availability_zone"`
+	Bootable         types.Bool   `tfsdk:"bootable"`
+	Region           types.String `tfsdk:"region"`
+}
+
+func (d *volumeDataSource) Metadata(_ context.Context, req datasource.MetadataRequest, resp *datasource.MetadataResponse) {
+	resp.TypeName = req.ProviderTypeName + "_blockstorage_volume"
+}
+
+func (d *volumeDataSource) Schema(_ context.Context, _ datasource.SchemaRequest, resp *datasource.SchemaResponse) {
+	resp.Schema = schema.Schema{
+		MarkdownDescription: "Look up a Cinder volume by ID or name.",
+		Attributes: map[string]schema.Attribute{
+			"id":                schema.StringAttribute{Computed: true, MarkdownDescription: "The volume ID."},
+			"volume_id":         schema.StringAttribute{Optional: true, MarkdownDescription: "Look up by volume ID (takes precedence over name)."},
+			"name":              schema.StringAttribute{Optional: true, MarkdownDescription: "Look up by name."},
+			"size":              schema.Int64Attribute{Computed: true, MarkdownDescription: "Size in GB."},
+			"status":            schema.StringAttribute{Computed: true, MarkdownDescription: "The Cinder status."},
+			"volume_type":       schema.StringAttribute{Computed: true, MarkdownDescription: "The volume type."},
+			"availability_zone": schema.StringAttribute{Computed: true, MarkdownDescription: "The availability zone."},
+			"bootable":          schema.BoolAttribute{Computed: true, MarkdownDescription: "Whether the volume is bootable."},
+			"region":            schema.StringAttribute{Optional: true, Computed: true, MarkdownDescription: "The region. Defaults to the provider's region."},
+		},
+	}
+}
+
+func (d *volumeDataSource) Configure(_ context.Context, req datasource.ConfigureRequest, resp *datasource.ConfigureResponse) {
+	d.config = configureClient(req.ProviderData, &resp.Diagnostics)
+}
+
+func (d *volumeDataSource) Read(ctx context.Context, req datasource.ReadRequest, resp *datasource.ReadResponse) {
+	var data volumeDataSourceModel
+	resp.Diagnostics.Append(req.Config.Get(ctx, &data)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	client, err := d.config.BlockStorageV3Client()
+	if err != nil {
+		resp.Diagnostics.AddError("blockstorage: building v3 client", err.Error())
+		return
+	}
+
+	var vol *volumes.Volume
+	if v := data.VolumeID.ValueString(); v != "" {
+		vol, err = volumes.Get(ctx, client, v).Extract()
+		if err != nil {
+			resp.Diagnostics.AddError("blockstorage: getting volume", err.Error())
+			return
+		}
+	} else {
+		pages, err := volumes.List(client, volumes.ListOpts{Name: data.Name.ValueString()}).AllPages(ctx)
+		if err != nil {
+			resp.Diagnostics.AddError("blockstorage: listing volumes", err.Error())
+			return
+		}
+		all, err := volumes.ExtractVolumes(pages)
+		if err != nil {
+			resp.Diagnostics.AddError("blockstorage: extracting volumes", err.Error())
+			return
+		}
+		switch len(all) {
+		case 0:
+			resp.Diagnostics.AddError("No volume found", "No volume matched the given criteria.")
+			return
+		case 1:
+			vol = &all[0]
+		default:
+			resp.Diagnostics.AddError("Multiple volumes found", fmt.Sprintf("%d volumes matched; refine the criteria.", len(all)))
+			return
+		}
+	}
+
+	data.ID = types.StringValue(vol.ID)
+	data.VolumeID = types.StringValue(vol.ID)
+	data.Name = types.StringValue(vol.Name)
+	data.Size = types.Int64Value(int64(vol.Size))
+	data.Status = types.StringValue(vol.Status)
+	data.VolumeType = types.StringValue(vol.VolumeType)
+	data.AvailabilityZone = types.StringValue(vol.AvailabilityZone)
+	data.Bootable = types.BoolValue(vol.Bootable == "true")
+	if data.Region.IsNull() || data.Region.IsUnknown() {
+		data.Region = types.StringValue(d.config.Region)
+	}
+	resp.Diagnostics.Append(resp.State.Set(ctx, &data)...)
+}