api

type BufferPool struct {
	PoolName string

	Cached    float64
	Used      float64
	Available float64
}

type BufferStats struct {
	Buffer map[string]BufferPool
}

type Channel interface {
	// SendRequest asynchronously sends a request to VPP. Returns a request context, that can be used to call ReceiveReply.
	// In case of any errors by sending, the error will be delivered to ReplyChan (and returned by ReceiveReply).
	SendRequest(msg Message) RequestCtx

	// SendMultiRequest asynchronously sends a multipart request (request to which multiple responses are expected) to VPP.
	// Returns a multipart request context, that can be used to call ReceiveReply.
	// In case of any errors by sending, the error will be delivered to ReplyChan (and returned by ReceiveReply).
	SendMultiRequest(msg Message) MultiRequestCtx

	// SubscribeNotification subscribes for receiving of the specified notification messages via provided Go channel.
	// Note that the caller is responsible for creating the Go channel with preferred buffer size. If the channel's
	// buffer is full, the notifications will not be delivered into it.
	SubscribeNotification(notifChan chan Message, event Message) (SubscriptionCtx, error)

	// SetReplyTimeout sets the timeout for replies from VPP. It represents the maximum time the client waits for a reply
	// from VPP before returning a timeout error. Setting the reply timeout to 0 disables it. The initial reply timeout is
	//set to the value of core.DefaultReplyTimeout.
	SetReplyTimeout(timeout time.Duration)

	// CheckCompatibility checks the compatiblity for the given messages.
	// It will return an error if any of the given messages are not compatible.
	CheckCompatiblity(msgs ...Message) error

	// Close closes the API channel and releases all API channel-related resources
	// in the ChannelProvider.
	Close()
}

type ChannelProvider interface {
	// NewAPIChannel returns a new channel for communication with VPP via govpp core.
	// It uses default buffer sizes for the request and reply Go channels.
	NewAPIChannel() (Channel, error)

	// NewAPIChannelBuffered returns a new channel for communication with VPP via govpp core.
	// It allows to specify custom buffer sizes for the request and reply Go channels.
	NewAPIChannelBuffered(reqChanBufSize, replyChanBufSize int) (Channel, error)
}

type CompatibilityError struct {
	CompatibleMessages   []string
	IncompatibleMessages []string
}

type Connection interface {
	// NewStream creates a new stream for sending and receiving messages.
	// Context can be used to close the stream using cancel or timeout.
	NewStream(ctx context.Context, options ...StreamOption) (Stream, error)

	// Invoke can be used for a simple request-reply RPC.
	// It creates stream and calls SendMsg with req and RecvMsg which returns
	// reply.
	Invoke(ctx context.Context, req Message, reply Message) error

	// WatchEvent creates a new watcher for watching events of type specified by
	// event parameter. Context can be used to close the watcher.
	WatchEvent(ctx context.Context, event Message) (Watcher, error)
}

type DataType interface {
	// GetTypeName returns the original VPP name of the data type, as defined in the VPP API.
	GetTypeName() string
}

type ErrorCounter struct {
	CounterName string

	Values []uint64
}

type ErrorStats struct {
	Errors []ErrorCounter
}

type InterfaceCounterCombined struct {
	Packets uint64
	Bytes   uint64
}

type InterfaceCounters struct {
	InterfaceIndex uint32
	InterfaceName  string // requires VPP 19.04+

	Rx InterfaceCounterCombined
	Tx InterfaceCounterCombined

	RxErrors uint64
	TxErrors uint64

	RxUnicast   InterfaceCounterCombined
	RxMulticast InterfaceCounterCombined
	RxBroadcast InterfaceCounterCombined
	TxUnicast   InterfaceCounterCombined
	TxMulticast InterfaceCounterCombined
	TxBroadcast InterfaceCounterCombined

	Drops   uint64
	Punts   uint64
	IP4     uint64
	IP6     uint64
	RxNoBuf uint64
	RxMiss  uint64
	Mpls    uint64
}

