Merge pull request #1430 from Tinyblargon/lxc-release

LXC release

Author: Tinyblargon

docs/resources/lxc_guest.md

@@ -27,7 +27,7 @@ const (
 	schemaMTU        = "mtu"
 	schemaName       = "name"
 	schemaNativeVlan = native.Root
-	schemaRate       = "rate"
+	schemaRateLimit  = "rate_limit"
 
 	schmemaIPv4 = "ipv4"
 	schmemaIPv6 = "ipv6"

proxmox/Internal/resource/guest/lxc/networks/schema.go

@@ -38,6 +38,6 @@ func SchemaNetwork() *schema.Schema {
 				schemaMTU:         subSchemaMTU(true, schemaMTU),
 				schemaName:        subSchemaName(true, schemaName),
 				schemaNativeVlan:  subSchemaNativeVlan(true, schemaNativeVlan),
-				schemaRate:        subSchemaRate(true, schemaRate),
+				schemaRateLimit:   subSchemaRate(true, schemaRateLimit),
 				schemaSLAAC:       subSchemaSLAAC(schema.Schema{})}}}
 }

proxmox/Internal/resource/guest/lxc/networks/schema_network.go

@@ -43,7 +43,7 @@ func networksSubSchema(slot string) *schema.Schema {
 				schemaMTU:        subSchemaMTU(false, pathSimple+schemaMTU),
 				schemaName:       subSchemaName(false, pathSimple+schemaName),
 				schemaNativeVlan: subSchemaNativeVlan(false, pathSimple+schemaNativeVlan),
-				schemaRate:       subSchemaRate(false, pathSimple+schemaRate),
+				schemaRateLimit:  subSchemaRate(false, pathSimple+schemaRateLimit),
 				schmemaIPv4: {
 					Type:     schema.TypeList,
 					Optional: true,

proxmox/Internal/resource/guest/lxc/networks/schema_networks.go

@@ -32,7 +32,7 @@ func sdkNetwork(schema []any) (pveSDK.LxcNetworks, diag.Diagnostics) {
 			Mtu:           util.Pointer(pveSDK.MTU(schemaMap[schemaMTU].(int))),
 			Name:          util.Pointer(pveSDK.LxcNetworkName(schemaMap[schemaName].(string))),
 			NativeVlan:    util.Pointer(pveSDK.Vlan(schemaMap[schemaNativeVlan].(int))),
-			RateLimitKBps: util.Pointer(pveSDK.GuestNetworkRate(schemaMap[schemaRate].(int)))}
+			RateLimitKBps: util.Pointer(pveSDK.GuestNetworkRate(schemaMap[schemaRateLimit].(int)))}
 	}
 	for i := range pveSDK.LxcNetworkID(networksAmount) { // ensure all networks are present
 		if _, ok := config[i]; !ok {

proxmox/Internal/resource/guest/lxc/networks/sdk_network.go

@@ -32,7 +32,7 @@ func sdkNetworks(schema map[string]any) pveSDK.LxcNetworks {
 			Mtu:           util.Pointer(pveSDK.MTU(schemaMap[schemaMTU].(int))),
 			Name:          util.Pointer(pveSDK.LxcNetworkName(schemaMap[schemaName].(string))),
 			NativeVlan:    util.Pointer(pveSDK.Vlan(schemaMap[schemaNativeVlan].(int))),
-			RateLimitKBps: util.Pointer(pveSDK.GuestNetworkRate(schemaMap[schemaRate].(int)))}
+			RateLimitKBps: util.Pointer(pveSDK.GuestNetworkRate(schemaMap[schemaRateLimit].(int)))}
 	}
 	return config
 }

proxmox/Internal/resource/guest/lxc/networks/sdk_networks.go

@@ -33,9 +33,9 @@ func terraformNetwork(config pveSDK.LxcNetworks, tfConfig []any) []map[string]an
 			params[schemaNativeVlan] = int(*v.NativeVlan)
 		}
 		if v.RateLimitKBps != nil {
-			params[schemaRate] = int(*v.RateLimitKBps)
+			params[schemaRateLimit] = int(*v.RateLimitKBps)
 		} else {
-			params[schemaRate] = 0
+			params[schemaRateLimit] = 0
 		}
 		if v.IPv4 != nil {
 			params[schemaIPv4DHCP] = v.IPv4.DHCP

proxmox/Internal/resource/guest/lxc/networks/terraform_network.go

@@ -51,7 +51,7 @@ func terraformNetworks(config pveSDK.LxcNetworks) []any {
 				schemaSLAAC:   ipv6.SLAAC}}
 		}
 		if v.RateLimitKBps != nil {
-			settings[schemaRate] = int(*v.RateLimitKBps)
+			settings[schemaRateLimit] = int(*v.RateLimitKBps)
 		}
 		mapParams[prefixSchemaID+strconv.Itoa(int(k))] = []any{settings}
 	}

proxmox/Internal/resource/guest/lxc/networks/terraform_networks.go

