in maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/DefaultArtifactResolver.java [206:432]
private List<ArtifactResult> resolve(
SyncContext shared,
SyncContext exclusive,
Collection<Artifact> subjects,
RepositorySystemSession session,
Collection<? extends ArtifactRequest> requests)
throws ArtifactResolutionException {
SystemDependencyScope systemDependencyScope = session.getSystemDependencyScope();
SyncContext current = shared;
try {
while (true) {
current.acquire(subjects, null);
boolean failures = false;
final List<ArtifactResult> results = new ArrayList<>(requests.size());
final boolean simpleLrmInterop =
ConfigUtils.getBoolean(session, DEFAULT_SIMPLE_LRM_INTEROP, CONFIG_PROP_SIMPLE_LRM_INTEROP);
final LocalRepositoryManager lrm = session.getLocalRepositoryManager();
final WorkspaceReader workspace = session.getWorkspaceReader();
final List<ResolutionGroup> groups = new ArrayList<>();
// filter != null: means "filtering applied", if null no filtering applied (behave as before)
final RemoteRepositoryFilter filter = remoteRepositoryFilterManager.getRemoteRepositoryFilter(session);
for (ArtifactRequest request : requests) {
RequestTrace trace = RequestTrace.newChild(request.getTrace(), request);
ArtifactResult result = new ArtifactResult(request);
results.add(result);
Artifact artifact = request.getArtifact();
if (current == shared) {
artifactResolving(session, trace, artifact);
}
String localPath =
systemDependencyScope != null ? systemDependencyScope.getSystemPath(artifact) : null;
if (localPath != null) {
// unhosted artifact, just validate file
Path path = Paths.get(localPath);
if (!Files.isRegularFile(path)) {
failures = true;
result.addException(
ArtifactResult.NO_REPOSITORY, new ArtifactNotFoundException(artifact, localPath));
} else {
artifact = artifact.setPath(path);
result.setArtifact(artifact);
artifactResolved(session, trace, artifact, null, result.getExceptions());
}
continue;
}
List<RemoteRepository> remoteRepositories = request.getRepositories();
List<RemoteRepository> filteredRemoteRepositories = new ArrayList<>(remoteRepositories);
if (filter != null) {
for (RemoteRepository repository : remoteRepositories) {
RemoteRepositoryFilter.Result filterResult = filter.acceptArtifact(repository, artifact);
if (!filterResult.isAccepted()) {
result.addException(
repository,
new ArtifactFilteredOutException(
artifact, repository, filterResult.reasoning()));
filteredRemoteRepositories.remove(repository);
}
}
}
VersionResult versionResult;
try {
VersionRequest versionRequest =
new VersionRequest(artifact, filteredRemoteRepositories, request.getRequestContext());
versionRequest.setTrace(trace);
versionResult = versionResolver.resolveVersion(session, versionRequest);
} catch (VersionResolutionException e) {
if (filteredRemoteRepositories.isEmpty()) {
result.addException(lrm.getRepository(), e);
} else {
filteredRemoteRepositories.forEach(r -> result.addException(r, e));
}
continue;
}
artifact = artifact.setVersion(versionResult.getVersion());
if (versionResult.getRepository() != null) {
if (versionResult.getRepository() instanceof RemoteRepository) {
filteredRemoteRepositories =
Collections.singletonList((RemoteRepository) versionResult.getRepository());
} else {
filteredRemoteRepositories = Collections.emptyList();
}
}
if (workspace != null) {
Path path = workspace.findArtifactPath(artifact);
if (path != null) {
artifact = artifact.setPath(path);
result.setArtifact(artifact);
result.setRepository(workspace.getRepository());
artifactResolved(session, trace, artifact, result.getRepository(), null);
continue;
}
}
LocalArtifactResult local = lrm.find(
session,
new LocalArtifactRequest(
artifact, filteredRemoteRepositories, request.getRequestContext()));
result.setLocalArtifactResult(local);
boolean found = (filter != null && local.isAvailable()) || isLocallyInstalled(local, versionResult);
// with filtering it is availability that drives logic
// without filtering it is simply presence of file that drives the logic
// "interop" logic with simple LRM leads to RRF breakage: hence is ignored when filtering in effect
if (found) {
if (local.getRepository() != null) {
result.setRepository(local.getRepository());
} else {
result.setRepository(lrm.getRepository());
}
try {
artifact = artifact.setPath(getPath(session, artifact, local.getPath()));
result.setArtifact(artifact);
artifactResolved(session, trace, artifact, result.getRepository(), null);
} catch (ArtifactTransferException e) {
result.addException(lrm.getRepository(), e);
}
if (filter == null && simpleLrmInterop && !local.isAvailable()) {
/*
* NOTE: Interop with simple local repository: An artifact installed by a simple local repo
* manager will not show up in the repository tracking file of the enhanced local repository.
* If however the maven-metadata-local.xml tells us the artifact was installed locally, we
* sync the repository tracking file.
*/
lrm.add(session, new LocalArtifactRegistration(artifact));
}
continue;
}
if (local.getPath() != null) {
LOGGER.info(
"Artifact {} is present in the local repository, but cached from a remote repository ID that is unavailable in current build context, verifying that is downloadable from {}",
artifact,
remoteRepositories);
}
LOGGER.debug("Resolving artifact {} from {}", artifact, remoteRepositories);
AtomicBoolean resolved = new AtomicBoolean(false);
Iterator<ResolutionGroup> groupIt = groups.iterator();
for (RemoteRepository repo : filteredRemoteRepositories) {
if (!repo.getPolicy(artifact.isSnapshot()).isEnabled()) {
continue;
}
try {
Utils.checkOffline(session, offlineController, repo);
} catch (RepositoryOfflineException e) {
Exception exception = new ArtifactNotFoundException(
artifact,
repo,
"Cannot access " + repo.getId() + " ("
+ repo.getUrl() + ") in offline mode and the artifact " + artifact
+ " has not been downloaded from it before.",
e);
result.addException(repo, exception);
continue;
}
ResolutionGroup group = null;
while (groupIt.hasNext()) {
ResolutionGroup t = groupIt.next();
if (t.matches(repo)) {
group = t;
break;
}
}
if (group == null) {
group = new ResolutionGroup(repo);
groups.add(group);
groupIt = Collections.emptyIterator();
}
group.items.add(new ResolutionItem(trace, artifact, resolved, result, local, repo));
}
}
if (!groups.isEmpty() && current == shared) {
current.close();
current = exclusive;
continue;
}
for (ResolutionGroup group : groups) {
performDownloads(session, group);
}
for (ArtifactResolverPostProcessor artifactResolverPostProcessor :
artifactResolverPostProcessors.values()) {
artifactResolverPostProcessor.postProcess(session, results);
}
for (ArtifactResult result : results) {
ArtifactRequest request = result.getRequest();
Artifact artifact = result.getArtifact();
if (artifact == null || artifact.getPath() == null) {
failures = true;
if (result.getExceptions().isEmpty()) {
Exception exception =
new ArtifactNotFoundException(request.getArtifact(), (RemoteRepository) null);
result.addException(result.getRepository(), exception);
}
RequestTrace trace = RequestTrace.newChild(request.getTrace(), request);
artifactResolved(session, trace, request.getArtifact(), null, result.getExceptions());
}
}
if (failures) {
throw new ArtifactResolutionException(results);
}
return results;
}
} finally {
current.close();
}
}