Added support for updated behavior of linode API's (networkingip, rdns, instance)

go.mod

@@ -125,3 +125,5 @@ require (
 	sigs.k8s.io/structured-merge-diff/v4 v4.2.3 // indirect
 	sigs.k8s.io/yaml v1.3.0 // indirect
 )
+
+

linode/framework_provider.go

@@ -54,6 +54,10 @@ import (
 	"github.com/linode/terraform-provider-linode/v2/linode/nbs"
 	"github.com/linode/terraform-provider-linode/v2/linode/nbtypes"
 	"github.com/linode/terraform-provider-linode/v2/linode/networkingip"
+	"github.com/linode/terraform-provider-linode/v2/linode/networkingips"
+	"github.com/linode/terraform-provider-linode/v2/linode/networkipassignment"
+	"github.com/linode/terraform-provider-linode/v2/linode/networkreservedip"
+	"github.com/linode/terraform-provider-linode/v2/linode/networkreservedips"
 	"github.com/linode/terraform-provider-linode/v2/linode/networktransferprices"
 	"github.com/linode/terraform-provider-linode/v2/linode/objbucket"
 	"github.com/linode/terraform-provider-linode/v2/linode/objcluster"
@@ -225,13 +229,16 @@ func (p *FrameworkProvider) Resources(ctx context.Context) []func() resource.Res
 		placementgroup.NewResource,
 		placementgroupassignment.NewResource,
 		instancereservedipassignment.NewResource,
+		networkreservedip.NewResource,
 		rdns.NewResource,
 		sshkey.NewResource,
 		stackscript.NewResource,
 		token.NewResource,
 		volume.NewResource,
 		vpc.NewResource,
 		vpcsubnet.NewResource,
+		networkingip.NewResource,
+		networkipassignment.NewResource,
 	}
 }
 
@@ -300,5 +307,8 @@ func (p *FrameworkProvider) DataSources(ctx context.Context) []func() datasource
 		placementgroups.NewDataSource,
 		childaccount.NewDataSource,
 		childaccounts.NewDataSource,
+		networkreservedip.NewDataSourceFetch,
+		networkreservedips.NewDataSourceList,
+		networkingips.NewDataSource,
 	}
 }

linode/instance/resource.go

@@ -830,6 +830,11 @@ func updateResource(ctx context.Context, d *schema.ResourceData, meta interface{
 		}
 	}
 
