feat(Tycho): Improve handling of wrapped artifacts

oheger-bosch · sschuberth · commit 770ee7591410 · 2026-02-25T13:13:23.000+01:00
If a wrapped artifact cannot be matched against the target platform,
still try to resolve it via the standard Maven resolution mechanism.
This seems to be necessary for fat or uber jars for which Tycho
sometimes operate on submodules.

Signed-off-by: Oliver Heger &lt;oliver.heger@bosch.com&gt;
diff --git a/plugins/package-managers/maven/src/main/kotlin/tycho/TargetHandler.kt b/plugins/package-managers/maven/src/main/kotlin/tycho/TargetHandler.kt
@@ -115,19 +115,72 @@ internal class TargetHandler(
      * Maven dependencies. There are also options to change the default resolution mechanism for such dependencies.
      * If this is done, Tycho sometimes creates alternative identifiers for the dependencies. This function attempts
      * to find the original Maven coordinates for affected artifacts. They are needed to retrieve the correct metadata.
-     * Result is *null* if no matching Maven dependency is found.
+     * There are cases where no unique mapping can be found, especially if Tycho automatically wraps a Maven artifact to
+     * an OSGi bundle. In such cases, there may be a number of potential candidates for the original Maven artifact
+     * which are returned as a [List]. The caller should then try all of these candidates to find the correct one. If
+     * no mapping can be found, result is an empty [List].
      */
-    fun mapToMavenDependency(tychoArtifact: Artifact): Artifact? {
+    fun mapToMavenDependency(tychoArtifact: Artifact): List<Artifact> {
         // Strip the "wrapped." prefix that might have been added by Tycho's automatic bundle wrapping mechanism
         // (missingManifest="generate") to find the original Maven artifact.
         val unwrappedArtifactId = tychoArtifact.artifactId.removePrefix("wrapped.")
 
-        return mavenDependencies[unwrappedArtifactId]?.also { dep ->
+        return mavenDependencies[unwrappedArtifactId]?.let { dep ->
             logger.info {
                 "Mapping Tycho artifact '${tychoArtifact.groupId}:${tychoArtifact.artifactId}' to Maven " +
                     "dependency '${dep.groupId}:${dep.artifactId}'."
             }
+
+            listOf(dep)
+        } ?: if (unwrappedArtifactId != tychoArtifact.artifactId) {
+            logger.info {
+                "Handling a wrapped Tycho artifact '${tychoArtifact.artifactId}' by enumerating all candidates."
+            }
+
+            createCandidatesForWrappedArtifact(tychoArtifact, unwrappedArtifactId)
+        } else {
+            emptyList()
+        }
+    }
+
+    /**
+     * Generate potential candidates for the original Maven artifact for the given [tychoArtifact] which has been
+     * wrapped by Tycho's automatic bundle wrapping mechanism (missingManifest="generate"). For such wrapped artifacts,
+     * Tycho generates an artifact ID by concatenating the group ID and artifact ID of the original Maven dependency
+     * using a dot as separator and adding a "wrapped." prefix. This transformation cannot be reversed in a unique way
+     * if the original Maven artifactId contains dots. Therefore, this function generates a list of all combinations
+     * of group and artifact IDs resulting in the given [unwrappedArtifactId].
+     */
+    private fun createCandidatesForWrappedArtifact(
+        tychoArtifact: Artifact,
+        unwrappedArtifactId: String
+    ): List<Artifact> {
+        val candidates = mutableListOf<Artifact>()
+
+        tailrec fun generateCandidates(groupId: String, artifactId: String) {
+            val newGroupId = groupId.substringBeforeLast('.')
+            if (newGroupId != groupId) {
+                val newArtifactComponent = groupId.substringAfterLast('.')
+                val newArtifactId = if (artifactId.isEmpty()) {
+                    newArtifactComponent
+                } else {
+                    "$newArtifactComponent.$artifactId"
+                }
+
+                candidates += DefaultArtifact(
+                    newGroupId,
+                    newArtifactId,
+                    tychoArtifact.classifier,
+                    "jar", // Always set to "jar", the Tycho artifact may have "pom" instead.
+                    tychoArtifact.version
+                )
+
+                generateCandidates(newGroupId, newArtifactId)
+            }
         }
+
+        generateCandidates(unwrappedArtifactId, "")
+        return candidates
     }
 }
 
diff --git a/plugins/package-managers/maven/src/main/kotlin/tycho/Tycho.kt b/plugins/package-managers/maven/src/main/kotlin/tycho/Tycho.kt
@@ -23,6 +23,7 @@ import java.io.File
 import java.util.concurrent.atomic.AtomicReference
 import java.util.jar.Manifest
 
+import org.apache.logging.log4j.kotlin.KotlinLogger
 import org.apache.logging.log4j.kotlin.logger
 import org.apache.maven.AbstractMavenLifecycleParticipant
 import org.apache.maven.cli.MavenCli
@@ -199,7 +200,8 @@ class Tycho(override val descriptor: PluginDescriptor = TychoFactory.descriptor)
             mavenSupport.defaultPackageResolverFun(),
             repositoryHelper,
             resolver,
-            targetHandler
+            targetHandler,
+            logger
         )
         val dependencyHandler = MavenDependencyHandler(descriptor.displayName, projectType, mavenProjects, resolverFun)
         return DependencyGraphBuilder(dependencyHandler)
@@ -372,21 +374,52 @@ internal fun tychoPackageResolverFun(
     delegate: PackageResolverFun,
     repositoryHelper: LocalRepositoryHelper,
     resolver: P2ArtifactResolver,
-    targetHandler: TargetHandler
+    targetHandler: TargetHandler,
+    logger: KotlinLogger
 ): PackageResolverFun =
     { dependency ->
         runCatching {
             delegate(dependency)
         }.recoverCatching { exception ->
-            targetHandler.mapToMavenDependency(dependency.artifact)?.let { artifact ->
+            targetHandler.mapToMavenDependency(dependency.artifact)
+                .takeIf { it.isNotEmpty() }?.let { artifacts ->
+                    resolveMavenArtifacts(dependency, delegate, artifacts, logger)
+                } ?: createPackageFromLocalArtifact(dependency.artifact, repositoryHelper, resolver)
+                ?: throw exception
+        }.getOrThrow()
+    }
+
+/**
+ * Resolve a [dependency] via the standard Maven resolution process accessible through the given [resolver] function.
+ * Try the given [candidates] as potential Maven artifacts corresponding to the given dependency and return the first
+ * successfully resolved [Package]. Throw an exception if none of the candidates could be resolved.
+ */
+private fun resolveMavenArtifacts(
+    dependency: DependencyNode,
+    resolver: PackageResolverFun,
+    candidates: List<Artifact>,
+    logger: KotlinLogger
+): Package =
+    checkNotNull(
+        candidates.firstNotNullOfOrNull { artifact ->
+            runCatching {
+                logger.debug {
+                    "Trying to resolve Maven artifact candidate " +
+                        "'${artifact.groupId}:${artifact.artifactId}:${artifact.version}'."
+                }
+
                 val mappedDependency = DefaultDependencyNode(artifact).apply {
                     repositories = dependency.repositories
                 }
 
-                delegate(mappedDependency)
-            } ?: createPackageFromLocalArtifact(dependency.artifact, repositoryHelper, resolver)
-                ?: throw exception
-        }.getOrThrow()
+                resolver(mappedDependency)
+            }.onFailure { exception ->
+                logger.debug(exception) { "Failed to resolve Maven artifact candidate." }
+            }.getOrNull()
+        }
+    ) {
+        "Failed to resolve ${candidates.size} candidates for dependency " +
+            "'${dependency.artifact.identifier()}'."
     }
 
 /**
diff --git a/plugins/package-managers/maven/src/test/kotlin/tycho/TargetHandlerTest.kt b/plugins/package-managers/maven/src/test/kotlin/tycho/TargetHandlerTest.kt
@@ -24,8 +24,7 @@ import io.kotest.core.spec.style.WordSpec
 import io.kotest.engine.spec.tempdir
 import io.kotest.matchers.collections.beEmpty
 import io.kotest.matchers.collections.containExactlyInAnyOrder
-import io.kotest.matchers.nulls.beNull
-import io.kotest.matchers.nulls.shouldNotBeNull
+import io.kotest.matchers.collections.shouldBeSingleton
 import io.kotest.matchers.should
 import io.kotest.matchers.shouldBe
 
@@ -55,23 +54,40 @@ class TargetHandlerTest : WordSpec({
     }
 
     "mapToMavenDependency()" should {
-        "return null if an artifact cannot be mapped to a Maven dependency" {
+        "return an empty list if an artifact cannot be mapped to a Maven dependency" {
             val tychoArtifact = DefaultArtifact("groupId", "artifactId", "ext", "version")
             val targetHandler = TargetHandler.create(tempdir())
 
-            targetHandler.mapToMavenDependency(tychoArtifact) should beNull()
+            targetHandler.mapToMavenDependency(tychoArtifact) should beEmpty()
         }
 
         "return the correct Maven dependency if an artifact can be mapped" {
             val tychoArtifact = DefaultArtifact("p2.eclipse.plugin", "ch.qos.logback.logback-classic", "jar", "1.5.6")
             val targetHandler = createTargetHandlerWithTargetFiles()
 
-            targetHandler.mapToMavenDependency(tychoArtifact).shouldNotBeNull {
-                groupId shouldBe "ch.qos.logback"
-                artifactId shouldBe "logback-classic"
-                version shouldBe "1.5.6"
+            targetHandler.mapToMavenDependency(tychoArtifact).shouldBeSingleton {
+                it.groupId shouldBe "ch.qos.logback"
+                it.artifactId shouldBe "logback-classic"
+                it.version shouldBe "1.5.6"
             }
         }
+
+        "return the potential candidates for a wrapped artifact" {
+            val tychoArtifact = DefaultArtifact(
+                "p2.eclipse.plugin",
+                "wrapped.org.apache.commons.commons-lang3",
+                "pom",
+                "3.12.0"
+            )
+            val expectedCandidates = listOf(
+                DefaultArtifact("org.apache.commons", "commons-lang3", "jar", "3.12.0"),
+                DefaultArtifact("org.apache", "commons.commons-lang3", "jar", "3.12.0"),
+                DefaultArtifact("org", "apache.commons.commons-lang3", "jar", "3.12.0")
+            )
+            val targetHandler = createTargetHandlerWithTargetFiles()
+
+            targetHandler.mapToMavenDependency(tychoArtifact) should containExactlyInAnyOrder(expectedCandidates)
+        }
     }
 
     "featureIds" should {
diff --git a/plugins/package-managers/maven/src/test/kotlin/tycho/TychoTest.kt b/plugins/package-managers/maven/src/test/kotlin/tycho/TychoTest.kt
@@ -314,7 +314,7 @@ class TychoTest : WordSpec({
                 pkg
             }
 
-            val resolver = tychoPackageResolverFun(delegate, mockk(), mockk(), mockk())
+            val resolver = tychoPackageResolverFun(delegate, mockk(), mockk(), mockk(), mockk(relaxed = true))
 
             resolver(dependency) shouldBe pkg
         }
@@ -404,13 +404,73 @@ class TychoTest : WordSpec({
             }
 
             val targetHandler = mockk<TargetHandler> {
-                every { mapToMavenDependency(originalArtifact) } returns mappedArtifact
+                every { mapToMavenDependency(originalArtifact) } returns listOf(mappedArtifact)
             }
 
-            val resolver = tychoPackageResolverFun(delegate, mockk(), mockk(), targetHandler)
+            val resolver = tychoPackageResolverFun(delegate, mockk(), mockk(), targetHandler, mockk(relaxed = true))
 
             resolver(dependency) shouldBe pkg
         }
+
+        "test all candidates for a wrapped artifact" {
+            val originalArtifact = mockk<Artifact>()
+            val mappedArtifact1 = mockk<Artifact>()
+            val mappedArtifact2 = mockk<Artifact>()
+            val mappedArtifact3 = mockk<Artifact>()
+            val mappedArtifact4 = mockk<Artifact>()
+            val dependency = DefaultDependencyNode(originalArtifact)
+
+            var delegateCount = 0
+            val pkg = mockk<Package>()
+            val delegate: PackageResolverFun = { node ->
+                delegateCount++
+                if (node.artifact != mappedArtifact3) {
+                    throw IOException("Test exception: Unresolvable dependency.")
+                }
+
+                pkg
+            }
+
+            val targetHandler = mockk<TargetHandler> {
+                every { mapToMavenDependency(originalArtifact) } returns listOf(
+                    mappedArtifact1,
+                    mappedArtifact2,
+                    mappedArtifact3,
+                    mappedArtifact4
+                )
+            }
+
+            val resolver = tychoPackageResolverFun(delegate, mockk(), mockk(), targetHandler, mockk(relaxed = true))
+
+            resolver(dependency) shouldBe pkg
+            delegateCount shouldBe 4
+        }
+
+        "throw if none of the candidates for a wrapped artifact can be resolved" {
+            val originalArtifact = mockk<Artifact>(relaxed = true)
+            val mappedArtifact1 = mockk<Artifact>()
+            val mappedArtifact2 = mockk<Artifact>()
+            val mappedArtifact3 = mockk<Artifact>()
+            val dependency = DefaultDependencyNode(originalArtifact)
+
+            val delegate: PackageResolverFun = {
+                throw IOException("Test exception: Unresolvable dependency.")
+            }
+
+            val targetHandler = mockk<TargetHandler> {
+                every { mapToMavenDependency(originalArtifact) } returns listOf(
+                    mappedArtifact1,
+                    mappedArtifact2,
+                    mappedArtifact3
+                )
+            }
+
+            val resolver = tychoPackageResolverFun(delegate, mockk(), mockk(), targetHandler, mockk(relaxed = true))
+
+            shouldThrow<IllegalStateException> {
+                resolver(dependency)
+            }
+        }
     }
 
     "createPackageFromManifest()" should {
@@ -656,11 +716,11 @@ private fun createResolverFunWithRepositoryHelper(block: LocalRepositoryHelper.(
     val helper = mockk<LocalRepositoryHelper>(block = block)
     val resolver = createResolverMock()
     val targetHandler = mockk<TargetHandler> {
-        every { mapToMavenDependency(any()) } returns null
+        every { mapToMavenDependency(any()) } returns emptyList()
     }
 
     val delegateResolverFun: PackageResolverFun = { throw resolveException }
-    return tychoPackageResolverFun(delegateResolverFun, helper, resolver, targetHandler)
+    return tychoPackageResolverFun(delegateResolverFun, helper, resolver, targetHandler, mockk(relaxed = true))
 }
 
 /**
