From febb8b7c762470ad13402fc8bea35ffa34514e38 Mon Sep 17 00:00:00 2001 From: Jake Shadle Date: Thu, 29 Feb 2024 16:38:37 +0100 Subject: [PATCH] Format --- proto-gen/gen.rs | 2 +- src/generated/envoy/config/accesslog/v3.rs | 32 +- src/generated/envoy/config/core/v3.rs | 229 +++----- src/generated/envoy/config/endpoint/v3.rs | 8 +- src/generated/envoy/config/listener/v3.rs | 113 ++-- src/generated/envoy/config/route/v3.rs | 505 +++++++----------- src/generated/envoy/kind/tracing/v3.rs | 8 +- src/generated/envoy/kind/v3.rs | 12 +- src/generated/envoy/service/discovery/v3.rs | 127 ++--- .../quilkin/filters/compress/v1alpha1.rs | 24 +- .../quilkin/filters/concatenate/v1alpha1.rs | 12 +- .../quilkin/filters/firewall/v1alpha1.rs | 12 +- .../quilkin/filters/load_balancer/v1alpha1.rs | 12 +- src/generated/quilkin/relay/v1alpha1.rs | 93 ++-- src/generated/xds/annotations/v3.rs | 4 +- src/generated/xds/core/v3.rs | 26 +- src/generated/xds/kind/matcher/v3.rs | 18 +- 17 files changed, 398 insertions(+), 839 deletions(-) diff --git a/proto-gen/gen.rs b/proto-gen/gen.rs index d5a19da501..c030b4ebef 100644 --- a/proto-gen/gen.rs +++ b/proto-gen/gen.rs @@ -135,7 +135,7 @@ fn execute(which: &str) { cmd // Run rustfmt on the output, since they're committed they might as well be nice - //.arg("--format") + .arg("--format") .arg("--build-server") .arg("--build-client") .arg("--generate-transport") diff --git a/src/generated/envoy/config/accesslog/v3.rs b/src/generated/envoy/config/accesslog/v3.rs index 8e497ede37..702125c99d 100644 --- a/src/generated/envoy/config/accesslog/v3.rs +++ b/src/generated/envoy/config/accesslog/v3.rs @@ -96,17 +96,7 @@ pub struct ComparisonFilter { } /// Nested message and enum types in `ComparisonFilter`. pub mod comparison_filter { - #[derive( - Clone, - Copy, - Debug, - PartialEq, - Eq, - Hash, - PartialOrd, - Ord, - ::prost::Enumeration - )] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum Op { /// = @@ -177,9 +167,7 @@ pub struct RuntimeFilter { /// The default sampling percentage. If not specified, defaults to 0% with /// denominator of 100. #[prost(message, optional, tag = "2")] - pub percent_sampled: ::core::option::Option< - super::super::super::kind::v3::FractionalPercent, - >, + pub percent_sampled: ::core::option::Option, /// By default, sampling pivots on the header /// :ref:`x-request-id` being /// present. If :ref:`x-request-id` @@ -259,17 +247,7 @@ pub struct GrpcStatusFilter { } /// Nested message and enum types in `GrpcStatusFilter`. pub mod grpc_status_filter { - #[derive( - Clone, - Copy, - Debug, - PartialEq, - Eq, - Hash, - PartialOrd, - Ord, - ::prost::Enumeration - )] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum Status { Ok = 0, @@ -354,9 +332,7 @@ pub struct MetadataFilter { /// access_log_hint metadata, set the filter to "envoy.common" and the path to /// "access_log_hint", and the value to "true". #[prost(message, optional, tag = "1")] - pub matcher: ::core::option::Option< - super::super::super::kind::matcher::v3::MetadataMatcher, - >, + pub matcher: ::core::option::Option, /// Default result if the key does not exist in dynamic metadata: if unset or /// true, then log; if false, then don't log. #[prost(message, optional, tag = "2")] diff --git a/src/generated/envoy/config/core/v3.rs b/src/generated/envoy/config/core/v3.rs index 63a9987a14..8066622c96 100644 --- a/src/generated/envoy/config/core/v3.rs +++ b/src/generated/envoy/config/core/v3.rs @@ -101,10 +101,8 @@ pub struct Metadata { /// are present in the metadata with same keys, only *typed_filter_metadata* /// field will be parsed. #[prost(map = "string, message", tag = "1")] - pub filter_metadata: ::std::collections::HashMap< - ::prost::alloc::string::String, - ::prost_types::Struct, - >, + pub filter_metadata: + ::std::collections::HashMap<::prost::alloc::string::String, ::prost_types::Struct>, /// Key is the reverse DNS filter name, e.g. com.acme.widget. The envoy.* /// namespace is reserved for Envoy's built-in filters. /// The value is encoded as google.protobuf.Any. @@ -113,10 +111,8 @@ pub struct Metadata { /// *typed_filter_metadata* fields are present in the metadata with same keys, /// only *typed_filter_metadata* field will be parsed. #[prost(map = "string, message", tag = "2")] - pub typed_filter_metadata: ::std::collections::HashMap< - ::prost::alloc::string::String, - ::prost_types::Any, - >, + pub typed_filter_metadata: + ::std::collections::HashMap<::prost::alloc::string::String, ::prost_types::Any>, } /// Runtime derived uint32 with a default when not specified. #[allow(clippy::derive_partial_eq_without_eq)] @@ -211,17 +207,7 @@ pub struct HeaderValueOption { /// Nested message and enum types in `HeaderValueOption`. pub mod header_value_option { /// Describes the supported actions types for header append action. - #[derive( - Clone, - Copy, - Debug, - PartialEq, - Eq, - Hash, - PartialOrd, - Ord, - ::prost::Enumeration - )] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum HeaderAppendAction { /// This action will append the specified value to the existing values if the @@ -245,9 +231,7 @@ pub mod header_value_option { match self { HeaderAppendAction::AppendIfExistsOrAdd => "APPEND_IF_EXISTS_OR_ADD", HeaderAppendAction::AddIfAbsent => "ADD_IF_ABSENT", - HeaderAppendAction::OverwriteIfExistsOrAdd => { - "OVERWRITE_IF_EXISTS_OR_ADD" - } + HeaderAppendAction::OverwriteIfExistsOrAdd => "OVERWRITE_IF_EXISTS_OR_ADD", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -354,9 +338,7 @@ 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::kind::v3::FractionalPercent, - >, + pub default_value: ::core::option::Option, /// Runtime key for a YAML representation of a FractionalPercent. #[prost(string, tag = "2")] pub runtime_key: ::prost::alloc::string::String, @@ -517,17 +499,7 @@ pub struct ProxyProtocolConfig { } /// Nested message and enum types in `ProxyProtocolConfig`. pub mod proxy_protocol_config { - #[derive( - Clone, - Copy, - Debug, - PartialEq, - Eq, - Hash, - PartialOrd, - Ord, - ::prost::Enumeration - )] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum Version { /// PROXY protocol version 1. Human readable format. @@ -581,17 +553,7 @@ pub struct SocketOption { } /// Nested message and enum types in `SocketOption`. pub mod socket_option { - #[derive( - Clone, - Copy, - Debug, - PartialEq, - Eq, - Hash, - PartialOrd, - Ord, - ::prost::Enumeration - )] + #[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 @@ -657,9 +619,8 @@ pub struct Pipe { #[derive(Clone, PartialEq, ::prost::Message)] pub struct EnvoyInternalAddress { #[prost(oneof = "envoy_internal_address::AddressNameSpecifier", tags = "1")] - pub address_name_specifier: ::core::option::Option< - envoy_internal_address::AddressNameSpecifier, - >, + pub address_name_specifier: + ::core::option::Option, } /// Nested message and enum types in `EnvoyInternalAddress`. pub mod envoy_internal_address { @@ -714,17 +675,7 @@ pub struct SocketAddress { } /// Nested message and enum types in `SocketAddress`. pub mod socket_address { - #[derive( - Clone, - Copy, - Debug, - PartialEq, - Eq, - Hash, - PartialOrd, - Ord, - ::prost::Enumeration - )] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum Protocol { Tcp = 0, @@ -895,16 +846,16 @@ pub mod grpc_service { /// service. /// /// .. csv-table:: -///```ignore + ///```ignore /// :header: Name, Type, Description /// :widths: 1, 1, 2 -///``` + ///``` /// -///```ignore + ///```ignore /// streams_total, Counter, Total number of streams opened /// streams_closed_, Counter, Total streams closed with /// -///``` + ///``` #[prost(string, tag = "4")] pub stat_prefix: ::prost::alloc::string::String, /// The name of the Google gRPC credentials factory to use. This must have @@ -951,13 +902,9 @@ pub mod grpc_service { #[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, - >, + #[prost(oneof = "channel_credentials::CredentialSpecifier", tags = "1, 2, 3")] + pub credential_specifier: + ::core::option::Option, } /// Nested message and enum types in `ChannelCredentials`. pub mod channel_credentials { @@ -981,9 +928,7 @@ pub mod grpc_service { oneof = "call_credentials::CredentialSpecifier", tags = "1, 2, 3, 4, 5, 6, 7" )] - pub credential_specifier: ::core::option::Option< - call_credentials::CredentialSpecifier, - >, + pub credential_specifier: ::core::option::Option, } /// Nested message and enum types in `CallCredentials`. pub mod call_credentials { @@ -1009,13 +954,9 @@ pub mod grpc_service { #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, /// \[#extension-category: envoy.grpc_credentials\] - #[prost( - oneof = "metadata_credentials_from_plugin::ConfigType", - tags = "3" - )] - pub config_type: ::core::option::Option< - metadata_credentials_from_plugin::ConfigType, - >, + #[prost(oneof = "metadata_credentials_from_plugin::ConfigType", tags = "3")] + pub config_type: + ::core::option::Option, } /// Nested message and enum types in `MetadataCredentialsFromPlugin`. pub mod metadata_credentials_from_plugin { @@ -1114,10 +1055,8 @@ pub mod grpc_service { pub struct ChannelArgs { /// See grpc_types.h GRPC_ARG #defines for keys that work here. #[prost(map = "string, message", tag = "1")] - pub args: ::std::collections::HashMap< - ::prost::alloc::string::String, - channel_args::Value, - >, + pub args: + ::std::collections::HashMap<::prost::alloc::string::String, channel_args::Value>, } /// Nested message and enum types in `ChannelArgs`. pub mod channel_args { @@ -1215,17 +1154,7 @@ pub struct ApiConfigSource { /// 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 - )] + #[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 @@ -1331,7 +1260,7 @@ pub struct PathConfigSource { /// /// .. note:: /// -///```ignore + ///```ignore /// If `watched_directory` is *not* configured, Envoy will 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 @@ -1340,7 +1269,7 @@ pub struct PathConfigSource { /// this path. Instead, the configured `watched_directory` will be used to /// trigger reloads of this path. This is required in certain deployment /// scenarios. See below for more information. -///``` + ///``` #[prost(string, tag = "1")] pub path: ::prost::alloc::string::String, /// If configured, this directory will be watched for *moves.* When an entry in @@ -1378,9 +1307,7 @@ pub struct ConfigSource { /// configuration source. /// \[#not-implemented-hide:\] #[prost(message, repeated, tag = "7")] - pub authorities: ::prost::alloc::vec::Vec< - super::super::super::super::xds::core::v3::Authority, - >, + pub authorities: ::prost::alloc::vec::Vec, /// 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 `. After @@ -1397,9 +1324,7 @@ pub struct ConfigSource { #[prost(enumeration = "ApiVersion", tag = "6")] pub resource_api_version: i32, #[prost(oneof = "config_source::ConfigSourceSpecifier", tags = "1, 8, 2, 3, 5")] - pub config_source_specifier: ::core::option::Option< - config_source::ConfigSourceSpecifier, - >, + pub config_source_specifier: ::core::option::Option, } /// Nested message and enum types in `ConfigSource`. pub mod config_source { @@ -1673,12 +1598,12 @@ pub struct AlternateProtocolsCacheOptions { /// /// .. note: /// -///```ignore + ///```ignore /// The implementation is approximate and enforced independently on each /// worker thread, thus it is possible for the maximum entries in the cache /// to go slightly above the configured value depending on timing. This is /// similar to how other circuit breakers work. -///``` + ///``` #[prost(message, optional, tag = "2")] pub max_entries: ::core::option::Option, /// Allows configuring a persistent @@ -1691,9 +1616,8 @@ pub struct AlternateProtocolsCacheOptions { pub key_value_store_config: ::core::option::Option, /// Allows pre-populating the cache with entries, as described above. #[prost(message, repeated, tag = "4")] - pub prepopulated_entries: ::prost::alloc::vec::Vec< - alternate_protocols_cache_options::AlternateProtocolsCacheEntry, - >, + pub prepopulated_entries: + ::prost::alloc::vec::Vec, } /// Nested message and enum types in `AlternateProtocolsCacheOptions`. pub mod alternate_protocols_cache_options { @@ -1732,10 +1656,10 @@ pub struct HttpProtocolOptions { /// idle timeouts explicitly set this to 0. /// /// .. warning:: -///```ignore + ///```ignore /// Disabling this timeout has a highly likelihood of yielding connection /// leaks due to lost TCP FIN packets, etc. -///``` + ///``` /// /// If the :ref:`overload action ` /// "envoy.overload_actions.reduce_timeouts" is configured, this timeout is @@ -1791,17 +1715,7 @@ pub mod http_protocol_options { /// 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 - )] + #[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. @@ -1864,22 +1778,20 @@ pub struct Http1ProtocolOptions { /// 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, - >, + pub header_key_format: ::core::option::Option, /// Enables trailers for HTTP/1. By default the HTTP/1 codec drops proxied /// trailers. /// /// .. attention:: /// -///```ignore + ///```ignore /// 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, /// Allows Envoy to process requests/responses with both `Content-Length` and @@ -1889,10 +1801,10 @@ pub struct Http1ProtocolOptions { /// <`_> for details. /// /// .. attention:: -///```ignore + ///```ignore /// Enabling this option might lead to request smuggling vulnerability, /// especially if traffic is proxied via multiple layers of proxies. -///``` + ///``` #[prost(bool, tag = "6")] pub allow_chunked_length: bool, /// Allows invalid HTTP messaging. When this option is false, then Envoy will @@ -2054,9 +1966,9 @@ pub struct Http2ProtocolOptions { /// If the number of PRIORITY frames received over the lifetime of connection /// exceeds the value calculated using this formula:: /// -///```ignore + ///```ignore /// max_inbound_priority_frames_per_stream * (1 + opened_streams) -///``` + ///``` /// /// the connection is terminated. For downstream connections the /// `opened_streams` is incremented when Envoy receives complete response @@ -2072,11 +1984,11 @@ pub struct Http2ProtocolOptions { /// sent. If the number of WINDOW_UPDATE frames received over the lifetime of /// connection exceeds the value calculated using this formula:: /// -///```ignore + ///```ignore /// 5 + 2 * (opened_streams + /// max_inbound_window_update_frames_per_data_frame_sent * /// outbound_data_frames) -///``` + ///``` /// /// the connection is terminated. For downstream connections the /// `opened_streams` is incremented when Envoy receives complete response @@ -2090,9 +2002,7 @@ pub struct Http2ProtocolOptions { /// flow control, but more complex implementations that try to estimate /// available bandwidth require at least 2. #[prost(message, optional, tag = "11")] - pub max_inbound_window_update_frames_per_data_frame_sent: ::core::option::Option< - u32, - >, + pub max_inbound_window_update_frames_per_data_frame_sent: ::core::option::Option, /// 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 @@ -2138,13 +2048,13 @@ pub struct Http2ProtocolOptions { /// /// .. code-block:: text /// -///```ignore + ///```ignore /// 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 @@ -2154,9 +2064,8 @@ pub struct Http2ProtocolOptions { /// <`_> /// for standardized identifiers. #[prost(message, repeated, tag = "13")] - pub custom_settings_parameters: ::prost::alloc::vec::Vec< - http2_protocol_options::SettingsParameter, - >, + pub custom_settings_parameters: + ::prost::alloc::vec::Vec, /// Send HTTP/2 PING frames to verify that the connection is still healthy. If /// the remote peer does not respond within the configured timeout, the /// connection will be aborted. @@ -2216,9 +2125,7 @@ pub struct Http3ProtocolOptions { #[derive(Clone, PartialEq, ::prost::Message)] pub struct SchemeHeaderTransformation { #[prost(oneof = "scheme_header_transformation::Transformation", tags = "1")] - pub transformation: ::core::option::Option< - scheme_header_transformation::Transformation, - >, + pub transformation: ::core::option::Option, } /// Nested message and enum types in `SchemeHeaderTransformation`. pub mod scheme_header_transformation { @@ -2236,9 +2143,8 @@ pub mod scheme_header_transformation { #[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, - >, + pub config_source_specifier: + ::core::option::Option, } /// Nested message and enum types in `EventServiceConfig`. pub mod event_service_config { @@ -2386,9 +2292,9 @@ pub struct HealthCheck { /// .. code-block:: yaml /// /// transport_socket_match_criteria: -///```ignore + ///```ignore /// useMTLS: true -///``` + ///``` /// /// Will match the following :ref:`cluster socket match /// ` @@ -2397,13 +2303,13 @@ pub struct HealthCheck { /// /// transport_socket_matches: /// - name: "useMTLS" -///```ignore + ///```ignore /// match: /// useMTLS: true /// transport_socket: /// name: envoy.transport_sockets.tls /// config: { ... } # tls socket configuration -///``` + ///``` /// /// If this field is set, then for health checks it will supersede an entry of /// *envoy.transport_socket* in the :ref:`LbEndpoint.Metadata @@ -2477,9 +2383,7 @@ pub mod health_check { /// 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, - >, + pub request_headers_to_remove: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// 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 @@ -2487,9 +2391,8 @@ pub mod health_check { /// 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::kind::v3::Int64Range, - >, + pub expected_statuses: + ::prost::alloc::vec::Vec, /// Specifies a list of HTTP response statuses considered retriable. If /// provided, responses in this range will count towards the configured /// :ref:`unhealthy_threshold @@ -2510,9 +2413,8 @@ pub mod health_check { /// statuses, any non-200 response will result in the host being marked /// unhealthy. #[prost(message, repeated, tag = "12")] - pub retriable_statuses: ::prost::alloc::vec::Vec< - super::super::super::super::kind::v3::Int64Range, - >, + pub retriable_statuses: + ::prost::alloc::vec::Vec, /// Use specified application protocol for health checks. #[prost( enumeration = "super::super::super::super::kind::v3::CodecClientType", @@ -2525,9 +2427,8 @@ pub mod health_check { /// :ref:`architecture overview ` for /// more information. #[prost(message, optional, tag = "11")] - pub service_name_matcher: ::core::option::Option< - super::super::super::super::kind::matcher::v3::StringMatcher, - >, + pub service_name_matcher: + ::core::option::Option, } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] diff --git a/src/generated/envoy/config/endpoint/v3.rs b/src/generated/envoy/config/endpoint/v3.rs index 08a071140d..6ef40a1145 100644 --- a/src/generated/envoy/config/endpoint/v3.rs +++ b/src/generated/envoy/config/endpoint/v3.rs @@ -6,14 +6,14 @@ pub struct Endpoint { /// /// .. attention:: /// -///```ignore + ///```ignore /// The form of host address depends on the given cluster type. For STATIC or /// EDS, it is expected to be a direct IP address (or something resolvable by /// the specified :ref:`resolver /// ` in the /// Address). For LOGICAL or STRICT DNS, it is expected to be hostname, and /// will be resolved via DNS. -///``` + ///``` #[prost(message, optional, tag = "1")] pub address: ::core::option::Option, /// The optional health check configuration is used as configuration for the @@ -21,10 +21,10 @@ pub struct Endpoint { /// /// .. attention:: /// -///```ignore + ///```ignore /// This takes into effect only for upstream clusters with /// :ref:`active health checking ` enabled. -///``` + ///``` #[prost(message, optional, tag = "2")] pub health_check_config: ::core::option::Option, /// The hostname associated with this endpoint. This hostname is not used for diff --git a/src/generated/envoy/config/listener/v3.rs b/src/generated/envoy/config/listener/v3.rs index eaee5f42bb..5f948c1d2a 100644 --- a/src/generated/envoy/config/listener/v3.rs +++ b/src/generated/envoy/config/listener/v3.rs @@ -124,9 +124,7 @@ pub struct FilterChainMatch { /// subnets. If the parameter is not specified or the list is empty, the /// directly connected source IP address is ignored. #[prost(message, repeated, tag = "13")] - pub direct_source_prefix_ranges: ::prost::alloc::vec::Vec< - super::super::core::v3::CidrRange, - >, + pub direct_source_prefix_ranges: ::prost::alloc::vec::Vec, /// Specifies the connection source IP match type. Can be any, local or /// external network. #[prost(enumeration = "filter_chain_match::ConnectionSourceType", tag = "12")] @@ -136,9 +134,7 @@ pub struct FilterChainMatch { /// parameter is not specified or the list is empty, the source IP address is /// ignored. #[prost(message, repeated, tag = "6")] - pub source_prefix_ranges: ::prost::alloc::vec::Vec< - super::super::core::v3::CidrRange, - >, + pub source_prefix_ranges: ::prost::alloc::vec::Vec, /// The criteria is satisfied if the source port of the downstream connection /// is contained in at least one of the specified ports. If the parameter is /// not specified, the source port is ignored. @@ -158,10 +154,10 @@ pub struct FilterChainMatch { /// /// .. attention:: /// -///```ignore + ///```ignore /// See the :ref:`FAQ entry ` on how to configure SNI /// for more information. -///``` + ///``` #[prost(string, repeated, tag = "11")] pub server_names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// If non-empty, a transport protocol to consider when determining a filter @@ -173,9 +169,9 @@ pub struct FilterChainMatch { /// * ``raw_buffer`` - default, used when no transport protocol is detected, /// * ``tls`` - set by :ref:`envoy.filters.listener.tls_inspector /// ` -///```ignore + ///```ignore /// when TLS protocol is detected. -///``` + ///``` #[prost(string, tag = "9")] pub transport_protocol: ::prost::alloc::string::String, /// If non-empty, a list of application protocols (e.g. ALPN for TLS protocol) @@ -186,44 +182,34 @@ pub struct FilterChainMatch { /// Suggested values include: /// /// * ``http/1.1`` - set by :ref:`envoy.filters.listener.tls_inspector -///```ignore + ///```ignore /// `, -///``` + ///``` /// * ``h2`` - set by :ref:`envoy.filters.listener.tls_inspector /// ` /// /// .. attention:: /// -///```ignore + ///```ignore /// Currently, only :ref:`TLS Inspector /// ` provides application protocol /// detection based on the requested `ALPN /// <`_> /// values. -///``` + ///``` /// -///```ignore + ///```ignore /// However, the use of ALPN is pretty much limited to the HTTP/2 traffic on /// the Internet, and matching on values other than ``h2`` is going to lead /// to a lot of false negatives, unless all connecting clients are known to /// use ALPN. -///``` + ///``` #[prost(string, repeated, tag = "10")] pub application_protocols: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } /// Nested message and enum types in `FilterChainMatch`. pub mod filter_chain_match { - #[derive( - Clone, - Copy, - Debug, - PartialEq, - Eq, - Hash, - PartialOrd, - Ord, - ::prost::Enumeration - )] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum ConnectionSourceType { /// Any connection source matches. @@ -295,17 +281,13 @@ pub struct FilterChain { /// new connections will be set up with plaintext. /// \[#extension-category: envoy.transport_sockets.downstream\] #[prost(message, optional, tag = "6")] - pub transport_socket: ::core::option::Option< - super::super::core::v3::TransportSocket, - >, + pub transport_socket: ::core::option::Option, /// If present and nonzero, the amount of time to allow incoming connections to /// complete any transport socket negotiations. If this expires before the /// transport reports connection establishment, the connection is summarily /// closed. #[prost(message, optional, tag = "9")] - pub transport_socket_connect_timeout: ::core::option::Option< - ::prost_types::Duration, - >, + pub transport_socket_connect_timeout: ::core::option::Option<::prost_types::Duration>, /// \[#not-implemented-hide:\] The unique name (or empty) by which this filter /// chain is known. If no name is provided, Envoy will allocate an internal /// UUID for the filter chain. If the filter chain is to be dynamically updated @@ -317,9 +299,7 @@ pub struct FilterChain { /// will be built on-demand. Otherwise, the filter chain will be built normally /// and block listener warming. #[prost(message, optional, tag = "8")] - pub on_demand_configuration: ::core::option::Option< - filter_chain::OnDemandConfiguration, - >, + pub on_demand_configuration: ::core::option::Option, } /// Nested message and enum types in `FilterChain`. pub mod filter_chain { @@ -460,9 +440,7 @@ pub mod listener_filter { #[derive(Clone, PartialEq, ::prost::Message)] pub struct QuicProtocolOptions { #[prost(message, optional, tag = "1")] - pub quic_protocol_options: ::core::option::Option< - super::super::core::v3::QuicProtocolOptions, - >, + pub quic_protocol_options: ::core::option::Option, /// Maximum number of milliseconds that connection will be alive when there is /// no network activity. /// @@ -495,18 +473,14 @@ pub struct QuicProtocolOptions { /// will be used. /// \[#extension-category: envoy.quic.server.crypto_stream\] #[prost(message, optional, tag = "6")] - pub crypto_stream_config: ::core::option::Option< - super::super::core::v3::TypedExtensionConfig, - >, + pub crypto_stream_config: ::core::option::Option, /// Configure which implementation of `quic::ProofSource` to be used for this /// listener. If not specified the :ref:`default one configured by /// ` will /// be used. /// \[#extension-category: envoy.quic.proof_source\] #[prost(message, optional, tag = "7")] - pub proof_source_config: ::core::option::Option< - super::super::core::v3::TypedExtensionConfig, - >, + pub proof_source_config: ::core::option::Option, } /// \[#next-free-field: 8\] #[allow(clippy::derive_partial_eq_without_eq)] @@ -519,9 +493,7 @@ pub struct UdpListenerConfig { /// number of sources, it may be worthwhile to enable this option after /// performance testing. #[prost(message, optional, tag = "5")] - pub downstream_socket_config: ::core::option::Option< - super::super::core::v3::UdpSocketConfig, - >, + pub downstream_socket_config: ::core::option::Option, /// Configuration for QUIC protocol. If empty, QUIC will not be enabled on this /// listener. Set to the default object to enable QUIC without modifying any /// additional options. @@ -537,9 +509,8 @@ pub struct ActiveRawUdpListenerConfig {} #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListenerCollection { #[prost(message, repeated, tag = "1")] - pub entries: ::prost::alloc::vec::Vec< - super::super::super::super::xds::core::v3::CollectionEntry, - >, + pub entries: + ::prost::alloc::vec::Vec, } /// \[#next-free-field: 32\] #[allow(clippy::derive_partial_eq_without_eq)] @@ -623,11 +594,11 @@ pub struct Listener { /// /// .. attention:: /// -///```ignore + ///```ignore /// Some listener filters, such as :ref:`Proxy Protocol filter /// `, should not be used with this /// option. It will cause unexpected behavior when a connection is created. -///``` + ///``` #[prost(bool, tag = "17")] pub continue_on_listener_filters_timeout: bool, /// Whether the listener should be set as a transparent socket. @@ -722,9 +693,7 @@ pub struct Listener { /// avoid the cost of balancing, and enable the balance config in Y1 and Y2 to /// balance the connections among the workers. #[prost(message, optional, tag = "20")] - pub connection_balance_config: ::core::option::Option< - listener::ConnectionBalanceConfig, - >, + pub connection_balance_config: ::core::option::Option, /// Deprecated. Use `enable_reuse_port` instead. #[deprecated] #[prost(bool, tag = "21")] @@ -737,31 +706,31 @@ pub struct Listener { /// /// .. attention:: /// -///```ignore + ///```ignore /// Although this field defaults to true, it has different behavior on /// different platforms. See the following text for more information. -///``` + ///``` /// /// * On Linux, reuse_port is respected for both TCP and UDP listeners. It also /// works correctly -///```ignore + ///```ignore /// with hot restart. -///``` + ///``` /// * On macOS, reuse_port for TCP does not do what it does on Linux. Instead /// of load balancing, -///```ignore + ///```ignore /// the last socket wins and receives all connections/packets. For TCP, /// reuse_port is force disabled and the user is warned. For UDP, it is /// enabled, but only one worker will receive packets. For QUIC/H3, SW /// routing will send packets to other workers. For "raw" UDP, only a single /// worker will currently receive packets. -///``` + ///``` /// * On Windows, reuse_port for TCP has undefined behavior. It is force /// disabled and the user -///```ignore + ///```ignore /// is warned similar to macOS. It is left enabled for UDP with undefined /// behavior currently. -///``` + ///``` #[prost(message, optional, tag = "29")] pub enable_reuse_port: ::core::option::Option, /// Configuration for :ref:`access logs ` @@ -847,17 +816,7 @@ pub mod listener { #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct InternalListenerConfig {} - #[derive( - Clone, - Copy, - Debug, - PartialEq, - Eq, - Hash, - PartialOrd, - Ord, - ::prost::Enumeration - )] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum DrainType { /// Drain in response to calling /healthcheck/fail admin endpoint (along with @@ -910,10 +869,10 @@ pub mod listener { /// * :ref:`ConnectionBalanceConfig /// ` /// is not -///```ignore + ///```ignore /// allowed because both cluster connection and listener connection must be /// owned by the same dispatcher. -///``` + ///``` /// * :ref:`tcp_backlog_size /// ` /// * :ref:`freebind diff --git a/src/generated/envoy/config/route/v3.rs b/src/generated/envoy/config/route/v3.rs index e301f1f100..4dd94e0ddc 100644 --- a/src/generated/envoy/config/route/v3.rs +++ b/src/generated/envoy/config/route/v3.rs @@ -23,14 +23,14 @@ pub struct VirtualHost { /// /// .. note:: /// -///```ignore + ///```ignore /// The wildcard will not match the empty string. /// e.g. ``*-bar.foo.com`` will match ``baz-bar.foo.com`` but not /// ``-bar.foo.com``. The longest wildcards match first. Only a single /// virtual host in the entire route configuration can match on ``*``. A /// domain must be unique across all virtual hosts or the config will fail to /// load. -///``` + ///``` /// /// Domains cannot contain control characters. This is validated by the /// well_known_regex HTTP_HEADER_VALUE. @@ -45,9 +45,8 @@ pub struct VirtualHost { /// wrapped in a message.] The match tree to use when resolving route actions /// for incoming requests. Only one of this and `routes` can be specified. #[prost(message, optional, tag = "21")] - pub matcher: ::core::option::Option< - super::super::super::super::xds::kind::matcher::v3::Matcher, - >, + pub matcher: + ::core::option::Option, /// Specifies the type of TLS enforcement the virtual host expects. If this /// option is not specified, there is no TLS requirement for the virtual host. #[prost(enumeration = "virtual_host::TlsRequirementType", tag = "4")] @@ -69,15 +68,11 @@ pub struct VirtualHost { /// documentation on :ref:`custom request headers /// `. #[prost(message, repeated, tag = "7")] - pub request_headers_to_add: ::prost::alloc::vec::Vec< - super::super::core::v3::HeaderValueOption, - >, + pub request_headers_to_add: ::prost::alloc::vec::Vec, /// Specifies a list of HTTP headers that should be removed from each request /// handled by this virtual host. #[prost(string, repeated, tag = "13")] - pub request_headers_to_remove: ::prost::alloc::vec::Vec< - ::prost::alloc::string::String, - >, + pub request_headers_to_remove: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// Specifies a list of HTTP headers that should be added to each response /// handled by this virtual host. Headers specified at this level are applied /// after headers from enclosed :ref:`envoy_v3_api_msg_config.route.v3.Route` @@ -87,15 +82,12 @@ pub struct VirtualHost { /// documentation on :ref:`custom request headers /// `. #[prost(message, repeated, tag = "10")] - pub response_headers_to_add: ::prost::alloc::vec::Vec< - super::super::core::v3::HeaderValueOption, - >, + pub response_headers_to_add: + ::prost::alloc::vec::Vec, /// Specifies a list of HTTP headers that should be removed from each response /// handled by this virtual host. #[prost(string, repeated, tag = "11")] - pub response_headers_to_remove: ::prost::alloc::vec::Vec< - ::prost::alloc::string::String, - >, + pub response_headers_to_remove: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// Indicates that the virtual host has a CORS policy. #[prost(message, optional, tag = "8")] pub cors: ::core::option::Option, @@ -108,10 +100,8 @@ pub struct VirtualHost { /// :ref:`FilterConfig` /// message to specify additional options.] #[prost(map = "string, message", tag = "15")] - pub typed_per_filter_config: ::std::collections::HashMap< - ::prost::alloc::string::String, - ::prost_types::Any, - >, + pub typed_per_filter_config: + ::std::collections::HashMap<::prost::alloc::string::String, ::prost_types::Any>, /// Decides whether the :ref:`x-envoy-attempt-count /// ` header should be /// included in the upstream request. Setting this option will cause it to @@ -164,17 +154,7 @@ pub struct VirtualHost { } /// Nested message and enum types in `VirtualHost`. pub mod virtual_host { - #[derive( - Clone, - Copy, - Debug, - PartialEq, - Eq, - Hash, - PartialOrd, - Ord, - ::prost::Enumeration - )] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum TlsRequirementType { /// No TLS requirement for the virtual host. @@ -254,10 +234,8 @@ pub struct Route { /// :ref:`FilterConfig` /// message to specify additional options.] #[prost(map = "string, message", tag = "13")] - pub typed_per_filter_config: ::std::collections::HashMap< - ::prost::alloc::string::String, - ::prost_types::Any, - >, + pub typed_per_filter_config: + ::std::collections::HashMap<::prost::alloc::string::String, ::prost_types::Any>, /// Specifies a set of headers that will be added to requests matching this /// route. Headers specified at this level are applied before headers from the /// enclosing :ref:`envoy_v3_api_msg_config.route.v3.VirtualHost` and @@ -266,15 +244,11 @@ pub struct Route { /// documentation on :ref:`custom request headers /// `. #[prost(message, repeated, tag = "9")] - pub request_headers_to_add: ::prost::alloc::vec::Vec< - super::super::core::v3::HeaderValueOption, - >, + pub request_headers_to_add: ::prost::alloc::vec::Vec, /// Specifies a list of HTTP headers that should be removed from each request /// matching this route. #[prost(string, repeated, tag = "12")] - pub request_headers_to_remove: ::prost::alloc::vec::Vec< - ::prost::alloc::string::String, - >, + pub request_headers_to_remove: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// Specifies a set of headers that will be added to responses to requests /// matching this route. Headers specified at this level are applied before /// headers from the enclosing @@ -284,15 +258,12 @@ pub struct Route { /// documentation on :ref:`custom request headers /// `. #[prost(message, repeated, tag = "10")] - pub response_headers_to_add: ::prost::alloc::vec::Vec< - super::super::core::v3::HeaderValueOption, - >, + pub response_headers_to_add: + ::prost::alloc::vec::Vec, /// Specifies a list of HTTP headers that should be removed from each response /// to requests matching this route. #[prost(string, repeated, tag = "11")] - pub response_headers_to_remove: ::prost::alloc::vec::Vec< - ::prost::alloc::string::String, - >, + pub response_headers_to_remove: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// Presence of the object defines whether the connection manager's tracing /// configuration is overridden by this route specific instance. #[prost(message, optional, tag = "15")] @@ -366,9 +337,7 @@ pub struct WeightedCluster { #[prost(string, tag = "2")] pub runtime_key_prefix: ::prost::alloc::string::String, #[prost(oneof = "weighted_cluster::RandomValueSpecifier", tags = "4")] - pub random_value_specifier: ::core::option::Option< - weighted_cluster::RandomValueSpecifier, - >, + pub random_value_specifier: ::core::option::Option, } /// Nested message and enum types in `WeightedCluster`. pub mod weighted_cluster { @@ -392,17 +361,17 @@ pub mod weighted_cluster { /// /// .. attention:: /// -///```ignore + ///```ignore /// Internally, Envoy always uses the HTTP/2 *:authority* header to /// represent the HTTP/1 *Host* header. Thus, if attempting to match on /// *Host*, match on *:authority* instead. -///``` + ///``` /// /// .. note:: /// -///```ignore + ///```ignore /// If the header appears multiple times only the first value is used. -///``` + ///``` #[prost(string, tag = "12")] pub cluster_header: ::prost::alloc::string::String, /// An integer between 0 and :ref:`total_weight @@ -421,9 +390,7 @@ pub mod weighted_cluster { /// values here taking precedence. The filter name should be specified as /// *envoy.lb*. #[prost(message, optional, tag = "3")] - pub metadata_match: ::core::option::Option< - super::super::super::core::v3::Metadata, - >, + pub metadata_match: ::core::option::Option, /// Specifies a list of headers to be added to requests when this cluster is /// selected through the enclosing /// :ref:`envoy_v3_api_msg_config.route.v3.RouteAction`. Headers specified at @@ -435,16 +402,13 @@ pub mod weighted_cluster { /// documentation on :ref:`custom request headers /// `. #[prost(message, repeated, tag = "4")] - pub request_headers_to_add: ::prost::alloc::vec::Vec< - super::super::super::core::v3::HeaderValueOption, - >, + pub request_headers_to_add: + ::prost::alloc::vec::Vec, /// Specifies a list of HTTP headers that should be removed from each request /// when this cluster is selected through the enclosing /// :ref:`envoy_v3_api_msg_config.route.v3.RouteAction`. #[prost(string, repeated, tag = "9")] - pub request_headers_to_remove: ::prost::alloc::vec::Vec< - ::prost::alloc::string::String, - >, + pub request_headers_to_remove: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// Specifies a list of headers to be added to responses when this cluster is /// selected through the enclosing /// :ref:`envoy_v3_api_msg_config.route.v3.RouteAction`. Headers specified at @@ -456,16 +420,13 @@ pub mod weighted_cluster { /// documentation on :ref:`custom request headers /// `. #[prost(message, repeated, tag = "5")] - pub response_headers_to_add: ::prost::alloc::vec::Vec< - super::super::super::core::v3::HeaderValueOption, - >, + pub response_headers_to_add: + ::prost::alloc::vec::Vec, /// Specifies a list of headers to be removed from responses when this /// cluster is selected through the enclosing /// :ref:`envoy_v3_api_msg_config.route.v3.RouteAction`. #[prost(string, repeated, tag = "6")] - pub response_headers_to_remove: ::prost::alloc::vec::Vec< - ::prost::alloc::string::String, - >, + pub response_headers_to_remove: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// The per_filter_config field can be used to provide weighted /// cluster-specific configurations for filters. The key should match the /// filter name, such as *envoy.filters.http.buffer* for the HTTP buffer @@ -475,14 +436,10 @@ pub mod weighted_cluster { /// :ref:`FilterConfig` /// message to specify additional options.] #[prost(map = "string, message", tag = "10")] - pub typed_per_filter_config: ::std::collections::HashMap< - ::prost::alloc::string::String, - ::prost_types::Any, - >, + pub typed_per_filter_config: + ::std::collections::HashMap<::prost::alloc::string::String, ::prost_types::Any>, #[prost(oneof = "cluster_weight::HostRewriteSpecifier", tags = "11")] - pub host_rewrite_specifier: ::core::option::Option< - cluster_weight::HostRewriteSpecifier, - >, + pub host_rewrite_specifier: ::core::option::Option, } /// Nested message and enum types in `ClusterWeight`. pub mod cluster_weight { @@ -531,7 +488,7 @@ pub struct RouteMatch { /// /// .. note:: /// -///```ignore + ///```ignore /// Parsing this field is implemented such that the runtime key's data may /// be represented as a FractionalPercent proto represented as JSON/YAML and /// may also be represented as an integer with the assumption that the value @@ -539,11 +496,9 @@ pub struct RouteMatch { /// returning the value "42" would parse as a FractionalPercent whose /// numerator is 42 and denominator is HUNDRED. This preserves legacy /// semantics. -///``` + ///``` #[prost(message, optional, tag = "9")] - pub runtime_fraction: ::core::option::Option< - super::super::core::v3::RuntimeFractionalPercent, - >, + pub runtime_fraction: ::core::option::Option, /// Specifies a set of headers that the route should match on. The router will /// check the request’s headers against all the specified headers in the route /// config. A match will happen if all the headers in the route are present in @@ -559,7 +514,7 @@ pub struct RouteMatch { /// /// .. note:: /// -///```ignore + ///```ignore /// If query parameters are used to pass request message fields when /// `grpc_json_transcoder /// <`_> @@ -567,7 +522,7 @@ pub struct RouteMatch { /// parameters are url encoded, but the message fields are not. For example, /// if a query parameter is "foo%20bar", the message field will be "foo /// bar". -///``` + ///``` #[prost(message, repeated, tag = "7")] pub query_parameters: ::prost::alloc::vec::Vec, /// If specified, only gRPC requests will be matched. The router will check @@ -587,9 +542,8 @@ pub struct RouteMatch { /// matchers is nonzero, they all must match the dynamic metadata for a match /// to occur. #[prost(message, repeated, tag = "13")] - pub dynamic_metadata: ::prost::alloc::vec::Vec< - super::super::super::kind::matcher::v3::MetadataMatcher, - >, + pub dynamic_metadata: + ::prost::alloc::vec::Vec, #[prost(oneof = "route_match::PathSpecifier", tags = "1, 2, 10, 12")] pub path_specifier: ::core::option::Option, } @@ -663,9 +617,8 @@ pub struct CorsPolicy { /// Specifies string patterns that match allowed origins. An origin is allowed /// if any of the string matchers match. #[prost(message, repeated, tag = "11")] - pub allow_origin_string_match: ::prost::alloc::vec::Vec< - super::super::super::kind::matcher::v3::StringMatcher, - >, + pub allow_origin_string_match: + ::prost::alloc::vec::Vec, /// Specifies the content for the *access-control-allow-methods* header. #[prost(string, tag = "2")] pub allow_methods: ::prost::alloc::string::String, @@ -694,9 +647,7 @@ pub struct CorsPolicy { /// requests for which it will evaluate and track the request's *Origin* to /// determine if it's valid but will not enforce any policies. #[prost(message, optional, tag = "10")] - pub shadow_enabled: ::core::option::Option< - super::super::core::v3::RuntimeFractionalPercent, - >, + pub shadow_enabled: ::core::option::Option, #[prost(oneof = "cors_policy::EnabledSpecifier", tags = "9")] pub enabled_specifier: ::core::option::Option, } @@ -749,7 +700,7 @@ pub struct RouteAction { /// /// .. attention:: /// -///```ignore + ///```ignore /// Pay careful attention to the use of trailing slashes in the /// :ref:`route's match ` /// prefix value. Stripping a prefix from a path requires multiple Routes to @@ -757,13 +708,13 @@ pub struct RouteAction { /// */prefix/etc* to */etc* cannot be done in a single :ref:`Route /// `, as shown by the below config /// entries: -///``` + ///``` /// -///```ignore + ///```ignore /// .. code-block:: yaml -///``` + ///``` /// -///```ignore + ///```ignore /// - match: /// prefix: "/prefix/" /// route: @@ -772,13 +723,13 @@ pub struct RouteAction { /// prefix: "/prefix" /// route: /// prefix_rewrite: "/" -///``` + ///``` /// -///```ignore + ///```ignore /// Having above entries in the config, requests to */prefix* will be /// stripped to */*, while requests to */prefix/etc* will be stripped to /// */etc*. -///``` + ///``` #[prost(string, tag = "5")] pub prefix_rewrite: ::prost::alloc::string::String, /// Indicates that during forwarding, portions of the path that match the @@ -797,31 +748,30 @@ pub struct RouteAction { /// Examples using Google's `RE2 <`_> engine: /// /// * The path pattern ``^/service/(\[^/\]+)(/.*)$`` paired with a substitution -///```ignore + ///```ignore /// string of ``\2/instance/\1`` would transform ``/service/foo/v1/api`` /// into ``/v1/api/instance/foo``. -///``` + ///``` /// /// * The pattern ``one`` paired with a substitution string of ``two`` would -///```ignore + ///```ignore /// transform ``/xxx/one/yyy/one/zzz`` into ``/xxx/two/yyy/two/zzz``. -///``` + ///``` /// /// * The pattern ``^(.*?)one(.*)$`` paired with a substitution string of -///```ignore + ///```ignore /// ``\1two\2`` would replace only the first occurrence of ``one``, /// transforming path ``/xxx/one/yyy/one/zzz`` into ``/xxx/two/yyy/one/zzz``. -///``` + ///``` /// /// * The pattern ``(?i)/xxx/`` paired with a substitution string of ``/yyy/`` -///```ignore + ///```ignore /// would do a case-insensitive match and transform path ``/aaa/XxX/bbb`` to /// ``/aaa/yyy/bbb``. -///``` + ///``` #[prost(message, optional, tag = "32")] - pub regex_rewrite: ::core::option::Option< - super::super::super::kind::matcher::v3::RegexMatchAndSubstitute, - >, + pub regex_rewrite: + ::core::option::Option, /// If set, then a host rewrite action (one of /// :ref:`host_rewrite_literal /// `, @@ -842,12 +792,12 @@ pub struct RouteAction { /// /// .. note:: /// -///```ignore + ///```ignore /// This timeout includes all retries. See also /// :ref:`config_http_filters_router_x-envoy-upstream-rq-timeout-ms`, /// :ref:`config_http_filters_router_x-envoy-upstream-rq-per-try-timeout-ms`, /// and the :ref:`retry overview `. -///``` + ///``` #[prost(message, optional, tag = "8")] pub timeout: ::core::option::Option<::prost_types::Duration>, /// Specifies the idle timeout for the route. If not specified, there is no @@ -893,9 +843,7 @@ pub struct RouteAction { pub retry_policy_typed_config: ::core::option::Option<::prost_types::Any>, /// Indicates that the route has request mirroring policies. #[prost(message, repeated, tag = "30")] - pub request_mirror_policies: ::prost::alloc::vec::Vec< - route_action::RequestMirrorPolicy, - >, + pub request_mirror_policies: ::prost::alloc::vec::Vec, /// Optionally specifies the :ref:`routing priority /// `. #[prost(enumeration = "super::super::core::v3::RoutingPriority", tag = "11")] @@ -950,7 +898,7 @@ pub struct RouteAction { /// /// .. note:: /// -///```ignore + ///```ignore /// If a timeout is specified using /// :ref:`config_http_filters_router_x-envoy-upstream-rq-timeout-ms`, it /// takes precedence over `grpc-timeout header @@ -959,7 +907,7 @@ pub struct RouteAction { /// :ref:`config_http_filters_router_x-envoy-upstream-rq-timeout-ms`, /// :ref:`config_http_filters_router_x-envoy-upstream-rq-per-try-timeout-ms`, /// and the :ref:`retry overview `. -///``` + ///``` #[deprecated] #[prost(message, optional, tag = "23")] pub max_grpc_timeout: ::core::option::Option<::prost_types::Duration>, @@ -1018,9 +966,7 @@ pub struct RouteAction { #[prost(oneof = "route_action::ClusterSpecifier", tags = "1, 2, 3, 37")] pub cluster_specifier: ::core::option::Option, #[prost(oneof = "route_action::HostRewriteSpecifier", tags = "6, 7, 29, 35")] - pub host_rewrite_specifier: ::core::option::Option< - route_action::HostRewriteSpecifier, - >, + pub host_rewrite_specifier: ::core::option::Option, } /// Nested message and enum types in `RouteAction`. pub mod route_action { @@ -1036,9 +982,9 @@ pub mod route_action { /// /// .. note:: /// -///```ignore + ///```ignore /// Shadowing will not be triggered if the primary cluster does not exist. -///``` + ///``` #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct RequestMirrorPolicy { @@ -1056,9 +1002,8 @@ pub mod route_action { /// the number is <= the value of the numerator N, or if the key is not /// present, the default value, the request will be mirrored. #[prost(message, optional, tag = "3")] - pub runtime_fraction: ::core::option::Option< - super::super::super::core::v3::RuntimeFractionalPercent, - >, + pub runtime_fraction: + ::core::option::Option, /// Determines if the trace span should be sampled. Defaults to true. #[prost(message, optional, tag = "4")] pub trace_sampled: ::core::option::Option, @@ -1112,12 +1057,12 @@ pub mod route_action { /// Envoy supports two types of cookie affinity: /// /// 1. Passive. Envoy takes a cookie that's present in the cookies header and -///```ignore + ///```ignore /// hashes on its value. -///``` + ///``` /// /// 2. Generated. Envoy generates and sets a cookie with an expiration (TTL) -///```ignore + ///```ignore /// on the first request from the client in its response to the client, /// based on the endpoint the request gets sent to. The client then /// presents this on the next and all subsequent requests. The hash of @@ -1126,7 +1071,7 @@ pub mod route_action { /// destination ports and addresses so that multiple independent HTTP2 /// streams on the same connection will independently receive the same /// cookie, even if they arrive at the Envoy simultaneously. -///``` + ///``` #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct Cookie { @@ -1225,9 +1170,8 @@ pub mod route_action { /// If present, the proxy protocol header will be prepended to the CONNECT /// payload sent upstream. #[prost(message, optional, tag = "1")] - pub proxy_protocol_config: ::core::option::Option< - super::super::super::super::core::v3::ProxyProtocolConfig, - >, + pub proxy_protocol_config: + ::core::option::Option, /// If set, the route will also allow forwarding POST payload as raw TCP. #[prost(bool, tag = "2")] pub allow_post: bool, @@ -1263,17 +1207,7 @@ pub mod route_action { #[prost(message, optional, tag = "3")] pub grpc_timeout_header_offset: ::core::option::Option<::prost_types::Duration>, } - #[derive( - Clone, - Copy, - Debug, - PartialEq, - Eq, - Hash, - PartialOrd, - Ord, - ::prost::Enumeration - )] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum ClusterNotFoundResponseCode { /// HTTP status code - 503 Service Unavailable. @@ -1305,17 +1239,7 @@ pub mod route_action { /// behavior. /// [#next-major-version: remove this definition - it's defined in the /// InternalRedirectPolicy message.] - #[derive( - Clone, - Copy, - Debug, - PartialEq, - Eq, - Hash, - PartialOrd, - Ord, - ::prost::Enumeration - )] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum InternalRedirectAction { PassThroughInternalRedirect = 0, @@ -1331,17 +1255,13 @@ pub mod route_action { InternalRedirectAction::PassThroughInternalRedirect => { "PASS_THROUGH_INTERNAL_REDIRECT" } - InternalRedirectAction::HandleInternalRedirect => { - "HANDLE_INTERNAL_REDIRECT" - } + InternalRedirectAction::HandleInternalRedirect => "HANDLE_INTERNAL_REDIRECT", } } /// Creates an enum from field names used in the ProtoBuf definition. pub fn from_str_name(value: &str) -> ::core::option::Option { match value { - "PASS_THROUGH_INTERNAL_REDIRECT" => { - Some(Self::PassThroughInternalRedirect) - } + "PASS_THROUGH_INTERNAL_REDIRECT" => Some(Self::PassThroughInternalRedirect), "HANDLE_INTERNAL_REDIRECT" => Some(Self::HandleInternalRedirect), _ => None, } @@ -1361,17 +1281,17 @@ pub mod route_action { /// /// .. attention:: /// -///```ignore + ///```ignore /// Internally, Envoy always uses the HTTP/2 *:authority* header to /// represent the HTTP/1 *Host* header. Thus, if attempting to match on /// *Host*, match on *:authority* instead. -///``` + ///``` /// /// .. note:: /// -///```ignore + ///```ignore /// If the header appears multiple times only the first value is used. -///``` + ///``` #[prost(string, tag = "2")] ClusterHeader(::prost::alloc::string::String), /// Multiple upstream clusters can be specified for a given route. The @@ -1424,16 +1344,16 @@ pub mod route_action { /// /// .. attention:: /// -///```ignore + ///```ignore /// Pay attention to the potential security implications of using this /// option. Provided header must come from trusted source. -///``` + ///``` /// /// .. note:: /// -///```ignore + ///```ignore /// If the header appears multiple times only the first value is used. -///``` + ///``` #[prost(string, tag = "29")] HostRewriteHeader(::prost::alloc::string::String), /// Indicates that during forwarding, the host header will be swapped with @@ -1447,17 +1367,17 @@ pub mod route_action { /// /// For example with the following config: /// -///```ignore + ///```ignore /// .. code-block:: yaml -///``` + ///``` /// -///```ignore + ///```ignore /// host_rewrite_path_regex: /// pattern: /// google_re2: {} /// regex: "^/(.+)/.+$" /// substitution: \1 -///``` + ///``` /// /// Would rewrite the host header to `envoyproxy.io` given the path /// `/envoyproxy.io/some/path`. @@ -1491,7 +1411,7 @@ pub struct RetryPolicy { /// /// .. note:: /// -///```ignore + ///```ignore /// If left unspecified, Envoy will use the global /// :ref:`route timeout /// ` for the @@ -1499,7 +1419,7 @@ pub struct RetryPolicy { /// ` based retry policy, a /// request that times out will not be retried as the total timeout budget /// would have been exhausted. -///``` + ///``` #[prost(message, optional, tag = "3")] pub per_try_timeout: ::core::option::Option<::prost_types::Duration>, /// Specifies an upstream idle timeout per retry attempt (including the initial @@ -1545,9 +1465,8 @@ pub struct RetryPolicy { /// \[#comment: add [#extension-category: envoy.retry_options_predicates\] when /// there are built-in extensions] #[prost(message, repeated, tag = "12")] - pub retry_options_predicates: ::prost::alloc::vec::Vec< - super::super::core::v3::TypedExtensionConfig, - >, + pub retry_options_predicates: + ::prost::alloc::vec::Vec, /// The maximum number of times host selection will be reattempted before /// giving up, at which point the host that was last selected will be routed /// to. If unspecified, this will default to retrying once. @@ -1574,9 +1493,7 @@ pub struct RetryPolicy { /// default exponential back off strategy (configured using `retry_back_off`) /// whenever a response includes the matching headers. #[prost(message, optional, tag = "11")] - pub rate_limited_retry_back_off: ::core::option::Option< - retry_policy::RateLimitedRetryBackOff, - >, + pub rate_limited_retry_back_off: ::core::option::Option, /// HTTP response headers that trigger a retry if present in the response. A /// retry will be triggered if any of the header matches match the upstream /// response headers. The field is only consulted if 'retriable-headers' retry @@ -1652,9 +1569,9 @@ pub mod retry_policy { /// /// .. note:: /// -///```ignore + ///```ignore /// If the header appears multiple times only the first value is used. -///``` + ///``` #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, /// The format of the reset header. @@ -1668,7 +1585,7 @@ pub mod retry_policy { /// /// .. code-block:: yaml /// -///```ignore + ///```ignore /// rate_limited_retry_back_off: /// reset_headers: /// - name: Retry-After @@ -1676,31 +1593,31 @@ pub mod retry_policy { /// - name: X-RateLimit-Reset /// format: UNIX_TIMESTAMP /// max_interval: "300s" -///``` + ///``` /// /// The following algorithm will apply: /// /// 1. If the response contains the header ``Retry-After`` its value must be /// on -///```ignore + ///```ignore /// the form ``120`` (an integer that represents the number of seconds to /// wait before retrying). If so, this value is used as the back-off /// interval. -///``` + ///``` /// 2. Otherwise, if the response contains the header ``X-RateLimit-Reset`` /// its -///```ignore + ///```ignore /// value must be on the form ``1595320702`` (an integer that represents /// the point in time at which to retry, as a Unix timestamp in seconds). /// If so, the current time is subtracted from this value and the result is /// used as the back-off interval. -///``` + ///``` /// 3. Otherwise, Envoy will use the default -///```ignore + ///```ignore /// :ref:`exponential back-off /// ` /// strategy. -///``` + ///``` /// /// No matter which format is used, if the resulting back-off interval exceeds /// ``max_interval`` it is discarded and the next header in ``reset_headers`` @@ -1713,11 +1630,11 @@ pub mod retry_policy { /// /// .. attention:: /// -///```ignore + ///```ignore /// Configuring ``rate_limited_retry_back_off`` will not by itself cause a /// request to be retried. You will still need to configure the right retry /// policy to match the responses from the upstream server. -///``` + ///``` #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct RateLimitedRetryBackOff { @@ -1734,17 +1651,7 @@ pub mod retry_policy { #[prost(message, optional, tag = "2")] pub max_interval: ::core::option::Option<::prost_types::Duration>, } - #[derive( - Clone, - Copy, - Debug, - PartialEq, - Eq, - Hash, - PartialOrd, - Ord, - ::prost::Enumeration - )] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum ResetHeaderFormat { Seconds = 0, @@ -1787,9 +1694,8 @@ pub struct HedgePolicy { /// Defaults to 0. /// \[#not-implemented-hide:\] #[prost(message, optional, tag = "2")] - pub additional_request_chance: ::core::option::Option< - super::super::super::kind::v3::FractionalPercent, - >, + pub additional_request_chance: + ::core::option::Option, /// Indicates that a hedged request should be sent when the per-try timeout is /// hit. This means that a retry will be issued without resetting the original /// request, leaving multiple upstream requests in flight. The first request to @@ -1799,9 +1705,9 @@ pub struct HedgePolicy { /// retry-on conditions) would be returned to the client. /// * Before per-try timeout, an error response (per retry-on conditions) would /// be retried immediately or returned ot the client -///```ignore + ///```ignore /// if there are no more retries left. -///``` + ///``` /// * After per-try timeout, an error response would be discarded, as a retry /// in the form of a hedged request is already in progress. /// @@ -1833,35 +1739,21 @@ pub struct RedirectAction { pub strip_query: bool, /// When the scheme redirection take place, the following rules apply: /// 1. If the source URI scheme is `http` and the port is explicitly -///```ignore + ///```ignore /// set to `:80`, the port will be removed after the redirection -///``` + ///``` /// 2. If the source URI scheme is `https` and the port is explicitly -///```ignore + ///```ignore /// set to `:443`, the port will be removed after the redirection -///``` + ///``` #[prost(oneof = "redirect_action::SchemeRewriteSpecifier", tags = "4, 7")] - pub scheme_rewrite_specifier: ::core::option::Option< - redirect_action::SchemeRewriteSpecifier, - >, + pub scheme_rewrite_specifier: ::core::option::Option, #[prost(oneof = "redirect_action::PathRewriteSpecifier", tags = "2, 5, 9")] - pub path_rewrite_specifier: ::core::option::Option< - redirect_action::PathRewriteSpecifier, - >, + pub path_rewrite_specifier: ::core::option::Option, } /// Nested message and enum types in `RedirectAction`. pub mod redirect_action { - #[derive( - Clone, - Copy, - Debug, - PartialEq, - Eq, - Hash, - PartialOrd, - Ord, - ::prost::Enumeration - )] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum RedirectResponseCode { /// Moved Permanently HTTP Status Code - 301. @@ -1903,13 +1795,13 @@ pub mod redirect_action { } /// When the scheme redirection take place, the following rules apply: /// 1. If the source URI scheme is `http` and the port is explicitly -///```ignore + ///```ignore /// set to `:80`, the port will be removed after the redirection -///``` + ///``` /// 2. If the source URI scheme is `https` and the port is explicitly -///```ignore + ///```ignore /// set to `:443`, the port will be removed after the redirection -///``` + ///``` #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum SchemeRewriteSpecifier { @@ -1930,17 +1822,17 @@ pub mod redirect_action { /// For example, let's say we have the following routes: /// /// - match: { path: "/old-path-1" } -///```ignore + ///```ignore /// redirect: { path_redirect: "/new-path-1" } -///``` + ///``` /// - match: { path: "/old-path-2" } -///```ignore + ///```ignore /// redirect: { path_redirect: "/new-path-2", strip-query: "true" } -///``` + ///``` /// - match: { path: "/old-path-3" } -///```ignore + ///```ignore /// redirect: { path_redirect: "/new-path-3?foo=1", strip_query: "true" } -///``` + ///``` /// /// 1. if request uri is "/old-path-1?bar=1", users will be redirected to /// "/new-path-1?bar=1" @@ -1956,11 +1848,11 @@ pub mod redirect_action { /// /// .. attention:: /// -///```ignore + ///```ignore /// Pay attention to the use of trailing slashes as mentioned in /// :ref:`RouteAction's prefix_rewrite /// `. -///``` + ///``` #[prost(string, tag = "5")] PrefixRewrite(::prost::alloc::string::String), /// Indicates that during redirect, portions of the path that match the @@ -1973,34 +1865,32 @@ pub mod redirect_action { /// Examples using Google's `RE2 <`_> engine: /// /// * The path pattern ``^/service/(\[^/\]+)(/.*)$`` paired with a substitution -///```ignore + ///```ignore /// string of ``\2/instance/\1`` would transform ``/service/foo/v1/api`` /// into ``/v1/api/instance/foo``. -///``` + ///``` /// /// * The pattern ``one`` paired with a substitution string of ``two`` would -///```ignore + ///```ignore /// transform ``/xxx/one/yyy/one/zzz`` into ``/xxx/two/yyy/two/zzz``. -///``` + ///``` /// /// * The pattern ``^(.*?)one(.*)$`` paired with a substitution string of -///```ignore + ///```ignore /// ``\1two\2`` would replace only the first occurrence of ``one``, /// transforming path ``/xxx/one/yyy/one/zzz`` into /// ``/xxx/two/yyy/one/zzz``. -///``` + ///``` /// /// * The pattern ``(?i)/xxx/`` paired with a substitution string of /// ``/yyy/`` -///```ignore + ///```ignore /// would do a case-insensitive match and transform path ``/aaa/XxX/bbb`` /// to /// ``/aaa/yyy/bbb``. -///``` + ///``` #[prost(message, tag = "9")] - RegexRewrite( - super::super::super::super::kind::matcher::v3::RegexMatchAndSubstitute, - ), + RegexRewrite(super::super::super::super::kind::matcher::v3::RegexMatchAndSubstitute), } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -2014,12 +1904,12 @@ pub struct DirectResponseAction { /// /// .. note:: /// -///```ignore + ///```ignore /// Headers can be specified using *response_headers_to_add* in the enclosing /// :ref:`envoy_v3_api_msg_config.route.v3.Route`, /// :ref:`envoy_v3_api_msg_config.route.v3.RouteConfiguration` or /// :ref:`envoy_v3_api_msg_config.route.v3.VirtualHost`. -///``` + ///``` #[prost(message, optional, tag = "2")] pub body: ::core::option::Option, } @@ -2036,11 +1926,11 @@ pub struct Decorator { /// /// .. note:: /// -///```ignore + ///```ignore /// For ingress (inbound) requests, or egress (outbound) responses, this /// value may be overridden by the :ref:`x-envoy-decorator-operation /// ` header. -///``` + ///``` #[prost(string, tag = "1")] pub operation: ::prost::alloc::string::String, /// Whether the decorated details should be propagated to the other party. The @@ -2058,18 +1948,14 @@ pub struct Tracing { /// the :ref:`HTTP Connection Manager `. Default: /// 100% #[prost(message, optional, tag = "1")] - pub client_sampling: ::core::option::Option< - super::super::super::kind::v3::FractionalPercent, - >, + pub client_sampling: ::core::option::Option, /// Target percentage of requests managed by this HTTP connection manager that /// will be randomly selected for trace generation, if not requested by the /// client or not forced. This field is a direct analog for the runtime /// variable 'tracing.random_sampling' in the :ref:`HTTP Connection Manager /// `. Default: 100% #[prost(message, optional, tag = "2")] - pub random_sampling: ::core::option::Option< - super::super::super::kind::v3::FractionalPercent, - >, + pub random_sampling: ::core::option::Option, /// Target percentage of requests managed by this HTTP connection manager that /// will be traced after all other sampling checks have been applied /// (client-directed, force tracing, random sampling). This field functions as @@ -2080,9 +1966,7 @@ pub struct Tracing { /// in the :ref:`HTTP Connection Manager `. /// Default: 100% #[prost(message, optional, tag = "3")] - pub overall_sampling: ::core::option::Option< - super::super::super::kind::v3::FractionalPercent, - >, + pub overall_sampling: ::core::option::Option, /// A list of custom tags with unique tag name to create tags for the active /// span. It will take effect after merging with the :ref:`corresponding /// configuration @@ -2091,9 +1975,7 @@ pub struct Tracing { /// are configured each in the HTTP connection manager and the route level, the /// one configured here takes priority. #[prost(message, repeated, tag = "4")] - pub custom_tags: ::prost::alloc::vec::Vec< - super::super::super::kind::tracing::v3::CustomTag, - >, + pub custom_tags: ::prost::alloc::vec::Vec, } /// A virtual cluster is a way of specifying a regex matching rule against /// certain important endpoints such that statistics are generated explicitly for @@ -2142,9 +2024,9 @@ pub struct RateLimit { /// /// .. note:: /// -///```ignore + ///```ignore /// The filter supports a range of 0 - 10 inclusively for stage numbers. -///``` + ///``` #[prost(message, optional, tag = "1")] pub stage: ::core::option::Option, /// The key to be set in runtime to disable this rate limit configuration. @@ -2182,9 +2064,9 @@ pub mod rate_limit { /// /// .. code-block:: cpp /// -///```ignore + ///```ignore /// ("source_cluster", "") -///``` + ///``` /// /// is derived from the :option:`--service-cluster` /// option. @@ -2195,9 +2077,9 @@ pub mod rate_limit { /// /// .. code-block:: cpp /// -///```ignore + ///```ignore /// ("destination_cluster", "") -///``` + ///``` /// /// Once a request matches against a route table rule, a routed cluster is /// determined by one of the following :ref:`route table configuration @@ -2205,21 +2087,21 @@ pub mod rate_limit { /// /// * :ref:`cluster ` /// indicates the upstream cluster -///```ignore + ///```ignore /// to route to. -///``` + ///``` /// * :ref:`weighted_clusters /// ` -///```ignore + ///```ignore /// chooses a cluster randomly from a set of clusters with attributed /// weight. -///``` + ///``` /// * :ref:`cluster_header /// ` /// indicates which -///```ignore + ///```ignore /// header in the request contains the target cluster. -///``` + ///``` #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct DestinationCluster {} @@ -2228,9 +2110,9 @@ pub mod rate_limit { /// /// .. code-block:: cpp /// -///```ignore + ///```ignore /// ("", "") -///``` + ///``` #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct RequestHeaders { @@ -2255,9 +2137,9 @@ pub mod rate_limit { /// /// .. code-block:: cpp /// -///```ignore + ///```ignore /// ("remote_address", "") -///``` + ///``` #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct RemoteAddress {} @@ -2265,9 +2147,9 @@ pub mod rate_limit { /// /// .. code-block:: cpp /// -///```ignore + ///```ignore /// ("generic_key", "") -///``` + ///``` #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct GenericKey { @@ -2283,9 +2165,9 @@ pub mod rate_limit { /// /// .. code-block:: cpp /// -///```ignore + ///```ignore /// ("header_match", "") -///``` + ///``` #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct HeaderValueMatch { @@ -2312,15 +2194,15 @@ pub mod rate_limit { /// /// .. code-block:: cpp /// -///```ignore + ///```ignore /// ("", "") -///``` + ///``` /// /// .. attention:: -///```ignore + ///```ignore /// This action has been deprecated in favor of the :ref:`metadata /// ` action -///``` + ///``` #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct DynamicMetaData { @@ -2345,9 +2227,9 @@ pub mod rate_limit { /// /// .. code-block:: cpp /// -///```ignore + ///```ignore /// ("", "") -///``` + ///``` #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MetaData { @@ -2373,15 +2255,7 @@ pub mod rate_limit { /// Nested message and enum types in `MetaData`. pub mod meta_data { #[derive( - Clone, - Copy, - Debug, - PartialEq, - Eq, - Hash, - PartialOrd, - Ord, - ::prost::Enumeration + Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration, )] #[repr(i32)] pub enum Source { @@ -2436,10 +2310,10 @@ pub mod rate_limit { /// Rate limit on dynamic metadata. /// /// .. attention:: -///```ignore + ///```ignore /// This field has been deprecated in favor of the :ref:`metadata /// ` field -///``` + ///``` #[prost(message, tag = "7")] DynamicMetadata(DynamicMetaData), /// Rate limit on metadata. @@ -2544,9 +2418,7 @@ pub struct HeaderMatcher { oneof = "header_matcher::HeaderMatchSpecifier", tags = "4, 11, 6, 7, 9, 10, 12, 13" )] - pub header_match_specifier: ::core::option::Option< - header_matcher::HeaderMatchSpecifier, - >, + pub header_match_specifier: ::core::option::Option, } /// Nested message and enum types in `HeaderMatcher`. pub mod header_matcher { @@ -2578,9 +2450,9 @@ pub mod header_matcher { /// /// * For range [-10,0), route will match for header value -1, but not for 0, /// "somestring", 10.9, -///```ignore + ///```ignore /// "-1somestring" -///``` + ///``` #[prost(message, tag = "6")] RangeMatch(super::super::super::super::kind::v3::Int64Range), /// If specified as true, header match will be performed based on whether the @@ -2640,9 +2512,8 @@ pub struct QueryParameterMatcher { oneof = "query_parameter_matcher::QueryParameterMatchSpecifier", tags = "5, 6" )] - pub query_parameter_match_specifier: ::core::option::Option< - query_parameter_matcher::QueryParameterMatchSpecifier, - >, + pub query_parameter_match_specifier: + ::core::option::Option, } /// Nested message and enum types in `QueryParameterMatcher`. pub mod query_parameter_matcher { @@ -2685,9 +2556,7 @@ pub struct InternalRedirectPolicy { /// proxied to downstream. /// \[#extension-category: envoy.internal_redirect_predicates\] #[prost(message, repeated, tag = "3")] - pub predicates: ::prost::alloc::vec::Vec< - super::super::core::v3::TypedExtensionConfig, - >, + pub predicates: ::prost::alloc::vec::Vec, /// Allow internal redirect to follow a target URI with a different scheme than /// the value of x-forwarded-proto. The default is false. #[prost(bool, tag = "4")] diff --git a/src/generated/envoy/kind/tracing/v3.rs b/src/generated/envoy/kind/tracing/v3.rs index 2abf42f74d..d2cc2b65f9 100644 --- a/src/generated/envoy/kind/tracing/v3.rs +++ b/src/generated/envoy/kind/tracing/v3.rs @@ -58,14 +58,10 @@ pub mod custom_tag { pub struct Metadata { /// Specify what kind of metadata to obtain tag value from. #[prost(message, optional, tag = "1")] - pub kind: ::core::option::Option< - super::super::super::metadata::v3::MetadataKind, - >, + pub kind: ::core::option::Option, /// Metadata key to define the path to retrieve the tag value. #[prost(message, optional, tag = "2")] - pub metadata_key: ::core::option::Option< - super::super::super::metadata::v3::MetadataKey, - >, + pub metadata_key: ::core::option::Option, /// When no valid metadata is found, /// the tag value would be populated with this default value if specified, /// otherwise no tag would be populated. diff --git a/src/generated/envoy/kind/v3.rs b/src/generated/envoy/kind/v3.rs index 44aaa9ab51..1e96fb76b6 100644 --- a/src/generated/envoy/kind/v3.rs +++ b/src/generated/envoy/kind/v3.rs @@ -26,17 +26,7 @@ pub struct FractionalPercent { /// Nested message and enum types in `FractionalPercent`. pub mod fractional_percent { /// Fraction percentages support several fixed denominator values. - #[derive( - Clone, - Copy, - Debug, - PartialEq, - Eq, - Hash, - PartialOrd, - Ord, - ::prost::Enumeration - )] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum DenominatorType { /// 100. diff --git a/src/generated/envoy/service/discovery/v3.rs b/src/generated/envoy/service/discovery/v3.rs index a7839cd276..f38d833e08 100644 --- a/src/generated/envoy/service/discovery/v3.rs +++ b/src/generated/envoy/service/discovery/v3.rs @@ -44,9 +44,7 @@ pub struct DiscoveryRequest { /// consumption during manual debugging, the string provided is not guaranteed /// to be stable across Envoy versions. #[prost(message, optional, tag = "6")] - pub error_detail: ::core::option::Option< - super::super::super::super::google::rpc::Status, - >, + pub error_detail: ::core::option::Option, } /// \[#next-free-field: 7\] #[allow(clippy::derive_partial_eq_without_eq)] @@ -63,7 +61,7 @@ pub struct DiscoveryResponse { /// Canary is used to support two Envoy command line flags: /// /// * --terminate-on-canary-transition-failure. When set, Envoy is able to -///```ignore + ///```ignore /// terminate if it detects that configuration is stuck at canary. Consider /// this example sequence of updates: /// - Management server applies a canary config successfully. @@ -72,11 +70,11 @@ pub struct DiscoveryResponse { /// Since there is no sensible way to continue receiving configuration /// updates, Envoy will then terminate and apply production config from a /// clean slate. -///``` + ///``` /// * --dry-run-canary. When set, a canary response will never be applied, only -///```ignore + ///```ignore /// validated via a dry run. -///``` + ///``` #[prost(bool, tag = "3")] pub canary: bool, /// Type URL for resources. Identifies the xDS API when muxing over ADS. @@ -96,9 +94,7 @@ pub struct DiscoveryResponse { pub nonce: ::prost::alloc::string::String, /// The control plane instance that sent the response. #[prost(message, optional, tag = "6")] - pub control_plane: ::core::option::Option< - super::super::super::config::core::v3::ControlPlane, - >, + pub control_plane: ::core::option::Option, } /// DeltaDiscoveryRequest and DeltaDiscoveryResponse are used in a new gRPC /// endpoint for Delta xDS. @@ -171,14 +167,10 @@ pub struct DeltaDiscoveryRequest { /// /// A list of Resource names to add to the list of tracked resources. #[prost(string, repeated, tag = "3")] - pub resource_names_subscribe: ::prost::alloc::vec::Vec< - ::prost::alloc::string::String, - >, + pub resource_names_subscribe: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// A list of Resource names to remove from the list of tracked resources. #[prost(string, repeated, tag = "4")] - pub resource_names_unsubscribe: ::prost::alloc::vec::Vec< - ::prost::alloc::string::String, - >, + pub resource_names_unsubscribe: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// Informs the server of the versions of the resources the xDS client knows /// of, to enable the client to continue the same logical xDS session even in /// the face of gRPC stream reconnection. It will not be populated: \[1\] in the @@ -189,10 +181,8 @@ pub struct DeltaDiscoveryRequest { /// stream populates this map.) The map's keys are names of xDS resources known /// to the xDS client. The map's values are opaque resource versions. #[prost(map = "string, string", tag = "5")] - pub initial_resource_versions: ::std::collections::HashMap< - ::prost::alloc::string::String, - ::prost::alloc::string::String, - >, + pub initial_resource_versions: + ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, /// When the DeltaDiscoveryRequest is a ACK or NACK message in response /// to a previous DeltaDiscoveryResponse, the response_nonce must be the /// nonce in the DeltaDiscoveryResponse. @@ -204,9 +194,7 @@ pub struct DeltaDiscoveryRequest { /// configuration. The *message* field in *error_details* provides the Envoy /// internal exception related to the failure. #[prost(message, optional, tag = "7")] - pub error_detail: ::core::option::Option< - super::super::super::super::google::rpc::Status, - >, + pub error_detail: ::core::option::Option, } /// \[#next-free-field: 8\] #[allow(clippy::derive_partial_eq_without_eq)] @@ -235,9 +223,7 @@ pub struct DeltaDiscoveryResponse { /// \[#not-implemented-hide:\] /// The control plane instance that sent the response. #[prost(message, optional, tag = "7")] - pub control_plane: ::core::option::Option< - super::super::super::config::core::v3::ControlPlane, - >, + pub control_plane: ::core::option::Option, } /// \[#next-free-field: 8\] #[allow(clippy::derive_partial_eq_without_eq)] @@ -303,8 +289,8 @@ pub struct AdsDummy {} /// Generated client implementations. pub mod aggregated_discovery_service_client { #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] - use tonic::codegen::*; use tonic::codegen::http::Uri; + use tonic::codegen::*; /// See https://github.com/envoyproxy/envoy-api#apis for a description of the /// role of ADS and how it is intended to be used by a management server. ADS /// requests have the same structure as their singleton xDS counterparts, but can @@ -354,13 +340,10 @@ pub mod aggregated_discovery_service_client { >::ResponseBody, >, >, - , - >>::Error: Into + Send + Sync, + >>::Error: + Into + Send + Sync, { - AggregatedDiscoveryServiceClient::new( - InterceptedService::new(inner, interceptor), - ) + AggregatedDiscoveryServiceClient::new(InterceptedService::new(inner, interceptor)) } /// Compress requests with the given encoding. /// @@ -401,59 +384,45 @@ pub mod aggregated_discovery_service_client { tonic::Response>, tonic::Status, > { - self.inner - .ready() - .await - .map_err(|e| { - tonic::Status::new( - tonic::Code::Unknown, - format!("Service was not ready: {}", e.into()), - ) - })?; + self.inner.ready().await.map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/envoy.service.discovery.v3.AggregatedDiscoveryService/StreamAggregatedResources", ); let mut req = request.into_streaming_request(); - req.extensions_mut() - .insert( - GrpcMethod::new( - "envoy.service.discovery.v3.AggregatedDiscoveryService", - "StreamAggregatedResources", - ), - ); + req.extensions_mut().insert(GrpcMethod::new( + "envoy.service.discovery.v3.AggregatedDiscoveryService", + "StreamAggregatedResources", + )); self.inner.streaming(req, path, codec).await } pub async fn delta_aggregated_resources( &mut self, - request: impl tonic::IntoStreamingRequest< - Message = super::DeltaDiscoveryRequest, - >, + request: impl tonic::IntoStreamingRequest, ) -> std::result::Result< tonic::Response>, tonic::Status, > { - self.inner - .ready() - .await - .map_err(|e| { - tonic::Status::new( - tonic::Code::Unknown, - format!("Service was not ready: {}", e.into()), - ) - })?; + self.inner.ready().await.map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/envoy.service.discovery.v3.AggregatedDiscoveryService/DeltaAggregatedResources", ); let mut req = request.into_streaming_request(); - req.extensions_mut() - .insert( - GrpcMethod::new( - "envoy.service.discovery.v3.AggregatedDiscoveryService", - "DeltaAggregatedResources", - ), - ); + req.extensions_mut().insert(GrpcMethod::new( + "envoy.service.discovery.v3.AggregatedDiscoveryService", + "DeltaAggregatedResources", + )); self.inner.streaming(req, path, codec).await } } @@ -468,8 +437,7 @@ pub mod aggregated_discovery_service_server { /// Server streaming response type for the StreamAggregatedResources method. type StreamAggregatedResourcesStream: tonic::codegen::tokio_stream::Stream< Item = std::result::Result, - > - + Send + > + Send + 'static; /// This is a gRPC-only API. async fn stream_aggregated_resources( @@ -482,16 +450,12 @@ pub mod aggregated_discovery_service_server { /// Server streaming response type for the DeltaAggregatedResources method. type DeltaAggregatedResourcesStream: tonic::codegen::tokio_stream::Stream< Item = std::result::Result, - > - + Send + > + Send + 'static; async fn delta_aggregated_resources( &self, request: tonic::Request>, - ) -> std::result::Result< - tonic::Response, - tonic::Status, - >; + ) -> std::result::Result, tonic::Status>; } /// See https://github.com/envoyproxy/envoy-api#apis for a description of the /// role of ADS and how it is intended to be used by a management server. ADS @@ -522,10 +486,7 @@ pub mod aggregated_discovery_service_server { max_encoding_message_size: None, } } - pub fn with_interceptor( - inner: T, - interceptor: F, - ) -> InterceptedService + pub fn with_interceptor(inner: T, interceptor: F) -> InterceptedService where F: tonic::service::Interceptor, { @@ -560,8 +521,7 @@ pub mod aggregated_discovery_service_server { self } } - impl tonic::codegen::Service> - for AggregatedDiscoveryServiceServer + impl tonic::codegen::Service> for AggregatedDiscoveryServiceServer where T: AggregatedDiscoveryService, B: Body + Send + 'static, @@ -727,7 +687,8 @@ pub mod aggregated_discovery_service_server { } } impl tonic::server::NamedService - for AggregatedDiscoveryServiceServer { + for AggregatedDiscoveryServiceServer + { const NAME: &'static str = "envoy.service.discovery.v3.AggregatedDiscoveryService"; } } diff --git a/src/generated/quilkin/filters/compress/v1alpha1.rs b/src/generated/quilkin/filters/compress/v1alpha1.rs index 170c0bff22..6ad84f6c56 100644 --- a/src/generated/quilkin/filters/compress/v1alpha1.rs +++ b/src/generated/quilkin/filters/compress/v1alpha1.rs @@ -22,17 +22,7 @@ pub mod compress { #[prost(enumeration = "Action", tag = "1")] pub value: i32, } - #[derive( - Clone, - Copy, - Debug, - PartialEq, - Eq, - Hash, - PartialOrd, - Ord, - ::prost::Enumeration - )] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum Mode { Snappy = 0, @@ -58,17 +48,7 @@ pub mod compress { } } } - #[derive( - Clone, - Copy, - Debug, - PartialEq, - Eq, - Hash, - PartialOrd, - Ord, - ::prost::Enumeration - )] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum Action { DoNothing = 0, diff --git a/src/generated/quilkin/filters/concatenate/v1alpha1.rs b/src/generated/quilkin/filters/concatenate/v1alpha1.rs index 2565fe5093..c8c889d4e7 100644 --- a/src/generated/quilkin/filters/concatenate/v1alpha1.rs +++ b/src/generated/quilkin/filters/concatenate/v1alpha1.rs @@ -16,17 +16,7 @@ pub mod concatenate { #[prost(enumeration = "Strategy", tag = "1")] pub value: i32, } - #[derive( - Clone, - Copy, - Debug, - PartialEq, - Eq, - Hash, - PartialOrd, - Ord, - ::prost::Enumeration - )] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum Strategy { DoNothing = 0, diff --git a/src/generated/quilkin/filters/firewall/v1alpha1.rs b/src/generated/quilkin/filters/firewall/v1alpha1.rs index 610987e8dc..a71a16e723 100644 --- a/src/generated/quilkin/filters/firewall/v1alpha1.rs +++ b/src/generated/quilkin/filters/firewall/v1alpha1.rs @@ -26,17 +26,7 @@ pub mod firewall { #[prost(message, repeated, tag = "3")] pub ports: ::prost::alloc::vec::Vec, } - #[derive( - Clone, - Copy, - Debug, - PartialEq, - Eq, - Hash, - PartialOrd, - Ord, - ::prost::Enumeration - )] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum Action { Allow = 0, diff --git a/src/generated/quilkin/filters/load_balancer/v1alpha1.rs b/src/generated/quilkin/filters/load_balancer/v1alpha1.rs index 89246502b7..936e4bdffc 100644 --- a/src/generated/quilkin/filters/load_balancer/v1alpha1.rs +++ b/src/generated/quilkin/filters/load_balancer/v1alpha1.rs @@ -12,17 +12,7 @@ pub mod load_balancer { #[prost(enumeration = "Policy", tag = "1")] pub value: i32, } - #[derive( - Clone, - Copy, - Debug, - PartialEq, - Eq, - Hash, - PartialOrd, - Ord, - ::prost::Enumeration - )] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum Policy { RoundRobin = 0, diff --git a/src/generated/quilkin/relay/v1alpha1.rs b/src/generated/quilkin/relay/v1alpha1.rs index 53925614b2..5207c95aed 100644 --- a/src/generated/quilkin/relay/v1alpha1.rs +++ b/src/generated/quilkin/relay/v1alpha1.rs @@ -1,8 +1,8 @@ /// Generated client implementations. pub mod aggregated_control_plane_discovery_service_client { #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] - use tonic::codegen::*; use tonic::codegen::http::Uri; + use tonic::codegen::*; /// The Manager Discovery Service provides an RPC for a management /// service to upstream its configuration to a relay service. /// This RPC works essentially the same as xDS, except instead of the @@ -56,13 +56,13 @@ pub mod aggregated_control_plane_discovery_service_client { >::ResponseBody, >, >, - , - >>::Error: Into + Send + Sync, + >>::Error: + Into + Send + Sync, { - AggregatedControlPlaneDiscoveryServiceClient::new( - InterceptedService::new(inner, interceptor), - ) + AggregatedControlPlaneDiscoveryServiceClient::new(InterceptedService::new( + inner, + interceptor, + )) } /// Compress requests with the given encoding. /// @@ -112,27 +112,21 @@ pub mod aggregated_control_plane_discovery_service_client { >, tonic::Status, > { - self.inner - .ready() - .await - .map_err(|e| { - tonic::Status::new( - tonic::Code::Unknown, - format!("Service was not ready: {}", e.into()), - ) - })?; + self.inner.ready().await.map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/quilkin.relay.v1alpha1.AggregatedControlPlaneDiscoveryService/StreamAggregatedResources", ); let mut req = request.into_streaming_request(); - req.extensions_mut() - .insert( - GrpcMethod::new( - "quilkin.relay.v1alpha1.AggregatedControlPlaneDiscoveryService", - "StreamAggregatedResources", - ), - ); + req.extensions_mut().insert(GrpcMethod::new( + "quilkin.relay.v1alpha1.AggregatedControlPlaneDiscoveryService", + "StreamAggregatedResources", + )); self.inner.streaming(req, path, codec).await } pub async fn delta_aggregated_resources( @@ -147,28 +141,22 @@ pub mod aggregated_control_plane_discovery_service_client { >, >, tonic::Status, - > { - self.inner - .ready() - .await - .map_err(|e| { - tonic::Status::new( - tonic::Code::Unknown, - format!("Service was not ready: {}", e.into()), - ) - })?; + >{ + self.inner.ready().await.map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/quilkin.relay.v1alpha1.AggregatedControlPlaneDiscoveryService/DeltaAggregatedResources", ); let mut req = request.into_streaming_request(); - req.extensions_mut() - .insert( - GrpcMethod::new( - "quilkin.relay.v1alpha1.AggregatedControlPlaneDiscoveryService", - "DeltaAggregatedResources", - ), - ); + req.extensions_mut().insert(GrpcMethod::new( + "quilkin.relay.v1alpha1.AggregatedControlPlaneDiscoveryService", + "DeltaAggregatedResources", + )); self.inner.streaming(req, path, codec).await } } @@ -186,8 +174,7 @@ pub mod aggregated_control_plane_discovery_service_server { super::super::super::super::envoy::service::discovery::v3::DiscoveryRequest, tonic::Status, >, - > - + Send + > + Send + 'static; /// The RPC protocol begins with a single empty DiscoveryResponse /// initiated by the management server, after that this behaves @@ -220,10 +207,7 @@ pub mod aggregated_control_plane_discovery_service_server { super::super::super::super::envoy::service::discovery::v3::DeltaDiscoveryResponse, >, >, - ) -> std::result::Result< - tonic::Response, - tonic::Status, - >; + ) -> std::result::Result, tonic::Status>; } /// The Manager Discovery Service provides an RPC for a management /// service to upstream its configuration to a relay service. @@ -246,9 +230,7 @@ pub mod aggregated_control_plane_discovery_service_server { max_encoding_message_size: Option, } struct _Inner(Arc); - impl< - T: AggregatedControlPlaneDiscoveryService, - > AggregatedControlPlaneDiscoveryServiceServer { + impl AggregatedControlPlaneDiscoveryServiceServer { pub fn new(inner: T) -> Self { Self::from_arc(Arc::new(inner)) } @@ -262,10 +244,7 @@ pub mod aggregated_control_plane_discovery_service_server { max_encoding_message_size: None, } } - pub fn with_interceptor( - inner: T, - interceptor: F, - ) -> InterceptedService + pub fn with_interceptor(inner: T, interceptor: F) -> InterceptedService where F: tonic::service::Interceptor, { @@ -301,7 +280,7 @@ pub mod aggregated_control_plane_discovery_service_server { } } impl tonic::codegen::Service> - for AggregatedControlPlaneDiscoveryServiceServer + for AggregatedControlPlaneDiscoveryServiceServer where T: AggregatedControlPlaneDiscoveryService, B: Body + Send + 'static, @@ -455,7 +434,8 @@ pub mod aggregated_control_plane_discovery_service_server { } } impl Clone - for AggregatedControlPlaneDiscoveryServiceServer { + for AggregatedControlPlaneDiscoveryServiceServer + { fn clone(&self) -> Self { let inner = self.inner.clone(); Self { @@ -478,7 +458,8 @@ pub mod aggregated_control_plane_discovery_service_server { } } impl tonic::server::NamedService - for AggregatedControlPlaneDiscoveryServiceServer { + for AggregatedControlPlaneDiscoveryServiceServer + { const NAME: &'static str = "quilkin.relay.v1alpha1.AggregatedControlPlaneDiscoveryService"; } } diff --git a/src/generated/xds/annotations/v3.rs b/src/generated/xds/annotations/v3.rs index cffde3996e..f281d4d14b 100644 --- a/src/generated/xds/annotations/v3.rs +++ b/src/generated/xds/annotations/v3.rs @@ -52,9 +52,7 @@ impl PackageVersionStatus { PackageVersionStatus::Unknown => "UNKNOWN", PackageVersionStatus::Frozen => "FROZEN", PackageVersionStatus::Active => "ACTIVE", - PackageVersionStatus::NextMajorVersionCandidate => { - "NEXT_MAJOR_VERSION_CANDIDATE" - } + PackageVersionStatus::NextMajorVersionCandidate => "NEXT_MAJOR_VERSION_CANDIDATE", } } /// Creates an enum from field names used in the ProtoBuf definition. diff --git a/src/generated/xds/core/v3.rs b/src/generated/xds/core/v3.rs index e0d8327923..c628ff2e01 100644 --- a/src/generated/xds/core/v3.rs +++ b/src/generated/xds/core/v3.rs @@ -34,10 +34,8 @@ pub struct Authority { #[derive(Clone, PartialEq, ::prost::Message)] pub struct ContextParams { #[prost(map = "string, string", tag = "1")] - pub params: ::std::collections::HashMap< - ::prost::alloc::string::String, - ::prost::alloc::string::String, - >, + pub params: + ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, } /// xDS resource locators identify a xDS resource name and instruct the /// data-plane load balancer on how the resource may be located. @@ -90,9 +88,7 @@ pub struct ResourceLocator { #[prost(message, repeated, tag = "6")] pub directives: ::prost::alloc::vec::Vec, #[prost(oneof = "resource_locator::ContextParamSpecifier", tags = "5")] - pub context_param_specifier: ::core::option::Option< - resource_locator::ContextParamSpecifier, - >, + pub context_param_specifier: ::core::option::Option, } /// Nested message and enum types in `ResourceLocator`. pub mod resource_locator { @@ -131,9 +127,9 @@ pub mod resource_locator { /// An alternative resource locator for fallback if the resource is /// unavailable. For example, take the resource locator: /// -///```ignore + ///```ignore /// xdstp://foo/some-type/some-route-table#alt=xdstp://bar/some-type/another-route-table -///``` + ///``` /// /// If the data-plane load balancer is unable to reach `foo` to fetch the /// resource, it will fallback to `bar`. Alternative resources do not need @@ -149,17 +145,7 @@ pub mod resource_locator { Entry(::prost::alloc::string::String), } } - #[derive( - Clone, - Copy, - Debug, - PartialEq, - Eq, - Hash, - PartialOrd, - Ord, - ::prost::Enumeration - )] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum Scheme { Xdstp = 0, diff --git a/src/generated/xds/kind/matcher/v3.rs b/src/generated/xds/kind/matcher/v3.rs index 06165da8a1..0b0ac4fec8 100644 --- a/src/generated/xds/kind/matcher/v3.rs +++ b/src/generated/xds/kind/matcher/v3.rs @@ -116,9 +116,7 @@ pub struct Matcher { /// succeeded). If no matcher above matched and this field is not populated, /// the match will be considered unsuccessful. #[prost(message, optional, boxed, tag = "3")] - pub on_no_match: ::core::option::Option< - ::prost::alloc::boxed::Box, - >, + pub on_no_match: ::core::option::Option<::prost::alloc::boxed::Box>, #[prost(oneof = "matcher::MatcherType", tags = "1, 2")] pub matcher_type: ::core::option::Option, } @@ -240,9 +238,8 @@ pub mod matcher { pub struct MatcherTree { /// Protocol-specific specification of input field to match on. #[prost(message, optional, tag = "1")] - pub input: ::core::option::Option< - super::super::super::super::core::v3::TypedExtensionConfig, - >, + pub input: + ::core::option::Option, /// Exact or prefix match maps in which to look up the input value. /// If the lookup succeeds, the match is considered successful, and /// the corresponding OnMatch is used. @@ -256,10 +253,7 @@ pub mod matcher { #[derive(Clone, PartialEq, ::prost::Message)] pub struct MatchMap { #[prost(map = "string, message", tag = "1")] - pub map: ::std::collections::HashMap< - ::prost::alloc::string::String, - super::OnMatch, - >, + pub map: ::std::collections::HashMap<::prost::alloc::string::String, super::OnMatch>, } /// Exact or prefix match maps in which to look up the input value. /// If the lookup succeeds, the match is considered successful, and @@ -274,9 +268,7 @@ pub mod matcher { PrefixMatchMap(MatchMap), /// Extension for custom matching logic. #[prost(message, tag = "4")] - CustomMatch( - super::super::super::super::super::core::v3::TypedExtensionConfig, - ), + CustomMatch(super::super::super::super::super::core::v3::TypedExtensionConfig), } } #[allow(clippy::derive_partial_eq_without_eq)]