binapi/vxlan_gpe/vxlan_gpe_rpc.ba.go

   1 // Code generated by GoVPP's binapi-generator. DO NOT EDIT.
   2
   3 package vxlan_gpe
   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 vxlan_gpe.
  15 type RPCService interface {
  16         SwInterfaceSetVxlanGpeBypass(ctx context.Context, in *SwInterfaceSetVxlanGpeBypass) (*SwInterfaceSetVxlanGpeBypassReply, error)
  17         VxlanGpeAddDelTunnel(ctx context.Context, in *VxlanGpeAddDelTunnel) (*VxlanGpeAddDelTunnelReply, error)
  18         VxlanGpeAddDelTunnelV2(ctx context.Context, in *VxlanGpeAddDelTunnelV2) (*VxlanGpeAddDelTunnelV2Reply, error)
  19         VxlanGpeTunnelDump(ctx context.Context, in *VxlanGpeTunnelDump) (RPCService_VxlanGpeTunnelDumpClient, error)
  20         VxlanGpeTunnelV2Dump(ctx context.Context, in *VxlanGpeTunnelV2Dump) (RPCService_VxlanGpeTunnelV2DumpClient, error)
  21 }
  22
  23 type serviceClient struct {
  24         conn api.Connection
  25 }
  26
  27 func NewServiceClient(conn api.Connection) RPCService {
  28         return &serviceClient{conn}
  29 }
  30
  31 func (c *serviceClient) SwInterfaceSetVxlanGpeBypass(ctx context.Context, in *SwInterfaceSetVxlanGpeBypass) (*SwInterfaceSetVxlanGpeBypassReply, error) {
  32         out := new(SwInterfaceSetVxlanGpeBypassReply)
  33         err := c.conn.Invoke(ctx, in, out)
  34         if err != nil {
  35                 return nil, err
  36         }
  37         return out, api.RetvalToVPPApiError(out.Retval)
  38 }
  39
  40 func (c *serviceClient) VxlanGpeAddDelTunnel(ctx context.Context, in *VxlanGpeAddDelTunnel) (*VxlanGpeAddDelTunnelReply, error) {
  41         out := new(VxlanGpeAddDelTunnelReply)
  42         err := c.conn.Invoke(ctx, in, out)
  43         if err != nil {
  44                 return nil, err
  45         }
  46         return out, api.RetvalToVPPApiError(out.Retval)
  47 }
  48
  49 func (c *serviceClient) VxlanGpeAddDelTunnelV2(ctx context.Context, in *VxlanGpeAddDelTunnelV2) (*VxlanGpeAddDelTunnelV2Reply, error) {
  50         out := new(VxlanGpeAddDelTunnelV2Reply)
  51         err := c.conn.Invoke(ctx, in, out)
  52         if err != nil {
  53                 return nil, err
  54         }
  55         return out, api.RetvalToVPPApiError(out.Retval)
  56 }
  57
  58 func (c *serviceClient) VxlanGpeTunnelDump(ctx context.Context, in *VxlanGpeTunnelDump) (RPCService_VxlanGpeTunnelDumpClient, error) {
  59         stream, err := c.conn.NewStream(ctx)
  60         if err != nil {
  61                 return nil, err
  62         }
  63         x := &serviceClient_VxlanGpeTunnelDumpClient{stream}
  64         if err := x.Stream.SendMsg(in); err != nil {
  65                 return nil, err
  66         }
  67         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
  68                 return nil, err
  69         }
  70         return x, nil
  71 }
  72
  73 type RPCService_VxlanGpeTunnelDumpClient interface {
  74         Recv() (*VxlanGpeTunnelDetails, error)
  75         api.Stream
  76 }
  77
  78 type serviceClient_VxlanGpeTunnelDumpClient struct {
  79         api.Stream
  80 }
  81
  82 func (c *serviceClient_VxlanGpeTunnelDumpClient) Recv() (*VxlanGpeTunnelDetails, error) {
  83         msg, err := c.Stream.RecvMsg()
  84         if err != nil {
  85                 return nil, err
  86         }
  87         switch m := msg.(type) {
  88         case *VxlanGpeTunnelDetails:
  89                 return m, nil
  90         case *memclnt.ControlPingReply:
  91                 err = c.Stream.Close()
  92                 if err != nil {
  93                         return nil, err
  94                 }
  95                 return nil, io.EOF
  96         default:
  97                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
  98         }
  99 }
 100
 101 func (c *serviceClient) VxlanGpeTunnelV2Dump(ctx context.Context, in *VxlanGpeTunnelV2Dump) (RPCService_VxlanGpeTunnelV2DumpClient, error) {
 102         stream, err := c.conn.NewStream(ctx)
 103         if err != nil {
 104                 return nil, err
 105         }
 106         x := &serviceClient_VxlanGpeTunnelV2DumpClient{stream}
 107         if err := x.Stream.SendMsg(in); err != nil {
 108                 return nil, err
 109         }
 110         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 111                 return nil, err
 112         }
 113         return x, nil
 114 }
 115
 116 type RPCService_VxlanGpeTunnelV2DumpClient interface {
 117         Recv() (*VxlanGpeTunnelV2Details, error)
 118         api.Stream
 119 }
 120
 121 type serviceClient_VxlanGpeTunnelV2DumpClient struct {
 122         api.Stream
 123 }
 124
 125 func (c *serviceClient_VxlanGpeTunnelV2DumpClient) Recv() (*VxlanGpeTunnelV2Details, error) {
 126         msg, err := c.Stream.RecvMsg()
 127         if err != nil {
 128                 return nil, err
 129         }
 130         switch m := msg.(type) {
 131         case *VxlanGpeTunnelV2Details:
 132                 return m, nil
 133         case *memclnt.ControlPingReply:
 134                 err = c.Stream.Close()
 135                 if err != nil {
 136                         return nil, err
 137                 }
 138                 return nil, io.EOF
 139         default:
 140                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 141         }
 142 }