internal/testbinapi/binapi2001/ipfix_export/ipfix_export_rpc.ba.go

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