/// <summary>
/// Sends the message to the given destination.
/// </summary>
public void Send(Apache.NMS.IDestination destination,
Apache.NMS.IMessage message)
{
Apache.NMS.XMS.Destination dest =
(Apache.NMS.XMS.Destination)destination;
Apache.NMS.XMS.Message msg = GetXMSMessage(message);
long timeToLive = (long)message.NMSTimeToLive.TotalMilliseconds;
if (0 == timeToLive)
{
timeToLive = this.xmsMessageProducer.TimeToLive;
}
try
{
this.xmsMessageProducer.Send(
dest.xmsDestination,
msg.xmsMessage,
this.xmsMessageProducer.DeliveryMode,
this.xmsMessageProducer.Priority,
timeToLive);
}
catch (Exception ex)
{
ExceptionUtil.WrapAndThrowNMSException(ex);
}
}
public static ContextBag GetContextBag(this IMessage amqpMessage)
{
var contextBag = new ContextBag();
contextBag.Set(amqpMessage);
return(contextBag);
}
public async Task RecieveMessages(
Func <ISchedule, Task <IScheduleRank> > handler,
string recieveMessagesChannelName,
string sendMessageChannelName,
CancellationToken cancellationToken = default)
{
using (ISession session = mConnection.CreateSession())
using (IDestination dest = session.GetTopic(recieveMessagesChannelName))
using (IMessageConsumer consumer = session.CreateConsumer(dest))
{
Console.WriteLine($"Start listening to {recieveMessagesChannelName}");
while (!cancellationToken.IsCancellationRequested)
{
Apache.NMS.IMessage message = consumer.Receive();
if (message != null)
{
if (message is IBytesMessage byteMessage)
{
ScheduleDto.Schedule schedule = ScheduleDto.Schedule.Parser.ParseFrom(byteMessage.Content);
IScheduleRank scheduleRank = await handler(schedule);
SendMessage((scheduleRank as ScheduleRank.ScheduleRank).ToByteArray(), sendMessageChannelName);
}
Console.WriteLine($"Could not parse message, type of message is: {message.NMSType}");
}
Console.WriteLine($"Null message recieved");
}
}
}
private void HandleXmsMessage(IBM.XMS.IMessage xmsMessage)
{
Apache.NMS.IMessage message = XMSConvert.ToNMSMessage(xmsMessage);
if (message != null)
{
if (this.ConsumerTransformer != null)
{
IMessage newMessage = ConsumerTransformer(this.nmsSession, this, message);
if (newMessage != null)
{
message = newMessage;
}
}
if (Listener != null)
{
try
{
Listener(message);
}
catch (Exception ex)
{
Apache.NMS.Tracer.Debug("Error handling message: " + ex.Message);
}
}
else
{
this.dispatcher.Enqueue(message);
}
}
}
public static void PopulatePropertiesFromNsbMessage(
this IMessage amqpMessage,
OutgoingMessage outgoingMessage,
ISession session)
{
amqpMessage.NMSMessageId = outgoingMessage.MessageId;
amqpMessage.NMSCorrelationID = GetNsbHeaderValue(
Headers.CorrelationId,
outgoingMessage.Headers,
amqpMessage.NMSCorrelationID);
var replyToQueueName = GetNsbHeaderValue(
Headers.ReplyToAddress,
outgoingMessage.Headers,
string.Empty);
if (!string.IsNullOrEmpty(replyToQueueName))
{
amqpMessage.NMSReplyTo = session.GetQueue(replyToQueueName);
}
if (outgoingMessage.Headers.ContainsKey(Headers.NonDurableMessage))
{
amqpMessage.NMSDeliveryMode = MsgDeliveryMode.NonPersistent;
}
amqpMessage.NMSTimestamp = GetNsbHeaderValue(
Headers.TimeSent,
outgoingMessage.Headers,
amqpMessage.NMSTimestamp);
}
public static Dictionary <string, string> GetProperties(
this IMessage amqpMessage)
{
var headers = new Dictionary <string, string> ();
headers.Add(Headers.CorrelationId, amqpMessage.NMSCorrelationID);
if (amqpMessage.NMSReplyTo != null)
{
if (amqpMessage.NMSReplyTo.IsQueue)
{
headers.Add(Headers.ReplyToAddress,
((IQueue)amqpMessage.NMSReplyTo).QueueName);
}
else if (amqpMessage.NMSReplyTo.IsTopic)
{
headers.Add(Headers.ReplyToAddress,
((ITopic)amqpMessage.NMSReplyTo).TopicName);
}
}
foreach (var keyName in amqpMessage.Properties.Keys)
{
if (headers.ContainsKey(keyName.ToString()))
{
continue;
}
headers.Add(keyName.ToString(), amqpMessage.Properties[keyName.ToString()].ToString());
}
return(headers);
}
public void OnMessage(Apache.NMS.IMessage message)
{
ITextMessage textMessage = message as ITextMessage;
HistoricoCompras deserializadHistoricoCompras = JsonConvert.DeserializeObject <HistoricoCompras>(textMessage.Text.ToString());
deserializadHistoricoCompras.GravarCompra();
}
private AsyncMessage convertToFlexMessage(IMessage message, String clientId)
{
AsyncMessage asyncMessage = new AsyncMessage();
if (message is ActiveMQObjectMessage)
{
ActiveMQObjectMessage objectMessage = ((ActiveMQObjectMessage)message);
asyncMessage.body = objectMessage.Body;
}
else if (message is ActiveMQTextMessage)
{
asyncMessage.body = ((ActiveMQTextMessage)message).Text;
}
try
{
asyncMessage.destination = this.DestinationDefinition.Id;
asyncMessage.clientId = clientId;
asyncMessage.messageId = message.NMSMessageId;
asyncMessage.timestamp = message.NMSTimestamp.Ticks;
asyncMessage.correlationId = message.NMSCorrelationID;
foreach (String key in message.Properties.Keys)
{
asyncMessage.headers.Add(key, message.Properties[key]);
}
}
catch (Exception ex)
{
log.Error("Error while converting to Flex Message", ex);
}
return(asyncMessage);
}
private static void Consumer_Listener(Apache.NMS.IMessage message)
{
try
{
ITextMessage msg = (ITextMessage)message;
Console.WriteLine("Receive: " + msg.Text);
}
catch (System.Exception e)
{
Console.WriteLine(e.Message);
}
}
public static void PopulateApplicationPropertiesFromNsbHeaders(
this IMessage amqpMessage,
Dictionary <string, string> headers)
{
foreach (var headerPropertyName in headers.Keys)
{
if (!amqpMessage.Properties.Contains(headerPropertyName))
{
amqpMessage.Properties.SetString(headerPropertyName,
headers[headerPropertyName]);
}
}
}
public IDictionary <string, object> ToHeaders(Apache.NMS.IMessage nmsMessage)
{
IDictionary <string, object> headers = new Dictionary <string, object>();
try
{
string messageId = nmsMessage.NMSMessageId;
if (messageId != null)
{
headers.Add(NmsHeaders.MESSAGE_ID, messageId);
}
string correlationId = nmsMessage.NMSCorrelationID;
if (correlationId != null)
{
headers.Add(NmsHeaders.CORRELATION_ID, correlationId);
}
IDestination replyTo = nmsMessage.NMSReplyTo;
if (replyTo != null)
{
headers.Add(NmsHeaders.REPLY_TO, replyTo);
}
headers.Add(NmsHeaders.REDELIVERED, nmsMessage.NMSRedelivered);
string type = nmsMessage.NMSType;
if (type != null)
{
headers.Add(NmsHeaders.TYPE, type);
}
ICollection nmsPropertyNames = nmsMessage.Properties.Keys;
if (nmsPropertyNames != null)
{
foreach (string propertyName in nmsPropertyNames)
{
try
{
headers.Add(propertyName, nmsMessage.Properties[propertyName]);
} catch (Exception ex)
{
if (logger.IsWarnEnabled)
{
logger.Warn("error occurred while mapping NMS property '"
+ propertyName + "' to Message header", ex);
}
}
}
}
} catch (Exception ex)
{
throw new MessageMappingException("failure occurred while mapping NMS properties to MessageHeaders", ex);
}
return(headers);
}
private Apache.NMS.XMS.Message GetXMSMessage(Apache.NMS.IMessage message)
{
Apache.NMS.XMS.Message msg = (Apache.NMS.XMS.Message)message;
if (this.ProducerTransformer != null)
{
IMessage transformed = this.ProducerTransformer(this.nmsSession, this, message);
if (transformed != null)
{
msg = (Apache.NMS.XMS.Message)transformed;
}
}
return(msg);
}
private async Task ProcessMessageAsync(IMessage message)
{
var headers = message.GetProperties();
string messageId = message.GetMessageId();
var contextBag = message.GetContextBag();
using var tokenSource = new CancellationTokenSource();
var messageContext = new MessageContext(
messageId,
headers,
((IBytesMessage)message).Content,
transportTransaction,
tokenSource,
contextBag);
await this.passMessageToNsb(messageContext).ConfigureAwait(false);
}
public virtual void onMessage(String clientId, String subscriptionId, IMessage message)
{
try
{
log.Debug(string.Format("Recieved new Message for Client ID: {0}", clientId));
ArrayList list = new ArrayList();
list.Add(subscriptionId);
AsyncMessage asyncMessage = convertToFlexMessage(message, clientId);
MessageService messageService = this.Destination.Service as MessageService;
messageService.PushMessageToClients(list, asyncMessage);
}
catch (Exception ex)
{
log.Error("Error while handling incoming message", ex);
}
}
/// <summary>
/// Sends the message to the default destination with the explicit QoS
/// configuration.
/// </summary>
public void Send(Apache.NMS.IMessage message,
MsgDeliveryMode deliveryMode, MsgPriority priority,
TimeSpan timeToLive)
{
Apache.NMS.XMS.Message msg = GetXMSMessage(message);
try
{
this.xmsMessageProducer.Send(
msg.xmsMessage,
XMSConvert.ToJMSDeliveryMode(deliveryMode),
(int)priority,
(long)timeToLive.TotalMilliseconds);
}
catch (Exception ex)
{
ExceptionUtil.WrapAndThrowNMSException(ex);
}
}
public void OnMessage(IMessage nmsMessage, ISession session)
{
object obj = messageConverter.FromMessage(nmsMessage);
Spring.Integration.Core.IMessage requestMessage = obj as Spring.Integration.Core.IMessage;
if (requestMessage == null)
{
requestMessage = MessageBuilder.WithPayload(obj).Build();
}
if (!expectReply)
{
bool sent = channelTemplate.Send(requestMessage);
if (!sent)
{
throw new MessageDeliveryException(requestMessage, "failed to send Message to request channel");
}
}
else
{
Spring.Integration.Core.IMessage replyMessage = channelTemplate.SendAndReceive(requestMessage);
if (replyMessage != null)
{
IDestination destination = GetReplyDestination(nmsMessage, session);
Apache.NMS.IMessage nmsReply = messageConverter.ToMessage(replyMessage, session);
if (nmsReply.NMSCorrelationID != null)
{
nmsReply.NMSCorrelationID = nmsMessage.NMSMessageId;
}
Apache.NMS.IMessageProducer producer = session.CreateProducer(destination);
try
{
producer.Send(nmsReply);
} finally
{
producer.Close();
}
}
}
}
public virtual void onMessage(String clientId, String subscriptionId, IMessage message)
{
try
{
log.Debug(string.Format("Recieved new Message for Client ID: {0}", clientId));
ArrayList list = new ArrayList();
list.Add(subscriptionId);
AsyncMessage asyncMessage = convertToFlexMessage(message, clientId);
MessageService messageService = this.Destination.Service as MessageService;
messageService.PushMessageToClients(list, asyncMessage);
}
catch (Exception ex)
{
log.Error("Error while handling incoming message", ex);
}
}
public static string GetMessageId(this IMessage amqpMessage)
{
return(amqpMessage.NMSMessageId);
}
public void FromHeaders(MessageHeaders headers, Apache.NMS.IMessage nmsMessage)
{
try
{
if (headers.ContainsKey(NmsHeaders.CORRELATION_ID))
{
object nmsCorrelationId = headers[NmsHeaders.CORRELATION_ID] as string;
if (nmsCorrelationId != null)
{
nmsMessage.NMSCorrelationID = (string)nmsCorrelationId;
}
}
if (headers.ContainsKey(NmsHeaders.REPLY_TO))
{
object nmsReplyTo = headers[NmsHeaders.REPLY_TO] as IDestination;
if (nmsReplyTo != null)
{
nmsMessage.NMSReplyTo = (IDestination)nmsReplyTo;
}
}
if (headers.ContainsKey(NmsHeaders.TYPE))
{
object nmsType = headers[NmsHeaders.TYPE] as string;
if (nmsType != null)
{
nmsMessage.NMSType = (string)nmsType;
}
}
ICollection <string> attributeNames = headers.Keys;
foreach (string attributeName in attributeNames)
{
if (!attributeName.StartsWith(NmsHeaders.PREFIX))
{
if (StringUtils.HasText(attributeName))
{
object val = headers[attributeName];
if (val != null && IsValidPropertyType(val))
{
try
{
nmsMessage.Properties[attributeName] = val;
}
catch (Exception ex)
{
if (logger.IsWarnEnabled)
{
logger.Warn("failed to map Message header '"
+ attributeName + "' to NMS property", ex);
}
}
}
}
}
}
} catch (Exception ex)
{
if (logger.IsWarnEnabled)
{
logger.Warn("error occurred while mapping properties from MessageHeaders", ex);
}
}
}
private async void HandleConsumerMessage(IMessage message)
{
await this.ProcessMessageAsync(message).ConfigureAwait(false);
}
public override object Invoke(FluorineFx.Messaging.Messages.IMessage message)
{
IMessageProducer producer;
lock (_producers)
{
if (_producers.Count < MAX_PRODUCERS)
{
producer = _session.CreateProducer(_destination);
log.Debug("Creating new Message Producer");
}
else
{
producer = _producers.First.Value;
_producers.RemoveFirst();
}
_producers.AddLast(producer);
}
IMessage nmsMessage = _session.CreateObjectMessage(message.body);
try
{
foreach (String key in message.headers.Keys)
{
object value = message.headers[key];
if (value is string)
{
nmsMessage.Properties.SetString(key, (string)value);
}
else if (value is long)
{
nmsMessage.Properties.SetLong(key, (long)value);
}
else if (value is bool)
{
nmsMessage.Properties.SetBool(key, (bool)value);
}
else if (value is int)
{
nmsMessage.Properties.SetInt(key, (int)value);
}
else if (value is byte)
{
nmsMessage.Properties.SetByte(key, (byte)value);
}
else if (value is char)
{
nmsMessage.Properties.SetChar(key, (char)value);
}
else if (value is double)
{
nmsMessage.Properties.SetDouble(key, (double)value);
}
else if (value is float)
{
nmsMessage.Properties.SetFloat(key, (float)value);
}
else if (value is IList)
{
nmsMessage.Properties.SetList(key, (IList)value);
}
else if (value is short)
{
nmsMessage.Properties.SetShort(key, (short)value);
}
}
}
catch (Exception ex)
{
log.Error("Error while converting to NMS Message", ex);
}
producer.Send(nmsMessage);
log.Debug(string.Format("Sent message for Client ID: {0}", message.clientId));
return(null);
}
public object FromMessage(IMessage messageToConvert)
{
return("test-from");
}
public object FromMessage(IMessage messageToConvert)
{
return "test-from";
}
private AsyncMessage convertToFlexMessage(IMessage message, String clientId)
{
AsyncMessage asyncMessage = new AsyncMessage();
if (message is ActiveMQObjectMessage)
{
ActiveMQObjectMessage objectMessage = ((ActiveMQObjectMessage)message);
asyncMessage.body = objectMessage.Body;
}
else if (message is ActiveMQTextMessage)
{
asyncMessage.body = ((ActiveMQTextMessage)message).Text;
}
try
{
asyncMessage.destination = this.DestinationDefinition.Id;
asyncMessage.clientId = clientId;
asyncMessage.messageId = message.NMSMessageId;
asyncMessage.timestamp = message.NMSTimestamp.Ticks;
asyncMessage.correlationId = message.NMSCorrelationID;
foreach (String key in message.Properties.Keys)
{
asyncMessage.headers.Add(key, message.Properties[key]);
}
}
catch (Exception ex)
{
log.Error("Error while converting to Flex Message", ex);
}
return asyncMessage;
}
public void OnMessage(IMessage nmsMessage, ISession session)
{
object obj = messageConverter.FromMessage(nmsMessage);
Spring.Integration.Core.IMessage requestMessage = obj as Spring.Integration.Core.IMessage;
if (requestMessage == null)
{
requestMessage = MessageBuilder.WithPayload(obj).Build();
}
if (!expectReply)
{
bool sent = channelTemplate.Send(requestMessage);
if (!sent)
{
throw new MessageDeliveryException(requestMessage, "failed to send Message to request channel");
}
} else
{
Spring.Integration.Core.IMessage replyMessage = channelTemplate.SendAndReceive(requestMessage);
if (replyMessage != null)
{
IDestination destination = GetReplyDestination(nmsMessage, session);
Apache.NMS.IMessage nmsReply = messageConverter.ToMessage(replyMessage, session);
if (nmsReply.NMSCorrelationID != null)
{
nmsReply.NMSCorrelationID = nmsMessage.NMSMessageId;
}
Apache.NMS.IMessageProducer producer = session.CreateProducer(destination);
try
{
producer.Send(nmsReply);
} finally
{
producer.Close();
}
}
}
}
