Package io.envoyproxy.envoy.extensions.filters.network.http_connection_manager.v3

Class HttpConnectionManager.PathNormalizationOptions.Builder

  • All Implemented Interfaces:
    com.google.protobuf.Message.Builder, com.google.protobuf.MessageLite.Builder, com.google.protobuf.MessageLiteOrBuilder, com.google.protobuf.MessageOrBuilder, HttpConnectionManager.PathNormalizationOptionsOrBuilder, Cloneable
    Enclosing class:
    HttpConnectionManager.PathNormalizationOptions
    public static final class HttpConnectionManager.PathNormalizationOptions.Builder
extends com.google.protobuf.GeneratedMessageV3.Builder<HttpConnectionManager.PathNormalizationOptions.Builder>
implements HttpConnectionManager.PathNormalizationOptionsOrBuilder
     [#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.
    Protobuf type envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.PathNormalizationOptions

    • Method Detail

      • getDescriptor

        public static final com.google.protobuf.Descriptors.Descriptor getDescriptor()

      • internalGetFieldAccessorTable

        protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable()
        Specified by:
        internalGetFieldAccessorTable in class com.google.protobuf.GeneratedMessageV3.Builder<HttpConnectionManager.PathNormalizationOptions.Builder>

      • getDescriptorForType

        public com.google.protobuf.Descriptors.Descriptor getDescriptorForType()
        Specified by:
        getDescriptorForType in interface com.google.protobuf.Message.Builder
        Specified by:
        getDescriptorForType in interface com.google.protobuf.MessageOrBuilder
        Overrides:
        getDescriptorForType in class com.google.protobuf.GeneratedMessageV3.Builder<HttpConnectionManager.PathNormalizationOptions.Builder>

      • getDefaultInstanceForType

        public HttpConnectionManager.PathNormalizationOptions getDefaultInstanceForType()
        Specified by:
        getDefaultInstanceForType in interface com.google.protobuf.MessageLiteOrBuilder
        Specified by:
        getDefaultInstanceForType in interface com.google.protobuf.MessageOrBuilder

      • buildPartial

        public HttpConnectionManager.PathNormalizationOptions buildPartial()
        Specified by:
        buildPartial in interface com.google.protobuf.Message.Builder
        Specified by:
        buildPartial in interface com.google.protobuf.MessageLite.Builder

      • isInitialized

        public final boolean isInitialized()
        Specified by:
        isInitialized in interface com.google.protobuf.MessageLiteOrBuilder
        Overrides:
        isInitialized in class com.google.protobuf.GeneratedMessageV3.Builder<HttpConnectionManager.PathNormalizationOptions.Builder>

      • hasForwardingTransformation

        public boolean hasForwardingTransformation()
         [#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.)
        .envoy.type.http.v3.PathTransformation forwarding_transformation = 1;
        Specified by:
        hasForwardingTransformation in interface HttpConnectionManager.PathNormalizationOptionsOrBuilder
        Returns:
        Whether the forwardingTransformation field is set.

      • getForwardingTransformation

        public PathTransformation getForwardingTransformation()
         [#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.)
        .envoy.type.http.v3.PathTransformation forwarding_transformation = 1;
        Specified by:
        getForwardingTransformation in interface HttpConnectionManager.PathNormalizationOptionsOrBuilder
        Returns:
        The forwardingTransformation.

      • setForwardingTransformation

        public HttpConnectionManager.PathNormalizationOptions.Builder setForwardingTransformation​(PathTransformation value)
         [#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.)
        .envoy.type.http.v3.PathTransformation forwarding_transformation = 1;

      • setForwardingTransformation

        public HttpConnectionManager.PathNormalizationOptions.Builder setForwardingTransformation​(PathTransformation.Builder builderForValue)
         [#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.)
        .envoy.type.http.v3.PathTransformation forwarding_transformation = 1;

      • mergeForwardingTransformation

        public HttpConnectionManager.PathNormalizationOptions.Builder mergeForwardingTransformation​(PathTransformation value)
         [#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.)
        .envoy.type.http.v3.PathTransformation forwarding_transformation = 1;

      • clearForwardingTransformation

        public HttpConnectionManager.PathNormalizationOptions.Builder clearForwardingTransformation()
         [#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.)
        .envoy.type.http.v3.PathTransformation forwarding_transformation = 1;

      • getForwardingTransformationBuilder

        public PathTransformation.Builder getForwardingTransformationBuilder()
         [#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.)
        .envoy.type.http.v3.PathTransformation forwarding_transformation = 1;

      • getForwardingTransformationOrBuilder

        public PathTransformationOrBuilder getForwardingTransformationOrBuilder()
         [#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.)
        .envoy.type.http.v3.PathTransformation forwarding_transformation = 1;
        Specified by:
        getForwardingTransformationOrBuilder in interface HttpConnectionManager.PathNormalizationOptionsOrBuilder

      • hasHttpFilterTransformation

        public boolean hasHttpFilterTransformation()
         [#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.)
        .envoy.type.http.v3.PathTransformation http_filter_transformation = 2;
        Specified by:
        hasHttpFilterTransformation in interface HttpConnectionManager.PathNormalizationOptionsOrBuilder
        Returns:
        Whether the httpFilterTransformation field is set.

      • getHttpFilterTransformation

        public PathTransformation getHttpFilterTransformation()
         [#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.)
        .envoy.type.http.v3.PathTransformation http_filter_transformation = 2;
        Specified by:
        getHttpFilterTransformation in interface HttpConnectionManager.PathNormalizationOptionsOrBuilder
        Returns:
        The httpFilterTransformation.

      • setHttpFilterTransformation

        public HttpConnectionManager.PathNormalizationOptions.Builder setHttpFilterTransformation​(PathTransformation value)
         [#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.)
        .envoy.type.http.v3.PathTransformation http_filter_transformation = 2;

      • setHttpFilterTransformation

        public HttpConnectionManager.PathNormalizationOptions.Builder setHttpFilterTransformation​(PathTransformation.Builder builderForValue)
         [#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.)
        .envoy.type.http.v3.PathTransformation http_filter_transformation = 2;

      • mergeHttpFilterTransformation

        public HttpConnectionManager.PathNormalizationOptions.Builder mergeHttpFilterTransformation​(PathTransformation value)
         [#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.)
        .envoy.type.http.v3.PathTransformation http_filter_transformation = 2;

      • clearHttpFilterTransformation

        public HttpConnectionManager.PathNormalizationOptions.Builder clearHttpFilterTransformation()
         [#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.)
        .envoy.type.http.v3.PathTransformation http_filter_transformation = 2;

      • getHttpFilterTransformationBuilder

        public PathTransformation.Builder getHttpFilterTransformationBuilder()
         [#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.)
        .envoy.type.http.v3.PathTransformation http_filter_transformation = 2;

      • getHttpFilterTransformationOrBuilder

        public PathTransformationOrBuilder getHttpFilterTransformationOrBuilder()
         [#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.)
        .envoy.type.http.v3.PathTransformation http_filter_transformation = 2;
        Specified by:
        getHttpFilterTransformationOrBuilder in interface HttpConnectionManager.PathNormalizationOptionsOrBuilder