kind: ServiceEntry
metadata:
  name: app
  namespace: app
spec:
  hosts:
  - app.com
  ports:
  - number: 80
    name: http
    protocol: HTTP
  resolution: {{.Resolution}}
  endpoints:
{{- if eq .Resolution "DNS" }}
  - address: app.com
{{- else }}
  - address: 1.1.1.1
{{- end }}
---
apiVersion: networking.istio.io/v1alpha3
kind: ServiceEntry
metadata:
  name: excluded

        this.resolutions = ImmutableList.copyOf(resolutions);

        LOGGER.info("Variant Selection Exception: {} caused by Resolution Failure: {}", this.getClass().getName(), failure.getClass().getName());
    }

    public ResolutionFailure getFailure() {
        return failure;
    }

    @Override
    public ImmutableList<String> getResolutions() {
        return resolutions;
    }

 */

package org.gradle.internal.component.resolution.failure.describer;

import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Lists;
import org.gradle.api.attributes.Attribute;
import org.gradle.api.internal.attributes.AttributesSchemaInternal;
import org.gradle.api.internal.attributes.ImmutableAttributes;
import org.gradle.internal.component.resolution.failure.ResolutionCandidateAssessor.AssessedCandidate;

    /**
     * Gets the local repository to use for the resolution.
     *
     * @return The local repository to use for the resolution or {@code null} if not set.
     */
    ArtifactRepository getLocalRepository();

    /**
     * Sets the local repository to use for the resolution.
     *
     * @param localRepository The local repository to use for the resolution.
     * @return This request, never {@code null}.
     */

====

[[reproducible-resolution]]
== Making sure resolution is reproducible

There are cases where dependency resolution can be _unstable_ over time.
That is to say that if you build at date D, building at date D+x may give a different resolution result.

This is possible in the following cases:

 * limitations under the License.
 */

package org.gradle.internal.component.resolution.failure.describer;

import org.gradle.api.internal.attributes.AttributesSchemaInternal;
import org.gradle.internal.component.resolution.failure.exception.ConfigurationSelectionException;
import org.gradle.internal.component.resolution.failure.type.ExternalRequestedConfigurationNotFoundFailure;

import java.util.List;

kind: ServiceEntry
metadata:
  name: external-service-locality
spec:
  hosts:
  - {{.Host}}
  location: MESH_EXTERNAL
  ports:
  - name: http
    number: 80
    protocol: HTTP
  resolution: {{.Resolution}}
  endpoints:
  - address: {{.Local}}
    locality: region/zone/subzone
  - address: {{.Remote}}
    locality: notregion/notzone/notsubzone
  {{ if ne .NearLocal "" }}
  - address: {{.NearLocal}}

        for (NativeBinaryRequirementResolveResult resolution : getAllResolutions()) {
            if (resolution.getLibraryBinary() != null) {
                result.add(resolution.getLibraryBinary());
            }
        }
        return result;
    }

    public List<NativeBinaryRequirementResolveResult> getPendingResolutions() {
        return CollectionUtils.filter(resolutions, new Spec<NativeBinaryRequirementResolveResult>() {

    /**
     * Returns the graph resolution state for the component, if it was available at resolve time.
     *
     * @throws ModuleVersionResolveException If resolution was unsuccessful and the descriptor is not available.
     */
    @Nullable
    ComponentGraphResolveState getState();

    /**
     * Returns the graph specific resolution state for the component, if it was available at resolve time.
     *

    }

    def "does not allow changing conflict resolution on a configuration that has been resolved"() {
        buildFile << """
            configurations { a }
            configurations.a.resolve()
            configurations.a.resolutionStrategy.failOnVersionConflict()
        """

        when: fails()
        then: failure.assertHasCause("Cannot change resolution strategy of dependency configuration ':a' after it has been resolved")