You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@geode.apache.org by bs...@apache.org on 2018/02/06 19:40:48 UTC

[geode] branch develop updated: GEODE-3948 Improve CQ performance under flaky network conditions

This is an automated email from the ASF dual-hosted git repository.

bschuchardt pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/geode.git


The following commit(s) were added to refs/heads/develop by this push:
     new 906ed2a  GEODE-3948 Improve CQ performance under flaky network conditions
906ed2a is described below

commit 906ed2ae369f130f0d6186d636daa5eba0188f43
Author: Bruce Schuchardt <bs...@pivotal.io>
AuthorDate: Tue Feb 6 11:31:53 2018 -0800

    GEODE-3948 Improve CQ performance under flaky network conditions
    
    This adds a new PoolFactory setting allowing subscription connections to
    time out and initiate failover to a backup server. The new setting is
    setSubscriptionTimeoutMultiplier:
    
    A server has an inactivity monitor that ensures a message is sent to a client at least once a
    minute (60,000 milliseconds). If a subscription timeout multipler is set in the client it
    enables timing out of the subscription feed with failover to another server.
    
    A value of zero (the default) disables timeouts
    
    A value of one will time out the server connection after one of its ping intervals (not
    recommended)
    
    A value of two or more will time out the server connection after that many ping intervals have
    elapsed
    
    The client/server handshake is modified for clients having version 1.5 or
    later. The server sends its ping-interval setting to the client. The client
    then uses this and the multiplier to establish a read-timeout in the
    CacheClientUpdater subscription processor.
    
    Two tests are added to ensure that 1) the Message method that allows a
    read to timeout functions correctly and 2) the CacheClientUpdater
    correctly receives the multiplier setting.
    
    This closes #1364
---
 .../java/org/apache/geode/cache/client/Pool.java   |  10 ++
 .../org/apache/geode/cache/client/PoolFactory.java |  20 ++++
 .../geode/cache/client/internal/AbstractOp.java    |   2 +-
 .../cache/client/internal/AuthenticateUserOp.java  |   2 +-
 .../client/internal/ClientSideHandshakeImpl.java   |  32 +++--
 .../geode/cache/client/internal/PoolImpl.java      |  10 ++
 .../apache/geode/cache/client/internal/PutOp.java  |   2 +-
 .../internal/pooling/ConnectionManagerImpl.java    |   1 -
 .../java/org/apache/geode/internal/Version.java    |   8 +-
 .../geode/internal/cache/PoolFactoryImpl.java      |  36 +++++-
 .../apache/geode/internal/cache/properties.html    |   4 +-
 .../internal/cache/tier/ServerSideHandshake.java   |   5 +-
 .../internal/cache/tier/sockets/AcceptorImpl.java  |   5 +-
 .../internal/cache/tier/sockets/BaseCommand.java   |   2 +-
 .../cache/tier/sockets/CacheClientNotifier.java    |  23 ++--
 .../cache/tier/sockets/CacheClientUpdater.java     |  29 +++--
 .../cache/tier/sockets/CommandInitializer.java     |   5 +
 .../geode/internal/cache/tier/sockets/Message.java | 130 ++++++++++++---------
 .../tier/sockets/OriginalServerConnection.java     |   4 +-
 .../tier/sockets/ServerHandshakeProcessor.java     |   2 +
 .../cache/tier/sockets/ServerQueueStatus.java      |  32 +++--
 .../tier/sockets/ServerSideHandshakeImpl.java      |   5 +-
 .../AutoConnectionSourceImplJUnitTest.java         |   5 +
 .../client/internal/QueueManagerJUnitTest.java     |  43 ++++++-
 .../tier/sockets/ClientServerMiscDUnitTest.java    |  55 +++++++++
 .../cache/tier/sockets/MessageJUnitTest.java       |  58 +++++++++
 .../cache/tier/sockets/ServerConnectionTest.java   |   2 +-
 .../tier/sockets/ClientServerMiscBCDUnitTest.java  |  10 ++
 .../client/internal/GatewaySenderBatchOp.java      |   3 +-
 29 files changed, 422 insertions(+), 123 deletions(-)

diff --git a/geode-core/src/main/java/org/apache/geode/cache/client/Pool.java b/geode-core/src/main/java/org/apache/geode/cache/client/Pool.java
index 4b98329..7f85101 100644
--- a/geode-core/src/main/java/org/apache/geode/cache/client/Pool.java
+++ b/geode-core/src/main/java/org/apache/geode/cache/client/Pool.java
@@ -291,4 +291,14 @@ public interface Pool {
    */
   int getPendingEventCount();
 
+  /**
+   * A server has an inactivity monitor that ensures a message is sent to a client at least once a
+   * minute (60,000 milliseconds). If a subscription timeout multipler is set in the client it
+   * enables timing out of the subscription feed with failover to another server.
+   *
+   * @see PoolFactory#setSubscriptionTimeoutMultiplier(int)
+   *
+   * @return The timeout multiplier
+   */
+  int getSubscriptionTimeoutMultiplier();
 }
