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

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

Introduction

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

Prototype

@Deprecated
    public Set<Artifact> createArtifacts(ArtifactFactory artifactFactory, String inheritedScope,
            ArtifactFilter filter) throws InvalidDependencyVersionException 

Source Link

Usage

From source file:org.apache.geronimo.mavenplugins.car.AbstractCarMojo.java

License:Apache License

protected void getDependencies(MavenProject project, boolean useTransitiveDependencies)
        throws MojoExecutionException {

    DependencyTreeResolutionListener listener = new DependencyTreeResolutionListener(getLogger());

    DependencyNode rootNode;/*ww  w .j  ava 2  s  .  c om*/
    try {
        Map managedVersions = project.getManagedVersionMap();

        Set dependencyArtifacts = project.getDependencyArtifacts();

        if (dependencyArtifacts == null) {
            dependencyArtifacts = project.createArtifacts(artifactFactory, null, null);
        }
        ArtifactResolutionResult result = artifactCollector.collect(dependencyArtifacts, project.getArtifact(),
                managedVersions, localRepository, project.getRemoteArtifactRepositories(),
                artifactMetadataSource, null, Collections.singletonList(listener));

        this.dependencyArtifacts = result.getArtifacts();
        rootNode = listener.getRootNode();
    } catch (ArtifactResolutionException exception) {
        throw new MojoExecutionException("Cannot build project dependency tree", exception);
    } catch (InvalidDependencyVersionException e) {
        throw new MojoExecutionException("Invalid dependency version for artifact " + project.getArtifact());
    }

    Scanner scanner = new Scanner();
    scanner.scan(rootNode, useTransitiveDependencies);
    localDependencies = scanner.localDependencies.keySet();
    treeListing = scanner.getLog();
}

From source file:org.apache.synapse.maven.xar.AbstractXarMojo.java

License:Apache License

/**
 * Get the set of artifacts that are provided by Synapse at runtime.
 * //w  w w.j a  v  a2s  .c  om
 * @return
 * @throws MojoExecutionException
 */
private Set<Artifact> getSynapseRuntimeArtifacts() throws MojoExecutionException {
    Log log = getLog();
    log.debug("Looking for synapse-core artifact in XAR project dependencies ...");
    Artifact synapseCore = null;
    for (Iterator<?> it = project.getDependencyArtifacts().iterator(); it.hasNext();) {
        Artifact artifact = (Artifact) it.next();
        if (artifact.getGroupId().equals("org.apache.synapse")
                && artifact.getArtifactId().equals("synapse-core")) {
            synapseCore = artifact;
            break;
        }
    }
    if (synapseCore == null) {
        throw new MojoExecutionException("Could not locate dependency on synapse-core");
    }

    log.debug("Loading project data for " + synapseCore + " ...");
    MavenProject synapseCoreProject;
    try {
        synapseCoreProject = projectBuilder.buildFromRepository(synapseCore, remoteArtifactRepositories,
                localRepository);
    } catch (ProjectBuildingException e) {
        throw new MojoExecutionException("Unable to retrieve project information for " + synapseCore, e);
    }
    Set<Artifact> synapseRuntimeDeps;
    try {
        synapseRuntimeDeps = synapseCoreProject.createArtifacts(artifactFactory, Artifact.SCOPE_RUNTIME,
                new TypeArtifactFilter("jar"));
    } catch (InvalidDependencyVersionException e) {
        throw new MojoExecutionException("Unable to get project dependencies for " + synapseCore, e);
    }
    log.debug("Direct runtime dependencies for " + synapseCore + " :");
    logArtifacts(synapseRuntimeDeps);

    log.debug("Resolving transitive dependencies for " + synapseCore + " ...");
    try {
        synapseRuntimeDeps = artifactCollector.collect(synapseRuntimeDeps, synapseCoreProject.getArtifact(),
                synapseCoreProject.getManagedVersionMap(), localRepository, remoteArtifactRepositories,
                artifactMetadataSource, null, Collections.singletonList(new DebugResolutionListener(logger)))
                .getArtifacts();
    } catch (ArtifactResolutionException e) {
        throw new MojoExecutionException("Unable to resolve transitive dependencies for " + synapseCore);
    }
    log.debug("All runtime dependencies for " + synapseCore + " :");
    logArtifacts(synapseRuntimeDeps);

    return synapseRuntimeDeps;
}

