http_connection_managerv3

package
v1.36.11-2026011520535... Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: unknown License: Apache-2.0 Imports: 18 Imported by: 0

Documentation

Index

Constants

View Source 
const HttpConnectionManager_ProxyStatusConfig_LiteralProxyName_case case_HttpConnectionManager_ProxyStatusConfig_ProxyName = 6
View Source 
const HttpConnectionManager_ProxyStatusConfig_ProxyName_not_set_case case_HttpConnectionManager_ProxyStatusConfig_ProxyName = 0
View Source 
const HttpConnectionManager_ProxyStatusConfig_UseNodeId_case case_HttpConnectionManager_ProxyStatusConfig_ProxyName = 5
View Source 
const HttpConnectionManager_Rds_case case_HttpConnectionManager_RouteSpecifier = 3
View Source 
const HttpConnectionManager_RouteConfig_case case_HttpConnectionManager_RouteSpecifier = 4
View Source 
const HttpConnectionManager_RouteSpecifier_not_set_case case_HttpConnectionManager_RouteSpecifier = 0
View Source 
const HttpConnectionManager_ScopedRoutes_case case_HttpConnectionManager_RouteSpecifier = 31
View Source 
const HttpConnectionManager_StripAnyHostPort_case case_HttpConnectionManager_StripPortMode = 42
View Source 
const HttpConnectionManager_StripPortMode_not_set_case case_HttpConnectionManager_StripPortMode = 0
View Source 
const HttpFilter_ConfigDiscovery_case case_HttpFilter_ConfigType = 5
View Source 
const HttpFilter_ConfigType_not_set_case case_HttpFilter_ConfigType = 0
View Source 
const HttpFilter_TypedConfig_case case_HttpFilter_ConfigType = 4
View Source 
const ScopedRoutes_ConfigSpecifier_not_set_case case_ScopedRoutes_ConfigSpecifier = 0
View Source 
const ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_Element_case case_ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_ExtractType = 4
View Source 
const ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_ExtractType_not_set_case case_ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_ExtractType = 0
View Source 
const ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_Index_case case_ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_ExtractType = 3
View Source 
const ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_case case_ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_Type = 1
View Source 
const ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_Type_not_set_case case_ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_Type = 0
View Source 
const ScopedRoutes_ScopedRds_case case_ScopedRoutes_ConfigSpecifier = 5
View Source 
const ScopedRoutes_ScopedRouteConfigurationsList_case case_ScopedRoutes_ConfigSpecifier = 4

Variables

View Source 
var (
	HttpConnectionManager_CodecType_name = map[int32]string{
		0: "AUTO",
		1: "HTTP1",
		2: "HTTP2",
		3: "HTTP3",
	}
	HttpConnectionManager_CodecType_value = map[string]int32{
		"AUTO":  0,
		"HTTP1": 1,
		"HTTP2": 2,
		"HTTP3": 3,
	}
)

Enum value maps for HttpConnectionManager_CodecType.

View Source 
var (
	HttpConnectionManager_ServerHeaderTransformation_name = map[int32]string{
		0: "OVERWRITE",
		1: "APPEND_IF_ABSENT",
		2: "PASS_THROUGH",
	}
	HttpConnectionManager_ServerHeaderTransformation_value = map[string]int32{
		"OVERWRITE":        0,
		"APPEND_IF_ABSENT": 1,
		"PASS_THROUGH":     2,
	}
)

Enum value maps for HttpConnectionManager_ServerHeaderTransformation.

View Source 
var (
	HttpConnectionManager_ForwardClientCertDetails_name = map[int32]string{
		0: "SANITIZE",
		1: "FORWARD_ONLY",
		2: "APPEND_FORWARD",
		3: "SANITIZE_SET",
		4: "ALWAYS_FORWARD_ONLY",
	}
	HttpConnectionManager_ForwardClientCertDetails_value = map[string]int32{
		"SANITIZE":            0,
		"FORWARD_ONLY":        1,
		"APPEND_FORWARD":      2,
		"SANITIZE_SET":        3,
		"ALWAYS_FORWARD_ONLY": 4,
	}
)

Enum value maps for HttpConnectionManager_ForwardClientCertDetails.

View Source 
var (
	HttpConnectionManager_PathWithEscapedSlashesAction_name = map[int32]string{
		0: "IMPLEMENTATION_SPECIFIC_DEFAULT",
		1: "KEEP_UNCHANGED",
		2: "REJECT_REQUEST",
		3: "UNESCAPE_AND_REDIRECT",
		4: "UNESCAPE_AND_FORWARD",
	}
	HttpConnectionManager_PathWithEscapedSlashesAction_value = map[string]int32{
		"IMPLEMENTATION_SPECIFIC_DEFAULT": 0,
		"KEEP_UNCHANGED":                  1,
		"REJECT_REQUEST":                  2,
		"UNESCAPE_AND_REDIRECT":           3,
		"UNESCAPE_AND_FORWARD":            4,
	}
)

Enum value maps for HttpConnectionManager_PathWithEscapedSlashesAction.

View Source 
var (
	HttpConnectionManager_Tracing_OperationName_name = map[int32]string{
		0: "INGRESS",
		1: "EGRESS",
	}
	HttpConnectionManager_Tracing_OperationName_value = map[string]int32{
		"INGRESS": 0,
		"EGRESS":  1,
	}
)

Enum value maps for HttpConnectionManager_Tracing_OperationName.

View Source 
var File_envoy_extensions_filters_network_http_connection_manager_v3_http_connection_manager_proto protoreflect.FileDescriptor

Functions

This section is empty.

Types

type EnvoyMobileHttpConnectionManager 

type EnvoyMobileHttpConnectionManager struct {

	// The configuration for the underlying HttpConnectionManager which will be
	// instantiated for Envoy mobile.
	Config *HttpConnectionManager `protobuf:"bytes,1,opt,name=config,proto3" json:"config,omitempty"`
	// contains filtered or unexported fields
}

