+cam akka#11214 add attachments to CamelMessage

add support for attachments in CamelMessage, taken from JCamelMessage

add a extension class CamelMessageWithAttachments base on CamelMessage that contains attachments based on JCamelMessage

add newline CamelMessageTest

replace for-cycle attachment adding with one putAll

remove CamelMessageWithAttachments and update CamelMessage to contain attachments

fix the binary compatibility issues on CamelMessage

add documentation for new methods in CamelMessage, add return type for method withBody

Author: Michal Lacko

akka-camel/src/main/scala/akka/camel/CamelMessage.scala

@@ -5,20 +5,26 @@
 package akka.camel
 
 import java.util.{ Map ⇒ JMap, Set ⇒ JSet }
+import javax.activation.DataHandler
 import org.apache.camel.{ CamelContext, Message ⇒ JCamelMessage, StreamCache }
 import akka.AkkaException
 import scala.reflect.ClassTag
+import scala.runtime.ScalaRunTime
 import scala.util.Try
 import scala.collection.JavaConversions._
 import akka.dispatch.Mapper
 
 /**
  * An immutable representation of a Camel message.
  */
-case class CamelMessage(body: Any, headers: Map[String, Any]) {
-  def this(body: Any, headers: JMap[String, Any]) = this(body, headers.toMap) //for Java
+class CamelMessage(val body: Any, val headers: Map[String, Any], val attachments: Map[String, DataHandler]) extends Serializable with Product {
+  def this(body: Any, headers: JMap[String, Any]) = this(body, headers.toMap, Map.empty[String, DataHandler]) //Java
+  def this(body: Any, headers: JMap[String, Any], attachments: JMap[String, DataHandler]) = this(body, headers.toMap, attachments.toMap) //Java
+  def this(body: Any, headers: Map[String, Any]) = this(body, headers.toMap, Map.empty[String, DataHandler])
 
-  override def toString: String = "CamelMessage(%s, %s)" format (body, headers)
+  def copy(body: Any = this.body, headers: Map[String, Any] = this.headers): CamelMessage = CamelMessage(body, headers, this.attachments)
+
+  override def toString: String = "CamelMessage(%s, %s, %s)" format (body, headers, attachments)
 
   /**
    * Returns those headers from this message whose name is contained in <code>names</code>.
@@ -112,7 +118,7 @@ case class CamelMessage(body: Any, headers: Map[String, Any]) {
   /**
    * Java API: Returns a new CamelMessage with a new body, while keeping the same headers.
    */
-  def withBody[T](body: T) = this.copy(body = body)
+  def withBody[T](body: T): CamelMessage = copy(body = body)
   /**
    * Creates a CamelMessage with current <code>body</code> converted to type <code>T</code>.
    * The CamelContext is accessible in a [[akka.camel.javaapi.UntypedConsumerActor]] and [[akka.camel.javaapi.UntypedProducerActor]]
@@ -128,12 +134,95 @@ case class CamelMessage(body: Any, headers: Map[String, Any]) {
    */
   def withBodyAs[T](clazz: Class[T])(implicit camelContext: CamelContext): CamelMessage = copy(body = getBodyAs(clazz, camelContext))
 
+  /**
+   * Returns those attachments from this message whose name is contained in <code>names</code>.
+   */
+  def attachments(names: Set[String]): Map[String, DataHandler] = attachments filterKeys names
+
+  /**
+   * Java API: Returns those attachments from this message whose name is contained in <code>names</code>.
+   * The returned headers map is backed up by an immutable headers map. Any attempt to modify
+   * the returned map will throw an exception.
+   */
+  def getAttachments(names: JSet[String]): JMap[String, DataHandler] = attachments(names.toSet)
+
+  /**
+   * Java API: Returns all attachments from this message. The returned attachments map is backed up by this
+   * message's immutable headers map. Any attempt to modify the returned map will throw an
+   * exception.
+   */
+  def getAttachments: JMap[String, DataHandler] = attachments
+
+  /**
+   * Java API: Creates a new CamelMessage with given <code>attachments</code>. A copy of the attachments map is made.
+   */
+  def withAttachments(attachments: JMap[String, DataHandler]): CamelMessage = CamelMessage(this.body, this.headers, attachments.toMap)
+
+  /**
+   * SCALA API: Creates a new CamelMessage with given <code>attachments</code>.
+   */
+  def withAttachments(attachments: Map[String, DataHandler]): CamelMessage = CamelMessage(this.body, this.headers, attachments)
+
+  /**
+   * Indicates whether some other object is "equal to" this one.
+   */
+  override def equals(that: Any): Boolean =
+    that match {
+      case that: CamelMessage if canEqual(that) ⇒
+        this.body == that.body &&
+          this.headers == that.headers &&
+          this.attachments == that.attachments
+      case _ ⇒ false
+    }
+
+  /**
+   * Returns a hash code value for the object.
+   */
+  override def hashCode(): Int = ScalaRunTime._hashCode(this)
+
+  /**
+   * Returns the n-th element of this product, 0-based.
+   */
+  override def productElement(n: Int): Any = n match {
+    case 0 ⇒ body
+    case 1 ⇒ headers
+    case 2 ⇒ attachments
+  }
+
+  /**
+   * Returns the size of this product.
+   */
+  override def productArity: Int = 3
+
+  /**
+   * Indicates if some other object can be compared (based on type).
+   * This method should be called from every well-designed equals method that is open to be overridden in a subclass.
+   */
+  override def canEqual(that: Any): Boolean = that match {
+    case _: CamelMessage ⇒ true
+    case _               ⇒ false
+  }
 }
 
 /**
  * Companion object of CamelMessage class.
  */
-object CamelMessage {
+object CamelMessage extends ((Any, Map[String, Any]) ⇒ CamelMessage) {
+
+  /**
+   * Returns a new CamelMessage based on the <code>body</code> and <code>headers</code>.
+   */
+  def apply(body: Any, headers: Map[String, Any]): CamelMessage = new CamelMessage(body, headers, Map.empty[String, DataHandler])
+
+  /**
+   * Returns a new CamelMessage based on the <code>body</code>, <code>headers</code> and <code>attachments</code>.
+   */
+  def apply(body: Any, headers: Map[String, Any], attachments: Map[String, DataHandler]): CamelMessage = new CamelMessage(body, headers, attachments)
+
+  /**
+   * Returns <code>Some(body, headers)</code>.
+   */
+  def unapply(camelMessage: CamelMessage): Option[(Any, Map[String, Any])] = Some((camelMessage.body, camelMessage.headers))
 
   /**
    * CamelMessage header to correlate request with response messages. Applications that send
@@ -150,7 +239,7 @@ object CamelMessage {
    */
   private[camel] def canonicalize(msg: Any) = msg match {
     case mobj: CamelMessage ⇒ mobj
-    case body               ⇒ CamelMessage(body, Map.empty)
+    case body               ⇒ CamelMessage(body, Map.empty[String, Any])
   }
 
   /**
@@ -159,15 +248,28 @@ object CamelMessage {
    * @param headers additional headers to set on the created CamelMessage in addition to those
    *                in the Camel message.
    */
-  private[camel] def from(camelMessage: JCamelMessage, headers: Map[String, Any]): CamelMessage = CamelMessage(camelMessage.getBody, headers ++ camelMessage.getHeaders)
+  private[camel] def from(camelMessage: JCamelMessage, headers: Map[String, Any]): CamelMessage =
+    CamelMessage(camelMessage.getBody, headers ++ camelMessage.getHeaders, camelMessage.getAttachments.toMap)
+
+  /**
+   * Creates a new CamelMessageWithAttachments object from the Camel message.
+   *
+   * @param headers additional headers to set on the created CamelMessageWithAttachments in addition to those
+   *                in the Camel message.
+   * @param attachments additional attachments to set on the created CamelMessageWithAttachments in addition to those
+   *                in the Camel message.
+   */
+  private[camel] def from(camelMessage: JCamelMessage, headers: Map[String, Any], attachments: Map[String, DataHandler]): CamelMessage =
+    CamelMessage(camelMessage.getBody, headers ++ camelMessage.getHeaders, attachments ++ camelMessage.getAttachments)
 
   /**
    * INTERNAL API
-   * copies the content of this CamelMessage to an Apache Camel Message.
+   * copies the content of this CamelMessageWithAttachments to an Apache Camel Message.
    */
   private[camel] def copyContent(from: CamelMessage, to: JCamelMessage): Unit = {
     to.setBody(from.body)
     for ((name, value) ← from.headers) to.getHeaders.put(name, value.asInstanceOf[AnyRef])
+    to.getAttachments.putAll(from.getAttachments)
   }
 }
 

akka-camel/src/test/scala/akka/camel/CamelMessageTest.scala

@@ -4,6 +4,9 @@
 
 package akka.camel
 
+import java.net.URL
+import javax.activation.DataHandler
+
 import org.apache.camel.impl.{ DefaultExchange, DefaultMessage }
 import akka.camel.TestSupport.SharedCamelSystem
 import org.scalatest.Matchers
@@ -12,22 +15,23 @@ import org.scalatest.WordSpecLike
 //TODO merge it with MessageScalaTest
 class CamelMessageTest extends Matchers with WordSpecLike with SharedCamelSystem {
 
-  "CamelMessage" must {
+  "CamelMessage copyContent" must {
+    "create a new CamelMessage with additional headers, attachments and new body" in {
+      val attachment = new DataHandler(new URL("https://foo.bar"))
+      val message = new DefaultMessage
+      message.setBody("test")
+      message.setHeader("foo", "bar")
+      message.addAttachment("foo", attachment)
+      message.setExchange(new DefaultExchange(camel.context))
 
-    "overwrite body and add header" in {
-      val msg = sampleMessage
-      CamelMessage.copyContent(CamelMessage("blah", Map("key" -> "baz")), msg)
-      assert(msg.getBody === "blah")
-      assert(msg.getHeader("foo") === "bar")
-      assert(msg.getHeader("key") === "baz")
-    }
-  }
+      val attachmentToAdd = new DataHandler(new URL("https://another.url"))
+      CamelMessage.copyContent(new CamelMessage("body", Map("key" -> "baz"), Map("key" -> attachmentToAdd)), message)
 
-  private[camel] def sampleMessage = {
-    val message = new DefaultMessage
-    message.setBody("test")
-    message.setHeader("foo", "bar")
-    message.setExchange(new DefaultExchange(camel.context))
-    message
+      assert(message.getBody === "body")
+      assert(message.getHeader("foo") === "bar")
+      assert(message.getHeader("key") === "baz")
+      assert(message.getAttachment("key") === attachmentToAdd)
+      assert(message.getAttachment("foo") === attachment)
+    }
   }
 }