feat(rdns): support setting RDNS for Primary IPs (#669)

Previously you could only set the RDNS for Primary IPs if they were
attached to a server, through the `server_id` attribute. This now also
allows setting the RDNS for Primary IPs directly, even if they are not
attached to a server.

Closes #668

Author: apricote

internal/e2etests/rdns/resource_test.go

@@ -2,20 +2,20 @@ package rdns_test
 
 import (
 	"fmt"
-	"testing"
 
-	"github.com/hetznercloud/terraform-provider-hcloud/internal/e2etests"
-	"github.com/hetznercloud/terraform-provider-hcloud/internal/loadbalancer"
-	"github.com/hetznercloud/terraform-provider-hcloud/internal/sshkey"
+	"testing"
 
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/terraform"
 
+	"github.com/hetznercloud/hcloud-go/hcloud"
+	"github.com/hetznercloud/terraform-provider-hcloud/internal/e2etests"
 	"github.com/hetznercloud/terraform-provider-hcloud/internal/floatingip"
+	"github.com/hetznercloud/terraform-provider-hcloud/internal/loadbalancer"
+	"github.com/hetznercloud/terraform-provider-hcloud/internal/primaryip"
 	"github.com/hetznercloud/terraform-provider-hcloud/internal/rdns"
 	"github.com/hetznercloud/terraform-provider-hcloud/internal/server"
-
-	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
-	"github.com/hetznercloud/hcloud-go/hcloud"
+	"github.com/hetznercloud/terraform-provider-hcloud/internal/sshkey"
 	"github.com/hetznercloud/terraform-provider-hcloud/internal/testsupport"
 	"github.com/hetznercloud/terraform-provider-hcloud/internal/testtemplate"
 )
@@ -97,6 +97,71 @@ func TestRDNSResource_Server(t *testing.T) {
 	}
 }
 
