Add support of trunk ports

Currenlty, getAttachedInterfacesByID() only returns neutron ports directly attached to VM.
For vlan-aware VMs that have trunk ports, subports attached to the trunk ports are not returned.
This pull request checks if VM has trunk ports, if so, adds their subports in the return.

Signed-off-by: Jing Zhang <[email protected]>

Author: Jing Zhang

pkg/openstack/instances.go

@@ -30,6 +30,9 @@ import (
 	"github.com/gophercloud/gophercloud/openstack/compute/v2/extensions/attachinterfaces"
 	"github.com/gophercloud/gophercloud/openstack/compute/v2/flavors"
 	"github.com/gophercloud/gophercloud/openstack/compute/v2/servers"
+	"github.com/gophercloud/gophercloud/openstack/networking/v2/extensions/trunks"
+	"github.com/gophercloud/gophercloud/openstack/networking/v2/networks"
+	"github.com/gophercloud/gophercloud/openstack/networking/v2/ports"
 	"github.com/gophercloud/gophercloud/pagination"
 	"github.com/mitchellh/mapstructure"
 	v1 "k8s.io/api/core/v1"
@@ -48,6 +51,7 @@ import (
 // Instances encapsulates an implementation of Instances for OpenStack.
 type Instances struct {
 	compute          *gophercloud.ServiceClient
+	network          *gophercloud.ServiceClient
 	region           string
 	regionProviderID bool
 	opts             metadata.Opts
@@ -148,13 +152,20 @@ func (os *OpenStack) instances() (*Instances, bool) {
 		return nil, false
 	}
 
+	network, err := client.NewNetworkV2(os.provider, os.epOpts)
+	if err != nil {
+		klog.Errorf("Failed to create an OpenStack Network client: %v", err)
+		return nil, false
+	}
+
 	regionalProviderID := false
 	if isRegionalProviderID := sysos.Getenv(RegionalProviderIDEnv); isRegionalProviderID == "true" {
 		regionalProviderID = true
 	}
 
 	return &Instances{
 		compute:          compute,
+		network:          network,
 		region:           os.epOpts.Region,
 		regionProviderID: regionalProviderID,
 		opts:             os.metadataOpts,
@@ -193,7 +204,7 @@ func (i *Instances) AddSSHKeyToAllInstances(ctx context.Context, user string, ke
 func (i *Instances) NodeAddresses(ctx context.Context, name types.NodeName) ([]v1.NodeAddress, error) {
 	klog.V(4).Infof("NodeAddresses(%v) called", name)
 
-	addrs, err := getAddressesByName(i.compute, name, i.networkingOpts)
+	addrs, err := getAddressesByName(i.compute, name, i.networkingOpts, i.network)
 	if err != nil {
 		return nil, err
 	}
@@ -226,7 +237,7 @@ func (i *Instances) NodeAddressesByProviderID(ctx context.Context, providerID st
 		return []v1.NodeAddress{}, err
 	}
 
-	interfaces, err := getAttachedInterfacesByID(i.compute, server.ID)
+	interfaces, err := getAttachedInterfacesByID(i.compute, server.ID, i.network)
 	if err != nil {
 		return []v1.NodeAddress{}, err
 	}
@@ -332,7 +343,7 @@ func (i *Instances) InstanceMetadata(ctx context.Context, node *v1.Node) (*cloud
 		return nil, err
 	}
 
-	interfaces, err := getAttachedInterfacesByID(i.compute, srv.ID)
+	interfaces, err := getAttachedInterfacesByID(i.compute, srv.ID, i.network)
 	if err != nil {
 		return nil, err
 	}
@@ -565,9 +576,15 @@ func getServerByName(client *gophercloud.ServiceClient, name types.NodeName) (*S
 // * metadata hostname
 // * server object Addresses (floating type)
 func nodeAddresses(srv *servers.Server, interfaces []attachinterfaces.Interface, networkingOpts NetworkingOpts) ([]v1.NodeAddress, error) {
+	type Address struct {
+		IPType string `mapstructure:"OS-EXT-IPS:type"`
+		Addr   string
+	}
+
 	addrs := []v1.NodeAddress{}
 
 	// parse private IP addresses first in an ordered manner
+	allPrivates := make(map[string][]Address)
 	for _, iface := range interfaces {
 		for _, fixedIP := range iface.FixedIPs {
 			if iface.PortState == "ACTIVE" {
@@ -579,6 +596,10 @@ func nodeAddresses(srv *servers.Server, interfaces []attachinterfaces.Interface,
 							Address: fixedIP.IPAddress,
 						},
 					)
+					if len(iface.NetID) > 0 {
+						addr := Address{IPType: "fixed", Addr: fixedIP.IPAddress}
+						allPrivates[iface.NetID] = append(allPrivates[iface.NetID], addr)
+					}
 				}
 			}
 		}
@@ -613,17 +634,40 @@ func nodeAddresses(srv *servers.Server, interfaces []attachinterfaces.Interface,
 	}
 
 	// process the rest
-	type Address struct {
-		IPType string `mapstructure:"OS-EXT-IPS:type"`
-		Addr   string
-	}
-
 	var addresses map[string][]Address
 	err := mapstructure.Decode(srv.Addresses, &addresses)
 	if err != nil {
 		return nil, err
 	}
 
+	// add subports if exist to the server
+	extraPrivates := make(map[string][]Address)
+	for k, v := range allPrivates {
+		ok := false
+		for _, a := range v {
+			for _, v1 := range addresses {
+				for _, a1 := range v1 {
+					if a.Addr == a1.Addr {
+						ok = true
+						break
+					}
+				}
+			}
+		}
+		if !ok {
+			extraPrivates[k] = v
+		}
+	}
+	klog.V(5).Infof("Node '%s' extraPrivates '%s'", srv.Name, extraPrivates)
+	for k, v := range extraPrivates {
+		v1, ok := addresses[k]
+		if !ok {
+			addresses[k] = v
+		} else {
+			addresses[k] = append(v1, v...)
+		}
+	}
+
 	var networks []string
 	for k := range addresses {
 		networks = append(networks, k)
@@ -677,26 +721,91 @@ func nodeAddresses(srv *servers.Server, interfaces []attachinterfaces.Interface,
 	return addrs, nil
 }
 
-func getAddressesByName(client *gophercloud.ServiceClient, name types.NodeName, networkingOpts NetworkingOpts) ([]v1.NodeAddress, error) {
-	srv, err := getServerByName(client, name)
+func getAddressesByName(compute *gophercloud.ServiceClient, name types.NodeName, networkingOpts NetworkingOpts, network *gophercloud.ServiceClient) ([]v1.NodeAddress, error) {
+	srv, err := getServerByName(compute, name)
 	if err != nil {
 		return nil, err
 	}
 
-	interfaces, err := getAttachedInterfacesByID(client, srv.ID)
+	interfaces, err := getAttachedInterfacesByID(compute, srv.ID, network)
 	if err != nil {
 		return nil, err
 	}
 
 	return nodeAddresses(&srv.Server, interfaces, networkingOpts)
 }
 
+// getSubInterfaces
+func getSubInterfaces(network *gophercloud.ServiceClient) ([]attachinterfaces.Interface, error) {
+	var interfaces []attachinterfaces.Interface
+
+	// Check if trunk ports are attached
+	listOpts := trunks.ListOpts{}
+	allPages, err := trunks.List(network, listOpts).AllPages()
+	if err != nil {
+		klog.Errorf("Failed to list trunks: %v", err)
+		return interfaces, err
+	}
+	allTrunks, err := trunks.ExtractTrunks(allPages)
+	if err != nil {
+		klog.Errorf("Failed to extract trunks: %v", err)
+		return interfaces, err
+	}
+
+	// Get subports attached to the trunk
+	var subports []trunks.Subport
+	for _, trunk := range allTrunks {
+		for _, iface := range interfaces {
+			if iface.PortID == trunk.PortID {
+				s, err := trunks.GetSubports(network, trunk.ID).Extract()
+				if err != nil {
+					klog.Errorf("Failed to get subports for trunk %s: %v", trunk.ID, err)
+					return interfaces, err
+				}
+				subports = append(subports, s...)
+			}
+		}
+	}
+	klog.V(5).Infof("subports %v", subports)
+
+	// Arrange subports as for directly attached ports
+	for _, sport := range subports {
+		p, err := ports.Get(network, sport.PortID).Extract()
+		if err != nil {
+			klog.Errorf("Failed to get port info for subport %s: %v", sport.PortID, err)
+			return interfaces, err
+		}
+		n, err := networks.Get(network, p.NetworkID).Extract()
+		if err != nil {
+			klog.Errorf("Failed to get network info for subport %s: %v", sport.PortID, err)
+			return interfaces, err
+		}
+		var iface = attachinterfaces.Interface{
+			PortState: "ACTIVE",
+			FixedIPs:  []attachinterfaces.FixedIP{},
+			PortID:    p.ID,
+			NetID:     n.Name,
+			MACAddr:   p.MACAddress,
+		}
+		for _, ip := range p.FixedIPs {
+			var ip2 = attachinterfaces.FixedIP{
+				SubnetID:  ip.SubnetID,
+				IPAddress: ip.IPAddress,
+			}
+			iface.FixedIPs = append(iface.FixedIPs, ip2)
+		}
+		interfaces = append(interfaces, iface)
+	}
+	klog.V(5).Infof("interfaces %v", interfaces)
+	return interfaces, nil
+}
+
 // getAttachedInterfacesByID returns the node interfaces of the specified instance.
-func getAttachedInterfacesByID(client *gophercloud.ServiceClient, serviceID string) ([]attachinterfaces.Interface, error) {
+func getAttachedInterfacesByID(compute *gophercloud.ServiceClient, serviceID string, network *gophercloud.ServiceClient) ([]attachinterfaces.Interface, error) {
 	var interfaces []attachinterfaces.Interface
 
 	mc := metrics.NewMetricContext("server_os_interface", "list")
-	pager := attachinterfaces.List(client, serviceID)
+	pager := attachinterfaces.List(compute, serviceID)
 	err := pager.EachPage(func(page pagination.Page) (bool, error) {
 		s, err := attachinterfaces.ExtractInterfaces(page)
 		if err != nil {
@@ -708,6 +817,10 @@ func getAttachedInterfacesByID(client *gophercloud.ServiceClient, serviceID stri
 	if mc.ObserveRequest(err) != nil {
 		return interfaces, err
 	}
-
+	subInterfaces, err := getSubInterfaces(network)
+	if err != nil {
+		return interfaces, err
+	}
+	interfaces = append(interfaces, subInterfaces...)
 	return interfaces, nil
 }

pkg/openstack/instancesv2.go

@@ -34,6 +34,7 @@ import (
 // InstancesV2 encapsulates an implementation of InstancesV2 for OpenStack.
 type InstancesV2 struct {
 	compute          *gophercloud.ServiceClient
+	network          *gophercloud.ServiceClient
 	region           string
 	regionProviderID bool
 	networkingOpts   NetworkingOpts
@@ -56,13 +57,20 @@ func (os *OpenStack) instancesv2() (*InstancesV2, bool) {
 		return nil, false
 	}
 
+	network, err := client.NewNetworkV2(os.provider, os.epOpts)
+	if err != nil {
+		klog.Errorf("unable to access network V2 API : %v", err)
+		return nil, false
+	}
+
 	regionalProviderID := false
 	if isRegionalProviderID := sysos.Getenv(RegionalProviderIDEnv); isRegionalProviderID == "true" {
 		regionalProviderID = true
 	}
 
 	return &InstancesV2{
 		compute:          compute,
+		network:          network,
 		region:           os.epOpts.Region,
 		regionProviderID: regionalProviderID,
 		networkingOpts:   os.networkingOpts,
@@ -115,7 +123,7 @@ func (i *InstancesV2) InstanceMetadata(ctx context.Context, node *v1.Node) (*clo
 		return nil, err
 	}
 
-	interfaces, err := getAttachedInterfacesByID(i.compute, server.ID)
+	interfaces, err := getAttachedInterfacesByID(i.compute, server.ID, i.network)
 	if err != nil {
 		return nil, err
 	}

pkg/openstack/loadbalancer.go

@@ -707,7 +707,7 @@ func getBoolFromServiceAnnotation(service *corev1.Service, annotationKey string,
 }
 
 // getSubnetIDForLB returns subnet-id for a specific node
-func getSubnetIDForLB(compute *gophercloud.ServiceClient, node corev1.Node, preferredIPFamily corev1.IPFamily) (string, error) {
+func getSubnetIDForLB(compute *gophercloud.ServiceClient, node corev1.Node, preferredIPFamily corev1.IPFamily, network *gophercloud.ServiceClient) (string, error) {
 	ipAddress, err := nodeAddressForLB(&node, preferredIPFamily)
 	if err != nil {
 		return "", err
@@ -718,7 +718,7 @@ func getSubnetIDForLB(compute *gophercloud.ServiceClient, node corev1.Node, pref
 		instanceID = instanceID[(ind + 1):]
 	}
 
-	interfaces, err := getAttachedInterfacesByID(compute, instanceID)
+	interfaces, err := getAttachedInterfacesByID(compute, instanceID, network)
 	if err != nil {
 		return "", err
 	}
@@ -1503,7 +1503,7 @@ func (lbaas *LbaasV2) checkServiceUpdate(service *corev1.Service, nodes []*corev
 		} else {
 			svcConf.lbMemberSubnetID = getStringFromServiceAnnotation(service, ServiceAnnotationLoadBalancerSubnetID, lbaas.opts.SubnetID)
 			if len(svcConf.lbMemberSubnetID) == 0 && len(nodes) > 0 {
-				subnetID, err := getSubnetIDForLB(lbaas.compute, *nodes[0], svcConf.preferredIPFamily)
+				subnetID, err := getSubnetIDForLB(lbaas.compute, *nodes[0], svcConf.preferredIPFamily, lbaas.network)
 				if err != nil {
 					return fmt.Errorf("no subnet-id found for service %s: %v", serviceName, err)
 				}
@@ -1617,7 +1617,7 @@ func (lbaas *LbaasV2) checkService(service *corev1.Service, nodes []*corev1.Node
 		svcConf.lbMemberSubnetID = svcConf.lbSubnetID
 	}
 	if len(svcConf.lbNetworkID) == 0 && len(svcConf.lbSubnetID) == 0 {
-		subnetID, err := getSubnetIDForLB(lbaas.compute, *nodes[0], svcConf.preferredIPFamily)
+		subnetID, err := getSubnetIDForLB(lbaas.compute, *nodes[0], svcConf.preferredIPFamily, lbaas.network)
 		if err != nil {
 			return fmt.Errorf("failed to get subnet to create load balancer for service %s: %v", serviceName, err)
 		}