github.com/tarrant/terraform@v0.3.8-0.20150402012457-f68c9eee638e/builtin/providers/openstack/resource_openstack_lb_vip_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"
    10  	"github.com/rackspace/gophercloud/openstack/networking/v2/extensions/lbaas/vips"
    11  )
    12  
    13  func resourceLBVipV1() *schema.Resource {
    14  	return &schema.Resource{
    15  		Create: resourceLBVipV1Create,
    16  		Read:   resourceLBVipV1Read,
    17  		Update: resourceLBVipV1Update,
    18  		Delete: resourceLBVipV1Delete,
    19  
    20  		Schema: map[string]*schema.Schema{
    21  			"region": &schema.Schema{
    22  				Type:        schema.TypeString,
    23  				Required:    true,
    24  				ForceNew:    true,
    25  				DefaultFunc: envDefaultFunc("OS_REGION_NAME"),
    26  			},
    27  			"name": &schema.Schema{
    28  				Type:     schema.TypeString,
    29  				Required: true,
    30  				ForceNew: false,
    31  			},
    32  			"subnet_id": &schema.Schema{
    33  				Type:     schema.TypeString,
    34  				Required: true,
    35  				ForceNew: true,
    36  			},
    37  			"protocol": &schema.Schema{
    38  				Type:     schema.TypeString,
    39  				Required: true,
    40  				ForceNew: true,
    41  			},
    42  			"port": &schema.Schema{
    43  				Type:     schema.TypeInt,
    44  				Required: true,
    45  				ForceNew: true,
    46  			},
    47  			"pool_id": &schema.Schema{
    48  				Type:     schema.TypeString,
    49  				Required: true,
    50  				ForceNew: false,
    51  			},
    52  			"tenant_id": &schema.Schema{
    53  				Type:     schema.TypeString,
    54  				Optional: true,
    55  				ForceNew: true,
    56  			},
    57  			"address": &schema.Schema{
    58  				Type:     schema.TypeString,
    59  				Optional: true,
    60  				ForceNew: true,
    61  			},
    62  			"description": &schema.Schema{
    63  				Type:     schema.TypeString,
    64  				Optional: true,
    65  				ForceNew: false,
    66  			},
    67  			"persistence": &schema.Schema{
    68  				Type:     schema.TypeMap,
    69  				Optional: true,
    70  				ForceNew: false,
    71  			},
    72  			"conn_limit": &schema.Schema{
    73  				Type:     schema.TypeInt,
    74  				Optional: true,
    75  				ForceNew: false,
    76  			},
    77  			"admin_state_up": &schema.Schema{
    78  				Type:     schema.TypeString,
    79  				Optional: true,
    80  				ForceNew: false,
    81  			},
    82  		},
    83  	}
    84  }
    85  
    86  func resourceLBVipV1Create(d *schema.ResourceData, meta interface{}) error {
    87  	config := meta.(*Config)
    88  	networkingClient, err := config.networkingV2Client(d.Get("region").(string))
    89  	if err != nil {
    90  		return fmt.Errorf("Error creating OpenStack networking client: %s", err)
    91  	}
    92  
    93  	createOpts := vips.CreateOpts{
    94  		Name:         d.Get("name").(string),
    95  		SubnetID:     d.Get("subnet_id").(string),
    96  		Protocol:     d.Get("protocol").(string),
    97  		ProtocolPort: d.Get("port").(int),
    98  		PoolID:       d.Get("pool_id").(string),
    99  		TenantID:     d.Get("tenant_id").(string),
   100  		Address:      d.Get("address").(string),
   101  		Description:  d.Get("description").(string),
   102  		Persistence:  resourceVipPersistenceV1(d),
   103  		ConnLimit:    gophercloud.MaybeInt(d.Get("conn_limit").(int)),
   104  	}
   105  
   106  	asuRaw := d.Get("admin_state_up").(string)
   107  	if asuRaw != "" {
   108  		asu, err := strconv.ParseBool(asuRaw)
   109  		if err != nil {
   110  			return fmt.Errorf("admin_state_up, if provided, must be either 'true' or 'false'")
   111  		}
   112  		createOpts.AdminStateUp = &asu
   113  	}
   114  
   115  	log.Printf("[DEBUG] Create Options: %#v", createOpts)
   116  	p, err := vips.Create(networkingClient, createOpts).Extract()
   117  	if err != nil {
   118  		return fmt.Errorf("Error creating OpenStack LB VIP: %s", err)
   119  	}
   120  	log.Printf("[INFO] LB VIP ID: %s", p.ID)
   121  
   122  	d.SetId(p.ID)
   123  
   124  	return resourceLBVipV1Read(d, meta)
   125  }
   126  
   127  func resourceLBVipV1Read(d *schema.ResourceData, meta interface{}) error {
   128  	config := meta.(*Config)
   129  	networkingClient, err := config.networkingV2Client(d.Get("region").(string))
   130  	if err != nil {
   131  		return fmt.Errorf("Error creating OpenStack networking client: %s", err)
   132  	}
   133  
   134  	p, err := vips.Get(networkingClient, d.Id()).Extract()
   135  	if err != nil {
   136  		return CheckDeleted(d, err, "LB VIP")
   137  	}
   138  
   139  	log.Printf("[DEBUG] Retreived OpenStack LB VIP %s: %+v", d.Id(), p)
   140  
   141  	d.Set("name", p.Name)
   142  	d.Set("subnet_id", p.SubnetID)
   143  	d.Set("protocol", p.Protocol)
   144  	d.Set("port", p.ProtocolPort)
   145  	d.Set("pool_id", p.PoolID)
   146  
   147  	if t, exists := d.GetOk("tenant_id"); exists && t != "" {
   148  		d.Set("tenant_id", p.TenantID)
   149  	} else {
   150  		d.Set("tenant_id", "")
   151  	}
   152  
   153  	if t, exists := d.GetOk("address"); exists && t != "" {
   154  		d.Set("address", p.Address)
   155  	} else {
   156  		d.Set("address", "")
   157  	}
   158  
   159  	if t, exists := d.GetOk("description"); exists && t != "" {
   160  		d.Set("description", p.Description)
   161  	} else {
   162  		d.Set("description", "")
   163  	}
   164  
   165  	if t, exists := d.GetOk("persistence"); exists && t != "" {
   166  		d.Set("persistence", p.Description)
   167  	}
   168  
   169  	if t, exists := d.GetOk("conn_limit"); exists && t != "" {
   170  		d.Set("conn_limit", p.ConnLimit)
   171  	} else {
   172  		d.Set("conn_limit", "")
   173  	}
   174  
   175  	if t, exists := d.GetOk("admin_state_up"); exists && t != "" {
   176  		d.Set("admin_state_up", strconv.FormatBool(p.AdminStateUp))
   177  	} else {
   178  		d.Set("admin_state_up", "")
   179  	}
   180  
   181  	return nil
   182  }
   183  
   184  func resourceLBVipV1Update(d *schema.ResourceData, meta interface{}) error {
   185  	config := meta.(*Config)
   186  	networkingClient, err := config.networkingV2Client(d.Get("region").(string))
   187  	if err != nil {
   188  		return fmt.Errorf("Error creating OpenStack networking client: %s", err)
   189  	}
   190  
   191  	var updateOpts vips.UpdateOpts
   192  	if d.HasChange("name") {
   193  		updateOpts.Name = d.Get("name").(string)
   194  	}
   195  	if d.HasChange("pool_id") {
   196  		updateOpts.PoolID = d.Get("pool_id").(string)
   197  	}
   198  	if d.HasChange("description") {
   199  		updateOpts.Description = d.Get("description").(string)
   200  	}
   201  	if d.HasChange("persistence") {
   202  		updateOpts.Persistence = resourceVipPersistenceV1(d)
   203  	}
   204  	if d.HasChange("conn_limit") {
   205  		updateOpts.ConnLimit = gophercloud.MaybeInt(d.Get("conn_limit").(int))
   206  	}
   207  	if d.HasChange("admin_state_up") {
   208  		asuRaw := d.Get("admin_state_up").(string)
   209  		if asuRaw != "" {
   210  			asu, err := strconv.ParseBool(asuRaw)
   211  			if err != nil {
   212  				return fmt.Errorf("admin_state_up, if provided, must be either 'true' or 'false'")
   213  			}
   214  			updateOpts.AdminStateUp = &asu
   215  		}
   216  	}
   217  
   218  	log.Printf("[DEBUG] Updating OpenStack LB VIP %s with options: %+v", d.Id(), updateOpts)
   219  
   220  	_, err = vips.Update(networkingClient, d.Id(), updateOpts).Extract()
   221  	if err != nil {
   222  		return fmt.Errorf("Error updating OpenStack LB VIP: %s", err)
   223  	}
   224  
   225  	return resourceLBVipV1Read(d, meta)
   226  }
   227  
   228  func resourceLBVipV1Delete(d *schema.ResourceData, meta interface{}) error {
   229  	config := meta.(*Config)
   230  	networkingClient, err := config.networkingV2Client(d.Get("region").(string))
   231  	if err != nil {
   232  		return fmt.Errorf("Error creating OpenStack networking client: %s", err)
   233  	}
   234  
   235  	err = vips.Delete(networkingClient, d.Id()).ExtractErr()
   236  	if err != nil {
   237  		return fmt.Errorf("Error deleting OpenStack LB VIP: %s", err)
   238  	}
   239  
   240  	d.SetId("")
   241  	return nil
   242  }
   243  
   244  func resourceVipPersistenceV1(d *schema.ResourceData) *vips.SessionPersistence {
   245  	rawP := d.Get("persistence").(interface{})
   246  	rawMap := rawP.(map[string]interface{})
   247  	if len(rawMap) != 0 {
   248  		p := vips.SessionPersistence{}
   249  		if t, ok := rawMap["type"]; ok {
   250  			p.Type = t.(string)
   251  		}
   252  		if c, ok := rawMap["cookie_name"]; ok {
   253  			p.CookieName = c.(string)
   254  		}
   255  		return &p
   256  	}
   257  	return nil
   258  }