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

Class RedisProxy.ConnPoolSettings.Builder

    • 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<RedisProxy.ConnPoolSettings.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<RedisProxy.ConnPoolSettings.Builder>

      • getDefaultInstanceForType

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

      • build

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

      • buildPartial

        public RedisProxy.ConnPoolSettings 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<RedisProxy.ConnPoolSettings.Builder>

      • mergeFrom

        public RedisProxy.ConnPoolSettings.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<RedisProxy.ConnPoolSettings.Builder>
        Throws:
        IOException

      • hasOpTimeout

        public boolean hasOpTimeout()
         Per-operation timeout in milliseconds. The timer starts when the first
 command of a pipeline is written to the backend connection. Each response received from Redis
 resets the timer since it signifies that the next command is being processed by the backend.
 The only exception to this behavior is when a connection to a backend is not yet established.
 In that case, the connect timeout on the cluster will govern the timeout until the connection
 is ready.
        .google.protobuf.Duration op_timeout = 1 [(.validate.rules) = { ... }
        Specified by:
        hasOpTimeout in interface RedisProxy.ConnPoolSettingsOrBuilder
        Returns:
        Whether the opTimeout field is set.

      • getOpTimeout

        public com.google.protobuf.Duration getOpTimeout()
         Per-operation timeout in milliseconds. The timer starts when the first
 command of a pipeline is written to the backend connection. Each response received from Redis
 resets the timer since it signifies that the next command is being processed by the backend.
 The only exception to this behavior is when a connection to a backend is not yet established.
 In that case, the connect timeout on the cluster will govern the timeout until the connection
 is ready.
        .google.protobuf.Duration op_timeout = 1 [(.validate.rules) = { ... }
        Specified by:
        getOpTimeout in interface RedisProxy.ConnPoolSettingsOrBuilder
        Returns:
        The opTimeout.

      • setOpTimeout

        public RedisProxy.ConnPoolSettings.Builder setOpTimeout​(com.google.protobuf.Duration value)
         Per-operation timeout in milliseconds. The timer starts when the first
 command of a pipeline is written to the backend connection. Each response received from Redis
 resets the timer since it signifies that the next command is being processed by the backend.
 The only exception to this behavior is when a connection to a backend is not yet established.
 In that case, the connect timeout on the cluster will govern the timeout until the connection
 is ready.
        .google.protobuf.Duration op_timeout = 1 [(.validate.rules) = { ... }

      • setOpTimeout

        public RedisProxy.ConnPoolSettings.Builder setOpTimeout​(com.google.protobuf.Duration.Builder builderForValue)
         Per-operation timeout in milliseconds. The timer starts when the first
 command of a pipeline is written to the backend connection. Each response received from Redis
 resets the timer since it signifies that the next command is being processed by the backend.
 The only exception to this behavior is when a connection to a backend is not yet established.
 In that case, the connect timeout on the cluster will govern the timeout until the connection
 is ready.
        .google.protobuf.Duration op_timeout = 1 [(.validate.rules) = { ... }

      • mergeOpTimeout

        public RedisProxy.ConnPoolSettings.Builder mergeOpTimeout​(com.google.protobuf.Duration value)
         Per-operation timeout in milliseconds. The timer starts when the first
 command of a pipeline is written to the backend connection. Each response received from Redis
 resets the timer since it signifies that the next command is being processed by the backend.
 The only exception to this behavior is when a connection to a backend is not yet established.
 In that case, the connect timeout on the cluster will govern the timeout until the connection
 is ready.
        .google.protobuf.Duration op_timeout = 1 [(.validate.rules) = { ... }

      • clearOpTimeout

        public RedisProxy.ConnPoolSettings.Builder clearOpTimeout()
         Per-operation timeout in milliseconds. The timer starts when the first
 command of a pipeline is written to the backend connection. Each response received from Redis
 resets the timer since it signifies that the next command is being processed by the backend.
 The only exception to this behavior is when a connection to a backend is not yet established.
 In that case, the connect timeout on the cluster will govern the timeout until the connection
 is ready.
        .google.protobuf.Duration op_timeout = 1 [(.validate.rules) = { ... }

      • getOpTimeoutBuilder

        public com.google.protobuf.Duration.Builder getOpTimeoutBuilder()
         Per-operation timeout in milliseconds. The timer starts when the first
 command of a pipeline is written to the backend connection. Each response received from Redis
 resets the timer since it signifies that the next command is being processed by the backend.
 The only exception to this behavior is when a connection to a backend is not yet established.
 In that case, the connect timeout on the cluster will govern the timeout until the connection
 is ready.
        .google.protobuf.Duration op_timeout = 1 [(.validate.rules) = { ... }

      • getOpTimeoutOrBuilder

        public com.google.protobuf.DurationOrBuilder getOpTimeoutOrBuilder()
         Per-operation timeout in milliseconds. The timer starts when the first
 command of a pipeline is written to the backend connection. Each response received from Redis
 resets the timer since it signifies that the next command is being processed by the backend.
 The only exception to this behavior is when a connection to a backend is not yet established.
 In that case, the connect timeout on the cluster will govern the timeout until the connection
 is ready.
        .google.protobuf.Duration op_timeout = 1 [(.validate.rules) = { ... }
        Specified by:
        getOpTimeoutOrBuilder in interface RedisProxy.ConnPoolSettingsOrBuilder

      • getEnableHashtagging

        public boolean getEnableHashtagging()
         Use hash tagging on every redis key to guarantee that keys with the same hash tag will be
 forwarded to the same upstream. The hash key used for determining the upstream in a
 consistent hash ring configuration will be computed from the hash tagged key instead of the
 whole key. The algorithm used to compute the hash tag is identical to the `redis-cluster
 implementation <https://redis.io/topics/cluster-spec#keys-hash-tags>`_.
 Examples:
 * '{user1000}.following' and '{user1000}.followers' **will** be sent to the same upstream
 * '{user1000}.following' and '{user1001}.following' **might** be sent to the same upstream
        bool enable_hashtagging = 2;
        Specified by:
        getEnableHashtagging in interface RedisProxy.ConnPoolSettingsOrBuilder
        Returns:
        The enableHashtagging.

      • setEnableHashtagging

        public RedisProxy.ConnPoolSettings.Builder setEnableHashtagging​(boolean value)
         Use hash tagging on every redis key to guarantee that keys with the same hash tag will be
 forwarded to the same upstream. The hash key used for determining the upstream in a
 consistent hash ring configuration will be computed from the hash tagged key instead of the
 whole key. The algorithm used to compute the hash tag is identical to the `redis-cluster
 implementation <https://redis.io/topics/cluster-spec#keys-hash-tags>`_.
 Examples:
 * '{user1000}.following' and '{user1000}.followers' **will** be sent to the same upstream
 * '{user1000}.following' and '{user1001}.following' **might** be sent to the same upstream
        bool enable_hashtagging = 2;
        Parameters:
        value - The enableHashtagging to set.
        Returns:
        This builder for chaining.

      • clearEnableHashtagging

        public RedisProxy.ConnPoolSettings.Builder clearEnableHashtagging()
         Use hash tagging on every redis key to guarantee that keys with the same hash tag will be
 forwarded to the same upstream. The hash key used for determining the upstream in a
 consistent hash ring configuration will be computed from the hash tagged key instead of the
 whole key. The algorithm used to compute the hash tag is identical to the `redis-cluster
 implementation <https://redis.io/topics/cluster-spec#keys-hash-tags>`_.
 Examples:
 * '{user1000}.following' and '{user1000}.followers' **will** be sent to the same upstream
 * '{user1000}.following' and '{user1001}.following' **might** be sent to the same upstream
        bool enable_hashtagging = 2;
        Returns:
        This builder for chaining.

      • getEnableRedirection

        public boolean getEnableRedirection()
         Accept `moved and ask redirection
 <https://redis.io/topics/cluster-spec#redirection-and-resharding>`_ errors from upstream
 redis servers, and retry commands to the specified target server. The target server does not
 need to be known to the cluster manager. If the command cannot be redirected, then the
 original error is passed downstream unchanged. By default, this support is not enabled.
        bool enable_redirection = 3;
        Specified by:
        getEnableRedirection in interface RedisProxy.ConnPoolSettingsOrBuilder
        Returns:
        The enableRedirection.

      • setEnableRedirection

        public RedisProxy.ConnPoolSettings.Builder setEnableRedirection​(boolean value)
         Accept `moved and ask redirection
 <https://redis.io/topics/cluster-spec#redirection-and-resharding>`_ errors from upstream
 redis servers, and retry commands to the specified target server. The target server does not
 need to be known to the cluster manager. If the command cannot be redirected, then the
 original error is passed downstream unchanged. By default, this support is not enabled.
        bool enable_redirection = 3;
        Parameters:
        value - The enableRedirection to set.
        Returns:
        This builder for chaining.

      • clearEnableRedirection

        public RedisProxy.ConnPoolSettings.Builder clearEnableRedirection()
         Accept `moved and ask redirection
 <https://redis.io/topics/cluster-spec#redirection-and-resharding>`_ errors from upstream
 redis servers, and retry commands to the specified target server. The target server does not
 need to be known to the cluster manager. If the command cannot be redirected, then the
 original error is passed downstream unchanged. By default, this support is not enabled.
        bool enable_redirection = 3;
        Returns:
        This builder for chaining.

      • getMaxBufferSizeBeforeFlush

        public int getMaxBufferSizeBeforeFlush()
         Maximum size of encoded request buffer before flush is triggered and encoded requests
 are sent upstream. If this is unset, the buffer flushes whenever it receives data
 and performs no batching.
 This feature makes it possible for multiple clients to send requests to Envoy and have
 them batched- for example if one is running several worker processes, each with its own
 Redis connection. There is no benefit to using this with a single downstream process.
 Recommended size (if enabled) is 1024 bytes.
        uint32 max_buffer_size_before_flush = 4;
        Specified by:
        getMaxBufferSizeBeforeFlush in interface RedisProxy.ConnPoolSettingsOrBuilder
        Returns:
        The maxBufferSizeBeforeFlush.

      • setMaxBufferSizeBeforeFlush

        public RedisProxy.ConnPoolSettings.Builder setMaxBufferSizeBeforeFlush​(int value)
         Maximum size of encoded request buffer before flush is triggered and encoded requests
 are sent upstream. If this is unset, the buffer flushes whenever it receives data
 and performs no batching.
 This feature makes it possible for multiple clients to send requests to Envoy and have
 them batched- for example if one is running several worker processes, each with its own
 Redis connection. There is no benefit to using this with a single downstream process.
 Recommended size (if enabled) is 1024 bytes.
        uint32 max_buffer_size_before_flush = 4;
        Parameters:
        value - The maxBufferSizeBeforeFlush to set.
        Returns:
        This builder for chaining.

      • clearMaxBufferSizeBeforeFlush

        public RedisProxy.ConnPoolSettings.Builder clearMaxBufferSizeBeforeFlush()
         Maximum size of encoded request buffer before flush is triggered and encoded requests
 are sent upstream. If this is unset, the buffer flushes whenever it receives data
 and performs no batching.
 This feature makes it possible for multiple clients to send requests to Envoy and have
 them batched- for example if one is running several worker processes, each with its own
 Redis connection. There is no benefit to using this with a single downstream process.
 Recommended size (if enabled) is 1024 bytes.
        uint32 max_buffer_size_before_flush = 4;
        Returns:
        This builder for chaining.

      • hasBufferFlushTimeout

        public boolean hasBufferFlushTimeout()
         The encoded request buffer is flushed N milliseconds after the first request has been
 encoded, unless the buffer size has already exceeded ``max_buffer_size_before_flush``.
 If ``max_buffer_size_before_flush`` is not set, this flush timer is not used. Otherwise,
 the timer should be set according to the number of clients, overall request rate and
 desired maximum latency for a single command. For example, if there are many requests
 being batched together at a high rate, the buffer will likely be filled before the timer
 fires. Alternatively, if the request rate is lower the buffer will not be filled as often
 before the timer fires.
 If ``max_buffer_size_before_flush`` is set, but ``buffer_flush_timeout`` is not, the latter
 defaults to 3ms.
        .google.protobuf.Duration buffer_flush_timeout = 5;
        Specified by:
        hasBufferFlushTimeout in interface RedisProxy.ConnPoolSettingsOrBuilder
        Returns:
        Whether the bufferFlushTimeout field is set.

      • getBufferFlushTimeout

        public com.google.protobuf.Duration getBufferFlushTimeout()
         The encoded request buffer is flushed N milliseconds after the first request has been
 encoded, unless the buffer size has already exceeded ``max_buffer_size_before_flush``.
 If ``max_buffer_size_before_flush`` is not set, this flush timer is not used. Otherwise,
 the timer should be set according to the number of clients, overall request rate and
 desired maximum latency for a single command. For example, if there are many requests
 being batched together at a high rate, the buffer will likely be filled before the timer
 fires. Alternatively, if the request rate is lower the buffer will not be filled as often
 before the timer fires.
 If ``max_buffer_size_before_flush`` is set, but ``buffer_flush_timeout`` is not, the latter
 defaults to 3ms.
        .google.protobuf.Duration buffer_flush_timeout = 5;
        Specified by:
        getBufferFlushTimeout in interface RedisProxy.ConnPoolSettingsOrBuilder
        Returns:
        The bufferFlushTimeout.

      • setBufferFlushTimeout

        public RedisProxy.ConnPoolSettings.Builder setBufferFlushTimeout​(com.google.protobuf.Duration value)
         The encoded request buffer is flushed N milliseconds after the first request has been
 encoded, unless the buffer size has already exceeded ``max_buffer_size_before_flush``.
 If ``max_buffer_size_before_flush`` is not set, this flush timer is not used. Otherwise,
 the timer should be set according to the number of clients, overall request rate and
 desired maximum latency for a single command. For example, if there are many requests
 being batched together at a high rate, the buffer will likely be filled before the timer
 fires. Alternatively, if the request rate is lower the buffer will not be filled as often
 before the timer fires.
 If ``max_buffer_size_before_flush`` is set, but ``buffer_flush_timeout`` is not, the latter
 defaults to 3ms.
        .google.protobuf.Duration buffer_flush_timeout = 5;

      • setBufferFlushTimeout

        public RedisProxy.ConnPoolSettings.Builder setBufferFlushTimeout​(com.google.protobuf.Duration.Builder builderForValue)
         The encoded request buffer is flushed N milliseconds after the first request has been
 encoded, unless the buffer size has already exceeded ``max_buffer_size_before_flush``.
 If ``max_buffer_size_before_flush`` is not set, this flush timer is not used. Otherwise,
 the timer should be set according to the number of clients, overall request rate and
 desired maximum latency for a single command. For example, if there are many requests
 being batched together at a high rate, the buffer will likely be filled before the timer
 fires. Alternatively, if the request rate is lower the buffer will not be filled as often
 before the timer fires.
 If ``max_buffer_size_before_flush`` is set, but ``buffer_flush_timeout`` is not, the latter
 defaults to 3ms.
        .google.protobuf.Duration buffer_flush_timeout = 5;

      • mergeBufferFlushTimeout

        public RedisProxy.ConnPoolSettings.Builder mergeBufferFlushTimeout​(com.google.protobuf.Duration value)
         The encoded request buffer is flushed N milliseconds after the first request has been
 encoded, unless the buffer size has already exceeded ``max_buffer_size_before_flush``.
 If ``max_buffer_size_before_flush`` is not set, this flush timer is not used. Otherwise,
 the timer should be set according to the number of clients, overall request rate and
 desired maximum latency for a single command. For example, if there are many requests
 being batched together at a high rate, the buffer will likely be filled before the timer
 fires. Alternatively, if the request rate is lower the buffer will not be filled as often
 before the timer fires.
 If ``max_buffer_size_before_flush`` is set, but ``buffer_flush_timeout`` is not, the latter
 defaults to 3ms.
        .google.protobuf.Duration buffer_flush_timeout = 5;

      • clearBufferFlushTimeout

        public RedisProxy.ConnPoolSettings.Builder clearBufferFlushTimeout()
         The encoded request buffer is flushed N milliseconds after the first request has been
 encoded, unless the buffer size has already exceeded ``max_buffer_size_before_flush``.
 If ``max_buffer_size_before_flush`` is not set, this flush timer is not used. Otherwise,
 the timer should be set according to the number of clients, overall request rate and
 desired maximum latency for a single command. For example, if there are many requests
 being batched together at a high rate, the buffer will likely be filled before the timer
 fires. Alternatively, if the request rate is lower the buffer will not be filled as often
 before the timer fires.
 If ``max_buffer_size_before_flush`` is set, but ``buffer_flush_timeout`` is not, the latter
 defaults to 3ms.
        .google.protobuf.Duration buffer_flush_timeout = 5;

      • getBufferFlushTimeoutBuilder

        public com.google.protobuf.Duration.Builder getBufferFlushTimeoutBuilder()
         The encoded request buffer is flushed N milliseconds after the first request has been
 encoded, unless the buffer size has already exceeded ``max_buffer_size_before_flush``.
 If ``max_buffer_size_before_flush`` is not set, this flush timer is not used. Otherwise,
 the timer should be set according to the number of clients, overall request rate and
 desired maximum latency for a single command. For example, if there are many requests
 being batched together at a high rate, the buffer will likely be filled before the timer
 fires. Alternatively, if the request rate is lower the buffer will not be filled as often
 before the timer fires.
 If ``max_buffer_size_before_flush`` is set, but ``buffer_flush_timeout`` is not, the latter
 defaults to 3ms.
        .google.protobuf.Duration buffer_flush_timeout = 5;

      • getBufferFlushTimeoutOrBuilder

        public com.google.protobuf.DurationOrBuilder getBufferFlushTimeoutOrBuilder()
         The encoded request buffer is flushed N milliseconds after the first request has been
 encoded, unless the buffer size has already exceeded ``max_buffer_size_before_flush``.
 If ``max_buffer_size_before_flush`` is not set, this flush timer is not used. Otherwise,
 the timer should be set according to the number of clients, overall request rate and
 desired maximum latency for a single command. For example, if there are many requests
 being batched together at a high rate, the buffer will likely be filled before the timer
 fires. Alternatively, if the request rate is lower the buffer will not be filled as often
 before the timer fires.
 If ``max_buffer_size_before_flush`` is set, but ``buffer_flush_timeout`` is not, the latter
 defaults to 3ms.
        .google.protobuf.Duration buffer_flush_timeout = 5;
        Specified by:
        getBufferFlushTimeoutOrBuilder in interface RedisProxy.ConnPoolSettingsOrBuilder

      • hasMaxUpstreamUnknownConnections

        public boolean hasMaxUpstreamUnknownConnections()
         ``max_upstream_unknown_connections`` controls how many upstream connections to unknown hosts
 can be created at any given time by any given worker thread (see ``enable_redirection`` for
 more details). If the host is unknown and a connection cannot be created due to enforcing
 this limit, then redirection will fail and the original redirection error will be passed
 downstream unchanged. This limit defaults to 100.
        .google.protobuf.UInt32Value max_upstream_unknown_connections = 6;
        Specified by:
        hasMaxUpstreamUnknownConnections in interface RedisProxy.ConnPoolSettingsOrBuilder
        Returns:
        Whether the maxUpstreamUnknownConnections field is set.

      • getMaxUpstreamUnknownConnections

        public com.google.protobuf.UInt32Value getMaxUpstreamUnknownConnections()
         ``max_upstream_unknown_connections`` controls how many upstream connections to unknown hosts
 can be created at any given time by any given worker thread (see ``enable_redirection`` for
 more details). If the host is unknown and a connection cannot be created due to enforcing
 this limit, then redirection will fail and the original redirection error will be passed
 downstream unchanged. This limit defaults to 100.
        .google.protobuf.UInt32Value max_upstream_unknown_connections = 6;
        Specified by:
        getMaxUpstreamUnknownConnections in interface RedisProxy.ConnPoolSettingsOrBuilder
        Returns:
        The maxUpstreamUnknownConnections.

      • setMaxUpstreamUnknownConnections

        public RedisProxy.ConnPoolSettings.Builder setMaxUpstreamUnknownConnections​(com.google.protobuf.UInt32Value value)
         ``max_upstream_unknown_connections`` controls how many upstream connections to unknown hosts
 can be created at any given time by any given worker thread (see ``enable_redirection`` for
 more details). If the host is unknown and a connection cannot be created due to enforcing
 this limit, then redirection will fail and the original redirection error will be passed
 downstream unchanged. This limit defaults to 100.
        .google.protobuf.UInt32Value max_upstream_unknown_connections = 6;

      • setMaxUpstreamUnknownConnections

        public RedisProxy.ConnPoolSettings.Builder setMaxUpstreamUnknownConnections​(com.google.protobuf.UInt32Value.Builder builderForValue)
         ``max_upstream_unknown_connections`` controls how many upstream connections to unknown hosts
 can be created at any given time by any given worker thread (see ``enable_redirection`` for
 more details). If the host is unknown and a connection cannot be created due to enforcing
 this limit, then redirection will fail and the original redirection error will be passed
 downstream unchanged. This limit defaults to 100.
        .google.protobuf.UInt32Value max_upstream_unknown_connections = 6;

      • mergeMaxUpstreamUnknownConnections

        public RedisProxy.ConnPoolSettings.Builder mergeMaxUpstreamUnknownConnections​(com.google.protobuf.UInt32Value value)
         ``max_upstream_unknown_connections`` controls how many upstream connections to unknown hosts
 can be created at any given time by any given worker thread (see ``enable_redirection`` for
 more details). If the host is unknown and a connection cannot be created due to enforcing
 this limit, then redirection will fail and the original redirection error will be passed
 downstream unchanged. This limit defaults to 100.
        .google.protobuf.UInt32Value max_upstream_unknown_connections = 6;

      • clearMaxUpstreamUnknownConnections

        public RedisProxy.ConnPoolSettings.Builder clearMaxUpstreamUnknownConnections()
         ``max_upstream_unknown_connections`` controls how many upstream connections to unknown hosts
 can be created at any given time by any given worker thread (see ``enable_redirection`` for
 more details). If the host is unknown and a connection cannot be created due to enforcing
 this limit, then redirection will fail and the original redirection error will be passed
 downstream unchanged. This limit defaults to 100.
        .google.protobuf.UInt32Value max_upstream_unknown_connections = 6;

      • getMaxUpstreamUnknownConnectionsBuilder

        public com.google.protobuf.UInt32Value.Builder getMaxUpstreamUnknownConnectionsBuilder()
         ``max_upstream_unknown_connections`` controls how many upstream connections to unknown hosts
 can be created at any given time by any given worker thread (see ``enable_redirection`` for
 more details). If the host is unknown and a connection cannot be created due to enforcing
 this limit, then redirection will fail and the original redirection error will be passed
 downstream unchanged. This limit defaults to 100.
        .google.protobuf.UInt32Value max_upstream_unknown_connections = 6;

      • getMaxUpstreamUnknownConnectionsOrBuilder

        public com.google.protobuf.UInt32ValueOrBuilder getMaxUpstreamUnknownConnectionsOrBuilder()
         ``max_upstream_unknown_connections`` controls how many upstream connections to unknown hosts
 can be created at any given time by any given worker thread (see ``enable_redirection`` for
 more details). If the host is unknown and a connection cannot be created due to enforcing
 this limit, then redirection will fail and the original redirection error will be passed
 downstream unchanged. This limit defaults to 100.
        .google.protobuf.UInt32Value max_upstream_unknown_connections = 6;
        Specified by:
        getMaxUpstreamUnknownConnectionsOrBuilder in interface RedisProxy.ConnPoolSettingsOrBuilder

      • getEnableCommandStats

        public boolean getEnableCommandStats()
         Enable per-command statistics per upstream cluster, in addition to the filter level aggregate
 count. These commands are measured in microseconds.
        bool enable_command_stats = 8;
        Specified by:
        getEnableCommandStats in interface RedisProxy.ConnPoolSettingsOrBuilder
        Returns:
        The enableCommandStats.

      • setEnableCommandStats

        public RedisProxy.ConnPoolSettings.Builder setEnableCommandStats​(boolean value)
         Enable per-command statistics per upstream cluster, in addition to the filter level aggregate
 count. These commands are measured in microseconds.
        bool enable_command_stats = 8;
        Parameters:
        value - The enableCommandStats to set.
        Returns:
        This builder for chaining.

      • clearEnableCommandStats

        public RedisProxy.ConnPoolSettings.Builder clearEnableCommandStats()
         Enable per-command statistics per upstream cluster, in addition to the filter level aggregate
 count. These commands are measured in microseconds.
        bool enable_command_stats = 8;
        Returns:
        This builder for chaining.

      • getReadPolicyValue

        public int getReadPolicyValue()
         Read policy. The default is to read from the primary.
        .envoy.extensions.filters.network.redis_proxy.v3.RedisProxy.ConnPoolSettings.ReadPolicy read_policy = 7 [(.validate.rules) = { ... }
        Specified by:
        getReadPolicyValue in interface RedisProxy.ConnPoolSettingsOrBuilder
        Returns:
        The enum numeric value on the wire for readPolicy.

      • setReadPolicyValue

        public RedisProxy.ConnPoolSettings.Builder setReadPolicyValue​(int value)
         Read policy. The default is to read from the primary.
        .envoy.extensions.filters.network.redis_proxy.v3.RedisProxy.ConnPoolSettings.ReadPolicy read_policy = 7 [(.validate.rules) = { ... }
        Parameters:
        value - The enum numeric value on the wire for readPolicy to set.
        Returns:
        This builder for chaining.

      • setReadPolicy

        public RedisProxy.ConnPoolSettings.Builder setReadPolicy​(RedisProxy.ConnPoolSettings.ReadPolicy value)
         Read policy. The default is to read from the primary.
        .envoy.extensions.filters.network.redis_proxy.v3.RedisProxy.ConnPoolSettings.ReadPolicy read_policy = 7 [(.validate.rules) = { ... }
        Parameters:
        value - The readPolicy to set.
        Returns:
        This builder for chaining.

      • clearReadPolicy

        public RedisProxy.ConnPoolSettings.Builder clearReadPolicy()
         Read policy. The default is to read from the primary.
        .envoy.extensions.filters.network.redis_proxy.v3.RedisProxy.ConnPoolSettings.ReadPolicy read_policy = 7 [(.validate.rules) = { ... }
        Returns:
        This builder for chaining.

      • mergeUnknownFields

        public final RedisProxy.ConnPoolSettings.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<RedisProxy.ConnPoolSettings.Builder>