vm

type BootOrderEntryModel ¶

type BootOrderEntryModel struct {
	Type               types.String `tfsdk:"type"`
	ControllerType     types.String `tfsdk:"controller_type"`
	ControllerNumber   types.Int64  `tfsdk:"controller_number"`
	ControllerLocation types.Int64  `tfsdk:"controller_location"`
	Name               types.String `tfsdk:"name"`
}

BootOrderEntryModel is one element of the `boot_order` list on a gen 2 hyperv_vm. Type discriminates between hard_disk_drive / dvd_drive entries (which carry the slot tuple) and network_adapter entries (which carry Name). Unused fields for a given Type are null.

Gen 1 BIOS startup order is a separate, deferred slice; the schema validator rejects boot_order on gen 1 at plan time.

type CPUModel ¶

type CPUModel struct {
	Count types.Int64 `tfsdk:"count"`
}

CPUModel is the nested `cpu` block. Static count only in this slice; dynamic-CPU attributes (weight, reserve, limit) attach as additional fields here in a follow-up.

type DvdDriveModel ¶

type DvdDriveModel struct {
	IsoPath            pathtype.Path `tfsdk:"iso_path"`
	ControllerType     types.String  `tfsdk:"controller_type"`
	ControllerNumber   types.Int64   `tfsdk:"controller_number"`
	ControllerLocation types.Int64   `tfsdk:"controller_location"`
}

DvdDriveModel is one element of the `dvd_drive` list on hyperv_vm. Same slot-tuple shape as HardDiskDriveModel (controller_type, controller_number, controller_location), but IsoPath is Optional -- an empty DVD drive (no medium loaded) is a legitimate config.

IsoPath uses pathtype.Path for slash-style folding consistent with hyperv_image_file.destination_path and hyperv_vhd.path.

type HardDiskDriveModel ¶

type HardDiskDriveModel struct {
	Path               pathtype.Path `tfsdk:"path"`
	ControllerType     types.String  `tfsdk:"controller_type"`
	ControllerNumber   types.Int64   `tfsdk:"controller_number"`
	ControllerLocation types.Int64   `tfsdk:"controller_location"`
}

HardDiskDriveModel is one element of the `hard_disk_drive` nested set on hyperv_vm. Identifies an attached VHD (Path) at a specific controller slot (ControllerType + ControllerNumber + ControllerLocation).

Path uses pathtype.Path for slash/case folding consistent with hyperv_vhd.path and hyperv_image_file.destination_path -- a VHD path the user wrote with forward slashes round-trips through the bench's canonical backslash form without phantom diffs.

type MemoryModel ¶

type MemoryModel struct {
	StartupBytes types.Int64 `tfsdk:"startup_bytes"`
	Dynamic      types.Bool  `tfsdk:"dynamic"`
	MinBytes     types.Int64 `tfsdk:"min_bytes"`
	MaxBytes     types.Int64 `tfsdk:"max_bytes"`
}

MemoryModel is the nested `memory` block. StartupBytes is the only required field; Dynamic / MinBytes / MaxBytes opt in to Hyper-V's dynamic memory mode.

Dynamic is types.Bool (not pointer) because the framework's null representation handles both "user didn't manage" and "explicit false" cleanly via the wire-side *bool with omitempty: null on the wire means absent, which the script treats as static. MinBytes and MaxBytes follow the same Optional+Computed + UseStateForUnknown pattern as state.shutdown_mode (PR #33).

Buffer and Priority are deferred -- they're Hyper-V dynamic-memory niceties (~5% of users) and adding them later is a strict superset of the current schema.

type Model ¶

type Model struct {
	ID              types.String          `tfsdk:"id"`
	Name            types.String          `tfsdk:"name"`
	Generation      types.Int64           `tfsdk:"generation"`
	CPU             *CPUModel             `tfsdk:"cpu"`
	Memory          *MemoryModel          `tfsdk:"memory"`
	HardDiskDrives  []HardDiskDriveModel  `tfsdk:"hard_disk_drive"`
	NetworkAdapters []NetworkAdapterModel `tfsdk:"network_adapter"`
	// DvdDrives and BootOrder are types.List rather than []Struct so the
	// framework can represent unknown values cleanly. The framework's
	// reflect path can't fit "the whole list is unknown" into a Go slice
	// (no representation for it), and emits "Value Conversion Error /
	// Suggested Type: basetypes.ListValue" when a config drives the
	// attribute from a for_each variable that hasn't materialized at
	// validate time. Same fix shape PR #70 applied to URLConfig on
	// hyperv_image_file. Helpers below give resource code typed access
	// to the underlying []DvdDriveModel / []BootOrderEntryModel slice
	// when the value is known.
	DvdDrives          types.List   `tfsdk:"dvd_drive"`
	BootOrder          types.List   `tfsdk:"boot_order"`
	SecureBoot         types.Bool   `tfsdk:"secure_boot"`
	SecureBootTemplate types.String `tfsdk:"secure_boot_template"`
	Notes              types.String `tfsdk:"notes"`
	State              *StateModel  `tfsdk:"state"`
	IPAddresses        types.List   `tfsdk:"ip_addresses"`
	Path               types.String `tfsdk:"path"`
}

Model is the tfsdk-bound struct backing the resource state. Field tags align with schema.go attribute names; conversion to/from the typed hyperv.VM DTO lives in resource.go.

