pottering about with making a docker-compose plugin

buildSrc/src/main/kotlin/dev/adamko/kafkatorio/infra/docker-compose.gradle.kts

@@ -45,10 +45,8 @@ val dockerRemove by tasks.registering(Exec::class) {
 }
 
 
-afterEvaluate {
-  tasks.named("processRun") { dependsOn(dockerUp, dockerEnvUpdate) }
-  tasks.named("processKill") { dependsOn(dockerDown) }
-}
+tasks.matching { it.name == "processRun" }.configureEach { dependsOn(dockerUp, dockerEnvUpdate) }
+tasks.matching { it.name == "processKill" }.configureEach { dependsOn(dockerDown) }
 
 
 val dockerEnvUpdate by tasks.registering(DockerEnvUpdateTask::class) {

buildSrc/src/main/kotlin/dev/adamko/kafkatorio/task/DockerComposeExec.kt

@@ -23,6 +23,7 @@ import org.gradle.work.NormalizeLineEndings
 import org.jetbrains.kotlin.util.parseSpaceSeparatedArgs
 
 @CacheableTask
+@Suppress("UnstableApiUsage")
 abstract class DockerComposeExec @Inject constructor(
   private val executor: ExecOperations,
   private val objects: ObjectFactory,
@@ -57,8 +58,9 @@ abstract class DockerComposeExec @Inject constructor(
     group = DOCKER_COMPOSE_GROUP
     logging.captureStandardOutput(LogLevel.LIFECYCLE)
 
-    super.onlyIf {
-      it is DockerComposeExec && it.dockerIsActive.getOrElse(false)
+    super.onlyIf { task ->
+      require(task is DockerComposeExec)
+      task.dockerIsActive.getOrElse(false)
     }
   }
 

gradle-plugins/docker-compose/build.gradle.kts

@@ -0,0 +1,36 @@
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+plugins {
+  kotlin("jvm") version embeddedKotlinVersion
+  `kotlin-dsl`
+  `java-gradle-plugin`
+}
+
+val gradleJvmTarget = "11"
+
+dependencies {
+  implementation(platform(libs.kotlin.bom))
+  implementation("org.jetbrains.kotlin:kotlin-compiler-embeddable")
+}
+
+kotlin {
+  jvmToolchain {
+    (this as JavaToolchainSpec).languageVersion.set(JavaLanguageVersion.of(gradleJvmTarget))
+  }
+}
+
+tasks.withType<KotlinCompile>().configureEach {
+  kotlinOptions {
+    jvmTarget = gradleJvmTarget
+  }
+}
+
+gradlePlugin {
+  plugins {
+    create("geedeecee") {
+      id = "dev.adamko.geedeecee"
+      displayName = "geedeecee - Gradle Docker Compose"
+      implementationClass = "dev.adamko.geedeecee.GDCPlugin"
+    }
+  }
+}

gradle-plugins/docker-compose/settings.gradle.kts

@@ -0,0 +1,18 @@
+rootProject.name = "docker-compose"
+
+pluginManagement {
+  @Suppress("UnstableApiUsage")
+  includeBuild("../settings-plugins/")
+}
+
+plugins {
+  id("kafkatorio.convention.settings.repositories")
+}
+
+ dependencyResolutionManagement {
+  versionCatalogs {
+    create("libs") {
+      from(files("../../gradle/libs.versions.toml"))
+    }
+  }
+}

gradle-plugins/docker-compose/src/main/kotlin/dev/adamko/geedeecee/GDCPlugin.kt

@@ -0,0 +1,48 @@
+package dev.adamko.geedeecee
+
+import javax.inject.Inject
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.file.ProjectLayout
+import org.gradle.api.provider.ProviderFactory
+import org.gradle.kotlin.dsl.create
+import org.jetbrains.kotlin.util.parseSpaceSeparatedArgs
+
+
+abstract class GDCPlugin @Inject constructor(
+  private val providers: ProviderFactory,
+  private val layout: ProjectLayout,
+) : Plugin<Project> {
+
+
+  override fun apply(target: Project) {
+    target.createSettings()
+  }
+
+
+  private fun Project.createSettings(): GDCSettings =
+    extensions.create<GDCSettings>(GDC_EXTENSION_NAME).apply {
+      composeProjectName.convention(providers.provider { project.name })
+      srcDir.convention(layout.projectDirectory.dir("docker"))
+
+      dotEnv.put("COMPOSE_PROJECT_NAME", composeProjectName)
+      dotEnv.put("PROJECT_VERSION", providers.provider { project.version.toString() })
+      dotEnv.put("REGISTRY_HOST", providers.gradleProperty("dockerContainerRegistryHost"))
+
+      enabled.convention(
+        providers.exec {
+          commandLine = parseSpaceSeparatedArgs("docker info")
+          isIgnoreExitValue = true
+        }.result.map {
+          it.exitValue == 0
+        }
+      )
+    }
+
+
+  companion object {
+    const val GDC_EXTENSION_NAME = "geedeecee"
+    const val GCD_TASK_GROUP = "docker-compose"
+  }
+
+}

gradle-plugins/docker-compose/src/main/kotlin/dev/adamko/geedeecee/GDCSettings.kt

@@ -0,0 +1,68 @@
+package dev.adamko.geedeecee
+
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.provider.MapProperty
+import org.gradle.api.provider.Property
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.Internal
+
+interface GDCSettings {
+
+  @get:Input
+  val composeProjectName: Property<String>
+
+  @get:Internal
+  val srcDir: DirectoryProperty
+
+  @get:Input
+  val dotEnv: MapProperty<String, String>
+
+  @get:Input
+  val enabled: Property<Boolean>
+
+//  @Suppress("PropertyName", "FunctionName")
+//  abstract class DotEnv(
+//    private val dotEnv: MapProperty<String, String>,
+//    private val providers: ProviderFactory,
+//  ) {
+//    var COMPOSE_API_VERSION: Provider<String> by dotEnv
+//    fun COMPOSE_API_VERSION(value: () -> String) {
+//      COMPOSE_API_VERSION = providers.provider(value)
+//    }
+//    //    var COMPOSE_CONVERT_WINDOWS_PATHS: String
+////    var COMPOSE_FILE: String
+////    var COMPOSE_HTTP_TIMEOUT: String
+////    var COMPOSE_PROFILES: String
+////    var COMPOSE_PROJECT_NAME: String
+////    var COMPOSE_TLS_VERSION: String
+////    var DOCKER_CERT_PATH: String
+////    var DOCKER_HOST: String
+////    var DOCKER_TLS_VERIFY: String
+//    fun setComposeApiVersion(composeApiVersion: String) {}
+//    fun setComposeConvertWindowsPaths(composeConvertWindowsPaths: String) {}
+//    fun setComposeFile(composeFile: String) {}
+//    fun setComposeHttpTimeout(composeHttpTimeout: String) {}
+//    fun setComposeProfiles(composeProfiles: String) {}
+//    fun setComposeProjectName(composeProjectName: String) {}
+//    fun setComposeTlsVersion(composeTlsVersion: String) {}
+//    fun setDockerCertPath(dockerCertPath: String) {}
+//    fun setDockerHost(dockerHost: String) {}
+//    fun setDockerTlsVerify(dockerTlsVerify: String) {}
+//  }
+
+}
+//
+//private operator fun <PV : Provider<String>> MapProperty<String, String>.setValue(
+//  dotEnv: GDCSettings.DotEnv,
+//  property: KProperty<*>,
+//  v: PV
+//) {
+//  put(property.name, v)
+//}
+//
+//private operator fun MapProperty<String, String>.getValue(
+//  dotEnv: GDCSettings.DotEnv,
+//  property: KProperty<*>
+//): Provider<String> {
+//  return getting(property.name)
+//}

settings.gradle.kts

@@ -8,6 +8,7 @@ pluginManagement {
 
 
 includeBuild("./gradle-plugins/builder-plugins/")
+includeBuild("./gradle-plugins/docker-compose/")
 includeBuild("./gradle-plugins/factorio-mod-manager/")