Example usage for org.apache.maven.artifact.resolver ArtifactResolver ROLE

Introduction

In this page you can find the example usage for org.apache.maven.artifact.resolver ArtifactResolver ROLE.

Prototype

String ROLE

To view the source code for org.apache.maven.artifact.resolver ArtifactResolver ROLE.

Click Source Link

Usage

From source file:com.googlecode.jndiresources.maven.MavenEmbedder.java

License:Apache License

/**
 * Start the maven embedded./*  ww w.  j  a  v a2  s.  c o  m*/
 * @throws DuplicateRealmException If error.
 * @throws PlexusContainerException If error.
 * @throws ComponentLookupException If error.
 * @throws IOException If error.
 * @throws XmlPullParserException If error.
 */
public void start() throws DuplicateRealmException, PlexusContainerException, ComponentLookupException,
        IOException, XmlPullParserException {
    detectUserInstallation();

    // ----------------------------------------------------------------------
    // Set the maven.home system property which is need by components like
    // the plugin registry builder.
    // ----------------------------------------------------------------------

    if (classLoader_ == null) {
        throw new IllegalStateException("A classloader must be specified using setClassLoader(ClassLoader).");
    }

    embedder_ = new Embedder();

    embedder_.setLoggerManager(new MavenEmbedderLoggerManager(new PlexusLogger()));

    final ClassWorld classWorld = new ClassWorld();

    classWorld.newRealm("plexus.core", classLoader_);

    embedder_.start(classWorld);

    // ----------------------------------------------------------------------
    // Artifact related components
    // ----------------------------------------------------------------------
    artifactRepositoryFactory_ = (ArtifactRepositoryFactory) embedder_.lookup(ArtifactRepositoryFactory.ROLE);

    artifactFactory_ = (ArtifactFactory) embedder_.lookup(ArtifactFactory.ROLE);

    artifactResolver_ = (ArtifactResolver) embedder_.lookup(ArtifactResolver.ROLE);

    defaultArtifactRepositoryLayout_ = (ArtifactRepositoryLayout) embedder_
            .lookup(ArtifactRepositoryLayout.ROLE, DEFAULT_LAYOUT_ID);

    // TODO : gestion Artifact
    // defaultMetadatSource=(ArtifactMetadataSource)embedder.lookup(ArtifactMetadataSource.ROLE);
    // defaultMetadatSource=new ArtifactRepositoryMetadata(artifact);
    createMavenSettings();
    localRepository_ = createLocalRepository(settings_);
}

---

From source file:com.pongasoft.maven.ant.tasks.ResolveTask.java

License:Apache License

@Override
protected void doExecute() {
    if (_dependency == null)
        throw new BuildException("mising dependency");

    _localRepo = createLocalArtifactRepository();
    log("Using local repository: " + _localRepo.getBasedir(), Project.MSG_VERBOSE);

    _resolver = (ArtifactResolver) lookup(ArtifactResolver.ROLE);
    _artifactFactory = (ArtifactFactory) lookup(ArtifactFactory.ROLE);

    MavenProject mavenProject = createMavenProject();
    _remoteArtifactRepositories = createRemoteArtifactRepositories(mavenProject.getRepositories());

    log("Resolving " + _dependency, Project.MSG_VERBOSE);

    Artifact mainArtifact;//www.jav  a  2 s.  c o m

    try {
        mainArtifact = resolveJarArtifact(null);
        _result.put("artifact", mainArtifact);
    } catch (ArtifactResolutionException e) {
        throw new BuildException("Unable to resolve artifact: " + e.getMessage(), e);
    } catch (ArtifactNotFoundException e) {
        throw new BuildException("Unable to resolve artifact: " + e.getMessage(), e);
    }

    try {
        if (_sources)
            _result.put("sources", resolveJarArtifact("sources"));
        if (_javadoc)
            _result.put("javadoc", resolveJarArtifact("javadoc"));
    } catch (ArtifactResolutionException e) {
        throw new BuildException("Unable to resolve artifact: " + e.getMessage(), e);
    } catch (ArtifactNotFoundException e) {
        // ok... sources and javadocs are optional
    }

    if (!_artifactOnly) {
        resolveTransitively(mainArtifact);
    }
}

---

From source file:fr.imag.adele.cadse.platform.DependenciesTask.java

License:Apache License

/**
 * Main task execution.  Called by parent execute().
 *///from  www  .  j a v a2s .  co m