+	if d.HasChange("ipv4") {
+		// Log a warning that direct IP changes are not supported
+		return diag.Errorf("Changing IPv4 addresses after instance creation is not directly supported. The attempted change will be ignored.")
+	}
+
 	// Don't reboot if the Linode should be powered off
 	if !bootedNull && !booted {
 		rebootInstance = false

linode/instance/resource_test.go

@@ -2899,27 +2899,24 @@ func checkComputeInstanceDisk(instance *linodego.Instance, label string, size in
 }
 
 func TestAccResourceInstance_withReservedIP(t *testing.T) {
-	acceptance.OptInTest(t)
 	t.Parallel()
 
 	var instance linodego.Instance
 	resourceName := "linode_instance.foobar"
 	instanceName := acctest.RandomWithPrefix("tf_test")
 	rootPass := acctest.RandString(16)
-	reservedIP := "50.116.51.242" // Use a test IP or fetch a real reserved IP
 
 	resource.Test(t, resource.TestCase{
 		PreCheck:                 func() { acceptance.PreCheck(t) },
 		ProtoV5ProviderFactories: acceptance.ProtoV5ProviderFactories,
 		CheckDestroy:             acceptance.CheckInstanceDestroy,
 		Steps: []resource.TestStep{
 			{
-				Config: tmpl.WithReservedIP(t, instanceName, acceptance.PublicKeyMaterial, testRegion, rootPass, reservedIP),
+				Config: tmpl.WithReservedIP(t, instanceName, acceptance.PublicKeyMaterial, testRegion, rootPass),
 				Check: resource.ComposeTestCheckFunc(
 					acceptance.CheckInstanceExists(resourceName, &instance),
 					resource.TestCheckResourceAttr(resourceName, "label", instanceName),
 					resource.TestCheckResourceAttr(resourceName, "ipv4.#", "1"),
-					resource.TestCheckResourceAttr(resourceName, "ipv4.0", reservedIP),
 				),
 			},
 			{
@@ -2931,3 +2928,65 @@ func TestAccResourceInstance_withReservedIP(t *testing.T) {
 		},
 	})
 }
+
+func TestAccResourceInstance_deleteWithReservedIP(t *testing.T) {
+	t.Parallel()
+	var instance linodego.Instance
+	resourceName := "linode_instance.foobar"
+	testRegion := "us-east"
+	reservedIP := ""
+	instanceName := acctest.RandomWithPrefix("tf_test")
+	ipResourceName := "linode_reserved_ip.test"
+	rootPass := acctest.RandString(16)
+	resource.Test(t, resource.TestCase{
+		PreCheck:                 func() { acceptance.PreCheck(t) },
+		ProtoV5ProviderFactories: acceptance.ProtoV5ProviderFactories,
+		CheckDestroy:             acceptance.CheckInstanceDestroy,
+		Steps: []resource.TestStep{
+			{
+				Config: tmpl.WithReservedIP(t, instanceName, acceptance.PublicKeyMaterial, testRegion, rootPass),
+				Check: resource.ComposeTestCheckFunc(
+					acceptance.CheckInstanceExists(resourceName, &instance),
+					resource.TestCheckResourceAttr(resourceName, "label", instanceName),
+					resource.TestCheckResourceAttr(resourceName, "ipv4.#", "1"),
+					func(s *terraform.State) error {
+						rs, ok := s.RootModule().Resources[ipResourceName]
+						if !ok {
+							return fmt.Errorf("Not found: %s", ipResourceName)
+						}
+						reservedIP = rs.Primary.Attributes["address"]
+						return nil
+					},
+				),
+			},
+			{
+				Config: tmpl.OnlyReservedIP(t, testRegion), // This config only includes the reserved IP resource
+				Check: resource.ComposeTestCheckFunc(
+					func(s *terraform.State) error {
+						client := acceptance.TestAccProvider.Meta().(*helper.ProviderMeta).Client
+
+						// Check if the instance is deleted
+						_, err := client.GetInstance(context.Background(), instance.ID)
+						if err == nil {
+							return fmt.Errorf("Linode instance %d still exists", instance.ID)
+						}
+						if apiErr, ok := err.(*linodego.Error); ok && apiErr.Code != 404 {
+							return fmt.Errorf("Error requesting Linode instance %d: %s", instance.ID, err)
+						}
+
+						// Check if the Reserved IP still exists and is reserved
+						ip, err := client.GetIPAddress(context.Background(), reservedIP)
+						if err != nil {
+							return fmt.Errorf("Error checking if Reserved IP exists: %s", err)
+						}
+						if !ip.Reserved {
+							return fmt.Errorf("Reserved IP %s is no longer reserved after instance deletion", reservedIP)
+						}
+
+						return nil
+					},
+				),
+			},
+		},
+	})
+}

linode/instance/tmpl/template.go

@@ -1,6 +1,7 @@
 package tmpl
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/linode/linodego"
@@ -28,7 +29,6 @@ type TemplateData struct {
 	AssignedGroup   string
 
 	DiskEncryption *linodego.InstanceDiskEncryption
-	IPv4           []string
 }
 
 func Basic(t testing.TB, label, pubKey, region string, rootPass string) string {
@@ -743,15 +743,22 @@ func WithPG(t testing.TB, label, region, assignedGroup string, groups []string)
 		})
 }
 
-func WithReservedIP(t *testing.T, label, pubKey, region, rootPass string, reservedIP string) string {
+func WithReservedIP(t *testing.T, label, pubKey, region, rootPass string) string {
 	generatedConfig := acceptance.ExecuteTemplate(t,
 		"instance_with_reserved_ip", TemplateData{
 			Label:    label,
 			PubKey:   pubKey,
 			Image:    acceptance.TestImageLatest,
 			Region:   region,
 			RootPass: rootPass,
-			IPv4:     []string{reservedIP},
 		})
 	return generatedConfig
 }
+
+func OnlyReservedIP(t *testing.T, region string) string {
+	return fmt.Sprintf(`
+resource "linode_reserved_ip" "test" {
+	region = "%s"
+}
+`, region)
+}

linode/instance/tmpl/templates/instance_with_reserved_ip.gotf

@@ -2,17 +2,20 @@
 
 {{ template "e2e_test_firewall" . }}
 
+resource "linode_reserved_ip" "test" {
+  region = "{{ .Region }}"
+}
+
 resource "linode_instance" "foobar" {
     label  = "{{ .Label }}"
     type   = "g6-nanode-1"
     region = "{{ .Region }}"
     image  = "{{ .Image }}"
     firewall_id = linode_firewall.e2e_test_firewall.id
-
     root_pass = "{{ .RootPass }}"
     authorized_keys = ["{{ .PubKey }}"]
 
-    ipv4 = [{{ range $index, $ip := .IPv4 }}{{ if $index }}, {{ end }}"{{ $ip }}"{{ end }}]
+    ipv4 = [linode_reserved_ip.test.address]
 }
 
 {{ end }}

linode/instanceip/framework_resource.go

@@ -153,7 +153,6 @@ func (r *Resource) Read(
 	if resp.Diagnostics.HasError() {
 		return
 	}
-
 	ip, err := client.GetInstanceIPAddress(ctx, linodeID, address)
 	if err != nil {
 		if lerr, ok := err.(*linodego.Error); ok && lerr.Code == 404 {

linode/instanceip/tmpl/template.go

@@ -10,6 +10,7 @@ type TemplateData struct {
 	Label            string
 	ApplyImmediately bool
 	Region           string
+	Address          string
 }
 
 func Basic(t testing.TB, instanceLabel, region string, applyImmediately bool) string {

linode/instancenetworking/datasource_test.go

@@ -80,3 +80,34 @@ func TestAccDataSourceInstanceNetworking_vpc(t *testing.T) {
 		},
 	})
 }
+
+func TestAccDataSourceInstanceNetworking_basicwithReseved(t *testing.T) {
+	t.Parallel()
+
+	var instance linodego.Instance
+
+	name := acctest.RandomWithPrefix("tf_test")
+	resource.Test(t, resource.TestCase{
+		PreCheck:                 func() { acceptance.PreCheck(t) },
+		ProtoV5ProviderFactories: acceptance.ProtoV5ProviderFactories,
+		CheckDestroy:             acceptance.CheckInstanceDestroy,
+		Steps: []resource.TestStep{
+			{
+				Config: tmpl.DataBasic_withReservedField(t, name, testRegion),
+			},
+			{
+				Config: tmpl.DataBasic_withReservedField(t, name, testRegion),
+				Check: resource.ComposeTestCheckFunc(
+					acceptance.CheckInstanceExists("linode_instance.foobar", &instance),
+					resource.TestCheckResourceAttrSet(testInstanceNetworkResName, "ipv4.0.private.#"),
+					resource.TestCheckResourceAttrSet(testInstanceNetworkResName, "ipv4.0.public.#"),
+					resource.TestCheckResourceAttrSet(testInstanceNetworkResName, "ipv4.0.reserved.#"),
+					resource.TestCheckResourceAttrSet(testInstanceNetworkResName, "ipv4.0.shared.#"),
+					resource.TestCheckResourceAttrSet(testInstanceNetworkResName, "ipv6.0.global.#"),
+					resource.TestCheckResourceAttrSet(testInstanceNetworkResName, "ipv6.0.link_local.%"),
+					resource.TestCheckResourceAttrSet(testInstanceNetworkResName, "ipv6.0.slaac.%"),
+				),
+			},
+		},
+	})
+}

linode/instancenetworking/tmpl/data_basic_reserved.gotf

@@ -0,0 +1,22 @@
+{{ define "instance_networking_data_basic_with_reserved" }}
+
+resource "linode_instance" "foobar" {
+    label = "{{.Label}}"
+    type = "g6-nanode-1"
+    region = "{{ .Region }}"
+    image = "linode/debian12"
+}
+
+resource "linode_networking_ip" "reserved_ip" {
+  region   = "{{ .Region }}"
+  public   = true
+  type     = "ipv4"
+  reserved = true
+  linode_id = linode_instance.foobar.id
+}
+
+data "linode_instance_networking" "test" {
+    linode_id = linode_instance.foobar.id
+}
+
+{{ end }}

linode/instancenetworking/tmpl/template.go

@@ -30,3 +30,11 @@ func DataVPC(t testing.TB, label, region, subnetIPv4, interfaceIPv4 string) stri
 			InterfaceIPv4: interfaceIPv4,
 		})
 }
