if (execution.getCommand() instanceof ReportStatus) {
            String version = GradleVersion.current().getVersion();
            String status = execution.getDaemonStateControl().getState().toString().toUpperCase(Locale.ROOT);
            Status message = new Status(execution.getDaemonContext().getPid(), version, status);
            execution.getConnection().completed(new Success(message));
        } else {

     */
    @Override
    void close();

    /**
     * Returns some memento of the current state of this target file.
     */
    State getState();

    /**
     * The actual mode of the lock. May be different to what was requested.
     */
    FileLockManager.LockMode getMode();

    /**
     * An immutable snapshot of the state of a lock.
     */

    /**
     * The browsable repository URL of this SCM.
     */
    Property<String> getUrl();

    /**
     * The tag of current code in this SCM.
     */
    Property<String> getTag();

        return path;
    }

    @Override
    public ModelRuleDescriptor getDescriptor() {
        return descriptor;
    }

    @Override
    public ModelNode.State getState() {
        return state;
    }

    public void setState(ModelNode.State state) {
        this.state = state;
    }

    @Override
    public boolean isMutable() {
        return state.mutable;

import org.gradle.api.internal.TaskInternal
import spock.lang.Specification

class TaskMutatorTest extends Specification {
    def state = Stub(TaskStateInternal)
    def task = Stub(TaskInternal) {
        getState() >> state
        toString() >> "<task>"
    }
    def nagger = new TaskMutator(task)

    def "executes mutation action when in configurable state"() {
        def action = Mock(Runnable)

        given:

        if (!node.isAtLeast(ModelNode.State.Created)) {
            throw new IllegalStateException("Cannot get view for node " + node.getPath() + " in state " + node.getState());
        }
        ModelType<T> type = getSubject().getType();
        ModelView<? extends T> view = node.asMutable(type, getDescriptor());
        try {
            execute(node, view.getInstance(), inputs);

   *
   * @param index the index of the stripe to return; must be in {@code [0...size())}
   * @return the stripe at the specified index
   */
  public abstract L getAt(int index);

  /**
   * Returns the index to which the given key is mapped, so that getAt(indexFor(key)) == get(key).
   */
  abstract int indexFor(Object key);

  /** Returns the total number of stripes in this instance. */
  public abstract int size();

        if (node instanceof LocalTaskNode) {
            LocalTaskNode localTaskNode = (LocalTaskNode) node;
            TaskInternal task = localTaskNode.getTask();
            TaskStateInternal state = task.getState();
            MissingTaskDependencyDetector missingTaskDependencyDetector = context.getService(MissingTaskDependencyDetector.class);
            TaskExecutionContext ctx = new DefaultTaskExecutionContext(

        if (cachedResult == null) {
            cachedResult = resolveState.resolve();
        }
        return cachedResult.getState() == BuildableModuleComponentMetaDataResolveResult.State.Resolved;
    }

    @Override
    public boolean isUsable() {
        return cachedResult == null || cachedResult.getState() == BuildableModuleComponentMetaDataResolveResult.State.Resolved;
    }

    /**
     * Starts this process, blocking until the process has started.
     *
     * @return this
     */
    ExecHandle start();

    void removeStartupContext();

    ExecHandleState getState();

    /**
     * Aborts the process, blocking until the process has exited. Does nothing if the process has already completed.
     */
    void abort();

    /**