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         memclnt "git.fd.io/govpp.git/binapi/memclnt"
  12 )
  13
  14 // RPCService defines RPC service wireguard.
  15 type RPCService interface {
  16         WantWireguardPeerEvents(ctx context.Context, in *WantWireguardPeerEvents) (*WantWireguardPeerEventsReply, error)
  17         WgSetAsyncMode(ctx context.Context, in *WgSetAsyncMode) (*WgSetAsyncModeReply, error)
  18         WireguardInterfaceCreate(ctx context.Context, in *WireguardInterfaceCreate) (*WireguardInterfaceCreateReply, error)
  19         WireguardInterfaceDelete(ctx context.Context, in *WireguardInterfaceDelete) (*WireguardInterfaceDeleteReply, error)
  20         WireguardInterfaceDump(ctx context.Context, in *WireguardInterfaceDump) (RPCService_WireguardInterfaceDumpClient, error)
  21         WireguardPeerAdd(ctx context.Context, in *WireguardPeerAdd) (*WireguardPeerAddReply, error)
  22         WireguardPeerRemove(ctx context.Context, in *WireguardPeerRemove) (*WireguardPeerRemoveReply, error)
  23         WireguardPeersDump(ctx context.Context, in *WireguardPeersDump) (RPCService_WireguardPeersDumpClient, 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) WantWireguardPeerEvents(ctx context.Context, in *WantWireguardPeerEvents) (*WantWireguardPeerEventsReply, error) {
  35         out := new(WantWireguardPeerEventsReply)
  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) WgSetAsyncMode(ctx context.Context, in *WgSetAsyncMode) (*WgSetAsyncModeReply, error) {
  44         out := new(WgSetAsyncModeReply)
  45         err := c.conn.Invoke(ctx, in, out)
  46         if err != nil {
  47                 return nil, err
  48         }
  49         return out, api.RetvalToVPPApiError(out.Retval)
  50 }
  51
  52 func (c *serviceClient) WireguardInterfaceCreate(ctx context.Context, in *WireguardInterfaceCreate) (*WireguardInterfaceCreateReply, error) {
  53         out := new(WireguardInterfaceCreateReply)
  54         err := c.conn.Invoke(ctx, in, out)
  55         if err != nil {
  56                 return nil, err
  57         }
  58         return out, api.RetvalToVPPApiError(out.Retval)
  59 }
  60
  61 func (c *serviceClient) WireguardInterfaceDelete(ctx context.Context, in *WireguardInterfaceDelete) (*WireguardInterfaceDeleteReply, error) {
  62         out := new(WireguardInterfaceDeleteReply)
  63         err := c.conn.Invoke(ctx, in, out)
  64         if err != nil {
  65                 return nil, err
  66         }
  67         return out, api.RetvalToVPPApiError(out.Retval)
  68 }
  69
  70 func (c *serviceClient) WireguardInterfaceDump(ctx context.Context, in *WireguardInterfaceDump) (RPCService_WireguardInterfaceDumpClient, error) {
  71         stream, err := c.conn.NewStream(ctx)
  72         if err != nil {
  73                 return nil, err
  74         }
  75         x := &serviceClient_WireguardInterfaceDumpClient{stream}
  76         if err := x.Stream.SendMsg(in); err != nil {
  77                 return nil, err
  78         }
  79         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
  80                 return nil, err
  81         }
  82         return x, nil
  83 }
  84
  85 type RPCService_WireguardInterfaceDumpClient interface {
  86         Recv() (*WireguardInterfaceDetails, error)
  87         api.Stream
  88 }
  89
  90 type serviceClient_WireguardInterfaceDumpClient struct {
  91         api.Stream
  92 }
  93
  94 func (c *serviceClient_WireguardInterfaceDumpClient) Recv() (*WireguardInterfaceDetails, error) {
  95         msg, err := c.Stream.RecvMsg()
  96         if err != nil {
  97                 return nil, err
  98         }
  99         switch m := msg.(type) {
 100         case *WireguardInterfaceDetails:
 101                 return m, nil
 102         case *memclnt.ControlPingReply:
 103                 err = c.Stream.Close()
 104                 if err != nil {
 105                         return nil, err
 106                 }
 107                 return nil, io.EOF
 108         default:
 109                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 110         }
 111 }
 112
 113 func (c *serviceClient) WireguardPeerAdd(ctx context.Context, in *WireguardPeerAdd) (*WireguardPeerAddReply, error) {
 114         out := new(WireguardPeerAddReply)
 115         err := c.conn.Invoke(ctx, in, out)
 116         if err != nil {
 117                 return nil, err
 118         }
 119         return out, api.RetvalToVPPApiError(out.Retval)
 120 }
 121
 122 func (c *serviceClient) WireguardPeerRemove(ctx context.Context, in *WireguardPeerRemove) (*WireguardPeerRemoveReply, error) {
 123         out := new(WireguardPeerRemoveReply)
 124         err := c.conn.Invoke(ctx, in, out)
 125         if err != nil {
 126                 return nil, err
 127         }
 128         return out, api.RetvalToVPPApiError(out.Retval)
 129 }
 130
 131 func (c *serviceClient) WireguardPeersDump(ctx context.Context, in *WireguardPeersDump) (RPCService_WireguardPeersDumpClient, error) {
 132         stream, err := c.conn.NewStream(ctx)
 133         if err != nil {
 134                 return nil, err
 135         }
 136         x := &serviceClient_WireguardPeersDumpClient{stream}
 137         if err := x.Stream.SendMsg(in); err != nil {
 138                 return nil, err
 139         }
 140         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 141                 return nil, err
 142         }
 143         return x, nil
 144 }
 145
 146 type RPCService_WireguardPeersDumpClient interface {
 147         Recv() (*WireguardPeersDetails, error)
 148         api.Stream
 149 }
 150
 151 type serviceClient_WireguardPeersDumpClient struct {
 152         api.Stream
 153 }
 154
 155 func (c *serviceClient_WireguardPeersDumpClient) Recv() (*WireguardPeersDetails, error) {
 156         msg, err := c.Stream.RecvMsg()
 157         if err != nil {
 158                 return nil, err
 159         }
 160         switch m := msg.(type) {
 161         case *WireguardPeersDetails:
 162                 return m, nil
 163         case *memclnt.ControlPingReply:
 164                 err = c.Stream.Close()
 165                 if err != nil {
 166                         return nil, err
 167                 }
 168                 return nil, io.EOF
 169         default:
 170                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 171         }
 172 }