diff --git a/geode-core/src/main/java/org/apache/geode/cache/client/PoolFactory.java b/geode-core/src/main/java/org/apache/geode/cache/client/PoolFactory.java
index 40a9ccd..92ff133 100644
--- a/geode-core/src/main/java/org/apache/geode/cache/client/PoolFactory.java
+++ b/geode-core/src/main/java/org/apache/geode/cache/client/PoolFactory.java
@@ -175,6 +175,14 @@ public interface PoolFactory {
   int DEFAULT_SUBSCRIPTION_ACK_INTERVAL = 100;
 
   /**
+   * The default number of server "ping" intervals that can elapse with no activity before a
+   * subscription connection is deemed dead and failover is initiated.
+   * <p>
+   * Current value: 0
+   */
+  public static final int DEFAULT_SUBSCRIPTION_TIMEOUT_MULTIPLIER = 0;
+
+  /**
    * The default server group.
    * <p>
    * Current value: <code>""</code>.
@@ -428,6 +436,18 @@ public interface PoolFactory {
   PoolFactory setSubscriptionMessageTrackingTimeout(int messageTrackingTimeout);
 
   /**
+   * A server has an inactivity monitor that ensures a message is sent to a client at least once a
+   * minute (60,000 milliseconds). If a subscription timeout multipler is set in the client it
+   * enables timing out of the subscription feed with failover to another server.
+   * <p>
+   * A value of zero (the default) disables timeouts
+   * <p>
+   * The resulting timeout will be multiplied by 1.25 in order to avoid race conditions with the
+   * server sending its "ping" message.
+   */
+  public PoolFactory setSubscriptionTimeoutMultiplier(int multiplier);
+
+  /**
    * Sets the interval in milliseconds to wait before sending acknowledgements to the cache server
    * for events received from the server subscriptions.
    *
diff --git a/geode-core/src/main/java/org/apache/geode/cache/client/internal/AbstractOp.java b/geode-core/src/main/java/org/apache/geode/cache/client/internal/AbstractOp.java
index 898eb1f..7048f54 100644
--- a/geode-core/src/main/java/org/apache/geode/cache/client/internal/AbstractOp.java
+++ b/geode-core/src/main/java/org/apache/geode/cache/client/internal/AbstractOp.java
@@ -204,7 +204,7 @@ public abstract class AbstractOp implements Op {
         }
       } else {
         try {
-          msg.recv();
+          msg.receive();
         } finally {
           msg.unsetComms();
           processSecureBytes(cnx, msg);
diff --git a/geode-core/src/main/java/org/apache/geode/cache/client/internal/AuthenticateUserOp.java b/geode-core/src/main/java/org/apache/geode/cache/client/internal/AuthenticateUserOp.java
index 7f3a778..b10d333 100644
--- a/geode-core/src/main/java/org/apache/geode/cache/client/internal/AuthenticateUserOp.java
+++ b/geode-core/src/main/java/org/apache/geode/cache/client/internal/AuthenticateUserOp.java
@@ -194,7 +194,7 @@ public class AuthenticateUserOp {
           }
         } else {
           try {
-            msg.recv();
+            msg.receive();
           } finally {
             msg.unsetComms();
             processSecureBytes(cnx, msg);
diff --git a/geode-core/src/main/java/org/apache/geode/cache/client/internal/ClientSideHandshakeImpl.java b/geode-core/src/main/java/org/apache/geode/cache/client/internal/ClientSideHandshakeImpl.java
index ee6c697..2afb53e 100644
--- a/geode-core/src/main/java/org/apache/geode/cache/client/internal/ClientSideHandshakeImpl.java
+++ b/geode-core/src/main/java/org/apache/geode/cache/client/internal/ClientSideHandshakeImpl.java
@@ -34,6 +34,8 @@ import java.util.Properties;
 
 import javax.net.ssl.SSLSocket;
 
+import org.apache.logging.log4j.Logger;
+
 import org.apache.geode.CancelCriterion;
 import org.apache.geode.DataSerializer;
 import org.apache.geode.GemFireConfigException;
@@ -61,12 +63,15 @@ import org.apache.geode.internal.cache.tier.sockets.EncryptorImpl;
 import org.apache.geode.internal.cache.tier.sockets.Handshake;
 import org.apache.geode.internal.cache.tier.sockets.ServerQueueStatus;
 import org.apache.geode.internal.i18n.LocalizedStrings;
+import org.apache.geode.internal.logging.LogService;
 import org.apache.geode.internal.security.SecurityService;
 import org.apache.geode.security.AuthenticationFailedException;
 import org.apache.geode.security.AuthenticationRequiredException;
 import org.apache.geode.security.GemFireSecurityException;
 
 public class ClientSideHandshakeImpl extends Handshake implements ClientSideHandshake {
+  private static final Logger logger = LogService.getLogger();
+
   /**
    * Used at client side, indicates whether the 'delta-propagation' property is enabled on the DS
    * this client is connected to. This variable is used to decide whether to send delta bytes or
@@ -155,7 +160,7 @@ public class ClientSideHandshakeImpl extends Handshake implements ClientSideHand
    * @param sock the socket this handshake is operating on
    * @return temporary id to reprent the other vm
    */
-  private DistributedMember getIDForSocket(Socket sock) {
+  private InternalDistributedMember getIDForSocket(Socket sock) {
     return new InternalDistributedMember(sock.getInetAddress(), sock.getPort(), false);
   }
 
@@ -172,7 +177,7 @@ public class ClientSideHandshakeImpl extends Handshake implements ClientSideHand
       DataOutputStream dos = new DataOutputStream(sock.getOutputStream());
       final InputStream in = sock.getInputStream();
       DataInputStream dis = new DataInputStream(in);
-      DistributedMember member = getIDForSocket(sock);
+      InternalDistributedMember member = getIDForSocket(sock);
       // if running in a loner system, use the new port number in the ID to
       // help differentiate from other clients
       DistributionManager dm = ((InternalDistributedSystem) this.system).getDistributionManager();
@@ -225,6 +230,7 @@ public class ClientSideHandshakeImpl extends Handshake implements ClientSideHand
       int queueSize = dis.readInt();
 
       member = readServerMember(dis);
+
       serverQStatus = new ServerQueueStatus(endpointType, queueSize, member);
 
       // Read the message (if any)
@@ -265,7 +271,7 @@ public class ClientSideHandshakeImpl extends Handshake implements ClientSideHand
     }
   }
 
-  private DistributedMember readServerMember(DataInputStream p_dis) throws IOException {
+  private InternalDistributedMember readServerMember(DataInputStream p_dis) throws IOException {
 
     byte[] memberBytes = DataSerializer.readByteArray(p_dis);
     ByteArrayInputStream bais = new ByteArrayInputStream(memberBytes);
@@ -293,7 +299,7 @@ public class ClientSideHandshakeImpl extends Handshake implements ClientSideHand
   public ServerQueueStatus handshakeWithSubscriptionFeed(Socket sock, boolean isPrimary)
       throws IOException, AuthenticationRequiredException, AuthenticationFailedException,
       ServerRefusedConnectionException, ClassNotFoundException {
-    ServerQueueStatus sqs = null;
+    ServerQueueStatus serverQueueStatus = null;
     try {
       DataOutputStream dos = new DataOutputStream(sock.getOutputStream());
       final InputStream in = sock.getInputStream();
@@ -316,12 +322,8 @@ public class ClientSideHandshakeImpl extends Handshake implements ClientSideHand
             LocalizedStrings.HandShake_SERVER_EXPECTING_SSL_CONNECTION.toLocalizedString());
       }
 
-      // No need to check for return value since DataInputStream already throws
-      // EOFException in case of EOF
-      byte qType = dis.readByte();
-      // read and ignore qSize flag
-      int qSize = dis.readInt();
-      sqs = new ServerQueueStatus(qType, qSize, member);
+      byte endpointType = dis.readByte();
+      int queueSize = dis.readInt();
 
       // Read the message (if any)
       readMessage(dis, dos, acceptanceCode, member);
@@ -330,7 +332,7 @@ public class ClientSideHandshakeImpl extends Handshake implements ClientSideHand
       // there is a difference in serializer map registration for >= 6.5.1.6
       // clients but that is not used in tests
       if (currentClientVersion.compareTo(Version.GFE_61) < 0) {
-        return sqs;
+        return new ServerQueueStatus(endpointType, queueSize, member);
       }
       HashMap instantiatorMap = DataSerializer.readHashMap(dis);
       for (Iterator itr = instantiatorMap.entrySet().iterator(); itr.hasNext();) {
@@ -349,6 +351,12 @@ public class ClientSideHandshakeImpl extends Handshake implements ClientSideHand
       }
       HashMap<Integer, ArrayList<String>> dsToSupportedClassNames = DataSerializer.readHashMap(dis);
       InternalDataSerializer.updateSupportedClassesMap(dsToSupportedClassNames);
+
+      // the server's ping interval is only sent to subscription feeds so we can't read it as
+      // part of a "standard" server response along with the other status data.
+      int pingInterval = dis.readInt();
+      serverQueueStatus = new ServerQueueStatus(endpointType, queueSize, member, pingInterval);
+
     } catch (IOException ex) {
       CancelCriterion stopper = this.system.getCancelCriterion();
       stopper.checkCancelInProgress(null);
@@ -358,7 +366,7 @@ public class ClientSideHandshakeImpl extends Handshake implements ClientSideHand
       stopper.checkCancelInProgress(null);
       throw ex;
     }
-    return sqs;
+    return serverQueueStatus;
   }
 
   /**
diff --git a/geode-core/src/main/java/org/apache/geode/cache/client/internal/PoolImpl.java b/geode-core/src/main/java/org/apache/geode/cache/client/internal/PoolImpl.java
index ec2c091..6edd7b4 100644
--- a/geode-core/src/main/java/org/apache/geode/cache/client/internal/PoolImpl.java
+++ b/geode-core/src/main/java/org/apache/geode/cache/client/internal/PoolImpl.java
@@ -107,6 +107,7 @@ public class PoolImpl implements InternalPool {
   private final int subscriptionRedundancyLevel;
   private final int subscriptionMessageTrackingTimeout;
   private final int subscriptionAckInterval;
+  private final int subscriptionTimeoutMultiplier;
   private final String serverGroup;
   private final List<HostAddress> locatorAddresses;
   private final List<InetSocketAddress> locators;
@@ -201,6 +202,10 @@ public class PoolImpl implements InternalPool {
     this.subscriptionRedundancyLevel = attributes.getSubscriptionRedundancy();
     this.subscriptionMessageTrackingTimeout = attributes.getSubscriptionMessageTrackingTimeout();
     this.subscriptionAckInterval = attributes.getSubscriptionAckInterval();
+    this.subscriptionTimeoutMultiplier = attributes.getSubscriptionTimeoutMultiplier();
+    if (this.subscriptionTimeoutMultiplier < 0) {
+      throw new IllegalArgumentException("The subscription timeout multipler must not be negative");
+    }
     this.serverGroup = attributes.getServerGroup();
     this.multiuserSecureModeEnabled = attributes.getMultiuserAuthentication();
     this.locatorAddresses = locAddresses;
@@ -1608,4 +1613,9 @@ public class PoolImpl implements InternalPool {
     }
     return this.primaryQueueSize.get();
   }
+
+  @Override
+  public int getSubscriptionTimeoutMultiplier() {
+    return subscriptionTimeoutMultiplier;
+  }
 }
diff --git a/geode-core/src/main/java/org/apache/geode/cache/client/internal/PutOp.java b/geode-core/src/main/java/org/apache/geode/cache/client/internal/PutOp.java
index 60888ce..e98d997 100644
--- a/geode-core/src/main/java/org/apache/geode/cache/client/internal/PutOp.java
+++ b/geode-core/src/main/java/org/apache/geode/cache/client/internal/PutOp.java
@@ -466,7 +466,7 @@ public class PutOp {
           }
         } else {
           try {
-            msg.recv();
+            msg.receive();
           } finally {
             msg.unsetComms();
             processSecureBytes(cnx, msg);
diff --git a/geode-core/src/main/java/org/apache/geode/cache/client/internal/pooling/ConnectionManagerImpl.java b/geode-core/src/main/java/org/apache/geode/cache/client/internal/pooling/ConnectionManagerImpl.java
index 687470b..c75d545 100644
--- a/geode-core/src/main/java/org/apache/geode/cache/client/internal/pooling/ConnectionManagerImpl.java
+++ b/geode-core/src/main/java/org/apache/geode/cache/client/internal/pooling/ConnectionManagerImpl.java
@@ -174,7 +174,6 @@ public class ConnectionManagerImpl implements ConnectionManager {
     this.idleTimeoutNanos = this.idleTimeout * NANOS_PER_MS;
     this.securityLogWriter = securityLogger;
     this.prefillRetry = pingInterval;
-    // this.pingInterval = pingInterval;
     this.cancelCriterion = cancelCriterion;
     this.endpointListener = new EndpointManager.EndpointListenerAdapter() {
       @Override
diff --git a/geode-core/src/main/java/org/apache/geode/internal/Version.java b/geode-core/src/main/java/org/apache/geode/internal/Version.java
index 6ae5ac2..cf5bb5d 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/Version.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/Version.java
@@ -59,7 +59,7 @@ public class Version implements Comparable<Version> {
   /** byte used as ordinal to represent this <code>Version</code> */
   private final short ordinal;
 
