AuthRequest  func(r *http.Request) error // Validate incoming requests.
	TLSConfig    *tls.Config                 // TLS to apply to the connections.
	Incoming     func(n int64)               // Record incoming bytes.
	Outgoing     func(n int64)               // Record outgoing bytes.
	BlockConnect chan struct{}               // If set, incoming and outgoing connections will be blocked until closed.

import org.gradle.internal.service.scopes.ServiceScope;

@ServiceScope(Scope.Global.class)
public interface IncomingConnector {
    /**
     * Starts listening for incoming connections. Assigns an arbitrary address for the endpoint.
     *
     * @param action the action to execute on incoming connection. The supplied action is not required to be thread-safe.

public interface ConnectionAcceptor extends AsyncStoppable {
    Address getAddress();

    /**
     * Stops accepting incoming connections.
     */
    @Override
    void requestStop();

    /**
     * Stops accepting incoming connections and blocks until the accept action has completed executing for any queued connections.
     */
    @Override
    void stop();

val codeCoverageReport by tasks.registering(JacocoReport::class) {
    additionalClassDirs(classesPath.filter { it.isDirectory() })
    additionalSourceDirs(sourcesPath.incoming.artifactView { lenient(true) }.files)
    executionData(coverageDataPath.incoming.artifactView { lenient(true) }.files.filter { it.exists() })

    reports {
        html.required = true
        xml.required = true
    }
}

                compile 'test:test:1.3'
                compile 'test:test2:2.3'
                compile 'test:test3:3.3'
            }
            task resolve {
                def artifacts = configurations.compile.incoming.artifactView {
                    attributes { it.attribute(artifactType, 'size') }
                }.artifacts
                inputs.files artifacts.artifactFiles

                doLast {

        given:
        buildFile << """
            configurations {
                parent { }
                things.extendsFrom parent
                all {
                    incoming.beforeResolve { throw new RuntimeException() }
                    incoming.afterResolve { throw new RuntimeException() }
                }
            }
            dependencies {
                parent files("parent.txt")

dependencies {
    shared 'org.test:module3:1.0'
}

task resolveDependencies {
    def rootA = configurations.a.incoming.resolutionResult.rootComponent
    def rootB = configurations.b.incoming.resolutionResult.rootComponent
    doLast {
        rootA.get()
        rootB.get()
        rootA.get()
    }
}
"""

        expect: "that resolving conf a, then b, then a again, succeeds"

                    artifacts.from(configurations.producerArtifacts)
                }

                tasks.register('resolveJavadoc', Resolve) {
                    artifacts.from(configurations.producerArtifacts.incoming.artifactView {
                        withVariantReselection()
                        attributes {
                            attribute(Attribute.of('shared', String), 'shared-value')

package org.gradle.execution.plan.edges;

import org.gradle.execution.plan.Node;
import org.gradle.execution.plan.NodeSets;

import java.util.SortedSet;
import java.util.function.Consumer;

/**
 * Only incoming dependencies, no incoming must-run-after or finalizes relationships.
 */
class DependencyPredecessorsOnlyNodeSet implements DependentNodesSet {
    private final SortedSet<Node> dependencyPredecessors = NodeSets.newSortedNodeSet();

// A function that returns extra dependencies for each op. These might
// e.g. be known side-effects (or control dependencies) between ops.
// If "incoming" is true, then the list of (extra) predecessors of the
// op should be returned. If "incoming" is false, the list of successors.
// The algorithm assumes that these are consistent which each other. So
// if (and only if) op1 is in extra_dependencies(op2, true), then op2