| /** |
| * |
| * Copyright 2005 the original author or authors. |
| * |
| * Licensed 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.gbean.kernel.standard; |
| |
| import java.net.URL; |
| import java.net.URLClassLoader; |
| import java.util.Collections; |
| import java.util.HashSet; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Set; |
| |
| import edu.emory.mathcs.backport.java.util.concurrent.Callable; |
| import edu.emory.mathcs.backport.java.util.concurrent.CountDownLatch; |
| import edu.emory.mathcs.backport.java.util.concurrent.FutureTask; |
| import edu.emory.mathcs.backport.java.util.concurrent.TimeUnit; |
| import junit.framework.TestCase; |
| import org.gbean.kernel.ForcedStopException; |
| import org.gbean.kernel.IllegalServiceStateException; |
| import org.gbean.kernel.Kernel; |
| import org.gbean.kernel.KernelMonitor; |
| import org.gbean.kernel.ServiceAlreadyExistsException; |
| import org.gbean.kernel.ServiceCondition; |
| import org.gbean.kernel.ServiceConditionContext; |
| import org.gbean.kernel.ServiceContext; |
| import org.gbean.kernel.ServiceEvent; |
| import org.gbean.kernel.ServiceFactory; |
| import org.gbean.kernel.ServiceMonitor; |
| import org.gbean.kernel.ServiceName; |
| import org.gbean.kernel.ServiceNotFoundException; |
| import org.gbean.kernel.ServiceRegistrationException; |
| import org.gbean.kernel.ServiceState; |
| import org.gbean.kernel.StartStrategies; |
| import org.gbean.kernel.StartStrategy; |
| import org.gbean.kernel.StaticServiceFactory; |
| import org.gbean.kernel.StopStrategies; |
| import org.gbean.kernel.StopStrategy; |
| import org.gbean.kernel.StringServiceName; |
| import org.gbean.kernel.UnregisterServiceException; |
| import org.gbean.kernel.UnsatisfiedConditionsException; |
| |
| /** |
| * Test ServiceManager. |
| * @author Dain Sundstrom |
| * @version $Id$ |
| * @since 1.0 |
| */ |
| public class ServiceManagerTest extends TestCase { |
| private static final Object SERVICE = new Object(); |
| private final MockKernel kernel = new MockKernel(); |
| private final StringServiceName serviceName = new StringServiceName("Service"); |
| private final StringServiceName ownedServiceName = new StringServiceName("OwnedService"); |
| private final MockStartCondition startCondition = new MockStartCondition(); |
| private final MockStopCondition stopCondition = new MockStopCondition(); |
| private final MockServiceFactory serviceFactory = new MockServiceFactory(); |
| private final ClassLoader classLoader = new URLClassLoader(new URL[0]); |
| private final MockServiceMonitor serviceMonitor = new MockServiceMonitor(); |
| private ServiceManager serviceManager; |
| |
| /** |
| * Tests that the initial state of the service manager is as expected. |
| */ |
| public void testInitialState() { |
| assertSame(serviceName, serviceManager.getServiceName()); |
| assertSame(serviceFactory, serviceManager.getServiceFactory()); |
| assertSame(classLoader, serviceManager.getClassLoader()); |
| assertEquals(0, serviceManager.getStartTime()); |
| assertNull(serviceManager.getService()); |
| assertSame(ServiceState.STOPPED, serviceManager.getState()); |
| } |
| |
| /** |
| * Tests that initialize and destroy work without exception. |
| * @throws Exception if a problem occurs |
| */ |
| public void testInitializeDestroy() throws Exception { |
| initialize(); |
| destroy(StopStrategies.SYNCHRONOUS); |
| initialize(); |
| destroy(StopStrategies.SYNCHRONOUS); |
| } |
| |
| /** |
| * Tests that start and stop work without exception. |
| * @throws Exception if a problem occurs |
| */ |
| public void testStartStop() throws Exception { |
| startStop(StartStrategies.ASYNCHRONOUS, false); |
| startStop(StartStrategies.SYNCHRONOUS, false); |
| startStop(StartStrategies.UNREGISTER, false); |
| startStop(StartStrategies.BLOCK, false); |
| |
| startStop(StartStrategies.ASYNCHRONOUS, false); |
| startStop(StartStrategies.SYNCHRONOUS, false); |
| startStop(StartStrategies.UNREGISTER, false); |
| startStop(StartStrategies.BLOCK, false); |
| } |
| |
| /** |
| * Tests that startRecursive results in recursive start calls on the owned services. |
| * @throws Exception if a problem occurs |
| */ |
| public void testStartRecursive() throws Exception { |
| startStop(StartStrategies.ASYNCHRONOUS, true); |
| startStop(StartStrategies.SYNCHRONOUS, true); |
| startStop(StartStrategies.UNREGISTER, true); |
| startStop(StartStrategies.BLOCK, true); |
| |
| startStop(StartStrategies.ASYNCHRONOUS, true); |
| startStop(StartStrategies.SYNCHRONOUS, true); |
| startStop(StartStrategies.UNREGISTER, true); |
| startStop(StartStrategies.BLOCK, true); |
| } |
| |
| private void startStop(StartStrategy startStrategy, boolean recursive) throws Exception { |
| start(recursive, startStrategy); |
| stop(StopStrategies.SYNCHRONOUS); |
| |
| start(recursive, startStrategy); |
| start(recursive, startStrategy); |
| stop(StopStrategies.SYNCHRONOUS); |
| stop(StopStrategies.SYNCHRONOUS); |
| } |
| |
| /** |
| * Tests how the start strategies respond when an Exception is thrown. |
| * @throws Exception if a problem occurs |
| */ |
| public void testStartException() throws Exception { |
| startException(StartStrategies.ASYNCHRONOUS, false); |
| startException(StartStrategies.SYNCHRONOUS, false); |
| startException(StartStrategies.UNREGISTER, false); |
| startException(StartStrategies.BLOCK, false); |
| |
| startException(StartStrategies.ASYNCHRONOUS, false); |
| startException(StartStrategies.SYNCHRONOUS, false); |
| startException(StartStrategies.UNREGISTER, false); |
| startException(StartStrategies.BLOCK, false); |
| } |
| |
| /** |
| * Tests how startRecursive start strategies respond when an Exception is thrown. |
| * @throws Exception if a problem occurs |
| */ |
| public void testStartExceptionRecursive() throws Exception { |
| startException(StartStrategies.ASYNCHRONOUS, true); |
| startException(StartStrategies.SYNCHRONOUS, true); |
| startException(StartStrategies.UNREGISTER, true); |
| startException(StartStrategies.BLOCK, true); |
| |
| startException(StartStrategies.ASYNCHRONOUS, true); |
| startException(StartStrategies.SYNCHRONOUS, true); |
| startException(StartStrategies.UNREGISTER, true); |
| startException(StartStrategies.BLOCK, true); |
| } |
| |
| private void startException(StartStrategy startStrategy, boolean recursive) throws Exception { |
| serviceFactory.throwExceptionFromCreate = true; |
| try { |
| start(recursive, startStrategy); |
| } catch (MockCreateException e) { |
| assertTrue(startStrategy == StartStrategies.SYNCHRONOUS || startStrategy == StartStrategies.BLOCK); |
| assertEquals(serviceFactory.createException, e); |
| } catch (UnregisterServiceException e) { |
| assertEquals(StartStrategies.UNREGISTER, startStrategy); |
| assertSame(serviceFactory.createException, e.getCause()); |
| assertEquals(serviceName, e.getServiceName()); |
| } |
| stop(StopStrategies.SYNCHRONOUS); |
| } |
| |
| /** |
| * Tests how the start strategies respond when confronted with an unsatisfied start condition. |
| * @throws Exception if a problem occurs |
| */ |
| public void testStartWaiting() throws Exception { |
| startWaiting(StartStrategies.ASYNCHRONOUS, false); |
| startWaiting(StartStrategies.SYNCHRONOUS, false); |
| startWaiting(StartStrategies.UNREGISTER, false); |
| |
| startWaiting(StartStrategies.ASYNCHRONOUS, false); |
| startWaiting(StartStrategies.SYNCHRONOUS, false); |
| startWaiting(StartStrategies.UNREGISTER, false); |
| } |
| |
| /** |
| * Tests how the startRecursive start strategies responed when confronted with an unsatisfied start condition. |
| * @throws Exception |
| */ |
| public void testStartWaitingRecursive() throws Exception { |
| startWaiting(StartStrategies.ASYNCHRONOUS, true); |
| startWaiting(StartStrategies.SYNCHRONOUS, true); |
| startWaiting(StartStrategies.UNREGISTER, true); |
| |
| startWaiting(StartStrategies.ASYNCHRONOUS, true); |
| startWaiting(StartStrategies.SYNCHRONOUS, true); |
| startWaiting(StartStrategies.UNREGISTER, true); |
| } |
| |
| private void startWaiting(StartStrategy startStrategy, boolean recursive) throws Exception { |
| startCondition.satisfied = false; |
| try { |
| start(recursive, startStrategy); |
| } catch (UnsatisfiedConditionsException e) { |
| assertTrue(startStrategy == StartStrategies.SYNCHRONOUS); |
| assertTrue(e.getUnsatisfiedConditions().contains(startCondition)); |
| assertEquals(serviceName, e.getServiceName()); |
| } catch (UnregisterServiceException e) { |
| assertEquals(StartStrategies.UNREGISTER, startStrategy); |
| assertEquals(serviceName, e.getServiceName()); |
| UnsatisfiedConditionsException cause = (UnsatisfiedConditionsException) e.getCause(); |
| assertTrue(cause.getUnsatisfiedConditions().contains(startCondition)); |
| assertEquals(serviceName, cause.getServiceName()); |
| } |
| stop(StopStrategies.SYNCHRONOUS); |
| } |
| |
| |
| /** |
| * Tests how the start strategies respond once a once unsatisfied start condition becomes satisfied. |
| * @throws Exception if a problem occurs |
| */ |
| public void testStartWaitingStart() throws Exception { |
| startWaitingStart(StartStrategies.ASYNCHRONOUS, false); |
| startWaitingStart(StartStrategies.SYNCHRONOUS, false); |
| startWaitingStart(StartStrategies.UNREGISTER, false); |
| |
| startWaitingStart(StartStrategies.ASYNCHRONOUS, false); |
| startWaitingStart(StartStrategies.SYNCHRONOUS, false); |
| startWaitingStart(StartStrategies.UNREGISTER, false); |
| } |
| |
| /** |
| * Tests how startRecursive start strategies respond once a once unsatisfied start condition becomes satisfied. |
| * @throws Exception if a problem occurs |
| */ |
| public void testStartWaitingStartRecursive() throws Exception { |
| startWaitingStart(StartStrategies.ASYNCHRONOUS, true); |
| startWaitingStart(StartStrategies.SYNCHRONOUS, true); |
| startWaitingStart(StartStrategies.UNREGISTER, true); |
| |
| startWaitingStart(StartStrategies.ASYNCHRONOUS, true); |
| startWaitingStart(StartStrategies.SYNCHRONOUS, true); |
| startWaitingStart(StartStrategies.UNREGISTER, true); |
| } |
| |
| private void startWaitingStart(StartStrategy startStrategy, boolean recursive) throws Exception { |
| startCondition.satisfied = recursive; |
| try { |
| start(recursive, startStrategy); |
| } catch (UnsatisfiedConditionsException e) { |
| assertTrue(startStrategy == StartStrategies.SYNCHRONOUS); |
| assertTrue(e.getUnsatisfiedConditions().contains(startCondition)); |
| assertEquals(serviceName, e.getServiceName()); |
| } catch (UnregisterServiceException e) { |
| assertEquals(StartStrategies.UNREGISTER, startStrategy); |
| assertEquals(serviceName, e.getServiceName()); |
| UnsatisfiedConditionsException cause = (UnsatisfiedConditionsException) e.getCause(); |
| assertTrue(cause.getUnsatisfiedConditions().contains(startCondition)); |
| assertEquals(serviceName, cause.getServiceName()); |
| } |
| try { |
| start(recursive, startStrategy); |
| } catch (UnsatisfiedConditionsException e) { |
| assertTrue(startStrategy == StartStrategies.SYNCHRONOUS); |
| assertTrue(e.getUnsatisfiedConditions().contains(startCondition)); |
| assertEquals(serviceName, e.getServiceName()); |
| } catch (UnregisterServiceException e) { |
| assertEquals(StartStrategies.UNREGISTER, startStrategy); |
| assertEquals(serviceName, e.getServiceName()); |
| UnsatisfiedConditionsException cause = (UnsatisfiedConditionsException) e.getCause(); |
| assertTrue(cause.getUnsatisfiedConditions().contains(startCondition)); |
| assertEquals(serviceName, cause.getServiceName()); |
| } |
| startCondition.satisfied = true; |
| start(recursive, startStrategy); |
| start(recursive, startStrategy); |
| stop(StopStrategies.SYNCHRONOUS); |
| } |
| |
| /** |
| * Tests the BLOCK start stragegy. |
| * @throws Exception if a problem occurs |
| */ |
| public void testBlockStartWaiting() throws Exception { |
| startCondition.satisfied = false; |
| startCondition.isSatisfiedSignal = new CountDownLatch(1); |
| FutureTask startTask = new FutureTask(new Callable() { |
| public Object call() throws Exception { |
| start(false, StartStrategies.BLOCK); |
| return Boolean.TRUE; |
| } |
| }); |
| Thread startThread = new Thread(startTask, "StartTask"); |
| startThread.setDaemon(true); |
| startThread.start(); |
| |
| // wait for the start thread to reach the startContion initialize method |
| assertTrue(startCondition.isSatisfiedSignal.await(5, TimeUnit.SECONDS)); |
| |
| // we should not have a service instance and be in the starting state |
| assertSame(ServiceState.STARTING, serviceManager.getState()); |
| assertNull(serviceManager.getService()); |
| assertEquals(0, serviceManager.getStartTime()); |
| assertNotNull(serviceMonitor.starting); |
| assertNull(serviceMonitor.waitingToStart); |
| assertNull(serviceMonitor.startError); |
| assertNull(serviceMonitor.running); |
| assertNull(serviceMonitor.stopping); |
| assertNull(serviceMonitor.stopError); |
| assertNull(serviceMonitor.stopped); |
| assertTrue(startCondition.initializeCalled); |
| assertTrue(startCondition.isSatisfiedCalled); |
| assertFalse(startCondition.destroyCalled); |
| |
| long now = System.currentTimeMillis(); |
| // introduce a bit of delay so subsequent times are much less likely to equal to not |
| Thread.sleep(500); |
| |
| startCondition.satisfied = true; |
| startCondition.context.setSatisfied(); |
| |
| // wait for the start task to complete |
| assertEquals(Boolean.TRUE, startTask.get(5, TimeUnit.SECONDS)); |
| |
| // we should be running |
| assertSame(ServiceState.RUNNING, serviceManager.getState()); |
| assertSame(SERVICE, serviceManager.getService()); |
| assertTrue(serviceManager.getStartTime() >= now); |
| assertNotNull(serviceMonitor.starting); |
| assertNull(serviceMonitor.waitingToStart); |
| assertNull(serviceMonitor.startError); |
| assertNotNull(serviceMonitor.running); |
| assertNull(serviceMonitor.stopping); |
| assertNull(serviceMonitor.stopError); |
| assertNull(serviceMonitor.stopped); |
| assertTrue(startCondition.initializeCalled); |
| assertTrue(startCondition.isSatisfiedCalled); |
| assertFalse(startCondition.destroyCalled); |
| |
| stop(StopStrategies.SYNCHRONOUS); |
| } |
| |
| /** |
| * Tests how start responds when the service factory is not enabled. |
| * @throws Exception if a problem occurs |
| */ |
| public void testDisabledStart() throws Exception { |
| disabledStart(StartStrategies.ASYNCHRONOUS); |
| disabledStart(StartStrategies.SYNCHRONOUS); |
| disabledStart(StartStrategies.UNREGISTER); |
| disabledStart(StartStrategies.BLOCK); |
| |
| disabledStart(StartStrategies.ASYNCHRONOUS); |
| disabledStart(StartStrategies.SYNCHRONOUS); |
| disabledStart(StartStrategies.UNREGISTER); |
| disabledStart(StartStrategies.BLOCK); |
| } |
| |
| private void disabledStart(StartStrategy startStrategy) throws Exception { |
| serviceFactory.setEnabled(false); |
| try { |
| serviceManager.start(false, startStrategy); |
| fail("A disabled service should throw an IllegalServiceStateException from start"); |
| } catch (IllegalServiceStateException e) { |
| // expected |
| assertEquals(serviceName, e.getServiceName()); |
| } |
| |
| // move to starting disable, move to running, and try to restart |
| serviceFactory.setEnabled(true); |
| startCondition.satisfied = false; |
| start(false, StartStrategies.ASYNCHRONOUS); |
| |
| serviceFactory.setEnabled(false); |
| startCondition.satisfied = true; |
| start(false, startStrategy); |
| start(false, startStrategy); |
| stop(StopStrategies.ASYNCHRONOUS); |
| try { |
| serviceManager.start(false, startStrategy); |
| fail("A disabled service should throw an IllegalServiceStateException from start"); |
| } catch (IllegalServiceStateException e) { |
| // expected |
| assertEquals(serviceName, e.getServiceName()); |
| } |
| } |
| |
| /** |
| * Tests how the stop strategies respond when destroyService throws an Exception. |
| * @throws Exception if a problem occurs |
| */ |
| public void testStopException() throws Exception { |
| stopException(StopStrategies.ASYNCHRONOUS); |
| stopException(StopStrategies.SYNCHRONOUS); |
| stopException(StopStrategies.FORCE); |
| stopException(StopStrategies.BLOCK); |
| } |
| |
| private void stopException(StopStrategy stopStrategy) throws Exception { |
| serviceFactory.throwExceptionFromDestroy = true; |
| start(false, StartStrategies.SYNCHRONOUS); |
| stop(stopStrategy); |
| } |
| |
| /** |
| * Tests how the start and stop strategies work when both create and destroy throw exceptions. |
| * @throws Exception if a problem occurs |
| */ |
| public void testStartStopsException() throws Exception { |
| startStopsException(StartStrategies.ASYNCHRONOUS, StopStrategies.ASYNCHRONOUS); |
| startStopsException(StartStrategies.ASYNCHRONOUS, StopStrategies.SYNCHRONOUS); |
| startStopsException(StartStrategies.ASYNCHRONOUS, StopStrategies.FORCE); |
| startStopsException(StartStrategies.ASYNCHRONOUS, StopStrategies.BLOCK); |
| startStopsException(StartStrategies.SYNCHRONOUS, StopStrategies.ASYNCHRONOUS); |
| startStopsException(StartStrategies.SYNCHRONOUS, StopStrategies.SYNCHRONOUS); |
| startStopsException(StartStrategies.SYNCHRONOUS, StopStrategies.FORCE); |
| startStopsException(StartStrategies.SYNCHRONOUS, StopStrategies.BLOCK); |
| startStopsException(StartStrategies.UNREGISTER, StopStrategies.ASYNCHRONOUS); |
| startStopsException(StartStrategies.UNREGISTER, StopStrategies.SYNCHRONOUS); |
| startStopsException(StartStrategies.UNREGISTER, StopStrategies.FORCE); |
| startStopsException(StartStrategies.UNREGISTER, StopStrategies.BLOCK); |
| startStopsException(StartStrategies.BLOCK, StopStrategies.ASYNCHRONOUS); |
| startStopsException(StartStrategies.BLOCK, StopStrategies.SYNCHRONOUS); |
| startStopsException(StartStrategies.BLOCK, StopStrategies.FORCE); |
| startStopsException(StartStrategies.BLOCK, StopStrategies.BLOCK); |
| } |
| |
| private void startStopsException(StartStrategy startStrategy, StopStrategy stopStrategy) throws Exception { |
| serviceFactory.throwExceptionFromCreate = true; |
| serviceFactory.throwExceptionFromDestroy = true; |
| try { |
| start(false, startStrategy); |
| } catch (MockCreateException e) { |
| assertTrue(startStrategy == StartStrategies.SYNCHRONOUS || startStrategy == StartStrategies.BLOCK); |
| assertEquals(serviceFactory.createException, e); |
| } catch (UnregisterServiceException e) { |
| assertEquals(StartStrategies.UNREGISTER, startStrategy); |
| assertEquals(serviceName, e.getServiceName()); |
| assertSame(serviceFactory.createException, e.getCause()); |
| } |
| stop(stopStrategy); |
| } |
| |
| /** |
| * Tests how stop strategies respond when confronted with an unsatisfied stop condition. |
| * @throws Exception if a problem occurs |
| */ |
| public void testWaitingStop() throws Exception { |
| waitingStop(StopStrategies.ASYNCHRONOUS); |
| waitingStop(StopStrategies.SYNCHRONOUS); |
| waitingStop(StopStrategies.FORCE); |
| } |
| |
| private void waitingStop(StopStrategy stopStrategy) throws Exception { |
| start(false, StartStrategies.SYNCHRONOUS); |
| stopCondition.satisfied = false; |
| try { |
| stop(stopStrategy); |
| } catch (UnsatisfiedConditionsException e) { |
| assertTrue(stopStrategy == StopStrategies.SYNCHRONOUS); |
| assertTrue(e.getUnsatisfiedConditions().contains(stopCondition)); |
| assertEquals(serviceName, e.getServiceName()); |
| } |
| try { |
| stop(stopStrategy); |
| } catch (UnsatisfiedConditionsException e) { |
| assertTrue(stopStrategy == StopStrategies.SYNCHRONOUS); |
| assertTrue(e.getUnsatisfiedConditions().contains(stopCondition)); |
| assertEquals(serviceName, e.getServiceName()); |
| } |
| |
| stopCondition.satisfied = true; |
| stop(stopStrategy); |
| } |
| |
| /** |
| * Tests the BLOCK stop strategy. |
| * @throws Exception if a problem occurs |
| */ |
| public void testBlockStopWaiting() throws Exception { |
| start(false, StartStrategies.SYNCHRONOUS); |
| stopCondition.satisfied = false; |
| stopCondition.isStatisfiedSignal = new CountDownLatch(1); |
| FutureTask stopTask = new FutureTask(new Callable() { |
| public Object call() throws Exception { |
| stop(StopStrategies.BLOCK); |
| return Boolean.TRUE; |
| } |
| }); |
| Thread stopThread = new Thread(stopTask, "StopTask"); |
| stopThread.setDaemon(true); |
| stopThread.start(); |
| |
| // wait for the stop thread to reach the stopContion initialize method |
| assertTrue(stopCondition.isStatisfiedSignal.await(5, TimeUnit.SECONDS)); |
| |
| // we should blocked waiting to stop |
| assertSame(ServiceState.STOPPING, serviceManager.getState()); |
| assertTrue(serviceManager.getStartTime() > 0); |
| assertSame(SERVICE, serviceManager.getService()); |
| assertNull(serviceMonitor.waitingToStop); |
| assertNull(serviceMonitor.stopError); |
| assertNull(serviceMonitor.stopped); |
| assertNull(serviceMonitor.unregistered); |
| assertFalse(startCondition.initializeCalled); |
| assertFalse(startCondition.isSatisfiedCalled); |
| assertFalse(startCondition.destroyCalled); |
| assertTrue(stopCondition.initializeCalled); |
| assertTrue(stopCondition.isSatisfiedCalled); |
| assertFalse(stopCondition.destroyCalled); |
| |
| // wait for the start task to complete |
| stopCondition.satisfied = true; |
| stopCondition.context.setSatisfied(); |
| assertEquals(Boolean.TRUE, stopTask.get(5, TimeUnit.SECONDS)); |
| |
| // we should be STOPPED |
| assertSame(ServiceState.STOPPED, serviceManager.getState()); |
| assertEquals(0, serviceManager.getStartTime()); |
| assertNull(serviceManager.getService()); |
| assertNotNull(serviceMonitor.stopping); |
| assertNull(serviceMonitor.waitingToStop); |
| assertNull(serviceMonitor.stopError); |
| assertNotNull(serviceMonitor.stopped); |
| assertNull(serviceMonitor.unregistered); |
| assertEquals(serviceMonitor.stopping.getEventId() + 1, serviceMonitor.stopped.getEventId()); |
| assertFalse(startCondition.initializeCalled); |
| assertFalse(startCondition.isSatisfiedCalled); |
| assertTrue(startCondition.destroyCalled); |
| assertTrue(stopCondition.initializeCalled); |
| assertTrue(stopCondition.isSatisfiedCalled); |
| assertTrue(stopCondition.destroyCalled); |
| } |
| |
| |
| /** |
| * Tests that start throws an exception when the service is in the stoping state. |
| * @throws Exception if a problem occurs |
| */ |
| public void testStartFromStopping() throws Exception { |
| startFromStopping(StartStrategies.ASYNCHRONOUS); |
| startFromStopping(StartStrategies.SYNCHRONOUS); |
| startFromStopping(StartStrategies.UNREGISTER); |
| startFromStopping(StartStrategies.BLOCK); |
| } |
| |
| private void startFromStopping(StartStrategy startStrategy) throws Exception { |
| start(false, StartStrategies.ASYNCHRONOUS); |
| stopCondition.satisfied = false; |
| stop(StopStrategies.ASYNCHRONOUS); |
| try { |
| serviceManager.start(false, startStrategy); |
| fail("Should have thrown an IllegalServiceStateException since start on a stopping service is an error"); |
| } catch (IllegalServiceStateException e) { |
| // expected |
| assertEquals(serviceName, e.getServiceName()); |
| } |
| stopCondition.satisfied = true; |
| stop(StopStrategies.ASYNCHRONOUS); |
| } |
| |
| /** |
| * Tests that a non-restartable servie is immedately started when initialized and stopped in destroy. |
| * @throws Exception if a problem occurs |
| */ |
| public void testNotRestartableInitDestroy() throws Exception { |
| notRestartableInitDestroy(StopStrategies.ASYNCHRONOUS); |
| notRestartableInitDestroy(StopStrategies.SYNCHRONOUS); |
| notRestartableInitDestroy(StopStrategies.FORCE); |
| notRestartableInitDestroy(StopStrategies.BLOCK); |
| } |
| |
| private void notRestartableInitDestroy(StopStrategy stopStrategy) throws Exception { |
| serviceFactory.restartable = false; |
| initialize(); |
| destroy(stopStrategy); |
| } |
| |
| /** |
| * Tests how initialize on a non-restartable service responds when an Exception is thrown from create service. |
| * @throws Exception if a problem occurs |
| */ |
| public void testNotRestartableInitException() throws Exception { |
| serviceFactory.throwExceptionFromCreate = true; |
| serviceFactory.restartable = false; |
| initialize(); |
| } |
| |
| /** |
| * Tests how initialize on a non-restartable service responds when confronted with an unsatisfied start condition. |
| * @throws Exception if a problem occurs |
| */ |
| public void testNotRestartableInitWaiting() throws Exception { |
| startCondition.satisfied = false; |
| serviceFactory.restartable = false; |
| initialize(); |
| } |
| |
| /** |
| * Tests how initialize on a non-restartable service responds when the service factory is disabled. |
| * @throws Exception if a problem occurs |
| */ |
| public void testNotRestartableInitDisabled() throws Exception { |
| serviceFactory.setEnabled(false); |
| serviceFactory.restartable = false; |
| initialize(); |
| } |
| |
| /** |
| * Tests how destroy on a non-restartable service responds when destroyService throws an exception. |
| * @throws Exception if a problem occurs |
| */ |
| public void testNotRestartableDestroyException() throws Exception { |
| notRestartableDestroyException(StopStrategies.ASYNCHRONOUS); |
| notRestartableDestroyException(StopStrategies.SYNCHRONOUS); |
| notRestartableDestroyException(StopStrategies.FORCE); |
| notRestartableDestroyException(StopStrategies.BLOCK); |
| } |
| |
| private void notRestartableDestroyException(StopStrategy stopStrategy) throws Exception { |
| serviceFactory.throwExceptionFromDestroy = true; |
| serviceFactory.restartable = false; |
| initialize(); |
| destroy(stopStrategy); |
| } |
| |
| |
| /** |
| * Tests how destroy on a non-restartable service responds when createService and destroyService throws an exception. |
| * @throws Exception if a problem occurs |
| */ |
| public void testNotRestartableInitDestroyException() throws Exception { |
| notRestartableInitDestroyException(StopStrategies.ASYNCHRONOUS); |
| notRestartableInitDestroyException(StopStrategies.SYNCHRONOUS); |
| notRestartableInitDestroyException(StopStrategies.FORCE); |
| notRestartableInitDestroyException(StopStrategies.BLOCK); |
| } |
| |
| private void notRestartableInitDestroyException(StopStrategy stopStrategy) throws Exception { |
| serviceFactory.throwExceptionFromCreate = true; |
| serviceFactory.throwExceptionFromDestroy = true; |
| serviceFactory.restartable = false; |
| initialize(); |
| destroy(stopStrategy); |
| } |
| |
| /** |
| * Tests how destroy on a non-restartable service responds when confronted with an unsatisfied stop condition. |
| * @throws Exception if a problem occurs |
| */ |
| public void testNotRestartableWaitingStop() throws Exception { |
| notRestartableWaitingDestroy(StopStrategies.ASYNCHRONOUS); |
| notRestartableWaitingDestroy(StopStrategies.SYNCHRONOUS); |
| notRestartableWaitingDestroy(StopStrategies.FORCE); |
| } |
| |
| private void notRestartableWaitingDestroy(StopStrategy stopStrategy) throws Exception { |
| serviceFactory.restartable = false; |
| initialize(); |
| stopCondition.satisfied = false; |
| destroy(stopStrategy); |
| destroy(stopStrategy); |
| stopCondition.satisfied = true; |
| destroy(stopStrategy); |
| } |
| |
| /** |
| * Tests the BLOCK stop strategy on a non-restartable service. |
| * @throws Exception if a problem occurs |
| */ |
| public void testNotRestartableBlockWaitingStop() throws Exception { |
| serviceFactory.restartable = false; |
| initialize(); |
| stopCondition.satisfied = false; |
| stopCondition.isStatisfiedSignal = new CountDownLatch(1); |
| FutureTask destroyTask = new FutureTask(new Callable() { |
| public Object call() throws Exception { |
| destroy(StopStrategies.BLOCK); |
| return Boolean.TRUE; |
| } |
| }); |
| Thread destroyThread = new Thread(destroyTask, "DestroyTask"); |
| destroyThread.setDaemon(true); |
| destroyThread.start(); |
| |
| // wait for the stop thread to reach the stopContion initialize method |
| assertTrue(stopCondition.isStatisfiedSignal.await(5, TimeUnit.SECONDS)); |
| |
| // we should blocked waiting to stop |
| assertSame(ServiceState.RUNNING, serviceManager.getState()); |
| assertSame(serviceName, serviceManager.getServiceName()); |
| assertSame(serviceFactory, serviceManager.getServiceFactory()); |
| assertSame(classLoader, serviceManager.getClassLoader()); |
| assertTrue(serviceManager.getStartTime() > 0); |
| assertNotNull(serviceManager.getService()); |
| assertNull(serviceMonitor.registered); |
| assertNull(serviceMonitor.starting); |
| assertNull(serviceMonitor.waitingToStart); |
| assertNull(serviceMonitor.startError); |
| assertNull(serviceMonitor.running); |
| assertNull(serviceMonitor.stopping); |
| assertNull(serviceMonitor.waitingToStop); |
| assertNull(serviceMonitor.stopError); |
| assertNull(serviceMonitor.stopped); |
| assertNull(serviceMonitor.unregistered); |
| |
| // wait for the destroy task to complete |
| stopCondition.satisfied = true; |
| stopCondition.context.setSatisfied(); |
| assertEquals(Boolean.TRUE, destroyTask.get(5, TimeUnit.SECONDS)); |
| |
| // we should be STOPPED |
| assertSame(ServiceState.STOPPED, serviceManager.getState()); |
| assertEquals(0, serviceManager.getStartTime()); |
| assertNull(serviceManager.getService()); |
| assertNull(serviceMonitor.registered); |
| assertNull(serviceMonitor.starting); |
| assertNull(serviceMonitor.waitingToStart); |
| assertNull(serviceMonitor.startError); |
| assertNull(serviceMonitor.running); |
| assertNotNull(serviceMonitor.stopping); |
| assertNull(serviceMonitor.waitingToStop); |
| assertNull(serviceMonitor.stopError); |
| assertNotNull(serviceMonitor.stopped); |
| assertNotNull(serviceMonitor.unregistered); |
| assertEquals(serviceMonitor.stopping.getEventId() + 1, serviceMonitor.stopped.getEventId()); |
| assertEquals(serviceMonitor.stopping.getEventId() + 2, serviceMonitor.unregistered.getEventId()); |
| assertFalse(startCondition.initializeCalled); |
| assertFalse(startCondition.isSatisfiedCalled); |
| assertTrue(startCondition.destroyCalled); |
| assertTrue(stopCondition.initializeCalled); |
| assertTrue(stopCondition.isSatisfiedCalled); |
| assertTrue(stopCondition.destroyCalled); |
| } |
| |
| private void initialize() throws Exception { |
| long now = System.currentTimeMillis(); |
| // introduce a bit of delay so subsequent times are much less likely to equal to not |
| Thread.sleep(50); |
| |
| serviceMonitor.reset(); |
| startCondition.reset(); |
| stopCondition.reset(); |
| kernel.reset(); |
| try { |
| serviceManager.initialize(); |
| } catch (MockCreateException e) { |
| assertTrue(serviceFactory.throwExceptionFromCreate); |
| assertSame(serviceFactory.createException, e); |
| } catch (UnsatisfiedConditionsException e) { |
| assertTrue(!startCondition.satisfied); |
| assertTrue(e.getUnsatisfiedConditions().contains(startCondition)); |
| assertEquals(serviceName, e.getServiceName()); |
| } catch (IllegalServiceStateException e) { |
| assertFalse(serviceFactory.isEnabled()); |
| assertEquals(serviceName, e.getServiceName()); |
| } |
| |
| assertSame(serviceName, serviceManager.getServiceName()); |
| assertSame(serviceFactory, serviceManager.getServiceFactory()); |
| assertSame(classLoader, serviceManager.getClassLoader()); |
| |
| if (serviceFactory.restartable) { |
| assertSame(ServiceState.STOPPED, serviceManager.getState()); |
| assertEquals(0, serviceManager.getStartTime()); |
| assertNull(serviceManager.getService()); |
| assertNotNull(serviceMonitor.registered); |
| assertNull(serviceMonitor.starting); |
| assertNull(serviceMonitor.waitingToStart); |
| assertNull(serviceMonitor.startError); |
| assertNull(serviceMonitor.running); |
| assertNull(serviceMonitor.stopping); |
| assertNull(serviceMonitor.waitingToStop); |
| assertNull(serviceMonitor.stopError); |
| assertNull(serviceMonitor.stopped); |
| assertNull(serviceMonitor.unregistered); |
| assertFalse(startCondition.initializeCalled); |
| assertFalse(startCondition.isSatisfiedCalled); |
| assertFalse(startCondition.destroyCalled); |
| assertFalse(stopCondition.initializeCalled); |
| assertFalse(stopCondition.isSatisfiedCalled); |
| assertFalse(stopCondition.destroyCalled); |
| } else if (!serviceFactory.isEnabled()) { |
| assertSame(ServiceState.STOPPED, serviceManager.getState()); |
| assertEquals(0, serviceManager.getStartTime()); |
| assertNull(serviceManager.getService()); |
| assertNull(serviceMonitor.registered); |
| assertNull(serviceMonitor.starting); |
| assertNull(serviceMonitor.waitingToStart); |
| assertNull(serviceMonitor.startError); |
| assertNull(serviceMonitor.running); |
| assertNull(serviceMonitor.stopping); |
| assertNull(serviceMonitor.stopError); |
| assertNull(serviceMonitor.stopped); |
| assertNull(serviceMonitor.unregistered); |
| assertFalse(startCondition.initializeCalled); |
| assertFalse(startCondition.isSatisfiedCalled); |
| assertFalse(startCondition.destroyCalled); |
| assertFalse(stopCondition.initializeCalled); |
| assertFalse(stopCondition.isSatisfiedCalled); |
| assertFalse(stopCondition.destroyCalled); |
| } else if (!serviceFactory.throwExceptionFromCreate && startCondition.satisfied) { |
| assertSame(ServiceState.RUNNING, serviceManager.getState()); |
| assertSame(SERVICE, serviceManager.getService()); |
| assertTrue(serviceManager.getStartTime() > now); |
| assertNotNull(serviceMonitor.registered); |
| assertNotNull(serviceMonitor.starting); |
| assertNull(serviceMonitor.waitingToStart); |
| assertNull(serviceMonitor.startError); |
| assertNotNull(serviceMonitor.running); |
| assertNull(serviceMonitor.stopping); |
| assertNull(serviceMonitor.stopError); |
| assertNull(serviceMonitor.stopped); |
| assertNull(serviceMonitor.unregistered); |
| assertEquals(serviceMonitor.registered.getEventId() + 1, serviceMonitor.starting.getEventId()); |
| assertEquals(serviceMonitor.registered.getEventId() + 2, serviceMonitor.running.getEventId()); |
| assertTrue(startCondition.initializeCalled); |
| assertTrue(startCondition.isSatisfiedCalled); |
| assertFalse(startCondition.destroyCalled); |
| assertFalse(stopCondition.initializeCalled); |
| assertFalse(stopCondition.isSatisfiedCalled); |
| assertFalse(stopCondition.destroyCalled); |
| } else { |
| assertSame(ServiceState.STOPPED, serviceManager.getState()); |
| assertEquals(0, serviceManager.getStartTime()); |
| assertNull(serviceManager.getService()); |
| assertNotNull(serviceMonitor.registered); |
| assertNotNull(serviceMonitor.starting); |
| assertNull(serviceMonitor.waitingToStart); |
| assertNull(serviceMonitor.startError); |
| assertNull(serviceMonitor.running); |
| assertNotNull(serviceMonitor.stopping); |
| assertNull(serviceMonitor.stopError); |
| assertNotNull(serviceMonitor.stopped); |
| assertNotNull(serviceMonitor.unregistered); |
| assertEquals(serviceMonitor.registered.getEventId() + 1, serviceMonitor.starting.getEventId()); |
| assertEquals(serviceMonitor.registered.getEventId() + 2, serviceMonitor.stopping.getEventId()); |
| assertEquals(serviceMonitor.registered.getEventId() + 3, serviceMonitor.stopped.getEventId()); |
| assertEquals(serviceMonitor.registered.getEventId() + 4, serviceMonitor.unregistered.getEventId()); |
| assertTrue(startCondition.initializeCalled); |
| assertTrue(startCondition.isSatisfiedCalled); |
| assertTrue(startCondition.destroyCalled); |
| assertFalse(stopCondition.initializeCalled); |
| assertFalse(stopCondition.isSatisfiedCalled); |
| assertFalse(stopCondition.destroyCalled); |
| } |
| } |
| |
| private void start(boolean recursive, StartStrategy startStrategy) throws Exception { |
| ServiceState initialState = serviceManager.getState(); |
| |
| long now = System.currentTimeMillis(); |
| // introduce a bit of delay so subsequent times are much less likely to equal to not |
| Thread.sleep(50); |
| |
| serviceMonitor.reset(); |
| startCondition.reset(); |
| stopCondition.reset(); |
| kernel.reset(); |
| serviceManager.start(recursive, startStrategy); |
| |
| assertSame(serviceName, serviceManager.getServiceName()); |
| assertSame(serviceFactory, serviceManager.getServiceFactory()); |
| assertSame(classLoader, serviceManager.getClassLoader()); |
| |
| // these events should never fire in response to start |
| assertNull(serviceMonitor.registered); |
| assertNull(serviceMonitor.waitingToStop); |
| assertNull(serviceMonitor.unregistered); |
| |
| if (initialState == ServiceState.RUNNING) { |
| // |
| // We were alredy running so nothing should have happened |
| // |
| assertSame(ServiceState.RUNNING, serviceManager.getState()); |
| assertSame(SERVICE, serviceManager.getService()); |
| assertTrue(serviceManager.getStartTime() > 0); |
| assertTrue(serviceManager.getStartTime() <= now); |
| |
| // verify expected events fired |
| assertNull(serviceMonitor.starting); |
| assertNull(serviceMonitor.waitingToStart); |
| assertNull(serviceMonitor.startError); |
| assertNull(serviceMonitor.running); |
| assertNull(serviceMonitor.stopping); |
| assertNull(serviceMonitor.stopError); |
| assertNull(serviceMonitor.stopped); |
| |
| // check if recursive fired |
| if (recursive) { |
| assertEquals(1, kernel.startRecursive.size()); |
| assertTrue(kernel.startRecursive.contains(ownedServiceName)); |
| } else { |
| assertTrue(kernel.startRecursive.isEmpty()); |
| } |
| |
| // start condition methods |
| assertFalse(startCondition.initializeCalled); |
| assertFalse(startCondition.isSatisfiedCalled); |
| assertFalse(startCondition.destroyCalled); |
| |
| // stop condition methods |
| assertFalse(stopCondition.initializeCalled); |
| assertFalse(stopCondition.isSatisfiedCalled); |
| assertFalse(stopCondition.destroyCalled); |
| } else if (!startCondition.satisfied) { |
| // |
| // watiting to start |
| // |
| assertTrue(initialState == ServiceState.STOPPED || initialState == ServiceState.STARTING); |
| |
| // we should have not a service instance and be in the starting state |
| assertSame(ServiceState.STARTING, serviceManager.getState()); |
| assertNull(serviceManager.getService()); |
| assertEquals(0, serviceManager.getStartTime()); |
| |
| |
| // verify expected events fired |
| assertNotNull(serviceMonitor.waitingToStart); |
| |
| assertNull(serviceMonitor.startError); |
| assertNull(serviceMonitor.running); |
| assertNull(serviceMonitor.stopping); |
| assertNull(serviceMonitor.stopError); |
| assertNull(serviceMonitor.stopped); |
| |
| // verify events fired in the correct order |
| if (initialState == ServiceState.STOPPED) { |
| assertEquals(serviceMonitor.starting.getEventId() + 1, serviceMonitor.waitingToStart.getEventId()); |
| } |
| |
| // our condition should be in the unsatisfied condition list |
| assertNotNull(serviceMonitor.waitingToStart.getUnsatisfiedConditions()); |
| assertTrue(serviceMonitor.waitingToStart.getUnsatisfiedConditions().contains(startCondition)); |
| |
| // check if recursive fired |
| assertTrue(kernel.startRecursive.isEmpty()); |
| |
| // start condition methods |
| if (initialState == ServiceState.STOPPED) { |
| assertTrue(startCondition.initializeCalled); |
| } else { |
| assertFalse(startCondition.initializeCalled); |
| } |
| assertTrue(startCondition.isSatisfiedCalled); |
| assertFalse(startCondition.destroyCalled); |
| |
| // stop condition methods |
| assertFalse(stopCondition.initializeCalled); |
| assertFalse(stopCondition.isSatisfiedCalled); |
| assertFalse(stopCondition.destroyCalled); |
| } else if (!serviceFactory.throwExceptionFromCreate) { |
| // |
| // Normal transition to RUNNING from either STOPPED or STARTING |
| // |
| assertTrue(initialState == ServiceState.STOPPED || initialState == ServiceState.STARTING); |
| |
| // we should have a service instance and be in the running state |
| assertSame(ServiceState.RUNNING, serviceManager.getState()); |
| assertSame(SERVICE, serviceManager.getService()); |
| assertTrue(serviceManager.getStartTime() > now); |
| |
| if (initialState == ServiceState.STOPPED) { |
| assertNotNull(serviceMonitor.starting); |
| } else { |
| assertNull(serviceMonitor.starting); |
| } |
| assertNull(serviceMonitor.waitingToStart); |
| assertNull(serviceMonitor.startError); |
| assertNotNull(serviceMonitor.running); |
| assertNull(serviceMonitor.stopping); |
| assertNull(serviceMonitor.stopError); |
| assertNull(serviceMonitor.stopped); |
| |
| // verify events fired in the correct order |
| if (initialState == ServiceState.STOPPED) { |
| assertEquals(serviceMonitor.starting.getEventId() + 1, serviceMonitor.running.getEventId()); |
| } |
| |
| // check if recursive fired |
| if (recursive) { |
| assertEquals(1, kernel.startRecursive.size()); |
| assertTrue(kernel.startRecursive.contains(ownedServiceName)); |
| } else { |
| assertTrue(kernel.startRecursive.isEmpty()); |
| } |
| |
| // start condition methods |
| if (initialState == ServiceState.STOPPED) { |
| assertTrue(startCondition.initializeCalled); |
| } else { |
| assertFalse(startCondition.initializeCalled); |
| } |
| assertTrue(startCondition.isSatisfiedCalled); |
| assertFalse(startCondition.destroyCalled); |
| |
| // stop condition methods |
| assertFalse(stopCondition.initializeCalled); |
| assertFalse(stopCondition.isSatisfiedCalled); |
| assertFalse(stopCondition.destroyCalled); |
| } else { |
| // |
| // Throw an exception from the create method |
| // |
| |
| // we should be stopped |
| assertSame(ServiceState.STOPPED, serviceManager.getState()); |
| assertNull(serviceManager.getService()); |
| assertEquals(0, serviceManager.getStartTime()); |
| |
| // verify expected events fired |
| assertNotNull(serviceMonitor.starting); |
| assertNull(serviceMonitor.waitingToStart); |
| assertNotNull(serviceMonitor.startError); |
| assertNull(serviceMonitor.running); |
| assertNotNull(serviceMonitor.stopping); |
| assertNull(serviceMonitor.stopError); |
| assertNotNull(serviceMonitor.stopped); |
| |
| // verify events fired in the correct order |
| assertEquals(serviceMonitor.starting.getEventId() + 1, serviceMonitor.startError.getEventId()); |
| assertEquals(serviceMonitor.starting.getEventId() + 2, serviceMonitor.stopping.getEventId()); |
| assertEquals(serviceMonitor.starting.getEventId() + 3, serviceMonitor.stopped.getEventId()); |
| |
| // verify that the exception is in the reson field |
| assertSame(serviceFactory.createException, serviceMonitor.startError.getCause()); |
| |
| // check if recursive fired |
| assertTrue(kernel.startRecursive.isEmpty()); |
| |
| // start condition methods |
| if (initialState == ServiceState.STOPPED) { |
| assertTrue(startCondition.initializeCalled); |
| } else { |
| assertFalse(startCondition.initializeCalled); |
| } |
| assertTrue(startCondition.isSatisfiedCalled); |
| assertTrue(startCondition.destroyCalled); |
| |
| // stop condition methods |
| assertFalse(stopCondition.initializeCalled); |
| assertFalse(stopCondition.isSatisfiedCalled); |
| assertFalse(stopCondition.destroyCalled); |
| } |
| } |
| |
| private void stop(StopStrategy stopStrategy) throws Exception { |
| serviceMonitor.reset(); |
| startCondition.reset(); |
| stopCondition.reset(); |
| kernel.reset(); |
| ServiceState initialState = serviceManager.getState(); |
| serviceManager.stop(stopStrategy); |
| |
| assertSame(serviceName, serviceManager.getServiceName()); |
| assertSame(serviceFactory, serviceManager.getServiceFactory()); |
| assertSame(classLoader, serviceManager.getClassLoader()); |
| |
| // these events should never fire in response to start |
| assertNull(serviceMonitor.registered); |
| assertNull(serviceMonitor.starting); |
| assertNull(serviceMonitor.waitingToStart); |
| assertNull(serviceMonitor.startError); |
| assertNull(serviceMonitor.running); |
| |
| if (initialState == ServiceState.STOPPED) { |
| // |
| // We were alredy stopped so nothing should have happened |
| // |
| assertEquals(0, serviceManager.getStartTime()); |
| assertNull(serviceManager.getService()); |
| assertSame(ServiceState.STOPPED, serviceManager.getState()); |
| |
| assertNull(serviceMonitor.stopping); |
| assertNull(serviceMonitor.waitingToStop); |
| assertNull(serviceMonitor.stopError); |
| assertNull(serviceMonitor.stopped); |
| assertNull(serviceMonitor.unregistered); |
| |
| // start condition methods |
| assertFalse(startCondition.initializeCalled); |
| assertFalse(startCondition.isSatisfiedCalled); |
| assertFalse(startCondition.destroyCalled); |
| |
| // stop condition methods |
| assertFalse(stopCondition.initializeCalled); |
| assertFalse(stopCondition.isSatisfiedCalled); |
| assertFalse(stopCondition.destroyCalled); |
| } else if (!stopCondition.satisfied && stopStrategy != StopStrategies.FORCE) { |
| // |
| // waiting to stop |
| // |
| assertSame(ServiceState.STOPPING, serviceManager.getState()); |
| assertTrue(serviceManager.getStartTime() > 0); |
| assertSame(SERVICE, serviceManager.getService()); |
| |
| // verify expected events fired |
| if (initialState != ServiceState.STOPPING) { |
| assertNotNull(serviceMonitor.stopping); |
| } |
| assertNotNull(serviceMonitor.waitingToStop); |
| assertNull(serviceMonitor.stopError); |
| assertNull(serviceMonitor.stopped); |
| assertNull(serviceMonitor.unregistered); |
| |
| // verify events fired in the correct order |
| if (initialState != ServiceState.STOPPING) { |
| assertEquals(serviceMonitor.stopping.getEventId() + 1, serviceMonitor.waitingToStop.getEventId()); |
| } |
| |
| // our condition should be in the unsatisfied condition list |
| assertNotNull(serviceMonitor.waitingToStop.getUnsatisfiedConditions()); |
| assertTrue(serviceMonitor.waitingToStop.getUnsatisfiedConditions().contains(stopCondition)); |
| |
| // start condition methods |
| assertFalse(startCondition.initializeCalled); |
| assertFalse(startCondition.isSatisfiedCalled); |
| assertFalse(startCondition.destroyCalled); |
| |
| // stop condition methods |
| if (initialState == ServiceState.RUNNING) { |
| assertTrue(stopCondition.initializeCalled); |
| } else { |
| assertFalse(stopCondition.initializeCalled); |
| } |
| assertTrue(stopCondition.isSatisfiedCalled); |
| assertFalse(stopCondition.destroyCalled); |
| } else if (!serviceFactory.throwExceptionFromDestroy) { |
| // |
| // Normal transition to STOPPED from either STARTING, RUNNING or STOPPING |
| // |
| assertSame(ServiceState.STOPPED, serviceManager.getState()); |
| assertEquals(0, serviceManager.getStartTime()); |
| assertNull(serviceManager.getService()); |
| |
| // verify expected events fired |
| if (initialState != ServiceState.STOPPING) { |
| assertNotNull(serviceMonitor.stopping); |
| } |
| assertNull(serviceMonitor.waitingToStop); |
| if (stopStrategy == StopStrategies.FORCE) { |
| assertNotNull(serviceMonitor.stopError); |
| ForcedStopException cause = (ForcedStopException) serviceMonitor.stopError.getCause(); |
| assertTrue(cause.getUnsatisfiedConditions().contains(stopCondition)); |
| assertEquals(serviceName, cause.getServiceName()); |
| } else { |
| assertNull(serviceMonitor.stopError); |
| } |
| assertNotNull(serviceMonitor.stopped); |
| assertNull(serviceMonitor.unregistered); |
| |
| // verify events fired in the correct order |
| if (stopStrategy == StopStrategies.FORCE) { |
| assertEquals(serviceMonitor.stopping.getEventId() + 1, serviceMonitor.stopError.getEventId()); |
| assertEquals(serviceMonitor.stopping.getEventId() + 2, serviceMonitor.stopped.getEventId()); |
| } else if (initialState != ServiceState.STOPPING) { |
| assertEquals(serviceMonitor.stopping.getEventId() + 1, serviceMonitor.stopped.getEventId()); |
| } |
| |
| // start condition methods |
| assertFalse(startCondition.initializeCalled); |
| assertFalse(startCondition.isSatisfiedCalled); |
| assertTrue(startCondition.destroyCalled); |
| |
| // stop condition methods |
| if (initialState == ServiceState.STOPPING) { |
| assertFalse(stopCondition.initializeCalled); |
| assertTrue(stopCondition.isSatisfiedCalled); |
| assertTrue(stopCondition.destroyCalled); |
| } else { |
| assertTrue(stopCondition.initializeCalled); |
| assertTrue(stopCondition.isSatisfiedCalled); |
| assertTrue(stopCondition.destroyCalled); |
| } |
| } else { |
| // |
| // Throw an exception from the destroy method |
| // |
| assertEquals(0, serviceManager.getStartTime()); |
| assertNull(serviceManager.getService()); |
| assertSame(ServiceState.STOPPED, serviceManager.getState()); |
| |
| // verify expected events fired |
| if (initialState != ServiceState.STOPPING) { |
| assertNotNull(serviceMonitor.stopping); |
| } |
| assertNull(serviceMonitor.waitingToStop); |
| assertNotNull(serviceMonitor.stopError); |
| assertNotNull(serviceMonitor.stopped); |
| assertNull(serviceMonitor.unregistered); |
| |
| // verify events fired in the correct order |
| if (initialState != ServiceState.STOPPING) { |
| assertEquals(serviceMonitor.stopping.getEventId() + 1, serviceMonitor.stopError.getEventId()); |
| assertEquals(serviceMonitor.stopping.getEventId() + 2, serviceMonitor.stopped.getEventId()); |
| } else { |
| assertEquals(serviceMonitor.stopError.getEventId() + 1, serviceMonitor.stopped.getEventId()); |
| } |
| |
| // verify that the exception is in the reson field |
| assertSame(serviceFactory.destroyException, serviceMonitor.stopError.getCause()); |
| |
| // start condition methods |
| assertFalse(startCondition.initializeCalled); |
| assertFalse(startCondition.isSatisfiedCalled); |
| assertTrue(startCondition.destroyCalled); |
| |
| // stop condition methods |
| if (initialState == ServiceState.RUNNING) { |
| assertTrue(stopCondition.initializeCalled); |
| } else { |
| assertFalse(stopCondition.initializeCalled); |
| } |
| assertTrue(stopCondition.isSatisfiedCalled); |
| assertTrue(stopCondition.destroyCalled); |
| } |
| } |
| |
| private void destroy(StopStrategy stopStrategy) { |
| ServiceState initialState = serviceManager.getState(); |
| serviceMonitor.reset(); |
| startCondition.reset(); |
| stopCondition.reset(); |
| kernel.reset(); |
| try { |
| serviceManager.destroy(stopStrategy); |
| } catch (IllegalServiceStateException e) { |
| assertFalse(stopCondition.satisfied); |
| assertSame(StopStrategies.ASYNCHRONOUS, stopStrategy); |
| assertEquals(serviceName, e.getServiceName()); |
| } catch (UnsatisfiedConditionsException e) { |
| assertFalse(stopCondition.satisfied); |
| assertSame(StopStrategies.SYNCHRONOUS, stopStrategy); |
| assertTrue(e.getUnsatisfiedConditions().contains(stopCondition)); |
| assertEquals(serviceName, e.getServiceName()); |
| } |
| |
| if (serviceFactory.restartable || initialState == ServiceState.STOPPED) { |
| assertSame(ServiceState.STOPPED, serviceManager.getState()); |
| assertSame(serviceName, serviceManager.getServiceName()); |
| assertSame(serviceFactory, serviceManager.getServiceFactory()); |
| assertSame(classLoader, serviceManager.getClassLoader()); |
| assertEquals(0, serviceManager.getStartTime()); |
| assertNull(serviceManager.getService()); |
| // verify expected events fired |
| assertNull(serviceMonitor.registered); |
| assertNull(serviceMonitor.starting); |
| assertNull(serviceMonitor.waitingToStart); |
| assertNull(serviceMonitor.startError); |
| assertNull(serviceMonitor.running); |
| assertNull(serviceMonitor.stopping); |
| assertNull(serviceMonitor.waitingToStop); |
| assertNull(serviceMonitor.stopError); |
| assertNull(serviceMonitor.stopped); |
| assertNotNull(serviceMonitor.unregistered); |
| } else if (!stopCondition.satisfied && stopStrategy != StopStrategies.FORCE) { |
| assertSame(ServiceState.RUNNING, serviceManager.getState()); |
| assertSame(serviceName, serviceManager.getServiceName()); |
| assertSame(serviceFactory, serviceManager.getServiceFactory()); |
| assertSame(classLoader, serviceManager.getClassLoader()); |
| assertTrue(serviceManager.getStartTime() > 0); |
| assertNotNull(serviceManager.getService()); |
| assertNull(serviceMonitor.registered); |
| assertNull(serviceMonitor.starting); |
| assertNull(serviceMonitor.waitingToStart); |
| assertNull(serviceMonitor.startError); |
| assertNull(serviceMonitor.running); |
| assertNull(serviceMonitor.stopping); |
| if (stopStrategy == StopStrategies.ASYNCHRONOUS) { |
| assertNotNull(serviceMonitor.waitingToStop); |
| assertTrue(serviceMonitor.waitingToStop.getUnsatisfiedConditions().contains(stopCondition)); |
| } else { |
| assertNull(serviceMonitor.waitingToStop); |
| } |
| assertNull(serviceMonitor.stopError); |
| assertNull(serviceMonitor.stopped); |
| assertNull(serviceMonitor.unregistered); |
| } else if (!serviceFactory.throwExceptionFromDestroy) { |
| assertSame(ServiceState.STOPPED, serviceManager.getState()); |
| assertEquals(0, serviceManager.getStartTime()); |
| assertNull(serviceManager.getService()); |
| assertNull(serviceMonitor.registered); |
| assertNull(serviceMonitor.starting); |
| assertNull(serviceMonitor.waitingToStart); |
| assertNull(serviceMonitor.startError); |
| assertNull(serviceMonitor.running); |
| assertNotNull(serviceMonitor.stopping); |
| assertNull(serviceMonitor.waitingToStop); |
| if (!stopCondition.satisfied && stopStrategy == StopStrategies.FORCE) { |
| assertNotNull(serviceMonitor.stopError); |
| } else { |
| assertNull(serviceMonitor.stopError); |
| } |
| assertNotNull(serviceMonitor.stopped); |
| assertNotNull(serviceMonitor.unregistered); |
| if (!stopCondition.satisfied && stopStrategy == StopStrategies.FORCE) { |
| assertEquals(serviceMonitor.stopError.getEventId() + 1, serviceMonitor.stopping.getEventId()); |
| assertEquals(serviceMonitor.stopError.getEventId() + 2, serviceMonitor.stopped.getEventId()); |
| assertEquals(serviceMonitor.stopError.getEventId() + 3, serviceMonitor.unregistered.getEventId()); |
| } else { |
| assertEquals(serviceMonitor.stopping.getEventId() + 1, serviceMonitor.stopped.getEventId()); |
| assertEquals(serviceMonitor.stopping.getEventId() + 2, serviceMonitor.unregistered.getEventId()); |
| |
| } |
| assertFalse(startCondition.initializeCalled); |
| assertFalse(startCondition.isSatisfiedCalled); |
| assertTrue(startCondition.destroyCalled); |
| // There is no way to determine if the init should have been called |
| // stopCondition.initializeCalled |
| assertTrue(stopCondition.isSatisfiedCalled); |
| assertTrue(stopCondition.destroyCalled); |
| } else { |
| assertSame(ServiceState.STOPPED, serviceManager.getState()); |
| assertEquals(0, serviceManager.getStartTime()); |
| assertNull(serviceManager.getService()); |
| assertNull(serviceMonitor.registered); |
| assertNull(serviceMonitor.starting); |
| assertNull(serviceMonitor.waitingToStart); |
| assertNull(serviceMonitor.startError); |
| assertNull(serviceMonitor.running); |
| assertNotNull(serviceMonitor.stopping); |
| assertNull(serviceMonitor.waitingToStop); |
| assertNotNull(serviceMonitor.stopError); |
| assertNotNull(serviceMonitor.stopped); |
| assertNotNull(serviceMonitor.unregistered); |
| assertEquals(serviceMonitor.stopping.getEventId() + 1, serviceMonitor.stopError.getEventId()); |
| assertEquals(serviceMonitor.stopping.getEventId() + 2, serviceMonitor.stopped.getEventId()); |
| assertEquals(serviceMonitor.stopping.getEventId() + 3, serviceMonitor.unregistered.getEventId()); |
| assertFalse(startCondition.initializeCalled); |
| assertFalse(startCondition.isSatisfiedCalled); |
| assertTrue(startCondition.destroyCalled); |
| assertTrue(stopCondition.initializeCalled); |
| assertTrue(stopCondition.isSatisfiedCalled); |
| assertTrue(stopCondition.destroyCalled); |
| } |
| } |
| |
| protected void setUp() throws Exception { |
| super.setUp(); |
| serviceManager = new ServiceManager(kernel, |
| 0, |
| serviceName, |
| serviceFactory, |
| classLoader, |
| serviceMonitor, |
| 10, |
| TimeUnit.SECONDS); |
| } |
| |
| private class MockServiceFactory extends StaticServiceFactory { |
| private boolean restartable = true; |
| private boolean throwExceptionFromCreate = false; |
| private boolean throwExceptionFromDestroy = false; |
| private MockCreateException createException; |
| private MockDestroyException destroyException; |
| private ServiceContext serviceContext; |
| |
| private MockServiceFactory() throws NullPointerException { |
| super(SERVICE); |
| } |
| |
| public Set getOwnedServices() { |
| return Collections.singleton(ownedServiceName); |
| } |
| |
| public boolean isRestartable() { |
| return restartable; |
| } |
| |
| public synchronized Set getStartConditions() { |
| Set startConditions = new HashSet(super.getStartConditions()); |
| startConditions.add(startCondition); |
| return startConditions; |
| } |
| |
| public synchronized Set getStopConditions() { |
| Set stopConditions = new HashSet(super.getStopConditions()); |
| stopConditions.add(stopCondition); |
| return stopConditions; |
| } |
| |
| public Object createService(ServiceContext serviceContext) { |
| assertValidServiceContext(serviceContext); |
| this.serviceContext = serviceContext; |
| |
| createException = new MockCreateException("MockCreateException"); |
| if (throwExceptionFromCreate) throw createException; |
| return super.createService(serviceContext); |
| } |
| |
| public void destroyService(ServiceContext serviceContext) { |
| assertSame(this.serviceContext, serviceContext); |
| assertValidServiceContext(serviceContext); |
| |
| destroyException = new MockDestroyException("MockDestroyException"); |
| if (throwExceptionFromDestroy) throw destroyException; |
| super.destroyService(serviceContext); |
| } |
| |
| private void assertValidServiceContext(ServiceContext serviceContext) { |
| assertSame(serviceName, serviceContext.getServiceName()); |
| assertSame(kernel, serviceContext.getKernel()); |
| assertSame(classLoader, serviceContext.getClassLoader()); |
| } |
| |
| } |
| |
| private static class MockCreateException extends RuntimeException { |
| private MockCreateException(String message) { |
| super(message); |
| } |
| } |
| |
| private static class MockDestroyException extends RuntimeException { |
| private MockDestroyException(String message) { |
| super(message); |
| } |
| } |
| |
| private class MockStartCondition implements ServiceCondition { |
| private boolean satisfied = true; |
| private boolean initializeCalled = false; |
| private boolean isSatisfiedCalled = false; |
| private boolean destroyCalled = false; |
| private ServiceConditionContext context; |
| private CountDownLatch isSatisfiedSignal; |
| |
| private void reset() { |
| initializeCalled = false; |
| isSatisfiedCalled = false; |
| destroyCalled = false; |
| } |
| |
| public void initialize(ServiceConditionContext context) { |
| assertValidServiceConditionContext(context); |
| initializeCalled = true; |
| this.context = context; |
| } |
| |
| public boolean isSatisfied() { |
| isSatisfiedCalled = true; |
| if (isSatisfiedSignal != null) { |
| isSatisfiedSignal.countDown(); |
| } |
| return satisfied; |
| } |
| |
| public void destroy() { |
| destroyCalled = true; |
| } |
| } |
| |
| private class MockStopCondition implements ServiceCondition { |
| private boolean satisfied = true; |
| private boolean initializeCalled = false; |
| private boolean isSatisfiedCalled = false; |
| private boolean destroyCalled = false; |
| private ServiceConditionContext context; |
| private CountDownLatch isStatisfiedSignal; |
| |
| private void reset() { |
| initializeCalled = false; |
| isSatisfiedCalled = false; |
| destroyCalled = false; |
| } |
| |
| public void initialize(ServiceConditionContext context) { |
| assertValidServiceConditionContext(context); |
| initializeCalled = true; |
| this.context = context; |
| } |
| |
| public boolean isSatisfied() { |
| isSatisfiedCalled = true; |
| if (isStatisfiedSignal != null) { |
| isStatisfiedSignal.countDown(); |
| } |
| return satisfied; |
| } |
| |
| public void destroy() { |
| destroyCalled = true; |
| } |
| } |
| |
| private void assertValidServiceConditionContext(ServiceConditionContext context) { |
| assertSame(serviceName, context.getServiceName()); |
| assertSame(kernel, context.getKernel()); |
| assertSame(classLoader, context.getClassLoader()); |
| } |
| |
| private class MockServiceMonitor implements ServiceMonitor { |
| private ServiceEvent registered; |
| private ServiceEvent starting; |
| private ServiceEvent waitingToStart; |
| private ServiceEvent startError; |
| private ServiceEvent running; |
| private ServiceEvent stopping; |
| private ServiceEvent waitingToStop; |
| private ServiceEvent stopError; |
| private ServiceEvent stopped; |
| private ServiceEvent unregistered; |
| |
| private void reset() { |
| registered = null; |
| starting = null; |
| waitingToStart = null; |
| startError = null; |
| running = null; |
| stopping = null; |
| waitingToStop = null; |
| stopError = null; |
| stopped = null; |
| unregistered = null; |
| } |
| |
| public void serviceRegistered(ServiceEvent serviceEvent) { |
| registered = serviceEvent; |
| assertValidEvent(serviceEvent, false); |
| } |
| |
| public void serviceStarting(ServiceEvent serviceEvent) { |
| starting = serviceEvent; |
| assertValidEvent(serviceEvent, false); |
| } |
| |
| public void serviceWaitingToStart(ServiceEvent serviceEvent) { |
| waitingToStart = serviceEvent; |
| assertValidEvent(serviceEvent, false); |
| } |
| |
| public void serviceStartError(ServiceEvent serviceEvent) { |
| startError = serviceEvent; |
| assertValidEvent(serviceEvent, false); |
| } |
| |
| public void serviceRunning(ServiceEvent serviceEvent) { |
| running = serviceEvent; |
| assertValidEvent(serviceEvent, true); |
| } |
| |
| public void serviceStopping(ServiceEvent serviceEvent) { |
| stopping = serviceEvent; |
| assertValidEvent(serviceEvent, false); |
| } |
| |
| public void serviceWaitingToStop(ServiceEvent serviceEvent) { |
| waitingToStop = serviceEvent; |
| assertValidEvent(serviceEvent, true); |
| } |
| |
| public void serviceStopError(ServiceEvent serviceEvent) { |
| stopError = serviceEvent; |
| assertValidEvent(serviceEvent, false); |
| } |
| |
| public void serviceStopped(ServiceEvent serviceEvent) { |
| stopped = serviceEvent; |
| assertValidEvent(serviceEvent, false); |
| } |
| |
| public void serviceUnregistered(ServiceEvent serviceEvent) { |
| unregistered = serviceEvent; |
| assertValidEvent(serviceEvent, false); |
| } |
| |
| private void assertValidEvent(ServiceEvent serviceEvent, boolean mustHaveService) { |
| assertSame(serviceName, serviceEvent.getServiceName()); |
| assertSame(kernel, serviceEvent.getKernel()); |
| assertSame(classLoader, serviceEvent.getClassLoader()); |
| assertSame(serviceFactory, serviceEvent.getServiceFactory()); |
| if (mustHaveService) { |
| assertSame(SERVICE, serviceEvent.getService()); |
| } |
| } |
| } |
| |
| private static class MockKernel implements Kernel { |
| private List startRecursive = new LinkedList(); |
| |
| private void reset() { |
| startRecursive.clear(); |
| } |
| |
| public void startServiceRecursive(ServiceName serviceName) throws ServiceNotFoundException, IllegalStateException { |
| startRecursive.add(serviceName); |
| } |
| |
| public void startServiceRecursive(ServiceName serviceName, StartStrategy startStrategy) throws ServiceNotFoundException, IllegalServiceStateException, UnsatisfiedConditionsException, Exception { |
| startRecursive.add(serviceName); |
| } |
| |
| // |
| // Unimplemented methods |
| // |
| public void startService(ServiceName serviceName) throws ServiceNotFoundException, IllegalStateException { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public void startService(ServiceName serviceName, StartStrategy startStrategy) throws ServiceNotFoundException, IllegalServiceStateException, UnsatisfiedConditionsException, Exception { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public void stopService(ServiceName serviceName) throws ServiceNotFoundException { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public void stopService(ServiceName serviceName, StopStrategy stopStrategy) throws ServiceNotFoundException, UnsatisfiedConditionsException { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public void destroy() { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public boolean isRunning() { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public String getKernelName() { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public void registerService(ServiceName serviceName, ServiceFactory serviceFactory, ClassLoader classLoader) throws ServiceAlreadyExistsException, ServiceRegistrationException { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public void unregisterService(ServiceName serviceName) throws ServiceNotFoundException, IllegalStateException { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public void unregisterService(ServiceName serviceName, StopStrategy stopStrategy) throws ServiceNotFoundException, ServiceRegistrationException { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public boolean isRegistered(ServiceName serviceName) { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public ServiceState getServiceState(ServiceName serviceName) throws ServiceNotFoundException { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public long getServiceStartTime(ServiceName serviceName) throws ServiceNotFoundException { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public boolean isServiceEnabled(ServiceName serviceName) throws ServiceNotFoundException { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public void setServiceEnabled(ServiceName serviceName, boolean enabled) throws ServiceNotFoundException { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public Object getService(ServiceName serviceName) throws ServiceNotFoundException, IllegalArgumentException { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public Object getService(Class type) { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public List getServices(Class type) { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public ServiceFactory getServiceFactory(ServiceName serviceName) throws ServiceNotFoundException { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public ServiceFactory getServiceFactory(Class type) { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public List getServiceFactories(Class type) { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public ClassLoader getClassLoaderFor(ServiceName serviceName) throws ServiceNotFoundException { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public void addKernelMonitor(KernelMonitor kernelMonitor) { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public void removeKernelMonitor(KernelMonitor kernelMonitor) { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public void addServiceMonitor(ServiceMonitor serviceMonitor) { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public void addServiceMonitor(ServiceMonitor serviceMonitor, ServiceName serviceName) { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public void removeServiceMonitor(ServiceMonitor serviceMonitor) { |
| throw new UnsupportedOperationException(); |
| } |
| } |
| } |