@@ -201,6 +201,7 @@ func Provider() *schema.Provider {
 			"proxmox_vm_qemu":         resourceVmQemu(),
 			"proxmox_lxc":             resourceLxc(),
 			"proxmox_lxc_disk":        resourceLxcDisk(),
+			"proxmox_lxc_guest":       resourceLxcGuest(),
 			"proxmox_pool":            resourcePool(),
 			"proxmox_cloud_init_disk": resourceCloudInitDisk(),
 			"proxmox_storage_iso":     resourceStorageIso(),

proxmox/provider.go

@@ -9,7 +9,6 @@ import (
 	"github.com/Telmate/terraform-provider-proxmox/v2/proxmox/Internal/resource/guest/dns"
 	"github.com/Telmate/terraform-provider-proxmox/v2/proxmox/Internal/resource/guest/lxc/architecture"
 	"github.com/Telmate/terraform-provider-proxmox/v2/proxmox/Internal/resource/guest/lxc/cpu"
-	"github.com/Telmate/terraform-provider-proxmox/v2/proxmox/Internal/resource/guest/lxc/features"
 	tags "github.com/Telmate/terraform-provider-proxmox/v2/proxmox/Internal/resource/guest/lxc/lxc_tags"
 	"github.com/Telmate/terraform-provider-proxmox/v2/proxmox/Internal/resource/guest/lxc/memory"
 	"github.com/Telmate/terraform-provider-proxmox/v2/proxmox/Internal/resource/guest/lxc/mounts"
@@ -34,24 +33,24 @@ import (
 
 var lxcNewResourceDef *schema.Resource
 
-func ResourceLxcNew() *schema.Resource {
+func resourceLxcGuest() *schema.Resource {
 	lxcNewResourceDef = &schema.Resource{
-		CreateContext: resourceLxcNewCreate,
-		ReadContext:   resourceLxcNewReadWithLock,
-		UpdateContext: resourceLxcNewUpdate,
-		DeleteContext: resourceLxcNewDelete,
+		CreateContext: resourceLxcGuestCreate,
+		ReadContext:   resourceLxcGuestReadWithLock,
+		UpdateContext: resourceLxcGuestUpdate,
+		DeleteContext: resourceLxcGuestDelete,
 		Importer: &schema.ResourceImporter{
 			StateContext: schema.ImportStatePassthroughContext,
 		},
 		CustomizeDiff: reboot.CustomizeDiff(),
 
 		Schema: map[string]*schema.Schema{
-			architecture.Root:            architecture.Schema(),
-			clone.Root:                   clone.Schema(),
-			cpu.Root:                     cpu.Schema(),
-			description.Root:             description.Schema(),
-			dns.Root:                     dns.Schema(),
-			features.Root:                features.Schema(),
+			architecture.Root: architecture.Schema(),
+			clone.Root:        clone.Schema(),
+			cpu.Root:          cpu.Schema(),
+			description.Root:  description.Schema(),
+			dns.Root:          dns.Schema(),
+			// features.Root:                features.Schema(),
 			memory.Root:                  memory.Schema(),
 			mounts.RootMount:             mounts.SchemaMount(),
 			mounts.RootMounts:            mounts.SchemaMounts(),
@@ -81,15 +80,21 @@ func ResourceLxcNew() *schema.Resource {
 	return lxcNewResourceDef
 }
 
-func resourceLxcNewCreate(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
+func resourceLxcGuestCreate(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
 	pconf := meta.(*providerConfiguration)
 	lock := pmParallelBegin(pconf)
 	defer lock.unlock()
 
+	diags := lxcGuestWarning()
+
 	client := pconf.Client
 
 	privileged := privilege.SDK(d)
-	config, diags := lxcSDK(privileged, d)
+	config, tmpDiags := lxcSDK(privileged, d)
+	diags = append(diags, tmpDiags...)
+	if diags.HasError() {
+		return diags
+	}
 	config.Privileged = &privileged
 
 	// Set the node for the LXC container
@@ -150,36 +155,41 @@ func resourceLxcNewCreate(ctx context.Context, d *schema.ResourceData, meta any)
 			Type: id.GuestLxc}.String())
 	}
 
-	return append(diags, resourceLxcNewRead(ctx, d, meta, vmr, client)...)
+	return append(diags, resourceLxcGuestRead(ctx, d, meta, vmr, client)...)
 }
 
-func resourceLxcNewUpdate(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
+func resourceLxcGuestUpdate(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
 	pConf := meta.(*providerConfiguration)
 	lock := pmParallelBegin(pConf)
 	defer lock.unlock()
 
 	client := pConf.Client
 
+	diags := lxcGuestWarning()
+
 	// Get vm reference
 	var resourceID id.Guest
 	err := resourceID.Parse(d.Id())
 	if err != nil {
 		d.SetId("")
-		return diag.Diagnostics{{
+		return append(diags, diag.Diagnostic{
 			Summary:  "unexpected error when trying to read and parse the resource: " + err.Error(),
-			Severity: diag.Error}}
+			Severity: diag.Error})
 	}
 	var vmr *pveSDK.VmRef
 	vmr, err = client.GetVmRefById(ctx, resourceID.ID)
 	if err != nil {
-		return diag.Diagnostics{
-			diag.Diagnostic{
-				Summary:  err.Error(),
-				Severity: diag.Error}}
+		return append(diags, diag.Diagnostic{
+			Summary:  err.Error(),
+			Severity: diag.Error})
 	}
 
 	// create a new config from the resource data
-	config, diags := lxcSDK(privilege.SDK(d), d)
+	config, tmpDiags := lxcSDK(privilege.SDK(d), d)
+	diags = append(diags, tmpDiags...)
+	if diags.HasError() {
+		return diags
+	}
 
 	// update the targetNode for the LXC container
 	var targetNode pveSDK.NodeName
@@ -201,27 +211,29 @@ func resourceLxcNewUpdate(ctx context.Context, d *schema.ResourceData, meta any)
 			Severity: diag.Error})
 	}
 
-	return append(diags, resourceLxcNewRead(ctx, d, meta, vmr, client)...)
+	return append(diags, resourceLxcGuestRead(ctx, d, meta, vmr, client)...)
 }
 
-func resourceLxcNewReadWithLock(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
+func resourceLxcGuestReadWithLock(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
 	pConf := meta.(*providerConfiguration)
 	lock := pmParallelBegin(pConf)
 	defer lock.unlock()
 
+	diags := lxcGuestWarning()
+
 	var resourceID id.Guest
 	err := resourceID.Parse(d.Id())
 	if err != nil {
 		d.SetId("")
-		return diag.Diagnostics{{
+		return append(diags, diag.Diagnostic{
 			Summary:  "unexpected error when trying to read and parse the resource: " + err.Error(),
-			Severity: diag.Error}}
+			Severity: diag.Error})
 	}
 
-	return resourceLxcNewRead(ctx, d, meta, pveSDK.NewVmRef(resourceID.ID), pConf.Client)
+	return append(diags, resourceLxcGuestRead(ctx, d, meta, pveSDK.NewVmRef(resourceID.ID), pConf.Client)...)
 }
 
-func resourceLxcNewRead(ctx context.Context, d *schema.ResourceData, meta any, vmr *pveSDK.VmRef, client *pveSDK.Client) diag.Diagnostics {
+func resourceLxcGuestRead(ctx context.Context, d *schema.ResourceData, meta any, vmr *pveSDK.VmRef, client *pveSDK.Client) diag.Diagnostics {
 	guestStatus, err := vmr.GetRawGuestStatus(ctx, client)
 	if err != nil {
 		return diag.Diagnostics{{
@@ -245,7 +257,7 @@ func resourceLxcNewRead(ctx context.Context, d *schema.ResourceData, meta any, v
 	cpu.Terraform(config.CPU, d)
 	description.Terraform(config.Description, false, d)
 	dns.Terraform(config.DNS, d)
-	features.Terraform(config.Features, d)
+	// features.Terraform(config.Features, d)
 	memory.Terraform(config.Memory, d)
 	mounts.Terraform(config.Mounts, d)
 	name.Terraform_Unsafe(config.Name, d)
@@ -261,7 +273,7 @@ func resourceLxcNewRead(ctx context.Context, d *schema.ResourceData, meta any, v
 	return nil
 }
 
-func resourceLxcNewDelete(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
+func resourceLxcGuestDelete(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
 	return guestDelete(ctx, d, meta, "LXC")
 }
 
@@ -275,12 +287,12 @@ func lxcSDK(privilidged bool, d *schema.ResourceData) (pveSDK.ConfigLXC, diag.Di
 		CPU:         cpu.SDK(d),
 		DNS:         dns.SDK(d),
 		Description: description.SDK(false, d),
-		Features:    features.SDK(privilidged, d),
-		Memory:      memory.SDK(d),
-		Name:        guestName,
-		State:       powerstate.SDK(d),
-		Swap:        swap.SDK(d),
-		Tags:        tags.SDK(d),
+		// Features:    features.SDK(privilidged, d),
+		Memory: memory.SDK(d),
+		Name:   guestName,
+		State:  powerstate.SDK(d),
+		Swap:   swap.SDK(d),
+		Tags:   tags.SDK(d),
 	}
 	var diags, tmpDiags diag.Diagnostics
 	config.Networks, diags = networks.SDK(d)
@@ -291,3 +303,10 @@ func lxcSDK(privilidged bool, d *schema.ResourceData) (pveSDK.ConfigLXC, diag.Di
 	diags = append(diags, tmpDiags...)
 	return config, diags
 }
+
+func lxcGuestWarning() diag.Diagnostics {
+	return diag.Diagnostics{{
+		Detail:   "The LXC Guest resource is experimental. The schema and functionality may change in future releases without a major version bump.",
+		Summary:  "LXC Guest resource is experimental",
+		Severity: diag.Warning}}
+}