"git.fd.io/govpp.git/adapter/socketclient"
"git.fd.io/govpp.git/adapter/statsclient"
"git.fd.io/govpp.git/api"
+ _ "git.fd.io/govpp.git/core"
"git.fd.io/govpp.git/examples/binapi/interfaces"
"git.fd.io/govpp.git/examples/binapi/vpe"
"git.fd.io/govpp.git/proxy"
if err != nil {
log.Fatalln(err)
}
+ log.Println("checking compatibility")
+ var msgs []api.Message
+ msgs = append(msgs, interfaces.AllMessages()...)
+ msgs = append(msgs, vpe.AllMessages()...)
+ if err := binapiChannel.CheckCompatiblity(msgs...); err != nil {
+ panic(err)
+ }
// - using binapi message directly
req := &vpe.CliInband{Cmd: "show version"}
func Connect(addr string) (*Client, error) {
client, err := rpc.DialHTTP("tcp", addr)
if err != nil {
- log.Fatal("Connection error: ", err)
+ return nil, fmt.Errorf("connection error:%v", err)
}
c := &Client{
serverAddr: addr,
}
func (s *StatsClient) GetSystemStats(sysStats *api.SystemStats) error {
+ // we need to start with a clean, zeroed item before decoding
+ // 'cause if the new values are 'zero' for the type, they will be ignored
+ // by the decoder. (i.e the old values will be left unchanged).
req := StatsRequest{StatsType: "system"}
- resp := StatsResponse{SysStats: sysStats}
- return s.rpc.Call("StatsRPC.GetStats", req, &resp)
+ resp := StatsResponse{SysStats: new(api.SystemStats)}
+ if err := s.rpc.Call("StatsRPC.GetStats", req, &resp); err != nil {
+ return err
+ }
+ *sysStats = *resp.SysStats
+ return nil
}
func (s *StatsClient) GetNodeStats(nodeStats *api.NodeStats) error {
req := StatsRequest{StatsType: "node"}
- resp := StatsResponse{NodeStats: nodeStats}
- return s.rpc.Call("StatsRPC.GetStats", req, &resp)
+ resp := StatsResponse{NodeStats: new(api.NodeStats)}
+ if err := s.rpc.Call("StatsRPC.GetStats", req, &resp); err != nil {
+ return err
+ }
+ *nodeStats = *resp.NodeStats
+ return nil
}
func (s *StatsClient) GetInterfaceStats(ifaceStats *api.InterfaceStats) error {
req := StatsRequest{StatsType: "interface"}
- resp := StatsResponse{IfaceStats: ifaceStats}
- return s.rpc.Call("StatsRPC.GetStats", req, &resp)
+ resp := StatsResponse{IfaceStats: new(api.InterfaceStats)}
+ if err := s.rpc.Call("StatsRPC.GetStats", req, &resp); err != nil {
+ return err
+ }
+ *ifaceStats = *resp.IfaceStats
+ return nil
}
func (s *StatsClient) GetErrorStats(errStats *api.ErrorStats) error {
req := StatsRequest{StatsType: "error"}
- resp := StatsResponse{ErrStats: errStats}
- return s.rpc.Call("StatsRPC.GetStats", req, &resp)
+ resp := StatsResponse{ErrStats: new(api.ErrorStats)}
+ if err := s.rpc.Call("StatsRPC.GetStats", req, &resp); err != nil {
+ return err
+ }
+ *errStats = *resp.ErrStats
+ return nil
}
func (s *StatsClient) GetBufferStats(bufStats *api.BufferStats) error {
req := StatsRequest{StatsType: "buffer"}
- resp := StatsResponse{BufStats: bufStats}
- return s.rpc.Call("StatsRPC.GetStats", req, &resp)
+ resp := StatsResponse{BufStats: new(api.BufferStats)}
+ if err := s.rpc.Call("StatsRPC.GetStats", req, &resp); err != nil {
+ return err
+ }
+ *bufStats = *resp.BufStats
+ return nil
}
type BinapiClient struct {
}
func (b *BinapiClient) SetReplyTimeout(timeout time.Duration) {
- panic("implement me")
+ req := BinapiTimeoutRequest{Timeout: timeout}
+ resp := BinapiTimeoutResponse{}
+ if err := b.rpc.Call("BinapiRPC.SetTimeout", req, &resp); err != nil {
+ log.Println(err)
+ }
}
func (b *BinapiClient) CheckCompatiblity(msgs ...api.Message) error {
- return nil // TODO: proxy this
+ for _, msg := range msgs {
+ req := BinapiCompatibilityRequest{
+ MsgName: msg.GetMessageName(),
+ Crc: msg.GetCrcString(),
+ }
+ resp := BinapiCompatibilityResponse{}
+ if err := b.rpc.Call("BinapiRPC.Compatibility", req, &resp); err != nil {
+ return err
+ }
+ }
+ return nil
}
func (b *BinapiClient) Close() {
"fmt"
"log"
"reflect"
+ "time"
"git.fd.io/govpp.git/api"
)
Msgs []api.Message
}
+type BinapiCompatibilityRequest struct {
+ MsgName string
+ Crc string
+}
+
+type BinapiCompatibilityResponse struct {
+}
+
+type BinapiTimeoutRequest struct {
+ Timeout time.Duration
+}
+
+type BinapiTimeoutResponse struct {
+}
+
// BinapiRPC is a RPC server for proxying client request to api.Channel.
type BinapiRPC struct {
binapi api.Channel
return nil
}
+
+func (s *BinapiRPC) SetTimeout(req BinapiTimeoutRequest, _ *BinapiTimeoutResponse) error {
+ log.Printf("BinapiRPC.SetTimeout - REQ: %#v", req)
+ s.binapi.SetReplyTimeout(req.Timeout)
+ return nil
+}
+
+func (s *BinapiRPC) Compatibility(req BinapiCompatibilityRequest, _ *BinapiCompatibilityResponse) error {
+ log.Printf("BinapiRPC.Compatiblity - REQ: %#v", req)
+ if val, ok := api.GetRegisteredMessages()[req.MsgName+"_"+req.Crc]; ok {
+ return s.binapi.CheckCompatiblity(val)
+ }
+ return fmt.Errorf("compatibility check failed for the message: %s", req.MsgName+"_"+req.Crc)
+}