import org.apache.ivy.plugins.repository.Resource; //导入依赖的package包/类
public void transferProgress(TransferEvent evt) {
    final Resource resource = evt.getResource();
    if (resource.isLocal()) {
        return;
    }
    final int eventType = evt.getEventType();
    if (eventType == TransferEvent.TRANSFER_STARTED) {
        resourceOperation = createResourceOperation(resource.getName(), getRequestType(evt), loggingClass, evt.getTotalLength());
    }
    if (eventType == TransferEvent.TRANSFER_PROGRESS) {
        resourceOperation.logProcessedBytes(evt.getLength());
    }
    if (eventType == TransferEvent.TRANSFER_COMPLETED) {
        resourceOperation.completed();
    }
}
 

import org.apache.ivy.plugins.repository.Resource; //导入依赖的package包/类
/**
 * Handles a request to retrieve a file from the repository.
 * 
 * @param source Path to the resource to retrieve, including the repository root.
 * @param destination The location where the file should be retrieved to.
 * @throws IOException If an error occurs retrieving the file.
 */
public void get(String source, File destination) throws IOException {
  fireTransferInitiated(getResource(source), TransferEvent.REQUEST_GET);
  String repositorySource = source;
  if (!source.startsWith(repositoryRoot)) {
    repositorySource = getRepositoryRoot() + source;
  }
  Message.debug("Getting file for user " + userName + " from " + repositorySource + " [revision="
      + svnRetrieveRevision + "] to " + destination.getAbsolutePath());
  try {
    SVNURL url = SVNURL.parseURIEncoded(repositorySource);
    SVNRepository repository = getRepository(url, true);
    repository.setLocation(url, false);

    Resource resource = getResource(source);
    fireTransferInitiated(resource, TransferEvent.REQUEST_GET);

    SvnDao svnDAO = new SvnDao(repository);
    svnDAO.getFile(url, destination, svnRetrieveRevision);

    fireTransferCompleted(destination.length());
  } catch (SVNException e) {
    Message.error("Error retrieving" + repositorySource + " [revision=" + svnRetrieveRevision + "]");
    throw (IOException) new IOException().initCause(e);
  }
}
 

import org.apache.ivy.plugins.repository.Resource; //导入依赖的package包/类
public Resource getResource(String source) throws IOException {
    source = encode(source);
    Resource res = resourcesCache.get(source);
    if (res == null) {
        URI uri;
        try {
            uri = new URI(source);
        } catch (URISyntaxException e) {
            // very weird URL, let's assume it is absolute
            uri = null;
        }
        if (uri == null || uri.isAbsolute()) {
            res = new URLResource(new URL(source), getTimeoutConstraint());
        } else {
            res = new URLResource(new URL(baseUrl + source), getTimeoutConstraint());
        }
        resourcesCache.put(source, res);
    }
    return res;
}
 

import org.apache.ivy.plugins.repository.Resource; //导入依赖的package包/类
/**
 * Check that a cached file can be considered up to date and thus not downloaded
 *
 * @param archiveFile
 *            the file in the cache
 * @param resource
 *            the remote resource to check
 * @param savedOrigin
 *            the saved origin which contains that last checked date
 * @param origin
 *            the origin in which to store the new last checked date
 * @param ttl
 *            the time to live to consider the cache up to date
 * @return <code>true</code> if the cache is considered up to date
 */
private boolean checkCacheUptodate(File archiveFile, Resource resource,
        ArtifactOrigin savedOrigin, ArtifactOrigin origin, long ttl) {
    long time = System.currentTimeMillis();
    if (savedOrigin.getLastChecked() != null
            && (time - savedOrigin.getLastChecked()) < ttl) {
        // still in the ttl period, no need to check, trust the cache
        return archiveFile.exists() || !savedOrigin.isExists();
    }
    if (!archiveFile.exists()) {
        // the the file doesn't exist in the cache, obviously not up to date
        return false;
    }
    origin.setLastChecked(time);
    // check if the local resource is up to date regarding the remote one
    return archiveFile.lastModified() >= resource.getLastModified();
}
 

import org.apache.ivy.plugins.repository.Resource; //导入依赖的package包/类
/**
 * This method is similar to getResource, except that the returned resource is fully initialized
 * (resolved in the sftp repository), and that the given string is a full remote path
 *
 * @param path
 *            the full remote path in the repository of the resource
 * @return a fully initialized resource, able to answer to all its methods without needing any
 *         further connection
 */
@SuppressWarnings("unchecked")
public Resource resolveResource(String path) {
    try {
        List<LsEntry> r = getSftpChannel(path).ls(getPath(path));
        if (r != null) {
            SftpATTRS attrs = r.get(0).getAttrs();
            return new BasicResource(path, true, attrs.getSize(),
                        attrs.getMTime() * MILLIS_PER_SECOND, false);
        }
    } catch (Exception e) {
        Message.debug("Error while resolving resource " + path, e);
        // silent fail, return nonexistent resource
    }

    return new BasicResource(path, false, 0, 0, false);
}
 

