How can I add an attribute disambiguation rule for all configurations in a project?

Help/Discuss
1

I am trying to setup a basic app running quarkus 3.4.3 and javafx 21.0.1 using gradle 8.4 with kotlin dsl as the build tool.
Based on the solution provided in question about declaring variants for configurations question, I was trying to resolve an issue where quarkus configurations where unable to decide between versions of variants of org.openjfx:javafx-controls.
To find out the configurations for my project I did:

configurations.stream().forEach { configuration ->
    println(configuration.toString())
}

which produced the following output:

configuration ':jfxapp:annotationProcessor'
configuration ':jfxapp:apiElements'
configuration ':jfxapp:archives'
configuration ':jfxapp:compileClasspath'
configuration ':jfxapp:compileOnly'
configuration ':jfxapp:default'
configuration ':jfxapp:implementation'
configuration ':jfxapp:integrationTestAnnotationProcessor'
configuration ':jfxapp:integrationTestCompileClasspath'
configuration ':jfxapp:integrationTestCompileOnly'
configuration ':jfxapp:integrationTestImplementation'
configuration ':jfxapp:integrationTestRuntimeClasspath'
configuration ':jfxapp:integrationTestRuntimeOnly'
configuration ':jfxapp:mainSourceElements'
configuration ':jfxapp:nativeTestAnnotationProcessor'
configuration ':jfxapp:nativeTestCompileClasspath'
configuration ':jfxapp:nativeTestCompileOnly'
configuration ':jfxapp:nativeTestImplementation'
configuration ':jfxapp:nativeTestRuntimeClasspath'
configuration ':jfxapp:nativeTestRuntimeOnly'
configuration ':jfxapp:quarkusDev'
configuration ':jfxapp:quarkusDevBaseRuntimeClasspathConfiguration'
configuration ':jfxapp:quarkusDevRuntimeClasspathConfiguration'
configuration ':jfxapp:quarkusDevRuntimeClasspathConfigurationDeployment'
configuration ':jfxapp:quarkusDevRuntimeClasspathConfigurationPlatform'
configuration ':jfxapp:quarkusGeneratedSourcesAnnotationProcessor'
configuration ':jfxapp:quarkusGeneratedSourcesCompileClasspath'
configuration ':jfxapp:quarkusGeneratedSourcesCompileOnly'
configuration ':jfxapp:quarkusGeneratedSourcesImplementation'
configuration ':jfxapp:quarkusGeneratedSourcesRuntimeClasspath'
configuration ':jfxapp:quarkusGeneratedSourcesRuntimeOnly'
configuration ':jfxapp:quarkusProdBaseRuntimeClasspathConfiguration'
configuration ':jfxapp:quarkusProdRuntimeClasspathConfiguration'
configuration ':jfxapp:quarkusProdRuntimeClasspathConfigurationDeployment'
configuration ':jfxapp:quarkusProdRuntimeClasspathConfigurationPlatform'
configuration ':jfxapp:quarkusTestBaseRuntimeClasspathConfiguration'
configuration ':jfxapp:quarkusTestGeneratedSourcesAnnotationProcessor'
configuration ':jfxapp:quarkusTestGeneratedSourcesCompileClasspath'
configuration ':jfxapp:quarkusTestGeneratedSourcesCompileOnly'
configuration ':jfxapp:quarkusTestGeneratedSourcesImplementation'
configuration ':jfxapp:quarkusTestGeneratedSourcesRuntimeClasspath'
configuration ':jfxapp:quarkusTestGeneratedSourcesRuntimeOnly'
configuration ':jfxapp:quarkusTestRuntimeClasspathConfiguration'
configuration ':jfxapp:quarkusTestRuntimeClasspathConfigurationDeployment'
configuration ':jfxapp:quarkusTestRuntimeClasspathConfigurationPlatform'
configuration ':jfxapp:runtimeClasspath'
configuration ':jfxapp:runtimeElements'
configuration ':jfxapp:runtimeOnly'
configuration ':jfxapp:testAnnotationProcessor'
configuration ':jfxapp:testCompileClasspath'
configuration ':jfxapp:testCompileOnly'
configuration ':jfxapp:testImplementation'
configuration ':jfxapp:testResultsElementsForTest'
configuration ':jfxapp:testRuntimeClasspath'
configuration ':jfxapp:testRuntimeOnly'

I tried solving my problem adding the following (this is based on the solution provided to my previous question, which was the recommended way specified by the javafx-gradle-plugin) to my build script:

configurations.stream().forEach { configuration ->
    if (configuration.name.contains("quarkus")) {
        configuration.attributes {
            attribute(Usage.USAGE_ATTRIBUTE, objects.named<Usage>(Usage.JAVA_RUNTIME))
            attribute(OperatingSystemFamily.OPERATING_SYSTEM_ATTRIBUTE, objects.named<OperatingSystemFamily>("linux"))
            attribute(MachineArchitecture.ARCHITECTURE_ATTRIBUTE, objects.named<MachineArchitecture>("x86-64"))
        }
    }
}

Thad made me move forward but, to my surprise, I am getting the following error:

Execution failed for task ':jfxapp:compileJava'.
> Could not resolve all dependencies for configuration ':jfxapp:quarkusDependency'.
   > Could not resolve org.openjfx:javafx-controls:21.0.1.
     Required by:
         project :jfxapp
      > Cannot choose between the following variants of org.openjfx:javafx-controls:21.0.1:
          - linux-aarch64Runtime
          - linuxRuntime
          - mac-aarch64Runtime
          - macRuntime
          - runtime
          - winRuntime
        All of them match the consumer attributes:
          - Variant 'linux-aarch64Runtime' capability org.openjfx:javafx-controls:21.0.1:
              - Unmatched attributes:
                  - Provides org.gradle.category 'library' but the consumer didn't ask for it
                  - Provides org.gradle.libraryelements 'jar' but the consumer didn't ask for it
                  - Provides org.gradle.native.architecture 'aarch64' but the consumer didn't ask for it
                  - Provides org.gradle.native.operatingSystem 'linux' but the consumer didn't ask for it
                  - Provides org.gradle.status 'release' but the consumer didn't ask for it
                  - Provides org.gradle.usage 'java-runtime' but the consumer didn't ask for it
          - Variant 'linuxRuntime' capability org.openjfx:javafx-controls:21.0.1:
              - Unmatched attributes:
                  - Provides org.gradle.category 'library' but the consumer didn't ask for it
                  - Provides org.gradle.libraryelements 'jar' but the consumer didn't ask for it
                  - Provides org.gradle.native.architecture 'x86-64' but the consumer didn't ask for it
                  - Provides org.gradle.native.operatingSystem 'linux' but the consumer didn't ask for it
                  - Provides org.gradle.status 'release' but the consumer didn't ask for it
                  - Provides org.gradle.usage 'java-runtime' but the consumer didn't ask for it
          - Variant 'mac-aarch64Runtime' capability org.openjfx:javafx-controls:21.0.1:
              - Unmatched attributes:
                  - Provides org.gradle.category 'library' but the consumer didn't ask for it
                  - Provides org.gradle.libraryelements 'jar' but the consumer didn't ask for it
                  - Provides org.gradle.native.architecture 'aarch64' but the consumer didn't ask for it
                  - Provides org.gradle.native.operatingSystem 'macos' but the consumer didn't ask for it
                  - Provides org.gradle.status 'release' but the consumer didn't ask for it
                  - Provides org.gradle.usage 'java-runtime' but the consumer didn't ask for it
          - Variant 'macRuntime' capability org.openjfx:javafx-controls:21.0.1:
              - Unmatched attributes:
                  - Provides org.gradle.category 'library' but the consumer didn't ask for it
                  - Provides org.gradle.libraryelements 'jar' but the consumer didn't ask for it
                  - Provides org.gradle.native.architecture 'x86-64' but the consumer didn't ask for it
                  - Provides org.gradle.native.operatingSystem 'macos' but the consumer didn't ask for it
                  - Provides org.gradle.status 'release' but the consumer didn't ask for it
                  - Provides org.gradle.usage 'java-runtime' but the consumer didn't ask for it
          - Variant 'runtime' capability org.openjfx:javafx-controls:21.0.1:
              - Unmatched attributes:
                  - Provides org.gradle.category 'library' but the consumer didn't ask for it
                  - Provides org.gradle.libraryelements 'jar' but the consumer didn't ask for it
                  - Provides org.gradle.status 'release' but the consumer didn't ask for it
                  - Provides org.gradle.usage 'java-runtime' but the consumer didn't ask for it
          - Variant 'winRuntime' capability org.openjfx:javafx-controls:21.0.1:
              - Unmatched attributes:
                  - Provides org.gradle.category 'library' but the consumer didn't ask for it
                  - Provides org.gradle.libraryelements 'jar' but the consumer didn't ask for it
                  - Provides org.gradle.native.architecture 'x86-64' but the consumer didn't ask for it
                  - Provides org.gradle.native.operatingSystem 'windows' but the consumer didn't ask for it
                  - Provides org.gradle.status 'release' but the consumer didn't ask for it
                  - Provides org.gradle.usage 'java-runtime' but the consumer didn't ask for it

The interesting part is that the configuration ‘:jfxapp:quarkusDependency’ was not printed in my list, and I don’t now how to get a reference to it.
Writing:

configurations.named("quarkusDependency") {}

or

configurations.named(":jfxapp:quarkusDependency") {}

give me the errors:
Configuration with name ‘quarkusDependency’ not found.
and Configuration with name ‘:jfxapp:quarkusDependency’ not found.

My questions are:

1 - Is it possible to get a reference to the configuration ‘quarkusDependency’ to apply the solution that worked for all the other ‘quarkus’ configurations? Why was not part of my configuration list?

2 - The gradle documentation in the section named Attribute disambiguation rules mentions that the process is called disambiguation and can be done implementing an attribute disambiguation rule that have to be registered via the attribute matching strategy that you can obtain from the attributes schema, which is a member of DependencyHandler.
Unfortunately the documentation doesn’t show any examples on how to do this.
Is there a way to implement an AttributeDisambiguationRule for the whole project so whenever any configuration requires anything from JavaFX I can make the selection programatically?
Thanks!

2

I don’t think you should mess with the disambiguation rules, nor would it really help in this case.
Also the title of the thread is a bit misleading, you are not talking about tasks, but configurations.
By using configurations.stream() you are eagerly handling only configurations that are existing currently, same with .named.
So I guess the configuration is simply added after your try to configure it.
It might also be a bad idea to just big-hammer configure all configurations that contain some string in the name.
If you really not want to do it explicitly, you should probably at least only do it on resolvable configurations, as the attributes should only be relevant for those.
Combined with also configuring configurations that are added after your code, you probably want something like

configurations
    .matching { it.isCanBeResolved && it.name.contains("quarkus") }
    .configureEach { ... }

or something like that.

1 Like
3

Thank you @Vampire, matching the configurations with resolved ones did the trick

1 Like