[#protodoc-title: Envoy Mobile HTTP connection manager] HTTP connection manager for use in Envoy mobile. [#extension: envoy.filters.network.envoy_mobile_http_connection_manager]

func (*EnvoyMobileHttpConnectionManager) ClearConfig 

func (x *EnvoyMobileHttpConnectionManager) ClearConfig()

func (*EnvoyMobileHttpConnectionManager) GetConfig 

func (x *EnvoyMobileHttpConnectionManager) GetConfig() *HttpConnectionManager

func (*EnvoyMobileHttpConnectionManager) HasConfig 

func (x *EnvoyMobileHttpConnectionManager) HasConfig() bool

func (*EnvoyMobileHttpConnectionManager) ProtoMessage 

func (*EnvoyMobileHttpConnectionManager) ProtoMessage()

func (*EnvoyMobileHttpConnectionManager) ProtoReflect 

func (x *EnvoyMobileHttpConnectionManager) ProtoReflect() protoreflect.Message

func (*EnvoyMobileHttpConnectionManager) Reset 

func (x *EnvoyMobileHttpConnectionManager) Reset()

func (*EnvoyMobileHttpConnectionManager) SetConfig 

func (x *EnvoyMobileHttpConnectionManager) SetConfig(v *HttpConnectionManager)

func (*EnvoyMobileHttpConnectionManager) String 

func (x *EnvoyMobileHttpConnectionManager) String() string

type EnvoyMobileHttpConnectionManager_builder 

type EnvoyMobileHttpConnectionManager_builder struct {

	// The configuration for the underlying HttpConnectionManager which will be
	// instantiated for Envoy mobile.
	Config *HttpConnectionManager
	// contains filtered or unexported fields
}

func (EnvoyMobileHttpConnectionManager_builder) Build 

func (b0 EnvoyMobileHttpConnectionManager_builder) Build() *EnvoyMobileHttpConnectionManager

type HttpConnectionManager 

type HttpConnectionManager struct {

	// Supplies the type of codec that the connection manager should use.
	CodecType HttpConnectionManager_CodecType `` /* 186-byte string literal not displayed */
	// The human readable prefix to use when emitting statistics for the
	// connection manager. See the :ref:`statistics documentation <config_http_conn_man_stats>` for
	// more information.
	StatPrefix string `protobuf:"bytes,2,opt,name=stat_prefix,json=statPrefix,proto3" json:"stat_prefix,omitempty"`
	// Types that are valid to be assigned to RouteSpecifier:
	//
	//	*HttpConnectionManager_Rds
	//	*HttpConnectionManager_RouteConfig
	//	*HttpConnectionManager_ScopedRoutes
	RouteSpecifier isHttpConnectionManager_RouteSpecifier `protobuf_oneof:"route_specifier"`
	// A list of individual HTTP filters that make up the filter chain for
	// requests made to the connection manager. :ref:`Order matters <arch_overview_http_filters_ordering>`
	// as the filters are processed sequentially as request events happen.
	HttpFilters []*HttpFilter `protobuf:"bytes,5,rep,name=http_filters,json=httpFilters,proto3" json:"http_filters,omitempty"`
	// Whether the connection manager manipulates the :ref:`config_http_conn_man_headers_user-agent`
	// and :ref:`config_http_conn_man_headers_downstream-service-cluster` headers. See the linked
	// documentation for more information. Defaults to false.
	AddUserAgent *wrapperspb.BoolValue `protobuf:"bytes,6,opt,name=add_user_agent,json=addUserAgent,proto3" json:"add_user_agent,omitempty"`
	// Presence of the object defines whether the connection manager
	// emits :ref:`tracing <arch_overview_tracing>` data to the :ref:`configured tracing provider
	// <envoy_v3_api_msg_config.trace.v3.Tracing>`.
	Tracing *HttpConnectionManager_Tracing `protobuf:"bytes,7,opt,name=tracing,proto3" json:"tracing,omitempty"`
	// Additional settings for HTTP requests handled by the connection manager. These will be
	// applicable to both HTTP/1.1 and HTTP/2 requests.
	CommonHttpProtocolOptions *v3.HttpProtocolOptions `` /* 141-byte string literal not displayed */
	// If set to “true“, Envoy will not initiate an immediate drain timer for downstream HTTP/1 connections
	// once :ref:`common_http_protocol_options.max_connection_duration
	// <envoy_v3_api_field_config.core.v3.HttpProtocolOptions.max_connection_duration>` is exceeded.
	// Instead, Envoy will wait until the next downstream request arrives, add a “connection: close“ header
	// to the response, and then gracefully close the connection once the stream has completed.
	//
	// This behavior adheres to `RFC 9112, Section 9.6 <https://www.rfc-editor.org/rfc/rfc9112#name-tear-down>`_.
	//
	// If set to “false“, exceeding “max_connection_duration“ triggers Envoy's default drain behavior for HTTP/1,
	// where the connection is eventually closed after all active streams finish.
	//
	// This option has no effect if “max_connection_duration“ is not configured.
	// Defaults to “false“.
	Http1SafeMaxConnectionDuration bool `` /* 159-byte string literal not displayed */
	// Additional HTTP/1 settings that are passed to the HTTP/1 codec.
	// [#comment:TODO: The following fields are ignored when the
	// :ref:`header validation configuration <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.typed_header_validation_config>`
	// is present:
	// 1. :ref:`allow_chunked_length <envoy_v3_api_field_config.core.v3.Http1ProtocolOptions.allow_chunked_length>`]
	HttpProtocolOptions *v3.Http1ProtocolOptions `protobuf:"bytes,8,opt,name=http_protocol_options,json=httpProtocolOptions,proto3" json:"http_protocol_options,omitempty"`
	// Additional HTTP/2 settings that are passed directly to the HTTP/2 codec.
	Http2ProtocolOptions *v3.Http2ProtocolOptions `protobuf:"bytes,9,opt,name=http2_protocol_options,json=http2ProtocolOptions,proto3" json:"http2_protocol_options,omitempty"`
	// Additional HTTP/3 settings that are passed directly to the HTTP/3 codec.
	Http3ProtocolOptions *v3.Http3ProtocolOptions `protobuf:"bytes,44,opt,name=http3_protocol_options,json=http3ProtocolOptions,proto3" json:"http3_protocol_options,omitempty"`
	// An optional override that the connection manager will write to the server
	// header in responses. If not set, the default is “envoy“.
	ServerName string `protobuf:"bytes,10,opt,name=server_name,json=serverName,proto3" json:"server_name,omitempty"`
	// Defines the action to be applied to the Server header on the response path.
	// By default, Envoy will overwrite the header with the value specified in
	// server_name.
	ServerHeaderTransformation HttpConnectionManager_ServerHeaderTransformation `` /* 257-byte string literal not displayed */
	// Allows for explicit transformation of the :scheme header on the request path.
	// If not set, Envoy's default :ref:`scheme  <config_http_conn_man_headers_scheme>`
	// handling applies.
	SchemeHeaderTransformation *v3.SchemeHeaderTransformation `` /* 142-byte string literal not displayed */
	// The maximum request headers size for incoming connections.
	// If unconfigured, the default max request headers allowed is 60 KiB.
	// The default value can be overridden by setting runtime key “envoy.reloadable_features.max_request_headers_size_kb“.
	// Requests that exceed this limit will receive a 431 response.
	//
	// .. note::
	//
	//	Currently some protocol codecs impose limits on the maximum size of a single header.
	//
	//	* HTTP/2 (when using nghttp2) limits a single header to around 100kb.
	//	* HTTP/3 limits a single header to around 1024kb.
	MaxRequestHeadersKb *wrapperspb.UInt32Value `protobuf:"bytes,29,opt,name=max_request_headers_kb,json=maxRequestHeadersKb,proto3" json:"max_request_headers_kb,omitempty"`
	// The stream idle timeout for connections managed by the connection manager.
	// If not specified, this defaults to 5 minutes. The default value was selected
	// so as not to interfere with any smaller configured timeouts that may have
	// existed in configurations prior to the introduction of this feature, while
	// introducing robustness to TCP connections that terminate without a FIN.
	//
	// This idle timeout applies to new streams and is overridable by the
	// :ref:`route-level idle_timeout
	// <envoy_v3_api_field_config.route.v3.RouteAction.idle_timeout>`. Even on a stream in
	// which the override applies, prior to receipt of the initial request
	// headers, the :ref:`stream_idle_timeout
	// <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.stream_idle_timeout>`
	// applies. Each time an encode/decode event for headers or data is processed
	// for the stream, the timer will be reset. If the timeout fires, the stream
	// is terminated with a 408 Request Timeout error code if no upstream response
	// header has been received, otherwise a stream reset occurs.
	//
	// If the :ref:`overload action <config_overload_manager_overload_actions>` "envoy.overload_actions.reduce_timeouts"
	// is configured, this timeout is scaled according to the value for
	// :ref:`HTTP_DOWNSTREAM_STREAM_IDLE <envoy_v3_api_enum_value_config.overload.v3.ScaleTimersOverloadActionConfig.TimerType.HTTP_DOWNSTREAM_STREAM_IDLE>`.
	//
	// Note that it is possible to idle timeout even if the wire traffic for a stream is non-idle, due
	// to the granularity of events presented to the connection manager. For example, while receiving
	// very large request headers, it may be the case that there is traffic regularly arriving on the
	// wire while the connection manage is only able to observe the end-of-headers event, hence the
	// stream may still idle timeout.
	//
	// A value of 0 will completely disable the connection manager stream idle
	// timeout, although per-route idle timeout overrides will continue to apply.
	//
	// This timeout is also used as the default value for :ref:`stream_flush_timeout
	// <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.stream_flush_timeout>`.
	StreamIdleTimeout *durationpb.Duration `protobuf:"bytes,24,opt,name=stream_idle_timeout,json=streamIdleTimeout,proto3" json:"stream_idle_timeout,omitempty"`
	// The stream flush timeout for connections managed by the connection manager.
	//
	// If not specified, the value of stream_idle_timeout is used. This is for backwards compatibility
	// since this was the original behavior. In essence this timeout is an override for the
	// stream_idle_timeout that applies specifically to the end of stream flush case.
	//
	// This timeout specifies the amount of time that Envoy will wait for the peer to open enough
	// window to write any remaining stream data once the entirety of stream data (local end stream is
	// true) has been buffered pending available window. In other words, this timeout defends against
	// a peer that does not release enough window to completely write the stream, even though all
	// data has been proxied within available flow control windows. If the timeout is hit in this
	// case, the :ref:`tx_flush_timeout <config_http_conn_man_stats_per_codec>` counter will be
	// incremented. Note that :ref:`max_stream_duration
	// <envoy_v3_api_field_config.core.v3.HttpProtocolOptions.max_stream_duration>` does not apply to
	// this corner case.
	StreamFlushTimeout *durationpb.Duration `protobuf:"bytes,59,opt,name=stream_flush_timeout,json=streamFlushTimeout,proto3" json:"stream_flush_timeout,omitempty"`
	// The amount of time that Envoy will wait for the entire request to be received.
	// The timer is activated when the request is initiated, and is disarmed when the last byte of the
	// request is sent upstream (i.e. all decoding filters have processed the request), OR when the
	// response is initiated. If not specified or set to 0, this timeout is disabled.
	RequestTimeout *durationpb.Duration `protobuf:"bytes,28,opt,name=request_timeout,json=requestTimeout,proto3" json:"request_timeout,omitempty"`
	// The amount of time that Envoy will wait for the request headers to be received. The timer is
	// activated when the first byte of the headers is received, and is disarmed when the last byte of
	// the headers has been received. If not specified or set to 0, this timeout is disabled.
	RequestHeadersTimeout *durationpb.Duration `` /* 127-byte string literal not displayed */
	// The time that Envoy will wait between sending an HTTP/2 “shutdown
	// notification” (GOAWAY frame with max stream ID) and a final GOAWAY frame.
	// This is used so that Envoy provides a grace period for new streams that
	// race with the final GOAWAY frame. During this grace period, Envoy will
	// continue to accept new streams. After the grace period, a final GOAWAY
	// frame is sent and Envoy will start refusing new streams. Draining occurs
	// either when a connection hits the idle timeout, when :ref:`max_connection_duration
	// <envoy_v3_api_field_config.core.v3.HttpProtocolOptions.max_connection_duration>`
	// is reached, or during general server draining. The default grace period is
	// 5000 milliseconds (5 seconds) if this option is not specified.
	DrainTimeout *durationpb.Duration `protobuf:"bytes,12,opt,name=drain_timeout,json=drainTimeout,proto3" json:"drain_timeout,omitempty"`
	// The delayed close timeout is for downstream connections managed by the HTTP connection manager.
	// It is defined as a grace period after connection close processing has been locally initiated
	// during which Envoy will wait for the peer to close (i.e., a TCP FIN/RST is received by Envoy
	// from the downstream connection) prior to Envoy closing the socket associated with that
	// connection.
	//
	// .. note::
	//
	//	This timeout is enforced even when the socket associated with the downstream connection is pending a flush of
	//	the write buffer. However, any progress made writing data to the socket will restart the timer associated with
	//	this timeout. This means that the total grace period for a socket in this state will be
	//	<total_time_waiting_for_write_buffer_flushes>+<delayed_close_timeout>.
	//
	// Delaying Envoy's connection close and giving the peer the opportunity to initiate the close
	// sequence mitigates a race condition that exists when downstream clients do not drain/process
	// data in a connection's receive buffer after a remote close has been detected via a socket
	// “write()“. This race leads to such clients failing to process the response code sent by Envoy,
	// which could result in erroneous downstream processing.
	//
	// If the timeout triggers, Envoy will close the connection's socket.
	//
	// The default timeout is 1000 ms if this option is not specified.
	//
	// .. note::
	//
	//	To be useful in avoiding the race condition described above, this timeout must be set
	//	to *at least* <max round trip time expected between clients and Envoy>+<100ms to account for
	//	a reasonable "worst" case processing time for a full iteration of Envoy's event loop>.
	//
	// .. warning::
	//
	//	A value of “0“ will completely disable delayed close processing. When disabled, the downstream
	//	connection's socket will be closed immediately after the write flush is completed or will
	//	never close if the write flush does not complete.
	DelayedCloseTimeout *durationpb.Duration `protobuf:"bytes,26,opt,name=delayed_close_timeout,json=delayedCloseTimeout,proto3" json:"delayed_close_timeout,omitempty"`
	// Configuration for :ref:`HTTP access logs <arch_overview_access_logs>`
	// emitted by the connection manager.
	AccessLog []*v31.AccessLog `protobuf:"bytes,13,rep,name=access_log,json=accessLog,proto3" json:"access_log,omitempty"`
	// The interval to flush the above access logs.
	//
	// .. attention::
	//
	//	This field is deprecated in favor of
	//	:ref:`access_log_flush_interval
	//	<envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.HcmAccessLogOptions.access_log_flush_interval>`.
	//	Note that if both this field and :ref:`access_log_flush_interval
	//	<envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.HcmAccessLogOptions.access_log_flush_interval>`
	//	are specified, the former (deprecated field) is ignored.
	//
	// Deprecated: Marked as deprecated in envoy/extensions/filters/network/http_connection_manager/v3/http_connection_manager.proto.
	AccessLogFlushInterval *durationpb.Duration `` /* 132-byte string literal not displayed */
	// If set to true, HCM will flush an access log once when a new HTTP request is received, after the request
	// headers have been evaluated, and before iterating through the HTTP filter chain.
	//
	// .. attention::
	//
	//	This field is deprecated in favor of
	//	:ref:`flush_access_log_on_new_request
	//	<envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.HcmAccessLogOptions.flush_access_log_on_new_request>`.
	//	Note that if both this field and :ref:`flush_access_log_on_new_request
	//	<envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.HcmAccessLogOptions.flush_access_log_on_new_request>`
	//	are specified, the former (deprecated field) is ignored.
	//
	// Deprecated: Marked as deprecated in envoy/extensions/filters/network/http_connection_manager/v3/http_connection_manager.proto.
	FlushAccessLogOnNewRequest bool `` /* 149-byte string literal not displayed */
	// Additional access log options for HTTP connection manager.
	AccessLogOptions *HttpConnectionManager_HcmAccessLogOptions `protobuf:"bytes,56,opt,name=access_log_options,json=accessLogOptions,proto3" json:"access_log_options,omitempty"`
	// If set to true, the connection manager will use the real remote address
	// of the client connection when determining internal versus external origin and manipulating
	// various headers. If set to false or absent, the connection manager will use the
	// :ref:`config_http_conn_man_headers_x-forwarded-for` HTTP header. See the documentation for
	// :ref:`config_http_conn_man_headers_x-forwarded-for`,
	// :ref:`config_http_conn_man_headers_x-envoy-internal`, and
	// :ref:`config_http_conn_man_headers_x-envoy-external-address` for more information.
	UseRemoteAddress *wrapperspb.BoolValue `protobuf:"bytes,14,opt,name=use_remote_address,json=useRemoteAddress,proto3" json:"use_remote_address,omitempty"`
	// The number of additional ingress proxy hops from the right side of the
	// :ref:`config_http_conn_man_headers_x-forwarded-for` HTTP header to trust when
	// determining the origin client's IP address. The default is zero if this option
	// is not specified. See the documentation for
	// :ref:`config_http_conn_man_headers_x-forwarded-for` for more information.
	XffNumTrustedHops uint32 `protobuf:"varint,19,opt,name=xff_num_trusted_hops,json=xffNumTrustedHops,proto3" json:"xff_num_trusted_hops,omitempty"`
	// Configuration for original IP detection extensions.
	//
	// When these extensions are configured, Envoy will invoke them with the incoming request headers and
	// details about the downstream connection, including the directly connected address. Each extension uses
	// this information to determine the effective remote IP address for the request. If an extension cannot
	// identify the original IP address and isn't set to reject the request, Envoy will sequentially attempt
	// the remaining extensions until one successfully determines the IP or explicitly rejects the request.
	// If all extensions fail without rejection, Envoy defaults to using the directly connected remote address.
	//
	// .. warning::
	//
	//	These extensions cannot be configured simultaneously with :ref:`use_remote_address
	//	<envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.use_remote_address>`
	//	or :ref:`xff_num_trusted_hops
	//	<envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.xff_num_trusted_hops>`.
	//
	// [#extension-category: envoy.http.original_ip_detection]
	OriginalIpDetectionExtensions []*v3.TypedExtensionConfig `` /* 153-byte string literal not displayed */
	// The configuration for the early header mutation extensions.
	//
	// When configured the extensions will be called before any routing, tracing, or any filter processing.
	// Each extension will be applied in the order they are configured.
	// If the same header is mutated by multiple extensions, then the last extension will win.
	//
	// [#extension-category: envoy.http.early_header_mutation]
	EarlyHeaderMutationExtensions []*v3.TypedExtensionConfig `` /* 153-byte string literal not displayed */
	// Configures what network addresses are considered internal for stats and header sanitation
	// purposes. If unspecified, only RFC1918 IP addresses will be considered internal.
	// See the documentation for :ref:`config_http_conn_man_headers_x-envoy-internal` for more
	// information about internal/external addresses.
	//
	// .. warning::
	//
	//	As of Envoy 1.33.0 no IP addresses will be considered trusted. If you have tooling such as probes
	//	on your private network which need to be treated as trusted (e.g. changing arbitrary x-envoy headers)
	//	you will have to manually include those addresses or CIDR ranges like:
	//
	// .. validated-code-block:: yaml
	//
	//	:type-name: envoy.extensions.filters.network.http_connection_manager.v3.InternalAddressConfig
	//
	//	cidr_ranges:
	//	    address_prefix: 10.0.0.0
	//	    prefix_len: 8
	//	cidr_ranges:
	//	    address_prefix: 192.168.0.0
	//	    prefix_len: 16
	//	cidr_ranges:
	//	    address_prefix: 172.16.0.0
	//	    prefix_len: 12
	//	cidr_ranges:
	//	    address_prefix: 127.0.0.1
	//	    prefix_len: 32
	//	cidr_ranges:
	//	    address_prefix: fd00::
	//	    prefix_len: 8
	//	cidr_ranges:
	//	    address_prefix: ::1
	//	    prefix_len: 128
	InternalAddressConfig *HttpConnectionManager_InternalAddressConfig `` /* 127-byte string literal not displayed */
	// If set, Envoy will not append the remote address to the
	// :ref:`config_http_conn_man_headers_x-forwarded-for` HTTP header. This may be used in
	// conjunction with HTTP filters that explicitly manipulate XFF after the HTTP connection manager
	// has mutated the request headers. While :ref:`use_remote_address
	// <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.use_remote_address>`
	// will also suppress XFF addition, it has consequences for logging and other
	// Envoy uses of the remote address, so “skip_xff_append“ should be used
	// when only an elision of XFF addition is intended.
	SkipXffAppend bool `protobuf:"varint,21,opt,name=skip_xff_append,json=skipXffAppend,proto3" json:"skip_xff_append,omitempty"`
	// Via header value to append to request and response headers. If this is
	// empty, no via header will be appended.
	Via string `protobuf:"bytes,22,opt,name=via,proto3" json:"via,omitempty"`
	// Whether the connection manager will generate the :ref:`x-request-id
	// <config_http_conn_man_headers_x-request-id>` header if it does not exist. This defaults to
	// true. Generating a random UUID4 is expensive so in high throughput scenarios where this feature
	// is not desired it can be disabled.
	GenerateRequestId *wrapperspb.BoolValue `protobuf:"bytes,15,opt,name=generate_request_id,json=generateRequestId,proto3" json:"generate_request_id,omitempty"`
	// Whether the connection manager will keep the :ref:`x-request-id
	// <config_http_conn_man_headers_x-request-id>` header if passed for a request that is edge
	// (Edge request is the request from external clients to front Envoy) and not reset it, which
	// is the current Envoy behaviour. This defaults to false.
	PreserveExternalRequestId bool `` /* 142-byte string literal not displayed */
	// If set, Envoy will always set :ref:`x-request-id <config_http_conn_man_headers_x-request-id>` header in response.
	// If this is false or not set, the request ID is returned in responses only if tracing is forced using
	// :ref:`x-envoy-force-trace <config_http_conn_man_headers_x-envoy-force-trace>` header.
	AlwaysSetRequestIdInResponse bool `` /* 155-byte string literal not displayed */
	// How to handle the :ref:`config_http_conn_man_headers_x-forwarded-client-cert` (XFCC) HTTP
	// header.
	ForwardClientCertDetails HttpConnectionManager_ForwardClientCertDetails `` /* 251-byte string literal not displayed */
	// This field is valid only when :ref:`forward_client_cert_details
	// <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.forward_client_cert_details>`
	// is APPEND_FORWARD or SANITIZE_SET and the client connection is mTLS. It specifies the fields in
	// the client certificate to be forwarded. Note that in the
	// :ref:`config_http_conn_man_headers_x-forwarded-client-cert` header, “Hash“ is always set, and
	// “By“ is always set when the client certificate presents the URI type Subject Alternative Name
	// value.
	SetCurrentClientCertDetails *HttpConnectionManager_SetCurrentClientCertDetails `` /* 149-byte string literal not displayed */
	// The matcher for forwarding client cert details. This allows per-request configuration
	// of forward client cert behavior based on request properties. If a matcher is configured
	// and matches a request, the matched action's forward client cert config will be used.
	// If the matcher is not configured or doesn't match, the static
	// :ref:`forward_client_cert_details
	// <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.forward_client_cert_details>`
	// and
	// :ref:`set_current_client_cert_details
	// <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.set_current_client_cert_details>`
	// config will be used as fallback.
	//
	// Example: If the x-forwarded-client-cert header contains "trusted-client", use APPEND_FORWARD,
	// otherwise use SANITIZE_SET:
	//
	// .. code-block:: yaml
	//
	//	forward_client_cert_matcher:
	//	  matcher_list:
	//	    matchers:
	//	    - predicate:
	//	        single_predicate:
	//	          input:
	//	            name: envoy.matching.inputs.request_headers
	//	            typed_config:
	//	              "@type": type.googleapis.com/envoy.type.matcher.v3.HttpRequestHeaderMatchInput
	//	              header_name: "x-forwarded-client-cert"
	//	          value_match:
	//	            string_match:
	//	              contains: "trusted-client"
	//	      on_match:
	//	        action:
	//	          name: forward_client_cert
	//	          typed_config:
	//	            "@type": type.googleapis.com/envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.ForwardClientCertConfig
	//	            forward_client_cert_details: APPEND_FORWARD
	//	            set_current_client_cert_details:
	//	              uri: true
	//	  on_no_match:
	//	    action:
	//	      name: forward_client_cert
	//	      typed_config:
	//	        "@type": type.googleapis.com/envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.ForwardClientCertConfig
	//	        forward_client_cert_details: SANITIZE_SET
	//	        set_current_client_cert_details:
	//	          uri: true
	ForwardClientCertMatcher *v32.Matcher `` /* 138-byte string literal not displayed */
	// If proxy_100_continue is true, Envoy will proxy incoming "Expect:
	// 100-continue" headers upstream, and forward "100 Continue" responses
	// downstream. If this is false or not set, Envoy will instead strip the
	// "Expect: 100-continue" header, and send a "100 Continue" response itself.
	Proxy_100Continue bool `protobuf:"varint,18,opt,name=proxy_100_continue,json=proxy100Continue,proto3" json:"proxy_100_continue,omitempty"`
	// If
	// :ref:`use_remote_address
	// <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.use_remote_address>`
	// is true and represent_ipv4_remote_address_as_ipv4_mapped_ipv6 is true and the remote address is
	// an IPv4 address, the address will be mapped to IPv6 before it is appended to “x-forwarded-for“.
	// This is useful for testing compatibility of upstream services that parse the header value. For
	// example, 50.0.0.1 is represented as ::FFFF:50.0.0.1. See `IPv4-Mapped IPv6 Addresses
	// <https://tools.ietf.org/html/rfc4291#section-2.5.5.2>`_ for details. This will also affect the
	// :ref:`config_http_conn_man_headers_x-envoy-external-address` header. See
	// :ref:`http_connection_manager.represent_ipv4_remote_address_as_ipv4_mapped_ipv6
	// <config_http_conn_man_runtime_represent_ipv4_remote_address_as_ipv4_mapped_ipv6>` for runtime
	// control.
	// [#not-implemented-hide:]
	RepresentIpv4RemoteAddressAsIpv4MappedIpv6 bool                                   `` /* 201-byte string literal not displayed */
	UpgradeConfigs                             []*HttpConnectionManager_UpgradeConfig `protobuf:"bytes,23,rep,name=upgrade_configs,json=upgradeConfigs,proto3" json:"upgrade_configs,omitempty"`
	// Should paths be normalized according to RFC 3986 before any processing of
	// requests by HTTP filters or routing? This affects the upstream “:path“ header
	// as well. For paths that fail this check, Envoy will respond with 400 to
	// paths that are malformed. This defaults to false currently but will default
	// true in the future. When not specified, this value may be overridden by the
	// runtime variable
	// :ref:`http_connection_manager.normalize_path<config_http_conn_man_runtime_normalize_path>`.
	// See `Normalization and Comparison <https://tools.ietf.org/html/rfc3986#section-6>`_
	// for details of normalization.
	// Note that Envoy does not perform
	// `case normalization <https://tools.ietf.org/html/rfc3986#section-6.2.2.1>`_
	// [#comment:TODO: This field is ignored when the
	// :ref:`header validation configuration <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.typed_header_validation_config>`
	// is present.]
	NormalizePath *wrapperspb.BoolValue `protobuf:"bytes,30,opt,name=normalize_path,json=normalizePath,proto3" json:"normalize_path,omitempty"`
	// Determines if adjacent slashes in the path are merged into one before any processing of
	// requests by HTTP filters or routing. This affects the upstream “:path“ header as well. Without
	// setting this option, incoming requests with path “//dir///file“ will not match against route
	// with “prefix“ match set to “/dir“. Defaults to “false“. Note that slash merging is not part of
	// `HTTP spec <https://tools.ietf.org/html/rfc3986>`_ and is provided for convenience.
	// [#comment:TODO: This field is ignored when the
	// :ref:`header validation configuration <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.typed_header_validation_config>`
	// is present.]
	MergeSlashes bool `protobuf:"varint,33,opt,name=merge_slashes,json=mergeSlashes,proto3" json:"merge_slashes,omitempty"`
	// Action to take when request URL path contains escaped slash sequences (%2F, %2f, %5C and %5c).
	// The default value can be overridden by the :ref:`http_connection_manager.path_with_escaped_slashes_action<config_http_conn_man_runtime_path_with_escaped_slashes_action>`
	// runtime variable.
	// The :ref:`http_connection_manager.path_with_escaped_slashes_action_sampling<config_http_conn_man_runtime_path_with_escaped_slashes_action_enabled>` runtime
	// variable can be used to apply the action to a portion of all requests.
	// [#comment:TODO: This field is ignored when the
	// :ref:`header validation configuration <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.typed_header_validation_config>`
	// is present.]
	PathWithEscapedSlashesAction HttpConnectionManager_PathWithEscapedSlashesAction `` /* 269-byte string literal not displayed */
	// The configuration of the request ID extension. This includes operations such as
	// generation, validation, and associated tracing operations. If empty, the
	// :ref:`UuidRequestIdConfig <envoy_v3_api_msg_extensions.request_id.uuid.v3.UuidRequestIdConfig>`
	// default extension is used with default parameters. See the documentation for that extension
	// for details on what it does. Customizing the configuration for the default extension can be
	// achieved by configuring it explicitly here. For example, to disable trace reason packing,
	// the following configuration can be used:
	//
	// .. validated-code-block:: yaml
	//
	//	:type-name: envoy.extensions.filters.network.http_connection_manager.v3.RequestIDExtension
	//
	//	typed_config:
	//	  "@type": type.googleapis.com/envoy.extensions.request_id.uuid.v3.UuidRequestIdConfig
	//	  pack_trace_reason: false
	//
	// [#extension-category: envoy.request_id]
	RequestIdExtension *RequestIDExtension `protobuf:"bytes,36,opt,name=request_id_extension,json=requestIdExtension,proto3" json:"request_id_extension,omitempty"`
	// The configuration to customize local reply returned by Envoy. It can customize status code,
	// body text and response content type. If not specified, status code and text body are hard
	// coded in Envoy, the response content type is plain text.
	LocalReplyConfig *LocalReplyConfig `protobuf:"bytes,38,opt,name=local_reply_config,json=localReplyConfig,proto3" json:"local_reply_config,omitempty"`
	// Determines if the port part should be removed from host/authority header before any processing
	// of request by HTTP filters or routing. The port would be removed only if it is equal to the :ref:`listener's<envoy_v3_api_field_config.listener.v3.Listener.address>`
	// local port. This affects the upstream host header unless the method is
	// CONNECT in which case if no filter adds a port the original port will be restored before headers are
	// sent upstream.
	// Without setting this option, incoming requests with host “example:443“ will not match against
	// route with :ref:`domains<envoy_v3_api_field_config.route.v3.VirtualHost.domains>` match set to “example“. Defaults to “false“. Note that port removal is not part
	// of `HTTP spec <https://tools.ietf.org/html/rfc3986>`_ and is provided for convenience.
	// Only one of “strip_matching_host_port“ or “strip_any_host_port“ can be set.
	StripMatchingHostPort bool `` /* 130-byte string literal not displayed */
	// Types that are valid to be assigned to StripPortMode:
	//
	//	*HttpConnectionManager_StripAnyHostPort
	StripPortMode isHttpConnectionManager_StripPortMode `protobuf_oneof:"strip_port_mode"`
	// Governs Envoy's behavior when receiving invalid HTTP from downstream.
	// If this option is false (default), Envoy will err on the conservative side handling HTTP
	// errors, terminating both HTTP/1.1 and HTTP/2 connections when receiving an invalid request.
	// If this option is set to true, Envoy will be more permissive, only resetting the invalid
	// stream in the case of HTTP/2 and leaving the connection open where possible (if the entire
	// request is read for HTTP/1.1)
	// In general this should be true for deployments receiving trusted traffic (L2 Envoys,
	// company-internal mesh) and false when receiving untrusted traffic (edge deployments).
	//
	// If different behaviors for invalid_http_message for HTTP/1 and HTTP/2 are
	// desired, one should use the new HTTP/1 option :ref:`override_stream_error_on_invalid_http_message
	// <envoy_v3_api_field_config.core.v3.Http1ProtocolOptions.override_stream_error_on_invalid_http_message>` or the new HTTP/2 option
	// :ref:`override_stream_error_on_invalid_http_message
	// <envoy_v3_api_field_config.core.v3.Http2ProtocolOptions.override_stream_error_on_invalid_http_message>`
	// “not“ the deprecated but similarly named :ref:`stream_error_on_invalid_http_messaging
	// <envoy_v3_api_field_config.core.v3.Http2ProtocolOptions.stream_error_on_invalid_http_messaging>`
	StreamErrorOnInvalidHttpMessage *wrapperspb.BoolValue `` /* 163-byte string literal not displayed */
	// [#not-implemented-hide:] Path normalization configuration. This includes
	// configurations for transformations (e.g. RFC 3986 normalization or merge
	// adjacent slashes) and the policy to apply them. The policy determines
	// whether transformations affect the forwarded “:path“ header. RFC 3986 path
	// normalization is enabled by default and the default policy is that the
	// normalized header will be forwarded. See :ref:`PathNormalizationOptions
	// <envoy_v3_api_msg_extensions.filters.network.http_connection_manager.v3.PathNormalizationOptions>`
	// for details.
	PathNormalizationOptions *HttpConnectionManager_PathNormalizationOptions `` /* 136-byte string literal not displayed */
	// Determines if trailing dot of the host should be removed from host/authority header before any
	// processing of request by HTTP filters or routing.
	// This affects the upstream host header.
	// Without setting this option, incoming requests with host “example.com.“ will not match against
	// route with :ref:`domains<envoy_v3_api_field_config.route.v3.VirtualHost.domains>` match set to “example.com“. Defaults to “false“.
	// When the incoming request contains a host/authority header that includes a port number,
	// setting this option will strip a trailing dot, if present, from the host section,
	// leaving the port as is (e.g. host value “example.com.:443“ will be updated to “example.com:443“).
	StripTrailingHostDot bool `` /* 127-byte string literal not displayed */
	// Proxy-Status HTTP response header configuration.
	// If this config is set, the Proxy-Status HTTP response header field is
	// populated. By default, it is not.
	ProxyStatusConfig *HttpConnectionManager_ProxyStatusConfig `protobuf:"bytes,49,opt,name=proxy_status_config,json=proxyStatusConfig,proto3" json:"proxy_status_config,omitempty"`
	// Configuration options for Header Validation (UHV).
	// UHV is an extensible mechanism for checking validity of HTTP requests as well as providing
	// normalization for request attributes, such as URI path.
	// If the typed_header_validation_config is present it overrides the following options:
	// “normalize_path“, “merge_slashes“, “path_with_escaped_slashes_action“
	// “http_protocol_options.allow_chunked_length“, “common_http_protocol_options.headers_with_underscores_action“.
	//
	// The default UHV checks the following:
	//
	// #. HTTP/1 header map validity according to `RFC 7230 section 3.2<https://datatracker.ietf.org/doc/html/rfc7230#section-3.2>`_
	// #. Syntax of HTTP/1 request target URI and response status
	// #. HTTP/2 header map validity according to `RFC 7540 section 8.1.2<https://datatracker.ietf.org/doc/html/rfc7540#section-8.1.2`_
	// #. Syntax of HTTP/2 pseudo headers
	// #. HTTP/3 header map validity according to `RFC 9114 section 4.3 <https://www.rfc-editor.org/rfc/rfc9114.html>`_
	// #. Syntax of HTTP/3 pseudo headers
	// #. Syntax of “Content-Length“ and “Transfer-Encoding“
	// #. Validation of HTTP/1 requests with both “Content-Length“ and “Transfer-Encoding“ headers
	// #. Normalization of the URI path according to `Normalization and Comparison <https://datatracker.ietf.org/doc/html/rfc3986#section-6>`_
	//
	//	without `case normalization <https://datatracker.ietf.org/doc/html/rfc3986#section-6.2.2.1>`_
	//
	// [#not-implemented-hide:]
	// [#extension-category: envoy.http.header_validators]
	TypedHeaderValidationConfig *v3.TypedExtensionConfig `` /* 147-byte string literal not displayed */
	// Append the “x-forwarded-port“ header with the port value client used to connect to Envoy. It
	// will be ignored if the “x-forwarded-port“ header has been set by any trusted proxy in front of Envoy.
	AppendXForwardedPort bool `` /* 127-byte string literal not displayed */
	// Append the :ref:`config_http_conn_man_headers_x-envoy-local-overloaded` HTTP header in the scenario where
	// the Overload Manager has been triggered.
	AppendLocalOverload bool `protobuf:"varint,57,opt,name=append_local_overload,json=appendLocalOverload,proto3" json:"append_local_overload,omitempty"`
	// Whether the HCM will add ProxyProtocolFilterState to the Connection lifetime filter state. Defaults to “true“.
	// This should be set to “false“ in cases where Envoy's view of the downstream address may not correspond to the
	// actual client address, for example, if there's another proxy in front of the Envoy.
	AddProxyProtocolConnectionState *wrapperspb.BoolValue `` /* 161-byte string literal not displayed */
	// contains filtered or unexported fields
}

[#next-free-field: 61]

func (*HttpConnectionManager) ClearAccessLogFlushInterval deprecated 

func (x *HttpConnectionManager) ClearAccessLogFlushInterval()

Deprecated: Marked as deprecated in envoy/extensions/filters/network/http_connection_manager/v3/http_connection_manager.proto.

func (*HttpConnectionManager) ClearAccessLogOptions 

func (x *HttpConnectionManager) ClearAccessLogOptions()

func (*HttpConnectionManager) ClearAddProxyProtocolConnectionState 

func (x *HttpConnectionManager) ClearAddProxyProtocolConnectionState()

func (*HttpConnectionManager) ClearAddUserAgent 

func (x *HttpConnectionManager) ClearAddUserAgent()

func (*HttpConnectionManager) ClearCommonHttpProtocolOptions 

func (x *HttpConnectionManager) ClearCommonHttpProtocolOptions()

func (*HttpConnectionManager) ClearDelayedCloseTimeout 

func (x *HttpConnectionManager) ClearDelayedCloseTimeout()

func (*HttpConnectionManager) ClearDrainTimeout 

func (x *HttpConnectionManager) ClearDrainTimeout()

func (*HttpConnectionManager) ClearForwardClientCertMatcher 

func (x *HttpConnectionManager) ClearForwardClientCertMatcher()

func (*HttpConnectionManager) ClearGenerateRequestId 

func (x *HttpConnectionManager) ClearGenerateRequestId()

func (*HttpConnectionManager) ClearHttp2ProtocolOptions 

func (x *HttpConnectionManager) ClearHttp2ProtocolOptions()

func (*HttpConnectionManager) ClearHttp3ProtocolOptions 

func (x *HttpConnectionManager) ClearHttp3ProtocolOptions()

func (*HttpConnectionManager) ClearHttpProtocolOptions 

func (x *HttpConnectionManager) ClearHttpProtocolOptions()

func (*HttpConnectionManager) ClearInternalAddressConfig 

func (x *HttpConnectionManager) ClearInternalAddressConfig()

func (*HttpConnectionManager) ClearLocalReplyConfig 

func (x *HttpConnectionManager) ClearLocalReplyConfig()

func (*HttpConnectionManager) ClearMaxRequestHeadersKb 

func (x *HttpConnectionManager) ClearMaxRequestHeadersKb()

func (*HttpConnectionManager) ClearNormalizePath 

func (x *HttpConnectionManager) ClearNormalizePath()

func (*HttpConnectionManager) ClearPathNormalizationOptions 

func (x *HttpConnectionManager) ClearPathNormalizationOptions()

func (*HttpConnectionManager) ClearProxyStatusConfig 

func (x *HttpConnectionManager) ClearProxyStatusConfig()

func (*HttpConnectionManager) ClearRds 

func (x *HttpConnectionManager) ClearRds()

func (*HttpConnectionManager) ClearRequestHeadersTimeout 

func (x *HttpConnectionManager) ClearRequestHeadersTimeout()

func (*HttpConnectionManager) ClearRequestIdExtension 

func (x *HttpConnectionManager) ClearRequestIdExtension()

func (*HttpConnectionManager) ClearRequestTimeout 

func (x *HttpConnectionManager) ClearRequestTimeout()

func (*HttpConnectionManager) ClearRouteConfig 

func (x *HttpConnectionManager) ClearRouteConfig()

func (*HttpConnectionManager) ClearRouteSpecifier 

func (x *HttpConnectionManager) ClearRouteSpecifier()

func (*HttpConnectionManager) ClearSchemeHeaderTransformation 

func (x *HttpConnectionManager) ClearSchemeHeaderTransformation()

func (*HttpConnectionManager) ClearScopedRoutes 

func (x *HttpConnectionManager) ClearScopedRoutes()

func (*HttpConnectionManager) ClearSetCurrentClientCertDetails 

func (x *HttpConnectionManager) ClearSetCurrentClientCertDetails()

func (*HttpConnectionManager) ClearStreamErrorOnInvalidHttpMessage 

func (x *HttpConnectionManager) ClearStreamErrorOnInvalidHttpMessage()

func (*HttpConnectionManager) ClearStreamFlushTimeout 

func (x *HttpConnectionManager) ClearStreamFlushTimeout()

func (*HttpConnectionManager) ClearStreamIdleTimeout 

func (x *HttpConnectionManager) ClearStreamIdleTimeout()

func (*HttpConnectionManager) ClearStripAnyHostPort 

func (x *HttpConnectionManager) ClearStripAnyHostPort()

func (*HttpConnectionManager) ClearStripPortMode 

func (x *HttpConnectionManager) ClearStripPortMode()

func (*HttpConnectionManager) ClearTracing 

func (x *HttpConnectionManager) ClearTracing()

func (*HttpConnectionManager) ClearTypedHeaderValidationConfig 

func (x *HttpConnectionManager) ClearTypedHeaderValidationConfig()

func (*HttpConnectionManager) ClearUseRemoteAddress 

func (x *HttpConnectionManager) ClearUseRemoteAddress()

func (*HttpConnectionManager) GetAccessLog 

func (x *HttpConnectionManager) GetAccessLog() []*v31.AccessLog

func (*HttpConnectionManager) GetAccessLogFlushInterval deprecated 

func (x *HttpConnectionManager) GetAccessLogFlushInterval() *durationpb.Duration

Deprecated: Marked as deprecated in envoy/extensions/filters/network/http_connection_manager/v3/http_connection_manager.proto.

func (*HttpConnectionManager) GetAccessLogOptions 

func (x *HttpConnectionManager) GetAccessLogOptions() *HttpConnectionManager_HcmAccessLogOptions

func (*HttpConnectionManager) GetAddProxyProtocolConnectionState 

func (x *HttpConnectionManager) GetAddProxyProtocolConnectionState() *wrapperspb.BoolValue

func (*HttpConnectionManager) GetAddUserAgent 

func (x *HttpConnectionManager) GetAddUserAgent() *wrapperspb.BoolValue

func (*HttpConnectionManager) GetAlwaysSetRequestIdInResponse 

func (x *HttpConnectionManager) GetAlwaysSetRequestIdInResponse() bool

func (*HttpConnectionManager) GetAppendLocalOverload 

func (x *HttpConnectionManager) GetAppendLocalOverload() bool

func (*HttpConnectionManager) GetAppendXForwardedPort 

func (x *HttpConnectionManager) GetAppendXForwardedPort() bool

func (*HttpConnectionManager) GetCodecType 

func (x *HttpConnectionManager) GetCodecType() HttpConnectionManager_CodecType

func (*HttpConnectionManager) GetCommonHttpProtocolOptions 

func (x *HttpConnectionManager) GetCommonHttpProtocolOptions() *v3.HttpProtocolOptions

func (*HttpConnectionManager) GetDelayedCloseTimeout 

func (x *HttpConnectionManager) GetDelayedCloseTimeout() *durationpb.Duration

func (*HttpConnectionManager) GetDrainTimeout 

func (x *HttpConnectionManager) GetDrainTimeout() *durationpb.Duration

func (*HttpConnectionManager) GetEarlyHeaderMutationExtensions 

func (x *HttpConnectionManager) GetEarlyHeaderMutationExtensions() []*v3.TypedExtensionConfig

func (*HttpConnectionManager) GetFlushAccessLogOnNewRequest deprecated 

func (x *HttpConnectionManager) GetFlushAccessLogOnNewRequest() bool

Deprecated: Marked as deprecated in envoy/extensions/filters/network/http_connection_manager/v3/http_connection_manager.proto.

func (*HttpConnectionManager) GetForwardClientCertDetails 

func (x *HttpConnectionManager) GetForwardClientCertDetails() HttpConnectionManager_ForwardClientCertDetails

func (*HttpConnectionManager) GetForwardClientCertMatcher 

func (x *HttpConnectionManager) GetForwardClientCertMatcher() *v32.Matcher

func (*HttpConnectionManager) GetGenerateRequestId 

func (x *HttpConnectionManager) GetGenerateRequestId() *wrapperspb.BoolValue

func (*HttpConnectionManager) GetHttp1SafeMaxConnectionDuration 

func (x *HttpConnectionManager) GetHttp1SafeMaxConnectionDuration() bool

func (*HttpConnectionManager) GetHttp2ProtocolOptions 

func (x *HttpConnectionManager) GetHttp2ProtocolOptions() *v3.Http2ProtocolOptions

func (*HttpConnectionManager) GetHttp3ProtocolOptions 

func (x *HttpConnectionManager) GetHttp3ProtocolOptions() *v3.Http3ProtocolOptions

func (*HttpConnectionManager) GetHttpFilters 

func (x *HttpConnectionManager) GetHttpFilters() []*HttpFilter

func (*HttpConnectionManager) GetHttpProtocolOptions 

func (x *HttpConnectionManager) GetHttpProtocolOptions() *v3.Http1ProtocolOptions

func (*HttpConnectionManager) GetInternalAddressConfig 

func (x *HttpConnectionManager) GetInternalAddressConfig() *HttpConnectionManager_InternalAddressConfig

func (*HttpConnectionManager) GetLocalReplyConfig 

func (x *HttpConnectionManager) GetLocalReplyConfig() *LocalReplyConfig

func (*HttpConnectionManager) GetMaxRequestHeadersKb 

func (x *HttpConnectionManager) GetMaxRequestHeadersKb() *wrapperspb.UInt32Value

func (*HttpConnectionManager) GetMergeSlashes 

func (x *HttpConnectionManager) GetMergeSlashes() bool

func (*HttpConnectionManager) GetNormalizePath 

func (x *HttpConnectionManager) GetNormalizePath() *wrapperspb.BoolValue

func (*HttpConnectionManager) GetOriginalIpDetectionExtensions 

func (x *HttpConnectionManager) GetOriginalIpDetectionExtensions() []*v3.TypedExtensionConfig

func (*HttpConnectionManager) GetPathNormalizationOptions 

func (x *HttpConnectionManager) GetPathNormalizationOptions() *HttpConnectionManager_PathNormalizationOptions

func (*HttpConnectionManager) GetPathWithEscapedSlashesAction 

func (x *HttpConnectionManager) GetPathWithEscapedSlashesAction() HttpConnectionManager_PathWithEscapedSlashesAction

func (*HttpConnectionManager) GetPreserveExternalRequestId 

func (x *HttpConnectionManager) GetPreserveExternalRequestId() bool

func (*HttpConnectionManager) GetProxyStatusConfig 

func (x *HttpConnectionManager) GetProxyStatusConfig() *HttpConnectionManager_ProxyStatusConfig

func (*HttpConnectionManager) GetProxy_100Continue 

func (x *HttpConnectionManager) GetProxy_100Continue() bool

func (*HttpConnectionManager) GetRds 

func (x *HttpConnectionManager) GetRds() *Rds

func (*HttpConnectionManager) GetRepresentIpv4RemoteAddressAsIpv4MappedIpv6 

func (x *HttpConnectionManager) GetRepresentIpv4RemoteAddressAsIpv4MappedIpv6() bool

func (*HttpConnectionManager) GetRequestHeadersTimeout 

func (x *HttpConnectionManager) GetRequestHeadersTimeout() *durationpb.Duration

func (*HttpConnectionManager) GetRequestIdExtension 

func (x *HttpConnectionManager) GetRequestIdExtension() *RequestIDExtension

func (*HttpConnectionManager) GetRequestTimeout 

func (x *HttpConnectionManager) GetRequestTimeout() *durationpb.Duration

func (*HttpConnectionManager) GetRouteConfig 

func (x *HttpConnectionManager) GetRouteConfig() *v33.RouteConfiguration

func (*HttpConnectionManager) GetRouteSpecifier 

func (x *HttpConnectionManager) GetRouteSpecifier() isHttpConnectionManager_RouteSpecifier

func (*HttpConnectionManager) GetSchemeHeaderTransformation 

func (x *HttpConnectionManager) GetSchemeHeaderTransformation() *v3.SchemeHeaderTransformation

func (*HttpConnectionManager) GetScopedRoutes 

func (x *HttpConnectionManager) GetScopedRoutes() *ScopedRoutes

func (*HttpConnectionManager) GetServerHeaderTransformation 

func (x *HttpConnectionManager) GetServerHeaderTransformation() HttpConnectionManager_ServerHeaderTransformation

func (*HttpConnectionManager) GetServerName 

func (x *HttpConnectionManager) GetServerName() string

func (*HttpConnectionManager) GetSetCurrentClientCertDetails 

func (x *HttpConnectionManager) GetSetCurrentClientCertDetails() *HttpConnectionManager_SetCurrentClientCertDetails

func (*HttpConnectionManager) GetSkipXffAppend 

func (x *HttpConnectionManager) GetSkipXffAppend() bool

func (*HttpConnectionManager) GetStatPrefix 

func (x *HttpConnectionManager) GetStatPrefix() string

func (*HttpConnectionManager) GetStreamErrorOnInvalidHttpMessage 

func (x *HttpConnectionManager) GetStreamErrorOnInvalidHttpMessage() *wrapperspb.BoolValue

func (*HttpConnectionManager) GetStreamFlushTimeout 

func (x *HttpConnectionManager) GetStreamFlushTimeout() *durationpb.Duration

func (*HttpConnectionManager) GetStreamIdleTimeout 

func (x *HttpConnectionManager) GetStreamIdleTimeout() *durationpb.Duration

func (*HttpConnectionManager) GetStripAnyHostPort 

func (x *HttpConnectionManager) GetStripAnyHostPort() bool

func (*HttpConnectionManager) GetStripMatchingHostPort 

func (x *HttpConnectionManager) GetStripMatchingHostPort() bool

func (*HttpConnectionManager) GetStripPortMode 

func (x *HttpConnectionManager) GetStripPortMode() isHttpConnectionManager_StripPortMode

func (*HttpConnectionManager) GetStripTrailingHostDot 

func (x *HttpConnectionManager) GetStripTrailingHostDot() bool

func (*HttpConnectionManager) GetTracing 

func (x *HttpConnectionManager) GetTracing() *HttpConnectionManager_Tracing

func (*HttpConnectionManager) GetTypedHeaderValidationConfig 

func (x *HttpConnectionManager) GetTypedHeaderValidationConfig() *v3.TypedExtensionConfig

func (*HttpConnectionManager) GetUpgradeConfigs 

func (x *HttpConnectionManager) GetUpgradeConfigs() []*HttpConnectionManager_UpgradeConfig

func (*HttpConnectionManager) GetUseRemoteAddress 

func (x *HttpConnectionManager) GetUseRemoteAddress() *wrapperspb.BoolValue

func (*HttpConnectionManager) GetVia 

func (x *HttpConnectionManager) GetVia() string

func (*HttpConnectionManager) GetXffNumTrustedHops 

func (x *HttpConnectionManager) GetXffNumTrustedHops() uint32

func (*HttpConnectionManager) HasAccessLogFlushInterval deprecated 

func (x *HttpConnectionManager) HasAccessLogFlushInterval() bool

Deprecated: Marked as deprecated in envoy/extensions/filters/network/http_connection_manager/v3/http_connection_manager.proto.

func (*HttpConnectionManager) HasAccessLogOptions 

func (x *HttpConnectionManager) HasAccessLogOptions() bool

func (*HttpConnectionManager) HasAddProxyProtocolConnectionState 

func (x *HttpConnectionManager) HasAddProxyProtocolConnectionState() bool

func (*HttpConnectionManager) HasAddUserAgent 

func (x *HttpConnectionManager) HasAddUserAgent() bool

func (*HttpConnectionManager) HasCommonHttpProtocolOptions 

func (x *HttpConnectionManager) HasCommonHttpProtocolOptions() bool

func (*HttpConnectionManager) HasDelayedCloseTimeout 

func (x *HttpConnectionManager) HasDelayedCloseTimeout() bool

func (*HttpConnectionManager) HasDrainTimeout 

func (x *HttpConnectionManager) HasDrainTimeout() bool

func (*HttpConnectionManager) HasForwardClientCertMatcher 

func (x *HttpConnectionManager) HasForwardClientCertMatcher() bool

func (*HttpConnectionManager) HasGenerateRequestId 

func (x *HttpConnectionManager) HasGenerateRequestId() bool

func (*HttpConnectionManager) HasHttp2ProtocolOptions 

func (x *HttpConnectionManager) HasHttp2ProtocolOptions() bool

func (*HttpConnectionManager) HasHttp3ProtocolOptions 

func (x *HttpConnectionManager) HasHttp3ProtocolOptions() bool

func (*HttpConnectionManager) HasHttpProtocolOptions 

func (x *HttpConnectionManager) HasHttpProtocolOptions() bool

func (*HttpConnectionManager) HasInternalAddressConfig 

func (x *HttpConnectionManager) HasInternalAddressConfig() bool

func (*HttpConnectionManager) HasLocalReplyConfig 

func (x *HttpConnectionManager) HasLocalReplyConfig() bool

func (*HttpConnectionManager) HasMaxRequestHeadersKb 

func (x *HttpConnectionManager) HasMaxRequestHeadersKb() bool

func (*HttpConnectionManager) HasNormalizePath 

func (x *HttpConnectionManager) HasNormalizePath() bool

func (*HttpConnectionManager) HasPathNormalizationOptions 

func (x *HttpConnectionManager) HasPathNormalizationOptions() bool

func (*HttpConnectionManager) HasProxyStatusConfig 

func (x *HttpConnectionManager) HasProxyStatusConfig() bool

func (*HttpConnectionManager) HasRds 

func (x *HttpConnectionManager) HasRds() bool

func (*HttpConnectionManager) HasRequestHeadersTimeout 

func (x *HttpConnectionManager) HasRequestHeadersTimeout() bool

func (*HttpConnectionManager) HasRequestIdExtension 

func (x *HttpConnectionManager) HasRequestIdExtension() bool

func (*HttpConnectionManager) HasRequestTimeout 

func (x *HttpConnectionManager) HasRequestTimeout() bool

func (*HttpConnectionManager) HasRouteConfig 

func (x *HttpConnectionManager) HasRouteConfig() bool

func (*HttpConnectionManager) HasRouteSpecifier 

func (x *HttpConnectionManager) HasRouteSpecifier() bool

func (*HttpConnectionManager) HasSchemeHeaderTransformation 

func (x *HttpConnectionManager) HasSchemeHeaderTransformation() bool

func (*HttpConnectionManager) HasScopedRoutes 

func (x *HttpConnectionManager) HasScopedRoutes() bool

func (*HttpConnectionManager) HasSetCurrentClientCertDetails 

func (x *HttpConnectionManager) HasSetCurrentClientCertDetails() bool

func (*HttpConnectionManager) HasStreamErrorOnInvalidHttpMessage 

func (x *HttpConnectionManager) HasStreamErrorOnInvalidHttpMessage() bool

func (*HttpConnectionManager) HasStreamFlushTimeout 

func (x *HttpConnectionManager) HasStreamFlushTimeout() bool

func (*HttpConnectionManager) HasStreamIdleTimeout 

func (x *HttpConnectionManager) HasStreamIdleTimeout() bool

func (*HttpConnectionManager) HasStripAnyHostPort 

func (x *HttpConnectionManager) HasStripAnyHostPort() bool

func (*HttpConnectionManager) HasStripPortMode 

func (x *HttpConnectionManager) HasStripPortMode() bool

func (*HttpConnectionManager) HasTracing 

func (x *HttpConnectionManager) HasTracing() bool

func (*HttpConnectionManager) HasTypedHeaderValidationConfig 

func (x *HttpConnectionManager) HasTypedHeaderValidationConfig() bool

func (*HttpConnectionManager) HasUseRemoteAddress 

func (x *HttpConnectionManager) HasUseRemoteAddress() bool

func (*HttpConnectionManager) ProtoMessage 

func (*HttpConnectionManager) ProtoMessage()

func (*HttpConnectionManager) ProtoReflect 

func (x *HttpConnectionManager) ProtoReflect() protoreflect.Message

func (*HttpConnectionManager) Reset 

func (x *HttpConnectionManager) Reset()

func (*HttpConnectionManager) SetAccessLog 

func (x *HttpConnectionManager) SetAccessLog(v []*v31.AccessLog)

func (*HttpConnectionManager) SetAccessLogFlushInterval deprecated 

func (x *HttpConnectionManager) SetAccessLogFlushInterval(v *durationpb.Duration)

Deprecated: Marked as deprecated in envoy/extensions/filters/network/http_connection_manager/v3/http_connection_manager.proto.

func (*HttpConnectionManager) SetAccessLogOptions 

func (x *HttpConnectionManager) SetAccessLogOptions(v *HttpConnectionManager_HcmAccessLogOptions)

func (*HttpConnectionManager) SetAddProxyProtocolConnectionState 

func (x *HttpConnectionManager) SetAddProxyProtocolConnectionState(v *wrapperspb.BoolValue)

func (*HttpConnectionManager) SetAddUserAgent 

func (x *HttpConnectionManager) SetAddUserAgent(v *wrapperspb.BoolValue)

func (*HttpConnectionManager) SetAlwaysSetRequestIdInResponse 

func (x *HttpConnectionManager) SetAlwaysSetRequestIdInResponse(v bool)

func (*HttpConnectionManager) SetAppendLocalOverload 

func (x *HttpConnectionManager) SetAppendLocalOverload(v bool)

func (*HttpConnectionManager) SetAppendXForwardedPort 

func (x *HttpConnectionManager) SetAppendXForwardedPort(v bool)

func (*HttpConnectionManager) SetCodecType 

func (x *HttpConnectionManager) SetCodecType(v HttpConnectionManager_CodecType)

func (*HttpConnectionManager) SetCommonHttpProtocolOptions 

func (x *HttpConnectionManager) SetCommonHttpProtocolOptions(v *v3.HttpProtocolOptions)

func (*HttpConnectionManager) SetDelayedCloseTimeout 

func (x *HttpConnectionManager) SetDelayedCloseTimeout(v *durationpb.Duration)

func (*HttpConnectionManager) SetDrainTimeout 

func (x *HttpConnectionManager) SetDrainTimeout(v *durationpb.Duration)

func (*HttpConnectionManager) SetEarlyHeaderMutationExtensions 

func (x *HttpConnectionManager) SetEarlyHeaderMutationExtensions(v []*v3.TypedExtensionConfig)

func (*HttpConnectionManager) SetFlushAccessLogOnNewRequest deprecated 

func (x *HttpConnectionManager) SetFlushAccessLogOnNewRequest(v bool)

Deprecated: Marked as deprecated in envoy/extensions/filters/network/http_connection_manager/v3/http_connection_manager.proto.

func (*HttpConnectionManager) SetForwardClientCertDetails 

func (x *HttpConnectionManager) SetForwardClientCertDetails(v HttpConnectionManager_ForwardClientCertDetails)

func (*HttpConnectionManager) SetForwardClientCertMatcher 

func (x *HttpConnectionManager) SetForwardClientCertMatcher(v *v32.Matcher)

func (*HttpConnectionManager) SetGenerateRequestId 

func (x *HttpConnectionManager) SetGenerateRequestId(v *wrapperspb.BoolValue)

func (*HttpConnectionManager) SetHttp1SafeMaxConnectionDuration 

func (x *HttpConnectionManager) SetHttp1SafeMaxConnectionDuration(v bool)

func (*HttpConnectionManager) SetHttp2ProtocolOptions 

func (x *HttpConnectionManager) SetHttp2ProtocolOptions(v *v3.Http2ProtocolOptions)

func (*HttpConnectionManager) SetHttp3ProtocolOptions 

func (x *HttpConnectionManager) SetHttp3ProtocolOptions(v *v3.Http3ProtocolOptions)

func (*HttpConnectionManager) SetHttpFilters 

func (x *HttpConnectionManager) SetHttpFilters(v []*HttpFilter)

func (*HttpConnectionManager) SetHttpProtocolOptions 

func (x *HttpConnectionManager) SetHttpProtocolOptions(v *v3.Http1ProtocolOptions)

func (*HttpConnectionManager) SetInternalAddressConfig 

func (x *HttpConnectionManager) SetInternalAddressConfig(v *HttpConnectionManager_InternalAddressConfig)

func (*HttpConnectionManager) SetLocalReplyConfig 

func (x *HttpConnectionManager) SetLocalReplyConfig(v *LocalReplyConfig)

func (*HttpConnectionManager) SetMaxRequestHeadersKb 

func (x *HttpConnectionManager) SetMaxRequestHeadersKb(v *wrapperspb.UInt32Value)

func (*HttpConnectionManager) SetMergeSlashes 

func (x *HttpConnectionManager) SetMergeSlashes(v bool)

func (*HttpConnectionManager) SetNormalizePath 

func (x *HttpConnectionManager) SetNormalizePath(v *wrapperspb.BoolValue)

func (*HttpConnectionManager) SetOriginalIpDetectionExtensions 

func (x *HttpConnectionManager) SetOriginalIpDetectionExtensions(v []*v3.TypedExtensionConfig)

func (*HttpConnectionManager) SetPathNormalizationOptions 

func (x *HttpConnectionManager) SetPathNormalizationOptions(v *HttpConnectionManager_PathNormalizationOptions)

func (*HttpConnectionManager) SetPathWithEscapedSlashesAction 

func (x *HttpConnectionManager) SetPathWithEscapedSlashesAction(v HttpConnectionManager_PathWithEscapedSlashesAction)

func (*HttpConnectionManager) SetPreserveExternalRequestId 

func (x *HttpConnectionManager) SetPreserveExternalRequestId(v bool)

func (*HttpConnectionManager) SetProxyStatusConfig 

func (x *HttpConnectionManager) SetProxyStatusConfig(v *HttpConnectionManager_ProxyStatusConfig)

func (*HttpConnectionManager) SetProxy_100Continue 

func (x *HttpConnectionManager) SetProxy_100Continue(v bool)

func (*HttpConnectionManager) SetRds 

func (x *HttpConnectionManager) SetRds(v *Rds)

func (*HttpConnectionManager) SetRepresentIpv4RemoteAddressAsIpv4MappedIpv6 

func (x *HttpConnectionManager) SetRepresentIpv4RemoteAddressAsIpv4MappedIpv6(v bool)

func (*HttpConnectionManager) SetRequestHeadersTimeout 

func (x *HttpConnectionManager) SetRequestHeadersTimeout(v *durationpb.Duration)

func (*HttpConnectionManager) SetRequestIdExtension 

func (x *HttpConnectionManager) SetRequestIdExtension(v *RequestIDExtension)

func (*HttpConnectionManager) SetRequestTimeout 

func (x *HttpConnectionManager) SetRequestTimeout(v *durationpb.Duration)

func (*HttpConnectionManager) SetRouteConfig 

func (x *HttpConnectionManager) SetRouteConfig(v *v33.RouteConfiguration)

func (*HttpConnectionManager) SetSchemeHeaderTransformation 

func (x *HttpConnectionManager) SetSchemeHeaderTransformation(v *v3.SchemeHeaderTransformation)

func (*HttpConnectionManager) SetScopedRoutes 

func (x *HttpConnectionManager) SetScopedRoutes(v *ScopedRoutes)

func (*HttpConnectionManager) SetServerHeaderTransformation 

func (x *HttpConnectionManager) SetServerHeaderTransformation(v HttpConnectionManager_ServerHeaderTransformation)

func (*HttpConnectionManager) SetServerName 

func (x *HttpConnectionManager) SetServerName(v string)

func (*HttpConnectionManager) SetSetCurrentClientCertDetails 

func (x *HttpConnectionManager) SetSetCurrentClientCertDetails(v *HttpConnectionManager_SetCurrentClientCertDetails)

func (*HttpConnectionManager) SetSkipXffAppend 

func (x *HttpConnectionManager) SetSkipXffAppend(v bool)

func (*HttpConnectionManager) SetStatPrefix 

func (x *HttpConnectionManager) SetStatPrefix(v string)

func (*HttpConnectionManager) SetStreamErrorOnInvalidHttpMessage 

func (x *HttpConnectionManager) SetStreamErrorOnInvalidHttpMessage(v *wrapperspb.BoolValue)

func (*HttpConnectionManager) SetStreamFlushTimeout 

func (x *HttpConnectionManager) SetStreamFlushTimeout(v *durationpb.Duration)

func (*HttpConnectionManager) SetStreamIdleTimeout 

func (x *HttpConnectionManager) SetStreamIdleTimeout(v *durationpb.Duration)

func (*HttpConnectionManager) SetStripAnyHostPort 

func (x *HttpConnectionManager) SetStripAnyHostPort(v bool)

func (*HttpConnectionManager) SetStripMatchingHostPort 

func (x *HttpConnectionManager) SetStripMatchingHostPort(v bool)

func (*HttpConnectionManager) SetStripTrailingHostDot 

func (x *HttpConnectionManager) SetStripTrailingHostDot(v bool)

func (*HttpConnectionManager) SetTracing 

func (x *HttpConnectionManager) SetTracing(v *HttpConnectionManager_Tracing)

func (*HttpConnectionManager) SetTypedHeaderValidationConfig 

func (x *HttpConnectionManager) SetTypedHeaderValidationConfig(v *v3.TypedExtensionConfig)

func (*HttpConnectionManager) SetUpgradeConfigs 

func (x *HttpConnectionManager) SetUpgradeConfigs(v []*HttpConnectionManager_UpgradeConfig)

func (*HttpConnectionManager) SetUseRemoteAddress 

func (x *HttpConnectionManager) SetUseRemoteAddress(v *wrapperspb.BoolValue)

func (*HttpConnectionManager) SetVia 

func (x *HttpConnectionManager) SetVia(v string)

func (*HttpConnectionManager) SetXffNumTrustedHops 

func (x *HttpConnectionManager) SetXffNumTrustedHops(v uint32)

func (*HttpConnectionManager) String 

func (x *HttpConnectionManager) String() string

func (*HttpConnectionManager) WhichRouteSpecifier 

func (x *HttpConnectionManager) WhichRouteSpecifier() case_HttpConnectionManager_RouteSpecifier

func (*HttpConnectionManager) WhichStripPortMode 

func (x *HttpConnectionManager) WhichStripPortMode() case_HttpConnectionManager_StripPortMode

type HttpConnectionManager_CodecType 

type HttpConnectionManager_CodecType int32
const (
	// For every new connection, the connection manager will determine which
	// codec to use. This mode supports both ALPN for TLS listeners as well as
	// protocol inference for plaintext listeners. If ALPN data is available, it
	// is preferred, otherwise protocol inference is used. In almost all cases,
	// this is the right option to choose for this setting.
	HttpConnectionManager_AUTO HttpConnectionManager_CodecType = 0
	// The connection manager will assume that the client is speaking HTTP/1.1.
	HttpConnectionManager_HTTP1 HttpConnectionManager_CodecType = 1
	// The connection manager will assume that the client is speaking HTTP/2
	// (Envoy does not require HTTP/2 to take place over TLS or to use ALPN.
	// Prior knowledge is allowed).
	HttpConnectionManager_HTTP2 HttpConnectionManager_CodecType = 2
	// The connection manager will assume that the client is speaking HTTP/3.
	// This needs to be consistent with listener and transport socket config.
	HttpConnectionManager_HTTP3 HttpConnectionManager_CodecType = 3
)

func (HttpConnectionManager_CodecType) Descriptor 

func (HttpConnectionManager_CodecType) Descriptor() protoreflect.EnumDescriptor

func (HttpConnectionManager_CodecType) Enum 

func (x HttpConnectionManager_CodecType) Enum() *HttpConnectionManager_CodecType

func (HttpConnectionManager_CodecType) Number 

func (x HttpConnectionManager_CodecType) Number() protoreflect.EnumNumber

func (HttpConnectionManager_CodecType) String 

func (x HttpConnectionManager_CodecType) String() string

func (HttpConnectionManager_CodecType) Type 

func (HttpConnectionManager_CodecType) Type() protoreflect.EnumType

type HttpConnectionManager_ForwardClientCertConfig 

type HttpConnectionManager_ForwardClientCertConfig struct {

	// How to handle the XFCC header.
	ForwardClientCertDetails HttpConnectionManager_ForwardClientCertDetails `` /* 250-byte string literal not displayed */
	// How to set the current client cert details.
	SetCurrentClientCertDetails *HttpConnectionManager_SetCurrentClientCertDetails `` /* 148-byte string literal not displayed */
	// contains filtered or unexported fields
}

The configuration for forwarding client cert details.

func (*HttpConnectionManager_ForwardClientCertConfig) ClearSetCurrentClientCertDetails 

func (x *HttpConnectionManager_ForwardClientCertConfig) ClearSetCurrentClientCertDetails()

func (*HttpConnectionManager_ForwardClientCertConfig) GetForwardClientCertDetails 

func (x *HttpConnectionManager_ForwardClientCertConfig) GetForwardClientCertDetails() HttpConnectionManager_ForwardClientCertDetails

func (*HttpConnectionManager_ForwardClientCertConfig) GetSetCurrentClientCertDetails 

func (x *HttpConnectionManager_ForwardClientCertConfig) GetSetCurrentClientCertDetails() *HttpConnectionManager_SetCurrentClientCertDetails

func (*HttpConnectionManager_ForwardClientCertConfig) HasSetCurrentClientCertDetails 

func (x *HttpConnectionManager_ForwardClientCertConfig) HasSetCurrentClientCertDetails() bool

func (*HttpConnectionManager_ForwardClientCertConfig) ProtoMessage 

func (*HttpConnectionManager_ForwardClientCertConfig) ProtoMessage()

func (*HttpConnectionManager_ForwardClientCertConfig) ProtoReflect 

func (x *HttpConnectionManager_ForwardClientCertConfig) ProtoReflect() protoreflect.Message

func (*HttpConnectionManager_ForwardClientCertConfig) Reset 

func (x *HttpConnectionManager_ForwardClientCertConfig) Reset()

func (*HttpConnectionManager_ForwardClientCertConfig) SetForwardClientCertDetails 

func (x *HttpConnectionManager_ForwardClientCertConfig) SetForwardClientCertDetails(v HttpConnectionManager_ForwardClientCertDetails)

func (*HttpConnectionManager_ForwardClientCertConfig) SetSetCurrentClientCertDetails 

func (x *HttpConnectionManager_ForwardClientCertConfig) SetSetCurrentClientCertDetails(v *HttpConnectionManager_SetCurrentClientCertDetails)

func (*HttpConnectionManager_ForwardClientCertConfig) String 

func (x *HttpConnectionManager_ForwardClientCertConfig) String() string

type HttpConnectionManager_ForwardClientCertConfig_builder 

type HttpConnectionManager_ForwardClientCertConfig_builder struct {

	// How to handle the XFCC header.
	ForwardClientCertDetails HttpConnectionManager_ForwardClientCertDetails
	// How to set the current client cert details.
	SetCurrentClientCertDetails *HttpConnectionManager_SetCurrentClientCertDetails
	// contains filtered or unexported fields
}

func (HttpConnectionManager_ForwardClientCertConfig_builder) Build 

func (b0 HttpConnectionManager_ForwardClientCertConfig_builder) Build() *HttpConnectionManager_ForwardClientCertConfig

type HttpConnectionManager_ForwardClientCertDetails 

type HttpConnectionManager_ForwardClientCertDetails int32

How to handle the :ref:`config_http_conn_man_headers_x-forwarded-client-cert` (XFCC) HTTP header. 

const (
	// Do not send the XFCC header to the next hop. This is the default value.
	HttpConnectionManager_SANITIZE HttpConnectionManager_ForwardClientCertDetails = 0
	// When the client connection is mTLS (Mutual TLS), forward the XFCC header
	// in the request.
	HttpConnectionManager_FORWARD_ONLY HttpConnectionManager_ForwardClientCertDetails = 1
	// When the client connection is mTLS, append the client certificate
	// information to the request’s XFCC header and forward it.
	HttpConnectionManager_APPEND_FORWARD HttpConnectionManager_ForwardClientCertDetails = 2
	// When the client connection is mTLS, reset the XFCC header with the client
	// certificate information and send it to the next hop.
	HttpConnectionManager_SANITIZE_SET HttpConnectionManager_ForwardClientCertDetails = 3
	// Always forward the XFCC header in the request, regardless of whether the
	// client connection is mTLS.
	HttpConnectionManager_ALWAYS_FORWARD_ONLY HttpConnectionManager_ForwardClientCertDetails = 4
)

func (HttpConnectionManager_ForwardClientCertDetails) Descriptor 

func (HttpConnectionManager_ForwardClientCertDetails) Descriptor() protoreflect.EnumDescriptor

func (HttpConnectionManager_ForwardClientCertDetails) Enum 

func (x HttpConnectionManager_ForwardClientCertDetails) Enum() *HttpConnectionManager_ForwardClientCertDetails

func (HttpConnectionManager_ForwardClientCertDetails) Number 

func (x HttpConnectionManager_ForwardClientCertDetails) Number() protoreflect.EnumNumber

func (HttpConnectionManager_ForwardClientCertDetails) String 

func (x HttpConnectionManager_ForwardClientCertDetails) String() string

func (HttpConnectionManager_ForwardClientCertDetails) Type 

func (HttpConnectionManager_ForwardClientCertDetails) Type() protoreflect.EnumType

type HttpConnectionManager_HcmAccessLogOptions 

type HttpConnectionManager_HcmAccessLogOptions struct {

	// The interval to flush the above access logs. By default, the HCM will flush exactly one access log
	// on stream close, when the HTTP request is complete. If this field is set, the HCM will flush access
	// logs periodically at the specified interval. This is especially useful in the case of long-lived
	// requests, such as CONNECT and Websockets. Final access logs can be detected via the
	// “requestComplete()“ method of “StreamInfo“ in access log filters, or through the “%DURATION%“ substitution
	// string.
	// The interval must be at least 1 millisecond.
	AccessLogFlushInterval *durationpb.Duration `` /* 131-byte string literal not displayed */
	// If set to true, HCM will flush an access log when a new HTTP request is received, after request
	// headers have been evaluated, before iterating through the HTTP filter chain.
	// This log record, if enabled, does not depend on periodic log records or request completion log.
	// Details related to upstream cluster, such as upstream host, will not be available for this log.
	FlushAccessLogOnNewRequest bool `` /* 148-byte string literal not displayed */
	// If true, the HCM will flush an access log when a tunnel is successfully established. For example,
	// this could be when an upstream has successfully returned 101 Switching Protocols, or when the proxy
	// has returned 200 to a CONNECT request.
	FlushLogOnTunnelSuccessfullyEstablished bool `` /* 187-byte string literal not displayed */
	// contains filtered or unexported fields
}

func (*HttpConnectionManager_HcmAccessLogOptions) ClearAccessLogFlushInterval 

func (x *HttpConnectionManager_HcmAccessLogOptions) ClearAccessLogFlushInterval()

func (*HttpConnectionManager_HcmAccessLogOptions) GetAccessLogFlushInterval 

func (x *HttpConnectionManager_HcmAccessLogOptions) GetAccessLogFlushInterval() *durationpb.Duration

func (*HttpConnectionManager_HcmAccessLogOptions) GetFlushAccessLogOnNewRequest 

func (x *HttpConnectionManager_HcmAccessLogOptions) GetFlushAccessLogOnNewRequest() bool

func (*HttpConnectionManager_HcmAccessLogOptions) GetFlushLogOnTunnelSuccessfullyEstablished 

func (x *HttpConnectionManager_HcmAccessLogOptions) GetFlushLogOnTunnelSuccessfullyEstablished() bool

func (*HttpConnectionManager_HcmAccessLogOptions) HasAccessLogFlushInterval 

func (x *HttpConnectionManager_HcmAccessLogOptions) HasAccessLogFlushInterval() bool

func (*HttpConnectionManager_HcmAccessLogOptions) ProtoMessage 

func (*HttpConnectionManager_HcmAccessLogOptions) ProtoMessage()

func (*HttpConnectionManager_HcmAccessLogOptions) ProtoReflect 

func (x *HttpConnectionManager_HcmAccessLogOptions) ProtoReflect() protoreflect.Message

func (*HttpConnectionManager_HcmAccessLogOptions) Reset 

func (x *HttpConnectionManager_HcmAccessLogOptions) Reset()

func (*HttpConnectionManager_HcmAccessLogOptions) SetAccessLogFlushInterval 

func (x *HttpConnectionManager_HcmAccessLogOptions) SetAccessLogFlushInterval(v *durationpb.Duration)

func (*HttpConnectionManager_HcmAccessLogOptions) SetFlushAccessLogOnNewRequest 

func (x *HttpConnectionManager_HcmAccessLogOptions) SetFlushAccessLogOnNewRequest(v bool)

func (*HttpConnectionManager_HcmAccessLogOptions) SetFlushLogOnTunnelSuccessfullyEstablished 

func (x *HttpConnectionManager_HcmAccessLogOptions) SetFlushLogOnTunnelSuccessfullyEstablished(v bool)

func (*HttpConnectionManager_HcmAccessLogOptions) String 

func (x *HttpConnectionManager_HcmAccessLogOptions) String() string

type HttpConnectionManager_HcmAccessLogOptions_builder 

type HttpConnectionManager_HcmAccessLogOptions_builder struct {

	// The interval to flush the above access logs. By default, the HCM will flush exactly one access log
	// on stream close, when the HTTP request is complete. If this field is set, the HCM will flush access
	// logs periodically at the specified interval. This is especially useful in the case of long-lived
	// requests, such as CONNECT and Websockets. Final access logs can be detected via the
	// “requestComplete()“ method of “StreamInfo“ in access log filters, or through the “%DURATION%“ substitution
	// string.
	// The interval must be at least 1 millisecond.
	AccessLogFlushInterval *durationpb.Duration
	// If set to true, HCM will flush an access log when a new HTTP request is received, after request
	// headers have been evaluated, before iterating through the HTTP filter chain.
	// This log record, if enabled, does not depend on periodic log records or request completion log.
	// Details related to upstream cluster, such as upstream host, will not be available for this log.
	FlushAccessLogOnNewRequest bool
	// If true, the HCM will flush an access log when a tunnel is successfully established. For example,
	// this could be when an upstream has successfully returned 101 Switching Protocols, or when the proxy
	// has returned 200 to a CONNECT request.
	FlushLogOnTunnelSuccessfullyEstablished bool
	// contains filtered or unexported fields
}

func (HttpConnectionManager_HcmAccessLogOptions_builder) Build 

func (b0 HttpConnectionManager_HcmAccessLogOptions_builder) Build() *HttpConnectionManager_HcmAccessLogOptions

type HttpConnectionManager_InternalAddressConfig 

type HttpConnectionManager_InternalAddressConfig struct {

	// Whether unix socket addresses should be considered internal.
	UnixSockets bool `protobuf:"varint,1,opt,name=unix_sockets,json=unixSockets,proto3" json:"unix_sockets,omitempty"`
	// List of CIDR ranges that are treated as internal. If unset, then RFC1918 / RFC4193
	// IP addresses will be considered internal.
	CidrRanges []*v3.CidrRange `protobuf:"bytes,2,rep,name=cidr_ranges,json=cidrRanges,proto3" json:"cidr_ranges,omitempty"`
	// contains filtered or unexported fields
}

func (*HttpConnectionManager_InternalAddressConfig) GetCidrRanges 

func (x *HttpConnectionManager_InternalAddressConfig) GetCidrRanges() []*v3.CidrRange

func (*HttpConnectionManager_InternalAddressConfig) GetUnixSockets 

func (x *HttpConnectionManager_InternalAddressConfig) GetUnixSockets() bool

func (*HttpConnectionManager_InternalAddressConfig) ProtoMessage 

func (*HttpConnectionManager_InternalAddressConfig) ProtoMessage()

func (*HttpConnectionManager_InternalAddressConfig) ProtoReflect 

func (x *HttpConnectionManager_InternalAddressConfig) ProtoReflect() protoreflect.Message

func (*HttpConnectionManager_InternalAddressConfig) Reset 

func (x *HttpConnectionManager_InternalAddressConfig) Reset()

func (*HttpConnectionManager_InternalAddressConfig) SetCidrRanges 

func (x *HttpConnectionManager_InternalAddressConfig) SetCidrRanges(v []*v3.CidrRange)

func (*HttpConnectionManager_InternalAddressConfig) SetUnixSockets 

func (x *HttpConnectionManager_InternalAddressConfig) SetUnixSockets(v bool)

func (*HttpConnectionManager_InternalAddressConfig) String 

func (x *HttpConnectionManager_InternalAddressConfig) String() string

type HttpConnectionManager_InternalAddressConfig_builder 

type HttpConnectionManager_InternalAddressConfig_builder struct {

	// Whether unix socket addresses should be considered internal.
	UnixSockets bool
	// List of CIDR ranges that are treated as internal. If unset, then RFC1918 / RFC4193
	// IP addresses will be considered internal.
	CidrRanges []*v3.CidrRange
	// contains filtered or unexported fields
}

func (HttpConnectionManager_InternalAddressConfig_builder) Build 

func (b0 HttpConnectionManager_InternalAddressConfig_builder) Build() *HttpConnectionManager_InternalAddressConfig

type HttpConnectionManager_PathNormalizationOptions 

type HttpConnectionManager_PathNormalizationOptions struct {

	// [#not-implemented-hide:] Normalization applies internally before any processing of requests by
	// HTTP filters, routing, and matching *and* will affect the forwarded “:path“ header. Defaults
	// to :ref:`NormalizePathRFC3986
	// <envoy_v3_api_msg_type.http.v3.PathTransformation.Operation.NormalizePathRFC3986>`. When not
	// specified, this value may be overridden by the runtime variable
	// :ref:`http_connection_manager.normalize_path<config_http_conn_man_runtime_normalize_path>`.
	// Envoy will respond with 400 to paths that are malformed (e.g. for paths that fail RFC 3986
	// normalization due to disallowed characters.)
	ForwardingTransformation *v37.PathTransformation `` /* 133-byte string literal not displayed */
	// [#not-implemented-hide:] Normalization only applies internally before any processing of
	// requests by HTTP filters, routing, and matching. These will be applied after full
	// transformation is applied. The “:path“ header before this transformation will be restored in
	// the router filter and sent upstream unless it was mutated by a filter. Defaults to no
	// transformations.
	// Multiple actions can be applied in the same Transformation, forming a sequential
	// pipeline. The transformations will be performed in the order that they appear. Envoy will
	// respond with 400 to paths that are malformed (e.g. for paths that fail RFC 3986
	// normalization due to disallowed characters.)
	HttpFilterTransformation *v37.PathTransformation `` /* 135-byte string literal not displayed */
	// contains filtered or unexported fields
}

[#not-implemented-hide:] Transformations that apply to path headers. Transformations are applied before any processing of requests by HTTP filters, routing, and matching. Only the normalized path will be visible internally if a transformation is enabled. Any path rewrites that the router performs (e.g. :ref:`regex_rewrite <envoy_v3_api_field_config.route.v3.RouteAction.regex_rewrite>` or :ref:`prefix_rewrite <envoy_v3_api_field_config.route.v3.RouteAction.prefix_rewrite>`) will apply to the “:path“ header destined for the upstream.

.. note:: 

Access logging and tracing will show the original ``:path`` header.

func (*HttpConnectionManager_PathNormalizationOptions) ClearForwardingTransformation 

func (x *HttpConnectionManager_PathNormalizationOptions) ClearForwardingTransformation()

func (*HttpConnectionManager_PathNormalizationOptions) ClearHttpFilterTransformation 

func (x *HttpConnectionManager_PathNormalizationOptions) ClearHttpFilterTransformation()

func (*HttpConnectionManager_PathNormalizationOptions) GetForwardingTransformation 

func (x *HttpConnectionManager_PathNormalizationOptions) GetForwardingTransformation() *v37.PathTransformation

func (*HttpConnectionManager_PathNormalizationOptions) GetHttpFilterTransformation 

func (x *HttpConnectionManager_PathNormalizationOptions) GetHttpFilterTransformation() *v37.PathTransformation

func (*HttpConnectionManager_PathNormalizationOptions) HasForwardingTransformation 

func (x *HttpConnectionManager_PathNormalizationOptions) HasForwardingTransformation() bool

func (*HttpConnectionManager_PathNormalizationOptions) HasHttpFilterTransformation 

func (x *HttpConnectionManager_PathNormalizationOptions) HasHttpFilterTransformation() bool

func (*HttpConnectionManager_PathNormalizationOptions) ProtoMessage 

func (*HttpConnectionManager_PathNormalizationOptions) ProtoMessage()

func (*HttpConnectionManager_PathNormalizationOptions) ProtoReflect 

func (x *HttpConnectionManager_PathNormalizationOptions) ProtoReflect() protoreflect.Message

func (*HttpConnectionManager_PathNormalizationOptions) Reset 

func (x *HttpConnectionManager_PathNormalizationOptions) Reset()

func (*HttpConnectionManager_PathNormalizationOptions) SetForwardingTransformation 

func (x *HttpConnectionManager_PathNormalizationOptions) SetForwardingTransformation(v *v37.PathTransformation)

func (*HttpConnectionManager_PathNormalizationOptions) SetHttpFilterTransformation 

func (x *HttpConnectionManager_PathNormalizationOptions) SetHttpFilterTransformation(v *v37.PathTransformation)

func (*HttpConnectionManager_PathNormalizationOptions) String 

func (x *HttpConnectionManager_PathNormalizationOptions) String() string

type HttpConnectionManager_PathNormalizationOptions_builder 

type HttpConnectionManager_PathNormalizationOptions_builder struct {

	// [#not-implemented-hide:] Normalization applies internally before any processing of requests by
	// HTTP filters, routing, and matching *and* will affect the forwarded “:path“ header. Defaults
	// to :ref:`NormalizePathRFC3986
	// <envoy_v3_api_msg_type.http.v3.PathTransformation.Operation.NormalizePathRFC3986>`. When not
	// specified, this value may be overridden by the runtime variable
	// :ref:`http_connection_manager.normalize_path<config_http_conn_man_runtime_normalize_path>`.
	// Envoy will respond with 400 to paths that are malformed (e.g. for paths that fail RFC 3986
	// normalization due to disallowed characters.)
	ForwardingTransformation *v37.PathTransformation
	// [#not-implemented-hide:] Normalization only applies internally before any processing of
	// requests by HTTP filters, routing, and matching. These will be applied after full
	// transformation is applied. The “:path“ header before this transformation will be restored in
	// the router filter and sent upstream unless it was mutated by a filter. Defaults to no
	// transformations.
	// Multiple actions can be applied in the same Transformation, forming a sequential
	// pipeline. The transformations will be performed in the order that they appear. Envoy will
	// respond with 400 to paths that are malformed (e.g. for paths that fail RFC 3986
	// normalization due to disallowed characters.)
	HttpFilterTransformation *v37.PathTransformation
	// contains filtered or unexported fields
}

func (HttpConnectionManager_PathNormalizationOptions_builder) Build 

func (b0 HttpConnectionManager_PathNormalizationOptions_builder) Build() *HttpConnectionManager_PathNormalizationOptions

type HttpConnectionManager_PathWithEscapedSlashesAction 

type HttpConnectionManager_PathWithEscapedSlashesAction int32

Determines the action for request that contain “%2F“, “%2f“, “%5C“ or “%5c“ sequences in the URI path. This operation occurs before URL normalization and the merge slashes transformations if they were enabled. 

const (
	// Default behavior specific to implementation (i.e. Envoy) of this configuration option.
	// Envoy, by default, takes the KEEP_UNCHANGED action.
	//
	// .. note::
	//
	//	The implementation may change the default behavior at-will.
	HttpConnectionManager_IMPLEMENTATION_SPECIFIC_DEFAULT HttpConnectionManager_PathWithEscapedSlashesAction = 0
	// Keep escaped slashes.
	HttpConnectionManager_KEEP_UNCHANGED HttpConnectionManager_PathWithEscapedSlashesAction = 1
	// Reject client request with the 400 status. gRPC requests will be rejected with the INTERNAL (13) error code.
	// The “httpN.downstream_rq_failed_path_normalization“ counter is incremented for each rejected request.
	HttpConnectionManager_REJECT_REQUEST HttpConnectionManager_PathWithEscapedSlashesAction = 2
	// Unescape “%2F“ and “%5C“ sequences and redirect request to the new path if these sequences were present.
	// Redirect occurs after path normalization and merge slashes transformations if they were configured.
	//
	// .. note::
	//
	//	gRPC requests will be rejected with the INTERNAL (13) error code. This option minimizes possibility of path
	//	confusion exploits by forcing request with unescaped slashes to traverse all parties: downstream client,
	//	intermediate proxies, Envoy and upstream server. The “httpN.downstream_rq_redirected_with_normalized_path“
	//	counter is incremented for each redirected request.
	HttpConnectionManager_UNESCAPE_AND_REDIRECT HttpConnectionManager_PathWithEscapedSlashesAction = 3
	// Unescape “%2F“ and “%5C“ sequences.
	//
	// .. note::
	//
	//	This option should not be enabled if intermediaries perform path based access control as it may lead to path
	//	confusion vulnerabilities.
	HttpConnectionManager_UNESCAPE_AND_FORWARD HttpConnectionManager_PathWithEscapedSlashesAction = 4
)

func (HttpConnectionManager_PathWithEscapedSlashesAction) Descriptor 

func (HttpConnectionManager_PathWithEscapedSlashesAction) Descriptor() protoreflect.EnumDescriptor

func (HttpConnectionManager_PathWithEscapedSlashesAction) Enum 

func (x HttpConnectionManager_PathWithEscapedSlashesAction) Enum() *HttpConnectionManager_PathWithEscapedSlashesAction

func (HttpConnectionManager_PathWithEscapedSlashesAction) Number 

func (x HttpConnectionManager_PathWithEscapedSlashesAction) Number() protoreflect.EnumNumber

func (HttpConnectionManager_PathWithEscapedSlashesAction) String 

func (x HttpConnectionManager_PathWithEscapedSlashesAction) String() string

func (HttpConnectionManager_PathWithEscapedSlashesAction) Type 

func (HttpConnectionManager_PathWithEscapedSlashesAction) Type() protoreflect.EnumType

type HttpConnectionManager_ProxyStatusConfig 

type HttpConnectionManager_ProxyStatusConfig struct {

	// If true, the details field of the Proxy-Status header is not populated with stream_info.response_code_details.
	// This value defaults to “false“, i.e. the “details“ field is populated by default.
	RemoveDetails bool `protobuf:"varint,1,opt,name=remove_details,json=removeDetails,proto3" json:"remove_details,omitempty"`
	// If true, the details field of the Proxy-Status header will not contain
	// connection termination details. This value defaults to “false“, i.e. the
	// “details“ field will contain connection termination details by default.
	RemoveConnectionTerminationDetails bool `` /* 168-byte string literal not displayed */
	// If true, the details field of the Proxy-Status header will not contain an
	// enumeration of the Envoy ResponseFlags. This value defaults to “false“,
	// i.e. the “details“ field will contain a list of ResponseFlags by default.
	RemoveResponseFlags bool `protobuf:"varint,3,opt,name=remove_response_flags,json=removeResponseFlags,proto3" json:"remove_response_flags,omitempty"`
	// If true, overwrites the existing Status header with the response code
	// recommended by the Proxy-Status spec.
	// This value defaults to “false“, i.e. the HTTP response code is not
	// overwritten.
	SetRecommendedResponseCode bool `` /* 144-byte string literal not displayed */
	// The name of the proxy as it appears at the start of the Proxy-Status
	// header.
	//
	// If neither of these values are set, this value defaults to “server_name“,
	// which itself defaults to "envoy".
	//
	// Types that are valid to be assigned to ProxyName:
	//
	//	*HttpConnectionManager_ProxyStatusConfig_UseNodeId
	//	*HttpConnectionManager_ProxyStatusConfig_LiteralProxyName
	ProxyName isHttpConnectionManager_ProxyStatusConfig_ProxyName `protobuf_oneof:"proxy_name"`
	// contains filtered or unexported fields
}

Configures the manner in which the Proxy-Status HTTP response header is populated.

See the [Proxy-Status RFC](https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-proxy-status-08). [#comment:TODO: Update this with the non-draft URL when finalized.]

The Proxy-Status header is a string of the form: 

"<server_name>; error=<error_type>; details=<details>"

[#next-free-field: 7]

func (*HttpConnectionManager_ProxyStatusConfig) ClearLiteralProxyName 

func (x *HttpConnectionManager_ProxyStatusConfig) ClearLiteralProxyName()

func (*HttpConnectionManager_ProxyStatusConfig) ClearProxyName 

func (x *HttpConnectionManager_ProxyStatusConfig) ClearProxyName()

func (*HttpConnectionManager_ProxyStatusConfig) ClearUseNodeId 

func (x *HttpConnectionManager_ProxyStatusConfig) ClearUseNodeId()

func (*HttpConnectionManager_ProxyStatusConfig) GetLiteralProxyName 

func (x *HttpConnectionManager_ProxyStatusConfig) GetLiteralProxyName() string

func (*HttpConnectionManager_ProxyStatusConfig) GetProxyName 

func (x *HttpConnectionManager_ProxyStatusConfig) GetProxyName() isHttpConnectionManager_ProxyStatusConfig_ProxyName

func (*HttpConnectionManager_ProxyStatusConfig) GetRemoveConnectionTerminationDetails 

func (x *HttpConnectionManager_ProxyStatusConfig) GetRemoveConnectionTerminationDetails() bool

func (*HttpConnectionManager_ProxyStatusConfig) GetRemoveDetails 

func (x *HttpConnectionManager_ProxyStatusConfig) GetRemoveDetails() bool

func (*HttpConnectionManager_ProxyStatusConfig) GetRemoveResponseFlags 

func (x *HttpConnectionManager_ProxyStatusConfig) GetRemoveResponseFlags() bool

func (*HttpConnectionManager_ProxyStatusConfig) GetSetRecommendedResponseCode 

func (x *HttpConnectionManager_ProxyStatusConfig) GetSetRecommendedResponseCode() bool

func (*HttpConnectionManager_ProxyStatusConfig) GetUseNodeId 

func (x *HttpConnectionManager_ProxyStatusConfig) GetUseNodeId() bool

func (*HttpConnectionManager_ProxyStatusConfig) HasLiteralProxyName 

func (x *HttpConnectionManager_ProxyStatusConfig) HasLiteralProxyName() bool

func (*HttpConnectionManager_ProxyStatusConfig) HasProxyName 

func (x *HttpConnectionManager_ProxyStatusConfig) HasProxyName() bool

func (*HttpConnectionManager_ProxyStatusConfig) HasUseNodeId 

func (x *HttpConnectionManager_ProxyStatusConfig) HasUseNodeId() bool

func (*HttpConnectionManager_ProxyStatusConfig) ProtoMessage 

func (*HttpConnectionManager_ProxyStatusConfig) ProtoMessage()

func (*HttpConnectionManager_ProxyStatusConfig) ProtoReflect 

func (x *HttpConnectionManager_ProxyStatusConfig) ProtoReflect() protoreflect.Message

func (*HttpConnectionManager_ProxyStatusConfig) Reset 

func (x *HttpConnectionManager_ProxyStatusConfig) Reset()

func (*HttpConnectionManager_ProxyStatusConfig) SetLiteralProxyName 

func (x *HttpConnectionManager_ProxyStatusConfig) SetLiteralProxyName(v string)

func (*HttpConnectionManager_ProxyStatusConfig) SetRemoveConnectionTerminationDetails 

func (x *HttpConnectionManager_ProxyStatusConfig) SetRemoveConnectionTerminationDetails(v bool)

func (*HttpConnectionManager_ProxyStatusConfig) SetRemoveDetails 

func (x *HttpConnectionManager_ProxyStatusConfig) SetRemoveDetails(v bool)

func (*HttpConnectionManager_ProxyStatusConfig) SetRemoveResponseFlags 

func (x *HttpConnectionManager_ProxyStatusConfig) SetRemoveResponseFlags(v bool)

func (*HttpConnectionManager_ProxyStatusConfig) SetSetRecommendedResponseCode 

func (x *HttpConnectionManager_ProxyStatusConfig) SetSetRecommendedResponseCode(v bool)

func (*HttpConnectionManager_ProxyStatusConfig) SetUseNodeId 

func (x *HttpConnectionManager_ProxyStatusConfig) SetUseNodeId(v bool)

func (*HttpConnectionManager_ProxyStatusConfig) String 

func (x *HttpConnectionManager_ProxyStatusConfig) String() string

func (*HttpConnectionManager_ProxyStatusConfig) WhichProxyName 

func (x *HttpConnectionManager_ProxyStatusConfig) WhichProxyName() case_HttpConnectionManager_ProxyStatusConfig_ProxyName

type HttpConnectionManager_ProxyStatusConfig_LiteralProxyName 

type HttpConnectionManager_ProxyStatusConfig_LiteralProxyName struct {
	// If “literal_proxy_name“ is set, Proxy-Status headers will use this
	// value as the name of the proxy.
	LiteralProxyName string `protobuf:"bytes,6,opt,name=literal_proxy_name,json=literalProxyName,proto3,oneof"`
}

type HttpConnectionManager_ProxyStatusConfig_UseNodeId 

type HttpConnectionManager_ProxyStatusConfig_UseNodeId struct {
	// If “use_node_id“ is set, Proxy-Status headers will use the Envoy's node
	// ID as the name of the proxy.
	UseNodeId bool `protobuf:"varint,5,opt,name=use_node_id,json=useNodeId,proto3,oneof"`
}

type HttpConnectionManager_ProxyStatusConfig_builder 

type HttpConnectionManager_ProxyStatusConfig_builder struct {

	// If true, the details field of the Proxy-Status header is not populated with stream_info.response_code_details.
	// This value defaults to “false“, i.e. the “details“ field is populated by default.
	RemoveDetails bool
	// If true, the details field of the Proxy-Status header will not contain
	// connection termination details. This value defaults to “false“, i.e. the
	// “details“ field will contain connection termination details by default.
	RemoveConnectionTerminationDetails bool
	// If true, the details field of the Proxy-Status header will not contain an
	// enumeration of the Envoy ResponseFlags. This value defaults to “false“,
	// i.e. the “details“ field will contain a list of ResponseFlags by default.
	RemoveResponseFlags bool
	// If true, overwrites the existing Status header with the response code
	// recommended by the Proxy-Status spec.
	// This value defaults to “false“, i.e. the HTTP response code is not
	// overwritten.
	SetRecommendedResponseCode bool

	// Fields of oneof ProxyName:
	// If “use_node_id“ is set, Proxy-Status headers will use the Envoy's node
	// ID as the name of the proxy.
	UseNodeId *bool
	// If “literal_proxy_name“ is set, Proxy-Status headers will use this
	// value as the name of the proxy.
	LiteralProxyName *string
	// contains filtered or unexported fields
}

func (HttpConnectionManager_ProxyStatusConfig_builder) Build 

func (b0 HttpConnectionManager_ProxyStatusConfig_builder) Build() *HttpConnectionManager_ProxyStatusConfig

type HttpConnectionManager_Rds 

type HttpConnectionManager_Rds struct {
	// The connection manager’s route table will be dynamically loaded via the RDS API.
	Rds *Rds `protobuf:"bytes,3,opt,name=rds,proto3,oneof"`
}

type HttpConnectionManager_RouteConfig 

type HttpConnectionManager_RouteConfig struct {
	// The route table for the connection manager is static and is specified in this property.
	RouteConfig *v33.RouteConfiguration `protobuf:"bytes,4,opt,name=route_config,json=routeConfig,proto3,oneof"`
}

type HttpConnectionManager_ScopedRoutes 

type HttpConnectionManager_ScopedRoutes struct {
	// A route table will be dynamically assigned to each request based on request attributes
	// (e.g., the value of a header). The "routing scopes" (i.e., route tables) and "scope keys" are
	// specified in this message.
	ScopedRoutes *ScopedRoutes `protobuf:"bytes,31,opt,name=scoped_routes,json=scopedRoutes,proto3,oneof"`
}

type HttpConnectionManager_ServerHeaderTransformation 

type HttpConnectionManager_ServerHeaderTransformation int32
const (
	// Overwrite any Server header with the contents of server_name.
	HttpConnectionManager_OVERWRITE HttpConnectionManager_ServerHeaderTransformation = 0
	// If no Server header is present, append Server server_name
	// If a Server header is present, pass it through.
	HttpConnectionManager_APPEND_IF_ABSENT HttpConnectionManager_ServerHeaderTransformation = 1
	// Pass through the value of the server header, and do not append a header
	// if none is present.
	HttpConnectionManager_PASS_THROUGH HttpConnectionManager_ServerHeaderTransformation = 2
)

func (HttpConnectionManager_ServerHeaderTransformation) Descriptor 

func (HttpConnectionManager_ServerHeaderTransformation) Descriptor() protoreflect.EnumDescriptor

func (HttpConnectionManager_ServerHeaderTransformation) Enum 

func (x HttpConnectionManager_ServerHeaderTransformation) Enum() *HttpConnectionManager_ServerHeaderTransformation

func (HttpConnectionManager_ServerHeaderTransformation) Number 

func (x HttpConnectionManager_ServerHeaderTransformation) Number() protoreflect.EnumNumber

func (HttpConnectionManager_ServerHeaderTransformation) String 

func (x HttpConnectionManager_ServerHeaderTransformation) String() string

func (HttpConnectionManager_ServerHeaderTransformation) Type 

func (HttpConnectionManager_ServerHeaderTransformation) Type() protoreflect.EnumType

type HttpConnectionManager_SetCurrentClientCertDetails 

type HttpConnectionManager_SetCurrentClientCertDetails struct {

	// Whether to forward the subject of the client cert. Defaults to false.
	Subject *wrapperspb.BoolValue `protobuf:"bytes,1,opt,name=subject,proto3" json:"subject,omitempty"`
	// Whether to forward the entire client cert in URL encoded PEM format. This will appear in the
	// XFCC header comma separated from other values with the value Cert="PEM".
	// Defaults to false.
	Cert bool `protobuf:"varint,3,opt,name=cert,proto3" json:"cert,omitempty"`
	// Whether to forward the entire client cert chain (including the leaf cert) in URL encoded PEM
	// format. This will appear in the XFCC header comma separated from other values with the value
	// Chain="PEM".
	// Defaults to false.
	Chain bool `protobuf:"varint,6,opt,name=chain,proto3" json:"chain,omitempty"`
	// Whether to forward the DNS type Subject Alternative Names of the client cert.
	// Defaults to false.
	Dns bool `protobuf:"varint,4,opt,name=dns,proto3" json:"dns,omitempty"`
	// Whether to forward the URI type Subject Alternative Name of the client cert. Defaults to
	// false.
	Uri bool `protobuf:"varint,5,opt,name=uri,proto3" json:"uri,omitempty"`
	// contains filtered or unexported fields
}

[#next-free-field: 7]

func (*HttpConnectionManager_SetCurrentClientCertDetails) ClearSubject 

func (x *HttpConnectionManager_SetCurrentClientCertDetails) ClearSubject()

func (*HttpConnectionManager_SetCurrentClientCertDetails) GetCert 

func (x *HttpConnectionManager_SetCurrentClientCertDetails) GetCert() bool

func (*HttpConnectionManager_SetCurrentClientCertDetails) GetChain 

func (x *HttpConnectionManager_SetCurrentClientCertDetails) GetChain() bool

func (*HttpConnectionManager_SetCurrentClientCertDetails) GetDns 

func (x *HttpConnectionManager_SetCurrentClientCertDetails) GetDns() bool

func (*HttpConnectionManager_SetCurrentClientCertDetails) GetSubject 

func (x *HttpConnectionManager_SetCurrentClientCertDetails) GetSubject() *wrapperspb.BoolValue

func (*HttpConnectionManager_SetCurrentClientCertDetails) GetUri 

func (x *HttpConnectionManager_SetCurrentClientCertDetails) GetUri() bool

func (*HttpConnectionManager_SetCurrentClientCertDetails) HasSubject 

func (x *HttpConnectionManager_SetCurrentClientCertDetails) HasSubject() bool

func (*HttpConnectionManager_SetCurrentClientCertDetails) ProtoMessage 

func (*HttpConnectionManager_SetCurrentClientCertDetails) ProtoMessage()

func (*HttpConnectionManager_SetCurrentClientCertDetails) ProtoReflect 

func (x *HttpConnectionManager_SetCurrentClientCertDetails) ProtoReflect() protoreflect.Message

func (*HttpConnectionManager_SetCurrentClientCertDetails) Reset 

func (x *HttpConnectionManager_SetCurrentClientCertDetails) Reset()

func (*HttpConnectionManager_SetCurrentClientCertDetails) SetCert 

func (x *HttpConnectionManager_SetCurrentClientCertDetails) SetCert(v bool)

func (*HttpConnectionManager_SetCurrentClientCertDetails) SetChain 

func (x *HttpConnectionManager_SetCurrentClientCertDetails) SetChain(v bool)

func (*HttpConnectionManager_SetCurrentClientCertDetails) SetDns 

func (x *HttpConnectionManager_SetCurrentClientCertDetails) SetDns(v bool)

func (*HttpConnectionManager_SetCurrentClientCertDetails) SetSubject 

func (x *HttpConnectionManager_SetCurrentClientCertDetails) SetSubject(v *wrapperspb.BoolValue)

func (*HttpConnectionManager_SetCurrentClientCertDetails) SetUri 

func (x *HttpConnectionManager_SetCurrentClientCertDetails) SetUri(v bool)

func (*HttpConnectionManager_SetCurrentClientCertDetails) String 

func (x *HttpConnectionManager_SetCurrentClientCertDetails) String() string

type HttpConnectionManager_SetCurrentClientCertDetails_builder 

type HttpConnectionManager_SetCurrentClientCertDetails_builder struct {

	// Whether to forward the subject of the client cert. Defaults to false.
	Subject *wrapperspb.BoolValue
	// Whether to forward the entire client cert in URL encoded PEM format. This will appear in the
	// XFCC header comma separated from other values with the value Cert="PEM".
	// Defaults to false.
	Cert bool
	// Whether to forward the entire client cert chain (including the leaf cert) in URL encoded PEM
	// format. This will appear in the XFCC header comma separated from other values with the value
	// Chain="PEM".
	// Defaults to false.
	Chain bool
	// Whether to forward the DNS type Subject Alternative Names of the client cert.
	// Defaults to false.
	Dns bool
	// Whether to forward the URI type Subject Alternative Name of the client cert. Defaults to
	// false.
	Uri bool
	// contains filtered or unexported fields
}

func (HttpConnectionManager_SetCurrentClientCertDetails_builder) Build 

func (b0 HttpConnectionManager_SetCurrentClientCertDetails_builder) Build() *HttpConnectionManager_SetCurrentClientCertDetails

type HttpConnectionManager_StripAnyHostPort 

type HttpConnectionManager_StripAnyHostPort struct {
	// Determines if the port part should be removed from host/authority header before any processing
	// of request by HTTP filters or routing.
	// This affects the upstream host header unless the method is CONNECT in
	// which case if no filter adds a port the original port will be restored before headers are sent upstream.
	// Without setting this option, incoming requests with host “example:443“ will not match against
	// route with :ref:`domains<envoy_v3_api_field_config.route.v3.VirtualHost.domains>` match set to “example“. Defaults to “false“. Note that port removal is not part
	// of `HTTP spec <https://tools.ietf.org/html/rfc3986>`_ and is provided for convenience.
	// Only one of “strip_matching_host_port“ or “strip_any_host_port“ can be set.
	StripAnyHostPort bool `protobuf:"varint,42,opt,name=strip_any_host_port,json=stripAnyHostPort,proto3,oneof"`
}

type HttpConnectionManager_Tracing 

type HttpConnectionManager_Tracing struct {

	// Target percentage of requests managed by this HTTP connection manager that will be force
	// traced if the :ref:`x-client-trace-id <config_http_conn_man_headers_x-client-trace-id>`
	// header is set. This field is a direct analog for the runtime variable
	// 'tracing.client_enabled' in the :ref:`HTTP Connection Manager
	// <config_http_conn_man_runtime>`.
	// Default: 100%
	ClientSampling *v34.Percent `protobuf:"bytes,3,opt,name=client_sampling,json=clientSampling,proto3" json:"client_sampling,omitempty"`
	// 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 <config_http_conn_man_runtime>`.
	// Default: 100%
	RandomSampling *v34.Percent `protobuf:"bytes,4,opt,name=random_sampling,json=randomSampling,proto3" json:"random_sampling,omitempty"`
	// 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 an upper limit on the total configured sampling rate. For
	// instance, setting client_sampling to 100% but overall_sampling to 1% will result in only 1%
	// of client requests with the appropriate headers to be force traced. This field is a direct
	// analog for the runtime variable 'tracing.global_enabled' in the
	// :ref:`HTTP Connection Manager <config_http_conn_man_runtime>`.
	// Default: 100%
	OverallSampling *v34.Percent `protobuf:"bytes,5,opt,name=overall_sampling,json=overallSampling,proto3" json:"overall_sampling,omitempty"`
	// Whether to annotate spans with additional data. If true, spans will include logs for stream
	// events.
	Verbose bool `protobuf:"varint,6,opt,name=verbose,proto3" json:"verbose,omitempty"`
	// Maximum length of the request path to extract and include in the HttpUrl tag. Used to
	// truncate lengthy request paths to meet the needs of a tracing backend.
	// Default: 256
	MaxPathTagLength *wrapperspb.UInt32Value `protobuf:"bytes,7,opt,name=max_path_tag_length,json=maxPathTagLength,proto3" json:"max_path_tag_length,omitempty"`
	// A list of custom tags with unique tag name to create tags for the active span.
	CustomTags []*v35.CustomTag `protobuf:"bytes,8,rep,name=custom_tags,json=customTags,proto3" json:"custom_tags,omitempty"`
	// Configuration for an external tracing provider.
	// If not specified, no tracing will be performed.
	Provider *v36.Tracing_Http `protobuf:"bytes,9,opt,name=provider,proto3" json:"provider,omitempty"`
	// Create separate tracing span for each upstream request if true. And if this flag is set to true,
	// the tracing provider will assume that Envoy will be independent hop in the trace chain and may
	// set span type to client or server based on this flag.
	// This will deprecate the
	// :ref:`start_child_span <envoy_v3_api_field_extensions.filters.http.router.v3.Router.start_child_span>`
	// in the router.
	//
	// Users should set appropriate value based on their tracing provider and actual scenario:
	//
	//   - If Envoy is used as sidecar and users want to make the sidecar and its application as only one
	//     hop in the trace chain, this flag should be set to false. And please also make sure the
	//     :ref:`start_child_span <envoy_v3_api_field_extensions.filters.http.router.v3.Router.start_child_span>`
	//     in the router is not set to true.
	//   - If Envoy is used as gateway or independent proxy, or users want to make the sidecar and its
	//     application as different hops in the trace chain, this flag should be set to true.
	//   - If tracing provider that has explicit requirements on span creation (like SkyWalking),
	//     this flag should be set to true.
	//
	// The default value is false for now for backward compatibility.
	SpawnUpstreamSpan *wrapperspb.BoolValue `protobuf:"bytes,10,opt,name=spawn_upstream_span,json=spawnUpstreamSpan,proto3" json:"spawn_upstream_span,omitempty"`
	// The operation name of the span which will be used for tracing.
	//
	// The same :ref:`format specifier <config_access_log_format>` as used for
	// :ref:`HTTP access logging <config_access_log>` applies here, however
	// unknown specifier values are replaced with the empty string instead of “-“.
	//
	// This field will take precedence over and make following settings ineffective:
	//
	//   - :ref:`route decorator <envoy_v3_api_field_config.route.v3.Route.decorator>` and
	//   - :ref:`x-envoy-decorator-operation <config_http_filters_router_x-envoy-decorator-operation>`
	//     header will be ignored.
	Operation string `protobuf:"bytes,11,opt,name=operation,proto3" json:"operation,omitempty"`
	// The operation name of the upstream span which will be used for tracing.
	// This only takes effect when “spawn_upstream_span“ is set to true and the upstream
	// span is created.
	//
	// The same :ref:`format specifier <config_access_log_format>` as used for
	// :ref:`HTTP access logging <config_access_log>` applies here, however
	// unknown specifier values are replaced with the empty string instead of “-“.
	UpstreamOperation string `protobuf:"bytes,12,opt,name=upstream_operation,json=upstreamOperation,proto3" json:"upstream_operation,omitempty"`
	// contains filtered or unexported fields
}

[#next-free-field: 13]

func (*HttpConnectionManager_Tracing) ClearClientSampling 

func (x *HttpConnectionManager_Tracing) ClearClientSampling()

func (*HttpConnectionManager_Tracing) ClearMaxPathTagLength 

func (x *HttpConnectionManager_Tracing) ClearMaxPathTagLength()

func (*HttpConnectionManager_Tracing) ClearOverallSampling 

func (x *HttpConnectionManager_Tracing) ClearOverallSampling()

func (*HttpConnectionManager_Tracing) ClearProvider 

func (x *HttpConnectionManager_Tracing) ClearProvider()

func (*HttpConnectionManager_Tracing) ClearRandomSampling 

func (x *HttpConnectionManager_Tracing) ClearRandomSampling()

func (*HttpConnectionManager_Tracing) ClearSpawnUpstreamSpan 

func (x *HttpConnectionManager_Tracing) ClearSpawnUpstreamSpan()

func (*HttpConnectionManager_Tracing) GetClientSampling 

func (x *HttpConnectionManager_Tracing) GetClientSampling() *v34.Percent

func (*HttpConnectionManager_Tracing) GetCustomTags 

func (x *HttpConnectionManager_Tracing) GetCustomTags() []*v35.CustomTag

func (*HttpConnectionManager_Tracing) GetMaxPathTagLength 

func (x *HttpConnectionManager_Tracing) GetMaxPathTagLength() *wrapperspb.UInt32Value

func (*HttpConnectionManager_Tracing) GetOperation 

func (x *HttpConnectionManager_Tracing) GetOperation() string

func (*HttpConnectionManager_Tracing) GetOverallSampling 

func (x *HttpConnectionManager_Tracing) GetOverallSampling() *v34.Percent

func (*HttpConnectionManager_Tracing) GetProvider 

func (x *HttpConnectionManager_Tracing) GetProvider() *v36.Tracing_Http

func (*HttpConnectionManager_Tracing) GetRandomSampling 

func (x *HttpConnectionManager_Tracing) GetRandomSampling() *v34.Percent

func (*HttpConnectionManager_Tracing) GetSpawnUpstreamSpan 

func (x *HttpConnectionManager_Tracing) GetSpawnUpstreamSpan() *wrapperspb.BoolValue

func (*HttpConnectionManager_Tracing) GetUpstreamOperation 

func (x *HttpConnectionManager_Tracing) GetUpstreamOperation() string

func (*HttpConnectionManager_Tracing) GetVerbose 

func (x *HttpConnectionManager_Tracing) GetVerbose() bool

func (*HttpConnectionManager_Tracing) HasClientSampling 

func (x *HttpConnectionManager_Tracing) HasClientSampling() bool

func (*HttpConnectionManager_Tracing) HasMaxPathTagLength 

func (x *HttpConnectionManager_Tracing) HasMaxPathTagLength() bool

func (*HttpConnectionManager_Tracing) HasOverallSampling 

func (x *HttpConnectionManager_Tracing) HasOverallSampling() bool

func (*HttpConnectionManager_Tracing) HasProvider 

func (x *HttpConnectionManager_Tracing) HasProvider() bool

func (*HttpConnectionManager_Tracing) HasRandomSampling 

func (x *HttpConnectionManager_Tracing) HasRandomSampling() bool

func (*HttpConnectionManager_Tracing) HasSpawnUpstreamSpan 

func (x *HttpConnectionManager_Tracing) HasSpawnUpstreamSpan() bool

func (*HttpConnectionManager_Tracing) ProtoMessage 

func (*HttpConnectionManager_Tracing) ProtoMessage()

func (*HttpConnectionManager_Tracing) ProtoReflect 

func (x *HttpConnectionManager_Tracing) ProtoReflect() protoreflect.Message

func (*HttpConnectionManager_Tracing) Reset 

func (x *HttpConnectionManager_Tracing) Reset()

func (*HttpConnectionManager_Tracing) SetClientSampling 

func (x *HttpConnectionManager_Tracing) SetClientSampling(v *v34.Percent)

func (*HttpConnectionManager_Tracing) SetCustomTags 

func (x *HttpConnectionManager_Tracing) SetCustomTags(v []*v35.CustomTag)

func (*HttpConnectionManager_Tracing) SetMaxPathTagLength 

func (x *HttpConnectionManager_Tracing) SetMaxPathTagLength(v *wrapperspb.UInt32Value)

func (*HttpConnectionManager_Tracing) SetOperation 

func (x *HttpConnectionManager_Tracing) SetOperation(v string)

func (*HttpConnectionManager_Tracing) SetOverallSampling 

func (x *HttpConnectionManager_Tracing) SetOverallSampling(v *v34.Percent)

func (*HttpConnectionManager_Tracing) SetProvider 

func (x *HttpConnectionManager_Tracing) SetProvider(v *v36.Tracing_Http)

func (*HttpConnectionManager_Tracing) SetRandomSampling 

func (x *HttpConnectionManager_Tracing) SetRandomSampling(v *v34.Percent)

func (*HttpConnectionManager_Tracing) SetSpawnUpstreamSpan 

func (x *HttpConnectionManager_Tracing) SetSpawnUpstreamSpan(v *wrapperspb.BoolValue)

func (*HttpConnectionManager_Tracing) SetUpstreamOperation 

func (x *HttpConnectionManager_Tracing) SetUpstreamOperation(v string)

func (*HttpConnectionManager_Tracing) SetVerbose 

func (x *HttpConnectionManager_Tracing) SetVerbose(v bool)

func (*HttpConnectionManager_Tracing) String 

func (x *HttpConnectionManager_Tracing) String() string

type HttpConnectionManager_Tracing_OperationName 

type HttpConnectionManager_Tracing_OperationName int32

This OperationName makes no sense and is unnecessary in the current tracing API. [#not-implemented-hide:] 

const (
	// The HTTP listener is used for ingress/incoming requests.
	HttpConnectionManager_Tracing_INGRESS HttpConnectionManager_Tracing_OperationName = 0
	// The HTTP listener is used for egress/outgoing requests.
	HttpConnectionManager_Tracing_EGRESS HttpConnectionManager_Tracing_OperationName = 1
)

func (HttpConnectionManager_Tracing_OperationName) Descriptor 

func (HttpConnectionManager_Tracing_OperationName) Descriptor() protoreflect.EnumDescriptor

func (HttpConnectionManager_Tracing_OperationName) Enum 

func (x HttpConnectionManager_Tracing_OperationName) Enum() *HttpConnectionManager_Tracing_OperationName

func (HttpConnectionManager_Tracing_OperationName) Number 

func (x HttpConnectionManager_Tracing_OperationName) Number() protoreflect.EnumNumber

func (HttpConnectionManager_Tracing_OperationName) String 

func (x HttpConnectionManager_Tracing_OperationName) String() string

func (HttpConnectionManager_Tracing_OperationName) Type 

func (HttpConnectionManager_Tracing_OperationName) Type() protoreflect.EnumType

type HttpConnectionManager_Tracing_builder 

type HttpConnectionManager_Tracing_builder struct {

	// Target percentage of requests managed by this HTTP connection manager that will be force
	// traced if the :ref:`x-client-trace-id <config_http_conn_man_headers_x-client-trace-id>`
	// header is set. This field is a direct analog for the runtime variable
	// 'tracing.client_enabled' in the :ref:`HTTP Connection Manager
	// <config_http_conn_man_runtime>`.
	// Default: 100%
	ClientSampling *v34.Percent
	// 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 <config_http_conn_man_runtime>`.
	// Default: 100%
	RandomSampling *v34.Percent
	// 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 an upper limit on the total configured sampling rate. For
	// instance, setting client_sampling to 100% but overall_sampling to 1% will result in only 1%
	// of client requests with the appropriate headers to be force traced. This field is a direct
	// analog for the runtime variable 'tracing.global_enabled' in the
	// :ref:`HTTP Connection Manager <config_http_conn_man_runtime>`.
	// Default: 100%
	OverallSampling *v34.Percent
	// Whether to annotate spans with additional data. If true, spans will include logs for stream
	// events.
	Verbose bool
	// Maximum length of the request path to extract and include in the HttpUrl tag. Used to
	// truncate lengthy request paths to meet the needs of a tracing backend.
	// Default: 256
	MaxPathTagLength *wrapperspb.UInt32Value
	// A list of custom tags with unique tag name to create tags for the active span.
	CustomTags []*v35.CustomTag
	// Configuration for an external tracing provider.
	// If not specified, no tracing will be performed.
	Provider *v36.Tracing_Http
	// Create separate tracing span for each upstream request if true. And if this flag is set to true,
	// the tracing provider will assume that Envoy will be independent hop in the trace chain and may
	// set span type to client or server based on this flag.
	// This will deprecate the
	// :ref:`start_child_span <envoy_v3_api_field_extensions.filters.http.router.v3.Router.start_child_span>`
	// in the router.
	//
	// Users should set appropriate value based on their tracing provider and actual scenario:
	//
	//   - If Envoy is used as sidecar and users want to make the sidecar and its application as only one
	//     hop in the trace chain, this flag should be set to false. And please also make sure the
	//     :ref:`start_child_span <envoy_v3_api_field_extensions.filters.http.router.v3.Router.start_child_span>`
	//     in the router is not set to true.
	//   - If Envoy is used as gateway or independent proxy, or users want to make the sidecar and its
	//     application as different hops in the trace chain, this flag should be set to true.
	//   - If tracing provider that has explicit requirements on span creation (like SkyWalking),
	//     this flag should be set to true.
	//
	// The default value is false for now for backward compatibility.
	SpawnUpstreamSpan *wrapperspb.BoolValue
	// The operation name of the span which will be used for tracing.
	//
	// The same :ref:`format specifier <config_access_log_format>` as used for
	// :ref:`HTTP access logging <config_access_log>` applies here, however
	// unknown specifier values are replaced with the empty string instead of “-“.
	//
	// This field will take precedence over and make following settings ineffective:
	//
	//   - :ref:`route decorator <envoy_v3_api_field_config.route.v3.Route.decorator>` and
	//   - :ref:`x-envoy-decorator-operation <config_http_filters_router_x-envoy-decorator-operation>`
	//     header will be ignored.
	Operation string
	// The operation name of the upstream span which will be used for tracing.
	// This only takes effect when “spawn_upstream_span“ is set to true and the upstream
	// span is created.
	//
	// The same :ref:`format specifier <config_access_log_format>` as used for
	// :ref:`HTTP access logging <config_access_log>` applies here, however
	// unknown specifier values are replaced with the empty string instead of “-“.
	UpstreamOperation string
	// contains filtered or unexported fields
}

func (HttpConnectionManager_Tracing_builder) Build 

func (b0 HttpConnectionManager_Tracing_builder) Build() *HttpConnectionManager_Tracing

type HttpConnectionManager_UpgradeConfig 

type HttpConnectionManager_UpgradeConfig struct {

	// The case-insensitive name of this upgrade, e.g. "websocket".
	// For each upgrade type present in upgrade_configs, requests with
	// Upgrade: [upgrade_type]
	// will be proxied upstream.
	UpgradeType string `protobuf:"bytes,1,opt,name=upgrade_type,json=upgradeType,proto3" json:"upgrade_type,omitempty"`
	// If present, this represents the filter chain which will be created for
	// this type of upgrade. If no filters are present, the filter chain for
	// HTTP connections will be used for this upgrade type.
	Filters []*HttpFilter `protobuf:"bytes,2,rep,name=filters,proto3" json:"filters,omitempty"`
	// Determines if upgrades are enabled or disabled by default. Defaults to true.
	// This can be overridden on a per-route basis with :ref:`cluster
	// <envoy_v3_api_field_config.route.v3.RouteAction.upgrade_configs>` as documented in the
	// :ref:`upgrade documentation <arch_overview_upgrades>`.
	Enabled *wrapperspb.BoolValue `protobuf:"bytes,3,opt,name=enabled,proto3" json:"enabled,omitempty"`
	// contains filtered or unexported fields
}

The configuration for HTTP upgrades. For each upgrade type desired, an UpgradeConfig must be added.

.. warning:: 

The current implementation of upgrade headers does not handle multi-valued upgrade headers. Support for
multi-valued headers may be added in the future if needed.

.. warning:: 

The current implementation of upgrade headers does not work with HTTP/2 upstreams.

func (*HttpConnectionManager_UpgradeConfig) ClearEnabled 

func (x *HttpConnectionManager_UpgradeConfig) ClearEnabled()

func (*HttpConnectionManager_UpgradeConfig) GetEnabled 

func (x *HttpConnectionManager_UpgradeConfig) GetEnabled() *wrapperspb.BoolValue

func (*HttpConnectionManager_UpgradeConfig) GetFilters 

func (x *HttpConnectionManager_UpgradeConfig) GetFilters() []*HttpFilter

func (*HttpConnectionManager_UpgradeConfig) GetUpgradeType 

func (x *HttpConnectionManager_UpgradeConfig) GetUpgradeType() string

func (*HttpConnectionManager_UpgradeConfig) HasEnabled 

func (x *HttpConnectionManager_UpgradeConfig) HasEnabled() bool

func (*HttpConnectionManager_UpgradeConfig) ProtoMessage 

func (*HttpConnectionManager_UpgradeConfig) ProtoMessage()

func (*HttpConnectionManager_UpgradeConfig) ProtoReflect 

func (x *HttpConnectionManager_UpgradeConfig) ProtoReflect() protoreflect.Message

func (*HttpConnectionManager_UpgradeConfig) Reset 

func (x *HttpConnectionManager_UpgradeConfig) Reset()

func (*HttpConnectionManager_UpgradeConfig) SetEnabled 

func (x *HttpConnectionManager_UpgradeConfig) SetEnabled(v *wrapperspb.BoolValue)

func (*HttpConnectionManager_UpgradeConfig) SetFilters 

func (x *HttpConnectionManager_UpgradeConfig) SetFilters(v []*HttpFilter)

func (*HttpConnectionManager_UpgradeConfig) SetUpgradeType 

func (x *HttpConnectionManager_UpgradeConfig) SetUpgradeType(v string)

func (*HttpConnectionManager_UpgradeConfig) String 

func (x *HttpConnectionManager_UpgradeConfig) String() string

type HttpConnectionManager_UpgradeConfig_builder 

type HttpConnectionManager_UpgradeConfig_builder struct {

	// The case-insensitive name of this upgrade, e.g. "websocket".
	// For each upgrade type present in upgrade_configs, requests with
	// Upgrade: [upgrade_type]
	// will be proxied upstream.
	UpgradeType string
	// If present, this represents the filter chain which will be created for
	// this type of upgrade. If no filters are present, the filter chain for
	// HTTP connections will be used for this upgrade type.
	Filters []*HttpFilter
	// Determines if upgrades are enabled or disabled by default. Defaults to true.
	// This can be overridden on a per-route basis with :ref:`cluster
	// <envoy_v3_api_field_config.route.v3.RouteAction.upgrade_configs>` as documented in the
	// :ref:`upgrade documentation <arch_overview_upgrades>`.
	Enabled *wrapperspb.BoolValue
	// contains filtered or unexported fields
}

func (HttpConnectionManager_UpgradeConfig_builder) Build 

func (b0 HttpConnectionManager_UpgradeConfig_builder) Build() *HttpConnectionManager_UpgradeConfig

type HttpConnectionManager_builder 

type HttpConnectionManager_builder struct {

	// Supplies the type of codec that the connection manager should use.
	CodecType HttpConnectionManager_CodecType
	// The human readable prefix to use when emitting statistics for the
	// connection manager. See the :ref:`statistics documentation <config_http_conn_man_stats>` for
	// more information.
	StatPrefix string
	// Fields of oneof RouteSpecifier:
	// The connection manager’s route table will be dynamically loaded via the RDS API.
	Rds *Rds
	// The route table for the connection manager is static and is specified in this property.
	RouteConfig *v33.RouteConfiguration
	// A route table will be dynamically assigned to each request based on request attributes
	// (e.g., the value of a header). The "routing scopes" (i.e., route tables) and "scope keys" are
	// specified in this message.
	ScopedRoutes *ScopedRoutes
	// -- end of RouteSpecifier
	// A list of individual HTTP filters that make up the filter chain for
	// requests made to the connection manager. :ref:`Order matters <arch_overview_http_filters_ordering>`
	// as the filters are processed sequentially as request events happen.
	HttpFilters []*HttpFilter
	// Whether the connection manager manipulates the :ref:`config_http_conn_man_headers_user-agent`
	// and :ref:`config_http_conn_man_headers_downstream-service-cluster` headers. See the linked
	// documentation for more information. Defaults to false.
	AddUserAgent *wrapperspb.BoolValue
	// Presence of the object defines whether the connection manager
	// emits :ref:`tracing <arch_overview_tracing>` data to the :ref:`configured tracing provider
	// <envoy_v3_api_msg_config.trace.v3.Tracing>`.
	Tracing *HttpConnectionManager_Tracing
	// Additional settings for HTTP requests handled by the connection manager. These will be
	// applicable to both HTTP/1.1 and HTTP/2 requests.
	CommonHttpProtocolOptions *v3.HttpProtocolOptions
	// If set to “true“, Envoy will not initiate an immediate drain timer for downstream HTTP/1 connections
	// once :ref:`common_http_protocol_options.max_connection_duration
	// <envoy_v3_api_field_config.core.v3.HttpProtocolOptions.max_connection_duration>` is exceeded.
	// Instead, Envoy will wait until the next downstream request arrives, add a “connection: close“ header
	// to the response, and then gracefully close the connection once the stream has completed.
	//
	// This behavior adheres to `RFC 9112, Section 9.6 <https://www.rfc-editor.org/rfc/rfc9112#name-tear-down>`_.
	//
	// If set to “false“, exceeding “max_connection_duration“ triggers Envoy's default drain behavior for HTTP/1,
	// where the connection is eventually closed after all active streams finish.
	//
	// This option has no effect if “max_connection_duration“ is not configured.
	// Defaults to “false“.
	Http1SafeMaxConnectionDuration bool
	// Additional HTTP/1 settings that are passed to the HTTP/1 codec.
	// [#comment:TODO: The following fields are ignored when the
	// :ref:`header validation configuration <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.typed_header_validation_config>`
	// is present:
	// 1. :ref:`allow_chunked_length <envoy_v3_api_field_config.core.v3.Http1ProtocolOptions.allow_chunked_length>`]
	HttpProtocolOptions *v3.Http1ProtocolOptions
	// Additional HTTP/2 settings that are passed directly to the HTTP/2 codec.
	Http2ProtocolOptions *v3.Http2ProtocolOptions
	// Additional HTTP/3 settings that are passed directly to the HTTP/3 codec.
	Http3ProtocolOptions *v3.Http3ProtocolOptions
	// An optional override that the connection manager will write to the server
	// header in responses. If not set, the default is “envoy“.
	ServerName string
	// Defines the action to be applied to the Server header on the response path.
	// By default, Envoy will overwrite the header with the value specified in
	// server_name.
	ServerHeaderTransformation HttpConnectionManager_ServerHeaderTransformation
	// Allows for explicit transformation of the :scheme header on the request path.
	// If not set, Envoy's default :ref:`scheme  <config_http_conn_man_headers_scheme>`
	// handling applies.
	SchemeHeaderTransformation *v3.SchemeHeaderTransformation
	// The maximum request headers size for incoming connections.
	// If unconfigured, the default max request headers allowed is 60 KiB.
	// The default value can be overridden by setting runtime key “envoy.reloadable_features.max_request_headers_size_kb“.
	// Requests that exceed this limit will receive a 431 response.
	//
	// .. note::
	//
	//	Currently some protocol codecs impose limits on the maximum size of a single header.
	//
	//	* HTTP/2 (when using nghttp2) limits a single header to around 100kb.
	//	* HTTP/3 limits a single header to around 1024kb.
	MaxRequestHeadersKb *wrapperspb.UInt32Value
	// The stream idle timeout for connections managed by the connection manager.
	// If not specified, this defaults to 5 minutes. The default value was selected
	// so as not to interfere with any smaller configured timeouts that may have
	// existed in configurations prior to the introduction of this feature, while
	// introducing robustness to TCP connections that terminate without a FIN.
	//
	// This idle timeout applies to new streams and is overridable by the
	// :ref:`route-level idle_timeout
	// <envoy_v3_api_field_config.route.v3.RouteAction.idle_timeout>`. Even on a stream in
	// which the override applies, prior to receipt of the initial request
	// headers, the :ref:`stream_idle_timeout
	// <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.stream_idle_timeout>`
	// applies. Each time an encode/decode event for headers or data is processed
	// for the stream, the timer will be reset. If the timeout fires, the stream
	// is terminated with a 408 Request Timeout error code if no upstream response
	// header has been received, otherwise a stream reset occurs.
	//
	// If the :ref:`overload action <config_overload_manager_overload_actions>` "envoy.overload_actions.reduce_timeouts"
	// is configured, this timeout is scaled according to the value for
	// :ref:`HTTP_DOWNSTREAM_STREAM_IDLE <envoy_v3_api_enum_value_config.overload.v3.ScaleTimersOverloadActionConfig.TimerType.HTTP_DOWNSTREAM_STREAM_IDLE>`.
	//
	// Note that it is possible to idle timeout even if the wire traffic for a stream is non-idle, due
	// to the granularity of events presented to the connection manager. For example, while receiving
	// very large request headers, it may be the case that there is traffic regularly arriving on the
	// wire while the connection manage is only able to observe the end-of-headers event, hence the
	// stream may still idle timeout.
	//
	// A value of 0 will completely disable the connection manager stream idle
	// timeout, although per-route idle timeout overrides will continue to apply.
	//
	// This timeout is also used as the default value for :ref:`stream_flush_timeout
	// <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.stream_flush_timeout>`.
	StreamIdleTimeout *durationpb.Duration
	// The stream flush timeout for connections managed by the connection manager.
	//
	// If not specified, the value of stream_idle_timeout is used. This is for backwards compatibility
	// since this was the original behavior. In essence this timeout is an override for the
	// stream_idle_timeout that applies specifically to the end of stream flush case.
	//
	// This timeout specifies the amount of time that Envoy will wait for the peer to open enough
	// window to write any remaining stream data once the entirety of stream data (local end stream is
	// true) has been buffered pending available window. In other words, this timeout defends against
	// a peer that does not release enough window to completely write the stream, even though all
	// data has been proxied within available flow control windows. If the timeout is hit in this
	// case, the :ref:`tx_flush_timeout <config_http_conn_man_stats_per_codec>` counter will be
	// incremented. Note that :ref:`max_stream_duration
	// <envoy_v3_api_field_config.core.v3.HttpProtocolOptions.max_stream_duration>` does not apply to
	// this corner case.
	StreamFlushTimeout *durationpb.Duration
	// The amount of time that Envoy will wait for the entire request to be received.
	// The timer is activated when the request is initiated, and is disarmed when the last byte of the
	// request is sent upstream (i.e. all decoding filters have processed the request), OR when the
	// response is initiated. If not specified or set to 0, this timeout is disabled.
	RequestTimeout *durationpb.Duration
	// The amount of time that Envoy will wait for the request headers to be received. The timer is
	// activated when the first byte of the headers is received, and is disarmed when the last byte of
	// the headers has been received. If not specified or set to 0, this timeout is disabled.
	RequestHeadersTimeout *durationpb.Duration
	// The time that Envoy will wait between sending an HTTP/2 “shutdown
	// notification” (GOAWAY frame with max stream ID) and a final GOAWAY frame.
	// This is used so that Envoy provides a grace period for new streams that
	// race with the final GOAWAY frame. During this grace period, Envoy will
	// continue to accept new streams. After the grace period, a final GOAWAY
	// frame is sent and Envoy will start refusing new streams. Draining occurs
	// either when a connection hits the idle timeout, when :ref:`max_connection_duration
	// <envoy_v3_api_field_config.core.v3.HttpProtocolOptions.max_connection_duration>`
	// is reached, or during general server draining. The default grace period is
	// 5000 milliseconds (5 seconds) if this option is not specified.
	DrainTimeout *durationpb.Duration
	// The delayed close timeout is for downstream connections managed by the HTTP connection manager.
	// It is defined as a grace period after connection close processing has been locally initiated
	// during which Envoy will wait for the peer to close (i.e., a TCP FIN/RST is received by Envoy
	// from the downstream connection) prior to Envoy closing the socket associated with that
	// connection.
	//
	// .. note::
	//
	//	This timeout is enforced even when the socket associated with the downstream connection is pending a flush of
	//	the write buffer. However, any progress made writing data to the socket will restart the timer associated with
	//	this timeout. This means that the total grace period for a socket in this state will be
	//	<total_time_waiting_for_write_buffer_flushes>+<delayed_close_timeout>.
	//
	// Delaying Envoy's connection close and giving the peer the opportunity to initiate the close
	// sequence mitigates a race condition that exists when downstream clients do not drain/process
	// data in a connection's receive buffer after a remote close has been detected via a socket
	// “write()“. This race leads to such clients failing to process the response code sent by Envoy,
	// which could result in erroneous downstream processing.
	//
	// If the timeout triggers, Envoy will close the connection's socket.
	//
	// The default timeout is 1000 ms if this option is not specified.
	//
	// .. note::
	//
	//	To be useful in avoiding the race condition described above, this timeout must be set
	//	to *at least* <max round trip time expected between clients and Envoy>+<100ms to account for
	//	a reasonable "worst" case processing time for a full iteration of Envoy's event loop>.
	//
	// .. warning::
	//
	//	A value of “0“ will completely disable delayed close processing. When disabled, the downstream
	//	connection's socket will be closed immediately after the write flush is completed or will
	//	never close if the write flush does not complete.
	DelayedCloseTimeout *durationpb.Duration
	// Configuration for :ref:`HTTP access logs <arch_overview_access_logs>`
	// emitted by the connection manager.
	AccessLog []*v31.AccessLog
	// The interval to flush the above access logs.
	//
	// .. attention::
	//
	//	This field is deprecated in favor of
	//	:ref:`access_log_flush_interval
	//	<envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.HcmAccessLogOptions.access_log_flush_interval>`.
	//	Note that if both this field and :ref:`access_log_flush_interval
	//	<envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.HcmAccessLogOptions.access_log_flush_interval>`
	//	are specified, the former (deprecated field) is ignored.
	//
	// Deprecated: Marked as deprecated in envoy/extensions/filters/network/http_connection_manager/v3/http_connection_manager.proto.
	AccessLogFlushInterval *durationpb.Duration
	// If set to true, HCM will flush an access log once when a new HTTP request is received, after the request
	// headers have been evaluated, and before iterating through the HTTP filter chain.
	//
	// .. attention::
	//
	//	This field is deprecated in favor of
	//	:ref:`flush_access_log_on_new_request
	//	<envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.HcmAccessLogOptions.flush_access_log_on_new_request>`.
	//	Note that if both this field and :ref:`flush_access_log_on_new_request
	//	<envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.HcmAccessLogOptions.flush_access_log_on_new_request>`
	//	are specified, the former (deprecated field) is ignored.
	//
	// Deprecated: Marked as deprecated in envoy/extensions/filters/network/http_connection_manager/v3/http_connection_manager.proto.
	FlushAccessLogOnNewRequest bool
	// Additional access log options for HTTP connection manager.
	AccessLogOptions *HttpConnectionManager_HcmAccessLogOptions
	// If set to true, the connection manager will use the real remote address
	// of the client connection when determining internal versus external origin and manipulating
	// various headers. If set to false or absent, the connection manager will use the
	// :ref:`config_http_conn_man_headers_x-forwarded-for` HTTP header. See the documentation for
	// :ref:`config_http_conn_man_headers_x-forwarded-for`,
	// :ref:`config_http_conn_man_headers_x-envoy-internal`, and
	// :ref:`config_http_conn_man_headers_x-envoy-external-address` for more information.
	UseRemoteAddress *wrapperspb.BoolValue
	// The number of additional ingress proxy hops from the right side of the
	// :ref:`config_http_conn_man_headers_x-forwarded-for` HTTP header to trust when
	// determining the origin client's IP address. The default is zero if this option
	// is not specified. See the documentation for
	// :ref:`config_http_conn_man_headers_x-forwarded-for` for more information.
	XffNumTrustedHops uint32
	// Configuration for original IP detection extensions.
	//
	// When these extensions are configured, Envoy will invoke them with the incoming request headers and
	// details about the downstream connection, including the directly connected address. Each extension uses
	// this information to determine the effective remote IP address for the request. If an extension cannot
	// identify the original IP address and isn't set to reject the request, Envoy will sequentially attempt
	// the remaining extensions until one successfully determines the IP or explicitly rejects the request.
	// If all extensions fail without rejection, Envoy defaults to using the directly connected remote address.
	//
	// .. warning::
	//
	//	These extensions cannot be configured simultaneously with :ref:`use_remote_address
	//	<envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.use_remote_address>`
	//	or :ref:`xff_num_trusted_hops
	//	<envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.xff_num_trusted_hops>`.
	//
	// [#extension-category: envoy.http.original_ip_detection]
	OriginalIpDetectionExtensions []*v3.TypedExtensionConfig
	// The configuration for the early header mutation extensions.
	//
	// When configured the extensions will be called before any routing, tracing, or any filter processing.
	// Each extension will be applied in the order they are configured.
	// If the same header is mutated by multiple extensions, then the last extension will win.
	//
	// [#extension-category: envoy.http.early_header_mutation]
	EarlyHeaderMutationExtensions []*v3.TypedExtensionConfig
	// Configures what network addresses are considered internal for stats and header sanitation
	// purposes. If unspecified, only RFC1918 IP addresses will be considered internal.
	// See the documentation for :ref:`config_http_conn_man_headers_x-envoy-internal` for more
	// information about internal/external addresses.
	//
	// .. warning::
	//
	//	As of Envoy 1.33.0 no IP addresses will be considered trusted. If you have tooling such as probes
	//	on your private network which need to be treated as trusted (e.g. changing arbitrary x-envoy headers)
	//	you will have to manually include those addresses or CIDR ranges like:
	//
	// .. validated-code-block:: yaml
	//
	//	:type-name: envoy.extensions.filters.network.http_connection_manager.v3.InternalAddressConfig
	//
	//	cidr_ranges:
	//	    address_prefix: 10.0.0.0
	//	    prefix_len: 8
	//	cidr_ranges:
	//	    address_prefix: 192.168.0.0
	//	    prefix_len: 16
	//	cidr_ranges:
	//	    address_prefix: 172.16.0.0
	//	    prefix_len: 12
	//	cidr_ranges:
	//	    address_prefix: 127.0.0.1
	//	    prefix_len: 32
	//	cidr_ranges:
	//	    address_prefix: fd00::
	//	    prefix_len: 8
	//	cidr_ranges:
	//	    address_prefix: ::1
	//	    prefix_len: 128
	InternalAddressConfig *HttpConnectionManager_InternalAddressConfig
	// If set, Envoy will not append the remote address to the
	// :ref:`config_http_conn_man_headers_x-forwarded-for` HTTP header. This may be used in
	// conjunction with HTTP filters that explicitly manipulate XFF after the HTTP connection manager
	// has mutated the request headers. While :ref:`use_remote_address
	// <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.use_remote_address>`
	// will also suppress XFF addition, it has consequences for logging and other
	// Envoy uses of the remote address, so “skip_xff_append“ should be used
	// when only an elision of XFF addition is intended.
	SkipXffAppend bool
	// Via header value to append to request and response headers. If this is
	// empty, no via header will be appended.
	Via string
	// Whether the connection manager will generate the :ref:`x-request-id
	// <config_http_conn_man_headers_x-request-id>` header if it does not exist. This defaults to
	// true. Generating a random UUID4 is expensive so in high throughput scenarios where this feature
	// is not desired it can be disabled.
	GenerateRequestId *wrapperspb.BoolValue
	// Whether the connection manager will keep the :ref:`x-request-id
	// <config_http_conn_man_headers_x-request-id>` header if passed for a request that is edge
	// (Edge request is the request from external clients to front Envoy) and not reset it, which
	// is the current Envoy behaviour. This defaults to false.
	PreserveExternalRequestId bool
	// If set, Envoy will always set :ref:`x-request-id <config_http_conn_man_headers_x-request-id>` header in response.
	// If this is false or not set, the request ID is returned in responses only if tracing is forced using
	// :ref:`x-envoy-force-trace <config_http_conn_man_headers_x-envoy-force-trace>` header.
	AlwaysSetRequestIdInResponse bool
	// How to handle the :ref:`config_http_conn_man_headers_x-forwarded-client-cert` (XFCC) HTTP
	// header.
	ForwardClientCertDetails HttpConnectionManager_ForwardClientCertDetails
	// This field is valid only when :ref:`forward_client_cert_details
	// <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.forward_client_cert_details>`
	// is APPEND_FORWARD or SANITIZE_SET and the client connection is mTLS. It specifies the fields in
	// the client certificate to be forwarded. Note that in the
	// :ref:`config_http_conn_man_headers_x-forwarded-client-cert` header, “Hash“ is always set, and
	// “By“ is always set when the client certificate presents the URI type Subject Alternative Name
	// value.
	SetCurrentClientCertDetails *HttpConnectionManager_SetCurrentClientCertDetails
	// The matcher for forwarding client cert details. This allows per-request configuration
	// of forward client cert behavior based on request properties. If a matcher is configured
	// and matches a request, the matched action's forward client cert config will be used.
	// If the matcher is not configured or doesn't match, the static
	// :ref:`forward_client_cert_details
	// <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.forward_client_cert_details>`
	// and
	// :ref:`set_current_client_cert_details
	// <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.set_current_client_cert_details>`
	// config will be used as fallback.
	//
	// Example: If the x-forwarded-client-cert header contains "trusted-client", use APPEND_FORWARD,
	// otherwise use SANITIZE_SET:
	//
	// .. code-block:: yaml
	//
	//	forward_client_cert_matcher:
	//	  matcher_list:
	//	    matchers:
	//	    - predicate:
	//	        single_predicate:
	//	          input:
	//	            name: envoy.matching.inputs.request_headers
	//	            typed_config:
	//	              "@type": type.googleapis.com/envoy.type.matcher.v3.HttpRequestHeaderMatchInput
	//	              header_name: "x-forwarded-client-cert"
	//	          value_match:
	//	            string_match:
	//	              contains: "trusted-client"
	//	      on_match:
	//	        action:
	//	          name: forward_client_cert
	//	          typed_config:
	//	            "@type": type.googleapis.com/envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.ForwardClientCertConfig
	//	            forward_client_cert_details: APPEND_FORWARD
	//	            set_current_client_cert_details:
	//	              uri: true
	//	  on_no_match:
	//	    action:
	//	      name: forward_client_cert
	//	      typed_config:
	//	        "@type": type.googleapis.com/envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.ForwardClientCertConfig
	//	        forward_client_cert_details: SANITIZE_SET
	//	        set_current_client_cert_details:
	//	          uri: true
	ForwardClientCertMatcher *v32.Matcher
	// If proxy_100_continue is true, Envoy will proxy incoming "Expect:
	// 100-continue" headers upstream, and forward "100 Continue" responses
	// downstream. If this is false or not set, Envoy will instead strip the
	// "Expect: 100-continue" header, and send a "100 Continue" response itself.
	Proxy_100Continue bool
	// If
	// :ref:`use_remote_address
	// <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.use_remote_address>`
	// is true and represent_ipv4_remote_address_as_ipv4_mapped_ipv6 is true and the remote address is
	// an IPv4 address, the address will be mapped to IPv6 before it is appended to “x-forwarded-for“.
	// This is useful for testing compatibility of upstream services that parse the header value. For
	// example, 50.0.0.1 is represented as ::FFFF:50.0.0.1. See `IPv4-Mapped IPv6 Addresses
	// <https://tools.ietf.org/html/rfc4291#section-2.5.5.2>`_ for details. This will also affect the
	// :ref:`config_http_conn_man_headers_x-envoy-external-address` header. See
	// :ref:`http_connection_manager.represent_ipv4_remote_address_as_ipv4_mapped_ipv6
	// <config_http_conn_man_runtime_represent_ipv4_remote_address_as_ipv4_mapped_ipv6>` for runtime
	// control.
	// [#not-implemented-hide:]
	RepresentIpv4RemoteAddressAsIpv4MappedIpv6 bool
	UpgradeConfigs                             []*HttpConnectionManager_UpgradeConfig
	// Should paths be normalized according to RFC 3986 before any processing of
	// requests by HTTP filters or routing? This affects the upstream “:path“ header
	// as well. For paths that fail this check, Envoy will respond with 400 to
	// paths that are malformed. This defaults to false currently but will default
	// true in the future. When not specified, this value may be overridden by the
	// runtime variable
	// :ref:`http_connection_manager.normalize_path<config_http_conn_man_runtime_normalize_path>`.
	// See `Normalization and Comparison <https://tools.ietf.org/html/rfc3986#section-6>`_
	// for details of normalization.
	// Note that Envoy does not perform
	// `case normalization <https://tools.ietf.org/html/rfc3986#section-6.2.2.1>`_
	// [#comment:TODO: This field is ignored when the
	// :ref:`header validation configuration <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.typed_header_validation_config>`
	// is present.]
	NormalizePath *wrapperspb.BoolValue
	// Determines if adjacent slashes in the path are merged into one before any processing of
	// requests by HTTP filters or routing. This affects the upstream “:path“ header as well. Without
	// setting this option, incoming requests with path “//dir///file“ will not match against route
	// with “prefix“ match set to “/dir“. Defaults to “false“. Note that slash merging is not part of
	// `HTTP spec <https://tools.ietf.org/html/rfc3986>`_ and is provided for convenience.
	// [#comment:TODO: This field is ignored when the
	// :ref:`header validation configuration <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.typed_header_validation_config>`
	// is present.]
	MergeSlashes bool
	// Action to take when request URL path contains escaped slash sequences (%2F, %2f, %5C and %5c).
	// The default value can be overridden by the :ref:`http_connection_manager.path_with_escaped_slashes_action<config_http_conn_man_runtime_path_with_escaped_slashes_action>`
	// runtime variable.
	// The :ref:`http_connection_manager.path_with_escaped_slashes_action_sampling<config_http_conn_man_runtime_path_with_escaped_slashes_action_enabled>` runtime
	// variable can be used to apply the action to a portion of all requests.
	// [#comment:TODO: This field is ignored when the
	// :ref:`header validation configuration <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.typed_header_validation_config>`
	// is present.]
	PathWithEscapedSlashesAction HttpConnectionManager_PathWithEscapedSlashesAction
	// The configuration of the request ID extension. This includes operations such as
	// generation, validation, and associated tracing operations. If empty, the
	// :ref:`UuidRequestIdConfig <envoy_v3_api_msg_extensions.request_id.uuid.v3.UuidRequestIdConfig>`
	// default extension is used with default parameters. See the documentation for that extension
	// for details on what it does. Customizing the configuration for the default extension can be
	// achieved by configuring it explicitly here. For example, to disable trace reason packing,
	// the following configuration can be used:
	//
	// .. validated-code-block:: yaml
	//
	//	:type-name: envoy.extensions.filters.network.http_connection_manager.v3.RequestIDExtension
	//
	//	typed_config:
	//	  "@type": type.googleapis.com/envoy.extensions.request_id.uuid.v3.UuidRequestIdConfig
	//	  pack_trace_reason: false
	//
	// [#extension-category: envoy.request_id]
	RequestIdExtension *RequestIDExtension
	// The configuration to customize local reply returned by Envoy. It can customize status code,
	// body text and response content type. If not specified, status code and text body are hard
	// coded in Envoy, the response content type is plain text.
	LocalReplyConfig *LocalReplyConfig
	// Determines if the port part should be removed from host/authority header before any processing
	// of request by HTTP filters or routing. The port would be removed only if it is equal to the :ref:`listener's<envoy_v3_api_field_config.listener.v3.Listener.address>`
	// local port. This affects the upstream host header unless the method is
	// CONNECT in which case if no filter adds a port the original port will be restored before headers are
	// sent upstream.
	// Without setting this option, incoming requests with host “example:443“ will not match against
	// route with :ref:`domains<envoy_v3_api_field_config.route.v3.VirtualHost.domains>` match set to “example“. Defaults to “false“. Note that port removal is not part
	// of `HTTP spec <https://tools.ietf.org/html/rfc3986>`_ and is provided for convenience.
	// Only one of “strip_matching_host_port“ or “strip_any_host_port“ can be set.
	StripMatchingHostPort bool
	// Fields of oneof StripPortMode:
	// Determines if the port part should be removed from host/authority header before any processing
	// of request by HTTP filters or routing.
	// This affects the upstream host header unless the method is CONNECT in
	// which case if no filter adds a port the original port will be restored before headers are sent upstream.
	// Without setting this option, incoming requests with host “example:443“ will not match against
	// route with :ref:`domains<envoy_v3_api_field_config.route.v3.VirtualHost.domains>` match set to “example“. Defaults to “false“. Note that port removal is not part
	// of `HTTP spec <https://tools.ietf.org/html/rfc3986>`_ and is provided for convenience.
	// Only one of “strip_matching_host_port“ or “strip_any_host_port“ can be set.
	StripAnyHostPort *bool
	// -- end of StripPortMode
	// Governs Envoy's behavior when receiving invalid HTTP from downstream.
	// If this option is false (default), Envoy will err on the conservative side handling HTTP
	// errors, terminating both HTTP/1.1 and HTTP/2 connections when receiving an invalid request.
	// If this option is set to true, Envoy will be more permissive, only resetting the invalid
	// stream in the case of HTTP/2 and leaving the connection open where possible (if the entire
	// request is read for HTTP/1.1)
	// In general this should be true for deployments receiving trusted traffic (L2 Envoys,
	// company-internal mesh) and false when receiving untrusted traffic (edge deployments).
	//
	// If different behaviors for invalid_http_message for HTTP/1 and HTTP/2 are
	// desired, one should use the new HTTP/1 option :ref:`override_stream_error_on_invalid_http_message
	// <envoy_v3_api_field_config.core.v3.Http1ProtocolOptions.override_stream_error_on_invalid_http_message>` or the new HTTP/2 option
	// :ref:`override_stream_error_on_invalid_http_message
	// <envoy_v3_api_field_config.core.v3.Http2ProtocolOptions.override_stream_error_on_invalid_http_message>`
	// “not“ the deprecated but similarly named :ref:`stream_error_on_invalid_http_messaging
	// <envoy_v3_api_field_config.core.v3.Http2ProtocolOptions.stream_error_on_invalid_http_messaging>`
	StreamErrorOnInvalidHttpMessage *wrapperspb.BoolValue
	// [#not-implemented-hide:] Path normalization configuration. This includes
	// configurations for transformations (e.g. RFC 3986 normalization or merge
	// adjacent slashes) and the policy to apply them. The policy determines
	// whether transformations affect the forwarded “:path“ header. RFC 3986 path
	// normalization is enabled by default and the default policy is that the
	// normalized header will be forwarded. See :ref:`PathNormalizationOptions
	// <envoy_v3_api_msg_extensions.filters.network.http_connection_manager.v3.PathNormalizationOptions>`
	// for details.
	PathNormalizationOptions *HttpConnectionManager_PathNormalizationOptions
	// Determines if trailing dot of the host should be removed from host/authority header before any
	// processing of request by HTTP filters or routing.
	// This affects the upstream host header.
	// Without setting this option, incoming requests with host “example.com.“ will not match against
	// route with :ref:`domains<envoy_v3_api_field_config.route.v3.VirtualHost.domains>` match set to “example.com“. Defaults to “false“.
	// When the incoming request contains a host/authority header that includes a port number,
	// setting this option will strip a trailing dot, if present, from the host section,
	// leaving the port as is (e.g. host value “example.com.:443“ will be updated to “example.com:443“).
	StripTrailingHostDot bool
	// Proxy-Status HTTP response header configuration.
	// If this config is set, the Proxy-Status HTTP response header field is
	// populated. By default, it is not.
	ProxyStatusConfig *HttpConnectionManager_ProxyStatusConfig
	// Configuration options for Header Validation (UHV).
	// UHV is an extensible mechanism for checking validity of HTTP requests as well as providing
	// normalization for request attributes, such as URI path.
	// If the typed_header_validation_config is present it overrides the following options:
	// “normalize_path“, “merge_slashes“, “path_with_escaped_slashes_action“
	// “http_protocol_options.allow_chunked_length“, “common_http_protocol_options.headers_with_underscores_action“.
	//
	// The default UHV checks the following:
	//
	// #. HTTP/1 header map validity according to `RFC 7230 section 3.2<https://datatracker.ietf.org/doc/html/rfc7230#section-3.2>`_
	// #. Syntax of HTTP/1 request target URI and response status
	// #. HTTP/2 header map validity according to `RFC 7540 section 8.1.2<https://datatracker.ietf.org/doc/html/rfc7540#section-8.1.2`_
	// #. Syntax of HTTP/2 pseudo headers
	// #. HTTP/3 header map validity according to `RFC 9114 section 4.3 <https://www.rfc-editor.org/rfc/rfc9114.html>`_
	// #. Syntax of HTTP/3 pseudo headers
	// #. Syntax of “Content-Length“ and “Transfer-Encoding“
	// #. Validation of HTTP/1 requests with both “Content-Length“ and “Transfer-Encoding“ headers
	// #. Normalization of the URI path according to `Normalization and Comparison <https://datatracker.ietf.org/doc/html/rfc3986#section-6>`_
	//
	//	without `case normalization <https://datatracker.ietf.org/doc/html/rfc3986#section-6.2.2.1>`_
	//
	// [#not-implemented-hide:]
	// [#extension-category: envoy.http.header_validators]
	TypedHeaderValidationConfig *v3.TypedExtensionConfig
	// Append the “x-forwarded-port“ header with the port value client used to connect to Envoy. It
	// will be ignored if the “x-forwarded-port“ header has been set by any trusted proxy in front of Envoy.
	AppendXForwardedPort bool
	// Append the :ref:`config_http_conn_man_headers_x-envoy-local-overloaded` HTTP header in the scenario where
	// the Overload Manager has been triggered.
	AppendLocalOverload bool
	// Whether the HCM will add ProxyProtocolFilterState to the Connection lifetime filter state. Defaults to “true“.
	// This should be set to “false“ in cases where Envoy's view of the downstream address may not correspond to the
	// actual client address, for example, if there's another proxy in front of the Envoy.
	AddProxyProtocolConnectionState *wrapperspb.BoolValue
	// contains filtered or unexported fields
}

func (HttpConnectionManager_builder) Build 

func (b0 HttpConnectionManager_builder) Build() *HttpConnectionManager

type HttpFilter 

type HttpFilter struct {

	// The name of the filter configuration. It also serves as a resource name in ExtensionConfigDS.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Types that are valid to be assigned to ConfigType:
	//
	//	*HttpFilter_TypedConfig
	//	*HttpFilter_ConfigDiscovery
	ConfigType isHttpFilter_ConfigType `protobuf_oneof:"config_type"`
	// If true, clients that do not support this filter may ignore the
	// filter but otherwise accept the config.
	// Otherwise, clients that do not support this filter must reject the config.
	IsOptional bool `protobuf:"varint,6,opt,name=is_optional,json=isOptional,proto3" json:"is_optional,omitempty"`
	// If true, the filter is disabled by default and must be explicitly enabled by setting
	// per filter configuration in the route configuration.
	// See :ref:`route based filter chain <arch_overview_http_filters_route_based_filter_chain>`
	// for more details.
	//
	// Terminal filters (e.g. “envoy.filters.http.router“) cannot be marked as disabled.
	Disabled bool `protobuf:"varint,7,opt,name=disabled,proto3" json:"disabled,omitempty"`
	// contains filtered or unexported fields
}

[#next-free-field: 8]

func (*HttpFilter) ClearConfigDiscovery 

func (x *HttpFilter) ClearConfigDiscovery()

func (*HttpFilter) ClearConfigType 

func (x *HttpFilter) ClearConfigType()

func (*HttpFilter) ClearTypedConfig 

func (x *HttpFilter) ClearTypedConfig()

func (*HttpFilter) GetConfigDiscovery 

func (x *HttpFilter) GetConfigDiscovery() *v3.ExtensionConfigSource

func (*HttpFilter) GetConfigType 

func (x *HttpFilter) GetConfigType() isHttpFilter_ConfigType

func (*HttpFilter) GetDisabled 

func (x *HttpFilter) GetDisabled() bool

func (*HttpFilter) GetIsOptional 

func (x *HttpFilter) GetIsOptional() bool

func (*HttpFilter) GetName 

func (x *HttpFilter) GetName() string

func (*HttpFilter) GetTypedConfig 

func (x *HttpFilter) GetTypedConfig() *anypb.Any

func (*HttpFilter) HasConfigDiscovery 

func (x *HttpFilter) HasConfigDiscovery() bool

func (*HttpFilter) HasConfigType 

func (x *HttpFilter) HasConfigType() bool

func (*HttpFilter) HasTypedConfig 

func (x *HttpFilter) HasTypedConfig() bool

func (*HttpFilter) ProtoMessage 

func (*HttpFilter) ProtoMessage()

func (*HttpFilter) ProtoReflect 

func (x *HttpFilter) ProtoReflect() protoreflect.Message

func (*HttpFilter) Reset 

func (x *HttpFilter) Reset()

func (*HttpFilter) SetConfigDiscovery 

func (x *HttpFilter) SetConfigDiscovery(v *v3.ExtensionConfigSource)

func (*HttpFilter) SetDisabled 

func (x *HttpFilter) SetDisabled(v bool)

func (*HttpFilter) SetIsOptional 

func (x *HttpFilter) SetIsOptional(v bool)

func (*HttpFilter) SetName 

func (x *HttpFilter) SetName(v string)

func (*HttpFilter) SetTypedConfig 

func (x *HttpFilter) SetTypedConfig(v *anypb.Any)

func (*HttpFilter) String 

func (x *HttpFilter) String() string

func (*HttpFilter) WhichConfigType 

func (x *HttpFilter) WhichConfigType() case_HttpFilter_ConfigType

type HttpFilter_ConfigDiscovery 

type HttpFilter_ConfigDiscovery struct {
	// Configuration source specifier for an extension configuration discovery service.
	// In case of a failure and without the default configuration, the HTTP listener responds with code 500.
	// Extension configs delivered through this mechanism are not expected to require warming (see https://github.com/envoyproxy/envoy/issues/12061).
	//
	// To support configuring a :ref:`match tree <arch_overview_matching_api>`, use an
	// :ref:`ExtensionWithMatcher <envoy_v3_api_msg_extensions.common.matching.v3.ExtensionWithMatcher>`
	// with the desired HTTP filter. This works for both the default filter configuration as well
	// as for filters provided via the API.
	ConfigDiscovery *v3.ExtensionConfigSource `protobuf:"bytes,5,opt,name=config_discovery,json=configDiscovery,proto3,oneof"`
}

type HttpFilter_TypedConfig 

type HttpFilter_TypedConfig struct {
	// Filter specific configuration which depends on the filter being instantiated. See the supported
	// filters for further documentation.
	//
	// To support configuring a :ref:`match tree <arch_overview_matching_api>`, use an
	// :ref:`ExtensionWithMatcher <envoy_v3_api_msg_extensions.common.matching.v3.ExtensionWithMatcher>`
	// with the desired HTTP filter.
	// [#extension-category: envoy.filters.http]
	TypedConfig *anypb.Any `protobuf:"bytes,4,opt,name=typed_config,json=typedConfig,proto3,oneof"`
}

type HttpFilter_builder 

type HttpFilter_builder struct {

	// The name of the filter configuration. It also serves as a resource name in ExtensionConfigDS.
	Name string
	// Fields of oneof ConfigType:
	// Filter specific configuration which depends on the filter being instantiated. See the supported
	// filters for further documentation.
	//
	// To support configuring a :ref:`match tree <arch_overview_matching_api>`, use an
	// :ref:`ExtensionWithMatcher <envoy_v3_api_msg_extensions.common.matching.v3.ExtensionWithMatcher>`
	// with the desired HTTP filter.
	// [#extension-category: envoy.filters.http]
	TypedConfig *anypb.Any
	// Configuration source specifier for an extension configuration discovery service.
	// In case of a failure and without the default configuration, the HTTP listener responds with code 500.
	// Extension configs delivered through this mechanism are not expected to require warming (see https://github.com/envoyproxy/envoy/issues/12061).
	//
	// To support configuring a :ref:`match tree <arch_overview_matching_api>`, use an
	// :ref:`ExtensionWithMatcher <envoy_v3_api_msg_extensions.common.matching.v3.ExtensionWithMatcher>`
	// with the desired HTTP filter. This works for both the default filter configuration as well
	// as for filters provided via the API.
	ConfigDiscovery *v3.ExtensionConfigSource
	// -- end of ConfigType
	// If true, clients that do not support this filter may ignore the
	// filter but otherwise accept the config.
	// Otherwise, clients that do not support this filter must reject the config.
	IsOptional bool
	// If true, the filter is disabled by default and must be explicitly enabled by setting
	// per filter configuration in the route configuration.
	// See :ref:`route based filter chain <arch_overview_http_filters_route_based_filter_chain>`
	// for more details.
	//
	// Terminal filters (e.g. “envoy.filters.http.router“) cannot be marked as disabled.
	Disabled bool
	// contains filtered or unexported fields
}

func (HttpFilter_builder) Build 

func (b0 HttpFilter_builder) Build() *HttpFilter

type LocalReplyConfig 

type LocalReplyConfig struct {

	// Configuration of list of mappers which allows to filter and change local response.
	// The mappers will be checked by the specified order until one is matched.
	Mappers []*ResponseMapper `protobuf:"bytes,1,rep,name=mappers,proto3" json:"mappers,omitempty"`
	// The configuration to form response body from the :ref:`command operators <config_access_log_command_operators>`
	// and to specify response content type as one of: plain/text or application/json.
	//
	// Example one: "plain/text" “body_format“.
	//
	// .. validated-code-block:: yaml
	//
	//	:type-name: envoy.config.core.v3.SubstitutionFormatString
	//
	//	text_format: "%LOCAL_REPLY_BODY%:%RESPONSE_CODE%:path=%REQ(:path)%\n"
	//
	// The following response body in "plain/text" format will be generated for a request with
	// local reply body of "upstream connection error", response_code=503 and path=/foo.
	//
	// .. code-block:: text
	//
	//	upstream connect error:503:path=/foo
	//
	// Example two: "application/json" “body_format“.
	//
	// .. validated-code-block:: yaml
	//
	//	:type-name: envoy.config.core.v3.SubstitutionFormatString
	//
	//	json_format:
	//	  status: "%RESPONSE_CODE%"
	//	  message: "%LOCAL_REPLY_BODY%"
	//	  path: "%REQ(:path)%"
	//
	// The following response body in "application/json" format would be generated for a request with
	// local reply body of "upstream connection error", response_code=503 and path=/foo.
	//
	// .. code-block:: json
	//
	//	{
	//	  "status": 503,
	//	  "message": "upstream connection error",
	//	  "path": "/foo"
	//	}
	BodyFormat *v3.SubstitutionFormatString `protobuf:"bytes,2,opt,name=body_format,json=bodyFormat,proto3" json:"body_format,omitempty"`
	// contains filtered or unexported fields
}

The configuration to customize local reply returned by Envoy.

func (*LocalReplyConfig) ClearBodyFormat 

func (x *LocalReplyConfig) ClearBodyFormat()

func (*LocalReplyConfig) GetBodyFormat 

func (x *LocalReplyConfig) GetBodyFormat() *v3.SubstitutionFormatString

func (*LocalReplyConfig) GetMappers 

func (x *LocalReplyConfig) GetMappers() []*ResponseMapper

func (*LocalReplyConfig) HasBodyFormat 

func (x *LocalReplyConfig) HasBodyFormat() bool

func (*LocalReplyConfig) ProtoMessage 

func (*LocalReplyConfig) ProtoMessage()

func (*LocalReplyConfig) ProtoReflect 

func (x *LocalReplyConfig) ProtoReflect() protoreflect.Message

func (*LocalReplyConfig) Reset 

func (x *LocalReplyConfig) Reset()

func (*LocalReplyConfig) SetBodyFormat 

func (x *LocalReplyConfig) SetBodyFormat(v *v3.SubstitutionFormatString)

func (*LocalReplyConfig) SetMappers 

func (x *LocalReplyConfig) SetMappers(v []*ResponseMapper)

func (*LocalReplyConfig) String 

func (x *LocalReplyConfig) String() string

type LocalReplyConfig_builder 

type LocalReplyConfig_builder struct {

	// Configuration of list of mappers which allows to filter and change local response.
	// The mappers will be checked by the specified order until one is matched.
	Mappers []*ResponseMapper
	// The configuration to form response body from the :ref:`command operators <config_access_log_command_operators>`
	// and to specify response content type as one of: plain/text or application/json.
	//
	// Example one: "plain/text" “body_format“.
	//
	// .. validated-code-block:: yaml
	//
	//	:type-name: envoy.config.core.v3.SubstitutionFormatString
	//
	//	text_format: "%LOCAL_REPLY_BODY%:%RESPONSE_CODE%:path=%REQ(:path)%\n"
	//
	// The following response body in "plain/text" format will be generated for a request with
	// local reply body of "upstream connection error", response_code=503 and path=/foo.
	//
	// .. code-block:: text
	//
	//	upstream connect error:503:path=/foo
	//
	// Example two: "application/json" “body_format“.
	//
	// .. validated-code-block:: yaml
	//
	//	:type-name: envoy.config.core.v3.SubstitutionFormatString
	//
	//	json_format:
	//	  status: "%RESPONSE_CODE%"
	//	  message: "%LOCAL_REPLY_BODY%"
	//	  path: "%REQ(:path)%"
	//
	// The following response body in "application/json" format would be generated for a request with
	// local reply body of "upstream connection error", response_code=503 and path=/foo.
	//
	// .. code-block:: json
	//
	//	{
	//	  "status": 503,
	//	  "message": "upstream connection error",
	//	  "path": "/foo"
	//	}
	BodyFormat *v3.SubstitutionFormatString
	// contains filtered or unexported fields
}

func (LocalReplyConfig_builder) Build 

func (b0 LocalReplyConfig_builder) Build() *LocalReplyConfig

type Rds 

type Rds struct {

	// Configuration source specifier for RDS.
	ConfigSource *v3.ConfigSource `protobuf:"bytes,1,opt,name=config_source,json=configSource,proto3" json:"config_source,omitempty"`
	// The name of the route configuration. This name will be passed to the RDS
	// API. This allows an Envoy configuration with multiple HTTP listeners (and
	// associated HTTP connection manager filters) to use different route
	// configurations.
	RouteConfigName string `protobuf:"bytes,2,opt,name=route_config_name,json=routeConfigName,proto3" json:"route_config_name,omitempty"`
	// contains filtered or unexported fields
}

func (*Rds) ClearConfigSource 

func (x *Rds) ClearConfigSource()

func (*Rds) GetConfigSource 

func (x *Rds) GetConfigSource() *v3.ConfigSource

func (*Rds) GetRouteConfigName 

func (x *Rds) GetRouteConfigName() string

func (*Rds) HasConfigSource 

func (x *Rds) HasConfigSource() bool

func (*Rds) ProtoMessage 

func (*Rds) ProtoMessage()

func (*Rds) ProtoReflect 

func (x *Rds) ProtoReflect() protoreflect.Message

func (*Rds) Reset 

func (x *Rds) Reset()

func (*Rds) SetConfigSource 

func (x *Rds) SetConfigSource(v *v3.ConfigSource)

func (*Rds) SetRouteConfigName 

func (x *Rds) SetRouteConfigName(v string)

func (*Rds) String 

func (x *Rds) String() string

type Rds_builder 

type Rds_builder struct {

	// Configuration source specifier for RDS.
	ConfigSource *v3.ConfigSource
	// The name of the route configuration. This name will be passed to the RDS
	// API. This allows an Envoy configuration with multiple HTTP listeners (and
	// associated HTTP connection manager filters) to use different route
	// configurations.
	RouteConfigName string
	// contains filtered or unexported fields
}

func (Rds_builder) Build 

func (b0 Rds_builder) Build() *Rds

type RequestIDExtension 

type RequestIDExtension struct {

	// Request ID extension specific configuration.
	TypedConfig *anypb.Any `protobuf:"bytes,1,opt,name=typed_config,json=typedConfig,proto3" json:"typed_config,omitempty"`
	// contains filtered or unexported fields
}

func (*RequestIDExtension) ClearTypedConfig 

func (x *RequestIDExtension) ClearTypedConfig()

func (*RequestIDExtension) GetTypedConfig 

func (x *RequestIDExtension) GetTypedConfig() *anypb.Any

func (*RequestIDExtension) HasTypedConfig 

func (x *RequestIDExtension) HasTypedConfig() bool

func (*RequestIDExtension) ProtoMessage 

func (*RequestIDExtension) ProtoMessage()

func (*RequestIDExtension) ProtoReflect 

func (x *RequestIDExtension) ProtoReflect() protoreflect.Message

func (*RequestIDExtension) Reset 

func (x *RequestIDExtension) Reset()

func (*RequestIDExtension) SetTypedConfig 

func (x *RequestIDExtension) SetTypedConfig(v *anypb.Any)

func (*RequestIDExtension) String 

func (x *RequestIDExtension) String() string

type RequestIDExtension_builder 

type RequestIDExtension_builder struct {

	// Request ID extension specific configuration.
	TypedConfig *anypb.Any
	// contains filtered or unexported fields
}

func (RequestIDExtension_builder) Build 

func (b0 RequestIDExtension_builder) Build() *RequestIDExtension

type ResponseMapper 

type ResponseMapper struct {

	// Filter to determine if this mapper should apply.
	Filter *v31.AccessLogFilter `protobuf:"bytes,1,opt,name=filter,proto3" json:"filter,omitempty"`
	// The new response status code if specified.
	StatusCode *wrapperspb.UInt32Value `protobuf:"bytes,2,opt,name=status_code,json=statusCode,proto3" json:"status_code,omitempty"`
	// The new local reply body text if specified. It will be used in the “%LOCAL_REPLY_BODY%“
	// command operator in the “body_format“.
	Body *v3.DataSource `protobuf:"bytes,3,opt,name=body,proto3" json:"body,omitempty"`
	// A per mapper “body_format“ to override the :ref:`body_format <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.LocalReplyConfig.body_format>`.
	// It will be used when this mapper is matched.
	BodyFormatOverride *v3.SubstitutionFormatString `protobuf:"bytes,4,opt,name=body_format_override,json=bodyFormatOverride,proto3" json:"body_format_override,omitempty"`
	// HTTP headers to add to a local reply. This allows the response mapper to append, to add
	// or to override headers of any local reply before it is sent to a downstream client.
	HeadersToAdd []*v3.HeaderValueOption `protobuf:"bytes,5,rep,name=headers_to_add,json=headersToAdd,proto3" json:"headers_to_add,omitempty"`
	// contains filtered or unexported fields
}

The configuration to filter and change local response. [#next-free-field: 6]

func (*ResponseMapper) ClearBody 

func (x *ResponseMapper) ClearBody()

func (*ResponseMapper) ClearBodyFormatOverride 

func (x *ResponseMapper) ClearBodyFormatOverride()

func (*ResponseMapper) ClearFilter 

func (x *ResponseMapper) ClearFilter()

func (*ResponseMapper) ClearStatusCode 

func (x *ResponseMapper) ClearStatusCode()

func (*ResponseMapper) GetBody 

func (x *ResponseMapper) GetBody() *v3.DataSource

func (*ResponseMapper) GetBodyFormatOverride 

func (x *ResponseMapper) GetBodyFormatOverride() *v3.SubstitutionFormatString

func (*ResponseMapper) GetFilter 

func (x *ResponseMapper) GetFilter() *v31.AccessLogFilter

func (*ResponseMapper) GetHeadersToAdd 

func (x *ResponseMapper) GetHeadersToAdd() []*v3.HeaderValueOption

func (*ResponseMapper) GetStatusCode 

func (x *ResponseMapper) GetStatusCode() *wrapperspb.UInt32Value

func (*ResponseMapper) HasBody 

func (x *ResponseMapper) HasBody() bool

func (*ResponseMapper) HasBodyFormatOverride 

func (x *ResponseMapper) HasBodyFormatOverride() bool

func (*ResponseMapper) HasFilter 

func (x *ResponseMapper) HasFilter() bool

func (*ResponseMapper) HasStatusCode 

func (x *ResponseMapper) HasStatusCode() bool

func (*ResponseMapper) ProtoMessage 

func (*ResponseMapper) ProtoMessage()

func (*ResponseMapper) ProtoReflect 

func (x *ResponseMapper) ProtoReflect() protoreflect.Message

func (*ResponseMapper) Reset 

func (x *ResponseMapper) Reset()

func (*ResponseMapper) SetBody 

func (x *ResponseMapper) SetBody(v *v3.DataSource)

func (*ResponseMapper) SetBodyFormatOverride 

func (x *ResponseMapper) SetBodyFormatOverride(v *v3.SubstitutionFormatString)

func (*ResponseMapper) SetFilter 

func (x *ResponseMapper) SetFilter(v *v31.AccessLogFilter)

func (*ResponseMapper) SetHeadersToAdd 

func (x *ResponseMapper) SetHeadersToAdd(v []*v3.HeaderValueOption)

func (*ResponseMapper) SetStatusCode 

func (x *ResponseMapper) SetStatusCode(v *wrapperspb.UInt32Value)

func (*ResponseMapper) String 

func (x *ResponseMapper) String() string

type ResponseMapper_builder 

type ResponseMapper_builder struct {

	// Filter to determine if this mapper should apply.
	Filter *v31.AccessLogFilter
	// The new response status code if specified.
	StatusCode *wrapperspb.UInt32Value
	// The new local reply body text if specified. It will be used in the “%LOCAL_REPLY_BODY%“
	// command operator in the “body_format“.
	Body *v3.DataSource
	// A per mapper “body_format“ to override the :ref:`body_format <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.LocalReplyConfig.body_format>`.
	// It will be used when this mapper is matched.
	BodyFormatOverride *v3.SubstitutionFormatString
	// HTTP headers to add to a local reply. This allows the response mapper to append, to add
	// or to override headers of any local reply before it is sent to a downstream client.
	HeadersToAdd []*v3.HeaderValueOption
	// contains filtered or unexported fields
}

func (ResponseMapper_builder) Build 

func (b0 ResponseMapper_builder) Build() *ResponseMapper

type ScopedRds 

type ScopedRds struct {

	// Configuration source specifier for scoped RDS.
	ScopedRdsConfigSource *v3.ConfigSource `` /* 128-byte string literal not displayed */
	// xdstp:// resource locator for scoped RDS collection.
	// [#not-implemented-hide:]
	SrdsResourcesLocator string `protobuf:"bytes,2,opt,name=srds_resources_locator,json=srdsResourcesLocator,proto3" json:"srds_resources_locator,omitempty"`
	// contains filtered or unexported fields
}

func (*ScopedRds) ClearScopedRdsConfigSource 

func (x *ScopedRds) ClearScopedRdsConfigSource()

func (*ScopedRds) GetScopedRdsConfigSource 

func (x *ScopedRds) GetScopedRdsConfigSource() *v3.ConfigSource

func (*ScopedRds) GetSrdsResourcesLocator 

func (x *ScopedRds) GetSrdsResourcesLocator() string

func (*ScopedRds) HasScopedRdsConfigSource 

func (x *ScopedRds) HasScopedRdsConfigSource() bool

func (*ScopedRds) ProtoMessage 

func (*ScopedRds) ProtoMessage()

func (*ScopedRds) ProtoReflect 

func (x *ScopedRds) ProtoReflect() protoreflect.Message

func (*ScopedRds) Reset 

func (x *ScopedRds) Reset()

func (*ScopedRds) SetScopedRdsConfigSource 

func (x *ScopedRds) SetScopedRdsConfigSource(v *v3.ConfigSource)

func (*ScopedRds) SetSrdsResourcesLocator 

func (x *ScopedRds) SetSrdsResourcesLocator(v string)

func (*ScopedRds) String 

func (x *ScopedRds) String() string

type ScopedRds_builder 

type ScopedRds_builder struct {

	// Configuration source specifier for scoped RDS.
	ScopedRdsConfigSource *v3.ConfigSource
	// xdstp:// resource locator for scoped RDS collection.
	// [#not-implemented-hide:]
	SrdsResourcesLocator string
	// contains filtered or unexported fields
}

func (ScopedRds_builder) Build 

func (b0 ScopedRds_builder) Build() *ScopedRds

type ScopedRouteConfigurationsList 

type ScopedRouteConfigurationsList struct {
	ScopedRouteConfigurations []*v33.ScopedRouteConfiguration `` /* 138-byte string literal not displayed */
	// contains filtered or unexported fields
}

This message is used to work around the limitations with 'oneof' and repeated fields.

func (*ScopedRouteConfigurationsList) GetScopedRouteConfigurations 

func (x *ScopedRouteConfigurationsList) GetScopedRouteConfigurations() []*v33.ScopedRouteConfiguration

func (*ScopedRouteConfigurationsList) ProtoMessage 

func (*ScopedRouteConfigurationsList) ProtoMessage()

func (*ScopedRouteConfigurationsList) ProtoReflect 

func (x *ScopedRouteConfigurationsList) ProtoReflect() protoreflect.Message

func (*ScopedRouteConfigurationsList) Reset 

func (x *ScopedRouteConfigurationsList) Reset()

func (*ScopedRouteConfigurationsList) SetScopedRouteConfigurations 

func (x *ScopedRouteConfigurationsList) SetScopedRouteConfigurations(v []*v33.ScopedRouteConfiguration)

func (*ScopedRouteConfigurationsList) String 

func (x *ScopedRouteConfigurationsList) String() string

type ScopedRouteConfigurationsList_builder 

type ScopedRouteConfigurationsList_builder struct {
	ScopedRouteConfigurations []*v33.ScopedRouteConfiguration
	// contains filtered or unexported fields
}

func (ScopedRouteConfigurationsList_builder) Build 

func (b0 ScopedRouteConfigurationsList_builder) Build() *ScopedRouteConfigurationsList

type ScopedRoutes 

type ScopedRoutes struct {

	// The name assigned to the scoped routing configuration.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The algorithm to use for constructing a scope key for each request.
	ScopeKeyBuilder *ScopedRoutes_ScopeKeyBuilder `protobuf:"bytes,2,opt,name=scope_key_builder,json=scopeKeyBuilder,proto3" json:"scope_key_builder,omitempty"`
	// Configuration source specifier for RDS.
	// This config source is used to subscribe to RouteConfiguration resources specified in
	// ScopedRouteConfiguration messages.
	RdsConfigSource *v3.ConfigSource `protobuf:"bytes,3,opt,name=rds_config_source,json=rdsConfigSource,proto3" json:"rds_config_source,omitempty"`
	// Types that are valid to be assigned to ConfigSpecifier:
	//
	//	*ScopedRoutes_ScopedRouteConfigurationsList
	//	*ScopedRoutes_ScopedRds
	ConfigSpecifier isScopedRoutes_ConfigSpecifier `protobuf_oneof:"config_specifier"`
	// contains filtered or unexported fields
}

[#next-free-field: 6]

func (*ScopedRoutes) ClearConfigSpecifier 

func (x *ScopedRoutes) ClearConfigSpecifier()

func (*ScopedRoutes) ClearRdsConfigSource 

func (x *ScopedRoutes) ClearRdsConfigSource()

func (*ScopedRoutes) ClearScopeKeyBuilder 

func (x *ScopedRoutes) ClearScopeKeyBuilder()

func (*ScopedRoutes) ClearScopedRds 

func (x *ScopedRoutes) ClearScopedRds()

func (*ScopedRoutes) ClearScopedRouteConfigurationsList 

func (x *ScopedRoutes) ClearScopedRouteConfigurationsList()

func (*ScopedRoutes) GetConfigSpecifier 

func (x *ScopedRoutes) GetConfigSpecifier() isScopedRoutes_ConfigSpecifier

func (*ScopedRoutes) GetName 

func (x *ScopedRoutes) GetName() string

func (*ScopedRoutes) GetRdsConfigSource 

func (x *ScopedRoutes) GetRdsConfigSource() *v3.ConfigSource

func (*ScopedRoutes) GetScopeKeyBuilder 

func (x *ScopedRoutes) GetScopeKeyBuilder() *ScopedRoutes_ScopeKeyBuilder

func (*ScopedRoutes) GetScopedRds 

func (x *ScopedRoutes) GetScopedRds() *ScopedRds

func (*ScopedRoutes) GetScopedRouteConfigurationsList 

func (x *ScopedRoutes) GetScopedRouteConfigurationsList() *ScopedRouteConfigurationsList

func (*ScopedRoutes) HasConfigSpecifier 

func (x *ScopedRoutes) HasConfigSpecifier() bool

func (*ScopedRoutes) HasRdsConfigSource 

func (x *ScopedRoutes) HasRdsConfigSource() bool

func (*ScopedRoutes) HasScopeKeyBuilder 

func (x *ScopedRoutes) HasScopeKeyBuilder() bool

func (*ScopedRoutes) HasScopedRds 

func (x *ScopedRoutes) HasScopedRds() bool

func (*ScopedRoutes) HasScopedRouteConfigurationsList 

func (x *ScopedRoutes) HasScopedRouteConfigurationsList() bool

func (*ScopedRoutes) ProtoMessage 

func (*ScopedRoutes) ProtoMessage()

func (*ScopedRoutes) ProtoReflect 

func (x *ScopedRoutes) ProtoReflect() protoreflect.Message

func (*ScopedRoutes) Reset 

func (x *ScopedRoutes) Reset()

func (*ScopedRoutes) SetName 

func (x *ScopedRoutes) SetName(v string)

func (*ScopedRoutes) SetRdsConfigSource 

func (x *ScopedRoutes) SetRdsConfigSource(v *v3.ConfigSource)

func (*ScopedRoutes) SetScopeKeyBuilder 

func (x *ScopedRoutes) SetScopeKeyBuilder(v *ScopedRoutes_ScopeKeyBuilder)

func (*ScopedRoutes) SetScopedRds 

func (x *ScopedRoutes) SetScopedRds(v *ScopedRds)

func (*ScopedRoutes) SetScopedRouteConfigurationsList 

func (x *ScopedRoutes) SetScopedRouteConfigurationsList(v *ScopedRouteConfigurationsList)

func (*ScopedRoutes) String 

func (x *ScopedRoutes) String() string

func (*ScopedRoutes) WhichConfigSpecifier 

func (x *ScopedRoutes) WhichConfigSpecifier() case_ScopedRoutes_ConfigSpecifier

type ScopedRoutes_ScopeKeyBuilder 

type ScopedRoutes_ScopeKeyBuilder struct {

	// The final(built) scope key consists of the ordered union of these fragments, which are compared in order with the
	// fragments of a :ref:`ScopedRouteConfiguration<envoy_v3_api_msg_config.route.v3.ScopedRouteConfiguration>`.
	// A missing fragment during comparison will make the key invalid, i.e., the computed key doesn't match any key.
	Fragments []*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder `protobuf:"bytes,1,rep,name=fragments,proto3" json:"fragments,omitempty"`
	// contains filtered or unexported fields
}

Specifies the mechanism for constructing "scope keys" based on HTTP request attributes. These keys are matched against a set of :ref:`Key<envoy_v3_api_msg_config.route.v3.ScopedRouteConfiguration.Key>` objects assembled from :ref:`ScopedRouteConfiguration<envoy_v3_api_msg_config.route.v3.ScopedRouteConfiguration>` messages distributed via SRDS (the Scoped Route Discovery Service) or assigned statically via :ref:`scoped_route_configurations_list<envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.ScopedRoutes.scoped_route_configurations_list>`.

Upon receiving a request's headers, the Router will build a key using the algorithm specified by this message. This key will be used to look up the routing table (i.e., the :ref:`RouteConfiguration<envoy_v3_api_msg_config.route.v3.RouteConfiguration>`) to use for the request.

func (*ScopedRoutes_ScopeKeyBuilder) GetFragments 

func (x *ScopedRoutes_ScopeKeyBuilder) GetFragments() []*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder

func (*ScopedRoutes_ScopeKeyBuilder) ProtoMessage 

func (*ScopedRoutes_ScopeKeyBuilder) ProtoMessage()

func (*ScopedRoutes_ScopeKeyBuilder) ProtoReflect 

func (x *ScopedRoutes_ScopeKeyBuilder) ProtoReflect() protoreflect.Message

func (*ScopedRoutes_ScopeKeyBuilder) Reset 

func (x *ScopedRoutes_ScopeKeyBuilder) Reset()

func (*ScopedRoutes_ScopeKeyBuilder) SetFragments 

func (x *ScopedRoutes_ScopeKeyBuilder) SetFragments(v []*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder)

func (*ScopedRoutes_ScopeKeyBuilder) String 

func (x *ScopedRoutes_ScopeKeyBuilder) String() string

type ScopedRoutes_ScopeKeyBuilder_FragmentBuilder 

type ScopedRoutes_ScopeKeyBuilder_FragmentBuilder struct {

	// Types that are valid to be assigned to Type:
	//
	//	*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_
	Type isScopedRoutes_ScopeKeyBuilder_FragmentBuilder_Type `protobuf_oneof:"type"`
	// contains filtered or unexported fields
}

Specifies the mechanism for constructing key fragments which are composed into scope keys.

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder) ClearHeaderValueExtractor 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder) ClearHeaderValueExtractor()

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder) ClearType 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder) ClearType()

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder) GetHeaderValueExtractor 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder) GetHeaderValueExtractor() *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder) GetType 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder) GetType() isScopedRoutes_ScopeKeyBuilder_FragmentBuilder_Type

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder) HasHeaderValueExtractor 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder) HasHeaderValueExtractor() bool

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder) HasType 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder) HasType() bool

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder) ProtoMessage 

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder) ProtoMessage()

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder) ProtoReflect 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder) ProtoReflect() protoreflect.Message

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder) Reset 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder) Reset()

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder) SetHeaderValueExtractor 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder) SetHeaderValueExtractor(v *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor)

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder) String 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder) String() string

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder) WhichType 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder) WhichType() case_ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_Type

type ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor 

type ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor struct {

	// The name of the header field to extract the value from.
	//
	// .. note::
	//
	//	If the header appears multiple times only the first value is used.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The element separator (e.g., ';' separates 'a;b;c;d').
	// Default: empty string. This causes the entirety of the header field to be extracted.
	// If this field is set to an empty string and 'index' is used in the oneof below, 'index'
	// must be set to 0.
	ElementSeparator string `protobuf:"bytes,2,opt,name=element_separator,json=elementSeparator,proto3" json:"element_separator,omitempty"`
	// Types that are valid to be assigned to ExtractType:
	//
	//	*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_Index
	//	*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_Element
	ExtractType isScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_ExtractType `protobuf_oneof:"extract_type"`
	// contains filtered or unexported fields
}

Specifies how the value of a header should be extracted. The following example maps the structure of a header to the fields in this message.

.. code:: 

          <0> <1>   <-- index
X-Header: a=b;c=d
|         || |
|         || \----> <element_separator>
|         ||
|         |\----> <element.separator>
|         |
|         \----> <element.key>
|
\----> <name>

Each 'a=b' key-value pair constitutes an 'element' of the header field.

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) ClearElement 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) ClearElement()

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) ClearExtractType 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) ClearExtractType()

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) ClearIndex 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) ClearIndex()

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) GetElement 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) GetElement() *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) GetElementSeparator 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) GetElementSeparator() string

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) GetExtractType 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) GetExtractType() isScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_ExtractType

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) GetIndex 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) GetIndex() uint32

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) GetName 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) GetName() string

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) HasElement 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) HasElement() bool

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) HasExtractType 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) HasExtractType() bool

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) HasIndex 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) HasIndex() bool

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) ProtoMessage 

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) ProtoMessage()

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) ProtoReflect 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) ProtoReflect() protoreflect.Message

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) Reset 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) Reset()

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) SetElement 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) SetElement(v *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement)

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) SetElementSeparator 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) SetElementSeparator(v string)

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) SetIndex 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) SetIndex(v uint32)

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) SetName 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) SetName(v string)

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) String 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) String() string

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) WhichExtractType 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) WhichExtractType() case_ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_ExtractType

type ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_ 

type ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_ struct {
	// Specifies how a header field's value should be extracted.
	HeaderValueExtractor *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor `protobuf:"bytes,1,opt,name=header_value_extractor,json=headerValueExtractor,proto3,oneof"`
}

type ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_Element 

type ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_Element struct {
	// Specifies the key value pair to extract the value from.
	Element *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement `protobuf:"bytes,4,opt,name=element,proto3,oneof"`
}

type ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_Index 

type ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_Index struct {
	// Specifies the zero based index of the element to extract.
	// Note Envoy concatenates multiple values of the same header key into a comma separated
	// string, the splitting always happens after the concatenation.
	Index uint32 `protobuf:"varint,3,opt,name=index,proto3,oneof"`
}

type ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement 

type ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement struct {

	// The separator between key and value (e.g., '=' separates 'k=v;...').
	// If an element is an empty string, the element is ignored.
	// If an element contains no separator, the whole element is parsed as key and the
	// fragment value is an empty string.
	// If there are multiple values for a matched key, the first value is returned.
	Separator string `protobuf:"bytes,1,opt,name=separator,proto3" json:"separator,omitempty"`
	// The key to match on.
	Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
	// contains filtered or unexported fields
}

Specifies a header field's key value pair to match on.

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement) GetKey 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement) GetKey() string

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement) GetSeparator 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement) GetSeparator() string

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement) ProtoMessage 

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement) ProtoMessage()

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement) ProtoReflect 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement) ProtoReflect() protoreflect.Message

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement) Reset 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement) Reset()

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement) SetKey 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement) SetKey(v string)

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement) SetSeparator 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement) SetSeparator(v string)

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement) String 

