Class Cluster.PreconnectPolicy

  • All Implemented Interfaces:
    com.google.protobuf.Message, com.google.protobuf.MessageLite, com.google.protobuf.MessageLiteOrBuilder, com.google.protobuf.MessageOrBuilder, Cluster.PreconnectPolicyOrBuilder, java.io.Serializable
    Enclosing class:
    Cluster

    public static final class Cluster.PreconnectPolicy
    extends com.google.protobuf.GeneratedMessage
    implements Cluster.PreconnectPolicyOrBuilder
    Protobuf type envoy.config.cluster.v3.Cluster.PreconnectPolicy
    See Also:
    Serialized Form
    • Nested Class Summary

      Nested Classes 
      Modifier and Type Class Description
      static class  Cluster.PreconnectPolicy.Builder
      Protobuf type envoy.config.cluster.v3.Cluster.PreconnectPolicy
      • Nested classes/interfaces inherited from class com.google.protobuf.GeneratedMessage

        com.google.protobuf.GeneratedMessage.ExtendableBuilder<MessageT extends com.google.protobuf.GeneratedMessage.ExtendableMessage<MessageT>,​BuilderT extends com.google.protobuf.GeneratedMessage.ExtendableBuilder<MessageT,​BuilderT>>, com.google.protobuf.GeneratedMessage.ExtendableMessage<MessageT extends com.google.protobuf.GeneratedMessage.ExtendableMessage<MessageT>>, com.google.protobuf.GeneratedMessage.ExtendableMessageOrBuilder<MessageT extends com.google.protobuf.GeneratedMessage.ExtendableMessage<MessageT>>, com.google.protobuf.GeneratedMessage.FieldAccessorTable, com.google.protobuf.GeneratedMessage.GeneratedExtension<ContainingT extends com.google.protobuf.Message,​T extends java.lang.Object>, com.google.protobuf.GeneratedMessage.UnusedPrivateParameter
      • Nested classes/interfaces inherited from class com.google.protobuf.AbstractMessage

        com.google.protobuf.AbstractMessage.BuilderParent
      • Nested classes/interfaces inherited from class com.google.protobuf.AbstractMessageLite

        com.google.protobuf.AbstractMessageLite.InternalOneOfEnum
    • Constructor Summary

      Constructors 
      Modifier Constructor Description
      private PreconnectPolicy()  
      private PreconnectPolicy​(com.google.protobuf.GeneratedMessage.Builder<?> builder)  
    • Field Detail

      • bitField0_

        private int bitField0_
      • PER_UPSTREAM_PRECONNECT_RATIO_FIELD_NUMBER

        public static final int PER_UPSTREAM_PRECONNECT_RATIO_FIELD_NUMBER
        See Also:
        Constant Field Values
      • perUpstreamPreconnectRatio_

        private com.google.protobuf.DoubleValue perUpstreamPreconnectRatio_
      • PREDICTIVE_PRECONNECT_RATIO_FIELD_NUMBER

        public static final int PREDICTIVE_PRECONNECT_RATIO_FIELD_NUMBER
        See Also:
        Constant Field Values
      • predictivePreconnectRatio_

        private com.google.protobuf.DoubleValue predictivePreconnectRatio_
      • memoizedIsInitialized

        private byte memoizedIsInitialized
    • Constructor Detail

      • PreconnectPolicy

        private PreconnectPolicy​(com.google.protobuf.GeneratedMessage.Builder<?> builder)
      • PreconnectPolicy

        private PreconnectPolicy()
    • 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
      • hasPerUpstreamPreconnectRatio

        public boolean hasPerUpstreamPreconnectRatio()
         Indicates how many streams (rounded up) can be anticipated per-upstream for each
         incoming stream. This is useful for high-QPS or latency-sensitive services. Preconnecting
         will only be done if the upstream is healthy and the cluster has traffic.
        
         For example if this is 2, for an incoming HTTP/1.1 stream, 2 connections will be
         established, one for the new incoming stream, and one for a presumed follow-up stream. For
         HTTP/2, only one connection would be established by default as one connection can
         serve both the original and presumed follow-up stream.
        
         In steady state for non-multiplexed connections a value of 1.5 would mean if there were 100
         active streams, there would be 100 connections in use, and 50 connections preconnected.
         This might be a useful value for something like short lived single-use connections,
         for example proxying HTTP/1.1 if keep-alive were false and each stream resulted in connection
         termination. It would likely be overkill for long lived connections, such as TCP proxying SMTP
         or regular HTTP/1.1 with keep-alive. For long lived traffic, a value of 1.05 would be more
         reasonable, where for every 100 connections, 5 preconnected connections would be in the queue
         in case of unexpected disconnects where the connection could not be reused.
        
         If this value is not set, or set explicitly to one, Envoy will fetch as many connections
         as needed to serve streams in flight. This means in steady state if a connection is torn down,
         a subsequent streams will pay an upstream-rtt latency penalty waiting for a new connection.
        
         This is limited somewhat arbitrarily to 3 because preconnecting too aggressively can
         harm latency more than the preconnecting helps.
         
        .google.protobuf.DoubleValue per_upstream_preconnect_ratio = 1 [(.validate.rules) = { ... }
        Specified by:
        hasPerUpstreamPreconnectRatio in interface Cluster.PreconnectPolicyOrBuilder
        Returns:
        Whether the perUpstreamPreconnectRatio field is set.
      • getPerUpstreamPreconnectRatio

        public com.google.protobuf.DoubleValue getPerUpstreamPreconnectRatio()
         Indicates how many streams (rounded up) can be anticipated per-upstream for each
         incoming stream. This is useful for high-QPS or latency-sensitive services. Preconnecting
         will only be done if the upstream is healthy and the cluster has traffic.
        
         For example if this is 2, for an incoming HTTP/1.1 stream, 2 connections will be
         established, one for the new incoming stream, and one for a presumed follow-up stream. For
         HTTP/2, only one connection would be established by default as one connection can
         serve both the original and presumed follow-up stream.
        
         In steady state for non-multiplexed connections a value of 1.5 would mean if there were 100
         active streams, there would be 100 connections in use, and 50 connections preconnected.
         This might be a useful value for something like short lived single-use connections,
         for example proxying HTTP/1.1 if keep-alive were false and each stream resulted in connection
         termination. It would likely be overkill for long lived connections, such as TCP proxying SMTP
         or regular HTTP/1.1 with keep-alive. For long lived traffic, a value of 1.05 would be more
         reasonable, where for every 100 connections, 5 preconnected connections would be in the queue
         in case of unexpected disconnects where the connection could not be reused.
        
         If this value is not set, or set explicitly to one, Envoy will fetch as many connections
         as needed to serve streams in flight. This means in steady state if a connection is torn down,
         a subsequent streams will pay an upstream-rtt latency penalty waiting for a new connection.
        
         This is limited somewhat arbitrarily to 3 because preconnecting too aggressively can
         harm latency more than the preconnecting helps.
         
        .google.protobuf.DoubleValue per_upstream_preconnect_ratio = 1 [(.validate.rules) = { ... }
        Specified by:
        getPerUpstreamPreconnectRatio in interface Cluster.PreconnectPolicyOrBuilder
        Returns:
        The perUpstreamPreconnectRatio.
      • getPerUpstreamPreconnectRatioOrBuilder

        public com.google.protobuf.DoubleValueOrBuilder getPerUpstreamPreconnectRatioOrBuilder()
         Indicates how many streams (rounded up) can be anticipated per-upstream for each
         incoming stream. This is useful for high-QPS or latency-sensitive services. Preconnecting
         will only be done if the upstream is healthy and the cluster has traffic.
        
         For example if this is 2, for an incoming HTTP/1.1 stream, 2 connections will be
         established, one for the new incoming stream, and one for a presumed follow-up stream. For
         HTTP/2, only one connection would be established by default as one connection can
         serve both the original and presumed follow-up stream.
        
         In steady state for non-multiplexed connections a value of 1.5 would mean if there were 100
         active streams, there would be 100 connections in use, and 50 connections preconnected.
         This might be a useful value for something like short lived single-use connections,
         for example proxying HTTP/1.1 if keep-alive were false and each stream resulted in connection
         termination. It would likely be overkill for long lived connections, such as TCP proxying SMTP
         or regular HTTP/1.1 with keep-alive. For long lived traffic, a value of 1.05 would be more
         reasonable, where for every 100 connections, 5 preconnected connections would be in the queue
         in case of unexpected disconnects where the connection could not be reused.
        
         If this value is not set, or set explicitly to one, Envoy will fetch as many connections
         as needed to serve streams in flight. This means in steady state if a connection is torn down,
         a subsequent streams will pay an upstream-rtt latency penalty waiting for a new connection.
        
         This is limited somewhat arbitrarily to 3 because preconnecting too aggressively can
         harm latency more than the preconnecting helps.
         
        .google.protobuf.DoubleValue per_upstream_preconnect_ratio = 1 [(.validate.rules) = { ... }
        Specified by:
        getPerUpstreamPreconnectRatioOrBuilder in interface Cluster.PreconnectPolicyOrBuilder
      • hasPredictivePreconnectRatio

        public boolean hasPredictivePreconnectRatio()
         Indicates how many streams (rounded up) can be anticipated across a cluster for each
         stream, useful for low QPS services. This is currently supported for a subset of
         deterministic non-hash-based load-balancing algorithms (weighted round robin, random).
         Unlike ``per_upstream_preconnect_ratio`` this preconnects across the upstream instances in a
         cluster, doing best effort predictions of what upstream would be picked next and
         pre-establishing a connection.
        
         Preconnecting will be limited to one preconnect per configured upstream in the cluster and will
         only be done if there are healthy upstreams and the cluster has traffic.
        
         For example if preconnecting is set to 2 for a round robin HTTP/2 cluster, on the first
         incoming stream, 2 connections will be preconnected - one to the first upstream for this
         cluster, one to the second on the assumption there will be a follow-up stream.
        
         If this value is not set, or set explicitly to one, Envoy will fetch as many connections
         as needed to serve streams in flight, so during warm up and in steady state if a connection
         is closed (and per_upstream_preconnect_ratio is not set), there will be a latency hit for
         connection establishment.
        
         If both this and preconnect_ratio are set, Envoy will make sure both predicted needs are met,
         basically preconnecting max(predictive-preconnect, per-upstream-preconnect), for each
         upstream.
         
        .google.protobuf.DoubleValue predictive_preconnect_ratio = 2 [(.validate.rules) = { ... }
        Specified by:
        hasPredictivePreconnectRatio in interface Cluster.PreconnectPolicyOrBuilder
        Returns:
        Whether the predictivePreconnectRatio field is set.
      • getPredictivePreconnectRatio

        public com.google.protobuf.DoubleValue getPredictivePreconnectRatio()
         Indicates how many streams (rounded up) can be anticipated across a cluster for each
         stream, useful for low QPS services. This is currently supported for a subset of
         deterministic non-hash-based load-balancing algorithms (weighted round robin, random).
         Unlike ``per_upstream_preconnect_ratio`` this preconnects across the upstream instances in a
         cluster, doing best effort predictions of what upstream would be picked next and
         pre-establishing a connection.
        
         Preconnecting will be limited to one preconnect per configured upstream in the cluster and will
         only be done if there are healthy upstreams and the cluster has traffic.
        
         For example if preconnecting is set to 2 for a round robin HTTP/2 cluster, on the first
         incoming stream, 2 connections will be preconnected - one to the first upstream for this
         cluster, one to the second on the assumption there will be a follow-up stream.
        
         If this value is not set, or set explicitly to one, Envoy will fetch as many connections
         as needed to serve streams in flight, so during warm up and in steady state if a connection
         is closed (and per_upstream_preconnect_ratio is not set), there will be a latency hit for
         connection establishment.
        
         If both this and preconnect_ratio are set, Envoy will make sure both predicted needs are met,
         basically preconnecting max(predictive-preconnect, per-upstream-preconnect), for each
         upstream.
         
        .google.protobuf.DoubleValue predictive_preconnect_ratio = 2 [(.validate.rules) = { ... }
        Specified by:
        getPredictivePreconnectRatio in interface Cluster.PreconnectPolicyOrBuilder
        Returns:
        The predictivePreconnectRatio.
      • getPredictivePreconnectRatioOrBuilder

        public com.google.protobuf.DoubleValueOrBuilder getPredictivePreconnectRatioOrBuilder()
         Indicates how many streams (rounded up) can be anticipated across a cluster for each
         stream, useful for low QPS services. This is currently supported for a subset of
         deterministic non-hash-based load-balancing algorithms (weighted round robin, random).
         Unlike ``per_upstream_preconnect_ratio`` this preconnects across the upstream instances in a
         cluster, doing best effort predictions of what upstream would be picked next and
         pre-establishing a connection.
        
         Preconnecting will be limited to one preconnect per configured upstream in the cluster and will
         only be done if there are healthy upstreams and the cluster has traffic.
        
         For example if preconnecting is set to 2 for a round robin HTTP/2 cluster, on the first
         incoming stream, 2 connections will be preconnected - one to the first upstream for this
         cluster, one to the second on the assumption there will be a follow-up stream.
        
         If this value is not set, or set explicitly to one, Envoy will fetch as many connections
         as needed to serve streams in flight, so during warm up and in steady state if a connection
         is closed (and per_upstream_preconnect_ratio is not set), there will be a latency hit for
         connection establishment.
        
         If both this and preconnect_ratio are set, Envoy will make sure both predicted needs are met,
         basically preconnecting max(predictive-preconnect, per-upstream-preconnect), for each
         upstream.
         
        .google.protobuf.DoubleValue predictive_preconnect_ratio = 2 [(.validate.rules) = { ... }
        Specified by:
        getPredictivePreconnectRatioOrBuilder in interface Cluster.PreconnectPolicyOrBuilder
      • isInitialized

        public final boolean isInitialized()
        Specified by:
        isInitialized in interface com.google.protobuf.MessageLiteOrBuilder
        Overrides:
        isInitialized in class com.google.protobuf.GeneratedMessage
      • writeTo

        public void writeTo​(com.google.protobuf.CodedOutputStream output)
                     throws java.io.IOException
        Specified by:
        writeTo in interface com.google.protobuf.MessageLite
        Overrides:
        writeTo in class com.google.protobuf.GeneratedMessage
        Throws:
        java.io.IOException
      • getSerializedSize

        public int getSerializedSize()
        Specified by:
        getSerializedSize in interface com.google.protobuf.MessageLite
        Overrides:
        getSerializedSize in class com.google.protobuf.GeneratedMessage
      • equals

        public boolean equals​(java.lang.Object obj)
        Specified by:
        equals in interface com.google.protobuf.Message
        Overrides:
        equals in class com.google.protobuf.AbstractMessage
      • hashCode

        public int hashCode()
        Specified by:
        hashCode in interface com.google.protobuf.Message
        Overrides:
        hashCode in class com.google.protobuf.AbstractMessage
      • parseFrom

        public static Cluster.PreconnectPolicy parseFrom​(java.nio.ByteBuffer data)
                                                  throws com.google.protobuf.InvalidProtocolBufferException
        Throws:
        com.google.protobuf.InvalidProtocolBufferException
      • parseFrom

        public static Cluster.PreconnectPolicy parseFrom​(java.nio.ByteBuffer data,
                                                         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
                                                  throws com.google.protobuf.InvalidProtocolBufferException
        Throws:
        com.google.protobuf.InvalidProtocolBufferException
      • parseFrom

        public static Cluster.PreconnectPolicy parseFrom​(com.google.protobuf.ByteString data)
                                                  throws com.google.protobuf.InvalidProtocolBufferException
        Throws:
        com.google.protobuf.InvalidProtocolBufferException
      • parseFrom

        public static Cluster.PreconnectPolicy parseFrom​(com.google.protobuf.ByteString data,
                                                         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
                                                  throws com.google.protobuf.InvalidProtocolBufferException
        Throws:
        com.google.protobuf.InvalidProtocolBufferException
      • parseFrom

        public static Cluster.PreconnectPolicy parseFrom​(byte[] data)
                                                  throws com.google.protobuf.InvalidProtocolBufferException
        Throws:
        com.google.protobuf.InvalidProtocolBufferException
      • parseFrom

        public static Cluster.PreconnectPolicy parseFrom​(byte[] data,
                                                         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
                                                  throws com.google.protobuf.InvalidProtocolBufferException
        Throws:
        com.google.protobuf.InvalidProtocolBufferException
      • parseFrom

        public static Cluster.PreconnectPolicy parseFrom​(java.io.InputStream input)
                                                  throws java.io.IOException
        Throws:
        java.io.IOException
      • parseFrom

        public static Cluster.PreconnectPolicy parseFrom​(java.io.InputStream input,
                                                         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
                                                  throws java.io.IOException
        Throws:
        java.io.IOException
      • parseDelimitedFrom

        public static Cluster.PreconnectPolicy parseDelimitedFrom​(java.io.InputStream input)
                                                           throws java.io.IOException
        Throws:
        java.io.IOException
      • parseDelimitedFrom

        public static Cluster.PreconnectPolicy parseDelimitedFrom​(java.io.InputStream input,
                                                                  com.google.protobuf.ExtensionRegistryLite extensionRegistry)
                                                           throws java.io.IOException
        Throws:
        java.io.IOException
      • parseFrom

        public static Cluster.PreconnectPolicy parseFrom​(com.google.protobuf.CodedInputStream input)
                                                  throws java.io.IOException
        Throws:
        java.io.IOException
      • parseFrom

        public static Cluster.PreconnectPolicy parseFrom​(com.google.protobuf.CodedInputStream input,
                                                         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
                                                  throws java.io.IOException
        Throws:
        java.io.IOException
      • newBuilderForType

        public Cluster.PreconnectPolicy.Builder newBuilderForType()
        Specified by:
        newBuilderForType in interface com.google.protobuf.Message
        Specified by:
        newBuilderForType in interface com.google.protobuf.MessageLite
      • toBuilder

        public Cluster.PreconnectPolicy.Builder toBuilder()
        Specified by:
        toBuilder in interface com.google.protobuf.Message
        Specified by:
        toBuilder in interface com.google.protobuf.MessageLite
      • newBuilderForType

        protected Cluster.PreconnectPolicy.Builder newBuilderForType​(com.google.protobuf.AbstractMessage.BuilderParent parent)
        Overrides:
        newBuilderForType in class com.google.protobuf.AbstractMessage
      • getParserForType

        public com.google.protobuf.Parser<Cluster.PreconnectPolicy> getParserForType()
        Specified by:
        getParserForType in interface com.google.protobuf.Message
        Specified by:
        getParserForType in interface com.google.protobuf.MessageLite
        Overrides:
        getParserForType in class com.google.protobuf.GeneratedMessage
      • getDefaultInstanceForType

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