SecureBoot is types.Bool (not pointer-to-bool) -- the framework's null representation handles the gen-1 case where the host has no Secure Boot concept and the cmdlet returns null.

CPU and Memory are pointer-typed (not value) because at ImportState time the state passes through with just `name` set; the framework then calls Read to populate everything else, but in the brief window before Read runs, cpu/memory are null in state. A value type can't represent null and the framework errors with "Received null value, however the target type cannot handle null values." Pointers null cleanly; modelFromVM allocates them.

HardDiskDrives is a list of attachments stored canonically by slot tuple (controller_type, controller_number, controller_location). Schema-side ListNestedAttribute (rather than SetNestedAttribute) because terraform-plugin-framework v1.19's slice decode of nested-set attributes hits a reflect path that produces a "Target Type: []vm.HardDiskDriveModel, Suggested Type: basetypes.SetValue" error during req.Plan.Get. List + a canonical sort in modelFromVM gives the same user-visible behavior (HCL ordering matches canonical state on subsequent applies) with a simpler decode.

func (m *Model) BootOrderEntries(ctx context.Context) ([]BootOrderEntryModel, diag.Diagnostics)

func (m *Model) DvdDriveModels(ctx context.Context) ([]DvdDriveModel, diag.Diagnostics)

type NetworkAdapterModel ¶

type NetworkAdapterModel struct {
	Name        types.String `tfsdk:"name"`
	SwitchName  types.String `tfsdk:"switch_name"`
	IPAddresses types.List   `tfsdk:"ip_addresses"`
	MacAddress  mactype.MAC  `tfsdk:"mac_address"`
	VlanID      types.Int64  `tfsdk:"vlan_id"`
}

NetworkAdapterModel is one element of the `network_adapter` list on hyperv_vm. Display Name is the slot key for diff/reconciliation (Hyper-V allows duplicate-named NICs at the cmdlet level, but the resource-layer schema validator enforces uniqueness within a VM's list at plan time, so the slot key is well-defined).

SwitchName binds the NIC to a hyperv_virtual_switch by name.

IPAddresses is the per-NIC slice of IPv4 / IPv6 addresses that Hyper-V's integration services have reported for this specific adapter. Computed -- populated on Read from the host. Unlike the VM-level flat `ip_addresses` list, the per-NIC view gives multi- homed VMs a stable reference to a specific NIC's IPs (order within a single NIC is host-driven but the NIC selector itself is keyed by the deterministic display Name).

MacAddress is Optional (not Computed). When the user sets it, the NIC uses a static MAC of that value. When unset, Hyper-V auto- assigns from its dynamic-MAC pool; Read writes null to state in that case (we don't store the dynamically-assigned MAC -- that would create a perpetual plan diff against the empty config). Optional-only is deliberate: with Computed, the framework copies state-value forward when config goes null, which masks intentional reverts to dynamic-MAC mode (omitted-vs-explicit-null are indistinguishable at the framework's config layer).

VlanID is Optional (not Computed) for the same reason. When set to 1-4094, the NIC is tagged with that VLAN ID in Access mode. When unset, the NIC carries untagged frames. Read populates from Get-VMNetworkAdapterVlan.AccessVlanId; an untagged NIC produces state value null (matching unset config to avoid perpetual diff).

type Resource ¶

type Resource struct {
	// contains filtered or unexported fields
}

Resource implements hyperv_vm.

func (r *Resource) ConfigValidators(_ context.Context) []resource.ConfigValidator

func (r *Resource) Configure(_ context.Context, req resource.ConfigureRequest, resp *resource.ConfigureResponse)

func (r *Resource) Create(ctx context.Context, req resource.CreateRequest, resp *resource.CreateResponse)

func (r *Resource) Delete(ctx context.Context, req resource.DeleteRequest, resp *resource.DeleteResponse)

func (r *Resource) ImportState(ctx context.Context, req resource.ImportStateRequest, resp *resource.ImportStateResponse)

func (r *Resource) Metadata(_ context.Context, req resource.MetadataRequest, resp *resource.MetadataResponse)

func (r *Resource) Read(ctx context.Context, req resource.ReadRequest, resp *resource.ReadResponse)

func (r *Resource) Schema(_ context.Context, _ resource.SchemaRequest, resp *resource.SchemaResponse)

func (r *Resource) Update(ctx context.Context, req resource.UpdateRequest, resp *resource.UpdateResponse)

func (r *Resource) UpgradeState(_ context.Context) map[int64]resource.StateUpgrader

type StateModel ¶

type StateModel struct {
	Desired      types.String `tfsdk:"desired"`
	Current      types.String `tfsdk:"current"`
	ShutdownMode types.String `tfsdk:"shutdown_mode"`
}

StateModel is the nested `state` block on hyperv_vm. Pointer-typed (Model.State is *StateModel) for the same reason as CPU and Memory: during ImportState the framework writes a partial Model with just `name` set, and a value-typed nested struct can't represent null.

Desired is the user-facing power-state input ("Off" | "Running"); a transition fires only when Desired differs from the host's actual state. Current is the Computed readback from Hyper-V; useful for downstream resources that key off the actual state ("provision the guest only when state.current = Running").

Saved and Paused are out of scope for this slice -- the schema validator on Desired rejects values outside {Off, Running}. Drift from those states surfaces verbatim in Current; the next Update will hard-power-off or start as configured.