001package org.apache.maven.lifecycle.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.util.Collection; 023import java.util.Collections; 024import java.util.HashMap; 025import java.util.HashSet; 026import java.util.LinkedHashSet; 027import java.util.List; 028import java.util.Map; 029import java.util.Set; 030 031import javax.inject.Inject; 032import javax.inject.Named; 033 034import org.apache.maven.RepositoryUtils; 035import org.apache.maven.artifact.Artifact; 036import org.apache.maven.artifact.ArtifactUtils; 037import org.apache.maven.eventspy.internal.EventSpyDispatcher; 038import org.apache.maven.execution.MavenSession; 039import org.apache.maven.lifecycle.LifecycleExecutionException; 040import org.apache.maven.project.DefaultDependencyResolutionRequest; 041import org.apache.maven.project.DependencyResolutionException; 042import org.apache.maven.project.DependencyResolutionResult; 043import org.apache.maven.project.MavenProject; 044import org.apache.maven.project.ProjectDependenciesResolver; 045import org.apache.maven.project.artifact.InvalidDependencyVersionException; 046import org.codehaus.plexus.logging.Logger; 047import org.eclipse.aether.graph.Dependency; 048import org.eclipse.aether.graph.DependencyFilter; 049import org.eclipse.aether.graph.DependencyNode; 050import org.eclipse.aether.util.filter.AndDependencyFilter; 051import org.eclipse.aether.util.filter.ScopeDependencyFilter; 052 053/** 054 * Resolves dependencies for the artifacts in context of the lifecycle build 055 * 056 * @since 3.0 057 * @author Benjamin Bentmann 058 * @author Jason van Zyl 059 * @author Kristian Rosenvold (extracted class) 060 * <p/> 061 * NOTE: This class is not part of any public api and can be changed or deleted without prior notice. 062 */ 063@Named 064public class LifecycleDependencyResolver 065{ 066 067 @Inject 068 private ProjectDependenciesResolver dependenciesResolver; 069 070 @Inject 071 private Logger logger; 072 073 @Inject 074 private ProjectArtifactFactory artifactFactory; 075 076 @Inject 077 private EventSpyDispatcher eventSpyDispatcher; 078 079 public LifecycleDependencyResolver() 080 { 081 } 082 083 public LifecycleDependencyResolver( ProjectDependenciesResolver projectDependenciesResolver, Logger logger ) 084 { 085 this.dependenciesResolver = projectDependenciesResolver; 086 this.logger = logger; 087 } 088 089 public static List<MavenProject> getProjects( MavenProject project, MavenSession session, boolean aggregator ) 090 { 091 if ( aggregator ) 092 { 093 return session.getProjects(); 094 } 095 else 096 { 097 return Collections.singletonList( project ); 098 } 099 } 100 101 public void resolveProjectDependencies( MavenProject project, Collection<String> scopesToCollect, 102 Collection<String> scopesToResolve, MavenSession session, 103 boolean aggregating, Set<Artifact> projectArtifacts ) 104 throws LifecycleExecutionException 105 { 106 ClassLoader tccl = Thread.currentThread().getContextClassLoader(); 107 try 108 { 109 ClassLoader projectRealm = project.getClassRealm(); 110 if ( projectRealm != null && projectRealm != tccl ) 111 { 112 Thread.currentThread().setContextClassLoader( projectRealm ); 113 } 114 115 if ( project.getDependencyArtifacts() == null ) 116 { 117 try 118 { 119 project.setDependencyArtifacts( artifactFactory.createArtifacts( project ) ); 120 } 121 catch ( InvalidDependencyVersionException e ) 122 { 123 throw new LifecycleExecutionException( e ); 124 } 125 } 126 127 Set<Artifact> artifacts = 128 getDependencies( project, scopesToCollect, scopesToResolve, session, aggregating, projectArtifacts ); 129 130 project.setResolvedArtifacts( artifacts ); 131 132 Map<String, Artifact> map = new HashMap<String, Artifact>(); 133 for ( Artifact artifact : artifacts ) 134 { 135 map.put( artifact.getDependencyConflictId(), artifact ); 136 } 137 for ( Artifact artifact : project.getDependencyArtifacts() ) 138 { 139 if ( artifact.getFile() == null ) 140 { 141 Artifact resolved = map.get( artifact.getDependencyConflictId() ); 142 if ( resolved != null ) 143 { 144 artifact.setFile( resolved.getFile() ); 145 artifact.setDependencyTrail( resolved.getDependencyTrail() ); 146 artifact.setResolvedVersion( resolved.getVersion() ); 147 artifact.setResolved( true ); 148 } 149 } 150 } 151 } 152 finally 153 { 154 Thread.currentThread().setContextClassLoader( tccl ); 155 } 156 } 157 158 private Set<Artifact> getDependencies( MavenProject project, Collection<String> scopesToCollect, 159 Collection<String> scopesToResolve, MavenSession session, 160 boolean aggregating, Set<Artifact> projectArtifacts ) 161 throws LifecycleExecutionException 162 { 163 if ( scopesToCollect == null ) 164 { 165 scopesToCollect = Collections.emptySet(); 166 } 167 if ( scopesToResolve == null ) 168 { 169 scopesToResolve = Collections.emptySet(); 170 } 171 172 if ( scopesToCollect.isEmpty() && scopesToResolve.isEmpty() ) 173 { 174 return new LinkedHashSet<Artifact>(); 175 } 176 177 scopesToCollect = new HashSet<String>( scopesToCollect ); 178 scopesToCollect.addAll( scopesToResolve ); 179 180 DependencyFilter collectionFilter = new ScopeDependencyFilter( null, negate( scopesToCollect ) ); 181 DependencyFilter resolutionFilter = new ScopeDependencyFilter( null, negate( scopesToResolve ) ); 182 resolutionFilter = AndDependencyFilter.newInstance( collectionFilter, resolutionFilter ); 183 resolutionFilter = 184 AndDependencyFilter.newInstance( resolutionFilter, new ReactorDependencyFilter( projectArtifacts ) ); 185 186 DependencyResolutionResult result; 187 try 188 { 189 DefaultDependencyResolutionRequest request = 190 new DefaultDependencyResolutionRequest( project, session.getRepositorySession() ); 191 request.setResolutionFilter( resolutionFilter ); 192 193 eventSpyDispatcher.onEvent( request ); 194 195 result = dependenciesResolver.resolve( request ); 196 } 197 catch ( DependencyResolutionException e ) 198 { 199 result = e.getResult(); 200 201 /* 202 * MNG-2277, the check below compensates for our bad plugin support where we ended up with aggregator 203 * plugins that require dependency resolution although they usually run in phases of the build where project 204 * artifacts haven't been assembled yet. The prime example of this is "mvn release:prepare". 205 */ 206 if ( aggregating && areAllDependenciesInReactor( session.getProjects(), 207 result.getUnresolvedDependencies() ) ) 208 { 209 logger.warn( "The following dependencies could not be resolved at this point of the build" 210 + " but seem to be part of the reactor:" ); 211 212 for ( Dependency dependency : result.getUnresolvedDependencies() ) 213 { 214 logger.warn( "o " + dependency ); 215 } 216 217 logger.warn( "Try running the build up to the lifecycle phase \"package\"" ); 218 } 219 else 220 { 221 throw new LifecycleExecutionException( null, project, e ); 222 } 223 } 224 225 eventSpyDispatcher.onEvent( result ); 226 227 Set<Artifact> artifacts = new LinkedHashSet<Artifact>(); 228 if ( result.getDependencyGraph() != null && !result.getDependencyGraph().getChildren().isEmpty() ) 229 { 230 RepositoryUtils.toArtifacts( artifacts, result.getDependencyGraph().getChildren(), 231 Collections.singletonList( project.getArtifact().getId() ), collectionFilter ); 232 } 233 return artifacts; 234 } 235 236 private boolean areAllDependenciesInReactor( Collection<MavenProject> projects, 237 Collection<Dependency> dependencies ) 238 { 239 Set<String> projectKeys = getReactorProjectKeys( projects ); 240 241 for ( Dependency dependency : dependencies ) 242 { 243 org.eclipse.aether.artifact.Artifact a = dependency.getArtifact(); 244 String key = ArtifactUtils.key( a.getGroupId(), a.getArtifactId(), a.getVersion() ); 245 if ( !projectKeys.contains( key ) ) 246 { 247 return false; 248 } 249 } 250 251 return true; 252 } 253 254 private Set<String> getReactorProjectKeys( Collection<MavenProject> projects ) 255 { 256 Set<String> projectKeys = new HashSet<String>( projects.size() * 2 ); 257 for ( MavenProject project : projects ) 258 { 259 String key = ArtifactUtils.key( project.getGroupId(), project.getArtifactId(), project.getVersion() ); 260 projectKeys.add( key ); 261 } 262 return projectKeys; 263 } 264 265 private Collection<String> negate( Collection<String> scopes ) 266 { 267 Collection<String> result = new HashSet<String>(); 268 Collections.addAll( result, "system", "compile", "provided", "runtime", "test" ); 269 270 for ( String scope : scopes ) 271 { 272 if ( "compile".equals( scope ) ) 273 { 274 result.remove( "compile" ); 275 result.remove( "system" ); 276 result.remove( "provided" ); 277 } 278 else if ( "runtime".equals( scope ) ) 279 { 280 result.remove( "compile" ); 281 result.remove( "runtime" ); 282 } 283 else if ( "compile+runtime".equals( scope ) ) 284 { 285 result.remove( "compile" ); 286 result.remove( "system" ); 287 result.remove( "provided" ); 288 result.remove( "runtime" ); 289 } 290 else if ( "runtime+system".equals( scope ) ) 291 { 292 result.remove( "compile" ); 293 result.remove( "system" ); 294 result.remove( "runtime" ); 295 } 296 else if ( "test".equals( scope ) ) 297 { 298 result.clear(); 299 } 300 } 301 302 return result; 303 } 304 305 private static class ReactorDependencyFilter 306 implements DependencyFilter 307 { 308 309 private Set<String> keys = new HashSet<String>(); 310 311 public ReactorDependencyFilter( Collection<Artifact> artifacts ) 312 { 313 for ( Artifact artifact : artifacts ) 314 { 315 String key = ArtifactUtils.key( artifact ); 316 keys.add( key ); 317 } 318 } 319 320 public boolean accept( DependencyNode node, List<DependencyNode> parents ) 321 { 322 Dependency dependency = node.getDependency(); 323 if ( dependency != null ) 324 { 325 org.eclipse.aether.artifact.Artifact a = dependency.getArtifact(); 326 String key = ArtifactUtils.key( a.getGroupId(), a.getArtifactId(), a.getVersion() ); 327 return !keys.contains( key ); 328 } 329 return false; 330 } 331 332 } 333 334}