Example usage for org.apache.maven.project MavenProject setFile

List of usage examples for org.apache.maven.project MavenProject setFile

Introduction

In this page you can find the example usage for org.apache.maven.project MavenProject setFile.

Prototype

public void setFile(File file) 

Source Link

Usage

From source file:org.commonjava.emb.project.ProjectLoader.java

License:Apache License

public MavenProject buildProjectInstance(final String groupId, final String artifactId, final String version,
        final ProjectToolsSession session) throws ProjectToolsException {
    final ProjectBuildingRequest req = sessionInjector.getProjectBuildingRequest(session);

    try {//w ww . ja  va2s  . c  o m
        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());
    }
}

From source file:org.debian.dependency.sources.SCMSourceRetrieval.java

License:Apache License

private MavenProject constructProject(final Artifact artifact, final MavenSession session)
        throws SourceRetrievalException {
    try {//  w  w  w  . j  a  va  2  s .  c  o m
        // pom files are not set up in projects which are not in the workspace, we add them in manually since they are needed
        Artifact pomArtifact = repositorySystem.createProjectArtifact(artifact.getGroupId(),
                artifact.getArtifactId(), artifact.getVersion());
        pomArtifact = resolveArtifact(pomArtifact, session);

        ProjectBuildingRequest request = new DefaultProjectBuildingRequest(session.getProjectBuildingRequest());
        request.setActiveProfileIds(null);
        request.setInactiveProfileIds(null);
        request.setUserProperties(null);

        ProjectBuildingResult result = projectBuilder.build(artifact, request);

        MavenProject mavenProject = result.getProject();
        mavenProject.setArtifact(resolveArtifact(mavenProject.getArtifact(), session));
        mavenProject.setFile(pomArtifact.getFile());
        return mavenProject;
    } catch (ProjectBuildingException e) {
        throw new SourceRetrievalException(e);
    }
}

From source file:org.ops4j.pax.construct.lifecycle.EclipseOSGiMojo.java

License:Apache License

/**
 * Download and save the Maven POM for the given artifact
 * //from  www.j  a v a  2s  . c  o m
 * @param baseDir base directory
 * @param artifact Maven artifact
 * @return the downloaded project
 */
private MavenProject writeProjectPom(File baseDir, Artifact artifact) {
    MavenProject pom = null;

    String groupId = artifact.getGroupId();
    String artifactId = artifact.getArtifactId();
    String version = artifact.getVersion();

    Artifact pomArtifact = artifactFactory.createProjectArtifact(groupId, artifactId, version);

    try {
        pom = m_mavenProjectBuilder.buildFromRepository(pomArtifact, remoteArtifactRepositories,
                localRepository);

        // need this when using Maven 2.1 which doesn't do any alignment
        m_pathTranslator.alignToBaseDirectory(pom.getModel(), baseDir);

        File pomFile = new File(baseDir, "pom.xml");

        Writer writer = StreamFactory.newXmlWriter(pomFile);
        pom.writeModel(writer);
        pom.setFile(pomFile);
        IOUtil.close(writer);
    } catch (ProjectBuildingException e) {
        getLog().warn("Unable to build POM for artifact " + pomArtifact);
    } catch (IOException e) {
        getLog().warn("Unable to write POM for artifact " + pomArtifact);
    }

    return pom;
}

From source file:org.ops4j.pax.construct.lifecycle.ProvisionMojo.java

License:Apache License

/**
 * Create new POM (based on the root POM) which lists the deployed bundles as dependencies
 * /*from  w  ww .j  av  a 2 s  .c om*/
 * @param bundles list of bundles to be deployed
 * @return deployment project
 * @throws MojoExecutionException
 */
