mucking around trying to get protoc working. I've finally got a task that downloads the exe...

modules/factorio-events-data-model/build.gradle.kts

@@ -1,52 +1,237 @@
+import org.gradle.api.DefaultTask
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.artifacts.ExternalDependency
+import org.gradle.api.plugins.ExtensionAware
+import org.gradle.api.provider.Property
+import org.gradle.api.tasks.TaskAction
+import org.gradle.kotlin.dsl.domainObjectContainer
+import org.gradle.kotlin.dsl.create
+import org.gradle.kotlin.dsl.withType
+import org.gradle.kotlin.dsl.property
+import org.gradle.nativeplatform.platform.internal.DefaultNativePlatform
+
 plugins {
-//  id("dev.adamko.factoriowebmap.archetype.base")
-//  kotlin("multiplatform")
-
-  id("dev.adamko.factoriowebmap.archetype.kotlin-jvm")
-
-  id("com.google.protobuf") version "0.8.17"
-
-
+  id("dev.adamko.factoriowebmap.archetype.base")
+  `kotlin-dsl`
 }
 
 val projectId: String by project.extra
 val buildDir: Directory = layout.buildDirectory.dir(projectId).get()
-val nodeModulesDir: Directory by project.extra
 
-//kotlin {
+dependencies {
+}
+
+
+class ProtocPlugin : Plugin<Project> {
+
+  override fun apply(project: Project) {
+
+    val protocConfig =
+      project.extensions.create("protocPluginConfig", ProtocPluginConfig::class, project)
+
+//    val protocDep: Configuration = project.configurations.create("protoc") {
+//      isVisible = false
+//      isCanBeConsumed = false
+//      isCanBeResolved = true
+//      isTransitive = false
 //
-//  js(IR) {
-//    binaries.executable()
-////    browser {
-////      commonWebpackConfig {
-////        cssSupport.enabled = true
-////      }
-////    }
-//
-//    nodejs()
-//    useCommonJs()
-//
-//    compilations["main"].apply {
-//      packageJson {
-//        customField(
-//          "scripts",
-//          mapOf(
-//            "build" to "tstl",
-//            "dev" to "tstl --watch",
-//          )
-//        )
+//      defaultDependencies {
+//        add(protocConfig.dependencyProvider())
 //      }
 //    }
+
+    project.tasks.register<ProtocPrepareTask>("protocPrepare") {
+
+    }
+
 //
-//  }
+//    val prepareTask = project.tasks.register<Sync>("protocPrepare") {
+//      group = "protoc"
 //
-//  jvm {
-//    compilations.all {
-//      kotlinOptions.jvmTarget = "11"
+//      val outputDir = project.rootProject.layout.projectDirectory.dir(".gradle/protoc")
+//
+//      outputs.dir(outputDir)
+//
+////      doLast {
+//      val protoc: File = protocDep.resolve().single()
+//      logger.lifecycle("protoc file $protoc")
+//
+//      from(protoc)
+//      into(outputDir)
+////      }
 //    }
-//    testRuns["test"].executionTask.configure {
-//      useJUnitPlatform()
-//    }
-//  }
 //
-//}
+//    project.tasks.build { dependsOn(prepareTask) }
+//
+//    val generateTask = project.tasks.create<Exec>("protocGenerate") {
+//      dependsOn(prepareTask)
+//    }
+
+//    val protocDeps = project.configurations.create("pbAndG") {
+//      this.let { config ->
+//
+//        config.isVisible = false
+//        config.isCanBeConsumed = false
+//        config.isCanBeResolved = true
+//        config.description = "protoc dependencies"
+//
+//        config.defaultDependencies {
+//          add(protocConfig.dependencyProvider())
+//        }
+//      }
+//
+//      val generatorsContainer =
+//        project.objects.domainObjectContainer(ProtocGenerationTask::class)
+//      protocConfig.extensions.add("protocGenerate", generatorsContainer)
+//
+//
+//      project.extensions.add("testingExtensionThingy", project.provider {
+//        DefaultNativePlatform.getCurrentOperatingSystem().toFamilyName()
+//      })
+//
+//      project.tasks.withType<ProtocGenerationTask> {
+//      }
+//
+//    }
+//
+  }
+}
+
+abstract class ProtocPluginConfig(private val project: Project) : java.io.Serializable {
+
+  val protocVersion: Property<String> =
+    project.objects.property(String::class).convention("3.9.2")
+
+  val protocGroup: Property<String> =
+    project.objects.property(String::class).convention("com.google.protobuf")
+
+  val protocArtifactName: Property<String> =
+    project.objects.property(String::class).convention("protoc")
+
+  val protocArtifactExtension: Property<String> =
+    project.objects.property(String::class).convention("exe")
+
+  /**
+   * Should return one of
+   *
+   * * `linux`
+   * * `osx`
+   * * `windows`
+   */
+  var osFamilyNameProvider: () -> String = {
+    DefaultNativePlatform.getCurrentOperatingSystem().toFamilyName()
+  }
+
+  /**
+   * Should return one of
+   *
+   * * `aarch_64`
+   * * `ppcle_64`
+   * * `x86_32`
+   * * `x86_64`
+   */
+  var architectureProvider: () -> String = {
+    DefaultNativePlatform.getCurrentArchitecture()
+      .name
+      .replace("-", "_")
+  }
+
+  /**
+   * Default: concatenate [osFamilyNameProvider] and [architectureProvider]
+   *
+   * Should return one of:
+   *
+   *  * `linux-aarch_64`
+   *  * `linux-ppcle_64`
+   *  * `linux-x86_64`
+   *  * `osx-x86_32`
+   *  * `osx-x86_64`
+   *  * `windows-x86_32`
+   */
+  var classifierProvider: () -> String = {
+    "${osFamilyNameProvider()}-${architectureProvider()}"
+  }
+
+  var dependencyProvider: () -> ExternalModuleDependency = {
+    project.dependencies.create(
+      group = protocGroup.get(),
+      name = protocArtifactName.get(),
+      version = protocVersion.get(),
+      classifier = classifierProvider(),
+      ext = protocArtifactExtension.get(),
+    )
+  }
+
+//  val generators = project.objects.domainObjectContainer(ProtocGenerationConfig::class)
+}
+
+abstract class ProtocGenerationConfig
+
+abstract class ProtocPrepareTask : DefaultTask() {
+
+  @get:OutputDirectory
+  val outputDirectory: DirectoryProperty = project.objects.directoryProperty()
+    .convention(project.rootProject.layout.projectDirectory.dir(".gradle/protoc"))
+
+  @get:OutputFile
+  val protocOutput: RegularFileProperty = project.objects.fileProperty()
+    .convention { outputDirectory.asFileTree.singleFile }
+
+  @Internal
+  val protocPluginConfig: Provider<ProtocPluginConfig> = project.provider {
+    project.extensions.getByType<ProtocPluginConfig>()
+  }
+
+  @Internal
+  val protocDependency: Provider<ExternalModuleDependency> = protocPluginConfig.map {
+    it.dependencyProvider()
+  }
+
+  init {
+    super.setGroup("protoc")
+  }
+
+
+  @TaskAction
+  fun prepare() {
+
+    val protocDep: Configuration = project.configurations.create("protoc") {
+      isVisible = false
+      isCanBeConsumed = false
+      isCanBeResolved = true
+      isTransitive = false
+
+      defaultDependencies {
+        add(protocDependency.get())
+      }
+    }
+
+    val resolvedProtocDep = protocDep.resolve()
+
+    require(resolvedProtocDep.singleOrNull() != null) {
+      "Expected to download a single protoc.exe, but got ${resolvedProtocDep.size}: ${resolvedProtocDep.joinToString()}"
+    }
+
+    project.sync {
+      from(resolvedProtocDep)
+      into(outputDirectory)
+    }
+  }
+}
+
+abstract class ProtocGenerationTask : DefaultTask() {
+
+  @TaskAction
+  fun generate() {
+    logger.lifecycle("generating protoc...")
+  }
+
+}
+
+
+apply<ProtocPlugin>()
+
+configure<ProtocPluginConfig> {
+}
+