+
+func DataBasic_withReservedField(t *testing.T, instanceLabel, region string) string {
+	return acceptance.ExecuteTemplate(t,
+		"instance_networking_data_basic_with_reserved", TemplateData{
+			Label:  instanceLabel,
+			Region: region,
+		})
+}

linode/networkingip/datasource_test.go

@@ -49,6 +49,7 @@ func TestAccDataSourceNetworkingIP_basic(t *testing.T) {
 					resource.TestMatchResourceAttr(dataResourceName, "gateway", regexp.MustCompile(`\.1$`)),
 					resource.TestCheckResourceAttr(dataResourceName, "type", "ipv4"),
 					resource.TestCheckResourceAttr(dataResourceName, "public", "true"),
+					resource.TestCheckResourceAttrSet(dataResourceName, "reserved"),
 					resource.TestCheckResourceAttr(dataResourceName, "prefix", "24"),
 					resource.TestMatchResourceAttr(dataResourceName, "rdns", regexp.MustCompile(`.ip.linodeusercontent.com$`)),
 				),

linode/networkingip/framework_datasource.go

@@ -37,6 +37,7 @@ func (data *DataSourceModel) parseIP(ip *linodego.InstanceIP) {
 	data.RDNS = types.StringValue(ip.RDNS)
 	data.LinodeID = types.Int64Value(int64(ip.LinodeID))
 	data.Region = types.StringValue(ip.Region)
+	data.Reserved = types.BoolValue(ip.Reserved)
 
 	id, _ := json.Marshal(ip)
 
@@ -51,6 +52,7 @@ type DataSourceModel struct {
 	Type       types.String `tfsdk:"type"`
 	Public     types.Bool   `tfsdk:"public"`
 	RDNS       types.String `tfsdk:"rdns"`
+	Reserved   types.Bool   `tfsdk:"reserved"`
 	LinodeID   types.Int64  `tfsdk:"linode_id"`
 	Region     types.String `tfsdk:"region"`
 	ID         types.String `tfsdk:"id"`

linode/networkingip/framework_datasource_schema.go

@@ -43,6 +43,11 @@ var frameworkDatasourceSchema = schema.Schema{
 			Description: "The Region this IP address resides in.",
 			Computed:    true,
 		},
+		"reserved": schema.BoolAttribute{
+			Description: "Whether the IPv4 address should be reserved.",
+			Computed:    true,
+		},
+
 		"id": schema.StringAttribute{
 			Description: "A unique identifier for this datasource.",
 			Computed:    true,