001 package org.apache.maven.repository.internal;
002
003 /*
004 * Licensed to the Apache Software Foundation (ASF) under one
005 * or more contributor license agreements. See the NOTICE file
006 * distributed with this work for additional information
007 * regarding copyright ownership. The ASF licenses this file
008 * to you under the Apache License, Version 2.0 (the
009 * "License"); you may not use this file except in compliance
010 * with the License. You may obtain a copy of the License at
011 *
012 * http://www.apache.org/licenses/LICENSE-2.0
013 *
014 * Unless required by applicable law or agreed to in writing,
015 * software distributed under the License is distributed on an
016 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
017 * KIND, either express or implied. See the License for the
018 * specific language governing permissions and limitations
019 * under the License.
020 */
021
022 import java.io.FileInputStream;
023 import java.util.ArrayList;
024 import java.util.Collections;
025 import java.util.HashMap;
026 import java.util.List;
027 import java.util.Map;
028
029 import javax.inject.Inject;
030 import javax.inject.Named;
031
032 import org.apache.maven.artifact.repository.metadata.Versioning;
033 import org.apache.maven.artifact.repository.metadata.io.xpp3.MetadataXpp3Reader;
034 import org.codehaus.plexus.component.annotations.Component;
035 import org.codehaus.plexus.component.annotations.Requirement;
036 import org.codehaus.plexus.util.IOUtil;
037 import org.eclipse.aether.RepositoryEvent.EventType;
038 import org.eclipse.aether.RepositoryEvent;
039 import org.eclipse.aether.RepositorySystemSession;
040 import org.eclipse.aether.RequestTrace;
041 import org.eclipse.aether.SyncContext;
042 import org.eclipse.aether.impl.MetadataResolver;
043 import org.eclipse.aether.impl.RepositoryEventDispatcher;
044 import org.eclipse.aether.impl.SyncContextFactory;
045 import org.eclipse.aether.impl.VersionRangeResolver;
046 import org.eclipse.aether.metadata.DefaultMetadata;
047 import org.eclipse.aether.metadata.Metadata;
048 import org.eclipse.aether.repository.ArtifactRepository;
049 import org.eclipse.aether.repository.RemoteRepository;
050 import org.eclipse.aether.repository.WorkspaceReader;
051 import org.eclipse.aether.resolution.MetadataRequest;
052 import org.eclipse.aether.resolution.MetadataResult;
053 import org.eclipse.aether.resolution.VersionRangeRequest;
054 import org.eclipse.aether.resolution.VersionRangeResolutionException;
055 import org.eclipse.aether.resolution.VersionRangeResult;
056 import org.eclipse.aether.spi.locator.Service;
057 import org.eclipse.aether.spi.locator.ServiceLocator;
058 import org.eclipse.aether.spi.log.Logger;
059 import org.eclipse.aether.spi.log.LoggerFactory;
060 import org.eclipse.aether.spi.log.NullLoggerFactory;
061 import org.eclipse.aether.util.version.GenericVersionScheme;
062 import org.eclipse.aether.version.InvalidVersionSpecificationException;
063 import org.eclipse.aether.version.Version;
064 import org.eclipse.aether.version.VersionConstraint;
065 import org.eclipse.aether.version.VersionScheme;
066
067 /**
068 * @author Benjamin Bentmann
069 */
070 @Named
071 @Component( role = VersionRangeResolver.class )
072 public class DefaultVersionRangeResolver
073 implements VersionRangeResolver, Service
074 {
075
076 private static final String MAVEN_METADATA_XML = "maven-metadata.xml";
077
078 @SuppressWarnings( "unused" )
079 @Requirement( role = LoggerFactory.class )
080 private Logger logger = NullLoggerFactory.LOGGER;
081
082 @Requirement
083 private MetadataResolver metadataResolver;
084
085 @Requirement
086 private SyncContextFactory syncContextFactory;
087
088 @Requirement
089 private RepositoryEventDispatcher repositoryEventDispatcher;
090
091 public DefaultVersionRangeResolver()
092 {
093 // enable default constructor
094 }
095
096 @Inject
097 DefaultVersionRangeResolver( MetadataResolver metadataResolver, SyncContextFactory syncContextFactory,
098 RepositoryEventDispatcher repositoryEventDispatcher, LoggerFactory loggerFactory )
099 {
100 setMetadataResolver( metadataResolver );
101 setSyncContextFactory( syncContextFactory );
102 setLoggerFactory( loggerFactory );
103 setRepositoryEventDispatcher( repositoryEventDispatcher );
104 }
105
106 public void initService( ServiceLocator locator )
107 {
108 setLoggerFactory( locator.getService( LoggerFactory.class ) );
109 setMetadataResolver( locator.getService( MetadataResolver.class ) );
110 setSyncContextFactory( locator.getService( SyncContextFactory.class ) );
111 setRepositoryEventDispatcher( locator.getService( RepositoryEventDispatcher.class ) );
112 }
113
114 public DefaultVersionRangeResolver setLoggerFactory( LoggerFactory loggerFactory )
115 {
116 this.logger = NullLoggerFactory.getSafeLogger( loggerFactory, getClass() );
117 return this;
118 }
119
120 void setLogger( LoggerFactory loggerFactory )
121 {
122 // plexus support
123 setLoggerFactory( loggerFactory );
124 }
125
126 public DefaultVersionRangeResolver setMetadataResolver( MetadataResolver metadataResolver )
127 {
128 if ( metadataResolver == null )
129 {
130 throw new IllegalArgumentException( "metadata resolver has not been specified" );
131 }
132 this.metadataResolver = metadataResolver;
133 return this;
134 }
135
136 public DefaultVersionRangeResolver setSyncContextFactory( SyncContextFactory syncContextFactory )
137 {
138 if ( syncContextFactory == null )
139 {
140 throw new IllegalArgumentException( "sync context factory has not been specified" );
141 }
142 this.syncContextFactory = syncContextFactory;
143 return this;
144 }
145
146 public DefaultVersionRangeResolver setRepositoryEventDispatcher( RepositoryEventDispatcher repositoryEventDispatcher )
147 {
148 if ( repositoryEventDispatcher == null )
149 {
150 throw new IllegalArgumentException( "repository event dispatcher has not been specified" );
151 }
152 this.repositoryEventDispatcher = repositoryEventDispatcher;
153 return this;
154 }
155
156 public VersionRangeResult resolveVersionRange( RepositorySystemSession session, VersionRangeRequest request )
157 throws VersionRangeResolutionException
158 {
159 VersionRangeResult result = new VersionRangeResult( request );
160
161 VersionScheme versionScheme = new GenericVersionScheme();
162
163 VersionConstraint versionConstraint;
164 try
165 {
166 versionConstraint = versionScheme.parseVersionConstraint( request.getArtifact().getVersion() );
167 }
168 catch ( InvalidVersionSpecificationException e )
169 {
170 result.addException( e );
171 throw new VersionRangeResolutionException( result );
172 }
173
174 result.setVersionConstraint( versionConstraint );
175
176 if ( versionConstraint.getRange() == null )
177 {
178 result.addVersion( versionConstraint.getVersion() );
179 }
180 else
181 {
182 Map<String, ArtifactRepository> versionIndex = getVersions( session, result, request );
183
184 List<Version> versions = new ArrayList<Version>();
185 for ( Map.Entry<String, ArtifactRepository> v : versionIndex.entrySet() )
186 {
187 try
188 {
189 Version ver = versionScheme.parseVersion( v.getKey() );
190 if ( versionConstraint.containsVersion( ver ) )
191 {
192 versions.add( ver );
193 result.setRepository( ver, v.getValue() );
194 }
195 }
196 catch ( InvalidVersionSpecificationException e )
197 {
198 result.addException( e );
199 }
200 }
201
202 Collections.sort( versions );
203 result.setVersions( versions );
204 }
205
206 return result;
207 }
208
209 private Map<String, ArtifactRepository> getVersions( RepositorySystemSession session, VersionRangeResult result,
210 VersionRangeRequest request )
211 {
212 RequestTrace trace = RequestTrace.newChild( request.getTrace(), request );
213
214 Map<String, ArtifactRepository> versionIndex = new HashMap<String, ArtifactRepository>();
215
216 Metadata metadata =
217 new DefaultMetadata( request.getArtifact().getGroupId(), request.getArtifact().getArtifactId(),
218 MAVEN_METADATA_XML, Metadata.Nature.RELEASE_OR_SNAPSHOT );
219
220 List<MetadataRequest> metadataRequests = new ArrayList<MetadataRequest>( request.getRepositories().size() );
221
222 metadataRequests.add( new MetadataRequest( metadata, null, request.getRequestContext() ) );
223
224 for ( RemoteRepository repository : request.getRepositories() )
225 {
226 MetadataRequest metadataRequest = new MetadataRequest( metadata, repository, request.getRequestContext() );
227 metadataRequest.setDeleteLocalCopyIfMissing( true );
228 metadataRequest.setTrace( trace );
229 metadataRequests.add( metadataRequest );
230 }
231
232 List<MetadataResult> metadataResults = metadataResolver.resolveMetadata( session, metadataRequests );
233
234 WorkspaceReader workspace = session.getWorkspaceReader();
235 if ( workspace != null )
236 {
237 List<String> versions = workspace.findVersions( request.getArtifact() );
238 for ( String version : versions )
239 {
240 versionIndex.put( version, workspace.getRepository() );
241 }
242 }
243
244 for ( MetadataResult metadataResult : metadataResults )
245 {
246 result.addException( metadataResult.getException() );
247
248 ArtifactRepository repository = metadataResult.getRequest().getRepository();
249 if ( repository == null )
250 {
251 repository = session.getLocalRepository();
252 }
253
254 Versioning versioning = readVersions( session, trace, metadataResult.getMetadata(), repository, result );
255 for ( String version : versioning.getVersions() )
256 {
257 if ( !versionIndex.containsKey( version ) )
258 {
259 versionIndex.put( version, repository );
260 }
261 }
262 }
263
264 return versionIndex;
265 }
266
267 private Versioning readVersions( RepositorySystemSession session, RequestTrace trace, Metadata metadata,
268 ArtifactRepository repository, VersionRangeResult result )
269 {
270 Versioning versioning = null;
271
272 FileInputStream fis = null;
273 try
274 {
275 if ( metadata != null )
276 {
277 SyncContext syncContext = syncContextFactory.newInstance( session, true );
278
279 try
280 {
281 syncContext.acquire( null, Collections.singleton( metadata ) );
282
283 if ( metadata.getFile() != null && metadata.getFile().exists() )
284 {
285 fis = new FileInputStream( metadata.getFile() );
286 org.apache.maven.artifact.repository.metadata.Metadata m =
287 new MetadataXpp3Reader().read( fis, false );
288 versioning = m.getVersioning();
289 }
290 }
291 finally
292 {
293 syncContext.close();
294 }
295 }
296 }
297 catch ( Exception e )
298 {
299 invalidMetadata( session, trace, metadata, repository, e );
300 result.addException( e );
301 }
302 finally
303 {
304 IOUtil.close( fis );
305 }
306
307 return ( versioning != null ) ? versioning : new Versioning();
308 }
309
310 private void invalidMetadata( RepositorySystemSession session, RequestTrace trace, Metadata metadata,
311 ArtifactRepository repository, Exception exception )
312 {
313 RepositoryEvent.Builder event = new RepositoryEvent.Builder( session, EventType.METADATA_INVALID );
314 event.setTrace( trace );
315 event.setMetadata( metadata );
316 event.setException( exception );
317 event.setRepository( repository );
318
319 repositoryEventDispatcher.dispatch( event.build() );
320 }
321
322 }