001package 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 022import java.io.FileInputStream; 023import java.util.ArrayList; 024import java.util.Collections; 025import java.util.HashMap; 026import java.util.List; 027import java.util.Map; 028 029import javax.inject.Inject; 030import javax.inject.Named; 031 032import org.apache.maven.artifact.repository.metadata.Versioning; 033import org.apache.maven.artifact.repository.metadata.io.xpp3.MetadataXpp3Reader; 034import org.codehaus.plexus.component.annotations.Component; 035import org.codehaus.plexus.component.annotations.Requirement; 036import org.codehaus.plexus.util.IOUtil; 037import org.eclipse.aether.RepositoryEvent.EventType; 038import org.eclipse.aether.RepositoryEvent; 039import org.eclipse.aether.RepositorySystemSession; 040import org.eclipse.aether.RequestTrace; 041import org.eclipse.aether.SyncContext; 042import org.eclipse.aether.impl.MetadataResolver; 043import org.eclipse.aether.impl.RepositoryEventDispatcher; 044import org.eclipse.aether.impl.SyncContextFactory; 045import org.eclipse.aether.impl.VersionRangeResolver; 046import org.eclipse.aether.metadata.DefaultMetadata; 047import org.eclipse.aether.metadata.Metadata; 048import org.eclipse.aether.repository.ArtifactRepository; 049import org.eclipse.aether.repository.RemoteRepository; 050import org.eclipse.aether.repository.WorkspaceReader; 051import org.eclipse.aether.resolution.MetadataRequest; 052import org.eclipse.aether.resolution.MetadataResult; 053import org.eclipse.aether.resolution.VersionRangeRequest; 054import org.eclipse.aether.resolution.VersionRangeResolutionException; 055import org.eclipse.aether.resolution.VersionRangeResult; 056import org.eclipse.aether.spi.locator.Service; 057import org.eclipse.aether.spi.locator.ServiceLocator; 058import org.eclipse.aether.spi.log.Logger; 059import org.eclipse.aether.spi.log.LoggerFactory; 060import org.eclipse.aether.spi.log.NullLoggerFactory; 061import org.eclipse.aether.util.version.GenericVersionScheme; 062import org.eclipse.aether.version.InvalidVersionSpecificationException; 063import org.eclipse.aether.version.Version; 064import org.eclipse.aether.version.VersionConstraint; 065import org.eclipse.aether.version.VersionScheme; 066 067/** 068 * @author Benjamin Bentmann 069 */ 070@Named 071@Component( role = VersionRangeResolver.class ) 072public 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 red ) 147 { 148 if ( red == null ) 149 { 150 throw new IllegalArgumentException( "repository event dispatcher has not been specified" ); 151 } 152 this.repositoryEventDispatcher = red; 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}