func waitForNetworkDelete(networkingClient *gophercloud.ServiceClient, networkId string) resource.StateRefreshFunc { return func() (interface{}, string, error) { log.Printf("[DEBUG] Attempting to delete OpenStack Network %s.\n", networkId) n, err := networks.Get(networkingClient, networkId).Extract() if err != nil { if _, ok := err.(gophercloud.ErrDefault404); ok { log.Printf("[DEBUG] Successfully deleted OpenStack Network %s", networkId) return n, "DELETED", nil } return n, "ACTIVE", err } err = networks.Delete(networkingClient, networkId).ExtractErr() if err != nil { if _, ok := err.(gophercloud.ErrDefault404); ok { log.Printf("[DEBUG] Successfully deleted OpenStack Network %s", networkId) return n, "DELETED", nil } if errCode, ok := err.(gophercloud.ErrUnexpectedResponseCode); ok { if errCode.Actual == 409 { return n, "ACTIVE", nil } } return n, "ACTIVE", err } log.Printf("[DEBUG] OpenStack Network %s still active.\n", networkId) return n, "ACTIVE", nil } }
// DeleteNetwork will delete a network with a specified ID. A fatal error will // occur if the delete was not successful. This works best when used as a // deferred function. func DeleteNetwork(t *testing.T, client *gophercloud.ServiceClient, networkID string) { t.Logf("Attempting to delete network: %s", networkID) err := networks.Delete(client, networkID).ExtractErr() if err != nil { t.Fatalf("Unable to delete network %s: %v", networkID, err) } t.Logf("Deleted network: %s", networkID) }
// 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 TestDelete(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() th.Mux.HandleFunc("/v2.0/networks/4e8e5957-649f-477b-9e5b-f1f75b21c03c", func(w http.ResponseWriter, r *http.Request) { th.TestMethod(t, r, "DELETE") th.TestHeader(t, r, "X-Auth-Token", fake.TokenID) w.WriteHeader(http.StatusNoContent) }) res := networks.Delete(fake.ServiceClient(), "4e8e5957-649f-477b-9e5b-f1f75b21c03c") th.AssertNoErr(t, res.Err) }
func TestNeutron(t *testing.T) { authUrl := os.Getenv("OS_AUTH_URL") username := os.Getenv("OS_USERNAME") password := os.Getenv("OS_PASSWORD") tenantName := os.Getenv("OS_TENANT_NAME") regionName := os.Getenv("OS_REGION_NAME") opts := gophercloud.AuthOptions{ IdentityEndpoint: authUrl, Username: username, Password: password, TenantName: tenantName, } provider, err := openstack.AuthenticatedClient(opts) if err != nil { t.Fatal(err.Error()) } client, err := openstack.NewNetworkV2(provider, gophercloud.EndpointOpts{ Name: "neutron", Region: regionName, Availability: gophercloud.AvailabilityPublic, }) if err != nil { t.Fatalf("Failed to create neutron client: %s", err.Error()) } netResult := networks.Create(client, networks.CreateOpts{Name: "skydive-test-network"}) if netResult.Err != nil { t.Fatalf("Failed to create neutron network: %s", netResult.Err.Error()) } network, err := netResult.Extract() if err != nil { t.Fatalf("Failed to create neutron network: %s", err.Error()) } subResult := subnets.Create(client, subnets.CreateOpts{Name: "skydive-test-subnet", NetworkID: network.ID, CIDR: "192.168.1.0/24", IPVersion: 4}) if subResult.Err != nil { t.Fatalf("Failed to create neutron subnet: %s", subResult.Err.Error()) } subnet, err := subResult.Extract() if err != nil { t.Fatalf("Failed to create neutron subnet: %s", err.Error()) } portResult := ports.Create(client, ports.CreateOpts{NetworkID: network.ID, DeviceID: "skydive-123", DeviceOwner: "skydive-test"}) if portResult.Err != nil { t.Fatalf("Failed to create neutron port: %s", subResult.Err.Error()) } port, err := portResult.Extract() if err != nil { t.Fatalf("Failed to create neutron port: %s", err.Error()) } defer ports.Delete(client, port.ID) defer subnets.Delete(client, subnet.ID) defer networks.Delete(client, network.ID) authOptions := &shttp.AuthenticationOpts{ Username: username, Password: password, } subID := port.ID[0:11] dev := fmt.Sprintf("tap%s", subID) ovsctl := `ovs-vsctl add-port br-int %s -- set Interface %s external-ids:iface-id=%s` ovsctl += ` external-ids:iface-status=active external-ids:attached-mac=%s external-ids:vm-uuid=skydive-vm type=internal` setupCmds := []helper.Cmd{ {fmt.Sprintf(ovsctl, dev, dev, port.ID, port.MACAddress), true}, {"sleep 1", true}, {fmt.Sprintf("ip link set %s up", dev), true}, } tearDownCmds := []helper.Cmd{ {fmt.Sprintf("ovs-vsctl del-port %s", dev), true}, } helper.ExecCmds(t, setupCmds...) defer helper.ExecCmds(t, tearDownCmds...) gh := helper.NewGremlinQueryHelper(authOptions) // let neutron update the port time.Sleep(5 * time.Second) nodes := gh.GetNodesFromGremlinReply(t, `g.V().Has("Manager", "neutron", "ExtID/vm-uuid", "skydive-vm", "Name", "`+dev+`", "Neutron/PortID", "`+port.ID+`")`) if len(nodes) != 1 { t.Errorf("Should find the neutron port in the topology: %v", gh.GetNodesFromGremlinReply(t, `g.V()`)) } }
// 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 }