binapi/lisp/lisp_rpc.ba.go

   1 // Code generated by GoVPP's binapi-generator. DO NOT EDIT.
   2
   3 package lisp
   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  lisp.
  15 type RPCService interface {
  16         LispAddDelAdjacency(ctx context.Context, in *LispAddDelAdjacency) (*LispAddDelAdjacencyReply, error)
  17         LispAddDelLocalEid(ctx context.Context, in *LispAddDelLocalEid) (*LispAddDelLocalEidReply, error)
  18         LispAddDelLocator(ctx context.Context, in *LispAddDelLocator) (*LispAddDelLocatorReply, error)
  19         LispAddDelLocatorSet(ctx context.Context, in *LispAddDelLocatorSet) (*LispAddDelLocatorSetReply, error)
  20         LispAddDelMapRequestItrRlocs(ctx context.Context, in *LispAddDelMapRequestItrRlocs) (*LispAddDelMapRequestItrRlocsReply, error)
  21         LispAddDelMapResolver(ctx context.Context, in *LispAddDelMapResolver) (*LispAddDelMapResolverReply, error)
  22         LispAddDelMapServer(ctx context.Context, in *LispAddDelMapServer) (*LispAddDelMapServerReply, error)
  23         LispAddDelRemoteMapping(ctx context.Context, in *LispAddDelRemoteMapping) (*LispAddDelRemoteMappingReply, error)
  24         LispAdjacenciesGet(ctx context.Context, in *LispAdjacenciesGet) (*LispAdjacenciesGetReply, error)
  25         LispEidTableAddDelMap(ctx context.Context, in *LispEidTableAddDelMap) (*LispEidTableAddDelMapReply, error)
  26         LispEidTableDump(ctx context.Context, in *LispEidTableDump) (RPCService_LispEidTableDumpClient, error)
  27         LispEidTableMapDump(ctx context.Context, in *LispEidTableMapDump) (RPCService_LispEidTableMapDumpClient, error)
  28         LispEidTableVniDump(ctx context.Context, in *LispEidTableVniDump) (RPCService_LispEidTableVniDumpClient, error)
  29         LispEnableDisable(ctx context.Context, in *LispEnableDisable) (*LispEnableDisableReply, error)
  30         LispGetMapRequestItrRlocs(ctx context.Context, in *LispGetMapRequestItrRlocs) (*LispGetMapRequestItrRlocsReply, error)
  31         LispLocatorDump(ctx context.Context, in *LispLocatorDump) (RPCService_LispLocatorDumpClient, error)
  32         LispLocatorSetDump(ctx context.Context, in *LispLocatorSetDump) (RPCService_LispLocatorSetDumpClient, error)
  33         LispMapRegisterEnableDisable(ctx context.Context, in *LispMapRegisterEnableDisable) (*LispMapRegisterEnableDisableReply, error)
  34         LispMapRequestMode(ctx context.Context, in *LispMapRequestMode) (*LispMapRequestModeReply, error)
  35         LispMapResolverDump(ctx context.Context, in *LispMapResolverDump) (RPCService_LispMapResolverDumpClient, error)
  36         LispMapServerDump(ctx context.Context, in *LispMapServerDump) (RPCService_LispMapServerDumpClient, error)
  37         LispPitrSetLocatorSet(ctx context.Context, in *LispPitrSetLocatorSet) (*LispPitrSetLocatorSetReply, error)
  38         LispRlocProbeEnableDisable(ctx context.Context, in *LispRlocProbeEnableDisable) (*LispRlocProbeEnableDisableReply, error)
  39         LispUsePetr(ctx context.Context, in *LispUsePetr) (*LispUsePetrReply, error)
  40         ShowLispMapRegisterState(ctx context.Context, in *ShowLispMapRegisterState) (*ShowLispMapRegisterStateReply, error)
  41         ShowLispMapRequestMode(ctx context.Context, in *ShowLispMapRequestMode) (*ShowLispMapRequestModeReply, error)
  42         ShowLispPitr(ctx context.Context, in *ShowLispPitr) (*ShowLispPitrReply, error)
  43         ShowLispRlocProbeState(ctx context.Context, in *ShowLispRlocProbeState) (*ShowLispRlocProbeStateReply, error)
  44         ShowLispStatus(ctx context.Context, in *ShowLispStatus) (*ShowLispStatusReply, error)
  45         ShowLispUsePetr(ctx context.Context, in *ShowLispUsePetr) (*ShowLispUsePetrReply, error)
  46 }
  47
  48 type serviceClient struct {
  49         conn api.Connection
  50 }
  51
  52 func NewServiceClient(conn api.Connection) RPCService {
  53         return &serviceClient{conn}
  54 }
  55
  56 func (c *serviceClient) LispAddDelAdjacency(ctx context.Context, in *LispAddDelAdjacency) (*LispAddDelAdjacencyReply, error) {
  57         out := new(LispAddDelAdjacencyReply)
  58         err := c.conn.Invoke(ctx, in, out)
  59         if err != nil {
  60                 return nil, err
  61         }
  62         return out, nil
  63 }
  64
  65 func (c *serviceClient) LispAddDelLocalEid(ctx context.Context, in *LispAddDelLocalEid) (*LispAddDelLocalEidReply, error) {
  66         out := new(LispAddDelLocalEidReply)
  67         err := c.conn.Invoke(ctx, in, out)
  68         if err != nil {
  69                 return nil, err
  70         }
  71         return out, nil
  72 }
  73
  74 func (c *serviceClient) LispAddDelLocator(ctx context.Context, in *LispAddDelLocator) (*LispAddDelLocatorReply, error) {
  75         out := new(LispAddDelLocatorReply)
  76         err := c.conn.Invoke(ctx, in, out)
  77         if err != nil {
  78                 return nil, err
  79         }
  80         return out, nil
  81 }
  82
  83 func (c *serviceClient) LispAddDelLocatorSet(ctx context.Context, in *LispAddDelLocatorSet) (*LispAddDelLocatorSetReply, error) {
  84         out := new(LispAddDelLocatorSetReply)
  85         err := c.conn.Invoke(ctx, in, out)
  86         if err != nil {
  87                 return nil, err
  88         }
  89         return out, nil
  90 }
  91
  92 func (c *serviceClient) LispAddDelMapRequestItrRlocs(ctx context.Context, in *LispAddDelMapRequestItrRlocs) (*LispAddDelMapRequestItrRlocsReply, error) {
  93         out := new(LispAddDelMapRequestItrRlocsReply)
  94         err := c.conn.Invoke(ctx, in, out)
  95         if err != nil {
  96                 return nil, err
  97         }
  98         return out, nil
  99 }
 100
 101 func (c *serviceClient) LispAddDelMapResolver(ctx context.Context, in *LispAddDelMapResolver) (*LispAddDelMapResolverReply, error) {
 102         out := new(LispAddDelMapResolverReply)
 103         err := c.conn.Invoke(ctx, in, out)
 104         if err != nil {
 105                 return nil, err
 106         }
 107         return out, nil
 108 }
 109
 110 func (c *serviceClient) LispAddDelMapServer(ctx context.Context, in *LispAddDelMapServer) (*LispAddDelMapServerReply, error) {
 111         out := new(LispAddDelMapServerReply)
 112         err := c.conn.Invoke(ctx, in, out)
 113         if err != nil {
 114                 return nil, err
 115         }
 116         return out, nil
 117 }
 118
 119 func (c *serviceClient) LispAddDelRemoteMapping(ctx context.Context, in *LispAddDelRemoteMapping) (*LispAddDelRemoteMappingReply, error) {
 120         out := new(LispAddDelRemoteMappingReply)
 121         err := c.conn.Invoke(ctx, in, out)
 122         if err != nil {
 123                 return nil, err
 124         }
 125         return out, nil
 126 }
 127
 128 func (c *serviceClient) LispAdjacenciesGet(ctx context.Context, in *LispAdjacenciesGet) (*LispAdjacenciesGetReply, error) {
 129         out := new(LispAdjacenciesGetReply)
 130         err := c.conn.Invoke(ctx, in, out)
 131         if err != nil {
 132                 return nil, err
 133         }
 134         return out, nil
 135 }
 136
 137 func (c *serviceClient) LispEidTableAddDelMap(ctx context.Context, in *LispEidTableAddDelMap) (*LispEidTableAddDelMapReply, error) {
 138         out := new(LispEidTableAddDelMapReply)
 139         err := c.conn.Invoke(ctx, in, out)
 140         if err != nil {
 141                 return nil, err
 142         }
 143         return out, nil
 144 }
 145
 146 func (c *serviceClient) LispEidTableDump(ctx context.Context, in *LispEidTableDump) (RPCService_LispEidTableDumpClient, error) {
 147         stream, err := c.conn.NewStream(ctx)
 148         if err != nil {
 149                 return nil, err
 150         }
 151         x := &serviceClient_LispEidTableDumpClient{stream}
 152         if err := x.Stream.SendMsg(in); err != nil {
 153                 return nil, err
 154         }
 155         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 156                 return nil, err
 157         }
 158         return x, nil
 159 }
 160
 161 type RPCService_LispEidTableDumpClient interface {
 162         Recv() (*LispEidTableDetails, error)
 163         api.Stream
 164 }
 165
 166 type serviceClient_LispEidTableDumpClient struct {
 167         api.Stream
 168 }
 169
 170 func (c *serviceClient_LispEidTableDumpClient) Recv() (*LispEidTableDetails, error) {
 171         msg, err := c.Stream.RecvMsg()
 172         if err != nil {
 173                 return nil, err
 174         }
 175         switch m := msg.(type) {
 176         case *LispEidTableDetails:
 177                 return m, nil
 178         case *vpe.ControlPingReply:
 179                 return nil, io.EOF
 180         default:
 181                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 182         }
 183 }
 184
 185 func (c *serviceClient) LispEidTableMapDump(ctx context.Context, in *LispEidTableMapDump) (RPCService_LispEidTableMapDumpClient, error) {
 186         stream, err := c.conn.NewStream(ctx)
 187         if err != nil {
 188                 return nil, err
 189         }
 190         x := &serviceClient_LispEidTableMapDumpClient{stream}
 191         if err := x.Stream.SendMsg(in); err != nil {
 192                 return nil, err
 193         }
 194         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 195                 return nil, err
 196         }
 197         return x, nil
 198 }
 199
 200 type RPCService_LispEidTableMapDumpClient interface {
 201         Recv() (*LispEidTableMapDetails, error)
 202         api.Stream
 203 }
 204
 205 type serviceClient_LispEidTableMapDumpClient struct {
 206         api.Stream
 207 }
 208
 209 func (c *serviceClient_LispEidTableMapDumpClient) Recv() (*LispEidTableMapDetails, error) {
 210         msg, err := c.Stream.RecvMsg()
 211         if err != nil {
 212                 return nil, err
 213         }
 214         switch m := msg.(type) {
 215         case *LispEidTableMapDetails:
 216                 return m, nil
 217         case *vpe.ControlPingReply:
 218                 return nil, io.EOF
 219         default:
 220                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 221         }
 222 }
 223
 224 func (c *serviceClient) LispEidTableVniDump(ctx context.Context, in *LispEidTableVniDump) (RPCService_LispEidTableVniDumpClient, error) {
 225         stream, err := c.conn.NewStream(ctx)
 226         if err != nil {
 227                 return nil, err
 228         }
 229         x := &serviceClient_LispEidTableVniDumpClient{stream}
 230         if err := x.Stream.SendMsg(in); err != nil {
 231                 return nil, err
 232         }
 233         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 234                 return nil, err
 235         }
 236         return x, nil
 237 }
 238
 239 type RPCService_LispEidTableVniDumpClient interface {
 240         Recv() (*LispEidTableVniDetails, error)
 241         api.Stream
 242 }
 243
 244 type serviceClient_LispEidTableVniDumpClient struct {
 245         api.Stream
 246 }
 247
 248 func (c *serviceClient_LispEidTableVniDumpClient) Recv() (*LispEidTableVniDetails, error) {
 249         msg, err := c.Stream.RecvMsg()
 250         if err != nil {
 251                 return nil, err
 252         }
 253         switch m := msg.(type) {
 254         case *LispEidTableVniDetails:
 255                 return m, nil
 256         case *vpe.ControlPingReply:
 257                 return nil, io.EOF
 258         default:
 259                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 260         }
 261 }
 262
 263 func (c *serviceClient) LispEnableDisable(ctx context.Context, in *LispEnableDisable) (*LispEnableDisableReply, error) {
 264         out := new(LispEnableDisableReply)
 265         err := c.conn.Invoke(ctx, in, out)
 266         if err != nil {
 267                 return nil, err
 268         }
 269         return out, nil
 270 }
 271
 272 func (c *serviceClient) LispGetMapRequestItrRlocs(ctx context.Context, in *LispGetMapRequestItrRlocs) (*LispGetMapRequestItrRlocsReply, error) {
 273         out := new(LispGetMapRequestItrRlocsReply)
 274         err := c.conn.Invoke(ctx, in, out)
 275         if err != nil {
 276                 return nil, err
 277         }
 278         return out, nil
 279 }
 280
 281 func (c *serviceClient) LispLocatorDump(ctx context.Context, in *LispLocatorDump) (RPCService_LispLocatorDumpClient, error) {
 282         stream, err := c.conn.NewStream(ctx)
 283         if err != nil {
 284                 return nil, err
 285         }
 286         x := &serviceClient_LispLocatorDumpClient{stream}
 287         if err := x.Stream.SendMsg(in); err != nil {
 288                 return nil, err
 289         }
 290         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 291                 return nil, err
 292         }
 293         return x, nil
 294 }
 295
 296 type RPCService_LispLocatorDumpClient interface {
 297         Recv() (*LispLocatorDetails, error)
 298         api.Stream
 299 }
 300
 301 type serviceClient_LispLocatorDumpClient struct {
 302         api.Stream
 303 }
 304
 305 func (c *serviceClient_LispLocatorDumpClient) Recv() (*LispLocatorDetails, error) {
 306         msg, err := c.Stream.RecvMsg()
 307         if err != nil {
 308                 return nil, err
 309         }
 310         switch m := msg.(type) {
 311         case *LispLocatorDetails:
 312                 return m, nil
 313         case *vpe.ControlPingReply:
 314                 return nil, io.EOF
 315         default:
 316                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 317         }
 318 }
 319
 320 func (c *serviceClient) LispLocatorSetDump(ctx context.Context, in *LispLocatorSetDump) (RPCService_LispLocatorSetDumpClient, error) {
 321         stream, err := c.conn.NewStream(ctx)
 322         if err != nil {
 323                 return nil, err
 324         }
 325         x := &serviceClient_LispLocatorSetDumpClient{stream}
 326         if err := x.Stream.SendMsg(in); err != nil {
 327                 return nil, err
 328         }
 329         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 330                 return nil, err
 331         }
 332         return x, nil
 333 }
 334
 335 type RPCService_LispLocatorSetDumpClient interface {
 336         Recv() (*LispLocatorSetDetails, error)
 337         api.Stream
 338 }
 339
 340 type serviceClient_LispLocatorSetDumpClient struct {
 341         api.Stream
 342 }
 343
 344 func (c *serviceClient_LispLocatorSetDumpClient) Recv() (*LispLocatorSetDetails, error) {
 345         msg, err := c.Stream.RecvMsg()
 346         if err != nil {
 347                 return nil, err
 348         }
 349         switch m := msg.(type) {
 350         case *LispLocatorSetDetails:
 351                 return m, nil
 352         case *vpe.ControlPingReply:
 353                 return nil, io.EOF
 354         default:
 355                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 356         }
 357 }
 358
 359 func (c *serviceClient) LispMapRegisterEnableDisable(ctx context.Context, in *LispMapRegisterEnableDisable) (*LispMapRegisterEnableDisableReply, error) {
 360         out := new(LispMapRegisterEnableDisableReply)
 361         err := c.conn.Invoke(ctx, in, out)
 362         if err != nil {
 363                 return nil, err
 364         }
 365         return out, nil
 366 }
 367
 368 func (c *serviceClient) LispMapRequestMode(ctx context.Context, in *LispMapRequestMode) (*LispMapRequestModeReply, error) {
 369         out := new(LispMapRequestModeReply)
 370         err := c.conn.Invoke(ctx, in, out)
 371         if err != nil {
 372                 return nil, err
 373         }
 374         return out, nil
 375 }
 376
 377 func (c *serviceClient) LispMapResolverDump(ctx context.Context, in *LispMapResolverDump) (RPCService_LispMapResolverDumpClient, error) {
 378         stream, err := c.conn.NewStream(ctx)
 379         if err != nil {
 380                 return nil, err
 381         }
 382         x := &serviceClient_LispMapResolverDumpClient{stream}
 383         if err := x.Stream.SendMsg(in); err != nil {
 384                 return nil, err
 385         }
 386         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 387                 return nil, err
 388         }
 389         return x, nil
 390 }
 391
 392 type RPCService_LispMapResolverDumpClient interface {
 393         Recv() (*LispMapResolverDetails, error)
 394         api.Stream
 395 }
 396
 397 type serviceClient_LispMapResolverDumpClient struct {
 398         api.Stream
 399 }
 400
 401 func (c *serviceClient_LispMapResolverDumpClient) Recv() (*LispMapResolverDetails, error) {
 402         msg, err := c.Stream.RecvMsg()
 403         if err != nil {
 404                 return nil, err
 405         }
 406         switch m := msg.(type) {
 407         case *LispMapResolverDetails:
 408                 return m, nil
 409         case *vpe.ControlPingReply:
 410                 return nil, io.EOF
 411         default:
 412                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 413         }
 414 }
 415
 416 func (c *serviceClient) LispMapServerDump(ctx context.Context, in *LispMapServerDump) (RPCService_LispMapServerDumpClient, error) {
 417         stream, err := c.conn.NewStream(ctx)
 418         if err != nil {
 419                 return nil, err
 420         }
 421         x := &serviceClient_LispMapServerDumpClient{stream}
 422         if err := x.Stream.SendMsg(in); err != nil {
 423                 return nil, err
 424         }
 425         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 426                 return nil, err
 427         }
 428         return x, nil
 429 }
 430
 431 type RPCService_LispMapServerDumpClient interface {
 432         Recv() (*LispMapServerDetails, error)
 433         api.Stream
 434 }
 435
 436 type serviceClient_LispMapServerDumpClient struct {
 437         api.Stream
 438 }
 439
 440 func (c *serviceClient_LispMapServerDumpClient) Recv() (*LispMapServerDetails, error) {
 441         msg, err := c.Stream.RecvMsg()
 442         if err != nil {
 443                 return nil, err
 444         }
 445         switch m := msg.(type) {
 446         case *LispMapServerDetails:
 447                 return m, nil
 448         case *vpe.ControlPingReply:
 449                 return nil, io.EOF
 450         default:
 451                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 452         }
 453 }
 454
 455 func (c *serviceClient) LispPitrSetLocatorSet(ctx context.Context, in *LispPitrSetLocatorSet) (*LispPitrSetLocatorSetReply, error) {
 456         out := new(LispPitrSetLocatorSetReply)
 457         err := c.conn.Invoke(ctx, in, out)
 458         if err != nil {
 459                 return nil, err
 460         }
 461         return out, nil
 462 }
 463
 464 func (c *serviceClient) LispRlocProbeEnableDisable(ctx context.Context, in *LispRlocProbeEnableDisable) (*LispRlocProbeEnableDisableReply, error) {
 465         out := new(LispRlocProbeEnableDisableReply)
 466         err := c.conn.Invoke(ctx, in, out)
 467         if err != nil {
 468                 return nil, err
 469         }
 470         return out, nil
 471 }
 472
 473 func (c *serviceClient) LispUsePetr(ctx context.Context, in *LispUsePetr) (*LispUsePetrReply, error) {
 474         out := new(LispUsePetrReply)
 475         err := c.conn.Invoke(ctx, in, out)
 476         if err != nil {
 477                 return nil, err
 478         }
 479         return out, nil
 480 }
 481
 482 func (c *serviceClient) ShowLispMapRegisterState(ctx context.Context, in *ShowLispMapRegisterState) (*ShowLispMapRegisterStateReply, error) {
 483         out := new(ShowLispMapRegisterStateReply)
 484         err := c.conn.Invoke(ctx, in, out)
 485         if err != nil {
 486                 return nil, err
 487         }
 488         return out, nil
 489 }
 490
 491 func (c *serviceClient) ShowLispMapRequestMode(ctx context.Context, in *ShowLispMapRequestMode) (*ShowLispMapRequestModeReply, error) {
 492         out := new(ShowLispMapRequestModeReply)
 493         err := c.conn.Invoke(ctx, in, out)
 494         if err != nil {
 495                 return nil, err
 496         }
 497         return out, nil
 498 }
 499
 500 func (c *serviceClient) ShowLispPitr(ctx context.Context, in *ShowLispPitr) (*ShowLispPitrReply, error) {
 501         out := new(ShowLispPitrReply)
 502         err := c.conn.Invoke(ctx, in, out)
 503         if err != nil {
 504                 return nil, err
 505         }
 506         return out, nil
 507 }
 508
 509 func (c *serviceClient) ShowLispRlocProbeState(ctx context.Context, in *ShowLispRlocProbeState) (*ShowLispRlocProbeStateReply, error) {
 510         out := new(ShowLispRlocProbeStateReply)
 511         err := c.conn.Invoke(ctx, in, out)
 512         if err != nil {
 513                 return nil, err
 514         }
 515         return out, nil
 516 }
 517
 518 func (c *serviceClient) ShowLispStatus(ctx context.Context, in *ShowLispStatus) (*ShowLispStatusReply, error) {
 519         out := new(ShowLispStatusReply)
 520         err := c.conn.Invoke(ctx, in, out)
 521         if err != nil {
 522                 return nil, err
 523         }
 524         return out, nil
 525 }
 526
 527 func (c *serviceClient) ShowLispUsePetr(ctx context.Context, in *ShowLispUsePetr) (*ShowLispUsePetrReply, error) {
 528         out := new(ShowLispUsePetrReply)
 529         err := c.conn.Invoke(ctx, in, out)
 530         if err != nil {
 531                 return nil, err
 532         }
 533         return out, nil
 534 }