| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| package org.apache.maven.mae.project; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.io.PrintWriter; |
| import java.io.Reader; |
| import java.io.StringWriter; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.HashSet; |
| import java.util.LinkedHashMap; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.apache.commons.io.IOUtils; |
| import org.apache.log4j.Logger; |
| import org.apache.maven.RepositoryUtils; |
| import org.apache.maven.artifact.ArtifactUtils; |
| import org.apache.maven.mae.project.key.FullProjectKey; |
| import org.apache.maven.mae.project.session.ProjectToolsSession; |
| import org.apache.maven.mae.project.session.SessionInjector; |
| import org.apache.maven.model.Model; |
| import org.apache.maven.model.Parent; |
| import org.apache.maven.model.building.ModelProblem; |
| import org.apache.maven.model.io.xpp3.MavenXpp3Reader; |
| import org.apache.maven.project.MavenProject; |
| import org.apache.maven.project.ProjectBuilder; |
| import org.apache.maven.project.ProjectBuildingException; |
| import org.apache.maven.project.ProjectBuildingRequest; |
| import org.apache.maven.project.ProjectBuildingResult; |
| import org.codehaus.plexus.component.annotations.Component; |
| import org.codehaus.plexus.component.annotations.Requirement; |
| import org.codehaus.plexus.util.Os; |
| import org.codehaus.plexus.util.ReaderFactory; |
| import org.codehaus.plexus.util.StringUtils; |
| import org.codehaus.plexus.util.xml.pull.XmlPullParserException; |
| import org.sonatype.aether.RepositorySystem; |
| import org.sonatype.aether.artifact.Artifact; |
| import org.sonatype.aether.resolution.ArtifactRequest; |
| import org.sonatype.aether.resolution.ArtifactResolutionException; |
| import org.sonatype.aether.resolution.ArtifactResult; |
| |
| @Component( role = ProjectLoader.class ) |
| public class DefaultProjectLoader |
| implements ProjectLoader |
| { |
| |
| private static final Logger LOGGER = Logger.getLogger( DefaultProjectLoader.class ); |
| |
| @Requirement |
| private RepositorySystem aetherRepositorySystem; |
| |
| @Requirement |
| private org.apache.maven.repository.RepositorySystem mavenRepositorySystem; |
| |
| @Requirement |
| private ProjectBuilder projectBuilder; |
| |
| @Requirement |
| private SessionInjector sessionInjector; |
| |
| @Override |
| public List<MavenProject> buildReactorProjectInstances( final ProjectToolsSession session, final boolean recursive, |
| final File... rootPoms ) |
| throws ProjectToolsException |
| { |
| sessionInjector.getRemoteRepositories( session ); |
| final ProjectBuildingRequest pbr = sessionInjector.getProjectBuildingRequest( session ); |
| |
| try |
| { |
| final List<File> pomFiles = Arrays.asList( rootPoms ); |
| final List<ProjectBuildingResult> results = projectBuilder.build( pomFiles, recursive, pbr ); |
| |
| final List<MavenProject> projects = new ArrayList<MavenProject>( results.size() ); |
| for ( final ProjectBuildingResult result : results ) |
| { |
| final MavenProject project = result.getProject(); |
| project.setRemoteArtifactRepositories( session.getRemoteArtifactRepositories() ); |
| |
| projects.add( project ); |
| } |
| |
| session.setReactorProjects( projects ); |
| |
| if ( LOGGER.isDebugEnabled() ) |
| { |
| LOGGER.debug( "Adding projects to dependency graph:\n\t" |
| + StringUtils.join( projects.iterator(), "\n\t" ) ); |
| } |
| addProjects( session, projects ); |
| |
| return projects; |
| } |
| catch ( final ProjectBuildingException e ) |
| { |
| final List<ProjectBuildingResult> results = e.getResults(); |
| |
| final StringBuilder sb = new StringBuilder(); |
| |
| if ( results == null ) |
| { |
| sb.append( "Cannot build reactor project instances for root-POM: " ).append( rootPoms ); |
| |
| final StringWriter sWriter = new StringWriter(); |
| final PrintWriter pWriter = new PrintWriter( sWriter ); |
| |
| e.printStackTrace( pWriter ); |
| sb.append( "\n" ).append( sWriter ); |
| } |
| else |
| { |
| int i = 0; |
| for ( final ProjectBuildingResult result : results ) |
| { |
| StringBuilder builder = new StringBuilder(); |
| final List<ModelProblem> problems = result.getProblems(); |
| if ( problems != null && !problems.isEmpty() ) |
| { |
| builder.append( "\n" ).append( result.getProjectId() ); |
| for ( final ModelProblem problem : problems ) |
| { |
| builder.append( "\n\t" ).append( ( ++i ) ).append( " " ).append( problem.getMessage() ).append( "\n\t\t" ).append( problem.getSource() ).append( "@" ).append( problem.getLineNumber() ).append( ":" |
| + problem.getColumnNumber() ); |
| |
| if ( problem.getException() != null ) |
| { |
| final StringWriter sWriter = new StringWriter(); |
| final PrintWriter pWriter = new PrintWriter( sWriter ); |
| |
| problem.getException().printStackTrace( pWriter ); |
| builder.append( "\n" ).append( sWriter ); |
| } |
| } |
| } |
| |
| sb.append( builder ); |
| } |
| } |
| |
| throw new ProjectToolsException( "Failed to build project instance. \n\n%s", e, sb ); |
| } |
| } |
| |
| private void addProjects( final ProjectToolsSession session, final MavenProject... projects ) |
| { |
| if ( projects == null || projects.length == 0 ) |
| { |
| return; |
| } |
| |
| addProjects( session, Arrays.asList( projects ) ); |
| } |
| |
| private void addProjects( final ProjectToolsSession session, final List<MavenProject> projects ) |
| { |
| for ( final MavenProject project : projects ) |
| { |
| final LinkedList<Artifact> parentage = new LinkedList<Artifact>(); |
| MavenProject parent = project; |
| while ( parent != null ) |
| { |
| final org.apache.maven.artifact.Artifact pomArtifact = |
| mavenRepositorySystem.createArtifact( project.getGroupId(), project.getArtifactId(), |
| project.getVersion(), "pom" ); |
| |
| final Artifact aetherPomArtifact = RepositoryUtils.toArtifact( pomArtifact ); |
| |
| parentage.addFirst( aetherPomArtifact ); |
| |
| parent = parent.getParent(); |
| } |
| |
| Artifact current = parentage.removeFirst(); |
| while ( !parentage.isEmpty() ) |
| { |
| final Artifact next = parentage.getFirst(); |
| |
| // This is WEIRD, but the parent POM is actually a dependency of the current one, |
| // since it's required in order to build the current project... |
| if ( LOGGER.isDebugEnabled() ) |
| { |
| LOGGER.debug( "Marking parent POM: " + current + " as dependency of POM: " + next ); |
| } |
| |
| session.connectProjectHierarchy( next, true, current, true ); |
| |
| if ( !parentage.isEmpty() ) |
| { |
| current = parentage.removeFirst(); |
| } |
| } |
| } |
| } |
| |
| @Override |
| public MavenProject buildProjectInstance( final File pomFile, final ProjectToolsSession session ) |
| throws ProjectToolsException |
| { |
| sessionInjector.getRemoteRepositories( session ); |
| final ProjectBuildingRequest pbr = sessionInjector.getProjectBuildingRequest( session ); |
| |
| try |
| { |
| final ProjectBuildingResult result = projectBuilder.build( pomFile, pbr ); |
| |
| final MavenProject project = result.getProject(); |
| project.setRemoteArtifactRepositories( session.getRemoteArtifactRepositories() ); |
| |
| addProjects( session, project ); |
| |
| return project; |
| } |
| catch ( final ProjectBuildingException e ) |
| { |
| // logger.error( "Failed to build MavenProject instances from POM files for sorting: " + e.getMessage(), e |
| // ); |
| final List<ProjectBuildingResult> results = e.getResults(); |
| |
| final StringBuilder sb = new StringBuilder(); |
| |
| if ( results == null ) |
| { |
| sb.append( "Cannot build project instance for: " ).append( pomFile ); |
| |
| final StringWriter sWriter = new StringWriter(); |
| final PrintWriter pWriter = new PrintWriter( sWriter ); |
| |
| e.printStackTrace( pWriter ); |
| sb.append( "\n" ).append( sWriter ); |
| } |
| else |
| { |
| int i = 0; |
| for ( final ProjectBuildingResult result : results ) |
| { |
| final List<ModelProblem> problems = result.getProblems(); |
| for ( final ModelProblem problem : problems ) |
| { |
| sb.append( problem.getMessage() ).append( "\n\t" ).append( problem.getSource() ).append( "@" ).append( problem.getLineNumber() ).append( ":" |
| + problem.getColumnNumber() ); |
| |
| if ( problem.getException() != null ) |
| { |
| final StringWriter sWriter = new StringWriter(); |
| final PrintWriter pWriter = new PrintWriter( sWriter ); |
| |
| problem.getException().printStackTrace( pWriter ); |
| sb.append( "\n" ).append( sWriter ); |
| } |
| |
| sb.append( ( ++i ) ).append( " " ).append( sb ); |
| } |
| } |
| } |
| |
| throw new ProjectToolsException( "Failed to build project instance. \n\n%s", e, sb ); |
| } |
| } |
| |
| @Override |
| public MavenProject buildProjectInstance( final FullProjectKey key, final ProjectToolsSession session ) |
| throws ProjectToolsException |
| { |
| return buildProjectInstance( key.getGroupId(), key.getArtifactId(), key.getVersion(), session ); |
| } |
| |
| @Override |
| public MavenProject buildProjectInstance( final String groupId, final String artifactId, final String version, |
| final ProjectToolsSession session ) |
| throws ProjectToolsException |
| { |
| final ProjectBuildingRequest req = sessionInjector.getProjectBuildingRequest( session ); |
| |
| try |
| { |
| final org.apache.maven.artifact.Artifact pomArtifact = |
| mavenRepositorySystem.createArtifact( groupId, artifactId, version, "pom" ); |
| |
| final Artifact aetherPomArtifact = RepositoryUtils.toArtifact( pomArtifact ); |
| |
| final ArtifactRequest artifactRequest = |
| new ArtifactRequest( aetherPomArtifact, sessionInjector.getRemoteRepositories( session ), "project" ); |
| |
| final ArtifactResult artifactResult = |
| aetherRepositorySystem.resolveArtifact( req.getRepositorySession(), artifactRequest ); |
| |
| final File pomFile = artifactResult.getArtifact().getFile(); |
| final ProjectBuildingResult result = projectBuilder.build( pomFile, req ); |
| |
| final MavenProject project = result.getProject(); |
| project.setRemoteArtifactRepositories( session.getRemoteArtifactRepositories() ); |
| |
| project.setFile( pomFile ); |
| |
| addProjects( session, project ); |
| |
| return project; |
| } |
| catch ( final ProjectBuildingException e ) |
| { |
| // logger.error( "Failed to build MavenProject instances from POM files for sorting: " + e.getMessage(), e |
| // ); |
| final List<ProjectBuildingResult> results = e.getResults(); |
| |
| final StringBuilder sb = new StringBuilder(); |
| |
| int i = 0; |
| if ( results == null ) |
| { |
| sb.append( "Cannot build project instance for: " ).append( groupId ).append( ':' ).append( artifactId ).append( ':' ).append( version ); |
| |
| final StringWriter sWriter = new StringWriter(); |
| final PrintWriter pWriter = new PrintWriter( sWriter ); |
| |
| e.printStackTrace( pWriter ); |
| sb.append( "\n" ).append( sWriter ); |
| } |
| else |
| { |
| for ( final ProjectBuildingResult result : results ) |
| { |
| final List<ModelProblem> problems = result.getProblems(); |
| for ( final ModelProblem problem : problems ) |
| { |
| sb.append( problem.getMessage() ).append( "\n\t" ).append( problem.getSource() ).append( "@" ).append( problem.getLineNumber() ).append( ":" |
| + problem.getColumnNumber() ); |
| |
| if ( problem.getException() != null ) |
| { |
| final StringWriter sWriter = new StringWriter(); |
| final PrintWriter pWriter = new PrintWriter( sWriter ); |
| |
| problem.getException().printStackTrace( pWriter ); |
| sb.append( "\n" ).append( sWriter ); |
| } |
| |
| sb.append( ( ++i ) ).append( " " ).append( sb ); |
| } |
| } |
| } |
| |
| throw new ProjectToolsException( "Failed to build project instance. \n\n%s", e, sb ); |
| } |
| catch ( final ArtifactResolutionException e ) |
| { |
| throw new ProjectToolsException( "Failed to resolve POM: %s:%s:%s\nReason: %s", e, groupId, artifactId, |
| version, e.getMessage() ); |
| } |
| } |
| |
| @Override |
| public Set<String> retrieveReactorProjectIds( final File rootPom ) |
| throws ProjectToolsException |
| { |
| if ( LOGGER.isInfoEnabled() ) |
| { |
| if ( LOGGER.isDebugEnabled() ) |
| { |
| LOGGER.debug( "Finding projectIds contained within reactor for: " + rootPom ); |
| } |
| } |
| |
| final Map<File, Model> models = new LinkedHashMap<File, Model>(); |
| readReactorModels( rootPom, rootPom, models ); |
| |
| final Set<String> projectIds = new HashSet<String>( models.size() ); |
| for ( final Model model : models.values() ) |
| { |
| String groupId = model.getGroupId(); |
| final String artifactId = model.getArtifactId(); |
| String version = model.getVersion(); |
| String packaging = model.getPackaging(); |
| |
| if ( packaging == null ) |
| { |
| packaging = "jar"; |
| } |
| |
| if ( groupId == null || version == null ) |
| { |
| final Parent parent = model.getParent(); |
| if ( parent != null ) |
| { |
| if ( groupId == null ) |
| { |
| groupId = parent.getGroupId(); |
| } |
| if ( version == null ) |
| { |
| version = parent.getVersion(); |
| } |
| } |
| else |
| { |
| LOGGER.warn( String.format( "Invalid POM: %s", model.getId() ) ); |
| continue; |
| } |
| } |
| |
| final String key = ArtifactUtils.key( groupId, artifactId, version ); |
| if ( LOGGER.isInfoEnabled() ) |
| { |
| if ( LOGGER.isDebugEnabled() ) |
| { |
| LOGGER.debug( "Found: " + key ); |
| } |
| } |
| |
| projectIds.add( key ); |
| } |
| |
| return projectIds; |
| } |
| |
| private void readReactorModels( final File topPom, final File pom, final Map<File, Model> models ) |
| throws ProjectToolsException |
| { |
| final Model model = readModel( pom ); |
| models.put( pom, model ); |
| |
| if ( model.getModules() != null && !model.getModules().isEmpty() ) |
| { |
| final File basedir = pom.getParentFile(); |
| |
| final List<File> moduleFiles = new ArrayList<File>(); |
| |
| for ( String module : model.getModules() ) |
| { |
| if ( StringUtils.isEmpty( module ) ) |
| { |
| continue; |
| } |
| |
| module = module.replace( '\\', File.separatorChar ).replace( '/', File.separatorChar ); |
| |
| File moduleFile = new File( basedir, module ); |
| |
| if ( moduleFile.isDirectory() ) |
| { |
| moduleFile = new File( moduleFile, "pom.xml" ); |
| } |
| |
| if ( !moduleFile.isFile() ) |
| { |
| LOGGER.warn( String.format( "In reactor of: %s: Child module %s of %s does not exist.", topPom, |
| moduleFile, pom ) ); |
| continue; |
| } |
| |
| if ( Os.isFamily( Os.FAMILY_WINDOWS ) ) |
| { |
| // we don't canonicalize on unix to avoid interfering with symlinks |
| try |
| { |
| moduleFile = moduleFile.getCanonicalFile(); |
| } |
| catch ( final IOException e ) |
| { |
| moduleFile = moduleFile.getAbsoluteFile(); |
| } |
| } |
| else |
| { |
| moduleFile = new File( moduleFile.toURI().normalize() ); |
| } |
| |
| moduleFiles.add( moduleFile ); |
| readReactorModels( topPom, moduleFile, models ); |
| } |
| } |
| } |
| |
| private Model readModel( final File pom ) |
| throws ProjectToolsException |
| { |
| Reader reader = null; |
| try |
| { |
| reader = ReaderFactory.newPlatformReader( pom ); |
| |
| return new MavenXpp3Reader().read( reader, false ); |
| } |
| catch ( final IOException e ) |
| { |
| LOGGER.error( String.format( "Failed to read POM: %s.\nReason: %s", pom, e.getMessage() ), e ); |
| throw new ProjectToolsException( "Failed to read POM: %s. Reason: %s", e, pom.getAbsolutePath(), |
| e.getMessage() ); |
| } |
| catch ( final XmlPullParserException e ) |
| { |
| LOGGER.error( String.format( "Failed to read POM: %s.\nReason: %s", pom, e.getMessage() ), e ); |
| throw new ProjectToolsException( "Failed to read POM: %s. Reason: %s", e, pom.getAbsolutePath(), |
| e.getMessage() ); |
| } |
| finally |
| { |
| IOUtils.closeQuietly( reader ); |
| } |
| } |
| |
| } |
