binapi/wireguard/wireguard_rpc.ba.go

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