package main
import (
- "context"
+ "encoding/json"
"flag"
"fmt"
"log"
"os"
- "git.fd.io/govpp.git"
- "git.fd.io/govpp.git/adapter/socketclient"
- "git.fd.io/govpp.git/api"
- "git.fd.io/govpp.git/core"
- "git.fd.io/govpp.git/examples/binapi/interface_types"
- "git.fd.io/govpp.git/examples/binapi/interfaces"
- "git.fd.io/govpp.git/examples/binapi/ip"
- "git.fd.io/govpp.git/examples/binapi/ip_types"
- "git.fd.io/govpp.git/examples/binapi/mactime"
- "git.fd.io/govpp.git/examples/binapi/vpe"
+ "go.fd.io/govpp"
+ "go.fd.io/govpp/adapter/socketclient"
+ "go.fd.io/govpp/api"
+ interfaces "go.fd.io/govpp/binapi/interface"
+ "go.fd.io/govpp/binapi/interface_types"
+ "go.fd.io/govpp/binapi/ip"
+ "go.fd.io/govpp/binapi/ip_types"
+ "go.fd.io/govpp/binapi/vpe"
+ "go.fd.io/govpp/core"
)
var (
flag.Parse()
fmt.Println("Starting simple client example")
+ fmt.Println()
// connect to VPP asynchronously
- conn, conev, err := govpp.AsyncConnect(*sockAddr, core.DefaultMaxReconnectAttempts, core.DefaultReconnectInterval)
+ conn, connEv, err := govpp.AsyncConnect(*sockAddr, core.DefaultMaxReconnectAttempts, core.DefaultReconnectInterval)
if err != nil {
log.Fatalln("ERROR:", err)
}
// wait for Connected event
select {
- case e := <-conev:
+ case e := <-connEv:
if e.State != core.Connected {
log.Fatalln("ERROR: connecting to VPP failed:", e.Error)
}
}
- // create an API channel that will be used in the examples
+ // check compatibility of used messages
ch, err := conn.NewAPIChannel()
if err != nil {
log.Fatalln("ERROR: creating channel failed:", err)
}
defer ch.Close()
-
if err := ch.CheckCompatiblity(vpe.AllMessages()...); err != nil {
log.Fatal(err)
}
-
- vppVersion(ch)
-
if err := ch.CheckCompatiblity(interfaces.AllMessages()...); err != nil {
log.Fatal(err)
}
+ // process errors encountered during the example
+ defer func() {
+ if len(errors) > 0 {
+ fmt.Printf("finished with %d errors\n", len(errors))
+ os.Exit(1)
+ } else {
+ fmt.Println("finished successfully")
+ }
+ }()
+
+ // use request/reply (channel API)
+ getVppVersion(ch)
+ getSystemTime(ch)
idx := createLoopback(ch)
interfaceDump(ch)
-
addIPAddress(ch, idx)
ipAddressDump(ch, idx)
interfaceNotifications(ch, idx)
-
- mactimeDump(conn)
-
- if len(Errors) > 0 {
- fmt.Printf("finished with %d errors\n", len(Errors))
- os.Exit(1)
- } else {
- fmt.Println("finished successfully")
- }
}
-var Errors []error
-
-func logError(err error, msg string) {
- fmt.Printf("ERROR: %s: %v\n", msg, err)
- Errors = append(Errors, err)
-}
-
-// vppVersion is the simplest API example - it retrieves VPP version.
-func vppVersion(ch api.Channel) {
- fmt.Println("Retrieving version")
+func getVppVersion(ch api.Channel) {
+ fmt.Println("Retrieving version..")
req := &vpe.ShowVersion{}
reply := &vpe.ShowVersionReply{}
logError(err, "retrieving version")
return
}
- fmt.Printf("reply: %+v\n", reply)
fmt.Printf("VPP version: %q\n", reply.Version)
fmt.Println("OK")
fmt.Println()
}
-// createLoopback sends request to create loopback interface.
+func getSystemTime(ch api.Channel) {
+ fmt.Println("Retrieving system time..")
+
+ req := &vpe.ShowVpeSystemTime{}
+ reply := &vpe.ShowVpeSystemTimeReply{}
+
+ if err := ch.SendRequest(req).ReceiveReply(reply); err != nil {
+ logError(err, "retrieving system time")
+ return
+ }
+
+ fmt.Printf("system time: %v\n", reply.VpeSystemTime)
+ fmt.Println("OK")
+ fmt.Println()
+}
+
func createLoopback(ch api.Channel) interface_types.InterfaceIndex {
- fmt.Println("Creating loopback interface")
+ fmt.Println("Creating loopback interface..")
req := &interfaces.CreateLoopback{}
reply := &interfaces.CreateLoopbackReply{}
logError(err, "creating loopback interface")
return 0
}
- fmt.Printf("reply: %+v\n", reply)
fmt.Printf("interface index: %v\n", reply.SwIfIndex)
fmt.Println("OK")
return reply.SwIfIndex
}
-// interfaceDump shows an example of multipart request (multiple replies are expected).
func interfaceDump(ch api.Channel) {
- fmt.Println("Dumping interfaces")
+ fmt.Println("Dumping interfaces..")
n := 0
- reqCtx := ch.SendMultiRequest(&interfaces.SwInterfaceDump{})
+ reqCtx := ch.SendMultiRequest(&interfaces.SwInterfaceDump{
+ SwIfIndex: ^interface_types.InterfaceIndex(0),
+ })
for {
msg := &interfaces.SwInterfaceDetails{}
stop, err := reqCtx.ReceiveReply(msg)
}
n++
fmt.Printf(" - interface #%d: %+v\n", n, msg)
+ marshal(msg)
}
fmt.Println("OK")
fmt.Println()
}
-// addIPAddress sends request to add IP address to interface.
func addIPAddress(ch api.Channel, index interface_types.InterfaceIndex) {
- fmt.Printf("Adding IP address to interface to interface index %d\n", index)
+ fmt.Printf("Adding IP address to interface index %d\n", index)
req := &interfaces.SwInterfaceAddDelAddress{
SwIfIndex: index,
Len: 32,
},
}
+ marshal(req)
reply := &interfaces.SwInterfaceAddDelAddressReply{}
if err := ch.SendRequest(req).ReceiveReply(reply); err != nil {
logError(err, "adding IP address to interface")
return
}
- fmt.Printf("reply: %+v\n", reply)
fmt.Println("OK")
fmt.Println()
}
func ipAddressDump(ch api.Channel, index interface_types.InterfaceIndex) {
- fmt.Printf("Dumping IP addresses for interface index %d\n", index)
+ fmt.Printf("Dumping IP addresses for interface index %d..\n", index)
req := &ip.IPAddressDump{
SwIfIndex: index,
break
}
fmt.Printf(" - ip address: %+v\n", msg)
+ marshal(msg)
}
fmt.Println("OK")
// receive notifications
go func() {
for notif := range notifChan {
- fmt.Printf("incoming event: %+v\n", notif.(*interfaces.SwInterfaceEvent))
+ e := notif.(*interfaces.SwInterfaceEvent)
+ fmt.Printf("incoming event: %+v\n", e)
+ marshal(e)
}
}()
fmt.Println()
}
-func mactimeDump(conn api.Connection) {
- fmt.Println("Sending mactime dump")
-
- ctx := context.Background()
-
- stream, err := conn.NewStream(ctx)
+func marshal(v interface{}) {
+ fmt.Printf("GO: %#v\n", v)
+ b, err := json.MarshalIndent(v, "", " ")
if err != nil {
panic(err)
}
- defer stream.Close()
-
- if err := stream.SendMsg(&mactime.MactimeDump{}); err != nil {
- logError(err, "sending mactime dump")
- return
- }
-
-Loop:
- for {
- msg, err := stream.RecvMsg()
- if err != nil {
- logError(err, "dumping mactime")
- return
- }
-
- switch msg.(type) {
- case *mactime.MactimeDetails:
- fmt.Printf(" - MactimeDetails: %+v\n", msg)
+ fmt.Printf("JSON: %s\n", b)
+}
- case *mactime.MactimeDumpReply:
- fmt.Printf(" - MactimeDumpReply: %+v\n", msg)
- break Loop
+var errors []error
- default:
- logError(err, "unexpected message")
- return
- }
- }
-
- fmt.Println("OK")
- fmt.Println()
+func logError(err error, msg string) {
+ fmt.Printf("ERROR: %s: %v\n", msg, err)
+ errors = append(errors, err)
}
Code Review / govpp.git / blobdiff