} else {
    for (const auto& code : clean_stop_errors) {
      clean_stop_errors_.insert(static_cast<int>(code));
    }
  }
}

Coordinator::~Coordinator() {
  RequestStop().IgnoreError();
  Join().IgnoreError();
}

Status Coordinator::RegisterRunner(std::unique_ptr<RunnerInterface> runner) {
  {
    mutex_lock l(mu_);
    if (should_stop_) {

     *
     * <li>If no connections are available, dispatches queued messages to any handlers that implement {@link RejectedMessageListener}.</li>
     *
     * </ul>
     */
    @Override
    public void requestStop() {
        lock.lock();
        try {
            if (state != State.Running) {
                return;
            }
            try {
                outgoingQueue.endOutput();

public interface ConnectionAcceptor extends AsyncStoppable {
    Address getAddress();

    /**
     * Stops accepting incoming connections.
     */
    @Override
    void requestStop();

    /**
     * Stops accepting incoming connections and blocks until the accept action has completed executing for any queued connections.
     */
    @Override
    void stop();

import java.util.concurrent.locks.Lock;

class IncomingQueue extends MultiChannelQueue {
    IncomingQueue(Lock lock) {
        super(lock);
    }

    public void requestStop() {
        queue(new EndOfStream());
    }

                        state = State.STOPPED;
                    }
                }
            } finally {
                lock.unlock();
            }
        }
    }

    @Override
    public void requestStop() {
        lock.lock();
        try {
            if (state == State.RUNNING) {
                if (usages.isEmpty()) {
                    state = State.STOPPED;
                } else {

     * Requesting stopping means preparing for stopping; stopping accepting new work.
     * You have to call stop at some point anyway if your intention is to completely stop the stoppable.
     */
    void requestStop();

        connection = completion.create(serializer);
        hub.addConnection(connection);
        hub.noFurtherConnections();
        completion = null;
    }

    @Override
    public void requestStop() {
        hub.requestStop();
    }

    @Override
    public void stop() {
        // TODO:ADAM - need to cleanup completion too, if not used
        CompositeStoppable.stoppable(hub, connection).stop();
    }

                    count--
                    condition.signalAll()
                } finally {
                    lock.unlock()
                }
            }
        }
    }

    void requestStop() {
    }

    void stop() {
        lock.lock()
        try {
            while (count > 0) {
                condition.await()
            }
        } finally {
            lock.unlock()
        }

    void connect();

    /**
     * Commences a graceful stop of this connection. Stops accepting outgoing messages. Requests that the peer stop
     * sending incoming messages.
     */
    @Override
    void requestStop();

    /**
     * Performs a graceful stop of this connection. Stops accepting outgoing messages. Blocks until all incoming messages
     * have been handled, and all outgoing messages have been forwarded to the peer.

     *
     * <p>The daemon will stop accepting new work, so that subsequent calls to {@link #runCommand} will fail with {@link DaemonUnavailableException}.
     */
    void requestStop(String reason);

    /**
     * Requests a forceful stops of the daemon. Does not wait until the daemon is idle to begin stopping. The stop will happen asynchronously, and this method does not block.
     *