You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@felix.apache.org by fm...@apache.org on 2010/10/27 09:05:43 UTC
svn commit: r1027839 - in /felix/trunk/coordinator/src:
main/java/org/apache/felix/coordination/impl/ test/ test/java/
test/java/org/ test/java/org/apache/ test/java/org/apache/felix/
test/java/org/apache/felix/coordination/ test/java/org/apache/felix/...
Author: fmeschbe
Date: Wed Oct 27 07:05:42 2010
New Revision: 1027839
URL: http://svn.apache.org/viewvc?rev=1027839&view=rev
Log:
Adding unit tests and a few test induced fixes
Added:
felix/trunk/coordinator/src/test/
felix/trunk/coordinator/src/test/java/
felix/trunk/coordinator/src/test/java/org/
felix/trunk/coordinator/src/test/java/org/apache/
felix/trunk/coordinator/src/test/java/org/apache/felix/
felix/trunk/coordinator/src/test/java/org/apache/felix/coordination/
felix/trunk/coordinator/src/test/java/org/apache/felix/coordination/impl/
felix/trunk/coordinator/src/test/java/org/apache/felix/coordination/impl/CoordinatorImplTest.java (with props)
Modified:
felix/trunk/coordinator/src/main/java/org/apache/felix/coordination/impl/CoordinationImpl.java
felix/trunk/coordinator/src/main/java/org/apache/felix/coordination/impl/CoordinationMgr.java
Modified: felix/trunk/coordinator/src/main/java/org/apache/felix/coordination/impl/CoordinationImpl.java
URL: http://svn.apache.org/viewvc/felix/trunk/coordinator/src/main/java/org/apache/felix/coordination/impl/CoordinationImpl.java?rev=1027839&r1=1027838&r2=1027839&view=diff
==============================================================================
--- felix/trunk/coordinator/src/main/java/org/apache/felix/coordination/impl/CoordinationImpl.java (original)
+++ felix/trunk/coordinator/src/main/java/org/apache/felix/coordination/impl/CoordinationImpl.java Wed Oct 27 07:05:42 2010
@@ -6,9 +6,9 @@
* 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
@@ -115,8 +115,8 @@ public class CoordinationImpl implements
// If a timeout happens, the coordination thread is set to always fail
this.mustFail = TIMEOUT;
- // Faile the Coordination upon timeout
- CoordinationImpl.this.fail(null);
+ // Fail the Coordination upon timeout
+ fail(null);
}
long getTimeOut()
@@ -190,7 +190,7 @@ public class CoordinationImpl implements
*/
public boolean isTerminated()
{
- return state == TERMINATED;
+ return state == TERMINATED || state == FAILED;
}
public void addTimeout(long timeOutInMs)
@@ -212,7 +212,7 @@ public class CoordinationImpl implements
* another coordination.
* <p>
* Participants can only be added to a coordination if it is active.
- *
+ *
* @throws org.apache.felix.service.coordination.CoordinationException if
* the participant cannot currently participate in this
* coordination
@@ -267,7 +267,7 @@ public class CoordinationImpl implements
* {@value State#TERMINATING}, unregistering from the
* {@link CoordinationMgr} and ensuring there is no timeout task active any
* longer to timeout this coordination.
- *
+ *
* @return <code>true</code> If the coordination was active and termination
* can continue. If <code>false</code> is returned, the coordination
* must be considered terminated (or terminating) in the current
@@ -293,7 +293,7 @@ public class CoordinationImpl implements
* This method must only be called after the {@link #state} field has been
* set to {@link State#TERMINATING} and only be the method successfully
* setting this state.
- *
+ *
* @return OK or PARTIALLY_ENDED depending on whether all participants
* succeeded or some of them failed ending the coordination.
*/
@@ -350,7 +350,7 @@ public class CoordinationImpl implements
* Helper method for timeout scheduling. If a timer is currently scheduled
* it is canceled. If the new timeout value is a positive value a new timer
* is scheduled to fire of so many milliseconds from now.
- *
+ *
* @param timeout The new timeout value
*/
private void scheduleTimeout(final long timeout)
Modified: felix/trunk/coordinator/src/main/java/org/apache/felix/coordination/impl/CoordinationMgr.java
URL: http://svn.apache.org/viewvc/felix/trunk/coordinator/src/main/java/org/apache/felix/coordination/impl/CoordinationMgr.java?rev=1027839&r1=1027838&r2=1027839&view=diff
==============================================================================
--- felix/trunk/coordinator/src/main/java/org/apache/felix/coordination/impl/CoordinationMgr.java (original)
+++ felix/trunk/coordinator/src/main/java/org/apache/felix/coordination/impl/CoordinationMgr.java Wed Oct 27 07:05:42 2010
@@ -6,9 +6,9 @@
* 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
@@ -76,13 +76,14 @@ public class CoordinationMgr implements
/**
* Wait at most 60 seconds for participant to be eligible for participation
* in a coordination.
- *
+ *
* @see #singularizeParticipant(Participant, CoordinationImpl)
*/
private long participationTimeOut = 60 * 1000L;
CoordinationMgr()
{
+ threadStacks = new ThreadLocal<Stack<Coordination>>();
ctr = new AtomicLong(-1);
coordinations = new HashMap<Long, CoordinationImpl>();
participants = new HashMap<Participant, CoordinationImpl>();
@@ -105,6 +106,9 @@ public class CoordinationMgr implements
// release all participants
participants.clear();
+
+ // cannot really clear out the thread local but we can let it go
+ threadStacks = null;
}
void configure(final long coordinationTimeout, final long participationTimeout)
@@ -131,11 +135,13 @@ public class CoordinationMgr implements
{
// wait for participant to be released
long cutOff = System.currentTimeMillis() + participationTimeOut;
- while (participants.containsKey(p))
+ long waitTime = (participationTimeOut > 500) ? participationTimeOut / 500 : participationTimeOut;
+ CoordinationImpl current = participants.get(p);
+ while (current != null && current != c)
{
try
{
- participants.wait(participationTimeOut / 500);
+ participants.wait(waitTime);
}
catch (InterruptedException ie)
{
@@ -148,6 +154,9 @@ public class CoordinationMgr implements
throw new CoordinationException("Timed out waiting to join coordinaton", c.getName(),
CoordinationException.TIMEOUT);
}
+
+ // check again
+ current = participants.get(p);
}
// lock participant into coordination
Added: felix/trunk/coordinator/src/test/java/org/apache/felix/coordination/impl/CoordinatorImplTest.java
URL: http://svn.apache.org/viewvc/felix/trunk/coordinator/src/test/java/org/apache/felix/coordination/impl/CoordinatorImplTest.java?rev=1027839&view=auto
==============================================================================
--- felix/trunk/coordinator/src/test/java/org/apache/felix/coordination/impl/CoordinatorImplTest.java (added)
+++ felix/trunk/coordinator/src/test/java/org/apache/felix/coordination/impl/CoordinatorImplTest.java Wed Oct 27 07:05:42 2010
@@ -0,0 +1,387 @@
+/*
+ * 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.felix.coordination.impl;
+
+import org.apache.felix.service.coordination.Coordination;
+import org.apache.felix.service.coordination.CoordinationException;
+import org.apache.felix.service.coordination.Participant;
+
+import junit.framework.TestCase;
+
+@SuppressWarnings("deprecation")
+public class CoordinatorImplTest extends TestCase
+{
+
+ private CoordinationMgr mgr;
+ private CoordinatorImpl coordinator;
+
+ @Override
+ protected void setUp() throws Exception
+ {
+ super.setUp();
+
+ mgr = new CoordinationMgr();
+ coordinator = new CoordinatorImpl(null, mgr);
+ }
+
+ public void test_createCoordination()
+ {
+ final String name = "test";
+ final Coordination c1 = coordinator.create(name);
+ assertNotNull(c1);
+ assertEquals(name, c1.getName());
+ assertNull(coordinator.getCurrentCoordination());
+ assertFalse(c1.isFailed());
+ assertFalse(c1.isTerminated());
+ assertTrue(c1.getParticipants().isEmpty());
+
+ assertTrue(c1.fail(new Exception()));
+ assertTrue(c1.isFailed());
+ assertTrue(c1.isTerminated());
+ assertNull(coordinator.getCurrentCoordination());
+
+ assertFalse(c1.fail(new Exception()));
+ try
+ {
+ c1.end();
+ fail("Expected IllegalStateException on end() after fail()");
+ }
+ catch (IllegalStateException ise)
+ {
+ // expected
+ }
+
+ final Coordination c2 = coordinator.create(name);
+ assertNotNull(c2);
+ assertEquals(name, c2.getName());
+ assertNull(coordinator.getCurrentCoordination());
+ assertFalse(c2.isFailed());
+ assertFalse(c2.isTerminated());
+ assertTrue(c2.getParticipants().isEmpty());
+
+ assertEquals(Coordination.OK, c2.end());
+ assertFalse(c2.isFailed());
+ assertTrue(c2.isTerminated());
+ assertNull(coordinator.getCurrentCoordination());
+
+ assertFalse(c2.fail(new Exception()));
+ try
+ {
+ c2.end();
+ fail("Expected IllegalStateException on second end()");
+ }
+ catch (IllegalStateException ise)
+ {
+ // expected
+ }
+ }
+
+ public void test_beginCoordination()
+ {
+ final String name = "test";
+ final Coordination c1 = coordinator.begin(name);
+ assertNotNull(c1);
+ assertEquals(name, c1.getName());
+
+ assertEquals(c1, coordinator.getCurrentCoordination());
+ assertEquals(c1, coordinator.pop());
+
+ assertNull(coordinator.getCurrentCoordination());
+ coordinator.push(c1);
+ assertEquals(c1, coordinator.getCurrentCoordination());
+
+ c1.end();
+ assertNull(coordinator.getCurrentCoordination());
+
+ final Coordination c2 = coordinator.begin(name);
+ assertNotNull(c2);
+ assertEquals(name, c2.getName());
+ assertEquals(c2, coordinator.getCurrentCoordination());
+ c2.fail(null);
+ assertNull(coordinator.getCurrentCoordination());
+ }
+
+ public void test_beginCoordination_stack()
+ {
+ final String name = "test";
+
+ final Coordination c1 = coordinator.begin(name);
+ assertNotNull(c1);
+ assertEquals(name, c1.getName());
+ assertEquals(c1, coordinator.getCurrentCoordination());
+
+ final Coordination c2 = coordinator.begin(name);
+ assertNotNull(c2);
+ assertEquals(name, c2.getName());
+ assertEquals(c2, coordinator.getCurrentCoordination());
+
+ c2.end();
+ assertEquals(c1, coordinator.getCurrentCoordination());
+
+ c1.end();
+ assertNull(coordinator.getCurrentCoordination());
+ }
+
+ public void test_beginCoordination_stack2()
+ {
+ final String name = "test";
+
+ final Coordination c1 = coordinator.begin(name);
+ assertNotNull(c1);
+ assertEquals(name, c1.getName());
+ assertEquals(c1, coordinator.getCurrentCoordination());
+
+ final Coordination c2 = coordinator.begin(name);
+ assertNotNull(c2);
+ assertEquals(name, c2.getName());
+ assertEquals(c2, coordinator.getCurrentCoordination());
+
+ c1.end();
+ assertEquals(c2, coordinator.getCurrentCoordination());
+
+ c2.end();
+ assertNull(coordinator.getCurrentCoordination());
+ }
+
+ public void test_participate_with_ended()
+ {
+ final String name = "test";
+ final Coordination c1 = coordinator.create(name);
+
+ final MockParticipant p1 = new MockParticipant();
+ c1.participate(p1);
+ assertTrue(c1.getParticipants().contains(p1));
+ assertEquals(1, c1.getParticipants().size());
+
+ c1.end();
+ assertTrue(p1.ended);
+ assertFalse(p1.failed);
+ assertEquals(c1, p1.c);
+
+ // assert order of call
+ final Coordination c2 = coordinator.create(name);
+ final MockParticipant p21 = new MockParticipant();
+ final MockParticipant p22 = new MockParticipant();
+ c2.participate(p21);
+ c2.participate(p22);
+ assertTrue(c2.getParticipants().contains(p21));
+ assertTrue(c2.getParticipants().contains(p22));
+ assertEquals(2, c2.getParticipants().size());
+
+ c2.end();
+ assertTrue(p21.ended);
+ assertEquals(c2, p21.c);
+ assertTrue(p22.ended);
+ assertEquals(c2, p22.c);
+ assertTrue("p21 must be called before p22", p21.time < p22.time);
+
+ // assert order of call with two registrations
+ final Coordination c3 = coordinator.create(name);
+ final MockParticipant p31 = new MockParticipant();
+ final MockParticipant p32 = new MockParticipant();
+ c3.participate(p31);
+ c3.participate(p32);
+ c3.participate(p31); // should be "ignored"
+ assertTrue(c3.getParticipants().contains(p31));
+ assertTrue(c3.getParticipants().contains(p32));
+ assertEquals(2, c3.getParticipants().size());
+
+ c3.end();
+ assertTrue(p31.ended);
+ assertEquals(c3, p31.c);
+ assertTrue(p32.ended);
+ assertEquals(c3, p32.c);
+ assertTrue("p21 must be called before p22", p31.time < p32.time);
+ }
+
+ public void test_participate_with_failed()
+ {
+ final String name = "test";
+ final Coordination c1 = coordinator.create(name);
+
+ final MockParticipant p1 = new MockParticipant();
+ c1.participate(p1);
+ assertTrue(c1.getParticipants().contains(p1));
+ assertEquals(1, c1.getParticipants().size());
+
+ c1.fail(null);
+ assertFalse(p1.ended);
+ assertTrue(p1.failed);
+ assertEquals(c1, p1.c);
+
+ // assert order of call
+ final Coordination c2 = coordinator.create(name);
+ final MockParticipant p21 = new MockParticipant();
+ final MockParticipant p22 = new MockParticipant();
+ c2.participate(p21);
+ c2.participate(p22);
+ assertTrue(c2.getParticipants().contains(p21));
+ assertTrue(c2.getParticipants().contains(p22));
+ assertEquals(2, c2.getParticipants().size());
+
+ c2.fail(null);
+ assertTrue(p21.failed);
+ assertEquals(c2, p21.c);
+ assertTrue(p22.failed);
+ assertEquals(c2, p22.c);
+ assertTrue("p21 must be called before p22", p21.time < p22.time);
+
+ // assert order of call with two registrations
+ final Coordination c3 = coordinator.create(name);
+ final MockParticipant p31 = new MockParticipant();
+ final MockParticipant p32 = new MockParticipant();
+ c3.participate(p31);
+ c3.participate(p32);
+ c3.participate(p31); // should be "ignored"
+ assertTrue(c3.getParticipants().contains(p31));
+ assertTrue(c3.getParticipants().contains(p32));
+ assertEquals(2, c3.getParticipants().size());
+
+ c3.fail(null);
+ assertTrue(p31.failed);
+ assertEquals(c3, p31.c);
+ assertTrue(p32.failed);
+ assertEquals(c3, p32.c);
+ assertTrue("p21 must be called before p22", p31.time < p32.time);
+ }
+
+ public void test_Coordination_timeout() throws InterruptedException
+ {
+ final String name = "test";
+ final Coordination c1 = coordinator.create(name);
+ final MockParticipant p1 = new MockParticipant();
+ c1.participate(p1);
+ assertTrue(c1.getParticipants().contains(p1));
+ assertEquals(1, c1.getParticipants().size());
+
+ // set a short timeout and wait for it to pass
+ c1.addTimeout(100);
+ Thread.sleep(150);
+
+ // expect coordination to have terminated
+ assertTrue(c1.isTerminated());
+ assertTrue(c1.isFailed());
+
+ // expect Participant.failed() being called
+ assertTrue(p1.failed);
+ assertEquals(c1, p1.c);
+ }
+
+ public void test_Coordination_participate_timeout() throws InterruptedException
+ {
+ final String name1 = "test1";
+ final String name2 = "test2";
+ final MockParticipant p1 = new MockParticipant();
+
+ // ensure short timeout for participation
+ mgr.configure(60000, 200);
+
+ final Coordination c1 = coordinator.create(name1);
+ c1.participate(p1);
+ assertTrue(c1.getParticipants().contains(p1));
+ assertEquals(1, c1.getParticipants().size());
+
+ // preset p1PartFailure to be be sure the participation actually starts
+ p1.participateFailure(new Exception("Not Started yet"));
+
+ Thread c2Thread = new Thread()
+ {
+ public void run()
+ {
+ final Coordination c2 = coordinator.create(name2);
+ try
+ {
+ p1.participateFailure(null);
+ c2.participate(p1);
+ }
+ catch (Throwable t)
+ {
+ p1.participateFailure(t);
+ }
+ finally
+ {
+ c2.terminate();
+ }
+ }
+ };
+ c2Thread.start();
+
+ // wait at most 2 seconds for the second thread to terminate
+ // we expect this if the participation properly times out
+ c2Thread.join(2000);
+ assertFalse("Thread for second Coordination did not terminate....", c2Thread.isAlive());
+
+ Throwable p1PartFailure = p1.participateFailure;
+ if (p1PartFailure == null)
+ {
+ fail("Expecting CoordinationException/TIMEOUT for second participation");
+ }
+ else if (p1PartFailure instanceof CoordinationException)
+ {
+ assertEquals(CoordinationException.TIMEOUT, ((CoordinationException) p1PartFailure).getReason());
+ }
+ else
+ {
+ fail("Unexpected Throwable while trying to participate: " + p1PartFailure);
+ }
+
+ c1.terminate();
+
+ // make sure c2Thread has terminated
+ if (c2Thread.isAlive())
+ {
+ c2Thread.interrupt();
+ c2Thread.join(1000);
+ assertFalse("Thread for second Coordination did not terminate....", c2Thread.isAlive());
+ }
+ }
+
+ static final class MockParticipant implements Participant
+ {
+
+ long time;
+
+ Coordination c;
+
+ boolean failed;
+
+ boolean ended;
+
+ Throwable participateFailure;
+
+ public void failed(Coordination c) throws Exception
+ {
+ this.failed = true;
+ this.c = c;
+ this.time = System.nanoTime();
+ }
+
+ public void ended(Coordination c) throws Exception
+ {
+ this.ended = true;
+ this.c = c;
+ this.time = System.nanoTime();
+ }
+
+ void participateFailure(Throwable t)
+ {
+ this.participateFailure = t;
+ }
+ }
+}
Propchange: felix/trunk/coordinator/src/test/java/org/apache/felix/coordination/impl/CoordinatorImplTest.java
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: felix/trunk/coordinator/src/test/java/org/apache/felix/coordination/impl/CoordinatorImplTest.java
------------------------------------------------------------------------------
svn:keywords = Author Date Id Revision Rev Url