public async Task SendMessageAsync(IMessage inputMessage)
{
Preconditions.CheckNotNull(inputMessage, nameof(inputMessage));
IMessageConverter <Message> converter = this.messageConverterProvider.Get <Message>();
Message message = converter.FromMessage(inputMessage);
await this.ResetTimerAsync();
try
{
string outputRoute = inputMessage.GetOutput();
using (Metrics.TimeMessageSend(this.clientId, outputRoute))
{
Metrics.MessageProcessingLatency(this.clientId, inputMessage);
await this.client.SendEventAsync(message);
Events.SendMessage(this);
Metrics.AddSentMessages(this.clientId, 1, outputRoute, inputMessage.ProcessedPriority);
}
}
catch (Exception ex)
{
Events.ErrorSendingMessage(this, ex);
await this.HandleException(ex);
throw;
}
}
/// <summary>
/// Convert from a NMS Message to a .NET object.
/// </summary>
/// <param name="messageToConvert">the message to convert</param>
/// <returns>the converted .NET object</returns>
/// <throws>MessageConversionException in case of conversion failure </throws>
public object FromMessage(IMessage messageToConvert)
{
if (messageToConvert == null)
{
throw new MessageConversionException("Can't convert null message");
}
try
{
string converterId = messageToConvert.Properties.GetString(typeMapper.TypeIdFieldName);
if (converterId == null)
{
return(defaultMessageConverter.FromMessage(messageToConvert));
}
ITextMessage textMessage = messageToConvert as ITextMessage;
if (textMessage == null)
{
throw new MessageConversionException("Can't convert message of type " +
messageToConvert.GetType());
}
using (MemoryStream memoryStream = new MemoryStream(StringToUTF8ByteArray(textMessage.Text)))
{
XmlSerializer xs = new XmlSerializer(GetTargetType(textMessage));
XmlTextWriter xmlTextWriter = new XmlTextWriter(memoryStream, Encoding.UTF8);
return(xs.Deserialize(memoryStream));
}
} catch (Exception e)
{
throw new MessageConversionException("Can't convert message of type " + messageToConvert.GetType(), e);
}
}
public async Task SendMessageBatchAsync(IEnumerable <IMessage> inputMessages)
{
IMessageConverter <Message> converter = this.messageConverterProvider.Get <Message>();
string metricOutputRoute = null;
IList <Message> messages = Preconditions.CheckNotNull(inputMessages, nameof(inputMessages))
.Select(inputMessage =>
{
metricOutputRoute = metricOutputRoute ?? inputMessage.GetOutput();
Metrics.MessageProcessingLatency(this.clientId, inputMessage);
return(converter.FromMessage(inputMessage));
})
.ToList();
this.timer.Reset();
try
{
using (Metrics.TimeMessageSend(this.clientId))
{
await this.client.SendEventBatchAsync(messages);
Events.SendMessage(this);
Metrics.AddSentMessages(this.clientId, messages.Count, metricOutputRoute);
}
}
catch (Exception ex)
{
Events.ErrorSendingBatchMessage(this, ex);
await this.HandleException(ex);
throw;
}
}
/// <summary>
/// Convert from a NMS Message to a .NET object.
/// </summary>
/// <param name="nmsMessage">the message to convert</param>
/// <returns>the converted .NET object</returns>
/// <throws>MessageConversionException in case of conversion failure </throws>
public object FromMessage(Apache.NMS.IMessage nmsMessage)
{
MessageBuilder builder = null;
if (extractNmsMessageBody)
{
object conversionResult = converter.FromMessage(nmsMessage);
if (conversionResult == null)
{
return(null);
}
if (conversionResult is Spring.Integration.Core.IMessage)
{
builder = MessageBuilder.FromMessage((Spring.Integration.Core.IMessage)conversionResult);
}
else
{
builder = MessageBuilder.WithPayload(conversionResult);
}
}
else
{
builder = MessageBuilder.WithPayload(nmsMessage);
}
IDictionary <string, object> headers = headerMapper.ToHeaders(nmsMessage);
Spring.Integration.Core.IMessage message = builder.CopyHeadersIfAbsent(headers).Build();
if (logger.IsDebugEnabled)
{
logger.Debug("Converted NMS Message [" + nmsMessage + "] to integration message [" + message + "]");
}
return(message);
}
protected virtual IMessage BuildReturnedMessage(IMessage message, int replyCode, string replyText, string exchange, string returnedRoutingKey, IMessageConverter converter)
{
var returnedObject = converter.FromMessage(message, null);
var builder = PrepareMessageBuilder(returnedObject);
// TODO: Map < String, ?> headers = getHeaderMapper().toHeadersFromReply(message.getMessageProperties());
if (ErrorMessageStrategy == null)
{
builder.CopyHeadersIfAbsent(message.Headers)
.SetHeader(RabbitMessageHeaders.RETURN_REPLY_CODE, replyCode)
.SetHeader(RabbitMessageHeaders.RETURN_REPLY_TEXT, replyText)
.SetHeader(RabbitMessageHeaders.RETURN_EXCHANGE, exchange)
.SetHeader(RabbitMessageHeaders.RETURN_ROUTING_KEY, returnedRoutingKey);
}
var returnedMessage = builder.Build();
if (ErrorMessageStrategy != null)
{
returnedMessage = ErrorMessageStrategy.BuildErrorMessage(
new ReturnedRabbitMessageException(returnedMessage, replyCode, replyText, exchange, returnedRoutingKey),
null);
}
return(returnedMessage);
}
private object ConvertPayload(IMessage message, ParameterInfo parameter, Type targetPayloadType)
{
object result = null;
if (_converter is ISmartMessageConverter)
{
var smartConverter = (ISmartMessageConverter)_converter;
result = smartConverter.FromMessage(message, targetPayloadType, parameter);
}
else if (_converter != null)
{
result = _converter.FromMessage(message, targetPayloadType);
}
if (result == null)
{
var payloadType = message.Payload != null?message.Payload.GetType().ToString() : "null";
throw new MessageConversionException(
message,
"No converter found from actual payload type '" + payloadType + "' to expected payload type '" + targetPayloadType.ToString() + "'");
}
return(result);
}
protected virtual IMessageBuilder BuildReply(IMessageConverter converter, IMessage amqpReplyMessage)
{
var replyObject = converter.FromMessage(amqpReplyMessage, null);
var builder = PrepareMessageBuilder(replyObject);
// var headers = getHeaderMapper().toHeadersFromReply(amqpReplyMessage.getMessageProperties());
builder.CopyHeadersIfAbsent(amqpReplyMessage.Headers);
return(builder);
}
/// <summary>
/// Extract the message body from the given message.
/// </summary>
/// <param name="message">The message.</param>
/// <returns>the content of the message, to be passed into the
/// listener method as argument</returns>
/// <exception cref="EMSException">if thrown by EMS API methods</exception>
private object ExtractMessage(Message message)
{
IMessageConverter converter = MessageConverter;
if (converter != null)
{
return(converter.FromMessage(message));
}
return(message);
}
/// <summary>
/// Extracts the message body from the given message.
/// </summary>
/// <param name="message">The message.</param>
/// <returns>the content of the message, to be passed into the
/// listener method as argument</returns>
protected virtual object ExtractMessage(Message message)
{
IMessageConverter converter = MessageConverter;
if (converter != null)
{
return(converter.FromMessage(message));
}
return(message);
}
public virtual object ResolveArgument(ParameterInfo parameter, IMessage message)
{
var ann = parameter.GetCustomAttribute <PayloadAttribute>();
if (ann != null && !string.IsNullOrEmpty(ann.Expression))
{
throw new InvalidOperationException("Payload expressions not supported by this resolver");
}
var payload = message.Payload;
if (IsEmptyPayload(payload))
{
if (ann == null || ann.Required)
{
var paramName = GetParameterName(parameter);
throw new MethodArgumentNotValidException(message, parameter, "Payload value must not be empty when binding to: " + paramName);
}
else
{
return(null);
}
}
var targetClass = ResolveTargetClass(parameter, message);
var payloadClass = payload.GetType();
if (targetClass.IsAssignableFrom(payloadClass))
{
Validate(message, parameter, payload);
return(payload);
}
else
{
if (_converter is ISmartMessageConverter)
{
var smartConverter = (ISmartMessageConverter)_converter;
payload = smartConverter.FromMessage(message, targetClass, parameter);
}
else
{
payload = _converter.FromMessage(message, targetClass);
}
if (payload == null)
{
throw new MessageConversionException(message, "Cannot convert from [" + payloadClass.Name + "] to [" + targetClass.Name + "] for " + message);
}
Validate(message, parameter, payload);
return(payload);
}
}
public async Task SendMessageAsync(IMessage inputMessage)
{
Preconditions.CheckNotNull(inputMessage, nameof(inputMessage));
IMessageConverter <Message> converter = this.messageConverterProvider.Get <Message>();
Message message = converter.FromMessage(inputMessage);
try
{
await this.client.SendEventAsync(message);
Events.SendMessage(this);
}
catch (Exception ex)
{
Events.ErrorSendingMessage(this, ex);
await this.HandleException(ex);
throw;
}
}
public async Task SendMessageBatchAsync(IEnumerable <IMessage> inputMessages)
{
IMessageConverter <Message> converter = this.messageConverterProvider.Get <Message>();
IEnumerable <Message> messages = Preconditions.CheckNotNull(inputMessages, nameof(inputMessages))
.Select(inputMessage => converter.FromMessage(inputMessage));
try
{
await this.client.SendEventBatchAsync(messages);
Events.SendMessage(this);
}
catch (Exception ex)
{
Events.ErrorSendingBatchMessage(this, ex);
await this.HandleException(ex);
throw;
}
}
public async Task SendMessageBatchAsync(IEnumerable <IMessage> inputMessages)
{
IMessageConverter <Message> converter = this.messageConverterProvider.Get <Message>();
string metricOutputRoute = null;
IList <Message> messages = Preconditions.CheckNotNull(inputMessages, nameof(inputMessages))
.Select(inputMessage =>
{
metricOutputRoute = metricOutputRoute ?? inputMessage.GetOutput();
Metrics.MessageProcessingLatency(this.clientId, inputMessage);
return(converter.FromMessage(inputMessage));
})
.ToList();
await this.ResetTimerAsync();
try
{
using (Metrics.TimeMessageSend(this.clientId, metricOutputRoute))
{
await this.client.SendEventBatchAsync(messages);
Events.SendMessage(this);
if (messages.Count > 0)
{
// Priority for messages in any given batch is the same, so we can
// just use the priority from the first message in the collection
Metrics.AddSentMessages(this.clientId, messages.Count, metricOutputRoute, inputMessages.First().ProcessedPriority);
}
}
}
catch (Exception ex)
{
Events.ErrorSendingBatchMessage(this, ex);
await this.HandleException(ex);
throw;
}
}
public object FromMessage(IMessage messageToConvert)
{
if (messageToConvert == null)
{
throw new MessageConversionException("Can't convert null message");
}
string converterId = messageToConvert.Properties.GetString(converterIdFieldName);
if (converterId == null)
{
return(defaultMessageConverter.FromMessage(messageToConvert));
}
else
{
IMessageConverter converter = GetConverterForId(converterId);
if (converter != null)
{
return(converter.FromMessage(messageToConvert));
}
throw new MessageConversionException("Can't convert message with ConverterId = " + converterId + ". Message = " + messageToConvert);
}
}