/// <summary>
/// Process and dispatch a message to registered functions for this message type.
/// </summary>
/// <param name="streamMessage"></param>
/// <returns></returns>
public async Task Visit(IStreamMessage streamMessage)
{
CombinedMessage combinedMessage = streamMessage as CombinedMessage;;
if (combinedMessage != null)
{
foreach (var message in combinedMessage.Messages)
{
await Visit(message);
}
return;
}
List <dynamic> funcList;
_callbacks.TryGetValue(streamMessage.GetType(), out funcList);
if (funcList != null)
{
foreach (var func in funcList)
{
if (_logger != null && _logger.IsInfo)
{
_logger.Info("Dispatching message of type {0}", streamMessage.GetType().FullName);
}
await func(streamMessage as dynamic);
if (PostProcessedMessageFunc != null)
{
await PostProcessedMessageFunc();
}
}
}
}
/// <summary>
/// Enqueues a message that is sent to all outputs once the FlushQueueSize is reached.
/// </summary>
/// <param name="message">Message to send.</param>
/// <returns></returns>
public void EnqueueMessageBroadcast(IStreamMessage streamMessage)
{
foreach (var sender in Senders)
{
sender.EnqueueMessageBroadcast(streamMessage);
}
}
/// <summary>
/// Enqeues a message to one output once the FlushQueueSize is reached.
/// </summary>
/// <param name="streamMessage">Message to send.</param>
public void EnqueueMessage(IStreamMessage streamMessage)
{
_messages.Enqueue(streamMessage);
if (_messages.Count >= FlushQueueSize)
{
FlushQueue();
}
}
public void TestStreamMessageCompression()
{
using (Connection connection = CreateConnection(TEST_CLIENT_ID) as Connection)
{
connection.UseCompression = true;
connection.Start();
Assert.IsTrue(connection.UseCompression);
using (ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
{
IStreamMessage message = session.CreateStreamMessage();
IDestination destination = session.CreateTemporaryQueue();
IMessageProducer producer = session.CreateProducer(destination);
IMessageConsumer consumer = session.CreateConsumer(destination);
message.WriteBoolean(a);
message.WriteByte(b);
message.WriteChar(c);
message.WriteInt16(d);
message.WriteInt32(e);
message.WriteInt64(f);
message.WriteString(g);
message.WriteBoolean(h);
message.WriteByte(i);
message.WriteInt16(j);
message.WriteInt32(k);
message.WriteInt64(l);
message.WriteSingle(m);
message.WriteDouble(n);
producer.Send(message);
message = consumer.Receive(TimeSpan.FromMilliseconds(4000)) as IStreamMessage;
Assert.IsNotNull(message);
Assert.IsTrue(((ActiveMQMessage)message).Compressed);
// use generic API to access entries
Assert.AreEqual(a, message.ReadBoolean(), "Stream Boolean Value: a");
Assert.AreEqual(b, message.ReadByte(), "Stream Byte Value: b");
Assert.AreEqual(c, message.ReadChar(), "Stream Char Value: c");
Assert.AreEqual(d, message.ReadInt16(), "Stream Int16 Value: d");
Assert.AreEqual(e, message.ReadInt32(), "Stream Int32 Value: e");
Assert.AreEqual(f, message.ReadInt64(), "Stream Int64 Value: f");
Assert.AreEqual(g, message.ReadString(), "Stream String Value: g");
Assert.AreEqual(h, message.ReadBoolean(), "Stream Boolean Value: h");
Assert.AreEqual(i, message.ReadByte(), "Stream Byte Value: i");
Assert.AreEqual(j, message.ReadInt16(), "Stream Int16 Value: j");
Assert.AreEqual(k, message.ReadInt32(), "Stream Int32 Value: k");
Assert.AreEqual(l, message.ReadInt64(), "Stream Int64 Value: l");
Assert.AreEqual(m, message.ReadSingle(), "Stream Single Value: m");
Assert.AreEqual(n, message.ReadDouble(), "Stream Double Value: n");
}
}
}
private async Task SendMessage(IStreamMessage message, bool awaitPriorToSending)
{
if (awaitPriorToSending)
{
await AwaitSendingComplete();
}
await _sender.SendMessage(message);
}
public void SendReceiveStreamMessage(MsgDeliveryMode deliveryMode)
{
using (IConnection connection = CreateConnection(TEST_CLIENT_ID))
{
connection.Start();
using (ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
{
IDestination destination = SessionUtil.GetDestination(session, DESTINATION_NAME);
using (IMessageConsumer consumer = session.CreateConsumer(destination))
using (IMessageProducer producer = session.CreateProducer(destination))
{
producer.DeliveryMode = deliveryMode;
producer.RequestTimeout = receiveTimeout;
IStreamMessage request = session.CreateStreamMessage();
request.WriteBoolean(a);
request.WriteByte(b);
request.WriteChar(c);
request.WriteInt16(d);
request.WriteInt32(e);
request.WriteInt64(f);
request.WriteString(g);
request.WriteBoolean(h);
request.WriteByte(i);
request.WriteInt16(j);
request.WriteInt32(k);
request.WriteInt64(l);
request.WriteSingle(m);
request.WriteDouble(n);
producer.Send(request);
IStreamMessage message = consumer.Receive(receiveTimeout) as IStreamMessage;
Assert.IsNotNull(message, "No message returned!");
Assert.AreEqual(deliveryMode, message.NMSDeliveryMode, "NMSDeliveryMode does not match");
// use generic API to access entries
Assert.AreEqual(a, message.ReadBoolean(), "Stream Boolean Value: a");
Assert.AreEqual(b, message.ReadByte(), "Stream Byte Value: b");
Assert.AreEqual(c, message.ReadChar(), "Stream Char Value: c");
Assert.AreEqual(d, message.ReadInt16(), "Stream Int16 Value: d");
Assert.AreEqual(e, message.ReadInt32(), "Stream Int32 Value: e");
Assert.AreEqual(f, message.ReadInt64(), "Stream Int64 Value: f");
Assert.AreEqual(g, message.ReadString(), "Stream String Value: g");
Assert.AreEqual(h, message.ReadBoolean(), "Stream Boolean Value: h");
Assert.AreEqual(i, message.ReadByte(), "Stream Byte Value: i");
Assert.AreEqual(j, message.ReadInt16(), "Stream Int16 Value: j");
Assert.AreEqual(k, message.ReadInt32(), "Stream Int32 Value: k");
Assert.AreEqual(l, message.ReadInt64(), "Stream Int64 Value: l");
Assert.AreEqual(m, message.ReadSingle(), "Stream Single Value: m");
Assert.AreEqual(n, message.ReadDouble(), "Stream Double Value: n");
}
}
}
}
private static void RunWithOptions(CommandLineOpts opts)
{
ITrace logger = new Logger(Logger.ToLogLevel(opts.logLevel));
Tracer.Trace = logger;
string ip = opts.host;
Uri providerUri = new Uri(ip);
Console.WriteLine("scheme: {0}", providerUri.Scheme);
IConnection conn = null;
if (opts.topic == null && opts.queue == null)
{
Console.WriteLine("ERROR: Must specify a topic or queue destination");
return;
}
try
{
NmsConnectionFactory factory = new NmsConnectionFactory(ip);
if (opts.username != null)
{
factory.UserName = opts.username;
}
if (opts.password != null)
{
factory.Password = opts.password;
}
if (opts.clientId != null)
{
factory.ClientId = opts.clientId;
}
if (opts.connTimeout != default)
{
factory.SendTimeout = opts.connTimeout;
}
Console.WriteLine("Creating Connection...");
conn = factory.CreateConnection();
conn.ExceptionListener += (logger as Logger).LogException;
Console.WriteLine("Created Connection.");
Console.WriteLine("Version: {0}", conn.MetaData);
Console.WriteLine("Creating Session...");
ISession ses = conn.CreateSession();
Console.WriteLine("Session Created.");
conn.Start();
IDestination dest = (opts.topic == null) ? (IDestination)ses.GetQueue(opts.queue) : (IDestination)ses.GetTopic(opts.topic);
Console.WriteLine("Creating Message Producer for : {0}...", dest);
IMessageProducer prod = ses.CreateProducer(dest);
IMessageConsumer consumer = ses.CreateConsumer(dest);
Console.WriteLine("Created Message Producer.");
prod.DeliveryMode = opts.mode == 0 ? MsgDeliveryMode.NonPersistent : MsgDeliveryMode.Persistent;
prod.TimeToLive = TimeSpan.FromSeconds(20);
IMapMessage mapMsg = prod.CreateMapMessage();
IStreamMessage streamMsg = prod.CreateStreamMessage();
Console.WriteLine("Starting Connection...");
conn.Start();
Console.WriteLine("Connection Started: {0} Resquest Timeout: {1}", conn.IsStarted, conn.RequestTimeout);
Tracer.InfoFormat("Sending MapMsg");
// Map Msg Body
mapMsg.Body.SetString("mykey", "Hello World!");
mapMsg.Body.SetBytes("myBytesKey", new byte[] { 0x6d, 0x61, 0x70 });
Console.WriteLine("Sending Msg: {0}", mapMsg.ToString());
prod.Send(mapMsg);
mapMsg.ClearBody();
// Stream Msg Body
streamMsg.WriteBytes(new byte[] { 0x53, 0x74, 0x72 });
streamMsg.WriteInt64(1354684651565648484L);
streamMsg.WriteObject("bar");
streamMsg.Properties["foobar"] = 42 + "";
Console.WriteLine("Sending Msg: {0}", streamMsg.ToString());
prod.Send(streamMsg);
streamMsg.ClearBody();
IMessage rmsg = null;
for (int i = 0; i < 2; i++)
{
Tracer.InfoFormat("Waiting to receive message {0} from consumer.", i);
rmsg = consumer.Receive(TimeSpan.FromMilliseconds(opts.connTimeout));
if (rmsg == null)
{
Console.WriteLine("Failed to receive Message in {0}ms.", opts.connTimeout);
}
else
{
Console.WriteLine("Received Message with id {0} and contents {1}.", rmsg.NMSMessageId, rmsg.ToString());
foreach (string key in rmsg.Properties.Keys)
{
Console.WriteLine("Message contains Property[{0}] = {1}", key, rmsg.Properties[key].ToString());
}
}
}
if (conn.IsStarted)
{
Console.WriteLine("Closing Connection...");
conn.Close();
Console.WriteLine("Connection Closed.");
}
}
catch (NMSException ne)
{
Console.WriteLine("Caught NMSException : {0} \nStack: {1}", ne.Message, ne);
}
catch (Exception e)
{
Console.WriteLine("Caught unexpected exception : {0}", e);
}
finally
{
if (conn != null)
{
conn.Dispose();
}
}
}
public void TestCreateTemporaryDestination()
{
const int NUM_MSGS = 10;
try
{
using (IConnection connection = GetConnection("default"))
using (ISession session = GetSession("s1"))
{
IStreamMessage msg = session.CreateStreamMessage();
IDestination temp = session.CreateTemporaryQueue();
IMessageProducer producer = session.CreateProducer(temp);
for (int i = 0; i < NUM_MSGS; i++)
{
msg.WriteObject("barfoo");
msg.WriteObject(i);
msg.Properties.SetInt("count", i);
producer.Send(msg);
msg.ClearBody();
}
// Queues do not require an active consumer to receive messages.
// Create consumer on queue after messages sent and receive messages.
IMessageConsumer drain = session.CreateConsumer(temp);
connection.Start();
int msgsReceived = DrainDestination(drain, temp, NUM_MSGS);
Assert.AreEqual(NUM_MSGS, msgsReceived, "Received {0} of {1} on temporary destination {2}.", msgsReceived, NUM_MSGS, temp.ToString());
temp = session.CreateTemporaryTopic();
// Topics require an active consumer to receive messages.
drain = session.CreateConsumer(temp);
producer = session.CreateProducer(temp);
for (int i = 0; i < NUM_MSGS; i++)
{
msg.WriteObject("foobar");
msg.WriteObject(i);
msg.Properties.SetInt("count", i);
producer.Send(msg);
msg.ClearBody();
}
msgsReceived = DrainDestination(drain, temp, NUM_MSGS);
Assert.AreEqual(NUM_MSGS, msgsReceived, "Received {0} of {1} on temporary destination {2}.", msgsReceived, NUM_MSGS, temp.ToString());
}
}
catch (Exception ex)
{
this.PrintTestFailureAndAssert(GetTestMethodName(), "Unexpected exception.", ex);
}
}
protected abstract bool IsMatchRequestAndResponse(object request, IStreamMessage response);
protected override bool IsMatchRequestAndResponse(object request, IStreamMessage response)
{
return(true);
}
public void SendReceiveForeignStreamMessageTest(
[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
MsgDeliveryMode deliveryMode)
{
using (IConnection connection = CreateConnection())
{
connection.Start();
using (ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
{
IDestination destination = SessionUtil.GetDestination(session, DESTINATION_NAME);
using (IMessageConsumer consumer = session.CreateConsumer(destination))
using (IMessageProducer producer = session.CreateProducer(destination))
{
try
{
producer.DeliveryMode = deliveryMode;
StreamMessage request = new StreamMessage();
request.Properties[propertyName] = propertyValue;
request.WriteBoolean(a);
request.WriteByte(b);
request.WriteChar(c);
request.WriteInt16(d);
request.WriteInt32(e);
request.WriteInt64(f);
request.WriteString(g);
request.WriteBoolean(h);
request.WriteByte(i);
request.WriteInt16(j);
request.WriteInt32(k);
request.WriteInt64(l);
request.WriteSingle(m);
request.WriteDouble(n);
producer.Send(request);
IStreamMessage message = consumer.Receive(receiveTimeout) as IStreamMessage;
Assert.IsNotNull(message, "No message returned!");
Assert.AreEqual(request.Properties.Count, message.Properties.Count, "Invalid number of properties.");
Assert.AreEqual(deliveryMode, message.NMSDeliveryMode, "NMSDeliveryMode does not match");
// Check the body
Assert.AreEqual(a, message.ReadBoolean(), "Stream Boolean Value: a");
Assert.AreEqual(b, message.ReadByte(), "Stream Byte Value: b");
Assert.AreEqual(c, message.ReadChar(), "Stream Char Value: c");
Assert.AreEqual(d, message.ReadInt16(), "Stream Int16 Value: d");
Assert.AreEqual(e, message.ReadInt32(), "Stream Int32 Value: e");
Assert.AreEqual(f, message.ReadInt64(), "Stream Int64 Value: f");
Assert.AreEqual(g, message.ReadString(), "Stream String Value: g");
Assert.AreEqual(h, message.ReadBoolean(), "Stream Boolean Value: h");
Assert.AreEqual(i, message.ReadByte(), "Stream Byte Value: i");
Assert.AreEqual(j, message.ReadInt16(), "Stream Int16 Value: j");
Assert.AreEqual(k, message.ReadInt32(), "Stream Int32 Value: k");
Assert.AreEqual(l, message.ReadInt64(), "Stream Int64 Value: l");
Assert.AreEqual(m, message.ReadSingle(), "Stream Single Value: m");
Assert.AreEqual(n, message.ReadDouble(), "Stream Double Value: n");
// use generic API to access entries
Assert.AreEqual(propertyValue, message.Properties[propertyName], "generic map entry: " + propertyName);
// use type safe APIs
Assert.AreEqual(propertyValue, message.Properties.GetString(propertyName), "map entry: " + propertyName);
}
catch (NotSupportedException)
{
}
}
}
}
}
/// <summary>
/// Enqeues a message to one output once the FlushQueueSize is reached.
/// </summary>
/// <param name="streamMessage">Message to send.</param>
public void EnqueueMessage(IStreamMessage streamMessage)
{
Senders[_nextSenderIndex].EnqueueMessage(streamMessage);
_nextSenderIndex = (_nextSenderIndex + 1) % Senders.Count;
}
/// <summary>
/// Sends a generic message.
/// </summary>
/// <param name="message">Message to send.</param>
/// <returns></returns>
public async Task SendMessage(IStreamMessage message)
{
await SendMessage(message, true);
}
/// <summary>
/// Enqueues a message that is sent to all outputs once the FlushQueueSize is reached.
/// </summary>
/// <param name="streamMessage">Message to send.</param>
/// <returns></returns>
public void EnqueueMessageBroadcast(IStreamMessage streamMessage)
{
EnqueueMessage(streamMessage);
}
public T TransformMessage <T>(IMessage message)
{
if (message is T)
{
return((T)message);
}
else
{
IMessage result = null;
if (message is IBytesMessage)
{
IBytesMessage bytesMsg = message as IBytesMessage;
bytesMsg.Reset();
IBytesMessage msg = DoCreateBytesMessage();
try
{
for (;;)
{
// Reads a byte from the message stream until the stream is empty
msg.WriteByte(bytesMsg.ReadByte());
}
}
catch
{
}
result = msg;
}
else if (message is IMapMessage)
{
IMapMessage mapMsg = message as IMapMessage;
IMapMessage msg = DoCreateMapMessage();
foreach (string key in mapMsg.Body.Keys)
{
msg.Body[key] = mapMsg.Body[key];
}
result = msg;
}
else if (message is IObjectMessage)
{
IObjectMessage objMsg = message as IObjectMessage;
IObjectMessage msg = DoCreateObjectMessage();
msg.Body = objMsg.Body;
result = msg;
}
else if (message is IStreamMessage)
{
IStreamMessage streamMessage = message as IStreamMessage;
streamMessage.Reset();
IStreamMessage msg = DoCreateStreamMessage();
object obj = null;
try
{
while ((obj = streamMessage.ReadObject()) != null)
{
msg.WriteObject(obj);
}
}
catch
{
}
result = msg;
}
else if (message is ITextMessage)
{
ITextMessage textMsg = message as ITextMessage;
ITextMessage msg = DoCreateTextMessage();
msg.Text = textMsg.Text;
result = msg;
}
else
{
result = DoCreateMessage();
}
CopyProperties(message, result);
// Let the subclass have a chance to do any last minute configurations
// on the newly converted message.
DoPostProcessMessage(result);
return((T)result);
}
}
protected override bool IsMatchRequestAndResponse(object request, IStreamMessage response)
{
return($"api:{(request as WsRequest)?.Body?.Id}" == (response as WsResponse)?.Body?.Id);
}
/// <summary>
/// Sends a generic message via all output channels.
/// </summary>
/// <param name="message">Message to send.</param>
/// <returns></returns>
public async Task SendMessage(IStreamMessage message)
{
await Senders.First().SendMessage(message);
}
//[Test]
public virtual void TestSendReceiveStreamMessage(
//[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
MsgDeliveryMode deliveryMode, string testDestRef)
{
using (IConnection connection = CreateConnection(GetTestClientId()))
{
connection.Start();
using (ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
{
IDestination destination = GetClearDestinationByNodeReference(session, testDestRef);
using (IMessageConsumer consumer = session.CreateConsumer(destination))
using (IMessageProducer producer = session.CreateProducer(destination))
{
producer.DeliveryMode = deliveryMode;
IStreamMessage request;
try
{
request = session.CreateStreamMessage();
}
catch (System.NotSupportedException)
{
return;
}
request.WriteBoolean(a);
request.WriteByte(b);
request.WriteChar(c);
request.WriteInt16(d);
request.WriteInt32(e);
request.WriteInt64(f);
request.WriteString(g);
request.WriteBoolean(h);
request.WriteByte(i);
request.WriteInt16(j);
request.WriteInt32(k);
request.WriteInt64(l);
request.WriteSingle(m);
request.WriteDouble(n);
producer.Send(request);
IStreamMessage message = consumer.Receive(receiveTimeout) as IStreamMessage;
Assert.IsNotNull(message, "No message returned!");
Assert.AreEqual(deliveryMode, message.NMSDeliveryMode, "NMSDeliveryMode does not match");
// use generic API to access entries
Assert.AreEqual(a, message.ReadBoolean(), "Stream Boolean Value: a");
Assert.AreEqual(b, message.ReadByte(), "Stream Byte Value: b");
Assert.AreEqual(c, message.ReadChar(), "Stream Char Value: c");
Assert.AreEqual(d, message.ReadInt16(), "Stream Int16 Value: d");
Assert.AreEqual(e, message.ReadInt32(), "Stream Int32 Value: e");
Assert.AreEqual(f, message.ReadInt64(), "Stream Int64 Value: f");
Assert.AreEqual(g, message.ReadString(), "Stream String Value: g");
Assert.AreEqual(h, message.ReadBoolean(), "Stream Boolean Value: h");
Assert.AreEqual(i, message.ReadByte(), "Stream Byte Value: i");
Assert.AreEqual(j, message.ReadInt16(), "Stream Int16 Value: j");
Assert.AreEqual(k, message.ReadInt32(), "Stream Int32 Value: k");
Assert.AreEqual(l, message.ReadInt64(), "Stream Int64 Value: l");
Assert.AreEqual(m, message.ReadSingle(), "Stream Single Value: m");
Assert.AreEqual(n, message.ReadDouble(), "Stream Double Value: n");
}
}
}
}
/// <summary>
/// Sends a message to all outputs.
/// </summary>
/// <param name="message">Message to send.</param>
/// <returns></returns>
public async Task SendMessageBroadcast(IStreamMessage message)
{
await Task.WhenAll(Senders.Select(s => s.SendMessage(message)));
}
/// <summary>
/// 写网络消息
/// </summary>
/// <param name="message"></param>
public void Write(IStreamMessage message)
{
message.Write(this);
}
public async Task SendMessage(IStreamMessage message)
{
await _messageStream.OnNextAsync(message);
}