modules/factorio-events-data-model/src/main/proto/FactorioServerLogRecord.proto

@@ -0,0 +1,94 @@
+syntax = "proto3";
+
+option optimize_for = LITE_RUNTIME;
+option java_multiple_files = true;
+
+package dev.adamko.factorioevents;
+
+import "google/protobuf/any.proto";
+import "google/protobuf/timestamp.proto";
+
+message FactorioServerLogRecord {
+  string mod_version = 1;
+  uint32 tick = 2;
+  string event_type = 3;
+  FactorioLuaObject data = 4;
+
+}
+
+message FactorioLuaObject {
+  string object_name = 1;
+  oneof data {
+    LuaControl lua_control = 2;
+  }
+}
+
+// https://lua-api.factorio.com/next/LuaControl.html
+message LuaControl {
+  bool is_player = 2;
+  uint32 surface_index = 3;
+  Position position = 4;
+  uint32 force_index = 5;
+
+  oneof subtype {
+    LuaPlayer player = 10;
+    LuaEntity entity = 11;
+  }
+}
+
+// https://lua-api.factorio.com/next/LuaPlayer.html
+message LuaPlayer {
+  uint32 index = 1; // unique ID
+  string name = 2;
+  repeated int32 data = 4 [packed = true];
+
+  Colour colour = 8;
+
+  bool is_connected = 10;
+  bool is_admin = 11;
+
+  uint32 afk_time_ticks = 100;
+  uint32 online_time_ticks = 101;
+  uint32 last_online_ticks = 102;
+}
+
+// https://lua-api.factorio.com/next/LuaEntity.html
+message LuaEntity {
+  uint32 unit_number = 1; // (optional) unique ID
+  string name = 2;
+  string type = 3;
+  string status = 4; // https://lua-api.factorio.com/next/defines.html#defines.entity_status
+
+  bool is_active = 8;
+  bool is_moving = 9;
+
+  uint32 player_index = 50; // (optional) The player connected to this character or nil if none.
+  uint32 last_user_index = 51; // (optional) The last player that changed any setting on this entity.
+
+  Colour colour = 100; // (optional)
+}
+
+message LuaSurface {
+  uint32 index = 1; // unique ID
+  string name = 2;
+  float daytime = 3;
+}
+
+message LuaForce {
+  uint32 index = 1; // unique ID
+  string force_name = 2;
+
+  repeated uint32 player_ids = 100 [packed = true];
+}
+
+message Position {
+  int32 x = 1;
+  int32  y = 2;
+}
+
+message Colour {
+  float red = 1;
+  float green = 2;
+  float blue = 3;
+  float alpha = 4;
+}