private Set<ResolvedArtifact> getArtifacts(ConfigurationNode childConfiguration) { String[] targetConfigurations = from.metaData.getHierarchy().toArray(new String[from.metaData.getHierarchy().size()]); DependencyArtifactDescriptor[] dependencyArtifacts = dependencyDescriptor.getDependencyArtifacts(targetConfigurations); if (dependencyArtifacts.length == 0) { return Collections.emptySet(); } Set<ResolvedArtifact> artifacts = new LinkedHashSet<ResolvedArtifact>(); for (DependencyArtifactDescriptor artifactDescriptor : dependencyArtifacts) { ModuleRevisionId id = childConfiguration.moduleRevision.metaData.getDescriptor().getModuleRevisionId(); Artifact artifact = new DefaultArtifact( id, null, artifactDescriptor.getName(), artifactDescriptor.getType(), artifactDescriptor.getExt(), artifactDescriptor.getUrl(), artifactDescriptor.getQualifiedExtraAttributes()); artifacts.add( resolveState.builder.newArtifact( childConfiguration.getResult(), artifact, targetModuleRevision.resolve().getArtifactResolver())); } return artifacts; }
public void visitOutgoingDependencies(Collection<DependencyEdge> target) { // If this configuration's version is in conflict, don't do anything // If not traversed before, add all selected outgoing edges // If traversed before, and the selected modules have changed, remove previous outgoing edges // and add outgoing edges again with // the new selections. // If traversed before, and the selected modules have not changed, ignore // If none of the incoming edges are transitive, then the node has no outgoing edges if (moduleRevision.state != ModuleState.Selected) { LOGGER.debug("version for {} is not selected. ignoring.", this); return; } List<DependencyEdge> transitiveIncoming = new ArrayList<DependencyEdge>(); for (DependencyEdge edge : incomingEdges) { if (edge.isTransitive()) { transitiveIncoming.add(edge); } } if (transitiveIncoming.isEmpty() && this != resolveState.root) { if (previousTraversal != null) { removeOutgoingEdges(); } if (incomingEdges.isEmpty()) { LOGGER.debug("{} has no incoming edges. ignoring.", this); } else { LOGGER.debug("{} has no transitive incoming edges. ignoring outgoing edges.", this); } return; } ModuleResolutionFilter resolutionFilter = getSelector(transitiveIncoming); if (previousTraversal != null) { if (previousTraversal.acceptsSameModulesAs(resolutionFilter)) { LOGGER.debug( "Changed edges for {} selects same versions as previous traversal. ignoring", this); // Don't need to traverse again, but hang on to the new filter as the set of artifact may // have changed previousTraversal = resolutionFilter; return; } removeOutgoingEdges(); } for (DependencyMetaData dependency : metaData.getDependencies()) { ModuleIdentifier targetModuleId = DefaultModuleIdentifier.newId( dependency.getRequested().getGroup(), dependency.getRequested().getName()); if (isExcluded(resolutionFilter, targetModuleId)) { continue; } DependencyEdge dependencyEdge = new DependencyEdge(this, dependency, resolutionFilter, resolveState); outgoingEdges.add(dependencyEdge); target.add(dependencyEdge); } previousTraversal = resolutionFilter; }
public Set<File> getFiles(Spec<Dependency> dependencySpec) { rethrowFailure(); Set<ModuleDependency> allDependencies = configuration.getAllDependencies(ModuleDependency.class); Set<ModuleDependency> selectedDependencies = Specs.filterIterable(allDependencies, dependencySpec); Set<ResolvedArtifact> artifacts = new LinkedHashSet<ResolvedArtifact>(); for (ModuleDependency moduleDependency : selectedDependencies) { Set<ResolvedDependency> resolvedDependencies = conversionResult.getFirstLevelResolvedDependencies().get(moduleDependency); for (ResolvedDependency resolvedDependency : resolvedDependencies) { artifacts.addAll(resolvedDependency.getParentArtifacts(conversionResult.getRoot())); walker.add(resolvedDependency); } } artifacts.addAll(walker.findValues()); Set<File> files = new LinkedHashSet<File>(); for (ResolvedArtifact artifact : artifacts) { File depFile = artifact.getFile(); if (depFile != null) { files.add(depFile); } else { logger.debug(String.format("Resolved artifact %s contains a null value.", artifact)); } } return files; }
/** * Called when a change is made to a configuration node, such that its dependency graph * <em>may</em> now be larger than it previously was, and the node should be visited. */ public void onMoreSelected(ConfigurationNode configuration) { // Add to the end of the queue, so that we traverse the graph in breadth-wise order to pick up // as many conflicts as // possible before attempting to resolve them if (queued.add(configuration)) { queue.addLast(configuration); } }
public void visitOutgoingDependencies(Collection<DependencyEdge> target) { // If this configuration's version is in conflict, don't do anything // If not traversed before, add all selected outgoing edges // If traversed before, and the selected modules have changed, remove previous outgoing edges // and add outgoing edges again with // the new selections. // If traversed before, and the selected modules have not changed, ignore // If none of the incoming edges are transitive, then the node has no outgoing edges if (moduleRevision.state != ModuleState.Selected) { LOGGER.debug("version for {} is not selected. ignoring.", this); return; } List<DependencyEdge> transitiveIncoming = new ArrayList<DependencyEdge>(); for (DependencyEdge edge : incomingEdges) { if (edge.isTransitive()) { transitiveIncoming.add(edge); } } if (transitiveIncoming.isEmpty() && this != resolveState.root) { if (previousTraversal != null) { removeOutgoingEdges(); } if (incomingEdges.isEmpty()) { LOGGER.debug("{} has no incoming edges. ignoring.", this); } else { LOGGER.debug("{} has no transitive incoming edges. ignoring outgoing edges.", this); } return; } ModuleVersionSpec selectorSpec = getSelector(transitiveIncoming); if (previousTraversal != null) { if (previousTraversal.acceptsSameModulesAs(selectorSpec)) { LOGGER.debug( "Changed edges for {} selects same versions as previous traversal. ignoring", this); return; } removeOutgoingEdges(); } for (DependencyMetaData dependency : metaData.getDependencies()) { DependencyDescriptor dependencyDescriptor = dependency.getDescriptor(); ModuleId targetModuleId = dependencyDescriptor.getDependencyRevisionId().getModuleId(); if (!selectorSpec.isSatisfiedBy(targetModuleId)) { LOGGER.debug("{} is excluded from {}.", targetModuleId, this); continue; } DependencyEdge dependencyEdge = new DependencyEdge(this, dependency, selectorSpec, resolveState); outgoingEdges.add(dependencyEdge); target.add(dependencyEdge); } previousTraversal = selectorSpec; }
public Set<ResolvedArtifact> getArtifacts() { if (artifacts == null) { artifacts = new LinkedHashSet<ResolvedArtifact>(); for (Artifact artifact : metaData.getArtifacts()) { artifacts.add( resolveState.builder.newArtifact( getResult(), artifact, moduleRevision.resolve().getArtifactResolver())); } } return artifacts; }
/** * Traverses the dependency graph, resolving conflicts and building the paths from the root * configuration. */ private void traverseGraph(ResolveState resolveState) { Set<ModuleIdentifier> conflicts = new LinkedHashSet<ModuleIdentifier>(); resolveState.onMoreSelected(resolveState.root); List<DependencyEdge> dependencies = new ArrayList<DependencyEdge>(); while (resolveState.peek() != null || !conflicts.isEmpty()) { if (resolveState.peek() != null) { ConfigurationNode node = resolveState.pop(); LOGGER.debug("Visiting configuration {}.", node); // Calculate the outgoing edges of this configuration dependencies.clear(); node.visitOutgoingDependencies(dependencies); for (DependencyEdge dependency : dependencies) { LOGGER.debug("Visiting dependency {}", dependency); // Resolve dependency to a particular revision ModuleVersionResolveState moduleRevision = dependency.resolveModuleRevisionId(); if (moduleRevision == null) { // Failed to resolve. continue; } ModuleIdentifier moduleId = moduleRevision.id.getModule(); // Check for a new conflict if (moduleRevision.state == ModuleState.New) { ModuleResolveState module = resolveState.getModule(moduleId); // A new module revision. Check for conflict Collection<ModuleVersionResolveState> versions = module.getVersions(); if (versions.size() == 1) { // First version of this module. Select it for now LOGGER.debug("Selecting new module version {}", moduleRevision); module.select(moduleRevision); } else { // Not the first version of this module. We have a new conflict LOGGER.debug("Found new conflicting module version {}", moduleRevision); conflicts.add(moduleId); // Deselect the currently selected version, and remove all outgoing edges from the // version // This will propagate through the graph and prune configurations that are no longer // required ModuleVersionResolveState previouslySelected = module.clearSelection(); if (previouslySelected != null) { for (ConfigurationNode configuration : previouslySelected.configurations) { configuration.removeOutgoingEdges(); } } } } dependency.attachToTargetConfigurations(); } } else { // We have some batched up conflicts. Resolve the first, and continue traversing the graph ModuleIdentifier moduleId = conflicts.iterator().next(); conflicts.remove(moduleId); ModuleResolveState module = resolveState.getModule(moduleId); ModuleVersionResolveState selected = conflictResolver.select(module.getVersions(), resolveState.root.moduleRevision); LOGGER.debug("Selected {} from conflicting modules {}.", selected, module.getVersions()); // Restart each configuration. For the evicted configuration, this means moving incoming // dependencies across to the // matching selected configuration. For the select configuration, this mean traversing its // dependencies. module.restart(selected); } } }
public void addIncomingEdge(DependencyEdge dependencyEdge) { incomingEdges.add(dependencyEdge); resolveState.onMoreSelected(this); }
public void addConfiguration(ConfigurationNode configurationNode) { configurations.add(configurationNode); }
public void addUnattachedDependency(DependencyEdge edge) { unattachedDependencies.add(edge); }
/** * Called when a change is made to a configuration node, such that its dependency graph * <em>may</em> now be smaller than it previously was, and the node should be visited. */ public void onFewerSelected(ConfigurationNode configuration) { // Add to the front of the queue, to flush out configurations that are no longer required. if (queued.add(configuration)) { queue.addFirst(configuration); } }
private Collection<List<ModuleVersionIdentifier>> calculatePaths( BrokenDependency brokenDependency) { // Include the shortest path from each version that has a direct dependency on the broken // dependency, back to the root Map<ModuleVersionResolveState, List<ModuleVersionIdentifier>> shortestPaths = new LinkedHashMap<ModuleVersionResolveState, List<ModuleVersionIdentifier>>(); List<ModuleVersionIdentifier> rootPath = new ArrayList<ModuleVersionIdentifier>(); rootPath.add(root.moduleRevision.id); shortestPaths.put(root.moduleRevision, rootPath); Set<ModuleVersionResolveState> directDependees = new LinkedHashSet<ModuleVersionResolveState>(); for (ConfigurationNode node : brokenDependency.requiredBy) { directDependees.add(node.moduleRevision); } Set<ModuleVersionResolveState> seen = new HashSet<ModuleVersionResolveState>(); LinkedList<ModuleVersionResolveState> queue = new LinkedList<ModuleVersionResolveState>(); queue.addAll(directDependees); while (!queue.isEmpty()) { ModuleVersionResolveState version = queue.getFirst(); if (version == root.moduleRevision) { queue.removeFirst(); } else if (seen.add(version)) { for (ConfigurationNode configuration : version.configurations) { for (DependencyEdge dependencyEdge : configuration.incomingEdges) { queue.add(0, dependencyEdge.from.moduleRevision); } } } else { queue.remove(); List<ModuleVersionIdentifier> shortest = null; for (ConfigurationNode configuration : version.configurations) { for (DependencyEdge dependencyEdge : configuration.incomingEdges) { List<ModuleVersionIdentifier> candidate = shortestPaths.get(dependencyEdge.from.moduleRevision); if (candidate == null) { continue; } if (shortest == null) { shortest = candidate; } else if (shortest.size() > candidate.size()) { shortest = candidate; } } } if (shortest == null) { continue; } List<ModuleVersionIdentifier> path = new ArrayList<ModuleVersionIdentifier>(); path.addAll(shortest); path.add(version.id); shortestPaths.put(version, path); } } List<List<ModuleVersionIdentifier>> paths = new ArrayList<List<ModuleVersionIdentifier>>(); for (ModuleVersionResolveState version : directDependees) { List<ModuleVersionIdentifier> path = shortestPaths.get(version); paths.add(path); } return paths; }
public void addSelector(ModuleVersionSelectorResolveState selector) { selectors.add(selector); }