Align implementation with Tycho

Author: laeubi

org.eclipse.m2e.pde.target/src/org/eclipse/m2e/pde/target/DependencyNodeGenerator.java

@@ -42,6 +42,7 @@
 import org.apache.maven.RepositoryUtils;
 import org.apache.maven.artifact.repository.ArtifactRepository;
 import org.apache.maven.project.MavenProject;
+import org.eclipse.aether.RepositoryException;
 import org.eclipse.aether.RepositorySystem;
 import org.eclipse.aether.RepositorySystemSession;
 import org.eclipse.aether.artifact.Artifact;
@@ -68,8 +69,12 @@
 import org.eclipse.m2e.core.internal.MavenPluginActivator;
 import org.eclipse.m2e.core.project.IMavenProjectFacade;
 import org.eclipse.m2e.core.project.IMavenProjectRegistry;
+import org.eclipse.m2e.pde.target.shared.AdditionalRepository;
 import org.eclipse.m2e.pde.target.shared.DependencyDepth;
 import org.eclipse.m2e.pde.target.shared.DependencyResult;
+import org.eclipse.m2e.pde.target.shared.MavenDependencyCollector;
+import org.eclipse.m2e.pde.target.shared.MavenRootDependency;
+import org.eclipse.m2e.pde.target.shared.RepositoryArtifact;
 import org.eclipse.pde.core.IModel;
 import org.eclipse.pde.core.target.ITargetDefinition;
 import org.eclipse.pde.core.target.TargetBundle;
