diff options
Diffstat (limited to 'api')
| -rw-r--r-- | api/api.go | 314 | ||||
| -rw-r--r-- | api/api_test.go | 588 | ||||
| -rw-r--r-- | api/doc.go | 94 |
3 files changed, 54 insertions, 942 deletions
@@ -15,11 +15,7 @@ package api import ( - "errors" - "fmt" "time" - - "github.com/sirupsen/logrus" ) // MessageType represents the type of a VPP message. @@ -61,11 +57,11 @@ type DataType interface { type ChannelProvider interface { // NewAPIChannel returns a new channel for communication with VPP via govpp core. // It uses default buffer sizes for the request and reply Go channels. - NewAPIChannel() (*Channel, error) + NewAPIChannel() (Channel, error) // NewAPIChannelBuffered returns a new channel for communication with VPP via govpp core. // It allows to specify custom buffer sizes for the request and reply Go channels. - NewAPIChannelBuffered() (*Channel, error) + NewAPIChannelBuffered(reqChanBufSize, replyChanBufSize int) (Channel, error) } // MessageDecoder provides functionality for decoding binary data to generated API messages. @@ -82,26 +78,57 @@ type MessageIdentifier interface { LookupByID(ID uint16) (string, error) } -// Channel is the main communication interface with govpp core. It contains two Go channels, one for sending the requests -// to VPP and one for receiving the replies from it. The user can access the Go channels directly, or use the helper -// methods provided inside of this package. Do not use the same channel from multiple goroutines concurrently, -// otherwise the responses could mix! Use multiple channels instead. -type Channel struct { - ID uint16 // channel ID - - ReqChan chan *VppRequest // channel for sending the requests to VPP, closing this channel releases all resources in the ChannelProvider - ReplyChan chan *VppReply // channel where VPP replies are delivered to - - NotifSubsChan chan *NotifSubscribeRequest // channel for sending notification subscribe requests - NotifSubsReplyChan chan error // channel where replies to notification subscribe requests are delivered to - - MsgDecoder MessageDecoder // used to decode binary data to generated API messages - MsgIdentifier MessageIdentifier // used to retrieve message ID of a message - - lastSeqNum uint16 // sequence number of the last sent request - - delayedReply *VppReply // reply already taken from ReplyChan, buffered for later delivery - replyTimeout time.Duration // maximum time that the API waits for a reply from VPP before returning an error, can be set with SetReplyTimeout +// Channel provides methods for direct communication with VPP channel. +type Channel interface { + // SendRequest asynchronously sends a request to VPP. Returns a request context, that can be used to call ReceiveReply. + // In case of any errors by sending, the error will be delivered to ReplyChan (and returned by ReceiveReply). + SendRequest(msg Message) RequestCtx + // SendMultiRequest asynchronously sends a multipart request (request to which multiple responses are expected) to VPP. + // Returns a multipart request context, that can be used to call ReceiveReply. + // In case of any errors by sending, the error will be delivered to ReplyChan (and returned by ReceiveReply). + SendMultiRequest(msg Message) MultiRequestCtx + // SubscribeNotification subscribes for receiving of the specified notification messages via provided Go channel. + // Note that the caller is responsible for creating the Go channel with preferred buffer size. If the channel's + // buffer is full, the notifications will not be delivered into it. + SubscribeNotification(notifChan chan Message, msgFactory func() Message) (*NotifSubscription, error) + // UnsubscribeNotification unsubscribes from receiving the notifications tied to the provided notification subscription. + UnsubscribeNotification(subscription *NotifSubscription) error + // CheckMessageCompatibility checks whether provided messages are compatible with the version of VPP + // which the library is connected to. + CheckMessageCompatibility(messages ...Message) error + // SetReplyTimeout sets the timeout for replies from VPP. It represents the maximum time the API waits for a reply + // from VPP before returning an error. + SetReplyTimeout(timeout time.Duration) + // GetRequestChannel returns request go channel of the VPP channel + GetRequestChannel() chan<- *VppRequest + // GetReplyChannel returns reply go channel of the VPP channel + GetReplyChannel() <-chan *VppReply + // GetNotificationChannel returns notification go channel of the VPP channel + GetNotificationChannel() chan<- *NotifSubscribeRequest + // GetNotificationReplyChannel returns notification reply go channel of the VPP channel + GetNotificationReplyChannel() <-chan error + // GetMessageDecoder returns message decoder instance + GetMessageDecoder() MessageDecoder + // GetID returns channel's ID + GetID() uint16 + // Close closes the API channel and releases all API channel-related resources in the ChannelProvider. + Close() +} + +// RequestCtx is helper interface which allows to receive reply on request context data +type RequestCtx interface { + // ReceiveReply receives a reply from VPP (blocks until a reply is delivered from VPP, or until an error occurs). + // The reply will be decoded into the msg argument. Error will be returned if the response cannot be received or decoded. + ReceiveReply(msg Message) error +} + +// MultiRequestCtx is helper interface which allows to receive reply on multi-request context data +type MultiRequestCtx interface { + // ReceiveReply receives a reply from VPP (blocks until a reply is delivered from VPP, or until an error occurs). + // The reply will be decoded into the msg argument. If the last reply has been already consumed, lastReplyReceived is + // set to true. Do not use the message itself if lastReplyReceived is true - it won't be filled with actual data. + // Error will be returned if the response cannot be received or decoded. + ReceiveReply(msg Message) (lastReplyReceived bool, err error) } // VppRequest is a request that will be sent to VPP. @@ -131,238 +158,3 @@ type NotifSubscription struct { NotifChan chan Message // channel where notification messages will be delivered to MsgFactory func() Message // function that returns a new instance of the specific message that is expected as a notification } - -// RequestCtx is a context of a ongoing request (simple one - only one response is expected). -type RequestCtx struct { - ch *Channel - seqNum uint16 -} - -// MultiRequestCtx is a context of a ongoing multipart request (multiple responses are expected). -type MultiRequestCtx struct { - ch *Channel - seqNum uint16 -} - -const defaultReplyTimeout = time.Second * 1 // default timeout for replies from VPP, can be changed with SetReplyTimeout - -// NewChannelInternal returns a new channel structure. -// Note that this is just a raw channel not yet connected to VPP, it is not intended to be used directly. -// Use ChannelProvider to get an API channel ready for communication with VPP. -func NewChannelInternal(id uint16) *Channel { - return &Channel{ - ID: id, - replyTimeout: defaultReplyTimeout, - } -} - -// SetReplyTimeout sets the timeout for replies from VPP. It represents the maximum time the API waits for a reply -// from VPP before returning an error. -func (ch *Channel) SetReplyTimeout(timeout time.Duration) { - ch.replyTimeout = timeout -} - -// Close closes the API channel and releases all API channel-related resources in the ChannelProvider. -func (ch *Channel) Close() { - if ch.ReqChan != nil { - close(ch.ReqChan) - } -} - -// SendRequest asynchronously sends a request to VPP. Returns a request context, that can be used to call ReceiveReply. -// In case of any errors by sending, the error will be delivered to ReplyChan (and returned by ReceiveReply). -func (ch *Channel) SendRequest(msg Message) *RequestCtx { - ch.lastSeqNum++ - ch.ReqChan <- &VppRequest{ - Message: msg, - SeqNum: ch.lastSeqNum, - } - return &RequestCtx{ch: ch, seqNum: ch.lastSeqNum} -} - -// ReceiveReply receives a reply from VPP (blocks until a reply is delivered from VPP, or until an error occurs). -// The reply will be decoded into the msg argument. Error will be returned if the response cannot be received or decoded. -func (req *RequestCtx) ReceiveReply(msg Message) error { - if req == nil || req.ch == nil { - return errors.New("invalid request context") - } - - lastReplyReceived, err := req.ch.receiveReplyInternal(msg, req.seqNum) - - if lastReplyReceived { - err = errors.New("multipart reply recieved while a simple reply expected") - } - return err -} - -// SendMultiRequest asynchronously sends a multipart request (request to which multiple responses are expected) to VPP. -// Returns a multipart request context, that can be used to call ReceiveReply. -// In case of any errors by sending, the error will be delivered to ReplyChan (and returned by ReceiveReply). -func (ch *Channel) SendMultiRequest(msg Message) *MultiRequestCtx { - ch.lastSeqNum++ - ch.ReqChan <- &VppRequest{ - Message: msg, - Multipart: true, - SeqNum: ch.lastSeqNum, - } - return &MultiRequestCtx{ch: ch, seqNum: ch.lastSeqNum} -} - -// ReceiveReply receives a reply from VPP (blocks until a reply is delivered from VPP, or until an error occurs). -// The reply will be decoded into the msg argument. If the last reply has been already consumed, lastReplyReceived is -// set to true. Do not use the message itself if lastReplyReceived is true - it won't be filled with actual data. -// Error will be returned if the response cannot be received or decoded. -func (req *MultiRequestCtx) ReceiveReply(msg Message) (lastReplyReceived bool, err error) { - if req == nil || req.ch == nil { - return false, errors.New("invalid request context") - } - - return req.ch.receiveReplyInternal(msg, req.seqNum) -} - -// receiveReplyInternal receives a reply from the reply channel into the provided msg structure. -func (ch *Channel) receiveReplyInternal(msg Message, expSeqNum uint16) (lastReplyReceived bool, err error) { - var ignore bool - if msg == nil { - return false, errors.New("nil message passed in") - } - - if ch.delayedReply != nil { - // try the delayed reply - vppReply := ch.delayedReply - ch.delayedReply = nil - ignore, lastReplyReceived, err = ch.processReply(vppReply, expSeqNum, msg) - if !ignore { - return lastReplyReceived, err - } - } - - timer := time.NewTimer(ch.replyTimeout) - for { - select { - // blocks until a reply comes to ReplyChan or until timeout expires - case vppReply := <-ch.ReplyChan: - ignore, lastReplyReceived, err = ch.processReply(vppReply, expSeqNum, msg) - if ignore { - continue - } - return lastReplyReceived, err - - case <-timer.C: - err = fmt.Errorf("no reply received within the timeout period %s", ch.replyTimeout) - return false, err - } - } - return -} - -func (ch *Channel) processReply(reply *VppReply, expSeqNum uint16, msg Message) (ignore bool, lastReplyReceived bool, err error) { - // check the sequence number - cmpSeqNums := compareSeqNumbers(reply.SeqNum, expSeqNum) - if cmpSeqNums == -1 { - // reply received too late, ignore the message - logrus.WithField("sequence-number", reply.SeqNum).Warn( - "Received reply to an already closed binary API request") - ignore = true - return - } - if cmpSeqNums == 1 { - ch.delayedReply = reply - err = fmt.Errorf("missing binary API reply with sequence number: %d", expSeqNum) - return - } - - if reply.Error != nil { - err = reply.Error - return - } - if reply.LastReplyReceived { - lastReplyReceived = true - return - } - - // message checks - var expMsgID uint16 - expMsgID, err = ch.MsgIdentifier.GetMessageID(msg) - if err != nil { - err = fmt.Errorf("message %s with CRC %s is not compatible with the VPP we are connected to", - msg.GetMessageName(), msg.GetCrcString()) - return - } - - if reply.MessageID != expMsgID { - var msgNameCrc string - if nameCrc, err := ch.MsgIdentifier.LookupByID(reply.MessageID); err != nil { - msgNameCrc = err.Error() - } else { - msgNameCrc = nameCrc - } - - err = fmt.Errorf("received invalid message ID (seq-num=%d), expected %d (%s), but got %d (%s) "+ - "(check if multiple goroutines are not sharing single GoVPP channel)", - reply.SeqNum, expMsgID, msg.GetMessageName(), reply.MessageID, msgNameCrc) - return - } - - // decode the message - err = ch.MsgDecoder.DecodeMsg(reply.Data, msg) - return -} - -// compareSeqNumbers returns -1, 0, 1 if sequence number <seqNum1> precedes, equals to, -// or succeeds seq. number <seqNum2>. -// Since sequence numbers cycle in the finite set of size 2^16, the function -// must assume that the distance between compared sequence numbers is less than -// (2^16)/2 to determine the order. -func compareSeqNumbers(seqNum1, seqNum2 uint16) int { - // calculate distance from seqNum1 to seqNum2 - var dist uint16 - if seqNum1 <= seqNum2 { - dist = seqNum2 - seqNum1 - } else { - dist = 0xffff - (seqNum1 - seqNum2 - 1) - } - if dist == 0 { - return 0 - } else if dist <= 0x8000 { - return -1 - } - return 1 -} - -// SubscribeNotification subscribes for receiving of the specified notification messages via provided Go channel. -// Note that the caller is responsible for creating the Go channel with preferred buffer size. If the channel's -// buffer is full, the notifications will not be delivered into it. -func (ch *Channel) SubscribeNotification(notifChan chan Message, msgFactory func() Message) (*NotifSubscription, error) { - subscription := &NotifSubscription{ - NotifChan: notifChan, - MsgFactory: msgFactory, - } - ch.NotifSubsChan <- &NotifSubscribeRequest{ - Subscription: subscription, - Subscribe: true, - } - return subscription, <-ch.NotifSubsReplyChan -} - -// UnsubscribeNotification unsubscribes from receiving the notifications tied to the provided notification subscription. -func (ch *Channel) UnsubscribeNotification(subscription *NotifSubscription) error { - ch.NotifSubsChan <- &NotifSubscribeRequest{ - Subscription: subscription, - Subscribe: false, - } - return <-ch.NotifSubsReplyChan -} - -// CheckMessageCompatibility checks whether provided messages are compatible with the version of VPP -// which the library is connected to. -func (ch *Channel) CheckMessageCompatibility(messages ...Message) error { - for _, msg := range messages { - _, err := ch.MsgIdentifier.GetMessageID(msg) - if err != nil { - return fmt.Errorf("message %s with CRC %s is not compatible with the VPP we are connected to", - msg.GetMessageName(), msg.GetCrcString()) - } - } - return nil -} diff --git a/api/api_test.go b/api/api_test.go deleted file mode 100644 index 7cbd9f0..0000000 --- a/api/api_test.go +++ /dev/null @@ -1,588 +0,0 @@ -// Copyright (c) 2017 Cisco and/or its affiliates. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at: -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package api_test - -import ( - "testing" - "time" - - "git.fd.io/govpp.git/adapter/mock" - "git.fd.io/govpp.git/api" - "git.fd.io/govpp.git/core" - "git.fd.io/govpp.git/core/bin_api/vpe" - "git.fd.io/govpp.git/examples/bin_api/interfaces" - "git.fd.io/govpp.git/examples/bin_api/memif" - "git.fd.io/govpp.git/examples/bin_api/tap" - - . "github.com/onsi/gomega" -) - -type testCtx struct { - mockVpp *mock.VppAdapter - conn *core.Connection - ch *api.Channel -} - -func setupTest(t *testing.T) *testCtx { - RegisterTestingT(t) - - ctx := &testCtx{ - mockVpp: &mock.VppAdapter{}, - } - - var err error - ctx.conn, err = core.Connect(ctx.mockVpp) - Expect(err).ShouldNot(HaveOccurred()) - - ctx.ch, err = ctx.conn.NewAPIChannel() - Expect(err).ShouldNot(HaveOccurred()) - - return ctx -} - -func (ctx *testCtx) teardownTest() { - ctx.ch.Close() - ctx.conn.Disconnect() -} - -func TestRequestReplyTapConnect(t *testing.T) { - ctx := setupTest(t) - defer ctx.teardownTest() - - ctx.mockVpp.MockReply(&tap.TapConnectReply{ - Retval: 10, - SwIfIndex: 1, - }) - request := &tap.TapConnect{ - TapName: []byte("test-tap-name"), - UseRandomMac: 1, - } - reply := &tap.TapConnectReply{} - - err := ctx.ch.SendRequest(request).ReceiveReply(reply) - Expect(err).ShouldNot(HaveOccurred()) - Expect(reply.Retval).To(BeEquivalentTo(10), "Incorrect retval value for TapConnectReply") - Expect(reply.SwIfIndex).To(BeEquivalentTo(1), "Incorrect SwIfIndex value for TapConnectReply") -} - -func TestRequestReplyTapModify(t *testing.T) { - ctx := setupTest(t) - defer ctx.teardownTest() - - ctx.mockVpp.MockReply(&tap.TapModifyReply{ - Retval: 15, - SwIfIndex: 2, - }) - request := &tap.TapModify{ - TapName: []byte("test-tap-modify"), - UseRandomMac: 1, - CustomDevInstance: 1, - } - reply := &tap.TapModifyReply{} - - err := ctx.ch.SendRequest(request).ReceiveReply(reply) - Expect(err).ShouldNot(HaveOccurred()) - Expect(reply.Retval).To(BeEquivalentTo(15), "Incorrect retval value for TapModifyReply") - Expect(reply.SwIfIndex).To(BeEquivalentTo(2), "Incorrect SwIfIndex value for TapModifyReply") -} - -func TestRequestReplyTapDelete(t *testing.T) { - ctx := setupTest(t) - defer ctx.teardownTest() - - ctx.mockVpp.MockReply(&tap.TapDeleteReply{ - Retval: 20, - }) - request := &tap.TapDelete{ - SwIfIndex: 3, - } - reply := &tap.TapDeleteReply{} - - err := ctx.ch.SendRequest(request).ReceiveReply(reply) - Expect(err).ShouldNot(HaveOccurred()) - Expect(reply.Retval).To(BeEquivalentTo(20), "Incorrect retval value for TapDeleteReply") -} - -func TestRequestReplySwInterfaceTapDump(t *testing.T) { - ctx := setupTest(t) - defer ctx.teardownTest() - - byteName := []byte("dev-name-test") - ctx.mockVpp.MockReply(&tap.SwInterfaceTapDetails{ - SwIfIndex: 25, - DevName: byteName, - }) - request := &tap.SwInterfaceTapDump{} - reply := &tap.SwInterfaceTapDetails{} - - err := ctx.ch.SendRequest(request).ReceiveReply(reply) - Expect(err).ShouldNot(HaveOccurred()) - Expect(reply.SwIfIndex).To(BeEquivalentTo(25), "Incorrect SwIfIndex value for SwInterfaceTapDetails") - Expect(reply.DevName).ToNot(BeNil(), "Incorrect DevName value for SwInterfaceTapDetails") -} - -func TestRequestReplyMemifCreate(t *testing.T) { - ctx := setupTest(t) - defer ctx.teardownTest() - - ctx.mockVpp.MockReply(&memif.MemifCreateReply{ - Retval: 22, - SwIfIndex: 4, - }) - request := &memif.MemifCreate{ - Role: 10, - ID: 12, - RingSize: 8000, - BufferSize: 50, - } - reply := &memif.MemifCreateReply{} - - err := ctx.ch.SendRequest(request).ReceiveReply(reply) - Expect(err).ShouldNot(HaveOccurred()) - Expect(reply.Retval).To(BeEquivalentTo(22), "Incorrect Retval value for MemifCreate") - Expect(reply.SwIfIndex).To(BeEquivalentTo(4), "Incorrect SwIfIndex value for MemifCreate") -} - -func TestRequestReplyMemifDelete(t *testing.T) { - ctx := setupTest(t) - defer ctx.teardownTest() - - ctx.mockVpp.MockReply(&memif.MemifDeleteReply{ - Retval: 24, - }) - request := &memif.MemifDelete{ - SwIfIndex: 15, - } - reply := &memif.MemifDeleteReply{} - - err := ctx.ch.SendRequest(request).ReceiveReply(reply) - Expect(err).ShouldNot(HaveOccurred()) - Expect(reply.Retval).To(BeEquivalentTo(24), "Incorrect Retval value for MemifDelete") -} - -func TestRequestReplyMemifDetails(t *testing.T) { - ctx := setupTest(t) - defer ctx.teardownTest() - - ctx.mockVpp.MockReply(&memif.MemifDetails{ - SwIfIndex: 25, - IfName: []byte("memif-name"), - Role: 0, - }) - request := &memif.MemifDump{} - reply := &memif.MemifDetails{} - - err := ctx.ch.SendRequest(request).ReceiveReply(reply) - Expect(err).ShouldNot(HaveOccurred()) - Expect(reply.SwIfIndex).To(BeEquivalentTo(25), "Incorrect SwIfIndex value for MemifDetails") - Expect(reply.IfName).ToNot(BeEmpty(), "MemifDetails IfName is empty byte array") - Expect(reply.Role).To(BeEquivalentTo(0), "Incorrect Role value for MemifDetails") -} - -func TestMultiRequestReplySwInterfaceTapDump(t *testing.T) { - ctx := setupTest(t) - defer ctx.teardownTest() - - // mock reply - msgs := []api.Message{} - for i := 1; i <= 10; i++ { - msgs = append(msgs, &tap.SwInterfaceTapDetails{ - SwIfIndex: uint32(i), - DevName: []byte("dev-name-test"), - }) - } - ctx.mockVpp.MockReply(msgs...) - ctx.mockVpp.MockReply(&vpe.ControlPingReply{}) - - reqCtx := ctx.ch.SendMultiRequest(&tap.SwInterfaceTapDump{}) - cnt := 0 - for { - msg := &tap.SwInterfaceTapDetails{} - stop, err := reqCtx.ReceiveReply(msg) - if stop { - break // break out of the loop - } - Expect(err).ShouldNot(HaveOccurred()) - cnt++ - } - Expect(cnt).To(BeEquivalentTo(10)) -} - -func TestMultiRequestReplySwInterfaceMemifDump(t *testing.T) { - ctx := setupTest(t) - defer ctx.teardownTest() - - // mock reply - msgs := []api.Message{} - for i := 1; i <= 10; i++ { - msgs = append(msgs, &memif.MemifDetails{ - SwIfIndex: uint32(i), - }) - } - ctx.mockVpp.MockReply(msgs...) - ctx.mockVpp.MockReply(&vpe.ControlPingReply{}) - - reqCtx := ctx.ch.SendMultiRequest(&memif.MemifDump{}) - cnt := 0 - for { - msg := &memif.MemifDetails{} - stop, err := reqCtx.ReceiveReply(msg) - if stop { - break // break out of the loop - } - Expect(err).ShouldNot(HaveOccurred()) - cnt++ - } - Expect(cnt).To(BeEquivalentTo(10)) -} - -func TestNotifications(t *testing.T) { - ctx := setupTest(t) - defer ctx.teardownTest() - - // subscribe for notification - notifChan := make(chan api.Message, 1) - subs, err := ctx.ch.SubscribeNotification(notifChan, interfaces.NewSwInterfaceSetFlags) - Expect(err).ShouldNot(HaveOccurred()) - - // mock the notification and force its delivery - ctx.mockVpp.MockReply(&interfaces.SwInterfaceSetFlags{ - SwIfIndex: 3, - AdminUpDown: 1, - }) - ctx.mockVpp.SendMsg(0, []byte("")) - - // receive the notification - var notif *interfaces.SwInterfaceSetFlags - Eventually(func() *interfaces.SwInterfaceSetFlags { - select { - case n := <-notifChan: - notif = n.(*interfaces.SwInterfaceSetFlags) - return notif - default: - return nil - } - }).ShouldNot(BeNil()) - - // verify the received notifications - Expect(notif.SwIfIndex).To(BeEquivalentTo(3), "Incorrect SwIfIndex value for SwInterfaceSetFlags") - Expect(notif.AdminUpDown).To(BeEquivalentTo(1), "Incorrect AdminUpDown value for SwInterfaceSetFlags") - - ctx.ch.UnsubscribeNotification(subs) -} - -func TestNotificationEvent(t *testing.T) { - ctx := setupTest(t) - defer ctx.teardownTest() - - // subscribe for notification - notifChan := make(chan api.Message, 1) - subs, err := ctx.ch.SubscribeNotification(notifChan, interfaces.NewSwInterfaceEvent) - Expect(err).ShouldNot(HaveOccurred()) - - // mock the notification and force its delivery - ctx.mockVpp.MockReply(&interfaces.SwInterfaceEvent{ - SwIfIndex: 2, - LinkUpDown: 1, - }) - ctx.mockVpp.SendMsg(0, []byte("")) - - // receive the notification - var notif *interfaces.SwInterfaceEvent - Eventually(func() *interfaces.SwInterfaceEvent { - select { - case n := <-notifChan: - notif = n.(*interfaces.SwInterfaceEvent) - return notif - default: - return nil - } - }).ShouldNot(BeNil()) - - // verify the received notifications - Expect(notif.SwIfIndex).To(BeEquivalentTo(2), "Incorrect SwIfIndex value for SwInterfaceSetFlags") - Expect(notif.LinkUpDown).To(BeEquivalentTo(1), "Incorrect LinkUpDown value for SwInterfaceSetFlags") - - ctx.ch.UnsubscribeNotification(subs) -} - -func TestCheckMessageCompatibility(t *testing.T) { - ctx := setupTest(t) - defer ctx.teardownTest() - - err := ctx.ch.CheckMessageCompatibility(&interfaces.SwInterfaceSetFlags{}) - Expect(err).ShouldNot(HaveOccurred()) -} -func TestSetReplyTimeout(t *testing.T) { - ctx := setupTest(t) - defer ctx.teardownTest() - - ctx.ch.SetReplyTimeout(time.Millisecond) - - // first one request should work - ctx.mockVpp.MockReply(&vpe.ControlPingReply{}) - err := ctx.ch.SendRequest(&vpe.ControlPing{}).ReceiveReply(&vpe.ControlPingReply{}) - Expect(err).ShouldNot(HaveOccurred()) - - // no other reply ready - expect timeout - err = ctx.ch.SendRequest(&vpe.ControlPing{}).ReceiveReply(&vpe.ControlPingReply{}) - Expect(err).Should(HaveOccurred()) - Expect(err.Error()).To(ContainSubstring("timeout")) -} - -func TestSetReplyTimeoutMultiRequest(t *testing.T) { - ctx := setupTest(t) - defer ctx.teardownTest() - - ctx.ch.SetReplyTimeout(time.Millisecond) - - msgs := []api.Message{} - for i := 1; i <= 3; i++ { - msgs = append(msgs, &interfaces.SwInterfaceDetails{ - SwIfIndex: uint32(i), - InterfaceName: []byte("if-name-test"), - }) - } - ctx.mockVpp.MockReply(msgs...) - ctx.mockVpp.MockReply(&vpe.ControlPingReply{}) - - cnt := 0 - sendMultiRequest := func() error { - reqCtx := ctx.ch.SendMultiRequest(&interfaces.SwInterfaceDump{}) - for { - msg := &interfaces.SwInterfaceDetails{} - stop, err := reqCtx.ReceiveReply(msg) - if stop { - break // break out of the loop - } - if err != nil { - return err - } - cnt++ - } - return nil - } - - // first one request should work - err := sendMultiRequest() - Expect(err).ShouldNot(HaveOccurred()) - - // no other reply ready - expect timeout - err = sendMultiRequest() - Expect(err).Should(HaveOccurred()) - Expect(err.Error()).To(ContainSubstring("timeout")) - - Expect(cnt).To(BeEquivalentTo(3)) -} - -func TestReceiveReplyNegative(t *testing.T) { - ctx := setupTest(t) - defer ctx.teardownTest() - - // invalid context 1 - reqCtx1 := &api.RequestCtx{} - err := reqCtx1.ReceiveReply(&vpe.ControlPingReply{}) - Expect(err).Should(HaveOccurred()) - Expect(err.Error()).To(ContainSubstring("invalid request context")) - - // invalid context 2 - reqCtx2 := &api.MultiRequestCtx{} - _, err = reqCtx2.ReceiveReply(&vpe.ControlPingReply{}) - Expect(err).Should(HaveOccurred()) - Expect(err.Error()).To(ContainSubstring("invalid request context")) - - // NU - reqCtx3 := &api.RequestCtx{} - err = reqCtx3.ReceiveReply(nil) - Expect(err).Should(HaveOccurred()) - Expect(err.Error()).To(ContainSubstring("invalid request context")) -} - -func TestMultiRequestDouble(t *testing.T) { - ctx := setupTest(t) - defer ctx.teardownTest() - - // mock reply - msgs := []mock.MsgWithContext{} - for i := 1; i <= 3; i++ { - msgs = append(msgs, mock.MsgWithContext{ - Msg: &interfaces.SwInterfaceDetails{ - SwIfIndex: uint32(i), - InterfaceName: []byte("if-name-test"), - }, - Multipart: true, - SeqNum: 1, - }) - } - msgs = append(msgs, mock.MsgWithContext{Msg: &vpe.ControlPingReply{}, Multipart: true, SeqNum: 1}) - - for i := 1; i <= 3; i++ { - msgs = append(msgs, - mock.MsgWithContext{ - Msg: &interfaces.SwInterfaceDetails{ - SwIfIndex: uint32(i), - InterfaceName: []byte("if-name-test"), - }, - Multipart: true, - SeqNum: 2, - }) - } - msgs = append(msgs, mock.MsgWithContext{Msg: &vpe.ControlPingReply{}, Multipart: true, SeqNum: 2}) - - ctx.mockVpp.MockReplyWithContext(msgs...) - - cnt := 0 - var sendMultiRequest = func() error { - reqCtx := ctx.ch.SendMultiRequest(&interfaces.SwInterfaceDump{}) - for { - msg := &interfaces.SwInterfaceDetails{} - stop, err := reqCtx.ReceiveReply(msg) - if stop { - break // break out of the loop - } - if err != nil { - return err - } - cnt++ - } - return nil - } - - err := sendMultiRequest() - Expect(err).ShouldNot(HaveOccurred()) - - err = sendMultiRequest() - Expect(err).ShouldNot(HaveOccurred()) - - Expect(cnt).To(BeEquivalentTo(6)) -} - -func TestReceiveReplyAfterTimeout(t *testing.T) { - ctx := setupTest(t) - defer ctx.teardownTest() - - ctx.ch.SetReplyTimeout(time.Millisecond) - - // first one request should work - ctx.mockVpp.MockReplyWithContext(mock.MsgWithContext{Msg: &vpe.ControlPingReply{}, SeqNum: 1}) - err := ctx.ch.SendRequest(&vpe.ControlPing{}).ReceiveReply(&vpe.ControlPingReply{}) - Expect(err).ShouldNot(HaveOccurred()) - - err = ctx.ch.SendRequest(&vpe.ControlPing{}).ReceiveReply(&vpe.ControlPingReply{}) - Expect(err).Should(HaveOccurred()) - Expect(err.Error()).To(ContainSubstring("timeout")) - - ctx.mockVpp.MockReplyWithContext( - // simulating late reply - mock.MsgWithContext{Msg: &vpe.ControlPingReply{}, SeqNum: 2}, - // normal reply for next request - mock.MsgWithContext{Msg: &tap.TapConnectReply{}, SeqNum: 3}) - - req := &tap.TapConnect{ - TapName: []byte("test-tap-name"), - UseRandomMac: 1, - } - reply := &tap.TapConnectReply{} - - // should succeed - err = ctx.ch.SendRequest(req).ReceiveReply(reply) - Expect(err).ShouldNot(HaveOccurred()) -} - -func TestReceiveReplyAfterTimeoutMultiRequest(t *testing.T) { - /* - TODO: fix mock adapter - This test will fail because mock adapter will stop sending replies - when it encounters control_ping_reply from multi request, - thus never sending reply for next request - */ - t.Skip() - - ctx := setupTest(t) - defer ctx.teardownTest() - - ctx.ch.SetReplyTimeout(time.Millisecond * 100) - - // first one request should work - ctx.mockVpp.MockReplyWithContext(mock.MsgWithContext{Msg: &vpe.ControlPingReply{}, SeqNum: 1}) - err := ctx.ch.SendRequest(&vpe.ControlPing{}).ReceiveReply(&vpe.ControlPingReply{}) - Expect(err).ShouldNot(HaveOccurred()) - - cnt := 0 - var sendMultiRequest = func() error { - reqCtx := ctx.ch.SendMultiRequest(&interfaces.SwInterfaceDump{}) - for { - msg := &interfaces.SwInterfaceDetails{} - stop, err := reqCtx.ReceiveReply(msg) - if stop { - break // break out of the loop - } - if err != nil { - return err - } - cnt++ - } - return nil - } - - err = sendMultiRequest() - Expect(err).Should(HaveOccurred()) - Expect(err.Error()).To(ContainSubstring("timeout")) - Expect(cnt).To(BeEquivalentTo(0)) - - // simulating late replies - msgs := []mock.MsgWithContext{} - for i := 1; i <= 3; i++ { - msgs = append(msgs, mock.MsgWithContext{ - Msg: &interfaces.SwInterfaceDetails{ - SwIfIndex: uint32(i), - InterfaceName: []byte("if-name-test"), - }, - Multipart: true, - SeqNum: 2, - }) - } - msgs = append(msgs, mock.MsgWithContext{Msg: &vpe.ControlPingReply{}, Multipart: true, SeqNum: 2}) - ctx.mockVpp.MockReplyWithContext(msgs...) - - // normal reply for next request - ctx.mockVpp.MockReplyWithContext(mock.MsgWithContext{Msg: &tap.TapConnectReply{}, SeqNum: 3}) - - req := &tap.TapConnect{ - TapName: []byte("test-tap-name"), - UseRandomMac: 1, - } - reply := &tap.TapConnectReply{} - - // should succeed - err = ctx.ch.SendRequest(req).ReceiveReply(reply) - Expect(err).ShouldNot(HaveOccurred()) -} - -func TestInvalidMessageID(t *testing.T) { - ctx := setupTest(t) - defer ctx.teardownTest() - - // first one request should work - ctx.mockVpp.MockReply(&vpe.ShowVersionReply{}) - err := ctx.ch.SendRequest(&vpe.ShowVersion{}).ReceiveReply(&vpe.ShowVersionReply{}) - Expect(err).ShouldNot(HaveOccurred()) - - // second should fail with error invalid message ID - ctx.mockVpp.MockReply(&vpe.ShowVersionReply{}) - err = ctx.ch.SendRequest(&vpe.ControlPing{}).ReceiveReply(&vpe.ControlPingReply{}) - Expect(err).Should(HaveOccurred()) - Expect(err.Error()).To(ContainSubstring("invalid message ID")) -} @@ -1,94 +1,2 @@ -// Package api provides API for communication with govpp core using Go channels, -// without the need of importing the govpp core package itself. -// -// The API offers two ways of communication with govpp core: using Go channels, or using convenient function -// wrappers over the Go channels. The latter should be sufficient for most of the use cases. -// -// The entry point to the API is the Channel structure, that can be obtained from the existing connection using -// the NewAPIChannel or NewAPIChannelBuffered functions: -// -// conn, err := govpp.Connect() -// if err != nil { -// // handle error! -// } -// defer conn.Disconnect() -// -// ch, err := conn.NewAPIChannel() -// if err != nil { -// // handle error! -// } -// defer ch.Close() -// -// -// Simple Request-Reply API -// -// The simple version of the API is based on blocking SendRequest / ReceiveReply calls, where a single request -// message is sent to VPP and a single reply message is filled in when the reply comes from VPP: -// -// req := &acl.ACLPluginGetVersion{} -// reply := &acl.ACLPluginGetVersionReply{} -// -// err := ch.SendRequest(req).ReceiveReply(reply) -// // process the reply -// -// Note that if the reply message type that comes from VPP does not match with provided one, you'll get an error. -// -// -// Multipart Reply API -// -// If multiple messages are expected as a reply to a request, SendMultiRequest API must be used: -// -// req := &interfaces.SwInterfaceDump{} -// reqCtx := ch.SendMultiRequest(req) -// -// for { -// reply := &interfaces.SwInterfaceDetails{} -// stop, err := reqCtx.ReceiveReply(reply) -// if stop { -// break // break out of the loop -// } -// // process the reply -// } -// -// Note that if the last reply has been already consumed, stop boolean return value is set to true. -// Do not use the message itself if stop is true - it won't be filled with actual data. -// -// -// Go Channels API -// -// The blocking API introduced above may be not sufficient for some management applications that strongly -// rely on usage of Go channels. In this case, the API allows to access the underlying Go channels directly, e.g. -// the following replacement of the SendRequest / ReceiveReply API: -// -// req := &acl.ACLPluginGetVersion{} -// // send the request to the request go channel -// ch.ReqChan <- &api.VppRequest{Message: req} -// -// // receive a reply from the reply go channel -// vppReply := <-ch.ReplyChan -// -// // decode the message -// reply := &acl.ACLPluginGetVersionReply{} -// err := ch.MsgDecoder.DecodeMsg(vppReply.Data, reply) -// -// // process the reply -// -// -// Notifications API -// -// to subscribe for receiving of the specified notification messages via provided Go channel, use the -// SubscribeNotification API: -// -// // subscribe for specific notification message -// notifChan := make(chan api.Message, 100) -// subs, _ := ch.SubscribeNotification(notifChan, interfaces.NewSwInterfaceSetFlags) -// -// // receive one notification -// notif := (<-notifChan).(*interfaces.SwInterfaceSetFlags) -// -// ch.UnsubscribeNotification(subs) -// -// Note that the caller is responsible for creating the Go channel with preferred buffer size. If the channel's -// buffer is full, the notifications will not be delivered into it. -// +// Package api defines interfaces required by every file generated with binapi-generator package api |