You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@sling.apache.org by st...@apache.org on 2015/09/22 14:35:24 UTC
svn commit: r1704604 [2/2] - in
/sling/trunk/bundles/extensions/discovery/impl/src:
main/java/org/apache/sling/discovery/impl/
main/java/org/apache/sling/discovery/impl/cluster/
main/java/org/apache/sling/discovery/impl/cluster/voting/ main/java/org/ap...
Modified: sling/trunk/bundles/extensions/discovery/impl/src/test/java/org/apache/sling/discovery/impl/cluster/TopologyEventTest.java
URL: http://svn.apache.org/viewvc/sling/trunk/bundles/extensions/discovery/impl/src/test/java/org/apache/sling/discovery/impl/cluster/TopologyEventTest.java?rev=1704604&r1=1704603&r2=1704604&view=diff
==============================================================================
--- sling/trunk/bundles/extensions/discovery/impl/src/test/java/org/apache/sling/discovery/impl/cluster/TopologyEventTest.java (original)
+++ sling/trunk/bundles/extensions/discovery/impl/src/test/java/org/apache/sling/discovery/impl/cluster/TopologyEventTest.java Tue Sep 22 12:35:19 2015
@@ -20,9 +20,9 @@ package org.apache.sling.discovery.impl.
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.fail;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
-import java.util.Iterator;
import java.util.UUID;
import org.apache.log4j.Level;
@@ -76,6 +76,7 @@ public class TopologyEventTest {
/**
* Tests the fact that the INIT event is delayed until voting has succeeded
+ * (which is the default with SLIGN-5030 and SLING-4959
* @throws Throwable
*/
@Test
@@ -83,7 +84,7 @@ public class TopologyEventTest {
logger.info("testDelayedInitEvent: start");
instance1 = Instance.newStandaloneInstance("/var/discovery/impl/",
"firstInstanceA", true, 20 /* heartbeat-timeout */, 3 /*min event delay*/,
- UUID.randomUUID().toString(), true /*delayInitEventUntilVoted*/);
+ UUID.randomUUID().toString());
AssertingTopologyEventListener l1 = new AssertingTopologyEventListener("instance1.l1");
instance1.bindTopologyEventListener(l1);
logger.info("testDelayedInitEvent: instance1 created, no events expected yet. slingId="+instance1.slingId);
@@ -114,7 +115,7 @@ public class TopologyEventTest {
logger.info("testDelayedInitEvent: creating instance2");
instance2 = Instance.newClusterInstance("/var/discovery/impl/",
- "secondInstanceB", instance1, false, 20, 3, UUID.randomUUID().toString(), true);
+ "secondInstanceB", instance1, false, 20, 3, UUID.randomUUID().toString());
logger.info("testDelayedInitEvent: instance2 created with slingId="+instance2.slingId);
AssertingTopologyEventListener l2 = new AssertingTopologyEventListener("instance2.l2");
instance2.bindTopologyEventListener(l2);
@@ -182,146 +183,68 @@ public class TopologyEventTest {
logger.info("testDelayedInitEvent: end");
}
- /**
- * Tests the fact that the INIT event is NOT delayed (until voting has succeeded)
- * when the config is set accordingly (ie: config test).
- * @throws Throwable
- */
@Test
- public void testNonDelayedInitEvent() throws Throwable {
- logger.info("testNonDelayedInitEvent: start");
+ public void testGetDuringDelay() throws Throwable {
instance1 = Instance.newStandaloneInstance("/var/discovery/impl/",
- "firstInstanceB", true, 20 /* heartbeat-timeout */, 10 /*min event delay*/,
- UUID.randomUUID().toString(), false /*delayInitEventUntilVoted*/);
- AssertingTopologyEventListener l1 = new AssertingTopologyEventListener("instance1.l1") {
- private volatile boolean firstEvent = false;
- @Override
- public void handleTopologyEvent(TopologyEvent event) {
- super.handleTopologyEvent(event);
- if (firstEvent) {
- // only handle the first event - that one must be INIT with isCurrent==false
- assertFalse(event.getNewView().isCurrent());
- firstEvent = false;
- }
- }
- };
- l1.addExpected(Type.TOPOLOGY_INIT);
+ "firstInstanceA", true, 20 /* heartbeat-timeout */, 6 /*min event delay*/,
+ UUID.randomUUID().toString());
+ AssertingTopologyEventListener l1 = new AssertingTopologyEventListener("instance1.l1");
+ l1.addExpected(TopologyEvent.Type.TOPOLOGY_INIT);
instance1.bindTopologyEventListener(l1);
-
- Thread.sleep(500); // SLING-4755: async event sending requires some minimal wait time nowadays
- // when delayInitEventUntilVoted is disabled, the INIT event is sent immediately
- assertEquals(1, l1.getEvents().size());
- assertEquals(0, l1.getUnexpectedCount());
- assertEquals(0, l1.getRemainingExpectedCount());
+ TopologyView earlyTopo = instance1.getDiscoveryService().getTopology();
+ assertNotNull(earlyTopo);
+ assertFalse(earlyTopo.isCurrent());
+ assertEquals(1, earlyTopo.getInstances().size());
+
+ for(int i=0; i<4; i++) {
+ instance1.runHeartbeatOnce();
+ Thread.sleep(125);
+ }
+ TopologyView secondTopo = instance1.getDiscoveryService().getTopology();
+ assertEquals(1, secondTopo.getInstances().size());
+ assertEquals(instance1.getSlingId(), secondTopo.getInstances().iterator().next().getSlingId());
+ assertTrue(secondTopo.isCurrent());
+ instance1.dumpRepo();
+ assertEquals(earlyTopo.getLocalInstance().getClusterView().getId(),
+ secondTopo.getLocalInstance().getClusterView().getId());
- instance1.runHeartbeatOnce();
- Thread.sleep(1000);
- // no further event now:
- assertEquals(1, l1.getEvents().size());
- assertEquals(0, l1.getUnexpectedCount());
- assertEquals(0, l1.getRemainingExpectedCount());
-
- instance1.runHeartbeatOnce();
- // still no further event, only INIT
- assertEquals(1, l1.getEvents().size());
+ Thread.sleep(500);
+ // should have gotten the INIT, hence 0 remaining expected events
assertEquals(0, l1.getRemainingExpectedCount());
assertEquals(0, l1.getUnexpectedCount());
+ l1.addExpected(TopologyEvent.Type.TOPOLOGY_CHANGING);
instance2 = Instance.newClusterInstance("/var/discovery/impl/",
- "secondInstanceB", instance1, false, 20, 10, UUID.randomUUID().toString(), false);
- AssertingTopologyEventListener l2 = new AssertingTopologyEventListener("instance2.l2");
- l2.addExpected(Type.TOPOLOGY_INIT);
+ "secondInstanceB", instance1, false, 20, 1, UUID.randomUUID().toString());
+ AssertingTopologyEventListener l2 = new AssertingTopologyEventListener("instance2.l1");
+ l2.addExpected(TopologyEvent.Type.TOPOLOGY_INIT);
instance2.bindTopologyEventListener(l2);
- AssertingTopologyEventListener l1Two = new AssertingTopologyEventListener("instance1.l1Two");
- l1Two.addExpected(Type.TOPOLOGY_INIT);
- instance1.bindTopologyEventListener(l1Two);
-
- Thread.sleep(500); // SLING-4755: async event sending requires some minimal wait time nowadays
- // just because instance2 is started doesn't kick off any events yet
- // since instance2 didn't send heartbeats yet
- assertEquals(1, l1.getEvents().size()); // one event
- assertEquals(0, l1.getRemainingExpectedCount()); // the expected one
- assertEquals(0, l1.getUnexpectedCount());
- assertEquals(1, l2.getEvents().size());
- assertEquals(0, l2.getUnexpectedCount());
- assertEquals(1, l1Two.getEvents().size());
- assertEquals(0, l1Two.getRemainingExpectedCount()); // the expected one
- assertEquals(0, l1Two.getUnexpectedCount());
+ for(int i=0; i<4; i++) {
+ instance2.runHeartbeatOnce();
+ instance1.runHeartbeatOnce();
+ Thread.sleep(750);
+ }
- // one heartbeat doesn't change the history yet
- instance1.runHeartbeatOnce();
- instance2.runHeartbeatOnce();
- assertEquals(1, l1.getEvents().size()); // one event
assertEquals(0, l1.getUnexpectedCount());
- assertEquals(1, l2.getEvents().size());
- assertEquals(0, l2.getUnexpectedCount());
- assertEquals(1, l1Two.getEvents().size());
- assertEquals(0, l1Two.getUnexpectedCount());
+ TopologyView topo2 = instance2.getDiscoveryService().getTopology();
+ assertTrue(topo2.isCurrent());
+ assertEquals(2, topo2.getInstances().size());
+ TopologyView topo1 = instance1.getDiscoveryService().getTopology();
+ assertTrue(topo1.isCurrent());
+ assertEquals(2, topo1.getInstances().size());
- // the second & third heartbeat though triggers the voting etc
- l1.addExpected(Type.TOPOLOGY_CHANGING);
- l1Two.addExpected(Type.TOPOLOGY_CHANGING);
- l2.addExpected(Type.TOPOLOGY_CHANGING);
- instance1.runHeartbeatOnce();
- instance2.runHeartbeatOnce();
- Thread.sleep(1500);
- instance1.runHeartbeatOnce();
- instance2.runHeartbeatOnce();
- Thread.sleep(1500);
- logger.info("testNonDelayedInitEvent: instance1: "+instance1.slingId);
- logger.info("testNonDelayedInitEvent: instance2: "+instance2.slingId);
- instance1.dumpRepo();
- assertEquals(0, l1.getUnexpectedCount());
- assertEquals(2, l1.getEvents().size());
- assertEquals(0, l2.getUnexpectedCount());
- assertEquals(2, l2.getEvents().size());
- assertEquals(0, l1Two.getUnexpectedCount());
- assertEquals(2, l1Two.getEvents().size());
-
- // now meanwhile - for SLING-4638 : register a listener 'late':
- // this one should get an INIT with a newView that has isCurrent()==false
- AssertingTopologyEventListener late = new AssertingTopologyEventListener("instance1.late") {
- @Override
- public void handleTopologyEvent(TopologyEvent event) {
- super.handleTopologyEvent(event);
- if (event.getType()==Type.TOPOLOGY_INIT) {
- // also check if the newView has isCurrent==false
- if (event.getNewView().isCurrent()) {
- fail("for TOPOLOGY_INIT: new view is expected to be not current, but it is: "+event);
- }
- // plus lets now directly ask the discovery service for getTopology and check that
- TopologyView topology = instance1.getDiscoveryService().getTopology();
- if (topology.isCurrent()) {
- fail("for TOPOLOGY_INIT: discovery service is expected to have a topology that is not current, but it is: "+topology);
- }
- }
- }
- };
- late.addExpected(Type.TOPOLOGY_INIT);
- instance1.bindTopologyEventListener(late);
-
- // wait until CHANGED is sent - which is 10 sec after CHANGING - we already waited 3 sec above, so 12sec more should be enough
- l1.addExpected(Type.TOPOLOGY_CHANGED);
- l1Two.addExpected(Type.TOPOLOGY_CHANGED);
- l2.addExpected(Type.TOPOLOGY_CHANGED);
- Thread.sleep(12000);
- final Iterator<TopologyEvent> it = l1.getEvents().iterator();
- while(it.hasNext()) {
- final TopologyEvent e = it.next();
- logger.info("testNonDelayedInitEvent: got event: "+e);
- }
+ l1.addExpected(TopologyEvent.Type.TOPOLOGY_CHANGED);
+ Thread.sleep(5000);
+ assertEquals(0, l1.getRemainingExpectedCount());
assertEquals(0, l1.getUnexpectedCount());
- assertEquals(3, l1.getEvents().size()); // one event
+ assertEquals(0, l2.getRemainingExpectedCount());
assertEquals(0, l2.getUnexpectedCount());
- assertEquals(3, l2.getEvents().size());
- assertEquals(0, l1Two.getUnexpectedCount());
- assertEquals(3, l1Two.getEvents().size());
- if (late.getErrorMsg()!=null) {
- fail(late.getErrorMsg());
- }
- logger.info("testNonDelayedInitEvent: end");
+ assertTrue(instance2.getDiscoveryService().getTopology().isCurrent());
+ assertEquals(2, instance2.getDiscoveryService().getTopology().getInstances().size());
+ assertTrue(instance1.getDiscoveryService().getTopology().isCurrent());
+ assertEquals(2, instance1.getDiscoveryService().getTopology().getInstances().size());
}
-}
+}
\ No newline at end of file
Added: sling/trunk/bundles/extensions/discovery/impl/src/test/java/org/apache/sling/discovery/impl/common/heartbeat/HeartbeatTest.java
URL: http://svn.apache.org/viewvc/sling/trunk/bundles/extensions/discovery/impl/src/test/java/org/apache/sling/discovery/impl/common/heartbeat/HeartbeatTest.java?rev=1704604&view=auto
==============================================================================
--- sling/trunk/bundles/extensions/discovery/impl/src/test/java/org/apache/sling/discovery/impl/common/heartbeat/HeartbeatTest.java (added)
+++ sling/trunk/bundles/extensions/discovery/impl/src/test/java/org/apache/sling/discovery/impl/common/heartbeat/HeartbeatTest.java Tue Sep 22 12:35:19 2015
@@ -0,0 +1,430 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.sling.discovery.impl.common.heartbeat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import java.io.Serializable;
+import java.util.Date;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Set;
+import java.util.UUID;
+
+import org.apache.sling.commons.scheduler.Scheduler;
+import org.apache.sling.discovery.TopologyEvent;
+import org.apache.sling.discovery.TopologyEventListener;
+import org.apache.sling.discovery.TopologyView;
+import org.apache.sling.discovery.impl.DiscoveryServiceImpl;
+import org.apache.sling.discovery.impl.setup.Instance;
+import org.junit.After;
+import org.junit.Test;
+import org.slf4j.LoggerFactory;
+
+public class HeartbeatTest {
+
+ class SimpleTopologyEventListener implements TopologyEventListener {
+
+ private TopologyEvent lastEvent;
+ private int eventCount;
+ private final String name;
+
+ public SimpleTopologyEventListener(String name) {
+ this.name = name;
+ }
+
+ @Override
+ public void handleTopologyEvent(TopologyEvent event) {
+ String msg = event.toString();
+ TopologyView newView = event.getNewView();
+ switch(event.getType()) {
+ case PROPERTIES_CHANGED: {
+ msg = String.valueOf(TopologyEvent.Type.PROPERTIES_CHANGED);
+ break;
+ }
+ case TOPOLOGY_CHANGED: {
+ msg = TopologyEvent.Type.TOPOLOGY_CHANGED + ", newView contains "+newView.getInstances().size()+", newView.isCurrent="+newView.isCurrent();
+ break;
+ }
+ case TOPOLOGY_CHANGING: {
+ msg = TopologyEvent.Type.TOPOLOGY_CHANGING + ", oldView contained "+event.getOldView().getInstances().size()+", oldView.isCurrent="+event.getOldView().isCurrent();
+ break;
+ }
+ case TOPOLOGY_INIT: {
+ if (newView==null) {
+ msg = TopologyEvent.Type.TOPOLOGY_INIT + ", newView contains null: "+newView;
+ } else if (newView.getInstances()==null) {
+ msg = TopologyEvent.Type.TOPOLOGY_INIT + ", newView contains no instances:"+newView+", newView.isCurrent="+newView.isCurrent();
+ } else {
+ msg = TopologyEvent.Type.TOPOLOGY_INIT + ", newView contains "+newView.getInstances().size()+", newView.isCurrent="+newView.isCurrent();
+ }
+ break;
+ }
+ }
+ LoggerFactory.getLogger(this.getClass()).info("handleTopologyEvent["+name+"]: "+msg);
+ lastEvent = event;
+ eventCount++;
+ }
+
+ public int getEventCount() {
+ return eventCount;
+ }
+
+ public TopologyEvent getLastEvent() {
+ return lastEvent;
+ }
+
+ }
+
+ Set<Instance> instances = new HashSet<Instance>();
+
+ @After
+ public void tearDown() throws Exception {
+ Instance.setSingletonScheduler(null);
+ Iterator<Instance> it = instances.iterator();
+ while(it.hasNext()) {
+ Instance i = it.next();
+ i.stop();
+ }
+ }
+
+ @Test
+ public void testPartitioning() throws Throwable {
+ doTestPartitioning(true);
+ }
+
+ @Test
+ public void testPartitioningWithFailingScheduler() throws Throwable {
+ installFailingScheduler();
+ doTestPartitioning(false);
+ }
+
+ public void doTestPartitioning(boolean scheduler) throws Throwable {
+ Instance slowMachine = Instance.newStandaloneInstance("/var/discovery/impl/", "slow", true, 5 /*5sec timeout*/,
+ 999 /* 999sec interval: to disable it*/, 0, UUID.randomUUID().toString());
+ assertEquals(1, slowMachine.getDiscoveryService().getTopology().getInstances().size());
+ assertEquals(slowMachine.getSlingId(), slowMachine.getDiscoveryService().getTopology().getInstances().iterator().next().getSlingId());
+ instances.add(slowMachine);
+ SimpleTopologyEventListener slowListener = new SimpleTopologyEventListener("slow");
+ slowMachine.bindTopologyEventListener(slowListener);
+ Instance fastMachine1 = Instance.newClusterInstance("/var/discovery/impl/", "fast1", slowMachine, false, 5, 1, 0);
+ assertEquals(1, fastMachine1.getDiscoveryService().getTopology().getInstances().size());
+ assertEquals(fastMachine1.getSlingId(), fastMachine1.getDiscoveryService().getTopology().getInstances().iterator().next().getSlingId());
+ instances.add(fastMachine1);
+ SimpleTopologyEventListener fastListener1 = new SimpleTopologyEventListener("fast1");
+ fastMachine1.bindTopologyEventListener(fastListener1);
+ Instance fastMachine2 = Instance.newClusterInstance("/var/discovery/impl/", "fast2", slowMachine, false, 5, 1, 0);
+ assertEquals(1, fastMachine2.getDiscoveryService().getTopology().getInstances().size());
+ assertEquals(fastMachine2.getSlingId(), fastMachine2.getDiscoveryService().getTopology().getInstances().iterator().next().getSlingId());
+ instances.add(fastMachine2);
+ SimpleTopologyEventListener fastListener2 = new SimpleTopologyEventListener("fast2");
+ fastMachine2.bindTopologyEventListener(fastListener2);
+ Instance fastMachine3 = Instance.newClusterInstance("/var/discovery/impl/", "fast3", slowMachine, false, 5, 1, 0);
+ assertEquals(1, fastMachine3.getDiscoveryService().getTopology().getInstances().size());
+ assertEquals(fastMachine3.getSlingId(), fastMachine3.getDiscoveryService().getTopology().getInstances().iterator().next().getSlingId());
+ instances.add(fastMachine3);
+ SimpleTopologyEventListener fastListener3 = new SimpleTopologyEventListener("fast3");
+ fastMachine3.bindTopologyEventListener(fastListener3);
+ Instance fastMachine4 = Instance.newClusterInstance("/var/discovery/impl/", "fast4", slowMachine, false, 5, 1, 0);
+ assertEquals(1, fastMachine4.getDiscoveryService().getTopology().getInstances().size());
+ assertEquals(fastMachine4.getSlingId(), fastMachine4.getDiscoveryService().getTopology().getInstances().iterator().next().getSlingId());
+ instances.add(fastMachine4);
+ SimpleTopologyEventListener fastListener4 = new SimpleTopologyEventListener("fast4");
+ fastMachine4.bindTopologyEventListener(fastListener4);
+
+ HeartbeatHandler hhSlow = slowMachine.getHeartbeatHandler();
+ for(int i=0; i<3; i++) {
+ hhSlow.issueHeartbeat();
+ hhSlow.checkView();
+ if (!scheduler) {
+ fastMachine1.getHeartbeatHandler().issueHeartbeat();
+ fastMachine1.getHeartbeatHandler().checkView();
+ fastMachine2.getHeartbeatHandler().issueHeartbeat();
+ fastMachine2.getHeartbeatHandler().checkView();
+ fastMachine3.getHeartbeatHandler().issueHeartbeat();
+ fastMachine3.getHeartbeatHandler().checkView();
+ fastMachine4.getHeartbeatHandler().issueHeartbeat();
+ fastMachine4.getHeartbeatHandler().checkView();
+ }
+ Thread.sleep(1000);
+ }
+
+ // at this stage the 4 fast plus the slow instance should all see each other
+ assertNotNull(fastListener1.getLastEvent());
+ assertEquals(TopologyEvent.Type.TOPOLOGY_INIT, fastListener1.getLastEvent().getType());
+ assertEquals(5, fastListener1.getLastEvent().getNewView().getInstances().size());
+ assertNotNull(fastListener2.getLastEvent());
+ assertEquals(TopologyEvent.Type.TOPOLOGY_INIT, fastListener2.getLastEvent().getType());
+ assertEquals(5, fastListener2.getLastEvent().getNewView().getInstances().size());
+ assertNotNull(fastListener3.getLastEvent());
+ assertEquals(TopologyEvent.Type.TOPOLOGY_INIT, fastListener3.getLastEvent().getType());
+ assertEquals(5, fastListener3.getLastEvent().getNewView().getInstances().size());
+ assertNotNull(fastListener4.getLastEvent());
+ assertEquals(TopologyEvent.Type.TOPOLOGY_INIT, fastListener4.getLastEvent().getType());
+ assertEquals(5, fastListener4.getLastEvent().getNewView().getInstances().size());
+ assertNotNull(slowListener.getLastEvent());
+ assertEquals(TopologyEvent.Type.TOPOLOGY_INIT, slowListener.getLastEvent().getType());
+ assertEquals(5, slowListener.getLastEvent().getNewView().getInstances().size());
+
+ // after 7sec the slow instance' heartbeat should have timed out
+ for(int i=0; i<7; i++) {
+ if (!scheduler) {
+ fastMachine1.getHeartbeatHandler().issueHeartbeat();
+ fastMachine1.getHeartbeatHandler().checkView();
+ fastMachine2.getHeartbeatHandler().issueHeartbeat();
+ fastMachine2.getHeartbeatHandler().checkView();
+ fastMachine3.getHeartbeatHandler().issueHeartbeat();
+ fastMachine3.getHeartbeatHandler().checkView();
+ fastMachine4.getHeartbeatHandler().issueHeartbeat();
+ fastMachine4.getHeartbeatHandler().checkView();
+ }
+ Thread.sleep(1000);
+ }
+
+ // so the fast listeners should only see 4 instances remaining
+ for(int i=0; i<5; i++) {
+ Thread.sleep(2000);
+ assertEquals(TopologyEvent.Type.TOPOLOGY_CHANGED, fastListener1.getLastEvent().getType());
+ assertEquals(4, fastListener1.getLastEvent().getNewView().getInstances().size());
+ assertEquals(TopologyEvent.Type.TOPOLOGY_CHANGED, fastListener2.getLastEvent().getType());
+ assertEquals(4, fastListener2.getLastEvent().getNewView().getInstances().size());
+ assertEquals(TopologyEvent.Type.TOPOLOGY_CHANGED, fastListener3.getLastEvent().getType());
+ assertEquals(4, fastListener3.getLastEvent().getNewView().getInstances().size());
+ assertEquals(TopologyEvent.Type.TOPOLOGY_CHANGED, fastListener4.getLastEvent().getType());
+ assertEquals(4, fastListener4.getLastEvent().getNewView().getInstances().size());
+
+ // and the slow instance should be isolated
+ assertFalse(slowMachine.getDiscoveryService().getTopology().isCurrent());
+ assertEquals(5, slowMachine.getDiscoveryService().getTopology().getInstances().size());
+ if (i==0) {
+ assertEquals(TopologyEvent.Type.TOPOLOGY_INIT, slowListener.getLastEvent().getType());
+ } else {
+ assertEquals(TopologyEvent.Type.TOPOLOGY_CHANGING, slowListener.getLastEvent().getType());
+ }
+ //TODO but only after 'handlePotentialTopologyChange' is called
+ // which either happens via handleTopologyChanged (via the TopologyChangeHandler)
+ // or via updateProperties
+ DiscoveryServiceImpl slowDisco = (DiscoveryServiceImpl) slowMachine.getDiscoveryService();
+ slowDisco.updateProperties();
+ // that should have triggered an async event - which takes a little moment
+ Thread.sleep(200);
+ assertEquals(TopologyEvent.Type.TOPOLOGY_CHANGING, slowListener.getLastEvent().getType());
+ assertEquals(2, slowListener.getEventCount());
+ TopologyView slowTopo = slowMachine.getDiscoveryService().getTopology();
+ assertNotNull(slowTopo);
+ assertFalse(slowTopo.isCurrent());
+ assertEquals(5, slowTopo.getInstances().size());
+ }
+
+ for(int i=0; i<3; i++) {
+ hhSlow.issueHeartbeat();
+ hhSlow.checkView();
+ if (!scheduler) {
+ fastMachine1.getHeartbeatHandler().issueHeartbeat();
+ fastMachine1.getHeartbeatHandler().checkView();
+ fastMachine2.getHeartbeatHandler().issueHeartbeat();
+ fastMachine2.getHeartbeatHandler().checkView();
+ fastMachine3.getHeartbeatHandler().issueHeartbeat();
+ fastMachine3.getHeartbeatHandler().checkView();
+ fastMachine4.getHeartbeatHandler().issueHeartbeat();
+ fastMachine4.getHeartbeatHandler().checkView();
+ }
+ Thread.sleep(1000);
+ }
+
+ // now all should be in one cluster again
+ assertEquals(TopologyEvent.Type.TOPOLOGY_CHANGED, fastListener1.getLastEvent().getType());
+ assertEquals(5, fastListener1.getLastEvent().getNewView().getInstances().size());
+ assertEquals(TopologyEvent.Type.TOPOLOGY_CHANGED, fastListener2.getLastEvent().getType());
+ assertEquals(5, fastListener2.getLastEvent().getNewView().getInstances().size());
+ assertEquals(TopologyEvent.Type.TOPOLOGY_CHANGED, fastListener3.getLastEvent().getType());
+ assertEquals(5, fastListener3.getLastEvent().getNewView().getInstances().size());
+ assertEquals(TopologyEvent.Type.TOPOLOGY_CHANGED, fastListener4.getLastEvent().getType());
+ assertEquals(5, fastListener4.getLastEvent().getNewView().getInstances().size());
+ assertEquals(TopologyEvent.Type.TOPOLOGY_CHANGED, slowListener.getLastEvent().getType());
+ assertEquals(5, slowListener.getLastEvent().getNewView().getInstances().size());
+ }
+
+ /**
+ * This tests the case where one machine is slow with sending heartbeats
+ * and should thus trigger the second, fast machine to kick it out of the topology.
+ * But the slow one should also get a TOPOLOGY_CHANGING but just not get a
+ * TOPOLOGY_CHANGED until it finally sends heartbeats again and the voting can
+ * happen again.
+ */
+ @Test
+ public void testSlowAndFastMachine() throws Throwable {
+ doTestSlowAndFastMachine();
+ }
+
+ @Test
+ public void testSlowAndFastMachineWithFailingScheduler() throws Throwable {
+ installFailingScheduler();
+ doTestSlowAndFastMachine();
+ }
+
+ public void doTestSlowAndFastMachine() throws Throwable {
+ Instance slowMachine = Instance.newStandaloneInstance("/var/discovery/impl/", "slow", true, 5 /*5sec timeout*/,
+ 999 /* 999sec interval: to disable it*/, 0, UUID.randomUUID().toString());
+ instances.add(slowMachine);
+ SimpleTopologyEventListener slowListener = new SimpleTopologyEventListener("slow");
+ slowMachine.bindTopologyEventListener(slowListener);
+ Instance fastMachine = Instance.newClusterInstance("/var/discovery/impl/", "fast", slowMachine, false, 5, 999, 0);
+ instances.add(fastMachine);
+ SimpleTopologyEventListener fastListener = new SimpleTopologyEventListener("fast");
+ fastMachine.bindTopologyEventListener(fastListener);
+ HeartbeatHandler hhSlow = slowMachine.getHeartbeatHandler();
+ HeartbeatHandler hhFast = fastMachine.getHeartbeatHandler();
+
+ Thread.sleep(1000);
+ assertFalse(fastMachine.getDiscoveryService().getTopology().isCurrent());
+ assertFalse(slowMachine.getDiscoveryService().getTopology().isCurrent());
+ assertNull(fastListener.getLastEvent());
+ assertNull(slowListener.getLastEvent());
+
+ // make few rounds of heartbeats so that the two instances see each other
+ for(int i=0; i<5; i++) {
+ hhSlow.issueHeartbeat();
+ hhSlow.checkView();
+ hhFast.issueHeartbeat();
+ hhFast.checkView();
+ Thread.sleep(100);
+ }
+ slowMachine.dumpRepo();
+
+ assertEquals(2, slowMachine.getDiscoveryService().getTopology().getInstances().size());
+ assertEquals(2, fastMachine.getDiscoveryService().getTopology().getInstances().size());
+ assertEquals(TopologyEvent.Type.TOPOLOGY_INIT, fastListener.getLastEvent().getType());
+ assertEquals(1, fastListener.getEventCount());
+ assertEquals(TopologyEvent.Type.TOPOLOGY_INIT, slowListener.getLastEvent().getType());
+ assertEquals(1, slowListener.getEventCount());
+
+ // now let the slow machine be slow while the fast one updates as expected
+ hhSlow.issueHeartbeat();
+ for(int i=0; i<6; i++) {
+ Thread.sleep(1500);
+ hhFast.issueHeartbeat();
+ hhFast.checkView();
+ }
+ fastMachine.dumpRepo();
+ hhFast.checkView(); // one more for the start of the vote
+ fastMachine.dumpRepo();
+ hhFast.checkView(); // and one for the promotion
+
+ // after 9 sec hhSlow's heartbeat will have timed out, so hhFast will not see hhSlow anymore
+ fastMachine.dumpRepo();
+ assertEquals(TopologyEvent.Type.TOPOLOGY_CHANGED, fastListener.getLastEvent().getType());
+ assertEquals(3, fastListener.getEventCount());
+ assertEquals(1, fastMachine.getDiscoveryService().getTopology().getInstances().size());
+
+ TopologyView topo = slowMachine.getDiscoveryService().getTopology();
+ assertFalse(topo.isCurrent());
+
+ // after those 6 sec, hhSlow does the check (6sec between heartbeat and check)
+ hhSlow.checkView();
+ slowMachine.dumpRepo();
+ hhSlow.issueHeartbeat();
+ assertEquals(TopologyEvent.Type.TOPOLOGY_CHANGED, fastListener.getLastEvent().getType());
+ assertEquals(3, fastListener.getEventCount());
+ assertEquals(TopologyEvent.Type.TOPOLOGY_CHANGING, slowListener.getLastEvent().getType());
+ assertEquals(2, slowListener.getEventCount());
+ Thread.sleep(8000);
+ // even after 8 sec the slow lsitener did not send a TOPOLOGY_CHANGED yet
+ assertEquals(TopologyEvent.Type.TOPOLOGY_CHANGING, slowListener.getLastEvent().getType());
+ assertFalse(slowMachine.getDiscoveryService().getTopology().isCurrent());
+ assertEquals(2, slowListener.getEventCount());
+ assertEquals(TopologyEvent.Type.TOPOLOGY_CHANGED, fastListener.getLastEvent().getType());
+ assertEquals(1, fastMachine.getDiscoveryService().getTopology().getInstances().size());
+ assertEquals(3, fastListener.getEventCount());
+
+ // make few rounds of heartbeats so that the two instances see each other again
+ for(int i=0; i<4; i++) {
+ hhFast.issueHeartbeat();
+ hhFast.checkView();
+ hhSlow.issueHeartbeat();
+ hhSlow.checkView();
+ Thread.sleep(1000);
+ }
+
+ // this should have put the two together again
+ // even after 8 sec the slow lsitener did not send a TOPOLOGY_CHANGED yet
+ assertEquals(TopologyEvent.Type.TOPOLOGY_CHANGED, fastListener.getLastEvent().getType());
+ assertTrue(fastMachine.getDiscoveryService().getTopology().isCurrent());
+ assertEquals(2, fastMachine.getDiscoveryService().getTopology().getInstances().size());
+ assertEquals(5, fastListener.getEventCount());
+ assertEquals(TopologyEvent.Type.TOPOLOGY_CHANGED, slowListener.getLastEvent().getType());
+ assertTrue(slowMachine.getDiscoveryService().getTopology().isCurrent());
+ assertEquals(2, slowMachine.getDiscoveryService().getTopology().getInstances().size());
+ assertEquals(3, slowListener.getEventCount());
+ }
+
+ private void installFailingScheduler() throws Exception {
+ Instance.setSingletonScheduler(new Scheduler() {
+
+ @Override
+ public void removeJob(String name) throws NoSuchElementException {
+ // nothing to do here
+ }
+
+ @Override
+ public boolean fireJobAt(String name, Object job, Map<String, Serializable> config, Date date, int times, long period) {
+ return false;
+ }
+
+ @Override
+ public void fireJobAt(String name, Object job, Map<String, Serializable> config, Date date) throws Exception {
+ throw new Exception("cos you are really worth it");
+ }
+
+ @Override
+ public boolean fireJob(Object job, Map<String, Serializable> config, int times, long period) {
+ return false;
+ }
+
+ @Override
+ public void fireJob(Object job, Map<String, Serializable> config) throws Exception {
+ throw new Exception("cos you are really worth it");
+ }
+
+ @Override
+ public void addPeriodicJob(String name, Object job, Map<String, Serializable> config, long period, boolean canRunConcurrently,
+ boolean startImmediate) throws Exception {
+ throw new Exception("cos you are really worth it");
+ }
+
+ @Override
+ public void addPeriodicJob(String name, Object job, Map<String, Serializable> config, long period, boolean canRunConcurrently)
+ throws Exception {
+ throw new Exception("cos you are really worth it");
+ }
+
+ @Override
+ public void addJob(String name, Object job, Map<String, Serializable> config, String schedulingExpression,
+ boolean canRunConcurrently) throws Exception {
+ throw new Exception("cos you are really worth it");
+ }
+ });
+ }
+}
Propchange: sling/trunk/bundles/extensions/discovery/impl/src/test/java/org/apache/sling/discovery/impl/common/heartbeat/HeartbeatTest.java
------------------------------------------------------------------------------
svn:eol-style = native
Modified: sling/trunk/bundles/extensions/discovery/impl/src/test/java/org/apache/sling/discovery/impl/setup/Instance.java
URL: http://svn.apache.org/viewvc/sling/trunk/bundles/extensions/discovery/impl/src/test/java/org/apache/sling/discovery/impl/setup/Instance.java?rev=1704604&r1=1704603&r2=1704604&view=diff
==============================================================================
--- sling/trunk/bundles/extensions/discovery/impl/src/test/java/org/apache/sling/discovery/impl/setup/Instance.java (original)
+++ sling/trunk/bundles/extensions/discovery/impl/src/test/java/org/apache/sling/discovery/impl/setup/Instance.java Tue Sep 22 12:35:19 2015
@@ -64,6 +64,7 @@ import org.apache.sling.discovery.impl.C
import org.apache.sling.discovery.impl.DiscoveryServiceImpl;
import org.apache.sling.discovery.impl.cluster.ClusterViewService;
import org.apache.sling.discovery.impl.cluster.ClusterViewServiceImpl;
+import org.apache.sling.discovery.impl.cluster.UndefinedClusterViewException;
import org.apache.sling.discovery.impl.cluster.voting.VotingHandler;
import org.apache.sling.discovery.impl.common.heartbeat.HeartbeatHandler;
import org.apache.sling.discovery.impl.topology.announcement.AnnouncementRegistry;
@@ -94,7 +95,6 @@ public class Instance {
long heartbeatInterval;
int minEventDelay;
List<String> whitelist;
- private boolean delayInitEventUntilVoted;
@Override
public long getHeartbeatInterval() {
@@ -148,15 +148,6 @@ public class Instance {
return 1;
}
- @Override
- public boolean isDelayInitEventUntilVoted() {
- return this.delayInitEventUntilVoted;
- }
-
- public void setDelayInitEventUntilVoted(boolean delayInitEventUntilVoted) {
- this.delayInitEventUntilVoted = delayInitEventUntilVoted;
- }
-
}
private final static Logger logger = LoggerFactory.getLogger(Instance.class);
@@ -187,8 +178,17 @@ public class Instance {
private int serviceId = 999;
private static Scheduler singletonScheduler = null;
+
+ private static Scheduler scheduler = null;
+
+ public static void setSingletonScheduler(Scheduler scheduler) throws Exception {
+ Instance.scheduler = scheduler;
+ }
- private static Scheduler getSingletonScheduler() throws Exception {
+ public static Scheduler getSingletonScheduler() throws Exception {
+ if (scheduler!=null) {
+ return scheduler;
+ }
if (singletonScheduler!=null) {
return singletonScheduler;
}
@@ -260,7 +260,7 @@ public class Instance {
private Instance(String debugName,
ResourceResolverFactory resourceResolverFactory, boolean resetRepo)
throws Exception {
- this("/var/discovery/impl/", debugName, resourceResolverFactory, resetRepo, 20, 20, 1, UUID.randomUUID().toString(), false);
+ this("/var/discovery/impl/", debugName, resourceResolverFactory, resetRepo, 20, 20, 1, UUID.randomUUID().toString());
}
private class MyEventListener implements EventListener {
@@ -300,7 +300,7 @@ public class Instance {
properties.put("path", event.getPath());
org.osgi.service.event.Event osgiEvent = new org.osgi.service.event.Event(
topic, properties);
- logger.info("onEvent: delivering event to listener: "+slingId+", stopped: "+stopped+", event: "+osgiEvent);
+ logger.debug("onEvent: delivering event to listener: "+slingId+", stopped: "+stopped+", event: "+osgiEvent);
votingHandler.handleEvent(osgiEvent);
} catch (RepositoryException e) {
logger.warn("RepositoryException: " + e, e);
@@ -323,8 +323,7 @@ public class Instance {
private Instance(String discoveryResourcePath, String debugName,
ResourceResolverFactory resourceResolverFactory, boolean resetRepo,
- final int heartbeatTimeout, final int heartbeatInterval, final int minEventDelay, String slingId,
- boolean delayInitEventUntilVoted)
+ final int heartbeatTimeout, final int heartbeatInterval, final int minEventDelay, String slingId)
throws Exception {
this.slingId = slingId;
this.debugName = debugName;
@@ -339,7 +338,6 @@ public class Instance {
config.setHeartbeatInterval(heartbeatInterval);
config.setMinEventDelay(minEventDelay);
config.addTopologyConnectorWhitelistEntry("127.0.0.1");
- config.setDelayInitEventUntilVoted(delayInitEventUntilVoted);
PrivateAccessor.setField(config, "discoveryResourcePath", discoveryResourcePath);
@@ -407,38 +405,31 @@ public class Instance {
}
public static Instance newStandaloneInstance(String discoveryResourcePath, String debugName,
- boolean resetRepo, int heartbeatTimeout, int minEventDelay, String slingId, boolean delayInitEventUntilVoted) throws Exception {
+ boolean resetRepo, int heartbeatTimeout, int minEventDelay, String slingId) throws Exception {
ResourceResolverFactory resourceResolverFactory = MockFactory
.mockResourceResolverFactory();
- return new Instance(discoveryResourcePath, debugName, resourceResolverFactory, resetRepo, heartbeatTimeout, 20, minEventDelay, slingId, delayInitEventUntilVoted);
+ return new Instance(discoveryResourcePath, debugName, resourceResolverFactory, resetRepo, heartbeatTimeout, 20, minEventDelay, slingId);
}
public static Instance newStandaloneInstance(String discoveryResourcePath, String debugName,
- boolean resetRepo, int heartbeatTimeout, int heartbeatInterval, int minEventDelay, String slingId, boolean delayInitEventUntilVoted) throws Exception {
- ResourceResolverFactory resourceResolverFactory = MockFactory
- .mockResourceResolverFactory();
- return new Instance(discoveryResourcePath, debugName, resourceResolverFactory, resetRepo, heartbeatTimeout, heartbeatInterval, minEventDelay, slingId, delayInitEventUntilVoted);
- }
-
- public static Instance newStandaloneInstance(String discoveryResourcePath, String debugName,
- boolean resetRepo, int heartbeatTimeout, int minEventDelay, String slingId) throws Exception {
+ boolean resetRepo, int heartbeatTimeout, int heartbeatInterval, int minEventDelay, String slingId) throws Exception {
ResourceResolverFactory resourceResolverFactory = MockFactory
.mockResourceResolverFactory();
- return new Instance(discoveryResourcePath, debugName, resourceResolverFactory, resetRepo, heartbeatTimeout, 20, minEventDelay, slingId, false);
+ return new Instance(discoveryResourcePath, debugName, resourceResolverFactory, resetRepo, heartbeatTimeout, heartbeatInterval, minEventDelay, slingId);
}
public static Instance newStandaloneInstance(String discoveryResourcePath, String debugName,
boolean resetRepo, int heartbeatTimeout, int minEventDelay) throws Exception {
ResourceResolverFactory resourceResolverFactory = MockFactory
.mockResourceResolverFactory();
- return new Instance(discoveryResourcePath, debugName, resourceResolverFactory, resetRepo, heartbeatTimeout, 20, minEventDelay, UUID.randomUUID().toString(), false);
+ return new Instance(discoveryResourcePath, debugName, resourceResolverFactory, resetRepo, heartbeatTimeout, 20, minEventDelay, UUID.randomUUID().toString());
}
public static Instance newStandaloneInstance(String discoveryResourcePath, String debugName,
boolean resetRepo, int heartbeatTimeout, int heartbeatInterval, int minEventDelay) throws Exception {
ResourceResolverFactory resourceResolverFactory = MockFactory
.mockResourceResolverFactory();
- return new Instance(discoveryResourcePath, debugName, resourceResolverFactory, resetRepo, heartbeatTimeout, heartbeatInterval, minEventDelay, UUID.randomUUID().toString(), false);
+ return new Instance(discoveryResourcePath, debugName, resourceResolverFactory, resetRepo, heartbeatTimeout, heartbeatInterval, minEventDelay, UUID.randomUUID().toString());
}
public static Instance newStandaloneInstance(String debugName,
@@ -449,23 +440,18 @@ public class Instance {
}
public static Instance newClusterInstance(String discoveryResourcePath, String debugName, Instance other,
- boolean resetRepo, int heartbeatTimeout, int minEventDelay, String slingId, boolean delayInitEventUntilVoted) throws Exception {
- return new Instance(discoveryResourcePath, debugName, other.resourceResolverFactory, resetRepo, heartbeatTimeout, 20, minEventDelay, slingId, delayInitEventUntilVoted);
- }
-
- public static Instance newClusterInstance(String discoveryResourcePath, String debugName, Instance other,
boolean resetRepo, int heartbeatTimeout, int minEventDelay, String slingId) throws Exception {
- return new Instance(discoveryResourcePath, debugName, other.resourceResolverFactory, resetRepo, heartbeatTimeout, 20, minEventDelay, slingId, false);
+ return new Instance(discoveryResourcePath, debugName, other.resourceResolverFactory, resetRepo, heartbeatTimeout, 20, minEventDelay, slingId);
}
public static Instance newClusterInstance(String discoveryResourcePath, String debugName, Instance other,
boolean resetRepo, int heartbeatTimeout, int minEventDelay) throws Exception {
- return new Instance(discoveryResourcePath, debugName, other.resourceResolverFactory, resetRepo, heartbeatTimeout, 20, minEventDelay, UUID.randomUUID().toString(), false);
+ return new Instance(discoveryResourcePath, debugName, other.resourceResolverFactory, resetRepo, heartbeatTimeout, 20, minEventDelay, UUID.randomUUID().toString());
}
public static Instance newClusterInstance(String discoveryResourcePath, String debugName, Instance other,
boolean resetRepo, int heartbeatTimeout, int heartbeatInterval, int minEventDelay) throws Exception {
- return new Instance(discoveryResourcePath, debugName, other.resourceResolverFactory, resetRepo, heartbeatTimeout, heartbeatInterval, minEventDelay, UUID.randomUUID().toString(), false);
+ return new Instance(discoveryResourcePath, debugName, other.resourceResolverFactory, resetRepo, heartbeatTimeout, heartbeatInterval, minEventDelay, UUID.randomUUID().toString());
}
public static Instance newClusterInstance(String debugName, Instance other,
@@ -550,7 +536,7 @@ public class Instance {
return connectorRegistry.registerOutgoingConnector(clusterViewService, new URL(url));
}
- public InstanceDescription getLocalInstanceDescription() {
+ public InstanceDescription getLocalInstanceDescription() throws UndefinedClusterViewException {
final Iterator<InstanceDescription> it = getClusterViewService().getClusterView().getInstances().iterator();
while(it.hasNext()) {
final InstanceDescription id = it.next();
@@ -695,4 +681,11 @@ public class Instance {
return config;
}
+ public HeartbeatHandler getHeartbeatHandler() {
+ return heartbeatHandler;
+ }
+
+ public void installVotingOnHeartbeatHandler() throws NoSuchFieldException {
+ PrivateAccessor.setField(heartbeatHandler, "votingHandler", votingHandler);
+ }
}
Modified: sling/trunk/bundles/extensions/discovery/impl/src/test/java/org/apache/sling/discovery/impl/topology/LargeTopologyWithHubTest.java
URL: http://svn.apache.org/viewvc/sling/trunk/bundles/extensions/discovery/impl/src/test/java/org/apache/sling/discovery/impl/topology/LargeTopologyWithHubTest.java?rev=1704604&r1=1704603&r2=1704604&view=diff
==============================================================================
--- sling/trunk/bundles/extensions/discovery/impl/src/test/java/org/apache/sling/discovery/impl/topology/LargeTopologyWithHubTest.java (original)
+++ sling/trunk/bundles/extensions/discovery/impl/src/test/java/org/apache/sling/discovery/impl/topology/LargeTopologyWithHubTest.java Tue Sep 22 12:35:19 2015
@@ -18,12 +18,15 @@
*/
package org.apache.sling.discovery.impl.topology;
+import static org.junit.Assert.assertNotNull;
+
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import org.apache.sling.commons.testing.junit.Retry;
import org.apache.sling.commons.testing.junit.RetryRule;
+import org.apache.sling.discovery.ClusterView;
import org.apache.sling.discovery.TopologyView;
import org.apache.sling.discovery.impl.setup.Instance;
import org.apache.sling.testing.tools.sling.TimeoutsProvider;
@@ -41,7 +44,7 @@ public class LargeTopologyWithHubTest {
private static List<Instance> instances;
private static Instance hub;
private static List<String> slingIds;
- private static final int TEST_SIZE = 100;
+ private static final int TEST_SIZE = 50;
@Rule
public final RetryRule retryRule = new RetryRule();
@@ -51,8 +54,14 @@ public class LargeTopologyWithHubTest {
instances = new LinkedList<Instance>();
final int defaultHeartbeatTimeout = 3600; // 1 hour should be enough, really
final int heartbeatTimeout = TimeoutsProvider.getInstance().getTimeout(defaultHeartbeatTimeout);
- hub = TopologyTestHelper.createInstance(instances, "/var/discovery/impl/hub/", "hub", heartbeatTimeout, 1000, 1);
+ hub = TopologyTestHelper.createInstance(instances, "/var/discovery/impl/hub/", "hub", true, heartbeatTimeout, 5, 1);
hub.getConfig().setHeartbeatTimeout(heartbeatTimeout);
+ hub.installVotingOnHeartbeatHandler();
+ hub.runHeartbeatOnce();
+ hub.runHeartbeatOnce();
+ assertNotNull(hub.getClusterViewService().getClusterView());
+ hub.startHeartbeats(1);
+ hub.dumpRepo();
slingIds = new LinkedList<String>();
slingIds.add(hub.getSlingId());
@@ -60,8 +69,13 @@ public class LargeTopologyWithHubTest {
+ "(default: "+defaultHeartbeatTimeout+")");
for(int i=0; i<TEST_SIZE; i++) {
logger.info("setUp: creating instance"+i);
- Instance instance = TopologyTestHelper.createInstance(instances, "/var/discovery/impl/i"+i+"/", "instance"+i, heartbeatTimeout, 10, 1);
+ Instance instance = TopologyTestHelper.createInstance(instances, "/var/discovery/impl/i"+i+"/", "instance"+i, false, heartbeatTimeout, 5, 1);
instance.getConfig().setHeartbeatTimeout(heartbeatTimeout);
+ instance.installVotingOnHeartbeatHandler();
+ instance.runHeartbeatOnce();
+ instance.runHeartbeatOnce();
+ ClusterView clusterView = instance.getClusterViewService().getClusterView();
+ assertNotNull(clusterView);
new Connector(instance, hub);
slingIds.add(instance.getSlingId());
}
@@ -80,6 +94,7 @@ public class LargeTopologyWithHubTest {
public void testLargeTopologyWithHub() throws Exception {
hub.dumpRepo();
final TopologyView tv = hub.getDiscoveryService().getTopology();
+ assertNotNull(tv);
logger.info(
"testLargeTopologyWithHub: checking if all connectors are registered, TopologyView has {} Instances",
tv.getInstances().size());
Modified: sling/trunk/bundles/extensions/discovery/impl/src/test/java/org/apache/sling/discovery/impl/topology/TopologyTest.java
URL: http://svn.apache.org/viewvc/sling/trunk/bundles/extensions/discovery/impl/src/test/java/org/apache/sling/discovery/impl/topology/TopologyTest.java?rev=1704604&r1=1704603&r2=1704604&view=diff
==============================================================================
--- sling/trunk/bundles/extensions/discovery/impl/src/test/java/org/apache/sling/discovery/impl/topology/TopologyTest.java (original)
+++ sling/trunk/bundles/extensions/discovery/impl/src/test/java/org/apache/sling/discovery/impl/topology/TopologyTest.java Tue Sep 22 12:35:19 2015
@@ -50,13 +50,19 @@ public class TopologyTest {
@Test
public void testTwoNodes() throws Throwable {
- Instance instance1 = TopologyTestHelper.createInstance(instances, "instance1");
- Instance instance2 = TopologyTestHelper.createInstance(instances, "instance2");
+ Instance instance1 = TopologyTestHelper.createInstance(instances, "/var/discovery/impl1/", "instance1", true, 200, 20, 1);
+ Instance instance2 = TopologyTestHelper.createInstance(instances, "/var/discovery/impl2/", "instance2", false, 200, 20, 1);
instance1.getConfig().setHeartbeatTimeout(8);
instance1.getConfig().setHeartbeatInterval(1);
instance2.getConfig().setHeartbeatTimeout(2);
instance2.getConfig().setHeartbeatInterval(1);
+ for(int i=0; i<5; i++) {
+ instance1.runHeartbeatOnce();
+ instance2.runHeartbeatOnce();
+ Thread.sleep(500);
+ }
+
Set<InstanceDescription> instances1 = instance1.getDiscoveryService().getTopology().getInstances();
Set<InstanceDescription> instances2 = instance2.getDiscoveryService().getTopology().getInstances();
Modified: sling/trunk/bundles/extensions/discovery/impl/src/test/java/org/apache/sling/discovery/impl/topology/TopologyTestHelper.java
URL: http://svn.apache.org/viewvc/sling/trunk/bundles/extensions/discovery/impl/src/test/java/org/apache/sling/discovery/impl/topology/TopologyTestHelper.java?rev=1704604&r1=1704603&r2=1704604&view=diff
==============================================================================
--- sling/trunk/bundles/extensions/discovery/impl/src/test/java/org/apache/sling/discovery/impl/topology/TopologyTestHelper.java (original)
+++ sling/trunk/bundles/extensions/discovery/impl/src/test/java/org/apache/sling/discovery/impl/topology/TopologyTestHelper.java Tue Sep 22 12:35:19 2015
@@ -147,8 +147,8 @@ public class TopologyTestHelper {
}
public static Instance createInstance(Collection<Instance> instances, String discoveryResourcePath, String debugName,
- int heartbeatTimeout, int heartbeatInterval, int minEventDelay) throws Exception {
- final Instance instance = Instance.newStandaloneInstance(discoveryResourcePath, debugName, true, heartbeatTimeout, heartbeatInterval, minEventDelay);
+ boolean resetRepo, int heartbeatTimeout, int heartbeatInterval, int minEventDelay) throws Exception {
+ final Instance instance = Instance.newStandaloneInstance(discoveryResourcePath, debugName, resetRepo, heartbeatTimeout, heartbeatInterval, minEventDelay);
instances.add(instance);
return instance;
}