github.com/gabrielperezs/terraform@v0.7.0-rc2.0.20160715084931-f7da2612946f/builtin/providers/openstack/resource_openstack_lb_pool_v1.go (about) 1 package openstack 2 3 import ( 4 "bytes" 5 "fmt" 6 "log" 7 "time" 8 9 "github.com/hashicorp/terraform/helper/hashcode" 10 "github.com/hashicorp/terraform/helper/resource" 11 "github.com/hashicorp/terraform/helper/schema" 12 13 "github.com/rackspace/gophercloud" 14 "github.com/rackspace/gophercloud/openstack/networking/v2/extensions/lbaas/members" 15 "github.com/rackspace/gophercloud/openstack/networking/v2/extensions/lbaas/pools" 16 "github.com/rackspace/gophercloud/pagination" 17 ) 18 19 func resourceLBPoolV1() *schema.Resource { 20 return &schema.Resource{ 21 Create: resourceLBPoolV1Create, 22 Read: resourceLBPoolV1Read, 23 Update: resourceLBPoolV1Update, 24 Delete: resourceLBPoolV1Delete, 25 Importer: &schema.ResourceImporter{ 26 State: schema.ImportStatePassthrough, 27 }, 28 29 Schema: map[string]*schema.Schema{ 30 "region": &schema.Schema{ 31 Type: schema.TypeString, 32 Required: true, 33 ForceNew: true, 34 DefaultFunc: schema.EnvDefaultFunc("OS_REGION_NAME", ""), 35 }, 36 "name": &schema.Schema{ 37 Type: schema.TypeString, 38 Required: true, 39 ForceNew: false, 40 }, 41 "protocol": &schema.Schema{ 42 Type: schema.TypeString, 43 Required: true, 44 ForceNew: true, 45 }, 46 "subnet_id": &schema.Schema{ 47 Type: schema.TypeString, 48 Required: true, 49 ForceNew: true, 50 }, 51 52 "lb_method": &schema.Schema{ 53 Type: schema.TypeString, 54 Required: true, 55 ForceNew: false, 56 }, 57 "lb_provider": &schema.Schema{ 58 Type: schema.TypeString, 59 Optional: true, 60 Computed: true, 61 ForceNew: true, 62 }, 63 "tenant_id": &schema.Schema{ 64 Type: schema.TypeString, 65 Optional: true, 66 ForceNew: true, 67 Computed: true, 68 }, 69 "member": &schema.Schema{ 70 Type: schema.TypeSet, 71 Deprecated: "Use openstack_lb_member_v1 instead. This attribute will be removed in a future version.", 72 Optional: true, 73 Elem: &schema.Resource{ 74 Schema: map[string]*schema.Schema{ 75 "region": &schema.Schema{ 76 Type: schema.TypeString, 77 Required: true, 78 ForceNew: true, 79 DefaultFunc: schema.EnvDefaultFunc("OS_REGION_NAME", ""), 80 }, 81 "tenant_id": &schema.Schema{ 82 Type: schema.TypeString, 83 Optional: true, 84 ForceNew: true, 85 }, 86 "address": &schema.Schema{ 87 Type: schema.TypeString, 88 Required: true, 89 ForceNew: true, 90 }, 91 "port": &schema.Schema{ 92 Type: schema.TypeInt, 93 Required: true, 94 ForceNew: true, 95 }, 96 "admin_state_up": &schema.Schema{ 97 Type: schema.TypeBool, 98 Required: true, 99 ForceNew: false, 100 }, 101 }, 102 }, 103 Set: resourceLBMemberV1Hash, 104 }, 105 "monitor_ids": &schema.Schema{ 106 Type: schema.TypeSet, 107 Optional: true, 108 ForceNew: false, 109 Elem: &schema.Schema{Type: schema.TypeString}, 110 Set: schema.HashString, 111 }, 112 }, 113 } 114 } 115 116 func resourceLBPoolV1Create(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 createOpts := pools.CreateOpts{ 124 Name: d.Get("name").(string), 125 Protocol: d.Get("protocol").(string), 126 SubnetID: d.Get("subnet_id").(string), 127 LBMethod: d.Get("lb_method").(string), 128 TenantID: d.Get("tenant_id").(string), 129 Provider: d.Get("lb_provider").(string), 130 } 131 132 log.Printf("[DEBUG] Create Options: %#v", createOpts) 133 p, err := pools.Create(networkingClient, createOpts).Extract() 134 if err != nil { 135 return fmt.Errorf("Error creating OpenStack LB pool: %s", err) 136 } 137 log.Printf("[INFO] LB Pool ID: %s", p.ID) 138 139 log.Printf("[DEBUG] Waiting for OpenStack LB pool (%s) to become available.", p.ID) 140 141 stateConf := &resource.StateChangeConf{ 142 Pending: []string{"PENDING_CREATE"}, 143 Target: []string{"ACTIVE"}, 144 Refresh: waitForLBPoolActive(networkingClient, p.ID), 145 Timeout: 2 * time.Minute, 146 Delay: 5 * time.Second, 147 MinTimeout: 3 * time.Second, 148 } 149 150 _, err = stateConf.WaitForState() 151 if err != nil { 152 return err 153 } 154 155 d.SetId(p.ID) 156 157 if mIDs := resourcePoolMonitorIDsV1(d); mIDs != nil { 158 for _, mID := range mIDs { 159 _, err := pools.AssociateMonitor(networkingClient, p.ID, mID).Extract() 160 if err != nil { 161 return fmt.Errorf("Error associating monitor (%s) with OpenStack LB pool (%s): %s", mID, p.ID, err) 162 } 163 } 164 } 165 166 if memberOpts := resourcePoolMembersV1(d); memberOpts != nil { 167 for _, memberOpt := range memberOpts { 168 _, err := members.Create(networkingClient, memberOpt).Extract() 169 if err != nil { 170 return fmt.Errorf("Error creating OpenStack LB member: %s", err) 171 } 172 } 173 } 174 175 return resourceLBPoolV1Read(d, meta) 176 } 177 178 func resourceLBPoolV1Read(d *schema.ResourceData, meta interface{}) error { 179 config := meta.(*Config) 180 networkingClient, err := config.networkingV2Client(d.Get("region").(string)) 181 if err != nil { 182 return fmt.Errorf("Error creating OpenStack networking client: %s", err) 183 } 184 185 p, err := pools.Get(networkingClient, d.Id()).Extract() 186 if err != nil { 187 return CheckDeleted(d, err, "LB pool") 188 } 189 190 log.Printf("[DEBUG] Retreived OpenStack LB Pool %s: %+v", d.Id(), p) 191 192 d.Set("name", p.Name) 193 d.Set("protocol", p.Protocol) 194 d.Set("subnet_id", p.SubnetID) 195 d.Set("lb_method", p.LBMethod) 196 d.Set("lb_provider", p.Provider) 197 d.Set("tenant_id", p.TenantID) 198 d.Set("monitor_ids", p.MonitorIDs) 199 d.Set("member_ids", p.MemberIDs) 200 201 return nil 202 } 203 204 func resourceLBPoolV1Update(d *schema.ResourceData, meta interface{}) error { 205 config := meta.(*Config) 206 networkingClient, err := config.networkingV2Client(d.Get("region").(string)) 207 if err != nil { 208 return fmt.Errorf("Error creating OpenStack networking client: %s", err) 209 } 210 211 var updateOpts pools.UpdateOpts 212 // If either option changed, update both. 213 // Gophercloud complains if one is empty. 214 if d.HasChange("name") || d.HasChange("lb_method") { 215 updateOpts.Name = d.Get("name").(string) 216 updateOpts.LBMethod = d.Get("lb_method").(string) 217 } 218 219 log.Printf("[DEBUG] Updating OpenStack LB Pool %s with options: %+v", d.Id(), updateOpts) 220 221 _, err = pools.Update(networkingClient, d.Id(), updateOpts).Extract() 222 if err != nil { 223 return fmt.Errorf("Error updating OpenStack LB Pool: %s", err) 224 } 225 226 if d.HasChange("monitor_ids") { 227 oldMIDsRaw, newMIDsRaw := d.GetChange("security_groups") 228 oldMIDsSet, newMIDsSet := oldMIDsRaw.(*schema.Set), newMIDsRaw.(*schema.Set) 229 monitorsToAdd := newMIDsSet.Difference(oldMIDsSet) 230 monitorsToRemove := oldMIDsSet.Difference(newMIDsSet) 231 232 log.Printf("[DEBUG] Monitors to add: %v", monitorsToAdd) 233 234 log.Printf("[DEBUG] Monitors to remove: %v", monitorsToRemove) 235 236 for _, m := range monitorsToAdd.List() { 237 _, err := pools.AssociateMonitor(networkingClient, d.Id(), m.(string)).Extract() 238 if err != nil { 239 return fmt.Errorf("Error associating monitor (%s) with OpenStack server (%s): %s", m.(string), d.Id(), err) 240 } 241 log.Printf("[DEBUG] Associated monitor (%s) with pool (%s)", m.(string), d.Id()) 242 } 243 244 for _, m := range monitorsToRemove.List() { 245 _, err := pools.DisassociateMonitor(networkingClient, d.Id(), m.(string)).Extract() 246 if err != nil { 247 return fmt.Errorf("Error disassociating monitor (%s) from OpenStack server (%s): %s", m.(string), d.Id(), err) 248 } 249 log.Printf("[DEBUG] Disassociated monitor (%s) from pool (%s)", m.(string), d.Id()) 250 } 251 } 252 253 if d.HasChange("member") { 254 oldMembersRaw, newMembersRaw := d.GetChange("member") 255 oldMembersSet, newMembersSet := oldMembersRaw.(*schema.Set), newMembersRaw.(*schema.Set) 256 membersToAdd := newMembersSet.Difference(oldMembersSet) 257 membersToRemove := oldMembersSet.Difference(newMembersSet) 258 259 log.Printf("[DEBUG] Members to add: %v", membersToAdd) 260 261 log.Printf("[DEBUG] Members to remove: %v", membersToRemove) 262 263 for _, m := range membersToRemove.List() { 264 oldMember := resourcePoolMemberV1(d, m) 265 listOpts := members.ListOpts{ 266 PoolID: d.Id(), 267 Address: oldMember.Address, 268 ProtocolPort: oldMember.ProtocolPort, 269 } 270 err = members.List(networkingClient, listOpts).EachPage(func(page pagination.Page) (bool, error) { 271 extractedMembers, err := members.ExtractMembers(page) 272 if err != nil { 273 return false, err 274 } 275 for _, member := range extractedMembers { 276 err := members.Delete(networkingClient, member.ID).ExtractErr() 277 if err != nil { 278 return false, fmt.Errorf("Error deleting member (%s) from OpenStack LB pool (%s): %s", member.ID, d.Id(), err) 279 } 280 log.Printf("[DEBUG] Deleted member (%s) from pool (%s)", member.ID, d.Id()) 281 } 282 return true, nil 283 }) 284 } 285 286 for _, m := range membersToAdd.List() { 287 createOpts := resourcePoolMemberV1(d, m) 288 newMember, err := members.Create(networkingClient, createOpts).Extract() 289 if err != nil { 290 return fmt.Errorf("Error creating LB member: %s", err) 291 } 292 log.Printf("[DEBUG] Created member (%s) in OpenStack LB pool (%s)", newMember.ID, d.Id()) 293 } 294 } 295 296 return resourceLBPoolV1Read(d, meta) 297 } 298 299 func resourceLBPoolV1Delete(d *schema.ResourceData, meta interface{}) error { 300 config := meta.(*Config) 301 networkingClient, err := config.networkingV2Client(d.Get("region").(string)) 302 if err != nil { 303 return fmt.Errorf("Error creating OpenStack networking client: %s", err) 304 } 305 306 // Make sure all monitors are disassociated first 307 if v, ok := d.GetOk("monitor_ids"); ok { 308 if monitorIDList, ok := v.([]interface{}); ok { 309 for _, monitorID := range monitorIDList { 310 mID := monitorID.(string) 311 log.Printf("[DEBUG] Attempting to disassociate monitor %s from pool %s", mID, d.Id()) 312 if res := pools.DisassociateMonitor(networkingClient, d.Id(), mID); res.Err != nil { 313 return fmt.Errorf("Error disassociating monitor %s from pool %s: %s", mID, d.Id(), err) 314 } 315 } 316 } 317 } 318 319 stateConf := &resource.StateChangeConf{ 320 Pending: []string{"ACTIVE", "PENDING_DELETE"}, 321 Target: []string{"DELETED"}, 322 Refresh: waitForLBPoolDelete(networkingClient, d.Id()), 323 Timeout: 2 * time.Minute, 324 Delay: 5 * time.Second, 325 MinTimeout: 3 * time.Second, 326 } 327 328 _, err = stateConf.WaitForState() 329 if err != nil { 330 return fmt.Errorf("Error deleting OpenStack LB Pool: %s", err) 331 } 332 333 d.SetId("") 334 return nil 335 } 336 337 func resourcePoolMonitorIDsV1(d *schema.ResourceData) []string { 338 mIDsRaw := d.Get("monitor_ids").(*schema.Set) 339 mIDs := make([]string, mIDsRaw.Len()) 340 for i, raw := range mIDsRaw.List() { 341 mIDs[i] = raw.(string) 342 } 343 return mIDs 344 } 345 346 func resourcePoolMembersV1(d *schema.ResourceData) []members.CreateOpts { 347 memberOptsRaw := d.Get("member").(*schema.Set) 348 memberOpts := make([]members.CreateOpts, memberOptsRaw.Len()) 349 for i, raw := range memberOptsRaw.List() { 350 rawMap := raw.(map[string]interface{}) 351 memberOpts[i] = members.CreateOpts{ 352 TenantID: rawMap["tenant_id"].(string), 353 Address: rawMap["address"].(string), 354 ProtocolPort: rawMap["port"].(int), 355 PoolID: d.Id(), 356 } 357 } 358 return memberOpts 359 } 360 361 func resourcePoolMemberV1(d *schema.ResourceData, raw interface{}) members.CreateOpts { 362 rawMap := raw.(map[string]interface{}) 363 return members.CreateOpts{ 364 TenantID: rawMap["tenant_id"].(string), 365 Address: rawMap["address"].(string), 366 ProtocolPort: rawMap["port"].(int), 367 PoolID: d.Id(), 368 } 369 } 370 371 func resourceLBMemberV1Hash(v interface{}) int { 372 var buf bytes.Buffer 373 m := v.(map[string]interface{}) 374 buf.WriteString(fmt.Sprintf("%s-", m["region"].(string))) 375 buf.WriteString(fmt.Sprintf("%s-", m["tenant_id"].(string))) 376 buf.WriteString(fmt.Sprintf("%s-", m["address"].(string))) 377 buf.WriteString(fmt.Sprintf("%d-", m["port"].(int))) 378 379 return hashcode.String(buf.String()) 380 } 381 382 func waitForLBPoolActive(networkingClient *gophercloud.ServiceClient, poolId string) resource.StateRefreshFunc { 383 return func() (interface{}, string, error) { 384 p, err := pools.Get(networkingClient, poolId).Extract() 385 if err != nil { 386 return nil, "", err 387 } 388 389 log.Printf("[DEBUG] OpenStack LB Pool: %+v", p) 390 if p.Status == "ACTIVE" { 391 return p, "ACTIVE", nil 392 } 393 394 return p, p.Status, nil 395 } 396 } 397 398 func waitForLBPoolDelete(networkingClient *gophercloud.ServiceClient, poolId string) resource.StateRefreshFunc { 399 return func() (interface{}, string, error) { 400 log.Printf("[DEBUG] Attempting to delete OpenStack LB Pool %s", poolId) 401 402 p, err := pools.Get(networkingClient, poolId).Extract() 403 if err != nil { 404 errCode, ok := err.(*gophercloud.UnexpectedResponseCodeError) 405 if !ok { 406 return p, "ACTIVE", err 407 } 408 if errCode.Actual == 404 { 409 log.Printf("[DEBUG] Successfully deleted OpenStack LB Pool %s", poolId) 410 return p, "DELETED", nil 411 } 412 } 413 414 log.Printf("[DEBUG] OpenStack LB Pool: %+v", p) 415 err = pools.Delete(networkingClient, poolId).ExtractErr() 416 if err != nil { 417 errCode, ok := err.(*gophercloud.UnexpectedResponseCodeError) 418 if !ok { 419 return p, "ACTIVE", err 420 } 421 if errCode.Actual == 404 { 422 log.Printf("[DEBUG] Successfully deleted OpenStack LB Pool %s", poolId) 423 return p, "DELETED", nil 424 } 425 } 426 427 log.Printf("[DEBUG] OpenStack LB Pool %s still active.", poolId) 428 return p, "ACTIVE", nil 429 } 430 431 }