func (x *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement) String() string

type ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement_builder 

type ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement_builder struct {

	// The separator between key and value (e.g., '=' separates 'k=v;...').
	// If an element is an empty string, the element is ignored.
	// If an element contains no separator, the whole element is parsed as key and the
	// fragment value is an empty string.
	// If there are multiple values for a matched key, the first value is returned.
	Separator string
	// The key to match on.
	Key string
	// contains filtered or unexported fields
}

func (ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement_builder) Build 

func (b0 ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement_builder) Build() *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement

type ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_builder 

type ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_builder struct {

	// The name of the header field to extract the value from.
	//
	// .. note::
	//
	//	If the header appears multiple times only the first value is used.
	Name string
	// The element separator (e.g., ';' separates 'a;b;c;d').
	// Default: empty string. This causes the entirety of the header field to be extracted.
	// If this field is set to an empty string and 'index' is used in the oneof below, 'index'
	// must be set to 0.
	ElementSeparator string
	// Fields of oneof ExtractType:
	// Specifies the zero based index of the element to extract.
	// Note Envoy concatenates multiple values of the same header key into a comma separated
	// string, the splitting always happens after the concatenation.
	Index *uint32
	// Specifies the key value pair to extract the value from.
	Element *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement
	// contains filtered or unexported fields
}

