github.com/armen/terraform@v0.5.2-0.20150529052519-caa8117a08f1/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  		Delete: resourceNetworkFloatingIPV2Delete,
    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  			"address": &schema.Schema{
    27  				Type:     schema.TypeString,
    28  				Computed: true,
    29  			},
    30  			"pool": &schema.Schema{
    31  				Type:        schema.TypeString,
    32  				Required:    true,
    33  				ForceNew:    true,
    34  				DefaultFunc: envDefaultFunc("OS_POOL_NAME"),
    35  			},
    36  		},
    37  	}
    38  }
    39  
    40  func resourceNetworkFloatingIPV2Create(d *schema.ResourceData, meta interface{}) error {
    41  	config := meta.(*Config)
    42  	networkClient, err := config.networkingV2Client(d.Get("region").(string))
    43  	if err != nil {
    44  		return fmt.Errorf("Error creating OpenStack network client: %s", err)
    45  	}
    46  
    47  	poolID, err := getNetworkID(d, meta, d.Get("pool").(string))
    48  	if err != nil {
    49  		return fmt.Errorf("Error retrieving floating IP pool name: %s", err)
    50  	}
    51  	if len(poolID) == 0 {
    52  		return fmt.Errorf("No network found with name: %s", d.Get("pool").(string))
    53  	}
    54  	createOpts := floatingips.CreateOpts{
    55  		FloatingNetworkID: poolID,
    56  	}
    57  	log.Printf("[DEBUG] Create Options: %#v", createOpts)
    58  	floatingIP, err := floatingips.Create(networkClient, createOpts).Extract()
    59  	if err != nil {
    60  		return fmt.Errorf("Error allocating floating IP: %s", err)
    61  	}
    62  
    63  	d.SetId(floatingIP.ID)
    64  
    65  	return resourceNetworkFloatingIPV2Read(d, meta)
    66  }
    67  
    68  func resourceNetworkFloatingIPV2Read(d *schema.ResourceData, meta interface{}) error {
    69  	config := meta.(*Config)
    70  	networkClient, err := config.networkingV2Client(d.Get("region").(string))
    71  	if err != nil {
    72  		return fmt.Errorf("Error creating OpenStack network client: %s", err)
    73  	}
    74  
    75  	floatingIP, err := floatingips.Get(networkClient, d.Id()).Extract()
    76  	if err != nil {
    77  		return CheckDeleted(d, err, "floating IP")
    78  	}
    79  
    80  	d.Set("address", floatingIP.FloatingIP)
    81  	poolName, err := getNetworkName(d, meta, floatingIP.FloatingNetworkID)
    82  	if err != nil {
    83  		return fmt.Errorf("Error retrieving floating IP pool name: %s", err)
    84  	}
    85  	d.Set("pool", poolName)
    86  
    87  	return nil
    88  }
    89  
    90  func resourceNetworkFloatingIPV2Delete(d *schema.ResourceData, meta interface{}) error {
    91  	config := meta.(*Config)
    92  	networkClient, err := config.networkingV2Client(d.Get("region").(string))
    93  	if err != nil {
    94  		return fmt.Errorf("Error creating OpenStack network client: %s", err)
    95  	}
    96  
    97  	err = floatingips.Delete(networkClient, d.Id()).ExtractErr()
    98  	if err != nil {
    99  		return fmt.Errorf("Error deleting floating IP: %s", err)
   100  	}
   101  	d.SetId("")
   102  	return nil
   103  }
   104  
   105  func getNetworkID(d *schema.ResourceData, meta interface{}, networkName string) (string, error) {
   106  	config := meta.(*Config)
   107  	networkClient, err := config.networkingV2Client(d.Get("region").(string))
   108  	if err != nil {
   109  		return "", fmt.Errorf("Error creating OpenStack network client: %s", err)
   110  	}
   111  
   112  	opts := networks.ListOpts{Name: networkName}
   113  	pager := networks.List(networkClient, opts)
   114  	networkID := ""
   115  
   116  	err = pager.EachPage(func(page pagination.Page) (bool, error) {
   117  		networkList, err := networks.ExtractNetworks(page)
   118  		if err != nil {
   119  			return false, err
   120  		}
   121  
   122  		for _, n := range networkList {
   123  			if n.Name == networkName {
   124  				networkID = n.ID
   125  				return false, nil
   126  			}
   127  		}
   128  
   129  		return true, nil
   130  	})
   131  
   132  	return networkID, err
   133  }
   134  
   135  func getNetworkName(d *schema.ResourceData, meta interface{}, networkID string) (string, error) {
   136  	config := meta.(*Config)
   137  	networkClient, err := config.networkingV2Client(d.Get("region").(string))
   138  	if err != nil {
   139  		return "", fmt.Errorf("Error creating OpenStack network client: %s", err)
   140  	}
   141  
   142  	opts := networks.ListOpts{ID: networkID}
   143  	pager := networks.List(networkClient, opts)
   144  	networkName := ""
   145  
   146  	err = pager.EachPage(func(page pagination.Page) (bool, error) {
   147  		networkList, err := networks.ExtractNetworks(page)
   148  		if err != nil {
   149  			return false, err
   150  		}
   151  
   152  		for _, n := range networkList {
   153  			if n.ID == networkID {
   154  				networkName = n.Name
   155  				return false, nil
   156  			}
   157  		}
   158  
   159  		return true, nil
   160  	})
   161  
   162  	return networkName, err
   163  }