CORDA-1140 - RPC Client's P2P Context should use AMQP (#2741)

client/rpc/src/main/kotlin/net/corda/client/rpc/internal/KryoClientSerializationScheme.kt

@@ -6,7 +6,7 @@ import net.corda.core.serialization.internal.SerializationEnvironment
 import net.corda.core.serialization.internal.SerializationEnvironmentImpl
 import net.corda.core.serialization.internal.nodeSerializationEnv
 import net.corda.core.utilities.ByteSequence
-import net.corda.nodeapi.internal.serialization.KRYO_P2P_CONTEXT
+import net.corda.nodeapi.internal.serialization.AMQP_P2P_CONTEXT
 import net.corda.nodeapi.internal.serialization.KRYO_RPC_CLIENT_CONTEXT
 import net.corda.nodeapi.internal.serialization.SerializationFactoryImpl
 import net.corda.nodeapi.internal.serialization.amqp.AMQPClientSerializationScheme
@@ -43,8 +43,8 @@ class KryoClientSerializationScheme : AbstractKryoSerializationScheme() {
                         registerScheme(KryoClientSerializationScheme())
                         registerScheme(AMQPClientSerializationScheme(emptyList()))
                     },
-                    KRYO_P2P_CONTEXT,
+                    AMQP_P2P_CONTEXT,
                     rpcClientContext = KRYO_RPC_CLIENT_CONTEXT)
         }
     }
-}
+}

core/src/test/kotlin/net/corda/core/utilities/KotlinUtilsTest.kt

@@ -6,7 +6,6 @@ import net.corda.core.serialization.CordaSerializable
 import net.corda.core.serialization.deserialize
 import net.corda.core.serialization.serialize
 import net.corda.nodeapi.internal.serialization.KRYO_CHECKPOINT_CONTEXT
-import net.corda.nodeapi.internal.serialization.KRYO_P2P_CONTEXT
 import net.corda.testing.core.SerializationEnvironmentRule
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.Rule
@@ -39,14 +38,6 @@ class KotlinUtilsTest {
         assertThat(copy.transientVal).isEqualTo(copyVal)
     }
 
