SPY-121: Make NOOP send optional on connect.

This changeset makes the NOOP sending before AUTH
on connect optional, because this may have issues
with other systems and therefore lead to non-working
systems.

The check can be activated by setting the
net.spy.verifyAliveOnConnect system property to
true.

Change-Id: If26439c024c3c50f02e992aaa80ba39fa683aed0
Reviewed-on: http://review.couchbase.org/26151
Reviewed-by: Matt Ingenthron <[email protected]>
Reviewed-by: Deepti Dawar <[email protected]>
Tested-by: Michael Nitschinger <[email protected]>

Author: daschl

src/main/java/net/spy/memcached/MemcachedClient.java

@@ -124,6 +124,13 @@
  *          // Do other timeout related stuff
  *      }
  * </pre>
+ *
+ * <p>Optionally, it is possible to activate a check that makes sure that
+ * the node is alive and responding before running actual operations (even
+ * before authentication. Only enable this if you are sure that you do not
+ * run into issues during connection (some memcached services have problems
+ * with it). You can enable it by setting the net.spy.verifyAliveOnConnect
+ * System Property to "true".</p>
  */
 public class MemcachedClient extends SpyObject implements MemcachedClientIF,
     ConnectionObserver {

src/main/java/net/spy/memcached/MemcachedConnection.java

@@ -105,6 +105,7 @@ public class MemcachedConnection extends SpyThread {
   private final int timeoutExceptionThreshold;
   private final Collection<Operation> retryOps;
   protected final ConcurrentLinkedQueue<MemcachedNode> nodesToShutdown;
+  private final boolean verifyAliveOnConnect;
 
   /**
    * Construct a memcached connection.
@@ -131,6 +132,14 @@ public MemcachedConnection(int bufSize, ConnectionFactory f,
     nodesToShutdown = new ConcurrentLinkedQueue<MemcachedNode>();
     this.bufSize = bufSize;
     this.connectionFactory = f;
+
+    String verifyAlive = System.getProperty("net.spy.verifyAliveOnConnect");
+    if(verifyAlive != null && verifyAlive.equals("true")) {
+      verifyAliveOnConnect = true;
+    } else {
+      verifyAliveOnConnect = false;
+    }
+
     List<MemcachedNode> connections = createConnections(a);
     locator = f.createLocator(connections);
     setName("Memcached IO over " + this);
@@ -412,47 +421,49 @@ private void handleIO(SelectionKey sk) {
         final SocketChannel channel = node.getChannel();
         if (channel.finishConnect()) {
 
-          // Test to see if it's truly alive, could be a hung process, OS
-          final CountDownLatch latch = new CountDownLatch(1);
-          final OperationFuture<Boolean> rv =
-            new OperationFuture<Boolean>("noop", latch, 2500);
-          NoopOperation testOp = opFact.noop(new OperationCallback() {
-            public void receivedStatus(OperationStatus status) {
-              rv.set(status.isSuccess(), status);
-            }
+          if(verifyAliveOnConnect) {
+            // Test to see if it's truly alive, could be a hung process, OS
+            final CountDownLatch latch = new CountDownLatch(1);
+            final OperationFuture<Boolean> rv =
+              new OperationFuture<Boolean>("noop", latch, 2500);
+            NoopOperation testOp = opFact.noop(new OperationCallback() {
+              public void receivedStatus(OperationStatus status) {
+                rv.set(status.isSuccess(), status);
+              }
 
-            @Override
-            public void complete() {
-              latch.countDown();
-            }
-          });
-
-          testOp.setHandlingNode(node);
-          testOp.initialize();
-
-          checkState();
-          insertOperation(node, testOp);
-          node.copyInputQueue();
-
-          boolean done = false;
-          if(sk.isValid()) {
-            long timeout = TimeUnit.MILLISECONDS.toNanos(
-              connectionFactory.getOperationTimeout());
-            for(long stop = System.nanoTime() + timeout;
-              stop > System.nanoTime();) {
-              handleWrites(sk, node);
-              handleReads(sk, node);
-              if(done = (latch.getCount() == 0)) {
-                break;
+              @Override
+              public void complete() {
+                latch.countDown();
+              }
+            });
+
+            testOp.setHandlingNode(node);
+            testOp.initialize();
+
+            checkState();
+            insertOperation(node, testOp);
+            node.copyInputQueue();
+
+            boolean done = false;
+            if(sk.isValid()) {
+              long timeout = TimeUnit.MILLISECONDS.toNanos(
+                connectionFactory.getOperationTimeout());
+              for(long stop = System.nanoTime() + timeout;
+                stop > System.nanoTime();) {
+                handleWrites(sk, node);
+                handleReads(sk, node);
+                if(done = (latch.getCount() == 0)) {
+                  break;
+                }
               }
             }
-          }
 
-          if (!done || testOp.isCancelled() || testOp.hasErrored()
-            || testOp.isTimedOut()) {
-            throw new ConnectException("Could not send noop upon connect! "
-              + "This may indicate a running, but not responding memcached "
-              + "instance.");
+            if (!done || testOp.isCancelled() || testOp.hasErrored()
+              || testOp.isTimedOut()) {
+              throw new ConnectException("Could not send noop upon connect! "
+                + "This may indicate a running, but not responding memcached "
+                + "instance.");
+            }
           }
 
           connected(node);