github.com/koding/terraform@v0.6.4-0.20170608090606-5d7e0339779d/builtin/providers/azurerm/resource_arm_loadbalancer_backend_address_pool.go (about) 1 package azurerm 2 3 import ( 4 "fmt" 5 "log" 6 "time" 7 8 "github.com/Azure/azure-sdk-for-go/arm/network" 9 "github.com/hashicorp/errwrap" 10 "github.com/hashicorp/terraform/helper/resource" 11 "github.com/hashicorp/terraform/helper/schema" 12 "github.com/jen20/riviera/azure" 13 ) 14 15 func resourceArmLoadBalancerBackendAddressPool() *schema.Resource { 16 return &schema.Resource{ 17 Create: resourceArmLoadBalancerBackendAddressPoolCreate, 18 Read: resourceArmLoadBalancerBackendAddressPoolRead, 19 Delete: resourceArmLoadBalancerBackendAddressPoolDelete, 20 Importer: &schema.ResourceImporter{ 21 State: loadBalancerSubResourceStateImporter, 22 }, 23 24 Schema: map[string]*schema.Schema{ 25 "name": { 26 Type: schema.TypeString, 27 Required: true, 28 ForceNew: true, 29 }, 30 31 "location": deprecatedLocationSchema(), 32 33 "resource_group_name": { 34 Type: schema.TypeString, 35 Required: true, 36 ForceNew: true, 37 }, 38 39 "loadbalancer_id": { 40 Type: schema.TypeString, 41 Required: true, 42 ForceNew: true, 43 }, 44 45 "backend_ip_configurations": { 46 Type: schema.TypeSet, 47 Computed: true, 48 Elem: &schema.Schema{Type: schema.TypeString}, 49 Set: schema.HashString, 50 }, 51 52 "load_balancing_rules": { 53 Type: schema.TypeSet, 54 Computed: true, 55 Elem: &schema.Schema{Type: schema.TypeString}, 56 Set: schema.HashString, 57 }, 58 }, 59 } 60 } 61 62 func resourceArmLoadBalancerBackendAddressPoolCreate(d *schema.ResourceData, meta interface{}) error { 63 client := meta.(*ArmClient) 64 lbClient := client.loadBalancerClient 65 66 loadBalancerID := d.Get("loadbalancer_id").(string) 67 armMutexKV.Lock(loadBalancerID) 68 defer armMutexKV.Unlock(loadBalancerID) 69 70 loadBalancer, exists, err := retrieveLoadBalancerById(loadBalancerID, meta) 71 if err != nil { 72 return errwrap.Wrapf("Error Getting LoadBalancer By ID {{err}}", err) 73 } 74 if !exists { 75 d.SetId("") 76 log.Printf("[INFO] LoadBalancer %q not found. Removing from state", d.Get("name").(string)) 77 return nil 78 } 79 80 backendAddressPools := append(*loadBalancer.LoadBalancerPropertiesFormat.BackendAddressPools, expandAzureRmLoadBalancerBackendAddressPools(d)) 81 existingPool, existingPoolIndex, exists := findLoadBalancerBackEndAddressPoolByName(loadBalancer, d.Get("name").(string)) 82 if exists { 83 if d.Get("name").(string) == *existingPool.Name { 84 // this pool is being updated/reapplied remove old copy from the slice 85 backendAddressPools = append(backendAddressPools[:existingPoolIndex], backendAddressPools[existingPoolIndex+1:]...) 86 } 87 } 88 89 loadBalancer.LoadBalancerPropertiesFormat.BackendAddressPools = &backendAddressPools 90 resGroup, loadBalancerName, err := resourceGroupAndLBNameFromId(d.Get("loadbalancer_id").(string)) 91 if err != nil { 92 return errwrap.Wrapf("Error Getting LoadBalancer Name and Group: {{err}}", err) 93 } 94 95 _, error := lbClient.CreateOrUpdate(resGroup, loadBalancerName, *loadBalancer, make(chan struct{})) 96 err = <-error 97 if err != nil { 98 return errwrap.Wrapf("Error Creating/Updating LoadBalancer {{err}}", err) 99 } 100 101 read, err := lbClient.Get(resGroup, loadBalancerName, "") 102 if err != nil { 103 return errwrap.Wrapf("Error Getting LoadBalancer {{err}}", err) 104 } 105 if read.ID == nil { 106 return fmt.Errorf("Cannot read LoadBalancer %s (resource group %s) ID", loadBalancerName, resGroup) 107 } 108 109 var pool_id string 110 for _, BackendAddressPool := range *(*read.LoadBalancerPropertiesFormat).BackendAddressPools { 111 if *BackendAddressPool.Name == d.Get("name").(string) { 112 pool_id = *BackendAddressPool.ID 113 } 114 } 115 116 if pool_id != "" { 117 d.SetId(pool_id) 118 } else { 119 return fmt.Errorf("Cannot find created LoadBalancer Backend Address Pool ID %q", pool_id) 120 } 121 122 log.Printf("[DEBUG] Waiting for LoadBalancer (%s) to become available", loadBalancerName) 123 stateConf := &resource.StateChangeConf{ 124 Pending: []string{"Accepted", "Updating"}, 125 Target: []string{"Succeeded"}, 126 Refresh: loadbalancerStateRefreshFunc(client, resGroup, loadBalancerName), 127 Timeout: 10 * time.Minute, 128 } 129 if _, err := stateConf.WaitForState(); err != nil { 130 return fmt.Errorf("Error waiting for LoadBalancer (%s) to become available: %s", loadBalancerName, err) 131 } 132 133 return resourceArmLoadBalancerBackendAddressPoolRead(d, meta) 134 } 135 136 func resourceArmLoadBalancerBackendAddressPoolRead(d *schema.ResourceData, meta interface{}) error { 137 id, err := parseAzureResourceID(d.Id()) 138 if err != nil { 139 return err 140 } 141 name := id.Path["backendAddressPools"] 142 143 loadBalancer, exists, err := retrieveLoadBalancerById(d.Get("loadbalancer_id").(string), meta) 144 if err != nil { 145 return errwrap.Wrapf("Error Getting LoadBalancer By ID {{err}}", err) 146 } 147 if !exists { 148 d.SetId("") 149 log.Printf("[INFO] LoadBalancer %q not found. Removing from state", name) 150 return nil 151 } 152 153 config, _, exists := findLoadBalancerBackEndAddressPoolByName(loadBalancer, name) 154 if !exists { 155 d.SetId("") 156 log.Printf("[INFO] LoadBalancer Backend Address Pool %q not found. Removing from state", name) 157 return nil 158 } 159 160 d.Set("name", config.Name) 161 d.Set("resource_group_name", id.ResourceGroup) 162 163 var backend_ip_configurations []string 164 if config.BackendAddressPoolPropertiesFormat.BackendIPConfigurations != nil { 165 for _, backendConfig := range *config.BackendAddressPoolPropertiesFormat.BackendIPConfigurations { 166 backend_ip_configurations = append(backend_ip_configurations, *backendConfig.ID) 167 } 168 169 } 170 d.Set("backend_ip_configurations", backend_ip_configurations) 171 172 var load_balancing_rules []string 173 if config.BackendAddressPoolPropertiesFormat.LoadBalancingRules != nil { 174 for _, rule := range *config.BackendAddressPoolPropertiesFormat.LoadBalancingRules { 175 load_balancing_rules = append(load_balancing_rules, *rule.ID) 176 } 177 } 178 d.Set("load_balancing_rules", load_balancing_rules) 179 180 return nil 181 } 182 183 func resourceArmLoadBalancerBackendAddressPoolDelete(d *schema.ResourceData, meta interface{}) error { 184 client := meta.(*ArmClient) 185 lbClient := client.loadBalancerClient 186 187 loadBalancerID := d.Get("loadbalancer_id").(string) 188 armMutexKV.Lock(loadBalancerID) 189 defer armMutexKV.Unlock(loadBalancerID) 190 191 loadBalancer, exists, err := retrieveLoadBalancerById(loadBalancerID, meta) 192 if err != nil { 193 return errwrap.Wrapf("Error Getting LoadBalancer By ID {{err}}", err) 194 } 195 if !exists { 196 d.SetId("") 197 return nil 198 } 199 200 _, index, exists := findLoadBalancerBackEndAddressPoolByName(loadBalancer, d.Get("name").(string)) 201 if !exists { 202 return nil 203 } 204 205 oldBackEndPools := *loadBalancer.LoadBalancerPropertiesFormat.BackendAddressPools 206 newBackEndPools := append(oldBackEndPools[:index], oldBackEndPools[index+1:]...) 207 loadBalancer.LoadBalancerPropertiesFormat.BackendAddressPools = &newBackEndPools 208 209 resGroup, loadBalancerName, err := resourceGroupAndLBNameFromId(d.Get("loadbalancer_id").(string)) 210 if err != nil { 211 return errwrap.Wrapf("Error Getting LoadBalancer Name and Group: {{err}}", err) 212 } 213 214 _, error := lbClient.CreateOrUpdate(resGroup, loadBalancerName, *loadBalancer, make(chan struct{})) 215 err = <-error 216 if err != nil { 217 return errwrap.Wrapf("Error Creating/Updating LoadBalancer {{err}}", err) 218 } 219 220 read, err := lbClient.Get(resGroup, loadBalancerName, "") 221 if err != nil { 222 return errwrap.Wrapf("Error Getting LoadBalancer {{err}}", err) 223 } 224 if read.ID == nil { 225 return fmt.Errorf("Cannot read LoadBalancer %s (resource group %s) ID", loadBalancerName, resGroup) 226 } 227 228 return nil 229 } 230 231 func expandAzureRmLoadBalancerBackendAddressPools(d *schema.ResourceData) network.BackendAddressPool { 232 return network.BackendAddressPool{ 233 Name: azure.String(d.Get("name").(string)), 234 } 235 }