private OutgoingMessage Delete(IncomingMessage deleteRequest)
{
Log.InfoFormat("Handling Delete request");
var response = _factory.CreateDeleteResponse();
var incomingHeaders = new IncomingHeaders(deleteRequest);
var outgoingHeaders = new OutgoingHeaders(response);
_handler.HandlerDelete(incomingHeaders, outgoingHeaders);
Log.InfoFormat("Delete request handled successfully");
return(response);
}
private OutgoingMessage Create(IncomingMessage createRequest)
{
Log.InfoFormat("Handling Create request");
var response = _factory.CreateCreateResponse();
var incomingHeaders = new IncomingHeaders(createRequest);
var outgoingHeaders = new OutgoingHeaders(response);
var reference = _handler.HandleCreate(incomingHeaders, outgoingHeaders, x => createRequest.GetPayload(x));
response.SetBody(new CreateResponseBodyWriter(reference));
Log.InfoFormat("Create request handled successfully");
return(response);
}
private OutgoingMessage Put(IncomingMessage putRequest)
{
Log.InfoFormat("Handling Put request");
var response = _factory.CreatePutResponse();
var incomingHeaders = new IncomingHeaders(putRequest);
var outgoingHeaders = new OutgoingHeaders(response);
var payload = _handler.HandlePut(incomingHeaders, outgoingHeaders, x => putRequest.GetPayload(x));
response.SetBody(new SerializerBodyWriter(payload));
Log.InfoFormat("Put request handled successfully");
return(response);
}
private TransportMessage MapTransportMessageFor(object[] messages, TransportMessage toSend)
{
toSend.Body = messages;
toSend.WindowsIdentityName = Thread.CurrentPrincipal.Identity.Name;
toSend.Headers = OutgoingHeaders.Select(x => new HeaderInfo()
{
Key = x.Key, Value = x.Value
}).ToList();
var timeToBeReceived = TimeSpan.MaxValue;
toSend.TimeToBeReceived = timeToBeReceived;
return(toSend);
}
private void OnMessageAvailable(MessageAvailable value)
{
using (var childServiceLocator = this.ServiceLocator.CreateNestedContainer())
{
currentMessageContext = new MessageContext(this, value.TransportMessage.MessageId, value.TransportMessage.Headers, childServiceLocator);
// register a bunch of things we might want to use during the message handling
childServiceLocator.RegisterSingleton <IBus>(this);
childServiceLocator.RegisterSingleton(this.MessageHandlers);
childServiceLocator.RegisterSingleton <IMessageSerializer>(this.MessageSerializer);
childServiceLocator.RegisterSingleton <IMessageMapper>(this.MessageMapper);
childServiceLocator.RegisterSingleton <ITransport>(this.Transport);
childServiceLocator.RegisterSingleton <MessageContext>(currentMessageContext);
OutgoingHeaders.Clear();
try
{
object message = null;
try
{
message = DeserializeMessage(value);
}
catch (Exception e)
{
logger.Error(e, "Cannot deserialize message.");
// The message cannot be deserialized. There is no reason
// to retry.
throw new CannotDeserializeMessageException(e);
}
currentMessageContext.CurrentMessage = message;
currentMessageContext.SerializedMessageData = value.TransportMessage.SerializedMessageData;
var stopwatch = Stopwatch.StartNew();
var startTimestamp = DateTime.UtcNow;
compiledMessagePipeline(currentMessageContext);
var endTimestamp = DateTime.UtcNow;
stopwatch.Stop();
OnMessageProcessed(new MessageProcessedEventArgs(currentMessageContext, startTimestamp, endTimestamp, stopwatch.Elapsed.TotalMilliseconds));
}
finally
{
currentMessageContext = null;
}
}
}
public TransportMessage SendDeferredReply(DateTime at, object message)
{
Guard.AgainstNull(message, "message");
if (TransportMessageReceived == null)
{
throw new InvalidOperationException(ESBResources.ReplyWithoutCurrentMessage);
}
if (!TransportMessageReceived.HasSenderInboxWorkQueueUri())
{
throw new InvalidOperationException(ESBResources.ReplyWithoutSenderInboxWorkQueueUri);
}
OutgoingCorrelationId = TransportMessageReceived.CorrelationId;
OutgoingHeaders.Merge(TransportMessageReceived.Headers);
return(SendDeferred(at, message, QueueManager.Instance.GetQueue(TransportMessageReceived.SenderInboxWorkQueueUri)));
}
