// 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 }