// Note this version was selected before to get the appropriate POM
// But it was reset by the call to setVersionRange on restricting the version
ResolutionNode[] resetNodes = { previous, node };
for ( int j = 0; j < 2; j++ )
{
Artifact resetArtifact = resetNodes[j].getArtifact();
// MNG-2123: if the previous node was not a range, then it wouldn't have any available
// versions. We just clobbered the selected version above. (why? i have no idea.)
// So since we are here and this is ranges we must go figure out the version (for a
// third time...)
if ( resetArtifact.getVersion() == null && resetArtifact.getVersionRange() != null )
{
// go find the version. This is a total hack. See previous comment.
List<ArtifactVersion> versions = resetArtifact.getAvailableVersions();
if ( versions == null )
{
try
{
MetadataResolutionRequest metadataRequest =
new DefaultMetadataResolutionRequest( request );
metadataRequest.setArtifact( resetArtifact );
versions = source.retrieveAvailableVersions( metadataRequest );
resetArtifact.setAvailableVersions( versions );
}
catch ( ArtifactMetadataRetrievalException e )
{
resetArtifact.setDependencyTrail( node.getDependencyTrail() );
throw new ArtifactResolutionException(
"Unable to get dependency information: "
+ e.getMessage(), resetArtifact,
request.getRemoteRepositories(), e );
}
}
// end hack
// MNG-2861: match version can return null
ArtifactVersion selectedVersion =
resetArtifact.getVersionRange().matchVersion( resetArtifact.getAvailableVersions() );
if ( selectedVersion != null )
{
resetArtifact.selectVersion( selectedVersion.toString() );
}
else
{
throw new OverConstrainedVersionException( " Unable to find a version in "
+ resetArtifact.getAvailableVersions() + " to match the range "
+ resetArtifact.getVersionRange(), resetArtifact );
}
fireEvent( ResolutionListener.SELECT_VERSION_FROM_RANGE, listeners, resetNodes[j] );
}
}
}
// Conflict Resolution
ResolutionNode resolved = null;
for ( Iterator j = conflictResolvers.iterator(); ( resolved == null ) && j.hasNext(); )
{
ConflictResolver conflictResolver = (ConflictResolver) j.next();
resolved = conflictResolver.resolveConflict( previous, node );
}
if ( resolved == null )
{
// TODO: add better exception that can detail the two conflicting artifacts
ArtifactResolutionException are =
new ArtifactResolutionException( "Cannot resolve artifact version conflict between "
+ previous.getArtifact().getVersion() + " and " + node.getArtifact().getVersion(),
previous.getArtifact() );
result.addVersionRangeViolation( are );
}
if ( ( resolved != previous ) && ( resolved != node ) )
{
// TODO: add better exception
result.addVersionRangeViolation( new ArtifactResolutionException(
"Conflict resolver returned unknown resolution node: ",
resolved.getArtifact() ) );
}
// TODO: should this be part of mediation?
// previous one is more dominant
ResolutionNode nearest;
ResolutionNode farthest;
if ( resolved == previous )
{
nearest = previous;
farthest = node;
}
else
{
nearest = node;
farthest = previous;
}
if ( checkScopeUpdate( farthest, nearest, listeners ) )
{
// if we need to update artifactScope of nearest to use farthest artifactScope, use the
// nearest version, but farthest artifactScope
nearest.disable();
farthest.getArtifact().setVersion( nearest.getArtifact().getVersion() );
fireEvent( ResolutionListener.OMIT_FOR_NEARER, listeners, nearest, farthest.getArtifact() );
}
else
{
farthest.disable();
fireEvent( ResolutionListener.OMIT_FOR_NEARER, listeners, farthest, nearest.getArtifact() );
}
}
}
catch ( OverConstrainedVersionException e )
{
result.addVersionRangeViolation( e );
}
}
}
else
{
previousNodes = new ArrayList<ResolutionNode>();
resolvedArtifacts.put( key, previousNodes );
}
previousNodes.add( node );
if ( node.isActive() )
{
fireEvent( ResolutionListener.INCLUDE_ARTIFACT, listeners, node );
}
// don't pull in the transitive deps of a system-scoped dependency.
if ( node.isActive() && !Artifact.SCOPE_SYSTEM.equals( node.getArtifact().getScope() ) )
{
fireEvent( ResolutionListener.PROCESS_CHILDREN, listeners, node );
Artifact parentArtifact = node.getArtifact();
for ( Iterator i = node.getChildrenIterator(); i.hasNext(); )
{
ResolutionNode child = (ResolutionNode) i.next();
try
{
// We leave in optional ones, but don't pick up its dependencies
if ( !child.isResolved() && ( !child.getArtifact().isOptional() || child.isChildOfRootNode() ) )
{
Artifact artifact = child.getArtifact();
artifact.setDependencyTrail( node.getDependencyTrail() );
List<ArtifactRepository> childRemoteRepositories = child.getRemoteRepositories();
MetadataResolutionRequest metadataRequest =
new DefaultMetadataResolutionRequest( request );
metadataRequest.setArtifact( artifact );
metadataRequest.setRemoteRepositories( childRemoteRepositories );
try
{
ResolutionGroup rGroup;
Object childKey;
do
{
childKey = child.getKey();
if ( managedVersions.containsKey( childKey ) )
{
// If this child node is a managed dependency, ensure
// we are using the dependency management version
// of this child if applicable b/c we want to use the
// managed version's POM, *not* any other version's POM.
// We retrieve the POM below in the retrieval step.
manageArtifact( child, managedVersions, listeners );
// Also, we need to ensure that any exclusions it presents are
// added to the artifact before we retrive the metadata
// for the artifact; otherwise we may end up with unwanted
// dependencies.
Artifact ma = (Artifact) managedVersions.get( childKey );
ArtifactFilter managedExclusionFilter = ma.getDependencyFilter();
if ( null != managedExclusionFilter )
{
if ( null != artifact.getDependencyFilter() )
{
AndArtifactFilter aaf = new AndArtifactFilter();