From source file:org.apache.tuscany.maven.bundle.plugin.BundlesMetaDataBuildMojo.java

License:Apache License

private MavenProject buildProject(Artifact artifact)
        throws ProjectBuildingException, InvalidDependencyVersionException, ArtifactResolutionException,
        ArtifactNotFoundException, DependencyTreeBuilderException {
    MavenProject pomProject = mavenProjectBuilder.buildFromRepository(artifact, this.remoteRepos, this.local);
    if (pomProject.getDependencyArtifacts() == null) {
        pomProject.setDependencyArtifacts(pomProject.createArtifacts(factory, null, // Artifact.SCOPE_TEST,
                new ScopeArtifactFilter(Artifact.SCOPE_TEST)));
    }// w ww  . j  a  va  2  s. c o m
    if (includeConflictingDepedencies) {
        pomProject.setArtifacts(getDependencyArtifacts(pomProject));
    } else {
        ArtifactResolutionResult result = resolver.resolveTransitively(pomProject.getDependencyArtifacts(),
                pomProject.getArtifact(), remoteRepos, local, artifactMetadataSource);
        pomProject.setArtifacts(result.getArtifacts());
    }
    return pomProject;
}

From source file:org.clinigrid.capillary.maven.CapillaryMojo.java

License:Open Source License

public Set<Artifact> getDependenciesOf(Artifact artifact) throws MojoExecutionException {
    try {/*from w w w  .j av a 2  s  . co  m*/
        Artifact pomArtifact = artifactFactory.createArtifact(artifact.getGroupId(), artifact.getArtifactId(),
                artifact.getVersion(), artifact.getClassifier(), "pom");
        MavenProject pomProject = mavenProjectBuilder.buildFromRepository(pomArtifact, remoteRepositories,
                localRepository);

        Set<?> artifacts = pomProject.createArtifacts(artifactFactory, null, null);
        ArtifactFilter filter = new ScopeArtifactFilter("compile");
        ArtifactResolutionResult arr = resolver.resolveTransitively(artifacts, pomArtifact, localRepository,
                remoteRepositories, artifactMetadataSource, filter);
        return CastUtil.castSet(arr.getArtifacts());
    } catch (ProjectBuildingException e) {
        throw new MojoExecutionException(String.format("Can't get depedencies of '%s'", artifact.toString()),
                e);
    } catch (InvalidDependencyVersionException e) {
        throw new MojoExecutionException(String.format("Can't get depedencies of '%s'", artifact.toString()),
                e);
    } catch (ArtifactResolutionException e) {
        throw new MojoExecutionException(String.format("Can't get depedencies of '%s'", artifact.toString()),
                e);
    } catch (ArtifactNotFoundException e) {
        throw new MojoExecutionException(String.format("Can't get depedencies of '%s'", artifact.toString()),
                e);
    }
}

From source file:org.codehaus.cargo.maven2.DependencyCalculator.java

License:Apache License

/**
 * Fixup the project artifact.//from  w w  w. j a va2  s. c o  m
 * @throws Exception If anything goes wrong.
 */
protected void fixupProjectArtifact() throws Exception {
    MavenProject mp2 = new MavenProject(mavenProject);
    // For each of our dependencies..
    for (Object artifact : mp2.createArtifacts(artifactFactory, null, null)) {
        Artifact art = (Artifact) artifact;
        if (art.getType().equals("war")) {
            // Sigh...
            Artifact art2 = artifactFactory.createArtifactWithClassifier(art.getGroupId(), art.getArtifactId(),
                    art.getVersion(), "pom", null);
            fixupRepositoryArtifact(art2);
        }
    }

    // If we mess with this model, it's the 'REAL' model. So lets copy it

    Model pomFile = mp2.getModel();

    File outFile = File.createTempFile("pom", ".xml");
    MavenXpp3Writer pomWriter = new MavenXpp3Writer();

    pomWriter.write(new FileWriter(outFile), pomFile);

    MavenXpp3Reader pomReader = new MavenXpp3Reader();
    pomFile = pomReader.read(new FileReader(outFile));

    Artifact art = mp2.getArtifact();
    fixModelAndSaveInRepository(art, pomFile);
    outFile.delete();
}

