diff options
| author | mo khan <mo@mokhan.ca> | 2025-07-16 13:44:59 -0600 |
|---|---|---|
| committer | mo khan <mo@mokhan.ca> | 2025-07-16 13:44:59 -0600 |
| commit | aadfbeb39d0ac5ccb1a19899d7680b1c96b1a6cf (patch) | |
| tree | 293cb102463ab1aeeac6aa899cedbbbf03ed6187 /src/rpc/envoy.api.v2.core.rs | |
| parent | e97b15bcb9581b895d8431f3f3eaf7a9dd1bcac6 (diff) | |
chore: add generated rpc code
Diffstat (limited to 'src/rpc/envoy.api.v2.core.rs')
| -rw-r--r-- | src/rpc/envoy.api.v2.core.rs | 1969 |
1 files changed, 1969 insertions, 0 deletions
diff --git a/src/rpc/envoy.api.v2.core.rs b/src/rpc/envoy.api.v2.core.rs new file mode 100644 index 00000000..a03b8f7a --- /dev/null +++ b/src/rpc/envoy.api.v2.core.rs @@ -0,0 +1,1969 @@ +// @generated +// This file is @generated by prost-build. +// \[#protodoc-title: Socket Option \] + +/// Generic socket option message. This would be used to set socket options that +/// might not exist in upstream kernels or precompiled Envoy binaries. +/// \[#next-free-field: 7\] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SocketOption { + /// An optional name to give this socket option for debugging, etc. + /// Uniqueness is not required and no special meaning is assumed. + #[prost(string, tag="1")] + pub description: ::prost::alloc::string::String, + /// Corresponding to the level value passed to setsockopt, such as IPPROTO_TCP + #[prost(int64, tag="2")] + pub level: i64, + /// The numeric name as passed to setsockopt + #[prost(int64, tag="3")] + pub name: i64, + /// The state in which the option will be applied. When used in BindConfig + /// STATE_PREBIND is currently the only valid value. + #[prost(enumeration="socket_option::SocketState", tag="6")] + pub state: i32, + #[prost(oneof="socket_option::Value", tags="4, 5")] + pub value: ::core::option::Option<socket_option::Value>, +} +/// Nested message and enum types in `SocketOption`. +pub mod socket_option { + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum SocketState { + /// Socket options are applied after socket creation but before binding the socket to a port + StatePrebind = 0, + /// Socket options are applied after binding the socket to a port but before calling listen() + StateBound = 1, + /// Socket options are applied after calling listen() + StateListening = 2, + } + impl SocketState { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + SocketState::StatePrebind => "STATE_PREBIND", + SocketState::StateBound => "STATE_BOUND", + SocketState::StateListening => "STATE_LISTENING", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option<Self> { + match value { + "STATE_PREBIND" => Some(Self::StatePrebind), + "STATE_BOUND" => Some(Self::StateBound), + "STATE_LISTENING" => Some(Self::StateListening), + _ => None, + } + } + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Value { + /// Because many sockopts take an int value. + #[prost(int64, tag="4")] + IntValue(i64), + /// Otherwise it's a byte buffer. + #[prost(bytes, tag="5")] + BufValue(::prost::alloc::vec::Vec<u8>), + } +} +// \[#protodoc-title: Network addresses\] + +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Pipe { + /// Unix Domain Socket path. On Linux, paths starting with '@' will use the + /// abstract namespace. The starting '@' is replaced by a null byte by Envoy. + /// Paths starting with '@' will result in an error in environments other than + /// Linux. + #[prost(string, tag="1")] + pub path: ::prost::alloc::string::String, + /// The mode for the Pipe. Not applicable for abstract sockets. + #[prost(uint32, tag="2")] + pub mode: u32, +} +/// \[#next-free-field: 7\] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SocketAddress { + #[prost(enumeration="socket_address::Protocol", tag="1")] + pub protocol: i32, + /// The address for this socket. :ref:`Listeners <config_listeners>` will bind + /// to the address. An empty address is not allowed. Specify ``0.0.0.0`` or ``::`` + /// to bind to any address. [#comment:TODO(zuercher) reinstate when implemented: + /// It is possible to distinguish a Listener address via the prefix/suffix matching + /// in :ref:`FilterChainMatch <envoy_api_msg_listener.FilterChainMatch>`.] When used + /// within an upstream :ref:`BindConfig <envoy_api_msg_core.BindConfig>`, the address + /// controls the source address of outbound connections. For :ref:`clusters + /// <envoy_api_msg_Cluster>`, the cluster type determines whether the + /// address must be an IP (*STATIC* or *EDS* clusters) or a hostname resolved by DNS + /// (*STRICT_DNS* or *LOGICAL_DNS* clusters). Address resolution can be customized + /// via :ref:`resolver_name <envoy_api_field_core.SocketAddress.resolver_name>`. + #[prost(string, tag="2")] + pub address: ::prost::alloc::string::String, + /// The name of the custom resolver. This must have been registered with Envoy. If + /// this is empty, a context dependent default applies. If the address is a concrete + /// IP address, no resolution will occur. If address is a hostname this + /// should be set for resolution other than DNS. Specifying a custom resolver with + /// *STRICT_DNS* or *LOGICAL_DNS* will generate an error at runtime. + #[prost(string, tag="5")] + pub resolver_name: ::prost::alloc::string::String, + /// When binding to an IPv6 address above, this enables `IPv4 compatibility + /// <<https://tools.ietf.org/html/rfc3493#page-11>`_.> Binding to ``::`` will + /// allow both IPv4 and IPv6 connections, with peer IPv4 addresses mapped into + /// IPv6 space as ``::FFFF:<IPv4-address>``. + #[prost(bool, tag="6")] + pub ipv4_compat: bool, + #[prost(oneof="socket_address::PortSpecifier", tags="3, 4")] + pub port_specifier: ::core::option::Option<socket_address::PortSpecifier>, +} +/// Nested message and enum types in `SocketAddress`. +pub mod socket_address { + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum Protocol { + Tcp = 0, + Udp = 1, + } + impl Protocol { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Protocol::Tcp => "TCP", + Protocol::Udp => "UDP", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option<Self> { + match value { + "TCP" => Some(Self::Tcp), + "UDP" => Some(Self::Udp), + _ => None, + } + } + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum PortSpecifier { + #[prost(uint32, tag="3")] + PortValue(u32), + /// This is only valid if :ref:`resolver_name + /// <envoy_api_field_core.SocketAddress.resolver_name>` is specified below and the + /// named resolver is capable of named port resolution. + #[prost(string, tag="4")] + NamedPort(::prost::alloc::string::String), + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct TcpKeepalive { + /// Maximum number of keepalive probes to send without response before deciding + /// the connection is dead. Default is to use the OS level configuration (unless + /// overridden, Linux defaults to 9.) + #[prost(message, optional, tag="1")] + pub keepalive_probes: ::core::option::Option<super::super::super::super::google::protobuf::UInt32Value>, + /// The number of seconds a connection needs to be idle before keep-alive probes + /// start being sent. Default is to use the OS level configuration (unless + /// overridden, Linux defaults to 7200s (i.e., 2 hours.) + #[prost(message, optional, tag="2")] + pub keepalive_time: ::core::option::Option<super::super::super::super::google::protobuf::UInt32Value>, + /// The number of seconds between keep-alive probes. Default is to use the OS + /// level configuration (unless overridden, Linux defaults to 75s.) + #[prost(message, optional, tag="3")] + pub keepalive_interval: ::core::option::Option<super::super::super::super::google::protobuf::UInt32Value>, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct BindConfig { + /// The address to bind to when creating a socket. + #[prost(message, optional, tag="1")] + pub source_address: ::core::option::Option<SocketAddress>, + /// Whether to set the *IP_FREEBIND* option when creating the socket. When this + /// flag is set to true, allows the :ref:`source_address + /// <envoy_api_field_UpstreamBindConfig.source_address>` to be an IP address + /// that is not configured on the system running Envoy. When this flag is set + /// to false, the option *IP_FREEBIND* is disabled on the socket. When this + /// flag is not set (default), the socket is not modified, i.e. the option is + /// neither enabled nor disabled. + #[prost(message, optional, tag="2")] + pub freebind: ::core::option::Option<super::super::super::super::google::protobuf::BoolValue>, + /// Additional socket options that may not be present in Envoy source code or + /// precompiled binaries. + #[prost(message, repeated, tag="3")] + pub socket_options: ::prost::alloc::vec::Vec<SocketOption>, +} +/// Addresses specify either a logical or physical address and port, which are +/// used to tell Envoy where to bind/listen, connect to upstream and find +/// management servers. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Address { + #[prost(oneof="address::Address", tags="1, 2")] + pub address: ::core::option::Option<address::Address>, +} +/// Nested message and enum types in `Address`. +pub mod address { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Address { + #[prost(message, tag="1")] + SocketAddress(super::SocketAddress), + #[prost(message, tag="2")] + Pipe(super::Pipe), + } +} +/// CidrRange specifies an IP Address and a prefix length to construct +/// the subnet mask for a `CIDR <<https://tools.ietf.org/html/rfc4632>`_> range. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CidrRange { + /// IPv4 or IPv6 address, e.g. ``192.0.0.0`` or ``2001:db8::``. + #[prost(string, tag="1")] + pub address_prefix: ::prost::alloc::string::String, + /// Length of prefix, e.g. 0, 32. Defaults to 0 when unset. + #[prost(message, optional, tag="2")] + pub prefix_len: ::core::option::Option<super::super::super::super::google::protobuf::UInt32Value>, +} +// \[#protodoc-title: Backoff Strategy\] + +/// Configuration defining a jittered exponential back off strategy. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct BackoffStrategy { + /// The base interval to be used for the next back off computation. It should + /// be greater than zero and less than or equal to :ref:`max_interval + /// <envoy_api_field_core.BackoffStrategy.max_interval>`. + #[prost(message, optional, tag="1")] + pub base_interval: ::core::option::Option<super::super::super::super::google::protobuf::Duration>, + /// Specifies the maximum interval between retries. This parameter is optional, + /// but must be greater than or equal to the :ref:`base_interval + /// <envoy_api_field_core.BackoffStrategy.base_interval>` if set. The default + /// is 10 times the :ref:`base_interval + /// <envoy_api_field_core.BackoffStrategy.base_interval>`. + #[prost(message, optional, tag="2")] + pub max_interval: ::core::option::Option<super::super::super::super::google::protobuf::Duration>, +} +// \[#protodoc-title: HTTP Service URI \] + +/// Envoy external URI descriptor +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct HttpUri { + /// The HTTP server URI. It should be a full FQDN with protocol, host and path. + /// + /// Example: + /// + /// .. code-block:: yaml + /// + /// uri: <https://www.googleapis.com/oauth2/v1/certs> + /// + #[prost(string, tag="1")] + pub uri: ::prost::alloc::string::String, + /// Sets the maximum duration in milliseconds that a response can take to arrive upon request. + #[prost(message, optional, tag="3")] + pub timeout: ::core::option::Option<super::super::super::super::google::protobuf::Duration>, + /// Specify how `uri` is to be fetched. Today, this requires an explicit + /// cluster, but in the future we may support dynamic cluster creation or + /// inline DNS resolution. See `issue + /// <<https://github.com/envoyproxy/envoy/issues/1606>`_.> + #[prost(oneof="http_uri::HttpUpstreamType", tags="2")] + pub http_upstream_type: ::core::option::Option<http_uri::HttpUpstreamType>, +} +/// Nested message and enum types in `HttpUri`. +pub mod http_uri { + /// Specify how `uri` is to be fetched. Today, this requires an explicit + /// cluster, but in the future we may support dynamic cluster creation or + /// inline DNS resolution. See `issue + /// <<https://github.com/envoyproxy/envoy/issues/1606>`_.> + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum HttpUpstreamType { + /// A cluster is created in the Envoy "cluster_manager" config + /// section. This field specifies the cluster name. + /// + /// Example: + /// + /// .. code-block:: yaml + /// + /// cluster: jwks_cluster + /// + #[prost(string, tag="2")] + Cluster(::prost::alloc::string::String), + } +} +/// Identifies location of where either Envoy runs or where upstream hosts run. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Locality { + /// Region this :ref:`zone <envoy_api_field_core.Locality.zone>` belongs to. + #[prost(string, tag="1")] + pub region: ::prost::alloc::string::String, + /// Defines the local service zone where Envoy is running. Though optional, it + /// should be set if discovery service routing is used and the discovery + /// service exposes :ref:`zone data <envoy_api_field_endpoint.LocalityLbEndpoints.locality>`, + /// either in this message or via :option:`--service-zone`. The meaning of zone + /// is context dependent, e.g. `Availability Zone (AZ) + /// <<https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html>`_> + /// on AWS, `Zone <<https://cloud.google.com/compute/docs/regions-zones/>`_> on + /// GCP, etc. + #[prost(string, tag="2")] + pub zone: ::prost::alloc::string::String, + /// When used for locality of upstream hosts, this field further splits zone + /// into smaller chunks of sub-zones so they can be load balanced + /// independently. + #[prost(string, tag="3")] + pub sub_zone: ::prost::alloc::string::String, +} +/// BuildVersion combines SemVer version of extension with free-form build information +/// (i.e. 'alpha', 'private-build') as a set of strings. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct BuildVersion { + /// SemVer version of extension. + #[prost(message, optional, tag="1")] + pub version: ::core::option::Option<super::super::super::r#type::SemanticVersion>, + /// Free-form build information. + /// Envoy defines several well known keys in the source/common/version/version.h file + #[prost(message, optional, tag="2")] + pub metadata: ::core::option::Option<super::super::super::super::google::protobuf::Struct>, +} +/// Version and identification for an Envoy extension. +/// \[#next-free-field: 6\] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Extension { + /// This is the name of the Envoy filter as specified in the Envoy + /// configuration, e.g. envoy.filters.http.router, com.acme.widget. + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + /// Category of the extension. + /// Extension category names use reverse DNS notation. For instance "envoy.filters.listener" + /// for Envoy's built-in listener filters or "com.acme.filters.http" for HTTP filters from + /// acme.com vendor. + /// \[#comment:TODO(yanavlasov): Link to the doc with existing envoy category names.\] + #[prost(string, tag="2")] + pub category: ::prost::alloc::string::String, + /// \[#not-implemented-hide:\] Type descriptor of extension configuration proto. + /// \[#comment:TODO(yanavlasov): Link to the doc with existing configuration protos.\] + /// \[#comment:TODO(yanavlasov): Add tests when PR #9391 lands.\] + #[prost(string, tag="3")] + pub type_descriptor: ::prost::alloc::string::String, + /// The version is a property of the extension and maintained independently + /// of other extensions and the Envoy API. + /// This field is not set when extension did not provide version information. + #[prost(message, optional, tag="4")] + pub version: ::core::option::Option<BuildVersion>, + /// Indicates that the extension is present but was disabled via dynamic configuration. + #[prost(bool, tag="5")] + pub disabled: bool, +} +/// Identifies a specific Envoy instance. The node identifier is presented to the +/// management server, which may use this identifier to distinguish per Envoy +/// configuration for serving. +/// \[#next-free-field: 12\] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Node { + /// An opaque node identifier for the Envoy node. This also provides the local + /// service node name. It should be set if any of the following features are + /// used: :ref:`statsd <arch_overview_statistics>`, :ref:`CDS + /// <config_cluster_manager_cds>`, and :ref:`HTTP tracing + /// <arch_overview_tracing>`, either in this message or via + /// :option:`--service-node`. + #[prost(string, tag="1")] + pub id: ::prost::alloc::string::String, + /// Defines the local service cluster name where Envoy is running. Though + /// optional, it should be set if any of the following features are used: + /// :ref:`statsd <arch_overview_statistics>`, :ref:`health check cluster + /// verification + /// <envoy_api_field_core.HealthCheck.HttpHealthCheck.service_name_matcher>`, + /// :ref:`runtime override directory <envoy_api_msg_config.bootstrap.v2.Runtime>`, + /// :ref:`user agent addition + /// <envoy_api_field_config.filter.network.http_connection_manager.v2.HttpConnectionManager.add_user_agent>`, + /// :ref:`HTTP global rate limiting <config_http_filters_rate_limit>`, + /// :ref:`CDS <config_cluster_manager_cds>`, and :ref:`HTTP tracing + /// <arch_overview_tracing>`, either in this message or via + /// :option:`--service-cluster`. + #[prost(string, tag="2")] + pub cluster: ::prost::alloc::string::String, + /// Opaque metadata extending the node identifier. Envoy will pass this + /// directly to the management server. + #[prost(message, optional, tag="3")] + pub metadata: ::core::option::Option<super::super::super::super::google::protobuf::Struct>, + /// Locality specifying where the Envoy instance is running. + #[prost(message, optional, tag="4")] + pub locality: ::core::option::Option<Locality>, + /// This is motivated by informing a management server during canary which + /// version of Envoy is being tested in a heterogeneous fleet. This will be set + /// by Envoy in management server RPCs. + /// This field is deprecated in favor of the user_agent_name and user_agent_version values. + #[deprecated] + #[prost(string, tag="5")] + pub build_version: ::prost::alloc::string::String, + /// Free-form string that identifies the entity requesting config. + /// E.g. "envoy" or "grpc" + #[prost(string, tag="6")] + pub user_agent_name: ::prost::alloc::string::String, + /// List of extensions and their versions supported by the node. + #[prost(message, repeated, tag="9")] + pub extensions: ::prost::alloc::vec::Vec<Extension>, + /// Client feature support list. These are well known features described + /// in the Envoy API repository for a given major version of an API. Client features + /// use reverse DNS naming scheme, for example `com.acme.feature`. + /// See :ref:`the list of features <client_features>` that xDS client may + /// support. + #[prost(string, repeated, tag="10")] + pub client_features: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// Known listening ports on the node as a generic hint to the management server + /// for filtering :ref:`listeners <config_listeners>` to be returned. For example, + /// if there is a listener bound to port 80, the list can optionally contain the + /// SocketAddress `(0.0.0.0,80)`. The field is optional and just a hint. + #[prost(message, repeated, tag="11")] + pub listening_addresses: ::prost::alloc::vec::Vec<Address>, + #[prost(oneof="node::UserAgentVersionType", tags="7, 8")] + pub user_agent_version_type: ::core::option::Option<node::UserAgentVersionType>, +} +/// Nested message and enum types in `Node`. +pub mod node { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum UserAgentVersionType { + /// Free-form string that identifies the version of the entity requesting config. + /// E.g. "1.12.2" or "abcd1234", or "SpecialEnvoyBuild" + #[prost(string, tag="7")] + UserAgentVersion(::prost::alloc::string::String), + /// Structured version of the entity requesting config. + #[prost(message, tag="8")] + UserAgentBuildVersion(super::BuildVersion), + } +} +/// Metadata provides additional inputs to filters based on matched listeners, +/// filter chains, routes and endpoints. It is structured as a map, usually from +/// filter name (in reverse DNS format) to metadata specific to the filter. Metadata +/// key-values for a filter are merged as connection and request handling occurs, +/// with later values for the same key overriding earlier values. +/// +/// An example use of metadata is providing additional values to +/// http_connection_manager in the envoy.http_connection_manager.access_log +/// namespace. +/// +/// Another example use of metadata is to per service config info in cluster metadata, which may get +/// consumed by multiple filters. +/// +/// For load balancing, Metadata provides a means to subset cluster endpoints. +/// Endpoints have a Metadata object associated and routes contain a Metadata +/// object to match against. There are some well defined metadata used today for +/// this purpose: +/// +/// * ``{"envoy.lb": {"canary": <bool> }}`` This indicates the canary status of an +/// endpoint and is also used during header processing +/// (x-envoy-upstream-canary) and for stats purposes. +/// \[#next-major-version: move to type/metadata/v2\] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Metadata { + /// Key is the reverse DNS filter name, e.g. com.acme.widget. The envoy.* + /// namespace is reserved for Envoy's built-in filters. + #[prost(map="string, message", tag="1")] + pub filter_metadata: ::std::collections::HashMap<::prost::alloc::string::String, super::super::super::super::google::protobuf::Struct>, +} +/// Runtime derived uint32 with a default when not specified. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RuntimeUInt32 { + /// Default value if runtime value is not available. + #[prost(uint32, tag="2")] + pub default_value: u32, + /// Runtime key to get value for comparison. This value is used if defined. + #[prost(string, tag="3")] + pub runtime_key: ::prost::alloc::string::String, +} +/// Runtime derived double with a default when not specified. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RuntimeDouble { + /// Default value if runtime value is not available. + #[prost(double, tag="1")] + pub default_value: f64, + /// Runtime key to get value for comparison. This value is used if defined. + #[prost(string, tag="2")] + pub runtime_key: ::prost::alloc::string::String, +} +/// Runtime derived bool with a default when not specified. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RuntimeFeatureFlag { + /// Default value if runtime value is not available. + #[prost(message, optional, tag="1")] + pub default_value: ::core::option::Option<super::super::super::super::google::protobuf::BoolValue>, + /// Runtime key to get value for comparison. This value is used if defined. The boolean value must + /// be represented via its + /// `canonical JSON encoding <<https://developers.google.com/protocol-buffers/docs/proto3#json>`_.> + #[prost(string, tag="2")] + pub runtime_key: ::prost::alloc::string::String, +} +/// Header name/value pair. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct HeaderValue { + /// Header name. + #[prost(string, tag="1")] + pub key: ::prost::alloc::string::String, + /// Header value. + /// + /// The same :ref:`format specifier <config_access_log_format>` as used for + /// :ref:`HTTP access logging <config_access_log>` applies here, however + /// unknown header values are replaced with the empty string instead of `-`. + #[prost(string, tag="2")] + pub value: ::prost::alloc::string::String, +} +/// Header name/value pair plus option to control append behavior. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct HeaderValueOption { + /// Header name/value pair that this option applies to. + #[prost(message, optional, tag="1")] + pub header: ::core::option::Option<HeaderValue>, + /// Should the value be appended? If true (default), the value is appended to + /// existing values. + #[prost(message, optional, tag="2")] + pub append: ::core::option::Option<super::super::super::super::google::protobuf::BoolValue>, +} +/// Wrapper for a set of headers. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct HeaderMap { + #[prost(message, repeated, tag="1")] + pub headers: ::prost::alloc::vec::Vec<HeaderValue>, +} +/// Data source consisting of either a file or an inline value. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DataSource { + #[prost(oneof="data_source::Specifier", tags="1, 2, 3")] + pub specifier: ::core::option::Option<data_source::Specifier>, +} +/// Nested message and enum types in `DataSource`. +pub mod data_source { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Specifier { + /// Local filesystem data source. + #[prost(string, tag="1")] + Filename(::prost::alloc::string::String), + /// Bytes inlined in the configuration. + #[prost(bytes, tag="2")] + InlineBytes(::prost::alloc::vec::Vec<u8>), + /// String inlined in the configuration. + #[prost(string, tag="3")] + InlineString(::prost::alloc::string::String), + } +} +/// The message specifies the retry policy of remote data source when fetching fails. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct RetryPolicy { + /// Specifies parameters that control :ref:`retry backoff strategy <envoy_api_msg_core.BackoffStrategy>`. + /// This parameter is optional, in which case the default base interval is 1000 milliseconds. The + /// default maximum interval is 10 times the base interval. + #[prost(message, optional, tag="1")] + pub retry_back_off: ::core::option::Option<BackoffStrategy>, + /// Specifies the allowed number of retries. This parameter is optional and + /// defaults to 1. + #[prost(message, optional, tag="2")] + pub num_retries: ::core::option::Option<super::super::super::super::google::protobuf::UInt32Value>, +} +/// The message specifies how to fetch data from remote and how to verify it. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RemoteDataSource { + /// The HTTP URI to fetch the remote data. + #[prost(message, optional, tag="1")] + pub http_uri: ::core::option::Option<HttpUri>, + /// SHA256 string for verifying data. + #[prost(string, tag="2")] + pub sha256: ::prost::alloc::string::String, + /// Retry policy for fetching remote data. + #[prost(message, optional, tag="3")] + pub retry_policy: ::core::option::Option<RetryPolicy>, +} +/// Async data source which support async data fetch. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AsyncDataSource { + #[prost(oneof="async_data_source::Specifier", tags="1, 2")] + pub specifier: ::core::option::Option<async_data_source::Specifier>, +} +/// Nested message and enum types in `AsyncDataSource`. +pub mod async_data_source { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Specifier { + /// Local async data source. + #[prost(message, tag="1")] + Local(super::DataSource), + /// Remote async data source. + #[prost(message, tag="2")] + Remote(super::RemoteDataSource), + } +} +/// Configuration for transport socket in :ref:`listeners <config_listeners>` and +/// :ref:`clusters <envoy_api_msg_Cluster>`. If the configuration is +/// empty, a default transport socket implementation and configuration will be +/// chosen based on the platform and existence of tls_context. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TransportSocket { + /// The name of the transport socket to instantiate. The name must match a supported transport + /// socket implementation. + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + /// Implementation specific configuration which depends on the implementation being instantiated. + /// See the supported transport socket implementations for further documentation. + #[prost(oneof="transport_socket::ConfigType", tags="2, 3")] + pub config_type: ::core::option::Option<transport_socket::ConfigType>, +} +/// Nested message and enum types in `TransportSocket`. +pub mod transport_socket { + /// Implementation specific configuration which depends on the implementation being instantiated. + /// See the supported transport socket implementations for further documentation. + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum ConfigType { + #[prost(message, tag="2")] + Config(super::super::super::super::super::google::protobuf::Struct), + #[prost(message, tag="3")] + TypedConfig(super::super::super::super::super::google::protobuf::Any), + } +} +/// Runtime derived FractionalPercent with defaults for when the numerator or denominator is not +/// specified via a runtime key. +/// +/// .. note:: +/// +/// Parsing of the runtime key's data is implemented such that it may be represented as a +/// :ref:`FractionalPercent <envoy_api_msg_type.FractionalPercent>` proto represented as JSON/YAML +/// and may also be represented as an integer with the assumption that the value is an integral +/// percentage out of 100. For instance, a runtime key lookup returning the value "42" would parse +/// as a `FractionalPercent` whose numerator is 42 and denominator is HUNDRED. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RuntimeFractionalPercent { + /// Default value if the runtime value's for the numerator/denominator keys are not available. + #[prost(message, optional, tag="1")] + pub default_value: ::core::option::Option<super::super::super::r#type::FractionalPercent>, + /// Runtime key for a YAML representation of a FractionalPercent. + #[prost(string, tag="2")] + pub runtime_key: ::prost::alloc::string::String, +} +/// Identifies a specific ControlPlane instance that Envoy is connected to. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ControlPlane { + /// An opaque control plane identifier that uniquely identifies an instance + /// of control plane. This can be used to identify which control plane instance, + /// the Envoy is connected to. + #[prost(string, tag="1")] + pub identifier: ::prost::alloc::string::String, +} +// \[#protodoc-title: Common types\] + +/// Envoy supports :ref:`upstream priority routing +/// <arch_overview_http_routing_priority>` both at the route and the virtual +/// cluster level. The current priority implementation uses different connection +/// pool and circuit breaking settings for each priority level. This means that +/// even for HTTP/2 requests, two physical connections will be used to an +/// upstream host. In the future Envoy will likely support true HTTP/2 priority +/// over a single upstream connection. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum RoutingPriority { + Default = 0, + High = 1, +} +impl RoutingPriority { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + RoutingPriority::Default => "DEFAULT", + RoutingPriority::High => "HIGH", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option<Self> { + match value { + "DEFAULT" => Some(Self::Default), + "HIGH" => Some(Self::High), + _ => None, + } + } +} +/// HTTP request method. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum RequestMethod { + MethodUnspecified = 0, + Get = 1, + Head = 2, + Post = 3, + Put = 4, + Delete = 5, + Connect = 6, + Options = 7, + Trace = 8, + Patch = 9, +} +impl RequestMethod { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + RequestMethod::MethodUnspecified => "METHOD_UNSPECIFIED", + RequestMethod::Get => "GET", + RequestMethod::Head => "HEAD", + RequestMethod::Post => "POST", + RequestMethod::Put => "PUT", + RequestMethod::Delete => "DELETE", + RequestMethod::Connect => "CONNECT", + RequestMethod::Options => "OPTIONS", + RequestMethod::Trace => "TRACE", + RequestMethod::Patch => "PATCH", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option<Self> { + match value { + "METHOD_UNSPECIFIED" => Some(Self::MethodUnspecified), + "GET" => Some(Self::Get), + "HEAD" => Some(Self::Head), + "POST" => Some(Self::Post), + "PUT" => Some(Self::Put), + "DELETE" => Some(Self::Delete), + "CONNECT" => Some(Self::Connect), + "OPTIONS" => Some(Self::Options), + "TRACE" => Some(Self::Trace), + "PATCH" => Some(Self::Patch), + _ => None, + } + } +} +/// Identifies the direction of the traffic relative to the local Envoy. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum TrafficDirection { + /// Default option is unspecified. + Unspecified = 0, + /// The transport is used for incoming traffic. + Inbound = 1, + /// The transport is used for outgoing traffic. + Outbound = 2, +} +impl TrafficDirection { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + TrafficDirection::Unspecified => "UNSPECIFIED", + TrafficDirection::Inbound => "INBOUND", + TrafficDirection::Outbound => "OUTBOUND", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option<Self> { + match value { + "UNSPECIFIED" => Some(Self::Unspecified), + "INBOUND" => Some(Self::Inbound), + "OUTBOUND" => Some(Self::Outbound), + _ => None, + } + } +} +// \[#protodoc-title: gRPC services\] + +/// gRPC service configuration. This is used by :ref:`ApiConfigSource +/// <envoy_api_msg_core.ApiConfigSource>` and filter configurations. +/// \[#next-free-field: 6\] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GrpcService { + /// The timeout for the gRPC request. This is the timeout for a specific + /// request. + #[prost(message, optional, tag="3")] + pub timeout: ::core::option::Option<super::super::super::super::google::protobuf::Duration>, + /// Additional metadata to include in streams initiated to the GrpcService. + /// This can be used for scenarios in which additional ad hoc authorization + /// headers (e.g. ``x-foo-bar: baz-key``) are to be injected. + #[prost(message, repeated, tag="5")] + pub initial_metadata: ::prost::alloc::vec::Vec<HeaderValue>, + #[prost(oneof="grpc_service::TargetSpecifier", tags="1, 2")] + pub target_specifier: ::core::option::Option<grpc_service::TargetSpecifier>, +} +/// Nested message and enum types in `GrpcService`. +pub mod grpc_service { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct EnvoyGrpc { + /// The name of the upstream gRPC cluster. SSL credentials will be supplied + /// in the :ref:`Cluster <envoy_api_msg_Cluster>` :ref:`transport_socket + /// <envoy_api_field_Cluster.transport_socket>`. + #[prost(string, tag="1")] + pub cluster_name: ::prost::alloc::string::String, + } + /// \[#next-free-field: 7\] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct GoogleGrpc { + /// The target URI when using the `Google C++ gRPC client + /// <<https://github.com/grpc/grpc>`_.> SSL credentials will be supplied in + /// :ref:`channel_credentials <envoy_api_field_core.GrpcService.GoogleGrpc.channel_credentials>`. + #[prost(string, tag="1")] + pub target_uri: ::prost::alloc::string::String, + #[prost(message, optional, tag="2")] + pub channel_credentials: ::core::option::Option<google_grpc::ChannelCredentials>, + /// A set of call credentials that can be composed with `channel credentials + /// <<https://grpc.io/docs/guides/auth.html#credential-types>`_.> + #[prost(message, repeated, tag="3")] + pub call_credentials: ::prost::alloc::vec::Vec<google_grpc::CallCredentials>, + /// The human readable prefix to use when emitting statistics for the gRPC + /// service. + /// + /// .. csv-table:: + /// :header: Name, Type, Description + /// :widths: 1, 1, 2 + /// + /// streams_total, Counter, Total number of streams opened + /// streams_closed_<gRPC status code>, Counter, Total streams closed with <gRPC status code> + #[prost(string, tag="4")] + pub stat_prefix: ::prost::alloc::string::String, + /// The name of the Google gRPC credentials factory to use. This must have been registered with + /// Envoy. If this is empty, a default credentials factory will be used that sets up channel + /// credentials based on other configuration parameters. + #[prost(string, tag="5")] + pub credentials_factory_name: ::prost::alloc::string::String, + /// Additional configuration for site-specific customizations of the Google + /// gRPC library. + #[prost(message, optional, tag="6")] + pub config: ::core::option::Option<super::super::super::super::super::google::protobuf::Struct>, + } + /// Nested message and enum types in `GoogleGrpc`. + pub mod google_grpc { + /// See <https://grpc.io/grpc/cpp/structgrpc_1_1_ssl_credentials_options.html.> + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct SslCredentials { + /// PEM encoded server root certificates. + #[prost(message, optional, tag="1")] + pub root_certs: ::core::option::Option<super::super::DataSource>, + /// PEM encoded client private key. + #[prost(message, optional, tag="2")] + pub private_key: ::core::option::Option<super::super::DataSource>, + /// PEM encoded client certificate chain. + #[prost(message, optional, tag="3")] + pub cert_chain: ::core::option::Option<super::super::DataSource>, + } + /// Local channel credentials. Only UDS is supported for now. + /// See <https://github.com/grpc/grpc/pull/15909.> + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] + pub struct GoogleLocalCredentials { + } + /// See <https://grpc.io/docs/guides/auth.html#credential-types> to understand Channel and Call + /// credential types. + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct ChannelCredentials { + #[prost(oneof="channel_credentials::CredentialSpecifier", tags="1, 2, 3")] + pub credential_specifier: ::core::option::Option<channel_credentials::CredentialSpecifier>, + } + /// Nested message and enum types in `ChannelCredentials`. + pub mod channel_credentials { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum CredentialSpecifier { + #[prost(message, tag="1")] + SslCredentials(super::SslCredentials), + /// <https://grpc.io/grpc/cpp/namespacegrpc.html#a6beb3ac70ff94bd2ebbd89b8f21d1f61> + #[prost(message, tag="2")] + GoogleDefault(super::super::super::super::super::super::super::google::protobuf::Empty), + #[prost(message, tag="3")] + LocalCredentials(super::GoogleLocalCredentials), + } + } + /// \[#next-free-field: 8\] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct CallCredentials { + #[prost(oneof="call_credentials::CredentialSpecifier", tags="1, 2, 3, 4, 5, 6, 7")] + pub credential_specifier: ::core::option::Option<call_credentials::CredentialSpecifier>, + } + /// Nested message and enum types in `CallCredentials`. + pub mod call_credentials { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct ServiceAccountJwtAccessCredentials { + #[prost(string, tag="1")] + pub json_key: ::prost::alloc::string::String, + #[prost(uint64, tag="2")] + pub token_lifetime_seconds: u64, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct GoogleIamCredentials { + #[prost(string, tag="1")] + pub authorization_token: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub authority_selector: ::prost::alloc::string::String, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct MetadataCredentialsFromPlugin { + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + #[prost(oneof="metadata_credentials_from_plugin::ConfigType", tags="2, 3")] + pub config_type: ::core::option::Option<metadata_credentials_from_plugin::ConfigType>, + } + /// Nested message and enum types in `MetadataCredentialsFromPlugin`. + pub mod metadata_credentials_from_plugin { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum ConfigType { + #[prost(message, tag="2")] + Config(super::super::super::super::super::super::super::super::google::protobuf::Struct), + #[prost(message, tag="3")] + TypedConfig(super::super::super::super::super::super::super::super::google::protobuf::Any), + } + } + /// Security token service configuration that allows Google gRPC to + /// fetch security token from an OAuth 2.0 authorization server. + /// See <https://tools.ietf.org/html/draft-ietf-oauth-token-exchange-16> and + /// <https://github.com/grpc/grpc/pull/19587.> + /// \[#next-free-field: 10\] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct StsService { + /// URI of the token exchange service that handles token exchange requests. + /// [#comment:TODO(asraa): Add URI validation when implemented. Tracked by + /// <https://github.com/bufbuild/protoc-gen-validate/issues/303]> + #[prost(string, tag="1")] + pub token_exchange_service_uri: ::prost::alloc::string::String, + /// Location of the target service or resource where the client + /// intends to use the requested security token. + #[prost(string, tag="2")] + pub resource: ::prost::alloc::string::String, + /// Logical name of the target service where the client intends to + /// use the requested security token. + #[prost(string, tag="3")] + pub audience: ::prost::alloc::string::String, + /// The desired scope of the requested security token in the + /// context of the service or resource where the token will be used. + #[prost(string, tag="4")] + pub scope: ::prost::alloc::string::String, + /// Type of the requested security token. + #[prost(string, tag="5")] + pub requested_token_type: ::prost::alloc::string::String, + /// The path of subject token, a security token that represents the + /// identity of the party on behalf of whom the request is being made. + #[prost(string, tag="6")] + pub subject_token_path: ::prost::alloc::string::String, + /// Type of the subject token. + #[prost(string, tag="7")] + pub subject_token_type: ::prost::alloc::string::String, + /// The path of actor token, a security token that represents the identity + /// of the acting party. The acting party is authorized to use the + /// requested security token and act on behalf of the subject. + #[prost(string, tag="8")] + pub actor_token_path: ::prost::alloc::string::String, + /// Type of the actor token. + #[prost(string, tag="9")] + pub actor_token_type: ::prost::alloc::string::String, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum CredentialSpecifier { + /// Access token credentials. + /// <https://grpc.io/grpc/cpp/namespacegrpc.html#ad3a80da696ffdaea943f0f858d7a360d.> + #[prost(string, tag="1")] + AccessToken(::prost::alloc::string::String), + /// Google Compute Engine credentials. + /// <https://grpc.io/grpc/cpp/namespacegrpc.html#a6beb3ac70ff94bd2ebbd89b8f21d1f61> + #[prost(message, tag="2")] + GoogleComputeEngine(super::super::super::super::super::super::super::google::protobuf::Empty), + /// Google refresh token credentials. + /// <https://grpc.io/grpc/cpp/namespacegrpc.html#a96901c997b91bc6513b08491e0dca37c.> + #[prost(string, tag="3")] + GoogleRefreshToken(::prost::alloc::string::String), + /// Service Account JWT Access credentials. + /// <https://grpc.io/grpc/cpp/namespacegrpc.html#a92a9f959d6102461f66ee973d8e9d3aa.> + #[prost(message, tag="4")] + ServiceAccountJwtAccess(ServiceAccountJwtAccessCredentials), + /// Google IAM credentials. + /// <https://grpc.io/grpc/cpp/namespacegrpc.html#a9fc1fc101b41e680d47028166e76f9d0.> + #[prost(message, tag="5")] + GoogleIam(GoogleIamCredentials), + /// Custom authenticator credentials. + /// <https://grpc.io/grpc/cpp/namespacegrpc.html#a823c6a4b19ffc71fb33e90154ee2ad07.> + /// <https://grpc.io/docs/guides/auth.html#extending-grpc-to-support-other-authentication-mechanisms.> + #[prost(message, tag="6")] + FromPlugin(MetadataCredentialsFromPlugin), + /// Custom security token service which implements OAuth 2.0 token exchange. + /// <https://tools.ietf.org/html/draft-ietf-oauth-token-exchange-16> + /// See <https://github.com/grpc/grpc/pull/19587.> + #[prost(message, tag="7")] + StsService(StsService), + } + } + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum TargetSpecifier { + /// Envoy's in-built gRPC client. + /// See the :ref:`gRPC services overview <arch_overview_grpc_services>` + /// documentation for discussion on gRPC client selection. + #[prost(message, tag="1")] + EnvoyGrpc(EnvoyGrpc), + /// `Google C++ gRPC client <<https://github.com/grpc/grpc>`_> + /// See the :ref:`gRPC services overview <arch_overview_grpc_services>` + /// documentation for discussion on gRPC client selection. + #[prost(message, tag="2")] + GoogleGrpc(GoogleGrpc), + } +} +/// \[#not-implemented-hide:\] +/// Configuration of the event reporting service endpoint. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct EventServiceConfig { + #[prost(oneof="event_service_config::ConfigSourceSpecifier", tags="1")] + pub config_source_specifier: ::core::option::Option<event_service_config::ConfigSourceSpecifier>, +} +/// Nested message and enum types in `EventServiceConfig`. +pub mod event_service_config { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum ConfigSourceSpecifier { + /// Specifies the gRPC service that hosts the event reporting service. + #[prost(message, tag="1")] + GrpcService(super::GrpcService), + } +} +/// \[#next-free-field: 23\] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct HealthCheck { + /// The time to wait for a health check response. If the timeout is reached the + /// health check attempt will be considered a failure. + #[prost(message, optional, tag="1")] + pub timeout: ::core::option::Option<super::super::super::super::google::protobuf::Duration>, + /// The interval between health checks. + #[prost(message, optional, tag="2")] + pub interval: ::core::option::Option<super::super::super::super::google::protobuf::Duration>, + /// An optional jitter amount in milliseconds. If specified, Envoy will start health + /// checking after for a random time in ms between 0 and initial_jitter. This only + /// applies to the first health check. + #[prost(message, optional, tag="20")] + pub initial_jitter: ::core::option::Option<super::super::super::super::google::protobuf::Duration>, + /// An optional jitter amount in milliseconds. If specified, during every + /// interval Envoy will add interval_jitter to the wait time. + #[prost(message, optional, tag="3")] + pub interval_jitter: ::core::option::Option<super::super::super::super::google::protobuf::Duration>, + /// An optional jitter amount as a percentage of interval_ms. If specified, + /// during every interval Envoy will add interval_ms * + /// interval_jitter_percent / 100 to the wait time. + /// + /// If interval_jitter_ms and interval_jitter_percent are both set, both of + /// them will be used to increase the wait time. + #[prost(uint32, tag="18")] + pub interval_jitter_percent: u32, + /// The number of unhealthy health checks required before a host is marked + /// unhealthy. Note that for *http* health checking if a host responds with 503 + /// this threshold is ignored and the host is considered unhealthy immediately. + #[prost(message, optional, tag="4")] + pub unhealthy_threshold: ::core::option::Option<super::super::super::super::google::protobuf::UInt32Value>, + /// The number of healthy health checks required before a host is marked + /// healthy. Note that during startup, only a single successful health check is + /// required to mark a host healthy. + #[prost(message, optional, tag="5")] + pub healthy_threshold: ::core::option::Option<super::super::super::super::google::protobuf::UInt32Value>, + /// \[#not-implemented-hide:\] Non-serving port for health checking. + #[prost(message, optional, tag="6")] + pub alt_port: ::core::option::Option<super::super::super::super::google::protobuf::UInt32Value>, + /// Reuse health check connection between health checks. Default is true. + #[prost(message, optional, tag="7")] + pub reuse_connection: ::core::option::Option<super::super::super::super::google::protobuf::BoolValue>, + /// The "no traffic interval" is a special health check interval that is used when a cluster has + /// never had traffic routed to it. This lower interval allows cluster information to be kept up to + /// date, without sending a potentially large amount of active health checking traffic for no + /// reason. Once a cluster has been used for traffic routing, Envoy will shift back to using the + /// standard health check interval that is defined. Note that this interval takes precedence over + /// any other. + /// + /// The default value for "no traffic interval" is 60 seconds. + #[prost(message, optional, tag="12")] + pub no_traffic_interval: ::core::option::Option<super::super::super::super::google::protobuf::Duration>, + /// The "unhealthy interval" is a health check interval that is used for hosts that are marked as + /// unhealthy. As soon as the host is marked as healthy, Envoy will shift back to using the + /// standard health check interval that is defined. + /// + /// The default value for "unhealthy interval" is the same as "interval". + #[prost(message, optional, tag="14")] + pub unhealthy_interval: ::core::option::Option<super::super::super::super::google::protobuf::Duration>, + /// The "unhealthy edge interval" is a special health check interval that is used for the first + /// health check right after a host is marked as unhealthy. For subsequent health checks + /// Envoy will shift back to using either "unhealthy interval" if present or the standard health + /// check interval that is defined. + /// + /// The default value for "unhealthy edge interval" is the same as "unhealthy interval". + #[prost(message, optional, tag="15")] + pub unhealthy_edge_interval: ::core::option::Option<super::super::super::super::google::protobuf::Duration>, + /// The "healthy edge interval" is a special health check interval that is used for the first + /// health check right after a host is marked as healthy. For subsequent health checks + /// Envoy will shift back to using the standard health check interval that is defined. + /// + /// The default value for "healthy edge interval" is the same as the default interval. + #[prost(message, optional, tag="16")] + pub healthy_edge_interval: ::core::option::Option<super::super::super::super::google::protobuf::Duration>, + /// Specifies the path to the :ref:`health check event log <arch_overview_health_check_logging>`. + /// If empty, no event log will be written. + #[prost(string, tag="17")] + pub event_log_path: ::prost::alloc::string::String, + /// \[#not-implemented-hide:\] + /// The gRPC service for the health check event service. + /// If empty, health check events won't be sent to a remote endpoint. + #[prost(message, optional, tag="22")] + pub event_service: ::core::option::Option<EventServiceConfig>, + /// If set to true, health check failure events will always be logged. If set to false, only the + /// initial health check failure event will be logged. + /// The default value is false. + #[prost(bool, tag="19")] + pub always_log_health_check_failures: bool, + /// This allows overriding the cluster TLS settings, just for health check connections. + #[prost(message, optional, tag="21")] + pub tls_options: ::core::option::Option<health_check::TlsOptions>, + #[prost(oneof="health_check::HealthChecker", tags="8, 9, 11, 13")] + pub health_checker: ::core::option::Option<health_check::HealthChecker>, +} +/// Nested message and enum types in `HealthCheck`. +pub mod health_check { + /// Describes the encoding of the payload bytes in the payload. + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct Payload { + #[prost(oneof="payload::Payload", tags="1, 2")] + pub payload: ::core::option::Option<payload::Payload>, + } + /// Nested message and enum types in `Payload`. + pub mod payload { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Payload { + /// Hex encoded payload. E.g., "000000FF". + #[prost(string, tag="1")] + Text(::prost::alloc::string::String), + /// \[#not-implemented-hide:\] Binary payload. + #[prost(bytes, tag="2")] + Binary(::prost::alloc::vec::Vec<u8>), + } + } + /// \[#next-free-field: 12\] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct HttpHealthCheck { + /// The value of the host header in the HTTP health check request. If + /// left empty (default value), the name of the cluster this health check is associated + /// with will be used. The host header can be customized for a specific endpoint by setting the + /// :ref:`hostname <envoy_api_field_endpoint.Endpoint.HealthCheckConfig.hostname>` field. + #[prost(string, tag="1")] + pub host: ::prost::alloc::string::String, + /// Specifies the HTTP path that will be requested during health checking. For example + /// */healthcheck*. + #[prost(string, tag="2")] + pub path: ::prost::alloc::string::String, + /// \[#not-implemented-hide:\] HTTP specific payload. + #[prost(message, optional, tag="3")] + pub send: ::core::option::Option<Payload>, + /// \[#not-implemented-hide:\] HTTP specific response. + #[prost(message, optional, tag="4")] + pub receive: ::core::option::Option<Payload>, + /// An optional service name parameter which is used to validate the identity of + /// the health checked cluster. See the :ref:`architecture overview + /// <arch_overview_health_checking_identity>` for more information. + /// + /// .. attention:: + /// + /// This field has been deprecated in favor of `service_name_matcher` for better flexibility + /// over matching with service-cluster name. + #[deprecated] + #[prost(string, tag="5")] + pub service_name: ::prost::alloc::string::String, + /// Specifies a list of HTTP headers that should be added to each request that is sent to the + /// health checked cluster. For more information, including details on header value syntax, see + /// the documentation on :ref:`custom request headers + /// <config_http_conn_man_headers_custom_request_headers>`. + #[prost(message, repeated, tag="6")] + pub request_headers_to_add: ::prost::alloc::vec::Vec<super::HeaderValueOption>, + /// Specifies a list of HTTP headers that should be removed from each request that is sent to the + /// health checked cluster. + #[prost(string, repeated, tag="8")] + pub request_headers_to_remove: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// If set, health checks will be made using http/2. + /// Deprecated, use :ref:`codec_client_type + /// <envoy_api_field_core.HealthCheck.HttpHealthCheck.codec_client_type>` instead. + #[deprecated] + #[prost(bool, tag="7")] + pub use_http2: bool, + /// Specifies a list of HTTP response statuses considered healthy. If provided, replaces default + /// 200-only policy - 200 must be included explicitly as needed. Ranges follow half-open + /// semantics of :ref:`Int64Range <envoy_api_msg_type.Int64Range>`. The start and end of each + /// range are required. Only statuses in the range [100, 600) are allowed. + #[prost(message, repeated, tag="9")] + pub expected_statuses: ::prost::alloc::vec::Vec<super::super::super::super::r#type::Int64Range>, + /// Use specified application protocol for health checks. + #[prost(enumeration="super::super::super::super::r#type::CodecClientType", tag="10")] + pub codec_client_type: i32, + /// An optional service name parameter which is used to validate the identity of + /// the health checked cluster using a :ref:`StringMatcher + /// <envoy_api_msg_type.matcher.StringMatcher>`. See the :ref:`architecture overview + /// <arch_overview_health_checking_identity>` for more information. + #[prost(message, optional, tag="11")] + pub service_name_matcher: ::core::option::Option<super::super::super::super::r#type::matcher::StringMatcher>, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct TcpHealthCheck { + /// Empty payloads imply a connect-only health check. + #[prost(message, optional, tag="1")] + pub send: ::core::option::Option<Payload>, + /// When checking the response, “fuzzy” matching is performed such that each + /// binary block must be found, and in the order specified, but not + /// necessarily contiguous. + #[prost(message, repeated, tag="2")] + pub receive: ::prost::alloc::vec::Vec<Payload>, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct RedisHealthCheck { + /// If set, optionally perform ``EXISTS <key>`` instead of ``PING``. A return value + /// from Redis of 0 (does not exist) is considered a passing healthcheck. A return value other + /// than 0 is considered a failure. This allows the user to mark a Redis instance for maintenance + /// by setting the specified key to any value and waiting for traffic to drain. + #[prost(string, tag="1")] + pub key: ::prost::alloc::string::String, + } + /// `grpc.health.v1.Health + /// <<https://github.com/grpc/grpc/blob/master/src/proto/grpc/health/v1/health.proto>`_-based> + /// healthcheck. See `gRPC doc <<https://github.com/grpc/grpc/blob/master/doc/health-checking.md>`_> + /// for details. + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct GrpcHealthCheck { + /// An optional service name parameter which will be sent to gRPC service in + /// `grpc.health.v1.HealthCheckRequest + /// <<https://github.com/grpc/grpc/blob/master/src/proto/grpc/health/v1/health.proto#L20>`_.> + /// message. See `gRPC health-checking overview + /// <<https://github.com/grpc/grpc/blob/master/doc/health-checking.md>`_> for more information. + #[prost(string, tag="1")] + pub service_name: ::prost::alloc::string::String, + /// The value of the :authority header in the gRPC health check request. If + /// left empty (default value), the name of the cluster this health check is associated + /// with will be used. The authority header can be customized for a specific endpoint by setting + /// the :ref:`hostname <envoy_api_field_endpoint.Endpoint.HealthCheckConfig.hostname>` field. + #[prost(string, tag="2")] + pub authority: ::prost::alloc::string::String, + } + /// Custom health check. + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct CustomHealthCheck { + /// The registered name of the custom health checker. + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + /// A custom health checker specific configuration which depends on the custom health checker + /// being instantiated. See :api:`envoy/config/health_checker` for reference. + #[prost(oneof="custom_health_check::ConfigType", tags="2, 3")] + pub config_type: ::core::option::Option<custom_health_check::ConfigType>, + } + /// Nested message and enum types in `CustomHealthCheck`. + pub mod custom_health_check { + /// A custom health checker specific configuration which depends on the custom health checker + /// being instantiated. See :api:`envoy/config/health_checker` for reference. + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum ConfigType { + #[prost(message, tag="2")] + Config(super::super::super::super::super::super::google::protobuf::Struct), + #[prost(message, tag="3")] + TypedConfig(super::super::super::super::super::super::google::protobuf::Any), + } + } + /// Health checks occur over the transport socket specified for the cluster. This implies that if a + /// cluster is using a TLS-enabled transport socket, the health check will also occur over TLS. + /// + /// This allows overriding the cluster TLS settings, just for health check connections. + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct TlsOptions { + /// Specifies the ALPN protocols for health check connections. This is useful if the + /// corresponding upstream is using ALPN-based :ref:`FilterChainMatch + /// <envoy_api_msg_listener.FilterChainMatch>` along with different protocols for health checks + /// versus data connections. If empty, no ALPN protocols will be set on health check connections. + #[prost(string, repeated, tag="1")] + pub alpn_protocols: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum HealthChecker { + /// HTTP health check. + #[prost(message, tag="8")] + HttpHealthCheck(HttpHealthCheck), + /// TCP health check. + #[prost(message, tag="9")] + TcpHealthCheck(TcpHealthCheck), + /// gRPC health check. + #[prost(message, tag="11")] + GrpcHealthCheck(GrpcHealthCheck), + /// Custom health check. + #[prost(message, tag="13")] + CustomHealthCheck(CustomHealthCheck), + } +} +// \[#protodoc-title: Health check\] +// * Health checking :ref:`architecture overview <arch_overview_health_checking>`. +// * If health checking is configured for a cluster, additional statistics are emitted. They are +// documented :ref:`here <config_cluster_manager_cluster_stats>`. + +/// Endpoint health status. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum HealthStatus { + /// The health status is not known. This is interpreted by Envoy as *HEALTHY*. + Unknown = 0, + /// Healthy. + Healthy = 1, + /// Unhealthy. + Unhealthy = 2, + /// Connection draining in progress. E.g., + /// `<<https://aws.amazon.com/blogs/aws/elb-connection-draining-remove-instances-from-service-with-care/>`_> + /// or + /// `<<https://cloud.google.com/compute/docs/load-balancing/enabling-connection-draining>`_.> + /// This is interpreted by Envoy as *UNHEALTHY*. + Draining = 3, + /// Health check timed out. This is part of HDS and is interpreted by Envoy as + /// *UNHEALTHY*. + Timeout = 4, + /// Degraded. + Degraded = 5, +} +impl HealthStatus { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + HealthStatus::Unknown => "UNKNOWN", + HealthStatus::Healthy => "HEALTHY", + HealthStatus::Unhealthy => "UNHEALTHY", + HealthStatus::Draining => "DRAINING", + HealthStatus::Timeout => "TIMEOUT", + HealthStatus::Degraded => "DEGRADED", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option<Self> { + match value { + "UNKNOWN" => Some(Self::Unknown), + "HEALTHY" => Some(Self::Healthy), + "UNHEALTHY" => Some(Self::Unhealthy), + "DRAINING" => Some(Self::Draining), + "TIMEOUT" => Some(Self::Timeout), + "DEGRADED" => Some(Self::Degraded), + _ => None, + } + } +} +/// API configuration source. This identifies the API type and cluster that Envoy +/// will use to fetch an xDS API. +/// \[#next-free-field: 9\] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ApiConfigSource { + /// API type (gRPC, REST, delta gRPC) + #[prost(enumeration="api_config_source::ApiType", tag="1")] + pub api_type: i32, + /// API version for xDS transport protocol. This describes the xDS gRPC/REST + /// endpoint and version of \[Delta\]DiscoveryRequest/Response used on the wire. + #[prost(enumeration="ApiVersion", tag="8")] + pub transport_api_version: i32, + /// Cluster names should be used only with REST. If > 1 + /// cluster is defined, clusters will be cycled through if any kind of failure + /// occurs. + /// + /// .. note:: + /// + /// The cluster with name ``cluster_name`` must be statically defined and its + /// type must not be ``EDS``. + #[prost(string, repeated, tag="2")] + pub cluster_names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// Multiple gRPC services be provided for GRPC. If > 1 cluster is defined, + /// services will be cycled through if any kind of failure occurs. + #[prost(message, repeated, tag="4")] + pub grpc_services: ::prost::alloc::vec::Vec<GrpcService>, + /// For REST APIs, the delay between successive polls. + #[prost(message, optional, tag="3")] + pub refresh_delay: ::core::option::Option<super::super::super::super::google::protobuf::Duration>, + /// For REST APIs, the request timeout. If not set, a default value of 1s will be used. + #[prost(message, optional, tag="5")] + pub request_timeout: ::core::option::Option<super::super::super::super::google::protobuf::Duration>, + /// For GRPC APIs, the rate limit settings. If present, discovery requests made by Envoy will be + /// rate limited. + #[prost(message, optional, tag="6")] + pub rate_limit_settings: ::core::option::Option<RateLimitSettings>, + /// Skip the node identifier in subsequent discovery requests for streaming gRPC config types. + #[prost(bool, tag="7")] + pub set_node_on_first_message_only: bool, +} +/// Nested message and enum types in `ApiConfigSource`. +pub mod api_config_source { + /// APIs may be fetched via either REST or gRPC. + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum ApiType { + /// Ideally this would be 'reserved 0' but one can't reserve the default + /// value. Instead we throw an exception if this is ever used. + UnsupportedRestLegacy = 0, + /// REST-JSON v2 API. The `canonical JSON encoding + /// <<https://developers.google.com/protocol-buffers/docs/proto3#json>`_> for + /// the v2 protos is used. + Rest = 1, + /// gRPC v2 API. + Grpc = 2, + /// Using the delta xDS gRPC service, i.e. DeltaDiscovery{Request,Response} + /// rather than Discovery{Request,Response}. Rather than sending Envoy the entire state + /// with every update, the xDS server only sends what has changed since the last update. + DeltaGrpc = 3, + } + impl ApiType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + ApiType::UnsupportedRestLegacy => "UNSUPPORTED_REST_LEGACY", + ApiType::Rest => "REST", + ApiType::Grpc => "GRPC", + ApiType::DeltaGrpc => "DELTA_GRPC", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option<Self> { + match value { + "UNSUPPORTED_REST_LEGACY" => Some(Self::UnsupportedRestLegacy), + "REST" => Some(Self::Rest), + "GRPC" => Some(Self::Grpc), + "DELTA_GRPC" => Some(Self::DeltaGrpc), + _ => None, + } + } + } +} +/// Aggregated Discovery Service (ADS) options. This is currently empty, but when +/// set in :ref:`ConfigSource <envoy_api_msg_core.ConfigSource>` can be used to +/// specify that ADS is to be used. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct AggregatedConfigSource { +} +/// \[#not-implemented-hide:\] +/// Self-referencing config source options. This is currently empty, but when +/// set in :ref:`ConfigSource <envoy_api_msg_core.ConfigSource>` can be used to +/// specify that other data can be obtained from the same server. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct SelfConfigSource { + /// API version for xDS transport protocol. This describes the xDS gRPC/REST + /// endpoint and version of \[Delta\]DiscoveryRequest/Response used on the wire. + #[prost(enumeration="ApiVersion", tag="1")] + pub transport_api_version: i32, +} +/// Rate Limit settings to be applied for discovery requests made by Envoy. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct RateLimitSettings { + /// Maximum number of tokens to be used for rate limiting discovery request calls. If not set, a + /// default value of 100 will be used. + #[prost(message, optional, tag="1")] + pub max_tokens: ::core::option::Option<super::super::super::super::google::protobuf::UInt32Value>, + /// Rate at which tokens will be filled per second. If not set, a default fill rate of 10 tokens + /// per second will be used. + #[prost(message, optional, tag="2")] + pub fill_rate: ::core::option::Option<super::super::super::super::google::protobuf::DoubleValue>, +} +/// Configuration for :ref:`listeners <config_listeners>`, :ref:`clusters +/// <config_cluster_manager>`, :ref:`routes +/// <envoy_api_msg_RouteConfiguration>`, :ref:`endpoints +/// <arch_overview_service_discovery>` etc. may either be sourced from the +/// filesystem or from an xDS API source. Filesystem configs are watched with +/// inotify for updates. +/// \[#next-free-field: 7\] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ConfigSource { + /// When this timeout is specified, Envoy will wait no longer than the specified time for first + /// config response on this xDS subscription during the :ref:`initialization process + /// <arch_overview_initialization>`. After reaching the timeout, Envoy will move to the next + /// initialization phase, even if the first config is not delivered yet. The timer is activated + /// when the xDS API subscription starts, and is disarmed on first config update or on error. 0 + /// means no timeout - Envoy will wait indefinitely for the first xDS config (unless another + /// timeout applies). The default is 15s. + #[prost(message, optional, tag="4")] + pub initial_fetch_timeout: ::core::option::Option<super::super::super::super::google::protobuf::Duration>, + /// API version for xDS resources. This implies the type URLs that the client + /// will request for resources and the resource type that the client will in + /// turn expect to be delivered. + #[prost(enumeration="ApiVersion", tag="6")] + pub resource_api_version: i32, + #[prost(oneof="config_source::ConfigSourceSpecifier", tags="1, 2, 3, 5")] + pub config_source_specifier: ::core::option::Option<config_source::ConfigSourceSpecifier>, +} +/// Nested message and enum types in `ConfigSource`. +pub mod config_source { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum ConfigSourceSpecifier { + /// Path on the filesystem to source and watch for configuration updates. + /// When sourcing configuration for :ref:`secret <envoy_api_msg_auth.Secret>`, + /// the certificate and key files are also watched for updates. + /// + /// .. note:: + /// + /// The path to the source must exist at config load time. + /// + /// .. note:: + /// + /// Envoy will only watch the file path for *moves.* This is because in general only moves + /// are atomic. The same method of swapping files as is demonstrated in the + /// :ref:`runtime documentation <config_runtime_symbolic_link_swap>` can be used here also. + #[prost(string, tag="1")] + Path(::prost::alloc::string::String), + /// API configuration source. + #[prost(message, tag="2")] + ApiConfigSource(super::ApiConfigSource), + /// When set, ADS will be used to fetch resources. The ADS API configuration + /// source in the bootstrap configuration is used. + #[prost(message, tag="3")] + Ads(super::AggregatedConfigSource), + /// \[#not-implemented-hide:\] + /// When set, the client will access the resources from the same server it got the + /// ConfigSource from, although not necessarily from the same stream. This is similar to the + /// :ref:`ads<envoy_api_field.ConfigSource.ads>` field, except that the client may use a + /// different stream to the same server. As a result, this field can be used for things + /// like LRS that cannot be sent on an ADS stream. It can also be used to link from (e.g.) + /// LDS to RDS on the same server without requiring the management server to know its name + /// or required credentials. + /// [#next-major-version: In xDS v3, consider replacing the ads field with this one, since + /// this field can implicitly mean to use the same stream in the case where the ConfigSource + /// is provided via ADS and the specified data can also be obtained via ADS.] + #[prost(message, tag="5")] + Self_(super::SelfConfigSource), + } +} +// \[#protodoc-title: Configuration sources\] + +/// xDS API version. This is used to describe both resource and transport +/// protocol versions (in distinct configuration fields). +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum ApiVersion { + /// When not specified, we assume v2, to ease migration to Envoy's stable API + /// versioning. If a client does not support v2 (e.g. due to deprecation), this + /// is an invalid value. + Auto = 0, + /// Use xDS v2 API. + V2 = 1, + /// Use xDS v3 API. + V3 = 2, +} +impl ApiVersion { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + ApiVersion::Auto => "AUTO", + ApiVersion::V2 => "V2", + ApiVersion::V3 => "V3", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option<Self> { + match value { + "AUTO" => Some(Self::Auto), + "V2" => Some(Self::V2), + "V3" => Some(Self::V3), + _ => None, + } + } +} +// \[#protodoc-title: Protocol options\] + +/// \[#not-implemented-hide:\] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct TcpProtocolOptions { +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct UpstreamHttpProtocolOptions { + /// Set transport socket `SNI <<https://en.wikipedia.org/wiki/Server_Name_Indication>`_> for new + /// upstream connections based on the downstream HTTP host/authority header, as seen by the + /// :ref:`router filter <config_http_filters_router>`. + #[prost(bool, tag="1")] + pub auto_sni: bool, + /// Automatic validate upstream presented certificate for new upstream connections based on the + /// downstream HTTP host/authority header, as seen by the + /// :ref:`router filter <config_http_filters_router>`. + /// This field is intended to set with `auto_sni` field. + #[prost(bool, tag="2")] + pub auto_san_validation: bool, +} +/// \[#next-free-field: 6\] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct HttpProtocolOptions { + /// The idle timeout for connections. The idle timeout is defined as the + /// period in which there are no active requests. When the + /// idle timeout is reached the connection will be closed. If the connection is an HTTP/2 + /// downstream connection a drain sequence will occur prior to closing the connection, see + /// :ref:`drain_timeout + /// <envoy_api_field_config.filter.network.http_connection_manager.v2.HttpConnectionManager.drain_timeout>`. + /// Note that request based timeouts mean that HTTP/2 PINGs will not keep the connection alive. + /// If not specified, this defaults to 1 hour. To disable idle timeouts explicitly set this to 0. + /// + /// .. warning:: + /// Disabling this timeout has a highly likelihood of yielding connection leaks due to lost TCP + /// FIN packets, etc. + #[prost(message, optional, tag="1")] + pub idle_timeout: ::core::option::Option<super::super::super::super::google::protobuf::Duration>, + /// The maximum duration of a connection. The duration is defined as a period since a connection + /// was established. If not set, there is no max duration. When max_connection_duration is reached + /// the connection will be closed. Drain sequence will occur prior to closing the connection if + /// if's applicable. See :ref:`drain_timeout + /// <envoy_api_field_config.filter.network.http_connection_manager.v2.HttpConnectionManager.drain_timeout>`. + /// Note: not implemented for upstream connections. + #[prost(message, optional, tag="3")] + pub max_connection_duration: ::core::option::Option<super::super::super::super::google::protobuf::Duration>, + /// The maximum number of headers. If unconfigured, the default + /// maximum number of request headers allowed is 100. Requests that exceed this limit will receive + /// a 431 response for HTTP/1.x and cause a stream reset for HTTP/2. + #[prost(message, optional, tag="2")] + pub max_headers_count: ::core::option::Option<super::super::super::super::google::protobuf::UInt32Value>, + /// Total duration to keep alive an HTTP request/response stream. If the time limit is reached the stream will be + /// reset independent of any other timeouts. If not specified, this value is not set. + #[prost(message, optional, tag="4")] + pub max_stream_duration: ::core::option::Option<super::super::super::super::google::protobuf::Duration>, + /// Action to take when a client request with a header name containing underscore characters is received. + /// If this setting is not specified, the value defaults to ALLOW. + /// Note: upstream responses are not affected by this setting. + #[prost(enumeration="http_protocol_options::HeadersWithUnderscoresAction", tag="5")] + pub headers_with_underscores_action: i32, +} +/// Nested message and enum types in `HttpProtocolOptions`. +pub mod http_protocol_options { + /// Action to take when Envoy receives client request with header names containing underscore + /// characters. + /// Underscore character is allowed in header names by the RFC-7230 and this behavior is implemented + /// as a security measure due to systems that treat '_' and '-' as interchangeable. Envoy by default allows client request headers with underscore + /// characters. + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum HeadersWithUnderscoresAction { + /// Allow headers with underscores. This is the default behavior. + Allow = 0, + /// Reject client request. HTTP/1 requests are rejected with the 400 status. HTTP/2 requests + /// end with the stream reset. The "httpN.requests_rejected_with_underscores_in_headers" counter + /// is incremented for each rejected request. + RejectRequest = 1, + /// Drop the header with name containing underscores. The header is dropped before the filter chain is + /// invoked and as such filters will not see dropped headers. The + /// "httpN.dropped_headers_with_underscores" is incremented for each dropped header. + DropHeader = 2, + } + impl HeadersWithUnderscoresAction { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + HeadersWithUnderscoresAction::Allow => "ALLOW", + HeadersWithUnderscoresAction::RejectRequest => "REJECT_REQUEST", + HeadersWithUnderscoresAction::DropHeader => "DROP_HEADER", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option<Self> { + match value { + "ALLOW" => Some(Self::Allow), + "REJECT_REQUEST" => Some(Self::RejectRequest), + "DROP_HEADER" => Some(Self::DropHeader), + _ => None, + } + } + } +} +/// \[#next-free-field: 6\] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Http1ProtocolOptions { + /// Handle HTTP requests with absolute URLs in the requests. These requests + /// are generally sent by clients to forward/explicit proxies. This allows clients to configure + /// envoy as their HTTP proxy. In Unix, for example, this is typically done by setting the + /// *http_proxy* environment variable. + #[prost(message, optional, tag="1")] + pub allow_absolute_url: ::core::option::Option<super::super::super::super::google::protobuf::BoolValue>, + /// Handle incoming HTTP/1.0 and HTTP 0.9 requests. + /// This is off by default, and not fully standards compliant. There is support for pre-HTTP/1.1 + /// style connect logic, dechunking, and handling lack of client host iff + /// *default_host_for_http_10* is configured. + #[prost(bool, tag="2")] + pub accept_http_10: bool, + /// A default host for HTTP/1.0 requests. This is highly suggested if *accept_http_10* is true as + /// Envoy does not otherwise support HTTP/1.0 without a Host header. + /// This is a no-op if *accept_http_10* is not true. + #[prost(string, tag="3")] + pub default_host_for_http_10: ::prost::alloc::string::String, + /// Describes how the keys for response headers should be formatted. By default, all header keys + /// are lower cased. + #[prost(message, optional, tag="4")] + pub header_key_format: ::core::option::Option<http1_protocol_options::HeaderKeyFormat>, + /// Enables trailers for HTTP/1. By default the HTTP/1 codec drops proxied trailers. + /// + /// .. attention:: + /// + /// Note that this only happens when Envoy is chunk encoding which occurs when: + /// - The request is HTTP/1.1. + /// - Is neither a HEAD only request nor a HTTP Upgrade. + /// - Not a response to a HEAD request. + /// - The content length header is not present. + #[prost(bool, tag="5")] + pub enable_trailers: bool, +} +/// Nested message and enum types in `Http1ProtocolOptions`. +pub mod http1_protocol_options { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] + pub struct HeaderKeyFormat { + #[prost(oneof="header_key_format::HeaderFormat", tags="1")] + pub header_format: ::core::option::Option<header_key_format::HeaderFormat>, + } + /// Nested message and enum types in `HeaderKeyFormat`. + pub mod header_key_format { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] + pub struct ProperCaseWords { + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Oneof)] + pub enum HeaderFormat { + /// Formats the header by proper casing words: the first character and any character following + /// a special character will be capitalized if it's an alpha character. For example, + /// "content-type" becomes "Content-Type", and "foo$b#$are" becomes "Foo$B#$Are". + /// Note that while this results in most headers following conventional casing, certain headers + /// are not covered. For example, the "TE" header will be formatted as "Te". + #[prost(message, tag="1")] + ProperCaseWords(ProperCaseWords), + } + } +} +/// \[#next-free-field: 14\] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Http2ProtocolOptions { + /// `Maximum table size <<https://httpwg.org/specs/rfc7541.html#rfc.section.4.2>`_> + /// (in octets) that the encoder is permitted to use for the dynamic HPACK table. Valid values + /// range from 0 to 4294967295 (2^32 - 1) and defaults to 4096. 0 effectively disables header + /// compression. + #[prost(message, optional, tag="1")] + pub hpack_table_size: ::core::option::Option<super::super::super::super::google::protobuf::UInt32Value>, + /// `Maximum concurrent streams <<https://httpwg.org/specs/rfc7540.html#rfc.section.5.1.2>`_> + /// allowed for peer on one HTTP/2 connection. Valid values range from 1 to 2147483647 (2^31 - 1) + /// and defaults to 2147483647. + /// + /// For upstream connections, this also limits how many streams Envoy will initiate concurrently + /// on a single connection. If the limit is reached, Envoy may queue requests or establish + /// additional connections (as allowed per circuit breaker limits). + #[prost(message, optional, tag="2")] + pub max_concurrent_streams: ::core::option::Option<super::super::super::super::google::protobuf::UInt32Value>, + /// `Initial stream-level flow-control window + /// <<https://httpwg.org/specs/rfc7540.html#rfc.section.6.9.2>`_> size. Valid values range from 65535 + /// (2^16 - 1, HTTP/2 default) to 2147483647 (2^31 - 1, HTTP/2 maximum) and defaults to 268435456 + /// (256 * 1024 * 1024). + /// + /// NOTE: 65535 is the initial window size from HTTP/2 spec. We only support increasing the default + /// window size now, so it's also the minimum. + /// + /// This field also acts as a soft limit on the number of bytes Envoy will buffer per-stream in the + /// HTTP/2 codec buffers. Once the buffer reaches this pointer, watermark callbacks will fire to + /// stop the flow of data to the codec buffers. + #[prost(message, optional, tag="3")] + pub initial_stream_window_size: ::core::option::Option<super::super::super::super::google::protobuf::UInt32Value>, + /// Similar to *initial_stream_window_size*, but for connection-level flow-control + /// window. Currently, this has the same minimum/maximum/default as *initial_stream_window_size*. + #[prost(message, optional, tag="4")] + pub initial_connection_window_size: ::core::option::Option<super::super::super::super::google::protobuf::UInt32Value>, + /// Allows proxying Websocket and other upgrades over H2 connect. + #[prost(bool, tag="5")] + pub allow_connect: bool, + /// \[#not-implemented-hide:\] Hiding until envoy has full metadata support. + /// Still under implementation. DO NOT USE. + /// + /// Allows metadata. See [metadata + /// docs](<https://github.com/envoyproxy/envoy/blob/main/source/docs/h2_metadata.md>) for more + /// information. + #[prost(bool, tag="6")] + pub allow_metadata: bool, + /// Limit the number of pending outbound downstream frames of all types (frames that are waiting to + /// be written into the socket). Exceeding this limit triggers flood mitigation and connection is + /// terminated. The ``http2.outbound_flood`` stat tracks the number of terminated connections due + /// to flood mitigation. The default limit is 10000. + /// \[#comment:TODO: implement same limits for upstream outbound frames as well.\] + #[prost(message, optional, tag="7")] + pub max_outbound_frames: ::core::option::Option<super::super::super::super::google::protobuf::UInt32Value>, + /// Limit the number of pending outbound downstream frames of types PING, SETTINGS and RST_STREAM, + /// preventing high memory utilization when receiving continuous stream of these frames. Exceeding + /// this limit triggers flood mitigation and connection is terminated. The + /// ``http2.outbound_control_flood`` stat tracks the number of terminated connections due to flood + /// mitigation. The default limit is 1000. + /// \[#comment:TODO: implement same limits for upstream outbound frames as well.\] + #[prost(message, optional, tag="8")] + pub max_outbound_control_frames: ::core::option::Option<super::super::super::super::google::protobuf::UInt32Value>, + /// Limit the number of consecutive inbound frames of types HEADERS, CONTINUATION and DATA with an + /// empty payload and no end stream flag. Those frames have no legitimate use and are abusive, but + /// might be a result of a broken HTTP/2 implementation. The `http2.inbound_empty_frames_flood`` + /// stat tracks the number of connections terminated due to flood mitigation. + /// Setting this to 0 will terminate connection upon receiving first frame with an empty payload + /// and no end stream flag. The default limit is 1. + /// \[#comment:TODO: implement same limits for upstream inbound frames as well.\] + #[prost(message, optional, tag="9")] + pub max_consecutive_inbound_frames_with_empty_payload: ::core::option::Option<super::super::super::super::google::protobuf::UInt32Value>, + /// Limit the number of inbound PRIORITY frames allowed per each opened stream. If the number + /// of PRIORITY frames received over the lifetime of connection exceeds the value calculated + /// using this formula:: + /// + /// max_inbound_priority_frames_per_stream * (1 + inbound_streams) + /// + /// the connection is terminated. The ``http2.inbound_priority_frames_flood`` stat tracks + /// the number of connections terminated due to flood mitigation. The default limit is 100. + /// \[#comment:TODO: implement same limits for upstream inbound frames as well.\] + #[prost(message, optional, tag="10")] + pub max_inbound_priority_frames_per_stream: ::core::option::Option<super::super::super::super::google::protobuf::UInt32Value>, + /// Limit the number of inbound WINDOW_UPDATE frames allowed per DATA frame sent. If the number + /// of WINDOW_UPDATE frames received over the lifetime of connection exceeds the value calculated + /// using this formula:: + /// + /// 1 + 2 * (inbound_streams + + /// max_inbound_window_update_frames_per_data_frame_sent * outbound_data_frames) + /// + /// the connection is terminated. The ``http2.inbound_priority_frames_flood`` stat tracks + /// the number of connections terminated due to flood mitigation. The default limit is 10. + /// Setting this to 1 should be enough to support HTTP/2 implementations with basic flow control, + /// but more complex implementations that try to estimate available bandwidth require at least 2. + /// \[#comment:TODO: implement same limits for upstream inbound frames as well.\] + #[prost(message, optional, tag="11")] + pub max_inbound_window_update_frames_per_data_frame_sent: ::core::option::Option<super::super::super::super::google::protobuf::UInt32Value>, + /// Allows invalid HTTP messaging and headers. When this option is disabled (default), then + /// the whole HTTP/2 connection is terminated upon receiving invalid HEADERS frame. However, + /// when this option is enabled, only the offending stream is terminated. + /// + /// See `RFC7540, sec. 8.1 <<https://tools.ietf.org/html/rfc7540#section-8.1>`_> for details. + #[prost(bool, tag="12")] + pub stream_error_on_invalid_http_messaging: bool, + /// \[#not-implemented-hide:\] + /// Specifies SETTINGS frame parameters to be sent to the peer, with two exceptions: + /// + /// 1. SETTINGS_ENABLE_PUSH (0x2) is not configurable as HTTP/2 server push is not supported by + /// Envoy. + /// + /// 2. SETTINGS_ENABLE_CONNECT_PROTOCOL (0x8) is only configurable through the named field + /// 'allow_connect'. + /// + /// Note that custom parameters specified through this field can not also be set in the + /// corresponding named parameters: + /// + /// .. code-block:: text + /// + /// ID Field Name + /// ---------------- + /// 0x1 hpack_table_size + /// 0x3 max_concurrent_streams + /// 0x4 initial_stream_window_size + /// + /// Collisions will trigger config validation failure on load/update. Likewise, inconsistencies + /// between custom parameters with the same identifier will trigger a failure. + /// + /// See `IANA HTTP/2 Settings + /// <<https://www.iana.org/assignments/http2-parameters/http2-parameters.xhtml#settings>`_> for + /// standardized identifiers. + #[prost(message, repeated, tag="13")] + pub custom_settings_parameters: ::prost::alloc::vec::Vec<http2_protocol_options::SettingsParameter>, +} +/// Nested message and enum types in `Http2ProtocolOptions`. +pub mod http2_protocol_options { + /// Defines a parameter to be sent in the SETTINGS frame. + /// See `RFC7540, sec. 6.5.1 <<https://tools.ietf.org/html/rfc7540#section-6.5.1>`_> for details. + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] + pub struct SettingsParameter { + /// The 16 bit parameter identifier. + #[prost(message, optional, tag="1")] + pub identifier: ::core::option::Option<super::super::super::super::super::google::protobuf::UInt32Value>, + /// The 32 bit parameter value. + #[prost(message, optional, tag="2")] + pub value: ::core::option::Option<super::super::super::super::super::google::protobuf::UInt32Value>, + } +} +/// \[#not-implemented-hide:\] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GrpcProtocolOptions { + #[prost(message, optional, tag="1")] + pub http2_protocol_options: ::core::option::Option<Http2ProtocolOptions>, +} +// \[#protodoc-title: gRPC method list\] + +/// A list of gRPC methods which can be used as an allowlist, for example. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GrpcMethodList { + #[prost(message, repeated, tag="1")] + pub services: ::prost::alloc::vec::Vec<grpc_method_list::Service>, +} +/// Nested message and enum types in `GrpcMethodList`. +pub mod grpc_method_list { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct Service { + /// The name of the gRPC service. + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + /// The names of the gRPC methods in this service. + #[prost(string, repeated, tag="2")] + pub method_names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + } +} +// @@protoc_insertion_point(module) |