// CreatePool will create a pool with a random name. An error will be returned // if the pool could not be deleted. func CreatePool(t *testing.T, client *gophercloud.ServiceClient, subnetID string) (*pools.Pool, error) { poolName := tools.RandomString("TESTACCT-", 8) t.Logf("Attempting to create pool %s", poolName) createOpts := pools.CreateOpts{ Name: poolName, SubnetID: subnetID, Protocol: pools.ProtocolTCP, LBMethod: pools.LBMethodRoundRobin, } pool, err := pools.Create(client, createOpts).Extract() if err != nil { return pool, err } t.Logf("Successfully created pool %s", poolName) return pool, nil }
func resourceLBPoolV1Create(d *schema.ResourceData, meta interface{}) error { config := meta.(*Config) networkingClient, err := config.networkingV2Client(d.Get("region").(string)) if err != nil { return fmt.Errorf("Error creating OpenStack networking client: %s", err) } createOpts := pools.CreateOpts{ Name: d.Get("name").(string), SubnetID: d.Get("subnet_id").(string), TenantID: d.Get("tenant_id").(string), Provider: d.Get("lb_provider").(string), } if v, ok := d.GetOk("protocol"); ok { protocol := resourceLBPoolV1DetermineProtocol(v.(string)) createOpts.Protocol = protocol } if v, ok := d.GetOk("lb_method"); ok { lbMethod := resourceLBPoolV1DetermineLBMethod(v.(string)) createOpts.LBMethod = lbMethod } log.Printf("[DEBUG] Create Options: %#v", createOpts) p, err := pools.Create(networkingClient, createOpts).Extract() if err != nil { return fmt.Errorf("Error creating OpenStack LB pool: %s", err) } log.Printf("[INFO] LB Pool ID: %s", p.ID) log.Printf("[DEBUG] Waiting for OpenStack LB pool (%s) to become available.", p.ID) stateConf := &resource.StateChangeConf{ Pending: []string{"PENDING_CREATE"}, Target: []string{"ACTIVE"}, Refresh: waitForLBPoolActive(networkingClient, p.ID), Timeout: 2 * time.Minute, Delay: 5 * time.Second, MinTimeout: 3 * time.Second, } _, err = stateConf.WaitForState() if err != nil { return err } d.SetId(p.ID) if mIDs := resourcePoolMonitorIDsV1(d); mIDs != nil { for _, mID := range mIDs { _, err := pools.AssociateMonitor(networkingClient, p.ID, mID).Extract() if err != nil { return fmt.Errorf("Error associating monitor (%s) with OpenStack LB pool (%s): %s", mID, p.ID, err) } } } if memberOpts := resourcePoolMembersV1(d); memberOpts != nil { for _, memberOpt := range memberOpts { _, err := members.Create(networkingClient, memberOpt).Extract() if err != nil { return fmt.Errorf("Error creating OpenStack LB member: %s", err) } } } return resourceLBPoolV1Read(d, meta) }
func TestCreate(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() th.Mux.HandleFunc("/v2.0/lb/pools", func(w http.ResponseWriter, r *http.Request) { th.TestMethod(t, r, "POST") th.TestHeader(t, r, "X-Auth-Token", fake.TokenID) th.TestHeader(t, r, "Content-Type", "application/json") th.TestHeader(t, r, "Accept", "application/json") th.TestJSONRequest(t, r, ` { "pool": { "lb_method": "ROUND_ROBIN", "protocol": "HTTP", "name": "Example pool", "subnet_id": "1981f108-3c48-48d2-b908-30f7d28532c9", "tenant_id": "2ffc6e22aae24e4795f87155d24c896f", "provider": "haproxy" } } `) w.Header().Add("Content-Type", "application/json") w.WriteHeader(http.StatusCreated) fmt.Fprintf(w, ` { "pool": { "status": "PENDING_CREATE", "lb_method": "ROUND_ROBIN", "protocol": "HTTP", "description": "", "health_monitors": [], "members": [], "status_description": null, "id": "69055154-f603-4a28-8951-7cc2d9e54a9a", "vip_id": null, "name": "Example pool", "admin_state_up": true, "subnet_id": "1981f108-3c48-48d2-b908-30f7d28532c9", "tenant_id": "2ffc6e22aae24e4795f87155d24c896f", "health_monitors_status": [], "provider": "haproxy" } } `) }) options := pools.CreateOpts{ LBMethod: pools.LBMethodRoundRobin, Protocol: "HTTP", Name: "Example pool", SubnetID: "1981f108-3c48-48d2-b908-30f7d28532c9", TenantID: "2ffc6e22aae24e4795f87155d24c896f", Provider: "haproxy", } p, err := pools.Create(fake.ServiceClient(), options).Extract() th.AssertNoErr(t, err) th.AssertEquals(t, "PENDING_CREATE", p.Status) th.AssertEquals(t, "ROUND_ROBIN", p.LBMethod) th.AssertEquals(t, "HTTP", p.Protocol) th.AssertEquals(t, "", p.Description) th.AssertDeepEquals(t, []string{}, p.MonitorIDs) th.AssertDeepEquals(t, []string{}, p.MemberIDs) th.AssertEquals(t, "69055154-f603-4a28-8951-7cc2d9e54a9a", p.ID) th.AssertEquals(t, "Example pool", p.Name) th.AssertEquals(t, "1981f108-3c48-48d2-b908-30f7d28532c9", p.SubnetID) th.AssertEquals(t, "2ffc6e22aae24e4795f87155d24c896f", p.TenantID) th.AssertEquals(t, "haproxy", p.Provider) }
// Create load balancer func (os *OpenStack) CreateLoadBalancer(loadBalancer *provider.LoadBalancer, affinity string) (string, error) { if len(loadBalancer.ExternalIPs) > 1 { return "", fmt.Errorf("multiple floatingips are not yet supported by openstack") } servicePort := 0 for _, p := range loadBalancer.Hosts { if servicePort == 0 { servicePort = int(p.ServicePort) } else if int(p.ServicePort) != servicePort { return "", fmt.Errorf("multiple ports are not yet supported in openstack load balancers") } } var persistence *vips.SessionPersistence switch affinity { case ServiceAffinityNone: persistence = nil case ServiceAffinityClientIP: persistence = &vips.SessionPersistence{Type: "SOURCE_IP"} default: return "", fmt.Errorf("unsupported load balancer affinity: %v", affinity) } glog.V(2).Info("Checking if openstack load balancer already exists: ", loadBalancer.Name) _, err := os.getPoolByName(loadBalancer.Name) if err != nil && err != ErrNotFound { return "", fmt.Errorf("error checking if openstack load balancer already exists: %v", err) } if err == nil { err := os.DeleteLoadBalancer(loadBalancer.Name) if err != nil { return "", fmt.Errorf("error deleting existing openstack load balancer: %v", err) } } lbmethod := pools.LBMethodRoundRobin if os.lbOpts.LBMethod != "" { lbmethod = pools.LBMethod(os.lbOpts.LBMethod) } pool, err := pools.Create(os.network, pools.CreateOpts{ Name: loadBalancer.Name, Protocol: pools.ProtocolTCP, SubnetID: loadBalancer.Subnets[0].Uid, LBMethod: lbmethod, TenantID: loadBalancer.TenantID, }).Extract() if err != nil { return "", err } for _, host := range loadBalancer.Hosts { _, err = members.Create(os.network, members.CreateOpts{ PoolID: pool.ID, ProtocolPort: int(host.TargetPort), Address: host.Ipaddress, TenantID: loadBalancer.TenantID, }).Extract() if err != nil { pools.Delete(os.network, pool.ID) return "", err } } var mon *monitors.Monitor if os.lbOpts.CreateMonitor { mon, err = monitors.Create(os.network, monitors.CreateOpts{ Type: monitors.TypeTCP, TenantID: loadBalancer.TenantID, Delay: int(os.lbOpts.MonitorDelay.Duration.Seconds()), Timeout: int(os.lbOpts.MonitorTimeout.Duration.Seconds()), MaxRetries: int(os.lbOpts.MonitorMaxRetries), }).Extract() if err != nil { pools.Delete(os.network, pool.ID) return "", err } _, err = pools.AssociateMonitor(os.network, pool.ID, mon.ID).Extract() if err != nil { monitors.Delete(os.network, mon.ID) pools.Delete(os.network, pool.ID) return "", err } } createOpts := vips.CreateOpts{ Name: loadBalancer.Name, Description: fmt.Sprintf("Kubernetes service %s", loadBalancer.Name), Protocol: "TCP", ProtocolPort: servicePort, PoolID: pool.ID, SubnetID: loadBalancer.Subnets[0].Uid, Persistence: persistence, TenantID: loadBalancer.TenantID, } //if loadBalancer.Vip != "" { // createOpts.Address = loadBalancer.Vip //} vip, err := vips.Create(os.network, createOpts).Extract() if err != nil { if mon != nil { monitors.Delete(os.network, mon.ID) } pools.Delete(os.network, pool.ID) return "", err } // bind external ip if len(loadBalancer.ExternalIPs) > 0 { err := os.BindPortToFloatingip(vip.PortID, loadBalancer.ExternalIPs[0], vip.TenantID) if err != nil { vips.Delete(os.network, vip.ID) if mon != nil { monitors.Delete(os.network, mon.ID) } pools.Delete(os.network, pool.ID) return "", err } } return vip.Address, nil }