type InterfaceStats struct {
	Interfaces []InterfaceCounters
}

type MemoryCounters struct {
	Total      uint64
	Used       uint64
	Free       uint64
	UsedMMap   uint64
	TotalAlloc uint64
	FreeChunks uint64
	Releasable uint64
}

type MemoryStats struct {
	// Deprecated: /mem/statseg total memory directory
	Total float64
	// Deprecated: /mem/statseg used memory directory
	Used float64

	// stat/main memory usage per-heap
	Stat map[int]MemoryCounters
	Main map[int]MemoryCounters
}

type Message interface {
	// GetMessageName returns the original VPP name of the message, as defined in the VPP API.
	GetMessageName() string

	// GetCrcString returns the string with CRC checksum of the message definition (the string represents a hexadecimal number).
	GetCrcString() string

	// GetMessageType returns the type of the VPP message.
	GetMessageType() MessageType
}

type MessageType int

type MultiRequestCtx interface {
	// ReceiveReply receives a reply from VPP (blocks until a reply is delivered
	// from VPP, or until an error occurs).The reply will be decoded into the msg
	// argument. If the last reply has been already consumed, lastReplyReceived is
	// set to true. Do not use the message itself if lastReplyReceived is
	// true - it won't be filled with actual data.Error will be returned if the
	// response cannot be received or decoded.
	ReceiveReply(msg Message) (lastReplyReceived bool, err error)
}

type NodeCounters struct {
	NodeIndex uint32
	NodeName  string // requires VPP 19.04+

	Clocks   uint64
	Vectors  uint64
	Calls    uint64
	Suspends uint64
}

type NodeStats struct {
	Nodes []NodeCounters
}

type Record struct {
	Message    Message
	Timestamp  time.Time
	IsReceived bool
	ChannelID  uint16
	Succeeded  bool
}

type RequestCtx interface {
	// ReceiveReply receives a reply from VPP (blocks until a reply is delivered
	// from VPP, or until an error occurs). The reply will be decoded into the msg
	// argument. Error will be returned if the response cannot be received or decoded.
	ReceiveReply(msg Message) error
}

type StatsProvider interface {
	GetSystemStats(*SystemStats) error
	GetNodeStats(*NodeStats) error
	GetInterfaceStats(*InterfaceStats) error
	GetErrorStats(*ErrorStats) error
	GetBufferStats(*BufferStats) error
	GetMemoryStats(*MemoryStats) error
}

type Stream interface {
	// Context returns the context for this stream.
	Context() context.Context

	// SendMsg sends a message to the client.
	// It blocks until message is sent to the transport.
	SendMsg(Message) error

	// RecvMsg blocks until a message is received or error occurs.
	RecvMsg() (Message, error)

	// Close closes the stream. Calling SendMsg and RecvMsg will return error
	// after closing stream.
	Close() error
}

type StreamOption func(Stream)

type SubscriptionCtx interface {
	// Unsubscribe unsubscribes from receiving the notifications tied to the
	// subscription context.
	Unsubscribe() error
}

type SystemStats struct {
	VectorRate          uint64
	NumWorkerThreads    uint64
	VectorRatePerWorker []uint64
	InputRate           uint64
	LastUpdate          uint64
	LastStatsClear      uint64
	Heartbeat           uint64
}

type Trace interface {
	// GetRecords returns all API messages from all channels captured since the trace
	// was initialized or cleared up to the point of the call.
	GetRecords() []*Record

	// GetRecordsForChannel returns all API messages recorded by the given channel.
	GetRecordsForChannel(chId uint16) []*Record

	// Clear erases messages captured so far.
	Clear()

	// Close the tracer and release associated resources
	Close()
}

type VPPApiError int32

type Watcher interface {
	// Events returns a channel where events are sent. The channel is closed when
	// watcher context is canceled or when Close is called.
	Events() <-chan Message

	// Close closes the watcher along with the events channel.
	Close()
}