binapi/ipsec/ipsec_rpc.ba.go

   1 // Code generated by GoVPP's binapi-generator. DO NOT EDIT.
   2
   3 package ipsec
   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 ipsec.
  15 type RPCService interface {
  16         IpsecBackendDump(ctx context.Context, in *IpsecBackendDump) (RPCService_IpsecBackendDumpClient, error)
  17         IpsecInterfaceAddDelSpd(ctx context.Context, in *IpsecInterfaceAddDelSpd) (*IpsecInterfaceAddDelSpdReply, error)
  18         IpsecItfCreate(ctx context.Context, in *IpsecItfCreate) (*IpsecItfCreateReply, error)
  19         IpsecItfDelete(ctx context.Context, in *IpsecItfDelete) (*IpsecItfDeleteReply, error)
  20         IpsecItfDump(ctx context.Context, in *IpsecItfDump) (RPCService_IpsecItfDumpClient, error)
  21         IpsecSaDump(ctx context.Context, in *IpsecSaDump) (RPCService_IpsecSaDumpClient, error)
  22         IpsecSaV2Dump(ctx context.Context, in *IpsecSaV2Dump) (RPCService_IpsecSaV2DumpClient, error)
  23         IpsecSaV3Dump(ctx context.Context, in *IpsecSaV3Dump) (RPCService_IpsecSaV3DumpClient, error)
  24         IpsecSadEntryAdd(ctx context.Context, in *IpsecSadEntryAdd) (*IpsecSadEntryAddReply, error)
  25         IpsecSadEntryAddDel(ctx context.Context, in *IpsecSadEntryAddDel) (*IpsecSadEntryAddDelReply, error)
  26         IpsecSadEntryAddDelV2(ctx context.Context, in *IpsecSadEntryAddDelV2) (*IpsecSadEntryAddDelV2Reply, error)
  27         IpsecSadEntryAddDelV3(ctx context.Context, in *IpsecSadEntryAddDelV3) (*IpsecSadEntryAddDelV3Reply, error)
  28         IpsecSadEntryDel(ctx context.Context, in *IpsecSadEntryDel) (*IpsecSadEntryDelReply, error)
  29         IpsecSelectBackend(ctx context.Context, in *IpsecSelectBackend) (*IpsecSelectBackendReply, error)
  30         IpsecSetAsyncMode(ctx context.Context, in *IpsecSetAsyncMode) (*IpsecSetAsyncModeReply, error)
  31         IpsecSpdAddDel(ctx context.Context, in *IpsecSpdAddDel) (*IpsecSpdAddDelReply, error)
  32         IpsecSpdDump(ctx context.Context, in *IpsecSpdDump) (RPCService_IpsecSpdDumpClient, error)
  33         IpsecSpdEntryAddDel(ctx context.Context, in *IpsecSpdEntryAddDel) (*IpsecSpdEntryAddDelReply, error)
  34         IpsecSpdInterfaceDump(ctx context.Context, in *IpsecSpdInterfaceDump) (RPCService_IpsecSpdInterfaceDumpClient, error)
  35         IpsecSpdsDump(ctx context.Context, in *IpsecSpdsDump) (RPCService_IpsecSpdsDumpClient, error)
  36         IpsecTunnelProtectDel(ctx context.Context, in *IpsecTunnelProtectDel) (*IpsecTunnelProtectDelReply, error)
  37         IpsecTunnelProtectDump(ctx context.Context, in *IpsecTunnelProtectDump) (RPCService_IpsecTunnelProtectDumpClient, error)
  38         IpsecTunnelProtectUpdate(ctx context.Context, in *IpsecTunnelProtectUpdate) (*IpsecTunnelProtectUpdateReply, error)
  39 }
  40
  41 type serviceClient struct {
  42         conn api.Connection
  43 }
  44
  45 func NewServiceClient(conn api.Connection) RPCService {
  46         return &serviceClient{conn}
  47 }
  48
  49 func (c *serviceClient) IpsecBackendDump(ctx context.Context, in *IpsecBackendDump) (RPCService_IpsecBackendDumpClient, error) {
  50         stream, err := c.conn.NewStream(ctx)
  51         if err != nil {
  52                 return nil, err
  53         }
  54         x := &serviceClient_IpsecBackendDumpClient{stream}
  55         if err := x.Stream.SendMsg(in); err != nil {
  56                 return nil, err
  57         }
  58         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
  59                 return nil, err
  60         }
  61         return x, nil
  62 }
  63
  64 type RPCService_IpsecBackendDumpClient interface {
  65         Recv() (*IpsecBackendDetails, error)
  66         api.Stream
  67 }
  68
  69 type serviceClient_IpsecBackendDumpClient struct {
  70         api.Stream
  71 }
  72
  73 func (c *serviceClient_IpsecBackendDumpClient) Recv() (*IpsecBackendDetails, error) {
  74         msg, err := c.Stream.RecvMsg()
  75         if err != nil {
  76                 return nil, err
  77         }
  78         switch m := msg.(type) {
  79         case *IpsecBackendDetails:
  80                 return m, nil
  81         case *memclnt.ControlPingReply:
  82                 err = c.Stream.Close()
  83                 if err != nil {
  84                         return nil, err
  85                 }
  86                 return nil, io.EOF
  87         default:
  88                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
  89         }
  90 }
  91
  92 func (c *serviceClient) IpsecInterfaceAddDelSpd(ctx context.Context, in *IpsecInterfaceAddDelSpd) (*IpsecInterfaceAddDelSpdReply, error) {
  93         out := new(IpsecInterfaceAddDelSpdReply)
  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) IpsecItfCreate(ctx context.Context, in *IpsecItfCreate) (*IpsecItfCreateReply, error) {
 102         out := new(IpsecItfCreateReply)
 103         err := c.conn.Invoke(ctx, in, out)
 104         if err != nil {
 105                 return nil, err
 106         }
 107         return out, api.RetvalToVPPApiError(out.Retval)
 108 }
 109
 110 func (c *serviceClient) IpsecItfDelete(ctx context.Context, in *IpsecItfDelete) (*IpsecItfDeleteReply, error) {
 111         out := new(IpsecItfDeleteReply)
 112         err := c.conn.Invoke(ctx, in, out)
 113         if err != nil {
 114                 return nil, err
 115         }
 116         return out, api.RetvalToVPPApiError(out.Retval)
 117 }
 118
 119 func (c *serviceClient) IpsecItfDump(ctx context.Context, in *IpsecItfDump) (RPCService_IpsecItfDumpClient, error) {
 120         stream, err := c.conn.NewStream(ctx)
 121         if err != nil {
 122                 return nil, err
 123         }
 124         x := &serviceClient_IpsecItfDumpClient{stream}
 125         if err := x.Stream.SendMsg(in); err != nil {
 126                 return nil, err
 127         }
 128         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 129                 return nil, err
 130         }
 131         return x, nil
 132 }
 133
 134 type RPCService_IpsecItfDumpClient interface {
 135         Recv() (*IpsecItfDetails, error)
 136         api.Stream
 137 }
 138
 139 type serviceClient_IpsecItfDumpClient struct {
 140         api.Stream
 141 }
 142
 143 func (c *serviceClient_IpsecItfDumpClient) Recv() (*IpsecItfDetails, error) {
 144         msg, err := c.Stream.RecvMsg()
 145         if err != nil {
 146                 return nil, err
 147         }
 148         switch m := msg.(type) {
 149         case *IpsecItfDetails:
 150                 return m, nil
 151         case *memclnt.ControlPingReply:
 152                 err = c.Stream.Close()
 153                 if err != nil {
 154                         return nil, err
 155                 }
 156                 return nil, io.EOF
 157         default:
 158                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 159         }
 160 }
 161
 162 func (c *serviceClient) IpsecSaDump(ctx context.Context, in *IpsecSaDump) (RPCService_IpsecSaDumpClient, error) {
 163         stream, err := c.conn.NewStream(ctx)
 164         if err != nil {
 165                 return nil, err
 166         }
 167         x := &serviceClient_IpsecSaDumpClient{stream}
 168         if err := x.Stream.SendMsg(in); err != nil {
 169                 return nil, err
 170         }
 171         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 172                 return nil, err
 173         }
 174         return x, nil
 175 }
 176
 177 type RPCService_IpsecSaDumpClient interface {
 178         Recv() (*IpsecSaDetails, error)
 179         api.Stream
 180 }
 181
 182 type serviceClient_IpsecSaDumpClient struct {
 183         api.Stream
 184 }
 185
 186 func (c *serviceClient_IpsecSaDumpClient) Recv() (*IpsecSaDetails, error) {
 187         msg, err := c.Stream.RecvMsg()
 188         if err != nil {
 189                 return nil, err
 190         }
 191         switch m := msg.(type) {
 192         case *IpsecSaDetails:
 193                 return m, nil
 194         case *memclnt.ControlPingReply:
 195                 err = c.Stream.Close()
 196                 if err != nil {
 197                         return nil, err
 198                 }
 199                 return nil, io.EOF
 200         default:
 201                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 202         }
 203 }
 204
 205 func (c *serviceClient) IpsecSaV2Dump(ctx context.Context, in *IpsecSaV2Dump) (RPCService_IpsecSaV2DumpClient, error) {
 206         stream, err := c.conn.NewStream(ctx)
 207         if err != nil {
 208                 return nil, err
 209         }
 210         x := &serviceClient_IpsecSaV2DumpClient{stream}
 211         if err := x.Stream.SendMsg(in); err != nil {
 212                 return nil, err
 213         }
 214         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 215                 return nil, err
 216         }
 217         return x, nil
 218 }
 219
 220 type RPCService_IpsecSaV2DumpClient interface {
 221         Recv() (*IpsecSaV2Details, error)
 222         api.Stream
 223 }
 224
 225 type serviceClient_IpsecSaV2DumpClient struct {
 226         api.Stream
 227 }
 228
 229 func (c *serviceClient_IpsecSaV2DumpClient) Recv() (*IpsecSaV2Details, error) {
 230         msg, err := c.Stream.RecvMsg()
 231         if err != nil {
 232                 return nil, err
 233         }
 234         switch m := msg.(type) {
 235         case *IpsecSaV2Details:
 236                 return m, nil
 237         case *memclnt.ControlPingReply:
 238                 err = c.Stream.Close()
 239                 if err != nil {
 240                         return nil, err
 241                 }
 242                 return nil, io.EOF
 243         default:
 244                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 245         }
 246 }
 247
 248 func (c *serviceClient) IpsecSaV3Dump(ctx context.Context, in *IpsecSaV3Dump) (RPCService_IpsecSaV3DumpClient, error) {
 249         stream, err := c.conn.NewStream(ctx)
 250         if err != nil {
 251                 return nil, err
 252         }
 253         x := &serviceClient_IpsecSaV3DumpClient{stream}
 254         if err := x.Stream.SendMsg(in); err != nil {
 255                 return nil, err
 256         }
 257         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 258                 return nil, err
 259         }
 260         return x, nil
 261 }
 262
 263 type RPCService_IpsecSaV3DumpClient interface {
 264         Recv() (*IpsecSaV3Details, error)
 265         api.Stream
 266 }
 267
 268 type serviceClient_IpsecSaV3DumpClient struct {
 269         api.Stream
 270 }
 271
 272 func (c *serviceClient_IpsecSaV3DumpClient) Recv() (*IpsecSaV3Details, error) {
 273         msg, err := c.Stream.RecvMsg()
 274         if err != nil {
 275                 return nil, err
 276         }
 277         switch m := msg.(type) {
 278         case *IpsecSaV3Details:
 279                 return m, nil
 280         case *memclnt.ControlPingReply:
 281                 err = c.Stream.Close()
 282                 if err != nil {
 283                         return nil, err
 284                 }
 285                 return nil, io.EOF
 286         default:
 287                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 288         }
 289 }
 290
 291 func (c *serviceClient) IpsecSadEntryAdd(ctx context.Context, in *IpsecSadEntryAdd) (*IpsecSadEntryAddReply, error) {
 292         out := new(IpsecSadEntryAddReply)
 293         err := c.conn.Invoke(ctx, in, out)
 294         if err != nil {
 295                 return nil, err
 296         }
 297         return out, api.RetvalToVPPApiError(out.Retval)
 298 }
 299
 300 func (c *serviceClient) IpsecSadEntryAddDel(ctx context.Context, in *IpsecSadEntryAddDel) (*IpsecSadEntryAddDelReply, error) {
 301         out := new(IpsecSadEntryAddDelReply)
 302         err := c.conn.Invoke(ctx, in, out)
 303         if err != nil {
 304                 return nil, err
 305         }
 306         return out, api.RetvalToVPPApiError(out.Retval)
 307 }
 308
 309 func (c *serviceClient) IpsecSadEntryAddDelV2(ctx context.Context, in *IpsecSadEntryAddDelV2) (*IpsecSadEntryAddDelV2Reply, error) {
 310         out := new(IpsecSadEntryAddDelV2Reply)
 311         err := c.conn.Invoke(ctx, in, out)
 312         if err != nil {
 313                 return nil, err
 314         }
 315         return out, api.RetvalToVPPApiError(out.Retval)
 316 }
 317
 318 func (c *serviceClient) IpsecSadEntryAddDelV3(ctx context.Context, in *IpsecSadEntryAddDelV3) (*IpsecSadEntryAddDelV3Reply, error) {
 319         out := new(IpsecSadEntryAddDelV3Reply)
 320         err := c.conn.Invoke(ctx, in, out)
 321         if err != nil {
 322                 return nil, err
 323         }
 324         return out, api.RetvalToVPPApiError(out.Retval)
 325 }
 326
 327 func (c *serviceClient) IpsecSadEntryDel(ctx context.Context, in *IpsecSadEntryDel) (*IpsecSadEntryDelReply, error) {
 328         out := new(IpsecSadEntryDelReply)
 329         err := c.conn.Invoke(ctx, in, out)
 330         if err != nil {
 331                 return nil, err
 332         }
 333         return out, api.RetvalToVPPApiError(out.Retval)
 334 }
 335
 336 func (c *serviceClient) IpsecSelectBackend(ctx context.Context, in *IpsecSelectBackend) (*IpsecSelectBackendReply, error) {
 337         out := new(IpsecSelectBackendReply)
 338         err := c.conn.Invoke(ctx, in, out)
 339         if err != nil {
 340                 return nil, err
 341         }
 342         return out, api.RetvalToVPPApiError(out.Retval)
 343 }
 344
 345 func (c *serviceClient) IpsecSetAsyncMode(ctx context.Context, in *IpsecSetAsyncMode) (*IpsecSetAsyncModeReply, error) {
 346         out := new(IpsecSetAsyncModeReply)
 347         err := c.conn.Invoke(ctx, in, out)
 348         if err != nil {
 349                 return nil, err
 350         }
 351         return out, api.RetvalToVPPApiError(out.Retval)
 352 }
 353
 354 func (c *serviceClient) IpsecSpdAddDel(ctx context.Context, in *IpsecSpdAddDel) (*IpsecSpdAddDelReply, error) {
 355         out := new(IpsecSpdAddDelReply)
 356         err := c.conn.Invoke(ctx, in, out)
 357         if err != nil {
 358                 return nil, err
 359         }
 360         return out, api.RetvalToVPPApiError(out.Retval)
 361 }
 362
 363 func (c *serviceClient) IpsecSpdDump(ctx context.Context, in *IpsecSpdDump) (RPCService_IpsecSpdDumpClient, error) {
 364         stream, err := c.conn.NewStream(ctx)
 365         if err != nil {
 366                 return nil, err
 367         }
 368         x := &serviceClient_IpsecSpdDumpClient{stream}
 369         if err := x.Stream.SendMsg(in); err != nil {
 370                 return nil, err
 371         }
 372         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 373                 return nil, err
 374         }
 375         return x, nil
 376 }
 377
 378 type RPCService_IpsecSpdDumpClient interface {
 379         Recv() (*IpsecSpdDetails, error)
 380         api.Stream
 381 }
 382
 383 type serviceClient_IpsecSpdDumpClient struct {
 384         api.Stream
 385 }
 386
 387 func (c *serviceClient_IpsecSpdDumpClient) Recv() (*IpsecSpdDetails, error) {
 388         msg, err := c.Stream.RecvMsg()
 389         if err != nil {
 390                 return nil, err
 391         }
 392         switch m := msg.(type) {
 393         case *IpsecSpdDetails:
 394                 return m, nil
 395         case *memclnt.ControlPingReply:
 396                 err = c.Stream.Close()
 397                 if err != nil {
 398                         return nil, err
 399                 }
 400                 return nil, io.EOF
 401         default:
 402                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 403         }
 404 }
 405
 406 func (c *serviceClient) IpsecSpdEntryAddDel(ctx context.Context, in *IpsecSpdEntryAddDel) (*IpsecSpdEntryAddDelReply, error) {
 407         out := new(IpsecSpdEntryAddDelReply)
 408         err := c.conn.Invoke(ctx, in, out)
 409         if err != nil {
 410                 return nil, err
 411         }
 412         return out, api.RetvalToVPPApiError(out.Retval)
 413 }
 414
 415 func (c *serviceClient) IpsecSpdInterfaceDump(ctx context.Context, in *IpsecSpdInterfaceDump) (RPCService_IpsecSpdInterfaceDumpClient, error) {
 416         stream, err := c.conn.NewStream(ctx)
 417         if err != nil {
 418                 return nil, err
 419         }
 420         x := &serviceClient_IpsecSpdInterfaceDumpClient{stream}
 421         if err := x.Stream.SendMsg(in); err != nil {
 422                 return nil, err
 423         }
 424         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 425                 return nil, err
 426         }
 427         return x, nil
 428 }
 429
 430 type RPCService_IpsecSpdInterfaceDumpClient interface {
 431         Recv() (*IpsecSpdInterfaceDetails, error)
 432         api.Stream
 433 }
 434
 435 type serviceClient_IpsecSpdInterfaceDumpClient struct {
 436         api.Stream
 437 }
 438
 439 func (c *serviceClient_IpsecSpdInterfaceDumpClient) Recv() (*IpsecSpdInterfaceDetails, error) {
 440         msg, err := c.Stream.RecvMsg()
 441         if err != nil {
 442                 return nil, err
 443         }
 444         switch m := msg.(type) {
 445         case *IpsecSpdInterfaceDetails:
 446                 return m, nil
 447         case *memclnt.ControlPingReply:
 448                 err = c.Stream.Close()
 449                 if err != nil {
 450                         return nil, err
 451                 }
 452                 return nil, io.EOF
 453         default:
 454                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 455         }
 456 }
 457
 458 func (c *serviceClient) IpsecSpdsDump(ctx context.Context, in *IpsecSpdsDump) (RPCService_IpsecSpdsDumpClient, error) {
 459         stream, err := c.conn.NewStream(ctx)
 460         if err != nil {
 461                 return nil, err
 462         }
 463         x := &serviceClient_IpsecSpdsDumpClient{stream}
 464         if err := x.Stream.SendMsg(in); err != nil {
 465                 return nil, err
 466         }
 467         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 468                 return nil, err
 469         }
 470         return x, nil
 471 }
 472
 473 type RPCService_IpsecSpdsDumpClient interface {
 474         Recv() (*IpsecSpdsDetails, error)
 475         api.Stream
 476 }
 477
 478 type serviceClient_IpsecSpdsDumpClient struct {
 479         api.Stream
 480 }
 481
 482 func (c *serviceClient_IpsecSpdsDumpClient) Recv() (*IpsecSpdsDetails, error) {
 483         msg, err := c.Stream.RecvMsg()
 484         if err != nil {
 485                 return nil, err
 486         }
 487         switch m := msg.(type) {
 488         case *IpsecSpdsDetails:
 489                 return m, nil
 490         case *memclnt.ControlPingReply:
 491                 err = c.Stream.Close()
 492                 if err != nil {
 493                         return nil, err
 494                 }
 495                 return nil, io.EOF
 496         default:
 497                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 498         }
 499 }
 500
 501 func (c *serviceClient) IpsecTunnelProtectDel(ctx context.Context, in *IpsecTunnelProtectDel) (*IpsecTunnelProtectDelReply, error) {
 502         out := new(IpsecTunnelProtectDelReply)
 503         err := c.conn.Invoke(ctx, in, out)
 504         if err != nil {
 505                 return nil, err
 506         }
 507         return out, api.RetvalToVPPApiError(out.Retval)
 508 }
 509
 510 func (c *serviceClient) IpsecTunnelProtectDump(ctx context.Context, in *IpsecTunnelProtectDump) (RPCService_IpsecTunnelProtectDumpClient, error) {
 511         stream, err := c.conn.NewStream(ctx)
 512         if err != nil {
 513                 return nil, err
 514         }
 515         x := &serviceClient_IpsecTunnelProtectDumpClient{stream}
 516         if err := x.Stream.SendMsg(in); err != nil {
 517                 return nil, err
 518         }
 519         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 520                 return nil, err
 521         }
 522         return x, nil
 523 }
 524
 525 type RPCService_IpsecTunnelProtectDumpClient interface {
 526         Recv() (*IpsecTunnelProtectDetails, error)
 527         api.Stream
 528 }
 529
 530 type serviceClient_IpsecTunnelProtectDumpClient struct {
 531         api.Stream
 532 }
 533
 534 func (c *serviceClient_IpsecTunnelProtectDumpClient) Recv() (*IpsecTunnelProtectDetails, error) {
 535         msg, err := c.Stream.RecvMsg()
 536         if err != nil {
 537                 return nil, err
 538         }
 539         switch m := msg.(type) {
 540         case *IpsecTunnelProtectDetails:
 541                 return m, nil
 542         case *memclnt.ControlPingReply:
 543                 err = c.Stream.Close()
 544                 if err != nil {
 545                         return nil, err
 546                 }
 547                 return nil, io.EOF
 548         default:
 549                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 550         }
 551 }
 552
 553 func (c *serviceClient) IpsecTunnelProtectUpdate(ctx context.Context, in *IpsecTunnelProtectUpdate) (*IpsecTunnelProtectUpdateReply, error) {
 554         out := new(IpsecTunnelProtectUpdateReply)
 555         err := c.conn.Invoke(ctx, in, out)
 556         if err != nil {
 557                 return nil, err
 558         }
 559         return out, api.RetvalToVPPApiError(out.Retval)
 560 }