// tearDown achieves the aims of TearDown()
func (p *openstackp) tearDown(resources *Resources) (err error) {
// throughout we'll ignore errors because we want to try and delete
// as much as possible; we'll end up returning the last error we encountered
// delete servers, except for ourselves
pager := servers.List(p.computeClient, servers.ListOpts{})
err = pager.EachPage(func(page pagination.Page) (bool, error) {
serverList, err := servers.ExtractServers(page)
if err != nil {
return false, err
}
for _, server := range serverList {
if p.ownName != server.Name && strings.HasPrefix(server.Name, resources.ResourceName) {
p.destroyServer(server.ID) // ignore errors, just try to delete others
}
}
return true, nil
})
if p.ownName == "" {
// delete router
if id := resources.Details["router"]; id != "" {
if subnetid := resources.Details["subnet"]; subnetid != "" {
// remove the interface from our router first
_, err = routers.RemoveInterface(p.networkClient, id, routers.RemoveInterfaceOpts{SubnetID: subnetid}).Extract()
}
err = routers.Delete(p.networkClient, id).ExtractErr()
}
// delete network (and its subnet)
if id := resources.Details["network"]; id != "" {
err = networks.Delete(p.networkClient, id).ExtractErr()
}
// delete secgroup
if id := resources.Details["secgroup"]; id != "" {
err = secgroups.Delete(p.computeClient, id).ExtractErr()
}
}
// delete keypair, unless we're running in OpenStack and securityGroup and
// keypair have the same resourcename, indicating our current server needs
// the same keypair we used to spawn our servers
if id := resources.Details["keypair"]; id != "" {
if p.ownName == "" || (p.securityGroup != "" && p.securityGroup != id) {
err = keypairs.Delete(p.computeClient, id).ExtractErr()
resources.PrivateKey = ""
}
}
return
}
func TestLayer3RouterInterface(t *testing.T) {
client, err := clients.NewNetworkV2Client()
if err != nil {
t.Fatalf("Unable to create a compute client: %v", err)
}
choices, err := clients.AcceptanceTestChoicesFromEnv()
if err != nil {
t.Fatalf("Unable to get choices: %v", err)
}
subnet, err := networking.CreateSubnet(t, client, choices.ExternalNetworkID)
if err != nil {
t.Fatalf("Unable to create subnet: %v", err)
}
defer networking.DeleteSubnet(t, client, subnet.ID)
networking.PrintSubnet(t, subnet)
router, err := CreateExternalRouter(t, client)
if err != nil {
t.Fatalf("Unable to create router: %v", err)
}
defer DeleteRouter(t, client, router.ID)
aiOpts := routers.AddInterfaceOpts{
SubnetID: subnet.ID,
}
iface, err := routers.AddInterface(client, router.ID, aiOpts).Extract()
if err != nil {
t.Fatalf("Failed to add interface to router: %v", err)
}
PrintRouter(t, router)
PrintRouterInterface(t, iface)
riOpts := routers.RemoveInterfaceOpts{
SubnetID: subnet.ID,
}
_, err = routers.RemoveInterface(client, router.ID, riOpts).Extract()
if err != nil {
t.Fatalf("Failed to remove interface from router: %v", err)
}
}
// DeleteRouterInterface will detach a subnet to a router. A fatal error will
// occur if the deletion failed. This works best when used as a deferred
// function.
func DeleteRouterInterface(t *testing.T, client *gophercloud.ServiceClient, portID, routerID string) {
t.Logf("Attempting to detach port %s from router %s", portID, routerID)
riOpts := routers.RemoveInterfaceOpts{
PortID: portID,
}
_, err := routers.RemoveInterface(client, routerID, riOpts).Extract()
if err != nil {
t.Fatalf("Failed to detach port %s from router %s", portID, routerID)
}
if err := WaitForRouterInterfaceToDetach(client, portID, 60); err != nil {
t.Fatalf("Failed to wait for port %s to detach from router %s", portID, routerID)
}
t.Logf("Successfully detached port %s from router %s", portID, routerID)
}
func waitForRouterInterfaceDelete(networkingClient *gophercloud.ServiceClient, d *schema.ResourceData) resource.StateRefreshFunc {
return func() (interface{}, string, error) {
routerId := d.Get("router_id").(string)
routerInterfaceId := d.Id()
log.Printf("[DEBUG] Attempting to delete OpenStack Router Interface %s.", routerInterfaceId)
removeOpts := routers.RemoveInterfaceOpts{
SubnetID: d.Get("subnet_id").(string),
PortID: d.Get("port_id").(string),
}
r, err := ports.Get(networkingClient, routerInterfaceId).Extract()
if err != nil {
if _, ok := err.(gophercloud.ErrDefault404); ok {
log.Printf("[DEBUG] Successfully deleted OpenStack Router Interface %s", routerInterfaceId)
return r, "DELETED", nil
}
return r, "ACTIVE", err
}
_, err = routers.RemoveInterface(networkingClient, routerId, removeOpts).Extract()
if err != nil {
if _, ok := err.(gophercloud.ErrDefault404); ok {
log.Printf("[DEBUG] Successfully deleted OpenStack Router Interface %s.", routerInterfaceId)
return r, "DELETED", nil
}
if errCode, ok := err.(gophercloud.ErrUnexpectedResponseCode); ok {
if errCode.Actual == 409 {
log.Printf("[DEBUG] Router Interface %s is still in use.", routerInterfaceId)
return r, "ACTIVE", nil
}
}
return r, "ACTIVE", err
}
log.Printf("[DEBUG] OpenStack Router Interface %s is still active.", routerInterfaceId)
return r, "ACTIVE", nil
}
}
// Delete network by networkName
func (os *OpenStack) DeleteNetwork(networkName string) error {
osNetwork, err := os.getOpenStackNetworkByName(networkName)
if err != nil {
glog.Errorf("Get openstack network failed: %v", err)
return err
}
if osNetwork != nil {
// Delete ports
opts := ports.ListOpts{NetworkID: osNetwork.ID}
pager := ports.List(os.network, opts)
err := pager.EachPage(func(page pagination.Page) (bool, error) {
portList, err := ports.ExtractPorts(page)
if err != nil {
glog.Errorf("Get openstack ports error: %v", err)
return false, err
}
for _, port := range portList {
if port.DeviceOwner == "network:router_interface" {
continue
}
err = ports.Delete(os.network, port.ID).ExtractErr()
if err != nil {
glog.Warningf("Delete port %v failed: %v", port.ID, err)
}
}
return true, nil
})
if err != nil {
glog.Errorf("Delete ports error: %v", err)
}
router, err := os.getRouterByName(networkName)
if err != nil {
glog.Errorf("Get openstack router %s error: %v", networkName, err)
return err
}
// delete all subnets
for _, subnet := range osNetwork.Subnets {
if router != nil {
opts := routers.RemoveInterfaceOpts{SubnetID: subnet}
_, err := routers.RemoveInterface(os.network, router.ID, opts).Extract()
if err != nil {
glog.Errorf("Get openstack router %s error: %v", networkName, err)
return err
}
}
err = subnets.Delete(os.network, subnet).ExtractErr()
if err != nil {
glog.Errorf("Delete openstack subnet %s error: %v", subnet, err)
return err
}
}
// delete router
if router != nil {
err = routers.Delete(os.network, router.ID).ExtractErr()
if err != nil {
glog.Errorf("Delete openstack router %s error: %v", router.ID, err)
return err
}
}
// delete network
err = networks.Delete(os.network, osNetwork.ID).ExtractErr()
if err != nil {
glog.Errorf("Delete openstack network %s error: %v", osNetwork.ID, err)
return err
}
}
return nil
}