dispatchLock.unlock();
            }
        } catch (MessageIOException e) {
            if (suspect) {
                LOG.debug("Problem dispatching message to the daemon.", e);
            } else {
                LOG.debug("Problem dispatching message to the daemon. Performing 'on failure' operation...");
                if (!hasReceived && staleAddressDetector.maybeStaleAddress(e)) {

	// Complete returns a QueueSet configured by the given
	// dispatching configuration.
	Complete(DispatchingConfig) QueueSet
}

// QueueSet is the abstraction for the queuing and dispatching
// functionality of one non-exempt priority level.  It covers the
// functionality described in the "Assignment to a Queue", "Queuing",
// and "Dispatching" sections of

 */
package org.gradle.internal.dispatch;

public interface DispatchFailureHandler<T> {
    /**
     * Called when a message could not be dispatched. This method can throw an exception to abort further dispatching.
     */
    void dispatchFailed(T message, Throwable failure);

	dispatching bool
	// watchersBuffer is a list of watchers potentially interested in currently
	// dispatched event.
	watchersBuffer []*cacheWatcher
	// blockedWatchers is a list of watchers whose buffer is currently full.
	blockedWatchers []*cacheWatcher
	// watchersToStop is a list of watchers that were supposed to be stopped
	// during current dispatching, but stopping was deferred to the end of

    @Override
    public void execute(DaemonCommandExecution execution) {
        execution.proceed();

        Result result = new Success(execution.getResult());

        LOGGER.debug("Daemon is dispatching the build result: {}", result);
        execution.getConnection().completed(result);
    }

        try {
            Runnable command = new Runnable() {
                @Override
                public void run() {
                    LOGGER.info("Daemon is about to start building {}. Dispatching build started information...", build);
                    execution.getConnection().buildStarted(new BuildStarted(diagnostics));
                    execution.proceed();
                }
            };

			src:        mustReader(t, bytes.NewReader([]byte("abcd")), 4, "", "", 4),
			size:       4,
			actualSize: 4,
			success:    true,
		},
		{
			desc:       "Mismatching sha256",
			src:        mustReader(t, bytes.NewReader([]byte("abcd")), 4, "", "88d4266fd4e6338d13b845fcf289579d209c897823b9217da3e161936f031589", 4),
			size:       4,
			actualSize: 4,

    /**
     * Stops accepting new method calls, and blocks until all method calls have been executed by the target object.
     *
     * @throws DispatchException When there were any failures dispatching method calls to the target object.
     */
    @Override
    void stop() throws DispatchException;

// Verifies that the given types are cast compatible. If not, emits appropriate
// error for the given op. If mask_one_dim is set to true, then the types are
// allowed to have one mismatching dimension. Masking one of the dimensions is
// useful for ops like Concat that requires all ranked inputs to have the same
// rank and match dimension sizes for all but one of the dimensions.

        then:
        new ArrayList<String>(messages).sort() == 0..19

        cleanup:
        connection1.stop()
        connection2.stop()
    }

    def "stops dispatching outgoing messages to failed connection"() {
        RemoteConnection<InterHubMessage> outgoing = Mock()
        def connection = new MockOutgoingConnection(outgoing)
        def dispatch = hub.getOutgoing("channel", String)