examples/binapi/vpe/vpe.ba.go

   1 // Code generated by GoVPP's binapi-generator. DO NOT EDIT.
   2 // source: /usr/share/vpp/api/core/vpe.api.json
   3
   4 /*
   5 Package vpe is a generated VPP binary API for 'vpe' module.
   6
   7 It consists of:
   8           1 enum
   9           2 aliases
  10           2 types
  11          26 messages
  12          13 services
  13 */
  14 package vpe
  15
  16 import (
  17         bytes "bytes"
  18         context "context"
  19         api "git.fd.io/govpp.git/api"
  20         struc "github.com/lunixbochs/struc"
  21         io "io"
  22         strconv "strconv"
  23 )
  24
  25 const (
  26         // ModuleName is the name of this module.
  27         ModuleName = "vpe"
  28         // APIVersion is the API version of this module.
  29         APIVersion = "1.5.0"
  30         // VersionCrc is the CRC of this module.
  31         VersionCrc = 0x2521f24d
  32 )
  33
  34 // LogLevel represents VPP binary API enum 'log_level'.
  35 type LogLevel uint32
  36
  37 const (
  38         VPE_API_LOG_LEVEL_EMERG    LogLevel = 0
  39         VPE_API_LOG_LEVEL_ALERT    LogLevel = 1
  40         VPE_API_LOG_LEVEL_CRIT     LogLevel = 2
  41         VPE_API_LOG_LEVEL_ERR      LogLevel = 3
  42         VPE_API_LOG_LEVEL_WARNING  LogLevel = 4
  43         VPE_API_LOG_LEVEL_NOTICE   LogLevel = 5
  44         VPE_API_LOG_LEVEL_INFO     LogLevel = 6
  45         VPE_API_LOG_LEVEL_DEBUG    LogLevel = 7
  46         VPE_API_LOG_LEVEL_DISABLED LogLevel = 8
  47 )
  48
  49 var LogLevel_name = map[uint32]string{
  50         0: "VPE_API_LOG_LEVEL_EMERG",
  51         1: "VPE_API_LOG_LEVEL_ALERT",
  52         2: "VPE_API_LOG_LEVEL_CRIT",
  53         3: "VPE_API_LOG_LEVEL_ERR",
  54         4: "VPE_API_LOG_LEVEL_WARNING",
  55         5: "VPE_API_LOG_LEVEL_NOTICE",
  56         6: "VPE_API_LOG_LEVEL_INFO",
  57         7: "VPE_API_LOG_LEVEL_DEBUG",
  58         8: "VPE_API_LOG_LEVEL_DISABLED",
  59 }
  60
  61 var LogLevel_value = map[string]uint32{
  62         "VPE_API_LOG_LEVEL_EMERG":    0,
  63         "VPE_API_LOG_LEVEL_ALERT":    1,
  64         "VPE_API_LOG_LEVEL_CRIT":     2,
  65         "VPE_API_LOG_LEVEL_ERR":      3,
  66         "VPE_API_LOG_LEVEL_WARNING":  4,
  67         "VPE_API_LOG_LEVEL_NOTICE":   5,
  68         "VPE_API_LOG_LEVEL_INFO":     6,
  69         "VPE_API_LOG_LEVEL_DEBUG":    7,
  70         "VPE_API_LOG_LEVEL_DISABLED": 8,
  71 }
  72
  73 func (x LogLevel) String() string {
  74         s, ok := LogLevel_name[uint32(x)]
  75         if ok {
  76                 return s
  77         }
  78         return strconv.Itoa(int(x))
  79 }
  80
  81 // Timedelta represents VPP binary API alias 'timedelta'.
  82 type Timedelta float64
  83
  84 // Timestamp represents VPP binary API alias 'timestamp'.
  85 type Timestamp float64
  86
  87 // ThreadData represents VPP binary API type 'thread_data'.
  88 type ThreadData struct {
  89         ID        uint32
  90         Name      []byte `struc:"[64]byte"`
  91         Type      []byte `struc:"[64]byte"`
  92         PID       uint32
  93         CPUID     uint32
  94         Core      uint32
  95         CPUSocket uint32
  96 }
  97
  98 func (*ThreadData) GetTypeName() string {
  99         return "thread_data"
 100 }
 101
 102 // Version represents VPP binary API type 'version'.
 103 type Version struct {
 104         Major         uint32
 105         Minor         uint32
 106         Patch         uint32
 107         PreRelease    []byte `struc:"[17]byte"`
 108         BuildMetadata []byte `struc:"[17]byte"`
 109 }
 110
 111 func (*Version) GetTypeName() string {
 112         return "version"
 113 }
 114
 115 // AddNodeNext represents VPP binary API message 'add_node_next'.
 116 type AddNodeNext struct {
 117         NodeName []byte `struc:"[64]byte"`
 118         NextName []byte `struc:"[64]byte"`
 119 }
 120
 121 func (*AddNodeNext) GetMessageName() string {
 122         return "add_node_next"
 123 }
 124 func (*AddNodeNext) GetCrcString() string {
 125         return "9ab92f7a"
 126 }
 127 func (*AddNodeNext) GetMessageType() api.MessageType {
 128         return api.RequestMessage
 129 }
 130
 131 // AddNodeNextReply represents VPP binary API message 'add_node_next_reply'.
 132 type AddNodeNextReply struct {
 133         Retval    int32
 134         NextIndex uint32
 135 }
 136
 137 func (*AddNodeNextReply) GetMessageName() string {
 138         return "add_node_next_reply"
 139 }
 140 func (*AddNodeNextReply) GetCrcString() string {
 141         return "2ed75f32"
 142 }
 143 func (*AddNodeNextReply) GetMessageType() api.MessageType {
 144         return api.ReplyMessage
 145 }
 146
 147 // Cli represents VPP binary API message 'cli'.
 148 type Cli struct {
 149         CmdInShmem uint64
 150 }
 151
 152 func (*Cli) GetMessageName() string {
 153         return "cli"
 154 }
 155 func (*Cli) GetCrcString() string {
 156         return "23bfbfff"
 157 }
 158 func (*Cli) GetMessageType() api.MessageType {
 159         return api.RequestMessage
 160 }
 161
 162 // CliInband represents VPP binary API message 'cli_inband'.
 163 type CliInband struct {
 164         XXX_CmdLen uint32 `struc:"sizeof=Cmd"`
 165         Cmd        string
 166 }
 167
 168 func (*CliInband) GetMessageName() string {
 169         return "cli_inband"
 170 }
 171 func (*CliInband) GetCrcString() string {
 172         return "b1ad59b3"
 173 }
 174 func (*CliInband) GetMessageType() api.MessageType {
 175         return api.RequestMessage
 176 }
 177
 178 // CliInbandReply represents VPP binary API message 'cli_inband_reply'.
 179 type CliInbandReply struct {
 180         Retval       int32
 181         XXX_ReplyLen uint32 `struc:"sizeof=Reply"`
 182         Reply        string
 183 }
 184
 185 func (*CliInbandReply) GetMessageName() string {
 186         return "cli_inband_reply"
 187 }
 188 func (*CliInbandReply) GetCrcString() string {
 189         return "6d3c80a4"
 190 }
 191 func (*CliInbandReply) GetMessageType() api.MessageType {
 192         return api.ReplyMessage
 193 }
 194
 195 // CliReply represents VPP binary API message 'cli_reply'.
 196 type CliReply struct {
 197         Retval       int32
 198         ReplyInShmem uint64
 199 }
 200
 201 func (*CliReply) GetMessageName() string {
 202         return "cli_reply"
 203 }
 204 func (*CliReply) GetCrcString() string {
 205         return "06d68297"
 206 }
 207 func (*CliReply) GetMessageType() api.MessageType {
 208         return api.ReplyMessage
 209 }
 210
 211 // ControlPing represents VPP binary API message 'control_ping'.
 212 type ControlPing struct{}
 213
 214 func (*ControlPing) GetMessageName() string {
 215         return "control_ping"
 216 }
 217 func (*ControlPing) GetCrcString() string {
 218         return "51077d14"
 219 }
 220 func (*ControlPing) GetMessageType() api.MessageType {
 221         return api.RequestMessage
 222 }
 223
 224 // ControlPingReply represents VPP binary API message 'control_ping_reply'.
 225 type ControlPingReply struct {
 226         Retval      int32
 227         ClientIndex uint32
 228         VpePID      uint32
 229 }
 230
 231 func (*ControlPingReply) GetMessageName() string {
 232         return "control_ping_reply"
 233 }
 234 func (*ControlPingReply) GetCrcString() string {
 235         return "f6b0b8ca"
 236 }
 237 func (*ControlPingReply) GetMessageType() api.MessageType {
 238         return api.ReplyMessage
 239 }
 240
 241 // GetF64EndianValue represents VPP binary API message 'get_f64_endian_value'.
 242 type GetF64EndianValue struct {
 243         F64One float64
 244 }
 245
 246 func (*GetF64EndianValue) GetMessageName() string {
 247         return "get_f64_endian_value"
 248 }
 249 func (*GetF64EndianValue) GetCrcString() string {
 250         return "809fcd44"
 251 }
 252 func (*GetF64EndianValue) GetMessageType() api.MessageType {
 253         return api.RequestMessage
 254 }
 255
 256 // GetF64EndianValueReply represents VPP binary API message 'get_f64_endian_value_reply'.
 257 type GetF64EndianValueReply struct {
 258         Retval       uint32
 259         F64OneResult float64
 260 }
 261
 262 func (*GetF64EndianValueReply) GetMessageName() string {
 263         return "get_f64_endian_value_reply"
 264 }
 265 func (*GetF64EndianValueReply) GetCrcString() string {
 266         return "7e02e404"
 267 }
 268 func (*GetF64EndianValueReply) GetMessageType() api.MessageType {
 269         return api.ReplyMessage
 270 }
 271
 272 // GetF64IncrementByOne represents VPP binary API message 'get_f64_increment_by_one'.
 273 type GetF64IncrementByOne struct {
 274         F64Value float64
 275 }
 276
 277 func (*GetF64IncrementByOne) GetMessageName() string {
 278         return "get_f64_increment_by_one"
 279 }
 280 func (*GetF64IncrementByOne) GetCrcString() string {
 281         return "b64f027e"
 282 }
 283 func (*GetF64IncrementByOne) GetMessageType() api.MessageType {
 284         return api.RequestMessage
 285 }
 286
 287 // GetF64IncrementByOneReply represents VPP binary API message 'get_f64_increment_by_one_reply'.
 288 type GetF64IncrementByOneReply struct {
 289         Retval   uint32
 290         F64Value float64
 291 }
 292
 293 func (*GetF64IncrementByOneReply) GetMessageName() string {
 294         return "get_f64_increment_by_one_reply"
 295 }
 296 func (*GetF64IncrementByOneReply) GetCrcString() string {
 297         return "d25dbaa3"
 298 }
 299 func (*GetF64IncrementByOneReply) GetMessageType() api.MessageType {
 300         return api.ReplyMessage
 301 }
 302
 303 // GetNextIndex represents VPP binary API message 'get_next_index'.
 304 type GetNextIndex struct {
 305         NodeName []byte `struc:"[64]byte"`
 306         NextName []byte `struc:"[64]byte"`
 307 }
 308
 309 func (*GetNextIndex) GetMessageName() string {
 310         return "get_next_index"
 311 }
 312 func (*GetNextIndex) GetCrcString() string {
 313         return "9ab92f7a"
 314 }
 315 func (*GetNextIndex) GetMessageType() api.MessageType {
 316         return api.RequestMessage
 317 }
 318
 319 // GetNextIndexReply represents VPP binary API message 'get_next_index_reply'.
 320 type GetNextIndexReply struct {
 321         Retval    int32
 322         NextIndex uint32
 323 }
 324
 325 func (*GetNextIndexReply) GetMessageName() string {
 326         return "get_next_index_reply"
 327 }
 328 func (*GetNextIndexReply) GetCrcString() string {
 329         return "2ed75f32"
 330 }
 331 func (*GetNextIndexReply) GetMessageType() api.MessageType {
 332         return api.ReplyMessage
 333 }
 334
 335 // GetNodeGraph represents VPP binary API message 'get_node_graph'.
 336 type GetNodeGraph struct{}
 337
 338 func (*GetNodeGraph) GetMessageName() string {
 339         return "get_node_graph"
 340 }
 341 func (*GetNodeGraph) GetCrcString() string {
 342         return "51077d14"
 343 }
 344 func (*GetNodeGraph) GetMessageType() api.MessageType {
 345         return api.RequestMessage
 346 }
 347
 348 // GetNodeGraphReply represents VPP binary API message 'get_node_graph_reply'.
 349 type GetNodeGraphReply struct {
 350         Retval       int32
 351         ReplyInShmem uint64
 352 }
 353
 354 func (*GetNodeGraphReply) GetMessageName() string {
 355         return "get_node_graph_reply"
 356 }
 357 func (*GetNodeGraphReply) GetCrcString() string {
 358         return "06d68297"
 359 }
 360 func (*GetNodeGraphReply) GetMessageType() api.MessageType {
 361         return api.ReplyMessage
 362 }
 363
 364 // GetNodeIndex represents VPP binary API message 'get_node_index'.
 365 type GetNodeIndex struct {
 366         NodeName []byte `struc:"[64]byte"`
 367 }
 368
 369 func (*GetNodeIndex) GetMessageName() string {
 370         return "get_node_index"
 371 }
 372 func (*GetNodeIndex) GetCrcString() string {
 373         return "6c9a495d"
 374 }
 375 func (*GetNodeIndex) GetMessageType() api.MessageType {
 376         return api.RequestMessage
 377 }
 378
 379 // GetNodeIndexReply represents VPP binary API message 'get_node_index_reply'.
 380 type GetNodeIndexReply struct {
 381         Retval    int32
 382         NodeIndex uint32
 383 }
 384
 385 func (*GetNodeIndexReply) GetMessageName() string {
 386         return "get_node_index_reply"
 387 }
 388 func (*GetNodeIndexReply) GetCrcString() string {
 389         return "a8600b89"
 390 }
 391 func (*GetNodeIndexReply) GetMessageType() api.MessageType {
 392         return api.ReplyMessage
 393 }
 394
 395 // LogDetails represents VPP binary API message 'log_details'.
 396 type LogDetails struct {
 397         Timestamp       Timestamp
 398         Level           LogLevel
 399         XXX_MsgClassLen uint32 `struc:"sizeof=MsgClass"`
 400         MsgClass        string `binapi:",limit=32"`
 401         XXX_MessageLen  uint32 `struc:"sizeof=Message"`
 402         Message         string `binapi:",limit=256"`
 403 }
 404
 405 func (*LogDetails) GetMessageName() string {
 406         return "log_details"
 407 }
 408 func (*LogDetails) GetCrcString() string {
 409         return "4aea1f4d"
 410 }
 411 func (*LogDetails) GetMessageType() api.MessageType {
 412         return api.ReplyMessage
 413 }
 414
 415 // LogDump represents VPP binary API message 'log_dump'.
 416 type LogDump struct {
 417         StartTimestamp Timestamp
 418 }
 419
 420 func (*LogDump) GetMessageName() string {
 421         return "log_dump"
 422 }
 423 func (*LogDump) GetCrcString() string {
 424         return "e4a022b6"
 425 }
 426 func (*LogDump) GetMessageType() api.MessageType {
 427         return api.RequestMessage
 428 }
 429
 430 // ShowThreads represents VPP binary API message 'show_threads'.
 431 type ShowThreads struct{}
 432
 433 func (*ShowThreads) GetMessageName() string {
 434         return "show_threads"
 435 }
 436 func (*ShowThreads) GetCrcString() string {
 437         return "51077d14"
 438 }
 439 func (*ShowThreads) GetMessageType() api.MessageType {
 440         return api.RequestMessage
 441 }
 442
 443 // ShowThreadsReply represents VPP binary API message 'show_threads_reply'.
 444 type ShowThreadsReply struct {
 445         Retval     int32
 446         Count      uint32 `struc:"sizeof=ThreadData"`
 447         ThreadData []ThreadData
 448 }
 449
 450 func (*ShowThreadsReply) GetMessageName() string {
 451         return "show_threads_reply"
 452 }
 453 func (*ShowThreadsReply) GetCrcString() string {
 454         return "f5e0b66f"
 455 }
 456 func (*ShowThreadsReply) GetMessageType() api.MessageType {
 457         return api.ReplyMessage
 458 }
 459
 460 // ShowVersion represents VPP binary API message 'show_version'.
 461 type ShowVersion struct{}
 462
 463 func (*ShowVersion) GetMessageName() string {
 464         return "show_version"
 465 }
 466 func (*ShowVersion) GetCrcString() string {
 467         return "51077d14"
 468 }
 469 func (*ShowVersion) GetMessageType() api.MessageType {
 470         return api.RequestMessage
 471 }
 472
 473 // ShowVersionReply represents VPP binary API message 'show_version_reply'.
 474 type ShowVersionReply struct {
 475         Retval                int32
 476         XXX_ProgramLen        uint32 `struc:"sizeof=Program"`
 477         Program               string `binapi:",limit=32"`
 478         XXX_VersionLen        uint32 `struc:"sizeof=Version"`
 479         Version               string `binapi:",limit=32"`
 480         XXX_BuildDateLen      uint32 `struc:"sizeof=BuildDate"`
 481         BuildDate             string `binapi:",limit=32"`
 482         XXX_BuildDirectoryLen uint32 `struc:"sizeof=BuildDirectory"`
 483         BuildDirectory        string `binapi:",limit=256"`
 484 }
 485
 486 func (*ShowVersionReply) GetMessageName() string {
 487         return "show_version_reply"
 488 }
 489 func (*ShowVersionReply) GetCrcString() string {
 490         return "b9bcf6df"
 491 }
 492 func (*ShowVersionReply) GetMessageType() api.MessageType {
 493         return api.ReplyMessage
 494 }
 495
 496 // ShowVpeSystemTime represents VPP binary API message 'show_vpe_system_time'.
 497 type ShowVpeSystemTime struct{}
 498
 499 func (*ShowVpeSystemTime) GetMessageName() string {
 500         return "show_vpe_system_time"
 501 }
 502 func (*ShowVpeSystemTime) GetCrcString() string {
 503         return "51077d14"
 504 }
 505 func (*ShowVpeSystemTime) GetMessageType() api.MessageType {
 506         return api.RequestMessage
 507 }
 508
 509 // ShowVpeSystemTimeReply represents VPP binary API message 'show_vpe_system_time_reply'.
 510 type ShowVpeSystemTimeReply struct {
 511         Retval        int32
 512         VpeSystemTime Timestamp
 513 }
 514
 515 func (*ShowVpeSystemTimeReply) GetMessageName() string {
 516         return "show_vpe_system_time_reply"
 517 }
 518 func (*ShowVpeSystemTimeReply) GetCrcString() string {
 519         return "3b12fb3f"
 520 }
 521 func (*ShowVpeSystemTimeReply) GetMessageType() api.MessageType {
 522         return api.ReplyMessage
 523 }
 524
 525 func init() {
 526         api.RegisterMessage((*AddNodeNext)(nil), "vpe.AddNodeNext")
 527         api.RegisterMessage((*AddNodeNextReply)(nil), "vpe.AddNodeNextReply")
 528         api.RegisterMessage((*Cli)(nil), "vpe.Cli")
 529         api.RegisterMessage((*CliInband)(nil), "vpe.CliInband")
 530         api.RegisterMessage((*CliInbandReply)(nil), "vpe.CliInbandReply")
 531         api.RegisterMessage((*CliReply)(nil), "vpe.CliReply")
 532         api.RegisterMessage((*ControlPing)(nil), "vpe.ControlPing")
 533         api.RegisterMessage((*ControlPingReply)(nil), "vpe.ControlPingReply")
 534         api.RegisterMessage((*GetF64EndianValue)(nil), "vpe.GetF64EndianValue")
 535         api.RegisterMessage((*GetF64EndianValueReply)(nil), "vpe.GetF64EndianValueReply")
 536         api.RegisterMessage((*GetF64IncrementByOne)(nil), "vpe.GetF64IncrementByOne")
 537         api.RegisterMessage((*GetF64IncrementByOneReply)(nil), "vpe.GetF64IncrementByOneReply")
 538         api.RegisterMessage((*GetNextIndex)(nil), "vpe.GetNextIndex")
 539         api.RegisterMessage((*GetNextIndexReply)(nil), "vpe.GetNextIndexReply")
 540         api.RegisterMessage((*GetNodeGraph)(nil), "vpe.GetNodeGraph")
 541         api.RegisterMessage((*GetNodeGraphReply)(nil), "vpe.GetNodeGraphReply")
 542         api.RegisterMessage((*GetNodeIndex)(nil), "vpe.GetNodeIndex")
 543         api.RegisterMessage((*GetNodeIndexReply)(nil), "vpe.GetNodeIndexReply")
 544         api.RegisterMessage((*LogDetails)(nil), "vpe.LogDetails")
 545         api.RegisterMessage((*LogDump)(nil), "vpe.LogDump")
 546         api.RegisterMessage((*ShowThreads)(nil), "vpe.ShowThreads")
 547         api.RegisterMessage((*ShowThreadsReply)(nil), "vpe.ShowThreadsReply")
 548         api.RegisterMessage((*ShowVersion)(nil), "vpe.ShowVersion")
 549         api.RegisterMessage((*ShowVersionReply)(nil), "vpe.ShowVersionReply")
 550         api.RegisterMessage((*ShowVpeSystemTime)(nil), "vpe.ShowVpeSystemTime")
 551         api.RegisterMessage((*ShowVpeSystemTimeReply)(nil), "vpe.ShowVpeSystemTimeReply")
 552 }
 553
 554 // Messages returns list of all messages in this module.
 555 func AllMessages() []api.Message {
 556         return []api.Message{
 557                 (*AddNodeNext)(nil),
 558                 (*AddNodeNextReply)(nil),
 559                 (*Cli)(nil),
 560                 (*CliInband)(nil),
 561                 (*CliInbandReply)(nil),
 562                 (*CliReply)(nil),
 563                 (*ControlPing)(nil),
 564                 (*ControlPingReply)(nil),
 565                 (*GetF64EndianValue)(nil),
 566                 (*GetF64EndianValueReply)(nil),
 567                 (*GetF64IncrementByOne)(nil),
 568                 (*GetF64IncrementByOneReply)(nil),
 569                 (*GetNextIndex)(nil),
 570                 (*GetNextIndexReply)(nil),
 571                 (*GetNodeGraph)(nil),
 572                 (*GetNodeGraphReply)(nil),
 573                 (*GetNodeIndex)(nil),
 574                 (*GetNodeIndexReply)(nil),
 575                 (*LogDetails)(nil),
 576                 (*LogDump)(nil),
 577                 (*ShowThreads)(nil),
 578                 (*ShowThreadsReply)(nil),
 579                 (*ShowVersion)(nil),
 580                 (*ShowVersionReply)(nil),
 581                 (*ShowVpeSystemTime)(nil),
 582                 (*ShowVpeSystemTimeReply)(nil),
 583         }
 584 }
 585
 586 // RPCService represents RPC service API for vpe module.
 587 type RPCService interface {
 588         DumpLog(ctx context.Context, in *LogDump) (RPCService_DumpLogClient, error)
 589         AddNodeNext(ctx context.Context, in *AddNodeNext) (*AddNodeNextReply, error)
 590         Cli(ctx context.Context, in *Cli) (*CliReply, error)
 591         CliInband(ctx context.Context, in *CliInband) (*CliInbandReply, error)
 592         ControlPing(ctx context.Context, in *ControlPing) (*ControlPingReply, error)
 593         GetF64EndianValue(ctx context.Context, in *GetF64EndianValue) (*GetF64EndianValueReply, error)
 594         GetF64IncrementByOne(ctx context.Context, in *GetF64IncrementByOne) (*GetF64IncrementByOneReply, error)
 595         GetNextIndex(ctx context.Context, in *GetNextIndex) (*GetNextIndexReply, error)
 596         GetNodeGraph(ctx context.Context, in *GetNodeGraph) (*GetNodeGraphReply, error)
 597         GetNodeIndex(ctx context.Context, in *GetNodeIndex) (*GetNodeIndexReply, error)
 598         ShowThreads(ctx context.Context, in *ShowThreads) (*ShowThreadsReply, error)
 599         ShowVersion(ctx context.Context, in *ShowVersion) (*ShowVersionReply, error)
 600         ShowVpeSystemTime(ctx context.Context, in *ShowVpeSystemTime) (*ShowVpeSystemTimeReply, error)
 601 }
 602
 603 type serviceClient struct {
 604         ch api.Channel
 605 }
 606
 607 func NewServiceClient(ch api.Channel) RPCService {
 608         return &serviceClient{ch}
 609 }
 610
 611 func (c *serviceClient) DumpLog(ctx context.Context, in *LogDump) (RPCService_DumpLogClient, error) {
 612         stream := c.ch.SendMultiRequest(in)
 613         x := &serviceClient_DumpLogClient{stream}
 614         return x, nil
 615 }
 616
 617 type RPCService_DumpLogClient interface {
 618         Recv() (*LogDetails, error)
 619 }
 620
 621 type serviceClient_DumpLogClient struct {
 622         api.MultiRequestCtx
 623 }
 624
 625 func (c *serviceClient_DumpLogClient) Recv() (*LogDetails, error) {
 626         m := new(LogDetails)
 627         stop, err := c.MultiRequestCtx.ReceiveReply(m)
 628         if err != nil {
 629                 return nil, err
 630         }
 631         if stop {
 632                 return nil, io.EOF
 633         }
 634         return m, nil
 635 }
 636
 637 func (c *serviceClient) AddNodeNext(ctx context.Context, in *AddNodeNext) (*AddNodeNextReply, error) {
 638         out := new(AddNodeNextReply)
 639         err := c.ch.SendRequest(in).ReceiveReply(out)
 640         if err != nil {
 641                 return nil, err
 642         }
 643         return out, nil
 644 }
 645
 646 func (c *serviceClient) Cli(ctx context.Context, in *Cli) (*CliReply, error) {
 647         out := new(CliReply)
 648         err := c.ch.SendRequest(in).ReceiveReply(out)
 649         if err != nil {
 650                 return nil, err
 651         }
 652         return out, nil
 653 }
 654
 655 func (c *serviceClient) CliInband(ctx context.Context, in *CliInband) (*CliInbandReply, error) {
 656         out := new(CliInbandReply)
 657         err := c.ch.SendRequest(in).ReceiveReply(out)
 658         if err != nil {
 659                 return nil, err
 660         }
 661         return out, nil
 662 }
 663
 664 func (c *serviceClient) ControlPing(ctx context.Context, in *ControlPing) (*ControlPingReply, error) {
 665         out := new(ControlPingReply)
 666         err := c.ch.SendRequest(in).ReceiveReply(out)
 667         if err != nil {
 668                 return nil, err
 669         }
 670         return out, nil
 671 }
 672
 673 func (c *serviceClient) GetF64EndianValue(ctx context.Context, in *GetF64EndianValue) (*GetF64EndianValueReply, error) {
 674         out := new(GetF64EndianValueReply)
 675         err := c.ch.SendRequest(in).ReceiveReply(out)
 676         if err != nil {
 677                 return nil, err
 678         }
 679         return out, nil
 680 }
 681
 682 func (c *serviceClient) GetF64IncrementByOne(ctx context.Context, in *GetF64IncrementByOne) (*GetF64IncrementByOneReply, error) {
 683         out := new(GetF64IncrementByOneReply)
 684         err := c.ch.SendRequest(in).ReceiveReply(out)
 685         if err != nil {
 686                 return nil, err
 687         }
 688         return out, nil
 689 }
 690
 691 func (c *serviceClient) GetNextIndex(ctx context.Context, in *GetNextIndex) (*GetNextIndexReply, error) {
 692         out := new(GetNextIndexReply)
 693         err := c.ch.SendRequest(in).ReceiveReply(out)
 694         if err != nil {
 695                 return nil, err
 696         }
 697         return out, nil
 698 }
 699
 700 func (c *serviceClient) GetNodeGraph(ctx context.Context, in *GetNodeGraph) (*GetNodeGraphReply, error) {
 701         out := new(GetNodeGraphReply)
 702         err := c.ch.SendRequest(in).ReceiveReply(out)
 703         if err != nil {
 704                 return nil, err
 705         }
 706         return out, nil
 707 }
 708
 709 func (c *serviceClient) GetNodeIndex(ctx context.Context, in *GetNodeIndex) (*GetNodeIndexReply, error) {
 710         out := new(GetNodeIndexReply)
 711         err := c.ch.SendRequest(in).ReceiveReply(out)
 712         if err != nil {
 713                 return nil, err
 714         }
 715         return out, nil
 716 }
 717
 718 func (c *serviceClient) ShowThreads(ctx context.Context, in *ShowThreads) (*ShowThreadsReply, error) {
 719         out := new(ShowThreadsReply)
 720         err := c.ch.SendRequest(in).ReceiveReply(out)
 721         if err != nil {
 722                 return nil, err
 723         }
 724         return out, nil
 725 }
 726
 727 func (c *serviceClient) ShowVersion(ctx context.Context, in *ShowVersion) (*ShowVersionReply, error) {
 728         out := new(ShowVersionReply)
 729         err := c.ch.SendRequest(in).ReceiveReply(out)
 730         if err != nil {
 731                 return nil, err
 732         }
 733         return out, nil
 734 }
 735
 736 func (c *serviceClient) ShowVpeSystemTime(ctx context.Context, in *ShowVpeSystemTime) (*ShowVpeSystemTimeReply, error) {
 737         out := new(ShowVpeSystemTimeReply)
 738         err := c.ch.SendRequest(in).ReceiveReply(out)
 739         if err != nil {
 740                 return nil, err
 741         }
 742         return out, nil
 743 }
 744
 745 // This is a compile-time assertion to ensure that this generated file
 746 // is compatible with the GoVPP api package it is being compiled against.
 747 // A compilation error at this line likely means your copy of the
 748 // GoVPP api package needs to be updated.
 749 const _ = api.GoVppAPIPackageIsVersion1 // please upgrade the GoVPP api package
 750
 751 // Reference imports to suppress errors if they are not otherwise used.
 752 var _ = api.RegisterMessage
 753 var _ = bytes.NewBuffer
 754 var _ = context.Background
 755 var _ = io.Copy
 756 var _ = strconv.Itoa
 757 var _ = struc.Pack