-    @Test
-    fun `serialise transient property with non-capturing lambda`() {
-        expectedEx.expect(KryoException::class.java)
-        expectedEx.expectMessage("is not annotated or on the whitelist, so cannot be used in serialization")
-        val original = NonCapturingTransientProperty()
-        original.serialize(context = KRYO_P2P_CONTEXT)
-    }
-
     @Test
     fun `deserialise transient property with non-capturing lambda`() {
         expectedEx.expect(KryoException::class.java)
@@ -66,14 +57,6 @@ class KotlinUtilsTest {
         assertThat(copy.transientVal).startsWith("Hello")
     }
 
-    @Test
-    fun `serialise transient property with capturing lambda`() {
-        expectedEx.expect(KryoException::class.java)
-        expectedEx.expectMessage("is not annotated or on the whitelist, so cannot be used in serialization")
-        val original = CapturingTransientProperty("Hello")
-        original.serialize(context = KRYO_P2P_CONTEXT)
-    }
-
     @Test
     fun `deserialise transient property with capturing lambda`() {
         expectedEx.expect(KryoException::class.java)

node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/ServerContexts.kt

@@ -29,14 +29,6 @@ val KRYO_RPC_SERVER_CONTEXT = SerializationContextImpl(KryoHeaderV0_1,
         true,
         SerializationContext.UseCase.RPCServer)
 
-val KRYO_STORAGE_CONTEXT = SerializationContextImpl(KryoHeaderV0_1,
-        SerializationDefaults.javaClass.classLoader,
-        AllButBlacklisted,
-        emptyMap(),
-        true,
-        SerializationContext.UseCase.Storage)
-
-
 val AMQP_STORAGE_CONTEXT = SerializationContextImpl(AmqpHeaderV1_0,
         SerializationDefaults.javaClass.classLoader,
         AllButBlacklisted,

node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/SharedContexts.kt

@@ -15,13 +15,6 @@ import net.corda.nodeapi.internal.serialization.kryo.KryoHeaderV0_1
  * MUST be kept separate from these ones!
  */
 
-val KRYO_P2P_CONTEXT = SerializationContextImpl(KryoHeaderV0_1,
-        SerializationDefaults.javaClass.classLoader,
-        GlobalTransientClassWhiteList(BuiltInExceptionsWhitelist()),
-        emptyMap(),
-        true,
-        SerializationContext.UseCase.P2P)
-
 val KRYO_CHECKPOINT_CONTEXT = SerializationContextImpl(KryoHeaderV0_1,
         SerializationDefaults.javaClass.classLoader,
         QuasarWhitelist,

node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/AMQPSerializationScheme.kt

@@ -2,12 +2,15 @@
 
 package net.corda.nodeapi.internal.serialization.amqp
 
+import io.github.lukehutch.fastclasspathscanner.FastClasspathScanner
 import net.corda.core.cordapp.Cordapp
+import net.corda.core.internal.objectOrNewInstance
 import net.corda.core.serialization.*
 import net.corda.core.utilities.ByteSequence
 import net.corda.nodeapi.internal.serialization.DefaultWhitelist
 import net.corda.nodeapi.internal.serialization.MutableClassWhitelist
 import net.corda.nodeapi.internal.serialization.SerializationScheme
+import java.lang.reflect.Modifier
 import java.security.PublicKey
 import java.util.*
 import java.util.concurrent.ConcurrentHashMap
@@ -27,10 +30,20 @@ fun SerializerFactory.addToWhitelist(vararg types: Class<*>) {
 
 abstract class AbstractAMQPSerializationScheme(val cordappLoader: List<Cordapp>) : SerializationScheme {
 
+    // TODO: This method of initialisation for the Whitelist and plugin serializers will have to change
+    // when we have per-cordapp contexts and dynamic app reloading but for now it's the easiest way
     companion object {
         private val serializationWhitelists: List<SerializationWhitelist> by lazy {
             ServiceLoader.load(SerializationWhitelist::class.java, this::class.java.classLoader).toList() + DefaultWhitelist
         }
+
+        private val customSerializers: List<SerializationCustomSerializer<*, *>> by lazy {
+            FastClasspathScanner().addClassLoader(this::class.java.classLoader).scan()
+                    .getNamesOfClassesImplementing(SerializationCustomSerializer::class.java)
+                    .mapNotNull { this::class.java.classLoader.loadClass(it).asSubclass(SerializationCustomSerializer::class.java) }
+                    .filterNot { Modifier.isAbstract(it.modifiers) }
+                    .map { it.kotlin.objectOrNewInstance() }
+        }
     }
 
     private fun registerCustomSerializers(factory: SerializerFactory) {
@@ -68,11 +81,20 @@ abstract class AbstractAMQPSerializationScheme(val cordappLoader: List<Cordapp>)
             factory.addToWhitelist(*whitelistProvider.whitelist.toTypedArray())
         }
 
-        for (loader in cordappLoader) {
+        // If we're passed in an external list we trust that, otherwise revert to looking at the scan of the
-            for (schema in loader.serializationCustomSerializers) {
+        // classpath to find custom serializers.
-                factory.registerExternal(CorDappCustomSerializer(schema, factory))
+        if (cordappLoader.isEmpty()) {
+            for (customSerializer in customSerializers) {
+                factory.registerExternal(CorDappCustomSerializer(customSerializer, factory))
+            }
+        } else {
+            cordappLoader.forEach { loader ->
+                for (customSerializer in loader.serializationCustomSerializers) {
+                    factory.registerExternal(CorDappCustomSerializer(customSerializer, factory))
+                }
             }
         }
+
     }
 
     private val serializerFactoriesForContexts = ConcurrentHashMap<Pair<ClassWhitelist, ClassLoader>, SerializerFactory>()