github.com/jsoriano/terraform@v0.6.7-0.20151026070445-8b70867fdd95/builtin/providers/openstack/resource_openstack_networking_floatingip_v2.go (about) 1 package openstack 2 3 import ( 4 "fmt" 5 "log" 6 7 "github.com/hashicorp/terraform/helper/schema" 8 "github.com/rackspace/gophercloud/openstack/networking/v2/extensions/layer3/floatingips" 9 "github.com/rackspace/gophercloud/openstack/networking/v2/networks" 10 "github.com/rackspace/gophercloud/pagination" 11 ) 12 13 func resourceNetworkingFloatingIPV2() *schema.Resource { 14 return &schema.Resource{ 15 Create: resourceNetworkFloatingIPV2Create, 16 Read: resourceNetworkFloatingIPV2Read, 17 Update: resourceNetworkFloatingIPV2Update, 18 Delete: resourceNetworkFloatingIPV2Delete, 19 20 Schema: map[string]*schema.Schema{ 21 "region": &schema.Schema{ 22 Type: schema.TypeString, 23 Required: true, 24 ForceNew: true, 25 DefaultFunc: envDefaultFuncAllowMissing("OS_REGION_NAME"), 26 }, 27 "address": &schema.Schema{ 28 Type: schema.TypeString, 29 Computed: true, 30 }, 31 "pool": &schema.Schema{ 32 Type: schema.TypeString, 33 Required: true, 34 ForceNew: true, 35 DefaultFunc: envDefaultFunc("OS_POOL_NAME"), 36 }, 37 "port_id": &schema.Schema{ 38 Type: schema.TypeString, 39 Optional: true, 40 Default: "", 41 }, 42 }, 43 } 44 } 45 46 func resourceNetworkFloatingIPV2Create(d *schema.ResourceData, meta interface{}) error { 47 config := meta.(*Config) 48 networkClient, err := config.networkingV2Client(d.Get("region").(string)) 49 if err != nil { 50 return fmt.Errorf("Error creating OpenStack network client: %s", err) 51 } 52 53 poolID, err := getNetworkID(d, meta, d.Get("pool").(string)) 54 if err != nil { 55 return fmt.Errorf("Error retrieving floating IP pool name: %s", err) 56 } 57 if len(poolID) == 0 { 58 return fmt.Errorf("No network found with name: %s", d.Get("pool").(string)) 59 } 60 createOpts := floatingips.CreateOpts{ 61 FloatingNetworkID: poolID, 62 PortID: d.Get("port_id").(string), 63 } 64 log.Printf("[DEBUG] Create Options: %#v", createOpts) 65 floatingIP, err := floatingips.Create(networkClient, createOpts).Extract() 66 if err != nil { 67 return fmt.Errorf("Error allocating floating IP: %s", err) 68 } 69 70 d.SetId(floatingIP.ID) 71 72 return resourceNetworkFloatingIPV2Read(d, meta) 73 } 74 75 func resourceNetworkFloatingIPV2Read(d *schema.ResourceData, meta interface{}) error { 76 config := meta.(*Config) 77 networkClient, err := config.networkingV2Client(d.Get("region").(string)) 78 if err != nil { 79 return fmt.Errorf("Error creating OpenStack network client: %s", err) 80 } 81 82 floatingIP, err := floatingips.Get(networkClient, d.Id()).Extract() 83 if err != nil { 84 return CheckDeleted(d, err, "floating IP") 85 } 86 87 d.Set("address", floatingIP.FloatingIP) 88 d.Set("port_id", floatingIP.PortID) 89 poolName, err := getNetworkName(d, meta, floatingIP.FloatingNetworkID) 90 if err != nil { 91 return fmt.Errorf("Error retrieving floating IP pool name: %s", err) 92 } 93 d.Set("pool", poolName) 94 95 return nil 96 } 97 98 func resourceNetworkFloatingIPV2Update(d *schema.ResourceData, meta interface{}) error { 99 config := meta.(*Config) 100 networkClient, err := config.networkingV2Client(d.Get("region").(string)) 101 if err != nil { 102 return fmt.Errorf("Error creating OpenStack network client: %s", err) 103 } 104 105 var updateOpts floatingips.UpdateOpts 106 107 if d.HasChange("port_id") { 108 updateOpts.PortID = d.Get("port_id").(string) 109 } 110 111 log.Printf("[DEBUG] Update Options: %#v", updateOpts) 112 113 _, err = floatingips.Update(networkClient, d.Id(), updateOpts).Extract() 114 if err != nil { 115 return fmt.Errorf("Error updating floating IP: %s", err) 116 } 117 118 return resourceNetworkFloatingIPV2Read(d, meta) 119 } 120 121 func resourceNetworkFloatingIPV2Delete(d *schema.ResourceData, meta interface{}) error { 122 config := meta.(*Config) 123 networkClient, err := config.networkingV2Client(d.Get("region").(string)) 124 if err != nil { 125 return fmt.Errorf("Error creating OpenStack network client: %s", err) 126 } 127 128 err = floatingips.Delete(networkClient, d.Id()).ExtractErr() 129 if err != nil { 130 return fmt.Errorf("Error deleting floating IP: %s", err) 131 } 132 d.SetId("") 133 return nil 134 } 135 136 func getNetworkID(d *schema.ResourceData, meta interface{}, networkName string) (string, error) { 137 config := meta.(*Config) 138 networkClient, err := config.networkingV2Client(d.Get("region").(string)) 139 if err != nil { 140 return "", fmt.Errorf("Error creating OpenStack network client: %s", err) 141 } 142 143 opts := networks.ListOpts{Name: networkName} 144 pager := networks.List(networkClient, opts) 145 networkID := "" 146 147 err = pager.EachPage(func(page pagination.Page) (bool, error) { 148 networkList, err := networks.ExtractNetworks(page) 149 if err != nil { 150 return false, err 151 } 152 153 for _, n := range networkList { 154 if n.Name == networkName { 155 networkID = n.ID 156 return false, nil 157 } 158 } 159 160 return true, nil 161 }) 162 163 return networkID, err 164 } 165 166 func getNetworkName(d *schema.ResourceData, meta interface{}, networkID string) (string, error) { 167 config := meta.(*Config) 168 networkClient, err := config.networkingV2Client(d.Get("region").(string)) 169 if err != nil { 170 return "", fmt.Errorf("Error creating OpenStack network client: %s", err) 171 } 172 173 opts := networks.ListOpts{ID: networkID} 174 pager := networks.List(networkClient, opts) 175 networkName := "" 176 177 err = pager.EachPage(func(page pagination.Page) (bool, error) { 178 networkList, err := networks.ExtractNetworks(page) 179 if err != nil { 180 return false, err 181 } 182 183 for _, n := range networkList { 184 if n.ID == networkID { 185 networkName = n.Name 186 return false, nil 187 } 188 } 189 190 return true, nil 191 }) 192 193 return networkName, err 194 }