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 }