github.com/gophercloud/gophercloud@v1.11.0/internal/acceptance/openstack/networking/v2/extensions/dns/dns.go (about)

     1  package dns
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/gophercloud/gophercloud"
     7  	"github.com/gophercloud/gophercloud/internal/acceptance/tools"
     8  	"github.com/gophercloud/gophercloud/openstack/networking/v2/extensions/dns"
     9  	"github.com/gophercloud/gophercloud/openstack/networking/v2/extensions/layer3/floatingips"
    10  	"github.com/gophercloud/gophercloud/openstack/networking/v2/networks"
    11  	"github.com/gophercloud/gophercloud/openstack/networking/v2/ports"
    12  	th "github.com/gophercloud/gophercloud/testhelper"
    13  )
    14  
    15  // PortWithDNSExt represents a port with the DNS fields
    16  type PortWithDNSExt struct {
    17  	ports.Port
    18  	dns.PortDNSExt
    19  }
    20  
    21  // FloatingIPWithDNSExt represents a floating IP with the DNS fields
    22  type FloatingIPWithDNSExt struct {
    23  	floatingips.FloatingIP
    24  	dns.FloatingIPDNSExt
    25  }
    26  
    27  // NetworkWithDNSExt represents a network with the DNS fields
    28  type NetworkWithDNSExt struct {
    29  	networks.Network
    30  	dns.NetworkDNSExt
    31  }
    32  
    33  // CreatePortDNS will create a port with a DNS name on the specified subnet. An
    34  // error will be returned if the port could not be created.
    35  func CreatePortDNS(t *testing.T, client *gophercloud.ServiceClient, networkID, subnetID, dnsName string) (*PortWithDNSExt, error) {
    36  	portName := tools.RandomString("TESTACC-", 8)
    37  	portDescription := tools.RandomString("TESTACC-PORT-DESC-", 8)
    38  	iFalse := true
    39  
    40  	t.Logf("Attempting to create port: %s", portName)
    41  
    42  	portCreateOpts := ports.CreateOpts{
    43  		NetworkID:    networkID,
    44  		Name:         portName,
    45  		Description:  portDescription,
    46  		AdminStateUp: &iFalse,
    47  		FixedIPs:     []ports.IP{{SubnetID: subnetID}},
    48  	}
    49  
    50  	createOpts := dns.PortCreateOptsExt{
    51  		CreateOptsBuilder: portCreateOpts,
    52  		DNSName:           dnsName,
    53  	}
    54  
    55  	var port PortWithDNSExt
    56  
    57  	err := ports.Create(client, createOpts).ExtractInto(&port)
    58  	if err != nil {
    59  		return &port, err
    60  	}
    61  
    62  	t.Logf("Successfully created port: %s", portName)
    63  
    64  	th.AssertEquals(t, port.Name, portName)
    65  	th.AssertEquals(t, port.Description, portDescription)
    66  	th.AssertEquals(t, port.DNSName, dnsName)
    67  
    68  	return &port, nil
    69  }
    70  
    71  // CreateFloatingIPDNS creates a floating IP with the DNS extension on a given
    72  // network and port. An error will be returned if the creation failed.
    73  func CreateFloatingIPDNS(t *testing.T, client *gophercloud.ServiceClient, networkID, portID, dnsName, dnsDomain string) (*FloatingIPWithDNSExt, error) {
    74  	t.Logf("Attempting to create floating IP on port: %s", portID)
    75  
    76  	fipDescription := "Test floating IP"
    77  	fipCreateOpts := &floatingips.CreateOpts{
    78  		Description:       fipDescription,
    79  		FloatingNetworkID: networkID,
    80  		PortID:            portID,
    81  	}
    82  
    83  	createOpts := dns.FloatingIPCreateOptsExt{
    84  		CreateOptsBuilder: fipCreateOpts,
    85  		DNSName:           dnsName,
    86  		DNSDomain:         dnsDomain,
    87  	}
    88  
    89  	var floatingIP FloatingIPWithDNSExt
    90  	err := floatingips.Create(client, createOpts).ExtractInto(&floatingIP)
    91  	if err != nil {
    92  		return &floatingIP, err
    93  	}
    94  
    95  	t.Logf("Created floating IP.")
    96  
    97  	th.AssertEquals(t, floatingIP.Description, fipDescription)
    98  	th.AssertEquals(t, floatingIP.FloatingNetworkID, networkID)
    99  	th.AssertEquals(t, floatingIP.PortID, portID)
   100  	th.AssertEquals(t, floatingIP.DNSName, dnsName)
   101  	th.AssertEquals(t, floatingIP.DNSDomain, dnsDomain)
   102  
   103  	return &floatingIP, err
   104  }
   105  
   106  // CreateNetworkDNS will create a network with a DNS domain set.
   107  // An error will be returned if the network could not be created.
   108  func CreateNetworkDNS(t *testing.T, client *gophercloud.ServiceClient, dnsDomain string) (*NetworkWithDNSExt, error) {
   109  	networkName := tools.RandomString("TESTACC-", 8)
   110  	networkCreateOpts := networks.CreateOpts{
   111  		Name:         networkName,
   112  		AdminStateUp: gophercloud.Enabled,
   113  	}
   114  
   115  	createOpts := dns.NetworkCreateOptsExt{
   116  		CreateOptsBuilder: networkCreateOpts,
   117  		DNSDomain:         dnsDomain,
   118  	}
   119  
   120  	t.Logf("Attempting to create network: %s", networkName)
   121  
   122  	var network NetworkWithDNSExt
   123  
   124  	err := networks.Create(client, createOpts).ExtractInto(&network)
   125  	if err != nil {
   126  		return &network, err
   127  	}
   128  
   129  	t.Logf("Successfully created network.")
   130  
   131  	th.AssertEquals(t, network.Name, networkName)
   132  	th.AssertEquals(t, network.DNSDomain, dnsDomain)
   133  
   134  	return &network, nil
   135  }