Split up some of the calls involved in resolving peered zones to make them easier to override.

git-svn-id: svn+ssh://src.earth.threerings.net/vilya/trunk@919 c613c5cb-e716-0410-b11b-feb51c14d237

src/java/com/threerings/whirled/zone/peer/server/PeeredZoneRegistry.java

@@ -131,49 +131,22 @@ public abstract class PeeredZoneRegistry extends ZoneRegistry
                 listener.zoneOnNode(nodeInfo); // somewhere else, pass the buck
             }
             return;
-        }
 
+        } else {
+            resolveNewZone(zoneId, listener);
+        }
+    }
+
+    /**
+     * Resolve a zone that's not yet hosted.
+     */
+    protected void resolveNewZone (final int zoneId, final PeerZoneResolutionListener listener)
+    {
         // otherwise the zone is not resolved here nor there; so we claim the zone by acquiring a
         // distributed lock and then resolve it locally
         _peerMgr.acquireLock(ZonePeerManager.getZoneLock(zoneId), new ResultListener<String>() {
             public void requestCompleted (String nodeName) {
-                if (_peerMgr.getNodeObject().nodeName.equals(nodeName)) {
+                resolveZoneForNode(zoneId, nodeName, listener);
-                    log.debug("Got lock, resolving zone", "zoneId", zoneId);
-                    resolveZone(zoneId, new ResolutionListener() {
-                        public void zoneWasResolved (ZoneSummary zonesum) {
-                            releaseLock();
-                            _peerMgr.zoneDidStartup(zonesum.zoneId, zonesum.name);
-                            PeerZoneShutdownListener shutdowner = new PeerZoneShutdownListener() {
-                                public void zoneDidShutdown (int zoneId) {
-                                    _peerMgr.zoneDidShutdown(zoneId);
-                                }
-                            };
-                            getZoneManager(zonesum.zoneId).setShutdownListener(
-                                zonesum.zoneId, shutdowner);
-                            listener.zoneWasResolved(zonesum);
-                        }
-                        public void zoneFailedToResolve (int zoneId, Exception reason) {
-                            releaseLock();
-                            listener.zoneFailedToResolve(zoneId, reason);
-                        }
-                        protected void releaseLock () {
-                            _peerMgr.releaseLock(ZonePeerManager.getZoneLock(zoneId),
-                                new ResultListener.NOOP<String>());
-                        }
-                    });
-
-                } else {
-                    // we didn't get the lock, so let's see what happened by re-checking
-                    Tuple<String, HostedZone> nodeInfo = _peerMgr.getZoneHost(zoneId);
-                    if (nodeName == null || nodeInfo == null || !nodeName.equals(nodeInfo.left)) {
-                        log.warning("Zone resolved on wacked-out node?",
-                            "zoneId", zoneId, "nodeName", nodeName, "nodeInfo", nodeInfo);
-                        listener.zoneFailedToResolve(zoneId,
-                            new Exception("Zone on bogus host node"));
-                    } else {
-                        listener.zoneOnNode(nodeInfo); // somewhere else
-                    }
-                }
             }
             public void requestFailed (Exception cause) {
                 log.warning("Failed to acquire zone resolution lock", "id", zoneId, cause);
@@ -182,6 +155,51 @@ public abstract class PeeredZoneRegistry extends ZoneRegistry
         });
     }
 
+    /**
+     * Resolve a zone that's hosted or to-be-hosted on a zone.
+     */
+    protected void resolveZoneForNode (final int zoneId, String nodeName,
+        final PeerZoneResolutionListener listener)
+    {
+        if (_peerMgr.getNodeObject().nodeName.equals(nodeName)) {
+            log.debug("Got lock, resolving zone", "zoneId", zoneId);
+            resolveZone(zoneId, new ResolutionListener() {
+                public void zoneWasResolved (ZoneSummary zonesum) {
+                    releaseLock();
+                    _peerMgr.zoneDidStartup(zonesum.zoneId, zonesum.name);
+                    PeerZoneShutdownListener shutdowner = new PeerZoneShutdownListener() {
+                        public void zoneDidShutdown (int zoneId) {
+                            _peerMgr.zoneDidShutdown(zoneId);
+                        }
+                    };
+                    getZoneManager(zonesum.zoneId).setShutdownListener(
+                        zonesum.zoneId, shutdowner);
+                    listener.zoneWasResolved(zonesum);
+                }
+                public void zoneFailedToResolve (int zoneId, Exception reason) {
+                    releaseLock();
+                    listener.zoneFailedToResolve(zoneId, reason);
+                }
+                protected void releaseLock () {
+                    _peerMgr.releaseLock(ZonePeerManager.getZoneLock(zoneId),
+                        new ResultListener.NOOP<String>());
+                }
+            });
+
+        } else {
+            // we didn't get the lock, so let's see what happened by re-checking
+            Tuple<String, HostedZone> nodeInfo = _peerMgr.getZoneHost(zoneId);
+            if (nodeName == null || nodeInfo == null || !nodeName.equals(nodeInfo.left)) {
+                log.warning("Zone resolved on wacked-out node?",
+                    "zoneId", zoneId, "nodeName", nodeName, "nodeInfo", nodeInfo);
+                listener.zoneFailedToResolve(zoneId,
+                    new Exception("Zone on bogus host node"));
+            } else {
+                listener.zoneOnNode(nodeInfo); // somewhere else
+            }
+        }
+    }
+
     /**
      * Pass on that the zone has shutdown.
      */