// CreateLoadBalancer will create a load balancer with a random name on a given
// subnet. An error will be returned if the loadbalancer could not be created.
func CreateLoadBalancer(t *testing.T, client *gophercloud.ServiceClient, subnetID string) (*loadbalancers.LoadBalancer, error) {
lbName := tools.RandomString("TESTACCT-", 8)
t.Logf("Attempting to create loadbalancer %s on subnet %s", lbName, subnetID)
createOpts := loadbalancers.CreateOpts{
Name: lbName,
VipSubnetID: subnetID,
AdminStateUp: gophercloud.Enabled,
}
lb, err := loadbalancers.Create(client, createOpts).Extract()
if err != nil {
return lb, err
}
t.Logf("Successfully created loadbalancer %s on subnet %s", lbName, subnetID)
t.Logf("Waiting for loadbalancer %s to become active", lbName)
if err := WaitForLoadBalancerState(client, lb.ID, "ACTIVE", loadbalancerActiveTimeoutSeconds); err != nil {
return lb, err
}
t.Logf("LoadBalancer %s is active", lbName)
return lb, nil
}
func TestRequiredCreateOpts(t *testing.T) {
res := loadbalancers.Create(fake.ServiceClient(), loadbalancers.CreateOpts{})
if res.Err == nil {
t.Fatalf("Expected error, got none")
}
res = loadbalancers.Create(fake.ServiceClient(), loadbalancers.CreateOpts{Name: "foo"})
if res.Err == nil {
t.Fatalf("Expected error, got none")
}
res = loadbalancers.Create(fake.ServiceClient(), loadbalancers.CreateOpts{Name: "foo", Description: "bar"})
if res.Err == nil {
t.Fatalf("Expected error, got none")
}
res = loadbalancers.Create(fake.ServiceClient(), loadbalancers.CreateOpts{Name: "foo", Description: "bar", VipAddress: "bar"})
if res.Err == nil {
t.Fatalf("Expected error, got none")
}
}
func resourceLoadBalancerV2Create(d *schema.ResourceData, meta interface{}) error {
config := meta.(*Config)
networkingClient, err := config.networkingV2Client(GetRegion(d))
if err != nil {
return fmt.Errorf("Error creating OpenStack networking client: %s", err)
}
adminStateUp := d.Get("admin_state_up").(bool)
createOpts := loadbalancers.CreateOpts{
Name: d.Get("name").(string),
Description: d.Get("description").(string),
VipSubnetID: d.Get("vip_subnet_id").(string),
TenantID: d.Get("tenant_id").(string),
VipAddress: d.Get("vip_address").(string),
AdminStateUp: &adminStateUp,
Flavor: d.Get("flavor").(string),
Provider: d.Get("provider").(string),
}
log.Printf("[DEBUG] Create Options: %#v", createOpts)
lb, err := loadbalancers.Create(networkingClient, createOpts).Extract()
if err != nil {
return fmt.Errorf("Error creating OpenStack LoadBalancer: %s", err)
}
log.Printf("[INFO] LoadBalancer ID: %s", lb.ID)
log.Printf("[DEBUG] Waiting for Openstack LoadBalancer (%s) to become available.", lb.ID)
stateConf := &resource.StateChangeConf{
Pending: []string{"PENDING_CREATE"},
Target: []string{"ACTIVE"},
Refresh: waitForLoadBalancerActive(networkingClient, lb.ID),
Timeout: 20 * time.Minute,
Delay: 5 * time.Second,
MinTimeout: 3 * time.Second,
}
_, err = stateConf.WaitForState()
if err != nil {
return err
}
// Once the loadbalancer has been created, apply any requested security groups
// to the port that was created behind the scenes.
if err := resourceLoadBalancerV2SecurityGroups(networkingClient, lb.VipPortID, d); err != nil {
return err
}
// If all has been successful, set the ID on the resource
d.SetId(lb.ID)
return resourceLoadBalancerV2Read(d, meta)
}
func TestCreateLoadbalancer(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleLoadbalancerCreationSuccessfully(t, SingleLoadbalancerBody)
actual, err := loadbalancers.Create(fake.ServiceClient(), loadbalancers.CreateOpts{
Name: "db_lb",
AdminStateUp: gophercloud.Enabled,
VipSubnetID: "9cedb85d-0759-4898-8a4b-fa5a5ea10086",
VipAddress: "10.30.176.48",
Flavor: "medium",
Provider: "haproxy",
}).Extract()
th.AssertNoErr(t, err)
th.CheckDeepEquals(t, LoadbalancerDb, *actual)
}