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