internal/testbinapi/binapi2001/acl/acl_rpc.ba.go

   1 // Code generated by GoVPP's binapi-generator. DO NOT EDIT.
   2
   3 package acl
   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 acl.
  15 type RPCService interface {
  16         ACLAddReplace(ctx context.Context, in *ACLAddReplace) (*ACLAddReplaceReply, error)
  17         ACLDel(ctx context.Context, in *ACLDel) (*ACLDelReply, error)
  18         ACLDump(ctx context.Context, in *ACLDump) (RPCService_ACLDumpClient, error)
  19         ACLInterfaceAddDel(ctx context.Context, in *ACLInterfaceAddDel) (*ACLInterfaceAddDelReply, error)
  20         ACLInterfaceEtypeWhitelistDump(ctx context.Context, in *ACLInterfaceEtypeWhitelistDump) (RPCService_ACLInterfaceEtypeWhitelistDumpClient, error)
  21         ACLInterfaceListDump(ctx context.Context, in *ACLInterfaceListDump) (RPCService_ACLInterfaceListDumpClient, error)
  22         ACLInterfaceSetACLList(ctx context.Context, in *ACLInterfaceSetACLList) (*ACLInterfaceSetACLListReply, error)
  23         ACLInterfaceSetEtypeWhitelist(ctx context.Context, in *ACLInterfaceSetEtypeWhitelist) (*ACLInterfaceSetEtypeWhitelistReply, error)
  24         ACLPluginControlPing(ctx context.Context, in *ACLPluginControlPing) (*ACLPluginControlPingReply, error)
  25         ACLPluginGetConnTableMaxEntries(ctx context.Context, in *ACLPluginGetConnTableMaxEntries) (*ACLPluginGetConnTableMaxEntriesReply, error)
  26         ACLPluginGetVersion(ctx context.Context, in *ACLPluginGetVersion) (*ACLPluginGetVersionReply, error)
  27         ACLStatsIntfCountersEnable(ctx context.Context, in *ACLStatsIntfCountersEnable) (*ACLStatsIntfCountersEnableReply, error)
  28         MacipACLAdd(ctx context.Context, in *MacipACLAdd) (*MacipACLAddReply, error)
  29         MacipACLAddReplace(ctx context.Context, in *MacipACLAddReplace) (*MacipACLAddReplaceReply, error)
  30         MacipACLDel(ctx context.Context, in *MacipACLDel) (*MacipACLDelReply, error)
  31         MacipACLDump(ctx context.Context, in *MacipACLDump) (RPCService_MacipACLDumpClient, error)
  32         MacipACLInterfaceAddDel(ctx context.Context, in *MacipACLInterfaceAddDel) (*MacipACLInterfaceAddDelReply, error)
  33         MacipACLInterfaceGet(ctx context.Context, in *MacipACLInterfaceGet) (*MacipACLInterfaceGetReply, error)
  34         MacipACLInterfaceListDump(ctx context.Context, in *MacipACLInterfaceListDump) (RPCService_MacipACLInterfaceListDumpClient, error)
  35 }
  36
  37 type serviceClient struct {
  38         conn api.Connection
  39 }
  40
  41 func NewServiceClient(conn api.Connection) RPCService {
  42         return &serviceClient{conn}
  43 }
  44
  45 func (c *serviceClient) ACLAddReplace(ctx context.Context, in *ACLAddReplace) (*ACLAddReplaceReply, error) {
  46         out := new(ACLAddReplaceReply)
  47         err := c.conn.Invoke(ctx, in, out)
  48         if err != nil {
  49                 return nil, err
  50         }
  51         return out, api.RetvalToVPPApiError(out.Retval)
  52 }
  53
  54 func (c *serviceClient) ACLDel(ctx context.Context, in *ACLDel) (*ACLDelReply, error) {
  55         out := new(ACLDelReply)
  56         err := c.conn.Invoke(ctx, in, out)
  57         if err != nil {
  58                 return nil, err
  59         }
  60         return out, api.RetvalToVPPApiError(out.Retval)
  61 }
  62
  63 func (c *serviceClient) ACLDump(ctx context.Context, in *ACLDump) (RPCService_ACLDumpClient, error) {
  64         stream, err := c.conn.NewStream(ctx)
  65         if err != nil {
  66                 return nil, err
  67         }
  68         x := &serviceClient_ACLDumpClient{stream}
  69         if err := x.Stream.SendMsg(in); err != nil {
  70                 return nil, err
  71         }
  72         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
  73                 return nil, err
  74         }
  75         return x, nil
  76 }
  77
  78 type RPCService_ACLDumpClient interface {
  79         Recv() (*ACLDetails, error)
  80         api.Stream
  81 }
  82
  83 type serviceClient_ACLDumpClient struct {
  84         api.Stream
  85 }
  86
  87 func (c *serviceClient_ACLDumpClient) Recv() (*ACLDetails, error) {
  88         msg, err := c.Stream.RecvMsg()
  89         if err != nil {
  90                 return nil, err
  91         }
  92         switch m := msg.(type) {
  93         case *ACLDetails:
  94                 return m, nil
  95         case *vpe.ControlPingReply:
  96                 err = c.Stream.Close()
  97                 if err != nil {
  98                         return nil, err
  99                 }
 100                 return nil, io.EOF
 101         default:
 102                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 103         }
 104 }
 105
 106 func (c *serviceClient) ACLInterfaceAddDel(ctx context.Context, in *ACLInterfaceAddDel) (*ACLInterfaceAddDelReply, error) {
 107         out := new(ACLInterfaceAddDelReply)
 108         err := c.conn.Invoke(ctx, in, out)
 109         if err != nil {
 110                 return nil, err
 111         }
 112         return out, api.RetvalToVPPApiError(out.Retval)
 113 }
 114
 115 func (c *serviceClient) ACLInterfaceEtypeWhitelistDump(ctx context.Context, in *ACLInterfaceEtypeWhitelistDump) (RPCService_ACLInterfaceEtypeWhitelistDumpClient, error) {
 116         stream, err := c.conn.NewStream(ctx)
 117         if err != nil {
 118                 return nil, err
 119         }
 120         x := &serviceClient_ACLInterfaceEtypeWhitelistDumpClient{stream}
 121         if err := x.Stream.SendMsg(in); err != nil {
 122                 return nil, err
 123         }
 124         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 125                 return nil, err
 126         }
 127         return x, nil
 128 }
 129
 130 type RPCService_ACLInterfaceEtypeWhitelistDumpClient interface {
 131         Recv() (*ACLInterfaceEtypeWhitelistDetails, error)
 132         api.Stream
 133 }
 134
 135 type serviceClient_ACLInterfaceEtypeWhitelistDumpClient struct {
 136         api.Stream
 137 }
 138
 139 func (c *serviceClient_ACLInterfaceEtypeWhitelistDumpClient) Recv() (*ACLInterfaceEtypeWhitelistDetails, error) {
 140         msg, err := c.Stream.RecvMsg()
 141         if err != nil {
 142                 return nil, err
 143         }
 144         switch m := msg.(type) {
 145         case *ACLInterfaceEtypeWhitelistDetails:
 146                 return m, nil
 147         case *vpe.ControlPingReply:
 148                 err = c.Stream.Close()
 149                 if err != nil {
 150                         return nil, err
 151                 }
 152                 return nil, io.EOF
 153         default:
 154                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 155         }
 156 }
 157
 158 func (c *serviceClient) ACLInterfaceListDump(ctx context.Context, in *ACLInterfaceListDump) (RPCService_ACLInterfaceListDumpClient, error) {
 159         stream, err := c.conn.NewStream(ctx)
 160         if err != nil {
 161                 return nil, err
 162         }
 163         x := &serviceClient_ACLInterfaceListDumpClient{stream}
 164         if err := x.Stream.SendMsg(in); err != nil {
 165                 return nil, err
 166         }
 167         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 168                 return nil, err
 169         }
 170         return x, nil
 171 }
 172
 173 type RPCService_ACLInterfaceListDumpClient interface {
 174         Recv() (*ACLInterfaceListDetails, error)
 175         api.Stream
 176 }
 177
 178 type serviceClient_ACLInterfaceListDumpClient struct {
 179         api.Stream
 180 }
 181
 182 func (c *serviceClient_ACLInterfaceListDumpClient) Recv() (*ACLInterfaceListDetails, error) {
 183         msg, err := c.Stream.RecvMsg()
 184         if err != nil {
 185                 return nil, err
 186         }
 187         switch m := msg.(type) {
 188         case *ACLInterfaceListDetails:
 189                 return m, nil
 190         case *vpe.ControlPingReply:
 191                 err = c.Stream.Close()
 192                 if err != nil {
 193                         return nil, err
 194                 }
 195                 return nil, io.EOF
 196         default:
 197                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 198         }
 199 }
 200
 201 func (c *serviceClient) ACLInterfaceSetACLList(ctx context.Context, in *ACLInterfaceSetACLList) (*ACLInterfaceSetACLListReply, error) {
 202         out := new(ACLInterfaceSetACLListReply)
 203         err := c.conn.Invoke(ctx, in, out)
 204         if err != nil {
 205                 return nil, err
 206         }
 207         return out, api.RetvalToVPPApiError(out.Retval)
 208 }
 209
 210 func (c *serviceClient) ACLInterfaceSetEtypeWhitelist(ctx context.Context, in *ACLInterfaceSetEtypeWhitelist) (*ACLInterfaceSetEtypeWhitelistReply, error) {
 211         out := new(ACLInterfaceSetEtypeWhitelistReply)
 212         err := c.conn.Invoke(ctx, in, out)
 213         if err != nil {
 214                 return nil, err
 215         }
 216         return out, api.RetvalToVPPApiError(out.Retval)
 217 }
 218
 219 func (c *serviceClient) ACLPluginControlPing(ctx context.Context, in *ACLPluginControlPing) (*ACLPluginControlPingReply, error) {
 220         out := new(ACLPluginControlPingReply)
 221         err := c.conn.Invoke(ctx, in, out)
 222         if err != nil {
 223                 return nil, err
 224         }
 225         return out, api.RetvalToVPPApiError(out.Retval)
 226 }
 227
 228 func (c *serviceClient) ACLPluginGetConnTableMaxEntries(ctx context.Context, in *ACLPluginGetConnTableMaxEntries) (*ACLPluginGetConnTableMaxEntriesReply, error) {
 229         out := new(ACLPluginGetConnTableMaxEntriesReply)
 230         err := c.conn.Invoke(ctx, in, out)
 231         if err != nil {
 232                 return nil, err
 233         }
 234         return out, nil
 235 }
 236
 237 func (c *serviceClient) ACLPluginGetVersion(ctx context.Context, in *ACLPluginGetVersion) (*ACLPluginGetVersionReply, error) {
 238         out := new(ACLPluginGetVersionReply)
 239         err := c.conn.Invoke(ctx, in, out)
 240         if err != nil {
 241                 return nil, err
 242         }
 243         return out, nil
 244 }
 245
 246 func (c *serviceClient) ACLStatsIntfCountersEnable(ctx context.Context, in *ACLStatsIntfCountersEnable) (*ACLStatsIntfCountersEnableReply, error) {
 247         out := new(ACLStatsIntfCountersEnableReply)
 248         err := c.conn.Invoke(ctx, in, out)
 249         if err != nil {
 250                 return nil, err
 251         }
 252         return out, api.RetvalToVPPApiError(out.Retval)
 253 }
 254
 255 func (c *serviceClient) MacipACLAdd(ctx context.Context, in *MacipACLAdd) (*MacipACLAddReply, error) {
 256         out := new(MacipACLAddReply)
 257         err := c.conn.Invoke(ctx, in, out)
 258         if err != nil {
 259                 return nil, err
 260         }
 261         return out, api.RetvalToVPPApiError(out.Retval)
 262 }
 263
 264 func (c *serviceClient) MacipACLAddReplace(ctx context.Context, in *MacipACLAddReplace) (*MacipACLAddReplaceReply, error) {
 265         out := new(MacipACLAddReplaceReply)
 266         err := c.conn.Invoke(ctx, in, out)
 267         if err != nil {
 268                 return nil, err
 269         }
 270         return out, api.RetvalToVPPApiError(out.Retval)
 271 }
 272
 273 func (c *serviceClient) MacipACLDel(ctx context.Context, in *MacipACLDel) (*MacipACLDelReply, error) {
 274         out := new(MacipACLDelReply)
 275         err := c.conn.Invoke(ctx, in, out)
 276         if err != nil {
 277                 return nil, err
 278         }
 279         return out, api.RetvalToVPPApiError(out.Retval)
 280 }
 281
 282 func (c *serviceClient) MacipACLDump(ctx context.Context, in *MacipACLDump) (RPCService_MacipACLDumpClient, error) {
 283         stream, err := c.conn.NewStream(ctx)
 284         if err != nil {
 285                 return nil, err
 286         }
 287         x := &serviceClient_MacipACLDumpClient{stream}
 288         if err := x.Stream.SendMsg(in); err != nil {
 289                 return nil, err
 290         }
 291         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 292                 return nil, err
 293         }
 294         return x, nil
 295 }
 296
 297 type RPCService_MacipACLDumpClient interface {
 298         Recv() (*MacipACLDetails, error)
 299         api.Stream
 300 }
 301
 302 type serviceClient_MacipACLDumpClient struct {
 303         api.Stream
 304 }
 305
 306 func (c *serviceClient_MacipACLDumpClient) Recv() (*MacipACLDetails, error) {
 307         msg, err := c.Stream.RecvMsg()
 308         if err != nil {
 309                 return nil, err
 310         }
 311         switch m := msg.(type) {
 312         case *MacipACLDetails:
 313                 return m, nil
 314         case *vpe.ControlPingReply:
 315                 err = c.Stream.Close()
 316                 if err != nil {
 317                         return nil, err
 318                 }
 319                 return nil, io.EOF
 320         default:
 321                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 322         }
 323 }
 324
 325 func (c *serviceClient) MacipACLInterfaceAddDel(ctx context.Context, in *MacipACLInterfaceAddDel) (*MacipACLInterfaceAddDelReply, error) {
 326         out := new(MacipACLInterfaceAddDelReply)
 327         err := c.conn.Invoke(ctx, in, out)
 328         if err != nil {
 329                 return nil, err
 330         }
 331         return out, api.RetvalToVPPApiError(out.Retval)
 332 }
 333
 334 func (c *serviceClient) MacipACLInterfaceGet(ctx context.Context, in *MacipACLInterfaceGet) (*MacipACLInterfaceGetReply, error) {
 335         out := new(MacipACLInterfaceGetReply)
 336         err := c.conn.Invoke(ctx, in, out)
 337         if err != nil {
 338                 return nil, err
 339         }
 340         return out, nil
 341 }
 342
 343 func (c *serviceClient) MacipACLInterfaceListDump(ctx context.Context, in *MacipACLInterfaceListDump) (RPCService_MacipACLInterfaceListDumpClient, error) {
 344         stream, err := c.conn.NewStream(ctx)
 345         if err != nil {
 346                 return nil, err
 347         }
 348         x := &serviceClient_MacipACLInterfaceListDumpClient{stream}
 349         if err := x.Stream.SendMsg(in); err != nil {
 350                 return nil, err
 351         }
 352         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 353                 return nil, err
 354         }
 355         return x, nil
 356 }
 357
 358 type RPCService_MacipACLInterfaceListDumpClient interface {
 359         Recv() (*MacipACLInterfaceListDetails, error)
 360         api.Stream
 361 }
 362
 363 type serviceClient_MacipACLInterfaceListDumpClient struct {
 364         api.Stream
 365 }
 366
 367 func (c *serviceClient_MacipACLInterfaceListDumpClient) Recv() (*MacipACLInterfaceListDetails, error) {
 368         msg, err := c.Stream.RecvMsg()
 369         if err != nil {
 370                 return nil, err
 371         }
 372         switch m := msg.(type) {
 373         case *MacipACLInterfaceListDetails:
 374                 return m, nil
 375         case *vpe.ControlPingReply:
 376                 err = c.Stream.Close()
 377                 if err != nil {
 378                         return nil, err
 379                 }
 380                 return nil, io.EOF
 381         default:
 382                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 383         }
 384 }