import org.apache.ivy.plugins.repository.Resource; //导入依赖的package包/类
/**
 * Parses a ls -l line and transforms it in a resource
 *
 * @param file ditto
 * @param responseLine ditto
 * @return Resource
 */
protected Resource lslToResource(String file, String responseLine) {
    if (responseLine == null || responseLine.startsWith("ls")) {
        return new BasicResource(file, false, 0, 0, false);
    } else {
        String[] parts = responseLine.split("\\s+");
        if (parts.length != LS_PARTS_NUMBER) {
            Message.debug("unrecognized ls format: " + responseLine);
            return new BasicResource(file, false, 0, 0, false);
        } else {
            try {
                long contentLength = Long.parseLong(parts[LS_SIZE_INDEX]);
                String date = parts[LS_DATE_INDEX1] + " " + parts[LS_DATE_INDEX2] + " "
                        + parts[LS_DATE_INDEX3] + " " + parts[LS_DATE_INDEX4];
                return new BasicResource(file, true, contentLength, FORMAT.parse(date)
                        .getTime(), false);
            } catch (Exception ex) {
                Message.warn("impossible to parse server response: " + responseLine, ex);
                return new BasicResource(file, false, 0, 0, false);
            }
        }
    }
}
 

import org.apache.ivy.plugins.repository.Resource; //导入依赖的package包/类
public void get(String source, File destination) throws IOException {
    fireTransferInitiated(getResource(source), TransferEvent.REQUEST_GET);
    try {
        Resource res = getResource(source);
        long totalLength = res.getContentLength();
        if (totalLength > 0) {
            progress.setTotalLength(totalLength);
        }
        FileUtil.copy(new URL(source), destination, progress, getTimeoutConstraint());
    } catch (IOException | RuntimeException ex) {
        fireTransferError(ex);
        throw ex;
    } finally {
        progress.setTotalLength(null);
    }
}
 

import org.apache.ivy.plugins.repository.Resource; //导入依赖的package包/类
public Resource getResource(String source) throws IOException {
    for (Repository repository : repositories) {
        logTry(repository);
        try {
            Resource r = repository.getResource(source);
            if (r != null && r.exists()) {
                logSuccess(repository);
                return r;
            }
        } catch (Exception e) {
            logFailed(repository, e);
        }
    }
    // resource that basically doesn't exists
    return new BasicResource(source, false, 0, 0, true);
}
 

import org.apache.ivy.plugins.repository.Resource; //导入依赖的package包/类
protected ResourceMDParser getRMDParser(final DependencyDescriptor dd, final ResolveData data) {
    return new ResourceMDParser() {
        public MDResolvedResource parse(Resource resource, String rev) {
            try {
                ResolvedModuleRevision rmr = BasicResolver.this.parse(new ResolvedResource(
                        resource, rev), dd, data);
                if (rmr != null) {
                    return new MDResolvedResource(resource, rev, rmr);
                }
            } catch (ParseException e) {
                Message.warn("Failed to parse the file '" + resource + "'", e);
            }
            return null;
        }

    };
}
 

import org.apache.ivy.plugins.repository.Resource; //导入依赖的package包/类
@Override
public ArtifactDownloadReport download(final ArtifactOrigin origin, DownloadOptions options) {
    Checks.checkNotNull(origin, "origin");
    return getRepositoryCacheManager().download(origin.getArtifact(),
        new ArtifactResourceResolver() {
            public ResolvedResource resolve(Artifact artifact) {
                try {
                    Resource resource = getResource(origin.getLocation());
                    if (resource != null) {
                        String revision = origin.getArtifact().getModuleRevisionId().getRevision();
                        return new ResolvedResource(resource, revision);
                    }
                } catch (IOException e) {
                    Message.debug(e);
                }
                return null;
            }
        }, downloader, getCacheDownloadOptions(options));
}
 

import org.apache.ivy.plugins.repository.Resource; //导入依赖的package包/类
@Override
public ResolvedResource findIvyFileRef( DependencyDescriptor depDescriptor, ResolveData data )
{
    Artifact artifact = DefaultArtifact.newIvyArtifact( depDescriptor.getDependencyRevisionId(), null );

    ResolutionRequest request = new ResolutionRequest();
    request.setArtifact( ivy2aether( artifact.getModuleRevisionId(), "pom" ) );
    ResolutionResult result = getResolver().resolve( request );
    Path pomPath = result.getArtifactPath();
    if ( pomPath == null )
        return null;

    Resource fileResource = new FileResource( new FileRepository(), pomPath.toFile() );
    return new ResolvedResource( fileResource, resolvedVersion( result ) );
}
 

