001package org.apache.maven.plugins.enforcer; 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.ArrayList; 023import java.util.Collections; 024import java.util.List; 025 026import org.apache.maven.artifact.Artifact; 027import org.apache.maven.artifact.repository.ArtifactRepository; 028import org.apache.maven.artifact.resolver.filter.ArtifactFilter; 029import org.apache.maven.enforcer.rule.api.EnforcerRule; 030import org.apache.maven.enforcer.rule.api.EnforcerRuleException; 031import org.apache.maven.enforcer.rule.api.EnforcerRuleHelper; 032import org.apache.maven.execution.MavenSession; 033import org.apache.maven.plugin.logging.Log; 034import org.apache.maven.plugins.enforcer.utils.DependencyVersionMap; 035import org.apache.maven.project.DefaultProjectBuildingRequest; 036import org.apache.maven.project.MavenProject; 037import org.apache.maven.project.ProjectBuildingRequest; 038import org.apache.maven.shared.dependency.graph.DependencyCollectorBuilder; 039import org.apache.maven.shared.dependency.graph.DependencyCollectorBuilderException; 040import org.apache.maven.shared.dependency.graph.DependencyNode; 041import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluationException; 042import org.codehaus.plexus.component.repository.exception.ComponentLookupException; 043 044/** 045 * @author <a href="mailto:rex@e-hoffman.org">Rex Hoffman</a> 046 */ 047public class DependencyConvergence 048 implements EnforcerRule 049{ 050 private static Log log; 051 052 private boolean uniqueVersions; 053 054 public void setUniqueVersions( boolean uniqueVersions ) 055 { 056 this.uniqueVersions = uniqueVersions; 057 } 058 059 // CHECKSTYLE_OFF: LineLength 060 /** 061 * Uses the {@link EnforcerRuleHelper} to populate the values of the 062 * {@link DependencyTreeBuilder#buildDependencyTree(MavenProject, ArtifactRepository, ArtifactFactory, ArtifactMetadataSource, ArtifactFilter, ArtifactCollector)} 063 * factory method. <br/> 064 * This method simply exists to hide all the ugly lookup that the {@link EnforcerRuleHelper} has to do. 065 * 066 * @param helper 067 * @return a Dependency Node which is the root of the project's dependency tree 068 * @throws EnforcerRuleException 069 */ 070 // CHECKSTYLE_ON: LineLength 071 private DependencyNode getNode( EnforcerRuleHelper helper ) 072 throws EnforcerRuleException 073 { 074 try 075 { 076 MavenProject project = (MavenProject) helper.evaluate( "${project}" ); 077 MavenSession session = (MavenSession) helper.evaluate( "${session}" ); 078 DependencyCollectorBuilder dependencyCollectorBuilder = 079 helper.getComponent( DependencyCollectorBuilder.class ); 080 ArtifactRepository repository = (ArtifactRepository) helper.evaluate( "${localRepository}" ); 081 082 ProjectBuildingRequest buildingRequest = 083 new DefaultProjectBuildingRequest( session.getProjectBuildingRequest() ); 084 buildingRequest.setProject( project ); 085 buildingRequest.setLocalRepository( repository ); 086 ArtifactFilter filter = ( Artifact a ) -> ( "compile".equalsIgnoreCase( a.getScope () ) 087 || "runtime".equalsIgnoreCase( a.getScope () ) ) 088 && !a.isOptional(); 089 090 return dependencyCollectorBuilder.collectDependencyGraph( buildingRequest, filter ); 091 } 092 catch ( ExpressionEvaluationException | ComponentLookupException e ) 093 { 094 throw new EnforcerRuleException( "Unable to lookup a component " + e.getLocalizedMessage(), e ); 095 } 096 catch ( DependencyCollectorBuilderException e ) 097 { 098 throw new EnforcerRuleException( "Could not build dependency tree " + e.getLocalizedMessage(), e ); 099 } 100 } 101 102 @Override 103 public void execute( EnforcerRuleHelper helper ) 104 throws EnforcerRuleException 105 { 106 if ( log == null ) 107 { 108 log = helper.getLog(); 109 } 110 try 111 { 112 DependencyNode node = getNode( helper ); 113 DependencyVersionMap visitor = new DependencyVersionMap( log ); 114 visitor.setUniqueVersions( uniqueVersions ); 115 node.accept( visitor ); 116 List<CharSequence> errorMsgs = new ArrayList<>(); 117 errorMsgs.addAll( getConvergenceErrorMsgs( visitor.getConflictedVersionNumbers() ) ); 118 for ( CharSequence errorMsg : errorMsgs ) 119 { 120 log.warn( errorMsg ); 121 } 122 if ( errorMsgs.size() > 0 ) 123 { 124 throw new EnforcerRuleException( "Failed while enforcing releasability. " 125 + "See above detailed error message." ); 126 } 127 } 128 catch ( Exception e ) 129 { 130 throw new EnforcerRuleException( e.getLocalizedMessage(), e ); 131 } 132 } 133 134 private StringBuilder buildTreeString( DependencyNode node ) 135 { 136 List<String> loc = new ArrayList<>(); 137 DependencyNode currentNode = node; 138 while ( currentNode != null ) 139 { 140 loc.add( currentNode.getArtifact().toString() ); 141 currentNode = currentNode.getParent(); 142 } 143 Collections.reverse( loc ); 144 StringBuilder builder = new StringBuilder(); 145 for ( int i = 0; i < loc.size(); i++ ) 146 { 147 for ( int j = 0; j < i; j++ ) 148 { 149 builder.append( " " ); 150 } 151 builder.append( "+-" + loc.get( i ) ); 152 builder.append( System.lineSeparator() ); 153 } 154 return builder; 155 } 156 157 private List<String> getConvergenceErrorMsgs( List<List<DependencyNode>> errors ) 158 { 159 List<String> errorMsgs = new ArrayList<>(); 160 for ( List<DependencyNode> nodeList : errors ) 161 { 162 errorMsgs.add( buildConvergenceErrorMsg( nodeList ) ); 163 } 164 return errorMsgs; 165 } 166 167 private String buildConvergenceErrorMsg( List<DependencyNode> nodeList ) 168 { 169 StringBuilder builder = new StringBuilder(); 170 builder.append( System.lineSeparator() + "Dependency convergence error for " 171 + nodeList.get( 0 ).getArtifact().toString() 172 + " paths to dependency are:" + System.lineSeparator() ); 173 if ( nodeList.size() > 0 ) 174 { 175 builder.append( buildTreeString( nodeList.get( 0 ) ) ); 176 } 177 for ( DependencyNode node : nodeList.subList( 1, nodeList.size() ) ) 178 { 179 builder.append( "and" + System.lineSeparator() ); 180 builder.append( buildTreeString( node ) ); 181 } 182 return builder.toString(); 183 } 184 185 @Override 186 public String getCacheId() 187 { 188 return ""; 189 } 190 191 @Override 192 public boolean isCacheable() 193 { 194 return false; 195 } 196 197 @Override 198 public boolean isResultValid( EnforcerRule rule ) 199 { 200 return false; 201 } 202}