github.com/keshavdv/terraform@v0.7.0-rc2.0.20160711232630-d69256dcb425/builtin/providers/openstack/resource_openstack_lb_monitor_v2.go (about)

     1  package openstack
     2  
     3  import (
     4  	"fmt"
     5  	"log"
     6  	"time"
     7  
     8  	"github.com/hashicorp/terraform/helper/resource"
     9  	"github.com/hashicorp/terraform/helper/schema"
    10  
    11  	"github.com/rackspace/gophercloud"
    12  	"github.com/rackspace/gophercloud/openstack/networking/v2/extensions/lbaas_v2/monitors"
    13  )
    14  
    15  func resourceMonitorV2() *schema.Resource {
    16  	return &schema.Resource{
    17  		Create: resourceMonitorV2Create,
    18  		Read:   resourceMonitorV2Read,
    19  		Update: resourceMonitorV2Update,
    20  		Delete: resourceMonitorV2Delete,
    21  
    22  		Schema: map[string]*schema.Schema{
    23  			"region": &schema.Schema{
    24  				Type:        schema.TypeString,
    25  				Required:    true,
    26  				ForceNew:    true,
    27  				DefaultFunc: schema.EnvDefaultFunc("OS_REGION_NAME", ""),
    28  			},
    29  
    30  			"pool_id": &schema.Schema{
    31  				Type:     schema.TypeString,
    32  				Required: true,
    33  				ForceNew: true,
    34  			},
    35  
    36  			"name": &schema.Schema{
    37  				Type:     schema.TypeString,
    38  				Optional: true,
    39  			},
    40  
    41  			"tenant_id": &schema.Schema{
    42  				Type:     schema.TypeString,
    43  				Optional: true,
    44  				Computed: true,
    45  				ForceNew: true,
    46  			},
    47  
    48  			"type": &schema.Schema{
    49  				Type:     schema.TypeString,
    50  				Required: true,
    51  				ForceNew: true,
    52  			},
    53  			"delay": &schema.Schema{
    54  				Type:     schema.TypeInt,
    55  				Required: true,
    56  			},
    57  			"timeout": &schema.Schema{
    58  				Type:     schema.TypeInt,
    59  				Required: true,
    60  			},
    61  			"max_retries": &schema.Schema{
    62  				Type:     schema.TypeInt,
    63  				Required: true,
    64  			},
    65  			"url_path": &schema.Schema{
    66  				Type:     schema.TypeString,
    67  				Optional: true,
    68  				Computed: true,
    69  			},
    70  			"http_method": &schema.Schema{
    71  				Type:     schema.TypeString,
    72  				Optional: true,
    73  				Computed: true,
    74  			},
    75  			"expected_codes": &schema.Schema{
    76  				Type:     schema.TypeString,
    77  				Optional: true,
    78  				Computed: true,
    79  			},
    80  			"admin_state_up": &schema.Schema{
    81  				Type:     schema.TypeBool,
    82  				Optional: true,
    83  			},
    84  
    85  			"id": &schema.Schema{
    86  				Type:     schema.TypeString,
    87  				Optional: true,
    88  				Computed: true,
    89  			},
    90  		},
    91  	}
    92  }
    93  
    94  func resourceMonitorV2Create(d *schema.ResourceData, meta interface{}) error {
    95  	config := meta.(*Config)
    96  	networkingClient, err := config.networkingV2Client(d.Get("region").(string))
    97  	if err != nil {
    98  		return fmt.Errorf("Error creating OpenStack networking client: %s", err)
    99  	}
   100  
   101  	adminStateUp := d.Get("admin_state_up").(bool)
   102  	createOpts := monitors.CreateOpts{
   103  		PoolID:        d.Get("pool_id").(string),
   104  		TenantID:      d.Get("tenant_id").(string),
   105  		Type:          d.Get("type").(string),
   106  		Delay:         d.Get("delay").(int),
   107  		Timeout:       d.Get("timeout").(int),
   108  		MaxRetries:    d.Get("max_retries").(int),
   109  		URLPath:       d.Get("url_path").(string),
   110  		HTTPMethod:    d.Get("http_method").(string),
   111  		ExpectedCodes: d.Get("expected_codes").(string),
   112  		Name:          d.Get("name").(string),
   113  		AdminStateUp:  &adminStateUp,
   114  	}
   115  
   116  	log.Printf("[DEBUG] Create Options: %#v", createOpts)
   117  	monitor, err := monitors.Create(networkingClient, createOpts).Extract()
   118  	if err != nil {
   119  		return fmt.Errorf("Error creating OpenStack LBaaSV2 monitor: %s", err)
   120  	}
   121  	log.Printf("[INFO] monitor ID: %s", monitor.ID)
   122  
   123  	log.Printf("[DEBUG] Waiting for Openstack LBaaSV2 monitor (%s) to become available.", monitor.ID)
   124  
   125  	stateConf := &resource.StateChangeConf{
   126  		Pending:    []string{"PENDING_CREATE"},
   127  		Target:     []string{"ACTIVE"},
   128  		Refresh:    waitForMonitorActive(networkingClient, monitor.ID),
   129  		Timeout:    2 * time.Minute,
   130  		Delay:      5 * time.Second,
   131  		MinTimeout: 3 * time.Second,
   132  	}
   133  
   134  	_, err = stateConf.WaitForState()
   135  	if err != nil {
   136  		return err
   137  	}
   138  
   139  	d.SetId(monitor.ID)
   140  
   141  	return resourceMonitorV2Read(d, meta)
   142  }
   143  
   144  func resourceMonitorV2Read(d *schema.ResourceData, meta interface{}) error {
   145  	config := meta.(*Config)
   146  	networkingClient, err := config.networkingV2Client(d.Get("region").(string))
   147  	if err != nil {
   148  		return fmt.Errorf("Error creating OpenStack networking client: %s", err)
   149  	}
   150  
   151  	monitor, err := monitors.Get(networkingClient, d.Id()).Extract()
   152  	if err != nil {
   153  		return CheckDeleted(d, err, "LBV2 Monitor")
   154  	}
   155  
   156  	log.Printf("[DEBUG] Retreived OpenStack LBaaSV2 Monitor %s: %+v", d.Id(), monitor)
   157  
   158  	d.Set("id", monitor.ID)
   159  	d.Set("tenant_id", monitor.TenantID)
   160  	d.Set("type", monitor.Type)
   161  	d.Set("delay", monitor.Delay)
   162  	d.Set("timeout", monitor.Timeout)
   163  	d.Set("max_retries", monitor.MaxRetries)
   164  	d.Set("url_path", monitor.URLPath)
   165  	d.Set("http_method", monitor.HTTPMethod)
   166  	d.Set("expected_codes", monitor.ExpectedCodes)
   167  	d.Set("admin_state_up", monitor.AdminStateUp)
   168  	d.Set("name", monitor.Name)
   169  
   170  	return nil
   171  }
   172  
   173  func resourceMonitorV2Update(d *schema.ResourceData, meta interface{}) error {
   174  	config := meta.(*Config)
   175  	networkingClient, err := config.networkingV2Client(d.Get("region").(string))
   176  	if err != nil {
   177  		return fmt.Errorf("Error creating OpenStack networking client: %s", err)
   178  	}
   179  
   180  	var updateOpts monitors.UpdateOpts
   181  	if d.HasChange("url_path") {
   182  		updateOpts.URLPath = d.Get("url_path").(string)
   183  	}
   184  	if d.HasChange("expected_codes") {
   185  		updateOpts.ExpectedCodes = d.Get("expected_codes").(string)
   186  	}
   187  	if d.HasChange("delay") {
   188  		updateOpts.Delay = d.Get("delay").(int)
   189  	}
   190  	if d.HasChange("timeout") {
   191  		updateOpts.Timeout = d.Get("timeout").(int)
   192  	}
   193  	if d.HasChange("max_retries") {
   194  		updateOpts.MaxRetries = d.Get("max_retries").(int)
   195  	}
   196  	if d.HasChange("admin_state_up") {
   197  		asu := d.Get("admin_state_up").(bool)
   198  		updateOpts.AdminStateUp = &asu
   199  	}
   200  	if d.HasChange("name") {
   201  		updateOpts.Name = d.Get("name").(string)
   202  	}
   203  	if d.HasChange("http_method") {
   204  		updateOpts.HTTPMethod = d.Get("http_method").(string)
   205  	}
   206  
   207  	log.Printf("[DEBUG] Updating OpenStack LBaaSV2 Monitor %s with options: %+v", d.Id(), updateOpts)
   208  
   209  	_, err = monitors.Update(networkingClient, d.Id(), updateOpts).Extract()
   210  	if err != nil {
   211  		return fmt.Errorf("Error updating OpenStack LBaaSV2 Monitor: %s", err)
   212  	}
   213  
   214  	return resourceMonitorV2Read(d, meta)
   215  }
   216  
   217  func resourceMonitorV2Delete(d *schema.ResourceData, meta interface{}) error {
   218  	config := meta.(*Config)
   219  	networkingClient, err := config.networkingV2Client(d.Get("region").(string))
   220  	if err != nil {
   221  		return fmt.Errorf("Error creating OpenStack networking client: %s", err)
   222  	}
   223  
   224  	stateConf := &resource.StateChangeConf{
   225  		Pending:    []string{"ACTIVE", "PENDING_DELETE"},
   226  		Target:     []string{"DELETED"},
   227  		Refresh:    waitForMonitorDelete(networkingClient, d.Id()),
   228  		Timeout:    2 * time.Minute,
   229  		Delay:      5 * time.Second,
   230  		MinTimeout: 3 * time.Second,
   231  	}
   232  
   233  	_, err = stateConf.WaitForState()
   234  	if err != nil {
   235  		return fmt.Errorf("Error deleting OpenStack LBaaSV2 Monitor: %s", err)
   236  	}
   237  
   238  	d.SetId("")
   239  	return nil
   240  }
   241  
   242  func waitForMonitorActive(networkingClient *gophercloud.ServiceClient, monitorID string) resource.StateRefreshFunc {
   243  	return func() (interface{}, string, error) {
   244  		monitor, err := monitors.Get(networkingClient, monitorID).Extract()
   245  		if err != nil {
   246  			return nil, "", err
   247  		}
   248  
   249  		log.Printf("[DEBUG] OpenStack LBaaSV2 Monitor: %+v", monitor)
   250  		return monitor, "ACTIVE", nil
   251  	}
   252  }
   253  
   254  func waitForMonitorDelete(networkingClient *gophercloud.ServiceClient, monitorID string) resource.StateRefreshFunc {
   255  	return func() (interface{}, string, error) {
   256  		log.Printf("[DEBUG] Attempting to delete OpenStack LBaaSV2 Monitor %s", monitorID)
   257  
   258  		monitor, err := monitors.Get(networkingClient, monitorID).Extract()
   259  		if err != nil {
   260  			errCode, ok := err.(*gophercloud.UnexpectedResponseCodeError)
   261  			if !ok {
   262  				return monitor, "ACTIVE", err
   263  			}
   264  			if errCode.Actual == 404 {
   265  				log.Printf("[DEBUG] Successfully deleted OpenStack LBaaSV2 Monitor %s", monitorID)
   266  				return monitor, "DELETED", nil
   267  			}
   268  		}
   269  
   270  		log.Printf("[DEBUG] Openstack LBaaSV2 Monitor: %+v", monitor)
   271  		err = monitors.Delete(networkingClient, monitorID).ExtractErr()
   272  		if err != nil {
   273  			errCode, ok := err.(*gophercloud.UnexpectedResponseCodeError)
   274  			if !ok {
   275  				return monitor, "ACTIVE", err
   276  			}
   277  			if errCode.Actual == 404 {
   278  				log.Printf("[DEBUG] Successfully deleted OpenStack LBaaSV2 Monitor %s", monitorID)
   279  				return monitor, "DELETED", nil
   280  			}
   281  		}
   282  
   283  		log.Printf("[DEBUG] OpenStack LBaaSV2 Monitor %s still active.", monitorID)
   284  		return monitor, "ACTIVE", nil
   285  	}
   286  }