WorkItem workItem = getNextItem(workerLease);
                    if (workItem == null) {
                        break;
                    }
                    Object selected = workItem.selection.getItem();
                    LOGGER.info("{} ({}) started.", selected, Thread.currentThread());
                    execute(selected, workItem.plan, workItem.executor);
                }

    }

    public Set<OperationType> getOperationTypes() {
        return operationTypes;
    }

    public boolean isRequested(OperationType workItem) {
        return operationTypes.contains(workItem);
    }

    public boolean isAnyOperationTypeRequested() {
        return !operationTypes.isEmpty();
    }

    public boolean isAnyRequested(OperationType... types) {

	if err != nil {
		autoRegistrationErrors.Increment()
		return err
	}
	if !changed {
		return nil
	}
	log.Infof("updated auto-registered WorkloadEntry %s/%s as disconnected", workItem.proxy.Metadata.Namespace, workItem.entryName)

	if workItem.autoCreated {
		autoRegistrationUnregistrations.Increment()
	}

	return &WorkArgs{
		NamespacedName: types.NamespacedName{Namespace: namespace, Name: name},
	}
}

// TimedWorker is a responsible for executing a function no earlier than at FireAt time.
type TimedWorker struct {
	WorkItem  *WorkArgs
	CreatedAt time.Time
	FireAt    time.Time
	Timer     clock.Timer
}

// createWorker creates a TimedWorker that will execute `f` not earlier than `fireAt`.

            }
        });
    }

    private void cancel(Iterable<AsyncWorkCompletion> workItems) {
        for (AsyncWorkCompletion workItem : workItems) {
            workItem.cancel();
        }
    }

    private void startWaiting(BuildOperationRef operation, List<AsyncWorkCompletion> workItems) {
        lock.lock();
        try {

        given:
        buildFile << """
            task parallelWorkTask(type: MultipleWorkItemTask) {
                doLast {
                    6.times { i ->
                        submitWorkItem("workItem\${i}")
                    }
                }
            }
        """

        // warm buildSrc
        succeeds("help")

        BuildOperationRef currentOperation = buildOperationRunner.getCurrentOperation();
        try {
            if (CollectionUtils.any(workItems, workItem -> !workItem.isComplete())) {
                executionQueue.expand();
            }
            asyncWorkTracker.waitForCompletion(currentOperation, workItems, RETAIN_PROJECT_LOCKS);

        }

        boolean isDownload() {
            return descriptor instanceof FileDownloadOperationDescriptor
        }

        boolean isBuildOperation() {
            return !test && !task && !workItem && !projectConfiguration && !transform
        }

        void assertIsTask() {
            assert startEvent instanceof TaskStartEvent
            assert finishEvent instanceof TaskFinishEvent