import org.apache.ivy.plugins.repository.Resource; //导入依赖的package包/类
private boolean existOnRepo(String dest) {
    try {
        final String path = completePath(dest);
        final Resource resource = resolver.getRepository().getResource(path);
        return resource.exists();
    } catch (final IOException e) {
        throw new RuntimeException(e);
    }
}
 

import org.apache.ivy.plugins.repository.Resource; //导入依赖的package包/类
private MavenMetadata loadMavenMedatata(String path) {
    try {
        final Resource resource = resolver.getRepository().getResource(completePath(path));
        if (resource.exists()) {
            final InputStream inputStream = resource.openStream();
            final MavenMetadata mavenMetadata = MavenMetadata.of(inputStream);
            inputStream.close();
            return mavenMetadata;
        }
        return null;
    } catch (final IOException e) {
        throw new RuntimeException(e);
    }
}
 

import org.apache.ivy.plugins.repository.Resource; //导入依赖的package包/类
private File downloadAndCacheArtifactFile(final ModuleVersionArtifactMetaData id, Artifact artifact, ResourceDownloader resourceDownloader, Resource resource) throws IOException {
    final File tmpFile = temporaryFileProvider.createTemporaryFile("gradle_download", "bin");
    try {
        resourceDownloader.download(artifact, resource, tmpFile);
        return cacheLockingManager.useCache(String.format("Store %s", id), new Factory<File>() {
            public File create() {
                return fileStore.move(id, tmpFile).getFile();
            }
        });
    } finally {
        tmpFile.delete();
    }
}
 

import org.apache.ivy.plugins.repository.Resource; //导入依赖的package包/类
protected ModuleDescriptor parseModuleDescriptor(DependencyResolver resolver, Artifact moduleArtifact, CacheMetadataOptions options, File artifactFile, Resource resource) throws ParseException {
    ModuleRevisionId moduleRevisionId = moduleArtifact.getId().getModuleRevisionId();
    try {
        IvySettings ivySettings = IvyContextualiser.getIvyContext().getSettings();
        ParserSettings parserSettings = new LegacyResolverParserSettings(ivySettings, resolver, moduleRevisionId);
        ModuleDescriptorParser parser = ModuleDescriptorParserRegistry.getInstance().getParser(resource);
        return parser.parseDescriptor(parserSettings, new URL(artifactFile.toURI().toASCIIString()), resource, options.isValidate());
    } catch (IOException e) {
        throw UncheckedException.throwAsUncheckedException(e);
    }
}
 

import org.apache.ivy.plugins.repository.Resource; //导入依赖的package包/类
public ModuleDescriptor getModuleDescriptor(ParserSettings settings, InputStream input,
        Resource res, boolean validate) throws ParseException, IOException {
    Parser parser = newParser(settings);
    parser.setValidate(validate);
    parser.setResource(res);
    parser.setInput(input);
    parser.parse();
    return parser.getModuleDescriptor();
}
 

import org.apache.ivy.plugins.repository.Resource; //导入依赖的package包/类
/**
 * Gets a SvnResource.
 * 
 * @param source Path to the resource in Subversion, relative to the repository root.
 * @return The resource.
 * @throws IOException Never thrown, just here to satisfy interface.
 */
public Resource getResource(String source) throws IOException {
  String repositorySource = getRepositoryRoot() + source;
  Resource resource = (Resource) resourcesCache.get(repositorySource);
  if (resource == null) {
    resource = new SvnResource(this, repositorySource);
    resourcesCache.put(repositorySource, resource);
  }
  return resource;
}
 

import org.apache.ivy.plugins.repository.Resource; //导入依赖的package包/类
protected URI buildBundleURI(String location) throws IOException {
    Resource resource = repo.getResource(location);
    // We have a resource to transform into an URI, let's use some heuristics
    try {
        return new URI(resource.getName());
    } catch (URISyntaxException e) {
        return new File(resource.getName()).toURI();
    }
}
 

import org.apache.ivy.plugins.repository.Resource; //导入依赖的package包/类
@Override
public ResolvedResource findArtifactRef(Artifact artifact, Date date) {
    URL url = artifact.getUrl();
    if (url == null) {
        // not an artifact resolved by this resolver
        return null;
    }
    Message.verbose("\tusing url for " + artifact + ": " + url);
    logArtifactAttempt(artifact, url.toExternalForm());
    final Resource resource = new URLResource(url, this.getTimeoutConstraint());
    return new ResolvedResource(resource, artifact.getModuleRevisionId().getRevision());
}
 

import org.apache.ivy.plugins.repository.Resource; //导入依赖的package包/类
@Override
protected long get(Resource resource, File dest) throws IOException {
    Message.verbose("\t" + getName() + ": downloading " + resource.getName());
    Message.debug("\t\tto " + dest);
    if (dest.getParentFile() != null) {
        dest.getParentFile().mkdirs();
    }
    getRepository().get(resource.getName(), dest);
    return dest.length();
}