JAVA-1157: Clean up messaging around server selectors and server selection timeouts.

jyemin · jyemin · commit 5fb47a3bf86c · 2014-04-01T16:15:31.000-04:00
diff --git a/src/main/com/mongodb/BaseCluster.java b/src/main/com/mongodb/BaseCluster.java
@@ -25,6 +25,7 @@
 import java.util.logging.Logger;
 
 import static java.lang.String.format;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
 import static java.util.concurrent.TimeUnit.NANOSECONDS;
 import static org.bson.util.Assertions.isTrue;
 import static org.bson.util.Assertions.notNull;
@@ -76,27 +77,24 @@ public Server getServer(final ServerSelector serverSelector, final long maxWaitT
                 }
 
                 if (!curDescription.isConnecting()) {
-                    throw new MongoServerSelectionException(
-                                                                  format("Unable to connect to any server that satisfies the selector " +
-                                                                         "%s", serverSelector));
+                    throw new MongoServerSelectionException(format("Unable to connect to any server that matches %s", serverSelector));
                 }
 
                 final long timeout = endTime - System.nanoTime();
 
                 LOGGER.info(format("No server chosen by %s from cluster description %s. Waiting for %d ms before timing out",
-                                   serverSelector, curDescription, TimeUnit.MILLISECONDS.convert(timeout, NANOSECONDS)));
+                                   serverSelector, curDescription, MILLISECONDS.convert(timeout, NANOSECONDS)));
 
                 if (!currentPhase.await(timeout, NANOSECONDS)) {
-                    throw new MongoTimeoutException(format("Timed out while waiting for a server that satisfies the selector: %s "
-                                                           + "after  %d %s", serverSelector, timeout, NANOSECONDS));
+                    throw new MongoTimeoutException(format("Timed out while waiting for a server that matches %s after %d ms",
+                                                           serverSelector, MILLISECONDS.convert(timeout, NANOSECONDS)));
                 }
                 currentPhase = phase.get();
                 curDescription = description;
                 serverDescriptions = serverSelector.choose(curDescription);
             }
         } catch (InterruptedException e) {
-            throw new MongoInterruptedException(format("Interrupted while waiting for a server that satisfies server selector %s ",
-                                                       serverSelector), e);
+            throw new MongoInterruptedException(format("Interrupted while waiting for a server that matches %s ", serverSelector), e);
         }
     }
 
@@ -117,18 +115,18 @@ public ClusterDescription getDescription(final long maxWaitTime, final TimeUnit
                 final long timeout = endTime - System.nanoTime();
 
                 LOGGER.info(format("Cluster description not yet available. Waiting for %d ms before timing out",
-                                   TimeUnit.MILLISECONDS.convert(timeout, NANOSECONDS)));
+                                   MILLISECONDS.convert(timeout, NANOSECONDS)));
 
                 if (!currentPhase.await(timeout, NANOSECONDS)) {
-                    throw new MongoTimeoutException(format("Timed out while waiting for the cluster description after waiting %d %s",
-                                                           timeout, NANOSECONDS));
+                    throw new MongoTimeoutException(format("Timed out while waiting to connect after %d ms",
+                                                           MILLISECONDS.convert(timeout, NANOSECONDS)));
                 }
                 currentPhase = phase.get();
                 curDescription = description;
             }
             return curDescription;
         } catch (InterruptedException e) {
-            throw new MongoInterruptedException(format("Interrupted while waiting for the cluster description"), e);
+            throw new MongoInterruptedException(format("Interrupted while waiting to connect"), e);
         }
     }
 
