protected void SendMessage(IMessageProducer producer)
{
IMessage request = producer.CreateMessage();
request.NMSCorrelationID = CORRELATION_ID;
request.NMSType = "Test";
producer.Send(request);
}
public void ProcessMessage(Apache.NMS.IMessage amqMessage, IMessageProducer errorMessageProducer)
{
try
{
var amqTextMessage = (ITextMessage)amqMessage;
this.messageHandler.ProcessMessage(amqTextMessage);
}
catch (Exception e)
{
ActiveMQMessage errorMessage = (ActiveMQMessage)((ActiveMQMessage)amqMessage).Clone();
errorMessage.ReadOnlyProperties = false;
errorMessage.Properties["Bridge.Error.Message"] = e.ToString();
errorMessage.Properties["Bridge.Error.OriginalDestination"] = amqMessage.NMSDestination.ToString();
errorMessage.Properties["Bridge.Error.OriginalTimestamp"] = amqMessage.NMSTimestamp.ToString(CultureInfo.InvariantCulture);
errorMessage.Properties["Bridge.Error.OriginalMessageId"] = amqMessage.NMSMessageId;
errorMessageProducer.Send(errorMessage);
}
}
/// <summary>
/// 发送主题文本消息
/// </summary>
/// <param name="config"></param>
/// <param name="textMsg"></param>
public static void SendTopicMessage(AQConfig config, string textMsg)
{
if (!string.IsNullOrEmpty(textMsg))
{
var factory = new ConnectionFactory(config._AQConfigConnectString);
//创建连接
using (var _connection = factory.CreateConnection())
{
using (ISession session = _connection.CreateSession())
{
//创建一个主题
IDestination destination = new ActiveMQTopic(config.ActiveMQName);
//创建生产者
IMessageProducer producer = session.CreateProducer(destination);
//创建一个文本消息
var _message = producer.CreateTextMessage(textMsg);
//发送消息
producer.Send(_message, MsgDeliveryMode.NonPersistent, MsgPriority.Normal, TimeSpan.MinValue);
}
}
}
}
/// <summary>
/// Sends a status message
/// </summary>
/// <param name="processor"></param>
/// <param name="message">Outgoing message string</param>
public void SendMessage(string processor, string message)
{
if (!mIsDisposed)
{
var textMessage = mStatusSession.CreateTextMessage(message);
textMessage.NMSTimeToLive = TimeSpan.FromMinutes(60);
textMessage.NMSDeliveryMode = MsgDeliveryMode.NonPersistent;
textMessage.Properties.SetString("ProcessorName", processor);
try
{
mStatusSender.Send(textMessage);
}
catch
{
// Do nothing
}
}
else
{
throw new ObjectDisposedException(GetType().FullName);
}
}
public void OnMessage(IMessage message)
{
using (ISession session = this.container.ConnectionFactory.CreateConnection().CreateSession())
{
Console.WriteLine("Message Received.");
ITextMessage textMessage = message as ITextMessage;
string incomingText = textMessage.Text;
Console.WriteLine("Message: {0}", incomingText);
string outgoingText = string.Format("Thanks for sending the following message: {0}", incomingText);
IDestination destination = message.NMSReplyTo;
if (destination != null)
{
ITextMessage response = session.CreateTextMessage(outgoingText);
response.NMSCorrelationID = message.NMSCorrelationID;
using (IMessageProducer producer = session.CreateProducer(destination))
{
producer.Send(response);
}
}
}
}
static void Main(string[] args)
{
IConnectionFactory factory = new ConnectionFactory("tcp://localhost:61616/");
using (IConnection connection = factory.CreateConnection())
{
using (ISession session = connection.CreateSession())
{
IMessageProducer producer = session.CreateProducer(new Apache.NMS.ActiveMQ.Commands.ActiveMQTopic("demo"));
int i = 0;
while (!Console.KeyAvailable)
{
ITextMessage msg = producer.CreateTextMessage();
msg.Text = i.ToString();
Console.WriteLine($"向Topic发送消息:{i.ToString()}");
producer.Send(msg);
Thread.Sleep(2000);
i++;
}
}
}
}
private void btn_OK_Click(object sender, EventArgs e)
{
IConnectionFactory factory = new NMSConnectionFactory("tcp://localhost:61616");
IConnection connect = factory.CreateConnection();
connect.Start();
ISession session = connect.CreateSession(AcknowledgementMode.AutoAcknowledge);
ActiveMQQueue ac = new ActiveMQQueue("Tan ne1");
IMessageProducer MessPorocedure = session.CreateProducer(ac);
//IMessage mess = new ActiveMQTextMessage(txt_send.Text);
//MessPorocedure.Send(mess);
//for (int i = 0; i < 10; i++)
//{
// MessPorocedure.Send(session.CreateTextMessage("cung dem nao "+i));
//}
MessPorocedure.Send(session.CreateTextMessage(txt_send.Text));
session.Close();
connect.Stop();
}
public void TestRequestResponseMessaging()
{
using (IConnection connection = CreateConnection())
{
connection.Start();
using (ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
{
IDestination destination = CreateDestination(session, DestinationType.Queue);
ITemporaryQueue replyTo = session.CreateTemporaryQueue();
using (IMessageConsumer consumer = session.CreateConsumer(destination))
using (IMessageProducer producer = session.CreateProducer(destination))
{
IMessage request = session.CreateMessage();
request.NMSReplyTo = replyTo;
producer.Send(request);
request = consumer.Receive(TimeSpan.FromMilliseconds(3000));
Assert.IsNotNull(request);
Assert.IsNotNull(request.NMSReplyTo);
using (IMessageProducer responder = session.CreateProducer(request.NMSReplyTo))
{
IMessage response = session.CreateTextMessage("RESPONSE");
responder.Send(response);
}
}
using (IMessageConsumer consumer = session.CreateConsumer(replyTo))
{
ITextMessage response = consumer.Receive(TimeSpan.FromMilliseconds(3000)) as ITextMessage;
Assert.IsNotNull(response);
Assert.AreEqual("RESPONSE", response.Text);
}
}
}
}
public override void Send(string filter, string value)
{
//通过工厂建立连接
using (IConnection connection = _factory.CreateConnection())
{
//通过连接创建Session会话
using (ISession session = connection.CreateSession())
{
//通过会话创建生产者，方法里面new出来的是MQ中的Queue
IMessageProducer prod =
session.CreateProducer(new Apache.NMS.ActiveMQ.Commands.ActiveMQQueue(filter));
//创建一个发送的消息对象
ITextMessage message = prod.CreateTextMessage();
//给这个对象赋实际的消息
message.Text = value;
//设置消息对象的属性，这个很重要哦，是Queue的过滤条件，也是P2P消息的唯一指定属性
//message.Properties.SetString("filter", filter);
//生产者把消息发送出去，几个枚举参数MsgDeliveryMode是否长链，MsgPriority消息优先级别，发送最小单位，当然还有其他重载
prod.Send(message, MsgDeliveryMode.NonPersistent, MsgPriority.Normal, TimeSpan.MinValue);
}
}
}
public void SendMessageQueue()
{
using (IConnection connection = this.connectionFactory.CreateConnection(Globals.ACTIVE_MQ_USERNAME, Globals.ACTIVE_MQ_PASSWORD))
{
connection.Start();
using (ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
using (IDestination producerDestination = session.GetQueue(Globals.QUEUE_NAME))
using (IMessageProducer producer = session.CreateProducer(producerDestination))
{
producer.DeliveryMode = MsgDeliveryMode.NonPersistent;
String msg = string.Format("Information sended to server MQ of Amazon!!!");
ITextMessage message = session.CreateTextMessage(msg);
producer.Send(message);
Console.WriteLine("INFO: Successful in sending message to server");
}
}
}
private void button1_Click(object sender, EventArgs e)
{
//通过工厂建立连接
using (IConnection connection = factory.CreateConnection())
{
//通过连接创建Session会话
using (ISession session = connection.CreateSession())
{
//通过会话创建生产者，方法里面new出来的是MQ中的Queue
IMessageProducer prod = session.CreateProducer(new Apache.NMS.ActiveMQ.Commands.ActiveMQQueue("firstQueue"));
//创建一个发送的消息对象
ITextMessage message = prod.CreateTextMessage();
//给这个对象赋实际的消息
message.Text = richTextBox1.Text;
//设置消息对象的属性，这个很重要哦，是Queue的过滤条件，也是P2P消息的唯一指定属性
message.Properties.SetString("filter", "demo");
//生产者把消息发送出去，几个枚举参数MsgDeliveryMode是否长链，MsgPriority消息优先级别，发送最小单位，当然还有其他重载
prod.Send(message, MsgDeliveryMode.NonPersistent, MsgPriority.Normal, TimeSpan.MinValue);
textBox1.Text = "发送成功!!";
}
}
}
public void TestCreateProducerInOnMessage()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
IConnection connection = EstablishConnection(testPeer);
connection.Start();
testPeer.ExpectBegin();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
IQueue destination = session.GetQueue("myQueue");
IQueue outbound = session.GetQueue("ForwardDest");
testPeer.ExpectReceiverAttach();
testPeer.ExpectLinkFlowRespondWithTransfer(message: CreateMessageWithContent(), 1);
testPeer.ExpectSenderAttach();
testPeer.ExpectTransfer(messageMatcher: Assert.NotNull);
testPeer.ExpectDetach(expectClosed: true, sendResponse: true, replyClosed: true);
testPeer.ExpectDispositionThatIsAcceptedAndSettled();
IMessageConsumer consumer = session.CreateConsumer(destination);
consumer.Listener += message =>
{
IMessageProducer producer = session.CreateProducer(outbound);
producer.Send(message);
producer.Close();
};
testPeer.WaitForAllMatchersToComplete(10_000);
testPeer.ExpectClose();
connection.Close();
testPeer.WaitForAllMatchersToComplete(2000);
}
}
public void SendReceiveBytesMessageContent(
[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
MsgDeliveryMode deliveryMode)
{
using (IConnection connection = CreateConnection(GetTestClientId()))
{
connection.Start();
using (ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
{
IDestination destination = CreateDestination(session, DestinationType.Queue);
using (IMessageConsumer consumer = session.CreateConsumer(destination))
using (IMessageProducer producer = session.CreateProducer(destination))
{
producer.DeliveryMode = deliveryMode;
IBytesMessage request = session.CreateBytesMessage();
request.WriteBoolean(true);
request.WriteByte((byte)1);
request.WriteBytes(new byte[1]);
request.WriteBytes(new byte[3], 0, 2);
request.WriteChar('a');
request.WriteDouble(1.5);
request.WriteSingle((float)1.5);
request.WriteInt32(1);
request.WriteInt64(1);
request.WriteObject("stringobj");
request.WriteInt16((short)1);
request.WriteString("utfstring");
producer.Send(request);
IMessage message = consumer.Receive(receiveTimeout);
AssertMessageIsReadOnly(message);
AssertBytesMessageEqual(request, message);
Assert.AreEqual(deliveryMode, message.NMSDeliveryMode, "NMSDeliveryMode does not match");
}
}
}
}
public void TestAsynchronousConsume(
[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
MsgDeliveryMode deliveryMode)
{
using (IConnection connection = CreateConnectionAndStart(GetTestClientId()))
using (ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
using (IDestination destination = CreateDestination(session, DestinationType.Queue))
using (IMessageConsumer consumer = session.CreateConsumer(destination))
using (IMessageProducer producer = session.CreateProducer(destination))
{
producer.DeliveryMode = deliveryMode;
consumer.Listener += new MessageListener(OnMessage);
IMessage request = session.CreateMessage();
request.NMSCorrelationID = "AsyncConsume";
request.NMSType = "Test";
producer.Send(request);
WaitForMessageToArrive();
Assert.AreEqual(request.NMSCorrelationID, receivedMsg.NMSCorrelationID, "Invalid correlation ID.");
}
}
private void button1_Click(object sender, EventArgs e)
{
IObjectMessage objMessage;
RequesterObject Request = new RequesterObject();
Request.Requestproerty = textBox1.Text.ToString();
IConnectionFactory factory = new NMSConnectionFactory("tcp://localhost/");
IConnection connection = factory.CreateConnection();
connection = factory.CreateConnection();
connection.Start();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
IDestination QueueDestination = SessionUtil.GetDestination(session, "Queue");
IMessageProducer MessageProducer = session.CreateProducer(QueueDestination);
objMessage = session.CreateObjectMessage(Request);
MessageProducer.Send(objMessage);
session.Close();
connection.Stop();
}
/// <summary>
/// Starts this instance.
/// </summary>
/// <exception cref="System.NotImplementedException"></exception>
private void Start()
{
while (true)
{
// Wait for a text message
var request = _consumer.Receive() as ITextMessage;
var requestText = request?.Text;
if (string.IsNullOrWhiteSpace(requestText))
{
continue;
}
// On consuming a text message send it for processing
Task.Factory.StartNew(async() =>
{
var messageToPublish = await ProfanityFilterService.Filter(requestText);
var response = _session.CreateTextMessage();
response.Text = messageToPublish;
_producer.Send(response);
});
}
}
static void Main(string[] args)
{
try
{
//Create the Connection Factory
IConnectionFactory factory = new ConnectionFactory("tcp://localhost:61616/");
using (IConnection connection = factory.CreateConnection())
{
//Create the Session
using (ISession session = connection.CreateSession())
{
//Create the Producer for the topic/queue
IMessageProducer prod = session.CreateProducer(
new Apache.NMS.ActiveMQ.Commands.ActiveMQTopic("testing"));
//Send Messages
int i = 0;
while (!Console.KeyAvailable)
{
ITextMessage msg = prod.CreateTextMessage();
msg.Text = i.ToString();
Console.WriteLine("Sending: " + i.ToString());
prod.Send(msg, Apache.NMS.MsgDeliveryMode.NonPersistent, Apache.NMS.MsgPriority.Normal, TimeSpan.MinValue);
System.Threading.Thread.Sleep(5000);
i++;
}
}
}
Console.ReadLine();
}
catch (System.Exception e)
{
Console.WriteLine("{0}", e.Message);
Console.ReadLine();
}
}
public void SendReceiveForeignMessageTest(
[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;
Message request = new Message();
request.Properties[propertyName] = propertyValue;
producer.Send(request);
IMessage message = consumer.Receive(receiveTimeout);
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");
// 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)
{
}
}
}
}
}
public ITextMessage RequestText(String jobName, String verb, String body)
{
ITextMessage ecjResponse;
ConnectionFactory connectionFactory = new ConnectionFactory(URI);
try
{
using (IConnection connection = connectionFactory.CreateConnection())
{
using (ISession session = connection.CreateSession())
{
ITemporaryQueue queue = session.CreateTemporaryQueue();
using (IMessageConsumer consumer = session.CreateConsumer(queue))
{
IMapMessage message = session.CreateMapMessage();
message.Body.SetString("VERB", verb);
message.Body.SetString("BODY", body);
message.Body.SetString("JOBNAME", jobName);
message.NMSReplyTo = queue;
string correlationId = Guid.NewGuid().ToString();
message.NMSCorrelationID = correlationId;
using (IMessageProducer producer = session.CreateProducer())
{
NmsDestinationAccessor destinationResolver = new NmsDestinationAccessor();
IDestination destination = destinationResolver.ResolveDestinationName(session, DESTINATION);
producer.Send(destination, message);
}
IMessage response = consumer.Receive(TimeSpan.FromSeconds(TIMEOUT_SECS));
ecjResponse = response as ITextMessage;
}
}
}
}
catch (Exception ex)
{
throw new ApplicationException("Failed to send request", ex);
}
return(ecjResponse);
}
private static void SendNewMessageTopic(string text)
{
string topic = "TestTopic";
string brokerUri = $"activemq:tcp://localhost:61616"; // Default port
NMSConnectionFactory factory = new NMSConnectionFactory(brokerUri);
using (IConnection connection = factory.CreateConnection())
{
connection.Start();
using (ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
using (IDestination dest = session.GetTopic(topic))
using (IMessageProducer producer = session.CreateProducer(dest))
{
producer.DeliveryMode = MsgDeliveryMode.NonPersistent;
producer.Send(session.CreateTextMessage(text));
Console.WriteLine($"Sent {text} messages");
}
}
}
public void TestTempQueueHoldsMessagesWithConsumers()
{
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
IQueue queue = session.CreateTemporaryQueue();
IMessageConsumer consumer = session.CreateConsumer(queue);
connection.Start();
IMessageProducer producer = session.CreateProducer(queue);
producer.DeliveryMode = MsgDeliveryMode.NonPersistent;
ITextMessage message = session.CreateTextMessage("Hello");
producer.Send(message);
IMessage message2 = consumer.Receive(TimeSpan.FromMilliseconds(1000));
Assert.IsNotNull(message2);
Assert.IsTrue(message2 is ITextMessage, "Expected message to be a TextMessage");
Assert.IsTrue(((ITextMessage)message2).Text.Equals(message.Text),
"Expected message to be a '" + message.Text + "'");
}
/// <summary>
/// 生产,入队列
/// </summary>
/// <param name="entity">对象</param>
/// <param name="delay">延迟时间,单位毫秒</param>
public void EnqueueObject(object entity, long delay)
{
if (producer == null)
{
if (sessionArray.Count == 0)
{
throw new Exception("队列服务尚未启动,请使用Start()方法.");
}
ISession session = sessionArray[0] as ISession;
producer = session.CreateProducer(new Apache.NMS.ActiveMQ.Commands.ActiveMQQueue(queueName));
}
IObjectMessage msg = producer.CreateObjectMessage(entity);
if (delay > 0)
{
msg.Properties["AMQ_SCHEDULED_DELAY"] = delay;
}
producer.Send(msg, Apache.NMS.MsgDeliveryMode.Persistent, Apache.NMS.MsgPriority.Normal, TimeSpan.MinValue);
//msg.Acknowledge();//不需要??
}
public IActionResult CheckAMQ(AmqModel model)
{
var url = model.Url;
if (url != null && url.Length > 0)
{
try
{
OperatorRequestObject operatorRequestObject = new OperatorRequestObject
{
ShortCode = "ABC"
};
Uri uri = new Uri("activemq:" + url);
IConnectionFactory factory = new Apache.NMS.ActiveMQ.ConnectionFactory(uri);
IConnection connection = factory.CreateConnection(); // ("admin", "admin");
connection.Start();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
IDestination queueDestination = SessionUtil.GetDestination(session, "ExampleQueue");
IMessageProducer messageProducer = session.CreateProducer(queueDestination);
var objMessage = session.CreateObjectMessage(operatorRequestObject);
messageProducer.Send(objMessage);
session.Close();
connection.Stop();
ViewData["Message"] = "All Fine even after romving Creds";
}
catch (Exception ex)
{
ViewData["Message"] = ex.Message;
}
}
else
{
ViewData["Message"] = "No URL";
}
return(View("Index"));
}
public void TestSendingMessageSetsNMSTimestamp()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
IConnection connection = EstablishConnection(testPeer);
testPeer.ExpectBegin();
testPeer.ExpectSenderAttach();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
IQueue destination = session.GetQueue("myQueue");
IMessageProducer producer = session.CreateProducer(destination);
// Create matcher to expect the absolute-expiry-time field of the properties section to
// be set to a value greater than 'now'+ttl, within a delta.
DateTime creationLower = DateTime.UtcNow;
DateTime creationUpper = creationLower + TimeSpan.FromMilliseconds(3000);
var text = "myMessage";
testPeer.ExpectTransfer(m =>
{
Assert.IsTrue(m.Header.Durable);
Assert.That(m.Properties.CreationTime.Ticks, Is.GreaterThanOrEqualTo(creationLower.Ticks).Within(TICKS_PER_MILLISECOND));
Assert.That(m.Properties.CreationTime.Ticks, Is.LessThanOrEqualTo(creationUpper.Ticks).Within(TICKS_PER_MILLISECOND));
Assert.AreEqual(text, (m.BodySection as AmqpValue).Value);
});
ITextMessage message = session.CreateTextMessage(text);
producer.Send(message);
testPeer.WaitForAllMatchersToComplete(1000);
testPeer.ExpectClose();
connection.Close();
testPeer.WaitForAllMatchersToComplete(1000);
}
}
public void SendReceiveBytesMessageContentTest(MsgDeliveryMode deliveryMode)
{
using (IConnection connection = CreateConnection(TEST_CLIENT_ID + ":" + new Random().Next()))
{
connection.Start();
using (ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
{
IDestination destination = session.CreateTemporaryTopic();
using (IMessageConsumer consumer = session.CreateConsumer(destination))
using (IMessageProducer producer = session.CreateProducer(destination))
{
producer.DeliveryMode = deliveryMode;
producer.RequestTimeout = receiveTimeout;
IBytesMessage request = session.CreateBytesMessage();
request.WriteBoolean(true);
request.WriteByte((byte)1);
request.WriteBytes(new byte[1]);
request.WriteBytes(new byte[3], 0, 2);
request.WriteChar('a');
request.WriteDouble(1.5);
request.WriteSingle((float)1.5);
request.WriteInt32(1);
request.WriteInt64(1);
request.WriteObject("stringobj");
request.WriteInt16((short)1);
request.WriteString("utfstring");
producer.Send(request);
IMessage message = consumer.Receive(receiveTimeout);
AssertBytesMessageEqual(request, message);
AssertMessageIsReadOnly(message);
Assert.AreEqual(deliveryMode, message.NMSDeliveryMode, "NMSDeliveryMode does not match");
}
}
}
}
public void TestSendingMessageSetsNMSMessageId()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
IConnection connection = EstablishConnection(testPeer);
testPeer.ExpectBegin();
testPeer.ExpectSenderAttach();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
IQueue destination = session.GetQueue("myQueue");
IMessageProducer producer = session.CreateProducer(destination);
string text = "myMessage";
string actualMessageId = null;
testPeer.ExpectTransfer(m =>
{
Assert.IsTrue(m.Header.Durable);
Assert.IsNotEmpty(m.Properties.MessageId);
actualMessageId = m.Properties.MessageId;
});
testPeer.ExpectClose();
ITextMessage message = session.CreateTextMessage(text);
Assert.IsNull(message.NMSMessageId, "NMSMessageId should not yet be set");
producer.Send(message);
Assert.IsNotNull(message.NMSMessageId);
Assert.IsNotEmpty(message.NMSMessageId, "NMSMessageId should be set");
Assert.IsTrue(message.NMSMessageId.StartsWith("ID:"), "MMS 'ID:' prefix not found");
connection.Close();
testPeer.WaitForAllMatchersToComplete(1000);
// Get the value that was actually transmitted/received, verify it is a string, compare to what we have locally
Assert.AreEqual(message.NMSMessageId, actualMessageId, "Expected NMSMessageId value to be present in AMQP message");
}
}
public void TestQueueSessionListenerExceptionDlq()
{
connection.Start();
session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
IQueue queue = session.CreateTemporaryQueue();
IMessageProducer producer = CreateProducer(session, queue);
IMessage message = CreateTextMessage(session);
producer.Send(message);
IDestination dlqDestination = session.GetQueue("ActiveMQ.DLQ");
connection.DeleteDestination(dlqDestination);
IMessageConsumer dlqConsumer = session.CreateConsumer(dlqDestination);
dlqConsumer.Listener += new MessageListener(OnDlqMessage);
IMessageConsumer consumer = session.CreateConsumer(queue);
consumer.Listener += new MessageListener(OnRedeliveredMessage);
Assert.IsTrue(gotMaxRedeliveries.await(TimeSpan.FromSeconds(20)), "got message before retry expiry");
// check DLQ
Assert.IsTrue(gotOneDlqMessage.await(TimeSpan.FromSeconds(20)), "got dlq message");
// check DLQ message cause is captured
message = dlqMessages[0] as IMessage;
Assert.IsNotNull(message, "dlq message captured");
String cause = message.Properties.GetString("dlqDeliveryFailureCause");
Assert.IsTrue(cause.Contains("JMSException"), "cause 'cause' exception is remembered");
Assert.IsTrue(cause.Contains("Test"), "is correct exception");
Assert.IsTrue(cause.Contains("RedeliveryPolicy"), "cause policy is remembered");
session.Close();
}
public IActionResult SaveDocument(Document document)
{
if (ModelState.IsValid)
{
dbManager.Documents.Add(document);
dbManager.SaveChanges();
String message = "{"
+ " \"nom\" : " + " \"" + document.Nom + " \", "
+ " \"format\" : " + " \"" + document.Format + " \", "
+ " \"taille\" : " + document.Taille
+ "}";
try
{
IConnectionFactory connectionFactory = new ConnectionFactory("tcp://localhost:61616");
IConnection _connection = connectionFactory.CreateConnection();
_connection.Start();
ISession _session = _connection.CreateSession();
IDestination destination = _session.GetDestination("topic://jmsapp");
using (IMessageProducer producer = _session.CreateProducer(destination))
{
var textMessage = producer.CreateTextMessage(message);
textMessage.Properties.SetString("code", "C1");
producer.Send(textMessage);
}
}
catch (Exception exception)
{
Console.WriteLine(exception.ToString());
}
return(RedirectToAction("Index"));
}
IEnumerable <Famille> familles = dbManager.Familles.ToList();
ViewBag.Familles = familles;
return(View("AddDocument", document));
}
/// <summary>
/// 发送Xml内容的Queue消息
/// </summary>
/// <param name="queue">消息队列名称</param>
/// <param name="doc">XmlDocument</param>
public void ProduceQueueMessage(string queue, XmlDocument doc)
{
try
{
using (IConnection connection = _factory.CreateConnection(_user, _pwd))
{
connection.Start();
using (ISession session = connection.CreateSession())
{
IMessageProducer producer = session.CreateProducer(new Apache.NMS.ActiveMQ.Commands.ActiveMQQueue(queue));
ITextMessage msg = producer.CreateTextMessage();
msg.Text = doc.InnerXml;
producer.Send(msg, MsgDeliveryMode.Persistent, MsgPriority.Normal, TimeSpan.MinValue);
}
connection.Stop();
connection.Close();
}
}
catch (Exception ex)
{
throw ex;
}
}
protected void DelayedProducerThreadProc(Object arg)
{
try
{
ThreadArg args = arg as ThreadArg;
using (ISession session = args.connection.CreateSession())
{
using (IMessageProducer producer = session.CreateProducer(args.destination))
{
// Give the consumer time to enter the receive.
Thread.Sleep(5000);
producer.Send(args.session.CreateTextMessage("Hello World"));
}
}
}
catch (Exception e)
{
// Some other exception occurred.
Assert.Fail("Test failed with exception: " + e.Message);
}
}
private void TruyenData()
{
IConnectionFactory factory = new ConnectionFactory("tcp://localhost:61616");
IConnection con = factory.CreateConnection("admin", "admin");
con.Start();
ISession session = con.CreateSession(AcknowledgementMode.AutoAcknowledge);
ActiveMQQueue destination = new ActiveMQQueue("donThuoc");
IMessageProducer producer = session.CreateProducer(destination);
eDonThuoc dt = new eDonThuoc();
dt.idNhaSi = idNV;;
dt.ngayLap = DateTime.Today;
dt.idPhieuKham = str;
dt.idDonThuoc = donThuocWCFClient.getIdLast();
dt.tinhTrang = false;
string xml = new ObjectToXml <eDonThuoc>().object2XML(dt);
IMessage msg = new ActiveMQTextMessage(xml);
producer.Send(msg);
session.Close();
con.Close();
}
private Boolean DoLogout(String name)
{
ITextMessage request = _session.CreateTextMessage("logout");
//request.NMSReplyTo = _readQueue;
request.Properties["Name"] = name;
Trace.TraceInformation("Sending logout for '{0}'", name);
IDestination destination = SessionUtil.GetDestination(_session, "topic://fennecfox.listeners");
using (IMessageProducer loginTopic = _session.CreateProducer(destination))
{
try
{
loginTopic.Send(request);
}
catch (RequestTimedOutException)
{
Trace.TraceInformation("*** Timeout sending login for '{0}'", name);
return(false);
}
}
return(true);
}
public void Send(string message)
{
try
{
var connection = Connection;
var session = connection.CreateSession();
_request = session.CreateTextMessage(message);
_destination = SessionUtil.GetDestination(session, "queue://" + Queue);
_producer = session.CreateProducer(_destination);
if (!stopped)
_producer.Send(_request);
}
catch (Apache.NMS.ActiveMQ.BrokerException)
{
Reset();
System.Threading.Thread.Sleep(5000);
}
catch (ThreadAbortException tae)
{
// catch debugging exceptions only when a debugger is attached.
Console.WriteLine(tae);
}
catch
{
Reset();
}
}
void Send(IMessageProducer producer, string message)
{
ITextMessage txtMessage = producer.CreateTextMessage();
txtMessage.Text = message;
_logger.DebugFormat("开始向 {0} 发送消息", _nm);
try
{
producer.Send(txtMessage);
_logger.DebugFormat("向 {0} 发送消息完成", _nm);
}
catch (Exception e)
{
if (_logger.IsDebugEnabled)
_logger.Debug(string.Format("向 {0} 发送消息发生错误", _nm), e);
throw;
}
}
void Send(IMessageProducer producer, MapMessage message)
{
IMapMessage mapMessage = producer.CreateMapMessage();
foreach (KeyValuePair<string, object> kp in message.Properties)
{
mapMessage.Properties[kp.Key] = kp.Value;
}
foreach (KeyValuePair<string, object> kp in message.Body)
{
mapMessage.Body[kp.Key] = kp.Value;
}
_logger.DebugFormat("开始向 {0} 发送消息", _nm);
try
{
if (isDefault)
{
producer.Send(mapMessage);
}
else if (isFast)
{
DateTime old = DateTime.Now;
producer.Send(mapMessage);
isFast = ((DateTime.Now - old) < TimeSpan.FromSeconds(1));
if (!isFast)
_logger.DebugFormat("向 {0} 发送消息发现耗时太长, 决定以后跳过!", _nm);
}
else
{
throw new ApplicationException("发送消息耗时太长, 决定跳过");
}
}
catch (Exception e)
{
if (_logger.IsDebugEnabled)
_logger.Debug(string.Format("向 {0} 发送消息发生错误", _nm), e);
throw;
}
}
/// <summary> Actually send the given EMS message.</summary>
/// <param name="producer">the EMS MessageProducer to send with
/// </param>
/// <param name="message">the EMS Message to send
/// </param>
/// <exception cref="EMSException">If there is any problem accessing the EMS API</exception>
protected virtual void DoSend(IMessageProducer producer, Message message)
{
if (ExplicitQosEnabled)
{
producer.Send(message, DeliveryMode, Priority, TimeToLive);
}
else
{
producer.Send(message);
}
}
protected void SendMessage(IMessageProducer producer)
{
IMessage request = producer.CreateMessage();
request.NMSType = "Test";
producer.Send(request);
}
public static void Send(this IMessage message, IMessageProducer producer, MsgDeliveryMode deliveryMode, MsgPriority priority, TimeSpan timeToLive)
{
producer.Send(message, deliveryMode, priority, timeToLive);
}
