guava-tests/test/com/google/common/util/concurrent/ServiceManagerTest.java - platform/external/guava - Git at Google

 /*
  * Copyright (C) 2012 The Guava 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 com.google.common.util.concurrent;

 import static java.util.Arrays.asList;

 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
 import com.google.common.testing.NullPointerTester;
 import com.google.common.testing.TestLogHandler;
 import com.google.common.util.concurrent.ServiceManager.Listener;

 import junit.framework.TestCase;

 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
 import java.util.Set;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.Executor;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.logging.Formatter;
 import java.util.logging.Level;
 import java.util.logging.LogRecord;
 import java.util.logging.Logger;

 /**
  * Tests for {@link ServiceManager}.
  *
  * @author Luke Sandberg
  * @author Chris Nokleberg
  */
 public class ServiceManagerTest extends TestCase {

   private static class NoOpService extends AbstractService {
     @Override protected void doStart() {
       notifyStarted();
     }

     @Override protected void doStop() {
       notifyStopped();
     }
   }

   /*
    * A NoOp service that will delay the startup and shutdown notification for a configurable amount
    * of time.
    */
   private static class NoOpDelayedSerivce extends NoOpService {
     private long delay;

     public NoOpDelayedSerivce(long delay) {
       this.delay = delay;
     }

     @Override protected void doStart() {
       new Thread() {
         @Override public void run() {
           Uninterruptibles.sleepUninterruptibly(delay, TimeUnit.MILLISECONDS);
           notifyStarted();
         }
       }.start();
     }

     @Override protected void doStop() {
       new Thread() {
         @Override public void run() {
           Uninterruptibles.sleepUninterruptibly(delay, TimeUnit.MILLISECONDS);
           notifyStopped();
         }
       }.start();
     }
   }

   private static class FailStartService extends NoOpService {
     @Override protected void doStart() {
       notifyFailed(new IllegalStateException("failed"));
     }
   }

   private static class FailRunService extends NoOpService {
     @Override protected void doStart() {
       super.doStart();
       notifyFailed(new IllegalStateException("failed"));
     }
   }

   private static class FailStopService extends NoOpService {
     @Override protected void doStop() {
       notifyFailed(new IllegalStateException("failed"));
     }
   }

   public void testServiceStartupTimes() {
     Service a = new NoOpDelayedSerivce(150);
     Service b = new NoOpDelayedSerivce(353);
     ServiceManager serviceManager = new ServiceManager(asList(a, b));
     serviceManager.startAsync().awaitHealthy();
     ImmutableMap<Service, Long> startupTimes = serviceManager.startupTimes();
     assertEquals(2, startupTimes.size());
     assertTrue(startupTimes.get(a) >= 150);
     assertTrue(startupTimes.get(b) >= 353);
   }

   public void testServiceStartStop() {
     Service a = new NoOpService();
     Service b = new NoOpService();
     ServiceManager manager = new ServiceManager(asList(a, b));
     RecordingListener listener = new RecordingListener();
     manager.addListener(listener);
     assertState(manager, Service.State.NEW, a, b);
     assertFalse(manager.isHealthy());
     manager.startAsync().awaitHealthy();
     assertState(manager, Service.State.RUNNING, a, b);
     assertTrue(manager.isHealthy());
     assertTrue(listener.healthyCalled);
     assertFalse(listener.stoppedCalled);
     assertTrue(listener.failedServices.isEmpty());
     manager.stopAsync().awaitStopped();
     assertState(manager, Service.State.TERMINATED, a, b);
     assertFalse(manager.isHealthy());
     assertTrue(listener.stoppedCalled);
     assertTrue(listener.failedServices.isEmpty());
   }

   public void testFailStart() throws Exception {
     Service a = new NoOpService();
     Service b = new FailStartService();
     Service c = new NoOpService();
     Service d = new FailStartService();
     Service e = new NoOpService();
     ServiceManager manager = new ServiceManager(asList(a, b, c, d, e));
     RecordingListener listener = new RecordingListener();
     manager.addListener(listener);
     assertState(manager, Service.State.NEW, a, b, c, d, e);
     try {
       manager.startAsync().awaitHealthy();
       fail();
     } catch (IllegalStateException expected) {
     }
     assertFalse(listener.healthyCalled);
     assertState(manager, Service.State.RUNNING, a, c, e);
     assertEquals(ImmutableSet.of(b, d), listener.failedServices);
     assertState(manager, Service.State.FAILED, b, d);
     assertFalse(manager.isHealthy());

     manager.stopAsync().awaitStopped();
     assertFalse(manager.isHealthy());
     assertFalse(listener.healthyCalled);
     assertTrue(listener.stoppedCalled);
   }

   public void testFailRun() throws Exception {
     Service a = new NoOpService();
     Service b = new FailRunService();
     ServiceManager manager = new ServiceManager(asList(a, b));
     RecordingListener listener = new RecordingListener();
     manager.addListener(listener);
     assertState(manager, Service.State.NEW, a, b);
     try {
       manager.startAsync().awaitHealthy();
       fail();
     } catch (IllegalStateException expected) {
     }
     assertTrue(listener.healthyCalled);
     assertEquals(ImmutableSet.of(b), listener.failedServices);

     manager.stopAsync().awaitStopped();
     assertState(manager, Service.State.FAILED, b);
     assertState(manager, Service.State.TERMINATED, a);

     assertTrue(listener.stoppedCalled);
   }

   public void testFailStop() throws Exception {
     Service a = new NoOpService();
     Service b = new FailStopService();
     Service c = new NoOpService();
     ServiceManager manager = new ServiceManager(asList(a, b, c));
     RecordingListener listener = new RecordingListener();
     manager.addListener(listener);

     manager.startAsync().awaitHealthy();
     assertTrue(listener.healthyCalled);
     assertFalse(listener.stoppedCalled);
     manager.stopAsync().awaitStopped();

     assertTrue(listener.stoppedCalled);
     assertEquals(ImmutableSet.of(b), listener.failedServices);
     assertState(manager, Service.State.FAILED, b);
     assertState(manager, Service.State.TERMINATED, a, c);
   }

   public void testToString() throws Exception {
     Service a = new NoOpService();
     Service b = new FailStartService();
     ServiceManager manager = new ServiceManager(asList(a, b));
     String toString = manager.toString();
     assertTrue(toString.contains("NoOpService"));
     assertTrue(toString.contains("FailStartService"));
   }

   public void testTimeouts() throws Exception {
     Service a = new NoOpDelayedSerivce(50);
     ServiceManager manager = new ServiceManager(asList(a));
     manager.startAsync();
     try {
       manager.awaitHealthy(1, TimeUnit.MILLISECONDS);
       fail();
     } catch (TimeoutException expected) {
     }
     manager.awaitHealthy(100, TimeUnit.MILLISECONDS); // no exception thrown

     manager.stopAsync();
     try {
       manager.awaitStopped(1, TimeUnit.MILLISECONDS);
       fail();
     } catch (TimeoutException expected) {
     }
     manager.awaitStopped(100, TimeUnit.MILLISECONDS);  // no exception thrown
   }

   /**
    * This covers a case where if the last service to stop failed then the stopped callback would
    * never be called.
    */
   public void testSingleFailedServiceCallsStopped() {
     Service a = new FailStartService();
     ServiceManager manager = new ServiceManager(asList(a));
     RecordingListener listener = new RecordingListener();
     manager.addListener(listener);
     try {
       manager.startAsync().awaitHealthy();
       fail();
     } catch (IllegalStateException expected) {
     }
     assertTrue(listener.stoppedCalled);
   }

   /**
    * This covers a bug where listener.healthy would get called when a single service failed during
    * startup (it occurred in more complicated cases also).
    */
   public void testFailStart_singleServiceCallsHealthy() {
     Service a = new FailStartService();
     ServiceManager manager = new ServiceManager(asList(a));
     RecordingListener listener = new RecordingListener();
     manager.addListener(listener);
     try {
       manager.startAsync().awaitHealthy();
       fail();
     } catch (IllegalStateException expected) {
     }
     assertFalse(listener.healthyCalled);
   }

   /**
    * This covers a bug where if a listener was installed that would stop the manager if any service
    * fails and something failed during startup before service.start was called on all the services,
    * then awaitStopped would deadlock due to an IllegalStateException that was thrown when trying to
    * stop the timer(!).
    */
   public void testFailStart_stopOthers() throws TimeoutException {
     Service a = new FailStartService();
     Service b = new NoOpService();
     final ServiceManager manager = new ServiceManager(asList(a, b));
     manager.addListener(new Listener() {
       @Override public void failure(Service service) {
         manager.stopAsync();
       }});
     manager.startAsync();
     manager.awaitStopped(10, TimeUnit.MILLISECONDS);
   }

   private static void assertState(
       ServiceManager manager, Service.State state, Service... services) {
     Collection<Service> managerServices = manager.servicesByState().get(state);
     for (Service service : services) {
       assertEquals(service.toString(), state, service.state());
       assertEquals(service.toString(), service.isRunning(), state == Service.State.RUNNING);
       assertTrue(managerServices + " should contain " + service, managerServices.contains(service));
     }
   }

   /**
    * This is for covering a case where the ServiceManager would behave strangely if constructed
    * with no service under management.  Listeners would never fire because the ServiceManager was
    * healthy and stopped at the same time.  This test ensures that listeners fire and isHealthy
    * makes sense.
    */
   public void testEmptyServiceManager() {
     Logger logger = Logger.getLogger(ServiceManager.class.getName());
     logger.setLevel(Level.FINEST);
     TestLogHandler logHandler = new TestLogHandler();
     logger.addHandler(logHandler);
     ServiceManager manager = new ServiceManager(Arrays.<Service>asList());
     RecordingListener listener = new RecordingListener();
     manager.addListener(listener, MoreExecutors.sameThreadExecutor());
     manager.startAsync().awaitHealthy();
     assertTrue(manager.isHealthy());
     assertTrue(listener.healthyCalled);
     assertFalse(listener.stoppedCalled);
     assertTrue(listener.failedServices.isEmpty());
     manager.stopAsync().awaitStopped();
     assertFalse(manager.isHealthy());
     assertTrue(listener.stoppedCalled);
     assertTrue(listener.failedServices.isEmpty());
     // check that our NoOpService is not directly observable via any of the inspection methods or
     // via logging.
     assertEquals("ServiceManager{services=[]}", manager.toString());
     assertTrue(manager.servicesByState().isEmpty());
     assertTrue(manager.startupTimes().isEmpty());
     Formatter logFormatter = new Formatter() {
       @Override public String format(LogRecord record) {
         return formatMessage(record);
       }
     };
     for (LogRecord record : logHandler.getStoredLogRecords()) {
       assertFalse(logFormatter.format(record).contains("NoOpService"));
     }
   }

   /**
    * Tests that a ServiceManager can be fully shut down if one of its failure listeners is slow or
    * even permanently blocked.
    */

   public void testListenerDeadlock() throws InterruptedException {
     final CountDownLatch failEnter = new CountDownLatch(1);
     final CountDownLatch failLeave = new CountDownLatch(1);
     final CountDownLatch afterStarted = new CountDownLatch(1);
     Service failRunService = new AbstractService() {
       @Override protected void doStart() {
         new Thread() {
           @Override public void run() {
             notifyStarted();
             // We need to wait for the main thread to leave the ServiceManager.startAsync call to
             // ensure that the thread running the failure callbacks is not the main thread.
             Uninterruptibles.awaitUninterruptibly(afterStarted);
             notifyFailed(new Exception("boom"));
           }
         }.start();
       }
       @Override protected void doStop() {
         notifyStopped();
       }
     };
     final ServiceManager manager = new ServiceManager(
         Arrays.asList(failRunService, new NoOpService()));
     manager.addListener(new ServiceManager.Listener() {
       @Override public void failure(Service service) {
         failEnter.countDown();
         // block until after the service manager is shutdown
         Uninterruptibles.awaitUninterruptibly(failLeave);
       }
     }, MoreExecutors.sameThreadExecutor());
     manager.startAsync();
     afterStarted.countDown();
     // We do not call awaitHealthy because, due to races, that method may throw an exception.  But
     // we really just want to wait for the thread to be in the failure callback so we wait for that
     // explicitly instead.
     failEnter.await();
     assertFalse("State should be updated before calling listeners", manager.isHealthy());
     // now we want to stop the services.
     Thread stoppingThread = new Thread() {
       @Override public void run() {
         manager.stopAsync().awaitStopped();
       }
     };
     stoppingThread.start();
     // this should be super fast since the only non stopped service is a NoOpService
     stoppingThread.join(1000);
     assertFalse("stopAsync has deadlocked!.", stoppingThread.isAlive());
     failLeave.countDown();  // release the background thread
   }

   /**
    * Catches a bug where when constructing a service manager failed, later interactions with the
    * service could cause IllegalStateExceptions inside the partially constructed ServiceManager.
    * This ISE wouldn't actually bubble up but would get logged by ExecutionQueue.  This obfuscated
    * the original error (which was not constructing ServiceManager correctly).
    */
   public void testPartiallyConstructedManager() {
     Logger logger = Logger.getLogger("global");
     logger.setLevel(Level.FINEST);
     TestLogHandler logHandler = new TestLogHandler();
     logger.addHandler(logHandler);
     NoOpService service = new NoOpService();
     service.startAsync();
     try {
       new ServiceManager(Arrays.asList(service));
       fail();
     } catch (IllegalArgumentException expected) {}
     service.stopAsync();
     // Nothing was logged!
     assertEquals(0, logHandler.getStoredLogRecords().size());
   }

   public void testPartiallyConstructedManager_transitionAfterAddListenerBeforeStateIsReady() {
     // The implementation of this test is pretty sensitive to the implementation :( but we want to
     // ensure that if weird things happen during construction then we get exceptions.
     final NoOpService service1 = new NoOpService();
     // This service will start service1 when addListener is called.  This simulates service1 being
     // started asynchronously.
     Service service2 = new Service() {
       final NoOpService delegate = new NoOpService();
       @Override public final void addListener(Listener listener, Executor executor) {
         service1.startAsync();
         delegate.addListener(listener, executor);
       }
       // Delegates from here on down
       @Override public final Service startAsync() {
         return delegate.startAsync();
       }

       @Override public final Service stopAsync() {
         return delegate.stopAsync();
       }

       @Override public final void awaitRunning() {
         delegate.awaitRunning();
       }

       @Override public final void awaitRunning(long timeout, TimeUnit unit)
           throws TimeoutException {
         delegate.awaitRunning(timeout, unit);
       }

       @Override public final void awaitTerminated() {
         delegate.awaitTerminated();
       }

       @Override public final void awaitTerminated(long timeout, TimeUnit unit)
           throws TimeoutException {
         delegate.awaitTerminated(timeout, unit);
       }

       @Override public final boolean isRunning() {
         return delegate.isRunning();
       }

       @Override public final State state() {
         return delegate.state();
       }

       @Override public final Throwable failureCause() {
         return delegate.failureCause();
       }
     };
     try {
       new ServiceManager(Arrays.asList(service1, service2));
       fail();
     } catch (IllegalArgumentException expected) {
       assertTrue(expected.getMessage().contains("started transitioning asynchronously"));
     }
   }

   /**
    * This test is for a case where two Service.Listener callbacks for the same service would call
    * transitionService in the wrong order due to a race.  Due to the fact that it is a race this
    * test isn't guaranteed to expose the issue, but it is at least likely to become flaky if the
    * race sneaks back in, and in this case flaky means something is definitely wrong.
    *
    * <p>Before the bug was fixed this test would fail at least 30% of the time.
    */

   public void testTransitionRace() throws TimeoutException {
     for (int k = 0; k < 1000; k++) {
       List<Service> services = Lists.newArrayList();
       for (int i = 0; i < 5; i++) {
         services.add(new SnappyShutdownService(i));
       }
       ServiceManager manager = new ServiceManager(services);
       manager.startAsync().awaitHealthy();
       manager.stopAsync().awaitStopped(1, TimeUnit.SECONDS);
     }
   }

   /**
    * This service will shutdown very quickly after stopAsync is called and uses a background thread
    * so that we know that the stopping() listeners will execute on a different thread than the
    * terminated() listeners.
    */
   private static class SnappyShutdownService extends AbstractExecutionThreadService {
     final int index;
     final CountDownLatch latch = new CountDownLatch(1);

     SnappyShutdownService(int index) {
       this.index = index;
     }

     @Override protected void run() throws Exception {
       latch.await();
     }

     @Override protected void triggerShutdown() {
       latch.countDown();
     }

     @Override protected String serviceName() {
       return this.getClass().getSimpleName() + "[" + index + "]";
     }
   }

   public void testNulls() {
     ServiceManager manager = new ServiceManager(Arrays.<Service>asList());
     new NullPointerTester()
         .setDefault(ServiceManager.Listener.class, new RecordingListener())
         .testAllPublicInstanceMethods(manager);
   }

   private static final class RecordingListener extends ServiceManager.Listener {
     volatile boolean healthyCalled;
     volatile boolean stoppedCalled;
     final Set<Service> failedServices = Sets.newConcurrentHashSet();

     @Override public void healthy() {
       healthyCalled = true;
     }

     @Override public void stopped() {
       stoppedCalled = true;
     }

     @Override public void failure(Service service) {
       failedServices.add(service);
     }
   }
 }
	/*
	* Copyright (C) 2012 The Guava 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 com.google.common.util.concurrent;

	import static java.util.Arrays.asList;

	import com.google.common.collect.ImmutableMap;
	import com.google.common.collect.ImmutableSet;
	import com.google.common.collect.Lists;
	import com.google.common.collect.Sets;
	import com.google.common.testing.NullPointerTester;
	import com.google.common.testing.TestLogHandler;
	import com.google.common.util.concurrent.ServiceManager.Listener;

	import junit.framework.TestCase;

	import java.util.Arrays;
	import java.util.Collection;
	import java.util.List;
	import java.util.Set;
	import java.util.concurrent.CountDownLatch;
	import java.util.concurrent.Executor;
	import java.util.concurrent.TimeUnit;
	import java.util.concurrent.TimeoutException;
	import java.util.logging.Formatter;
	import java.util.logging.Level;
	import java.util.logging.LogRecord;
	import java.util.logging.Logger;

	/**
	* Tests for {@link ServiceManager}.
	*
	* @author Luke Sandberg
	* @author Chris Nokleberg
	*/
	public class ServiceManagerTest extends TestCase {

	private static class NoOpService extends AbstractService {
	@Override protected void doStart() {
	notifyStarted();
	}

	@Override protected void doStop() {
	notifyStopped();
	}
	}

	/*
	* A NoOp service that will delay the startup and shutdown notification for a configurable amount
	* of time.
	*/
	private static class NoOpDelayedSerivce extends NoOpService {
	private long delay;

	public NoOpDelayedSerivce(long delay) {
	this.delay = delay;
	}

	@Override protected void doStart() {
	new Thread() {
	@Override public void run() {
	Uninterruptibles.sleepUninterruptibly(delay, TimeUnit.MILLISECONDS);
	notifyStarted();
	}
	}.start();
	}

	@Override protected void doStop() {
	new Thread() {
	@Override public void run() {
	Uninterruptibles.sleepUninterruptibly(delay, TimeUnit.MILLISECONDS);
	notifyStopped();
	}
	}.start();
	}
	}

	private static class FailStartService extends NoOpService {
	@Override protected void doStart() {
	notifyFailed(new IllegalStateException("failed"));
	}
	}

	private static class FailRunService extends NoOpService {
	@Override protected void doStart() {
	super.doStart();
	notifyFailed(new IllegalStateException("failed"));
	}
	}

	private static class FailStopService extends NoOpService {
	@Override protected void doStop() {
	notifyFailed(new IllegalStateException("failed"));
	}
	}

	public void testServiceStartupTimes() {
	Service a = new NoOpDelayedSerivce(150);
	Service b = new NoOpDelayedSerivce(353);
	ServiceManager serviceManager = new ServiceManager(asList(a, b));
	serviceManager.startAsync().awaitHealthy();
	ImmutableMap<Service, Long> startupTimes = serviceManager.startupTimes();
	assertEquals(2, startupTimes.size());
	assertTrue(startupTimes.get(a) >= 150);
	assertTrue(startupTimes.get(b) >= 353);
	}

	public void testServiceStartStop() {
	Service a = new NoOpService();
	Service b = new NoOpService();
	ServiceManager manager = new ServiceManager(asList(a, b));
	RecordingListener listener = new RecordingListener();
	manager.addListener(listener);
	assertState(manager, Service.State.NEW, a, b);
	assertFalse(manager.isHealthy());
	manager.startAsync().awaitHealthy();
	assertState(manager, Service.State.RUNNING, a, b);
	assertTrue(manager.isHealthy());
	assertTrue(listener.healthyCalled);
	assertFalse(listener.stoppedCalled);
	assertTrue(listener.failedServices.isEmpty());
	manager.stopAsync().awaitStopped();
	assertState(manager, Service.State.TERMINATED, a, b);
	assertFalse(manager.isHealthy());
	assertTrue(listener.stoppedCalled);
	assertTrue(listener.failedServices.isEmpty());
	}

	public void testFailStart() throws Exception {
	Service a = new NoOpService();
	Service b = new FailStartService();
	Service c = new NoOpService();
	Service d = new FailStartService();
	Service e = new NoOpService();
	ServiceManager manager = new ServiceManager(asList(a, b, c, d, e));
	RecordingListener listener = new RecordingListener();
	manager.addListener(listener);
	assertState(manager, Service.State.NEW, a, b, c, d, e);
	try {
	manager.startAsync().awaitHealthy();
	fail();
	} catch (IllegalStateException expected) {
	}
	assertFalse(listener.healthyCalled);
	assertState(manager, Service.State.RUNNING, a, c, e);
	assertEquals(ImmutableSet.of(b, d), listener.failedServices);
	assertState(manager, Service.State.FAILED, b, d);
	assertFalse(manager.isHealthy());

	manager.stopAsync().awaitStopped();
	assertFalse(manager.isHealthy());
	assertFalse(listener.healthyCalled);
	assertTrue(listener.stoppedCalled);
	}

	public void testFailRun() throws Exception {
	Service a = new NoOpService();
	Service b = new FailRunService();
	ServiceManager manager = new ServiceManager(asList(a, b));
	RecordingListener listener = new RecordingListener();
	manager.addListener(listener);
	assertState(manager, Service.State.NEW, a, b);
	try {
	manager.startAsync().awaitHealthy();
	fail();
	} catch (IllegalStateException expected) {
	}
	assertTrue(listener.healthyCalled);
	assertEquals(ImmutableSet.of(b), listener.failedServices);

	manager.stopAsync().awaitStopped();
	assertState(manager, Service.State.FAILED, b);
	assertState(manager, Service.State.TERMINATED, a);

	assertTrue(listener.stoppedCalled);
	}

	public void testFailStop() throws Exception {
	Service a = new NoOpService();
	Service b = new FailStopService();
	Service c = new NoOpService();
	ServiceManager manager = new ServiceManager(asList(a, b, c));
	RecordingListener listener = new RecordingListener();
	manager.addListener(listener);

	manager.startAsync().awaitHealthy();
	assertTrue(listener.healthyCalled);
	assertFalse(listener.stoppedCalled);
	manager.stopAsync().awaitStopped();

	assertTrue(listener.stoppedCalled);
	assertEquals(ImmutableSet.of(b), listener.failedServices);
	assertState(manager, Service.State.FAILED, b);
	assertState(manager, Service.State.TERMINATED, a, c);
	}

	public void testToString() throws Exception {
	Service a = new NoOpService();
	Service b = new FailStartService();
	ServiceManager manager = new ServiceManager(asList(a, b));
	String toString = manager.toString();
	assertTrue(toString.contains("NoOpService"));
	assertTrue(toString.contains("FailStartService"));
	}

	public void testTimeouts() throws Exception {
	Service a = new NoOpDelayedSerivce(50);
	ServiceManager manager = new ServiceManager(asList(a));
	manager.startAsync();
	try {
	manager.awaitHealthy(1, TimeUnit.MILLISECONDS);
	fail();
	} catch (TimeoutException expected) {
	}
	manager.awaitHealthy(100, TimeUnit.MILLISECONDS); // no exception thrown

	manager.stopAsync();
	try {
	manager.awaitStopped(1, TimeUnit.MILLISECONDS);
	fail();
	} catch (TimeoutException expected) {
	}
	manager.awaitStopped(100, TimeUnit.MILLISECONDS); // no exception thrown
	}

	/**
	* This covers a case where if the last service to stop failed then the stopped callback would
	* never be called.
	*/
	public void testSingleFailedServiceCallsStopped() {
	Service a = new FailStartService();
	ServiceManager manager = new ServiceManager(asList(a));
	RecordingListener listener = new RecordingListener();
	manager.addListener(listener);
	try {
	manager.startAsync().awaitHealthy();
	fail();
	} catch (IllegalStateException expected) {
	}
	assertTrue(listener.stoppedCalled);
	}

	/**
	* This covers a bug where listener.healthy would get called when a single service failed during
	* startup (it occurred in more complicated cases also).
	*/
	public void testFailStart_singleServiceCallsHealthy() {
	Service a = new FailStartService();
	ServiceManager manager = new ServiceManager(asList(a));
	RecordingListener listener = new RecordingListener();
	manager.addListener(listener);
	try {
	manager.startAsync().awaitHealthy();
	fail();
	} catch (IllegalStateException expected) {
	}
	assertFalse(listener.healthyCalled);
	}

	/**
	* This covers a bug where if a listener was installed that would stop the manager if any service
	* fails and something failed during startup before service.start was called on all the services,
	* then awaitStopped would deadlock due to an IllegalStateException that was thrown when trying to
	* stop the timer(!).
	*/
	public void testFailStart_stopOthers() throws TimeoutException {
	Service a = new FailStartService();
	Service b = new NoOpService();
	final ServiceManager manager = new ServiceManager(asList(a, b));
	manager.addListener(new Listener() {
	@Override public void failure(Service service) {
	manager.stopAsync();
	}});
	manager.startAsync();
	manager.awaitStopped(10, TimeUnit.MILLISECONDS);
	}

	private static void assertState(
	ServiceManager manager, Service.State state, Service... services) {
	Collection<Service> managerServices = manager.servicesByState().get(state);
	for (Service service : services) {
	assertEquals(service.toString(), state, service.state());
	assertEquals(service.toString(), service.isRunning(), state == Service.State.RUNNING);
	assertTrue(managerServices + " should contain " + service, managerServices.contains(service));
	}
	}

	/**
	* This is for covering a case where the ServiceManager would behave strangely if constructed
	* with no service under management. Listeners would never fire because the ServiceManager was
	* healthy and stopped at the same time. This test ensures that listeners fire and isHealthy
	* makes sense.
	*/
	public void testEmptyServiceManager() {
	Logger logger = Logger.getLogger(ServiceManager.class.getName());
	logger.setLevel(Level.FINEST);
	TestLogHandler logHandler = new TestLogHandler();
	logger.addHandler(logHandler);
	ServiceManager manager = new ServiceManager(Arrays.<Service>asList());
	RecordingListener listener = new RecordingListener();
	manager.addListener(listener, MoreExecutors.sameThreadExecutor());
	manager.startAsync().awaitHealthy();
	assertTrue(manager.isHealthy());
	assertTrue(listener.healthyCalled);
	assertFalse(listener.stoppedCalled);
	assertTrue(listener.failedServices.isEmpty());
	manager.stopAsync().awaitStopped();
	assertFalse(manager.isHealthy());
	assertTrue(listener.stoppedCalled);
	assertTrue(listener.failedServices.isEmpty());
	// check that our NoOpService is not directly observable via any of the inspection methods or
	// via logging.
	assertEquals("ServiceManager{services=[]}", manager.toString());
	assertTrue(manager.servicesByState().isEmpty());
	assertTrue(manager.startupTimes().isEmpty());
	Formatter logFormatter = new Formatter() {
	@Override public String format(LogRecord record) {
	return formatMessage(record);
	}
	};
	for (LogRecord record : logHandler.getStoredLogRecords()) {
	assertFalse(logFormatter.format(record).contains("NoOpService"));
	}
	}

	/**
	* Tests that a ServiceManager can be fully shut down if one of its failure listeners is slow or
	* even permanently blocked.
	*/

	public void testListenerDeadlock() throws InterruptedException {
	final CountDownLatch failEnter = new CountDownLatch(1);
	final CountDownLatch failLeave = new CountDownLatch(1);
	final CountDownLatch afterStarted = new CountDownLatch(1);
	Service failRunService = new AbstractService() {
	@Override protected void doStart() {
	new Thread() {
	@Override public void run() {
	notifyStarted();
	// We need to wait for the main thread to leave the ServiceManager.startAsync call to
	// ensure that the thread running the failure callbacks is not the main thread.
	Uninterruptibles.awaitUninterruptibly(afterStarted);
	notifyFailed(new Exception("boom"));
	}
	}.start();
	}
	@Override protected void doStop() {
	notifyStopped();
	}
	};
	final ServiceManager manager = new ServiceManager(
	Arrays.asList(failRunService, new NoOpService()));
	manager.addListener(new ServiceManager.Listener() {
	@Override public void failure(Service service) {
	failEnter.countDown();
	// block until after the service manager is shutdown
	Uninterruptibles.awaitUninterruptibly(failLeave);
	}
	}, MoreExecutors.sameThreadExecutor());
	manager.startAsync();
	afterStarted.countDown();
	// We do not call awaitHealthy because, due to races, that method may throw an exception. But
	// we really just want to wait for the thread to be in the failure callback so we wait for that
	// explicitly instead.
	failEnter.await();
	assertFalse("State should be updated before calling listeners", manager.isHealthy());
	// now we want to stop the services.
	Thread stoppingThread = new Thread() {
	@Override public void run() {
	manager.stopAsync().awaitStopped();
	}
	};
	stoppingThread.start();
	// this should be super fast since the only non stopped service is a NoOpService
	stoppingThread.join(1000);
	assertFalse("stopAsync has deadlocked!.", stoppingThread.isAlive());
	failLeave.countDown(); // release the background thread
	}

	/**
	* Catches a bug where when constructing a service manager failed, later interactions with the
	* service could cause IllegalStateExceptions inside the partially constructed ServiceManager.
	* This ISE wouldn't actually bubble up but would get logged by ExecutionQueue. This obfuscated
	* the original error (which was not constructing ServiceManager correctly).
	*/
	public void testPartiallyConstructedManager() {
	Logger logger = Logger.getLogger("global");
	logger.setLevel(Level.FINEST);
	TestLogHandler logHandler = new TestLogHandler();
	logger.addHandler(logHandler);
	NoOpService service = new NoOpService();
	service.startAsync();
	try {
	new ServiceManager(Arrays.asList(service));
	fail();
	} catch (IllegalArgumentException expected) {}
	service.stopAsync();
	// Nothing was logged!
	assertEquals(0, logHandler.getStoredLogRecords().size());
	}

	public void testPartiallyConstructedManager_transitionAfterAddListenerBeforeStateIsReady() {
	// The implementation of this test is pretty sensitive to the implementation :( but we want to
	// ensure that if weird things happen during construction then we get exceptions.
	final NoOpService service1 = new NoOpService();
	// This service will start service1 when addListener is called. This simulates service1 being
	// started asynchronously.
	Service service2 = new Service() {
	final NoOpService delegate = new NoOpService();
	@Override public final void addListener(Listener listener, Executor executor) {
	service1.startAsync();
	delegate.addListener(listener, executor);
	}
	// Delegates from here on down
	@Override public final Service startAsync() {
	return delegate.startAsync();
	}

	@Override public final Service stopAsync() {
	return delegate.stopAsync();
	}

	@Override public final void awaitRunning() {
	delegate.awaitRunning();
	}

	@Override public final void awaitRunning(long timeout, TimeUnit unit)
	throws TimeoutException {
	delegate.awaitRunning(timeout, unit);
	}

	@Override public final void awaitTerminated() {
	delegate.awaitTerminated();
	}

	@Override public final void awaitTerminated(long timeout, TimeUnit unit)
	throws TimeoutException {
	delegate.awaitTerminated(timeout, unit);
	}

	@Override public final boolean isRunning() {
	return delegate.isRunning();
	}

	@Override public final State state() {
	return delegate.state();
	}

	@Override public final Throwable failureCause() {
	return delegate.failureCause();
	}
	};
	try {
	new ServiceManager(Arrays.asList(service1, service2));
	fail();
	} catch (IllegalArgumentException expected) {
	assertTrue(expected.getMessage().contains("started transitioning asynchronously"));
	}
	}

	/**
	* This test is for a case where two Service.Listener callbacks for the same service would call
	* transitionService in the wrong order due to a race. Due to the fact that it is a race this
	* test isn't guaranteed to expose the issue, but it is at least likely to become flaky if the
	* race sneaks back in, and in this case flaky means something is definitely wrong.
	*
	* <p>Before the bug was fixed this test would fail at least 30% of the time.
	*/

	public void testTransitionRace() throws TimeoutException {
	for (int k = 0; k < 1000; k++) {
	List<Service> services = Lists.newArrayList();
	for (int i = 0; i < 5; i++) {
	services.add(new SnappyShutdownService(i));
	}
	ServiceManager manager = new ServiceManager(services);
	manager.startAsync().awaitHealthy();
	manager.stopAsync().awaitStopped(1, TimeUnit.SECONDS);
	}
	}

	/**
	* This service will shutdown very quickly after stopAsync is called and uses a background thread
	* so that we know that the stopping() listeners will execute on a different thread than the
	* terminated() listeners.
	*/
	private static class SnappyShutdownService extends AbstractExecutionThreadService {
	final int index;
	final CountDownLatch latch = new CountDownLatch(1);

	SnappyShutdownService(int index) {
	this.index = index;
	}

	@Override protected void run() throws Exception {
	latch.await();
	}

	@Override protected void triggerShutdown() {
	latch.countDown();
	}

	@Override protected String serviceName() {
	return this.getClass().getSimpleName() + "[" + index + "]";
	}
	}

	public void testNulls() {
	ServiceManager manager = new ServiceManager(Arrays.<Service>asList());
	new NullPointerTester()
	.setDefault(ServiceManager.Listener.class, new RecordingListener())
	.testAllPublicInstanceMethods(manager);
	}

	private static final class RecordingListener extends ServiceManager.Listener {
	volatile boolean healthyCalled;
	volatile boolean stoppedCalled;
	final Set<Service> failedServices = Sets.newConcurrentHashSet();

	@Override public void healthy() {
	healthyCalled = true;
	}

	@Override public void stopped() {
	stoppedCalled = true;
	}

	@Override public void failure(Service service) {
	failedServices.add(service);
	}
	}
	}