binapi/bond/bond_rpc.ba.go

   1 // Code generated by GoVPP's binapi-generator. DO NOT EDIT.
   2
   3 package bond
   4
   5 import (
   6         "context"
   7         "fmt"
   8         "io"
   9
  10         api "go.fd.io/govpp/api"
  11         memclnt "go.fd.io/govpp/binapi/memclnt"
  12 )
  13
  14 // RPCService defines RPC service bond.
  15 type RPCService interface {
  16         BondAddMember(ctx context.Context, in *BondAddMember) (*BondAddMemberReply, error)
  17         BondCreate(ctx context.Context, in *BondCreate) (*BondCreateReply, error)
  18         BondCreate2(ctx context.Context, in *BondCreate2) (*BondCreate2Reply, error)
  19         BondDelete(ctx context.Context, in *BondDelete) (*BondDeleteReply, error)
  20         BondDetachMember(ctx context.Context, in *BondDetachMember) (*BondDetachMemberReply, error)
  21         BondDetachSlave(ctx context.Context, in *BondDetachSlave) (*BondDetachSlaveReply, error)
  22         BondEnslave(ctx context.Context, in *BondEnslave) (*BondEnslaveReply, error)
  23         SwBondInterfaceDump(ctx context.Context, in *SwBondInterfaceDump) (RPCService_SwBondInterfaceDumpClient, error)
  24         SwInterfaceBondDump(ctx context.Context, in *SwInterfaceBondDump) (RPCService_SwInterfaceBondDumpClient, error)
  25         SwInterfaceSetBondWeight(ctx context.Context, in *SwInterfaceSetBondWeight) (*SwInterfaceSetBondWeightReply, error)
  26         SwInterfaceSlaveDump(ctx context.Context, in *SwInterfaceSlaveDump) (RPCService_SwInterfaceSlaveDumpClient, error)
  27         SwMemberInterfaceDump(ctx context.Context, in *SwMemberInterfaceDump) (RPCService_SwMemberInterfaceDumpClient, error)
  28 }
  29
  30 type serviceClient struct {
  31         conn api.Connection
  32 }
  33
  34 func NewServiceClient(conn api.Connection) RPCService {
  35         return &serviceClient{conn}
  36 }
  37
  38 func (c *serviceClient) BondAddMember(ctx context.Context, in *BondAddMember) (*BondAddMemberReply, error) {
  39         out := new(BondAddMemberReply)
  40         err := c.conn.Invoke(ctx, in, out)
  41         if err != nil {
  42                 return nil, err
  43         }
  44         return out, api.RetvalToVPPApiError(out.Retval)
  45 }
  46
  47 func (c *serviceClient) BondCreate(ctx context.Context, in *BondCreate) (*BondCreateReply, error) {
  48         out := new(BondCreateReply)
  49         err := c.conn.Invoke(ctx, in, out)
  50         if err != nil {
  51                 return nil, err
  52         }
  53         return out, api.RetvalToVPPApiError(out.Retval)
  54 }
  55
  56 func (c *serviceClient) BondCreate2(ctx context.Context, in *BondCreate2) (*BondCreate2Reply, error) {
  57         out := new(BondCreate2Reply)
  58         err := c.conn.Invoke(ctx, in, out)
  59         if err != nil {
  60                 return nil, err
  61         }
  62         return out, api.RetvalToVPPApiError(out.Retval)
  63 }
  64
  65 func (c *serviceClient) BondDelete(ctx context.Context, in *BondDelete) (*BondDeleteReply, error) {
  66         out := new(BondDeleteReply)
  67         err := c.conn.Invoke(ctx, in, out)
  68         if err != nil {
  69                 return nil, err
  70         }
  71         return out, api.RetvalToVPPApiError(out.Retval)
  72 }
  73
  74 func (c *serviceClient) BondDetachMember(ctx context.Context, in *BondDetachMember) (*BondDetachMemberReply, error) {
  75         out := new(BondDetachMemberReply)
  76         err := c.conn.Invoke(ctx, in, out)
  77         if err != nil {
  78                 return nil, err
  79         }
  80         return out, api.RetvalToVPPApiError(out.Retval)
  81 }
  82
  83 func (c *serviceClient) BondDetachSlave(ctx context.Context, in *BondDetachSlave) (*BondDetachSlaveReply, error) {
  84         out := new(BondDetachSlaveReply)
  85         err := c.conn.Invoke(ctx, in, out)
  86         if err != nil {
  87                 return nil, err
  88         }
  89         return out, api.RetvalToVPPApiError(out.Retval)
  90 }
  91
  92 func (c *serviceClient) BondEnslave(ctx context.Context, in *BondEnslave) (*BondEnslaveReply, error) {
  93         out := new(BondEnslaveReply)
  94         err := c.conn.Invoke(ctx, in, out)
  95         if err != nil {
  96                 return nil, err
  97         }
  98         return out, api.RetvalToVPPApiError(out.Retval)
  99 }
 100
 101 func (c *serviceClient) SwBondInterfaceDump(ctx context.Context, in *SwBondInterfaceDump) (RPCService_SwBondInterfaceDumpClient, error) {
 102         stream, err := c.conn.NewStream(ctx)
 103         if err != nil {
 104                 return nil, err
 105         }
 106         x := &serviceClient_SwBondInterfaceDumpClient{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_SwBondInterfaceDumpClient interface {
 117         Recv() (*SwBondInterfaceDetails, error)
 118         api.Stream
 119 }
 120
 121 type serviceClient_SwBondInterfaceDumpClient struct {
 122         api.Stream
 123 }
 124
 125 func (c *serviceClient_SwBondInterfaceDumpClient) Recv() (*SwBondInterfaceDetails, error) {
 126         msg, err := c.Stream.RecvMsg()
 127         if err != nil {
 128                 return nil, err
 129         }
 130         switch m := msg.(type) {
 131         case *SwBondInterfaceDetails:
 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 }
 143
 144 func (c *serviceClient) SwInterfaceBondDump(ctx context.Context, in *SwInterfaceBondDump) (RPCService_SwInterfaceBondDumpClient, error) {
 145         stream, err := c.conn.NewStream(ctx)
 146         if err != nil {
 147                 return nil, err
 148         }
 149         x := &serviceClient_SwInterfaceBondDumpClient{stream}
 150         if err := x.Stream.SendMsg(in); err != nil {
 151                 return nil, err
 152         }
 153         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 154                 return nil, err
 155         }
 156         return x, nil
 157 }
 158
 159 type RPCService_SwInterfaceBondDumpClient interface {
 160         Recv() (*SwInterfaceBondDetails, error)
 161         api.Stream
 162 }
 163
 164 type serviceClient_SwInterfaceBondDumpClient struct {
 165         api.Stream
 166 }
 167
 168 func (c *serviceClient_SwInterfaceBondDumpClient) Recv() (*SwInterfaceBondDetails, error) {
 169         msg, err := c.Stream.RecvMsg()
 170         if err != nil {
 171                 return nil, err
 172         }
 173         switch m := msg.(type) {
 174         case *SwInterfaceBondDetails:
 175                 return m, nil
 176         case *memclnt.ControlPingReply:
 177                 err = c.Stream.Close()
 178                 if err != nil {
 179                         return nil, err
 180                 }
 181                 return nil, io.EOF
 182         default:
 183                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 184         }
 185 }
 186
 187 func (c *serviceClient) SwInterfaceSetBondWeight(ctx context.Context, in *SwInterfaceSetBondWeight) (*SwInterfaceSetBondWeightReply, error) {
 188         out := new(SwInterfaceSetBondWeightReply)
 189         err := c.conn.Invoke(ctx, in, out)
 190         if err != nil {
 191                 return nil, err
 192         }
 193         return out, api.RetvalToVPPApiError(out.Retval)
 194 }
 195
 196 func (c *serviceClient) SwInterfaceSlaveDump(ctx context.Context, in *SwInterfaceSlaveDump) (RPCService_SwInterfaceSlaveDumpClient, error) {
 197         stream, err := c.conn.NewStream(ctx)
 198         if err != nil {
 199                 return nil, err
 200         }
 201         x := &serviceClient_SwInterfaceSlaveDumpClient{stream}
 202         if err := x.Stream.SendMsg(in); err != nil {
 203                 return nil, err
 204         }
 205         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 206                 return nil, err
 207         }
 208         return x, nil
 209 }
 210
 211 type RPCService_SwInterfaceSlaveDumpClient interface {
 212         Recv() (*SwInterfaceSlaveDetails, error)
 213         api.Stream
 214 }
 215
 216 type serviceClient_SwInterfaceSlaveDumpClient struct {
 217         api.Stream
 218 }
 219
 220 func (c *serviceClient_SwInterfaceSlaveDumpClient) Recv() (*SwInterfaceSlaveDetails, error) {
 221         msg, err := c.Stream.RecvMsg()
 222         if err != nil {
 223                 return nil, err
 224         }
 225         switch m := msg.(type) {
 226         case *SwInterfaceSlaveDetails:
 227                 return m, nil
 228         case *memclnt.ControlPingReply:
 229                 err = c.Stream.Close()
 230                 if err != nil {
 231                         return nil, err
 232                 }
 233                 return nil, io.EOF
 234         default:
 235                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 236         }
 237 }
 238
 239 func (c *serviceClient) SwMemberInterfaceDump(ctx context.Context, in *SwMemberInterfaceDump) (RPCService_SwMemberInterfaceDumpClient, error) {
 240         stream, err := c.conn.NewStream(ctx)
 241         if err != nil {
 242                 return nil, err
 243         }
 244         x := &serviceClient_SwMemberInterfaceDumpClient{stream}
 245         if err := x.Stream.SendMsg(in); err != nil {
 246                 return nil, err
 247         }
 248         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 249                 return nil, err
 250         }
 251         return x, nil
 252 }
 253
 254 type RPCService_SwMemberInterfaceDumpClient interface {
 255         Recv() (*SwMemberInterfaceDetails, error)
 256         api.Stream
 257 }
 258
 259 type serviceClient_SwMemberInterfaceDumpClient struct {
 260         api.Stream
 261 }
 262
 263 func (c *serviceClient_SwMemberInterfaceDumpClient) Recv() (*SwMemberInterfaceDetails, error) {
 264         msg, err := c.Stream.RecvMsg()
 265         if err != nil {
 266                 return nil, err
 267         }
 268         switch m := msg.(type) {
 269         case *SwMemberInterfaceDetails:
 270                 return m, nil
 271         case *memclnt.ControlPingReply:
 272                 err = c.Stream.Close()
 273                 if err != nil {
 274                         return nil, err
 275                 }
 276                 return nil, io.EOF
 277         default:
 278                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 279         }
 280 }