protected void doExecute() {

    if (useScope != null && scopes != null) {
        throw new BuildException("You cannot specify both useScope and scopes in the dependencies task.");
    }

    if (getPom() != null && !this.dependencies.isEmpty()) {
        throw new BuildException("You cannot specify both dependencies and a pom in the dependencies task");
    }

    // Try to load dependency refs from an exsiting Ant cache file
    if (isCacheDependencyRefs()) {
        if (getDependencyRefsBuildFile() == null) {
            setDependencyRefsBuildFile(DEFAULT_ANT_BUILD_FILE);
        }
        if (checkCachedDependencies()) {
            log("Dependency refs loaded from file: " + getDependencyRefsBuildFile(), Project.MSG_VERBOSE);
            return;
        }
    }

    ArtifactRepository localRepo = createLocalArtifactRepository();
    log("Using local repository: " + localRepo.getBasedir(), Project.MSG_VERBOSE);

    // Look up required resources from the plexus container
    ArtifactResolver resolver = (ArtifactResolver) lookup(ArtifactResolver.ROLE);
    ArtifactFactory artifactFactory = (ArtifactFactory) lookup(ArtifactFactory.ROLE);
    MavenMetadataSource metadataSource = (MavenMetadataSource) lookup(ArtifactMetadataSource.ROLE);

    Pom pom = initializePom(localRepo);
    if (pom != null) {
        dependencies = pom.getDependencies();
    } else {
        // we have to have some sort of Pom object in order to satisfy the requirements for building the
        // originating Artifact below...
        pom = createDummyPom(localRepo);
    }

    if (dependencies.isEmpty()) {
        log("There were no dependencies specified", Project.MSG_WARN);
    }

    log("Resolving dependencies...", Project.MSG_VERBOSE);

    Set artifacts;

    List remoteArtifactRepositories = createRemoteArtifactRepositories(pom.getRepositories());

    try {
        artifacts = MavenMetadataSource.createArtifacts(artifactFactory, dependencies, null, null, null);

        Artifact pomArtifact = artifactFactory.createBuildArtifact(pom.getGroupId(), pom.getArtifactId(),
                pom.getVersion(), pom.getPackaging());

        List listeners = Collections.singletonList(new AntResolutionListener(getProject()));

        ArtifactFilter filter = null;
        if (useScope != null) {
            filter = new ScopeArtifactFilter(useScope);
        }
        if (scopes != null) {
            filter = new SpecificScopesArtifactFilter(scopes);
        }
        if (type != null) {
            ArtifactFilter typeArtifactFilter = new TypesArtifactFilter(type);
            if (filter != null) {
                AndArtifactFilter andFilter = new AndArtifactFilter();
                andFilter.add(filter);
                andFilter.add(typeArtifactFilter);
                filter = andFilter;
            } else {
                filter = typeArtifactFilter;
            }
        }
        for (Object o : artifacts) {
            resolver.resolve((Artifact) o, remoteArtifactRepositories, localRepo);
        }

    } catch (ArtifactResolutionException e) {
        throw new BuildException("Unable to resolve artifact: " + e.getMessage(), e);
    } catch (ArtifactNotFoundException e) {
        throw new BuildException("Dependency not found: " + e.getMessage(), e);
    } catch (InvalidDependencyVersionException e) {
        throw new BuildException("Invalid dependency version: " + e.getMessage(), e);
    }

    FileSet dependencyFileSet = createFileSet();

    FileSet sourcesFileSet = createFileSet();

    FileSet javadocsFileSet = createFileSet();

    Path dependencyPath = new Path(getProject());

    Set versions = new HashSet();

    for (Object o : artifacts) {
        Artifact artifact = (Artifact) o;

        addArtifactToResult(localRepo, artifact, dependencyFileSet, dependencyPath);

        versions.add(artifact.getVersion());

        if (sourcesFilesetId != null) {
            resolveSource(artifactFactory, resolver, remoteArtifactRepositories, localRepo, artifact, "sources",
                    sourcesFileSet);
        }

        if (javadocFilesetId != null) {
            resolveSource(artifactFactory, resolver, remoteArtifactRepositories, localRepo, artifact, "javadoc",
                    javadocsFileSet);
        }

    }

    defineFilesetReference(filesetId, dependencyFileSet);

    defineFilesetReference(sourcesFilesetId, sourcesFileSet);

    defineFilesetReference(javadocFilesetId, javadocsFileSet);

    if (pathId != null) {
        getProject().addReference(pathId, dependencyPath);
    }

    if (versionsId != null) {
        String versionsValue = StringUtils.join(versions.iterator(), File.pathSeparator);
        getProject().setNewProperty(versionsId, versionsValue);
    }
}

---

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

License:Apache License

public MetadataHelper(MavenSession session, List remoteArtifactRepositories, ArtifactRepository localRepository)
        throws PomToolsRTException {
    PlexusContainer container = session.getContainer();

    try {/*from   w  ww  . j  ava2s  .c om*/
        this.repositoryMetadataManager = (RepositoryMetadataManager) container
                .lookup(RepositoryMetadataManager.class.getName());

        this.artifactFactory = (ArtifactFactory) container.lookup(ArtifactFactory.ROLE);

        this.metadataSource = (ArtifactMetadataSource) container.lookup(ArtifactMetadataSource.ROLE);

        this.artifactResolver = (ArtifactResolver) container.lookup(ArtifactResolver.ROLE);
    } catch (ComponentLookupException e) {
        throw new PomToolsRTException(e);
    }

    this.remoteRepositories = remoteArtifactRepositories;
    this.localRepository = localRepository;
}

---

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

License:Open Source License

@Override
public void setComponents(MavenWorkspaceCache cache, boolean failOnUnresolvedDependency,
        MavenTerminal mavenTerminal, MavenServerProgressNotifier notifier, boolean alwaysUpdateSnapshot)
        throws RemoteException {

    container.addComponent(getMavenComponent(ArtifactResolver.class, "che"), ArtifactResolver.ROLE);
    ArtifactResolver artifactResolver = getMavenComponent(ArtifactResolver.class);
    if (artifactResolver instanceof CheArtifactResolver) {
        ((CheArtifactResolver) artifactResolver).setWorkspaceCache(cache, failOnUnresolvedDependency);
    }/*from www.  j a  v  a2 s  .c  o  m*/

    buildDate = new Date();
    workspaceCache = cache;
    updateSnapshots = updateSnapshots || alwaysUpdateSnapshot;
    terminalLogger.setTerminal(mavenTerminal);
    mavenProgressNotifier = new MavenServerProgressNotifierImpl(notifier);
}

---

From source file:org.efaps.maven_java5.EfapsAnnotationDescriptorExtractor.java

License:Open Source License

/**
 * Initialize the container from the context.
 *
 *///from w  w  w .j av  a2 s. c o  m
public void contextualize(final Context _context) throws ContextException {
    final PlexusContainer container = (PlexusContainer) _context.get(PlexusConstants.PLEXUS_KEY);
    try {
        this.artifactRepositoryLayout = (ArtifactRepositoryLayout) container
                .lookup(ArtifactRepositoryLayout.ROLE);
    } catch (final ComponentLookupException e) {
        throw new ContextException("Could not get ArtifactRepositoryLayout from PlexusContainer", e);
    }
    try {
        this.artifactRepositoryFactory = (ArtifactRepositoryFactory) container
                .lookup(ArtifactRepositoryFactory.ROLE);
    } catch (final ComponentLookupException e) {
        throw new ContextException("Could not get ArtifactResolver from PlexusContainer", e);
    }
    try {
        this.settingsBuilder = (MavenSettingsBuilder) container.lookup(MavenSettingsBuilder.ROLE);
    } catch (final ComponentLookupException e) {
        throw new ContextException("Could not get ArtifactResolver from PlexusContainer", e);
    }
    try {
        this.artifactResolver = (ArtifactResolver) container.lookup(ArtifactResolver.ROLE);
    } catch (final ComponentLookupException e) {
        throw new ContextException("Could not get ArtifactResolver from PlexusContainer", e);
    }
    try {
        this.artifactFactory = (ArtifactFactory) container.lookup(ArtifactFactory.ROLE);
    } catch (final ComponentLookupException e) {
        throw new ContextException("Could not get ArtifactFactory from PlexusContainer", e);
    }
    try {
        this.artifactMetadataSource = (ArtifactMetadataSource) container.lookup(ArtifactMetadataSource.ROLE,
                "maven");
    } catch (final ComponentLookupException e) {
        throw new ContextException("Could not get ArtifactMetadataSource from PlexusContainer", e);
    }
}

---

From source file:org.jetbrains.idea.maven.server.Maven30ServerEmbedderImpl.java

License:Apache License

public void customizeComponents() throws RemoteException {
    // replace some plexus components
    myContainer.addComponent(getComponent(ArtifactFactory.class, "ide"), ArtifactFactory.ROLE);
    myContainer.addComponent(getComponent(ArtifactResolver.class, "ide"), ArtifactResolver.ROLE);
    myContainer.addComponent(getComponent(RepositoryMetadataManager.class, "ide"),
            RepositoryMetadataManager.class.getName());
    myContainer.addComponent(getComponent(PluginDescriptorCache.class, "ide"),
            PluginDescriptorCache.class.getName());
    myContainer.addComponent(getComponent(ModelInterpolator.class, "ide"), ModelInterpolator.class.getName());
    myContainer.addComponent(//from   w  w w  . j  a  v a2  s. co m
            getComponent(org.apache.maven.project.interpolation.ModelInterpolator.class, "ide"),
            org.apache.maven.project.interpolation.ModelInterpolator.ROLE);
}

---

From source file:org.maven.ide.eclipse.embedder.EmbedderFactory.java

License:Apache License

public static ContainerCustomizer createWorkspaceCustomizer(final boolean resolveWorkspaceProjects) {
    return new ContainerCustomizer() {
        public void customize(PlexusContainer container) {
            // desc = plexusContainer.getComponentDescriptor(ArtifactFactory.ROLE);
            // desc.setImplementation(org.maven.ide.eclipse.embedder.EclipseArtifactFactory.class.getName());

            // Used for building hierarchy of dependencies
            // desc = container.getComponentDescriptor(ResolutionListener.ROLE);
            // if(desc == null) {
            //   desc = new ComponentDescriptor();
            //   desc.setRole(ResolutionListener.ROLE);
            //   container.addComponentDescriptor(desc);
            // }//from  www .ja  v a  2  s .c  o m
            // desc.setImplementation(EclipseResolutionListener.class.getName());

            // Custom artifact resolver for resolving artifacts from Eclipse Worspace
            if (resolveWorkspaceProjects) {
                ComponentDescriptor resolverDescriptor = container
                        .getComponentDescriptor(ArtifactResolver.ROLE);
                // ComponentRequirement requirement = new ComponentRequirement();
                // requirement.setRole(ResolutionListener.ROLE);
                // desc.addRequirement(requirement);
                resolverDescriptor.setImplementation(EclipseArtifactResolver.class.getName());
            }

            //          desc = container.getComponentDescriptor(WagonManager.ROLE);
            //          desc.setImplementation(EclipseWagonManager.class.getName());
        }
    };
}

---

From source file:org.nuxeo.build.maven.MavenEmbedder.java

License:Open Source License

public void start() throws MavenEmbedderException {
    detectUserInstallation();// w ww.j  a v a 2s. c  o  m

    // ----------------------------------------------------------------------
    // Set the maven.home system property which is need by components like
    // the plugin registry builder.
    // ----------------------------------------------------------------------

    if (classLoader == null) {
        throw new IllegalStateException("A classloader must be specified using setClassLoader(ClassLoader).");
    }

    embedder = new Embedder();

    if (logger != null) {
        embedder.setLoggerManager(new MavenEmbedderLoggerManager(new PlexusLoggerAdapter(logger)));
    }

    try {
        ClassWorld classWorld = new ClassWorld();

        classWorld.newRealm("plexus.core", classLoader);

        embedder.start(classWorld);

        // ----------------------------------------------------------------------
        // Lookup each of the components we need to provide the desired
        // client interface.
        // ----------------------------------------------------------------------

        modelReader = new MavenXpp3Reader();

        modelWriter = new MavenXpp3Writer();

        pluginDescriptorBuilder = new PluginDescriptorBuilder();

        profileManager = new DefaultProfileManager(embedder.getContainer(), (Properties) null);

        mavenProjectBuilder = (MavenProjectBuilder) embedder.lookup(MavenProjectBuilder.ROLE);

        // ----------------------------------------------------------------------
        // Artifact related components
        // ----------------------------------------------------------------------

        artifactRepositoryFactory = (ArtifactRepositoryFactory) embedder.lookup(ArtifactRepositoryFactory.ROLE);

        artifactFactory = (ArtifactFactory) embedder.lookup(ArtifactFactory.ROLE);

        artifactResolver = (ArtifactResolver) embedder.lookup(ArtifactResolver.ROLE);

        artifactMetadataSource = (ArtifactMetadataSource) embedder.lookup(ArtifactMetadataSource.ROLE);

        defaultArtifactRepositoryLayout = (ArtifactRepositoryLayout) embedder
                .lookup(ArtifactRepositoryLayout.ROLE, DEFAULT_LAYOUT_ID);

        lifecycleExecutor = (LifecycleExecutor) embedder.lookup(LifecycleExecutor.ROLE);

        wagonManager = (WagonManager) embedder.lookup(WagonManager.ROLE);

        createMavenSettings();

        profileManager.loadSettingsProfiles(settings);

        localRepository = createLocalRepository();
    } catch (PlexusContainerException e) {
        throw new MavenEmbedderException("Cannot start Plexus embedder.", e);
    } catch (DuplicateRealmException e) {
        throw new MavenEmbedderException("Cannot create Classworld realm for the embedder.", e);
    } catch (ComponentLookupException e) {
        throw new MavenEmbedderException("Cannot lookup required component.", e);
    }
}

---