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