// CreateMember will create a member with a random name, port, address, and
// weight. An error will be returned if the member could not be created.
func CreateMember(t *testing.T, client *gophercloud.ServiceClient, lb *loadbalancers.LoadBalancer, pool *pools.Pool, subnetID, subnetCIDR string) (*pools.Member, error) {
memberName := tools.RandomString("TESTACCT-", 8)
memberPort := tools.RandomInt(100, 1000)
memberWeight := tools.RandomInt(1, 10)
cidrParts := strings.Split(subnetCIDR, "/")
subnetParts := strings.Split(cidrParts[0], ".")
memberAddress := fmt.Sprintf("%s.%s.%s.%d", subnetParts[0], subnetParts[1], subnetParts[2], tools.RandomInt(10, 100))
t.Logf("Attempting to create member %s", memberName)
createOpts := pools.CreateMemberOpts{
Name: memberName,
ProtocolPort: memberPort,
Weight: memberWeight,
Address: memberAddress,
SubnetID: subnetID,
}
t.Logf("Member create opts: %#v", createOpts)
member, err := pools.CreateMember(client, pool.ID, createOpts).Extract()
if err != nil {
return member, err
}
t.Logf("Successfully created member %s", memberName)
if err := WaitForLoadBalancerState(client, lb.ID, "ACTIVE", loadbalancerActiveTimeoutSeconds); err != nil {
return member, fmt.Errorf("Timed out waiting for loadbalancer to become active")
}
return member, nil
}
// CreateRule will create a Firewall Rule with a random source address and
//source port, destination address and port. An error will be returned if
// the rule could not be created.
func CreateRule(t *testing.T, client *gophercloud.ServiceClient) (*rules.Rule, error) {
ruleName := tools.RandomString("TESTACC-", 8)
sourceAddress := fmt.Sprintf("192.168.1.%d", tools.RandomInt(1, 100))
sourcePort := strconv.Itoa(tools.RandomInt(1, 100))
destinationAddress := fmt.Sprintf("192.168.2.%d", tools.RandomInt(1, 100))
destinationPort := strconv.Itoa(tools.RandomInt(1, 100))
t.Logf("Attempting to create rule %s with source %s:%s and destination %s:%s",
ruleName, sourceAddress, sourcePort, destinationAddress, destinationPort)
createOpts := rules.CreateOpts{
Name: ruleName,
Protocol: rules.ProtocolTCP,
Action: "allow",
SourceIPAddress: sourceAddress,
SourcePort: sourcePort,
DestinationIPAddress: destinationAddress,
DestinationPort: destinationPort,
}
rule, err := rules.Create(client, createOpts).Extract()
if err != nil {
return rule, err
}
t.Logf("Rule %s successfully created", ruleName)
return rule, nil
}
// CreateListener will create a listener for a given load balancer on a random
// port with a random name. An error will be returned if the listener could not
// be created.
func CreateListener(t *testing.T, client *gophercloud.ServiceClient, lb *loadbalancers.LoadBalancer) (*listeners.Listener, error) {
listenerName := tools.RandomString("TESTACCT-", 8)
listenerPort := tools.RandomInt(1, 100)
t.Logf("Attempting to create listener %s on port %d", listenerName, listenerPort)
createOpts := listeners.CreateOpts{
Name: listenerName,
LoadbalancerID: lb.ID,
Protocol: "TCP",
ProtocolPort: listenerPort,
}
listener, err := listeners.Create(client, createOpts).Extract()
if err != nil {
return listener, err
}
t.Logf("Successfully created listener %s", listenerName)
if err := WaitForLoadBalancerState(client, lb.ID, "ACTIVE", loadbalancerActiveTimeoutSeconds); err != nil {
return listener, fmt.Errorf("Timed out waiting for loadbalancer to become active")
}
return listener, nil
}
// CreateSubnetWithNoGateway will create a subnet with no gateway on the
// specified Network ID. An error will be returned if the subnet could not be
// created.
func CreateSubnetWithNoGateway(t *testing.T, client *gophercloud.ServiceClient, networkID string) (*subnets.Subnet, error) {
var noGateway = ""
subnetName := tools.RandomString("TESTACC-", 8)
subnetOctet := tools.RandomInt(1, 250)
subnetCIDR := fmt.Sprintf("192.168.%d.0/24", subnetOctet)
dhcpStart := fmt.Sprintf("192.168.%d.10", subnetOctet)
dhcpEnd := fmt.Sprintf("192.168.%d.200", subnetOctet)
createOpts := subnets.CreateOpts{
NetworkID: networkID,
CIDR: subnetCIDR,
IPVersion: 4,
Name: subnetName,
EnableDHCP: gophercloud.Disabled,
GatewayIP: &noGateway,
AllocationPools: []subnets.AllocationPool{
{
Start: dhcpStart,
End: dhcpEnd,
},
},
}
t.Logf("Attempting to create subnet: %s", subnetName)
subnet, err := subnets.Create(client, createOpts).Extract()
if err != nil {
return subnet, err
}
t.Logf("Successfully created subnet.")
return subnet, nil
}
// CreateSecurityGroupRule will create a security group rule with a random name
// and a random TCP port range between port 80 and 99. An error will be
// returned if the rule failed to be created.
func CreateSecurityGroupRule(t *testing.T, client *gophercloud.ServiceClient, securityGroupID string) (secgroups.Rule, error) {
createOpts := secgroups.CreateRuleOpts{
ParentGroupID: securityGroupID,
FromPort: tools.RandomInt(80, 89),
ToPort: tools.RandomInt(90, 99),
IPProtocol: "TCP",
CIDR: "0.0.0.0/0",
}
rule, err := secgroups.CreateRule(client, createOpts).Extract()
if err != nil {
return *rule, err
}
t.Logf("Created security group rule: %s", rule.ID)
return *rule, nil
}
// CreateDefaultRule will create a default security group rule with a
// random port range between 80 and 90. An error will be returned if
// a default rule was unable to be created.
func CreateDefaultRule(t *testing.T, client *gophercloud.ServiceClient) (dsr.DefaultRule, error) {
createOpts := dsr.CreateOpts{
FromPort: tools.RandomInt(80, 89),
ToPort: tools.RandomInt(90, 99),
IPProtocol: "TCP",
CIDR: "0.0.0.0/0",
}
defaultRule, err := dsr.Create(client, createOpts).Extract()
if err != nil {
return *defaultRule, err
}
t.Logf("Created default rule: %s", defaultRule.ID)
return *defaultRule, nil
}
// CreateMember will create a load balancer member in a specified pool on a
// random port. An error will be returned if the member could not be created.
func CreateMember(t *testing.T, client *gophercloud.ServiceClient, poolID string) (*members.Member, error) {
protocolPort := tools.RandomInt(100, 1000)
address := tools.RandomInt(2, 200)
t.Logf("Attempting to create member in port %d", protocolPort)
createOpts := members.CreateOpts{
PoolID: poolID,
ProtocolPort: protocolPort,
Address: fmt.Sprintf("192.168.1.%d", address),
}
member, err := members.Create(client, createOpts).Extract()
if err != nil {
return member, err
}
t.Logf("Successfully created member %s")
return member, nil
}
// CreateSecurityGroupRule will create a security group rule with a random name
// and random port between 80 and 99.
// An error will be returned if one was failed to be created.
func CreateSecurityGroupRule(t *testing.T, client *gophercloud.ServiceClient, secGroupID string) (*rules.SecGroupRule, error) {
t.Logf("Attempting to create security group rule in group: %s", secGroupID)
fromPort := tools.RandomInt(80, 89)
toPort := tools.RandomInt(90, 99)
createOpts := rules.CreateOpts{
Direction: "ingress",
EtherType: "IPv4",
SecGroupID: secGroupID,
PortRangeMin: fromPort,
PortRangeMax: toPort,
Protocol: rules.ProtocolTCP,
}
rule, err := rules.Create(client, createOpts).Extract()
if err != nil {
return rule, err
}
t.Logf("Created security group rule: %s", rule.ID)
return rule, nil
}
// CreateSubnetWithDefaultGateway will create a subnet on the specified Network
// ID and have Neutron set the gateway by default An error will be returned if
// the subnet could not be created.
func CreateSubnetWithDefaultGateway(t *testing.T, client *gophercloud.ServiceClient, networkID string) (*subnets.Subnet, error) {
subnetName := tools.RandomString("TESTACC-", 8)
subnetOctet := tools.RandomInt(1, 250)
subnetCIDR := fmt.Sprintf("192.168.%d.0/24", subnetOctet)
createOpts := subnets.CreateOpts{
NetworkID: networkID,
CIDR: subnetCIDR,
IPVersion: 4,
Name: subnetName,
EnableDHCP: gophercloud.Disabled,
}
t.Logf("Attempting to create subnet: %s", subnetName)
subnet, err := subnets.Create(client, createOpts).Extract()
if err != nil {
return subnet, err
}
t.Logf("Successfully created subnet.")
return subnet, nil
}
// CreateVIP will create a vip with a random name and a random port in a
// specified subnet and pool. An error will be returned if the vip could
// not be created.
func CreateVIP(t *testing.T, client *gophercloud.ServiceClient, subnetID, poolID string) (*vips.VirtualIP, error) {
vipName := tools.RandomString("TESTACCT-", 8)
vipPort := tools.RandomInt(100, 10000)
t.Logf("Attempting to create VIP %s", vipName)
createOpts := vips.CreateOpts{
Name: vipName,
SubnetID: subnetID,
PoolID: poolID,
Protocol: "TCP",
ProtocolPort: vipPort,
}
vip, err := vips.Create(client, createOpts).Extract()
if err != nil {
return vip, err
}
t.Logf("Successfully created vip %s", vipName)
return vip, nil
}
func TestLoadbalancersCRUD(t *testing.T) {
client, err := clients.NewNetworkV2Client()
if err != nil {
t.Fatalf("Unable to create a network client: %v", err)
}
network, err := networking.CreateNetwork(t, client)
if err != nil {
t.Fatalf("Unable to create network: %v", err)
}
defer networking.DeleteNetwork(t, client, network.ID)
subnet, err := networking.CreateSubnet(t, client, network.ID)
if err != nil {
t.Fatalf("Unable to create subnet: %v", err)
}
defer networking.DeleteSubnet(t, client, subnet.ID)
lb, err := CreateLoadBalancer(t, client, subnet.ID)
if err != nil {
t.Fatalf("Unable to create loadbalancer: %v", err)
}
defer DeleteLoadBalancer(t, client, lb.ID)
newLB, err := loadbalancers.Get(client, lb.ID).Extract()
if err != nil {
t.Fatalf("Unable to get loadbalancer: %v", err)
}
PrintLoadBalancer(t, newLB)
// Because of the time it takes to create a loadbalancer,
// this test will include some other resources.
// Listener
listener, err := CreateListener(t, client, lb)
if err != nil {
t.Fatalf("Unable to create listener: %v", err)
}
defer DeleteListener(t, client, lb.ID, listener.ID)
updateListenerOpts := listeners.UpdateOpts{
Description: "Some listener description",
}
_, err = listeners.Update(client, listener.ID, updateListenerOpts).Extract()
if err != nil {
t.Fatalf("Unable to update listener")
}
if err := WaitForLoadBalancerState(client, lb.ID, "ACTIVE", loadbalancerActiveTimeoutSeconds); err != nil {
t.Fatalf("Timed out waiting for loadbalancer to become active")
}
newListener, err := listeners.Get(client, listener.ID).Extract()
if err != nil {
t.Fatalf("Unable to get listener")
}
PrintListener(t, newListener)
// Pool
pool, err := CreatePool(t, client, lb)
if err != nil {
t.Fatalf("Unable to create pool: %v", err)
}
defer DeletePool(t, client, lb.ID, pool.ID)
updatePoolOpts := pools.UpdateOpts{
Description: "Some pool description",
}
_, err = pools.Update(client, pool.ID, updatePoolOpts).Extract()
if err != nil {
t.Fatalf("Unable to update pool")
}
if err := WaitForLoadBalancerState(client, lb.ID, "ACTIVE", loadbalancerActiveTimeoutSeconds); err != nil {
t.Fatalf("Timed out waiting for loadbalancer to become active")
}
newPool, err := pools.Get(client, pool.ID).Extract()
if err != nil {
t.Fatalf("Unable to get pool")
}
PrintPool(t, newPool)
// Member
member, err := CreateMember(t, client, lb, newPool, subnet.ID, subnet.CIDR)
if err != nil {
t.Fatalf("Unable to create member: %v", err)
}
defer DeleteMember(t, client, lb.ID, pool.ID, member.ID)
newWeight := tools.RandomInt(11, 100)
updateMemberOpts := pools.UpdateMemberOpts{
Weight: newWeight,
}
_, err = pools.UpdateMember(client, pool.ID, member.ID, updateMemberOpts).Extract()
if err != nil {
t.Fatalf("Unable to update pool")
}
if err := WaitForLoadBalancerState(client, lb.ID, "ACTIVE", loadbalancerActiveTimeoutSeconds); err != nil {
t.Fatalf("Timed out waiting for loadbalancer to become active")
}
newMember, err := pools.GetMember(client, pool.ID, member.ID).Extract()
if err != nil {
t.Fatalf("Unable to get member")
}
PrintMember(t, newMember)
// Monitor
monitor, err := CreateMonitor(t, client, lb, newPool)
if err != nil {
t.Fatalf("Unable to create monitor: %v", err)
}
defer DeleteMonitor(t, client, lb.ID, monitor.ID)
newDelay := tools.RandomInt(20, 30)
updateMonitorOpts := monitors.UpdateOpts{
Delay: newDelay,
}
_, err = monitors.Update(client, monitor.ID, updateMonitorOpts).Extract()
if err != nil {
t.Fatalf("Unable to update monitor")
}
if err := WaitForLoadBalancerState(client, lb.ID, "ACTIVE", loadbalancerActiveTimeoutSeconds); err != nil {
t.Fatalf("Timed out waiting for loadbalancer to become active")
}
newMonitor, err := monitors.Get(client, monitor.ID).Extract()
if err != nil {
t.Fatalf("Unable to get monitor")
}
PrintMonitor(t, newMonitor)
}