Add DumpPortMappings API to retrieve ofport and MAC address for tap interfaces

Author: yrkurapati

ovs/openflow.go

@@ -21,6 +21,9 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"regexp"
+	"strconv"
+	"strings"
 )
 
 var (
@@ -69,6 +72,15 @@ type flowDirective struct {
 	flow      string
 }
 
+// PortMapping contains the ofport number and MAC address for an interface.
+type PortMapping struct {
+	// OfPort specifies the OpenFlow port number.
+	OfPort int
+
+	// MACAddress specifies the MAC address of the interface.
+	MACAddress string
+}
+
 // Possible flowDirective directive values.
 const (
 	dirAdd    = "add"
@@ -324,6 +336,54 @@ func (o *OpenFlowService) DumpAggregate(bridge string, flow *MatchFlow) (*FlowSt
 	return stats, nil
 }
 
+// DumpPortMappings retrieves port mappings (ofport and MAC address) for all
+// tap interfaces and the LOCAL port from the specified bridge. The output is
+// parsed from 'ovs-ofctl show' command.
+func (o *OpenFlowService) DumpPortMappings(bridge string) (map[string]*PortMapping, error) {
+	args := []string{"show", bridge}
+	args = append(args, o.c.ofctlFlags...)
+
+	out, err := o.exec(args...)
+	if err != nil {
+		return nil, err
+	}
+
+	mappings := make(map[string]*PortMapping)
+	scanner := bufio.NewScanner(bytes.NewReader(out))
+
+	for scanner.Scan() {
+		line := scanner.Bytes()
+		matches := portMappingPattern.FindSubmatch(line)
+		if len(matches) != 4 {
+			// Skip lines that don't match the pattern
+			continue
+		}
+
+		interfaceName := string(matches[2])
+		// Filter: only include interfaces starting with "tap" or "LOCAL"
+		if !strings.HasPrefix(interfaceName, "tap") && interfaceName != "LOCAL" {
+			continue
+		}
+
+		ofport, err := strconv.Atoi(string(matches[1]))
+		if err != nil {
+			// Skip malformed ofport numbers
+			continue
+		}
+
+		mappings[interfaceName] = &PortMapping{
+			OfPort:     ofport,
+			MACAddress: string(matches[3]),
+		}
+	}
+
+	if err := scanner.Err(); err != nil {
+		return nil, fmt.Errorf("failed to parse port mappings: %w", err)
+	}
+
+	return mappings, nil
+}
+
 var (
 	// dumpPortsPrefix is a sentinel value returned at the beginning of
 	// the output from 'ovs-ofctl dump-ports'.
@@ -343,6 +403,11 @@ var (
 	// dumpAggregatePrefix is a sentinel value returned at the beginning of
 	// the output from "ovs-ofctl dump-aggregate"
 	//dumpAggregatePrefix = []byte("NXST_AGGREGATE reply")
+
+	// portMappingPattern matches port lines from 'ovs-ofctl show' output.
+	// Pattern matches: " 7(tapext10396233): addr:fe:4f:76:09:88:2b"
+	// or " 65534(LOCAL): addr:fe:4f:76:09:88:2b"
+	portMappingPattern = regexp.MustCompile(`^\s*(\d+)\(([^)]+)\):\s*addr:([a-fA-F0-9:]+)`)
 )
 
 // dumpPorts calls 'ovs-ofctl dump-ports' with the specified arguments and

ovs/openflow_test.go

@@ -1415,3 +1415,208 @@ func mustVerifyFlowBundle(t *testing.T, stdin io.Reader, flows []*Flow, matchFlo
 		}
 	}
 }
+
+func TestClientOpenFlowDumpPortMappingsOK(t *testing.T) {
+	want := map[string]*PortMapping{
+		"tapext10396233": {
+			OfPort:     7,
+			MACAddress: "fe:4f:76:09:88:2b",
+		},
+		"tapext12716181": {
+			OfPort:     8,
+			MACAddress: "fe:be:7b:0d:53:d8",
+		},
+		"tapext10864673": {
+			OfPort:     9,
+			MACAddress: "fe:b6:4c:d5:40:79",
+		},
+		"tapint10396233": {
+			OfPort:     20,
+			MACAddress: "fe:cf:a6:90:30:29",
+		},
+		"LOCAL": {
+			OfPort:     65534,
+			MACAddress: "fe:74:0f:80:cf:9a",
+		},
+	}
+
+	bridge := "br0"
+
+	c := testClient([]OptionFunc{Timeout(1)}, func(cmd string, args ...string) ([]byte, error) {
+		// Verify correct command and arguments passed, including option flags
+		if want, got := "ovs-ofctl", cmd; want != got {
+			t.Fatalf("incorrect command:\n- want: %v\n-  got: %v",
+				want, got)
+		}
+
+		wantArgs := []string{"--timeout=1", "show", bridge}
+		if want, got := wantArgs, args; !reflect.DeepEqual(want, got) {
+			t.Fatalf("incorrect arguments\n- want: %v\n-  got: %v",
+				want, got)
+		}
+
+		return []byte(`
+OFPT_FEATURES_REPLY (xid=0x2): dpid:0000000000000001
+n_tables:254, n_buffers:256
+capabilities: FLOW_STATS TABLE_STATS PORT_STATS QUEUE_STATS ARP_MATCH_IP
+actions: output enqueue set_vlan_vid set_vlan_pcp strip_vlan mod_dl_src mod_dl_dst mod_nw_src mod_nw_dst mod_nw_tos mod_tp_src mod_tp_dst
+ 7(tapext10396233): addr:fe:4f:76:09:88:2b
+     config:     0
+     state:      0
+     current:    10GB-FD COPPER
+     speed: 10000 Mbps now, 0 Mbps max
+ 8(tapext12716181): addr:fe:be:7b:0d:53:d8
+     config:     0
+     state:      0
+     current:    10GB-FD COPPER
+     speed: 10000 Mbps now, 0 Mbps max
+ 9(tapext10864673): addr:fe:b6:4c:d5:40:79
+     config:     0
+     state:      0
+     current:    10GB-FD COPPER
+     speed: 10000 Mbps now, 0 Mbps max
+ 20(tapint10396233): addr:fe:cf:a6:90:30:29
+     config:     0
+     state:      0
+     current:    10GB-FD COPPER
+     speed: 10000 Mbps now, 0 Mbps max
+ 65534(LOCAL): addr:fe:74:0f:80:cf:9a
+     config:     0
+     state:      0
+     current:    10GB-FD COPPER
+     speed: 10000 Mbps now, 0 Mbps max
+ 1(non-tap-interface): addr:aa:bb:cc:dd:ee:ff
+     config:     0
+     state:      0
+`), nil
+	})
+
+	got, err := c.OpenFlow.DumpPortMappings(bridge)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if len(want) != len(got) {
+		t.Fatalf("unexpected number of mappings:\n- want: %d\n-  got: %d",
+			len(want), len(got))
+	}
+
+	for name, wantMapping := range want {
+		gotMapping, ok := got[name]
+		if !ok {
+			t.Fatalf("missing mapping for interface %q", name)
+		}
+
+		if wantMapping.OfPort != gotMapping.OfPort {
+			t.Fatalf("unexpected OfPort for %q:\n- want: %d\n-  got: %d",
+				name, wantMapping.OfPort, gotMapping.OfPort)
+		}
+
+		if wantMapping.MACAddress != gotMapping.MACAddress {
+			t.Fatalf("unexpected MACAddress for %q:\n- want: %q\n-  got: %q",
+				name, wantMapping.MACAddress, gotMapping.MACAddress)
+		}
+	}
+
+	// Verify non-tap interfaces are filtered out
+	if _, ok := got["non-tap-interface"]; ok {
+		t.Fatalf("non-tap interface should be filtered out")
+	}
+}
+
+func TestClientOpenFlowDumpPortMappingsEmptyOutput(t *testing.T) {
+	bridge := "br0"
+
+	c := testClient(nil, func(cmd string, args ...string) ([]byte, error) {
+		return []byte(""), nil
+	})
+
+	got, err := c.OpenFlow.DumpPortMappings(bridge)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if len(got) != 0 {
+		t.Fatalf("unexpected mappings for empty output:\n- want: 0\n-  got: %d", len(got))
+	}
+}
+
+func TestClientOpenFlowDumpPortMappingsNoTapInterfaces(t *testing.T) {
+	bridge := "br0"
+
+	c := testClient(nil, func(cmd string, args ...string) ([]byte, error) {
+		return []byte(`
+OFPT_FEATURES_REPLY (xid=0x2): dpid:0000000000000001
+ 1(eth0): addr:aa:bb:cc:dd:ee:ff
+ 2(eth1): addr:11:22:33:44:55:66
+`), nil
+	})
+
+	got, err := c.OpenFlow.DumpPortMappings(bridge)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if len(got) != 0 {
+		t.Fatalf("unexpected mappings (should be empty):\n- want: 0\n-  got: %d", len(got))
+	}
+}
+
+func TestClientOpenFlowDumpPortMappingsOnlyLOCAL(t *testing.T) {
+	want := map[string]*PortMapping{
+		"LOCAL": {
+			OfPort:     65534,
+			MACAddress: "fe:74:0f:80:cf:9a",
+		},
+	}
+
+	bridge := "br0"
+
+	c := testClient(nil, func(cmd string, args ...string) ([]byte, error) {
+		return []byte(`
+OFPT_FEATURES_REPLY (xid=0x2): dpid:0000000000000001
+ 65534(LOCAL): addr:fe:74:0f:80:cf:9a
+`), nil
+	})
+
+	got, err := c.OpenFlow.DumpPortMappings(bridge)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if len(want) != len(got) {
+		t.Fatalf("unexpected number of mappings:\n- want: %d\n-  got: %d",
+			len(want), len(got))
+	}
+
+	for name, wantMapping := range want {
+		gotMapping, ok := got[name]
+		if !ok {
+			t.Fatalf("missing mapping for interface %q", name)
+		}
+
+		if wantMapping.OfPort != gotMapping.OfPort {
+			t.Fatalf("unexpected OfPort for %q:\n- want: %d\n-  got: %d",
+				name, wantMapping.OfPort, gotMapping.OfPort)
+		}
+
+		if wantMapping.MACAddress != gotMapping.MACAddress {
+			t.Fatalf("unexpected MACAddress for %q:\n- want: %q\n-  got: %q",
+				name, wantMapping.MACAddress, gotMapping.MACAddress)
+		}
+	}
+}
+
+func TestClientOpenFlowDumpPortMappingsCommandError(t *testing.T) {
+	bridge := "br0"
+	wantErr := errors.New("command failed")
+
+	c := testClient(nil, func(cmd string, args ...string) ([]byte, error) {
+		return nil, wantErr
+	})
+
+	_, err := c.OpenFlow.DumpPortMappings(bridge)
+	if err == nil {
+		t.Fatalf("expected error, got nil")
+	}
+}