// Unbind an port from external
func (os *OpenStack) UnbindPortFromExternal(portName string) error {
port, err := os.GetPort(portName)
if err != nil {
glog.Errorf("get port failed: %v", err)
return err
}
fip, err := os.getFloatingIPByPort(port.ID)
if err != nil {
glog.Errorf("get floatingip failed: %v", err)
return err
}
if fip != nil {
err = floatingips.Delete(os.network, fip.ID).ExtractErr()
if err != nil {
glog.Errorf("delete floatingip failed: %v", err)
return err
}
}
err = ports.Delete(os.network, port.ID).ExtractErr()
if err != nil {
glog.Errorf("delete port failed: %v", err)
return err
}
return nil
}
func waitForNetworkPortDelete(networkingClient *gophercloud.ServiceClient, portId string) resource.StateRefreshFunc {
return func() (interface{}, string, error) {
log.Printf("[DEBUG] Attempting to delete OpenStack Neutron Port %s", portId)
p, err := ports.Get(networkingClient, portId).Extract()
if err != nil {
if _, ok := err.(gophercloud.ErrDefault404); ok {
log.Printf("[DEBUG] Successfully deleted OpenStack Port %s", portId)
return p, "DELETED", nil
}
return p, "ACTIVE", err
}
err = ports.Delete(networkingClient, portId).ExtractErr()
if err != nil {
if _, ok := err.(gophercloud.ErrDefault404); ok {
log.Printf("[DEBUG] Successfully deleted OpenStack Port %s", portId)
return p, "DELETED", nil
}
return p, "ACTIVE", err
}
log.Printf("[DEBUG] OpenStack Port %s still active.\n", portId)
return p, "ACTIVE", nil
}
}
// DeletePort will delete a port 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 DeletePort(t *testing.T, client *gophercloud.ServiceClient, portID string) {
t.Logf("Attempting to delete port: %s", portID)
err := ports.Delete(client, portID).ExtractErr()
if err != nil {
t.Fatalf("Unable to delete port %s: %v", portID, err)
}
t.Logf("Deleted port: %s", portID)
}
func TestDelete(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
th.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0d", 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 := ports.Delete(fake.ServiceClient(), "65c0ee9f-d634-4522-8954-51021b570b0d")
th.AssertNoErr(t, res.Err)
}
// Delete port by portName
func (os *OpenStack) DeletePort(portName string) error {
port, err := os.GetPort(portName)
if err == ErrNotFound {
glog.V(4).Infof("Port %s already deleted", portName)
return nil
} else if err != nil {
glog.Errorf("Get openstack port %s failed: %v", portName, err)
return err
}
if port != nil {
err := ports.Delete(os.network, port.ID).ExtractErr()
if err != nil {
glog.Errorf("Delete openstack port %s failed: %v", portName, err)
return err
}
}
return nil
}
// Create an port
func (os *OpenStack) CreatePort(networkID, tenantID, portName, podHostname string) (*portsbinding.Port, error) {
securitygroup, err := os.ensureSecurityGroup(tenantID)
if err != nil {
glog.Errorf("EnsureSecurityGroup failed: %v", err)
return nil, err
}
opts := portsbinding.CreateOpts{
HostID: getHostName(),
DNSName: podHostname,
CreateOptsBuilder: ports.CreateOpts{
NetworkID: networkID,
Name: portName,
AdminStateUp: &adminStateUp,
TenantID: tenantID,
DeviceID: uuid.Generate().String(),
DeviceOwner: fmt.Sprintf("compute:%s", getHostName()),
SecurityGroups: []string{securitygroup},
},
}
port, err := portsbinding.Create(os.network, opts).Extract()
if err != nil {
glog.Errorf("Create port %s failed: %v", portName, err)
return nil, err
}
// Update dns_name in order to make sure it is correct
updateOpts := portsbinding.UpdateOpts{
DNSName: podHostname,
}
_, err = portsbinding.Update(os.network, port.ID, updateOpts).Extract()
if err != nil {
ports.Delete(os.network, port.ID)
glog.Errorf("Update port %s failed: %v", portName, err)
return nil, err
}
return port, nil
}
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
}
// Setup pod
func (os *OpenStack) SetupPod(podName, namespace, podInfraContainerID string, network *provider.Network, containerRuntime string) error {
portName := os.BuildPortName(podName, namespace, network.Uid)
// get dns server ips
dnsServers := make([]string, 0, 1)
networkPorts, err := os.ListPorts(network.Uid, "network:dhcp")
if err != nil {
glog.Errorf("Query dhcp ports failed: %v", err)
return err
}
for _, p := range networkPorts {
dnsServers = append(dnsServers, p.FixedIPs[0].IPAddress)
}
// get port from openstack; if port doesn't exist, create a new one
port, err := os.GetPort(portName)
if err == ErrNotFound || port == nil {
podHostname := strings.Split(podName, "_")[0]
if len(podHostname) > hostnameMaxLen {
podHostname = podHostname[:hostnameMaxLen]
}
// Port not found, create one
portWithBinding, err := os.CreatePort(network.Uid, network.TenantID, portName, podHostname)
if err != nil {
glog.Errorf("CreatePort failed: %v", err)
return err
}
port = &portWithBinding.Port
} else if err != nil {
glog.Errorf("GetPort failed: %v", err)
return err
}
deviceOwner := fmt.Sprintf("compute:%s", getHostName())
if port.DeviceOwner != deviceOwner {
// Update hostname in order to make sure it is correct
updateOpts := portsbinding.UpdateOpts{
HostID: getHostName(),
UpdateOptsBuilder: ports.UpdateOpts{
DeviceOwner: deviceOwner,
},
}
_, err = portsbinding.Update(os.network, port.ID, updateOpts).Extract()
if err != nil {
ports.Delete(os.network, port.ID)
glog.Errorf("Update port %s failed: %v", portName, err)
return err
}
}
glog.V(4).Infof("Pod %s's port is %v", podName, port)
// get subnet and gateway
subnet, err := os.getProviderSubnet(port.FixedIPs[0].SubnetID)
if err != nil {
glog.Errorf("Get info of subnet %s failed: %v", port.FixedIPs[0].SubnetID, err)
if nil != ports.Delete(os.network, port.ID).ExtractErr() {
glog.Warningf("Delete port %s failed", port.ID)
}
return err
}
// setup interface for pod
_, cidr, _ := net.ParseCIDR(subnet.Cidr)
prefixSize, _ := cidr.Mask.Size()
err = os.Plugin.SetupInterface(podName+"_"+namespace, podInfraContainerID, port,
fmt.Sprintf("%s/%d", port.FixedIPs[0].IPAddress, prefixSize),
subnet.Gateway, dnsServers, containerRuntime)
if err != nil {
glog.Errorf("SetupInterface failed: %v", err)
if nil != ports.Delete(os.network, port.ID).ExtractErr() {
glog.Warningf("Delete port %s failed", port.ID)
}
return err
}
return nil
}