private MavenProject createDeploymentProject(List bundles) throws MojoExecutionException {
    MavenProject deployProject;

    if (null == m_project.getFile()) {
        deployProject = new MavenProject();
        deployProject.setGroupId("examples");
        deployProject.setArtifactId("pax-provision");
        deployProject.setVersion("1.0-SNAPSHOT");
    } else {
        deployProject = new MavenProject(m_project);
    }

    String internalId = PomUtils.getCompoundId(deployProject.getGroupId(), deployProject.getArtifactId());
    deployProject.setGroupId(internalId + ".build");
    deployProject.setArtifactId("deployment");

    // remove unnecessary cruft
    deployProject.setPackaging("pom");
    deployProject.getModel().setModules(null);
    deployProject.getModel().setDependencies(bundles);
    deployProject.getModel().setPluginRepositories(null);
    deployProject.getModel().setReporting(null);
    deployProject.setBuild(null);

    File deployFile = new File(deployProject.getBasedir(), "runner/deploy-pom.xml");

    deployFile.getParentFile().mkdirs();
    deployProject.setFile(deployFile);

    try {
        Writer writer = StreamFactory.newXmlWriter(deployFile);
        deployProject.writeModel(writer);
        IOUtil.close(writer);
    } catch (IOException e) {
        throw new MojoExecutionException("Unable to write deployment POM " + deployFile);
    }

    return deployProject;
}

From source file:org.ops4j.pax.construct.project.ImportBundleMojo.java

License:Apache License

/**
 * Resolve the Maven project for the given artifact, handling when a POM cannot be found in the repository
 * /*from  w w  w .j a v a2  s .c o  m*/
 * @param pomGroupId project group id
 * @param pomArtifactId project artifact id
 * @param pomVersion project version
 * @return resolved Maven project
 */
private MavenProject buildMavenProject(String pomGroupId, String pomArtifactId, String pomVersion) {
    Artifact pomArtifact = m_factory.createProjectArtifact(pomGroupId, pomArtifactId, pomVersion);
    MavenProject project;
    try {
        project = m_projectBuilder.buildFromRepository(pomArtifact, m_remoteRepos, m_localRepo);
    } catch (ProjectBuildingException e) {
        getLog().warn("Problem resolving project " + pomArtifact.getId());
        return null;
    }

    /*
     * look to see if this is a local project (if so then set the POM location)
     */
    Pom localPom = DirUtils.findPom(targetDirectory, pomGroupId + ':' + pomArtifactId);
    if (localPom != null) {
        project.setFile(localPom.getFile());
    }

    /*
     * Repair stubs (ie. when a POM couldn't be found in the various repositories)
     */
    DistributionManagement dm = project.getDistributionManagement();
    if (dm != null && "generated".equals(dm.getStatus())) {
        if (localPom != null) {
            // local project, use values from the local POM
            project.setPackaging(localPom.getPackaging());
            project.setName(localPom.getId());
        } else {
            // remote project - assume it creates a jarfile (so we can test later for OSGi metadata)
            Artifact jar = m_factory.createBuildArtifact(pomGroupId, pomArtifactId, pomVersion, "jar");
            project.setArtifact(jar);

            project.setPackaging("jar");
            project.setName(jar.getId());
        }
    }

    return project;
}

From source file:org.reficio.p2.TychoFeatureBuilder.java

License:Open Source License

public void execute() throws MojoExecutionException, IOException {
    MavenProject mp = new MavenProject();
    mp.getModel().setGroupId(this.mavenProject.getGroupId());
    mp.getModel().setArtifactId(featureId);
    mp.getModel().setVersion(featureVersion);
    mp.getModel().setPackaging("eclipse-feature");
    mp.setPluginArtifactRepositories(this.mavenProject.getPluginArtifactRepositories());
    mp.setFile(featureFile); //sets the basedir for the MavenProject
    org.eclipse.tycho.artifacts.DependencyArtifacts da = new DefaultTargetPlatform();
    mp.setContextValue(TychoConstants.CTX_DEPENDENCY_ARTIFACTS, da);
    mavenSession.setCurrentProject(mp);//from   w  ww .  j a  v  a  2s .  co m
    executeMojo(
            plugin(groupId("org.eclipse.tycho"), artifactId("tycho-packaging-plugin"), version(TYCHO_VERSION)),
            goal("package-feature"),
            configuration(element(name("finalName"), this.featureId + "_" + this.featureVersion + ".jar"),
                    element(name("basedir"), this.featureFile.getParent()),
                    element(name("outputDirectory"), outputDirectory)),
            executionEnvironment(mp, mavenSession, buildPluginManager));

}

