github.com/wangzhucn/terraform@v0.6.7-0.20151109233120-4eea011b56b3/builtin/providers/openstack/resource_openstack_lb_monitor_v1.go (about)

     1  package openstack
     2  
     3  import (
     4  	"fmt"
     5  	"log"
     6  	"strconv"
     7  
     8  	"github.com/hashicorp/terraform/helper/schema"
     9  	"github.com/rackspace/gophercloud/openstack/networking/v2/extensions/lbaas/monitors"
    10  )
    11  
    12  func resourceLBMonitorV1() *schema.Resource {
    13  	return &schema.Resource{
    14  		Create: resourceLBMonitorV1Create,
    15  		Read:   resourceLBMonitorV1Read,
    16  		Update: resourceLBMonitorV1Update,
    17  		Delete: resourceLBMonitorV1Delete,
    18  
    19  		Schema: map[string]*schema.Schema{
    20  			"region": &schema.Schema{
    21  				Type:        schema.TypeString,
    22  				Required:    true,
    23  				ForceNew:    true,
    24  				DefaultFunc: envDefaultFuncAllowMissing("OS_REGION_NAME"),
    25  			},
    26  			"tenant_id": &schema.Schema{
    27  				Type:     schema.TypeString,
    28  				Optional: true,
    29  				ForceNew: true,
    30  				Computed: true,
    31  			},
    32  			"type": &schema.Schema{
    33  				Type:     schema.TypeString,
    34  				Required: true,
    35  				ForceNew: true,
    36  			},
    37  			"delay": &schema.Schema{
    38  				Type:     schema.TypeInt,
    39  				Required: true,
    40  				ForceNew: false,
    41  			},
    42  			"timeout": &schema.Schema{
    43  				Type:     schema.TypeInt,
    44  				Required: true,
    45  				ForceNew: false,
    46  			},
    47  			"max_retries": &schema.Schema{
    48  				Type:     schema.TypeInt,
    49  				Required: true,
    50  				ForceNew: false,
    51  			},
    52  			"url_path": &schema.Schema{
    53  				Type:     schema.TypeString,
    54  				Optional: true,
    55  				ForceNew: false,
    56  			},
    57  			"http_method": &schema.Schema{
    58  				Type:     schema.TypeString,
    59  				Optional: true,
    60  				ForceNew: false,
    61  			},
    62  			"expected_codes": &schema.Schema{
    63  				Type:     schema.TypeString,
    64  				Optional: true,
    65  				ForceNew: false,
    66  			},
    67  			"admin_state_up": &schema.Schema{
    68  				Type:     schema.TypeString,
    69  				Optional: true,
    70  				ForceNew: false,
    71  				Computed: true,
    72  			},
    73  		},
    74  	}
    75  }
    76  
    77  func resourceLBMonitorV1Create(d *schema.ResourceData, meta interface{}) error {
    78  	config := meta.(*Config)
    79  	networkingClient, err := config.networkingV2Client(d.Get("region").(string))
    80  	if err != nil {
    81  		return fmt.Errorf("Error creating OpenStack networking client: %s", err)
    82  	}
    83  
    84  	createOpts := monitors.CreateOpts{
    85  		TenantID:      d.Get("tenant_id").(string),
    86  		Type:          d.Get("type").(string),
    87  		Delay:         d.Get("delay").(int),
    88  		Timeout:       d.Get("timeout").(int),
    89  		MaxRetries:    d.Get("max_retries").(int),
    90  		URLPath:       d.Get("url_path").(string),
    91  		ExpectedCodes: d.Get("expected_codes").(string),
    92  		HTTPMethod:    d.Get("http_method").(string),
    93  	}
    94  
    95  	asuRaw := d.Get("admin_state_up").(string)
    96  	if asuRaw != "" {
    97  		asu, err := strconv.ParseBool(asuRaw)
    98  		if err != nil {
    99  			return fmt.Errorf("admin_state_up, if provided, must be either 'true' or 'false'")
   100  		}
   101  		createOpts.AdminStateUp = &asu
   102  	}
   103  
   104  	log.Printf("[DEBUG] Create Options: %#v", createOpts)
   105  	m, err := monitors.Create(networkingClient, createOpts).Extract()
   106  	if err != nil {
   107  		return fmt.Errorf("Error creating OpenStack LB Monitor: %s", err)
   108  	}
   109  	log.Printf("[INFO] LB Monitor ID: %s", m.ID)
   110  
   111  	d.SetId(m.ID)
   112  
   113  	return resourceLBMonitorV1Read(d, meta)
   114  }
   115  
   116  func resourceLBMonitorV1Read(d *schema.ResourceData, meta interface{}) error {
   117  	config := meta.(*Config)
   118  	networkingClient, err := config.networkingV2Client(d.Get("region").(string))
   119  	if err != nil {
   120  		return fmt.Errorf("Error creating OpenStack networking client: %s", err)
   121  	}
   122  
   123  	m, err := monitors.Get(networkingClient, d.Id()).Extract()
   124  	if err != nil {
   125  		return CheckDeleted(d, err, "LB monitor")
   126  	}
   127  
   128  	log.Printf("[DEBUG] Retreived OpenStack LB Monitor %s: %+v", d.Id(), m)
   129  
   130  	d.Set("type", m.Type)
   131  	d.Set("delay", m.Delay)
   132  	d.Set("timeout", m.Timeout)
   133  	d.Set("max_retries", m.MaxRetries)
   134  	d.Set("tenant_id", m.TenantID)
   135  	d.Set("url_path", m.URLPath)
   136  	d.Set("http_method", m.HTTPMethod)
   137  	d.Set("expected_codes", m.ExpectedCodes)
   138  	d.Set("admin_state_up", strconv.FormatBool(m.AdminStateUp))
   139  
   140  	return nil
   141  }
   142  
   143  func resourceLBMonitorV1Update(d *schema.ResourceData, meta interface{}) error {
   144  	config := meta.(*Config)
   145  	networkingClient, err := config.networkingV2Client(d.Get("region").(string))
   146  	if err != nil {
   147  		return fmt.Errorf("Error creating OpenStack networking client: %s", err)
   148  	}
   149  
   150  	updateOpts := monitors.UpdateOpts{
   151  		Delay:         d.Get("delay").(int),
   152  		Timeout:       d.Get("timeout").(int),
   153  		MaxRetries:    d.Get("max_retries").(int),
   154  		URLPath:       d.Get("url_path").(string),
   155  		HTTPMethod:    d.Get("http_method").(string),
   156  		ExpectedCodes: d.Get("expected_codes").(string),
   157  	}
   158  
   159  	if d.HasChange("admin_state_up") {
   160  		asuRaw := d.Get("admin_state_up").(string)
   161  		if asuRaw != "" {
   162  			asu, err := strconv.ParseBool(asuRaw)
   163  			if err != nil {
   164  				return fmt.Errorf("admin_state_up, if provided, must be either 'true' or 'false'")
   165  			}
   166  			updateOpts.AdminStateUp = &asu
   167  		}
   168  	}
   169  
   170  	log.Printf("[DEBUG] Updating OpenStack LB Monitor %s with options: %+v", d.Id(), updateOpts)
   171  
   172  	_, err = monitors.Update(networkingClient, d.Id(), updateOpts).Extract()
   173  	if err != nil {
   174  		return fmt.Errorf("Error updating OpenStack LB Monitor: %s", err)
   175  	}
   176  
   177  	return resourceLBMonitorV1Read(d, meta)
   178  }
   179  
   180  func resourceLBMonitorV1Delete(d *schema.ResourceData, meta interface{}) error {
   181  	config := meta.(*Config)
   182  	networkingClient, err := config.networkingV2Client(d.Get("region").(string))
   183  	if err != nil {
   184  		return fmt.Errorf("Error creating OpenStack networking client: %s", err)
   185  	}
   186  
   187  	err = monitors.Delete(networkingClient, d.Id()).ExtractErr()
   188  	if err != nil {
   189  		return fmt.Errorf("Error deleting OpenStack LB Monitor: %s", err)
   190  	}
   191  
   192  	d.SetId("")
   193  	return nil
   194  }