proxy/server.go

   1 package proxy
   2
   3 import (
   4         "fmt"
   5         "log"
   6         "reflect"
   7
   8         "git.fd.io/govpp.git/api"
   9 )
  10
  11 type StatsRequest struct {
  12         StatsType string
  13 }
  14
  15 type StatsResponse struct {
  16         SysStats   *api.SystemStats
  17         NodeStats  *api.NodeStats
  18         IfaceStats *api.InterfaceStats
  19         ErrStats   *api.ErrorStats
  20         BufStats   *api.BufferStats
  21 }
  22
  23 // StatsRPC is a RPC server for proxying client request to api.StatsProvider.
  24 type StatsRPC struct {
  25         stats api.StatsProvider
  26 }
  27
  28 // NewStatsRPC returns new StatsRPC to be used as RPC server
  29 // proxying request to given api.StatsProvider.
  30 func NewStatsRPC(stats api.StatsProvider) *StatsRPC {
  31         return &StatsRPC{stats: stats}
  32 }
  33
  34 func (s *StatsRPC) GetStats(req StatsRequest, resp *StatsResponse) error {
  35         log.Printf("StatsRPC.GetStats - REQ: %+v", req)
  36
  37         switch req.StatsType {
  38         case "system":
  39                 resp.SysStats = new(api.SystemStats)
  40                 return s.stats.GetSystemStats(resp.SysStats)
  41         case "node":
  42                 resp.NodeStats = new(api.NodeStats)
  43                 return s.stats.GetNodeStats(resp.NodeStats)
  44         case "interface":
  45                 resp.IfaceStats = new(api.InterfaceStats)
  46                 return s.stats.GetInterfaceStats(resp.IfaceStats)
  47         case "error":
  48                 resp.ErrStats = new(api.ErrorStats)
  49                 return s.stats.GetErrorStats(resp.ErrStats)
  50         case "buffer":
  51                 resp.BufStats = new(api.BufferStats)
  52                 return s.stats.GetBufferStats(resp.BufStats)
  53         default:
  54                 return fmt.Errorf("unknown stats type: %s", req.StatsType)
  55         }
  56 }
  57
  58 type BinapiRequest struct {
  59         Msg      api.Message
  60         IsMulti  bool
  61         ReplyMsg api.Message
  62 }
  63
  64 type BinapiResponse struct {
  65         Msg  api.Message
  66         Msgs []api.Message
  67 }
  68
  69 // BinapiRPC is a RPC server for proxying client request to api.Channel.
  70 type BinapiRPC struct {
  71         binapi api.Channel
  72 }
  73
  74 // NewBinapiRPC returns new BinapiRPC to be used as RPC server
  75 // proxying request to given api.Channel.
  76 func NewBinapiRPC(binapi api.Channel) *BinapiRPC {
  77         return &BinapiRPC{binapi: binapi}
  78 }
  79
  80 func (s *BinapiRPC) Invoke(req BinapiRequest, resp *BinapiResponse) error {
  81         log.Printf("BinapiRPC.Invoke - REQ: %#v", req)
  82
  83         if req.IsMulti {
  84                 multi := s.binapi.SendMultiRequest(req.Msg)
  85                 for {
  86                         // create new message in response of type ReplyMsg
  87                         msg := reflect.New(reflect.TypeOf(req.ReplyMsg).Elem()).Interface().(api.Message)
  88
  89                         stop, err := multi.ReceiveReply(msg)
  90                         if err != nil {
  91                                 return err
  92                         } else if stop {
  93                                 break
  94                         }
  95
  96                         resp.Msgs = append(resp.Msgs, msg)
  97                 }
  98         } else {
  99                 // create new message in response of type ReplyMsg
 100                 resp.Msg = reflect.New(reflect.TypeOf(req.ReplyMsg).Elem()).Interface().(api.Message)
 101
 102                 err := s.binapi.SendRequest(req.Msg).ReceiveReply(resp.Msg)
 103                 if err != nil {
 104                         return err
 105                 }
 106         }
 107
 108         return nil
 109 }