Add support for using multiple generated versions

- added CheckCompatibility for checking if given messages are compatible
- generating Messages global for easier usage of compatibility check
- added ReconnectInterval and MaxReconnectAttempts for reconnecting
- added Failed state that is sent after exceeding max reconnect attempts

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

diff --git a/api/api.go b/api/api.go
index 3e4eb0b..ac9f8a4 100644 (file)
--- a/api/api.go
+++ b/api/api.go
@@ -15,7 +15,6 @@
 package api
 
 import (
-       "fmt"
        "time"
 )
 
@@ -89,6 +88,10 @@ type Channel interface {
        // from VPP before returning an error.
        SetReplyTimeout(timeout time.Duration)
 
+       // CheckCompatibility checks the compatiblity for the given messages.
+       // It will return an error if any of the given messages are not compatible.
+       CheckCompatiblity(msgs ...Message) error
+
        // Close closes the API channel and releases all API channel-related resources in the ChannelProvider.
        Close()
 }
@@ -119,9 +122,10 @@ var registeredMessages = make(map[string]Message)
 
 // RegisterMessage is called from generated code to register message.
 func RegisterMessage(x Message, name string) {
-       if _, ok := registeredMessages[name]; ok {
+       name = x.GetMessageName() + "_" + x.GetCrcString()
+       /*if _, ok := registeredMessages[name]; ok {
                panic(fmt.Errorf("govpp: duplicate message registered: %s (%s)", name, x.GetCrcString()))
-       }
+       }*/
        registeredMessages[name] = x
 }
 

diff --git a/cmd/binapi-generator/generate.go b/cmd/binapi-generator/generate.go
index f2da08a..f22a035 100644 (file)
--- a/cmd/binapi-generator/generate.go
+++ b/cmd/binapi-generator/generate.go
@@ -152,6 +152,14 @@ func generatePackage(ctx *context, w *bufio.Writer) error {
                        fmt.Fprintf(w, "\tapi.RegisterMessage((*%s)(nil), \"%s\")\n", name, ctx.moduleName+"."+name)
                }
                fmt.Fprintln(w, "}")
+               fmt.Fprintln(w)
+
+               fmt.Fprintln(w, "var Messages = []api.Message{")
+               for _, msg := range ctx.packageData.Messages {
+                       name := camelCaseName(msg.Name)
+                       fmt.Fprintf(w, "\t(*%s)(nil),\n", name)
+               }
+               fmt.Fprintln(w, "}")
        }
 
        // flush the data:

diff --git a/core/channel.go b/core/channel.go
index 5b69eab..bf27b73 100644 (file)
--- a/core/channel.go
+++ b/core/channel.go
@@ -142,10 +142,14 @@ func (ch *Channel) SendMultiRequest(msg api.Message) api.MultiRequestCtx {
        return &multiRequestCtx{ch: ch, seqNum: seqNum}
 }
 
