[
https://issues.apache.org/jira/browse/MRESOLVER-345?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Tamas Cservenak updated MRESOLVER-345:
--------------------------------------
Description:
It all started with MENFORCER-426. In short, if we have layout of dependencies
like this below (ranges are key here), *conflict resolution in verbose mode*
will misbehave, is sensitive on version ordering in the "dirty tree" (collected
graph, output of DependencyCollector).
{noformat}
A -> B -> C[1..2]
\--> C[1..2] {noformat}
(explained: A depends on B and C[1..2] range, and B depends on C[1..2] as well)
As when "dirty tree" is being collected by DependencyCollector (and we have
two, old DF and new BF), the ranges are turned into series of discovered (by
VersionRangeResolver) versions, so the input above while collecting A from
above would yield some tree like this (in this example {{some-group:c:jar}} has
versions 1.0 and 2.0 ):
{noformat}
some-group:a:jar:1.0 [compile]
+- some-group:b:jar:1.0 [compile]
| +- some-group:c:jar:1.0 [compile]
| \- some-group:c:jar:2.0 [compile]
+- some-group:c:jar:1.0 [compile]
\- some-group:c:jar:2.0 [compile] {noformat}
This "dirty tree" is then transformed using {{ConflictResolver}} into final
graph. Conflict resolver in "normal" mode works OK and produces stable outputs,
that is not sensitive to ordering, this is OK.
But, conflict resolver supports so called "verbose" mode as well, mostly used
to perform some "analysis" on graph (like for example "dependency convergence"
is). Conflict resolver in "verbose" mode {*}is version ordering sensitive{*}.
Conflict resolver "verbose"
> Conflict resolution is sensitive to version ordering
> ----------------------------------------------------
>
> Key: MRESOLVER-345
> URL: https://issues.apache.org/jira/browse/MRESOLVER-345
> Project: Maven Resolver
> Issue Type: Bug
> Reporter: Tamas Cservenak
> Priority: Major
>
> It all started with MENFORCER-426. In short, if we have layout of
> dependencies like this below (ranges are key here), *conflict resolution in
> verbose mode* will misbehave, is sensitive on version ordering in the "dirty
> tree" (collected graph, output of DependencyCollector).
> {noformat}
> A -> B -> C[1..2]
> \--> C[1..2] {noformat}
> (explained: A depends on B and C[1..2] range, and B depends on C[1..2] as
> well)
> As when "dirty tree" is being collected by DependencyCollector (and we have
> two, old DF and new BF), the ranges are turned into series of discovered (by
> VersionRangeResolver) versions, so the input above while collecting A from
> above would yield some tree like this (in this example {{some-group:c:jar}}
> has versions 1.0 and 2.0 ):
> {noformat}
> some-group:a:jar:1.0 [compile]
> +- some-group:b:jar:1.0 [compile]
> | +- some-group:c:jar:1.0 [compile]
> | \- some-group:c:jar:2.0 [compile]
> +- some-group:c:jar:1.0 [compile]
> \- some-group:c:jar:2.0 [compile] {noformat}
> This "dirty tree" is then transformed using {{ConflictResolver}} into final
> graph. Conflict resolver in "normal" mode works OK and produces stable
> outputs, that is not sensitive to ordering, this is OK.
> But, conflict resolver supports so called "verbose" mode as well, mostly used
> to perform some "analysis" on graph (like for example "dependency
> convergence" is). Conflict resolver in "verbose" mode {*}is version ordering
> sensitive{*}.
> Conflict resolver "verbose"
--
This message was sent by Atlassian Jira
(v8.20.10#820010)