From source file:org.sonar.api.test.MavenTestUtils.java

License:Open Source License

public static MavenProject loadPom(String pomUrlInClasspath) {
    FileReader fileReader = null;
    try {/*from ww w .j  a  v  a 2 s  . com*/
        File pomFile = new File(MavenTestUtils.class.getResource(pomUrlInClasspath).toURI());
        MavenXpp3Reader pomReader = new MavenXpp3Reader();
        fileReader = new FileReader(pomFile);
        Model model = pomReader.read(fileReader);
        MavenProject project = new MavenProject(model);
        project.setFile(pomFile);
        project.getBuild().setDirectory(pomFile.getParentFile().getPath());
        project.addCompileSourceRoot(pomFile.getParentFile().getPath() + "/src/main/java");
        project.addTestCompileSourceRoot(pomFile.getParentFile().getPath() + "/src/test/java");
        return project;
    } catch (Exception e) {
        throw new SonarException("Failed to read Maven project file : " + pomUrlInClasspath, e);

    } finally {
        IOUtils.closeQuietly(fileReader);
    }
}

From source file:org.sourcepit.b2.release.B2ReleaseHelper.java

License:Apache License

public MavenProject adaptModuleProject(MavenProject reactorProject) {
    MavenProject moduleProject = (MavenProject) reactorProject.getContextValue("b2.moduleProject");
    if (moduleProject == null) {
        if (bridge.getModule(reactorProject) != null) {
            moduleProject = (MavenProject) reactorProject.clone();
            moduleProject.setFile(new File(reactorProject.getBasedir(), "module.xml"));
            reactorProject.setContextValue("b2.moduleProject", moduleProject);
        }//from   ww  w.  j a  va2 s  .c om
    }
    return moduleProject;
}

From source file:org.sourcepit.tpmp.resolver.tycho.TychoSessionTargetPlatformResolver.java

License:Apache License

