Pim van Pelt
4347bb9b05
This session covers three distinct arcs: correctness bug fixes in the
VPP sync path and frontend reducers, new config validation, and a
large polish pass on the web frontend (tighter layout, backend kebab
dialogs, live grouped-table, live config-reload re-sync).
- encap for a VIP is now derived from the backend address family,
not the VIP's. A v6 VIP with v4 backends is programmed as IP6_GRE4
(not the buggy IP6_GRE6), matching the VPP LB plugin's
requirement that encap reflects the tunnel inner family. desiredVIP
gained an Encap field populated in desiredFromFrontend.
- ActivePoolIndex now requires at least one backend in a pool to be
BOTH in StateUp AND pb.Weight>0 before the pool counts as active.
Previously a primary pool with every backend manually zeroed would
still win over a fallback with weight=100, so fallback traffic
never materialized. New TestActivePoolIndexWeightedFailover table
pins the rule in five subcases.
- SyncLBStateVIP gained a flushAddress parameter threaded through
reconcileVIP; it forces flush=true on the setASWeight call for a
specific backend regardless of the usual 0→N heuristic. Wires up
the explicit [flush] knob the CLI exposes.
- convertFrontend already enforced that backends within one frontend
share a family. New cross-frontend pass validateVIPFamilyConsistency
rejects configs where two frontends share a VIP address but carry
backends in different families — VPP's LB plugin requires every
VIP on a prefix to have the same encap type, so such a config
would fail at lb_add_del_vip_v2 time with VNET_API_ERROR_INVALID
_ARGUMENT (-73). Catching it at config load turns a silent
runtime failure into a clear startup error.
- Two new TestValidationErrors cases pin the behavior: mismatched
families reject, same-family frontends on one VIP address allowed.
- Proto adds `bool flush = 5` to SetWeightRequest. The RPC now
drives a VIP sync immediately after mutating config (fixing the
latent "weight change only takes effect at the next 30s periodic
reconcile" gap), passing flushAddress = backend IP when req.Flush
is true.
- maglevc grows an optional [flush] token: `set frontend F pool P
backend B weight N [flush]`. Implementation uses two Run closures
(runSetFrontendPoolBackendWeight and -Flush) because the tree
walker only puts slot tokens in args — literal keywords like
`flush` advance the node but don't appear in the arg list.
- docs/user-guide.md updated with the [flush] optional and a
three-paragraph explainer of the graceful-drain vs. flush
semantics at the VPP level.
- checker.ListFrontends now sorts alphabetically to match the
existing sort in ListBackends / ListHealthChecks — RPC responses
no longer shuffle VIPs per call. cmd/frontend/client.go also
sorts defensively in refreshAll so an old maglevd build renders
alphabetically too.
- backendFromProto was returning out.Transitions[n-1] as the
LastTransition, but maglevd stores (and the proto carries)
transitions newest-first, so [n-1] was actually the oldest.
Reverse on read, which normalizes the client's Transitions slice
to oldest-first and makes [n-1] genuinely the newest. LastTransition
now points at the actual latest transition record.
- applyBackendTransition (Go and TS) derives Enabled = state!="disabled"
so the two fields stay in lockstep — closed a drift window where
a recently re-enabled backend still rendered with a stuck
[disabled] tag. The tag was later removed entirely since state
and enabled carry the same information.
- Layout tightened substantially: "FRONTENDS" panel header removed,
zippy-summary and zippy-body paddings cut, backend-table row
padding dropped to 2px, per-pool <h3> removed. Pools now live in
a single consolidated table per frontend with a dedicated "pool"
column that shows the pool name only on the first row of each
group — classic grouped-table layout, maximally dense.
- Description moved inline into the Zippy summary as muted italic
text, freeing a vertical line per frontend card.
- formatVIPAddress() helper renders IPv6 VIPs as [addr]:port and
IPv4 as addr:port, matching RFC 3986 authority syntax.
- Pools with effective_weight=0 on every backend (standby
fallbacks, fully-drained primaries) render at opacity 0.35 on
their non-actions cells; the kebab column stays at full contrast
because its menu is still fully functional on standby backends.
- Config-reload propagation: a maglevd config-reload-done log
event triggers triggerConfigResync() on the frontend side —
refreshAll() runs off the event-dispatch goroutine, then a
BrowserEvent{Type:"resync"} is published through the broker.
writeEvent emits type="resync" as a named SSE frame so the
SPA's existing addEventListener("resync") handler picks it up
and calls fetchAllState → replaceAll.
- recomputeEffectiveWeights in stores/state.ts mirrors the
server-side health.EffectiveWeights logic so the SPA keeps
pool.effective_weight correct the moment a backend transitions,
without waiting for the 30s refresh. Fixed a nasty bug where
applyBackendEffectiveWeight wrote VIP-scoped vpp-lb-sync-as-*
event weights into every frontend sharing the backend,
corrupting frontends with different per-pool configured weights.
The old log-event reducer was removed; applyConfiguredWeight is
the narrower replacement used by the kebab set-weight flow.
- applyBackendTransition calls recomputeEffectiveWeights after
state updates so pool-failover transitions (primary ⇌ fallback)
reflect instantly in the UI.
- Confirmation dialogs via a new Modal primitive
(Portal-mounted to document.body, escape/click-outside close,
click-outside debounced on mousedown so mid-row-text-selection
drags don't dismiss).
- pause/resume/enable/disable each show a Modal with a consequence
paragraph explaining what hits live traffic ("will keep existing
flows", "will flush VPP's flow table", etc.). The disable commit
button is styled btn-danger red.
- set-weight action shows a Modal with a range slider (0-100,
seeded from the current configured weight, accent-colored live
numeric readout via <output>) plus a flush checkbox and a live-
swapping note/warn paragraph describing what will happen. On
commit, the SPA also updates its local store via
applyConfiguredWeight so the operator sees the new weight
immediately without waiting for the next refresh.
- ProbeHeartbeat is now state-aware: ▶ (play) at rest for up/
down/unknown backends, ⏸ (pause) for paused, ⏹ (stop) for
disabled/removed, ❤️ (heart) during an in-flight probe.
- Drop the probe-done event listener — fast probes (<10ms)
could fire probe-done in the same render tick as probe-start
and the heart would never visibly paint. Each probe-start now
runs a fixed 400ms scale-pop animation on a timer; subsequent
probe-start events reset the timer, so fast cadences produce a
continuous heart pulse.
- Fixed wrapper box (16x14 px, overflow hidden) so the row
doesn't jiggle when the glyph swaps between the narrow ▶/⏸/⏹
text glyphs and the wider ❤️ emoji.
- Brand wordmark changed from "maglev" to "vpp-maglev" and wrapped
in an <a> linking to https://git.ipng.ch/ipng/vpp-maglev. Logo
link changed to https://ipng.ch/. Both open in a new tab with
rel="noopener".
- .gitignore fix: `frontend`, `maglevc`, `maglevd` were matching
ANY file or directory with those names anywhere in the tree,
silently ignoring cmd/frontend and friends. Anchored with
leading slashes so only repo-root build artifacts match.
2926 lines
89 KiB
Go
2926 lines
89 KiB
Go
// Code generated by protoc-gen-go. DO NOT EDIT.
|
|
// versions:
|
|
// protoc-gen-go v1.36.11
|
|
// protoc v3.21.12
|
|
// source: proto/maglev.proto
|
|
|
|
package grpcapi
|
|
|
|
import (
|
|
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
|
|
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
|
|
reflect "reflect"
|
|
sync "sync"
|
|
unsafe "unsafe"
|
|
)
|
|
|
|
const (
|
|
// Verify that this generated code is sufficiently up-to-date.
|
|
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
|
|
// Verify that runtime/protoimpl is sufficiently up-to-date.
|
|
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
|
|
)
|
|
|
|
type ListFrontendsRequest struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *ListFrontendsRequest) Reset() {
|
|
*x = ListFrontendsRequest{}
|
|
mi := &file_proto_maglev_proto_msgTypes[0]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *ListFrontendsRequest) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*ListFrontendsRequest) ProtoMessage() {}
|
|
|
|
func (x *ListFrontendsRequest) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[0]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use ListFrontendsRequest.ProtoReflect.Descriptor instead.
|
|
func (*ListFrontendsRequest) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{0}
|
|
}
|
|
|
|
type GetFrontendRequest struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *GetFrontendRequest) Reset() {
|
|
*x = GetFrontendRequest{}
|
|
mi := &file_proto_maglev_proto_msgTypes[1]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *GetFrontendRequest) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*GetFrontendRequest) ProtoMessage() {}
|
|
|
|
func (x *GetFrontendRequest) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[1]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use GetFrontendRequest.ProtoReflect.Descriptor instead.
|
|
func (*GetFrontendRequest) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{1}
|
|
}
|
|
|
|
func (x *GetFrontendRequest) GetName() string {
|
|
if x != nil {
|
|
return x.Name
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type ListBackendsRequest struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *ListBackendsRequest) Reset() {
|
|
*x = ListBackendsRequest{}
|
|
mi := &file_proto_maglev_proto_msgTypes[2]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *ListBackendsRequest) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*ListBackendsRequest) ProtoMessage() {}
|
|
|
|
func (x *ListBackendsRequest) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[2]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use ListBackendsRequest.ProtoReflect.Descriptor instead.
|
|
func (*ListBackendsRequest) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{2}
|
|
}
|
|
|
|
type GetBackendRequest struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *GetBackendRequest) Reset() {
|
|
*x = GetBackendRequest{}
|
|
mi := &file_proto_maglev_proto_msgTypes[3]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *GetBackendRequest) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*GetBackendRequest) ProtoMessage() {}
|
|
|
|
func (x *GetBackendRequest) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[3]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use GetBackendRequest.ProtoReflect.Descriptor instead.
|
|
func (*GetBackendRequest) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{3}
|
|
}
|
|
|
|
func (x *GetBackendRequest) GetName() string {
|
|
if x != nil {
|
|
return x.Name
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type BackendRequest struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *BackendRequest) Reset() {
|
|
*x = BackendRequest{}
|
|
mi := &file_proto_maglev_proto_msgTypes[4]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *BackendRequest) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*BackendRequest) ProtoMessage() {}
|
|
|
|
func (x *BackendRequest) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[4]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use BackendRequest.ProtoReflect.Descriptor instead.
|
|
func (*BackendRequest) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{4}
|
|
}
|
|
|
|
func (x *BackendRequest) GetName() string {
|
|
if x != nil {
|
|
return x.Name
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type ListHealthChecksRequest struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *ListHealthChecksRequest) Reset() {
|
|
*x = ListHealthChecksRequest{}
|
|
mi := &file_proto_maglev_proto_msgTypes[5]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *ListHealthChecksRequest) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*ListHealthChecksRequest) ProtoMessage() {}
|
|
|
|
func (x *ListHealthChecksRequest) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[5]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use ListHealthChecksRequest.ProtoReflect.Descriptor instead.
|
|
func (*ListHealthChecksRequest) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{5}
|
|
}
|
|
|
|
type GetHealthCheckRequest struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *GetHealthCheckRequest) Reset() {
|
|
*x = GetHealthCheckRequest{}
|
|
mi := &file_proto_maglev_proto_msgTypes[6]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *GetHealthCheckRequest) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*GetHealthCheckRequest) ProtoMessage() {}
|
|
|
|
func (x *GetHealthCheckRequest) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[6]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use GetHealthCheckRequest.ProtoReflect.Descriptor instead.
|
|
func (*GetHealthCheckRequest) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{6}
|
|
}
|
|
|
|
func (x *GetHealthCheckRequest) GetName() string {
|
|
if x != nil {
|
|
return x.Name
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type CheckConfigRequest struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *CheckConfigRequest) Reset() {
|
|
*x = CheckConfigRequest{}
|
|
mi := &file_proto_maglev_proto_msgTypes[7]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *CheckConfigRequest) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*CheckConfigRequest) ProtoMessage() {}
|
|
|
|
func (x *CheckConfigRequest) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[7]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use CheckConfigRequest.ProtoReflect.Descriptor instead.
|
|
func (*CheckConfigRequest) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{7}
|
|
}
|
|
|
|
type CheckConfigResponse struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Ok bool `protobuf:"varint,1,opt,name=ok,proto3" json:"ok,omitempty"`
|
|
ParseError string `protobuf:"bytes,2,opt,name=parse_error,json=parseError,proto3" json:"parse_error,omitempty"` // set when YAML cannot be read or parsed
|
|
SemanticError string `protobuf:"bytes,3,opt,name=semantic_error,json=semanticError,proto3" json:"semantic_error,omitempty"` // set when YAML is valid but semantically incorrect
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *CheckConfigResponse) Reset() {
|
|
*x = CheckConfigResponse{}
|
|
mi := &file_proto_maglev_proto_msgTypes[8]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *CheckConfigResponse) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*CheckConfigResponse) ProtoMessage() {}
|
|
|
|
func (x *CheckConfigResponse) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[8]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use CheckConfigResponse.ProtoReflect.Descriptor instead.
|
|
func (*CheckConfigResponse) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{8}
|
|
}
|
|
|
|
func (x *CheckConfigResponse) GetOk() bool {
|
|
if x != nil {
|
|
return x.Ok
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *CheckConfigResponse) GetParseError() string {
|
|
if x != nil {
|
|
return x.ParseError
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *CheckConfigResponse) GetSemanticError() string {
|
|
if x != nil {
|
|
return x.SemanticError
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type ReloadConfigRequest struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *ReloadConfigRequest) Reset() {
|
|
*x = ReloadConfigRequest{}
|
|
mi := &file_proto_maglev_proto_msgTypes[9]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *ReloadConfigRequest) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*ReloadConfigRequest) ProtoMessage() {}
|
|
|
|
func (x *ReloadConfigRequest) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[9]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use ReloadConfigRequest.ProtoReflect.Descriptor instead.
|
|
func (*ReloadConfigRequest) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{9}
|
|
}
|
|
|
|
type ReloadConfigResponse struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Ok bool `protobuf:"varint,1,opt,name=ok,proto3" json:"ok,omitempty"`
|
|
ParseError string `protobuf:"bytes,2,opt,name=parse_error,json=parseError,proto3" json:"parse_error,omitempty"` // set when YAML cannot be read or parsed
|
|
SemanticError string `protobuf:"bytes,3,opt,name=semantic_error,json=semanticError,proto3" json:"semantic_error,omitempty"` // set when YAML is valid but semantically incorrect
|
|
ReloadError string `protobuf:"bytes,4,opt,name=reload_error,json=reloadError,proto3" json:"reload_error,omitempty"` // set when config is valid but the reload itself failed
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *ReloadConfigResponse) Reset() {
|
|
*x = ReloadConfigResponse{}
|
|
mi := &file_proto_maglev_proto_msgTypes[10]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *ReloadConfigResponse) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*ReloadConfigResponse) ProtoMessage() {}
|
|
|
|
func (x *ReloadConfigResponse) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[10]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use ReloadConfigResponse.ProtoReflect.Descriptor instead.
|
|
func (*ReloadConfigResponse) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{10}
|
|
}
|
|
|
|
func (x *ReloadConfigResponse) GetOk() bool {
|
|
if x != nil {
|
|
return x.Ok
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *ReloadConfigResponse) GetParseError() string {
|
|
if x != nil {
|
|
return x.ParseError
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *ReloadConfigResponse) GetSemanticError() string {
|
|
if x != nil {
|
|
return x.SemanticError
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *ReloadConfigResponse) GetReloadError() string {
|
|
if x != nil {
|
|
return x.ReloadError
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type GetVPPInfoRequest struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *GetVPPInfoRequest) Reset() {
|
|
*x = GetVPPInfoRequest{}
|
|
mi := &file_proto_maglev_proto_msgTypes[11]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *GetVPPInfoRequest) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*GetVPPInfoRequest) ProtoMessage() {}
|
|
|
|
func (x *GetVPPInfoRequest) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[11]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use GetVPPInfoRequest.ProtoReflect.Descriptor instead.
|
|
func (*GetVPPInfoRequest) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{11}
|
|
}
|
|
|
|
type VPPInfo struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Version string `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
|
|
BuildDate string `protobuf:"bytes,2,opt,name=build_date,json=buildDate,proto3" json:"build_date,omitempty"`
|
|
BuildDirectory string `protobuf:"bytes,3,opt,name=build_directory,json=buildDirectory,proto3" json:"build_directory,omitempty"`
|
|
Pid uint32 `protobuf:"varint,4,opt,name=pid,proto3" json:"pid,omitempty"`
|
|
BoottimeNs int64 `protobuf:"varint,5,opt,name=boottime_ns,json=boottimeNs,proto3" json:"boottime_ns,omitempty"` // unix timestamp (ns) when VPP started (from /sys/boottime)
|
|
ConnecttimeNs int64 `protobuf:"varint,6,opt,name=connecttime_ns,json=connecttimeNs,proto3" json:"connecttime_ns,omitempty"` // unix timestamp (ns) when maglevd connected to VPP
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *VPPInfo) Reset() {
|
|
*x = VPPInfo{}
|
|
mi := &file_proto_maglev_proto_msgTypes[12]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *VPPInfo) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*VPPInfo) ProtoMessage() {}
|
|
|
|
func (x *VPPInfo) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[12]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use VPPInfo.ProtoReflect.Descriptor instead.
|
|
func (*VPPInfo) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{12}
|
|
}
|
|
|
|
func (x *VPPInfo) GetVersion() string {
|
|
if x != nil {
|
|
return x.Version
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *VPPInfo) GetBuildDate() string {
|
|
if x != nil {
|
|
return x.BuildDate
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *VPPInfo) GetBuildDirectory() string {
|
|
if x != nil {
|
|
return x.BuildDirectory
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *VPPInfo) GetPid() uint32 {
|
|
if x != nil {
|
|
return x.Pid
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *VPPInfo) GetBoottimeNs() int64 {
|
|
if x != nil {
|
|
return x.BoottimeNs
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *VPPInfo) GetConnecttimeNs() int64 {
|
|
if x != nil {
|
|
return x.ConnecttimeNs
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type GetVPPLBStateRequest struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *GetVPPLBStateRequest) Reset() {
|
|
*x = GetVPPLBStateRequest{}
|
|
mi := &file_proto_maglev_proto_msgTypes[13]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *GetVPPLBStateRequest) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*GetVPPLBStateRequest) ProtoMessage() {}
|
|
|
|
func (x *GetVPPLBStateRequest) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[13]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use GetVPPLBStateRequest.ProtoReflect.Descriptor instead.
|
|
func (*GetVPPLBStateRequest) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{13}
|
|
}
|
|
|
|
// VPPLBConf mirrors VPP's lb_conf_get_reply: global LB plugin settings.
|
|
type VPPLBConf struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Ip4SrcAddress string `protobuf:"bytes,1,opt,name=ip4_src_address,json=ip4SrcAddress,proto3" json:"ip4_src_address,omitempty"`
|
|
Ip6SrcAddress string `protobuf:"bytes,2,opt,name=ip6_src_address,json=ip6SrcAddress,proto3" json:"ip6_src_address,omitempty"`
|
|
StickyBucketsPerCore uint32 `protobuf:"varint,3,opt,name=sticky_buckets_per_core,json=stickyBucketsPerCore,proto3" json:"sticky_buckets_per_core,omitempty"`
|
|
FlowTimeout uint32 `protobuf:"varint,4,opt,name=flow_timeout,json=flowTimeout,proto3" json:"flow_timeout,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *VPPLBConf) Reset() {
|
|
*x = VPPLBConf{}
|
|
mi := &file_proto_maglev_proto_msgTypes[14]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *VPPLBConf) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*VPPLBConf) ProtoMessage() {}
|
|
|
|
func (x *VPPLBConf) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[14]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use VPPLBConf.ProtoReflect.Descriptor instead.
|
|
func (*VPPLBConf) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{14}
|
|
}
|
|
|
|
func (x *VPPLBConf) GetIp4SrcAddress() string {
|
|
if x != nil {
|
|
return x.Ip4SrcAddress
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *VPPLBConf) GetIp6SrcAddress() string {
|
|
if x != nil {
|
|
return x.Ip6SrcAddress
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *VPPLBConf) GetStickyBucketsPerCore() uint32 {
|
|
if x != nil {
|
|
return x.StickyBucketsPerCore
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *VPPLBConf) GetFlowTimeout() uint32 {
|
|
if x != nil {
|
|
return x.FlowTimeout
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// VPPLBAS is one application server attached to a VIP.
|
|
type VPPLBAS struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
|
|
Weight uint32 `protobuf:"varint,2,opt,name=weight,proto3" json:"weight,omitempty"` // 0-100
|
|
Flags uint32 `protobuf:"varint,3,opt,name=flags,proto3" json:"flags,omitempty"` // VPP AS flags (bit 0 = used, bit 1 = flushed)
|
|
NumBuckets uint32 `protobuf:"varint,4,opt,name=num_buckets,json=numBuckets,proto3" json:"num_buckets,omitempty"`
|
|
InUseSinceNs int64 `protobuf:"varint,5,opt,name=in_use_since_ns,json=inUseSinceNs,proto3" json:"in_use_since_ns,omitempty"` // unix timestamp (ns), 0 if never used
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *VPPLBAS) Reset() {
|
|
*x = VPPLBAS{}
|
|
mi := &file_proto_maglev_proto_msgTypes[15]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *VPPLBAS) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*VPPLBAS) ProtoMessage() {}
|
|
|
|
func (x *VPPLBAS) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[15]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use VPPLBAS.ProtoReflect.Descriptor instead.
|
|
func (*VPPLBAS) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{15}
|
|
}
|
|
|
|
func (x *VPPLBAS) GetAddress() string {
|
|
if x != nil {
|
|
return x.Address
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *VPPLBAS) GetWeight() uint32 {
|
|
if x != nil {
|
|
return x.Weight
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *VPPLBAS) GetFlags() uint32 {
|
|
if x != nil {
|
|
return x.Flags
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *VPPLBAS) GetNumBuckets() uint32 {
|
|
if x != nil {
|
|
return x.NumBuckets
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *VPPLBAS) GetInUseSinceNs() int64 {
|
|
if x != nil {
|
|
return x.InUseSinceNs
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// VPPLBVIP mirrors VPP's lb_vip_details plus the attached application servers.
|
|
// Note: srv_type, dscp, and target_port are intentionally omitted — maglevd
|
|
// only supports GRE encap, so NAT/L3DSR-specific fields don't apply.
|
|
type VPPLBVIP struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Prefix string `protobuf:"bytes,1,opt,name=prefix,proto3" json:"prefix,omitempty"` // CIDR, e.g. 192.0.2.1/32
|
|
Protocol uint32 `protobuf:"varint,2,opt,name=protocol,proto3" json:"protocol,omitempty"` // 6=TCP, 17=UDP, 255=any
|
|
Port uint32 `protobuf:"varint,3,opt,name=port,proto3" json:"port,omitempty"` // 0 = all-port VIP
|
|
Encap string `protobuf:"bytes,4,opt,name=encap,proto3" json:"encap,omitempty"` // gre4|gre6|l3dsr|nat4|nat6
|
|
FlowTableLength uint32 `protobuf:"varint,5,opt,name=flow_table_length,json=flowTableLength,proto3" json:"flow_table_length,omitempty"`
|
|
ApplicationServers []*VPPLBAS `protobuf:"bytes,6,rep,name=application_servers,json=applicationServers,proto3" json:"application_servers,omitempty"`
|
|
SrcIpSticky bool `protobuf:"varint,7,opt,name=src_ip_sticky,json=srcIpSticky,proto3" json:"src_ip_sticky,omitempty"` // source-IP based sticky session (scraped via cli_inband)
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *VPPLBVIP) Reset() {
|
|
*x = VPPLBVIP{}
|
|
mi := &file_proto_maglev_proto_msgTypes[16]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *VPPLBVIP) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*VPPLBVIP) ProtoMessage() {}
|
|
|
|
func (x *VPPLBVIP) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[16]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use VPPLBVIP.ProtoReflect.Descriptor instead.
|
|
func (*VPPLBVIP) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{16}
|
|
}
|
|
|
|
func (x *VPPLBVIP) GetPrefix() string {
|
|
if x != nil {
|
|
return x.Prefix
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *VPPLBVIP) GetProtocol() uint32 {
|
|
if x != nil {
|
|
return x.Protocol
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *VPPLBVIP) GetPort() uint32 {
|
|
if x != nil {
|
|
return x.Port
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *VPPLBVIP) GetEncap() string {
|
|
if x != nil {
|
|
return x.Encap
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *VPPLBVIP) GetFlowTableLength() uint32 {
|
|
if x != nil {
|
|
return x.FlowTableLength
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *VPPLBVIP) GetApplicationServers() []*VPPLBAS {
|
|
if x != nil {
|
|
return x.ApplicationServers
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *VPPLBVIP) GetSrcIpSticky() bool {
|
|
if x != nil {
|
|
return x.SrcIpSticky
|
|
}
|
|
return false
|
|
}
|
|
|
|
type VPPLBState struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Conf *VPPLBConf `protobuf:"bytes,1,opt,name=conf,proto3" json:"conf,omitempty"`
|
|
Vips []*VPPLBVIP `protobuf:"bytes,2,rep,name=vips,proto3" json:"vips,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *VPPLBState) Reset() {
|
|
*x = VPPLBState{}
|
|
mi := &file_proto_maglev_proto_msgTypes[17]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *VPPLBState) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*VPPLBState) ProtoMessage() {}
|
|
|
|
func (x *VPPLBState) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[17]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use VPPLBState.ProtoReflect.Descriptor instead.
|
|
func (*VPPLBState) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{17}
|
|
}
|
|
|
|
func (x *VPPLBState) GetConf() *VPPLBConf {
|
|
if x != nil {
|
|
return x.Conf
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *VPPLBState) GetVips() []*VPPLBVIP {
|
|
if x != nil {
|
|
return x.Vips
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// SyncVPPLBStateRequest triggers a reconciliation between the maglev config
|
|
// and the VPP load-balancer dataplane. When frontend_name is set, only that
|
|
// frontend's VIP is synced (SyncLBStateVIP) and no VIPs are removed. When
|
|
// unset, a full reconciliation runs (SyncLBStateAll), which will also remove
|
|
// stale VIPs from VPP.
|
|
type SyncVPPLBStateRequest struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
FrontendName *string `protobuf:"bytes,1,opt,name=frontend_name,json=frontendName,proto3,oneof" json:"frontend_name,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *SyncVPPLBStateRequest) Reset() {
|
|
*x = SyncVPPLBStateRequest{}
|
|
mi := &file_proto_maglev_proto_msgTypes[18]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *SyncVPPLBStateRequest) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*SyncVPPLBStateRequest) ProtoMessage() {}
|
|
|
|
func (x *SyncVPPLBStateRequest) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[18]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use SyncVPPLBStateRequest.ProtoReflect.Descriptor instead.
|
|
func (*SyncVPPLBStateRequest) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{18}
|
|
}
|
|
|
|
func (x *SyncVPPLBStateRequest) GetFrontendName() string {
|
|
if x != nil && x.FrontendName != nil {
|
|
return *x.FrontendName
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type SyncVPPLBStateResponse struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *SyncVPPLBStateResponse) Reset() {
|
|
*x = SyncVPPLBStateResponse{}
|
|
mi := &file_proto_maglev_proto_msgTypes[19]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *SyncVPPLBStateResponse) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*SyncVPPLBStateResponse) ProtoMessage() {}
|
|
|
|
func (x *SyncVPPLBStateResponse) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[19]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use SyncVPPLBStateResponse.ProtoReflect.Descriptor instead.
|
|
func (*SyncVPPLBStateResponse) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{19}
|
|
}
|
|
|
|
// GetVPPLBCountersRequest asks maglevd for the most recent per-VIP and
|
|
// per-backend counter snapshot. The data is served from an in-process
|
|
// cache that is refreshed every ~5 seconds server-side; the call itself
|
|
// is cheap and does not hit VPP.
|
|
type GetVPPLBCountersRequest struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *GetVPPLBCountersRequest) Reset() {
|
|
*x = GetVPPLBCountersRequest{}
|
|
mi := &file_proto_maglev_proto_msgTypes[20]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *GetVPPLBCountersRequest) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*GetVPPLBCountersRequest) ProtoMessage() {}
|
|
|
|
func (x *GetVPPLBCountersRequest) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[20]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use GetVPPLBCountersRequest.ProtoReflect.Descriptor instead.
|
|
func (*GetVPPLBCountersRequest) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{20}
|
|
}
|
|
|
|
// VPPLBVIPCounters is the point-in-time counter row for a single VIP.
|
|
// The four lb_* fields are the LB plugin's SimpleCounters (packets only);
|
|
// packets / bytes come from the VPP FIB's combined counter at the VIP's
|
|
// host prefix (/net/route/to).
|
|
type VPPLBVIPCounters struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Prefix string `protobuf:"bytes,1,opt,name=prefix,proto3" json:"prefix,omitempty"` // CIDR, e.g. 192.0.2.1/32
|
|
Protocol string `protobuf:"bytes,2,opt,name=protocol,proto3" json:"protocol,omitempty"` // tcp | udp | any
|
|
Port uint32 `protobuf:"varint,3,opt,name=port,proto3" json:"port,omitempty"`
|
|
NextPacket uint64 `protobuf:"varint,4,opt,name=next_packet,json=nextPacket,proto3" json:"next_packet,omitempty"` // "/packet from existing sessions"
|
|
FirstPacket uint64 `protobuf:"varint,5,opt,name=first_packet,json=firstPacket,proto3" json:"first_packet,omitempty"` // "/first session packet"
|
|
UntrackedPacket uint64 `protobuf:"varint,6,opt,name=untracked_packet,json=untrackedPacket,proto3" json:"untracked_packet,omitempty"` // "/untracked packet"
|
|
NoServer uint64 `protobuf:"varint,7,opt,name=no_server,json=noServer,proto3" json:"no_server,omitempty"` // "/no server configured"
|
|
Packets uint64 `protobuf:"varint,8,opt,name=packets,proto3" json:"packets,omitempty"` // /net/route/to (FIB, summed across workers)
|
|
Bytes uint64 `protobuf:"varint,9,opt,name=bytes,proto3" json:"bytes,omitempty"` // /net/route/to (FIB, summed across workers)
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *VPPLBVIPCounters) Reset() {
|
|
*x = VPPLBVIPCounters{}
|
|
mi := &file_proto_maglev_proto_msgTypes[21]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *VPPLBVIPCounters) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*VPPLBVIPCounters) ProtoMessage() {}
|
|
|
|
func (x *VPPLBVIPCounters) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[21]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use VPPLBVIPCounters.ProtoReflect.Descriptor instead.
|
|
func (*VPPLBVIPCounters) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{21}
|
|
}
|
|
|
|
func (x *VPPLBVIPCounters) GetPrefix() string {
|
|
if x != nil {
|
|
return x.Prefix
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *VPPLBVIPCounters) GetProtocol() string {
|
|
if x != nil {
|
|
return x.Protocol
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *VPPLBVIPCounters) GetPort() uint32 {
|
|
if x != nil {
|
|
return x.Port
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *VPPLBVIPCounters) GetNextPacket() uint64 {
|
|
if x != nil {
|
|
return x.NextPacket
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *VPPLBVIPCounters) GetFirstPacket() uint64 {
|
|
if x != nil {
|
|
return x.FirstPacket
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *VPPLBVIPCounters) GetUntrackedPacket() uint64 {
|
|
if x != nil {
|
|
return x.UntrackedPacket
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *VPPLBVIPCounters) GetNoServer() uint64 {
|
|
if x != nil {
|
|
return x.NoServer
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *VPPLBVIPCounters) GetPackets() uint64 {
|
|
if x != nil {
|
|
return x.Packets
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *VPPLBVIPCounters) GetBytes() uint64 {
|
|
if x != nil {
|
|
return x.Bytes
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// VPPLBBackendCounters is the FIB combined counter for a single backend's
|
|
// host prefix, summed across worker threads.
|
|
type VPPLBBackendCounters struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Backend string `protobuf:"bytes,1,opt,name=backend,proto3" json:"backend,omitempty"` // backend name from config
|
|
Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"` // backend IP address
|
|
Packets uint64 `protobuf:"varint,3,opt,name=packets,proto3" json:"packets,omitempty"`
|
|
Bytes uint64 `protobuf:"varint,4,opt,name=bytes,proto3" json:"bytes,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *VPPLBBackendCounters) Reset() {
|
|
*x = VPPLBBackendCounters{}
|
|
mi := &file_proto_maglev_proto_msgTypes[22]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *VPPLBBackendCounters) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*VPPLBBackendCounters) ProtoMessage() {}
|
|
|
|
func (x *VPPLBBackendCounters) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[22]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use VPPLBBackendCounters.ProtoReflect.Descriptor instead.
|
|
func (*VPPLBBackendCounters) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{22}
|
|
}
|
|
|
|
func (x *VPPLBBackendCounters) GetBackend() string {
|
|
if x != nil {
|
|
return x.Backend
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *VPPLBBackendCounters) GetAddress() string {
|
|
if x != nil {
|
|
return x.Address
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *VPPLBBackendCounters) GetPackets() uint64 {
|
|
if x != nil {
|
|
return x.Packets
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *VPPLBBackendCounters) GetBytes() uint64 {
|
|
if x != nil {
|
|
return x.Bytes
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type VPPLBCounters struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Vips []*VPPLBVIPCounters `protobuf:"bytes,1,rep,name=vips,proto3" json:"vips,omitempty"`
|
|
Backends []*VPPLBBackendCounters `protobuf:"bytes,2,rep,name=backends,proto3" json:"backends,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *VPPLBCounters) Reset() {
|
|
*x = VPPLBCounters{}
|
|
mi := &file_proto_maglev_proto_msgTypes[23]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *VPPLBCounters) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*VPPLBCounters) ProtoMessage() {}
|
|
|
|
func (x *VPPLBCounters) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[23]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use VPPLBCounters.ProtoReflect.Descriptor instead.
|
|
func (*VPPLBCounters) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{23}
|
|
}
|
|
|
|
func (x *VPPLBCounters) GetVips() []*VPPLBVIPCounters {
|
|
if x != nil {
|
|
return x.Vips
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *VPPLBCounters) GetBackends() []*VPPLBBackendCounters {
|
|
if x != nil {
|
|
return x.Backends
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type SetWeightRequest struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Frontend string `protobuf:"bytes,1,opt,name=frontend,proto3" json:"frontend,omitempty"`
|
|
Pool string `protobuf:"bytes,2,opt,name=pool,proto3" json:"pool,omitempty"`
|
|
Backend string `protobuf:"bytes,3,opt,name=backend,proto3" json:"backend,omitempty"`
|
|
Weight int32 `protobuf:"varint,4,opt,name=weight,proto3" json:"weight,omitempty"` // 0-100
|
|
// flush, when true, also clears VPP's flow table for this backend
|
|
// so existing sessions are torn down. When false (default), only
|
|
// Maglev's new-bucket mapping is updated and live flows keep
|
|
// draining to this backend.
|
|
Flush bool `protobuf:"varint,5,opt,name=flush,proto3" json:"flush,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *SetWeightRequest) Reset() {
|
|
*x = SetWeightRequest{}
|
|
mi := &file_proto_maglev_proto_msgTypes[24]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *SetWeightRequest) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*SetWeightRequest) ProtoMessage() {}
|
|
|
|
func (x *SetWeightRequest) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[24]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use SetWeightRequest.ProtoReflect.Descriptor instead.
|
|
func (*SetWeightRequest) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{24}
|
|
}
|
|
|
|
func (x *SetWeightRequest) GetFrontend() string {
|
|
if x != nil {
|
|
return x.Frontend
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *SetWeightRequest) GetPool() string {
|
|
if x != nil {
|
|
return x.Pool
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *SetWeightRequest) GetBackend() string {
|
|
if x != nil {
|
|
return x.Backend
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *SetWeightRequest) GetWeight() int32 {
|
|
if x != nil {
|
|
return x.Weight
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *SetWeightRequest) GetFlush() bool {
|
|
if x != nil {
|
|
return x.Flush
|
|
}
|
|
return false
|
|
}
|
|
|
|
// WatchRequest controls which event types are streamed. All fields default to
|
|
// true (i.e. an empty request subscribes to everything at info level).
|
|
type WatchRequest struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Log *bool `protobuf:"varint,1,opt,name=log,proto3,oneof" json:"log,omitempty"` // include log events (default: true)
|
|
LogLevel string `protobuf:"bytes,2,opt,name=log_level,json=logLevel,proto3" json:"log_level,omitempty"` // minimum log level: debug|info|warn|error (default: info)
|
|
Backend *bool `protobuf:"varint,3,opt,name=backend,proto3,oneof" json:"backend,omitempty"` // include backend transition events (default: true)
|
|
Frontend *bool `protobuf:"varint,4,opt,name=frontend,proto3,oneof" json:"frontend,omitempty"` // include frontend events (default: true)
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *WatchRequest) Reset() {
|
|
*x = WatchRequest{}
|
|
mi := &file_proto_maglev_proto_msgTypes[25]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *WatchRequest) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*WatchRequest) ProtoMessage() {}
|
|
|
|
func (x *WatchRequest) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[25]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use WatchRequest.ProtoReflect.Descriptor instead.
|
|
func (*WatchRequest) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{25}
|
|
}
|
|
|
|
func (x *WatchRequest) GetLog() bool {
|
|
if x != nil && x.Log != nil {
|
|
return *x.Log
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *WatchRequest) GetLogLevel() string {
|
|
if x != nil {
|
|
return x.LogLevel
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *WatchRequest) GetBackend() bool {
|
|
if x != nil && x.Backend != nil {
|
|
return *x.Backend
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *WatchRequest) GetFrontend() bool {
|
|
if x != nil && x.Frontend != nil {
|
|
return *x.Frontend
|
|
}
|
|
return false
|
|
}
|
|
|
|
type ListFrontendsResponse struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
FrontendNames []string `protobuf:"bytes,1,rep,name=frontend_names,json=frontendNames,proto3" json:"frontend_names,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *ListFrontendsResponse) Reset() {
|
|
*x = ListFrontendsResponse{}
|
|
mi := &file_proto_maglev_proto_msgTypes[26]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *ListFrontendsResponse) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*ListFrontendsResponse) ProtoMessage() {}
|
|
|
|
func (x *ListFrontendsResponse) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[26]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use ListFrontendsResponse.ProtoReflect.Descriptor instead.
|
|
func (*ListFrontendsResponse) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{26}
|
|
}
|
|
|
|
func (x *ListFrontendsResponse) GetFrontendNames() []string {
|
|
if x != nil {
|
|
return x.FrontendNames
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type PoolBackendInfo struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
|
|
Weight int32 `protobuf:"varint,2,opt,name=weight,proto3" json:"weight,omitempty"` // configured weight from YAML (0-100)
|
|
EffectiveWeight int32 `protobuf:"varint,3,opt,name=effective_weight,json=effectiveWeight,proto3" json:"effective_weight,omitempty"` // state-aware weight after pool-failover logic
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *PoolBackendInfo) Reset() {
|
|
*x = PoolBackendInfo{}
|
|
mi := &file_proto_maglev_proto_msgTypes[27]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *PoolBackendInfo) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*PoolBackendInfo) ProtoMessage() {}
|
|
|
|
func (x *PoolBackendInfo) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[27]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use PoolBackendInfo.ProtoReflect.Descriptor instead.
|
|
func (*PoolBackendInfo) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{27}
|
|
}
|
|
|
|
func (x *PoolBackendInfo) GetName() string {
|
|
if x != nil {
|
|
return x.Name
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *PoolBackendInfo) GetWeight() int32 {
|
|
if x != nil {
|
|
return x.Weight
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *PoolBackendInfo) GetEffectiveWeight() int32 {
|
|
if x != nil {
|
|
return x.EffectiveWeight
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type PoolInfo struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
|
|
Backends []*PoolBackendInfo `protobuf:"bytes,2,rep,name=backends,proto3" json:"backends,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *PoolInfo) Reset() {
|
|
*x = PoolInfo{}
|
|
mi := &file_proto_maglev_proto_msgTypes[28]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *PoolInfo) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*PoolInfo) ProtoMessage() {}
|
|
|
|
func (x *PoolInfo) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[28]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use PoolInfo.ProtoReflect.Descriptor instead.
|
|
func (*PoolInfo) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{28}
|
|
}
|
|
|
|
func (x *PoolInfo) GetName() string {
|
|
if x != nil {
|
|
return x.Name
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *PoolInfo) GetBackends() []*PoolBackendInfo {
|
|
if x != nil {
|
|
return x.Backends
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type FrontendInfo struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
|
|
Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
|
|
Protocol string `protobuf:"bytes,3,opt,name=protocol,proto3" json:"protocol,omitempty"`
|
|
Port uint32 `protobuf:"varint,4,opt,name=port,proto3" json:"port,omitempty"`
|
|
Pools []*PoolInfo `protobuf:"bytes,5,rep,name=pools,proto3" json:"pools,omitempty"`
|
|
Description string `protobuf:"bytes,6,opt,name=description,proto3" json:"description,omitempty"`
|
|
SrcIpSticky bool `protobuf:"varint,7,opt,name=src_ip_sticky,json=srcIpSticky,proto3" json:"src_ip_sticky,omitempty"` // VPP LB uses src-IP-based stickiness for this VIP
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *FrontendInfo) Reset() {
|
|
*x = FrontendInfo{}
|
|
mi := &file_proto_maglev_proto_msgTypes[29]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *FrontendInfo) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*FrontendInfo) ProtoMessage() {}
|
|
|
|
func (x *FrontendInfo) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[29]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use FrontendInfo.ProtoReflect.Descriptor instead.
|
|
func (*FrontendInfo) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{29}
|
|
}
|
|
|
|
func (x *FrontendInfo) GetName() string {
|
|
if x != nil {
|
|
return x.Name
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *FrontendInfo) GetAddress() string {
|
|
if x != nil {
|
|
return x.Address
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *FrontendInfo) GetProtocol() string {
|
|
if x != nil {
|
|
return x.Protocol
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *FrontendInfo) GetPort() uint32 {
|
|
if x != nil {
|
|
return x.Port
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *FrontendInfo) GetPools() []*PoolInfo {
|
|
if x != nil {
|
|
return x.Pools
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *FrontendInfo) GetDescription() string {
|
|
if x != nil {
|
|
return x.Description
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *FrontendInfo) GetSrcIpSticky() bool {
|
|
if x != nil {
|
|
return x.SrcIpSticky
|
|
}
|
|
return false
|
|
}
|
|
|
|
type ListBackendsResponse struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
BackendNames []string `protobuf:"bytes,1,rep,name=backend_names,json=backendNames,proto3" json:"backend_names,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *ListBackendsResponse) Reset() {
|
|
*x = ListBackendsResponse{}
|
|
mi := &file_proto_maglev_proto_msgTypes[30]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *ListBackendsResponse) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*ListBackendsResponse) ProtoMessage() {}
|
|
|
|
func (x *ListBackendsResponse) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[30]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use ListBackendsResponse.ProtoReflect.Descriptor instead.
|
|
func (*ListBackendsResponse) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{30}
|
|
}
|
|
|
|
func (x *ListBackendsResponse) GetBackendNames() []string {
|
|
if x != nil {
|
|
return x.BackendNames
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type ListHealthChecksResponse struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Names []string `protobuf:"bytes,1,rep,name=names,proto3" json:"names,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *ListHealthChecksResponse) Reset() {
|
|
*x = ListHealthChecksResponse{}
|
|
mi := &file_proto_maglev_proto_msgTypes[31]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *ListHealthChecksResponse) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*ListHealthChecksResponse) ProtoMessage() {}
|
|
|
|
func (x *ListHealthChecksResponse) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[31]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use ListHealthChecksResponse.ProtoReflect.Descriptor instead.
|
|
func (*ListHealthChecksResponse) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{31}
|
|
}
|
|
|
|
func (x *ListHealthChecksResponse) GetNames() []string {
|
|
if x != nil {
|
|
return x.Names
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type HTTPCheckParams struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
|
|
Host string `protobuf:"bytes,2,opt,name=host,proto3" json:"host,omitempty"`
|
|
ResponseCodeMin int32 `protobuf:"varint,3,opt,name=response_code_min,json=responseCodeMin,proto3" json:"response_code_min,omitempty"`
|
|
ResponseCodeMax int32 `protobuf:"varint,4,opt,name=response_code_max,json=responseCodeMax,proto3" json:"response_code_max,omitempty"`
|
|
ResponseRegexp string `protobuf:"bytes,5,opt,name=response_regexp,json=responseRegexp,proto3" json:"response_regexp,omitempty"`
|
|
ServerName string `protobuf:"bytes,6,opt,name=server_name,json=serverName,proto3" json:"server_name,omitempty"`
|
|
InsecureSkipVerify bool `protobuf:"varint,7,opt,name=insecure_skip_verify,json=insecureSkipVerify,proto3" json:"insecure_skip_verify,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *HTTPCheckParams) Reset() {
|
|
*x = HTTPCheckParams{}
|
|
mi := &file_proto_maglev_proto_msgTypes[32]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *HTTPCheckParams) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*HTTPCheckParams) ProtoMessage() {}
|
|
|
|
func (x *HTTPCheckParams) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[32]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use HTTPCheckParams.ProtoReflect.Descriptor instead.
|
|
func (*HTTPCheckParams) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{32}
|
|
}
|
|
|
|
func (x *HTTPCheckParams) GetPath() string {
|
|
if x != nil {
|
|
return x.Path
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *HTTPCheckParams) GetHost() string {
|
|
if x != nil {
|
|
return x.Host
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *HTTPCheckParams) GetResponseCodeMin() int32 {
|
|
if x != nil {
|
|
return x.ResponseCodeMin
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *HTTPCheckParams) GetResponseCodeMax() int32 {
|
|
if x != nil {
|
|
return x.ResponseCodeMax
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *HTTPCheckParams) GetResponseRegexp() string {
|
|
if x != nil {
|
|
return x.ResponseRegexp
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *HTTPCheckParams) GetServerName() string {
|
|
if x != nil {
|
|
return x.ServerName
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *HTTPCheckParams) GetInsecureSkipVerify() bool {
|
|
if x != nil {
|
|
return x.InsecureSkipVerify
|
|
}
|
|
return false
|
|
}
|
|
|
|
type TCPCheckParams struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Ssl bool `protobuf:"varint,1,opt,name=ssl,proto3" json:"ssl,omitempty"`
|
|
ServerName string `protobuf:"bytes,2,opt,name=server_name,json=serverName,proto3" json:"server_name,omitempty"`
|
|
InsecureSkipVerify bool `protobuf:"varint,3,opt,name=insecure_skip_verify,json=insecureSkipVerify,proto3" json:"insecure_skip_verify,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *TCPCheckParams) Reset() {
|
|
*x = TCPCheckParams{}
|
|
mi := &file_proto_maglev_proto_msgTypes[33]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *TCPCheckParams) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*TCPCheckParams) ProtoMessage() {}
|
|
|
|
func (x *TCPCheckParams) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[33]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use TCPCheckParams.ProtoReflect.Descriptor instead.
|
|
func (*TCPCheckParams) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{33}
|
|
}
|
|
|
|
func (x *TCPCheckParams) GetSsl() bool {
|
|
if x != nil {
|
|
return x.Ssl
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *TCPCheckParams) GetServerName() string {
|
|
if x != nil {
|
|
return x.ServerName
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *TCPCheckParams) GetInsecureSkipVerify() bool {
|
|
if x != nil {
|
|
return x.InsecureSkipVerify
|
|
}
|
|
return false
|
|
}
|
|
|
|
type HealthCheckInfo struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
|
|
Type string `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"`
|
|
Port uint32 `protobuf:"varint,3,opt,name=port,proto3" json:"port,omitempty"`
|
|
ProbeIpv4Src string `protobuf:"bytes,4,opt,name=probe_ipv4_src,json=probeIpv4Src,proto3" json:"probe_ipv4_src,omitempty"`
|
|
ProbeIpv6Src string `protobuf:"bytes,5,opt,name=probe_ipv6_src,json=probeIpv6Src,proto3" json:"probe_ipv6_src,omitempty"`
|
|
IntervalNs int64 `protobuf:"varint,6,opt,name=interval_ns,json=intervalNs,proto3" json:"interval_ns,omitempty"`
|
|
FastIntervalNs int64 `protobuf:"varint,7,opt,name=fast_interval_ns,json=fastIntervalNs,proto3" json:"fast_interval_ns,omitempty"`
|
|
DownIntervalNs int64 `protobuf:"varint,8,opt,name=down_interval_ns,json=downIntervalNs,proto3" json:"down_interval_ns,omitempty"`
|
|
TimeoutNs int64 `protobuf:"varint,9,opt,name=timeout_ns,json=timeoutNs,proto3" json:"timeout_ns,omitempty"`
|
|
Rise int32 `protobuf:"varint,10,opt,name=rise,proto3" json:"rise,omitempty"`
|
|
Fall int32 `protobuf:"varint,11,opt,name=fall,proto3" json:"fall,omitempty"`
|
|
Http *HTTPCheckParams `protobuf:"bytes,12,opt,name=http,proto3" json:"http,omitempty"`
|
|
Tcp *TCPCheckParams `protobuf:"bytes,13,opt,name=tcp,proto3" json:"tcp,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *HealthCheckInfo) Reset() {
|
|
*x = HealthCheckInfo{}
|
|
mi := &file_proto_maglev_proto_msgTypes[34]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *HealthCheckInfo) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*HealthCheckInfo) ProtoMessage() {}
|
|
|
|
func (x *HealthCheckInfo) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[34]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use HealthCheckInfo.ProtoReflect.Descriptor instead.
|
|
func (*HealthCheckInfo) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{34}
|
|
}
|
|
|
|
func (x *HealthCheckInfo) GetName() string {
|
|
if x != nil {
|
|
return x.Name
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *HealthCheckInfo) GetType() string {
|
|
if x != nil {
|
|
return x.Type
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *HealthCheckInfo) GetPort() uint32 {
|
|
if x != nil {
|
|
return x.Port
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *HealthCheckInfo) GetProbeIpv4Src() string {
|
|
if x != nil {
|
|
return x.ProbeIpv4Src
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *HealthCheckInfo) GetProbeIpv6Src() string {
|
|
if x != nil {
|
|
return x.ProbeIpv6Src
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *HealthCheckInfo) GetIntervalNs() int64 {
|
|
if x != nil {
|
|
return x.IntervalNs
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *HealthCheckInfo) GetFastIntervalNs() int64 {
|
|
if x != nil {
|
|
return x.FastIntervalNs
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *HealthCheckInfo) GetDownIntervalNs() int64 {
|
|
if x != nil {
|
|
return x.DownIntervalNs
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *HealthCheckInfo) GetTimeoutNs() int64 {
|
|
if x != nil {
|
|
return x.TimeoutNs
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *HealthCheckInfo) GetRise() int32 {
|
|
if x != nil {
|
|
return x.Rise
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *HealthCheckInfo) GetFall() int32 {
|
|
if x != nil {
|
|
return x.Fall
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *HealthCheckInfo) GetHttp() *HTTPCheckParams {
|
|
if x != nil {
|
|
return x.Http
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *HealthCheckInfo) GetTcp() *TCPCheckParams {
|
|
if x != nil {
|
|
return x.Tcp
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type BackendInfo struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
|
|
Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
|
|
State string `protobuf:"bytes,3,opt,name=state,proto3" json:"state,omitempty"`
|
|
Transitions []*TransitionRecord `protobuf:"bytes,4,rep,name=transitions,proto3" json:"transitions,omitempty"`
|
|
Enabled bool `protobuf:"varint,5,opt,name=enabled,proto3" json:"enabled,omitempty"`
|
|
Healthcheck string `protobuf:"bytes,6,opt,name=healthcheck,proto3" json:"healthcheck,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *BackendInfo) Reset() {
|
|
*x = BackendInfo{}
|
|
mi := &file_proto_maglev_proto_msgTypes[35]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *BackendInfo) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*BackendInfo) ProtoMessage() {}
|
|
|
|
func (x *BackendInfo) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[35]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use BackendInfo.ProtoReflect.Descriptor instead.
|
|
func (*BackendInfo) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{35}
|
|
}
|
|
|
|
func (x *BackendInfo) GetName() string {
|
|
if x != nil {
|
|
return x.Name
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *BackendInfo) GetAddress() string {
|
|
if x != nil {
|
|
return x.Address
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *BackendInfo) GetState() string {
|
|
if x != nil {
|
|
return x.State
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *BackendInfo) GetTransitions() []*TransitionRecord {
|
|
if x != nil {
|
|
return x.Transitions
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *BackendInfo) GetEnabled() bool {
|
|
if x != nil {
|
|
return x.Enabled
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *BackendInfo) GetHealthcheck() string {
|
|
if x != nil {
|
|
return x.Healthcheck
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type TransitionRecord struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
From string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
|
|
To string `protobuf:"bytes,2,opt,name=to,proto3" json:"to,omitempty"`
|
|
AtUnixNs int64 `protobuf:"varint,3,opt,name=at_unix_ns,json=atUnixNs,proto3" json:"at_unix_ns,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *TransitionRecord) Reset() {
|
|
*x = TransitionRecord{}
|
|
mi := &file_proto_maglev_proto_msgTypes[36]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *TransitionRecord) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*TransitionRecord) ProtoMessage() {}
|
|
|
|
func (x *TransitionRecord) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[36]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use TransitionRecord.ProtoReflect.Descriptor instead.
|
|
func (*TransitionRecord) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{36}
|
|
}
|
|
|
|
func (x *TransitionRecord) GetFrom() string {
|
|
if x != nil {
|
|
return x.From
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *TransitionRecord) GetTo() string {
|
|
if x != nil {
|
|
return x.To
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *TransitionRecord) GetAtUnixNs() int64 {
|
|
if x != nil {
|
|
return x.AtUnixNs
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// LogAttr is a single key/value attribute from a structured log record.
|
|
type LogAttr struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
|
|
Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *LogAttr) Reset() {
|
|
*x = LogAttr{}
|
|
mi := &file_proto_maglev_proto_msgTypes[37]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *LogAttr) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*LogAttr) ProtoMessage() {}
|
|
|
|
func (x *LogAttr) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[37]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use LogAttr.ProtoReflect.Descriptor instead.
|
|
func (*LogAttr) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{37}
|
|
}
|
|
|
|
func (x *LogAttr) GetKey() string {
|
|
if x != nil {
|
|
return x.Key
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *LogAttr) GetValue() string {
|
|
if x != nil {
|
|
return x.Value
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// LogEvent carries a single structured log record.
|
|
type LogEvent struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
AtUnixNs int64 `protobuf:"varint,1,opt,name=at_unix_ns,json=atUnixNs,proto3" json:"at_unix_ns,omitempty"`
|
|
Level string `protobuf:"bytes,2,opt,name=level,proto3" json:"level,omitempty"`
|
|
Msg string `protobuf:"bytes,3,opt,name=msg,proto3" json:"msg,omitempty"`
|
|
Attrs []*LogAttr `protobuf:"bytes,4,rep,name=attrs,proto3" json:"attrs,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *LogEvent) Reset() {
|
|
*x = LogEvent{}
|
|
mi := &file_proto_maglev_proto_msgTypes[38]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *LogEvent) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*LogEvent) ProtoMessage() {}
|
|
|
|
func (x *LogEvent) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[38]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use LogEvent.ProtoReflect.Descriptor instead.
|
|
func (*LogEvent) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{38}
|
|
}
|
|
|
|
func (x *LogEvent) GetAtUnixNs() int64 {
|
|
if x != nil {
|
|
return x.AtUnixNs
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *LogEvent) GetLevel() string {
|
|
if x != nil {
|
|
return x.Level
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *LogEvent) GetMsg() string {
|
|
if x != nil {
|
|
return x.Msg
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *LogEvent) GetAttrs() []*LogAttr {
|
|
if x != nil {
|
|
return x.Attrs
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// BackendEvent is emitted on every backend state transition.
|
|
type BackendEvent struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
BackendName string `protobuf:"bytes,1,opt,name=backend_name,json=backendName,proto3" json:"backend_name,omitempty"`
|
|
Transition *TransitionRecord `protobuf:"bytes,2,opt,name=transition,proto3" json:"transition,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *BackendEvent) Reset() {
|
|
*x = BackendEvent{}
|
|
mi := &file_proto_maglev_proto_msgTypes[39]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *BackendEvent) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*BackendEvent) ProtoMessage() {}
|
|
|
|
func (x *BackendEvent) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[39]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use BackendEvent.ProtoReflect.Descriptor instead.
|
|
func (*BackendEvent) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{39}
|
|
}
|
|
|
|
func (x *BackendEvent) GetBackendName() string {
|
|
if x != nil {
|
|
return x.BackendName
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *BackendEvent) GetTransition() *TransitionRecord {
|
|
if x != nil {
|
|
return x.Transition
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// FrontendEvent is emitted when a frontend's aggregate state changes.
|
|
// Frontends have three states: unknown, up, down. See docs/healthchecks.md.
|
|
type FrontendEvent struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
FrontendName string `protobuf:"bytes,1,opt,name=frontend_name,json=frontendName,proto3" json:"frontend_name,omitempty"`
|
|
Transition *TransitionRecord `protobuf:"bytes,2,opt,name=transition,proto3" json:"transition,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *FrontendEvent) Reset() {
|
|
*x = FrontendEvent{}
|
|
mi := &file_proto_maglev_proto_msgTypes[40]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *FrontendEvent) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*FrontendEvent) ProtoMessage() {}
|
|
|
|
func (x *FrontendEvent) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[40]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use FrontendEvent.ProtoReflect.Descriptor instead.
|
|
func (*FrontendEvent) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{40}
|
|
}
|
|
|
|
func (x *FrontendEvent) GetFrontendName() string {
|
|
if x != nil {
|
|
return x.FrontendName
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *FrontendEvent) GetTransition() *TransitionRecord {
|
|
if x != nil {
|
|
return x.Transition
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Event is the envelope returned by WatchEvents.
|
|
type Event struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
// Types that are valid to be assigned to Event:
|
|
//
|
|
// *Event_Log
|
|
// *Event_Backend
|
|
// *Event_Frontend
|
|
Event isEvent_Event `protobuf_oneof:"event"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *Event) Reset() {
|
|
*x = Event{}
|
|
mi := &file_proto_maglev_proto_msgTypes[41]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *Event) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*Event) ProtoMessage() {}
|
|
|
|
func (x *Event) ProtoReflect() protoreflect.Message {
|
|
mi := &file_proto_maglev_proto_msgTypes[41]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use Event.ProtoReflect.Descriptor instead.
|
|
func (*Event) Descriptor() ([]byte, []int) {
|
|
return file_proto_maglev_proto_rawDescGZIP(), []int{41}
|
|
}
|
|
|
|
func (x *Event) GetEvent() isEvent_Event {
|
|
if x != nil {
|
|
return x.Event
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Event) GetLog() *LogEvent {
|
|
if x != nil {
|
|
if x, ok := x.Event.(*Event_Log); ok {
|
|
return x.Log
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Event) GetBackend() *BackendEvent {
|
|
if x != nil {
|
|
if x, ok := x.Event.(*Event_Backend); ok {
|
|
return x.Backend
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Event) GetFrontend() *FrontendEvent {
|
|
if x != nil {
|
|
if x, ok := x.Event.(*Event_Frontend); ok {
|
|
return x.Frontend
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type isEvent_Event interface {
|
|
isEvent_Event()
|
|
}
|
|
|
|
type Event_Log struct {
|
|
Log *LogEvent `protobuf:"bytes,1,opt,name=log,proto3,oneof"`
|
|
}
|
|
|
|
type Event_Backend struct {
|
|
Backend *BackendEvent `protobuf:"bytes,2,opt,name=backend,proto3,oneof"`
|
|
}
|
|
|
|
type Event_Frontend struct {
|
|
Frontend *FrontendEvent `protobuf:"bytes,3,opt,name=frontend,proto3,oneof"`
|
|
}
|
|
|
|
func (*Event_Log) isEvent_Event() {}
|
|
|
|
func (*Event_Backend) isEvent_Event() {}
|
|
|
|
func (*Event_Frontend) isEvent_Event() {}
|
|
|
|
var File_proto_maglev_proto protoreflect.FileDescriptor
|
|
|
|
const file_proto_maglev_proto_rawDesc = "" +
|
|
"\n" +
|
|
"\x12proto/maglev.proto\x12\x06maglev\"\x16\n" +
|
|
"\x14ListFrontendsRequest\"(\n" +
|
|
"\x12GetFrontendRequest\x12\x12\n" +
|
|
"\x04name\x18\x01 \x01(\tR\x04name\"\x15\n" +
|
|
"\x13ListBackendsRequest\"'\n" +
|
|
"\x11GetBackendRequest\x12\x12\n" +
|
|
"\x04name\x18\x01 \x01(\tR\x04name\"$\n" +
|
|
"\x0eBackendRequest\x12\x12\n" +
|
|
"\x04name\x18\x01 \x01(\tR\x04name\"\x19\n" +
|
|
"\x17ListHealthChecksRequest\"+\n" +
|
|
"\x15GetHealthCheckRequest\x12\x12\n" +
|
|
"\x04name\x18\x01 \x01(\tR\x04name\"\x14\n" +
|
|
"\x12CheckConfigRequest\"m\n" +
|
|
"\x13CheckConfigResponse\x12\x0e\n" +
|
|
"\x02ok\x18\x01 \x01(\bR\x02ok\x12\x1f\n" +
|
|
"\vparse_error\x18\x02 \x01(\tR\n" +
|
|
"parseError\x12%\n" +
|
|
"\x0esemantic_error\x18\x03 \x01(\tR\rsemanticError\"\x15\n" +
|
|
"\x13ReloadConfigRequest\"\x91\x01\n" +
|
|
"\x14ReloadConfigResponse\x12\x0e\n" +
|
|
"\x02ok\x18\x01 \x01(\bR\x02ok\x12\x1f\n" +
|
|
"\vparse_error\x18\x02 \x01(\tR\n" +
|
|
"parseError\x12%\n" +
|
|
"\x0esemantic_error\x18\x03 \x01(\tR\rsemanticError\x12!\n" +
|
|
"\freload_error\x18\x04 \x01(\tR\vreloadError\"\x13\n" +
|
|
"\x11GetVPPInfoRequest\"\xc5\x01\n" +
|
|
"\aVPPInfo\x12\x18\n" +
|
|
"\aversion\x18\x01 \x01(\tR\aversion\x12\x1d\n" +
|
|
"\n" +
|
|
"build_date\x18\x02 \x01(\tR\tbuildDate\x12'\n" +
|
|
"\x0fbuild_directory\x18\x03 \x01(\tR\x0ebuildDirectory\x12\x10\n" +
|
|
"\x03pid\x18\x04 \x01(\rR\x03pid\x12\x1f\n" +
|
|
"\vboottime_ns\x18\x05 \x01(\x03R\n" +
|
|
"boottimeNs\x12%\n" +
|
|
"\x0econnecttime_ns\x18\x06 \x01(\x03R\rconnecttimeNs\"\x16\n" +
|
|
"\x14GetVPPLBStateRequest\"\xb5\x01\n" +
|
|
"\tVPPLBConf\x12&\n" +
|
|
"\x0fip4_src_address\x18\x01 \x01(\tR\rip4SrcAddress\x12&\n" +
|
|
"\x0fip6_src_address\x18\x02 \x01(\tR\rip6SrcAddress\x125\n" +
|
|
"\x17sticky_buckets_per_core\x18\x03 \x01(\rR\x14stickyBucketsPerCore\x12!\n" +
|
|
"\fflow_timeout\x18\x04 \x01(\rR\vflowTimeout\"\x99\x01\n" +
|
|
"\aVPPLBAS\x12\x18\n" +
|
|
"\aaddress\x18\x01 \x01(\tR\aaddress\x12\x16\n" +
|
|
"\x06weight\x18\x02 \x01(\rR\x06weight\x12\x14\n" +
|
|
"\x05flags\x18\x03 \x01(\rR\x05flags\x12\x1f\n" +
|
|
"\vnum_buckets\x18\x04 \x01(\rR\n" +
|
|
"numBuckets\x12%\n" +
|
|
"\x0fin_use_since_ns\x18\x05 \x01(\x03R\finUseSinceNs\"\xfa\x01\n" +
|
|
"\bVPPLBVIP\x12\x16\n" +
|
|
"\x06prefix\x18\x01 \x01(\tR\x06prefix\x12\x1a\n" +
|
|
"\bprotocol\x18\x02 \x01(\rR\bprotocol\x12\x12\n" +
|
|
"\x04port\x18\x03 \x01(\rR\x04port\x12\x14\n" +
|
|
"\x05encap\x18\x04 \x01(\tR\x05encap\x12*\n" +
|
|
"\x11flow_table_length\x18\x05 \x01(\rR\x0fflowTableLength\x12@\n" +
|
|
"\x13application_servers\x18\x06 \x03(\v2\x0f.maglev.VPPLBASR\x12applicationServers\x12\"\n" +
|
|
"\rsrc_ip_sticky\x18\a \x01(\bR\vsrcIpSticky\"Y\n" +
|
|
"\n" +
|
|
"VPPLBState\x12%\n" +
|
|
"\x04conf\x18\x01 \x01(\v2\x11.maglev.VPPLBConfR\x04conf\x12$\n" +
|
|
"\x04vips\x18\x02 \x03(\v2\x10.maglev.VPPLBVIPR\x04vips\"S\n" +
|
|
"\x15SyncVPPLBStateRequest\x12(\n" +
|
|
"\rfrontend_name\x18\x01 \x01(\tH\x00R\ffrontendName\x88\x01\x01B\x10\n" +
|
|
"\x0e_frontend_name\"\x18\n" +
|
|
"\x16SyncVPPLBStateResponse\"\x19\n" +
|
|
"\x17GetVPPLBCountersRequest\"\x96\x02\n" +
|
|
"\x10VPPLBVIPCounters\x12\x16\n" +
|
|
"\x06prefix\x18\x01 \x01(\tR\x06prefix\x12\x1a\n" +
|
|
"\bprotocol\x18\x02 \x01(\tR\bprotocol\x12\x12\n" +
|
|
"\x04port\x18\x03 \x01(\rR\x04port\x12\x1f\n" +
|
|
"\vnext_packet\x18\x04 \x01(\x04R\n" +
|
|
"nextPacket\x12!\n" +
|
|
"\ffirst_packet\x18\x05 \x01(\x04R\vfirstPacket\x12)\n" +
|
|
"\x10untracked_packet\x18\x06 \x01(\x04R\x0funtrackedPacket\x12\x1b\n" +
|
|
"\tno_server\x18\a \x01(\x04R\bnoServer\x12\x18\n" +
|
|
"\apackets\x18\b \x01(\x04R\apackets\x12\x14\n" +
|
|
"\x05bytes\x18\t \x01(\x04R\x05bytes\"z\n" +
|
|
"\x14VPPLBBackendCounters\x12\x18\n" +
|
|
"\abackend\x18\x01 \x01(\tR\abackend\x12\x18\n" +
|
|
"\aaddress\x18\x02 \x01(\tR\aaddress\x12\x18\n" +
|
|
"\apackets\x18\x03 \x01(\x04R\apackets\x12\x14\n" +
|
|
"\x05bytes\x18\x04 \x01(\x04R\x05bytes\"w\n" +
|
|
"\rVPPLBCounters\x12,\n" +
|
|
"\x04vips\x18\x01 \x03(\v2\x18.maglev.VPPLBVIPCountersR\x04vips\x128\n" +
|
|
"\bbackends\x18\x02 \x03(\v2\x1c.maglev.VPPLBBackendCountersR\bbackends\"\x8a\x01\n" +
|
|
"\x10SetWeightRequest\x12\x1a\n" +
|
|
"\bfrontend\x18\x01 \x01(\tR\bfrontend\x12\x12\n" +
|
|
"\x04pool\x18\x02 \x01(\tR\x04pool\x12\x18\n" +
|
|
"\abackend\x18\x03 \x01(\tR\abackend\x12\x16\n" +
|
|
"\x06weight\x18\x04 \x01(\x05R\x06weight\x12\x14\n" +
|
|
"\x05flush\x18\x05 \x01(\bR\x05flush\"\xa3\x01\n" +
|
|
"\fWatchRequest\x12\x15\n" +
|
|
"\x03log\x18\x01 \x01(\bH\x00R\x03log\x88\x01\x01\x12\x1b\n" +
|
|
"\tlog_level\x18\x02 \x01(\tR\blogLevel\x12\x1d\n" +
|
|
"\abackend\x18\x03 \x01(\bH\x01R\abackend\x88\x01\x01\x12\x1f\n" +
|
|
"\bfrontend\x18\x04 \x01(\bH\x02R\bfrontend\x88\x01\x01B\x06\n" +
|
|
"\x04_logB\n" +
|
|
"\n" +
|
|
"\b_backendB\v\n" +
|
|
"\t_frontend\">\n" +
|
|
"\x15ListFrontendsResponse\x12%\n" +
|
|
"\x0efrontend_names\x18\x01 \x03(\tR\rfrontendNames\"h\n" +
|
|
"\x0fPoolBackendInfo\x12\x12\n" +
|
|
"\x04name\x18\x01 \x01(\tR\x04name\x12\x16\n" +
|
|
"\x06weight\x18\x02 \x01(\x05R\x06weight\x12)\n" +
|
|
"\x10effective_weight\x18\x03 \x01(\x05R\x0feffectiveWeight\"S\n" +
|
|
"\bPoolInfo\x12\x12\n" +
|
|
"\x04name\x18\x01 \x01(\tR\x04name\x123\n" +
|
|
"\bbackends\x18\x02 \x03(\v2\x17.maglev.PoolBackendInfoR\bbackends\"\xda\x01\n" +
|
|
"\fFrontendInfo\x12\x12\n" +
|
|
"\x04name\x18\x01 \x01(\tR\x04name\x12\x18\n" +
|
|
"\aaddress\x18\x02 \x01(\tR\aaddress\x12\x1a\n" +
|
|
"\bprotocol\x18\x03 \x01(\tR\bprotocol\x12\x12\n" +
|
|
"\x04port\x18\x04 \x01(\rR\x04port\x12&\n" +
|
|
"\x05pools\x18\x05 \x03(\v2\x10.maglev.PoolInfoR\x05pools\x12 \n" +
|
|
"\vdescription\x18\x06 \x01(\tR\vdescription\x12\"\n" +
|
|
"\rsrc_ip_sticky\x18\a \x01(\bR\vsrcIpSticky\";\n" +
|
|
"\x14ListBackendsResponse\x12#\n" +
|
|
"\rbackend_names\x18\x01 \x03(\tR\fbackendNames\"0\n" +
|
|
"\x18ListHealthChecksResponse\x12\x14\n" +
|
|
"\x05names\x18\x01 \x03(\tR\x05names\"\x8d\x02\n" +
|
|
"\x0fHTTPCheckParams\x12\x12\n" +
|
|
"\x04path\x18\x01 \x01(\tR\x04path\x12\x12\n" +
|
|
"\x04host\x18\x02 \x01(\tR\x04host\x12*\n" +
|
|
"\x11response_code_min\x18\x03 \x01(\x05R\x0fresponseCodeMin\x12*\n" +
|
|
"\x11response_code_max\x18\x04 \x01(\x05R\x0fresponseCodeMax\x12'\n" +
|
|
"\x0fresponse_regexp\x18\x05 \x01(\tR\x0eresponseRegexp\x12\x1f\n" +
|
|
"\vserver_name\x18\x06 \x01(\tR\n" +
|
|
"serverName\x120\n" +
|
|
"\x14insecure_skip_verify\x18\a \x01(\bR\x12insecureSkipVerify\"u\n" +
|
|
"\x0eTCPCheckParams\x12\x10\n" +
|
|
"\x03ssl\x18\x01 \x01(\bR\x03ssl\x12\x1f\n" +
|
|
"\vserver_name\x18\x02 \x01(\tR\n" +
|
|
"serverName\x120\n" +
|
|
"\x14insecure_skip_verify\x18\x03 \x01(\bR\x12insecureSkipVerify\"\xac\x03\n" +
|
|
"\x0fHealthCheckInfo\x12\x12\n" +
|
|
"\x04name\x18\x01 \x01(\tR\x04name\x12\x12\n" +
|
|
"\x04type\x18\x02 \x01(\tR\x04type\x12\x12\n" +
|
|
"\x04port\x18\x03 \x01(\rR\x04port\x12$\n" +
|
|
"\x0eprobe_ipv4_src\x18\x04 \x01(\tR\fprobeIpv4Src\x12$\n" +
|
|
"\x0eprobe_ipv6_src\x18\x05 \x01(\tR\fprobeIpv6Src\x12\x1f\n" +
|
|
"\vinterval_ns\x18\x06 \x01(\x03R\n" +
|
|
"intervalNs\x12(\n" +
|
|
"\x10fast_interval_ns\x18\a \x01(\x03R\x0efastIntervalNs\x12(\n" +
|
|
"\x10down_interval_ns\x18\b \x01(\x03R\x0edownIntervalNs\x12\x1d\n" +
|
|
"\n" +
|
|
"timeout_ns\x18\t \x01(\x03R\ttimeoutNs\x12\x12\n" +
|
|
"\x04rise\x18\n" +
|
|
" \x01(\x05R\x04rise\x12\x12\n" +
|
|
"\x04fall\x18\v \x01(\x05R\x04fall\x12+\n" +
|
|
"\x04http\x18\f \x01(\v2\x17.maglev.HTTPCheckParamsR\x04http\x12(\n" +
|
|
"\x03tcp\x18\r \x01(\v2\x16.maglev.TCPCheckParamsR\x03tcp\"\xc9\x01\n" +
|
|
"\vBackendInfo\x12\x12\n" +
|
|
"\x04name\x18\x01 \x01(\tR\x04name\x12\x18\n" +
|
|
"\aaddress\x18\x02 \x01(\tR\aaddress\x12\x14\n" +
|
|
"\x05state\x18\x03 \x01(\tR\x05state\x12:\n" +
|
|
"\vtransitions\x18\x04 \x03(\v2\x18.maglev.TransitionRecordR\vtransitions\x12\x18\n" +
|
|
"\aenabled\x18\x05 \x01(\bR\aenabled\x12 \n" +
|
|
"\vhealthcheck\x18\x06 \x01(\tR\vhealthcheck\"T\n" +
|
|
"\x10TransitionRecord\x12\x12\n" +
|
|
"\x04from\x18\x01 \x01(\tR\x04from\x12\x0e\n" +
|
|
"\x02to\x18\x02 \x01(\tR\x02to\x12\x1c\n" +
|
|
"\n" +
|
|
"at_unix_ns\x18\x03 \x01(\x03R\batUnixNs\"1\n" +
|
|
"\aLogAttr\x12\x10\n" +
|
|
"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
|
|
"\x05value\x18\x02 \x01(\tR\x05value\"w\n" +
|
|
"\bLogEvent\x12\x1c\n" +
|
|
"\n" +
|
|
"at_unix_ns\x18\x01 \x01(\x03R\batUnixNs\x12\x14\n" +
|
|
"\x05level\x18\x02 \x01(\tR\x05level\x12\x10\n" +
|
|
"\x03msg\x18\x03 \x01(\tR\x03msg\x12%\n" +
|
|
"\x05attrs\x18\x04 \x03(\v2\x0f.maglev.LogAttrR\x05attrs\"k\n" +
|
|
"\fBackendEvent\x12!\n" +
|
|
"\fbackend_name\x18\x01 \x01(\tR\vbackendName\x128\n" +
|
|
"\n" +
|
|
"transition\x18\x02 \x01(\v2\x18.maglev.TransitionRecordR\n" +
|
|
"transition\"n\n" +
|
|
"\rFrontendEvent\x12#\n" +
|
|
"\rfrontend_name\x18\x01 \x01(\tR\ffrontendName\x128\n" +
|
|
"\n" +
|
|
"transition\x18\x02 \x01(\v2\x18.maglev.TransitionRecordR\n" +
|
|
"transition\"\x9d\x01\n" +
|
|
"\x05Event\x12$\n" +
|
|
"\x03log\x18\x01 \x01(\v2\x10.maglev.LogEventH\x00R\x03log\x120\n" +
|
|
"\abackend\x18\x02 \x01(\v2\x14.maglev.BackendEventH\x00R\abackend\x123\n" +
|
|
"\bfrontend\x18\x03 \x01(\v2\x15.maglev.FrontendEventH\x00R\bfrontendB\a\n" +
|
|
"\x05event2\xec\t\n" +
|
|
"\x06Maglev\x12L\n" +
|
|
"\rListFrontends\x12\x1c.maglev.ListFrontendsRequest\x1a\x1d.maglev.ListFrontendsResponse\x12?\n" +
|
|
"\vGetFrontend\x12\x1a.maglev.GetFrontendRequest\x1a\x14.maglev.FrontendInfo\x12I\n" +
|
|
"\fListBackends\x12\x1b.maglev.ListBackendsRequest\x1a\x1c.maglev.ListBackendsResponse\x12<\n" +
|
|
"\n" +
|
|
"GetBackend\x12\x19.maglev.GetBackendRequest\x1a\x13.maglev.BackendInfo\x12;\n" +
|
|
"\fPauseBackend\x12\x16.maglev.BackendRequest\x1a\x13.maglev.BackendInfo\x12<\n" +
|
|
"\rResumeBackend\x12\x16.maglev.BackendRequest\x1a\x13.maglev.BackendInfo\x12<\n" +
|
|
"\rEnableBackend\x12\x16.maglev.BackendRequest\x1a\x13.maglev.BackendInfo\x12=\n" +
|
|
"\x0eDisableBackend\x12\x16.maglev.BackendRequest\x1a\x13.maglev.BackendInfo\x12U\n" +
|
|
"\x10ListHealthChecks\x12\x1f.maglev.ListHealthChecksRequest\x1a .maglev.ListHealthChecksResponse\x12H\n" +
|
|
"\x0eGetHealthCheck\x12\x1d.maglev.GetHealthCheckRequest\x1a\x17.maglev.HealthCheckInfo\x12N\n" +
|
|
"\x1cSetFrontendPoolBackendWeight\x12\x18.maglev.SetWeightRequest\x1a\x14.maglev.FrontendInfo\x124\n" +
|
|
"\vWatchEvents\x12\x14.maglev.WatchRequest\x1a\r.maglev.Event0\x01\x12F\n" +
|
|
"\vCheckConfig\x12\x1a.maglev.CheckConfigRequest\x1a\x1b.maglev.CheckConfigResponse\x12I\n" +
|
|
"\fReloadConfig\x12\x1b.maglev.ReloadConfigRequest\x1a\x1c.maglev.ReloadConfigResponse\x128\n" +
|
|
"\n" +
|
|
"GetVPPInfo\x12\x19.maglev.GetVPPInfoRequest\x1a\x0f.maglev.VPPInfo\x12A\n" +
|
|
"\rGetVPPLBState\x12\x1c.maglev.GetVPPLBStateRequest\x1a\x12.maglev.VPPLBState\x12O\n" +
|
|
"\x0eSyncVPPLBState\x12\x1d.maglev.SyncVPPLBStateRequest\x1a\x1e.maglev.SyncVPPLBStateResponse\x12J\n" +
|
|
"\x10GetVPPLBCounters\x12\x1f.maglev.GetVPPLBCountersRequest\x1a\x15.maglev.VPPLBCountersB.Z,git.ipng.ch/ipng/vpp-maglev/internal/grpcapib\x06proto3"
|
|
|
|
var (
|
|
file_proto_maglev_proto_rawDescOnce sync.Once
|
|
file_proto_maglev_proto_rawDescData []byte
|
|
)
|
|
|
|
func file_proto_maglev_proto_rawDescGZIP() []byte {
|
|
file_proto_maglev_proto_rawDescOnce.Do(func() {
|
|
file_proto_maglev_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_proto_maglev_proto_rawDesc), len(file_proto_maglev_proto_rawDesc)))
|
|
})
|
|
return file_proto_maglev_proto_rawDescData
|
|
}
|
|
|
|
var file_proto_maglev_proto_msgTypes = make([]protoimpl.MessageInfo, 42)
|
|
var file_proto_maglev_proto_goTypes = []any{
|
|
(*ListFrontendsRequest)(nil), // 0: maglev.ListFrontendsRequest
|
|
(*GetFrontendRequest)(nil), // 1: maglev.GetFrontendRequest
|
|
(*ListBackendsRequest)(nil), // 2: maglev.ListBackendsRequest
|
|
(*GetBackendRequest)(nil), // 3: maglev.GetBackendRequest
|
|
(*BackendRequest)(nil), // 4: maglev.BackendRequest
|
|
(*ListHealthChecksRequest)(nil), // 5: maglev.ListHealthChecksRequest
|
|
(*GetHealthCheckRequest)(nil), // 6: maglev.GetHealthCheckRequest
|
|
(*CheckConfigRequest)(nil), // 7: maglev.CheckConfigRequest
|
|
(*CheckConfigResponse)(nil), // 8: maglev.CheckConfigResponse
|
|
(*ReloadConfigRequest)(nil), // 9: maglev.ReloadConfigRequest
|
|
(*ReloadConfigResponse)(nil), // 10: maglev.ReloadConfigResponse
|
|
(*GetVPPInfoRequest)(nil), // 11: maglev.GetVPPInfoRequest
|
|
(*VPPInfo)(nil), // 12: maglev.VPPInfo
|
|
(*GetVPPLBStateRequest)(nil), // 13: maglev.GetVPPLBStateRequest
|
|
(*VPPLBConf)(nil), // 14: maglev.VPPLBConf
|
|
(*VPPLBAS)(nil), // 15: maglev.VPPLBAS
|
|
(*VPPLBVIP)(nil), // 16: maglev.VPPLBVIP
|
|
(*VPPLBState)(nil), // 17: maglev.VPPLBState
|
|
(*SyncVPPLBStateRequest)(nil), // 18: maglev.SyncVPPLBStateRequest
|
|
(*SyncVPPLBStateResponse)(nil), // 19: maglev.SyncVPPLBStateResponse
|
|
(*GetVPPLBCountersRequest)(nil), // 20: maglev.GetVPPLBCountersRequest
|
|
(*VPPLBVIPCounters)(nil), // 21: maglev.VPPLBVIPCounters
|
|
(*VPPLBBackendCounters)(nil), // 22: maglev.VPPLBBackendCounters
|
|
(*VPPLBCounters)(nil), // 23: maglev.VPPLBCounters
|
|
(*SetWeightRequest)(nil), // 24: maglev.SetWeightRequest
|
|
(*WatchRequest)(nil), // 25: maglev.WatchRequest
|
|
(*ListFrontendsResponse)(nil), // 26: maglev.ListFrontendsResponse
|
|
(*PoolBackendInfo)(nil), // 27: maglev.PoolBackendInfo
|
|
(*PoolInfo)(nil), // 28: maglev.PoolInfo
|
|
(*FrontendInfo)(nil), // 29: maglev.FrontendInfo
|
|
(*ListBackendsResponse)(nil), // 30: maglev.ListBackendsResponse
|
|
(*ListHealthChecksResponse)(nil), // 31: maglev.ListHealthChecksResponse
|
|
(*HTTPCheckParams)(nil), // 32: maglev.HTTPCheckParams
|
|
(*TCPCheckParams)(nil), // 33: maglev.TCPCheckParams
|
|
(*HealthCheckInfo)(nil), // 34: maglev.HealthCheckInfo
|
|
(*BackendInfo)(nil), // 35: maglev.BackendInfo
|
|
(*TransitionRecord)(nil), // 36: maglev.TransitionRecord
|
|
(*LogAttr)(nil), // 37: maglev.LogAttr
|
|
(*LogEvent)(nil), // 38: maglev.LogEvent
|
|
(*BackendEvent)(nil), // 39: maglev.BackendEvent
|
|
(*FrontendEvent)(nil), // 40: maglev.FrontendEvent
|
|
(*Event)(nil), // 41: maglev.Event
|
|
}
|
|
var file_proto_maglev_proto_depIdxs = []int32{
|
|
15, // 0: maglev.VPPLBVIP.application_servers:type_name -> maglev.VPPLBAS
|
|
14, // 1: maglev.VPPLBState.conf:type_name -> maglev.VPPLBConf
|
|
16, // 2: maglev.VPPLBState.vips:type_name -> maglev.VPPLBVIP
|
|
21, // 3: maglev.VPPLBCounters.vips:type_name -> maglev.VPPLBVIPCounters
|
|
22, // 4: maglev.VPPLBCounters.backends:type_name -> maglev.VPPLBBackendCounters
|
|
27, // 5: maglev.PoolInfo.backends:type_name -> maglev.PoolBackendInfo
|
|
28, // 6: maglev.FrontendInfo.pools:type_name -> maglev.PoolInfo
|
|
32, // 7: maglev.HealthCheckInfo.http:type_name -> maglev.HTTPCheckParams
|
|
33, // 8: maglev.HealthCheckInfo.tcp:type_name -> maglev.TCPCheckParams
|
|
36, // 9: maglev.BackendInfo.transitions:type_name -> maglev.TransitionRecord
|
|
37, // 10: maglev.LogEvent.attrs:type_name -> maglev.LogAttr
|
|
36, // 11: maglev.BackendEvent.transition:type_name -> maglev.TransitionRecord
|
|
36, // 12: maglev.FrontendEvent.transition:type_name -> maglev.TransitionRecord
|
|
38, // 13: maglev.Event.log:type_name -> maglev.LogEvent
|
|
39, // 14: maglev.Event.backend:type_name -> maglev.BackendEvent
|
|
40, // 15: maglev.Event.frontend:type_name -> maglev.FrontendEvent
|
|
0, // 16: maglev.Maglev.ListFrontends:input_type -> maglev.ListFrontendsRequest
|
|
1, // 17: maglev.Maglev.GetFrontend:input_type -> maglev.GetFrontendRequest
|
|
2, // 18: maglev.Maglev.ListBackends:input_type -> maglev.ListBackendsRequest
|
|
3, // 19: maglev.Maglev.GetBackend:input_type -> maglev.GetBackendRequest
|
|
4, // 20: maglev.Maglev.PauseBackend:input_type -> maglev.BackendRequest
|
|
4, // 21: maglev.Maglev.ResumeBackend:input_type -> maglev.BackendRequest
|
|
4, // 22: maglev.Maglev.EnableBackend:input_type -> maglev.BackendRequest
|
|
4, // 23: maglev.Maglev.DisableBackend:input_type -> maglev.BackendRequest
|
|
5, // 24: maglev.Maglev.ListHealthChecks:input_type -> maglev.ListHealthChecksRequest
|
|
6, // 25: maglev.Maglev.GetHealthCheck:input_type -> maglev.GetHealthCheckRequest
|
|
24, // 26: maglev.Maglev.SetFrontendPoolBackendWeight:input_type -> maglev.SetWeightRequest
|
|
25, // 27: maglev.Maglev.WatchEvents:input_type -> maglev.WatchRequest
|
|
7, // 28: maglev.Maglev.CheckConfig:input_type -> maglev.CheckConfigRequest
|
|
9, // 29: maglev.Maglev.ReloadConfig:input_type -> maglev.ReloadConfigRequest
|
|
11, // 30: maglev.Maglev.GetVPPInfo:input_type -> maglev.GetVPPInfoRequest
|
|
13, // 31: maglev.Maglev.GetVPPLBState:input_type -> maglev.GetVPPLBStateRequest
|
|
18, // 32: maglev.Maglev.SyncVPPLBState:input_type -> maglev.SyncVPPLBStateRequest
|
|
20, // 33: maglev.Maglev.GetVPPLBCounters:input_type -> maglev.GetVPPLBCountersRequest
|
|
26, // 34: maglev.Maglev.ListFrontends:output_type -> maglev.ListFrontendsResponse
|
|
29, // 35: maglev.Maglev.GetFrontend:output_type -> maglev.FrontendInfo
|
|
30, // 36: maglev.Maglev.ListBackends:output_type -> maglev.ListBackendsResponse
|
|
35, // 37: maglev.Maglev.GetBackend:output_type -> maglev.BackendInfo
|
|
35, // 38: maglev.Maglev.PauseBackend:output_type -> maglev.BackendInfo
|
|
35, // 39: maglev.Maglev.ResumeBackend:output_type -> maglev.BackendInfo
|
|
35, // 40: maglev.Maglev.EnableBackend:output_type -> maglev.BackendInfo
|
|
35, // 41: maglev.Maglev.DisableBackend:output_type -> maglev.BackendInfo
|
|
31, // 42: maglev.Maglev.ListHealthChecks:output_type -> maglev.ListHealthChecksResponse
|
|
34, // 43: maglev.Maglev.GetHealthCheck:output_type -> maglev.HealthCheckInfo
|
|
29, // 44: maglev.Maglev.SetFrontendPoolBackendWeight:output_type -> maglev.FrontendInfo
|
|
41, // 45: maglev.Maglev.WatchEvents:output_type -> maglev.Event
|
|
8, // 46: maglev.Maglev.CheckConfig:output_type -> maglev.CheckConfigResponse
|
|
10, // 47: maglev.Maglev.ReloadConfig:output_type -> maglev.ReloadConfigResponse
|
|
12, // 48: maglev.Maglev.GetVPPInfo:output_type -> maglev.VPPInfo
|
|
17, // 49: maglev.Maglev.GetVPPLBState:output_type -> maglev.VPPLBState
|
|
19, // 50: maglev.Maglev.SyncVPPLBState:output_type -> maglev.SyncVPPLBStateResponse
|
|
23, // 51: maglev.Maglev.GetVPPLBCounters:output_type -> maglev.VPPLBCounters
|
|
34, // [34:52] is the sub-list for method output_type
|
|
16, // [16:34] is the sub-list for method input_type
|
|
16, // [16:16] is the sub-list for extension type_name
|
|
16, // [16:16] is the sub-list for extension extendee
|
|
0, // [0:16] is the sub-list for field type_name
|
|
}
|
|
|
|
func init() { file_proto_maglev_proto_init() }
|
|
func file_proto_maglev_proto_init() {
|
|
if File_proto_maglev_proto != nil {
|
|
return
|
|
}
|
|
file_proto_maglev_proto_msgTypes[18].OneofWrappers = []any{}
|
|
file_proto_maglev_proto_msgTypes[25].OneofWrappers = []any{}
|
|
file_proto_maglev_proto_msgTypes[41].OneofWrappers = []any{
|
|
(*Event_Log)(nil),
|
|
(*Event_Backend)(nil),
|
|
(*Event_Frontend)(nil),
|
|
}
|
|
type x struct{}
|
|
out := protoimpl.TypeBuilder{
|
|
File: protoimpl.DescBuilder{
|
|
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
|
|
RawDescriptor: unsafe.Slice(unsafe.StringData(file_proto_maglev_proto_rawDesc), len(file_proto_maglev_proto_rawDesc)),
|
|
NumEnums: 0,
|
|
NumMessages: 42,
|
|
NumExtensions: 0,
|
|
NumServices: 1,
|
|
},
|
|
GoTypes: file_proto_maglev_proto_goTypes,
|
|
DependencyIndexes: file_proto_maglev_proto_depIdxs,
|
|
MessageInfos: file_proto_maglev_proto_msgTypes,
|
|
}.Build()
|
|
File_proto_maglev_proto = out.File
|
|
file_proto_maglev_proto_goTypes = nil
|
|
file_proto_maglev_proto_depIdxs = nil
|
|
}
|