}


    @Override
    public DfsResolver getDfs () {
        return this.delegate.getDfs();
    }


    @Override
    public Credentials getCredentials () {
        return this.delegate.getCredentials();
    }


    @Override
    public URLStreamHandler getUrlHandler () {
        if ( this.wrappedHandler == null ) {
            this.wrappedHandler = new Handler(this);

        }

        @Override
        public <T> T getCredentials(Class<T> type) {
            if (authentications == null || authentications.size() < 1) {
                return null;
            }

            Credentials credentials = ((AuthenticationInternal) authentications.iterator().next()).getCredentials();

            if (credentials == null) {
                return null;
            }

import org.gradle.internal.verifier.HttpRedirectVerifier;

import java.util.Collection;
import java.util.Collections;

public interface ResourceConnectorSpecification {
    default <T> T getCredentials(Class<T> type) {
        return null;
    }

    default Collection<Authentication> getAuthentications() {
        return Collections.emptyList();
    }

     * @param tf
     * @param tdom
     * @param thost
     * @return
     */
    protected boolean matches ( CIFSContext tf, String thost, String tdom ) {
        return Objects.equals(this.getCredentials(), tf.getCredentials()) && Objects.equals(this.targetHost, thost)
                && Objects.equals(this.targetDomain, tdom);
    }

import org.apache.http.auth.Credentials;

/**
 *
 *
 * @author shinsuke
 *
 */
public interface Authentication {

    AuthScope getAuthScope();

    Credentials getCredentials();

    AuthScheme getAuthScheme();

    private WebConfig webConfig;

    public Authentication getAuthentication() {
        return new AuthenticationImpl(getAuthScope(), getCredentials(), getAuthScheme());
    }

    private AuthScheme getAuthScheme() {
        final String scheme = getProtocolScheme();
        if (Constants.BASIC.equals(scheme)) {
            return new BasicScheme();
        }

 * <p>
 * Any other type of response will be treated as an error, causing the remote cache to be disabled for the remainder of the build.
 * <p>
 * When credentials are configured (see {@link #getCredentials()}), they are sent using HTTP Basic Auth.
 * <p>
 * Requests that fail during request transmission, after having established a TCP connection, will automatically be retried.

    /**
     * @return the SID resolver for this context
     */
    SidResolver getSIDResolver ();


    /**
     * 
     * @return the used credentials
     */
    Credentials getCredentials ();


    /**
     * @return an URL handler using this context
     */
    URLStreamHandler getUrlHandler ();


    /**
     * @return whether default credentials are available
     */

    }

    @Override
    public ExternalResourceConnector createResourceConnector(ResourceConnectorSpecification connectionDetails) {
        PasswordCredentials passwordCredentials = connectionDetails.getCredentials(PasswordCredentials.class);
        SftpResourceAccessor accessor = new SftpResourceAccessor(sftpClientFactory, passwordCredentials);
        SftpResourceLister lister = new SftpResourceLister(sftpClientFactory, passwordCredentials);

    private Map<String, Map<String, CacheEntry<DfsReferralDataInternal>>> getTrustedDomains ( CIFSContext tf ) throws SmbAuthException {
        if ( tf.getConfig().isDfsDisabled() || tf.getCredentials().getUserDomain() == null || tf.getCredentials().getUserDomain().isEmpty() ) {
            return null;
        }

        if ( this._domains != null && System.currentTimeMillis() > this._domains.expiration ) {