func TestRequiredCreateOpts(t *testing.T) {
res := monitors.Create(fake.ServiceClient(), monitors.CreateOpts{})
if res.Err == nil {
t.Fatalf("Expected error, got none")
}
res = monitors.Create(fake.ServiceClient(), monitors.CreateOpts{Type: monitors.TypeHTTP})
if res.Err == nil {
t.Fatalf("Expected error, got none")
}
}
// CreateMonitor will create a monitor with a random name for a specific pool.
// An error will be returned if the monitor could not be created.
func CreateMonitor(t *testing.T, client *gophercloud.ServiceClient, lb *loadbalancers.LoadBalancer, pool *pools.Pool) (*monitors.Monitor, error) {
monitorName := tools.RandomString("TESTACCT-", 8)
t.Logf("Attempting to create monitor %s", monitorName)
createOpts := monitors.CreateOpts{
PoolID: pool.ID,
Name: monitorName,
Delay: 10,
Timeout: 5,
MaxRetries: 5,
Type: "PING",
}
monitor, err := monitors.Create(client, createOpts).Extract()
if err != nil {
return monitor, err
}
t.Logf("Successfully created monitor: %s", monitorName)
if err := WaitForLoadBalancerState(client, lb.ID, "ACTIVE", loadbalancerActiveTimeoutSeconds); err != nil {
return monitor, fmt.Errorf("Timed out waiting for loadbalancer to become active")
}
return monitor, nil
}
func resourceMonitorV2Create(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 := monitors.CreateOpts{
PoolID: d.Get("pool_id").(string),
TenantID: d.Get("tenant_id").(string),
Type: d.Get("type").(string),
Delay: d.Get("delay").(int),
Timeout: d.Get("timeout").(int),
MaxRetries: d.Get("max_retries").(int),
URLPath: d.Get("url_path").(string),
HTTPMethod: d.Get("http_method").(string),
ExpectedCodes: d.Get("expected_codes").(string),
Name: d.Get("name").(string),
AdminStateUp: &adminStateUp,
}
log.Printf("[DEBUG] Create Options: %#v", createOpts)
monitor, err := monitors.Create(networkingClient, createOpts).Extract()
if err != nil {
return fmt.Errorf("Error creating OpenStack LBaaSV2 monitor: %s", err)
}
log.Printf("[INFO] monitor ID: %s", monitor.ID)
log.Printf("[DEBUG] Waiting for Openstack LBaaSV2 monitor (%s) to become available.", monitor.ID)
stateConf := &resource.StateChangeConf{
Pending: []string{"PENDING_CREATE"},
Target: []string{"ACTIVE"},
Refresh: waitForMonitorActive(networkingClient, monitor.ID),
Timeout: 2 * time.Minute,
Delay: 5 * time.Second,
MinTimeout: 3 * time.Second,
}
_, err = stateConf.WaitForState()
if err != nil {
return err
}
d.SetId(monitor.ID)
return resourceMonitorV2Read(d, meta)
}
func TestCreateHealthmonitor(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleHealthmonitorCreationSuccessfully(t, SingleHealthmonitorBody)
actual, err := monitors.Create(fake.ServiceClient(), monitors.CreateOpts{
Type: "HTTP",
Name: "db",
PoolID: "84f1b61f-58c4-45bf-a8a9-2dafb9e5214d",
TenantID: "453105b9-1754-413f-aab1-55f1af620750",
Delay: 20,
Timeout: 10,
MaxRetries: 5,
URLPath: "/check",
ExpectedCodes: "200-299",
}).Extract()
th.AssertNoErr(t, err)
th.CheckDeepEquals(t, HealthmonitorDb, *actual)
}
func TestDelayMustBeGreaterOrEqualThanTimeout(t *testing.T) {
_, err := monitors.Create(fake.ServiceClient(), monitors.CreateOpts{
Type: "HTTP",
PoolID: "d459f7d8-c6ee-439d-8713-d3fc08aeed8d",
Delay: 1,
Timeout: 10,
MaxRetries: 5,
URLPath: "/check",
ExpectedCodes: "200-299",
}).Extract()
if err == nil {
t.Fatalf("Expected error, got none")
}
_, err = monitors.Update(fake.ServiceClient(), "453105b9-1754-413f-aab1-55f1af620750", monitors.UpdateOpts{
Delay: 1,
Timeout: 10,
}).Extract()
if err == nil {
t.Fatalf("Expected error, got none")
}
}