Break out message handler changes

Special serializer for kotlin object definitions

node/src/main/kotlin/com/r3corda/node/services/NotaryChangeService.kt

@@ -1,5 +1,6 @@
 package com.r3corda.node.services
 
+import com.r3corda.core.messaging.Ack
 import com.r3corda.core.messaging.MessagingService
 import com.r3corda.core.messaging.SingleMessageRecipient
 import com.r3corda.node.services.api.AbstractNodeService
@@ -17,11 +18,12 @@ class NotaryChangeService(net: MessagingService, val smm: StateMachineManager) :
         )
     }
 
-    private fun handleChangeNotaryRequest(req: NotaryChangeProtocol.Handshake) {
+    private fun handleChangeNotaryRequest(req: NotaryChangeProtocol.Handshake): Ack {
         val protocol = NotaryChangeProtocol.Acceptor(
                 req.replyTo as SingleMessageRecipient,
                 req.sessionID!!,
                 req.sessionIdForSend)
         smm.add(NotaryChangeProtocol.TOPIC_CHANGE, protocol)
+        return Ack
     }
 }

node/src/main/kotlin/com/r3corda/node/services/api/AbstractNodeService.kt

@@ -3,6 +3,7 @@ package com.r3corda.node.services.api
 import com.r3corda.core.messaging.Message
 import com.r3corda.core.messaging.MessagingService
 import com.r3corda.core.node.services.TOPIC_DEFAULT_POSTFIX
+import com.r3corda.core.serialization.SingletonSerializeAsToken
 import com.r3corda.core.serialization.deserialize
 import com.r3corda.core.serialization.serialize
 import com.r3corda.protocols.AbstractRequestMessage
@@ -12,14 +13,15 @@ import javax.annotation.concurrent.ThreadSafe
  * Abstract superclass for services that a node can host, which provides helper functions.
  */
 @ThreadSafe
-abstract class AbstractNodeService(val net: MessagingService) {
+abstract class AbstractNodeService(val net: MessagingService) : SingletonSerializeAsToken() {
 
     /**
      * Register a handler for a message topic. In comparison to using net.addMessageHandler() this manages a lot of
-     * common boilerplate code. Exceptions are caught and passed to the provided consumer.
+     * common boilerplate code. Exceptions are caught and passed to the provided consumer.  If you just want a simple
+     * acknowledgement response with no content, use [com.r3corda.core.messaging.Ack]
      *
      * @param topic the topic, without the default session ID postfix (".0)
-     * @param handler a function to handle the deserialised request and return a response
+     * @param handler a function to handle the deserialised request and return an optional response (if return type not Unit)
      * @param exceptionConsumer a function to which any thrown exception is passed.
      */
     protected inline fun <reified Q : AbstractRequestMessage, reified R : Any>
@@ -30,8 +32,11 @@ abstract class AbstractNodeService(val net: MessagingService) {
             try {
                 val req = message.data.deserialize<Q>()
                 val data = handler(req)
-                val msg = net.createMessage(topic + "." + req.sessionID, data.serialize().bits)
-                net.send(msg, req.replyTo)
+                // If the return type R is Unit, then do not send a response
+                if (data.javaClass != Unit.javaClass) {
+                    val msg = net.createMessage("$topic.${req.sessionID}", data.serialize().bits)
+                    net.send(msg, req.replyTo)
+                }
             } catch(e: Exception) {
                 exceptionConsumer(message, e)
             }
@@ -40,19 +45,15 @@ abstract class AbstractNodeService(val net: MessagingService) {
 
     /**
      * Register a handler for a message topic. In comparison to using net.addMessageHandler() this manages a lot of
-     * common boilerplate code. Exceptions are propagated to the messaging layer.
+     * common boilerplate code. Exceptions are propagated to the messaging layer.  If you just want a simple
+     * acknowledgement response with no content, use [com.r3corda.core.messaging.Ack]
      *
      * @param topic the topic, without the default session ID postfix (".0)
-     * @param handler a function to handle the deserialised request and return a response
+     * @param handler a function to handle the deserialised request and return an optional response (if return type not Unit)
      */
     protected inline fun <reified Q : AbstractRequestMessage, reified R : Any>
             addMessageHandler(topic: String,
                               crossinline handler: (Q) -> R) {
-        net.addMessageHandler(topic + TOPIC_DEFAULT_POSTFIX, null) { message, r ->
-            val req = message.data.deserialize<Q>()
-            val data = handler(req)
-            val msg = net.createMessage(topic + "." + req.sessionID, data.serialize().bits)
-            net.send(msg, req.replyTo)
-        }
+        addMessageHandler(topic, handler, { message: Message, exception: Exception -> throw exception })
     }
 }

node/src/main/kotlin/com/r3corda/node/services/transactions/NotaryService.kt

@@ -1,5 +1,6 @@
 package com.r3corda.node.services.transactions
 
+import com.r3corda.core.messaging.Ack
 import com.r3corda.core.messaging.MessagingService
 import com.r3corda.core.messaging.SingleMessageRecipient
 import com.r3corda.core.node.services.ServiceType
@@ -35,12 +36,13 @@ abstract class NotaryService(val smm: StateMachineManager,
         )
     }
 
-    private fun processRequest(req: NotaryProtocol.Handshake) {
+    private fun processRequest(req: NotaryProtocol.Handshake): Ack {
         val protocol = protocolFactory.create(req.replyTo as SingleMessageRecipient,
                 req.sessionID!!,
                 req.sendSessionID,
                 timestampChecker,
                 uniquenessProvider)
         smm.add(NotaryProtocol.TOPIC, protocol)
+        return Ack
     }
 }