public static string SendMessageToQueue(
[MarshalAs(UnmanagedType.LPWStr)] string queueName,
[MarshalAs(UnmanagedType.LPWStr)] string message)
{
try
{
IDestination destination = SessionUtil.GetDestination(session, "queue://" + queueName);
Console.WriteLine("Using destination: " + destination);
// Create a consumer and producer
using (IMessageProducer producer = session.CreateProducer(destination))
{
// Start the connection so that messages will be processed.
connection.Start();
// Send a message
ITextMessage request = session.CreateTextMessage(message);
//request.NMSCorrelationID = "abc";
//request.Properties["NMSXGroupID"] = "cheese";
//request.Properties["myHeader"] = "Cheddar";
producer.Send(request);
}
}
catch (Exception e)
{
return("ERROR when send message to queue: " + queueName + ", details:" + e.Message.ToString());
}
return("");
}
public void TestConnection()
{
IConnectionFactory factory = new NMSConnectionFactory(NMSTestSupport.ReplaceEnvVar(connectionUri));
using (connection = factory.CreateConnection())
using (ISession session = connection.CreateSession())
{
IDestination destination = SessionUtil.GetDestination(session, "queue://TEST.test.in");
using (IMessageConsumer consumer = session.CreateConsumer(destination))
{
Connection amqConnection = connection as Connection;
connection.ExceptionListener += ConnectionException;
consumer.Listener += OnMessage;
TcpFaultyTransport transport = amqConnection.ITransport.Narrow(typeof(TcpFaultyTransport)) as TcpFaultyTransport;
Assert.IsNotNull(transport);
transport.OnewayCommandPreProcessor += FailOnKeepAlive;
Thread.Sleep(TimeSpan.FromSeconds(2));
connection.Start();
Assert.IsTrue(exceptionOccuredEvent.WaitOne(TimeSpan.FromSeconds(30 * 3)),
"Exception didnt occured within waiting time");
}
}
}
public void SendReceiveMessageIdComparisonTest(MsgDeliveryMode deliveryMode)
{
using (IConnection connection = CreateConnection(TEST_CLIENT_ID + ":" + new Random().Next()))
{
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;
IMessage request1 = session.CreateMessage();
IMessage request2 = session.CreateMessage();
IMessage request3 = session.CreateMessage();
producer.Send(request1);
producer.Send(request2);
producer.Send(request3);
IMessage message1 = consumer.Receive(receiveTimeout);
Assert.IsNotNull(message1, "No message returned!");
IMessage message2 = consumer.Receive(receiveTimeout);
Assert.IsNotNull(message2, "No message returned!");
IMessage message3 = consumer.Receive(receiveTimeout);
Assert.IsNotNull(message3, "No message returned!");
Assert.AreNotEqual(message1.NMSMessageId, message2.NMSMessageId);
Assert.AreNotEqual(message1.NMSMessageId, message3.NMSMessageId);
Assert.AreNotEqual(message2.NMSMessageId, message3.NMSMessageId);
}
}
}
}
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();
}
}
/// <summary>
/// Envia un mensaje vacío a la cola especificada.
/// </summary>
/// <param name="queueName"></param>
/// <returns></returns>
public void CrearSessionAtomica(string queueName)
{
try
{
IConnection connection = CrearSessionAtomica(ServidorBrokerUri,
AcknowledgementMode.AutoAcknowledge,
UserName,
Password,
queueName);
using (ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
{
IDestination destination = SessionUtil.GetDestination(session, queueName);
using (IMessageProducer producer = session.CreateProducer(destination))
{
ITextMessage textMessage = producer.CreateTextMessage();
producer.DeliveryMode = MsgDeliveryMode.NonPersistent;
producer.DisableMessageID = true;
producer.DisableMessageTimestamp = true;
producer.Send(textMessage);
producer.Priority = MsgPriority.Lowest;
producer.TimeToLive = TimeSpan.MinValue;
producer.Close();
//connection.PurgeTempDestinations();
}
}
connection.Close();
}
catch (Exception ex)
{
Log.Error(ex, Constantes.MsgLog.ERRORMETODO, nameof(CrearSessionAtomica));
throw ex;
}
}
public void TestTemporaryQueueAsynchronousConsume(
[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
MsgDeliveryMode deliveryMode)
{
using (IConnection connection = CreateConnection(GetTestClientId()))
{
connection.Start();
using (ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
{
IDestination destination = SessionUtil.GetDestination(session, DESTINATION_NAME);
ITemporaryQueue tempReplyDestination = session.CreateTemporaryQueue();
using (IMessageConsumer consumer = session.CreateConsumer(destination))
using (IMessageConsumer tempConsumer = session.CreateConsumer(tempReplyDestination))
using (IMessageProducer producer = session.CreateProducer(destination))
{
producer.DeliveryMode = deliveryMode;
tempConsumer.Listener += new MessageListener(OnMessage);
consumer.Listener += new MessageListener(OnQueueMessage);
IMessage request = session.CreateMessage();
request.NMSCorrelationID = "TemqQueueAsyncConsume";
request.NMSType = "Test";
request.NMSReplyTo = tempReplyDestination;
producer.Send(request);
WaitForMessageToArrive();
Assert.AreEqual("TempQueueAsyncResponse", receivedMsg.NMSCorrelationID, "Invalid correlation ID.");
}
}
}
}
void AMQWriter()
{
try {
IDestination destination_Write = SessionUtil.GetDestination(session, defaultWriteTopic);
IMessageProducer defaultProducer = session.CreateProducer(destination_Write);
defaultProducer.DeliveryMode = MsgDeliveryMode.NonPersistent;
defaultProducer.RequestTimeout = System.TimeSpan.FromMilliseconds(250);
while (networkOpen) {
MSG msg = new MSG("");
lock (_sendQueueLock) {
if (_sendQueue.Count > 0) {
msg = _sendQueue.Dequeue();
}
}
if (msg.data.Length > 0) {
if (msg.src.Length == 0) {
defaultProducer.Send(session.CreateTextMessage(msg.data));
} else {
IMessageProducer producer = session.CreateProducer(SessionUtil.GetDestination(session, msg.src));
producer.DeliveryMode = MsgDeliveryMode.NonPersistent;
producer.RequestTimeout = receiveTimeout;
producer.Send(session.CreateTextMessage(msg.data));
}
}
}
} catch (System.Exception e) {
Debug.LogWarning("AMQWriter Exception " + e);
}
}
protected void doTestCreateConsumerAfterSend(bool persistent)
{
using (IConnection connection = CreateConnection(TEST_CLIENT_ID))
{
connection.Start();
using (ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
{
IDestination destination = SessionUtil.GetDestination(session, DESTINATION_NAME);
using (IMessageProducer producer = session.CreateProducer(destination))
{
producer.Persistent = false;
producer.RequestTimeout = receiveTimeout;
IMessage request = session.CreateMessage();
request.NMSCorrelationID = "AsyncConsumeAfterSend";
request.NMSType = "Test";
producer.Send(request);
using (IMessageConsumer consumer = session.CreateConsumer(destination))
{
consumer.Listener += new MessageListener(OnMessage);
WaitForMessageToArrive();
Assert.AreEqual(request.NMSCorrelationID, receivedMsg.NMSCorrelationID, "Invalid correlation ID.");
}
}
}
}
}
private void Run()
{
var connectionFactory = new NetTxConnectionFactory("failover:(tcp://localhost:61616,tcp://localhost:61616)?randomize=false&timeout=5000")
{
AcknowledgementMode = AcknowledgementMode.Transactional,
PrefetchPolicy = { QueuePrefetch = 1 }
};
using (var connection = connectionFactory.CreateNetTxConnection())
{
currentconnection = connection;
connection.Start();
using (var session = connection.CreateNetTxSession())
{
this.session = session;
var eventDestination = SessionUtil.GetDestination(session, "queue://Consumer.NMS.VirtualTopic.EventMessage");
var commandDestination = SessionUtil.GetDestination(session, "queue://subscribernms");
using (var eventConsumer = session.CreateConsumer(eventDestination))
using (var commandConsumer = session.CreateConsumer(commandDestination))
{
eventConsumer.Listener += OnEventMessage;
commandConsumer.Listener += this.OnCommandMessage;
Console.WriteLine("Consumer started. Press q to quit");
while (Console.ReadKey().KeyChar != 'q')
{
}
}
}
connection.Stop();
}
}
public void TempDestinationDeletionTest(MsgDeliveryMode deliveryMode, string destinationName)
{
using (IConnection connection1 = CreateConnection(TEST_CLIENT_ID))
{
connection1.Start();
using (ISession session = connection1.CreateSession(AcknowledgementMode.AutoAcknowledge))
{
const int MaxNumDestinations = 100;
for (int index = 1; index <= MaxNumDestinations; index++)
{
IDestination destination = SessionUtil.GetDestination(session, destinationName);
using (IMessageProducer producer = session.CreateProducer(destination))
using (IMessageConsumer consumer = session.CreateConsumer(destination))
{
producer.DeliveryMode = deliveryMode;
IMessage request = session.CreateTextMessage("Hello World, Just Passing Through!");
request.NMSType = "TEMP_MSG";
producer.Send(request);
IMessage receivedMsg = consumer.Receive();
Assert.AreEqual(receivedMsg.NMSType, "TEMP_MSG");
}
session.DeleteDestination(destination);
}
}
}
}
protected void doTestTemporaryQueueAsynchronousConsume(bool persistent)
{
using (IConnection connection = CreateConnection(TEST_CLIENT_ID))
{
connection.Start();
using (ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
{
IDestination destination = SessionUtil.GetDestination(session, DESTINATION_NAME);
ITemporaryQueue tempReplyDestination = session.CreateTemporaryQueue();
using (IMessageConsumer consumer = session.CreateConsumer(destination))
using (IMessageConsumer tempConsumer = session.CreateConsumer(tempReplyDestination))
using (IMessageProducer producer = session.CreateProducer(destination))
{
producer.Persistent = persistent;
producer.RequestTimeout = receiveTimeout;
tempConsumer.Listener += new MessageListener(OnMessage);
consumer.Listener += new MessageListener(OnQueueMessage);
IMessage request = session.CreateMessage();
request.NMSCorrelationID = "TemqQueueAsyncConsume";
request.NMSType = "Test";
request.NMSReplyTo = tempReplyDestination;
producer.Send(request);
WaitForMessageToArrive();
Assert.AreEqual("TempQueueAsyncResponse", receivedMsg.NMSCorrelationID, "Invalid correlation ID.");
}
}
}
}
private static void ReceiveMessages()
{
try
{
IConnectionFactory factory = new NMSConnectionFactory(ConfigHelper.GetConfigValueByKey("QueueConnectionString"));
Apache.NMS.IConnection connection = factory.CreateConnection();
//"username", "password"
connection.Start();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
IDestination queueDestination = SessionUtil.GetDestination(session, ConfigHelper.GetConfigValueByKey("QueueName"));
IMessageConsumer consumer = session.CreateConsumer(queueDestination);
consumer.Listener += new MessageListener(Message_Listener);
Thread.Sleep(Convert.ToInt32(ConfigHelper.GetConfigValueByKey("TimeOut")));
connection.Close();
Console.WriteLine("Restart message wait");
}
catch (Exception e)
{
StreamWriter sw = new StreamWriter("error.txt", true);
sw.WriteLine("Error==={0}==={1}", DateTime.Now.ToString(), e.ToString());
sw.Close();
}
ReceiveMessages();
}
void ApolloWriter()
{
try {
IDestination destination_Write = SessionUtil.GetDestination(session, topicWrite);
IMessageProducer producer = session.CreateProducer(destination_Write);
producer.DeliveryMode = MsgDeliveryMode.NonPersistent;
producer.RequestTimeout = receiveTimeout;
while (networkOpen)
{
if (writeMessageQueue.Count > 0)
{
string msg;
lock (_writeMessageQueueLock) {
msg = writeMessageQueue.Dequeue();
}
try {
if (msg.Length > 0)
{
producer.Send(session.CreateTextMessage(msg));
}
} catch (RequestTimedOutException rte) {
Debug.Log("Timeout " + rte);
continue;
}
}
}
} catch (System.Exception e) {
Debug.Log("ApolloWriter Exception " + e);
}
}
public static T PullFromActiveMQ(int queueNumber)
{
Uri connecturi = new Uri("activemq:tcp://localhost:61616");
// NOTE: ensure the nmsprovider-activemq.config file exists in the executable folder.
IConnectionFactory factory = new NMSConnectionFactory(connecturi);
using (IConnection connection = factory.CreateConnection())
using (ISession session = connection.CreateSession())
{
IDestination destination = SessionUtil.GetDestination(session, GETQueueName(queueNumber));
// Create a consumer and producer
using (IMessageConsumer consumer = session.CreateConsumer(destination))
using (IMessageProducer producer = session.CreateProducer(destination))
{
// Start the connection so that messages will be processed.
connection.Start();
producer.DeliveryMode = MsgDeliveryMode.Persistent;
// Consume a message
ITextMessage message = consumer.Receive() as ITextMessage;
if (message == null)
{
return(default(T));
}
else
{
T opld = Newtonsoft.Json.JsonConvert.DeserializeObject <T>(message.Text);
return(opld);
}
}
}
}
public void TestMaxInactivityDuration()
{
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))
{
SendMessage(producer);
IMessage receivedMsg = consumer.Receive(TimeSpan.FromSeconds(5));
Assert.AreEqual(CORRELATION_ID, receivedMsg.NMSCorrelationID, "Invalid correlation ID.");
// Go inactive...
Thread.Sleep(60 * 1000);
// Send another message.
SendMessage(producer);
receivedMsg = consumer.Receive(TimeSpan.FromSeconds(5));
Assert.AreEqual(CORRELATION_ID, receivedMsg.NMSCorrelationID, "Invalid correlation ID.");
}
}
}
}
private void SendMessageToBackgroundProcess()
{
//TODO: this is copid alot. This boiler plate code should be in a common shared class and setup using the same DI setup that the db context goes through.
Uri connecturi = new Uri("activemq:tcp://activemq:61616");
// NOTE: ensure the nmsprovider-activemq.config file exists in the executable folder.
IConnectionFactory factory = new NMSConnectionFactory(connecturi);
using (IConnection connection = factory.CreateConnection())
using (ISession session = connection.CreateSession())
{
IDestination destination = SessionUtil.GetDestination(session, "queue://FOO.BAR");
// Create a consumer and producer
using (IMessageProducer producer = session.CreateProducer(destination))
{
// Start the connection so that messages will be processed.
connection.Start();
producer.DeliveryMode = MsgDeliveryMode.Persistent;
// Send a message
ITextMessage request = session.CreateTextMessage("Message from actor api service.");
producer.Send(request);
}
}
}
public void TestAsynchronousTextMessageConsume(
[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
MsgDeliveryMode deliveryMode)
{
using (IConnection connection = CreateConnection(GetTestClientId()))
{
connection.Start();
using (ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
{
IDestination destination = SessionUtil.GetDestination(session, DESTINATION_NAME);
using (IMessageConsumer consumer = session.CreateConsumer(destination))
{
consumer.Listener += new MessageListener(OnMessage);
using (IMessageProducer producer = session.CreateProducer(destination))
{
producer.DeliveryMode = deliveryMode;
ITextMessage request = session.CreateTextMessage("Hello, World!");
request.NMSCorrelationID = "AsyncConsumeTextMessage";
request.Properties["NMSXGroupID"] = "cheese";
request.Properties["myHeader"] = "James";
producer.Send(request);
WaitForMessageToArrive();
Assert.AreEqual(request.NMSCorrelationID, receivedMsg.NMSCorrelationID, "Invalid correlation ID.");
Assert.AreEqual(request.Properties["NMSXGroupID"], receivedMsg.Properties["NMSXGroupID"], "Invalid NMSXGroupID.");
Assert.AreEqual(request.Properties["myHeader"], receivedMsg.Properties["myHeader"], "Invalid myHeader.");
Assert.AreEqual(request.Text, ((ITextMessage)receivedMsg).Text, "Invalid text body.");
}
}
}
}
}
/// <summary>
/// Gets a clear destination. This will try to delete an existing
/// destination and re-create it.
/// </summary>
/// <param name="session">Session</param>
/// <param name="destinationURI">Destination URI</param>
/// <returns>Clear destination</returns>
public virtual IDestination GetClearDestination(ISession session,
string destinationURI)
{
IDestination destination;
try
{
DeleteDestination(session, destinationURI);
destination = CreateDestination(session, destinationURI);
}
catch (Exception)
{
// Can't delete it, so lets try and purge it.
destination = SessionUtil.GetDestination(session, destinationURI);
using (IMessageConsumer consumer = session.CreateConsumer(destination))
{
while (consumer.Receive(TimeSpan.FromMilliseconds(750)) != null)
{
}
}
}
return(destination);
}
public void TestCreateConsumerAfterSend(
[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
MsgDeliveryMode deliveryMode)
{
using (IConnection connection = CreateConnection(GetTestClientId()))
{
connection.Start();
using (ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
{
IDestination destination = SessionUtil.GetDestination(session, DESTINATION_NAME);
using (IMessageProducer producer = session.CreateProducer(destination))
{
producer.DeliveryMode = deliveryMode;
IMessage request = session.CreateMessage();
request.NMSCorrelationID = "AsyncConsumeAfterSend";
request.NMSType = "Test";
producer.Send(request);
using (IMessageConsumer consumer = session.CreateConsumer(destination))
{
consumer.Listener += new MessageListener(OnMessage);
WaitForMessageToArrive();
Assert.AreEqual(request.NMSCorrelationID, receivedMsg.NMSCorrelationID, "Invalid correlation ID.");
}
}
}
}
}
public void TestAsynchronousConsume(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;
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.");
}
}
}
}
public void Login(String name)
{
Uri connecturi = new Uri("failover:tcp://mq.checkmywwstats.com:61616");
Trace.TraceInformation("About to connect to " + connecturi);
// NOTE: ensure the nmsprovider-activemq.config file exists in the executable folder.
IConnectionFactory factory = new Apache.NMS.ActiveMQ.ConnectionFactory(connecturi);
_connection = factory.CreateConnection();
_session = _connection.CreateSession();
// Examples for getting a destination:
//
// Hard coded destinations:
// IDestination destination = session.GetQueue("FOO.BAR");
// Debug.Assert(destination is IQueue);
// IDestination destination = session.GetTopic("FOO.BAR");
// Debug.Assert(destination is ITopic);
//
// Embedded destination type in the name:
// IDestination destination = SessionUtil.GetDestination(session, "queue://FOO.BAR");
// Debug.Assert(destination is IQueue);
// IDestination destination = SessionUtil.GetDestination(session, "topic://FOO.BAR");
// Debug.Assert(destination is ITopic);
//
// Defaults to queue if type is not specified:
// IDestination destination = SessionUtil.GetDestination(session, "FOO.BAR");
// Debug.Assert(destination is IQueue);
//
// .NET 3.5 Supports Extension methods for a simplified syntax:
// IDestination destination = session.GetDestination("queue://FOO.BAR");
// Debug.Assert(destination is IQueue);
// IDestination destination = session.GetDestination("topic://FOO.BAR");
// Debug.Assert(destination is ITopic);
//_readQueue = _session.CreateTemporaryQueue();
DoLogin(name);
IDestination destination = SessionUtil.GetDestination(_session, "queue://fennecfox.pleasereadlobby");
Trace.TraceInformation("Using destination: " + destination);
_lobbyRequestsQueue = _session.CreateConsumer(destination);
destination = SessionUtil.GetDestination(_session, "queue://fennecfox.pleasereadthread");
_threadRequestsQueue = _session.CreateConsumer(destination);
destination = SessionUtil.GetDestination(_session, "queue://fennecfox.posts");
_postsQueue = _session.CreateProducer(destination);
destination = SessionUtil.GetDestination(_session, "queue://fennecfox.lobby");
_lobbyQueue = _session.CreateProducer(destination);
_lobbyQueue.DeliveryMode = MsgDeliveryMode.NonPersistent;
// Start the connection so that messages will be processed.
_connection.Start();
_postsQueue.DeliveryMode = MsgDeliveryMode.NonPersistent;
_postsQueue.RequestTimeout = receiveTimeout;
_lobbyQueue.DeliveryMode = MsgDeliveryMode.NonPersistent;
_lobbyQueue.RequestTimeout = receiveTimeout;
_lobbyRequestsQueue.Listener += new MessageListener(OnLobbyMessage);
_threadRequestsQueue.Listener += new MessageListener(OnThreadMessage);
}
protected void ExecutePointToPoint(string data, string queueName, int?expirySecs = null)
{
var expiry = expirySecs.HasValue ? (TimeSpan?)TimeSpan.FromSeconds(expirySecs.Value) : null;
var queue = SessionUtil.GetDestination(Session, queueName);
Produce(Session, data, queue, expiry);
}
protected override async Task ExecuteAsync(CancellationToken ct)
{
_logger.LogInformation("CONSUMER running at: {time}", DateTimeOffset.Now);
_logger.LogInformation($"CONSUMER about to connect to {_options.ConnectUri}");
var factory = new NMSConnectionFactory(_options.ConnectUri);
using var connection = factory.CreateConnection();
using var session = connection.CreateSession();
var destination = SessionUtil.GetDestination(session, _options.Destination);
_logger.LogInformation($"CONSUMER using destination: {destination}");
using var consumer = session.CreateConsumer(destination);
connection.Start();
consumer.Listener += (IMessage message) =>
{
_logger.LogInformation($"Received message with ID: {message.NMSMessageId}");
_logger.LogInformation($"Received message with text: {(message as ITextMessage).Text}");
};
ct.WaitHandle.WaitOne();
}
static void Main(string[] args)
{
var uri = new Uri("activemq:tcp://*****:*****@gmail.com"
});
producer.Send(msg);
Console.WriteLine("Send");
}
}
}
}
/// <summary>
/// Envia mensaje al ActiveMQ y lo traduce si es requerido. [lanza excepcion]
/// </summary>
/// <param name="message"></param>
/// <param name="queueNameDestino"></param>
/// <param name="propertyValue">Valor de la propiedad adicional del objeto ITextMessage (dispositivoId)</param>
/// <returns></returns>
public async Task EmitirMensajeActiveMQAsync(string message, string queueNameDestino, string propertyValue)
{
try
{
CrearConexion(ServidorBrokerUri, AcknowledgementMode.AutoAcknowledge);
IDestination destination = SessionUtil.GetDestination(Session, queueNameDestino);
using (IMessageProducer producer = Session.CreateProducer(destination))
{
ITextMessage textMessage = producer.CreateTextMessage(message);
textMessage.Properties.SetString("dispositivoId", propertyValue);
producer.Send(textMessage);
}
}
catch (Exception ex)
{
Log.Error(ex, Constantes.MsgLog.ERRORMETODO, nameof(EmitirMensajeActiveMQAsync));
throw ex;
}
finally
{
//if (Connection != null)
//{
// Connection.Close();
//}
}
}
void ApolloWriter()
{
#if !UNITY_EDITOR && UNITY_METRO
throw new System.NotImplementedException();
#else
try {
IDestination destination_Write = SessionUtil.GetDestination(session, topicWrite);
IMessageProducer producer = session.CreateProducer(destination_Write);
producer.DeliveryMode = MsgDeliveryMode.NonPersistent;
producer.RequestTimeout = receiveTimeout;
while (networkOpen)
{
string msg = "";
lock (_sendQueueLock) {
if (_sendQueue.Count > 0)
{
msg = _sendQueue.Dequeue();
}
}
if (msg != null && msg.Length > 0)
{
producer.Send(session.CreateTextMessage(msg));
}
}
} catch (System.Exception e) {
Debug.Log("ApolloWriter Exception " + e);
}
#endif
}
public void TestZeroPrefetchSize()
{
using (IConnection connection = CreateConnection())
{
connection.Start();
using (Session session = (Session)connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
{
IDestination destination = SessionUtil.GetDestination(session, DESTINATION_NAME);
session.PrefetchSize = 0;
using (IMessageConsumer consumer = session.CreateConsumer(destination))
using (IMessageProducer producer = session.CreateProducer(destination))
{
SendMessage(producer);
SendMessage(producer);
IMessage receivedMsg = consumer.Receive(TimeSpan.FromSeconds(5));
Assert.IsNotNull(receivedMsg);
receivedMsg = consumer.Receive(TimeSpan.FromSeconds(5));
Assert.IsNotNull(receivedMsg);
receivedMsg = consumer.Receive(TimeSpan.FromSeconds(5));
Assert.IsNull(receivedMsg);
// Send another message.
SendMessage(producer);
receivedMsg = consumer.Receive(TimeSpan.FromSeconds(5));
Assert.IsNotNull(receivedMsg);
}
}
}
}
public void TestMaxInactivityDuration()
{
string testuri = "activemq:tcp://${activemqhost}:61616" +
"?wireFormat.maxInactivityDurationInitialDelay=5000" +
"&wireFormat.maxInactivityDuration=10000" +
"&connection.asyncClose=false";
NMSConnectionFactory factory = new NMSConnectionFactory(NMSTestSupport.ReplaceEnvVar(testuri));
using (IConnection connection = factory.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))
{
SendMessage(producer);
IMessage receivedMsg = consumer.Receive(TimeSpan.FromSeconds(5));
Assert.AreEqual(CORRELATION_ID, receivedMsg.NMSCorrelationID, "Invalid correlation ID.");
// Go inactive...
Thread.Sleep(TimeSpan.FromSeconds(30));
// Send another message.
SendMessage(producer);
receivedMsg = consumer.Receive(TimeSpan.FromSeconds(5));
Assert.AreEqual(CORRELATION_ID, receivedMsg.NMSCorrelationID, "Invalid correlation ID.");
}
}
}
}
public static void PushToActiveMQ(T opldObject, int queueNumber)
{
Uri connecturi = new Uri("activemq:tcp://54.173.238.145:61616");
// NOTE: ensure the nmsprovider-activemq.config file exists in the executable folder.
IConnectionFactory factory = new NMSConnectionFactory(connecturi);
using (IConnection connection = factory.CreateConnection())
using (ISession session = connection.CreateSession())
{
IDestination destination = SessionUtil.GetDestination(session, GETQueueName(queueNumber));
// Create the producer
using (IMessageProducer producer = session.CreateProducer(destination))
{
// Start the connection so that messages will be processed.
connection.Start();
producer.DeliveryMode = MsgDeliveryMode.Persistent;
var messageToQueue = JsonConvert.SerializeObject(opldObject);
//var ss = "Test Message " + DateTime.Now;
ITextMessage request = session.CreateTextMessage(messageToQueue);
request.NMSCorrelationID = "abc";
//request.Properties["NMSXGroupID"] = "cheese";
//request.Properties["myHeader"] = "Cheddar";
producer.Send(request);
}
}
}
public static string GetMessage([MarshalAs(UnmanagedType.LPWStr)] string queueName)
{
try
{
IDestination destination = SessionUtil.GetDestination(session, "queue://" + queueName);
Console.WriteLine("Using destination: " + destination);
string result = "";
// Create a consumer and producer
using (IMessageConsumer consumer = session.CreateConsumer(destination))
{
// Start the connection so that messages will be processed.
connection.Start();
// Consume a message
ITextMessage message = consumer.Receive(receiveTimeout) as ITextMessage;
if (message == null)
{
Console.WriteLine("No message received!");
}
else
{
result = message.Text.ToString();
Console.WriteLine("Received message with ID: " + message.NMSMessageId);
Console.WriteLine("Received message with text: " + message.Text);
}
}
return(result);
}
catch (Exception e)
{
return("ERROR when get message from queue: " + queueName + ", details:" + e.Message.ToString());
}
}
