I’ve defined Gradle Task in my root gradle scipt w...

# gradle

[Charlie Tapping]

I’ve defined Gradle Task in my root gradle scipt which works

tasks.register<Exec>("skynet") {
    dependsOn(":bin:nativeBinaries")

    val bin = "./bin/build/bin/native/debugExecutable/skynet.kexe"

    executable = "sh"
    args = listOf("-c", bin)
}

However I wanted to declare it like so

val nativeBinaries by project("bin").tasks.existing
val nativeBinaries by tasks.existing
tasks.register<Exec>("skynet") {
    dependsOn(nativeBinaries)

But I can’t seem to get a reference to it?
For context the nativeBinaries task exists in a kotlin native submodule called “bin”

[Adam S]

accessing the tasks and configurations of another subproject will usually lead to hard to diagnose problems

• https://docs.gradle.org/8.1/userguide/authoring_maintainable_build_scripts.html#sec:avoiding_inter_project_configuration
• https://docs.gradle.org/8.1/userguide/sharing_build_logic_between_subprojects.html#sec:convention_plugins_vs_cross_configuration
• https://docs.gradle.org/8.1/userguide/multi_project_configuration_and_execution.html#sec:decoupled_projects

[Adam S]

if you zoom out on your problem, can you explain what you’re trying to achieve? What does skynet.kexe do? Why are you trying to run it in a separate project?

[Charlie Tapping]

I feel like we should be okay here because the root project isn’t configuring any subprojects, instead I’m trying to declare a task which when executed triggers a subproject task

[Charlie Tapping]

So this is my project structure

[Charlie Tapping]

------------------------------------------------------------
Root project ‘skynet’
------------------------------------------------------------

Root project ‘skynet’
+--- Project ‘:bin’
\--- Project ‘:lib’

[Charlie Tapping]

bin is a kotlin native module

[ephemient]

depending on a task is not the same as depending on a task's outputs, even within the same project

[ephemient]

don't do that. use the proper way of exporting configurations/artifacts

[Charlie Tapping]

I want to ensure that specifically the kotlin native task nativeBinaries is ran before i try to exec one of its outputs

[Charlie Tapping]

This is the full command

[Charlie Tapping]

tasks.register<Exec>("skynet") {
    dependsOn(":bin:nativeBinaries")

    val bin = "./bin/build/bin/native/debugExecutable/skynet.kexe"

    executable = "sh"
    args = listOf("-c", bin)
}

[Charlie Tapping]

So I would remove depends on and put what exactly

[Charlie Tapping]

?

[Adam S]

there’s a few different options, so it depends…

[Adam S]

if you want to depend on the compiled executable, then maybe set up variant-aware sharing https://docs.gradle.org/current/userguide/cross_project_publications.html#sec:variant-aware-sharing

or maybe use composite builds, so you can run the task directly https://docs.gradle.org/current/userguide/composite_builds.html#included_build_task_dependencies

or set up your :bin project so it doesn’t produce an executable, it produces a library. And then it the root project also set up Kotlin/Native, add a dependency on :bin, and a custom K/N target with an exec

This stuff can be really complicated in Gradle, but if you explained what’s going on, or what error you get, or why the task needs to be run in a separate subproject, then maybe there’s a better way

[Charlie Tapping]

Thank you for the help

[Charlie Tapping]

The wider on all of this was that I simply wanted to run the native executable from gradle but gradle skipping that task, I found that I could run it from cli though and then tried to call cli from gradle.

[Charlie Tapping]

The actual solution to the original problem was

[Charlie Tapping]

changing

[Charlie Tapping]

val nativeTarget = when {
hostOs == “Mac OS X” -> macosX64(“native”)

[Charlie Tapping]

to

[Charlie Tapping]

val nativeTarget = when {
hostOs == “Mac OS X” -> when (System.getProperty(“os.arch”)) {
“aarch64” -> macosArm64(“native”)
else -> macosX64(“native”)
}

[Charlie Tapping]

it turns out the intelli j wizard doesnt generate the right config for apple silicon targets

[ephemient]

https://melix.github.io/blog/2021/10/gradle-quickie-dependson.html dependsOn is the wrong thing regardless of whether it's in one project or not

[ephemient]

what you should do is to register every host binary type in the producer - the ones that can't be built on the current platform will be automatically disabled

[ephemient]

then pick out the right one for local execution

[ephemient]

e.g.

kotlin {
    for (target in listOf(linuxX64(), linuxArm64(), macosArm64(), macosX64(), mingwX64())) {
        target.binaries.executable {
            entryPoint("...")
        }
    }
}

you can configure executable { runTaskProvider?.configure { ... } } if you want to specify args or environment variables

[ephemient]

or, if you really want to run it from another project, export the binaries

kotlin {
    targets.withType<KotlinNativeTarget> {
        binaries.matching { it.outputKind == NativeOutputKind.EXECUTABLE }.all {
            artifacts.add(
                configurations.create("${[e-mail]}${name.capitalized()}") {
                    isCanBeConsumed = true
                    isCanBeResolved = false
                    attributes {
                        attribute(KotlinPlatformType.attribute, KotlinPlatformType.native)
                        attribute(KotlinNativeTarget.konanTargetAttribute, konanTarget.name)
                        attribute(KotlinNativeTarget.kotlinNativeBuildTypeAttribute, buildType.name)
                        attribute(Usage.USAGE_ATTRIBUTE, objects.named("native-binary"))
                    }
                }.name,
                this.linkTaskProvider
            )
        }
    }
}

and consume the specific one,

val hostSkynetBinary by configurations.creating {
    isCanBeConsumed = false
    isCanBeResolved = true
    attributes {
        attribute(KotlinPlatformType.attribute, KotlinPlatformType.native)
        attribute(KotlinNativeTarget.konanTargetAttribute, HostManager.host.name)
        attribute(KotlinNativeTarget.kotlinNativeBuildTypeAttribute, "DEBUG")
        attribute(Usage.USAGE_ATTRIBUTE, objects.named("native-binary"))
    }
}

dependencies {
    hostSkynetBinary(project(":bin"))
}

tasks.register("skynet", Exec::class) {
    inputs.files(hostSkynetBinary)
    commandLine("/bin/sh", "-c")
    argumentProviders.add { listOf("${hostSkynetBinary.singleFile}/*.kexe") }
}

[Charlie Tapping]

Wow thats super useful to know thank you, there is actually a pair of tasks for running the binaries generated. runDebugExecutableNative and runReleaseExecutableNative. It just I couldn’t get these working at first because of the wizard generated config which targeted x86 binaries