Poc

.circleci/config.yml

@@ -0,0 +1,19 @@
+version: 2.1
+jobs:
+  build:
+    machine:
+      # https://circleci.com/docs/2.0/configuration-reference/#available-machine-images
+      image: ubuntu-2004:202101-01
+
+    working_directory: ~/akka-safer-serializer
+
+    steps:
+      - checkout
+
+      # -batch is necessary to make sure sbt doesn't stall waiting for user input in case of certain failures
+      - run: echo '-batch' >> .sbtopts
+      - run: sbt update
+      - run: sbt scalafmtCheckAll
+      - run: sbt compile
+      - run: sbt test:compile
+      - run: sbt test

.gitignore

@@ -1,2 +1,15 @@
 *.class
 *.log
+
+.bsp/
+.idea/
+
+dist/*
+target/
+lib_managed/
+src_managed/
+project/boot/
+project/plugins/project/
+.history
+.cache
+.lib/

.scalafmt.conf

@@ -0,0 +1,53 @@
+version = 2.6.4
+
+style = defaultWithAlign
+
+docstrings                 = JavaDoc
+indentOperator.preset      = spray
+maxColumn                  = 120
+rewrite.rules              = [RedundantParens, AvoidInfix]
+unindentTopLevelOperators  = true
+align.tokens               = [{code = "=>", owner = "Case"}]
+align.openParenDefnSite    = false
+align.openParenCallSite    = false
+optIn.breakChainOnFirstMethodDot = false
+optIn.configStyleArguments   = false
+danglingParentheses.defnSite = false
+danglingParentheses.callSite = false
+rewrite.neverInfix.excludeFilters = [
+  and
+  min
+  max
+  until
+  to
+  by
+  eq
+  ne
+  "should.*"
+  "contain.*"
+  "must.*"
+  in
+  ignore
+  be
+  taggedAs
+  thrownBy
+  synchronized
+  have
+  when
+  size
+  only
+  noneOf
+  oneElementOf
+  noElementsOf
+  atLeastOneElementOf
+  atMostOneElementOf
+  allElementsOf
+  inOrderElementsOf
+  theSameElementsAs
+  message
+]
+rewriteTokens = {
+  "⇒": "=>"
+  "→": "->"
+  "←": "<-"
+}

build.sbt

@@ -0,0 +1,31 @@
+import Dependencies._
+import org.scalafmt.sbt.ScalafmtPlugin.autoImport.scalafmtOnCompile
+
+ThisBuild / scalaVersion := "2.12.13"
+ThisBuild / version := "0.1.0-SNAPSHOT"
+ThisBuild / organization := "org.virtuslab"
+ThisBuild / organizationName := "VirtusLab"
+Global / onChangedBuildSource := ReloadOnSourceChanges
+
+lazy val root = (project in file("."))
+  .settings(
+    name := "akka-safer-serializer",
+    scalafmtOnCompile := true,
+    scalacOptions ++= Seq(
+      "-deprecation",
+      "-encoding",
+      "UTF-8",
+      "-feature",
+      "-language:_",
+      "-Xfatal-warnings",
+      "-Xlog-reflective-calls",
+      "-Xlint:_",
+      "-Ybackend-parallelism",
+      "8",
+      "-Ywarn-dead-code",
+      "-Ywarn-unused:-imports,_",
+      "-unchecked"),
+    libraryDependencies ++= deps
+  )
+
+// See https://www.scala-sbt.org/1.x/docs/Using-Sonatype.html for instructions on how to publish to Sonatype.

project/Dependencies.scala

@@ -0,0 +1,33 @@
+import sbt._
+
+object Dependencies {
+  val borerVersion = "1.6.3"
+  val akkaVersion = "2.6.13"
+
+  val scalaTest = "org.scalatest" %% "scalatest" % "3.2.2"
+  val akkaTyped = "com.typesafe.akka" %% "akka-actor-typed" % akkaVersion
+  val akkaTestKit = "com.typesafe.akka" %% "akka-actor-testkit-typed" % akkaVersion
+  val akkaStream = "com.typesafe.akka" %% "akka-stream" % akkaVersion
+  val akkaStreamTestKit = "com.typesafe.akka" %% "akka-stream-testkit" % akkaVersion
+
+  val enumeratum = "com.beachape" %% "enumeratum" % "1.6.1"
+
+  val borerCore = "io.bullet" %% "borer-core" % borerVersion
+  val borerDerivation = "io.bullet" %% "borer-derivation" % borerVersion
+  val borerAkka = "io.bullet" %% "borer-compat-akka" % borerVersion
+
+  val reflections = "net.oneandone.reflections8" % "reflections8" % "0.11.7"
+
+  val deps = Seq(
+    scalaTest % Test,
+    akkaTestKit % Test,
+    akkaStreamTestKit % Test,
+    akkaTyped % Provided,
+    akkaStream % Provided,
+    enumeratum % Test,
+    borerCore,
+    borerDerivation,
+    borerAkka,
+    reflections
+  )
+}

project/build.properties

@@ -0,0 +1 @@
+sbt.version=1.4.9

project/plugins.sbt

@@ -0,0 +1 @@
+addSbtPlugin("org.scalameta" % "sbt-scalafmt" % "2.4.2")

src/main/scala/org/virtuslab/akkasaferserializer/BorerAkkaSerializer.scala

@@ -0,0 +1,57 @@
+package org.virtuslab.akkasaferserializer
+
+import akka.serialization.Serializer
+import io.bullet.borer.{Cbor, Codec, Decoder, Encoder}
+
+import java.util.concurrent.atomic._
+import scala.reflect.ClassTag
+
+trait BorerAkkaSerializer[Ser] extends Serializer {
+
+  private val registrations = new AtomicReference[List[(Class[_], Codec[_])]](List.empty)
+
+  //noinspection UnitMethodIsParameterless
+  protected def register[T <: Ser: Encoder: Decoder: ClassTag]: Unit = {
+    registrations.getAndAccumulate(List(scala.reflect.classTag[T].runtimeClass -> Codec.of[T]), _ ++ _)
+  }
+
+  override def includeManifest: Boolean = true
+
+  override def toBinary(o: AnyRef): Array[Byte] = {
+    val codec = getCodec(o.getClass, "encoder")
+    val encoder = codec.encoder.asInstanceOf[Encoder[AnyRef]]
+    Cbor.encode(o)(encoder).toByteArray
+  }
+
+  override def fromBinary(bytes: Array[Byte], manifest: Option[Class[_]]): AnyRef = {
+    val codec = getCodec(manifest.get, "decoder")
+    val decoder = codec.decoder.asInstanceOf[Decoder[AnyRef]]
+    Cbor.decode(bytes).to[AnyRef](decoder).value
+  }
+
+  private def getCodec(clazzToFind: Class[_], item: String): Codec[_] = {
+    registrations
+      .get()
+      .collectFirst {
+        case (clazz, codec) if clazz.isAssignableFrom(clazzToFind) => codec
+      }
+      .getOrElse {
+        throw new RuntimeException(s"$item for $clazzToFind is not registered")
+      }
+  }
+
+  protected def runtimeChecks(cl: Class[_]): Unit = {
+    import org.reflections8.Reflections
+    import scala.collection.convert.ImplicitConversions._
+
+    val reflections = new Reflections()
+
+    def findAllObjects[T](cl: Class[T]): Seq[Class[_ <: T]] = reflections.getSubTypesOf(cl).toSeq
+
+    val found = findAllObjects(cl)
+
+    val foundClasses = found.filterNot(_.isInterface)
+
+    foundClasses.foreach(getCodec(_, "codec"))
+  }
+}

src/main/scala/org/virtuslab/akkasaferserializer/StandardCodecs.scala

@@ -0,0 +1,47 @@
+package org.virtuslab.akkasaferserializer
+
+import akka.actor
+import akka.actor.typed.{ActorRef, ActorRefResolver, ActorSystem}
+import akka.serialization.Serialization
+import akka.stream.{SinkRef, SourceRef, StreamRefResolver}
+import io.bullet.borer.Codec
+
+import java.io.{ByteArrayInputStream, ByteArrayOutputStream, ObjectInputStream, ObjectOutputStream}
+import java.time.OffsetDateTime
+
+object StandardCodecs {
+
+  implicit def sinkRefCodec[T](implicit system: actor.ActorSystem = serializationSystem): Codec[SinkRef[T]] = {
+    val resolver = StreamRefResolver(ActorSystem.wrap(system))
+
+    Codec.bimap[String, SinkRef[T]](resolver.toSerializationFormat(_: SinkRef[T]), resolver.resolveSinkRef)
+  }
+
+  implicit def sourceRefCodec[T](implicit system: actor.ActorSystem = serializationSystem): Codec[SourceRef[T]] = {
+    val resolver = StreamRefResolver(ActorSystem.wrap(system))
+
+    Codec.bimap[String, SourceRef[T]](resolver.toSerializationFormat(_: SourceRef[T]), resolver.resolveSourceRef)
+  }
+
+  private def serializationSystem: actor.ActorSystem = Serialization.getCurrentTransportInformation().system
+
+  implicit val offsetDateTimeCodec: Codec[OffsetDateTime] =
+    Codec.bimap[Array[Byte], OffsetDateTime](
+      serializeSerializable[OffsetDateTime],
+      deserializeSerializable[OffsetDateTime])
+
+  private def serializeSerializable[T <: java.io.Serializable](ser: T): Array[Byte] = {
+    val os = new ByteArrayOutputStream()
+    val oos = new ObjectOutputStream(os)
+    oos.writeObject(ser)
+    oos.close()
+    os.toByteArray
+  }
+
+  private def deserializeSerializable[T <: java.io.Serializable](buffer: Array[Byte]): T = {
+    val ois = new ObjectInputStream(new ByteArrayInputStream(buffer))
+    val ser = ois.readObject.asInstanceOf[T]
+    ois.close()
+    ser
+  }
+}

src/test/resources/application.conf

@@ -0,0 +1,10 @@
+akka.actor {
+  serializers {
+    borer-cbor = "org.virtuslab.akkasaferserializer.serializer.TestBorerAkkaSerializer"
+  }
+  serialization-bindings {
+    "org.virtuslab.akkasaferserializer.data.BorerSerializable" = borer-cbor
+  }
+  enable-additional-serialization-bindings = on
+  allow-java-serialization = off
+}

src/test/scala/org/virtuslab/akkasaferserializer/AkkaStreamSerializerSpec.scala

@@ -0,0 +1,40 @@
+package org.virtuslab.akkasaferserializer
+
+import akka.{Done, NotUsed}
+import akka.actor.testkit.typed.scaladsl.{ActorTestKit, SerializationTestKit}
+import akka.actor.typed.ActorSystem
+import akka.pattern.pipe
+import akka.stream.{Materializer, SinkRef, SourceRef}
+import akka.stream.scaladsl.{Sink, Source, StreamRefs}
+import com.typesafe.config.ConfigFactory
+import org.scalatest.matchers.should.Matchers
+import org.scalatest.wordspec.AnyWordSpecLike
+import org.virtuslab.akkasaferserializer.data.CodecsData.{SinkRefClass, SourceRefClass}
+
+import scala.concurrent.Future
+
+class AkkaStreamSerializerSpec extends AnyWordSpecLike with Matchers {
+
+  "BorerAkkaSerializer" should {
+
+    val config = ConfigFactory.load()
+    val testKit: ActorTestKit = ActorTestKit(config)
+    val system: ActorSystem[Nothing] = testKit.system
+    val serializationTestKit = new SerializationTestKit(system)
+
+    implicit val materializer: Materializer = Materializer.createMaterializer(system)
+
+    "serialize class with SourceRef" in {
+      val source: Source[Int, NotUsed] = Source(1 to 100)
+      val ref: SourceRef[Int] = source.runWith(StreamRefs.sourceRef())
+      serializationTestKit.verifySerialization(SourceRefClass(ref))
+    }
+
+    "serialize class with SinkRef" in {
+      val sink: Sink[Int, Future[Int]] = Sink.fold[Int, Int](0)(_ + _)
+      val ref: SinkRef[Int] = StreamRefs.sinkRef[Int]().to(sink).run()
+      serializationTestKit.verifySerialization(SinkRefClass(ref))
+    }
+
+  }
+}

src/test/scala/org/virtuslab/akkasaferserializer/TestBorerAkkaSerializerSpec.scala

@@ -0,0 +1,45 @@
+package org.virtuslab.akkasaferserializer
+
+import akka.actor.testkit.typed.scaladsl.{ActorTestKit, SerializationTestKit}
+import akka.actor.typed.ActorSystem
+import com.typesafe.config.ConfigFactory
+import org.virtuslab.akkasaferserializer.data.Animal.{Lion, Tiger}
+import org.virtuslab.akkasaferserializer.data.Zoo.{GreetingZoo, NorthZoo}
+import org.scalatest.matchers.should.Matchers
+import org.scalatest.wordspec.AnyWordSpecLike
+import org.virtuslab.akkasaferserializer.data.CodecsData.DateTimeClass
+import org.virtuslab.akkasaferserializer.data.Greeting
+
+import java.time.OffsetDateTime
+
+class TestBorerAkkaSerializerSpec extends AnyWordSpecLike with Matchers {
+
+  "BorerAkkaSerializer" should {
+
+    val config = ConfigFactory.load()
+    val testKit: ActorTestKit = ActorTestKit(config)
+    val system: ActorSystem[Nothing] = testKit.system
+    val serializationTestKit = new SerializationTestKit(system)
+
+    "serialize singleton" in {
+      serializationTestKit.verifySerialization(Tiger)
+    }
+
+    "serialize final case class" in {
+      serializationTestKit.verifySerialization(Lion("lion"))
+    }
+
+    "serialize nested case class" in {
+      serializationTestKit.verifySerialization(NorthZoo(Lion("lion")))
+    }
+
+    "serialize case class with enumeration" in {
+      serializationTestKit.verifySerialization(GreetingZoo(Lion("lion"), Greeting.Hello))
+    }
+
+    "serialize case class with additional codecs form StandardCodecs" in {
+      serializationTestKit.verifySerialization(DateTimeClass(OffsetDateTime.now()))
+    }
+  }
+
+}

src/test/scala/org/virtuslab/akkasaferserializer/data/BorerSerializable.scala

@@ -0,0 +1,3 @@
+package org.virtuslab.akkasaferserializer.data
+
+trait BorerSerializable

src/test/scala/org/virtuslab/akkasaferserializer/data/CodecsData.scala

@@ -0,0 +1,15 @@
+package org.virtuslab.akkasaferserializer.data
+
+import akka.stream.{SinkRef, SourceRef}
+
+import java.time.OffsetDateTime
+
+sealed trait CodecsData extends BorerSerializable
+
+object CodecsData {
+  case class DateTimeClass(offsetDateTime: OffsetDateTime) extends CodecsData
+
+  case class SourceRefClass(ref: SourceRef[Int]) extends CodecsData
+
+  case class SinkRefClass(ref: SinkRef[Int]) extends CodecsData
+}