chore: generate sources for tck tests for Java SDK

build.sbt

@@ -167,12 +167,13 @@ lazy val sdkJavaTestKit = project
 //FIXME add scalasdk as package to tck, tck will test both java and scala sdk
 lazy val tck = project
   .in(file("tck"))
-  .dependsOn(sdkJava, sdkJavaTestKit % Test)
-  .enablePlugins(AkkaGrpcPlugin, PublicDockerImage)
+  .dependsOn(sdkJava, sdkJavaTestKit)
+  .enablePlugins(AkkaGrpcPlugin, PublicDockerImage, ReflectiveCodeGen)
   .settings(common)
   .settings(
     name := "akkaserverless-tck-java-sdk",
     akkaGrpcGeneratedLanguages := Seq(AkkaGrpc.Java),
+    ReflectiveCodeGen.copyUnmanagedSources := true,
     Compile / mainClass := Some("com.akkaserverless.javasdk.tck.JavaSdkTck"),
     dockerEnvVars += "HOST" -> "0.0.0.0",
     dockerExposedPorts += 8080)
@@ -220,7 +221,8 @@ lazy val codegenJavaCompilationTest = project
   .settings(
     (publish / skip) := true,
     name := "akkaserverless-codegen-java-compilation-tests",
-    Compile / PB.protoSources += baseDirectory.value / ".." / ".." / "sbt-plugin" / "src" / "sbt-test" / "sbt-akkaserverless" / "compile-only" / "src" / "main" / "protobuf")
+    Compile / PB.protoSources += baseDirectory.value / ".." / ".." / "sbt-plugin" / "src" / "sbt-test" / "sbt-akkaserverless" / "compile-only" / "src" / "main" / "protobuf",
+    ReflectiveCodeGen.copyUnmanagedSources := false)
 
 lazy val javaValueentityCustomerRegistry = project
   .in(file("samples/java-valueentity-customer-registry"))

project/Dependencies.scala