func (ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_builder) Build 

func (b0 ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_builder) Build() *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor

type ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_builder 

type ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_builder struct {

	// Fields of oneof Type:
	// Specifies how a header field's value should be extracted.
	HeaderValueExtractor *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor
	// contains filtered or unexported fields
}

func (ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_builder) Build 

func (b0 ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_builder) Build() *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder

type ScopedRoutes_ScopeKeyBuilder_builder 

type ScopedRoutes_ScopeKeyBuilder_builder struct {

	// The final(built) scope key consists of the ordered union of these fragments, which are compared in order with the
	// fragments of a :ref:`ScopedRouteConfiguration<envoy_v3_api_msg_config.route.v3.ScopedRouteConfiguration>`.
	// A missing fragment during comparison will make the key invalid, i.e., the computed key doesn't match any key.
	Fragments []*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder
	// contains filtered or unexported fields
}

func (ScopedRoutes_ScopeKeyBuilder_builder) Build 

func (b0 ScopedRoutes_ScopeKeyBuilder_builder) Build() *ScopedRoutes_ScopeKeyBuilder

type ScopedRoutes_ScopedRds 

type ScopedRoutes_ScopedRds struct {
	// The set of routing scopes associated with the HCM will be dynamically loaded via the SRDS
	// API. A scope is assigned to a request by matching a key constructed from the request's
	// attributes according to the algorithm specified by the
	// :ref:`ScopeKeyBuilder<envoy_v3_api_msg_extensions.filters.network.http_connection_manager.v3.ScopedRoutes.ScopeKeyBuilder>`
	// in this message.
	ScopedRds *ScopedRds `protobuf:"bytes,5,opt,name=scoped_rds,json=scopedRds,proto3,oneof"`
}