private MavenProject setupAggregatedProject(MavenSession session,
        TargetPlatformConfiguration aggregatedConfiguration) {
    PropertiesMap mvnProperties = new LinkedPropertiesMap();
    mvnProperties.load(getClass().getClassLoader(), "META-INF/tpmp/maven.properties");

    String groupId = mvnProperties.get("groupId");
    String artifactId = mvnProperties.get("artifactId");
    String version = mvnProperties.get("version");

    final String tpmpKey = Plugin.constructKey(groupId, artifactId);

    MavenProject origin = session.getCurrentProject();

    Model model = origin.getModel().clone();
    Build build = model.getBuild();/*from w  ww.  j  a  v  a 2s. c  o m*/
    if (build.getPluginsAsMap().get(tpmpKey) == null) {
        Plugin tpmp = new Plugin();
        tpmp.setGroupId(groupId);
        tpmp.setArtifactId(artifactId);
        tpmp.setVersion(version);

        build.getPlugins().add(tpmp);
        build.flushPluginMap();
    }

    MavenProject fake = new MavenProject(model);
    fake.setClassRealm(origin.getClassRealm());
    fake.setFile(origin.getFile());

    final Map<String, ArtifactRepository> artifactRepositories = new LinkedHashMap<String, ArtifactRepository>();
    final Map<String, ArtifactRepository> pluginRepositories = new LinkedHashMap<String, ArtifactRepository>();
    for (MavenProject project : session.getProjects()) {
        for (ArtifactRepository repository : project.getRemoteArtifactRepositories()) {
            if (!artifactRepositories.containsKey(repository.getId())) {
                artifactRepositories.put(repository.getId(), repository);
            }
        }
        for (ArtifactRepository repository : project.getPluginArtifactRepositories()) {
            if (!pluginRepositories.containsKey(repository.getId())) {
                pluginRepositories.put(repository.getId(), repository);
            }
        }
    }

    fake.setRemoteArtifactRepositories(new ArrayList<ArtifactRepository>(artifactRepositories.values()));
    fake.setPluginArtifactRepositories(new ArrayList<ArtifactRepository>(pluginRepositories.values()));
    fake.setManagedVersionMap(origin.getManagedVersionMap());

    if (getTychoProject(fake) == null) {
        fake.setPackaging("eclipse-repository");
    }

    fake.getBuildPlugins();

    AbstractTychoProject tychoProject = (AbstractTychoProject) getTychoProject(fake);
    tychoProject.setupProject(session, fake);

    Properties properties = new Properties();
    properties.putAll(fake.getProperties());
    properties.putAll(session.getSystemProperties()); // session wins
    properties.putAll(session.getUserProperties());
    fake.setContextValue(TychoConstants.CTX_MERGED_PROPERTIES, properties);

    fake.setContextValue(TychoConstants.CTX_TARGET_PLATFORM_CONFIGURATION, aggregatedConfiguration);

    ExecutionEnvironmentConfiguration eeConfiguration = new ExecutionEnvironmentConfigurationImpl(logger,
            aggregatedConfiguration.isResolveWithEEConstraints());
    tychoProject.readExecutionEnvironmentConfiguration(fake, eeConfiguration);
    fake.setContextValue(TychoConstants.CTX_EXECUTION_ENVIRONMENT_CONFIGURATION, eeConfiguration);

    final DependencyMetadata dm = new DependencyMetadata();
    for (ReactorProject reactorProject : DefaultReactorProject.adapt(session)) {
        mergeMetadata(dm, reactorProject, true);
        mergeMetadata(dm, reactorProject, false);
    }

    int i = 0;
    for (Object object : dm.getMetadata(true)) {
        InstallableUnitDAO dao = new TychoSourceIUResolver.InstallableUnitDAO(
                object.getClass().getClassLoader());
        dao.setProperty(object, RepositoryLayoutHelper.PROP_CLASSIFIER, "fake_" + i);
        i++;
    }

    for (Object object : dm.getMetadata(false)) {
        InstallableUnitDAO dao = new TychoSourceIUResolver.InstallableUnitDAO(
                object.getClass().getClassLoader());
        dao.setProperty(object, RepositoryLayoutHelper.PROP_CLASSIFIER, "fake_" + i);
        i++;
    }

    Map<String, DependencyMetadata> metadata = new LinkedHashMap<String, DependencyMetadata>();
    metadata.put(null, dm);

    fake.setContextValue("tpmp.aggregatedMetadata", metadata);

    return fake;
}

From source file:org.springframework.ide.vscode.commons.maven.MavenBridge.java

License:Open Source License

MavenProject resolveParentProject(RepositorySystemSession repositorySession, MavenProject child,
        ProjectBuildingRequest configuration) throws MavenException {
    configuration.setValidationLevel(ModelBuildingRequest.VALIDATION_LEVEL_MINIMAL);
    configuration.setRepositorySession(repositorySession);

    try {/*from   w ww . j  a  va 2  s .c  o m*/
        configuration.setRemoteRepositories(child.getRemoteArtifactRepositories());

        File parentFile = child.getParentFile();
        if (parentFile != null) {
            return lookup(ProjectBuilder.class).build(parentFile, configuration).getProject();
        }

        Artifact parentArtifact = child.getParentArtifact();
        if (parentArtifact != null) {
            MavenProject parent = lookup(ProjectBuilder.class).build(parentArtifact, configuration)
                    .getProject();
            parentFile = parentArtifact.getFile(); // file is resolved as
            // side-effect of the
            // prior call
            // compensate for apparent bug in maven 3.0.4 which does not set
            // parent.file and parent.artifact.file
            if (parent.getFile() == null) {
                parent.setFile(parentFile);
            }
            if (parent.getArtifact().getFile() == null) {
                parent.getArtifact().setFile(parentFile);
            }
            return parent;
        }
    } catch (ProjectBuildingException ex) {
        log.error("Could not read parent project", ex);
    }

    return null;
}