@@ -112,8 +112,12 @@ object Dependencies {
   val sdkScalaTestKit = deps ++= Seq(testContainers, logback % "test;provided")
 
   val tck = deps ++= Seq(
-    akkaslsTckProtocol % "protobuf-src",
-    "com.akkaserverless" % "akkaserverless-tck-protocol" % AkkaServerless.FrameworkVersion % "protobuf-src",
+    // FIXME: For now TCK protos have been copied and adapted into this project.
+    //        Running the TCK is still meaningful as it runs the TCK check against the defined framework version.
+    //        Eventually, the final form of protos from should be backported to the framework.
+    //        See https://github.com/lightbend/akkaserverless-java-sdk/issues/605
+    //  akkaslsTckProtocol % "protobuf-src",
+    //  "com.akkaserverless" % "akkaserverless-tck-protocol" % AkkaServerless.FrameworkVersion % "protobuf-src",
     "ch.qos.logback" % "logback-classic" % LogbackVersion)
 
   val codegenCore = deps ++= Seq(

project/ReflectiveCodeGen.scala

@@ -1,13 +1,14 @@
 import sbt._
 import sbt.Keys._
 import sbt.Keys.streams
-
 import sbtprotoc.ProtocPlugin
 import ProtocPlugin.autoImport.PB
 import akka.grpc.sbt.AkkaGrpcPlugin
 import akka.grpc.sbt.AkkaGrpcPlugin.autoImport._
 import sbt.internal.inc.classpath.ClasspathUtilities
 
+import java.nio.file.{ Files, Path, Paths }
+
 /**
  * A plugin that allows to use a code generator compiled in one subproject to be used in a test project
  */
@@ -16,6 +17,10 @@ object ReflectiveCodeGen extends AutoPlugin {
   override def requires = AkkaGrpcPlugin
   override def trigger = noTrigger
 
+  val copyUnmanagedSources =
+    settingKey[Boolean](
+      "Flag to determine if code generation should copy generated unmanaged resources to the sourceDirectory directory if missing")
+
   override def projectSettings =
     Seq(
       Compile / akkaGrpcGeneratedLanguages := Seq(AkkaGrpc.Java),
@@ -25,8 +30,9 @@ object ReflectiveCodeGen extends AutoPlugin {
   def runAkkaServerlessCodegen(
       classpath: Classpath,
       protobufDescriptor: File,
+      srcDir: File,
       genSrcDir: File,
-      testSrcManaged: File,
+      genTestSrcDir: File,
       logger: Logger): Seq[File] = {
 
     val cp = classpath.map(_.data)
@@ -41,24 +47,24 @@ object ReflectiveCodeGen extends AutoPlugin {
       |import com.lightbend.akkasls.codegen.java.SourceGenerator
       |import scala.collection.immutable
       |
-      |(protobufDescriptor: java.io.File, genSrcDir: java.io.File, genTestSrcDir: java.io.File, logger: sbt.util.Logger) => {
-      |  
+      |(protobufDescriptor: java.io.File, srcDir: java.io.File, genSrcDir: java.io.File, genTestSrcDir: java.io.File, logger: sbt.util.Logger) => {
+      |
       |  val path = genSrcDir.toPath
       |  val testPath = genTestSrcDir.toPath
-      |  
+      |
       |  implicit val codegenLog = new com.lightbend.akkasls.codegen.Log {
       |      override def debug(message: String): Unit = logger.debug(message)
       |      override def info(message: String): Unit = logger.info(message)
       |    }
-      |  
+      |
       |  SourceGenerator
-      |    .generate(protobufDescriptor, path, testPath, testPath, path, testPath, "com.example.Main")
+      |    .generate(protobufDescriptor, srcDir.toPath, testPath, testPath, path, testPath, "com.example.Main")
       |    .map(_.toFile).to[immutable.Seq]
-      |}  
+      |}
       """.stripMargin
 
-    val generatorsF = tb.eval(tb.parse(source)).asInstanceOf[(File, File, File, sbt.util.Logger) => Seq[File]]
-    generatorsF(protobufDescriptor, genSrcDir, testSrcManaged, logger)
+    val generatorsF = tb.eval(tb.parse(source)).asInstanceOf[(File, File, File, File, sbt.util.Logger) => Seq[File]]
+    generatorsF(protobufDescriptor, srcDir, genSrcDir, genTestSrcDir, logger)
 
   }
 
@@ -68,23 +74,75 @@ object ReflectiveCodeGen extends AutoPlugin {
         val cp = (ProjectRef(file("."), "codegenJava") / Compile / fullClasspath).value
         val srcManaged = (Compile / sourceManaged).value
         val testSrcManaged = (Test / sourceManaged).value
+        val tmpUnmanaged = (Compile / temporaryUnmanagedDirectory).value
         val sbtLogger = streams.value.log
-        runAkkaServerlessCodegen(cp, protobufDescriptorSetOut.value, srcManaged, testSrcManaged, sbtLogger)
+        val generatedFiles =
+          runAkkaServerlessCodegen(
+            cp,
+            protobufDescriptorSetOut.value,
+            tmpUnmanaged,
+            srcManaged,
+            testSrcManaged,
+            sbtLogger)
+
+        if ((Compile / copyUnmanagedSources).value) // in this case use the files in the unmanaged source tree
+          generatedFiles.filterNot(_.getCanonicalPath.startsWith(tmpUnmanaged.getCanonicalPath))
+        else
+          generatedFiles // use files directly from the
       }
       .dependsOn(Compile / PB.generate)
 
   lazy val protobufDescriptorSetOut = settingKey[File]("The file to write the protobuf descriptor set to")
+  lazy val temporaryUnmanagedDirectory = settingKey[File]("Directory to generate 'unmanaged' sources into")
+  val generateUnmanaged = taskKey[Seq[File]](
+    "Generate \"unmanaged\" akkaserverless scaffolding code based on the available .proto definitions.\n" +
+    "These are the source files that are placed in the source tree, and after initial generation should typically be maintained by the user.\n" +
+    "Files that already exist they are not re-generated.")
+
   lazy val attachProtobufDescriptorSets = Seq(
     protobufDescriptorSetOut := (Compile / resourceManaged).value / "protobuf" / "descriptor-sets" / "user-function.desc",
     Compile / PB.generate := (Compile / PB.generate)
       .dependsOn(Def.task {
         protobufDescriptorSetOut.value.getParentFile.mkdirs()
       })
       .value,
+    Compile / temporaryUnmanagedDirectory := (Compile / baseDirectory).value / "target" / "akkaserverless-unmanaged",
     Compile / PB.protocOptions ++= Seq(
       "--descriptor_set_out",
       protobufDescriptorSetOut.value.getAbsolutePath,
       "--include_source_info"),
     Compile / managedResources += protobufDescriptorSetOut.value,
-    Compile / unmanagedResourceDirectories ++= (Compile / PB.protoSources).value)
+    Compile / unmanagedResourceDirectories ++= (Compile / PB.protoSources).value,
+    Compile / generateUnmanaged := {
+      if ((Compile / copyUnmanagedSources).value) {
+        Files.createDirectories(Paths.get((Compile / temporaryUnmanagedDirectory).value.toURI))
+        // Make sure generation has happened
+        val _ = (Compile / PB.generate).value
+        val managed = (Compile / managedSources).value
+        // Then copy over any new generated unmanaged sources
+        copyIfNotExist(
+          Paths.get((Compile / temporaryUnmanagedDirectory).value.toURI),
+          Paths.get((Compile / sourceDirectory).value.toURI).resolve("java")
+        ) // FIXME: copy java and scala separately
+      } else Seq.empty
+    },
+    Compile / unmanagedSources :=
+      (Compile / generateUnmanaged).value ++ (Compile / unmanagedSources).value)
+
+  // copied from AkkaserverlessPlugin.scala
+  private def copyIfNotExist(from: Path, to: Path): Seq[File] = {
+    Files
+      .walk(from)
+      .filter(Files.isRegularFile(_))
+      .flatMap[File](file => {
+        val target = to.resolve(from.relativize(file))
+        if (!Files.exists(target)) {
+          Files.createDirectories(target.getParent)
+          Files.copy(file, target)
+          java.util.stream.Stream.of[File](target.toFile)
+        } else java.util.stream.Stream.empty()
+      })
+      .toArray(new Array[File](_))
+      .toVector
+  }
 }

tck/src/main/java/com/akkaserverless/javasdk/tck/JavaSdkTck.java

@@ -21,16 +21,6 @@
 import com.akkaserverless.javasdk.eventsourcedentity.EventSourcedEntityOptions;
 import com.akkaserverless.javasdk.replicatedentity.ReplicatedEntityOptions;
 import com.akkaserverless.javasdk.replicatedentity.WriteConsistency;
-import com.akkaserverless.javasdk.tck.model.action.ActionTckModelBehavior;
-import com.akkaserverless.javasdk.tck.model.action.ActionTckModelBehaviorProvider;
-import com.akkaserverless.javasdk.tck.model.action.ActionTwoBehavior;
-import com.akkaserverless.javasdk.tck.model.action.ActionTwoBehaviorProvider;
-import com.akkaserverless.javasdk.tck.model.eventsourcedentity.EventSourcedConfiguredEntity;
-import com.akkaserverless.javasdk.tck.model.eventsourcedentity.EventSourcedConfiguredEntityProvider;
-import com.akkaserverless.javasdk.tck.model.eventsourcedentity.EventSourcedTckModelEntity;
-import com.akkaserverless.javasdk.tck.model.eventsourcedentity.EventSourcedTckModelEntityProvider;
-import com.akkaserverless.javasdk.tck.model.eventsourcedentity.EventSourcedTwoEntity;
-import com.akkaserverless.javasdk.tck.model.eventsourcedentity.EventSourcedTwoEntityProvider;
 import com.akkaserverless.javasdk.tck.model.localpersistenceeventing.EventSourcedEntityOne;
 import com.akkaserverless.javasdk.tck.model.localpersistenceeventing.EventSourcedEntityOneProvider;
 import com.akkaserverless.javasdk.tck.model.localpersistenceeventing.EventSourcedEntityTwo;
@@ -47,25 +37,31 @@
 import com.akkaserverless.javasdk.tck.model.replicatedentity.ReplicatedEntityTckModelEntityProvider;
 import com.akkaserverless.javasdk.tck.model.replicatedentity.ReplicatedEntityTwoEntity;
 import com.akkaserverless.javasdk.tck.model.replicatedentity.ReplicatedEntityTwoEntityProvider;
-import com.akkaserverless.javasdk.tck.model.valueentity.ValueEntityConfiguredEntity;
-import com.akkaserverless.javasdk.tck.model.valueentity.ValueEntityConfiguredEntityProvider;
-import com.akkaserverless.javasdk.tck.model.valueentity.ValueEntityTckModelEntity;
-import com.akkaserverless.javasdk.tck.model.valueentity.ValueEntityTckModelEntityProvider;
-import com.akkaserverless.javasdk.tck.model.valueentity.ValueEntityTwoEntity;
-import com.akkaserverless.javasdk.tck.model.valueentity.ValueEntityTwoEntityProvider;
+
 import com.akkaserverless.javasdk.tck.model.view.ViewTckModelBehavior;
 import com.akkaserverless.javasdk.tck.model.view.ViewTckModelBehaviorProvider;
 import com.akkaserverless.javasdk.tck.model.view.ViewTckSourceEntity;
 import com.akkaserverless.javasdk.tck.model.view.ViewTckSourceEntityProvider;
 import com.akkaserverless.javasdk.valueentity.ValueEntityOptions;
+import com.akkaserverless.tck.model.action.ActionTckModelActionProvider;
+import com.akkaserverless.tck.model.action.ActionTwoActionProvider;
+import com.akkaserverless.tck.model.action.ActionTckModelImpl;
+import com.akkaserverless.tck.model.action.ActionTwoImpl;
+import com.akkaserverless.tck.model.eventsourcedentity.EventSourcedConfiguredEntity;
+import com.akkaserverless.tck.model.eventsourcedentity.EventSourcedConfiguredEntityProvider;
+import com.akkaserverless.tck.model.eventsourcedentity.EventSourcedTckModelEntity;
+import com.akkaserverless.tck.model.eventsourcedentity.EventSourcedTckModelEntityProvider;
+import com.akkaserverless.tck.model.eventsourcedentity.EventSourcedTwoEntity;
+import com.akkaserverless.tck.model.eventsourcedentity.EventSourcedTwoEntityProvider;
+import com.akkaserverless.tck.model.valueentity.*;
 
 import java.time.Duration;
 
 public final class JavaSdkTck {
   public static AkkaServerless SERVICE =
       new AkkaServerless()
-          .register(ActionTckModelBehaviorProvider.of(ActionTckModelBehavior::new))
-          .register(ActionTwoBehaviorProvider.of(ActionTwoBehavior::new))
+          .register(ActionTckModelActionProvider.of(ActionTckModelImpl::new))
+          .register(ActionTwoActionProvider.of(ActionTwoImpl::new))
           .register(ValueEntityTckModelEntityProvider.of(ValueEntityTckModelEntity::new))
           .register(ValueEntityTwoEntityProvider.of(ValueEntityTwoEntity::new))
           .register(