X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=examples%2Fsimple-client%2Fsimple_client.go;h=fea3e43bb26f8a299282686464862644309887d7;hb=67cea0df30f7ef348e265c9326f7a9f15ba26240;hp=7aeaa0b7ea8250c4a1d234efb9303389b3f92a4f;hpb=c7ae74a95d1bd6fefcbb061f5f045c60c11e32fc;p=govpp.git diff --git a/examples/simple-client/simple_client.go b/examples/simple-client/simple_client.go index 7aeaa0b..fea3e43 100644 --- a/examples/simple-client/simple_client.go +++ b/examples/simple-client/simple_client.go @@ -17,22 +17,21 @@ 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 ( @@ -43,9 +42,10 @@ func main() { 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) } @@ -53,56 +53,47 @@ func main() { // 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{} @@ -111,16 +102,30 @@ func vppVersion(ch api.Channel) { 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{} @@ -129,7 +134,6 @@ func createLoopback(ch api.Channel) interface_types.InterfaceIndex { logError(err, "creating loopback interface") return 0 } - fmt.Printf("reply: %+v\n", reply) fmt.Printf("interface index: %v\n", reply.SwIfIndex) fmt.Println("OK") @@ -138,12 +142,13 @@ func createLoopback(ch api.Channel) interface_types.InterfaceIndex { 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) @@ -156,15 +161,15 @@ func interfaceDump(ch api.Channel) { } 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, @@ -177,20 +182,20 @@ func addIPAddress(ch api.Channel, index interface_types.InterfaceIndex) { 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, @@ -208,6 +213,7 @@ func ipAddressDump(ch api.Channel, index interface_types.InterfaceIndex) { break } fmt.Printf(" - ip address: %+v\n", msg) + marshal(msg) } fmt.Println("OK") @@ -242,7 +248,9 @@ func interfaceNotifications(ch api.Channel, index interface_types.InterfaceIndex // 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) } }() @@ -285,44 +293,18 @@ func interfaceNotifications(ch api.Channel, index interface_types.InterfaceIndex 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) }