public void GetAccessor()
{
var expected = new MessageHeaderAccessor();
var message = MessageBuilder <string> .CreateMessage("payload", expected.MessageHeaders);
Assert.Same(expected, MessageHeaderAccessor.GetAccessor <MessageHeaderAccessor>(message, typeof(MessageHeaderAccessor)));
}
public void TestBuildIMessageWithDefaultMutability()
{
var accessor = new MessageHeaderAccessor();
var headers = accessor.MessageHeaders;
var message = MessageBuilder.CreateMessage("foo", headers);
Assert.Throws <InvalidOperationException>(() => accessor.SetHeader("foo", "bar"));
Assert.Equal(accessor, MessageHeaderAccessor.GetAccessor(message, typeof(MessageHeaderAccessor)));
}
public override IMessage PreSend(IMessage message, IMessageChannel channel)
{
var accessor = MessageHeaderAccessor.GetAccessor(message, typeof(MessageHeaderAccessor));
if (accessor != null && accessor.IsMutable)
{
accessor.SetImmutable();
}
return(message);
}
public virtual IMessage ToMessage(object payload, IMessageHeaders headers = null)
{
if (headers != null)
{
var accessor = MessageHeaderAccessor.GetAccessor <MessageHeaderAccessor>(headers, typeof(MessageHeaderAccessor));
if (accessor != null && accessor.IsMutable)
{
return(MessageBuilder <object> .CreateMessage(payload, accessor.MessageHeaders));
}
}
return(MessageBuilder <object> .WithPayload(payload).CopyHeaders(headers).Build());
}
public void TestBuildIMessageWithMutableHeaders()
{
var accessor = new MessageHeaderAccessor();
accessor.LeaveMutable = true;
var headers = accessor.MessageHeaders;
var message = MessageBuilder <string> .CreateMessage("payload", headers);
accessor.SetHeader("foo", "bar");
Assert.Equal("bar", headers.Get <string>("foo"));
Assert.Equal(accessor, MessageHeaderAccessor.GetAccessor <MessageHeaderAccessor>(message, typeof(MessageHeaderAccessor)));
}
public void LeaveMutable()
{
var accessor = new MessageHeaderAccessor();
accessor.SetHeader("foo", "bar");
accessor.LeaveMutable = true;
var headers = accessor.MessageHeaders;
var message = MessageBuilder.CreateMessage("payload", headers);
accessor.SetHeader("foo", "baz");
Assert.Equal("baz", headers.Get <string>("foo"));
Assert.Same(accessor, MessageHeaderAccessor.GetAccessor(message, typeof(MessageHeaderAccessor)));
}
public void LeaveMutableDefaultBehavior()
{
var accessor = new MessageHeaderAccessor();
accessor.SetHeader("foo", "bar");
var headers = accessor.MessageHeaders;
var message = MessageBuilder <string> .CreateMessage("payload", headers);
Assert.Throws <InvalidOperationException>(() => accessor.LeaveMutable = true);
Assert.Throws <InvalidOperationException>(() => accessor.SetHeader("foo", "baz"));
Assert.Equal("bar", headers.Get <string>("foo"));
Assert.Same(accessor, MessageHeaderAccessor.GetAccessor <MessageHeaderAccessor>(message, typeof(MessageHeaderAccessor)));
}
public virtual IMessage ToMessage(object payload, IMessageHeaders headers = null, object conversionHint = null)
{
if (!CanConvertTo(payload, headers))
{
return(null);
}
var payloadToUse = ConvertToInternal(payload, headers, conversionHint);
if (payloadToUse == null)
{
return(null);
}
var mimeType = GetDefaultContentType(payloadToUse);
if (headers != null)
{
var accessor = MessageHeaderAccessor.GetAccessor <MessageHeaderAccessor>(headers, typeof(MessageHeaderAccessor));
if (accessor != null && accessor.IsMutable)
{
if (mimeType != null)
{
accessor.SetHeaderIfAbsent(MessageHeaders.CONTENT_TYPE, mimeType);
}
return(MessageBuilder <object> .CreateMessage(payloadToUse, accessor.MessageHeaders));
}
}
var builder = MessageBuilder <object> .WithPayload(payloadToUse);
if (headers != null)
{
builder.CopyHeaders(headers);
}
if (mimeType != null)
{
builder.SetHeaderIfAbsent(MessageHeaders.CONTENT_TYPE, mimeType);
}
return(builder.Build());
}
protected virtual IMessage ProcessMessageBeforeSend(IMessage message)
{
var messageToSend = message;
var accessor = MessageHeaderAccessor.GetAccessor(message, typeof(MessageHeaderAccessor));
if (accessor != null && accessor.IsMutable)
{
accessor.RemoveHeader(_sendTimeoutHeader);
accessor.RemoveHeader(_receiveTimeoutHeader);
accessor.SetImmutable();
}
else if (message.Headers.ContainsKey(_sendTimeoutHeader) ||
message.Headers.ContainsKey(_receiveTimeoutHeader))
{
messageToSend = MessageBuilder.FromMessage(message)
.SetHeader(_sendTimeoutHeader, null)
.SetHeader(_receiveTimeoutHeader, null)
.Build();
}
return(messageToSend);
}
public object ResolveArgument(ParameterInfo parameter, IMessage message)
{
var paramType = parameter.ParameterType;
if (typeof(IDictionary <string, object>).IsAssignableFrom(paramType))
{
return(message.Headers);
}
else if (typeof(MessageHeaderAccessor) == paramType)
{
var accessor = MessageHeaderAccessor.GetAccessor(message, typeof(MessageHeaderAccessor));
return(accessor != null ? accessor : new MessageHeaderAccessor(message));
}
else if (typeof(MessageHeaderAccessor).IsAssignableFrom(paramType))
{
var accessor = MessageHeaderAccessor.GetAccessor(message, typeof(MessageHeaderAccessor));
if (accessor != null && paramType.IsAssignableFrom(accessor.GetType()))
{
return(accessor);
}
else
{
var method = ReflectionHelpers.FindMethod(paramType, "Wrap", new Type[] { typeof(IMessage) });
if (method == null)
{
throw new InvalidOperationException("Cannot create accessor of type " + paramType + " for message " + message);
}
return(ReflectionHelpers.Invoke(method, null, new object[] { message }));
}
}
else
{
throw new InvalidOperationException("Unexpected parameter of type " + paramType + " in method " + parameter.Member + ". ");
}
}
