Package io.envoyproxy.envoy.extensions.filters.http.rate_limit_quota.v3

Class RateLimitQuotaFilterConfig.Builder

  • All Implemented Interfaces:
    com.google.protobuf.Message.Builder, com.google.protobuf.MessageLite.Builder, com.google.protobuf.MessageLiteOrBuilder, com.google.protobuf.MessageOrBuilder, RateLimitQuotaFilterConfigOrBuilder, Cloneable
    Enclosing class:
    RateLimitQuotaFilterConfig
    public static final class RateLimitQuotaFilterConfig.Builder
extends com.google.protobuf.GeneratedMessageV3.Builder<RateLimitQuotaFilterConfig.Builder>
implements RateLimitQuotaFilterConfigOrBuilder
     Configures the Rate Limit Quota filter.
 Can be overridden in the per-route and per-host configurations.
 The more specific definition completely overrides the less specific definition.
 [#next-free-field: 7]
    Protobuf type envoy.extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaFilterConfig

    • 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<RateLimitQuotaFilterConfig.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<RateLimitQuotaFilterConfig.Builder>

      • getDefaultInstanceForType

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

      • build

        public RateLimitQuotaFilterConfig build()
        Specified by:
        build in interface com.google.protobuf.Message.Builder
        Specified by:
        build in interface com.google.protobuf.MessageLite.Builder

      • buildPartial

        public RateLimitQuotaFilterConfig 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<RateLimitQuotaFilterConfig.Builder>

      • mergeFrom

        public RateLimitQuotaFilterConfig.Builder mergeFrom​(com.google.protobuf.CodedInputStream input,
                                                    com.google.protobuf.ExtensionRegistryLite extensionRegistry)
                                             throws IOException
        Specified by:
        mergeFrom in interface com.google.protobuf.Message.Builder
        Specified by:
        mergeFrom in interface com.google.protobuf.MessageLite.Builder
        Overrides:
        mergeFrom in class com.google.protobuf.AbstractMessage.Builder<RateLimitQuotaFilterConfig.Builder>
        Throws:
        IOException

      • hasRlqsServer

        public boolean hasRlqsServer()
         Configures the gRPC Rate Limit Quota Service (RLQS) RateLimitQuotaService.
        .envoy.config.core.v3.GrpcService rlqs_server = 1 [(.validate.rules) = { ... }
        Specified by:
        hasRlqsServer in interface RateLimitQuotaFilterConfigOrBuilder
        Returns:
        Whether the rlqsServer field is set.

      • getRlqsServer

        public GrpcService getRlqsServer()
         Configures the gRPC Rate Limit Quota Service (RLQS) RateLimitQuotaService.
        .envoy.config.core.v3.GrpcService rlqs_server = 1 [(.validate.rules) = { ... }
        Specified by:
        getRlqsServer in interface RateLimitQuotaFilterConfigOrBuilder
        Returns:
        The rlqsServer.

      • setRlqsServer

        public RateLimitQuotaFilterConfig.Builder setRlqsServer​(GrpcService value)
         Configures the gRPC Rate Limit Quota Service (RLQS) RateLimitQuotaService.
        .envoy.config.core.v3.GrpcService rlqs_server = 1 [(.validate.rules) = { ... }

      • setRlqsServer

        public RateLimitQuotaFilterConfig.Builder setRlqsServer​(GrpcService.Builder builderForValue)
         Configures the gRPC Rate Limit Quota Service (RLQS) RateLimitQuotaService.
        .envoy.config.core.v3.GrpcService rlqs_server = 1 [(.validate.rules) = { ... }

      • mergeRlqsServer

        public RateLimitQuotaFilterConfig.Builder mergeRlqsServer​(GrpcService value)
         Configures the gRPC Rate Limit Quota Service (RLQS) RateLimitQuotaService.
        .envoy.config.core.v3.GrpcService rlqs_server = 1 [(.validate.rules) = { ... }

      • clearRlqsServer

        public RateLimitQuotaFilterConfig.Builder clearRlqsServer()
         Configures the gRPC Rate Limit Quota Service (RLQS) RateLimitQuotaService.
        .envoy.config.core.v3.GrpcService rlqs_server = 1 [(.validate.rules) = { ... }

      • getRlqsServerBuilder

        public GrpcService.Builder getRlqsServerBuilder()
         Configures the gRPC Rate Limit Quota Service (RLQS) RateLimitQuotaService.
        .envoy.config.core.v3.GrpcService rlqs_server = 1 [(.validate.rules) = { ... }

      • getDomain

        public String getDomain()
         The application domain to use when calling the service. This enables sharing the quota
 server between different applications without fear of overlap.
 E.g., "envoy".
        string domain = 2 [(.validate.rules) = { ... }
        Specified by:
        getDomain in interface RateLimitQuotaFilterConfigOrBuilder
        Returns:
        The domain.

      • getDomainBytes

        public com.google.protobuf.ByteString getDomainBytes()
         The application domain to use when calling the service. This enables sharing the quota
 server between different applications without fear of overlap.
 E.g., "envoy".
        string domain = 2 [(.validate.rules) = { ... }
        Specified by:
        getDomainBytes in interface RateLimitQuotaFilterConfigOrBuilder
        Returns:
        The bytes for domain.

      • setDomain

        public RateLimitQuotaFilterConfig.Builder setDomain​(String value)
         The application domain to use when calling the service. This enables sharing the quota
 server between different applications without fear of overlap.
 E.g., "envoy".
        string domain = 2 [(.validate.rules) = { ... }
        Parameters:
        value - The domain to set.
        Returns:
        This builder for chaining.

      • clearDomain

        public RateLimitQuotaFilterConfig.Builder clearDomain()
         The application domain to use when calling the service. This enables sharing the quota
 server between different applications without fear of overlap.
 E.g., "envoy".
        string domain = 2 [(.validate.rules) = { ... }
        Returns:
        This builder for chaining.

      • setDomainBytes

        public RateLimitQuotaFilterConfig.Builder setDomainBytes​(com.google.protobuf.ByteString value)
         The application domain to use when calling the service. This enables sharing the quota
 server between different applications without fear of overlap.
 E.g., "envoy".
        string domain = 2 [(.validate.rules) = { ... }
        Parameters:
        value - The bytes for domain to set.
        Returns:
        This builder for chaining.

      • hasBucketMatchers

        public boolean hasBucketMatchers()
         The match tree to use for grouping incoming requests into buckets.
 Example:
 .. validated-code-block:: yaml
   :type-name: xds.type.matcher.v3.Matcher
   matcher_list:
     matchers:
     # Assign requests with header['env'] set to 'staging' to the bucket { name: 'staging' }
     - predicate:
         single_predicate:
           input:
             typed_config:
               '@type': type.googleapis.com/envoy.type.matcher.v3.HttpRequestHeaderMatchInput
               header_name: env
           value_match:
             exact: staging
       on_match:
         action:
           typed_config:
             '@type': type.googleapis.com/envoy.extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings
             bucket_id_builder:
               bucket_id_builder:
                 name:
                   string_value: staging
     # Assign requests with header['user_group'] set to 'admin' to the bucket { acl: 'admin_users' }
     - predicate:
         single_predicate:
           input:
             typed_config:
               '@type': type.googleapis.com/xds.type.matcher.v3.HttpAttributesCelMatchInput
           custom_match:
             typed_config:
               '@type': type.googleapis.com/xds.type.matcher.v3.CelMatcher
               expr_match:
                 # Shortened for illustration purposes. Here should be parsed CEL expression:
                 # request.headers['user_group'] == 'admin'
                 parsed_expr: {}
       on_match:
         action:
           typed_config:
             '@type': type.googleapis.com/envoy.extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings
             bucket_id_builder:
               bucket_id_builder:
                 acl:
                   string_value: admin_users
   # Catch-all clause for the requests not matched by any of the matchers.
   # In this example, deny all requests.
   on_no_match:
     action:
       typed_config:
         '@type': type.googleapis.com/envoy.extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings
         no_assignment_behavior:
           fallback_rate_limit:
             blanket_rule: DENY_ALL
 .. attention::
  The first matched group wins. Once the request is matched into a bucket, matcher
  evaluation ends.
 Use ``on_no_match`` field to assign the catch-all bucket. If a request is not matched
 into any bucket, and there's no  ``on_no_match`` field configured, the request will be
 ALLOWED by default. It will NOT be reported to the RLQS server.
 Refer to :ref:`Unified Matcher API <envoy_v3_api_msg_.xds.type.matcher.v3.Matcher>`
 documentation for more information on the matcher trees.
        .xds.type.matcher.v3.Matcher bucket_matchers = 3 [(.validate.rules) = { ... }
        Specified by:
        hasBucketMatchers in interface RateLimitQuotaFilterConfigOrBuilder
        Returns:
        Whether the bucketMatchers field is set.

      • getBucketMatchers

        public Matcher getBucketMatchers()
         The match tree to use for grouping incoming requests into buckets.
 Example:
 .. validated-code-block:: yaml
   :type-name: xds.type.matcher.v3.Matcher
   matcher_list:
     matchers:
     # Assign requests with header['env'] set to 'staging' to the bucket { name: 'staging' }
     - predicate:
         single_predicate:
           input:
             typed_config:
               '@type': type.googleapis.com/envoy.type.matcher.v3.HttpRequestHeaderMatchInput
               header_name: env
           value_match:
             exact: staging
       on_match:
         action:
           typed_config:
             '@type': type.googleapis.com/envoy.extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings
             bucket_id_builder:
               bucket_id_builder:
                 name:
                   string_value: staging
     # Assign requests with header['user_group'] set to 'admin' to the bucket { acl: 'admin_users' }
     - predicate:
         single_predicate:
           input:
             typed_config:
               '@type': type.googleapis.com/xds.type.matcher.v3.HttpAttributesCelMatchInput
           custom_match:
             typed_config:
               '@type': type.googleapis.com/xds.type.matcher.v3.CelMatcher
               expr_match:
                 # Shortened for illustration purposes. Here should be parsed CEL expression:
                 # request.headers['user_group'] == 'admin'
                 parsed_expr: {}
       on_match:
         action:
           typed_config:
             '@type': type.googleapis.com/envoy.extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings
             bucket_id_builder:
               bucket_id_builder:
                 acl:
                   string_value: admin_users
   # Catch-all clause for the requests not matched by any of the matchers.
   # In this example, deny all requests.
   on_no_match:
     action:
       typed_config:
         '@type': type.googleapis.com/envoy.extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings
         no_assignment_behavior:
           fallback_rate_limit:
             blanket_rule: DENY_ALL
 .. attention::
  The first matched group wins. Once the request is matched into a bucket, matcher
  evaluation ends.
 Use ``on_no_match`` field to assign the catch-all bucket. If a request is not matched
 into any bucket, and there's no  ``on_no_match`` field configured, the request will be
 ALLOWED by default. It will NOT be reported to the RLQS server.
 Refer to :ref:`Unified Matcher API <envoy_v3_api_msg_.xds.type.matcher.v3.Matcher>`
 documentation for more information on the matcher trees.
        .xds.type.matcher.v3.Matcher bucket_matchers = 3 [(.validate.rules) = { ... }
        Specified by:
        getBucketMatchers in interface RateLimitQuotaFilterConfigOrBuilder
        Returns:
        The bucketMatchers.

      • setBucketMatchers

        public RateLimitQuotaFilterConfig.Builder setBucketMatchers​(Matcher value)
         The match tree to use for grouping incoming requests into buckets.
 Example:
 .. validated-code-block:: yaml
   :type-name: xds.type.matcher.v3.Matcher
   matcher_list:
     matchers:
     # Assign requests with header['env'] set to 'staging' to the bucket { name: 'staging' }
     - predicate:
         single_predicate:
           input:
             typed_config:
               '@type': type.googleapis.com/envoy.type.matcher.v3.HttpRequestHeaderMatchInput
               header_name: env
           value_match:
             exact: staging
       on_match:
         action:
           typed_config:
             '@type': type.googleapis.com/envoy.extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings
             bucket_id_builder:
               bucket_id_builder:
                 name:
                   string_value: staging
     # Assign requests with header['user_group'] set to 'admin' to the bucket { acl: 'admin_users' }
     - predicate:
         single_predicate:
           input:
             typed_config:
               '@type': type.googleapis.com/xds.type.matcher.v3.HttpAttributesCelMatchInput
           custom_match:
             typed_config:
               '@type': type.googleapis.com/xds.type.matcher.v3.CelMatcher
               expr_match:
                 # Shortened for illustration purposes. Here should be parsed CEL expression:
                 # request.headers['user_group'] == 'admin'
                 parsed_expr: {}
       on_match:
         action:
           typed_config:
             '@type': type.googleapis.com/envoy.extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings
             bucket_id_builder:
               bucket_id_builder:
                 acl:
                   string_value: admin_users
   # Catch-all clause for the requests not matched by any of the matchers.
   # In this example, deny all requests.
   on_no_match:
     action:
       typed_config:
         '@type': type.googleapis.com/envoy.extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings
         no_assignment_behavior:
           fallback_rate_limit:
             blanket_rule: DENY_ALL
 .. attention::
  The first matched group wins. Once the request is matched into a bucket, matcher
  evaluation ends.
 Use ``on_no_match`` field to assign the catch-all bucket. If a request is not matched
 into any bucket, and there's no  ``on_no_match`` field configured, the request will be
 ALLOWED by default. It will NOT be reported to the RLQS server.
 Refer to :ref:`Unified Matcher API <envoy_v3_api_msg_.xds.type.matcher.v3.Matcher>`
 documentation for more information on the matcher trees.
        .xds.type.matcher.v3.Matcher bucket_matchers = 3 [(.validate.rules) = { ... }

      • setBucketMatchers

        public RateLimitQuotaFilterConfig.Builder setBucketMatchers​(Matcher.Builder builderForValue)
         The match tree to use for grouping incoming requests into buckets.
 Example:
 .. validated-code-block:: yaml
   :type-name: xds.type.matcher.v3.Matcher
   matcher_list:
     matchers:
     # Assign requests with header['env'] set to 'staging' to the bucket { name: 'staging' }
     - predicate:
         single_predicate:
           input:
             typed_config:
               '@type': type.googleapis.com/envoy.type.matcher.v3.HttpRequestHeaderMatchInput
               header_name: env
           value_match:
             exact: staging
       on_match:
         action:
           typed_config:
             '@type': type.googleapis.com/envoy.extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings
             bucket_id_builder:
               bucket_id_builder:
                 name:
                   string_value: staging
     # Assign requests with header['user_group'] set to 'admin' to the bucket { acl: 'admin_users' }
     - predicate:
         single_predicate:
           input:
             typed_config:
               '@type': type.googleapis.com/xds.type.matcher.v3.HttpAttributesCelMatchInput
           custom_match:
             typed_config:
               '@type': type.googleapis.com/xds.type.matcher.v3.CelMatcher
               expr_match:
                 # Shortened for illustration purposes. Here should be parsed CEL expression:
                 # request.headers['user_group'] == 'admin'
                 parsed_expr: {}
       on_match:
         action:
           typed_config:
             '@type': type.googleapis.com/envoy.extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings
             bucket_id_builder:
               bucket_id_builder:
                 acl:
                   string_value: admin_users
   # Catch-all clause for the requests not matched by any of the matchers.
   # In this example, deny all requests.
   on_no_match:
     action:
       typed_config:
         '@type': type.googleapis.com/envoy.extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings
         no_assignment_behavior:
           fallback_rate_limit:
             blanket_rule: DENY_ALL
 .. attention::
  The first matched group wins. Once the request is matched into a bucket, matcher
  evaluation ends.
 Use ``on_no_match`` field to assign the catch-all bucket. If a request is not matched
 into any bucket, and there's no  ``on_no_match`` field configured, the request will be
 ALLOWED by default. It will NOT be reported to the RLQS server.
 Refer to :ref:`Unified Matcher API <envoy_v3_api_msg_.xds.type.matcher.v3.Matcher>`
 documentation for more information on the matcher trees.
        .xds.type.matcher.v3.Matcher bucket_matchers = 3 [(.validate.rules) = { ... }

      • mergeBucketMatchers

        public RateLimitQuotaFilterConfig.Builder mergeBucketMatchers​(Matcher value)
         The match tree to use for grouping incoming requests into buckets.
 Example:
 .. validated-code-block:: yaml
   :type-name: xds.type.matcher.v3.Matcher
   matcher_list:
     matchers:
     # Assign requests with header['env'] set to 'staging' to the bucket { name: 'staging' }
     - predicate:
         single_predicate:
           input:
             typed_config:
               '@type': type.googleapis.com/envoy.type.matcher.v3.HttpRequestHeaderMatchInput
               header_name: env
           value_match:
             exact: staging
       on_match:
         action:
           typed_config:
             '@type': type.googleapis.com/envoy.extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings
             bucket_id_builder:
               bucket_id_builder:
                 name:
                   string_value: staging
     # Assign requests with header['user_group'] set to 'admin' to the bucket { acl: 'admin_users' }
     - predicate:
         single_predicate:
           input:
             typed_config:
               '@type': type.googleapis.com/xds.type.matcher.v3.HttpAttributesCelMatchInput
           custom_match:
             typed_config:
               '@type': type.googleapis.com/xds.type.matcher.v3.CelMatcher
               expr_match:
                 # Shortened for illustration purposes. Here should be parsed CEL expression:
                 # request.headers['user_group'] == 'admin'
                 parsed_expr: {}
       on_match:
         action:
           typed_config:
             '@type': type.googleapis.com/envoy.extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings
             bucket_id_builder:
               bucket_id_builder:
                 acl:
                   string_value: admin_users
   # Catch-all clause for the requests not matched by any of the matchers.
   # In this example, deny all requests.
   on_no_match:
     action:
       typed_config:
         '@type': type.googleapis.com/envoy.extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings
         no_assignment_behavior:
           fallback_rate_limit:
             blanket_rule: DENY_ALL
 .. attention::
  The first matched group wins. Once the request is matched into a bucket, matcher
  evaluation ends.
 Use ``on_no_match`` field to assign the catch-all bucket. If a request is not matched
 into any bucket, and there's no  ``on_no_match`` field configured, the request will be
 ALLOWED by default. It will NOT be reported to the RLQS server.
 Refer to :ref:`Unified Matcher API <envoy_v3_api_msg_.xds.type.matcher.v3.Matcher>`
 documentation for more information on the matcher trees.
        .xds.type.matcher.v3.Matcher bucket_matchers = 3 [(.validate.rules) = { ... }

      • clearBucketMatchers

        public RateLimitQuotaFilterConfig.Builder clearBucketMatchers()
         The match tree to use for grouping incoming requests into buckets.
 Example:
 .. validated-code-block:: yaml
   :type-name: xds.type.matcher.v3.Matcher
   matcher_list:
     matchers:
     # Assign requests with header['env'] set to 'staging' to the bucket { name: 'staging' }
     - predicate:
         single_predicate:
           input:
             typed_config:
               '@type': type.googleapis.com/envoy.type.matcher.v3.HttpRequestHeaderMatchInput
               header_name: env
           value_match:
             exact: staging
       on_match:
         action:
           typed_config:
             '@type': type.googleapis.com/envoy.extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings
             bucket_id_builder:
               bucket_id_builder:
                 name:
                   string_value: staging
     # Assign requests with header['user_group'] set to 'admin' to the bucket { acl: 'admin_users' }
     - predicate:
         single_predicate:
           input:
             typed_config:
               '@type': type.googleapis.com/xds.type.matcher.v3.HttpAttributesCelMatchInput
           custom_match:
             typed_config:
               '@type': type.googleapis.com/xds.type.matcher.v3.CelMatcher
               expr_match:
                 # Shortened for illustration purposes. Here should be parsed CEL expression:
                 # request.headers['user_group'] == 'admin'
                 parsed_expr: {}
       on_match:
         action:
           typed_config:
             '@type': type.googleapis.com/envoy.extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings
             bucket_id_builder:
               bucket_id_builder:
                 acl:
                   string_value: admin_users
   # Catch-all clause for the requests not matched by any of the matchers.
   # In this example, deny all requests.
   on_no_match:
     action:
       typed_config:
         '@type': type.googleapis.com/envoy.extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings
         no_assignment_behavior:
           fallback_rate_limit:
             blanket_rule: DENY_ALL
 .. attention::
  The first matched group wins. Once the request is matched into a bucket, matcher
  evaluation ends.
 Use ``on_no_match`` field to assign the catch-all bucket. If a request is not matched
 into any bucket, and there's no  ``on_no_match`` field configured, the request will be
 ALLOWED by default. It will NOT be reported to the RLQS server.
 Refer to :ref:`Unified Matcher API <envoy_v3_api_msg_.xds.type.matcher.v3.Matcher>`
 documentation for more information on the matcher trees.
        .xds.type.matcher.v3.Matcher bucket_matchers = 3 [(.validate.rules) = { ... }

      • getBucketMatchersBuilder

        public Matcher.Builder getBucketMatchersBuilder()
         The match tree to use for grouping incoming requests into buckets.
 Example:
 .. validated-code-block:: yaml
   :type-name: xds.type.matcher.v3.Matcher
   matcher_list:
     matchers:
     # Assign requests with header['env'] set to 'staging' to the bucket { name: 'staging' }
     - predicate:
         single_predicate:
           input:
             typed_config:
               '@type': type.googleapis.com/envoy.type.matcher.v3.HttpRequestHeaderMatchInput
               header_name: env
           value_match:
             exact: staging
       on_match:
         action:
           typed_config:
             '@type': type.googleapis.com/envoy.extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings
             bucket_id_builder:
               bucket_id_builder:
                 name:
                   string_value: staging
     # Assign requests with header['user_group'] set to 'admin' to the bucket { acl: 'admin_users' }
     - predicate:
         single_predicate:
           input:
             typed_config:
               '@type': type.googleapis.com/xds.type.matcher.v3.HttpAttributesCelMatchInput
           custom_match:
             typed_config:
               '@type': type.googleapis.com/xds.type.matcher.v3.CelMatcher
               expr_match:
                 # Shortened for illustration purposes. Here should be parsed CEL expression:
                 # request.headers['user_group'] == 'admin'
                 parsed_expr: {}
       on_match:
         action:
           typed_config:
             '@type': type.googleapis.com/envoy.extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings
             bucket_id_builder:
               bucket_id_builder:
                 acl:
                   string_value: admin_users
   # Catch-all clause for the requests not matched by any of the matchers.
   # In this example, deny all requests.
   on_no_match:
     action:
       typed_config:
         '@type': type.googleapis.com/envoy.extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings
         no_assignment_behavior:
           fallback_rate_limit:
             blanket_rule: DENY_ALL
 .. attention::
  The first matched group wins. Once the request is matched into a bucket, matcher
  evaluation ends.
 Use ``on_no_match`` field to assign the catch-all bucket. If a request is not matched
 into any bucket, and there's no  ``on_no_match`` field configured, the request will be
 ALLOWED by default. It will NOT be reported to the RLQS server.
 Refer to :ref:`Unified Matcher API <envoy_v3_api_msg_.xds.type.matcher.v3.Matcher>`
 documentation for more information on the matcher trees.
        .xds.type.matcher.v3.Matcher bucket_matchers = 3 [(.validate.rules) = { ... }

      • getBucketMatchersOrBuilder

        public MatcherOrBuilder getBucketMatchersOrBuilder()
         The match tree to use for grouping incoming requests into buckets.
 Example:
 .. validated-code-block:: yaml
   :type-name: xds.type.matcher.v3.Matcher
   matcher_list:
     matchers:
     # Assign requests with header['env'] set to 'staging' to the bucket { name: 'staging' }
     - predicate:
         single_predicate:
           input:
             typed_config:
               '@type': type.googleapis.com/envoy.type.matcher.v3.HttpRequestHeaderMatchInput
               header_name: env
           value_match:
             exact: staging
       on_match:
         action:
           typed_config:
             '@type': type.googleapis.com/envoy.extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings
             bucket_id_builder:
               bucket_id_builder:
                 name:
                   string_value: staging
     # Assign requests with header['user_group'] set to 'admin' to the bucket { acl: 'admin_users' }
     - predicate:
         single_predicate:
           input:
             typed_config:
               '@type': type.googleapis.com/xds.type.matcher.v3.HttpAttributesCelMatchInput
           custom_match:
             typed_config:
               '@type': type.googleapis.com/xds.type.matcher.v3.CelMatcher
               expr_match:
                 # Shortened for illustration purposes. Here should be parsed CEL expression:
                 # request.headers['user_group'] == 'admin'
                 parsed_expr: {}
       on_match:
         action:
           typed_config:
             '@type': type.googleapis.com/envoy.extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings
             bucket_id_builder:
               bucket_id_builder:
                 acl:
                   string_value: admin_users
   # Catch-all clause for the requests not matched by any of the matchers.
   # In this example, deny all requests.
   on_no_match:
     action:
       typed_config:
         '@type': type.googleapis.com/envoy.extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings
         no_assignment_behavior:
           fallback_rate_limit:
             blanket_rule: DENY_ALL
 .. attention::
  The first matched group wins. Once the request is matched into a bucket, matcher
  evaluation ends.
 Use ``on_no_match`` field to assign the catch-all bucket. If a request is not matched
 into any bucket, and there's no  ``on_no_match`` field configured, the request will be
 ALLOWED by default. It will NOT be reported to the RLQS server.
 Refer to :ref:`Unified Matcher API <envoy_v3_api_msg_.xds.type.matcher.v3.Matcher>`
 documentation for more information on the matcher trees.
        .xds.type.matcher.v3.Matcher bucket_matchers = 3 [(.validate.rules) = { ... }
        Specified by:
        getBucketMatchersOrBuilder in interface RateLimitQuotaFilterConfigOrBuilder

      • hasFilterEnabled

        public boolean hasFilterEnabled()
         If set, this will enable -- but not necessarily enforce -- the rate limit for the given
 fraction of requests.
 Defaults to 100% of requests.
        .envoy.config.core.v3.RuntimeFractionalPercent filter_enabled = 4;
        Specified by:
        hasFilterEnabled in interface RateLimitQuotaFilterConfigOrBuilder
        Returns:
        Whether the filterEnabled field is set.

      • getFilterEnabled

        public RuntimeFractionalPercent getFilterEnabled()
         If set, this will enable -- but not necessarily enforce -- the rate limit for the given
 fraction of requests.
 Defaults to 100% of requests.
        .envoy.config.core.v3.RuntimeFractionalPercent filter_enabled = 4;
        Specified by:
        getFilterEnabled in interface RateLimitQuotaFilterConfigOrBuilder
        Returns:
        The filterEnabled.

      • setFilterEnabled

        public RateLimitQuotaFilterConfig.Builder setFilterEnabled​(RuntimeFractionalPercent value)
         If set, this will enable -- but not necessarily enforce -- the rate limit for the given
 fraction of requests.
 Defaults to 100% of requests.
        .envoy.config.core.v3.RuntimeFractionalPercent filter_enabled = 4;

      • setFilterEnabled

        public RateLimitQuotaFilterConfig.Builder setFilterEnabled​(RuntimeFractionalPercent.Builder builderForValue)
         If set, this will enable -- but not necessarily enforce -- the rate limit for the given
 fraction of requests.
 Defaults to 100% of requests.
        .envoy.config.core.v3.RuntimeFractionalPercent filter_enabled = 4;

      • mergeFilterEnabled

        public RateLimitQuotaFilterConfig.Builder mergeFilterEnabled​(RuntimeFractionalPercent value)
         If set, this will enable -- but not necessarily enforce -- the rate limit for the given
 fraction of requests.
 Defaults to 100% of requests.
        .envoy.config.core.v3.RuntimeFractionalPercent filter_enabled = 4;

      • clearFilterEnabled

        public RateLimitQuotaFilterConfig.Builder clearFilterEnabled()
         If set, this will enable -- but not necessarily enforce -- the rate limit for the given
 fraction of requests.
 Defaults to 100% of requests.
        .envoy.config.core.v3.RuntimeFractionalPercent filter_enabled = 4;

      • getFilterEnabledBuilder

        public RuntimeFractionalPercent.Builder getFilterEnabledBuilder()
         If set, this will enable -- but not necessarily enforce -- the rate limit for the given
 fraction of requests.
 Defaults to 100% of requests.
        .envoy.config.core.v3.RuntimeFractionalPercent filter_enabled = 4;

      • hasFilterEnforced

        public boolean hasFilterEnforced()
         If set, this will enforce the rate limit decisions for the given fraction of requests.
 For requests that are not enforced the filter will still obtain the quota and include it
 in the load computation, however the request will always be allowed regardless of the outcome
 of quota application. This allows validation or testing of the rate limiting service
 infrastructure without disrupting existing traffic.
 Note: this only applies to the fraction of enabled requests.
 Defaults to 100% of requests.
        .envoy.config.core.v3.RuntimeFractionalPercent filter_enforced = 5;
        Specified by:
        hasFilterEnforced in interface RateLimitQuotaFilterConfigOrBuilder
        Returns:
        Whether the filterEnforced field is set.

      • getFilterEnforced

        public RuntimeFractionalPercent getFilterEnforced()
         If set, this will enforce the rate limit decisions for the given fraction of requests.
 For requests that are not enforced the filter will still obtain the quota and include it
 in the load computation, however the request will always be allowed regardless of the outcome
 of quota application. This allows validation or testing of the rate limiting service
 infrastructure without disrupting existing traffic.
 Note: this only applies to the fraction of enabled requests.
 Defaults to 100% of requests.
        .envoy.config.core.v3.RuntimeFractionalPercent filter_enforced = 5;
        Specified by:
        getFilterEnforced in interface RateLimitQuotaFilterConfigOrBuilder
        Returns:
        The filterEnforced.

      • setFilterEnforced

        public RateLimitQuotaFilterConfig.Builder setFilterEnforced​(RuntimeFractionalPercent value)
         If set, this will enforce the rate limit decisions for the given fraction of requests.
 For requests that are not enforced the filter will still obtain the quota and include it
 in the load computation, however the request will always be allowed regardless of the outcome
 of quota application. This allows validation or testing of the rate limiting service
 infrastructure without disrupting existing traffic.
 Note: this only applies to the fraction of enabled requests.
 Defaults to 100% of requests.
        .envoy.config.core.v3.RuntimeFractionalPercent filter_enforced = 5;

      • setFilterEnforced

        public RateLimitQuotaFilterConfig.Builder setFilterEnforced​(RuntimeFractionalPercent.Builder builderForValue)
         If set, this will enforce the rate limit decisions for the given fraction of requests.
 For requests that are not enforced the filter will still obtain the quota and include it
 in the load computation, however the request will always be allowed regardless of the outcome
 of quota application. This allows validation or testing of the rate limiting service
 infrastructure without disrupting existing traffic.
 Note: this only applies to the fraction of enabled requests.
 Defaults to 100% of requests.
        .envoy.config.core.v3.RuntimeFractionalPercent filter_enforced = 5;

      • mergeFilterEnforced

        public RateLimitQuotaFilterConfig.Builder mergeFilterEnforced​(RuntimeFractionalPercent value)
         If set, this will enforce the rate limit decisions for the given fraction of requests.
 For requests that are not enforced the filter will still obtain the quota and include it
 in the load computation, however the request will always be allowed regardless of the outcome
 of quota application. This allows validation or testing of the rate limiting service
 infrastructure without disrupting existing traffic.
 Note: this only applies to the fraction of enabled requests.
 Defaults to 100% of requests.
        .envoy.config.core.v3.RuntimeFractionalPercent filter_enforced = 5;

      • clearFilterEnforced

        public RateLimitQuotaFilterConfig.Builder clearFilterEnforced()
         If set, this will enforce the rate limit decisions for the given fraction of requests.
 For requests that are not enforced the filter will still obtain the quota and include it
 in the load computation, however the request will always be allowed regardless of the outcome
 of quota application. This allows validation or testing of the rate limiting service
 infrastructure without disrupting existing traffic.
 Note: this only applies to the fraction of enabled requests.
 Defaults to 100% of requests.
        .envoy.config.core.v3.RuntimeFractionalPercent filter_enforced = 5;

      • getFilterEnforcedBuilder

        public RuntimeFractionalPercent.Builder getFilterEnforcedBuilder()
         If set, this will enforce the rate limit decisions for the given fraction of requests.
 For requests that are not enforced the filter will still obtain the quota and include it
 in the load computation, however the request will always be allowed regardless of the outcome
 of quota application. This allows validation or testing of the rate limiting service
 infrastructure without disrupting existing traffic.
 Note: this only applies to the fraction of enabled requests.
 Defaults to 100% of requests.
        .envoy.config.core.v3.RuntimeFractionalPercent filter_enforced = 5;

      • getFilterEnforcedOrBuilder

        public RuntimeFractionalPercentOrBuilder getFilterEnforcedOrBuilder()
         If set, this will enforce the rate limit decisions for the given fraction of requests.
 For requests that are not enforced the filter will still obtain the quota and include it
 in the load computation, however the request will always be allowed regardless of the outcome
 of quota application. This allows validation or testing of the rate limiting service
 infrastructure without disrupting existing traffic.
 Note: this only applies to the fraction of enabled requests.
 Defaults to 100% of requests.
        .envoy.config.core.v3.RuntimeFractionalPercent filter_enforced = 5;
        Specified by:
        getFilterEnforcedOrBuilder in interface RateLimitQuotaFilterConfigOrBuilder

      • getRequestHeadersToAddWhenNotEnforcedList

        public List<HeaderValueOption> getRequestHeadersToAddWhenNotEnforcedList()
         Specifies a list of HTTP headers that should be added to each request that
 has been rate limited and is also forwarded upstream. This can only occur when the
 filter is enabled but not enforced.
        repeated .envoy.config.core.v3.HeaderValueOption request_headers_to_add_when_not_enforced = 6 [(.validate.rules) = { ... }
        Specified by:
        getRequestHeadersToAddWhenNotEnforcedList in interface RateLimitQuotaFilterConfigOrBuilder

      • getRequestHeadersToAddWhenNotEnforcedCount

        public int getRequestHeadersToAddWhenNotEnforcedCount()
         Specifies a list of HTTP headers that should be added to each request that
 has been rate limited and is also forwarded upstream. This can only occur when the
 filter is enabled but not enforced.
        repeated .envoy.config.core.v3.HeaderValueOption request_headers_to_add_when_not_enforced = 6 [(.validate.rules) = { ... }
        Specified by:
        getRequestHeadersToAddWhenNotEnforcedCount in interface RateLimitQuotaFilterConfigOrBuilder

      • getRequestHeadersToAddWhenNotEnforced

        public HeaderValueOption getRequestHeadersToAddWhenNotEnforced​(int index)
         Specifies a list of HTTP headers that should be added to each request that
 has been rate limited and is also forwarded upstream. This can only occur when the
 filter is enabled but not enforced.
        repeated .envoy.config.core.v3.HeaderValueOption request_headers_to_add_when_not_enforced = 6 [(.validate.rules) = { ... }
        Specified by:
        getRequestHeadersToAddWhenNotEnforced in interface RateLimitQuotaFilterConfigOrBuilder

      • setRequestHeadersToAddWhenNotEnforced

        public RateLimitQuotaFilterConfig.Builder setRequestHeadersToAddWhenNotEnforced​(int index,
                                                                                HeaderValueOption value)
         Specifies a list of HTTP headers that should be added to each request that
 has been rate limited and is also forwarded upstream. This can only occur when the
 filter is enabled but not enforced.
        repeated .envoy.config.core.v3.HeaderValueOption request_headers_to_add_when_not_enforced = 6 [(.validate.rules) = { ... }

      • setRequestHeadersToAddWhenNotEnforced

        public RateLimitQuotaFilterConfig.Builder setRequestHeadersToAddWhenNotEnforced​(int index,
                                                                                HeaderValueOption.Builder builderForValue)
         Specifies a list of HTTP headers that should be added to each request that
 has been rate limited and is also forwarded upstream. This can only occur when the
 filter is enabled but not enforced.
        repeated .envoy.config.core.v3.HeaderValueOption request_headers_to_add_when_not_enforced = 6 [(.validate.rules) = { ... }

      • addRequestHeadersToAddWhenNotEnforced

        public RateLimitQuotaFilterConfig.Builder addRequestHeadersToAddWhenNotEnforced​(HeaderValueOption value)
         Specifies a list of HTTP headers that should be added to each request that
 has been rate limited and is also forwarded upstream. This can only occur when the
 filter is enabled but not enforced.
        repeated .envoy.config.core.v3.HeaderValueOption request_headers_to_add_when_not_enforced = 6 [(.validate.rules) = { ... }

      • addRequestHeadersToAddWhenNotEnforced

        public RateLimitQuotaFilterConfig.Builder addRequestHeadersToAddWhenNotEnforced​(int index,
                                                                                HeaderValueOption value)
         Specifies a list of HTTP headers that should be added to each request that
 has been rate limited and is also forwarded upstream. This can only occur when the
 filter is enabled but not enforced.
        repeated .envoy.config.core.v3.HeaderValueOption request_headers_to_add_when_not_enforced = 6 [(.validate.rules) = { ... }

      • addRequestHeadersToAddWhenNotEnforced

        public RateLimitQuotaFilterConfig.Builder addRequestHeadersToAddWhenNotEnforced​(HeaderValueOption.Builder builderForValue)
         Specifies a list of HTTP headers that should be added to each request that
 has been rate limited and is also forwarded upstream. This can only occur when the
 filter is enabled but not enforced.
        repeated .envoy.config.core.v3.HeaderValueOption request_headers_to_add_when_not_enforced = 6 [(.validate.rules) = { ... }

      • addRequestHeadersToAddWhenNotEnforced

        public RateLimitQuotaFilterConfig.Builder addRequestHeadersToAddWhenNotEnforced​(int index,
                                                                                HeaderValueOption.Builder builderForValue)
         Specifies a list of HTTP headers that should be added to each request that
 has been rate limited and is also forwarded upstream. This can only occur when the
 filter is enabled but not enforced.
        repeated .envoy.config.core.v3.HeaderValueOption request_headers_to_add_when_not_enforced = 6 [(.validate.rules) = { ... }

      • addAllRequestHeadersToAddWhenNotEnforced

        public RateLimitQuotaFilterConfig.Builder addAllRequestHeadersToAddWhenNotEnforced​(Iterable<? extends HeaderValueOption> values)
         Specifies a list of HTTP headers that should be added to each request that
 has been rate limited and is also forwarded upstream. This can only occur when the
 filter is enabled but not enforced.
        repeated .envoy.config.core.v3.HeaderValueOption request_headers_to_add_when_not_enforced = 6 [(.validate.rules) = { ... }

      • clearRequestHeadersToAddWhenNotEnforced

        public RateLimitQuotaFilterConfig.Builder clearRequestHeadersToAddWhenNotEnforced()
         Specifies a list of HTTP headers that should be added to each request that
 has been rate limited and is also forwarded upstream. This can only occur when the
 filter is enabled but not enforced.
        repeated .envoy.config.core.v3.HeaderValueOption request_headers_to_add_when_not_enforced = 6 [(.validate.rules) = { ... }

      • removeRequestHeadersToAddWhenNotEnforced

        public RateLimitQuotaFilterConfig.Builder removeRequestHeadersToAddWhenNotEnforced​(int index)
         Specifies a list of HTTP headers that should be added to each request that
 has been rate limited and is also forwarded upstream. This can only occur when the
 filter is enabled but not enforced.
        repeated .envoy.config.core.v3.HeaderValueOption request_headers_to_add_when_not_enforced = 6 [(.validate.rules) = { ... }

      • getRequestHeadersToAddWhenNotEnforcedBuilder

        public HeaderValueOption.Builder getRequestHeadersToAddWhenNotEnforcedBuilder​(int index)
         Specifies a list of HTTP headers that should be added to each request that
 has been rate limited and is also forwarded upstream. This can only occur when the
 filter is enabled but not enforced.
        repeated .envoy.config.core.v3.HeaderValueOption request_headers_to_add_when_not_enforced = 6 [(.validate.rules) = { ... }

      • getRequestHeadersToAddWhenNotEnforcedOrBuilder

        public HeaderValueOptionOrBuilder getRequestHeadersToAddWhenNotEnforcedOrBuilder​(int index)
         Specifies a list of HTTP headers that should be added to each request that
 has been rate limited and is also forwarded upstream. This can only occur when the
 filter is enabled but not enforced.
        repeated .envoy.config.core.v3.HeaderValueOption request_headers_to_add_when_not_enforced = 6 [(.validate.rules) = { ... }
        Specified by:
        getRequestHeadersToAddWhenNotEnforcedOrBuilder in interface RateLimitQuotaFilterConfigOrBuilder

      • getRequestHeadersToAddWhenNotEnforcedOrBuilderList

        public List<? extends HeaderValueOptionOrBuilder> getRequestHeadersToAddWhenNotEnforcedOrBuilderList()
         Specifies a list of HTTP headers that should be added to each request that
 has been rate limited and is also forwarded upstream. This can only occur when the
 filter is enabled but not enforced.
        repeated .envoy.config.core.v3.HeaderValueOption request_headers_to_add_when_not_enforced = 6 [(.validate.rules) = { ... }
        Specified by:
        getRequestHeadersToAddWhenNotEnforcedOrBuilderList in interface RateLimitQuotaFilterConfigOrBuilder

      • addRequestHeadersToAddWhenNotEnforcedBuilder

        public HeaderValueOption.Builder addRequestHeadersToAddWhenNotEnforcedBuilder()
         Specifies a list of HTTP headers that should be added to each request that
 has been rate limited and is also forwarded upstream. This can only occur when the
 filter is enabled but not enforced.
        repeated .envoy.config.core.v3.HeaderValueOption request_headers_to_add_when_not_enforced = 6 [(.validate.rules) = { ... }

      • addRequestHeadersToAddWhenNotEnforcedBuilder

        public HeaderValueOption.Builder addRequestHeadersToAddWhenNotEnforcedBuilder​(int index)
         Specifies a list of HTTP headers that should be added to each request that
 has been rate limited and is also forwarded upstream. This can only occur when the
 filter is enabled but not enforced.
        repeated .envoy.config.core.v3.HeaderValueOption request_headers_to_add_when_not_enforced = 6 [(.validate.rules) = { ... }

      • getRequestHeadersToAddWhenNotEnforcedBuilderList

        public List<HeaderValueOption.Builder> getRequestHeadersToAddWhenNotEnforcedBuilderList()
         Specifies a list of HTTP headers that should be added to each request that
 has been rate limited and is also forwarded upstream. This can only occur when the
 filter is enabled but not enforced.
        repeated .envoy.config.core.v3.HeaderValueOption request_headers_to_add_when_not_enforced = 6 [(.validate.rules) = { ... }

      • setUnknownFields

        public final RateLimitQuotaFilterConfig.Builder setUnknownFields​(com.google.protobuf.UnknownFieldSet unknownFields)
        Specified by:
        setUnknownFields in interface com.google.protobuf.Message.Builder
        Overrides:
        setUnknownFields in class com.google.protobuf.GeneratedMessageV3.Builder<RateLimitQuotaFilterConfig.Builder>

      • mergeUnknownFields

        public final RateLimitQuotaFilterConfig.Builder mergeUnknownFields​(com.google.protobuf.UnknownFieldSet unknownFields)
        Specified by:
        mergeUnknownFields in interface com.google.protobuf.Message.Builder
        Overrides:
        mergeUnknownFields in class com.google.protobuf.GeneratedMessageV3.Builder<RateLimitQuotaFilterConfig.Builder>