private ArtifactResult findDependencies( RepositoryManager manager, Node node, Boolean fetchSingleArtifact) { final ArtifactContext ac = ArtifactContext.fromNode(node); if (ac == null) return null; final String name = ac.getName(); String[] groupArtifactIds = nameToGroupArtifactIds(name); if (groupArtifactIds == null) { return null; } final String groupId = groupArtifactIds[0]; final String artifactId = groupArtifactIds[1]; final String version = ac.getVersion(); String repositoryDisplayString = NodeUtils.getRepositoryDisplayString(node); CmrRepository repository = NodeUtils.getRepository(node); if (CeylonUtils.arrayContains(ac.getSuffixes(), ArtifactContext.LEGACY_SRC)) { return fetchWithClassifier( repository, groupId, artifactId, version, "sources", repositoryDisplayString); } return fetchDependencies( manager, repository, groupId, artifactId, version, fetchSingleArtifact != null ? fetchSingleArtifact : ac.isIgnoreDependencies(), repositoryDisplayString); }
protected ArtifactResult createArtifactResult( RepositoryManager manager, CmrRepository repository, final ArtifactContext dCo, String version, final boolean shared, boolean optional, final String repositoryDisplayString) { String[] groupArtifactIds = nameToGroupArtifactIds(dCo.getName()); if (groupArtifactIds == null) return createArtifactResult( manager, dCo.getName(), version, shared, optional, repositoryDisplayString); return createArtifactResult( manager, repository, groupArtifactIds[0], groupArtifactIds[1], version, shared, optional, repositoryDisplayString); }
void loadModule( String name, String version, boolean optional, boolean inCurrentClassLoader, ModuleGraph.Module dependent) throws IOException { ArtifactContext artifactContext = new ArtifactContext(name, version, ArtifactContext.CAR, ArtifactContext.JAR); Overrides overrides = repositoryManager.getOverrides(); if (overrides != null) { if (overrides.isRemoved(artifactContext)) return; ArtifactContext replacement = overrides.replace(artifactContext); if (replacement != null) { artifactContext = replacement; name = replacement.getName(); version = replacement.getVersion(); } if (overrides.isVersionOverridden(artifactContext)) { version = overrides.getVersionOverride(artifactContext); artifactContext.setVersion(version); } } // skip JDK modules if (JDKUtils.isJDKModule(name) || JDKUtils.isOracleJDKModule(name)) return; ModuleGraph.Module loadedModule = moduleGraph.findModule(name); if (loadedModule != null) { String loadedVersion = loadedModule.version; // we loaded the module already, but did we load it with the same version? if (!Objects.equals(version, loadedVersion)) { if (MavenVersionComparator.compareVersions(version, loadedModule.version) > 0) { // we want a newer version, keep going if (verbose) log("Replacing " + loadedModule + " with newer version " + version); } else { // we want an older version, just keep the one we have and ignore that addDependency(dependent, loadedModule); // already resolved and same version, we're good return; } } else if (loadedModule.artifact == null) { // now we're sure the version was the same // it was resolved to null so it was optional, but perhaps it's required now? if (!optional) { throw new ModuleNotFoundException( "Could not find module: " + ModuleUtil.makeModuleName(name, version)); } addDependency(dependent, loadedModule); // already resolved and same version, we're good return; } else { addDependency(dependent, loadedModule); // already resolved and same version, we're good return; } } if (verbose) log("Resolving " + name + "/" + version); ArtifactResult result = repositoryManager.getArtifactResult(artifactContext); if (!optional && (result == null || result.artifact() == null || !result.artifact().exists())) { throw new ModuleNotFoundException( "Could not find module: " + ModuleUtil.makeModuleName(name, version)); } // save even missing optional modules as nulls to not re-resolve them ModuleGraph.Module mod; if (dependent == null) mod = moduleGraph.addRoot(name, version); else mod = dependent.addDependency(name, version); if (loadedModule != null) loadedModule.replace(mod); mod.artifact = result; if (result != null) { // everything we know should be in the current class loader // plus everything from flat repositories if (inCurrentClassLoader || result.repository() instanceof FlatRepository) { mod.inCurrentClassLoader = true; } for (ArtifactResult dep : result.dependencies()) { // stop if we get removed at any point if (mod.replaced) break; loadModule( dep.name(), dep.version(), dep.importType() == ImportType.OPTIONAL, inCurrentClassLoader, mod); } } }
private void addSearchResult( String groupId, String artifactId, String version, ModuleVersionResult result, Overrides overrides, String repositoryDisplayString) throws AetherException { ArtifactOverrides artifactOverrides = null; if (overrides != null) { ArtifactContext ctx = new ArtifactContext(MavenRepository.NAMESPACE, groupId + ":" + artifactId, version); // see if this artifact is replaced ArtifactContext replaceContext = overrides.replace(ctx); if (replaceContext != null) { String[] groupArtifactIds = nameToGroupArtifactIds(replaceContext.getName()); if (groupArtifactIds == null) return; // abort groupId = groupArtifactIds[0]; artifactId = groupArtifactIds[1]; version = replaceContext.getVersion(); ctx = replaceContext; } else if (overrides.isVersionOverridden(ctx)) { // perhaps its version is overridden? version = overrides.getVersionOverride(ctx); ctx.setVersion(version); } artifactOverrides = overrides.getArtifactOverrides(ctx); } DependencyDescriptor info = impl.getDependencies(groupId, artifactId, version, null, "pom", false); if (info != null) { StringBuilder description = new StringBuilder(); StringBuilder licenseBuilder = new StringBuilder(); collectInfo(info, description, licenseBuilder); Set<ModuleDependencyInfo> dependencies = new HashSet<>(); Set<ModuleVersionArtifact> artifactTypes = new HashSet<>(); artifactTypes.add(new ModuleVersionArtifact(".jar", null, null)); Set<String> authors = new HashSet<>(); for (DependencyDescriptor dep : info.getDependencies()) { String namespace = MavenRepository.NAMESPACE; String depName = dep.getGroupId() + ":" + dep.getArtifactId(); String depVersion = dep.getVersion(); boolean export = false; boolean optional = dep.isOptional(); if (overrides != null) { ArtifactContext depCtx = new ArtifactContext(namespace, depName, dep.getVersion()); if (overrides.isRemoved(depCtx) || (artifactOverrides != null && (artifactOverrides.isRemoved(depCtx) || artifactOverrides.isAddedOrUpdated(depCtx)))) continue; ArtifactContext replaceCtx = overrides.replace(depCtx); if (replaceCtx != null) { depCtx = replaceCtx; namespace = replaceCtx.getNamespace(); depName = replaceCtx.getName(); } if (overrides.isVersionOverridden(depCtx)) depVersion = overrides.getVersionOverride(depCtx); if (artifactOverrides != null) { if (artifactOverrides.isShareOverridden(depCtx)) export = artifactOverrides.isShared(depCtx); if (artifactOverrides.isOptionalOverridden(depCtx)) optional = artifactOverrides.isOptional(depCtx); } } ModuleDependencyInfo moduleDependencyInfo = new ModuleDependencyInfo(namespace, depName, depVersion, optional, export); dependencies.add(moduleDependencyInfo); } if (artifactOverrides != null) { for (DependencyOverride add : artifactOverrides.getAdd()) { ArtifactContext ac = add.getArtifactContext(); ModuleDependencyInfo moduleDependencyInfo = new ModuleDependencyInfo( ac.getNamespace(), ac.getName(), ac.getVersion(), add.isOptional(), add.isShared()); dependencies.add(moduleDependencyInfo); } } ModuleVersionDetails moduleVersionDetails = new ModuleVersionDetails( MavenRepository.NAMESPACE, groupId + ":" + artifactId, version, description.length() > 0 ? description.toString() : null, licenseBuilder.length() > 0 ? licenseBuilder.toString() : null, authors, dependencies, artifactTypes, true, repositoryDisplayString); result.addVersion(moduleVersionDetails); } }
private ArtifactResult fetchDependencies( RepositoryManager manager, CmrRepository repository, String groupId, String artifactId, String version, boolean fetchSingleArtifact, String repositoryDisplayString) { String classifier = null; Overrides overrides = repository.getRoot().getService(Overrides.class); ArtifactOverrides ao = null; log.debug("Overrides: " + overrides); ArtifactContext context = getArtifactContext(groupId, artifactId, version, null, null); if (overrides != null) { ao = overrides.getArtifactOverrides(context); log.debug(" [" + context + "] => " + ao); } // entire replacement ArtifactContext replacementContext = null; if (ao != null && ao.getReplace() != null) { replacementContext = ao.getReplace().getArtifactContext(); } else if (overrides != null) { replacementContext = overrides.replace(context); } if (replacementContext != null) { log.debug( String.format("[Maven-Overrides] Replacing %s with %s.", context, replacementContext)); // replace fetched dependency String[] nameToGroupArtifactIds = nameToGroupArtifactIds(replacementContext.getName()); if (nameToGroupArtifactIds != null) { groupId = nameToGroupArtifactIds[0]; artifactId = nameToGroupArtifactIds[1]; version = replacementContext.getVersion(); // new AO context = getArtifactContext(groupId, artifactId, version, null, null); ao = overrides.getArtifactOverrides(context); } } // version replacement if (overrides != null && overrides.isVersionOverridden(context)) { version = overrides.getVersionOverride(context); context.setVersion(version); } // classifier replacement if (ao != null && ao.hasClassifier()) { classifier = ao.getClassifier(); log.debug("Using classifier " + classifier); } final String name = toCanonicalForm(groupId, artifactId); final String coordinates = toCanonicalForm(name, version); try { DependencyDescriptor info = impl.getDependencies(groupId, artifactId, version, classifier, null, fetchSingleArtifact); if (info == null) { log.debug("No artifact found: " + coordinates); return null; } final SingleArtifactResult result; if (fetchSingleArtifact) { result = new SingleArtifactResult( repository, name, version, info.getFile(), repositoryDisplayString); } else { final List<ArtifactResult> dependencies = new ArrayList<>(); for (DependencyDescriptor dep : info.getDependencies()) { String dGroupId = dep.getGroupId(); String dArtifactId = dep.getArtifactId(); String dVersion = dep.getVersion(); boolean export = false; boolean optional = dep.isOptional(); boolean isCeylon = false; ArtifactContext dContext = null; if (overrides != null) dContext = getArtifactContext(dGroupId, dArtifactId, dVersion, null, null); if (overrides != null) { if (overrides.isRemoved(dContext) || (ao != null && ao.isRemoved(dContext))) { log.debug(String.format("[Maven-Overrides] Removing %s from %s.", dep, context)); continue; // skip dependency } if (ao != null && ao.isAddedOrUpdated(dContext)) { log.debug(String.format("[Maven-Overrides] Replacing %s from %s.", dep, context)); continue; // skip dependency } ArtifactContext replace = overrides.replace(dContext); if (replace != null) { dContext = replace; String[] groupArtifactIds = nameToGroupArtifactIds(replace.getName()); if (groupArtifactIds == null) { isCeylon = true; } else { dGroupId = groupArtifactIds[0]; dArtifactId = groupArtifactIds[1]; } dVersion = replace.getVersion(); } if (ao != null) { if (ao.isShareOverridden(dContext)) export = ao.isShared(dContext); if (ao.isOptionalOverridden(dContext)) optional = ao.isOptional(dContext); } } // do we have a version update? if (overrides != null && overrides.isVersionOverridden(dContext)) { dVersion = overrides.getVersionOverride(dContext); } ArtifactResult dr; if (isCeylon) dr = createArtifactResult( manager, dContext.getName(), dVersion, export, optional, repositoryDisplayString); else dr = createArtifactResult( manager, repository, dGroupId, dArtifactId, dVersion, export, optional, repositoryDisplayString); dependencies.add(dr); } if (ao != null) { for (DependencyOverride addon : ao.getAdd()) { ArtifactContext dContext = addon.getArtifactContext(); String dVersion = overrides.getVersionOverride(dContext); dependencies.add( createArtifactResult( manager, repository, dContext, dVersion, addon.isShared(), addon.isOptional(), repositoryDisplayString)); log.debug( String.format( "[Maven-Overrides] Added %s to %s.", addon.getArtifactContext(), context)); } } result = new AetherArtifactResult( repository, name, version, info.getFile(), dependencies, repositoryDisplayString); } if (ao != null && ao.getFilter() != null) { result.setFilter(PathFilterParser.parse(ao.getFilter())); } return result; } catch (IOException e) { throw new IllegalStateException(e); } catch (AetherException e) { log.debug("Could not resolve artifact [" + coordinates + "] : " + e); return null; } }