#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Request {
#[prost(
oneof = "request::RequestType",
tags = "1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46"
)]
pub request_type: ::core::option::Option<request::RequestType>,
}
pub mod request {
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum RequestType {
#[prost(string, tag = "1")]
SaveState(::prost::alloc::string::String),
#[prost(string, tag = "2")]
LoadState(::prost::alloc::string::String),
#[prost(message, tag = "4")]
ListWorkers(super::ListWorkers),
#[prost(message, tag = "5")]
ListFrontends(super::FrontendFilters),
#[prost(message, tag = "6")]
ListListeners(super::ListListeners),
#[prost(string, tag = "7")]
LaunchWorker(::prost::alloc::string::String),
#[prost(message, tag = "8")]
UpgradeMain(super::UpgradeMain),
#[prost(uint32, tag = "9")]
UpgradeWorker(u32),
#[prost(message, tag = "10")]
SubscribeEvents(super::SubscribeEvents),
#[prost(string, tag = "11")]
ReloadConfiguration(::prost::alloc::string::String),
#[prost(message, tag = "12")]
Status(super::Status),
#[prost(message, tag = "13")]
AddCluster(super::Cluster),
#[prost(string, tag = "14")]
RemoveCluster(::prost::alloc::string::String),
#[prost(message, tag = "15")]
AddHttpFrontend(super::RequestHttpFrontend),
#[prost(message, tag = "16")]
RemoveHttpFrontend(super::RequestHttpFrontend),
#[prost(message, tag = "17")]
AddHttpsFrontend(super::RequestHttpFrontend),
#[prost(message, tag = "18")]
RemoveHttpsFrontend(super::RequestHttpFrontend),
#[prost(message, tag = "19")]
AddCertificate(super::AddCertificate),
#[prost(message, tag = "20")]
ReplaceCertificate(super::ReplaceCertificate),
#[prost(message, tag = "21")]
RemoveCertificate(super::RemoveCertificate),
#[prost(message, tag = "22")]
AddTcpFrontend(super::RequestTcpFrontend),
#[prost(message, tag = "23")]
RemoveTcpFrontend(super::RequestTcpFrontend),
#[prost(message, tag = "24")]
AddBackend(super::AddBackend),
#[prost(message, tag = "25")]
RemoveBackend(super::RemoveBackend),
#[prost(message, tag = "26")]
AddHttpListener(super::HttpListenerConfig),
#[prost(message, tag = "27")]
AddHttpsListener(super::HttpsListenerConfig),
#[prost(message, tag = "28")]
AddTcpListener(super::TcpListenerConfig),
#[prost(message, tag = "29")]
RemoveListener(super::RemoveListener),
#[prost(message, tag = "30")]
ActivateListener(super::ActivateListener),
#[prost(message, tag = "31")]
DeactivateListener(super::DeactivateListener),
#[prost(string, tag = "35")]
QueryClusterById(::prost::alloc::string::String),
#[prost(message, tag = "36")]
QueryClustersByDomain(super::QueryClusterByDomain),
#[prost(message, tag = "37")]
QueryClustersHashes(super::QueryClustersHashes),
#[prost(message, tag = "38")]
QueryMetrics(super::QueryMetricsOptions),
#[prost(message, tag = "39")]
SoftStop(super::SoftStop),
#[prost(message, tag = "40")]
HardStop(super::HardStop),
#[prost(enumeration = "super::MetricsConfiguration", tag = "41")]
ConfigureMetrics(i32),
#[prost(string, tag = "42")]
Logging(::prost::alloc::string::String),
#[prost(message, tag = "43")]
ReturnListenSockets(super::ReturnListenSockets),
#[prost(message, tag = "44")]
QueryCertificatesFromTheState(super::QueryCertificatesFilters),
#[prost(message, tag = "45")]
QueryCertificatesFromWorkers(super::QueryCertificatesFilters),
#[prost(message, tag = "46")]
CountRequests(super::CountRequests),
}
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListWorkers {}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListListeners {}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpgradeMain {}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SubscribeEvents {}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Status {}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryClustersHashes {}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SoftStop {}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HardStop {}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ReturnListenSockets {}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CountRequests {}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HttpListenerConfig {
#[prost(message, required, tag = "1")]
pub address: SocketAddress,
#[prost(message, optional, tag = "2")]
pub public_address: ::core::option::Option<SocketAddress>,
#[prost(bool, required, tag = "5", default = "false")]
pub expect_proxy: bool,
#[prost(string, required, tag = "6")]
pub sticky_name: ::prost::alloc::string::String,
#[prost(uint32, required, tag = "7", default = "60")]
pub front_timeout: u32,
#[prost(uint32, required, tag = "8", default = "30")]
pub back_timeout: u32,
#[prost(uint32, required, tag = "9", default = "3")]
pub connect_timeout: u32,
#[prost(uint32, required, tag = "10", default = "10")]
pub request_timeout: u32,
#[prost(bool, required, tag = "11", default = "false")]
pub active: bool,
#[prost(message, optional, tag = "12")]
pub http_answers: ::core::option::Option<CustomHttpAnswers>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HttpsListenerConfig {
#[prost(message, required, tag = "1")]
pub address: SocketAddress,
#[prost(message, optional, tag = "2")]
pub public_address: ::core::option::Option<SocketAddress>,
#[prost(bool, required, tag = "5", default = "false")]
pub expect_proxy: bool,
#[prost(string, required, tag = "6")]
pub sticky_name: ::prost::alloc::string::String,
#[prost(uint32, required, tag = "7", default = "60")]
pub front_timeout: u32,
#[prost(uint32, required, tag = "8", default = "30")]
pub back_timeout: u32,
#[prost(uint32, required, tag = "9", default = "3")]
pub connect_timeout: u32,
#[prost(uint32, required, tag = "10", default = "10")]
pub request_timeout: u32,
#[prost(bool, required, tag = "11", default = "false")]
pub active: bool,
#[prost(enumeration = "TlsVersion", repeated, packed = "false", tag = "12")]
pub versions: ::prost::alloc::vec::Vec<i32>,
#[prost(string, repeated, tag = "13")]
pub cipher_list: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
#[prost(string, repeated, tag = "14")]
pub cipher_suites: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
#[prost(string, repeated, tag = "15")]
pub signature_algorithms: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
#[prost(string, repeated, tag = "16")]
pub groups_list: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
#[prost(string, optional, tag = "17")]
pub certificate: ::core::option::Option<::prost::alloc::string::String>,
#[prost(string, repeated, tag = "18")]
pub certificate_chain: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
#[prost(string, optional, tag = "19")]
pub key: ::core::option::Option<::prost::alloc::string::String>,
#[prost(uint64, required, tag = "20")]
pub send_tls13_tickets: u64,
#[prost(message, optional, tag = "21")]
pub http_answers: ::core::option::Option<CustomHttpAnswers>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TcpListenerConfig {
#[prost(message, required, tag = "1")]
pub address: SocketAddress,
#[prost(message, optional, tag = "2")]
pub public_address: ::core::option::Option<SocketAddress>,
#[prost(bool, required, tag = "3", default = "false")]
pub expect_proxy: bool,
#[prost(uint32, required, tag = "4", default = "60")]
pub front_timeout: u32,
#[prost(uint32, required, tag = "5", default = "30")]
pub back_timeout: u32,
#[prost(uint32, required, tag = "6", default = "3")]
pub connect_timeout: u32,
#[prost(bool, required, tag = "7", default = "false")]
pub active: bool,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CustomHttpAnswers {
#[prost(string, optional, tag = "1")]
pub answer_301: ::core::option::Option<::prost::alloc::string::String>,
#[prost(string, optional, tag = "2")]
pub answer_400: ::core::option::Option<::prost::alloc::string::String>,
#[prost(string, optional, tag = "3")]
pub answer_401: ::core::option::Option<::prost::alloc::string::String>,
#[prost(string, optional, tag = "4")]
pub answer_404: ::core::option::Option<::prost::alloc::string::String>,
#[prost(string, optional, tag = "5")]
pub answer_408: ::core::option::Option<::prost::alloc::string::String>,
#[prost(string, optional, tag = "6")]
pub answer_413: ::core::option::Option<::prost::alloc::string::String>,
#[prost(string, optional, tag = "7")]
pub answer_502: ::core::option::Option<::prost::alloc::string::String>,
#[prost(string, optional, tag = "8")]
pub answer_503: ::core::option::Option<::prost::alloc::string::String>,
#[prost(string, optional, tag = "9")]
pub answer_504: ::core::option::Option<::prost::alloc::string::String>,
#[prost(string, optional, tag = "10")]
pub answer_507: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ActivateListener {
#[prost(message, required, tag = "1")]
pub address: SocketAddress,
#[prost(enumeration = "ListenerType", required, tag = "2")]
pub proxy: i32,
#[prost(bool, required, tag = "3")]
pub from_scm: bool,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeactivateListener {
#[prost(message, required, tag = "1")]
pub address: SocketAddress,
#[prost(enumeration = "ListenerType", required, tag = "2")]
pub proxy: i32,
#[prost(bool, required, tag = "3")]
pub to_scm: bool,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RemoveListener {
#[prost(message, required, tag = "1")]
pub address: SocketAddress,
#[prost(enumeration = "ListenerType", required, tag = "2")]
pub proxy: i32,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListenersList {
#[prost(btree_map = "string, message", tag = "1")]
pub http_listeners: ::prost::alloc::collections::BTreeMap<
::prost::alloc::string::String,
HttpListenerConfig,
>,
#[prost(btree_map = "string, message", tag = "2")]
pub https_listeners: ::prost::alloc::collections::BTreeMap<
::prost::alloc::string::String,
HttpsListenerConfig,
>,
#[prost(btree_map = "string, message", tag = "3")]
pub tcp_listeners: ::prost::alloc::collections::BTreeMap<
::prost::alloc::string::String,
TcpListenerConfig,
>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RequestHttpFrontend {
#[prost(string, optional, tag = "1")]
pub cluster_id: ::core::option::Option<::prost::alloc::string::String>,
#[prost(message, required, tag = "2")]
pub address: SocketAddress,
#[prost(string, required, tag = "3")]
pub hostname: ::prost::alloc::string::String,
#[prost(message, required, tag = "4")]
pub path: PathRule,
#[prost(string, optional, tag = "5")]
pub method: ::core::option::Option<::prost::alloc::string::String>,
#[prost(enumeration = "RulePosition", required, tag = "6", default = "Tree")]
pub position: i32,
#[prost(btree_map = "string, string", tag = "7")]
pub tags: ::prost::alloc::collections::BTreeMap<
::prost::alloc::string::String,
::prost::alloc::string::String,
>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RequestTcpFrontend {
#[prost(string, required, tag = "1")]
pub cluster_id: ::prost::alloc::string::String,
#[prost(message, required, tag = "2")]
pub address: SocketAddress,
#[prost(btree_map = "string, string", tag = "3")]
pub tags: ::prost::alloc::collections::BTreeMap<
::prost::alloc::string::String,
::prost::alloc::string::String,
>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FrontendFilters {
#[prost(bool, required, tag = "1")]
pub http: bool,
#[prost(bool, required, tag = "2")]
pub https: bool,
#[prost(bool, required, tag = "3")]
pub tcp: bool,
#[prost(string, optional, tag = "4")]
pub domain: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PathRule {
#[prost(enumeration = "PathRuleKind", required, tag = "1")]
pub kind: i32,
#[prost(string, required, tag = "2")]
pub value: ::prost::alloc::string::String,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AddCertificate {
#[prost(message, required, tag = "1")]
pub address: SocketAddress,
#[prost(message, required, tag = "2")]
pub certificate: CertificateAndKey,
#[prost(int64, optional, tag = "3")]
pub expired_at: ::core::option::Option<i64>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RemoveCertificate {
#[prost(message, required, tag = "1")]
pub address: SocketAddress,
#[prost(string, required, tag = "2")]
pub fingerprint: ::prost::alloc::string::String,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ReplaceCertificate {
#[prost(message, required, tag = "1")]
pub address: SocketAddress,
#[prost(message, required, tag = "2")]
pub new_certificate: CertificateAndKey,
#[prost(string, required, tag = "3")]
pub old_fingerprint: ::prost::alloc::string::String,
#[prost(int64, optional, tag = "4")]
pub new_expired_at: ::core::option::Option<i64>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CertificateAndKey {
#[prost(string, required, tag = "1")]
pub certificate: ::prost::alloc::string::String,
#[prost(string, repeated, tag = "2")]
pub certificate_chain: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
#[prost(string, required, tag = "3")]
pub key: ::prost::alloc::string::String,
#[prost(enumeration = "TlsVersion", repeated, packed = "false", tag = "4")]
pub versions: ::prost::alloc::vec::Vec<i32>,
#[prost(string, repeated, tag = "5")]
pub names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryCertificatesFilters {
#[prost(string, optional, tag = "1")]
pub domain: ::core::option::Option<::prost::alloc::string::String>,
#[prost(string, optional, tag = "2")]
pub fingerprint: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CertificateSummary {
#[prost(string, required, tag = "1")]
pub domain: ::prost::alloc::string::String,
#[prost(string, required, tag = "2")]
pub fingerprint: ::prost::alloc::string::String,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListOfCertificatesByAddress {
#[prost(message, repeated, tag = "1")]
pub certificates: ::prost::alloc::vec::Vec<CertificatesByAddress>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CertificatesByAddress {
#[prost(message, required, tag = "1")]
pub address: SocketAddress,
#[prost(message, repeated, tag = "2")]
pub certificate_summaries: ::prost::alloc::vec::Vec<CertificateSummary>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CertificatesWithFingerprints {
#[prost(btree_map = "string, message", tag = "1")]
pub certs: ::prost::alloc::collections::BTreeMap<
::prost::alloc::string::String,
CertificateAndKey,
>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Cluster {
#[prost(string, required, tag = "1")]
pub cluster_id: ::prost::alloc::string::String,
#[prost(bool, required, tag = "2")]
pub sticky_session: bool,
#[prost(bool, required, tag = "3")]
pub https_redirect: bool,
#[prost(enumeration = "ProxyProtocolConfig", optional, tag = "4")]
pub proxy_protocol: ::core::option::Option<i32>,
#[prost(
enumeration = "LoadBalancingAlgorithms",
required,
tag = "5",
default = "RoundRobin"
)]
pub load_balancing: i32,
#[prost(string, optional, tag = "6")]
pub answer_503: ::core::option::Option<::prost::alloc::string::String>,
#[prost(enumeration = "LoadMetric", optional, tag = "7")]
pub load_metric: ::core::option::Option<i32>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AddBackend {
#[prost(string, required, tag = "1")]
pub cluster_id: ::prost::alloc::string::String,
#[prost(string, required, tag = "2")]
pub backend_id: ::prost::alloc::string::String,
#[prost(message, required, tag = "3")]
pub address: SocketAddress,
#[prost(string, optional, tag = "4")]
pub sticky_id: ::core::option::Option<::prost::alloc::string::String>,
#[prost(message, optional, tag = "5")]
pub load_balancing_parameters: ::core::option::Option<LoadBalancingParams>,
#[prost(bool, optional, tag = "6")]
pub backup: ::core::option::Option<bool>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RemoveBackend {
#[prost(string, required, tag = "1")]
pub cluster_id: ::prost::alloc::string::String,
#[prost(string, required, tag = "2")]
pub backend_id: ::prost::alloc::string::String,
#[prost(message, required, tag = "3")]
pub address: SocketAddress,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LoadBalancingParams {
#[prost(int32, required, tag = "1")]
pub weight: i32,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryClusterByDomain {
#[prost(string, required, tag = "1")]
pub hostname: ::prost::alloc::string::String,
#[prost(string, optional, tag = "2")]
pub path: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryMetricsOptions {
#[prost(bool, required, tag = "1")]
pub list: bool,
#[prost(string, repeated, tag = "2")]
pub cluster_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
#[prost(string, repeated, tag = "3")]
pub backend_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
#[prost(string, repeated, tag = "4")]
pub metric_names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
#[prost(bool, required, tag = "5")]
pub no_clusters: bool,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Response {
#[prost(enumeration = "ResponseStatus", required, tag = "1", default = "Failure")]
pub status: i32,
#[prost(string, required, tag = "2")]
pub message: ::prost::alloc::string::String,
#[prost(message, optional, tag = "3")]
pub content: ::core::option::Option<ResponseContent>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResponseContent {
#[prost(
oneof = "response_content::ContentType",
tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13"
)]
pub content_type: ::core::option::Option<response_content::ContentType>,
}
pub mod response_content {
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum ContentType {
#[prost(message, tag = "1")]
Workers(super::WorkerInfos),
#[prost(message, tag = "2")]
Metrics(super::AggregatedMetrics),
#[prost(message, tag = "3")]
WorkerResponses(super::WorkerResponses),
#[prost(message, tag = "4")]
Event(super::Event),
#[prost(message, tag = "5")]
FrontendList(super::ListedFrontends),
#[prost(message, tag = "6")]
ListenersList(super::ListenersList),
#[prost(message, tag = "7")]
WorkerMetrics(super::WorkerMetrics),
#[prost(message, tag = "8")]
AvailableMetrics(super::AvailableMetrics),
#[prost(message, tag = "9")]
Clusters(super::ClusterInformations),
#[prost(message, tag = "10")]
ClusterHashes(super::ClusterHashes),
#[prost(message, tag = "11")]
CertificatesByAddress(super::ListOfCertificatesByAddress),
#[prost(message, tag = "12")]
CertificatesWithFingerprints(super::CertificatesWithFingerprints),
#[prost(message, tag = "13")]
RequestCounts(super::RequestCounts),
}
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WorkerResponses {
#[prost(btree_map = "string, message", tag = "1")]
pub map: ::prost::alloc::collections::BTreeMap<
::prost::alloc::string::String,
ResponseContent,
>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListedFrontends {
#[prost(message, repeated, tag = "1")]
pub http_frontends: ::prost::alloc::vec::Vec<RequestHttpFrontend>,
#[prost(message, repeated, tag = "2")]
pub https_frontends: ::prost::alloc::vec::Vec<RequestHttpFrontend>,
#[prost(message, repeated, tag = "3")]
pub tcp_frontends: ::prost::alloc::vec::Vec<RequestTcpFrontend>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ClusterInformations {
#[prost(message, repeated, tag = "1")]
pub vec: ::prost::alloc::vec::Vec<ClusterInformation>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ClusterInformation {
#[prost(message, optional, tag = "1")]
pub configuration: ::core::option::Option<Cluster>,
#[prost(message, repeated, tag = "2")]
pub http_frontends: ::prost::alloc::vec::Vec<RequestHttpFrontend>,
#[prost(message, repeated, tag = "3")]
pub https_frontends: ::prost::alloc::vec::Vec<RequestHttpFrontend>,
#[prost(message, repeated, tag = "4")]
pub tcp_frontends: ::prost::alloc::vec::Vec<RequestTcpFrontend>,
#[prost(message, repeated, tag = "5")]
pub backends: ::prost::alloc::vec::Vec<AddBackend>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Event {
#[prost(enumeration = "EventKind", required, tag = "1")]
pub kind: i32,
#[prost(string, optional, tag = "2")]
pub cluster_id: ::core::option::Option<::prost::alloc::string::String>,
#[prost(string, optional, tag = "3")]
pub backend_id: ::core::option::Option<::prost::alloc::string::String>,
#[prost(message, optional, tag = "4")]
pub address: ::core::option::Option<SocketAddress>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ClusterHashes {
#[prost(btree_map = "string, uint64", tag = "1")]
pub map: ::prost::alloc::collections::BTreeMap<::prost::alloc::string::String, u64>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WorkerInfos {
#[prost(message, repeated, tag = "1")]
pub vec: ::prost::alloc::vec::Vec<WorkerInfo>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WorkerInfo {
#[prost(uint32, required, tag = "1")]
pub id: u32,
#[prost(int32, required, tag = "2")]
pub pid: i32,
#[prost(enumeration = "RunState", required, tag = "3")]
pub run_state: i32,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AvailableMetrics {
#[prost(string, repeated, tag = "1")]
pub proxy_metrics: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
#[prost(string, repeated, tag = "2")]
pub cluster_metrics: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AggregatedMetrics {
#[prost(btree_map = "string, message", tag = "1")]
pub main: ::prost::alloc::collections::BTreeMap<
::prost::alloc::string::String,
FilteredMetrics,
>,
#[prost(btree_map = "string, message", tag = "2")]
pub workers: ::prost::alloc::collections::BTreeMap<
::prost::alloc::string::String,
WorkerMetrics,
>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WorkerMetrics {
#[prost(btree_map = "string, message", tag = "1")]
pub proxy: ::prost::alloc::collections::BTreeMap<
::prost::alloc::string::String,
FilteredMetrics,
>,
#[prost(btree_map = "string, message", tag = "2")]
pub clusters: ::prost::alloc::collections::BTreeMap<
::prost::alloc::string::String,
ClusterMetrics,
>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ClusterMetrics {
#[prost(btree_map = "string, message", tag = "1")]
pub cluster: ::prost::alloc::collections::BTreeMap<
::prost::alloc::string::String,
FilteredMetrics,
>,
#[prost(message, repeated, tag = "2")]
pub backends: ::prost::alloc::vec::Vec<BackendMetrics>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BackendMetrics {
#[prost(string, required, tag = "1")]
pub backend_id: ::prost::alloc::string::String,
#[prost(btree_map = "string, message", tag = "2")]
pub metrics: ::prost::alloc::collections::BTreeMap<
::prost::alloc::string::String,
FilteredMetrics,
>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FilteredMetrics {
#[prost(oneof = "filtered_metrics::Inner", tags = "1, 2, 3, 4, 5")]
pub inner: ::core::option::Option<filtered_metrics::Inner>,
}
pub mod filtered_metrics {
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum Inner {
#[prost(uint64, tag = "1")]
Gauge(u64),
#[prost(int64, tag = "2")]
Count(i64),
#[prost(uint64, tag = "3")]
Time(u64),
#[prost(message, tag = "4")]
Percentiles(super::Percentiles),
#[prost(message, tag = "5")]
TimeSerie(super::FilteredTimeSerie),
}
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FilteredTimeSerie {
#[prost(uint32, required, tag = "1")]
pub last_second: u32,
#[prost(uint32, repeated, packed = "false", tag = "2")]
pub last_minute: ::prost::alloc::vec::Vec<u32>,
#[prost(uint32, repeated, packed = "false", tag = "3")]
pub last_hour: ::prost::alloc::vec::Vec<u32>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Percentiles {
#[prost(uint64, required, tag = "1")]
pub samples: u64,
#[prost(uint64, required, tag = "2")]
pub p_50: u64,
#[prost(uint64, required, tag = "3")]
pub p_90: u64,
#[prost(uint64, required, tag = "4")]
pub p_99: u64,
#[prost(uint64, required, tag = "5")]
pub p_99_9: u64,
#[prost(uint64, required, tag = "6")]
pub p_99_99: u64,
#[prost(uint64, required, tag = "7")]
pub p_99_999: u64,
#[prost(uint64, required, tag = "8")]
pub p_100: u64,
#[prost(uint64, required, tag = "9")]
pub sum: u64,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RequestCounts {
#[prost(btree_map = "string, int32", tag = "1")]
pub map: ::prost::alloc::collections::BTreeMap<::prost::alloc::string::String, i32>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SocketAddress {
#[prost(message, required, tag = "1")]
pub ip: IpAddress,
#[prost(uint32, required, tag = "2")]
pub port: u32,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct IpAddress {
#[prost(oneof = "ip_address::Inner", tags = "1, 2")]
pub inner: ::core::option::Option<ip_address::Inner>,
}
pub mod ip_address {
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum Inner {
#[prost(fixed32, tag = "1")]
V4(u32),
#[prost(message, tag = "2")]
V6(super::Uint128),
}
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Uint128 {
#[prost(uint64, required, tag = "1")]
pub low: u64,
#[prost(uint64, required, tag = "2")]
pub high: u64,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WorkerRequest {
#[prost(string, required, tag = "1")]
pub id: ::prost::alloc::string::String,
#[prost(message, required, tag = "2")]
pub content: Request,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WorkerResponse {
#[prost(string, required, tag = "1")]
pub id: ::prost::alloc::string::String,
#[prost(enumeration = "ResponseStatus", required, tag = "2")]
pub status: i32,
#[prost(string, required, tag = "3")]
pub message: ::prost::alloc::string::String,
#[prost(message, optional, tag = "4")]
pub content: ::core::option::Option<ResponseContent>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ServerMetricsConfig {
#[prost(string, required, tag = "1")]
pub address: ::prost::alloc::string::String,
#[prost(bool, required, tag = "2")]
pub tagged_metrics: bool,
#[prost(string, optional, tag = "3")]
pub prefix: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ServerConfig {
#[prost(uint64, required, tag = "1", default = "10000")]
pub max_connections: u64,
#[prost(uint32, required, tag = "2", default = "60")]
pub front_timeout: u32,
#[prost(uint32, required, tag = "3", default = "30")]
pub back_timeout: u32,
#[prost(uint32, required, tag = "4", default = "3")]
pub connect_timeout: u32,
#[prost(uint32, required, tag = "5", default = "1800")]
pub zombie_check_interval: u32,
#[prost(uint32, required, tag = "6", default = "60")]
pub accept_queue_timeout: u32,
#[prost(uint64, required, tag = "7", default = "1")]
pub min_buffers: u64,
#[prost(uint64, required, tag = "8", default = "1000")]
pub max_buffers: u64,
#[prost(uint64, required, tag = "9", default = "16393")]
pub buffer_size: u64,
#[prost(string, required, tag = "10", default = "info")]
pub log_level: ::prost::alloc::string::String,
#[prost(string, required, tag = "11", default = "stdout")]
pub log_target: ::prost::alloc::string::String,
#[prost(string, optional, tag = "12")]
pub access_logs_target: ::core::option::Option<::prost::alloc::string::String>,
#[prost(uint64, required, tag = "13", default = "1000000")]
pub command_buffer_size: u64,
#[prost(uint64, required, tag = "14", default = "2000000")]
pub max_command_buffer_size: u64,
#[prost(message, optional, tag = "15")]
pub metrics: ::core::option::Option<ServerMetricsConfig>,
#[prost(enumeration = "ProtobufAccessLogFormat", required, tag = "16")]
pub access_log_format: i32,
#[prost(bool, required, tag = "17")]
pub log_colored: bool,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListenersCount {
#[prost(string, repeated, tag = "1")]
pub http: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
#[prost(string, repeated, tag = "2")]
pub tls: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
#[prost(string, repeated, tag = "3")]
pub tcp: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InitialState {
#[prost(message, repeated, tag = "1")]
pub requests: ::prost::alloc::vec::Vec<WorkerRequest>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ProtobufAccessLog {
#[prost(string, optional, tag = "1")]
pub message: ::core::option::Option<::prost::alloc::string::String>,
#[prost(message, required, tag = "2")]
pub request_id: Uint128,
#[prost(string, optional, tag = "3")]
pub cluster_id: ::core::option::Option<::prost::alloc::string::String>,
#[prost(string, optional, tag = "4")]
pub backend_id: ::core::option::Option<::prost::alloc::string::String>,
#[prost(message, optional, tag = "5")]
pub session_address: ::core::option::Option<SocketAddress>,
#[prost(message, optional, tag = "6")]
pub backend_address: ::core::option::Option<SocketAddress>,
#[prost(string, required, tag = "7")]
pub protocol: ::prost::alloc::string::String,
#[prost(message, required, tag = "8")]
pub endpoint: ProtobufEndpoint,
#[prost(uint64, optional, tag = "9")]
pub client_rtt: ::core::option::Option<u64>,
#[prost(uint64, optional, tag = "10")]
pub server_rtt: ::core::option::Option<u64>,
#[prost(uint64, required, tag = "12")]
pub response_time: u64,
#[prost(uint64, required, tag = "13")]
pub service_time: u64,
#[prost(uint64, required, tag = "14")]
pub bytes_in: u64,
#[prost(uint64, required, tag = "15")]
pub bytes_out: u64,
#[prost(string, optional, tag = "16")]
pub user_agent: ::core::option::Option<::prost::alloc::string::String>,
#[prost(btree_map = "string, string", tag = "17")]
pub tags: ::prost::alloc::collections::BTreeMap<
::prost::alloc::string::String,
::prost::alloc::string::String,
>,
#[prost(string, required, tag = "18")]
pub tag: ::prost::alloc::string::String,
#[prost(message, required, tag = "19")]
pub time: Uint128,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ProtobufEndpoint {
#[prost(oneof = "protobuf_endpoint::Inner", tags = "1, 2")]
pub inner: ::core::option::Option<protobuf_endpoint::Inner>,
}
pub mod protobuf_endpoint {
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum Inner {
#[prost(message, tag = "1")]
Http(super::HttpEndpoint),
#[prost(message, tag = "2")]
Tcp(super::TcpEndpoint),
}
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HttpEndpoint {
#[prost(string, optional, tag = "1")]
pub method: ::core::option::Option<::prost::alloc::string::String>,
#[prost(string, optional, tag = "2")]
pub authority: ::core::option::Option<::prost::alloc::string::String>,
#[prost(string, optional, tag = "3")]
pub path: ::core::option::Option<::prost::alloc::string::String>,
#[prost(uint32, optional, tag = "4")]
pub status: ::core::option::Option<u32>,
#[prost(string, optional, tag = "5")]
pub reason: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[derive(Hash, Eq, Ord, PartialOrd)]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TcpEndpoint {}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ListenerType {
Http = 0,
Https = 1,
Tcp = 2,
}
impl ListenerType {
pub fn as_str_name(&self) -> &'static str {
match self {
ListenerType::Http => "HTTP",
ListenerType::Https => "HTTPS",
ListenerType::Tcp => "TCP",
}
}
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"HTTP" => Some(Self::Http),
"HTTPS" => Some(Self::Https),
"TCP" => Some(Self::Tcp),
_ => None,
}
}
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum PathRuleKind {
Prefix = 0,
Regex = 1,
Equals = 2,
}
impl PathRuleKind {
pub fn as_str_name(&self) -> &'static str {
match self {
PathRuleKind::Prefix => "PREFIX",
PathRuleKind::Regex => "REGEX",
PathRuleKind::Equals => "EQUALS",
}
}
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"PREFIX" => Some(Self::Prefix),
"REGEX" => Some(Self::Regex),
"EQUALS" => Some(Self::Equals),
_ => None,
}
}
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum RulePosition {
Pre = 0,
Post = 1,
Tree = 2,
}
impl RulePosition {
pub fn as_str_name(&self) -> &'static str {
match self {
RulePosition::Pre => "PRE",
RulePosition::Post => "POST",
RulePosition::Tree => "TREE",
}
}
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"PRE" => Some(Self::Pre),
"POST" => Some(Self::Post),
"TREE" => Some(Self::Tree),
_ => None,
}
}
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum TlsVersion {
SslV2 = 0,
SslV3 = 1,
TlsV10 = 2,
TlsV11 = 3,
TlsV12 = 4,
TlsV13 = 5,
}
impl TlsVersion {
pub fn as_str_name(&self) -> &'static str {
match self {
TlsVersion::SslV2 => "SSL_V2",
TlsVersion::SslV3 => "SSL_V3",
TlsVersion::TlsV10 => "TLS_V1_0",
TlsVersion::TlsV11 => "TLS_V1_1",
TlsVersion::TlsV12 => "TLS_V1_2",
TlsVersion::TlsV13 => "TLS_V1_3",
}
}
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"SSL_V2" => Some(Self::SslV2),
"SSL_V3" => Some(Self::SslV3),
"TLS_V1_0" => Some(Self::TlsV10),
"TLS_V1_1" => Some(Self::TlsV11),
"TLS_V1_2" => Some(Self::TlsV12),
"TLS_V1_3" => Some(Self::TlsV13),
_ => None,
}
}
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum LoadBalancingAlgorithms {
RoundRobin = 0,
Random = 1,
LeastLoaded = 2,
PowerOfTwo = 3,
}
impl LoadBalancingAlgorithms {
pub fn as_str_name(&self) -> &'static str {
match self {
LoadBalancingAlgorithms::RoundRobin => "ROUND_ROBIN",
LoadBalancingAlgorithms::Random => "RANDOM",
LoadBalancingAlgorithms::LeastLoaded => "LEAST_LOADED",
LoadBalancingAlgorithms::PowerOfTwo => "POWER_OF_TWO",
}
}
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"ROUND_ROBIN" => Some(Self::RoundRobin),
"RANDOM" => Some(Self::Random),
"LEAST_LOADED" => Some(Self::LeastLoaded),
"POWER_OF_TWO" => Some(Self::PowerOfTwo),
_ => None,
}
}
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ProxyProtocolConfig {
ExpectHeader = 0,
SendHeader = 1,
RelayHeader = 2,
}
impl ProxyProtocolConfig {
pub fn as_str_name(&self) -> &'static str {
match self {
ProxyProtocolConfig::ExpectHeader => "EXPECT_HEADER",
ProxyProtocolConfig::SendHeader => "SEND_HEADER",
ProxyProtocolConfig::RelayHeader => "RELAY_HEADER",
}
}
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"EXPECT_HEADER" => Some(Self::ExpectHeader),
"SEND_HEADER" => Some(Self::SendHeader),
"RELAY_HEADER" => Some(Self::RelayHeader),
_ => None,
}
}
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum LoadMetric {
Connections = 0,
Requests = 1,
ConnectionTime = 2,
}
impl LoadMetric {
pub fn as_str_name(&self) -> &'static str {
match self {
LoadMetric::Connections => "CONNECTIONS",
LoadMetric::Requests => "REQUESTS",
LoadMetric::ConnectionTime => "CONNECTION_TIME",
}
}
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"CONNECTIONS" => Some(Self::Connections),
"REQUESTS" => Some(Self::Requests),
"CONNECTION_TIME" => Some(Self::ConnectionTime),
_ => None,
}
}
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum MetricsConfiguration {
Enabled = 0,
Disabled = 1,
Clear = 2,
}
impl MetricsConfiguration {
pub fn as_str_name(&self) -> &'static str {
match self {
MetricsConfiguration::Enabled => "ENABLED",
MetricsConfiguration::Disabled => "DISABLED",
MetricsConfiguration::Clear => "CLEAR",
}
}
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"ENABLED" => Some(Self::Enabled),
"DISABLED" => Some(Self::Disabled),
"CLEAR" => Some(Self::Clear),
_ => None,
}
}
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum EventKind {
BackendDown = 0,
BackendUp = 1,
NoAvailableBackends = 2,
RemovedBackendHasNoConnections = 3,
}
impl EventKind {
pub fn as_str_name(&self) -> &'static str {
match self {
EventKind::BackendDown => "BACKEND_DOWN",
EventKind::BackendUp => "BACKEND_UP",
EventKind::NoAvailableBackends => "NO_AVAILABLE_BACKENDS",
EventKind::RemovedBackendHasNoConnections => {
"REMOVED_BACKEND_HAS_NO_CONNECTIONS"
}
}
}
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"BACKEND_DOWN" => Some(Self::BackendDown),
"BACKEND_UP" => Some(Self::BackendUp),
"NO_AVAILABLE_BACKENDS" => Some(Self::NoAvailableBackends),
"REMOVED_BACKEND_HAS_NO_CONNECTIONS" => {
Some(Self::RemovedBackendHasNoConnections)
}
_ => None,
}
}
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ResponseStatus {
Ok = 0,
Processing = 1,
Failure = 2,
}
impl ResponseStatus {
pub fn as_str_name(&self) -> &'static str {
match self {
ResponseStatus::Ok => "OK",
ResponseStatus::Processing => "PROCESSING",
ResponseStatus::Failure => "FAILURE",
}
}
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"OK" => Some(Self::Ok),
"PROCESSING" => Some(Self::Processing),
"FAILURE" => Some(Self::Failure),
_ => None,
}
}
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum RunState {
Running = 0,
Stopping = 1,
Stopped = 2,
NotAnswering = 3,
}
impl RunState {
pub fn as_str_name(&self) -> &'static str {
match self {
RunState::Running => "RUNNING",
RunState::Stopping => "STOPPING",
RunState::Stopped => "STOPPED",
RunState::NotAnswering => "NOT_ANSWERING",
}
}
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"RUNNING" => Some(Self::Running),
"STOPPING" => Some(Self::Stopping),
"STOPPED" => Some(Self::Stopped),
"NOT_ANSWERING" => Some(Self::NotAnswering),
_ => None,
}
}
}
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ProtobufAccessLogFormat {
Ascii = 1,
Protobuf = 2,
}
impl ProtobufAccessLogFormat {
pub fn as_str_name(&self) -> &'static str {
match self {
ProtobufAccessLogFormat::Ascii => "Ascii",
ProtobufAccessLogFormat::Protobuf => "Protobuf",
}
}
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"Ascii" => Some(Self::Ascii),
"Protobuf" => Some(Self::Protobuf),
_ => None,
}
}
}