github.com/willrstern/terraform@v0.6.7-0.20151106173844-fa471ddbb53a/builtin/providers/openstack/resource_openstack_networking_router_interface_v2.go (about)

     1  package openstack
     2  
     3  import (
     4  	"fmt"
     5  	"log"
     6  	"time"
     7  
     8  	"github.com/hashicorp/terraform/helper/resource"
     9  	"github.com/hashicorp/terraform/helper/schema"
    10  
    11  	"github.com/rackspace/gophercloud"
    12  	"github.com/rackspace/gophercloud/openstack/networking/v2/extensions/layer3/routers"
    13  	"github.com/rackspace/gophercloud/openstack/networking/v2/ports"
    14  )
    15  
    16  func resourceNetworkingRouterInterfaceV2() *schema.Resource {
    17  	return &schema.Resource{
    18  		Create: resourceNetworkingRouterInterfaceV2Create,
    19  		Read:   resourceNetworkingRouterInterfaceV2Read,
    20  		Delete: resourceNetworkingRouterInterfaceV2Delete,
    21  
    22  		Schema: map[string]*schema.Schema{
    23  			"region": &schema.Schema{
    24  				Type:        schema.TypeString,
    25  				Required:    true,
    26  				ForceNew:    true,
    27  				DefaultFunc: envDefaultFuncAllowMissing("OS_REGION_NAME"),
    28  			},
    29  			"router_id": &schema.Schema{
    30  				Type:     schema.TypeString,
    31  				Required: true,
    32  				ForceNew: true,
    33  			},
    34  			"subnet_id": &schema.Schema{
    35  				Type:     schema.TypeString,
    36  				Required: true,
    37  				ForceNew: true,
    38  			},
    39  		},
    40  	}
    41  }
    42  
    43  func resourceNetworkingRouterInterfaceV2Create(d *schema.ResourceData, meta interface{}) error {
    44  	config := meta.(*Config)
    45  	networkingClient, err := config.networkingV2Client(d.Get("region").(string))
    46  	if err != nil {
    47  		return fmt.Errorf("Error creating OpenStack networking client: %s", err)
    48  	}
    49  
    50  	createOpts := routers.InterfaceOpts{
    51  		SubnetID: d.Get("subnet_id").(string),
    52  	}
    53  
    54  	log.Printf("[DEBUG] Create Options: %#v", createOpts)
    55  	n, err := routers.AddInterface(networkingClient, d.Get("router_id").(string), createOpts).Extract()
    56  	if err != nil {
    57  		return fmt.Errorf("Error creating OpenStack Neutron router interface: %s", err)
    58  	}
    59  	log.Printf("[INFO] Router interface Port ID: %s", n.PortID)
    60  
    61  	log.Printf("[DEBUG] Waiting for Router Interface (%s) to become available", n.PortID)
    62  
    63  	stateConf := &resource.StateChangeConf{
    64  		Pending:    []string{"BUILD", "PENDING_CREATE", "PENDING_UPDATE"},
    65  		Target:     "ACTIVE",
    66  		Refresh:    waitForRouterInterfaceActive(networkingClient, n.PortID),
    67  		Timeout:    2 * time.Minute,
    68  		Delay:      5 * time.Second,
    69  		MinTimeout: 3 * time.Second,
    70  	}
    71  
    72  	_, err = stateConf.WaitForState()
    73  
    74  	d.SetId(n.PortID)
    75  
    76  	return resourceNetworkingRouterInterfaceV2Read(d, meta)
    77  }
    78  
    79  func resourceNetworkingRouterInterfaceV2Read(d *schema.ResourceData, meta interface{}) error {
    80  	config := meta.(*Config)
    81  	networkingClient, err := config.networkingV2Client(d.Get("region").(string))
    82  	if err != nil {
    83  		return fmt.Errorf("Error creating OpenStack networking client: %s", err)
    84  	}
    85  
    86  	n, err := ports.Get(networkingClient, d.Id()).Extract()
    87  	if err != nil {
    88  		httpError, ok := err.(*gophercloud.UnexpectedResponseCodeError)
    89  		if !ok {
    90  			return fmt.Errorf("Error retrieving OpenStack Neutron Router Interface: %s", err)
    91  		}
    92  
    93  		if httpError.Actual == 404 {
    94  			d.SetId("")
    95  			return nil
    96  		}
    97  		return fmt.Errorf("Error retrieving OpenStack Neutron Router Interface: %s", err)
    98  	}
    99  
   100  	log.Printf("[DEBUG] Retreived Router Interface %s: %+v", d.Id(), n)
   101  
   102  	return nil
   103  }
   104  
   105  func resourceNetworkingRouterInterfaceV2Delete(d *schema.ResourceData, meta interface{}) error {
   106  	config := meta.(*Config)
   107  	networkingClient, err := config.networkingV2Client(d.Get("region").(string))
   108  	if err != nil {
   109  		return fmt.Errorf("Error creating OpenStack networking client: %s", err)
   110  	}
   111  
   112  	stateConf := &resource.StateChangeConf{
   113  		Pending:    []string{"ACTIVE"},
   114  		Target:     "DELETED",
   115  		Refresh:    waitForRouterInterfaceDelete(networkingClient, d),
   116  		Timeout:    2 * time.Minute,
   117  		Delay:      5 * time.Second,
   118  		MinTimeout: 3 * time.Second,
   119  	}
   120  
   121  	_, err = stateConf.WaitForState()
   122  	if err != nil {
   123  		return fmt.Errorf("Error deleting OpenStack Neutron Router Interface: %s", err)
   124  	}
   125  
   126  	d.SetId("")
   127  	return nil
   128  }
   129  
   130  func waitForRouterInterfaceActive(networkingClient *gophercloud.ServiceClient, rId string) resource.StateRefreshFunc {
   131  	return func() (interface{}, string, error) {
   132  		r, err := ports.Get(networkingClient, rId).Extract()
   133  		if err != nil {
   134  			return nil, "", err
   135  		}
   136  
   137  		log.Printf("[DEBUG] OpenStack Neutron Router Interface: %+v", r)
   138  		return r, r.Status, nil
   139  	}
   140  }
   141  
   142  func waitForRouterInterfaceDelete(networkingClient *gophercloud.ServiceClient, d *schema.ResourceData) resource.StateRefreshFunc {
   143  	return func() (interface{}, string, error) {
   144  		routerId := d.Get("router_id").(string)
   145  		routerInterfaceId := d.Id()
   146  
   147  		log.Printf("[DEBUG] Attempting to delete OpenStack Router Interface %s.\n", routerInterfaceId)
   148  
   149  		removeOpts := routers.InterfaceOpts{
   150  			SubnetID: d.Get("subnet_id").(string),
   151  		}
   152  
   153  		r, err := ports.Get(networkingClient, routerInterfaceId).Extract()
   154  		if err != nil {
   155  			errCode, ok := err.(*gophercloud.UnexpectedResponseCodeError)
   156  			if !ok {
   157  				return r, "ACTIVE", err
   158  			}
   159  			if errCode.Actual == 404 {
   160  				log.Printf("[DEBUG] Successfully deleted OpenStack Router Interface %s", routerInterfaceId)
   161  				return r, "DELETED", nil
   162  			}
   163  		}
   164  
   165  		_, err = routers.RemoveInterface(networkingClient, routerId, removeOpts).Extract()
   166  		if err != nil {
   167  			errCode, ok := err.(*gophercloud.UnexpectedResponseCodeError)
   168  			if !ok {
   169  				return r, "ACTIVE", err
   170  			}
   171  			if errCode.Actual == 404 {
   172  				log.Printf("[DEBUG] Successfully deleted OpenStack Router Interface %s", routerInterfaceId)
   173  				return r, "DELETED", nil
   174  			}
   175  		}
   176  
   177  		log.Printf("[DEBUG] OpenStack Router Interface %s still active.\n", routerInterfaceId)
   178  		return r, "ACTIVE", nil
   179  	}
   180  }