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