-  public static final int HIGHEST_VERSION = 75;
+  public static final int HIGHEST_VERSION = 80;
 
   private static final Version[] VALUES = new Version[HIGHEST_VERSION + 1];
 
@@ -208,11 +208,15 @@ public class Version implements Comparable<Version> {
   public static final Version GEODE_140 =
       new Version("GEODE", "1.4.0", (byte) 1, (byte) 4, (byte) 0, (byte) 0, GEODE_140_ORDINAL);
 
+  private static final byte GEODE_150_ORDINAL = 80;
+
+  public static final Version GEODE_150 =
+      new Version("GEODE", "1.5.0", (byte) 1, (byte) 5, (byte) 0, (byte) 0, GEODE_150_ORDINAL);
   /**
    * This constant must be set to the most current version of the product. !!! NOTE: update
    * HIGHEST_VERSION when changing CURRENT !!!
    */
-  public static final Version CURRENT = GEODE_140;
+  public static final Version CURRENT = GEODE_150;
 
   /**
    * A lot of versioning code needs access to the current version's ordinal
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/PoolFactoryImpl.java b/geode-core/src/main/java/org/apache/geode/internal/cache/PoolFactoryImpl.java
index f63784f..06f447f 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/PoolFactoryImpl.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/PoolFactoryImpl.java
@@ -221,6 +221,12 @@ public class PoolFactoryImpl implements PoolFactory {
     return this;
   }
 
+  @Override
+  public PoolFactory setSubscriptionTimeoutMultiplier(int multiplier) {
+    this.attributes.subscriptionTimeoutMultipler = multiplier;
+    return this;
+  }
+
   private InetSocketAddress getInetSocketAddress(String host, int port) {
     if (port == 0) {
       throw new IllegalArgumentException("port must be greater than 0 but was " + port);
@@ -372,6 +378,7 @@ public class PoolFactoryImpl implements PoolFactory {
     public int queueRedundancyLevel = DEFAULT_SUBSCRIPTION_REDUNDANCY;
     public int queueMessageTrackingTimeout = DEFAULT_SUBSCRIPTION_MESSAGE_TRACKING_TIMEOUT;
     public int queueAckInterval = DEFAULT_SUBSCRIPTION_ACK_INTERVAL;
+    public int subscriptionTimeoutMultipler = DEFAULT_SUBSCRIPTION_TIMEOUT_MULTIPLIER;
     public String serverGroup = DEFAULT_SERVER_GROUP;
     public boolean multiuserSecureModeEnabled = DEFAULT_MULTIUSER_AUTHENTICATION;
     public ArrayList/* <InetSocketAddress> */ locators = new ArrayList();
@@ -384,74 +391,92 @@ public class PoolFactoryImpl implements PoolFactory {
      */
     public boolean gateway = false;
 
+    @Override
     public int getSocketConnectTimeout() {
       return this.socketConnectTimeout;
     }
 
+    @Override
     public int getFreeConnectionTimeout() {
       return this.connectionTimeout;
     }
 
+    @Override
     public int getLoadConditioningInterval() {
       return this.connectionLifetime;
     }
 
+    @Override
     public int getSocketBufferSize() {
       return this.socketBufferSize;
     }
 
+    @Override
     public int getMinConnections() {
       return minConnections;
     }
 
+    @Override
     public int getMaxConnections() {
       return maxConnections;
     }
 
+    @Override
     public long getIdleTimeout() {
       return idleTimeout;
     }
 
+    @Override
     public int getRetryAttempts() {
       return retryAttempts;
     }
 
+    @Override
     public long getPingInterval() {
       return pingInterval;
     }
 
+    @Override
     public int getStatisticInterval() {
       return statisticInterval;
     }
 
+    @Override
     public boolean getThreadLocalConnections() {
       return this.threadLocalConnections;
     }
 
+    @Override
     public int getReadTimeout() {
       return this.readTimeout;
     }
 
+    @Override
     public boolean getSubscriptionEnabled() {
       return this.queueEnabled;
     }
 
+    @Override
     public boolean getPRSingleHopEnabled() {
       return this.prSingleHopEnabled;
     }
 
+    @Override
     public int getSubscriptionRedundancy() {
       return this.queueRedundancyLevel;
     }
 
+    @Override
     public int getSubscriptionMessageTrackingTimeout() {
       return this.queueMessageTrackingTimeout;
     }
 
+    @Override
     public int getSubscriptionAckInterval() {
       return queueAckInterval;
     }
 
+    @Override
     public String getServerGroup() {
       return this.serverGroup;
     }
@@ -472,6 +497,7 @@ public class PoolFactoryImpl implements PoolFactory {
       return this.gatewaySender;
     }
 
+    @Override
     public boolean getMultiuserAuthentication() {
       return this.multiuserSecureModeEnabled;
     }
@@ -480,6 +506,11 @@ public class PoolFactoryImpl implements PoolFactory {
       this.multiuserSecureModeEnabled = v;
     }
 
+    @Override
+    public int getSubscriptionTimeoutMultiplier() {
+      return this.subscriptionTimeoutMultipler;
+    }
+
     public List/* <InetSocketAddress> */ getLocators() {
       if (this.locators.size() == 0 && this.servers.size() == 0) {
         throw new IllegalStateException(
@@ -531,10 +562,8 @@ public class PoolFactoryImpl implements PoolFactory {
       throw new UnsupportedOperationException();
     }
 
-    public RegionService createAuthenticatedCacheView(Properties properties) {
-      throw new UnsupportedOperationException();
-    }
 
+    @Override
     public void toData(DataOutput out) throws IOException {
       DataSerializer.writePrimitiveInt(this.connectionTimeout, out);
       DataSerializer.writePrimitiveInt(this.connectionLifetime, out);
@@ -557,6 +586,7 @@ public class PoolFactoryImpl implements PoolFactory {
       DataSerializer.writePrimitiveInt(this.socketConnectTimeout, out);
     }
 
+    @Override
     public void fromData(DataInput in) throws IOException, ClassNotFoundException {
       this.connectionTimeout = DataSerializer.readPrimitiveInt(in);
       this.connectionLifetime = DataSerializer.readPrimitiveInt(in);
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/properties.html b/geode-core/src/main/java/org/apache/geode/internal/cache/properties.html
index baa9784..dea752a 100755
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/properties.html
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/properties.html
@@ -271,7 +271,7 @@ This is the TCP accept backlog for the acceptor thread's listening socket.
 </dd>
 
 <!-- -------------------------------------------------------  -->
-<dt><strong>BridgeServer.handshakeTimeout</strong></dt>
+<dt><strong>BridgeServer.handShakeTimeout</strong></dt>
 <dd>
 <em>Public:</em> false
 <p>
@@ -280,7 +280,7 @@ This is the TCP accept backlog for the acceptor thread's listening socket.
 See <code>org.apache.geode.internal.cache.tier.sockets.AcceptorImpl#handshakeTimeout</code>.
 <p>
 <pre>
-  Test value for handshake timeout
+  Test value for handshake timeout.  Note the capital S in "handShakeTimeout".
 </pre>
 <p>
 Units are in milliseconds.
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/ServerSideHandshake.java b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/ServerSideHandshake.java
index a9b12bc..6ab0ffe 100755
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/ServerSideHandshake.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/ServerSideHandshake.java
@@ -42,9 +42,8 @@ public interface ServerSideHandshake {
 
   void setClientReadTimeout(int clientReadTimeout);
 
-  void accept(OutputStream out, InputStream in, byte endpointType, int queueSize,
-      CommunicationMode communicationMode, Principal principal) throws IOException;
-
   Encryptor getEncryptor();
 
+  public void handshakeWithClient(OutputStream out, InputStream in, byte endpointType,
+      int queueSize, CommunicationMode communicationMode, Principal principal) throws IOException;
 }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/AcceptorImpl.java b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/AcceptorImpl.java
index 5aff86c..0b61d18 100755
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/AcceptorImpl.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/AcceptorImpl.java
@@ -72,6 +72,7 @@ import org.apache.geode.distributed.internal.LonerDistributionManager;
 import org.apache.geode.distributed.internal.PooledExecutorWithDMStats;
 import org.apache.geode.distributed.internal.ReplyProcessor21;
 import org.apache.geode.internal.SystemTimer;
+import org.apache.geode.internal.Version;
 import org.apache.geode.internal.cache.BucketAdvisor;
 import org.apache.geode.internal.cache.BucketAdvisor.BucketProfile;
 import org.apache.geode.internal.cache.InternalCache;
@@ -176,7 +177,7 @@ public class AcceptorImpl implements Acceptor, Runnable, CommBufferPool {
    * The name of a system property that sets the hand shake timeout (in milliseconds). This is how
    * long a client will wait to hear back from a server.
    */
-  public static final String HANDSHAKE_TIMEOUT_PROPERTY_NAME = "BridgeServer.handshakeTimeout";
+  public static final String HANDSHAKE_TIMEOUT_PROPERTY_NAME = "BridgeServer.handShakeTimeout";
 
   /**
    * The default value of the {@link #HANDSHAKE_TIMEOUT_PROPERTY_NAME} system property.
@@ -1831,7 +1832,7 @@ public class AcceptorImpl implements Acceptor, Runnable, CommBufferPool {
 
     @Override
     public void run() {
-      logger.info(":Bridge server: Initializing {} server-to-client communication socket: {}",
+      logger.info(":Cache server: Initializing {} server-to-client communication socket: {}",
           isPrimaryServerToClient ? "primary" : "secondary", socket);
       try {
         acceptor.getCacheClientNotifier().registerClient(socket, isPrimaryServerToClient,
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/BaseCommand.java b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/BaseCommand.java
index d2eb7b5..36e0876 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/BaseCommand.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/BaseCommand.java
@@ -848,7 +848,7 @@ public abstract class BaseCommand implements Command {
     Message requestMsg = null;
     try {
       requestMsg = servConn.getRequestMessage();
-      requestMsg.recv(servConn, MAX_INCOMING_DATA, INCOMING_DATA_LIMITER, INCOMING_MSG_LIMITER);
+      requestMsg.receive(servConn, MAX_INCOMING_DATA, INCOMING_DATA_LIMITER, INCOMING_MSG_LIMITER);
       return requestMsg;
     } catch (EOFException eof) {
       handleEOFException(null, servConn, eof);
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/CacheClientNotifier.java b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/CacheClientNotifier.java
index 0eadde9..6c993bd 100755
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/CacheClientNotifier.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/CacheClientNotifier.java
@@ -160,11 +160,11 @@ public class CacheClientNotifier {
    */
   private void writeMessage(DataOutputStream dos, byte type, String p_msg, Version clientVersion)
       throws IOException {
-    writeMessage(dos, type, p_msg, clientVersion, (byte) 0x00, 0);
+    writeHandshakeMessage(dos, type, p_msg, clientVersion, (byte) 0x00, 0);
   }
 
-  private void writeMessage(DataOutputStream dos, byte type, String p_msg, Version clientVersion,
-      byte endpointType, int queueSize) throws IOException {
+  private void writeHandshakeMessage(DataOutputStream dos, byte type, String p_msg,
+      Version clientVersion, byte endpointType, int queueSize) throws IOException {
     String msg = p_msg;
 
     // write the message type
@@ -213,6 +213,9 @@ public class CacheClientNotifier {
       if (clientVersion.compareTo(Version.GFE_6516) >= 0) {
         DataSerializer.writeHashMap(dsToSupportedClasses, dos);
       }
+      if (clientVersion.compareTo(Version.GEODE_150) >= 0) {
+        dos.writeInt(CLIENT_PING_TASK_PERIOD);
+      }
     }
     dos.flush();
   }
@@ -294,7 +297,7 @@ public class CacheClientNotifier {
     ClientProxyMembershipID proxyID = null;
     CacheClientProxy proxy;
     AccessControl authzCallback = null;
-    byte clientConflation = Handshake.CONFLATION_DEFAULT;
+    byte clientConflation;
     try {
       proxyID = ClientProxyMembershipID.readCanonicalized(dis);
       if (getBlacklistedClient().contains(proxyID)) {
@@ -564,7 +567,8 @@ public class CacheClientNotifier {
       DataOutputStream dos =
           new DataOutputStream(new BufferedOutputStream(socket.getOutputStream()));
       // write the message type, message length and the error message (if any)
-      writeMessage(dos, responseByte, unsuccessfulMsg, clientVersion, endpointType, queueSize);
+      writeHandshakeMessage(dos, responseByte, unsuccessfulMsg, clientVersion, endpointType,
+          queueSize);
     } catch (IOException ioe) {// remove the added proxy if we get IOException.
       if (l_proxy != null) {
         boolean keepProxy = l_proxy.close(false, false); // do not check for queue, just close it
@@ -2199,8 +2203,8 @@ public class CacheClientNotifier {
 
   private final SocketCloser socketCloser;
 
-  private static final long CLIENT_PING_TASK_PERIOD =
-      Long.getLong(DistributionConfig.GEMFIRE_PREFIX + "serverToClientPingPeriod", 60000);
+  private static final int CLIENT_PING_TASK_PERIOD =
+      Integer.getInteger(DistributionConfig.GEMFIRE_PREFIX + "serverToClientPingPeriod", 60000);
 
   private static final long CLIENT_PING_TASK_COUNTER =
       Long.getLong(DistributionConfig.GEMFIRE_PREFIX + "serverToClientPingCounter", 3);
@@ -2209,6 +2213,11 @@ public class CacheClientNotifier {
     return this.logFrequency;
   }
 
+  /** returns the interval between "ping" messages sent to clients on idle connections */
+  public static int getClientPingInterval() {
+    return CLIENT_PING_TASK_PERIOD;
+  }
+
   /**
    * @return the haContainer
    */
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/CacheClientUpdater.java b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/CacheClientUpdater.java
index 43894d7..aa5a045 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/CacheClientUpdater.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/CacheClientUpdater.java
@@ -132,6 +132,15 @@ public class CacheClientUpdater extends Thread implements ClientUpdater, Disconn
    */
   private final InputStream in;
 
+  public ServerQueueStatus getServerQueueStatus() {
+    return serverQueueStatus;
+  }
+
+  /**
+   * server-side queue status at the time we connected to it
+   */
+  private ServerQueueStatus serverQueueStatus;
+
   /**
    * Failed updater from the endpoint previously known as the primary
    */
@@ -324,11 +333,11 @@ public class CacheClientUpdater extends Thread implements ClientUpdater, Disconn
             mySock.getInetAddress().getHostAddress(), mySock.getLocalPort(), mySock.getPort());
       }
 
-      ServerQueueStatus sqs = handshake.handshakeWithSubscriptionFeed(mySock, this.isPrimary);
-      if (sqs.isPrimary() || sqs.isNonRedundant()) {
+      this.serverQueueStatus = handshake.handshakeWithSubscriptionFeed(mySock, this.isPrimary);
+      if (serverQueueStatus.isPrimary() || serverQueueStatus.isNonRedundant()) {
         PoolImpl pool = (PoolImpl) this.qManager.getPool();
         if (!pool.getReadyForEventsCalled()) {
-          pool.setPendingEventCount(sqs.getServerQueueSize());
+          pool.setPendingEventCount(serverQueueStatus.getServerQueueSize());
         }
       }
 
@@ -409,14 +418,6 @@ public class CacheClientUpdater extends Thread implements ClientUpdater, Disconn
         this.serverId = sid;
         this.commBuffer = cb;
 
-        // Don't want the timeout after handshake
-        if (mySock != null) {
-          try {
-            mySock.setSoTimeout(0);
-          } catch (SocketException ignore) {
-          }
-        }
-
       } else {
         this.socket = null;
         this.serverId = null;
@@ -1565,6 +1566,10 @@ public class CacheClientUpdater extends Thread implements ClientUpdater, Disconn
    */
   private void processMessages() {
     final boolean isDebugEnabled = logger.isDebugEnabled();
+
+    final int headerReadTimeout = (int) Math.round(serverQueueStatus.getPingInterval()
+        * qManager.getPool().getSubscriptionTimeoutMultiplier() * 1.25);
+
     try {
       Message clientMessage = initializeMessage();
 
@@ -1599,7 +1604,7 @@ public class CacheClientUpdater extends Thread implements ClientUpdater, Disconn
 
         try {
           // Read the message
-          clientMessage.recv();
+          clientMessage.receiveWithHeaderReadTimeout(headerReadTimeout);
 
           // Wait for the previously failed cache client updater
           // to finish. This will avoid out of order messages.
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/CommandInitializer.java b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/CommandInitializer.java
index 5a81308..6ad1bb3 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/CommandInitializer.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/CommandInitializer.java
@@ -355,6 +355,11 @@ public class CommandInitializer {
       commands.putAll(ALL_COMMANDS.get(Version.GEODE_130));
       ALL_COMMANDS.put(Version.GEODE_140, commands);
     }
+    {
+      Map<Integer, Command> commands = new HashMap<Integer, Command>();
+      commands.putAll(ALL_COMMANDS.get(Version.GEODE_140));
+      ALL_COMMANDS.put(Version.GEODE_150, commands);
+    }
 
   }
 
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/Message.java b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/Message.java
index 6fa115e..8e2afa2 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/Message.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/Message.java
@@ -109,6 +109,8 @@ public class Message {
   private static final byte[] TRUE = defineTrue();
   private static final byte[] FALSE = defineFalse();
 
+  private static final int NO_HEADER_READ_TIMEOUT = 0;
+
   private static byte[] defineTrue() {
     try (HeapDataOutputStream hdos = new HeapDataOutputStream(10, null)) {
       BlobHelper.serializeTo(Boolean.TRUE, hdos);
@@ -647,61 +649,18 @@ public class Message {
     cb.clear();
   }
 
-  private void read() throws IOException {
+  private void readHeaderAndBody(int headerReadTimeoutMillis) throws IOException {
     clearParts();
     // TODO: for server changes make sure sc is not null as this class also used by client
-    readHeaderAndPayload();
-  }
-
-  /**
-   * Read the actual bytes of the header off the socket
-   */
-  void fetchHeader() throws IOException {
-    final ByteBuffer cb = getCommBuffer();
-    cb.clear();
-
-    // messageType is invalidated here and can be used as an indicator
-    // of problems reading the message
-    this.messageType = MessageType.INVALID;
 
-    final int headerLength = getHeaderLength();
-    if (this.socketChannel != null) {
-      cb.limit(headerLength);
-      do {
-        int bytesRead = this.socketChannel.read(cb);
-        if (bytesRead == -1) {
-          throw new EOFException(
-              LocalizedStrings.Message_THE_CONNECTION_HAS_BEEN_RESET_WHILE_READING_THE_HEADER
-                  .toLocalizedString());
-        }
-        if (this.messageStats != null) {
-          this.messageStats.incReceivedBytes(bytesRead);
-        }
-      } while (cb.remaining() > 0);
-      cb.flip();
-
-    } else {
-      int hdr = 0;
-      do {
-        int bytesRead = this.inputStream.read(cb.array(), hdr, headerLength - hdr);
-        if (bytesRead == -1) {
-          throw new EOFException(
-              LocalizedStrings.Message_THE_CONNECTION_HAS_BEEN_RESET_WHILE_READING_THE_HEADER
-                  .toLocalizedString());
-        }
-        hdr += bytesRead;
-        if (this.messageStats != null) {
-          this.messageStats.incReceivedBytes(bytesRead);
-        }
-      } while (hdr < headerLength);
-
-      // now setup the commBuffer for the caller to parse it
-      cb.rewind();
+    int timeout = socket.getSoTimeout();
+    try {
+      socket.setSoTimeout(headerReadTimeoutMillis);
+      fetchHeader();
+    } finally {
+      socket.setSoTimeout(timeout);
     }
-  }
 
-  private void readHeaderAndPayload() throws IOException {
-    fetchHeader();
     final ByteBuffer cb = getCommBuffer();
     final int type = cb.getInt();
     final int len = cb.getInt();
@@ -818,6 +777,53 @@ public class Message {
   }
 
   /**
+   * Read the actual bytes of the header off the socket
+   */
+  void fetchHeader() throws IOException {
+    final ByteBuffer cb = getCommBuffer();
+    cb.clear();
+
+    // messageType is invalidated here and can be used as an indicator
+    // of problems reading the message
+    this.messageType = MessageType.INVALID;
+
+    final int headerLength = getHeaderLength();
+    if (this.socketChannel != null) {
+      cb.limit(headerLength);
+      do {
+        int bytesRead = this.socketChannel.read(cb);
+        if (bytesRead == -1) {
+          throw new EOFException(
+              LocalizedStrings.Message_THE_CONNECTION_HAS_BEEN_RESET_WHILE_READING_THE_HEADER
+                  .toLocalizedString());
+        }
+        if (this.messageStats != null) {
+          this.messageStats.incReceivedBytes(bytesRead);
+        }
+      } while (cb.remaining() > 0);
+      cb.flip();
+
+    } else {
+      int hdr = 0;
+      do {
+        int bytesRead = this.inputStream.read(cb.array(), hdr, headerLength - hdr);
+        if (bytesRead == -1) {
+          throw new EOFException(
+              LocalizedStrings.Message_THE_CONNECTION_HAS_BEEN_RESET_WHILE_READING_THE_HEADER
+                  .toLocalizedString());
+        }
+        hdr += bytesRead;
+        if (this.messageStats != null) {
+          this.messageStats.incReceivedBytes(bytesRead);
+        }
+      } while (hdr < headerLength);
+
+      // now setup the commBuffer for the caller to parse it
+      cb.rewind();
+    }
+  }
+
+  /**
    * TODO: refactor overly long method readPayloadFields
    */
   void readPayloadFields(final int numParts, final int len) throws IOException {
@@ -1043,12 +1049,14 @@ public class Message {
     return sb.toString();
   }
 
+  // Set up a message on the server side.
   void setComms(ServerConnection sc, Socket socket, ByteBuffer bb, MessageStats msgStats)
       throws IOException {
     this.serverConnection = sc;
     setComms(socket, bb, msgStats);
   }
 
+  // Set up a message on the client side.
   void setComms(Socket socket, ByteBuffer bb, MessageStats msgStats) throws IOException {
     this.socketChannel = socket.getChannel();
     if (this.socketChannel == null) {
@@ -1058,6 +1066,7 @@ public class Message {
     }
   }
 
+  // Set up a message on the client side.
   public void setComms(Socket socket, InputStream is, OutputStream os, ByteBuffer bb,
       MessageStats msgStats) {
     Assert.assertTrue(socket != null);
@@ -1104,25 +1113,36 @@ public class Message {
   }
 
   /**
-   * Populates the stats of this {@code Message} with information received via its socket
+   * Read a message, populating the state of this {@code Message} with information received via its
+   * socket
+   *
+   * @param timeoutMillis timeout setting for reading the header (0 = no timeout)
+   * @throws IOException
    */
-  public void recv() throws IOException {
+  public void receiveWithHeaderReadTimeout(int timeoutMillis) throws IOException {
     if (this.socket != null) {
       synchronized (getCommBuffer()) {
-        read();
+        readHeaderAndBody(timeoutMillis);
       }
     } else {
       throw new IOException(LocalizedStrings.Message_DEAD_CONNECTION.toLocalizedString());
     }
   }
 
-  public void recv(ServerConnection sc, int maxMessageLength, Semaphore dataLimiter,
+  /**
+   * Populates the state of this {@code Message} with information received via its socket
+   */
+  public void receive() throws IOException {
+    receiveWithHeaderReadTimeout(NO_HEADER_READ_TIMEOUT);
+  }
+
+  public void receive(ServerConnection sc, int maxMessageLength, Semaphore dataLimiter,
       Semaphore msgLimiter) throws IOException {
     this.serverConnection = sc;
     this.maxIncomingMessageLength = maxMessageLength;
     this.dataLimiter = dataLimiter;
     this.messageLimiter = msgLimiter;
-    recv();
+    receive();
   }
 
 }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/OriginalServerConnection.java b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/OriginalServerConnection.java
index 7d31cc7..d2a7384 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/OriginalServerConnection.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/OriginalServerConnection.java
@@ -62,8 +62,8 @@ public class OriginalServerConnection extends ServerConnection {
   @Override
   protected boolean doHandShake(byte endpointType, int queueSize) {
     try {
-      this.handshake.accept(theSocket.getOutputStream(), theSocket.getInputStream(), endpointType,
-          queueSize, this.communicationMode, this.principal);
+      handshake.handshakeWithClient(theSocket.getOutputStream(), theSocket.getInputStream(),
+          endpointType, queueSize, this.communicationMode, this.principal);
     } catch (IOException ioe) {
       if (!crHelper.isShutdown() && !isTerminated()) {
         logger.warn(LocalizedMessage.create(
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/ServerHandshakeProcessor.java b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/ServerHandshakeProcessor.java
index f1c05a9..c0ff9ff 100755
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/ServerHandshakeProcessor.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/ServerHandshakeProcessor.java
@@ -41,6 +41,7 @@ import org.apache.geode.cache.VersionException;
 import org.apache.geode.distributed.DistributedMember;
 import org.apache.geode.distributed.DistributedSystem;
 import org.apache.geode.distributed.internal.InternalDistributedSystem;
+import org.apache.geode.distributed.internal.membership.InternalDistributedMember;
 import org.apache.geode.internal.HeapDataOutputStream;
 import org.apache.geode.internal.Version;
 import org.apache.geode.internal.VersionedDataStream;
@@ -154,6 +155,7 @@ public class ServerHandshakeProcessor {
 
     // Write the server's member
     DistributedMember member = InternalDistributedSystem.getAnyInstance().getDistributedMember();
+
     writeServerMember(member, dos);
 
     // Write the refusal message
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/ServerQueueStatus.java b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/ServerQueueStatus.java
index 41094ea..b16f0c0 100755
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/ServerQueueStatus.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/ServerQueueStatus.java
@@ -26,6 +26,11 @@ import org.apache.geode.distributed.DistributedMember;
  *
  */
 public class ServerQueueStatus {
+  /**
+   * interval that server sends pings if connection is idle. This is only known for
+   * CacheClientUpdater subscription feed status objects
+   */
+  private final int pingInterval;
   /** queueSize of HARegionQueue for this client */
   private int qSize = 0;
   /** Endpoint type for this endpoint */
@@ -35,23 +40,26 @@ public class ServerQueueStatus {
   private int pdxSize = 0;
 
   /**
-   * Default constructor Called when connectionsPerServer=0
+   * Constructor Called when connectionsPerServer is nto equal to 0
+   *
    */
-  public ServerQueueStatus(DistributedMember memberId) {
-    this((byte) 0, 0, memberId);
+  public ServerQueueStatus(byte endpointType, int queueSize, DistributedMember memberId,
+      int pingInterval) {
+    this.qSize = queueSize;
+    this.endpointType = endpointType;
+    this.memberId = memberId;
+    this.pingInterval = pingInterval;
   }
 
   /**
    * Constructor Called when connectionsPerServer is nto equal to 0
    *
-   * @param endpointType
-   * @param queueSize
    */
   public ServerQueueStatus(byte endpointType, int queueSize, DistributedMember memberId) {
     this.qSize = queueSize;
     this.endpointType = endpointType;
     this.memberId = memberId;
-
+    this.pingInterval = -1;
   }
 
   /**
@@ -82,10 +90,20 @@ public class ServerQueueStatus {
     return this.qSize;
   }
 
+  /** returns the time between server-to-client ping messages on idle subscription connections */
+  public int getPingInterval() {
+    if (this.pingInterval < 0) {
+      throw new IllegalStateException(
+          "ping interval is only known for a subscription feed connection");
+    }
+    return this.pingInterval;
+  }
+
   public String toString() {
     StringBuffer buffer = new StringBuffer();
     buffer.append("ServerQueueStatus [").append("queueSize=").append(this.qSize)
-        .append("; endpointType=").append(getTypeAsString()).append("]");
+        .append("; endpointType=").append(getTypeAsString()).append("; pingInterval=")
+        .append(this.pingInterval).append("ms]");
     return buffer.toString();
   }
 
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/ServerSideHandshakeImpl.java b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/ServerSideHandshakeImpl.java
index bb14ecb..548c1e3 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/ServerSideHandshakeImpl.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/ServerSideHandshakeImpl.java
@@ -123,8 +123,9 @@ public class ServerSideHandshakeImpl extends Handshake implements ServerSideHand
     return this.clientVersion;
   }
 
-  public void accept(OutputStream out, InputStream in, byte endpointType, int queueSize,
-      CommunicationMode communicationMode, Principal principal) throws IOException {
+  @Override
+  public void handshakeWithClient(OutputStream out, InputStream in, byte endpointType,
+      int queueSize, CommunicationMode communicationMode, Principal principal) throws IOException {
     DataOutputStream dos = new DataOutputStream(out);
     DataInputStream dis;
     if (clientVersion.compareTo(Version.CURRENT) < 0) {
diff --git a/geode-core/src/test/java/org/apache/geode/cache/client/internal/AutoConnectionSourceImplJUnitTest.java b/geode-core/src/test/java/org/apache/geode/cache/client/internal/AutoConnectionSourceImplJUnitTest.java
index f1bcb46..1a213ee 100644
--- a/geode-core/src/test/java/org/apache/geode/cache/client/internal/AutoConnectionSourceImplJUnitTest.java
+++ b/geode-core/src/test/java/org/apache/geode/cache/client/internal/AutoConnectionSourceImplJUnitTest.java
@@ -638,6 +638,11 @@ public class AutoConnectionSourceImplJUnitTest {
       return 0;
     }
 
+    @Override
+    public int getSubscriptionTimeoutMultiplier() {
+      return 0;
+    }
+
     public RegionService createAuthenticatedCacheView(Properties properties) {
       return null;
     }
diff --git a/geode-core/src/test/java/org/apache/geode/cache/client/internal/QueueManagerJUnitTest.java b/geode-core/src/test/java/org/apache/geode/cache/client/internal/QueueManagerJUnitTest.java
index d6e7266..6f0d29d 100644
--- a/geode-core/src/test/java/org/apache/geode/cache/client/internal/QueueManagerJUnitTest.java
+++ b/geode-core/src/test/java/org/apache/geode/cache/client/internal/QueueManagerJUnitTest.java
@@ -493,6 +493,11 @@ public class QueueManagerJUnitTest {
       return 0;
     }
 
+    @Override
+    public int getSubscriptionTimeoutMultiplier() {
+      return 0;
+    }
+
     public RegionService createAuthenticatedCacheView(Properties properties) {
       return null;
     }
@@ -550,20 +555,26 @@ public class QueueManagerJUnitTest {
     public ClientUpdater createServerToClientConnection(Endpoint endpoint,
         QueueManager queueManager, boolean isPrimary, ClientUpdater failedUpdater) {
       return new ClientUpdater() {
+        @Override
         public void close() {}
 
+        @Override
         public boolean isAlive() {
           return true;
         }
 
+        @Override
         public void join(long wait) throws InterruptedException {}
 
+        @Override
         public void setFailedUpdater(ClientUpdater failedUpdater) {}
 
+        @Override
         public boolean isProcessing() {
           return true;
         }
 
+        @Override
         public boolean isPrimary() {
           return true;
         }
@@ -574,15 +585,18 @@ public class QueueManagerJUnitTest {
   private class DummySource implements ConnectionSource {
     int nextPort = 0;
 
+    @Override
     public ServerLocation findServer(Set excludedServers) {
       return new ServerLocation("localhost", nextPort++);
     }
 
+    @Override
     public ServerLocation findReplacementServer(ServerLocation currentServer,
         Set/* <ServerLocation> */ excludedServers) {
       return new ServerLocation("localhost", nextPort++);
     }
 
+    @Override
     public List findServersForQueue(Set excludedServers, int numServers,
         ClientProxyMembershipID proxyId, boolean findDurableQueue) {
       numServers =
@@ -594,12 +608,13 @@ public class QueueManagerJUnitTest {
       return locations;
     }
 
+    @Override
     public void start(InternalPool poolImpl) {}
 
-    public void stop() {
-
-    }
+    @Override
+    public void stop() {}
 
+    @Override
     public boolean isBalanced() {
       return false;
     }
@@ -623,72 +638,88 @@ public class QueueManagerJUnitTest {
 
     public DummyConnection(int endpointType, int queueSize, int port) throws UnknownHostException {
       InternalDistributedMember member = new InternalDistributedMember("localhost", 555);
-      ServerQueueStatus status = new ServerQueueStatus((byte) endpointType, queueSize, member);
+      ServerQueueStatus status = new ServerQueueStatus((byte) endpointType, queueSize, member, 0);
       this.status = status;
       this.location = new ServerLocation("localhost", port);
       this.endpoint = endpoints.referenceEndpoint(location, member);
     }
 
-    public void internalDestroy() {}
-
+    @Override
     public void close(boolean keepAlive) throws Exception {}
 
+    @Override
     public void destroy() {}
 
+    @Override
     public Object execute(Op op) throws Exception {
       return null;
     }
 
+    @Override
     public int getDistributedSystemId() {
       return 0;
     }
 
+    @Override
     public ByteBuffer getCommBuffer() {
       return null;
     }
 
+    @Override
     public Endpoint getEndpoint() {
       return endpoint;
     }
 
+    @Override
     public ServerQueueStatus getQueueStatus() {
       return status;
     }
 
+    @Override
     public ServerLocation getServer() {
       return location;
     }
 
+    @Override
     public Socket getSocket() {
       return null;
     }
 
+    @Override
     public ConnectionStats getStats() {
       return null;
     }
 
+    @Override
     public boolean isDestroyed() {
       return false;
     }
 
+    @Override
     public void emergencyClose() {}
 
+    @Override
     public short getWanSiteVersion() {
       return -1;
     }
 
+    @Override
     public void setWanSiteVersion(short wanSiteVersion) {}
 
+    @Override
     public OutputStream getOutputStream() {
       return null;
     }
 
+    @Override
     public InputStream getInputStream() {
       return null;
     }
 
+    @Override
     public void setConnectionID(long id) {}
 
+    @Override
     public long getConnectionID() {
       return 0;
     }
diff --git a/geode-core/src/test/java/org/apache/geode/internal/cache/tier/sockets/ClientServerMiscDUnitTest.java b/geode-core/src/test/java/org/apache/geode/internal/cache/tier/sockets/ClientServerMiscDUnitTest.java
index 76e8e7e..aac6eea 100755
--- a/geode-core/src/test/java/org/apache/geode/internal/cache/tier/sockets/ClientServerMiscDUnitTest.java
+++ b/geode-core/src/test/java/org/apache/geode/internal/cache/tier/sockets/ClientServerMiscDUnitTest.java
@@ -18,6 +18,7 @@ import static org.apache.geode.distributed.ConfigurationProperties.LOCATORS;
 import static org.apache.geode.distributed.ConfigurationProperties.MCAST_PORT;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
@@ -26,6 +27,7 @@ import static org.junit.Assert.fail;
 import java.io.ByteArrayInputStream;
 import java.io.DataInputStream;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Properties;
@@ -52,13 +54,16 @@ import org.apache.geode.cache.RegionEvent;
 import org.apache.geode.cache.RegionShortcut;
 import org.apache.geode.cache.Scope;
 import org.apache.geode.cache.client.ClientCacheFactory;
+import org.apache.geode.cache.client.ClientRegionShortcut;
 import org.apache.geode.cache.client.NoAvailableServersException;
 import org.apache.geode.cache.client.Pool;
 import org.apache.geode.cache.client.PoolFactory;
 import org.apache.geode.cache.client.PoolManager;
 import org.apache.geode.cache.client.internal.Connection;
+import org.apache.geode.cache.client.internal.ConnectionFactory;
 import org.apache.geode.cache.client.internal.Op;
 import org.apache.geode.cache.client.internal.PoolImpl;
+import org.apache.geode.cache.client.internal.QueueConnectionImpl;
 import org.apache.geode.cache.client.internal.RegisterInterestTracker;
 import org.apache.geode.cache.server.CacheServer;
 import org.apache.geode.cache.util.CacheListenerAdapter;
@@ -67,6 +72,7 @@ import org.apache.geode.distributed.DistributedMember;
 import org.apache.geode.distributed.DistributedSystem;
 import org.apache.geode.distributed.DistributedSystemDisconnectedException;
 import org.apache.geode.distributed.internal.DistributionConfig;
+import org.apache.geode.distributed.internal.ServerLocation;
 import org.apache.geode.distributed.internal.membership.InternalDistributedMember;
 import org.apache.geode.internal.AvailablePort;
 import org.apache.geode.internal.cache.CacheServerImpl;
@@ -182,6 +188,55 @@ public class ClientServerMiscDUnitTest extends JUnit4CacheTestCase {
     // TODO add verification in vm1
   }
 
+  /**
+   * When a client's subscription thread connects to a server it should receive the server's
+   * pingInterval setting. This is used by the client to set a read-timeout in order to avoid
+   * hanging should the server's machine crash.
+   *
+   * @see MessageJUnitTest#messageWillTimeoutDuringRecvOnInactiveSocket
+   */
+  @Test
+  public void testClientReceivesPingIntervalSetting() {
+    VM clientVM = Host.getHost(0).getVM(testVersion, 0);
+
+    final int port = initServerCache(true);
+    final String host = NetworkUtils.getServerHostName(server1.getHost());
+
+    clientVM.invoke("create client cache and verify", () -> {
+      createClientCacheAndVerifyPingIntervalIsSet(host, port);
+    });
+  }
+
+  void createClientCacheAndVerifyPingIntervalIsSet(String host, int port) throws Exception {
+    PoolImpl pool = null;
+    try {
+      Properties props = new Properties();
+      props.setProperty(MCAST_PORT, "0");
+      props.setProperty(LOCATORS, "");
+
+      createCache(props);
+
+      pool = (PoolImpl) PoolManager.createFactory().addServer(host, port)
+          .setSubscriptionEnabled(true).setThreadLocalConnections(false).setReadTimeout(1000)
+          .setSocketBufferSize(32768).setMinConnections(1).setSubscriptionRedundancy(-1)
+          .setPingInterval(2000).create("test pool");
+
+      Region<Object, Object> region = cache.createRegionFactory(RegionShortcut.LOCAL)
+          .setPoolName("test pool").create(REGION_NAME1);
+      region.registerInterest(".*");
+
+      /** get the subscription connection and verify that it has the correct timeout setting */
+      QueueConnectionImpl primaryConnection = (QueueConnectionImpl) pool.getPrimaryConnection();
+      int pingInterval = ((CacheClientUpdater) primaryConnection.getUpdater())
+          .getServerQueueStatus().getPingInterval();
+      assertNotEquals(0, pingInterval);
+      assertEquals(CacheClientNotifier.getClientPingInterval(), pingInterval);
+    } finally {
+      cache.close();
+    }
+
+  }
+
   @Test
   public void testConcurrentOperationsWithDRandPRandEmptyClient() {
     int port1 = initServerCache(true); // vm0
diff --git a/geode-core/src/test/java/org/apache/geode/internal/cache/tier/sockets/MessageJUnitTest.java b/geode-core/src/test/java/org/apache/geode/internal/cache/tier/sockets/MessageJUnitTest.java
index 20b11bd..b3ca83c 100755
--- a/geode-core/src/test/java/org/apache/geode/internal/cache/tier/sockets/MessageJUnitTest.java
+++ b/geode-core/src/test/java/org/apache/geode/internal/cache/tier/sockets/MessageJUnitTest.java
@@ -17,9 +17,18 @@ package org.apache.geode.internal.cache.tier.sockets;
 import static org.junit.Assert.*;
 import static org.mockito.Mockito.*;
 
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.ServerSocket;
 import java.net.Socket;
+import java.net.SocketTimeoutException;
 import java.nio.ByteBuffer;
+import java.util.concurrent.TimeUnit;
 
+import org.awaitility.Awaitility;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.experimental.categories.Category;
@@ -112,4 +121,53 @@ public class MessageJUnitTest {
     verify(mockPart1, times(2)).clear();
   }
 
+  /**
+   * Client subscription threads establish a timeout when reading a message header in order to avoid
+   * hanging should the server's machine fail, or should the network path to the server have
+   * problems. This test ensures that the method Message.receiveWithHeaderReadTimeout correctly
+   * times out when trying to read a message header.
+   *
+   * @See ClientServerMiscDUnitTest#testClientReceivesPingIntervalSetting
+   */
+  @Test(expected = SocketTimeoutException.class)
+  public void messageWillTimeoutDuringRecvOnInactiveSocket() throws Exception {
+    final ServerSocket serverSocket = new ServerSocket();
+    serverSocket.bind(new InetSocketAddress(InetAddress.getLocalHost(), 0));
+    Thread serverThread = new Thread("acceptor thread") {
+      public void run() {
+        Socket client = null;
+        try {
+          client = serverSocket.accept();
+          Thread.sleep(12000);
+        } catch (InterruptedException e) {
+
+        } catch (IOException e) {
+
+        } finally {
+          if (client != null && !client.isClosed()) {
+            try {
+              client.close();
+            } catch (IOException e) {
+            }
+          }
+        }
+      }
+    };
+    serverThread.setDaemon(true);
+    serverThread.start();
+
+    try {
+      Socket socket = new Socket(serverSocket.getInetAddress(), serverSocket.getLocalPort());
+      MessageStats messageStats = mock(MessageStats.class);
+
+      message.setComms(socket, ByteBuffer.allocate(100), messageStats);
+      message.receiveWithHeaderReadTimeout(500);
+
+    } finally {
+      serverThread.interrupt();
+      if (serverSocket != null && !serverSocket.isClosed()) {
+        serverSocket.close();
+      }
+    }
+  }
 }
diff --git a/geode-core/src/test/java/org/apache/geode/internal/cache/tier/sockets/ServerConnectionTest.java b/geode-core/src/test/java/org/apache/geode/internal/cache/tier/sockets/ServerConnectionTest.java
index 6334e31..d20d3c4 100644
--- a/geode-core/src/test/java/org/apache/geode/internal/cache/tier/sockets/ServerConnectionTest.java
+++ b/geode-core/src/test/java/org/apache/geode/internal/cache/tier/sockets/ServerConnectionTest.java
@@ -174,7 +174,7 @@ public class ServerConnectionTest {
     }
 
     @Override
-    public void recv() throws IOException {
+    public void receive() throws IOException {
       try {
         lock.lock();
         testGate.await(10, TimeUnit.SECONDS);
diff --git a/geode-cq/src/test/java/org/apache/geode/internal/cache/tier/sockets/ClientServerMiscBCDUnitTest.java b/geode-cq/src/test/java/org/apache/geode/internal/cache/tier/sockets/ClientServerMiscBCDUnitTest.java
index c2530bc..73689e8 100755
--- a/geode-cq/src/test/java/org/apache/geode/internal/cache/tier/sockets/ClientServerMiscBCDUnitTest.java
+++ b/geode-cq/src/test/java/org/apache/geode/internal/cache/tier/sockets/ClientServerMiscBCDUnitTest.java
@@ -43,6 +43,7 @@ import org.apache.geode.cache.query.CqListener;
 import org.apache.geode.cache.query.CqQuery;
 import org.apache.geode.cache.server.CacheServer;
 import org.apache.geode.distributed.DistributedSystem;
+import org.apache.geode.internal.Version;
 import org.apache.geode.internal.cache.EventID;
 import org.apache.geode.internal.cache.LocalRegion;
 import org.apache.geode.test.dunit.Host;
@@ -74,6 +75,15 @@ public class ClientServerMiscBCDUnitTest extends ClientServerMiscDUnitTest {
     testVersion = version;
   }
 
+  @Override
+  void createClientCacheAndVerifyPingIntervalIsSet(String host, int port) throws Exception {
+    // this functionality was introduced in 1.5. If we let the test run in older
+    // clients it will throw a NoSuchMethodError
+    if (Version.CURRENT_ORDINAL >= 80 /* GEODE_150 */) {
+      super.createClientCacheAndVerifyPingIntervalIsSet(host, port);
+    }
+  }
+
   @Test
   public void testSubscriptionWithCurrentServerAndOldClients() throws Exception {
     // start server first
diff --git a/geode-wan/src/main/java/org/apache/geode/cache/client/internal/GatewaySenderBatchOp.java b/geode-wan/src/main/java/org/apache/geode/cache/client/internal/GatewaySenderBatchOp.java
index 05a576d..d9459d4 100755
--- a/geode-wan/src/main/java/org/apache/geode/cache/client/internal/GatewaySenderBatchOp.java
+++ b/geode-wan/src/main/java/org/apache/geode/cache/client/internal/GatewaySenderBatchOp.java
@@ -30,7 +30,6 @@ import org.apache.geode.internal.cache.tier.sockets.Message;
 import org.apache.geode.internal.cache.tier.sockets.Part;
 import org.apache.geode.internal.cache.wan.BatchException70;
 import org.apache.geode.internal.cache.wan.GatewaySenderEventImpl;
-import org.apache.geode.internal.cache.wan.GatewaySenderEventRemoteDispatcher;
 import org.apache.geode.internal.cache.wan.GatewaySenderEventRemoteDispatcher.GatewayAck;
 import org.apache.geode.internal.i18n.LocalizedStrings;
 import org.apache.geode.internal.logging.LogService;
@@ -202,7 +201,7 @@ public class GatewaySenderBatchOp {
         }
 
         try {
-          msg.recv();
+          msg.receive();
         } finally {
           msg.unsetComms();
           processSecureBytes(cnx, msg);

-- 
To stop receiving notification emails like this one, please contact
bschuchardt@apache.org.