-func getMsgFactory(msg api.Message) func() api.Message {
-       return func() api.Message {
-               return reflect.New(reflect.TypeOf(msg).Elem()).Interface().(api.Message)
+func (ch *Channel) CheckCompatiblity(msgs ...api.Message) error {
+       for _, msg := range msgs {
+               _, err := ch.msgIdentifier.GetMessageID(msg)
+               if err != nil {
+                       return err
+               }
        }
+       return nil
 }
 
 func (ch *Channel) SubscribeNotification(notifChan chan api.Message, event api.Message) (api.SubscriptionCtx, error) {

diff --git a/core/connection.go b/core/connection.go
index 08f08f5..14b0af4 100644 (file)
--- a/core/connection.go
+++ b/core/connection.go
@@ -40,6 +40,8 @@ var (
        HealthCheckReplyTimeout  = time.Millisecond * 100 // timeout for reply to a health check probe
        HealthCheckThreshold     = 1                      // number of failed health checks until the error is reported
        DefaultReplyTimeout      = time.Second * 1        // default timeout for replies from VPP
+       ReconnectInterval        = time.Second * 1        // default interval for reconnect attempts
+       MaxReconnectAttempts     = 10                     // maximum number of reconnect attempts
 )
 
 // ConnectionState represents the current state of the connection to VPP.
@@ -51,6 +53,9 @@ const (
 
        // Disconnected represents state in which the connection has been dropped.
        Disconnected
+
+       // Failed represents state in which the reconnecting failed after exceeding maximum number of attempts.
+       Failed
 )
 
 // ConnectionEvent is a notification about change in the VPP connection state.
@@ -213,88 +218,11 @@ func (c *Connection) releaseAPIChannel(ch *Channel) {
        c.channelsLock.Unlock()
 }
 
-// GetMessageID returns message identifier of given API message.
-func (c *Connection) GetMessageID(msg api.Message) (uint16, error) {
-       if c == nil {
-               return 0, errors.New("nil connection passed in")
-       }
-
-       if msgID, ok := c.msgIDs[getMsgNameWithCrc(msg)]; ok {
-               return msgID, nil
-       }
-
-       return 0, fmt.Errorf("unknown message: %s (%s)", msg.GetMessageName(), msg.GetCrcString())
-}
-
-// LookupByID looks up message name and crc by ID.
-func (c *Connection) LookupByID(msgID uint16) (api.Message, error) {
-       if c == nil {
-               return nil, errors.New("nil connection passed in")
-       }
-
-       if msg, ok := c.msgMap[msgID]; ok {
-               return msg, nil
-       }
-
-       return nil, fmt.Errorf("unknown message ID: %d", msgID)
-}
-
-// retrieveMessageIDs retrieves IDs for all registered messages and stores them in map
-func (c *Connection) retrieveMessageIDs() (err error) {
-       t := time.Now()
-
-       var addMsg = func(msgID uint16, msg api.Message) {
-               c.msgIDs[getMsgNameWithCrc(msg)] = msgID
-               c.msgMap[msgID] = msg
-       }
-
-       msgs := api.GetRegisteredMessages()
-
-       for name, msg := range msgs {
-               msgID, err := c.vppClient.GetMsgID(msg.GetMessageName(), msg.GetCrcString())
-               if err != nil {
-                       return err
-               }
-
-               addMsg(msgID, msg)
-
-               if msg.GetMessageName() == msgControlPing.GetMessageName() {
-                       c.pingReqID = msgID
-                       msgControlPing = reflect.New(reflect.TypeOf(msg).Elem()).Interface().(api.Message)
-               } else if msg.GetMessageName() == msgControlPingReply.GetMessageName() {
-                       c.pingReplyID = msgID
-                       msgControlPingReply = reflect.New(reflect.TypeOf(msg).Elem()).Interface().(api.Message)
-               }
-
-               if debugMsgIDs {
-                       log.Debugf("message %q (%s) has ID: %d", name, getMsgNameWithCrc(msg), msgID)
-               }
-       }
-
-       log.Debugf("retrieving %d message IDs took %s", len(msgs), time.Since(t))
-
-       // fallback for control ping when vpe package is not imported
-       if c.pingReqID == 0 {
-               c.pingReqID, err = c.vppClient.GetMsgID(msgControlPing.GetMessageName(), msgControlPing.GetCrcString())
-               if err != nil {
-                       return err
-               }
-               addMsg(c.pingReqID, msgControlPing)
-       }
-       if c.pingReplyID == 0 {
-               c.pingReplyID, err = c.vppClient.GetMsgID(msgControlPingReply.GetMessageName(), msgControlPingReply.GetCrcString())
-               if err != nil {
-                       return err
-               }
-               addMsg(c.pingReplyID, msgControlPingReply)
-       }
-
-       return nil
-}
-
 // connectLoop attempts to connect to VPP until it succeeds.
 // Then it continues with healthCheckLoop.
 func (c *Connection) connectLoop(connChan chan ConnectionEvent) {
+       reconnectAttempts := 0
+
        // loop until connected
        for {
                if err := c.vppClient.WaitReady(); err != nil {
@@ -304,9 +232,13 @@ func (c *Connection) connectLoop(connChan chan ConnectionEvent) {
                        // signal connected event
                        connChan <- ConnectionEvent{Timestamp: time.Now(), State: Connected}
                        break
+               } else if reconnectAttempts < MaxReconnectAttempts {
+                       reconnectAttempts++
+                       log.Errorf("connecting failed (attempt %d/%d): %v", reconnectAttempts, MaxReconnectAttempts, err)
+                       time.Sleep(ReconnectInterval)
                } else {
-                       log.Errorf("connecting to VPP failed: %v", err)
-                       time.Sleep(time.Second)
+                       connChan <- ConnectionEvent{Timestamp: time.Now(), State: Failed, Error: err}
+                       return
                }
        }
 
@@ -405,3 +337,75 @@ func (c *Connection) healthCheckLoop(connChan chan ConnectionEvent) {
 func getMsgNameWithCrc(x api.Message) string {
        return x.GetMessageName() + "_" + x.GetCrcString()
 }
+
+func getMsgFactory(msg api.Message) func() api.Message {
+       return func() api.Message {
+               return reflect.New(reflect.TypeOf(msg).Elem()).Interface().(api.Message)
+       }
+}
+
+// GetMessageID returns message identifier of given API message.
+func (c *Connection) GetMessageID(msg api.Message) (uint16, error) {
+       if c == nil {
+               return 0, errors.New("nil connection passed in")
+       }
+
+       if msgID, ok := c.msgIDs[getMsgNameWithCrc(msg)]; ok {
+               return msgID, nil
+       }
+
+       msgID, err := c.vppClient.GetMsgID(msg.GetMessageName(), msg.GetCrcString())
+       if err != nil {
+               return 0, err
+       }
+
+       c.msgIDs[getMsgNameWithCrc(msg)] = msgID
+       c.msgMap[msgID] = msg
+
+       return msgID, nil
+}
+
+// LookupByID looks up message name and crc by ID.
+func (c *Connection) LookupByID(msgID uint16) (api.Message, error) {
+       if c == nil {
+               return nil, errors.New("nil connection passed in")
+       }
+
+       if msg, ok := c.msgMap[msgID]; ok {
+               return msg, nil
+       }
+
+       return nil, fmt.Errorf("unknown message ID: %d", msgID)
+}
+
+// retrieveMessageIDs retrieves IDs for all registered messages and stores them in map
+func (c *Connection) retrieveMessageIDs() (err error) {
+       t := time.Now()
+
+       msgs := api.GetRegisteredMessages()
+
+       var n int
+       for name, msg := range msgs {
+               msgID, err := c.GetMessageID(msg)
+               if err != nil {
+                       log.Debugf("retrieving msgID for %s failed: %v", name, err)
+                       continue
+               }
+               n++
+
+               if c.pingReqID == 0 && msg.GetMessageName() == msgControlPing.GetMessageName() {
+                       c.pingReqID = msgID
+                       msgControlPing = reflect.New(reflect.TypeOf(msg).Elem()).Interface().(api.Message)
+               } else if c.pingReplyID == 0 && msg.GetMessageName() == msgControlPingReply.GetMessageName() {
+                       c.pingReplyID = msgID
+                       msgControlPingReply = reflect.New(reflect.TypeOf(msg).Elem()).Interface().(api.Message)
+               }
+
+               if debugMsgIDs {
+                       log.Debugf("message %q (%s) has ID: %d", name, getMsgNameWithCrc(msg), msgID)
+               }
+       }
+       log.Debugf("retrieved %d/%d msgIDs (took %s)", n, len(msgs), time.Since(t))
+
+       return nil
+}

diff --git a/core/control_ping.go b/core/control_ping.go
index 904068a..cd447b7 100644 (file)
--- a/core/control_ping.go
+++ b/core/control_ping.go
@@ -7,6 +7,16 @@ var (
        msgControlPingReply api.Message = new(ControlPingReply)
 )
 
+// SetControlPing sets the control ping message used by core.
+func SetControlPing(m api.Message) {
+       msgControlPing = m
+}
+
+// SetControlPingReply sets the control ping reply message used by core.
+func SetControlPingReply(m api.Message) {
+       msgControlPingReply = m
+}
+
 type ControlPing struct{}
 
 func (*ControlPing) GetMessageName() string {
@@ -34,3 +44,8 @@ func (*ControlPingReply) GetCrcString() string {
 func (*ControlPingReply) GetMessageType() api.MessageType {
        return api.ReplyMessage
 }
+
+func init() {
+       api.RegisterMessage((*ControlPing)(nil), "ControlPing")
+       api.RegisterMessage((*ControlPingReply)(nil), "ControlPingReply")
+}

diff --git a/core/request_handler.go b/core/request_handler.go
index 4004d15..dc90747 100644 (file)
--- a/core/request_handler.go
+++ b/core/request_handler.go
@@ -91,6 +91,7 @@ func (c *Connection) processRequest(ch *Channel, req *vppRequest) error {
                        "msg_name": req.msg.GetMessageName(),
                        "msg_size": len(data),
                        "seq_num":  req.seqNum,
+                       "msg_crc":  req.msg.GetCrcString(),
                }).Debug(" -> Sending a message to VPP.")
        }
 
@@ -163,6 +164,7 @@ func (c *Connection) msgCallback(msgID uint16, data []byte) {
                        "channel":  chanID,
                        "is_multi": isMulti,
                        "seq_num":  seqNum,
+                       "msg_crc":  msg.GetCrcString(),
                }).Debug(" <- Received a message from VPP.")
        }
 

diff --git a/examples/bin_api/acl/acl.ba.go b/examples/bin_api/acl/acl.ba.go
index b37fd76..54fe26d 100644 (file)
--- a/examples/bin_api/acl/acl.ba.go
+++ b/examples/bin_api/acl/acl.ba.go
@@ -697,3 +697,42 @@ func init() {
        api.RegisterMessage((*MacipACLInterfaceListDetails)(nil), "acl.MacipACLInterfaceListDetails")
        api.RegisterMessage((*MacipACLInterfaceListDump)(nil), "acl.MacipACLInterfaceListDump")
 }
+
+var Messages = []api.Message{
+       (*ACLAddReplace)(nil),
+       (*ACLAddReplaceReply)(nil),
+       (*ACLDel)(nil),
+       (*ACLDelReply)(nil),
+       (*ACLDetails)(nil),
+       (*ACLDump)(nil),
+       (*ACLInterfaceAddDel)(nil),
+       (*ACLInterfaceAddDelReply)(nil),
+       (*ACLInterfaceEtypeWhitelistDetails)(nil),
+       (*ACLInterfaceEtypeWhitelistDump)(nil),
+       (*ACLInterfaceListDetails)(nil),
+       (*ACLInterfaceListDump)(nil),
+       (*ACLInterfaceSetACLList)(nil),
+       (*ACLInterfaceSetACLListReply)(nil),
+       (*ACLInterfaceSetEtypeWhitelist)(nil),
+       (*ACLInterfaceSetEtypeWhitelistReply)(nil),
+       (*ACLPluginControlPing)(nil),
+       (*ACLPluginControlPingReply)(nil),
+       (*ACLPluginGetConnTableMaxEntries)(nil),
+       (*ACLPluginGetConnTableMaxEntriesReply)(nil),
+       (*ACLPluginGetVersion)(nil),
+       (*ACLPluginGetVersionReply)(nil),
+       (*MacipACLAdd)(nil),
+       (*MacipACLAddReplace)(nil),
+       (*MacipACLAddReplaceReply)(nil),
+       (*MacipACLAddReply)(nil),
+       (*MacipACLDel)(nil),
+       (*MacipACLDelReply)(nil),
+       (*MacipACLDetails)(nil),
+       (*MacipACLDump)(nil),
+       (*MacipACLInterfaceAddDel)(nil),
+       (*MacipACLInterfaceAddDelReply)(nil),
+       (*MacipACLInterfaceGet)(nil),
+       (*MacipACLInterfaceGetReply)(nil),
+       (*MacipACLInterfaceListDetails)(nil),
+       (*MacipACLInterfaceListDump)(nil),
+}

diff --git a/examples/bin_api/af_packet/af_packet.ba.go b/examples/bin_api/af_packet/af_packet.ba.go
index 5177b7d..5197a5b 100644 (file)
--- a/examples/bin_api/af_packet/af_packet.ba.go
+++ b/examples/bin_api/af_packet/af_packet.ba.go
@@ -162,3 +162,14 @@ func init() {
        api.RegisterMessage((*AfPacketSetL4CksumOffload)(nil), "af_packet.AfPacketSetL4CksumOffload")
        api.RegisterMessage((*AfPacketSetL4CksumOffloadReply)(nil), "af_packet.AfPacketSetL4CksumOffloadReply")
 }
+
+var Messages = []api.Message{
+       (*AfPacketCreate)(nil),
+       (*AfPacketCreateReply)(nil),
+       (*AfPacketDelete)(nil),
+       (*AfPacketDeleteReply)(nil),
+       (*AfPacketDetails)(nil),
+       (*AfPacketDump)(nil),
+       (*AfPacketSetL4CksumOffload)(nil),
+       (*AfPacketSetL4CksumOffloadReply)(nil),
+}

diff --git a/examples/bin_api/interfaces/interfaces.ba.go b/examples/bin_api/interfaces/interfaces.ba.go
index 5f949df..dfdea00 100644 (file)
--- a/examples/bin_api/interfaces/interfaces.ba.go
+++ b/examples/bin_api/interfaces/interfaces.ba.go
@@ -958,3 +958,57 @@ func init() {
        api.RegisterMessage((*WantInterfaceEvents)(nil), "interface.WantInterfaceEvents")
        api.RegisterMessage((*WantInterfaceEventsReply)(nil), "interface.WantInterfaceEventsReply")
 }
+
+var Messages = []api.Message{
+       (*CollectDetailedInterfaceStats)(nil),
+       (*CollectDetailedInterfaceStatsReply)(nil),
+       (*CreateLoopback)(nil),
+       (*CreateLoopbackInstance)(nil),
+       (*CreateLoopbackInstanceReply)(nil),
+       (*CreateLoopbackReply)(nil),
+       (*CreateSubif)(nil),
+       (*CreateSubifReply)(nil),
+       (*CreateVlanSubif)(nil),
+       (*CreateVlanSubifReply)(nil),
+       (*DeleteLoopback)(nil),
+       (*DeleteLoopbackReply)(nil),
+       (*DeleteSubif)(nil),
+       (*DeleteSubifReply)(nil),
+       (*HwInterfaceSetMtu)(nil),
+       (*HwInterfaceSetMtuReply)(nil),
+       (*InterfaceNameRenumber)(nil),
+       (*InterfaceNameRenumberReply)(nil),
+       (*SwInterfaceAddDelAddress)(nil),
+       (*SwInterfaceAddDelAddressReply)(nil),
+       (*SwInterfaceClearStats)(nil),
+       (*SwInterfaceClearStatsReply)(nil),
+       (*SwInterfaceDetails)(nil),
+       (*SwInterfaceDump)(nil),
+       (*SwInterfaceEvent)(nil),
+       (*SwInterfaceGetMacAddress)(nil),
+       (*SwInterfaceGetMacAddressReply)(nil),
+       (*SwInterfaceGetTable)(nil),
+       (*SwInterfaceGetTableReply)(nil),
+       (*SwInterfaceRxPlacementDetails)(nil),
+       (*SwInterfaceRxPlacementDump)(nil),
+       (*SwInterfaceSetFlags)(nil),
+       (*SwInterfaceSetFlagsReply)(nil),
+       (*SwInterfaceSetIPDirectedBroadcast)(nil),
+       (*SwInterfaceSetIPDirectedBroadcastReply)(nil),
+       (*SwInterfaceSetMacAddress)(nil),
+       (*SwInterfaceSetMacAddressReply)(nil),
+       (*SwInterfaceSetMtu)(nil),
+       (*SwInterfaceSetMtuReply)(nil),
+       (*SwInterfaceSetRxMode)(nil),
+       (*SwInterfaceSetRxModeReply)(nil),
+       (*SwInterfaceSetRxPlacement)(nil),
+       (*SwInterfaceSetRxPlacementReply)(nil),
+       (*SwInterfaceSetTable)(nil),
+       (*SwInterfaceSetTableReply)(nil),
+       (*SwInterfaceSetUnnumbered)(nil),
+       (*SwInterfaceSetUnnumberedReply)(nil),
+       (*SwInterfaceTagAddDel)(nil),
+       (*SwInterfaceTagAddDelReply)(nil),
+       (*WantInterfaceEvents)(nil),
+       (*WantInterfaceEventsReply)(nil),
+}

diff --git a/examples/bin_api/ip/ip.ba.go b/examples/bin_api/ip/ip.ba.go
index bedb5c9..b566608 100644 (file)
--- a/examples/bin_api/ip/ip.ba.go
+++ b/examples/bin_api/ip/ip.ba.go
@@ -1959,3 +1959,97 @@ func init() {
        api.RegisterMessage((*WantIP6RaEvents)(nil), "ip.WantIP6RaEvents")
        api.RegisterMessage((*WantIP6RaEventsReply)(nil), "ip.WantIP6RaEventsReply")
 }
+
+var Messages = []api.Message{
+       (*IoamDisable)(nil),
+       (*IoamDisableReply)(nil),
+       (*IoamEnable)(nil),
+       (*IoamEnableReply)(nil),
+       (*IP4ArpEvent)(nil),
+       (*IP6FibDetails)(nil),
+       (*IP6FibDump)(nil),
+       (*IP6MfibDetails)(nil),
+       (*IP6MfibDump)(nil),
+       (*IP6NdEvent)(nil),
+       (*IP6RaEvent)(nil),
+       (*IP6ndProxyAddDel)(nil),
+       (*IP6ndProxyAddDelReply)(nil),
+       (*IP6ndProxyDetails)(nil),
+       (*IP6ndProxyDump)(nil),
+       (*IP6ndSendRouterSolicitation)(nil),
+       (*IP6ndSendRouterSolicitationReply)(nil),
+       (*IPAddDelRoute)(nil),
+       (*IPAddDelRouteReply)(nil),
+       (*IPAddressDetails)(nil),
+       (*IPAddressDump)(nil),
+       (*IPContainerProxyAddDel)(nil),
+       (*IPContainerProxyAddDelReply)(nil),
+       (*IPContainerProxyDetails)(nil),
+       (*IPContainerProxyDump)(nil),
+       (*IPDetails)(nil),
+       (*IPDump)(nil),
+       (*IPFibDetails)(nil),
+       (*IPFibDump)(nil),
+       (*IPMfibDetails)(nil),
+       (*IPMfibDump)(nil),
+       (*IPMrouteAddDel)(nil),
+       (*IPMrouteAddDelReply)(nil),
+       (*IPNeighborAddDel)(nil),
+       (*IPNeighborAddDelReply)(nil),
+       (*IPNeighborDetails)(nil),
+       (*IPNeighborDump)(nil),
+       (*IPProbeNeighbor)(nil),
+       (*IPProbeNeighborReply)(nil),
+       (*IPPuntPolice)(nil),
+       (*IPPuntPoliceReply)(nil),
+       (*IPPuntRedirect)(nil),
+       (*IPPuntRedirectDetails)(nil),
+       (*IPPuntRedirectDump)(nil),
+       (*IPPuntRedirectReply)(nil),
+       (*IPReassemblyEnableDisable)(nil),
+       (*IPReassemblyEnableDisableReply)(nil),
+       (*IPReassemblyGet)(nil),
+       (*IPReassemblyGetReply)(nil),
+       (*IPReassemblySet)(nil),
+       (*IPReassemblySetReply)(nil),
+       (*IPScanNeighborEnableDisable)(nil),
+       (*IPScanNeighborEnableDisableReply)(nil),
+       (*IPSourceAndPortRangeCheckAddDel)(nil),
+       (*IPSourceAndPortRangeCheckAddDelReply)(nil),
+       (*IPSourceAndPortRangeCheckInterfaceAddDel)(nil),
+       (*IPSourceAndPortRangeCheckInterfaceAddDelReply)(nil),
+       (*IPSourceCheckInterfaceAddDel)(nil),
+       (*IPSourceCheckInterfaceAddDelReply)(nil),
+       (*IPTableAddDel)(nil),
+       (*IPTableAddDelReply)(nil),
+       (*IPUnnumberedDetails)(nil),
+       (*IPUnnumberedDump)(nil),
+       (*MfibSignalDetails)(nil),
+       (*MfibSignalDump)(nil),
+       (*ProxyArpAddDel)(nil),
+       (*ProxyArpAddDelReply)(nil),
+       (*ProxyArpDetails)(nil),
+       (*ProxyArpDump)(nil),
+       (*ProxyArpIntfcDetails)(nil),
+       (*ProxyArpIntfcDump)(nil),
+       (*ProxyArpIntfcEnableDisable)(nil),
+       (*ProxyArpIntfcEnableDisableReply)(nil),
+       (*ResetFib)(nil),
+       (*ResetFibReply)(nil),
+       (*SetArpNeighborLimit)(nil),
+       (*SetArpNeighborLimitReply)(nil),
+       (*SetIPFlowHash)(nil),
+       (*SetIPFlowHashReply)(nil),
+       (*SwInterfaceIP6EnableDisable)(nil),
+       (*SwInterfaceIP6EnableDisableReply)(nil),
+       (*SwInterfaceIP6ndRaConfig)(nil),
+       (*SwInterfaceIP6ndRaConfigReply)(nil),
+       (*SwInterfaceIP6ndRaPrefix)(nil),
+       (*SwInterfaceIP6ndRaPrefixReply)(nil),
+       (*WantIP4ArpEvents)(nil),
+       (*WantIP4ArpEventsReply)(nil),
+       (*WantIP6NdEvents)(nil),
+       (*WantIP6NdEventsReply)(nil),
+       (*WantIP6RaEvents)(nil),
+       (*WantIP6RaEventsReply)(nil),
+}

diff --git a/examples/bin_api/maps/maps.ba.go b/examples/bin_api/maps/maps.ba.go
index e4fea90..366b822 100644 (file)
--- a/examples/bin_api/maps/maps.ba.go
+++ b/examples/bin_api/maps/maps.ba.go
@@ -741,3 +741,38 @@ func init() {
        api.RegisterMessage((*MapSummaryStats)(nil), "map.MapSummaryStats")
        api.RegisterMessage((*MapSummaryStatsReply)(nil), "map.MapSummaryStatsReply")
 }
+
+var Messages = []api.Message{
+       (*MapAddDelRule)(nil),
+       (*MapAddDelRuleReply)(nil),
+       (*MapAddDomain)(nil),
+       (*MapAddDomainReply)(nil),
+       (*MapDelDomain)(nil),
+       (*MapDelDomainReply)(nil),
+       (*MapDomainDetails)(nil),
+       (*MapDomainDump)(nil),
+       (*MapIfEnableDisable)(nil),
+       (*MapIfEnableDisableReply)(nil),
+       (*MapParamAddDelPreResolve)(nil),
+       (*MapParamAddDelPreResolveReply)(nil),
+       (*MapParamGet)(nil),
+       (*MapParamGetReply)(nil),
+       (*MapParamSetFragmentation)(nil),
+       (*MapParamSetFragmentationReply)(nil),
+       (*MapParamSetICMP)(nil),
+       (*MapParamSetICMP6)(nil),
+       (*MapParamSetICMP6Reply)(nil),
+       (*MapParamSetICMPReply)(nil),
+       (*MapParamSetReassembly)(nil),
+       (*MapParamSetReassemblyReply)(nil),
+       (*MapParamSetSecurityCheck)(nil),
+       (*MapParamSetSecurityCheckReply)(nil),
+       (*MapParamSetTCP)(nil),
+       (*MapParamSetTCPReply)(nil),
+       (*MapParamSetTrafficClass)(nil),
+       (*MapParamSetTrafficClassReply)(nil),
+       (*MapRuleDetails)(nil),
+       (*MapRuleDump)(nil),
+       (*MapSummaryStats)(nil),
+       (*MapSummaryStatsReply)(nil),
+}

diff --git a/examples/bin_api/memif/memif.ba.go b/examples/bin_api/memif/memif.ba.go
index 800b64c..58c466e 100644 (file)
--- a/examples/bin_api/memif/memif.ba.go
+++ b/examples/bin_api/memif/memif.ba.go
@@ -211,3 +211,16 @@ func init() {
        api.RegisterMessage((*MemifSocketFilenameDetails)(nil), "memif.MemifSocketFilenameDetails")
        api.RegisterMessage((*MemifSocketFilenameDump)(nil), "memif.MemifSocketFilenameDump")
 }
+
+var Messages = []api.Message{
+       (*MemifCreate)(nil),
+       (*MemifCreateReply)(nil),
+       (*MemifDelete)(nil),
+       (*MemifDeleteReply)(nil),
+       (*MemifDetails)(nil),
+       (*MemifDump)(nil),
+       (*MemifSocketFilenameAddDel)(nil),
+       (*MemifSocketFilenameAddDelReply)(nil),
+       (*MemifSocketFilenameDetails)(nil),
+       (*MemifSocketFilenameDump)(nil),
+}

diff --git a/examples/bin_api/tap/tap.ba.go b/examples/bin_api/tap/tap.ba.go
index aafd206..04ae411 100644 (file)
--- a/examples/bin_api/tap/tap.ba.go
+++ b/examples/bin_api/tap/tap.ba.go
@@ -176,3 +176,14 @@ func init() {
        api.RegisterMessage((*TapModify)(nil), "tap.TapModify")
        api.RegisterMessage((*TapModifyReply)(nil), "tap.TapModifyReply")
 }
+
+var Messages = []api.Message{
+       (*SwInterfaceTapDetails)(nil),
+       (*SwInterfaceTapDump)(nil),
+       (*TapConnect)(nil),
+       (*TapConnectReply)(nil),
+       (*TapDelete)(nil),
+       (*TapDeleteReply)(nil),
+       (*TapModify)(nil),
+       (*TapModifyReply)(nil),
+}

diff --git a/examples/bin_api/vpe/vpe.ba.go b/examples/bin_api/vpe/vpe.ba.go
index 7dc718d..486f1a0 100644 (file)
--- a/examples/bin_api/vpe/vpe.ba.go
+++ b/examples/bin_api/vpe/vpe.ba.go
@@ -359,3 +359,24 @@ func init() {
        api.RegisterMessage((*ShowVersion)(nil), "vpe.ShowVersion")
        api.RegisterMessage((*ShowVersionReply)(nil), "vpe.ShowVersionReply")
 }
+
+var Messages = []api.Message{
+       (*AddNodeNext)(nil),
+       (*AddNodeNextReply)(nil),
+       (*Cli)(nil),
+       (*CliInband)(nil),
+       (*CliInbandReply)(nil),
+       (*CliReply)(nil),
+       (*ControlPing)(nil),
+       (*ControlPingReply)(nil),
+       (*GetNextIndex)(nil),
+       (*GetNextIndexReply)(nil),
+       (*GetNodeGraph)(nil),
+       (*GetNodeGraphReply)(nil),
+       (*GetNodeIndex)(nil),
+       (*GetNodeIndexReply)(nil),
+       (*ShowThreads)(nil),
+       (*ShowThreadsReply)(nil),
+       (*ShowVersion)(nil),
+       (*ShowVersionReply)(nil),
+}

diff --git a/examples/simple-client/simple_client.go b/examples/simple-client/simple_client.go
index 08d4da6..6429c35 100644 (file)
--- a/examples/simple-client/simple_client.go
+++ b/examples/simple-client/simple_client.go
@@ -25,6 +25,7 @@ import (
 
        "git.fd.io/govpp.git"
        "git.fd.io/govpp.git/api"
+       "git.fd.io/govpp.git/core"
        "git.fd.io/govpp.git/examples/bin_api/acl"
        "git.fd.io/govpp.git/examples/bin_api/interfaces"
        "git.fd.io/govpp.git/examples/bin_api/ip"
@@ -34,12 +35,19 @@ func main() {
        fmt.Println("Starting simple VPP client...")
 
        // connect to VPP
-       conn, err := govpp.Connect("")
+       conn, conev, err := govpp.AsyncConnect("")
        if err != nil {
                log.Fatalln("ERROR:", err)
        }
        defer conn.Disconnect()
 
+       select {
+       case e := <-conev:
+               if e.State != core.Connected {
+                       log.Fatalf("failed to connect: %v", e.Error)
+               }
+       }
+
        // create an API channel that will be used in the examples
        ch, err := conn.NewAPIChannel()
        if err != nil {