package api
import (
- "fmt"
"time"
)
// 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()
}
// 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
}
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:
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) {
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.
// 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.
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 {
// 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
}
}
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
+}
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 {
func (*ControlPingReply) GetMessageType() api.MessageType {
return api.ReplyMessage
}
+
+func init() {
+ api.RegisterMessage((*ControlPing)(nil), "ControlPing")
+ api.RegisterMessage((*ControlPingReply)(nil), "ControlPingReply")
+}
"msg_name": req.msg.GetMessageName(),
"msg_size": len(data),
"seq_num": req.seqNum,
+ "msg_crc": req.msg.GetCrcString(),
}).Debug(" -> Sending a message to VPP.")
}
"channel": chanID,
"is_multi": isMulti,
"seq_num": seqNum,
+ "msg_crc": msg.GetCrcString(),
}).Debug(" <- Received a message from VPP.")
}
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),
+}
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),
+}
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),
+}
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),
+}
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),
+}
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),
+}
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),
+}
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),
+}
"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"
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 {