1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.maven.repository.internal;
20
21 import javax.inject.Inject;
22 import javax.inject.Named;
23 import javax.inject.Singleton;
24
25 import java.io.InputStream;
26 import java.nio.file.Files;
27 import java.util.ArrayList;
28 import java.util.Collections;
29 import java.util.HashMap;
30 import java.util.List;
31 import java.util.Locale;
32 import java.util.Map;
33 import java.util.Objects;
34
35 import org.apache.maven.api.Constants;
36 import org.apache.maven.artifact.ArtifactUtils;
37 import org.apache.maven.artifact.repository.metadata.Versioning;
38 import org.apache.maven.metadata.v4.MetadataStaxReader;
39 import org.eclipse.aether.RepositoryEvent;
40 import org.eclipse.aether.RepositoryEvent.EventType;
41 import org.eclipse.aether.RepositorySystemSession;
42 import org.eclipse.aether.RequestTrace;
43 import org.eclipse.aether.SyncContext;
44 import org.eclipse.aether.impl.MetadataResolver;
45 import org.eclipse.aether.impl.RepositoryEventDispatcher;
46 import org.eclipse.aether.impl.VersionRangeResolver;
47 import org.eclipse.aether.metadata.DefaultMetadata;
48 import org.eclipse.aether.metadata.Metadata;
49 import org.eclipse.aether.repository.ArtifactRepository;
50 import org.eclipse.aether.repository.RemoteRepository;
51 import org.eclipse.aether.repository.WorkspaceReader;
52 import org.eclipse.aether.resolution.MetadataRequest;
53 import org.eclipse.aether.resolution.MetadataResult;
54 import org.eclipse.aether.resolution.VersionRangeRequest;
55 import org.eclipse.aether.resolution.VersionRangeResolutionException;
56 import org.eclipse.aether.resolution.VersionRangeResult;
57 import org.eclipse.aether.spi.synccontext.SyncContextFactory;
58 import org.eclipse.aether.util.ConfigUtils;
59 import org.eclipse.aether.version.InvalidVersionSpecificationException;
60 import org.eclipse.aether.version.Version;
61 import org.eclipse.aether.version.VersionConstraint;
62 import org.eclipse.aether.version.VersionRange;
63 import org.eclipse.aether.version.VersionScheme;
64
65
66
67
68 @Named
69 @Singleton
70 @Deprecated(since = "4.0.0")
71 public class DefaultVersionRangeResolver implements VersionRangeResolver {
72
73 private static final String MAVEN_METADATA_XML = "maven-metadata.xml";
74
75 private final MetadataResolver metadataResolver;
76 private final SyncContextFactory syncContextFactory;
77 private final RepositoryEventDispatcher repositoryEventDispatcher;
78 private final VersionScheme versionScheme;
79
80 @Inject
81 public DefaultVersionRangeResolver(
82 MetadataResolver metadataResolver,
83 SyncContextFactory syncContextFactory,
84 RepositoryEventDispatcher repositoryEventDispatcher,
85 VersionScheme versionScheme) {
86 this.metadataResolver = Objects.requireNonNull(metadataResolver, "metadataResolver cannot be null");
87 this.syncContextFactory = Objects.requireNonNull(syncContextFactory, "syncContextFactory cannot be null");
88 this.repositoryEventDispatcher =
89 Objects.requireNonNull(repositoryEventDispatcher, "repositoryEventDispatcher cannot be null");
90 this.versionScheme = Objects.requireNonNull(versionScheme, "versionScheme cannot be null");
91 }
92
93 @Override
94 public VersionRangeResult resolveVersionRange(RepositorySystemSession session, VersionRangeRequest request)
95 throws VersionRangeResolutionException {
96 VersionRangeResult result = new VersionRangeResult(request);
97
98 VersionConstraint versionConstraint;
99 try {
100 versionConstraint =
101 versionScheme.parseVersionConstraint(request.getArtifact().getVersion());
102 } catch (InvalidVersionSpecificationException e) {
103 result.addException(e);
104 throw new VersionRangeResolutionException(result);
105 }
106
107 result.setVersionConstraint(versionConstraint);
108
109 if (versionConstraint.getRange() == null) {
110 result.addVersion(versionConstraint.getVersion());
111 } else {
112 VersionRange.Bound lowerBound = versionConstraint.getRange().getLowerBound();
113 VersionRange.Bound upperBound = versionConstraint.getRange().getUpperBound();
114 if (lowerBound != null
115 && lowerBound.equals(versionConstraint.getRange().getUpperBound())) {
116 result.addVersion(lowerBound.getVersion());
117 } else {
118 Metadata.Nature wantedNature;
119 String natureString = ConfigUtils.getString(
120 session, request.getNature().name(), Constants.MAVEN_VERSION_RANGE_RESOLVER_NATURE_OVERRIDE);
121 if ("auto".equals(natureString)) {
122 org.eclipse.aether.artifact.Artifact lowerArtifact = lowerBound != null
123 ? request.getArtifact()
124 .setVersion(lowerBound.getVersion().toString())
125 : null;
126 org.eclipse.aether.artifact.Artifact upperArtifact = upperBound != null
127 ? request.getArtifact()
128 .setVersion(upperBound.getVersion().toString())
129 : null;
130
131 if (lowerArtifact != null && lowerArtifact.isSnapshot()
132 || upperArtifact != null && upperArtifact.isSnapshot()) {
133 wantedNature = Metadata.Nature.RELEASE_OR_SNAPSHOT;
134 } else {
135 wantedNature = Metadata.Nature.RELEASE;
136 }
137 } else {
138 wantedNature = Metadata.Nature.valueOf(natureString.toUpperCase(Locale.ROOT));
139 }
140
141 Map<String, ArtifactRepository> versionIndex = getVersions(session, result, request, wantedNature);
142
143 List<Version> versions = new ArrayList<>();
144 for (Map.Entry<String, ArtifactRepository> v : versionIndex.entrySet()) {
145 try {
146 Version ver = versionScheme.parseVersion(v.getKey());
147 if (versionConstraint.containsVersion(ver)) {
148 versions.add(ver);
149 result.setRepository(ver, v.getValue());
150 }
151 } catch (InvalidVersionSpecificationException e) {
152 result.addException(e);
153 }
154 }
155
156 Collections.sort(versions);
157 result.setVersions(versions);
158 }
159 }
160
161 return result;
162 }
163
164 private Map<String, ArtifactRepository> getVersions(
165 RepositorySystemSession session,
166 VersionRangeResult result,
167 VersionRangeRequest request,
168 Metadata.Nature wantedNature) {
169 RequestTrace trace = RequestTrace.newChild(request.getTrace(), request);
170
171 Map<String, ArtifactRepository> versionIndex = new HashMap<>();
172
173 Metadata metadata = new DefaultMetadata(
174 request.getArtifact().getGroupId(),
175 request.getArtifact().getArtifactId(),
176 MAVEN_METADATA_XML,
177 wantedNature);
178
179 List<MetadataRequest> metadataRequests =
180 new ArrayList<>(request.getRepositories().size());
181
182 metadataRequests.add(new MetadataRequest(metadata, null, request.getRequestContext()));
183
184 for (RemoteRepository repository : request.getRepositories()) {
185 MetadataRequest metadataRequest = new MetadataRequest(metadata, repository, request.getRequestContext());
186 metadataRequest.setDeleteLocalCopyIfMissing(true);
187 metadataRequest.setTrace(trace);
188 metadataRequests.add(metadataRequest);
189 }
190
191 List<MetadataResult> metadataResults = metadataResolver.resolveMetadata(session, metadataRequests);
192
193 WorkspaceReader workspace = session.getWorkspaceReader();
194 if (workspace != null) {
195 List<String> versions = workspace.findVersions(request.getArtifact());
196 for (String version : versions) {
197 versionIndex.put(version, workspace.getRepository());
198 }
199 }
200
201 for (MetadataResult metadataResult : metadataResults) {
202 result.addException(metadataResult.getException());
203
204 ArtifactRepository repository = metadataResult.getRequest().getRepository();
205 if (repository == null) {
206 repository = session.getLocalRepository();
207 }
208
209 Versioning versioning = readVersions(session, trace, metadataResult.getMetadata(), repository, result);
210
211 versioning = filterVersionsByRepositoryType(
212 versioning, metadataResult.getRequest().getRepository());
213
214 for (String version : versioning.getVersions()) {
215 if (!versionIndex.containsKey(version)) {
216 versionIndex.put(version, repository);
217 }
218 }
219 }
220
221 return versionIndex;
222 }
223
224 private Versioning readVersions(
225 RepositorySystemSession session,
226 RequestTrace trace,
227 Metadata metadata,
228 ArtifactRepository repository,
229 VersionRangeResult result) {
230 Versioning versioning = null;
231 try {
232 if (metadata != null) {
233 try (SyncContext syncContext = syncContextFactory.newInstance(session, true)) {
234 syncContext.acquire(null, Collections.singleton(metadata));
235
236 if (metadata.getPath() != null && Files.exists(metadata.getPath())) {
237 try (InputStream in = Files.newInputStream(metadata.getPath())) {
238 versioning = new Versioning(
239 new MetadataStaxReader().read(in, false).getVersioning());
240 }
241 }
242 }
243 }
244 } catch (Exception e) {
245 invalidMetadata(session, trace, metadata, repository, e);
246 result.addException(e);
247 }
248
249 return (versioning != null) ? versioning : new Versioning();
250 }
251
252 private Versioning filterVersionsByRepositoryType(Versioning versioning, RemoteRepository remoteRepository) {
253 if (remoteRepository == null) {
254 return versioning;
255 }
256
257 Versioning filteredVersions = versioning.clone();
258
259 for (String version : versioning.getVersions()) {
260 if (!remoteRepository.getPolicy(ArtifactUtils.isSnapshot(version)).isEnabled()) {
261 filteredVersions.removeVersion(version);
262 }
263 }
264
265 return filteredVersions;
266 }
267
268 private void invalidMetadata(
269 RepositorySystemSession session,
270 RequestTrace trace,
271 Metadata metadata,
272 ArtifactRepository repository,
273 Exception exception) {
274 RepositoryEvent.Builder event = new RepositoryEvent.Builder(session, EventType.METADATA_INVALID);
275 event.setTrace(trace);
276 event.setMetadata(metadata);
277 event.setException(exception);
278 event.setRepository(repository);
279
280 repositoryEventDispatcher.dispatch(event.build());
281 }
282 }