| /* |
| * 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 com.google.common.base.Preconditions.checkArgument; |
| import static com.google.common.base.Preconditions.checkNotNull; |
| import static com.google.common.base.Preconditions.checkState; |
| import static com.google.common.base.Predicates.equalTo; |
| import static com.google.common.base.Predicates.in; |
| import static com.google.common.base.Predicates.instanceOf; |
| import static com.google.common.base.Predicates.not; |
| import static com.google.common.util.concurrent.MoreExecutors.directExecutor; |
| import static com.google.common.util.concurrent.Service.State.FAILED; |
| import static com.google.common.util.concurrent.Service.State.NEW; |
| import static com.google.common.util.concurrent.Service.State.RUNNING; |
| import static com.google.common.util.concurrent.Service.State.STARTING; |
| import static com.google.common.util.concurrent.Service.State.STOPPING; |
| import static com.google.common.util.concurrent.Service.State.TERMINATED; |
| import static java.util.concurrent.TimeUnit.MILLISECONDS; |
| |
| import com.google.common.annotations.Beta; |
| import com.google.common.base.Function; |
| import com.google.common.base.MoreObjects; |
| import com.google.common.base.Stopwatch; |
| import com.google.common.base.Supplier; |
| import com.google.common.collect.Collections2; |
| import com.google.common.collect.ImmutableCollection; |
| import com.google.common.collect.ImmutableList; |
| import com.google.common.collect.ImmutableMap; |
| import com.google.common.collect.ImmutableMultimap; |
| import com.google.common.collect.ImmutableSet; |
| import com.google.common.collect.ImmutableSetMultimap; |
| import com.google.common.collect.Lists; |
| import com.google.common.collect.Maps; |
| import com.google.common.collect.Multimaps; |
| import com.google.common.collect.Multiset; |
| import com.google.common.collect.Ordering; |
| import com.google.common.collect.SetMultimap; |
| import com.google.common.collect.Sets; |
| import com.google.common.util.concurrent.ListenerCallQueue.Callback; |
| import com.google.common.util.concurrent.Service.State; |
| |
| import java.lang.ref.WeakReference; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.EnumMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Map.Entry; |
| import java.util.Set; |
| import java.util.concurrent.Executor; |
| import java.util.concurrent.TimeUnit; |
| import java.util.concurrent.TimeoutException; |
| import java.util.logging.Level; |
| import java.util.logging.Logger; |
| |
| import javax.annotation.concurrent.GuardedBy; |
| |
| /** |
| * A manager for monitoring and controlling a set of {@linkplain Service services}. This class |
| * provides methods for {@linkplain #startAsync() starting}, {@linkplain #stopAsync() stopping} and |
| * {@linkplain #servicesByState inspecting} a collection of {@linkplain Service services}. |
| * Additionally, users can monitor state transitions with the {@linkplain Listener listener} |
| * mechanism. |
| * |
| * <p>While it is recommended that service lifecycles be managed via this class, state transitions |
| * initiated via other mechanisms do not impact the correctness of its methods. For example, if the |
| * services are started by some mechanism besides {@link #startAsync}, the listeners will be invoked |
| * when appropriate and {@link #awaitHealthy} will still work as expected. |
| * |
| * <p>Here is a simple example of how to use a {@code ServiceManager} to start a server. |
| * <pre> {@code |
| * class Server { |
| * public static void main(String[] args) { |
| * Set<Service> services = ...; |
| * ServiceManager manager = new ServiceManager(services); |
| * manager.addListener(new Listener() { |
| * public void stopped() {} |
| * public void healthy() { |
| * // Services have been initialized and are healthy, start accepting requests... |
| * } |
| * public void failure(Service service) { |
| * // Something failed, at this point we could log it, notify a load balancer, or take |
| * // some other action. For now we will just exit. |
| * System.exit(1); |
| * } |
| * }, |
| * MoreExecutors.directExecutor()); |
| * |
| * Runtime.getRuntime().addShutdownHook(new Thread() { |
| * public void run() { |
| * // Give the services 5 seconds to stop to ensure that we are responsive to shutdown |
| * // requests. |
| * try { |
| * manager.stopAsync().awaitStopped(5, TimeUnit.SECONDS); |
| * } catch (TimeoutException timeout) { |
| * // stopping timed out |
| * } |
| * } |
| * }); |
| * manager.startAsync(); // start all the services asynchronously |
| * } |
| * }}</pre> |
| * |
| * <p>This class uses the ServiceManager's methods to start all of its services, to respond to |
| * service failure and to ensure that when the JVM is shutting down all the services are stopped. |
| * |
| * @author Luke Sandberg |
| * @since 14.0 |
| */ |
| @Beta |
| public final class ServiceManager { |
| private static final Logger logger = Logger.getLogger(ServiceManager.class.getName()); |
| private static final Callback<Listener> HEALTHY_CALLBACK = new Callback<Listener>("healthy()") { |
| @Override void call(Listener listener) { |
| listener.healthy(); |
| } |
| }; |
| private static final Callback<Listener> STOPPED_CALLBACK = new Callback<Listener>("stopped()") { |
| @Override void call(Listener listener) { |
| listener.stopped(); |
| } |
| }; |
| |
| /** |
| * A listener for the aggregate state changes of the services that are under management. Users |
| * that need to listen to more fine-grained events (such as when each particular {@linkplain |
| * Service service} starts, or terminates), should attach {@linkplain Service.Listener service |
| * listeners} to each individual service. |
| * |
| * @author Luke Sandberg |
| * @since 15.0 (present as an interface in 14.0) |
| */ |
| @Beta // Should come out of Beta when ServiceManager does |
| public abstract static class Listener { |
| /** |
| * Called when the service initially becomes healthy. |
| * |
| * <p>This will be called at most once after all the services have entered the |
| * {@linkplain State#RUNNING running} state. If any services fail during start up or |
| * {@linkplain State#FAILED fail}/{@linkplain State#TERMINATED terminate} before all other |
| * services have started {@linkplain State#RUNNING running} then this method will not be called. |
| */ |
| public void healthy() {} |
| |
| /** |
| * Called when the all of the component services have reached a terminal state, either |
| * {@linkplain State#TERMINATED terminated} or {@linkplain State#FAILED failed}. |
| */ |
| public void stopped() {} |
| |
| /** |
| * Called when a component service has {@linkplain State#FAILED failed}. |
| * |
| * @param service The service that failed. |
| */ |
| public void failure(Service service) {} |
| } |
| |
| /** |
| * An encapsulation of all of the state that is accessed by the {@linkplain ServiceListener |
| * service listeners}. This is extracted into its own object so that {@link ServiceListener} |
| * could be made {@code static} and its instances can be safely constructed and added in the |
| * {@link ServiceManager} constructor without having to close over the partially constructed |
| * {@link ServiceManager} instance (i.e. avoid leaking a pointer to {@code this}). |
| */ |
| private final ServiceManagerState state; |
| private final ImmutableList<Service> services; |
| |
| /** |
| * Constructs a new instance for managing the given services. |
| * |
| * @param services The services to manage |
| * |
| * @throws IllegalArgumentException if not all services are {@linkplain State#NEW new} or if there |
| * are any duplicate services. |
| */ |
| public ServiceManager(Iterable<? extends Service> services) { |
| ImmutableList<Service> copy = ImmutableList.copyOf(services); |
| if (copy.isEmpty()) { |
| // Having no services causes the manager to behave strangely. Notably, listeners are never |
| // fired. To avoid this we substitute a placeholder service. |
| logger.log(Level.WARNING, |
| "ServiceManager configured with no services. Is your application configured properly?", |
| new EmptyServiceManagerWarning()); |
| copy = ImmutableList.<Service>of(new NoOpService()); |
| } |
| this.state = new ServiceManagerState(copy); |
| this.services = copy; |
| WeakReference<ServiceManagerState> stateReference = |
| new WeakReference<ServiceManagerState>(state); |
| for (Service service : copy) { |
| service.addListener(new ServiceListener(service, stateReference), directExecutor()); |
| // We check the state after adding the listener as a way to ensure that our listener was added |
| // to a NEW service. |
| checkArgument(service.state() == NEW, "Can only manage NEW services, %s", service); |
| } |
| // We have installed all of our listeners and after this point any state transition should be |
| // correct. |
| this.state.markReady(); |
| } |
| |
| /** |
| * Registers a {@link Listener} to be {@linkplain Executor#execute executed} on the given |
| * executor. The listener will not have previous state changes replayed, so it is |
| * suggested that listeners are added before any of the managed services are |
| * {@linkplain Service#startAsync started}. |
| * |
| * <p>{@code addListener} guarantees execution ordering across calls to a given listener but not |
| * across calls to multiple listeners. Specifically, a given listener will have its callbacks |
| * invoked in the same order as the underlying service enters those states. Additionally, at most |
| * one of the listener's callbacks will execute at once. However, multiple listeners' callbacks |
| * may execute concurrently, and listeners may execute in an order different from the one in which |
| * they were registered. |
| * |
| * <p>RuntimeExceptions thrown by a listener will be caught and logged. Any exception thrown |
| * during {@code Executor.execute} (e.g., a {@code RejectedExecutionException}) will be caught and |
| * logged. |
| * |
| * <p> For fast, lightweight listeners that would be safe to execute in any thread, consider |
| * calling {@link #addListener(Listener)}. |
| * |
| * @param listener the listener to run when the manager changes state |
| * @param executor the executor in which the listeners callback methods will be run. |
| */ |
| public void addListener(Listener listener, Executor executor) { |
| state.addListener(listener, executor); |
| } |
| |
| /** |
| * Registers a {@link Listener} to be run when this {@link ServiceManager} changes state. The |
| * listener will not have previous state changes replayed, so it is suggested that listeners are |
| * added before any of the managed services are {@linkplain Service#startAsync started}. |
| * |
| * <p>{@code addListener} guarantees execution ordering across calls to a given listener but not |
| * across calls to multiple listeners. Specifically, a given listener will have its callbacks |
| * invoked in the same order as the underlying service enters those states. Additionally, at most |
| * one of the listener's callbacks will execute at once. However, multiple listeners' callbacks |
| * may execute concurrently, and listeners may execute in an order different from the one in which |
| * they were registered. |
| * |
| * <p>RuntimeExceptions thrown by a listener will be caught and logged. |
| * |
| * @param listener the listener to run when the manager changes state |
| */ |
| public void addListener(Listener listener) { |
| state.addListener(listener, directExecutor()); |
| } |
| |
| /** |
| * Initiates service {@linkplain Service#startAsync startup} on all the services being managed. |
| * It is only valid to call this method if all of the services are {@linkplain State#NEW new}. |
| * |
| * @return this |
| * @throws IllegalStateException if any of the Services are not {@link State#NEW new} when the |
| * method is called. |
| */ |
| public ServiceManager startAsync() { |
| for (Service service : services) { |
| State state = service.state(); |
| checkState(state == NEW, "Service %s is %s, cannot start it.", service, state); |
| } |
| for (Service service : services) { |
| try { |
| state.tryStartTiming(service); |
| service.startAsync(); |
| } catch (IllegalStateException e) { |
| // This can happen if the service has already been started or stopped (e.g. by another |
| // service or listener). Our contract says it is safe to call this method if |
| // all services were NEW when it was called, and this has already been verified above, so we |
| // don't propagate the exception. |
| logger.log(Level.WARNING, "Unable to start Service " + service, e); |
| } |
| } |
| return this; |
| } |
| |
| /** |
| * Waits for the {@link ServiceManager} to become {@linkplain #isHealthy() healthy}. The manager |
| * will become healthy after all the component services have reached the {@linkplain State#RUNNING |
| * running} state. |
| * |
| * @throws IllegalStateException if the service manager reaches a state from which it cannot |
| * become {@linkplain #isHealthy() healthy}. |
| */ |
| public void awaitHealthy() { |
| state.awaitHealthy(); |
| } |
| |
| /** |
| * Waits for the {@link ServiceManager} to become {@linkplain #isHealthy() healthy} for no more |
| * than the given time. The manager will become healthy after all the component services have |
| * reached the {@linkplain State#RUNNING running} state. |
| * |
| * @param timeout the maximum time to wait |
| * @param unit the time unit of the timeout argument |
| * @throws TimeoutException if not all of the services have finished starting within the deadline |
| * @throws IllegalStateException if the service manager reaches a state from which it cannot |
| * become {@linkplain #isHealthy() healthy}. |
| */ |
| public void awaitHealthy(long timeout, TimeUnit unit) throws TimeoutException { |
| state.awaitHealthy(timeout, unit); |
| } |
| |
| /** |
| * Initiates service {@linkplain Service#stopAsync shutdown} if necessary on all the services |
| * being managed. |
| * |
| * @return this |
| */ |
| public ServiceManager stopAsync() { |
| for (Service service : services) { |
| service.stopAsync(); |
| } |
| return this; |
| } |
| |
| /** |
| * Waits for the all the services to reach a terminal state. After this method returns all |
| * services will either be {@linkplain Service.State#TERMINATED terminated} or {@linkplain |
| * Service.State#FAILED failed}. |
| */ |
| public void awaitStopped() { |
| state.awaitStopped(); |
| } |
| |
| /** |
| * Waits for the all the services to reach a terminal state for no more than the given time. After |
| * this method returns all services will either be {@linkplain Service.State#TERMINATED |
| * terminated} or {@linkplain Service.State#FAILED failed}. |
| * |
| * @param timeout the maximum time to wait |
| * @param unit the time unit of the timeout argument |
| * @throws TimeoutException if not all of the services have stopped within the deadline |
| */ |
| public void awaitStopped(long timeout, TimeUnit unit) throws TimeoutException { |
| state.awaitStopped(timeout, unit); |
| } |
| |
| /** |
| * Returns true if all services are currently in the {@linkplain State#RUNNING running} state. |
| * |
| * <p>Users who want more detailed information should use the {@link #servicesByState} method to |
| * get detailed information about which services are not running. |
| */ |
| public boolean isHealthy() { |
| for (Service service : services) { |
| if (!service.isRunning()) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * Provides a snapshot of the current state of all the services under management. |
| * |
| * <p>N.B. This snapshot is guaranteed to be consistent, i.e. the set of states returned will |
| * correspond to a point in time view of the services. |
| */ |
| public ImmutableMultimap<State, Service> servicesByState() { |
| return state.servicesByState(); |
| } |
| |
| /** |
| * Returns the service load times. This value will only return startup times for services that |
| * have finished starting. |
| * |
| * @return Map of services and their corresponding startup time in millis, the map entries will be |
| * ordered by startup time. |
| */ |
| public ImmutableMap<Service, Long> startupTimes() { |
| return state.startupTimes(); |
| } |
| |
| @Override public String toString() { |
| return MoreObjects.toStringHelper(ServiceManager.class) |
| .add("services", Collections2.filter(services, not(instanceOf(NoOpService.class)))) |
| .toString(); |
| } |
| |
| /** |
| * An encapsulation of all the mutable state of the {@link ServiceManager} that needs to be |
| * accessed by instances of {@link ServiceListener}. |
| */ |
| private static final class ServiceManagerState { |
| final Monitor monitor = new Monitor(); |
| |
| @GuardedBy("monitor") |
| final SetMultimap<State, Service> servicesByState = |
| Multimaps.newSetMultimap(new EnumMap<State, Collection<Service>>(State.class), |
| new Supplier<Set<Service>>() { |
| @Override public Set<Service> get() { |
| return Sets.newLinkedHashSet(); |
| } |
| }); |
| |
| @GuardedBy("monitor") |
| final Multiset<State> states = servicesByState.keys(); |
| |
| @GuardedBy("monitor") |
| final Map<Service, Stopwatch> startupTimers = Maps.newIdentityHashMap(); |
| |
| /** |
| * These two booleans are used to mark the state as ready to start. |
| * {@link #ready}: is set by {@link #markReady} to indicate that all listeners have been |
| * correctly installed |
| * {@link #transitioned}: is set by {@link #transitionService} to indicate that some transition |
| * has been performed. |
| * |
| * <p>Together, they allow us to enforce that all services have their listeners installed prior |
| * to any service performing a transition, then we can fail in the ServiceManager constructor |
| * rather than in a Service.Listener callback. |
| */ |
| @GuardedBy("monitor") |
| boolean ready; |
| |
| @GuardedBy("monitor") |
| boolean transitioned; |
| |
| final int numberOfServices; |
| |
| /** |
| * Controls how long to wait for all the services to either become healthy or reach a |
| * state from which it is guaranteed that it can never become healthy. |
| */ |
| final Monitor.Guard awaitHealthGuard = new Monitor.Guard(monitor) { |
| @Override public boolean isSatisfied() { |
| // All services have started or some service has terminated/failed. |
| return states.count(RUNNING) == numberOfServices |
| || states.contains(STOPPING) |
| || states.contains(TERMINATED) |
| || states.contains(FAILED); |
| } |
| }; |
| |
| /** |
| * Controls how long to wait for all services to reach a terminal state. |
| */ |
| final Monitor.Guard stoppedGuard = new Monitor.Guard(monitor) { |
| @Override public boolean isSatisfied() { |
| return states.count(TERMINATED) + states.count(FAILED) == numberOfServices; |
| } |
| }; |
| |
| /** The listeners to notify during a state transition. */ |
| @GuardedBy("monitor") |
| final List<ListenerCallQueue<Listener>> listeners = |
| Collections.synchronizedList(new ArrayList<ListenerCallQueue<Listener>>()); |
| |
| /** |
| * It is implicitly assumed that all the services are NEW and that they will all remain NEW |
| * until all the Listeners are installed and {@link #markReady()} is called. It is our caller's |
| * responsibility to only call {@link #markReady()} if all services were new at the time this |
| * method was called and when all the listeners were installed. |
| */ |
| ServiceManagerState(ImmutableCollection<Service> services) { |
| this.numberOfServices = services.size(); |
| servicesByState.putAll(NEW, services); |
| } |
| |
| /** |
| * Attempts to start the timer immediately prior to the service being started via |
| * {@link Service#startAsync()}. |
| */ |
| void tryStartTiming(Service service) { |
| monitor.enter(); |
| try { |
| Stopwatch stopwatch = startupTimers.get(service); |
| if (stopwatch == null) { |
| startupTimers.put(service, Stopwatch.createStarted()); |
| } |
| } finally { |
| monitor.leave(); |
| } |
| } |
| |
| /** |
| * Marks the {@link State} as ready to receive transitions. Returns true if no transitions have |
| * been observed yet. |
| */ |
| void markReady() { |
| monitor.enter(); |
| try { |
| if (!transitioned) { |
| // nothing has transitioned since construction, good. |
| ready = true; |
| } else { |
| // This should be an extremely rare race condition. |
| List<Service> servicesInBadStates = Lists.newArrayList(); |
| for (Service service : servicesByState().values()) { |
| if (service.state() != NEW) { |
| servicesInBadStates.add(service); |
| } |
| } |
| throw new IllegalArgumentException("Services started transitioning asynchronously before " |
| + "the ServiceManager was constructed: " + servicesInBadStates); |
| } |
| } finally { |
| monitor.leave(); |
| } |
| } |
| |
| void addListener(Listener listener, Executor executor) { |
| checkNotNull(listener, "listener"); |
| checkNotNull(executor, "executor"); |
| monitor.enter(); |
| try { |
| // no point in adding a listener that will never be called |
| if (!stoppedGuard.isSatisfied()) { |
| listeners.add(new ListenerCallQueue<Listener>(listener, executor)); |
| } |
| } finally { |
| monitor.leave(); |
| } |
| } |
| |
| void awaitHealthy() { |
| monitor.enterWhenUninterruptibly(awaitHealthGuard); |
| try { |
| checkHealthy(); |
| } finally { |
| monitor.leave(); |
| } |
| } |
| |
| void awaitHealthy(long timeout, TimeUnit unit) throws TimeoutException { |
| monitor.enter(); |
| try { |
| if (!monitor.waitForUninterruptibly(awaitHealthGuard, timeout, unit)) { |
| throw new TimeoutException("Timeout waiting for the services to become healthy. The " |
| + "following services have not started: " |
| + Multimaps.filterKeys(servicesByState, in(ImmutableSet.of(NEW, STARTING)))); |
| } |
| checkHealthy(); |
| } finally { |
| monitor.leave(); |
| } |
| } |
| |
| void awaitStopped() { |
| monitor.enterWhenUninterruptibly(stoppedGuard); |
| monitor.leave(); |
| } |
| |
| void awaitStopped(long timeout, TimeUnit unit) throws TimeoutException { |
| monitor.enter(); |
| try { |
| if (!monitor.waitForUninterruptibly(stoppedGuard, timeout, unit)) { |
| throw new TimeoutException("Timeout waiting for the services to stop. The following " |
| + "services have not stopped: " |
| + Multimaps.filterKeys(servicesByState, |
| not(in(ImmutableSet.of(TERMINATED, FAILED))))); |
| } |
| } finally { |
| monitor.leave(); |
| } |
| } |
| |
| ImmutableMultimap<State, Service> servicesByState() { |
| ImmutableSetMultimap.Builder<State, Service> builder = ImmutableSetMultimap.builder(); |
| monitor.enter(); |
| try { |
| for (Entry<State, Service> entry : servicesByState.entries()) { |
| if (!(entry.getValue() instanceof NoOpService)) { |
| builder.put(entry.getKey(), entry.getValue()); |
| } |
| } |
| } finally { |
| monitor.leave(); |
| } |
| return builder.build(); |
| } |
| |
| ImmutableMap<Service, Long> startupTimes() { |
| List<Entry<Service, Long>> loadTimes; |
| monitor.enter(); |
| try { |
| loadTimes = Lists.newArrayListWithCapacity(startupTimers.size()); |
| // N.B. There will only be an entry in the map if the service has started |
| for (Entry<Service, Stopwatch> entry : startupTimers.entrySet()) { |
| Service service = entry.getKey(); |
| Stopwatch stopWatch = entry.getValue(); |
| if (!stopWatch.isRunning() && !(service instanceof NoOpService)) { |
| loadTimes.add(Maps.immutableEntry(service, stopWatch.elapsed(MILLISECONDS))); |
| } |
| } |
| } finally { |
| monitor.leave(); |
| } |
| Collections.sort(loadTimes, Ordering.<Long>natural() |
| .onResultOf(new Function<Entry<Service, Long>, Long>() { |
| @Override public Long apply(Map.Entry<Service, Long> input) { |
| return input.getValue(); |
| } |
| })); |
| ImmutableMap.Builder<Service, Long> builder = ImmutableMap.builder(); |
| for (Entry<Service, Long> entry : loadTimes) { |
| builder.put(entry); |
| } |
| return builder.build(); |
| } |
| |
| /** |
| * Updates the state with the given service transition. |
| * |
| * <p>This method performs the main logic of ServiceManager in the following steps. |
| * <ol> |
| * <li>Update the {@link #servicesByState()} |
| * <li>Update the {@link #startupTimers} |
| * <li>Based on the new state queue listeners to run |
| * <li>Run the listeners (outside of the lock) |
| * </ol> |
| */ |
| void transitionService(final Service service, State from, State to) { |
| checkNotNull(service); |
| checkArgument(from != to); |
| monitor.enter(); |
| try { |
| transitioned = true; |
| if (!ready) { |
| return; |
| } |
| // Update state. |
| checkState(servicesByState.remove(from, service), |
| "Service %s not at the expected location in the state map %s", service, from); |
| checkState(servicesByState.put(to, service), |
| "Service %s in the state map unexpectedly at %s", service, to); |
| // Update the timer |
| Stopwatch stopwatch = startupTimers.get(service); |
| if (stopwatch == null) { |
| // This means the service was started by some means other than ServiceManager.startAsync |
| stopwatch = Stopwatch.createStarted(); |
| startupTimers.put(service, stopwatch); |
| } |
| if (to.compareTo(RUNNING) >= 0 && stopwatch.isRunning()) { |
| // N.B. if we miss the STARTING event then we may never record a startup time. |
| stopwatch.stop(); |
| if (!(service instanceof NoOpService)) { |
| logger.log(Level.FINE, "Started {0} in {1}.", new Object[] {service, stopwatch}); |
| } |
| } |
| // Queue our listeners |
| |
| // Did a service fail? |
| if (to == FAILED) { |
| fireFailedListeners(service); |
| } |
| |
| if (states.count(RUNNING) == numberOfServices) { |
| // This means that the manager is currently healthy. N.B. If other threads call isHealthy |
| // they are not guaranteed to get 'true', because any service could fail right now. |
| fireHealthyListeners(); |
| } else if (states.count(TERMINATED) + states.count(FAILED) == numberOfServices) { |
| fireStoppedListeners(); |
| } |
| } finally { |
| monitor.leave(); |
| // Run our executors outside of the lock |
| executeListeners(); |
| } |
| } |
| |
| @GuardedBy("monitor") |
| void fireStoppedListeners() { |
| STOPPED_CALLBACK.enqueueOn(listeners); |
| } |
| |
| @GuardedBy("monitor") |
| void fireHealthyListeners() { |
| HEALTHY_CALLBACK.enqueueOn(listeners); |
| } |
| |
| @GuardedBy("monitor") |
| void fireFailedListeners(final Service service) { |
| new Callback<Listener>("failed({service=" + service + "})") { |
| @Override void call(Listener listener) { |
| listener.failure(service); |
| } |
| }.enqueueOn(listeners); |
| } |
| |
| /** Attempts to execute all the listeners in {@link #listeners}. */ |
| void executeListeners() { |
| checkState(!monitor.isOccupiedByCurrentThread(), |
| "It is incorrect to execute listeners with the monitor held."); |
| // iterate by index to avoid concurrent modification exceptions |
| for (int i = 0; i < listeners.size(); i++) { |
| listeners.get(i).execute(); |
| } |
| } |
| |
| @GuardedBy("monitor") |
| void checkHealthy() { |
| if (states.count(RUNNING) != numberOfServices) { |
| IllegalStateException exception = new IllegalStateException( |
| "Expected to be healthy after starting. The following services are not running: " |
| + Multimaps.filterKeys(servicesByState, not(equalTo(RUNNING)))); |
| throw exception; |
| } |
| } |
| } |
| |
| /** |
| * A {@link Service} that wraps another service and times how long it takes for it to start and |
| * also calls the {@link ServiceManagerState#transitionService(Service, State, State)}, |
| * to record the state transitions. |
| */ |
| private static final class ServiceListener extends Service.Listener { |
| final Service service; |
| // We store the state in a weak reference to ensure that if something went wrong while |
| // constructing the ServiceManager we don't pointlessly keep updating the state. |
| final WeakReference<ServiceManagerState> state; |
| |
| ServiceListener(Service service, WeakReference<ServiceManagerState> state) { |
| this.service = service; |
| this.state = state; |
| } |
| |
| @Override public void starting() { |
| ServiceManagerState state = this.state.get(); |
| if (state != null) { |
| state.transitionService(service, NEW, STARTING); |
| if (!(service instanceof NoOpService)) { |
| logger.log(Level.FINE, "Starting {0}.", service); |
| } |
| } |
| } |
| |
| @Override public void running() { |
| ServiceManagerState state = this.state.get(); |
| if (state != null) { |
| state.transitionService(service, STARTING, RUNNING); |
| } |
| } |
| |
| @Override public void stopping(State from) { |
| ServiceManagerState state = this.state.get(); |
| if (state != null) { |
| state.transitionService(service, from, STOPPING); |
| } |
| } |
| |
| @Override public void terminated(State from) { |
| ServiceManagerState state = this.state.get(); |
| if (state != null) { |
| if (!(service instanceof NoOpService)) { |
| logger.log(Level.FINE, "Service {0} has terminated. Previous state was: {1}", |
| new Object[] {service, from}); |
| } |
| state.transitionService(service, from, TERMINATED); |
| } |
| } |
| |
| @Override public void failed(State from, Throwable failure) { |
| ServiceManagerState state = this.state.get(); |
| if (state != null) { |
| // Log before the transition, so that if the process exits in response to server failure, |
| // there is a higher likelihood that the cause will be in the logs. |
| if (!(service instanceof NoOpService)) { |
| logger.log(Level.SEVERE, "Service " + service + " has failed in the " + from + " state.", |
| failure); |
| } |
| state.transitionService(service, from, FAILED); |
| } |
| } |
| } |
| |
| /** |
| * A {@link Service} instance that does nothing. This is only useful as a placeholder to |
| * ensure that the {@link ServiceManager} functions properly even when it is managing no services. |
| * |
| * <p>The use of this class is considered an implementation detail of ServiceManager and as such |
| * it is excluded from {@link #servicesByState}, {@link #startupTimes}, {@link #toString} and all |
| * logging statements. |
| */ |
| private static final class NoOpService extends AbstractService { |
| @Override protected void doStart() { notifyStarted(); } |
| @Override protected void doStop() { notifyStopped(); } |
| } |
| |
| /** This is never thrown but only used for logging. */ |
| private static final class EmptyServiceManagerWarning extends Throwable {} |
| } |
