/// <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); }