api/api.go

   1 // Copyright (c) 2017 Cisco and/or its affiliates.
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at:
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 package api
  16
  17 import (
  18         "errors"
  19         "fmt"
  20         "time"
  21 )
  22
  23 // MessageType represents the type of a VPP message.
  24 type MessageType int
  25
  26 const (
  27         // RequestMessage represents a VPP request message
  28         RequestMessage MessageType = iota
  29         // ReplyMessage represents a VPP reply message
  30         ReplyMessage
  31         // OtherMessage represents other VPP message (e.g. counters)
  32         OtherMessage
  33 )
  34
  35 // Message is an interface that is implemented by all VPP Binary API messages generated by the binapi_generator.
  36 type Message interface {
  37         // GetMessageName returns the original VPP name of the message, as defined in the VPP API.
  38         GetMessageName() string
  39
  40         // GetMessageType returns the type of the VPP message.
  41         GetMessageType() MessageType
  42
  43         // GetCrcString returns the string with CRC checksum of the message definition (the string represents a hexadecimal number).
  44         GetCrcString() string
  45 }
  46
  47 // DataType is an interface that is implemented by all VPP Binary API data types by the binapi_generator.
  48 type DataType interface {
  49         // GetTypeName returns the original VPP name of the data type, as defined in the VPP API.
  50         GetTypeName() string
  51
  52         // GetCrcString returns the string with CRC checksum of the data type definition (the string represents a hexadecimal number).
  53         GetCrcString() string
  54 }
  55
  56 // ChannelProvider provides the communication channel with govpp core.
  57 type ChannelProvider interface {
  58         // NewAPIChannel returns a new channel for communication with VPP via govpp core.
  59         // It uses default buffer sizes for the request and reply Go channels.
  60         NewAPIChannel() (*Channel, error)
  61
  62         // NewAPIChannel returns a new channel for communication with VPP via govpp core.
  63         // It allows to specify custom buffer sizes for the request and reply Go channels.
  64         NewAPIChannelBuffered() (*Channel, error)
  65 }
  66
  67 // MessageDecoder provides functionality for decoding binary data to generated API messages.
  68 type MessageDecoder interface {
  69         // DecodeMsg decodes binary-encoded data of a message into provided Message structure.
  70         DecodeMsg(data []byte, msg Message) error
  71 }
  72
  73 // MessageIdentifier provides identification of generated API messages.
  74 type MessageIdentifier interface {
  75         // GetMessageID returns message identifier of given API message.
  76         GetMessageID(msg Message) (uint16, error)
  77 }
  78
  79 // Channel is the main communication interface with govpp core. It contains two Go channels, one for sending the requests
  80 // to VPP and one for receiving the replies from it. The user can access the Go channels directly, or use the helper
  81 // methods  provided inside of this package.
  82 type Channel struct {
  83         ReqChan   chan *VppRequest // channel for sending the requests to VPP, closing this channel releases all resources in the ChannelProvider
  84         ReplyChan chan *VppReply   // channel where VPP replies are delivered to
  85
  86         NotifSubsChan      chan *NotifSubscribeRequest // channel for sending notification subscribe requests
  87         NotifSubsReplyChan chan error                  // channel where replies to notification subscribe requests are delivered to
  88
  89         MsgDecoder    MessageDecoder    // used to decode binary data to generated API messages
  90         MsgIdentifier MessageIdentifier // used to retrieve message ID of a message
  91
  92         replyTimeout time.Duration // maximum time that the API waits for a reply from VPP before returning an error, can be set with SetReplyTimeout
  93         metadata     interface{}   // opaque metadata of the API channel
  94 }
  95
  96 // VppRequest is a request that will be sent to VPP.
  97 type VppRequest struct {
  98         Message   Message // binary API message to be send to VPP
  99         Multipart bool    // true if multipart response is expected, false otherwise
 100 }
 101
 102 // VppReply is a reply received from VPP.
 103 type VppReply struct {
 104         MessageID         uint16 // ID of the message
 105         Data              []byte // encoded data with the message - MessageDecoder can be used for decoding
 106         LastReplyReceived bool   // in case of multipart replies, true if the last reply has been already received and this one should be ignored
 107         Error             error  // in case of error, data is nil and this member contains error description
 108 }
 109
 110 // NotifSubscribeRequest is a request to subscribe for delivery of specific notification messages.
 111 type NotifSubscribeRequest struct {
 112         Subscription *NotifSubscription // subscription details
 113         Subscribe    bool               // true if this is a request to subscribe, false if unsubscribe
 114 }
 115
 116 // NotifSubscription represents a subscription for delivery of specific notification messages.
 117 type NotifSubscription struct {
 118         NotifChan  chan Message   // channel where notification messages will be delivered to
 119         MsgFactory func() Message // function that returns a new instance of the specific message that is expected as a notification
 120 }
 121
 122 // RequestCtx is a context of a ongoing request (simple one - only one response is expected).
 123 type RequestCtx struct {
 124         ch *Channel
 125 }
 126
 127 // MultiRequestCtx is a context of a ongoing multipart request (multiple responses are expected).
 128 type MultiRequestCtx struct {
 129         ch *Channel
 130 }
 131
 132 const defaultReplyTimeout = time.Second * 1 // default timeout for replies from VPP, can be changed with SetReplyTimeout
 133
 134 // NewChannelInternal returns a new channel structure with metadata field filled in with the provided argument.
 135 // Note that this is just a raw channel not yet connected to VPP, it is not intended to be used directly.
 136 // Use ChannelProvider to get an API channel ready for communication with VPP.
 137 func NewChannelInternal(metadata interface{}) *Channel {
 138         return &Channel{
 139                 replyTimeout: defaultReplyTimeout,
 140                 metadata:     metadata,
 141         }
 142 }
 143
 144 // Metadata returns the metadata stored within the channel structure by the NewChannelInternal call.
 145 func (ch *Channel) Metadata() interface{} {
 146         return ch.metadata
 147 }
 148
 149 // SetReplyTimeout sets the timeout for replies from VPP. It represents the maximum time the API waits for a reply
 150 // from VPP before returning an error.
 151 func (ch *Channel) SetReplyTimeout(timeout time.Duration) {
 152         ch.replyTimeout = timeout
 153 }
 154
 155 // Close closes the API channel and releases all API channel-related resources in the ChannelProvider.
 156 func (ch *Channel) Close() {
 157         if ch.ReqChan != nil {
 158                 close(ch.ReqChan)
 159         }
 160 }
 161
 162 // SendRequest asynchronously sends a request to VPP. Returns a request context, that can be used to call ReceiveReply.
 163 // In case of any errors by sending, the error will be delivered to ReplyChan (and returned by ReceiveReply).
 164 func (ch *Channel) SendRequest(msg Message) *RequestCtx {
 165         ch.ReqChan <- &VppRequest{
 166                 Message: msg,
 167         }
 168         return &RequestCtx{ch: ch}
 169 }
 170
 171 // ReceiveReply receives a reply from VPP (blocks until a reply is delivered from VPP, or until an error occurs).
 172 // The reply will be decoded into the msg argument. Error will be returned if the response cannot be received or decoded.
 173 func (req *RequestCtx) ReceiveReply(msg Message) error {
 174         if req == nil || req.ch == nil {
 175                 return errors.New("invalid request context")
 176         }
 177
 178         lastReplyReceived, err := req.ch.receiveReplyInternal(msg)
 179
 180         if lastReplyReceived {
 181                 err = errors.New("multipart reply recieved while a simple reply expected")
 182         }
 183         return err
 184 }
 185
 186 // SendMultiRequest asynchronously sends a multipart request (request to which multiple responses are expected) to VPP.
 187 // Returns a multipart request context, that can be used to call ReceiveReply.
 188 // In case of any errors by sending, the error will be delivered to ReplyChan (and returned by ReceiveReply).
 189 func (ch *Channel) SendMultiRequest(msg Message) *MultiRequestCtx {
 190         ch.ReqChan <- &VppRequest{
 191                 Message:   msg,
 192                 Multipart: true,
 193         }
 194         return &MultiRequestCtx{ch: ch}
 195 }
 196
 197 // ReceiveReply receives a reply from VPP (blocks until a reply is delivered from VPP, or until an error occurs).
 198 // The reply will be decoded into the msg argument. If the last reply has been already consumed, LastReplyReceived is
 199 // set to true. Do not use the message itself if LastReplyReceived is true - it won't be filled with actual data.
 200 // Error will be returned if the response cannot be received or decoded.
 201 func (req *MultiRequestCtx) ReceiveReply(msg Message) (LastReplyReceived bool, err error) {
 202         if req == nil || req.ch == nil {
 203                 return false, errors.New("invalid request context")
 204         }
 205
 206         return req.ch.receiveReplyInternal(msg)
 207 }
 208
 209 // receiveReplyInternal receives a reply from the reply channel into the provided msg structure.
 210 func (ch *Channel) receiveReplyInternal(msg Message) (LastReplyReceived bool, err error) {
 211         if msg == nil {
 212                 return false, errors.New("nil message passed in")
 213         }
 214         select {
 215         // blocks until a reply comes to ReplyChan or until timeout expires
 216         case vppReply := <-ch.ReplyChan:
 217                 if vppReply.Error != nil {
 218                         err = vppReply.Error
 219                         return
 220                 }
 221                 if vppReply.LastReplyReceived {
 222                         LastReplyReceived = true
 223                         return
 224                 }
 225                 // message checks
 226                 expMsgID, err := ch.MsgIdentifier.GetMessageID(msg)
 227                 if err != nil {
 228                         err = fmt.Errorf("message %s with CRC %s is not compatible with the VPP we are connected to",
 229                                 msg.GetMessageName(), msg.GetCrcString())
 230                         return false, err
 231                 }
 232                 if vppReply.MessageID != expMsgID {
 233                         err = fmt.Errorf("invalid message ID %d, expected %d", vppReply.MessageID, expMsgID)
 234                         return false, err
 235                 }
 236                 // decode the message
 237                 err = ch.MsgDecoder.DecodeMsg(vppReply.Data, msg)
 238
 239         case <-time.After(ch.replyTimeout):
 240                 err = fmt.Errorf("no reply received within the timeout period %ds", ch.replyTimeout/time.Second)
 241         }
 242         return
 243 }
 244
 245 // SubscribeNotification subscribes for receiving of the specified notification messages via provided Go channel.
 246 // Note that the caller is responsible for creating the Go channel with preferred buffer size. If the channel's
 247 // buffer is full, the notifications will not be delivered into it.
 248 func (ch *Channel) SubscribeNotification(notifChan chan Message, msgFactory func() Message) (*NotifSubscription, error) {
 249         subscription := &NotifSubscription{
 250                 NotifChan:  notifChan,
 251                 MsgFactory: msgFactory,
 252         }
 253         ch.NotifSubsChan <- &NotifSubscribeRequest{
 254                 Subscription: subscription,
 255                 Subscribe:    true,
 256         }
 257         return subscription, <-ch.NotifSubsReplyChan
 258 }
 259
 260 // UnsubscribeNotification unsubscribes from receiving the notifications tied to the provided notification subscription.
 261 func (ch *Channel) UnsubscribeNotification(subscription *NotifSubscription) error {
 262         ch.NotifSubsChan <- &NotifSubscribeRequest{
 263                 Subscription: subscription,
 264                 Subscribe:    false,
 265         }
 266         return <-ch.NotifSubsReplyChan
 267 }
 268
 269 // CheckMessageCompatibility checks whether provided messages are compatible with the version of VPP
 270 // which the library is connected to.
 271 func (ch *Channel) CheckMessageCompatibility(messages ...Message) error {
 272         for _, msg := range messages {
 273                 _, err := ch.MsgIdentifier.GetMessageID(msg)
 274                 if err != nil {
 275                         return fmt.Errorf("message %s with CRC %s is not compatible with the VPP we are connected to",
 276                                 msg.GetMessageName(), msg.GetCrcString())
 277                 }
 278         }
 279         return nil
 280 }