binapi/vrrp/vrrp_rpc.ba.go

   1 // Code generated by GoVPP's binapi-generator. DO NOT EDIT.
   2
   3 package vrrp
   4
   5 import (
   6         "context"
   7         "fmt"
   8         "io"
   9
  10         api "git.fd.io/govpp.git/api"
  11         memclnt "git.fd.io/govpp.git/binapi/memclnt"
  12 )
  13
  14 // RPCService defines RPC service vrrp.
  15 type RPCService interface {
  16         VrrpVrAddDel(ctx context.Context, in *VrrpVrAddDel) (*VrrpVrAddDelReply, error)
  17         VrrpVrDump(ctx context.Context, in *VrrpVrDump) (RPCService_VrrpVrDumpClient, error)
  18         VrrpVrPeerDump(ctx context.Context, in *VrrpVrPeerDump) (RPCService_VrrpVrPeerDumpClient, error)
  19         VrrpVrSetPeers(ctx context.Context, in *VrrpVrSetPeers) (*VrrpVrSetPeersReply, error)
  20         VrrpVrStartStop(ctx context.Context, in *VrrpVrStartStop) (*VrrpVrStartStopReply, error)
  21         VrrpVrTrackIfAddDel(ctx context.Context, in *VrrpVrTrackIfAddDel) (*VrrpVrTrackIfAddDelReply, error)
  22         VrrpVrTrackIfDump(ctx context.Context, in *VrrpVrTrackIfDump) (RPCService_VrrpVrTrackIfDumpClient, error)
  23         WantVrrpVrEvents(ctx context.Context, in *WantVrrpVrEvents) (*WantVrrpVrEventsReply, error)
  24 }
  25
  26 type serviceClient struct {
  27         conn api.Connection
  28 }
  29
  30 func NewServiceClient(conn api.Connection) RPCService {
  31         return &serviceClient{conn}
  32 }
  33
  34 func (c *serviceClient) VrrpVrAddDel(ctx context.Context, in *VrrpVrAddDel) (*VrrpVrAddDelReply, error) {
  35         out := new(VrrpVrAddDelReply)
  36         err := c.conn.Invoke(ctx, in, out)
  37         if err != nil {
  38                 return nil, err
  39         }
  40         return out, api.RetvalToVPPApiError(out.Retval)
  41 }
  42
  43 func (c *serviceClient) VrrpVrDump(ctx context.Context, in *VrrpVrDump) (RPCService_VrrpVrDumpClient, error) {
  44         stream, err := c.conn.NewStream(ctx)
  45         if err != nil {
  46                 return nil, err
  47         }
  48         x := &serviceClient_VrrpVrDumpClient{stream}
  49         if err := x.Stream.SendMsg(in); err != nil {
  50                 return nil, err
  51         }
  52         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
  53                 return nil, err
  54         }
  55         return x, nil
  56 }
  57
  58 type RPCService_VrrpVrDumpClient interface {
  59         Recv() (*VrrpVrDetails, error)
  60         api.Stream
  61 }
  62
  63 type serviceClient_VrrpVrDumpClient struct {
  64         api.Stream
  65 }
  66
  67 func (c *serviceClient_VrrpVrDumpClient) Recv() (*VrrpVrDetails, error) {
  68         msg, err := c.Stream.RecvMsg()
  69         if err != nil {
  70                 return nil, err
  71         }
  72         switch m := msg.(type) {
  73         case *VrrpVrDetails:
  74                 return m, nil
  75         case *memclnt.ControlPingReply:
  76                 err = c.Stream.Close()
  77                 if err != nil {
  78                         return nil, err
  79                 }
  80                 return nil, io.EOF
  81         default:
  82                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
  83         }
  84 }
  85
  86 func (c *serviceClient) VrrpVrPeerDump(ctx context.Context, in *VrrpVrPeerDump) (RPCService_VrrpVrPeerDumpClient, error) {
  87         stream, err := c.conn.NewStream(ctx)
  88         if err != nil {
  89                 return nil, err
  90         }
  91         x := &serviceClient_VrrpVrPeerDumpClient{stream}
  92         if err := x.Stream.SendMsg(in); err != nil {
  93                 return nil, err
  94         }
  95         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
  96                 return nil, err
  97         }
  98         return x, nil
  99 }
 100
 101 type RPCService_VrrpVrPeerDumpClient interface {
 102         Recv() (*VrrpVrPeerDetails, error)
 103         api.Stream
 104 }
 105
 106 type serviceClient_VrrpVrPeerDumpClient struct {
 107         api.Stream
 108 }
 109
 110 func (c *serviceClient_VrrpVrPeerDumpClient) Recv() (*VrrpVrPeerDetails, error) {
 111         msg, err := c.Stream.RecvMsg()
 112         if err != nil {
 113                 return nil, err
 114         }
 115         switch m := msg.(type) {
 116         case *VrrpVrPeerDetails:
 117                 return m, nil
 118         case *memclnt.ControlPingReply:
 119                 err = c.Stream.Close()
 120                 if err != nil {
 121                         return nil, err
 122                 }
 123                 return nil, io.EOF
 124         default:
 125                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 126         }
 127 }
 128
 129 func (c *serviceClient) VrrpVrSetPeers(ctx context.Context, in *VrrpVrSetPeers) (*VrrpVrSetPeersReply, error) {
 130         out := new(VrrpVrSetPeersReply)
 131         err := c.conn.Invoke(ctx, in, out)
 132         if err != nil {
 133                 return nil, err
 134         }
 135         return out, api.RetvalToVPPApiError(out.Retval)
 136 }
 137
 138 func (c *serviceClient) VrrpVrStartStop(ctx context.Context, in *VrrpVrStartStop) (*VrrpVrStartStopReply, error) {
 139         out := new(VrrpVrStartStopReply)
 140         err := c.conn.Invoke(ctx, in, out)
 141         if err != nil {
 142                 return nil, err
 143         }
 144         return out, api.RetvalToVPPApiError(out.Retval)
 145 }
 146
 147 func (c *serviceClient) VrrpVrTrackIfAddDel(ctx context.Context, in *VrrpVrTrackIfAddDel) (*VrrpVrTrackIfAddDelReply, error) {
 148         out := new(VrrpVrTrackIfAddDelReply)
 149         err := c.conn.Invoke(ctx, in, out)
 150         if err != nil {
 151                 return nil, err
 152         }
 153         return out, api.RetvalToVPPApiError(out.Retval)
 154 }
 155
 156 func (c *serviceClient) VrrpVrTrackIfDump(ctx context.Context, in *VrrpVrTrackIfDump) (RPCService_VrrpVrTrackIfDumpClient, error) {
 157         stream, err := c.conn.NewStream(ctx)
 158         if err != nil {
 159                 return nil, err
 160         }
 161         x := &serviceClient_VrrpVrTrackIfDumpClient{stream}
 162         if err := x.Stream.SendMsg(in); err != nil {
 163                 return nil, err
 164         }
 165         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 166                 return nil, err
 167         }
 168         return x, nil
 169 }
 170
 171 type RPCService_VrrpVrTrackIfDumpClient interface {
 172         Recv() (*VrrpVrTrackIfDetails, error)
 173         api.Stream
 174 }
 175
 176 type serviceClient_VrrpVrTrackIfDumpClient struct {
 177         api.Stream
 178 }
 179
 180 func (c *serviceClient_VrrpVrTrackIfDumpClient) Recv() (*VrrpVrTrackIfDetails, error) {
 181         msg, err := c.Stream.RecvMsg()
 182         if err != nil {
 183                 return nil, err
 184         }
 185         switch m := msg.(type) {
 186         case *VrrpVrTrackIfDetails:
 187                 return m, nil
 188         case *memclnt.ControlPingReply:
 189                 err = c.Stream.Close()
 190                 if err != nil {
 191                         return nil, err
 192                 }
 193                 return nil, io.EOF
 194         default:
 195                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 196         }
 197 }
 198
 199 func (c *serviceClient) WantVrrpVrEvents(ctx context.Context, in *WantVrrpVrEvents) (*WantVrrpVrEventsReply, error) {
 200         out := new(WantVrrpVrEventsReply)
 201         err := c.conn.Invoke(ctx, in, out)
 202         if err != nil {
 203                 return nil, err
 204         }
 205         return out, api.RetvalToVPPApiError(out.Retval)
 206 }