func TestUpdate(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleUpdate(t)
options := portsbinding.UpdateOpts{
UpdateOptsBuilder: ports.UpdateOpts{
Name: "new_port_name",
FixedIPs: []ports.IP{
{SubnetID: "a0304c3a-4f08-4c43-88af-d796509c97d2", IPAddress: "10.0.0.3"},
},
SecurityGroups: []string{"f0ac4394-7e4a-4409-9701-ba8be283dbc3"},
},
HostID: "HOST1",
VNICType: "normal",
}
s, err := portsbinding.Update(fake.ServiceClient(), "65c0ee9f-d634-4522-8954-51021b570b0d", options).Extract()
th.AssertNoErr(t, err)
th.AssertEquals(t, s.Name, "new_port_name")
th.AssertDeepEquals(t, s.FixedIPs, []ports.IP{
{SubnetID: "a0304c3a-4f08-4c43-88af-d796509c97d2", IPAddress: "10.0.0.3"},
})
th.AssertDeepEquals(t, s.SecurityGroups, []string{"f0ac4394-7e4a-4409-9701-ba8be283dbc3"})
th.AssertEquals(t, s.HostID, "HOST1")
th.AssertEquals(t, s.VNICType, "normal")
}
func TestPortsbindingCRUD(t *testing.T) {
client, err := clients.NewNetworkV2Client()
if err != nil {
t.Fatalf("Unable to create a network client: %v", err)
}
// Create Network
network, err := networking.CreateNetwork(t, client)
if err != nil {
t.Fatalf("Unable to create network: %v", err)
}
defer networking.DeleteNetwork(t, client, network.ID)
// Create Subnet
subnet, err := networking.CreateSubnet(t, client, network.ID)
if err != nil {
t.Fatalf("Unable to create subnet: %v", err)
}
defer networking.DeleteSubnet(t, client, subnet.ID)
// Define a host
hostID := "localhost"
// Create port
port, err := CreatePortsbinding(t, client, network.ID, subnet.ID, hostID)
if err != nil {
t.Fatalf("Unable to create port: %v", err)
}
defer networking.DeletePort(t, client, port.ID)
PrintPortsbinding(t, port)
// Update port
newPortName := tools.RandomString("TESTACC-", 8)
updateOpts := ports.UpdateOpts{
Name: newPortName,
}
newPort, err := portsbinding.Update(client, port.ID, updateOpts).Extract()
if err != nil {
t.Fatalf("Could not update port: %v", err)
}
PrintPortsbinding(t, newPort)
}
// 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
}
// 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
}
