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, java.lang.Cloneable
    Enclosing class:
    HttpConnectionManager.PathNormalizationOptions

    public static final class HttpConnectionManager.PathNormalizationOptions.Builder
    extends com.google.protobuf.GeneratedMessage.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
    • Constructor Detail

      • Builder

        private Builder()
      • Builder

        private Builder​(com.google.protobuf.AbstractMessage.BuilderParent parent)
    • Method Detail

      • getDescriptor

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

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

        private void maybeForceBuilderInitialization()
      • 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.GeneratedMessage.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.GeneratedMessage.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
      • getForwardingTransformationFieldBuilder

        private com.google.protobuf.SingleFieldBuilder<PathTransformation,​PathTransformation.Builder,​PathTransformationOrBuilder> getForwardingTransformationFieldBuilder()
         [#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;
      • 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
      • getHttpFilterTransformationFieldBuilder

        private com.google.protobuf.SingleFieldBuilder<PathTransformation,​PathTransformation.Builder,​PathTransformationOrBuilder> getHttpFilterTransformationFieldBuilder()
         [#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;