public void removeFromTargetConfigurations() { for (ConfigurationNode targetConfiguration : targetConfigurations) { targetConfiguration.removeIncomingEdge(this); } targetConfigurations.clear(); if (targetModuleRevision != null) { selector.getSelectedModule().removeUnattachedDependency(this); } }
public void validate() { for (DependencyEdge incomingEdge : incomingEdges) { ConfigurationNode fromNode = incomingEdge.from; if (!fromNode.isSelected()) { throw new IllegalStateException( String.format( "Unexpected state %s for parent node for dependency from %s to %s.", fromNode.moduleRevision.state, fromNode, this)); } } }
public void attachToTargetConfigurations() { if (targetModuleRevision.state != ModuleState.Selected) { return; } calculateTargetConfigurations(); for (ConfigurationNode targetConfiguration : targetConfigurations) { targetConfiguration.addIncomingEdge(this); } if (!targetConfigurations.isEmpty()) { selector.getSelectedModule().removeUnattachedDependency(this); } }
@Override public String toString() { return String.format( "%s -> %s(%s)", from.toString(), dependencyMetaData.getRequested(), Joiner.on(',').join(dependencyMetaData.getModuleConfigurations())); }
/** Populates the result from the graph traversal state. */ private void assembleResult(ResolveState resolveState, DependencyGraphVisitor listener) { listener.start(resolveState.root); // Visit the nodes for (ConfigurationNode resolvedConfiguration : resolveState.getConfigurationNodes()) { if (resolvedConfiguration.isSelected()) { resolvedConfiguration.validate(); listener.visitNode(resolvedConfiguration); } } // Visit the edges for (ConfigurationNode resolvedConfiguration : resolveState.getConfigurationNodes()) { if (resolvedConfiguration.isSelected()) { listener.visitEdge(resolvedConfiguration); } } listener.finish(resolveState.root); }
public void restart(ModuleVersionResolveState selected) { for (ConfigurationNode configuration : configurations) { configuration.restart(selected); } }
public boolean isTransitive() { return from.isTransitive() && dependencyMetaData.isTransitive(); }
/** * Traverses the dependency graph, resolving conflicts and building the paths from the root * configuration. */ private void traverseGraph( final ResolveState resolveState, final ConflictHandler conflictHandler) { resolveState.onMoreSelected(resolveState.root); List<DependencyEdge> dependencies = new ArrayList<DependencyEdge>(); while (resolveState.peek() != null || conflictHandler.hasConflicts()) { 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 PotentialConflict c = conflictHandler.registerModule(module); if (!c.conflictExists()) { // No conflict. Select it for now LOGGER.debug("Selecting new module version {}", moduleRevision); module.select(moduleRevision); } else { // We have a conflict LOGGER.debug("Found new conflicting module version {}", moduleRevision); // 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 // For each module participating in the conflict (many times there is only one // participating module that has multiple versions) c.withParticipatingModules( new Action<ModuleIdentifier>() { public void execute(ModuleIdentifier module) { ModuleVersionResolveState previouslySelected = resolveState.getModule(module).clearSelection(); if (previouslySelected != null) { for (ConfigurationNode configuration : previouslySelected.configurations) { configuration.deselect(); } } } }); } } dependency.attachToTargetConfigurations(); } } else { // We have some batched up conflicts. Resolve the first, and continue traversing the graph conflictHandler.resolveNextConflict( new Action<ConflictResolutionResult>() { public void execute(final ConflictResolutionResult result) { result .getConflict() .withParticipatingModules( new Action<ModuleIdentifier>() { public void execute(ModuleIdentifier moduleIdentifier) { ModuleVersionResolveState selected = result.getSelected(); // 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. resolveState.getModule(moduleIdentifier).restart(selected); } }); } }); } } }