diff --git a/src/main/com/mongodb/CompositeServerSelector.java b/src/main/com/mongodb/CompositeServerSelector.java
@@ -43,8 +43,8 @@ public List<ServerDescription> choose(final ClusterDescription clusterDescriptio
 
     @Override
     public String toString() {
-        return "CompositeServerSelector{"
-               + "serverSelectors=" + serverSelectors
-               + '}';
+            return "{"
+                   + "serverSelectors=" + serverSelectors
+                   + '}';
     }
-}
+}
diff --git a/src/main/com/mongodb/DBTCPConnector.java b/src/main/com/mongodb/DBTCPConnector.java
@@ -562,7 +562,7 @@ private synchronized ServerSelector getPrefixedServerSelector() {
         if (prefixedServerSelector == null) {
             ClusterDescription clusterDescription = getClusterDescription();
             if (clusterDescription.getConnectionMode() == Multiple && clusterDescription.getType() == Sharded) {
-                prefixedServerSelector = new StickyHAShardedClusterServerSelector();
+                prefixedServerSelector = new MongosHAServerSelector();
             } else {
                 prefixedServerSelector = new NoOpServerSelector();
             }
diff --git a/src/main/com/mongodb/LatencyMinimizingServerSelector.java b/src/main/com/mongodb/LatencyMinimizingServerSelector.java
@@ -21,14 +21,15 @@
 import java.util.Set;
 import java.util.concurrent.TimeUnit;
 
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static java.util.concurrent.TimeUnit.NANOSECONDS;
+
 class LatencyMinimizingServerSelector implements ServerSelector {
 
-    private final long acceptableLatencyDifference;
-    private final TimeUnit timeUnit;
+    private final long acceptableLatencyDifferenceNanos;
 
     LatencyMinimizingServerSelector(final long acceptableLatencyDifference, final TimeUnit timeUnit) {
-        this.acceptableLatencyDifference = acceptableLatencyDifference;
-        this.timeUnit = timeUnit;
+        this.acceptableLatencyDifferenceNanos = NANOSECONDS.convert(acceptableLatencyDifference, timeUnit);
     }
 
     @Override
@@ -39,8 +40,7 @@ public List<ServerDescription> choose(final ClusterDescription clusterDescriptio
     @Override
     public String toString() {
         return "LatencyMinimizingServerSelector{"
-               + "acceptableLatencyDifference=" + acceptableLatencyDifference
-               + ", timeUnit=" + timeUnit
+               + "acceptableLatencyDifference=" + MILLISECONDS.convert(acceptableLatencyDifferenceNanos, NANOSECONDS) + " ms"
                + '}';
     }
 
@@ -64,7 +64,7 @@ private List<ServerDescription> getServersWithAcceptableLatencyDifference(final
             if (!cur.isOk()) {
                 continue;
             }
-            if (cur.getAveragePingTimeNanos() - TimeUnit.NANOSECONDS.convert(acceptableLatencyDifference, timeUnit) <= bestPingTime) {
+            if (cur.getAveragePingTimeNanos() - acceptableLatencyDifferenceNanos <= bestPingTime) {
                 goodSecondaries.add(cur);
             }
         }
diff --git a/src/main/com/mongodb/MongosHAServerSelector.java b/src/main/com/mongodb/MongosHAServerSelector.java
@@ -22,8 +22,8 @@
 import java.util.List;
 import java.util.Set;
 
-class StickyHAShardedClusterServerSelector implements ServerSelector {
-    private ServerAddress stickyMongos;
+class MongosHAServerSelector implements ServerSelector {
+    private ServerAddress stickTo;
     private Set<ServerAddress> consideredServers = new HashSet<ServerAddress>();
 
     @Override
@@ -36,9 +36,9 @@ public List<ServerDescription> choose(final ClusterDescription clusterDescriptio
         Set<ServerAddress> okServers = getOkServers(clusterDescription);
 
         synchronized (this) {
-            if (!consideredServers.containsAll(okServers) || !okServers.contains(stickyMongos)) {
-                if (stickyMongos != null && !okServers.contains(stickyMongos)) {
-                    stickyMongos = null;
+            if (!consideredServers.containsAll(okServers) || !okServers.contains(stickTo)) {
+                if (stickTo != null && !okServers.contains(stickTo)) {
+                    stickTo = null;
                     consideredServers.clear();
                 }
                 ServerDescription fastestServer = null;
@@ -48,22 +48,22 @@ public List<ServerDescription> choose(final ClusterDescription clusterDescriptio
                     }
                 }
                 if (fastestServer != null) {
-                    stickyMongos = fastestServer.getAddress();
+                    stickTo = fastestServer.getAddress();
                     consideredServers.addAll(okServers);
                 }
             }
-            if (stickyMongos == null) {
+            if (stickTo == null) {
                 return Collections.emptyList();
             } else {
-                return Arrays.asList(clusterDescription.getByServerAddress(stickyMongos));
+                return Arrays.asList(clusterDescription.getByServerAddress(stickTo));
             }
         }
     }
 
     @Override
     public String toString() {
-        return "StickyHAShardedClusterServerSelector{"
-               + "stickyMongos=" + stickyMongos
+        return "MongosHAServerSelector{"
+               + (stickTo == null ? "" : "stickTo=" + stickTo)
                + '}';
     }
 
diff --git a/src/test/com/mongodb/MongosHAServerSelectorTest.java b/src/test/com/mongodb/MongosHAServerSelectorTest.java
@@ -34,16 +34,16 @@
 import static org.junit.Assert.assertEquals;
 
 
-public class StickyHAShardedClusterServerSelectorTest {
+public class MongosHAServerSelectorTest {
 
-    private StickyHAShardedClusterServerSelector selector;
+    private MongosHAServerSelector selector;
     private ServerDescription first;
     private ServerDescription secondConnecting;
     private ServerDescription secondConnected;
 
     @Before
     public void setUp() throws UnknownHostException {
-        selector = new StickyHAShardedClusterServerSelector();
+        selector = new MongosHAServerSelector();
         first = ServerDescription.builder()
                                                    .state(Connected)
                                                    .address(new ServerAddress())

Original file line number	Diff line number	Diff line change
`@@ -25,6 +25,7 @@`
`25`	`25`	`import java.util.logging.Logger;`
`26`	`26`
`27`	`27`	`import static java.lang.String.format;`
	`28`	`+import static java.util.concurrent.TimeUnit.MILLISECONDS;`
`28`	`29`	`import static java.util.concurrent.TimeUnit.NANOSECONDS;`
`29`	`30`	`import static org.bson.util.Assertions.isTrue;`
`30`	`31`	`import static org.bson.util.Assertions.notNull;`
`@@ -76,27 +77,24 @@ public Server getServer(final ServerSelector serverSelector, final long maxWaitT`
`76`	`77`	`}`
`77`	`78`
`78`	`79`	`if (!curDescription.isConnecting()) {`
`79`		`- throw new MongoServerSelectionException(`
`80`		`- format("Unable to connect to any server that satisfies the selector " +`
`81`		`- "%s", serverSelector));`
	`80`	`+ throw new MongoServerSelectionException(format("Unable to connect to any server that matches %s", serverSelector));`
`82`	`81`	`}`
`83`	`82`
`84`	`83`	`final long timeout = endTime - System.nanoTime();`
`85`	`84`
`86`	`85`	`LOGGER.info(format("No server chosen by %s from cluster description %s. Waiting for %d ms before timing out",`
`87`		`- serverSelector, curDescription, TimeUnit.MILLISECONDS.convert(timeout, NANOSECONDS)));`
	`86`	`+ serverSelector, curDescription, MILLISECONDS.convert(timeout, NANOSECONDS)));`
`88`	`87`
`89`	`88`	`if (!currentPhase.await(timeout, NANOSECONDS)) {`
`90`		`- throw new MongoTimeoutException(format("Timed out while waiting for a server that satisfies the selector: %s "`
`91`		`- + "after %d %s", serverSelector, timeout, NANOSECONDS));`
	`89`	`+ throw new MongoTimeoutException(format("Timed out while waiting for a server that matches %s after %d ms",`
	`90`	`+ serverSelector, MILLISECONDS.convert(timeout, NANOSECONDS)));`
`92`	`91`	`}`
`93`	`92`	`currentPhase = phase.get();`
`94`	`93`	`curDescription = description;`
`95`	`94`	`serverDescriptions = serverSelector.choose(curDescription);`
`96`	`95`	`}`
`97`	`96`	`} catch (InterruptedException e) {`
`98`		`- throw new MongoInterruptedException(format("Interrupted while waiting for a server that satisfies server selector %s ",`
`99`		`- serverSelector), e);`
	`97`	`+ throw new MongoInterruptedException(format("Interrupted while waiting for a server that matches %s ", serverSelector), e);`
`100`	`98`	`}`
`101`	`99`	`}`
`102`	`100`
`@@ -117,18 +115,18 @@ public ClusterDescription getDescription(final long maxWaitTime, final TimeUnit`
`117`	`115`	`final long timeout = endTime - System.nanoTime();`
`118`	`116`
`119`	`117`	`LOGGER.info(format("Cluster description not yet available. Waiting for %d ms before timing out",`
`120`		`- TimeUnit.MILLISECONDS.convert(timeout, NANOSECONDS)));`
	`118`	`+ MILLISECONDS.convert(timeout, NANOSECONDS)));`
`121`	`119`
`122`	`120`	`if (!currentPhase.await(timeout, NANOSECONDS)) {`
`123`		`- throw new MongoTimeoutException(format("Timed out while waiting for the cluster description after waiting %d %s",`
`124`		`- timeout, NANOSECONDS));`
	`121`	`+ throw new MongoTimeoutException(format("Timed out while waiting to connect after %d ms",`
	`122`	`+ MILLISECONDS.convert(timeout, NANOSECONDS)));`
`125`	`123`	`}`
`126`	`124`	`currentPhase = phase.get();`
`127`	`125`	`curDescription = description;`
`128`	`126`	`}`
`129`	`127`	`return curDescription;`
`130`	`128`	`} catch (InterruptedException e) {`
`131`		`- throw new MongoInterruptedException(format("Interrupted while waiting for the cluster description"), e);`
	`129`	`+ throw new MongoInterruptedException(format("Interrupted while waiting to connect"), e);`
`132`	`130`	`}`
`133`	`131`	`}`
`134`	`132`
Original file line number	Diff line number	Diff line change
`@@ -562,7 +562,7 @@ private synchronized ServerSelector getPrefixedServerSelector() {`
`562`	`562`	`if (prefixedServerSelector == null) {`
`563`	`563`	`ClusterDescription clusterDescription = getClusterDescription();`
`564`	`564`	`if (clusterDescription.getConnectionMode() == Multiple && clusterDescription.getType() == Sharded) {`
`565`		`- prefixedServerSelector = new StickyHAShardedClusterServerSelector();`
	`565`	`+ prefixedServerSelector = new MongosHAServerSelector();`
`566`	`566`	`} else {`
`567`	`567`	`prefixedServerSelector = new NoOpServerSelector();`
`568`	`568`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,8 +22,8 @@`
`22`	`22`	`import java.util.List;`
`23`	`23`	`import java.util.Set;`
`24`	`24`
`25`		`-class StickyHAShardedClusterServerSelector implements ServerSelector {`
`26`		`- private ServerAddress stickyMongos;`
	`25`	`+class MongosHAServerSelector implements ServerSelector {`
	`26`	`+ private ServerAddress stickTo;`
`27`	`27`	`private Set<ServerAddress> consideredServers = new HashSet<ServerAddress>();`
`28`	`28`
`29`	`29`	`@Override`
`@@ -36,9 +36,9 @@ public List<ServerDescription> choose(final ClusterDescription clusterDescriptio`
`36`	`36`	`Set<ServerAddress> okServers = getOkServers(clusterDescription);`
`37`	`37`
`38`	`38`	`synchronized (this) {`
`39`		`- if (!consideredServers.containsAll(okServers) \|\| !okServers.contains(stickyMongos)) {`
`40`		`- if (stickyMongos != null && !okServers.contains(stickyMongos)) {`
`41`		`- stickyMongos = null;`
	`39`	`+ if (!consideredServers.containsAll(okServers) \|\| !okServers.contains(stickTo)) {`
	`40`	`+ if (stickTo != null && !okServers.contains(stickTo)) {`
	`41`	`+ stickTo = null;`
`42`	`42`	`consideredServers.clear();`
`43`	`43`	`}`
`44`	`44`	`ServerDescription fastestServer = null;`
`@@ -48,22 +48,22 @@ public List<ServerDescription> choose(final ClusterDescription clusterDescriptio`
`48`	`48`	`}`
`49`	`49`	`}`
`50`	`50`	`if (fastestServer != null) {`
`51`		`- stickyMongos = fastestServer.getAddress();`
	`51`	`+ stickTo = fastestServer.getAddress();`
`52`	`52`	`consideredServers.addAll(okServers);`
`53`	`53`	`}`
`54`	`54`	`}`
`55`		`- if (stickyMongos == null) {`
	`55`	`+ if (stickTo == null) {`
`56`	`56`	`return Collections.emptyList();`
`57`	`57`	`} else {`
`58`		`- return Arrays.asList(clusterDescription.getByServerAddress(stickyMongos));`
	`58`	`+ return Arrays.asList(clusterDescription.getByServerAddress(stickTo));`
`59`	`59`	`}`
`60`	`60`	`}`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`@Override`
`64`	`64`	`public String toString() {`
`65`		`- return "StickyHAShardedClusterServerSelector{"`
`66`		`- + "stickyMongos=" + stickyMongos`
	`65`	`+ return "MongosHAServerSelector{"`
	`66`	`+ + (stickTo == null ? "" : "stickTo=" + stickTo)`
`67`	`67`	`+ '}';`
`68`	`68`	`}`
`69`	`69`