static void TransportTransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
if (!ConfigureClaimFlow.Flow)
{
return;
}
if (!e.Message.Headers.ContainsKey(SecurityTokenKey))
{
return;
}
var serializedToken = e.Message.Headers[SecurityTokenKey];
var certificate = ExtractCertificate(serializedToken);
var handler = new Saml2SecurityTokenHandler(new SamlSecurityTokenRequirement());
var tokens = new List <SecurityToken> {
new X509SecurityToken(certificate)
};
var resolver = SecurityTokenResolver.CreateDefaultSecurityTokenResolver(tokens.AsReadOnly(), false);
handler.Configuration = new SecurityTokenHandlerConfiguration
{
IssuerTokenResolver = resolver,
IssuerNameRegistry = new InternalIssuerNameRegistry(),
CertificateValidator = X509CertificateValidator.None
};
using (var reader = XmlReader.Create(new StringReader(serializedToken)))
{
var bootstrapToken = handler.ReadToken(reader);
handler.Configuration.AudienceRestriction.AudienceMode = AudienceUriMode.Never;
handler.Configuration.MaxClockSkew = TimeSpan.MaxValue;
var collection = handler.ValidateToken(bootstrapToken);
Thread.CurrentPrincipal = new ClaimsPrincipal(collection);
}
}
/// <summary>
/// Handles the <see cref="ITransport.TransportMessageReceived"/> event from the <see cref="ITransport"/> used
/// for the bus.
/// </summary>
/// <param name="sender">The sender of the event.</param>
/// <param name="e">The arguments for the event.</param>
/// <remarks>
/// When the transport passes up the <see cref="TransportMessage"/> its received,
/// the bus checks for initialization,
/// sets the message as that which is currently being handled for the current thread
/// and, depending on <see cref="DisableMessageHandling"/>, attempts to handle the message.
/// </remarks>
private void TransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
using (var child = Builder.CreateChildBuilder())
{
HandleTransportMessage(child, e.Message);
}
}
private void OnTransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
if (_messageCreator == null)
{
return;
}
var messages = e.Message.Body.OfType <TMessage>();
if (messages.Count() == 0)
{
return;
}
for (int i = 0; i < messages.Count(); i++)
{
var message = messages.ToArray()[i];
if (!_canBeHandled(message))
{
continue;
}
if (e.Message.ReturnAddress == _transport.Address)
{
_transport.HandleLocalMessage(e.Message.Headers, MessageCreator(e, message));
}
else
{
_transport.HandleMessageFromTp(e.Message.Headers, MessageCreator(e, message));
}
}
}
void HandleMessageReceived(object sender, TransportMessageReceivedEventArgs e, ISatellite satellite)
{
if (!satellite.Handle(e.Message))
{
((ITransport)sender).AbortHandlingCurrentMessage();
}
}
void OnTransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
var messageToDispatch = e.Message;
var destinationSites = GetDestinationSitesFor(messageToDispatch);
//if there is more than 1 destination we break it up into multiple messages
if (destinationSites.Count() > 1)
{
foreach (var destinationSite in destinationSites)
{
CloneAndSendLocal(messageToDispatch, destinationSite);
}
return;
}
var destination = destinationSites.FirstOrDefault();
if (destination == null)
{
throw new InvalidOperationException("No destination found for message");
}
SendToSite(messageToDispatch, destination);
}
void InternalTransportTransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
if (UnicastBus.HandledSubscriptionMessage(e.Message, Subscribers, null))
{
e.Message.ReplyToAddress = ExternalAddress;
ExternalMessageSender.Send(e.Message, RemoteServer);
Logger.Debug("Received subscription message.");
return;
}
var data = new ProxyData
{
Id = GenerateId(),
ClientAddress = e.Message.ReplyToAddress,
CorrelationId = e.Message.IdForCorrelation
};
Storage.Save(data);
Logger.Debug("Forwarding request to " + RemoteServer + ".");
e.Message.IdForCorrelation = data.Id;
e.Message.ReplyToAddress = ExternalAddress;
ExternalMessageSender.Send(e.Message, RemoteServer);
}
void AuditMessageQueueTransport_TransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
var message = e.Message;
// Get the xml content of the message in the audit Q that's being stored.
var doc = new XmlDocument();
doc.Load(new MemoryStream(message.Body));
var messageBodyXml = doc.InnerXml;
// Get the header list as a key value dictionary...
Dictionary <string, string> headerDictionary = message.Headers.ToDictionary(k => k.Key, v => v.Value);
var enclosedMessageType = headerDictionary["NServiceBus.EnclosedMessageTypes"];
string messageType = enclosedMessageType;
if (!String.IsNullOrWhiteSpace(enclosedMessageType))
{
messageType = enclosedMessageType.Split(new char[] { ',' }, StringSplitOptions.None)[0];
}
AuditMessage messageToStore = new AuditMessage
{
MessageId = message.Id,
OriginalMessageId = message.GetOriginalId(),
Body = messageBodyXml,
Headers = headerDictionary,
MessageType = messageType,
ReceivedTime = DateTime.ParseExact(headerDictionary["NServiceBus.TimeSent"], "yyyy-MM-dd HH:mm:ss:ffffff Z", System.Globalization.CultureInfo.InvariantCulture)
};
// Save the message
Console.WriteLine("Saving {0}", messageType);
Persister.Persist(messageToStore);
}
void OnTransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
//dispatch request will arrive at the same input so we need to make sure to call the correct handler
if (e.Message.Headers.ContainsKey(TimeoutDispatcher.TimeoutIdToDispatchHeader))
Builder.Build<TimeoutDispatchHandler>().Handle(e.Message);
else
Builder.Build<TimeoutTransportMessageHandler>().Handle(e.Message);
}
void AuditMessageQueueTransport_TransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
var message = e.Message;
var messageBodyXml = System.Text.Encoding.UTF8.GetString(message.Body);
// Save the message
Console.WriteLine("Saving {0}", messageBodyXml);
}
static void Transport_TransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
if (ConfigureImpersonation.Impersonate)
{
if (e.Message.Headers.ContainsKey(WindowsIdentityName))
{
Thread.CurrentPrincipal = new GenericPrincipal(new GenericIdentity(e.Message.Headers[WindowsIdentityName]), new string[0]);
}
}
}
private void OnTransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
var transportMessage = e.Message;
var timeoutId = transportMessage.Headers["Timeout.Id"];
TimeoutData timeoutData;
if (TimeoutsPersister.TryRemove(timeoutId, out timeoutData))
{
MessageSender.Send(timeoutData.ToTransportMessage(), timeoutData.Destination);
}
}
private void OnMessageReceived(object sender, TransportMessageReceivedEventArgs args)
{
EventHandler handler = (s, e) =>
{
var observers = this.TransportMessageReceived;
if (observers != null)
observers(this, args);
};
this.OnTransportEvent(handler, this.MasterSink.Failure);
}
private ISagaMessage[] MessageCreator(TransportMessageReceivedEventArgs e, TMessage message)
{
var headerValue = GetHeaderValue(e.Message, BusExtensions.SAGAID_KEY);
var sagaId = headerValue == null ? Guid.Empty : new Guid(headerValue.Value);
var result = _messageCreator(message);
foreach (var sagaMessage in result)
{
sagaMessage.SagaId = sagaId;
}
return(result);
}
void OnTransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
//dispatch request will arrive at the same input so we need to make sure to call the correct handler
if (e.Message.Headers.ContainsKey(TimeoutDispatcher.TimeoutIdToDispatchHeader))
{
Builder.Build <TimeoutDispatchHandler>().Handle(e.Message);
}
else
{
Builder.Build <TimeoutTransportMessageHandler>().Handle(e.Message);
}
}
void HandleMessageReceived(object sender, TransportMessageReceivedEventArgs e, ISatellite satellite)
{
try
{
satellite.Handle(e.Message);
}
catch (Exception ex)
{
Logger.ErrorFormat("{0} could not handle message. Exception: {1}", satellite.GetType().Name, ex.Message);
throw;
}
}
void OnTransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
//dispatch request will arrive at the same input so we need to make sure to call the correct handler
if (e.Message.Headers.ContainsKey(TimeoutIdToDispatchHeader))
{
HandleBackwardsCompatibility(e.Message);
}
else
{
Handle(e.Message);
}
}
/// <summary>
/// Handles reciept of a message on the bus to distribute for.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
/// <remarks>
/// This method checks whether a worker is available to handle the message and
/// forwards it if one is found.
/// </remarks>
private void messageBusTransport_TransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
var destination = WorkerManager.PopAvailableWorker();
if (destination == null)
{
Rollback();
}
else
{
logger.Debug("Sending message to: " + destination);
MessageSender.Send(e.Message, destination);
}
}
void OnTransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
var transportMessage = e.Message;
//send first so that we get the new id that we can use for retries
MessageSender.Send(transportMessage, errorLogAddress);
var message = new ProcessFaultMessage
{
FaultEnvelopeId = transportMessage.Id,
Headers = transportMessage.Headers,
Body = Encoding.UTF8.GetString(transportMessage.Body)//wil only work for text serialization
};
BackendUploader.Upload(message);
}
private void OnTransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
dynamic response = new ExpandoObject();
XmlMessageSerializer serializer = new XmlMessageSerializer(new MessageMapper());
var message = serializer.Deserialize(new MemoryStream(e.Message.Body)).First();
response.Endpoint = bus.InputAddress.Queue;
response.Time = DateTime.UtcNow;
response.type = message.GetType().ToString();
response.body = message;
response.headers = e.Message.Headers;
_monitor.Invoke("MessageReceived", response);
}
void ExternalTransportTransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
if (e.Message.MessageIntent == MessageIntentEnum.Publish)
{
string val = null;
foreach (var header in e.Message.Headers)
{
if (header.Key == UnicastBus.EnclosedMessageTypes)
{
val = header.Value;
}
}
var types = UnicastBus.DeserializeEnclosedMessageTypes(val);
var subs = Subscribers.GetSubscriberAddressesForMessage(types.Select(s => new MessageType(s)));
Logger.Debug("Received notification from " + remoteServer + ".");
foreach (var s in subs)
{
InternalMessageSender.Send(e.Message, s);
}
}
else
{
ProxyData data = null;
if (e.Message.CorrelationId != null)
{
data = Storage.GetAndRemove(e.Message.CorrelationId);
}
if (data == null)
{
return;
}
e.Message.CorrelationId = data.CorrelationId;
Logger.Debug("Received response from " + remoteServer + ".");
InternalMessageSender.Send(e.Message, data.ClientAddress);
}
}
void ExternalTransportTransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
if (e.Message.MessageIntent == MessageIntentEnum.Publish)
{
if (!e.Message.Headers.ContainsKey(EnclosedMessageTypesMutator.EnclosedMessageTypes))
{
throw new InvalidOperationException("Enclosed message type header was not found in message");
}
var types = e.Message.Headers[EnclosedMessageTypesMutator.EnclosedMessageTypes].Split(';');
var subs = Subscribers.GetSubscriberAddressesForMessage(types.Select(s => new MessageType(s)));
Logger.Debug("Received notification from " + RemoteServer + ".");
foreach (var s in subs)
{
InternalMessageSender.Send(e.Message, s);
}
}
else
{
ProxyData data = null;
if (e.Message.CorrelationId != null)
{
data = Storage.GetAndRemove(e.Message.CorrelationId);
}
if (data == null)
{
return;
}
e.Message.CorrelationId = data.CorrelationId;
Logger.Debug("Received response from " + RemoteServer + ".");
InternalMessageSender.Send(e.Message, data.ClientAddress);
}
}
void OnTransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
var transportMessage = e.Message;
var message = new ProcessAuditMessage
{
MessageId = transportMessage.IdForCorrelation,
Headers = transportMessage.Headers,
AdditionalInformation = new Dictionary <string, string>()
};
message.AdditionalInformation["MessageIntent"] = transportMessage.MessageIntent.ToString();
message.AdditionalInformation["CorrelationId"] = transportMessage.CorrelationId;
if (includeMessageBody)
{
message.Body = transportMessage.Body;
}
BackendUploader.Upload(message);
}
static void Transport_TransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
if (!ConfigureImpersonation.Impersonate)
{
return;
}
if (!e.Message.Headers.ContainsKey(Headers.WindowsIdentityName))
{
return;
}
var name = e.Message.Headers[Headers.WindowsIdentityName];
if (name == null)
{
return;
}
Thread.CurrentPrincipal = new GenericPrincipal(new GenericIdentity(name), new string[0]);
}
void OnTransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
var messageToDispatch = e.Message;
var destinationSites = routeMessages.GetDestinationSitesFor(messageToDispatch);
//if there is more than 1 destination we break it up into multiple messages
if (destinationSites.Count() > 1)
{
foreach (var destinationSite in destinationSites)
CloneAndSendLocal(messageToDispatch, destinationSite);
return;
}
var destination = destinationSites.FirstOrDefault();
if (destination == null)
throw new InvalidOperationException("No destination found for message");
SendToSite(messageToDispatch, destination);
}
private void Transport_TransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
this.OutgoingHeaders.Clear();
_messageBeingHandled = e.Message;
Logger.Debug("Received transport message with ID " + e.Message.Id + " from sender " + e.Message.ReturnAddress);
OnMessageReceived((ITransport)sender);
var sw = Stopwatch.StartNew();
try
{
if (e.Message.MessageIntent == MessageIntentEnum.Send)
{
using (var childServiceLocator = this.messageDispatcher.ServiceLocator.GetChildServiceLocator())
{
childServiceLocator.RegisterComponent <IMessageBus>(this);
this.messageDispatcher.DispatchMessages(childServiceLocator, e.Message.Body, CurrentMessageContext);
}
}
sw.Stop();
OnMessageHandled((ITransport)sender, e.Message, sw.Elapsed.TotalMilliseconds, sw.ElapsedTicks);
}
catch (Exception ex)
{
var orignalException = ex;
if (orignalException is TargetInvocationException)
{
orignalException = ex.InnerException;
}
throw new TransportMessageHandlingFailedException(orignalException);
}
finally
{
sw.Stop();
}
Logger.Debug("Finished handling message.");
}
static void TransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
throw new TransportMessageHandlingFailedException(new ApplicationException("A user exception"));
}
void TransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
PipelineFactory.InvokeReceivePhysicalMessagePipeline();
}
void HandleMessageReceived(object sender, TransportMessageReceivedEventArgs e, ISatellite satellite)
{
if (!satellite.Handle(e.Message))
{
((ITransport) sender).AbortHandlingCurrentMessage();
}
}
private void HandleTransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
counter.RawValue = Convert.ToInt32((DateTime.Now - e.Message.TimeSent).TotalSeconds);
timeOfLastCounter = DateTime.Now;
}
static void TransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
throw new TransportMessageHandlingFailedException(new ApplicationException( "A user exception"));
}
void OnTransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
//dispatch request will arrive at the same input so we need to make sure to call the correct handler
if (e.Message.Headers.ContainsKey(TimeoutIdToDispatchHeader))
HandleBackwardsCompatibility(e.Message);
else
Handle(e.Message);
}
private void OnTransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
var transportMessage = e.Message;
var timeoutId = transportMessage.Headers["Timeout.Id"];
TimeoutData timeoutData;
if (TimeoutsPersister.TryRemove(timeoutId, out timeoutData))
{
MessageSender.Send(timeoutData.ToTransportMessage(), timeoutData.Destination);
}
}
void TransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
var message = e.Message.Body[0];
_bus.SendLocal(message);
}
void OnTransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
Builder.Build<TimeoutTransportMessageHandler>()
.Handle(e.Message);
}
void OnTransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
Builder.Build <TimeoutTransportMessageHandler>()
.Handle(e.Message);
}
