1 // Copyright (c) 2017 Cisco and/or its affiliates.
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:
7 // http://www.apache.org/licenses/LICENSE-2.0
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.
25 logger "github.com/sirupsen/logrus"
27 "git.fd.io/govpp.git/adapter"
28 "git.fd.io/govpp.git/api"
29 "git.fd.io/govpp.git/codec"
33 RequestChanBufSize = 100 // default size of the request channel buffer
34 ReplyChanBufSize = 100 // default size of the reply channel buffer
35 NotificationChanBufSize = 100 // default size of the notification channel buffer
39 HealthCheckProbeInterval = time.Second * 1 // default health check probe interval
40 HealthCheckReplyTimeout = time.Millisecond * 100 // timeout for reply to a health check probe
41 HealthCheckThreshold = 1 // number of failed health checks until the error is reported
42 DefaultReplyTimeout = time.Second * 1 // default timeout for replies from VPP
43 ReconnectInterval = time.Second * 1 // default interval for reconnect attempts
44 MaxReconnectAttempts = 10 // maximum number of reconnect attempts
47 // ConnectionState represents the current state of the connection to VPP.
48 type ConnectionState int
51 // Connected represents state in which the connection has been successfully established.
52 Connected ConnectionState = iota
54 // Disconnected represents state in which the connection has been dropped.
57 // Failed represents state in which the reconnecting failed after exceeding maximum number of attempts.
61 // ConnectionEvent is a notification about change in the VPP connection state.
62 type ConnectionEvent struct {
63 // Timestamp holds the time when the event has been created.
66 // State holds the new state of the connection at the time when the event has been created.
69 // Error holds error if any encountered.
73 // Connection represents a shared memory connection to VPP via vppAdapter.
74 type Connection struct {
75 vppClient adapter.VppAPI // VPP binary API client adapter
77 vppConnected uint32 // non-zero if the adapter is connected to VPP
79 codec *codec.MsgCodec // message codec
80 msgIDs map[string]uint16 // map of message IDs indexed by message name + CRC
81 msgMap map[uint16]api.Message // map of messages indexed by message ID
83 maxChannelID uint32 // maximum used channel ID (the real limit is 2^15, 32-bit is used for atomic operations)
84 channelsLock sync.RWMutex // lock for the channels map
85 channels map[uint16]*Channel // map of all API channels indexed by the channel ID
87 subscriptionsLock sync.RWMutex // lock for the subscriptions map
88 subscriptions map[uint16][]*subscriptionCtx // map od all notification subscriptions indexed by message ID
90 pingReqID uint16 // ID if the ControlPing message
91 pingReplyID uint16 // ID of the ControlPingReply message
93 lastReplyLock sync.Mutex // lock for the last reply
94 lastReply time.Time // time of the last received reply from VPP
97 func newConnection(binapi adapter.VppAPI) *Connection {
100 codec: &codec.MsgCodec{},
101 msgIDs: make(map[string]uint16),
102 msgMap: make(map[uint16]api.Message),
103 channels: make(map[uint16]*Channel),
104 subscriptions: make(map[uint16][]*subscriptionCtx),
106 binapi.SetMsgCallback(c.msgCallback)
110 // Connect connects to VPP using specified VPP adapter and returns the connection handle.
111 // This call blocks until VPP is connected, or an error occurs. Only one connection attempt will be performed.
112 func Connect(binapi adapter.VppAPI) (*Connection, error) {
113 // create new connection handle
114 c := newConnection(binapi)
116 // blocking attempt to connect to VPP
117 if err := c.connectVPP(); err != nil {
124 // AsyncConnect asynchronously connects to VPP using specified VPP adapter and returns the connection handle
125 // and ConnectionState channel. This call does not block until connection is established, it
126 // returns immediately. The caller is supposed to watch the returned ConnectionState channel for
127 // Connected/Disconnected events. In case of disconnect, the library will asynchronously try to reconnect.
128 func AsyncConnect(binapi adapter.VppAPI) (*Connection, chan ConnectionEvent, error) {
129 // create new connection handle
130 c := newConnection(binapi)
132 // asynchronously attempt to connect to VPP
133 connChan := make(chan ConnectionEvent, NotificationChanBufSize)
134 go c.connectLoop(connChan)
136 return c, connChan, nil
139 // connectVPP performs blocking attempt to connect to VPP.
140 func (c *Connection) connectVPP() error {
141 log.Debug("Connecting to VPP..")
144 if err := c.vppClient.Connect(); err != nil {
148 log.Debugf("Connected to VPP.")
150 if err := c.retrieveMessageIDs(); err != nil {
151 c.vppClient.Disconnect()
152 return fmt.Errorf("VPP is incompatible: %v", err)
155 // store connected state
156 atomic.StoreUint32(&c.vppConnected, 1)
161 // Disconnect disconnects from VPP and releases all connection-related resources.
162 func (c *Connection) Disconnect() {
167 if c.vppClient != nil {
172 // disconnectVPP disconnects from VPP in case it is connected.
173 func (c *Connection) disconnectVPP() {
174 if atomic.CompareAndSwapUint32(&c.vppConnected, 1, 0) {
175 c.vppClient.Disconnect()
179 func (c *Connection) NewAPIChannel() (api.Channel, error) {
180 return c.newAPIChannel(RequestChanBufSize, ReplyChanBufSize)
183 func (c *Connection) NewAPIChannelBuffered(reqChanBufSize, replyChanBufSize int) (api.Channel, error) {
184 return c.newAPIChannel(reqChanBufSize, replyChanBufSize)
187 // NewAPIChannelBuffered returns a new API channel for communication with VPP via govpp core.
188 // It allows to specify custom buffer sizes for the request and reply Go channels.
189 func (c *Connection) newAPIChannel(reqChanBufSize, replyChanBufSize int) (*Channel, error) {
191 return nil, errors.New("nil connection passed in")
194 // create new channel
195 chID := uint16(atomic.AddUint32(&c.maxChannelID, 1) & 0x7fff)
196 channel := newChannel(chID, c, c.codec, c, reqChanBufSize, replyChanBufSize)
198 // store API channel within the client
199 c.channelsLock.Lock()
200 c.channels[chID] = channel
201 c.channelsLock.Unlock()
203 // start watching on the request channel
204 go c.watchRequests(channel)
209 // releaseAPIChannel releases API channel that needs to be closed.
210 func (c *Connection) releaseAPIChannel(ch *Channel) {
211 log.WithFields(logger.Fields{
213 }).Debug("API channel released")
215 // delete the channel from channels map
216 c.channelsLock.Lock()
217 delete(c.channels, ch.id)
218 c.channelsLock.Unlock()
221 // connectLoop attempts to connect to VPP until it succeeds.
222 // Then it continues with healthCheckLoop.
223 func (c *Connection) connectLoop(connChan chan ConnectionEvent) {
224 reconnectAttempts := 0
226 // loop until connected
228 if err := c.vppClient.WaitReady(); err != nil {
229 log.Warnf("wait ready failed: %v", err)
231 if err := c.connectVPP(); err == nil {
232 // signal connected event
233 connChan <- ConnectionEvent{Timestamp: time.Now(), State: Connected}
235 } else if reconnectAttempts < MaxReconnectAttempts {
237 log.Errorf("connecting failed (attempt %d/%d): %v", reconnectAttempts, MaxReconnectAttempts, err)
238 time.Sleep(ReconnectInterval)
240 connChan <- ConnectionEvent{Timestamp: time.Now(), State: Failed, Error: err}
245 // we are now connected, continue with health check loop
246 c.healthCheckLoop(connChan)
249 // healthCheckLoop checks whether connection to VPP is alive. In case of disconnect,
250 // it continues with connectLoop and tries to reconnect.
251 func (c *Connection) healthCheckLoop(connChan chan ConnectionEvent) {
252 // create a separate API channel for health check probes
253 ch, err := c.newAPIChannel(1, 1)
255 log.Error("Failed to create health check API channel, health check will be disabled:", err)
260 sinceLastReply time.Duration
264 // send health check probes until an error or timeout occurs
266 // sleep until next health check probe period
267 time.Sleep(HealthCheckProbeInterval)
269 if atomic.LoadUint32(&c.vppConnected) == 0 {
270 // Disconnect has been called in the meantime, return the healthcheck - reconnect loop
271 log.Debug("Disconnected on request, exiting health check loop.")
275 // try draining probe replies from previous request before sending next one
278 log.Debug("drained old probe reply from reply channel")
282 // send the control ping request
283 ch.reqChan <- &vppRequest{msg: msgControlPing}
286 // expect response within timeout period
288 case vppReply := <-ch.replyChan:
291 case <-time.After(HealthCheckReplyTimeout):
292 err = ErrProbeTimeout
294 // check if time since last reply from any other
295 // channel is less than health check reply timeout
296 c.lastReplyLock.Lock()
297 sinceLastReply = time.Since(c.lastReply)
298 c.lastReplyLock.Unlock()
300 if sinceLastReply < HealthCheckReplyTimeout {
301 log.Warnf("VPP health check probe timing out, but some request on other channel was received %v ago, continue waiting!", sinceLastReply)
308 if err == ErrProbeTimeout {
310 log.Warnf("VPP health check probe timed out after %v (%d. timeout)", HealthCheckReplyTimeout, failedChecks)
311 if failedChecks > HealthCheckThreshold {
312 // in case of exceeded failed check treshold, assume VPP disconnected
313 log.Errorf("VPP health check exceeded treshold for timeouts (>%d), assuming disconnect", HealthCheckThreshold)
314 connChan <- ConnectionEvent{Timestamp: time.Now(), State: Disconnected}
317 } else if err != nil {
318 // in case of error, assume VPP disconnected
319 log.Errorf("VPP health check probe failed: %v", err)
320 connChan <- ConnectionEvent{Timestamp: time.Now(), State: Disconnected, Error: err}
322 } else if failedChecks > 0 {
323 // in case of success after failed checks, clear failed check counter
325 log.Infof("VPP health check probe OK")
333 // we are now disconnected, start connect loop
334 c.connectLoop(connChan)
337 func getMsgNameWithCrc(x api.Message) string {
338 return x.GetMessageName() + "_" + x.GetCrcString()
341 func getMsgFactory(msg api.Message) func() api.Message {
342 return func() api.Message {
343 return reflect.New(reflect.TypeOf(msg).Elem()).Interface().(api.Message)
347 // GetMessageID returns message identifier of given API message.
348 func (c *Connection) GetMessageID(msg api.Message) (uint16, error) {
350 return 0, errors.New("nil connection passed in")
353 if msgID, ok := c.msgIDs[getMsgNameWithCrc(msg)]; ok {
357 msgID, err := c.vppClient.GetMsgID(msg.GetMessageName(), msg.GetCrcString())
362 c.msgIDs[getMsgNameWithCrc(msg)] = msgID
363 c.msgMap[msgID] = msg
368 // LookupByID looks up message name and crc by ID.
369 func (c *Connection) LookupByID(msgID uint16) (api.Message, error) {
371 return nil, errors.New("nil connection passed in")
374 if msg, ok := c.msgMap[msgID]; ok {
378 return nil, fmt.Errorf("unknown message ID: %d", msgID)
381 // retrieveMessageIDs retrieves IDs for all registered messages and stores them in map
382 func (c *Connection) retrieveMessageIDs() (err error) {
385 msgs := api.GetRegisteredMessages()
388 for name, msg := range msgs {
389 msgID, err := c.GetMessageID(msg)
391 log.Debugf("retrieving msgID for %s failed: %v", name, err)
396 if c.pingReqID == 0 && msg.GetMessageName() == msgControlPing.GetMessageName() {
398 msgControlPing = reflect.New(reflect.TypeOf(msg).Elem()).Interface().(api.Message)
399 } else if c.pingReplyID == 0 && msg.GetMessageName() == msgControlPingReply.GetMessageName() {
400 c.pingReplyID = msgID
401 msgControlPingReply = reflect.New(reflect.TypeOf(msg).Elem()).Interface().(api.Message)
405 log.Debugf("message %q (%s) has ID: %d", name, getMsgNameWithCrc(msg), msgID)
408 log.Debugf("retrieved %d/%d msgIDs (took %s)", n, len(msgs), time.Since(t))