Fix support for VPP 19.08

Signed-off-by: Ondrej Fabry <ofabry@cisco.com>

Makefile

@@ -128,9 +128,9 @@ get-binapi-generators:
 # Generate binary api
 generate-binapi: get-binapi-generators
 	@echo "=> generating binapi"
-	cd plugins/vpp/binapi && go generate ./...
+	cd plugins/vpp/binapi/vpp1904 && go generate ./...
 	@echo "=> applying fix patches"
-	find plugins/vpp/binapi -maxdepth 2 -type f -name '*.patch' -exec patch --no-backup-if-mismatch -p1 -i {} \;
+	find plugins/vpp/binapi/vpp1904 -maxdepth 2 -type f -name '*.patch' -exec patch --no-backup-if-mismatch -p1 -i {} \;
 	@echo
 
 get-desc-adapter-generator:

plugins/vpp/ifplugin/vppcalls/vpp1908/dump_interface_vppcalls.go

@@ -335,44 +335,6 @@ func (h *InterfaceVppHandler) DumpDhcpClients() (map[uint32]*vppcalls.Dhcp, erro
 	return dhcpData, nil
 }
 
-// DumpInterfaceStates dumps link and administrative state of every interface.
-func (h *InterfaceVppHandler) DumpInterfaceStates() (map[uint32]*vppcalls.InterfaceState, error) {
-	ifs := make(map[uint32]*vppcalls.InterfaceState)
-
-	reqCtx := h.callsChannel.SendMultiRequest(&binapi_interface.SwInterfaceDump{})
-	for {
-		ifDetails := &binapi_interface.SwInterfaceDetails{}
-		stop, err := reqCtx.ReceiveReply(ifDetails)
-		if stop {
-			break // Break from the loop.
-		}
-		if err != nil {
-			return nil, fmt.Errorf("failed to dump interface: %v", err)
-		}
-
-		ifaceState := &vppcalls.InterfaceState{}
-		switch ifDetails.AdminUpDown {
-		case 0:
-			ifaceState.AdminState = interfaces.InterfaceState_DOWN
-		case 1:
-			ifaceState.AdminState = interfaces.InterfaceState_UP
-		default:
-			ifaceState.AdminState = interfaces.InterfaceState_UNKNOWN_STATUS
-		}
-		switch ifDetails.LinkUpDown {
-		case 0:
-			ifaceState.LinkState = interfaces.InterfaceState_DOWN
-		case 1:
-			ifaceState.LinkState = interfaces.InterfaceState_UP
-		default:
-			ifaceState.LinkState = interfaces.InterfaceState_UNKNOWN_STATUS
-		}
-		ifs[ifDetails.SwIfIndex] = ifaceState
-	}
-
-	return ifs, nil
-}
-
 // Returns true if given interface contains at least one IPv6 address. For VxLAN, source and destination
 // addresses are also checked
 func (h *InterfaceVppHandler) isIpv6Interface(iface *interfaces.Interface) (bool, error) {
@@ -803,29 +765,19 @@ func (h *InterfaceVppHandler) dumpRxPlacement(ifs map[uint32]*vppcalls.Interface
 		if stop {
 			break
 		}
-
 		ifData, ok := ifs[rxDetails.SwIfIndex]
 		if !ok {
 			h.log.Warnf("Received rx-placement data for unknown interface with index %d", rxDetails.SwIfIndex)
 			continue
 		}
-
-		ifData.Interface.RxModes = append(ifData.Interface.RxModes,
-			&interfaces.Interface_RxMode{
-				Queue: rxDetails.QueueID,
-				Mode:  getRxModeType(rxDetails.Mode),
-			})
-
-		var worker uint32
-		if rxDetails.WorkerID > 0 {
-			worker = rxDetails.WorkerID - 1
+		ifData.Interface.RxModeSettings = &interfaces.Interface_RxModeSettings{
+			RxMode:  getRxModeType(rxDetails.Mode),
+			QueueId: rxDetails.QueueID,
+		}
+		ifData.Interface.RxPlacementSettings = &interfaces.Interface_RxPlacementSettings{
+			Queue:  rxDetails.QueueID,
+			Worker: rxDetails.WorkerID,
 		}
-		ifData.Interface.RxPlacements = append(ifData.Interface.RxPlacements,
-			&interfaces.Interface_RxPlacement{
-				Queue:      rxDetails.QueueID,
-				Worker:     worker,
-				MainThread: rxDetails.WorkerID == 0,
-			})
 	}
 	return nil
 }
@@ -880,18 +832,18 @@ func memifModetoNB(mode uint8) interfaces.MemifLink_MemifMode {
 }
 
 // Convert binary API rx-mode to northbound representation
-func getRxModeType(mode uint8) interfaces.Interface_RxMode_Type {
+func getRxModeType(mode uint8) interfaces.Interface_RxModeSettings_RxModeType {
 	switch mode {
 	case 1:
-		return interfaces.Interface_RxMode_POLLING
+		return interfaces.Interface_RxModeSettings_POLLING
 	case 2:
-		return interfaces.Interface_RxMode_INTERRUPT
+		return interfaces.Interface_RxModeSettings_INTERRUPT
 	case 3:
-		return interfaces.Interface_RxMode_ADAPTIVE
+		return interfaces.Interface_RxModeSettings_ADAPTIVE
 	case 4:
-		return interfaces.Interface_RxMode_DEFAULT
+		return interfaces.Interface_RxModeSettings_DEFAULT
 	default:
-		return interfaces.Interface_RxMode_UNKNOWN
+		return interfaces.Interface_RxModeSettings_UNKNOWN
 	}
 }
 

plugins/vpp/ifplugin/vppcalls/vpp1908/dump_interface_vppcalls_test.go

@@ -18,8 +18,6 @@ import (
 	"net"
 	"testing"
 
-	govppapi "git.fd.io/govpp.git/api"
-
 	interfaces2 "github.com/ligato/vpp-agent/api/models/vpp/interfaces"
 	"github.com/ligato/vpp-agent/plugins/vpp/binapi/vpp1908/dhcp"
 	"github.com/ligato/vpp-agent/plugins/vpp/binapi/vpp1908/interfaces"
@@ -306,113 +304,3 @@ func TestDumpMemifSocketDetails(t *testing.T) {
 	Expect(ok).To(BeTrue())
 	Expect(socketID).To(Equal(uint32(1)))
 }
-
-func TestDumpInterfacesRxPlacement(t *testing.T) {
-	ctx, ifHandler := ifTestSetup(t)
-	defer ctx.TeardownTestCtx()
-
-	ctx.MockReplies([]*vppcallmock.HandleReplies{
-		{
-			Name: (&interfaces.SwInterfaceDump{}).GetMessageName(),
-			Ping: true,
-			Message: &interfaces.SwInterfaceDetails{
-				InterfaceName: []byte("memif1"),
-			},
-		},
-		{
-			Name:    (&interfaces.SwInterfaceGetTable{}).GetMessageName(),
-			Ping:    false,
-			Message: &interfaces.SwInterfaceGetTableReply{},
-		},
-		{
-			Name:    (&ip.IPAddressDump{}).GetMessageName(),
-			Ping:    true,
-			Message: &ip.IPAddressDetails{},
-		},
-		{
-			Name: (&memif.MemifSocketFilenameDump{}).GetMessageName(),
-			Ping: true,
-			Message: &memif.MemifSocketFilenameDetails{
-				SocketID:       1,
-				SocketFilename: []byte("test"),
-			},
-		},
-		{
-			Name: (&memif.MemifDump{}).GetMessageName(),
-			Ping: true,
-			Message: &memif.MemifDetails{
-				ID:         2,
-				SwIfIndex:  0,
-				Role:       1, // Slave
-				Mode:       1, // IP
-				SocketID:   1,
-				RingSize:   0,
-				BufferSize: 0,
-			},
-		},
-		{
-			Name: (&tapv2.SwInterfaceTapV2Dump{}).GetMessageName(),
-			Ping: true,
-		},
-		{
-			Name: (&vxlan.VxlanTunnelDump{}).GetMessageName(),
-			Ping: true,
-		},
-		{
-			Name: (&interfaces.SwInterfaceRxPlacementDump{}).GetMessageName(),
-			Ping: true,
-			Messages: []govppapi.Message{
-				&interfaces.SwInterfaceRxPlacementDetails{
-					SwIfIndex: 0,
-					QueueID:   0,
-					WorkerID:  0, // main thread
-					Mode:      3, // adaptive
-				},
-				&interfaces.SwInterfaceRxPlacementDetails{
-					SwIfIndex: 0,
-					QueueID:   1,
-					WorkerID:  1, // worker 0
-					Mode:      2, // interrupt
-				},
-				&interfaces.SwInterfaceRxPlacementDetails{
-					SwIfIndex: 0,
-					QueueID:   2,
-					WorkerID:  2, // worker 1
-					Mode:      1, // polling
-				},
-			},
-		},
-	})
-
-	intfs, err := ifHandler.DumpInterfaces()
-	Expect(err).To(BeNil())
-	Expect(intfs).To(HaveLen(1))
-	intface := intfs[0].Interface
-
-	// Check memif
-	Expect(intface.GetMemif().SocketFilename).To(Equal("test"))
-	Expect(intface.GetMemif().Id).To(Equal(uint32(2)))
-	Expect(intface.GetMemif().Mode).To(Equal(interfaces2.MemifLink_IP))
-	Expect(intface.GetMemif().Master).To(BeFalse())
-
-	rxMode := intface.GetRxModes()
-	Expect(rxMode).To(HaveLen(3))
-	Expect(rxMode[0].Queue).To(BeEquivalentTo(0))
-	Expect(rxMode[0].Mode).To(BeEquivalentTo(interfaces2.Interface_RxMode_ADAPTIVE))
-	Expect(rxMode[1].Queue).To(BeEquivalentTo(1))
-	Expect(rxMode[1].Mode).To(BeEquivalentTo(interfaces2.Interface_RxMode_INTERRUPT))
-	Expect(rxMode[2].Queue).To(BeEquivalentTo(2))
-	Expect(rxMode[2].Mode).To(BeEquivalentTo(interfaces2.Interface_RxMode_POLLING))
-
-	rxPlacement := intface.GetRxPlacements()
-	Expect(rxPlacement).To(HaveLen(3))
-	Expect(rxPlacement[0].Queue).To(BeEquivalentTo(0))
-	Expect(rxPlacement[0].MainThread).To(BeTrue())
-	Expect(rxPlacement[0].Worker).To(BeEquivalentTo(0))
-	Expect(rxPlacement[1].Queue).To(BeEquivalentTo(1))
-	Expect(rxPlacement[1].MainThread).To(BeFalse())
-	Expect(rxPlacement[1].Worker).To(BeEquivalentTo(0))
-	Expect(rxPlacement[2].Queue).To(BeEquivalentTo(2))
-	Expect(rxPlacement[2].MainThread).To(BeFalse())
-	Expect(rxPlacement[2].Worker).To(BeEquivalentTo(1))
-}