resolver.resolve(identifier, componentOverrideMetadata, result);

        if (result.getFailure() != null) {
            return;
        }
        org.gradle.api.artifacts.ClientModule clientModule = componentOverrideMetadata.getClientModule();
        if (clientModule != null) {

        } else {
            List<String> executionReasons = result != null ? result.getUpToDateMessages() : null;
            Throwable failure = finishEvent.getFailure();
            if (failure == null) {
                return new DefaultTaskSuccessResult(startTime, endTime, false, state.isFromCache(), "SUCCESS", incremental, executionReasons);
            } else {

            delegate.getRemoteAccess().resolveArtifactsWithType(component, artifactType, result);

            if (result.getFailure() == null) {
                ModuleDescriptorHashModuleSource moduleSource = findCachingModuleSource(component.getSources());

        return true;
    }

    public TaskProperties getTaskProperties() {
        return taskProperties;
    }

    @Override
    public Throwable getNodeFailure() {
        return task.getState().getFailure();
    }

    @Override
    public void resolveDependencies(TaskDependencyResolver dependencyResolver) {
        // Make sure it has been configured
        taskProject.getTasks().prepareForExecution(task);

        reportItem(currentArtifact.key.getComponentIdentifier().getDisplayName());
        reportItem(createFileLink(currentArtifact.key, firstFailure.getFailure(), firstFailure.getRepositoryName()));
        contents.append("            <td>\n");
        currentArtifact.failures.forEach(this::formatError);
        contents.append("            </td>\n")

    public interface FailureTracker {
        FailureTracker NO_FAILURE_TRACKER = new FailureTracker() {
            @Override
            public RuntimeException getFailure() {
                return null;
            }
        };

        RuntimeException getFailure();
    }

    private static class SendEmptyResponse extends ErroringAction<HttpExchange> {
        @Override

                if (!responseProducer.isFailure()) {
                    responseProducer.writeTo(id, httpExchange);
                } else {
                    Throwable failure = responseProducer.getFailure();
                    requestFailed(outcome, failure);
                    String stacktrace = ExceptionUtils.getStackTrace(failure);
                    dumpThreadsUponTimeout(stacktrace);

        if (edge instanceof UnresolvedDependencyEdge) {
            UnresolvedDependencyEdge unresolved = (UnresolvedDependencyEdge) edge;
            Throwable failure = unresolved.getFailure();
            DefaultSection failures = new DefaultSection("Failures");
            LinkedHashSet<String> uniqueResolutions = new LinkedHashSet<>();

        if (result.getException() != null) {
            throw map(result, result.getException());
        }
        if (result.getFailure() != null) {
            throw map(result, (RuntimeException) payloadSerializer.deserialize(result.getFailure()));
        }
    }

    private RuntimeException map(BuildActionResult result, RuntimeException exception) {

            getRequested() >> selector
            getFromVariant() >> id(from)
            getSelected() >> id(selected)
            getSelectedVariant() >> id(selected)
            getFailure() >> failure
        }
    }

    private Long id(String module) {
        return module.hashCode()
    }

    class DummyModuleVersionSelection implements ResolvedGraphComponent {