}

// GridHost returns the host to be used for grid connections.
func (endpoint Endpoint) GridHost() string {
	return fmt.Sprintf("%s://%s", endpoint.Scheme, endpoint.Host)
}

// UpdateIsLocal - resolves the host and updates if it is local or not.
func (endpoint *Endpoint) UpdateIsLocal() (err error) {
	if endpoint.Host != "" {
		endpoint.IsLocal, err = isLocalHost(endpoint.Hostname(), endpoint.Port(), globalMinioPort)

                sb.append("Some toolchain resolvers had internal failures: ")
                    .append(failureMessage(resolveFailures))
                    .append(".");
            }
            if (!provisioningFailures.isEmpty()) {
                sb.append(resolveFailures.isEmpty() ? "" : " ");
                sb.append("Some toolchain resolvers had provisioning failures: ")

import org.gradle.internal.resolve.result.BuildableComponentResolveResult;
import org.gradle.util.internal.BuildCommencedTimeProvider;

import javax.annotation.Nullable;
import java.util.Collection;

/**
 * Creates resolvers that can resolve module components from repositories.
 */
public class ExternalModuleComponentResolverFactory {

    private final static Logger LOGGER = Logging.getLogger(ExternalModuleComponentResolverFactory.class);

        given:
        initialFiles()

        when:
        def dep5 = sourceFile("dep5")
        graph[dep5] = []
        parse(dep5)
        dependencyResolver.resolveAs("dep4", dep5)
        graph[source2] = [dep3, dep5]

        then:
        with(state) {
            recompile == [source2]
            removed == []
        }
    }

                new ModuleMetadataSpec.LocalVariant(
                    variant.getName(),
                    attributesFor(variant.getAttributes()),
                    capabilitiesFor(variant.getCapabilities()),
                    dependenciesOf(variant, resolvers.getComponentResolver()),

There are a number of ways a configuration might be resolved unsafely.
For example:

* A task from one project directly resolves a configuration in another project in the task's action.
* A task specifies a configuration from another project as an input file collection.
* A build script for one project resolves a configuration in another project during evaluation.
* Project configurations are resolved in the settings file.

     * recursively.
     * @return the set of all configurations
     */
    Set<Configuration> getHierarchy();

    /**
     * Resolves this configuration. This locates and downloads the files which make up this configuration, and returns
     * the resulting set of files.
     *

            }
            repositories {
                maven { url '${mavenHttpRepo.uri}' }
            }
        """
    }

    @ToBeFixedForConfigurationCache(because = "task uses Configuration API")
    def "resolves strictly for dependency resolve failures when #expression is used"() {
        createDirs("child")
        settingsFile << "include 'child'"
        def m1 = mavenHttpRepo.module('org.foo', 'hiphop').publish()

// Resolve repeatedly calls LogValue on v while it implements [LogValuer],
// and returns the result.
// If v resolves to a group, the group's attributes' values are not recursively
// resolved.
// If the number of LogValue calls exceeds a threshold, a Value containing an
// error is returned.
// Resolve's return value is guaranteed not to be of Kind [KindLogValuer].
func (v Value) Resolve() (rv Value) {
	orig := v

include::sample[dir="snippets/java/toolchain-foojay/groovy/",files="settings.gradle[tags=plugin-application]"]
====

In general, when applying toolchain resolver plugins, the toolchain download resolvers provided by them also need to be configured.
Let's illustrate with an example.
Consider two toolchain resolver plugins applied by the build: