Example usage for org.apache.maven.artifact.resolver ResolutionListener OMIT_FOR

Introduction

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

Prototype

int OMIT_FOR_CYCLE

To view the source code for org.apache.maven.artifact.resolver ResolutionListener OMIT_FOR_CYCLE.

Click Source Link

Usage

From source file:com.adviser.maven.GraphArtifactCollector.java

License:Apache License

private void recurse(ResolutionNode node, Map resolvedArtifacts, Map managedVersions,
        ArtifactRepository localRepository, List remoteRepositories, ArtifactMetadataSource source,
        ArtifactFilter filter, List listeners)
        throws CyclicDependencyException, ArtifactResolutionException, OverConstrainedVersionException {
    fireEvent(ResolutionListener.TEST_ARTIFACT, listeners, node);

    // TODO: use as a conflict resolver
    Object key = node.getKey();/*  w ww  .jav a 2 s.  c o m*/
    if (managedVersions.containsKey(key)) {
        Artifact artifact = (Artifact) managedVersions.get(key);
        fireEvent(ResolutionListener.MANAGE_ARTIFACT, listeners, node, artifact);
        if (artifact.getVersion() != null) {
            node.getArtifact().setVersion(artifact.getVersion());
        }
        if (artifact.getScope() != null) {
            node.getArtifact().setScope(artifact.getScope());
        }
    }

    List previousNodes = (List) resolvedArtifacts.get(key);
    if (previousNodes != null) {
        node = checkPreviousNodes(node, listeners, previousNodes);
    } else {
        previousNodes = new ArrayList();
        resolvedArtifacts.put(key, previousNodes);
    }
    previousNodes.add(node);

    if (node.isActive()) {
        fireEvent(ResolutionListener.INCLUDE_ARTIFACT, listeners, node);
    }

    // don't pull in the transitive deps of a system-scoped dependency.
    if (node.isActive() && !Artifact.SCOPE_SYSTEM.equals(node.getArtifact().getScope())) {
        fireEvent(ResolutionListener.PROCESS_CHILDREN, listeners, node);
        for (Iterator i = node.getChildrenIterator(); i.hasNext();) {
            ResolutionNode child = (ResolutionNode) i.next();
            // We leave in optional ones, but don't pick up its dependencies
            if (!child.isResolved() && (!child.getArtifact().isOptional() || child.isChildOfRootNode())) {
                Artifact artifact = child.getArtifact();
                try {
                    if (artifact.getVersion() == null) {
                        // set the recommended version
                        // TODO: maybe its better to just pass the range
                        // through to retrieval and use a transformation?
                        ArtifactVersion version;
                        version = getArtifactVersion(localRepository, remoteRepositories, source, artifact);

                        artifact.selectVersion(version.toString());
                        fireEvent(ResolutionListener.SELECT_VERSION_FROM_RANGE, listeners, child);
                    }

                    ResolutionGroup rGroup = source.retrieve(artifact, localRepository, remoteRepositories);

                    // TODO might be better to have source.retreive() throw
                    // a specific exception for this situation
                    // and catch here rather than have it return null
                    if (rGroup == null) {
                        // relocated dependency artifact is declared
                        // excluded, no need to add and recurse further
                        continue;
                    }

                    child.addDependencies(rGroup.getArtifacts(), rGroup.getResolutionRepositories(), filter);
                } catch (CyclicDependencyException e) {
                    // would like to throw this, but we have crappy stuff in
                    // the repo

                    fireEvent(ResolutionListener.OMIT_FOR_CYCLE, listeners,
                            new ResolutionNode(e.getArtifact(), remoteRepositories, child));
                } catch (ArtifactMetadataRetrievalException e) {
                    artifact.setDependencyTrail(node.getDependencyTrail());
                    throw new ArtifactResolutionException(
                            "Unable to get dependency information: " + e.getMessage(), artifact, e);
                }

                recurse(child, resolvedArtifacts, managedVersions, localRepository, remoteRepositories, source,
                        filter, listeners);
            }
        }
        fireEvent(ResolutionListener.FINISH_PROCESSING_CHILDREN, listeners, node);
    }
}

From source file:com.adviser.maven.GraphArtifactCollector.java

License:Apache License

private void fireEvent(int event, List listeners, ResolutionNode node, Artifact replacement,
        VersionRange newRange) {//from w  w w .j  av  a 2  s.  co  m
    for (Iterator i = listeners.iterator(); i.hasNext();) {
        ResolutionListener listener = (ResolutionListener) i.next();

        switch (event) {
        case ResolutionListener.TEST_ARTIFACT:
            listener.testArtifact(node.getArtifact());
            break;
        case ResolutionListener.PROCESS_CHILDREN:
            listener.startProcessChildren(node.getArtifact());
            break;
        case ResolutionListener.FINISH_PROCESSING_CHILDREN:
            listener.endProcessChildren(node.getArtifact());
            break;
        case ResolutionListener.INCLUDE_ARTIFACT:
            listener.includeArtifact(node.getArtifact());
            break;
        case ResolutionListener.OMIT_FOR_NEARER:
            String version = node.getArtifact().getVersion();
            String replacementVersion = replacement.getVersion();
            if (version != null ? !version.equals(replacementVersion) : replacementVersion != null) {
                listener.omitForNearer(node.getArtifact(), replacement);
            }
            break;
        case ResolutionListener.OMIT_FOR_CYCLE:
            listener.omitForCycle(node.getArtifact());
            break;
        case ResolutionListener.UPDATE_SCOPE:
            listener.updateScope(node.getArtifact(), replacement.getScope());
            break;
        case ResolutionListener.UPDATE_SCOPE_CURRENT_POM:
            listener.updateScopeCurrentPom(node.getArtifact(), replacement.getScope());
            break;
        case ResolutionListener.MANAGE_ARTIFACT:
            listener.manageArtifact(node.getArtifact(), replacement);
            break;
        case ResolutionListener.SELECT_VERSION_FROM_RANGE:
            listener.selectVersionFromRange(node.getArtifact());
            break;
        case ResolutionListener.RESTRICT_RANGE:
            if (node.getArtifact().getVersionRange().hasRestrictions()
                    || replacement.getVersionRange().hasRestrictions()) {
                listener.restrictRange(node.getArtifact(), replacement, newRange);
            }
            break;
        default:
            throw new IllegalStateException("Unknown event: " + event);
        }
    }
}

From source file:org.universAAL.maven.treebuilder.DependencyTreeBuilder.java

License:Apache License

/**
 * FireEvent methods are used for sending events related resolution process
 * to the listeners passed as arguments.
 * //from w  ww .  j  a  va  2  s . c  om
 * @param event
 *            Integer value of the event.
 * @param listener
 *            Listener which will be notified about the event.
 * @param node
 *            Node related to the event.
 * @param replacement
 *            Node which will replace the one passed in the previous
 *            argument.
 * @param newRange
 *            A new range which will be applied in case of RESTRICT_RANGE
 *            event.
 */
private void fireEvent(final int event, final DependencyTreeResolutionListener listener,
        final ResolutionNode node, final ResolutionNode replacement, final VersionRange newRange) {
    switch (event) {
    case ResolutionListener.TEST_ARTIFACT:
        listener.testArtifact(node.getArtifact());
        break;
    case ResolutionListener.PROCESS_CHILDREN:
        listener.startProcessChildren(node.getArtifact());
        break;
    case ResolutionListener.FINISH_PROCESSING_CHILDREN:
        listener.endProcessChildren(node.getArtifact());
        break;
    case ResolutionListener.INCLUDE_ARTIFACT:
        listener.includeArtifact(node);
        break;
    case ResolutionListener.OMIT_FOR_NEARER:
        listener.omitForNearer(node, replacement);
        break;
    case ResolutionListener.OMIT_FOR_CYCLE:
        listener.omitForCycle(node);
        break;
    case ResolutionListener.UPDATE_SCOPE:
        listener.updateScope(node, replacement.getArtifact().getScope());
        break;
    case ResolutionListener.UPDATE_SCOPE_CURRENT_POM:
        listener.updateScopeCurrentPom(node, replacement.getArtifact().getScope());
        break;
    case ResolutionListener.MANAGE_ARTIFACT_VERSION:
        if (listener instanceof ResolutionListenerForDepMgmt) {
            ResolutionListenerForDepMgmt asImpl = listener;
            asImpl.manageArtifactVersion(node.getArtifact(), replacement.getArtifact());
        } else {
            listener.manageArtifact(node.getArtifact(), replacement.getArtifact());
        }
        break;
    case ResolutionListener.MANAGE_ARTIFACT_SCOPE:
        if (listener instanceof ResolutionListenerForDepMgmt) {
            ResolutionListenerForDepMgmt asImpl = listener;
            asImpl.manageArtifactScope(node.getArtifact(), replacement.getArtifact());
        } else {
            listener.manageArtifact(node.getArtifact(), replacement.getArtifact());
        }
        break;
    case ResolutionListener.SELECT_VERSION_FROM_RANGE:
        listener.selectVersionFromRange(node.getArtifact());
        break;
    case ResolutionListener.RESTRICT_RANGE:
        if (node.getArtifact().getVersionRange().hasRestrictions()
                || replacement.getArtifact().getVersionRange().hasRestrictions()) {
            listener.restrictRange(node.getArtifact(), replacement.getArtifact(), newRange);
        }
        break;
    default:
        throw new IllegalStateException("Unknown event: " + event);
    }
}

From source file:org.universAAL.maven.treebuilder.DependencyTreeBuilder.java

License:Apache License

/**
 * Method resolves provided node with the use of provided
 * ArtifactMetadataSource and taking into account ManagedVersionMap. Output
 * is passed to listeners, passed as argument, which are notified about all
 * events related to dependencies detected in the tree.
 * //w w w  . j a v a2s  . c  o m
 * @param parentNode
 *            Parent node
 * @param child
 *            Child node
 * @param filter
 *            Filter for filtering artifacts for the resolving process.
 * @param managedVersions
 *            Map of managed versions.
 * @param listener
 *            Listener to be notified about events related to resolution
 *            process.
 * @param source
 *            ArtifactMetadataSource object passed by maven.
 * @param parentArtifact
 *            Parent artifact
 * @return returns true if the child should be recursively resolved.
 * @throws OverConstrainedVersionException
 *             Occurs when ranges exclude each other and no valid value
 *             remains.
 * @throws ArtifactMetadataRetrievalException
 *             Error while retrieving repository metadata from the
 *             repository
 */
private boolean resolveChildNode(final ResolutionNode parentNode, final ResolutionNode child,
        final ArtifactFilter filter, final ManagedVersionMap managedVersions,
        final DependencyTreeResolutionListener listener, final ArtifactMetadataSource source,
        final Artifact parentArtifact)
        throws OverConstrainedVersionException, ArtifactMetadataRetrievalException {
    // We leave in optional ones, but don't pick up its dependencies
    if (!child.isResolved() && (!child.getArtifact().isOptional() || child.isChildOfRootNode())) {
        Artifact artifact = child.getArtifact();
        artifact.setDependencyTrail(parentNode.getDependencyTrail());

        List childRemoteRepositories = child.getRemoteRepositories();
        try {
            Object childKey;
            do {
                childKey = child.getKey();

                if (managedVersions.containsKey(childKey)) {
                    // If this child node is a managed dependency,
                    // ensure
                    // we are using the dependency management
                    // version
                    // of this child if applicable b/c we want to
                    // use the
                    // managed version's POM, *not* any other
                    // version's POM.
                    // We retrieve the POM below in the retrieval
                    // step.
                    manageArtifact(child, managedVersions);

                    // Also, we need to ensure that any exclusions
                    // it presents are
                    // added to the artifact before we retrieve the
                    // metadata
                    // for the artifact; otherwise we may end up
                    // with unwanted
                    // dependencies.
                    Artifact ma = (Artifact) managedVersions.get(childKey);
                    ArtifactFilter managedExclusionFilter = ma.getDependencyFilter();
                    if (null != managedExclusionFilter) {
                        if (null != artifact.getDependencyFilter()) {
                            AndArtifactFilter aaf = new AndArtifactFilter();
                            aaf.add(artifact.getDependencyFilter());
                            aaf.add(managedExclusionFilter);
                            artifact.setDependencyFilter(aaf);
                        } else {
                            artifact.setDependencyFilter(managedExclusionFilter);
                        }
                    }
                }

                if (artifact.getVersion() == null) {
                    // set the recommended version
                    // TODO: maybe its better to just pass the range
                    // through to retrieval and use a
                    // transformation?
                    ArtifactVersion version;
                    if (artifact.isSelectedVersionKnown()) {
                        version = artifact.getSelectedVersion();
                    } else {
                        // go find the version
                        List versions = artifact.getAvailableVersions();
                        if (versions == null) {
                            versions = source.retrieveAvailableVersions(artifact, localRepository,
                                    childRemoteRepositories);
                            artifact.setAvailableVersions(versions);
                        }

                        Collections.sort(versions);

                        VersionRange versionRange = artifact.getVersionRange();

                        version = versionRange.matchVersion(versions);

                        if (version == null) {
                            if (versions.isEmpty()) {
                                throw new OverConstrainedVersionException(
                                        "No versions are present in the repository for the artifact with a range "
                                                + versionRange,
                                        artifact, childRemoteRepositories);
                            }

                            throw new OverConstrainedVersionException("Couldn't find a version in " + versions
                                    + " to match range " + versionRange, artifact, childRemoteRepositories);
                        }
                    }

                    // this is dangerous because
                    // artifact.getSelectedVersion() can
                    // return null. However it is ok here because we
                    // first check if the
                    // selected version is known. As currently coded
                    // we can't get a null here.
                    artifact.selectVersion(version.toString());
                    fireEvent(ResolutionListener.SELECT_VERSION_FROM_RANGE, listener, child);
                }

                // rotgier: it is not compatible with maven 3
                // Artifact relocated = source.retrieveRelocatedArtifact(
                // artifact, localRepository, childRemoteRepositories);
                // if (relocated != null && !artifact.equals(relocated)) {
                // relocated.setDependencyFilter(artifact
                // .getDependencyFilter());
                // artifact = relocated;
                // child.setArtifact(artifact);
                // }
            } while (!childKey.equals(child.getKey()));

            if (parentArtifact != null && parentArtifact.getDependencyFilter() != null
                    && !parentArtifact.getDependencyFilter().include(artifact)) {
                // MNG-3769: the [probably relocated] artifact is
                // excluded.
                // We could process exclusions on relocated artifact
                // details in the
                // MavenMetadataSource.createArtifacts(..) step, BUT
                // that would
                // require resolving the POM from the repository
                // very early on in
                // the build.
                return true;
            }

            ResolutionGroup rGroup = source.retrieve(artifact, localRepository, childRemoteRepositories);

            // TODO might be better to have source.retrieve() throw
            // a specific exception for this situation
            // and catch here rather than have it return null
            if (rGroup == null) {
                // relocated dependency artifact is declared
                // excluded, no need to add and recurse further
                return true;
            }
            child.addDependencies(rGroup.getArtifacts(), rGroup.getResolutionRepositories(), filter);

        } catch (CyclicDependencyException e) {
            // would like to throw this, but we have crappy stuff in
            // the repo

            fireEvent(ResolutionListener.OMIT_FOR_CYCLE, listener,
                    new ResolutionNode(e.getArtifact(), childRemoteRepositories, child));
        } catch (ArtifactMetadataRetrievalException e) {
            artifact.setDependencyTrail(parentNode.getDependencyTrail());
            throw e;
        }
    } else {
        return true;
    }
    return false;
}

Example usage for org.apache.maven.artifact.resolver ResolutionListener OMIT_FOR_CYCLE

Introduction

Prototype

Usage