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"
)
ipAddressDump(ch, idx)
interfaceNotifications(ch, idx)
+ mactimeDump(conn)
+
if len(Errors) > 0 {
fmt.Printf("finished with %d errors\n", len(Errors))
os.Exit(1)
}
fmt.Printf("reply: %+v\n", reply)
- fmt.Printf("VPP version: %q\n", cleanString(reply.Version))
+ 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) interfaces.InterfaceIndex {
+func createLoopback(ch api.Channel) interface_types.InterfaceIndex {
fmt.Println("Creating loopback interface")
req := &interfaces.CreateLoopback{}
}
// addIPAddress sends request to add IP address to interface.
-func addIPAddress(ch api.Channel, index interfaces.InterfaceIndex) {
+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: index,
IsAdd: true,
- Prefix: interfaces.AddressWithPrefix{
- Address: interfaces.Address{
- Af: interfaces.ADDRESS_IP4,
- Un: interfaces.AddressUnionIP4(interfaces.IP4Address{10, 10, 0, uint8(index)}),
+ 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: 32,
},
fmt.Println()
}
-func ipAddressDump(ch api.Channel, index interfaces.InterfaceIndex) {
+func ipAddressDump(ch api.Channel, index interface_types.InterfaceIndex) {
fmt.Printf("Dumping IP addresses for interface index %d\n", index)
req := &ip.IPAddressDump{
- SwIfIndex: ip.InterfaceIndex(index),
+ SwIfIndex: index,
}
reqCtx := ch.SendMultiRequest(req)
// 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, index interfaces.InterfaceIndex) {
+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)
// generate some events in VPP
err = ch.SendRequest(&interfaces.SwInterfaceSetFlags{
SwIfIndex: index,
- Flags: interfaces.IF_STATUS_API_FLAG_ADMIN_UP,
+ Flags: interface_types.IF_STATUS_API_FLAG_ADMIN_UP,
}).ReceiveReply(&interfaces.SwInterfaceSetFlagsReply{})
if err != nil {
logError(err, "setting interface flags")
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()
}