private final Object lock = new Object();
    private boolean cancelled;
    private List<Runnable> callbacks = new LinkedList<Runnable>();

    @Override
    public boolean isCancellationRequested() {
        synchronized (lock) {
            return cancelled;
        }
    }

    @Override
    public boolean addCallback(Runnable cancellationHandler) {
        boolean returnValue;

/**
 * Cancellation token passed from consumer to provider to propagate cancellation events.
 * @since 2.1-rc-1
 */
public interface InternalCancellationToken {
    boolean isCancellationRequested();

    /**
     * Adds a callback that will be executed when cancel event is triggered.
     * It can be run synchronously if the token is already cancelled.
     *

 *
 * @since 2.1
 */
public interface CancellationToken {
    /**
     * Gets whether cancellation has been requested for this token.
     * @return Cancellation status.
     */
    boolean isCancellationRequested();

        throws BuildExceptionVersion1, InternalUnsupportedModelException {
        assertCanQuery();
        if (cancellationToken.isCancellationRequested()) {
            throw new BuildCancelledException(String.format("Could not build '%s' model. Build cancelled.", modelIdentifier.getName()));
        }

                } else {
                    return BuildActionResult.of(payloadSerializer.serialize(result.getClientResult()));
                }
            }
            if (requestContext.getCancellationToken().isCancellationRequested()) {
                return BuildActionResult.cancelled(payloadSerializer.serialize(result.getBuildFailure()));
            }

        } finally {
            stopped = true;
            lock.unlock();
        }
    }

    private void requestCancellation() {
        if (cancellationToken != null && !cancellationToken.isCancellationRequested()) {
            cancellationToken.cancel();
        }
    }

    private void sendStopWhenIdleMessageToDaemons() {