+func TestRDNSResource_PrimaryIP(t *testing.T) {
+	tests := []struct {
+		name          string
+		dns           string
+		primaryIPType string
+	}{
+		{
+			name:          "primary-ipv6-rdns",
+			dns:           "ipv6.example.hetzner.cloud",
+			primaryIPType: "ipv6",
+		},
+		{
+			name:          "primary-ipv4-rdns",
+			dns:           "ipv4.example.hetzner.cloud",
+			primaryIPType: "ipv4",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var primaryIP hcloud.PrimaryIP
+
+			tmplMan := testtemplate.Manager{}
+			restPrimaryIP := &primaryip.RData{
+				Name:         tt.name,
+				Type:         tt.primaryIPType,
+				AssigneeType: "server",
+				Datacenter:   e2etests.TestDataCenter,
+			}
+			restPrimaryIP.SetRName(tt.name)
+			resRDNS := rdns.NewRDataPrimaryIP(t, tt.name, restPrimaryIP.TFID()+".id", restPrimaryIP.TFID()+".ip_address", tt.dns)
+
+			// TODO: Debug issues that causes this to fail when running in parallel
+			resource.Test(t, resource.TestCase{
+				PreCheck:     e2etests.PreCheck(t),
+				Providers:    e2etests.Providers(),
+				CheckDestroy: testsupport.CheckResourcesDestroyed(primaryip.ResourceType, primaryip.ByID(t, &primaryIP)),
+				Steps: []resource.TestStep{
+					{
+						// Create a new SSH Key using the required values
+						// only.
+						Config: tmplMan.Render(t,
+							"testdata/r/hcloud_primary_ip", restPrimaryIP,
+							"testdata/r/hcloud_rdns", resRDNS,
+						),
+						Check: resource.ComposeTestCheckFunc(
+							testsupport.CheckResourceExists(restPrimaryIP.TFID(), primaryip.ByID(t, &primaryIP)),
+							resource.TestCheckResourceAttr(resRDNS.TFID(), "dns_ptr", tt.dns),
+						),
+					},
+					{
+						// Try to import the newly created RDNS
+						ResourceName: resRDNS.TFID(),
+						ImportStateIdFunc: func(state *terraform.State) (string, error) {
+							return fmt.Sprintf("p-%d-%s", primaryIP.ID, primaryIP.IP.String()), nil
+						},
+						ImportState:       true,
+						ImportStateVerify: true,
+					},
+				},
+			})
+		})
+	}
+}
+
 func TestRDNSResource_FloatingIP(t *testing.T) {
 	tests := []struct {
 		name           string

internal/rdns/resource_rdns.go

@@ -34,19 +34,25 @@ func Resource() *schema.Resource {
 				Type:         schema.TypeInt,
 				Optional:     true,
 				ForceNew:     true,
-				ExactlyOneOf: []string{"server_id", "floating_ip_id", "load_balancer_id"},
+				ExactlyOneOf: []string{"server_id", "primary_ip_id", "floating_ip_id", "load_balancer_id"},
+			},
+			"primary_ip_id": {
+				Type:         schema.TypeInt,
+				Optional:     true,
+				ForceNew:     true,
+				ExactlyOneOf: []string{"server_id", "primary_ip_id", "floating_ip_id", "load_balancer_id"},
 			},
 			"floating_ip_id": {
 				Type:         schema.TypeInt,
 				Optional:     true,
 				ForceNew:     true,
-				ExactlyOneOf: []string{"server_id", "floating_ip_id", "load_balancer_id"},
+				ExactlyOneOf: []string{"server_id", "primary_ip_id", "floating_ip_id", "load_balancer_id"},
 			},
 			"load_balancer_id": {
 				Type:         schema.TypeInt,
 				Optional:     true,
 				ForceNew:     true,
-				ExactlyOneOf: []string{"server_id", "floating_ip_id", "load_balancer_id"},
+				ExactlyOneOf: []string{"server_id", "primary_ip_id", "floating_ip_id", "load_balancer_id"},
 			},
 			"ip_address": {
 				Type:     schema.TypeString,
@@ -82,6 +88,8 @@ func resourceReverseDNSRead(ctx context.Context, d *schema.ResourceData, m inter
 	switch v := rdns.(type) {
 	case *hcloud.Server:
 		d.Set("server_id", v.ID)
+	case *hcloud.PrimaryIP:
+		d.Set("primary_ip_id", v.ID)
 	case *hcloud.FloatingIP:
 		d.Set("floating_ip_id", v.ID)
 	case *hcloud.LoadBalancer:
@@ -97,6 +105,7 @@ func resourceReverseDNSRead(ctx context.Context, d *schema.ResourceData, m inter
 func resourceReverseDNSCreate(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
 	c := m.(*hcloud.Client)
 	serverID, serverOK := d.GetOk("server_id")
+	primaryIPID, primaryIPOK := d.GetOk("primary_ip_id")
 	floatingIPID, floatingIPOK := d.GetOk("floating_ip_id")
 	loadBalancerID, loadBalancerOK := d.GetOk("load_balancer_id")
 
@@ -114,6 +123,9 @@ func resourceReverseDNSCreate(ctx context.Context, d *schema.ResourceData, m int
 	case serverOK:
 		rdns, _, err = c.Server.GetByID(ctx, serverID.(int))
 		resourceName = "Server"
+	case primaryIPOK:
+		rdns, _, err = c.PrimaryIP.GetByID(ctx, primaryIPID.(int))
+		resourceName = "Primary IP"
 	case floatingIPOK:
 		rdns, _, err = c.FloatingIP.GetByID(ctx, floatingIPID.(int))
 		resourceName = "Floating IP"
@@ -201,6 +213,8 @@ func generateRDNSID(rdns hcloud.RDNSSupporter, ip net.IP) string {
 	switch v := rdns.(type) {
 	case *hcloud.Server:
 		return fmt.Sprintf("s-%d-%s", v.ID, ip)
+	case *hcloud.PrimaryIP:
+		return fmt.Sprintf("p-%d-%s", v.ID, ip)
 	case *hcloud.FloatingIP:
 		return fmt.Sprintf("f-%d-%s", v.ID, ip)
 	case *hcloud.LoadBalancer:
@@ -262,6 +276,15 @@ func lookupRDNSID(ctx context.Context, terraformID string, client *hcloud.Client
 			return nil, nil, InvalidRDNSIDError{terraformID}
 		}
 		rdns = srv
+	case "p":
+		pip, _, err := client.PrimaryIP.GetByID(ctx, id)
+		if err != nil {
+			return nil, nil, err
+		}
+		if pip == nil {
+			return nil, nil, InvalidRDNSIDError{terraformID}
+		}
+		rdns = pip
 	case "f":
 		fip, _, err := client.FloatingIP.GetByID(ctx, id)
 		if err != nil {

internal/rdns/testing.go

@@ -46,6 +46,7 @@ type RData struct {
 	testtemplate.DataCommon
 
 	ServerID       string
+	PrimaryIPID    string
 	FloatingIPID   string
 	LoadBalancerID string
 	IPAddress      string
@@ -68,6 +69,17 @@ func NewRDataServer(t *testing.T, rName string, serverID string, ipAddress strin
 	return r
 }
 
+// NewRDataPrimaryIP creates data for a new rdns resource with primary_ip_id.
+func NewRDataPrimaryIP(t *testing.T, rName string, primaryIPID string, ipAddress string, dnsPTR string) *RData {
+	r := &RData{
+		PrimaryIPID: primaryIPID,
+		IPAddress:   ipAddress,
+		DNSPTR:      dnsPTR,
+	}
+	r.SetRName(rName)
+	return r
+}
+
 // NewRDataFloatingIP creates data for a new rdns resource with floating_ip_id.
 func NewRDataFloatingIP(t *testing.T, rName string, floatingIPID string, ipAddress string, dnsPTR string) *RData {
 	r := &RData{

internal/testdata/r/hcloud_rdns.tf.tmpl

@@ -4,6 +4,9 @@ resource "hcloud_rdns" "{{ .RName }}" {
   {{- if .ServerID }}
   server_id        = {{ .ServerID }}
   {{ end }}
+  {{- if .PrimaryIPID }}
+  primary_ip_id        = {{ .PrimaryIPID }}
+  {{ end }}
   {{- if .FloatingIPID }}
   floating_ip_id        = {{ .FloatingIPID }}
   {{ end }}

website/docs/r/rdns.html.md

@@ -3,12 +3,12 @@ layout: "hcloud"
 page_title: "Hetzner Cloud: hcloud_rdns"
 sidebar_current: "docs-hcloud-resource-rdns"
 description: |-
-  Provides a Hetzner Cloud Reverse DNS Entry to create, modify and reset reverse dns entries for Hetzner Cloud Servers, Floating IPs or Load Balancers.
+  Provides a Hetzner Cloud Reverse DNS Entry to create, modify and reset reverse dns entries for Hetzner Cloud Servers, Primary IPs, Floating IPs or Load Balancers.
 ---
 
 # hcloud_rdns
 
-Provides a Hetzner Cloud Reverse DNS Entry to create, modify and reset reverse dns entries for Hetzner Cloud Servers, Floating IPs or Load Balancers.
+Provides a Hetzner Cloud Reverse DNS Entry to create, modify and reset reverse dns entries for Hetzner Cloud Servers, Primary IPs, Floating IPs or Load Balancers.
 
 ## Example Usage
 
@@ -28,6 +28,21 @@ resource "hcloud_rdns" "master" {
 }
 ```
 
+For Primary IPs:
+
+```hcl
+resource "hcloud_primary_ip" "primary1" {
+  datacenter = "nbg1-dc3"
+  type       = "ipv4"
+}
+
+resource "hcloud_rdns" "primary1" {
+  primary_ip_id  = hcloud_primary_ip.primary1.id
+  ip_address     = hcloud_primary_ip.primary1.ip_address
+  dns_ptr        = "example.com"
+}
+```
+
 For Floating IPs:
 
 ```hcl
@@ -62,16 +77,18 @@ resource "hcloud_rdns" "load_balancer_master" {
 
 - `dns_ptr` - (Required, string) The DNS address the `ip_address` should resolve to.
 - `ip_address` - (Required, string) The IP address that should point to `dns_ptr`.
-- `server_id` - (Required, int) The server the `ip_address` belongs to. Specify only one of `server_id`, `floating_ip_id` and `load_balancer_id`.
-- `floating_ip_id` - (Required, int) The Floating IP the `ip_address` belongs to. Specify only one of `server_id`, `floating_ip_id` and `load_balancer_id`.
-- `load_balancer_id` - (Required, int) The Load Balancer the `ip_address` belongs to. Specify only one of `server_id`, `floating_ip_id` and `load_balancer_id`.
+- `server_id` - (Required, int) The server the `ip_address` belongs to. - `server_id` - (Required, int) The server the `ip_address` belongs to. Specify only one of `server_id`, `primary_ip_id`, `floating_ip_id` and `load_balancer_id`.
+- `primary_ip_id` - (Required, int) The Primary IP the `ip_address` belongs to. - `server_id` - (Required, int) The server the `ip_address` belongs to. Specify only one of `server_id`, `primary_ip_id`, `floating_ip_id` and `load_balancer_id`.
+- `floating_ip_id` - (Required, int) The Floating IP the `ip_address` belongs to. - `server_id` - (Required, int) The server the `ip_address` belongs to. Specify only one of `server_id`, `primary_ip_id`, `floating_ip_id` and `load_balancer_id`.
+- `load_balancer_id` - (Required, int) The Load Balancer the `ip_address` belongs to. - `server_id` - (Required, int) The server the `ip_address` belongs to. Specify only one of `server_id`, `primary_ip_id`, `floating_ip_id` and `load_balancer_id`.
 
 ## Attributes Reference
 
 - `id` - (int) Unique ID of the Reverse DNS Entry.
 - `dns_ptr` - (string) DNS pointer for the IP address.
 - `ip_address` - (string) IP address.
 - `server_id` - (int) The server the IP address belongs to.
+- `primary_ip_id` - (int) The Primary IP the IP address belongs to.
 - `floating_ip_id` - (int) The Floating IP the IP address belongs to.
 - `load_balancer_id` - (int) The Load Balancer the IP address belongs to.
 
@@ -84,6 +101,9 @@ Reverse DNS entries can be imported using a compound ID with the following forma
 # import reverse dns entry on server with id 123, ip 192.168.100.1
 terraform import hcloud_rdns.myrdns s-123-192.168.100.1
 
+# import reverse dns entry on primary ip with id 123, ip 2001:db8::1
+terraform import hcloud_rdns.myrdns p-123-2001:db8::1
+
 # import reverse dns entry on floating ip with id 123, ip 2001:db8::1
 terraform import hcloud_rdns.myrdns f-123-2001:db8::1