@@ -228,7 +233,7 @@ public List<MavenTargetRepository> getExtraRepositories() {
 
 	private Artifact resolveDependency(MavenTargetDependency root, IMaven maven, List<ArtifactRepository> repositories,
 			TargetBundles targetBundles, CacheManager cacheManager, IProgressMonitor monitor) throws CoreException {
-		SubMonitor subMonitor = SubMonitor.convert(monitor, 100);
+		SubMonitor subMonitor = SubMonitor.convert(monitor, 100); 
 		IMavenProjectRegistry registry = MavenPlugin.getMavenProjectRegistry();
 		IMavenProjectFacade workspaceProject = registry.getMavenProject(root.getGroupId(), root.getArtifactId(),
 				root.getVersion());
@@ -241,36 +246,33 @@ private Artifact resolveDependency(MavenTargetDependency root, IMaven maven, Lis
 					root.getVersion(), root.getType(), root.getClassifier(), repositories, subMonitor.split(80)));
 		}
 		if (artifact != null) {
-			DependencyDepth depth = dependencyDepth;
-			if (isClassified(artifact)) {
-				// a classified artifact can not have any dependencies and will actually include
-				// the ones from the main artifact.
-				// if the user really wants this it is possible to include the pom typed
-				// artifact or the main artifact in the list
-				depth = DependencyDepth.NONE;
-			}
-			if (isPomType(artifact) && depth == DependencyDepth.NONE) {
-				// fetching only the pom but no dependencies does not makes much sense...
-				depth = DependencyDepth.DIRECT;
-			}
+			MavenRootDependency dependency = new MavenRootDependency(artifact.getGroupId(), artifact.getArtifactId(),
+					artifact.getVersion(), artifact.getClassifier(), artifact.getExtension());
+			DependencyDepth depth = MavenDependencyCollector.getEffectiveDepth(dependency,
+					dependencyDepth);
 			SubMonitor split = subMonitor.split(20);
 			if (depth == DependencyDepth.DIRECT || depth == DependencyDepth.INFINITE) {
-				ICallable<DependencyResult> callable = DependencyNodeGenerator.create(root, artifact, depth,
-						dependencyScopes, repositories, this);
+				// We should resolve the main artifact from the collector, but because this
+				// is currently separate we already have the additional repos added. see
+				// org.eclipse.tycho.core.resolver.MavenTargetDefinitionContent.resolveRoot(MavenDependencyCollector,
+				// MavenDependency)
+				Collection<AdditionalRepository> extra = new ArrayList<>();
+				ICallable<DependencyResult> callable = create(root, dependency, dependencyDepth, dependencyScopes,
+						repositories, this, extra);
 				DependencyResult dependecies;
 				if (workspaceProject == null) {
 					dependecies = maven.createExecutionContext().execute(callable, subMonitor);
 				} else {
 					dependecies = registry.execute(workspaceProject, callable, subMonitor);
 				}
-				List<Artifact> artifacts = dependecies.artifacts();
+				List<RepositoryArtifact> artifacts = dependecies.artifacts();
 				split.setWorkRemaining(artifacts.size());
-				for (Artifact a : artifacts) {
-					if (a.getFile() == null) {
+				for (RepositoryArtifact a : artifacts) {
+					if (a.artifact().getFile() == null) {
 						// this is a filtered dependency
 						continue;
 					}
-					addBundleForArtifact(a, cacheManager, maven, targetBundles, split.split(1));
+					addBundleForArtifact(a.artifact(), cacheManager, maven, targetBundles, split.split(1));
 				}
 				targetBundles.dependencyNodes.put(root, dependecies.nodes());
 			} else {
@@ -281,9 +283,26 @@ private Artifact resolveDependency(MavenTargetDependency root, IMaven maven, Lis
 		return artifact;
 	}
 
-	private boolean isClassified(Artifact artifact) {
-		String classifier = artifact.getClassifier();
-		return classifier != null && !classifier.isEmpty();
+	static ICallable<DependencyResult> create(MavenTargetDependency root, MavenRootDependency dependency,
+			DependencyDepth dependencyDepth, Collection<String> dependencyScopes,
+			@SuppressWarnings("deprecation") List<ArtifactRepository> repositories, MavenTargetLocation parent,
+			Collection<AdditionalRepository> extra) {
+		return (context, monitor) -> {
+			try {
+				MavenDependencyCollector collector = new MavenDependencyCollector(
+						MavenPluginActivator.getDefault().getRepositorySystem(), context.getRepositorySession(),
+						RepositoryUtils.toRepos(repositories), extra, dependencyDepth, dependencyScopes);
+				DependencyResult result = collector.collect(dependency);
+				DependencyNode node = result.root();
+				node.setData(MavenTargetLocation.DEPENDENCYNODE_PARENT, parent);
+				node.setData(MavenTargetLocation.DEPENDENCYNODE_ROOT, root);
+				return result;
+			} catch (RepositoryException e) {
+				throw new CoreException(Status.error("Resolving dependencies failed", e));
+			} catch (RuntimeException e) {
+				throw new CoreException(Status.error("Internal error", e));
+			}
+		};
 	}
 
 	private boolean isPomType(Artifact artifact) {

org.eclipse.m2e.pde.target/src/org/eclipse/m2e/pde/target/MavenTargetLocation.java

@@ -66,10 +66,14 @@ Optional<MavenTargetBundle> getTargetBundle(MavenTargetDependency dependency) {
 	}
 
 	public void addBundle(Artifact artifact, TargetBundle bundle) {
-		bundles.put(artifact, bundle);
+
 		File file = artifact.getFile();
-		if (file != null) {
-			artifacts.put(file, artifact);
+		if (file == null) {
+			bundles.put(artifact, bundle);
+		} else {
+			if (artifacts.put(file, artifact) == null) {
+				bundles.put(artifact, bundle);
+			}
 		}
 	}
 
@@ -84,4 +88,5 @@ public Stream<Entry<Artifact, TargetBundle>> bundles() {
 	public Optional<Artifact> getArtifact(File file) {
 		return Optional.ofNullable(artifacts.get(file));
 	}
+
 }

org.eclipse.m2e.pde.target/src/org/eclipse/m2e/pde/target/TargetBundles.java

@@ -0,0 +1,17 @@
+/*******************************************************************************
+ * Copyright (c) 2025 Christoph Läubrich and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * https://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *   Christoph Läubrich - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.m2e.pde.target.shared;
+
+public record AdditionalRepository(String id, String url) {
+
+}

org.eclipse.m2e.pde.target/src/org/eclipse/m2e/pde/target/shared/AdditionalRepository.java

@@ -14,9 +14,9 @@
 
 import java.util.List;
 
-import org.eclipse.aether.artifact.Artifact;
 import org.eclipse.aether.graph.DependencyNode;
 
-public record DependencyResult(List<Artifact> artifacts, DependencyNode root, List<DependencyNode> nodes) {
+public record DependencyResult(DependencyDepth depth, List<RepositoryArtifact> artifacts, DependencyNode root,
+		List<DependencyNode> nodes) {
 
 }

org.eclipse.m2e.pde.target/src/org/eclipse/m2e/pde/target/shared/DependencyResult.java

@@ -19,15 +19,18 @@
 import java.util.List;
 import java.util.Queue;
 import java.util.Set;
+import java.util.stream.Stream;
 
 import org.eclipse.aether.RepositoryException;
 import org.eclipse.aether.RepositorySystem;
 import org.eclipse.aether.RepositorySystemSession;
 import org.eclipse.aether.artifact.Artifact;
+import org.eclipse.aether.artifact.DefaultArtifact;
 import org.eclipse.aether.graph.DefaultDependencyNode;
 import org.eclipse.aether.graph.Dependency;
 import org.eclipse.aether.graph.DependencyNode;
 import org.eclipse.aether.repository.RemoteRepository;
+import org.eclipse.aether.repository.RepositoryPolicy;
 import org.eclipse.aether.resolution.ArtifactDescriptorRequest;
 import org.eclipse.aether.resolution.ArtifactDescriptorResult;
 import org.eclipse.aether.resolution.ArtifactRequest;
@@ -39,39 +42,63 @@
  */
 public class MavenDependencyCollector {
 
-	private static final Set<String> VALID_EXTENSIONS = Set.of("jar", "pom");
+	private static final String TYPE_POM = "pom";
 
-	private RepositorySystem repoSystem;
-	private RepositorySystemSession repositorySession;
-	private List<RemoteRepository> repositories;
-	private DependencyDepth depth;
-	private Collection<String> dependencyScopes;
+	private static final Set<String> VALID_EXTENSIONS = Set.of("jar", TYPE_POM);
+
+	private final RepositorySystem repoSystem;
+	private final RepositorySystemSession repositorySession;
+	private final List<RemoteRepository> repositories;
+	private final Collection<String> dependencyScopes;
+
+	private DependencyDepth dependencyDepth;
 
 	public MavenDependencyCollector(RepositorySystem repoSystem, RepositorySystemSession repositorySession,
-			List<RemoteRepository> repositories, DependencyDepth depth, Collection<String> dependencyScopes) {
+			List<RemoteRepository> defaultRepositories, Collection<AdditionalRepository> additionalRepositories,
+			DependencyDepth depth, Collection<String> dependencyScopes) {
 		this.repoSystem = repoSystem;
 		this.repositorySession = repositorySession;
-		this.repositories = repositories;
-		this.depth = depth;
+		if (additionalRepositories == null || additionalRepositories.isEmpty()) {
+			this.repositories = repoSystem.newResolutionRepositories(repositorySession, defaultRepositories);
+		} else {
+			List<RemoteRepository> combined = Stream
+					.concat(defaultRepositories.stream(), additionalRepositories.stream().map(additional -> {
+						return new RemoteRepository.Builder(additional.id(), "default", additional.url())
+								.setReleasePolicy(new RepositoryPolicy(true, RepositoryPolicy.UPDATE_POLICY_ALWAYS,
+										RepositoryPolicy.CHECKSUM_POLICY_WARN))
+								.setSnapshotPolicy(new RepositoryPolicy(true, RepositoryPolicy.UPDATE_POLICY_ALWAYS,
+										RepositoryPolicy.CHECKSUM_POLICY_WARN))
+								.build();
+					})).distinct().toList();
+			this.repositories = repoSystem.newResolutionRepositories(repositorySession, combined);
+		}
+		this.dependencyDepth = depth;
 		this.dependencyScopes = dependencyScopes;
 	}
 
-	public DependencyResult collect(Dependency root) throws RepositoryException {
-		if (!isValidDependency(root)) {
+	public List<RemoteRepository> getEffectiveRepositories() {
+		return repositories;
+	}
+
+	public DependencyResult collect(MavenRootDependency root) throws RepositoryException {
+		if (!VALID_EXTENSIONS.contains(root.getType())) {
 			throw new RepositoryException(
-					"Invalid root dependency: " + root + " allowed extensions are " + VALID_EXTENSIONS);
+					"Invalid root dependency: " + root + " allowed types are " + VALID_EXTENSIONS);
 		}
-		List<Artifact> artifacts = new ArrayList<>();
+		DependencyDepth depth = getEffectiveDepth(root, dependencyDepth);
+		List<RepositoryArtifact> artifacts = new ArrayList<>();
 		List<DependencyNode> nodes = new ArrayList<>();
-		ArtifactDescriptor rootDescriptor = readArtifactDescriptor(root, null, artifacts, nodes);
+		ArtifactDescriptor rootDescriptor = readArtifactDescriptor(new Dependency(
+				new DefaultArtifact(root.groupId(), root.artifactId(), root.classifier(), root.type(), root.version()),
+				null), null, artifacts, nodes);
 		if (depth == DependencyDepth.NONE) {
-			return new DependencyResult(artifacts, rootDescriptor.node(), nodes);
+			return new DependencyResult(depth, artifacts, rootDescriptor.node(), nodes);
 		}
 		if (depth == DependencyDepth.DIRECT) {
 			for (Dependency dependency : rootDescriptor.dependencies()) {
 				readArtifactDescriptor(dependency, rootDescriptor.node(), artifacts, nodes);
 			}
-			return new DependencyResult(artifacts, rootDescriptor.node(), nodes);
+			return new DependencyResult(depth, artifacts, rootDescriptor.node(), nodes);
 		}
 		// Add all dependencies with BFS method
 		Set<String> collected = new HashSet<>();
@@ -90,15 +117,7 @@ public DependencyResult collect(Dependency root) throws RepositoryException {
 				}
 			}
 		}
-		return new DependencyResult(artifacts, rootDescriptor.node(), nodes);
-	}
-
-	private String getId(Dependency dependency) {
-		Artifact artifact = dependency.getArtifact();
-		// This does not include the version so we always ever only collect one version
-		// of an (transitive) artifact
-		return artifact.getGroupId() + ":" + artifact.getArtifactId() + ":"
-				+ artifact.getClassifier();
+		return new DependencyResult(depth, artifacts, rootDescriptor.node(), nodes);
 	}
 
 	/**
@@ -111,8 +130,7 @@ private String getId(Dependency dependency) {
 	 * @throws RepositoryException
 	 */
 	private ArtifactDescriptor readArtifactDescriptor(Dependency dependency, DependencyNode parent,
-			Collection<Artifact> artifacts,
-			List<DependencyNode> nodes) throws RepositoryException {
+			Collection<RepositoryArtifact> artifacts, List<DependencyNode> nodes) throws RepositoryException {
 		if (isValidScope(dependency) && isValidDependency(dependency)) {
 			ArtifactDescriptorRequest descriptorRequest = new ArtifactDescriptorRequest();
 			descriptorRequest.setArtifact(dependency.getArtifact());
@@ -123,7 +141,7 @@ private ArtifactDescriptor readArtifactDescriptor(Dependency dependency, Depende
 			artifactRequest.setRepositories(repositories);
 			ArtifactResult artifactResult = repoSystem.resolveArtifact(repositorySession, artifactRequest);
 			Artifact resolved = artifactResult.getArtifact();
-			artifacts.add(resolved);
+			artifacts.add(new RepositoryArtifact(resolved, artifactResult.getRepository()));
 			DefaultDependencyNode dependencyNode = new DefaultDependencyNode(
 					new Dependency(resolved, dependency.getScope()));
 			nodes.add(dependencyNode);
@@ -153,4 +171,32 @@ private boolean isValidScope(Dependency dependency) {
 		return dependencyScopes.contains(scope);
 	}
 
+	public static DependencyDepth getEffectiveDepth(MavenRootDependency root, DependencyDepth dependencyDepth) {
+		DependencyDepth depth;
+		if (isClassified(root)) {
+			// a classified artifact can not have any dependencies and will actually include
+			// the ones from the main artifact.
+			// if the user really wants this it is possible to include the pom typed
+			// artifact or the main artifact in the list
+			depth = DependencyDepth.NONE;
+		} else if (dependencyDepth == DependencyDepth.NONE && TYPE_POM.equalsIgnoreCase(root.type())) {
+			depth = DependencyDepth.DIRECT;
+		} else {
+			depth = dependencyDepth;
+		}
+		return depth;
+	}
+
+	private static String getId(Dependency dependency) {
+		Artifact artifact = dependency.getArtifact();
+		// This does not include the version so we always ever only collect one version
+		// of an (transitive) artifact
+		return artifact.getGroupId() + ":" + artifact.getArtifactId() + ":" + artifact.getClassifier();
+	}
+
+	private static boolean isClassified(MavenRootDependency root) {
+		String classifier = root.classifier();
+		return classifier != null && !classifier.isBlank();
+	}
+
 }