From source file:org.codehaus.cargo.maven2.DependencyCalculator.java

License:Apache License

/**
 * Fixup an artifact./*  ww w  . j  av  a  2  s .  c o m*/
 * @param artifact Artifact to fixup.
 * @throws Exception If anything goes wrong.
 */
protected void fixupRepositoryArtifact(Artifact artifact) throws Exception {

    // Resolve it
    resolver.resolve(artifact, remoteRepositories, localRepository);
    File artifactFile = artifact.getFile();

    // Also, create a project for it
    MavenProject mavenProject = mavenProjectBuilder.buildFromRepository(artifact, remoteRepositories,
            localRepository);
    for (Object createdArtifact : mavenProject.createArtifacts(artifactFactory, null, null)) {
        Artifact art = (Artifact) createdArtifact;

        if (art.getType().equals("war")) {
            // Sigh...
            Artifact art2 = artifactFactory.createArtifactWithClassifier(art.getGroupId(), art.getArtifactId(),
                    art.getVersion(), "pom", null);
            fixupRepositoryArtifact(art2);
        }
    }

    MavenXpp3Reader pomReader = new MavenXpp3Reader();
    Model pomFile = pomReader.read(new FileReader(artifactFile));

    fixModelAndSaveInRepository(artifact, pomFile);
}

From source file:org.codehaus.mojo.clirr.AbstractClirrMojo.java

License:Apache License

protected List getTransitiveDependencies(final Set previousArtifacts) throws ProjectBuildingException,
        InvalidDependencyVersionException, ArtifactResolutionException, ArtifactNotFoundException {
    final List dependencies = new ArrayList();
    for (Iterator iter = previousArtifacts.iterator(); iter.hasNext();) {
        final Artifact a = (Artifact) iter.next();
        final Artifact pomArtifact = factory.createArtifact(a.getGroupId(), a.getArtifactId(), a.getVersion(),
                a.getScope(), "pom");
        final MavenProject pomProject = mavenProjectBuilder.buildFromRepository(pomArtifact,
                project.getRemoteArtifactRepositories(), localRepository);
        final Set pomProjectArtifacts = pomProject.createArtifacts(factory, null, null);
        final ArtifactResolutionResult result = resolver.resolveTransitively(pomProjectArtifacts, pomArtifact,
                localRepository, project.getRemoteArtifactRepositories(), metadataSource, null);
        dependencies.addAll(result.getArtifacts());
    }//w ww.j av a  2 s . co  m
    return dependencies;
}

From source file:org.codehaus.mojo.pluginsupport.dependency.DependencyHelper.java

License:Apache License

public DependencyTree getDependencies(final MavenProject project)
        throws ProjectBuildingException, InvalidDependencyVersionException, ArtifactResolutionException {
    assert project != null;

    Map managedVersions = getManagedVersionMap(project, artifactFactory);
    DependencyResolutionListener listener = new DependencyResolutionListener();

    if (project.getDependencyArtifacts() == null) {
        project.setDependencyArtifacts(project.createArtifacts(artifactFactory, null, null));
    }/*from  w  w  w .  j av a  2 s .c om*/

    artifactCollector.collect(project.getDependencyArtifacts(), project.getArtifact(), managedVersions,
            getArtifactRepository(), project.getRemoteArtifactRepositories(), artifactMetadataSource, null,
            Collections.singletonList(listener));

    return listener.getDependencyTree();
}

From source file:org.codehaus.mojo.pomtools.helpers.MetadataHelper.java

License:Apache License

/** Resolves all transitive dependencies for the current project and returns a list
 * of {@link TransitiveDependencyInfo} objects.  Each object represents a distinct 
 * groupId:artifactId:type dependency.  The {@link TransitiveDependencyInfo#getResolutionNodes()}
 * represent all of the possible ResolutionNodes which resolve to this groupId:artifactId.
 * //  w  w  w .  j  a va2 s.  c o m
 * @return
 * @throws PomToolsException
 */