type ScopedRoutes_ScopedRouteConfigurationsList 

type ScopedRoutes_ScopedRouteConfigurationsList struct {
	// The set of routing scopes corresponding to the HCM. A scope is assigned to a request by
	// matching a key constructed from the request's attributes according to the algorithm specified
	// by the
	// :ref:`ScopeKeyBuilder<envoy_v3_api_msg_extensions.filters.network.http_connection_manager.v3.ScopedRoutes.ScopeKeyBuilder>`
	// in this message.
	ScopedRouteConfigurationsList *ScopedRouteConfigurationsList `protobuf:"bytes,4,opt,name=scoped_route_configurations_list,json=scopedRouteConfigurationsList,proto3,oneof"`
}

type ScopedRoutes_builder 

type ScopedRoutes_builder struct {

	// The name assigned to the scoped routing configuration.
	Name string
	// The algorithm to use for constructing a scope key for each request.
	ScopeKeyBuilder *ScopedRoutes_ScopeKeyBuilder
	// Configuration source specifier for RDS.
	// This config source is used to subscribe to RouteConfiguration resources specified in
	// ScopedRouteConfiguration messages.
	RdsConfigSource *v3.ConfigSource
	// Fields of oneof ConfigSpecifier:
	// The set of routing scopes corresponding to the HCM. A scope is assigned to a request by
	// matching a key constructed from the request's attributes according to the algorithm specified
	// by the
	// :ref:`ScopeKeyBuilder<envoy_v3_api_msg_extensions.filters.network.http_connection_manager.v3.ScopedRoutes.ScopeKeyBuilder>`
	// in this message.
	ScopedRouteConfigurationsList *ScopedRouteConfigurationsList
	// The set of routing scopes associated with the HCM will be dynamically loaded via the SRDS
	// API. A scope is assigned to a request by matching a key constructed from the request's
	// attributes according to the algorithm specified by the
	// :ref:`ScopeKeyBuilder<envoy_v3_api_msg_extensions.filters.network.http_connection_manager.v3.ScopedRoutes.ScopeKeyBuilder>`
	// in this message.
	ScopedRds *ScopedRds
	// contains filtered or unexported fields
}

func (ScopedRoutes_builder) Build 

func (b0 ScopedRoutes_builder) Build() *ScopedRoutes

Source Files

  • http_connection_manager.pb.go

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.