X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=examples%2Fsimple-client%2Fsimple_client.go;h=7aeaa0b7ea8250c4a1d234efb9303389b3f92a4f;hb=c7ae74a95d1bd6fefcbb061f5f045c60c11e32fc;hp=3a24e6a856c726d70fcfa27ba7a0c17f33e3c24d;hpb=ccb7b913d54fafdf08b36ac7eb36e462b1ecc9eb;p=govpp.git diff --git a/examples/simple-client/simple_client.go b/examples/simple-client/simple_client.go index 3a24e6a..7aeaa0b 100644 --- a/examples/simple-client/simple_client.go +++ b/examples/simple-client/simple_client.go @@ -17,18 +17,21 @@ package main import ( + "context" "flag" "fmt" "log" "os" - "strings" "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" ) @@ -63,16 +66,24 @@ func main() { } defer ch.Close() + if err := ch.CheckCompatiblity(vpe.AllMessages()...); err != nil { + log.Fatal(err) + } + vppVersion(ch) - createLoopback(ch) - createLoopback(ch) + if err := ch.CheckCompatiblity(interfaces.AllMessages()...); err != nil { + log.Fatal(err) + } + + idx := createLoopback(ch) interfaceDump(ch) - addIPAddress(ch) - ipAddressDump(ch) + addIPAddress(ch, idx) + ipAddressDump(ch, idx) + interfaceNotifications(ch, idx) - interfaceNotifications(ch) + mactimeDump(conn) if len(Errors) > 0 { fmt.Printf("finished with %d errors\n", len(Errors)) @@ -102,12 +113,13 @@ func vppVersion(ch api.Channel) { } fmt.Printf("reply: %+v\n", reply) - fmt.Printf("VPP version: %q\n", cleanString(reply.Version)) - fmt.Println("ok") + fmt.Printf("VPP version: %q\n", reply.Version) + fmt.Println("OK") + fmt.Println() } // createLoopback sends request to create loopback interface. -func createLoopback(ch api.Channel) { +func createLoopback(ch api.Channel) interface_types.InterfaceIndex { fmt.Println("Creating loopback interface") req := &interfaces.CreateLoopback{} @@ -115,53 +127,55 @@ func createLoopback(ch api.Channel) { if err := ch.SendRequest(req).ReceiveReply(reply); err != nil { logError(err, "creating loopback interface") - return + return 0 } fmt.Printf("reply: %+v\n", reply) - fmt.Printf("loopback interface index: %v\n", reply.SwIfIndex) + fmt.Printf("interface index: %v\n", reply.SwIfIndex) fmt.Println("OK") + fmt.Println() + + return reply.SwIfIndex } // interfaceDump shows an example of multipart request (multiple replies are expected). func interfaceDump(ch api.Channel) { fmt.Println("Dumping interfaces") + n := 0 reqCtx := ch.SendMultiRequest(&interfaces.SwInterfaceDump{}) for { msg := &interfaces.SwInterfaceDetails{} stop, err := reqCtx.ReceiveReply(msg) + if stop { + break + } if err != nil { logError(err, "dumping interfaces") return } - if stop { - break - } - fmt.Printf(" - interface: %+v\n", msg) + n++ + fmt.Printf(" - interface #%d: %+v\n", n, msg) } fmt.Println("OK") + fmt.Println() } // addIPAddress sends request to add IP address to interface. -func addIPAddress(ch api.Channel) { - fmt.Println("Adding 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) req := &interfaces.SwInterfaceAddDelAddress{ - SwIfIndex: 1, - IsAdd: 1, - Address: []byte{10, 10, 0, 1}, - AddressLength: 24, - /* below for 20.01-rc0 + SwIfIndex: index, IsAdd: true, - Prefix: interfaces.Prefix{ - Address: interfaces.Address{ - Af: interfaces.ADDRESS_IP4, - Un: interfaces.AddressUnionIP4(interfaces.IP4Address{10, 10, 0, 1}), + Prefix: ip_types.AddressWithPrefix{ + Address: ip_types.Address{ + Af: ip_types.ADDRESS_IP4, + Un: ip_types.AddressUnionIP4(ip_types.IP4Address{10, 10, 0, uint8(index)}), }, - Len: 24, - },*/ + Len: 32, + }, } reply := &interfaces.SwInterfaceAddDelAddressReply{} @@ -172,13 +186,14 @@ func addIPAddress(ch api.Channel) { fmt.Printf("reply: %+v\n", reply) fmt.Println("OK") + fmt.Println() } -func ipAddressDump(ch api.Channel) { - fmt.Println("Dumping IP addresses") +func ipAddressDump(ch api.Channel, index interface_types.InterfaceIndex) { + fmt.Printf("Dumping IP addresses for interface index %d\n", index) req := &ip.IPAddressDump{ - SwIfIndex: 1, + SwIfIndex: index, } reqCtx := ch.SendMultiRequest(req) @@ -196,13 +211,14 @@ func ipAddressDump(ch api.Channel) { } fmt.Println("OK") + fmt.Println() } // interfaceNotifications shows the usage of notification API. Note that for notifications, // you are supposed to create your own Go channel with your preferred buffer size. If the channel's // buffer is full, the notifications will not be delivered into it. -func interfaceNotifications(ch api.Channel) { - fmt.Println("Subscribing to notificaiton events") +func interfaceNotifications(ch api.Channel, index interface_types.InterfaceIndex) { + fmt.Printf("Subscribing to notificaiton events for interface index %d\n", index) notifChan := make(chan api.Message, 100) @@ -223,30 +239,31 @@ func interfaceNotifications(ch api.Channel) { return } + // receive notifications + go func() { + for notif := range notifChan { + fmt.Printf("incoming event: %+v\n", notif.(*interfaces.SwInterfaceEvent)) + } + }() + // generate some events in VPP err = ch.SendRequest(&interfaces.SwInterfaceSetFlags{ - SwIfIndex: 1, + SwIfIndex: index, + Flags: interface_types.IF_STATUS_API_FLAG_ADMIN_UP, }).ReceiveReply(&interfaces.SwInterfaceSetFlagsReply{}) if err != nil { logError(err, "setting interface flags") return } err = ch.SendRequest(&interfaces.SwInterfaceSetFlags{ - SwIfIndex: 1, - AdminUpDown: 1, - /* below for 20.01-rc0 - AdminUpDown: true, - Flags: interfaces.IF_STATUS_API_FLAG_ADMIN_UP,*/ + SwIfIndex: index, + Flags: 0, }).ReceiveReply(&interfaces.SwInterfaceSetFlagsReply{}) if err != nil { logError(err, "setting interface flags") return } - // receive one notification - notif := (<-notifChan).(*interfaces.SwInterfaceEvent) - fmt.Printf("incoming event: %+v\n", notif) - // disable interface events in VPP err = ch.SendRequest(&interfaces.WantInterfaceEvents{ PID: uint32(os.Getpid()), @@ -264,9 +281,48 @@ func interfaceNotifications(ch api.Channel) { return } + fmt.Println("OK") fmt.Println() } -func cleanString(str string) string { - return strings.Split(str, "\x00")[0] +func mactimeDump(conn api.Connection) { + fmt.Println("Sending mactime dump") + + ctx := context.Background() + + stream, err := conn.NewStream(ctx) + 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) + + case *mactime.MactimeDumpReply: + fmt.Printf(" - MactimeDumpReply: %+v\n", msg) + break Loop + + default: + logError(err, "unexpected message") + return + } + } + + fmt.Println("OK") + fmt.Println() }