public INMSProducer Send(IDestination destination, IMessage message)
{
if (message == null)
{
throw new MessageFormatException("Message must not be null");
}
NmsMessageTransformation.CopyMap(messageProperties, message.Properties);
if (correlationId != null)
{
message.NMSCorrelationID = correlationId;
}
if (type != null)
{
message.NMSType = type;
}
if (replyTo != null)
{
message.NMSReplyTo = replyTo;
}
producer.Send(destination, message);
return(this);
}
public INMSProducer Send(IDestination destination, IPrimitiveMap body)
{
IMapMessage message = CreateMapMessage();
NmsMessageTransformation.CopyMap(body, message.Body);
return(Send(destination, message));
}
public void TestNMSMessageHeadersAreCopied()
{
string destinationName = "Test-Destination-Name";
NmsMessage source = new NmsMessage(new NmsTestMessageFacade());
NmsTopic destination = new NmsTopic(destinationName);
NmsTopic replyTo = new NmsTopic("ReplyTo: " + destinationName);
source.NMSMessageId = "ID:TEST";
source.NMSCorrelationID = "ID:CORRELATION";
source.NMSDestination = destination;
source.NMSReplyTo = replyTo;
source.NMSDeliveryMode = MsgDeliveryMode.NonPersistent;
source.NMSRedelivered = true;
source.NMSType = "test-type";
source.NMSPriority = MsgPriority.Highest;
source.NMSTimestamp = DateTime.UtcNow;
NmsMessage transformed = NmsMessageTransformation.TransformMessage(factory, source);
Assert.AreEqual(source.NMSMessageId, transformed.NMSMessageId);
Assert.AreEqual(source.NMSCorrelationID, transformed.NMSCorrelationID);
Assert.AreEqual(source.NMSDestination, transformed.NMSDestination);
Assert.AreEqual(source.NMSReplyTo, transformed.NMSReplyTo);
Assert.AreEqual(source.NMSDeliveryMode, transformed.NMSDeliveryMode);
Assert.AreEqual(source.NMSRedelivered, transformed.NMSRedelivered);
Assert.AreEqual(source.NMSType, transformed.NMSType);
Assert.AreEqual(source.NMSPriority, transformed.NMSPriority);
Assert.AreEqual(source.NMSTimestamp, transformed.NMSTimestamp);
}
public void TestForeignMessageTransformCreateNewMessage()
{
ForeignNmsMessage foreignMessage = new ForeignNmsMessage();
NmsMessage transformed = NmsMessageTransformation.TransformMessage(factory, foreignMessage);
Assert.AreNotSame(foreignMessage, transformed);
Assert.AreNotEqual(foreignMessage, transformed);
}
public void TestTransformNmsMessage()
{
NmsMessage orig = new NmsMessage(new NmsTestMessageFacade());
orig.NMSMessageId = "ID:CONNECTION:1:1";
NmsMessage transformed = NmsMessageTransformation.TransformMessage(factory, orig);
Assert.NotNull(transformed);
Assert.AreEqual(orig, transformed);
Assert.AreNotSame(orig, transformed);
}
public void TestEmptyForeignBytesMessageTransformCreateNewMessage()
{
ForeignNmsBytesMessage foreignMessage = new ForeignNmsBytesMessage();
NmsMessage transformed = NmsMessageTransformation.TransformMessage(factory, foreignMessage);
Assert.AreNotSame(foreignMessage, transformed);
Assert.IsInstanceOf <NmsBytesMessage>(transformed);
NmsBytesMessage message = (NmsBytesMessage)transformed;
message.Reset();
Assert.AreEqual(0, message.BodyLength);
}
public void TestEmptyForeignObjectMessageTransformCreateNewMessage()
{
ForeignNmsObjectMessage foreignMessage = new ForeignNmsObjectMessage();
NmsMessage transformed = NmsMessageTransformation.TransformMessage(factory, foreignMessage);
Assert.AreNotSame(foreignMessage, transformed);
Assert.IsInstanceOf <NmsObjectMessage>(transformed);
NmsObjectMessage message = (NmsObjectMessage)transformed;
Assert.IsNull(message.Body);
}
public void TestForeignMapMessageTransformCreateNewMessage()
{
ForeignNmsMapMessage foreignMessage = new ForeignNmsMapMessage();
foreignMessage.Body.SetBool("bool", true);
foreignMessage.Body.SetChar("char", 'a');
foreignMessage.Body.SetString("string", "string");
foreignMessage.Body.SetByte("byte", 1);
foreignMessage.Body.SetShort("short", 1);
foreignMessage.Body.SetInt("int", 1);
foreignMessage.Body.SetLong("long", 1);
foreignMessage.Body.SetFloat("float", 1.5F);
foreignMessage.Body.SetDouble("double", 1.5D);
foreignMessage.Body.SetList("list", new List <string>()
{
"a"
});
foreignMessage.Body.SetDictionary("dictionary", new Dictionary <string, string>()
{
{ "a", "a" }
});
foreignMessage.Body.SetBytes("bytes", new byte[] { 6 });
NmsMessage transformed = NmsMessageTransformation.TransformMessage(factory, foreignMessage);
Assert.IsNotNull(transformed);
Assert.AreNotSame(foreignMessage, transformed);
Assert.IsInstanceOf <NmsMapMessage>(transformed);
NmsMapMessage message = (NmsMapMessage)transformed;
Assert.IsTrue(message.Body.GetBool("bool"));
Assert.AreEqual('a', message.Body.GetChar("char"));
Assert.AreEqual("string", message.Body.GetString("string"));
Assert.AreEqual(1, message.Body.GetByte("byte"));
Assert.AreEqual(1, message.Body.GetShort("short"));
Assert.AreEqual(1, message.Body.GetInt("int"));
Assert.AreEqual(1, message.Body.GetLong("long"));
Assert.AreEqual(1.5F, message.Body.GetFloat("float"));
Assert.AreEqual(1.5F, message.Body.GetDouble("double"));
CollectionAssert.AreEqual(new List <string>()
{
"a"
}, message.Body.GetList("list"));
CollectionAssert.AreEqual(new Dictionary <string, string>()
{
{ "a", "a" }
}, message.Body.GetDictionary("dictionary"));
CollectionAssert.AreEqual(new byte[] { 6 }, message.Body.GetBytes("bytes"));
}
public void TestEmptyForeignMapMessageTransformCreateNewMessage()
{
ForeignNmsMapMessage foreignMessage = new ForeignNmsMapMessage();
NmsMessage transformed = NmsMessageTransformation.TransformMessage(factory, foreignMessage);
Assert.IsNotNull(transformed);
Assert.AreNotSame(foreignMessage, transformed);
Assert.IsInstanceOf <NmsMapMessage>(transformed);
NmsMapMessage message = (NmsMapMessage)transformed;
CollectionAssert.IsEmpty(message.Body.Keys);
}
public void TestForeignObjectMessageTransformCreateNewMessage()
{
string messageBody = "TEST-MESSAGE-BODY";
ForeignNmsObjectMessage foreignMessage = new ForeignNmsObjectMessage();
foreignMessage.Body = messageBody;
NmsMessage transformed = NmsMessageTransformation.TransformMessage(factory, foreignMessage);
Assert.AreNotSame(foreignMessage, transformed);
Assert.IsInstanceOf <NmsObjectMessage>(transformed);
NmsObjectMessage message = (NmsObjectMessage)transformed;
Assert.AreEqual(messageBody, message.Body);
}
public void TestEmptyForeignStreamMessageTransformCreateNewMessage()
{
ForeignNmsStreamMessage foreignMessage = new ForeignNmsStreamMessage();
NmsMessage transformed = NmsMessageTransformation.TransformMessage(factory, foreignMessage);
Assert.IsNotNull(transformed);
Assert.AreNotSame(foreignMessage, transformed);
Assert.IsInstanceOf <NmsStreamMessage>(transformed);
NmsStreamMessage message = (NmsStreamMessage)transformed;
message.Reset();
Assert.Catch <MessageEOFException>(() => message.ReadBoolean());
}
public void TestForeignBytesMessageTransformCreateNewMessage()
{
ForeignNmsBytesMessage foreignMessage = new ForeignNmsBytesMessage();
foreignMessage.WriteBoolean(true);
foreignMessage.Properties.SetBool("boolProperty", true);
NmsMessage transformed = NmsMessageTransformation.TransformMessage(factory, foreignMessage);
Assert.AreNotSame(foreignMessage, transformed);
Assert.IsInstanceOf <NmsBytesMessage>(transformed);
NmsBytesMessage message = (NmsBytesMessage)transformed;
message.Reset();
Assert.IsTrue(message.BodyLength > 0);
Assert.IsTrue(message.ReadBoolean());
Assert.IsTrue(message.Properties.Contains("boolProperty"));
}
public void TestNMSMessagePropertiesAreCopied()
{
ForeignNmsMapMessage foreignMessage = new ForeignNmsMapMessage();
foreignMessage.Properties.SetBool("bool", true);
foreignMessage.Properties.SetChar("char", 'a');
foreignMessage.Properties.SetString("string", "string");
foreignMessage.Properties.SetByte("byte", 1);
foreignMessage.Properties.SetShort("short", 1);
foreignMessage.Properties.SetInt("int", 1);
foreignMessage.Properties.SetLong("long", 1);
foreignMessage.Properties.SetFloat("float", 1.5F);
foreignMessage.Properties.SetDouble("double", 1.5D);
foreignMessage.Properties.SetList("list", new List <string>()
{
"a"
});
foreignMessage.Properties.SetDictionary("dictionary", new Dictionary <string, string>()
{
{ "a", "a" }
});
foreignMessage.Properties.SetBytes("bytes", new byte[] { 6 });
NmsMessage transformed = NmsMessageTransformation.TransformMessage(factory, foreignMessage);
Assert.IsTrue(transformed.Properties.GetBool("bool"));
Assert.AreEqual('a', transformed.Properties.GetChar("char"));
Assert.AreEqual("string", transformed.Properties.GetString("string"));
Assert.AreEqual(1, transformed.Properties.GetByte("byte"));
Assert.AreEqual(1, transformed.Properties.GetShort("short"));
Assert.AreEqual(1, transformed.Properties.GetInt("int"));
Assert.AreEqual(1, transformed.Properties.GetLong("long"));
Assert.AreEqual(1.5F, transformed.Properties.GetFloat("float"));
Assert.AreEqual(1.5F, transformed.Properties.GetDouble("double"));
CollectionAssert.AreEqual(new List <string>()
{
"a"
}, transformed.Properties.GetList("list"));
CollectionAssert.AreEqual(new Dictionary <string, string>()
{
{ "a", "a" }
}, transformed.Properties.GetDictionary("dictionary"));
CollectionAssert.AreEqual(new byte[] { 6 }, transformed.Properties.GetBytes("bytes"));
}
public void TestForeignStreamMessageTransformCreateNewMessage()
{
ForeignNmsStreamMessage foreignMessage = new ForeignNmsStreamMessage();
foreignMessage.WriteBoolean(true);
foreignMessage.WriteString("test");
foreignMessage.WriteBoolean(true);
NmsMessage transformed = NmsMessageTransformation.TransformMessage(factory, foreignMessage);
Assert.IsNotNull(transformed);
Assert.AreNotSame(foreignMessage, transformed);
Assert.IsInstanceOf <NmsStreamMessage>(transformed);
NmsStreamMessage message = (NmsStreamMessage)transformed;
message.Reset();
Assert.IsTrue(message.ReadBoolean());
Assert.AreEqual("test", message.ReadString());
Assert.IsTrue(message.ReadBoolean());
}
public void Send(NmsMessageProducer producer, IDestination destination, IMessage original, MsgDeliveryMode deliveryMode,
MsgPriority priority, TimeSpan timeToLive, bool disableMessageId, bool disableMessageTimestamp)
{
if (destination == null)
{
throw new InvalidDestinationException("Destination must not be null");
}
if (original == null)
{
throw new MessageFormatException("Message must not be null");
}
NmsMessage outbound = null;
original.NMSDeliveryMode = deliveryMode;
original.NMSPriority = priority;
original.NMSRedelivered = false;
original.NMSDestination = destination;
bool isNmsMessage = original is NmsMessage;
DateTime timeStamp = DateTime.UtcNow;
bool hasTTL = timeToLive > TimeSpan.Zero;
if (!disableMessageTimestamp)
{
original.NMSTimestamp = timeStamp;
}
else
{
original.NMSTimestamp = DateTime.MinValue;
}
if (!disableMessageId)
{
original.NMSMessageId = producer.MessageIdGenerator.GenerateId().ToString();
}
else
{
original.NMSMessageId = null;
}
if (isNmsMessage)
{
outbound = (NmsMessage)original;
}
else
{
outbound = NmsMessageTransformation.TransformMessage(Connection.MessageFactory, original);
}
if (hasTTL)
{
outbound.Facade.Expiration = timeStamp + timeToLive;
}
else
{
outbound.Facade.Expiration = DateTime.MinValue;
}
outbound.OnSend(timeToLive);
bool sync = deliveryMode == MsgDeliveryMode.Persistent;
Connection.Send(new OutboundMessageDispatch
{
Message = outbound,
ProducerId = producer.Info.Id,
ProducerInfo = producer.Info,
SendAsync = !sync
}).ConfigureAwait(false).GetAwaiter().GetResult();
}