public List getTransitiveDependencies() throws PomToolsException, ProjectBuildingException {
    // Certain things like groupId or versions for dependencies may be declared in a parent
    // pom so we need to have maven fully resolve the model before walking the tree.
    MavenProject project = PomToolsPluginContext.getInstance().getActiveProject().getTemporaryResolvedProject();

    try {
        project.setDependencyArtifacts(project.createArtifacts(artifactFactory, null, null));
    } catch (InvalidDependencyVersionException e) {
        throw new PomToolsVersionException(
                "Unable to build project due to an invalid dependency version: " + e.getMessage(), e);
    }

    Artifact projectArtifact = project.getArtifact();

    Set artifacts = project.getDependencyArtifacts();

    try {
        List dependencies = new ArrayList();

        ArtifactResolutionResult result;
        result = artifactResolver.resolveTransitively(artifacts, projectArtifact, Collections.EMPTY_MAP,
                localRepository, remoteRepositories, metadataSource, projectArtifact.getDependencyFilter());

        Map dependencyMap = new HashMap();
        Set seen = new HashSet();

        // First build our map of distinct groupId:artifactIds
        for (Iterator iter = result.getArtifactResolutionNodes().iterator(); iter.hasNext();) {
            ResolutionNode node = (ResolutionNode) iter.next();

            TransitiveDependencyInfo info = new TransitiveDependencyInfo(node);

            dependencyMap.put(info.getKey(), info);

            dependencies.add(info);
        }

        // Now populate the map with all children
        recurseNode(dependencyMap, seen, result.getArtifactResolutionNodes().iterator(), 0);

        return dependencies;
    } catch (ArtifactNotFoundException e) {
        throw new PomToolsException(e);
    } catch (ArtifactResolutionException e) {
        throw new PomToolsException(e);
    }

}

From source file:org.eclipse.che.maven.server.MavenServerImpl.java

License:Open Source License

private MavenResult internalResolveProject(File pom, List<String> activeProfiles, List<String> inactiveProfiles,
        List<ResolutionListener> dependencyTreeResolutionListeners) {

    MavenExecutionRequest request = newMavenRequest(pom, activeProfiles, inactiveProfiles,
            Collections.emptyList());
    request.setUpdateSnapshots(updateSnapshots);

    AtomicReference<MavenResult> reference = new AtomicReference<>();
    runMavenRequest(request, () -> {//from   ww  w.j a  va2s .  c o  m
        try {
            ProjectBuilder builder = getMavenComponent(ProjectBuilder.class);

            List<ProjectBuildingResult> resultList = builder.build(Collections.singletonList(pom), false,
                    request.getProjectBuildingRequest());
            ProjectBuildingResult result = resultList.get(0);
            MavenProject mavenProject = result.getProject();
            RepositorySystemSession repositorySession = getMavenComponent(LegacySupport.class)
                    .getRepositorySession();
            if (repositorySession instanceof DefaultRepositorySystemSession) {
                ((DefaultRepositorySystemSession) repositorySession)
                        .setTransferListener(new ArtifactTransferListener(mavenProgressNotifier));
                if (workspaceCache != null) {
                    ((DefaultRepositorySystemSession) repositorySession)
                            .setWorkspaceReader(new MavenWorkspaceReader(workspaceCache));
                }

            }

            List<Exception> exceptions = new ArrayList<>();

            loadExtensions(mavenProject, exceptions);
            mavenProject.setDependencyArtifacts(
                    mavenProject.createArtifacts(getMavenComponent(ArtifactFactory.class), null, null));

            ArtifactResolutionRequest resolutionRequest = new ArtifactResolutionRequest();
            resolutionRequest.setArtifact(mavenProject.getArtifact());
            resolutionRequest.setRemoteRepositories(mavenProject.getRemoteArtifactRepositories());
            resolutionRequest.setArtifactDependencies(mavenProject.getDependencyArtifacts());
            resolutionRequest.setListeners(dependencyTreeResolutionListeners);
            resolutionRequest.setLocalRepository(localRepo);
            resolutionRequest.setManagedVersionMap(mavenProject.getManagedVersionMap());
            resolutionRequest.setResolveTransitively(true);
            resolutionRequest.setResolveRoot(false);
            ArtifactResolver resolver = getMavenComponent(ArtifactResolver.class);
            ArtifactResolutionResult resolve = resolver.resolve(resolutionRequest);
            mavenProject.setArtifacts(resolve.getArtifacts());
            reference.set(new MavenResult(mavenProject, exceptions));

        } catch (Exception e) {
            reference.set(new MavenResult(null, null, Collections.singletonList(e)));
        }
    });
    return reference.get();
}