// 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
}
func resourceListenerV2Create(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)
}
adminStateUp := d.Get("admin_state_up").(bool)
connLimit := d.Get("connection_limit").(int)
var sniContainerRefs []string
if raw, ok := d.GetOk("sni_container_refs"); ok {
for _, v := range raw.([]interface{}) {
sniContainerRefs = append(sniContainerRefs, v.(string))
}
}
createOpts := listeners.CreateOpts{
Protocol: listeners.Protocol(d.Get("protocol").(string)),
ProtocolPort: d.Get("protocol_port").(int),
TenantID: d.Get("tenant_id").(string),
LoadbalancerID: d.Get("loadbalancer_id").(string),
Name: d.Get("name").(string),
DefaultPoolID: d.Get("default_pool_id").(string),
Description: d.Get("description").(string),
ConnLimit: &connLimit,
DefaultTlsContainerRef: d.Get("default_tls_container_ref").(string),
SniContainerRefs: sniContainerRefs,
AdminStateUp: &adminStateUp,
}
log.Printf("[DEBUG] Create Options: %#v", createOpts)
listener, err := listeners.Create(networkingClient, createOpts).Extract()
if err != nil {
return fmt.Errorf("Error creating OpenStack LBaaSV2 listener: %s", err)
}
log.Printf("[INFO] Listener ID: %s", listener.ID)
log.Printf("[DEBUG] Waiting for Openstack LBaaSV2 listener (%s) to become available.", listener.ID)
stateConf := &resource.StateChangeConf{
Pending: []string{"PENDING_CREATE"},
Target: []string{"ACTIVE"},
Refresh: waitForListenerActive(networkingClient, listener.ID),
Timeout: 2 * time.Minute,
Delay: 5 * time.Second,
MinTimeout: 3 * time.Second,
}
_, err = stateConf.WaitForState()
if err != nil {
return err
}
d.SetId(listener.ID)
return resourceListenerV2Read(d, meta)
}
func TestRequiredCreateOpts(t *testing.T) {
res := listeners.Create(fake.ServiceClient(), listeners.CreateOpts{})
if res.Err == nil {
t.Fatalf("Expected error, got none")
}
res = listeners.Create(fake.ServiceClient(), listeners.CreateOpts{Name: "foo"})
if res.Err == nil {
t.Fatalf("Expected error, got none")
}
res = listeners.Create(fake.ServiceClient(), listeners.CreateOpts{Name: "foo", TenantID: "bar"})
if res.Err == nil {
t.Fatalf("Expected error, got none")
}
res = listeners.Create(fake.ServiceClient(), listeners.CreateOpts{Name: "foo", TenantID: "bar", Protocol: "bar"})
if res.Err == nil {
t.Fatalf("Expected error, got none")
}
res = listeners.Create(fake.ServiceClient(), listeners.CreateOpts{Name: "foo", TenantID: "bar", Protocol: "bar", ProtocolPort: 80})
if res.Err == nil {
t.Fatalf("Expected error, got none")
}
}
func TestCreateListener(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleListenerCreationSuccessfully(t, SingleListenerBody)
actual, err := listeners.Create(fake.ServiceClient(), listeners.CreateOpts{
Protocol: "TCP",
Name: "db",
LoadbalancerID: "79e05663-7f03-45d2-a092-8b94062f22ab",
AdminStateUp: gophercloud.Enabled,
DefaultTlsContainerRef: "2c433435-20de-4411-84ae-9cc8917def76",
DefaultPoolID: "41efe233-7591-43c5-9cf7-923964759f9e",
ProtocolPort: 3306,
}).Extract()
th.AssertNoErr(t, err)
th.CheckDeepEquals(t, ListenerDb, *actual)
}