public virtual void AuditSend(ChannelEnvelope envelope, IDeliveryContext delivery)
{
if (envelope == null)
{
throw new ArgumentNullException("envelope");
}
if (delivery != null && delivery.CurrentMessage == envelope.Message)
{
return;
}
var message = envelope.Message;
if (message == envelope.State)
{
return;
}
var process = Process.GetCurrentProcess();
var headers = message.Headers;
headers[DispatchStamp] = SystemTime.UtcNow.ToIsoString();
headers[OriginHost] = Environment.MachineName.ToLowerInvariant();
headers[ProcessName] = process.ProcessName;
headers[ProcessId] = process.Id.ToString(CultureInfo.InvariantCulture);
}
public void DispatchToRegisteredResponseHandler(TResponse response, IDeliveryContext deliveryContext)
{
var correlationId = deliveryContext.Delivery.CorrelationId;
if (string.IsNullOrEmpty(correlationId))
{
var message = string.Format(
"The requester {0}/{1} received a response with with no correlation id",
typeof(TRequest).Name,
typeof(TResponse).Name);
throw new ChinchillaException(message);
}
Action <TResponse, IDeliveryContext> handler;
if (!responders.TryGetValue(correlationId, out handler))
{
var message = string.Format(
"The requester {0}/{1} received a response with a correlation id that wasn't found " +
"in the responders dictionary.",
typeof(TRequest).Name,
typeof(TResponse).Name);
throw new ChinchillaException(message);
}
handler(response, deliveryContext);
}
public void Consume(ConnectMessage message, IDeliveryContext deliveryContext)
{
var exchange = publisher.Exchange;
var keys = message.Tickers.Select(
t => string.Format("prices.{0}", t)).ToArray();
var formattedKeys = string.Join(", ", keys);
Console.WriteLine("Client Connected: {0} on {1} for {2}", message.ClientId, message.QueueName, formattedKeys);
var binding = new Binding(
new Queue(message.QueueName),
new Exchange(exchange.Name, ExchangeType.Topic),
keys);
try
{
var topologyBuilder = new TopologyBuilder(publisher.ModelReference);
topologyBuilder.Visit(binding);
}
catch
{
// TODO: Throw exception here to reject the message
}
}
public void AuditSend(ChannelEnvelope envelope, IDeliveryContext delivery)
{
if (!this.cloud)
{
return;
}
if (envelope == null)
{
throw new ArgumentNullException("envelope");
}
if (delivery != null && delivery.CurrentMessage == envelope.Message)
{
return;
}
var message = envelope.Message;
if (message == envelope.State)
{
return;
}
var headers = message.Headers;
headers[ProviderNameHeader] = ProviderName;
headers[FacilityNameHeader] = FacilityName;
headers[MachineIdHeader] = MachineId;
}
private void OnMessage(TimeoutMessage message, IDeliveryContext context)
{
Console.WriteLine("[Consumer] Received message: {0}", message.JobId);
Thread.Sleep(8000);
Console.WriteLine("[Consumer] Processed message: {0}", message.JobId);
context.Reply(new TimeoutResponse());
}
public DefaultHandlerContext(IDeliveryContext delivery)
{
if (delivery == null)
throw new ArgumentNullException("delivery");
this.delivery = delivery;
this.continueHandling = true;
}
private void OnMessage(TimeoutMessage message, IDeliveryContext context)
{
Console.WriteLine("[Consumer] Received message: {0}", message.JobId);
Thread.Sleep(8000);
Console.WriteLine("[Consumer] Processed message: {0}", message.JobId);
context.Reply(new TimeoutResponse());
}
public virtual void Handle(IDeliveryContext delivery)
{
Log.Debug("Channel message received, routing message to configured handlers.");
using (var context = new DefaultHandlerContext(delivery))
this.routingTable.Route(context, delivery.CurrentMessage);
Log.Verbose("Channel message payload successfully delivered to all configured recipients.");
}
public virtual void Handle(IDeliveryContext delivery)
{
Log.Debug("Channel message received, routing message to configured handlers.");
using (var context = new DefaultHandlerContext(delivery))
this.routingTable.Route(context, delivery.CurrentMessage);
Log.Verbose("Channel message payload successfully delivered to all configured recipients.");
}
public void AuditSend(ChannelEnvelope envelope, IDeliveryContext delivery)
{
_telemetryClient.TrackEvent("SendMessage",
new Dictionary <string, string>
{
{ "ChannelGroup", _channel.CurrentConfiguration.GroupName },
{ "MessageType", envelope.Message.ActiveMessage.GetType().Name }
});
}
public void AuditReceive(IDeliveryContext delivery)
{
_telemetryClient.TrackEvent("ReceiveMessage",
new Dictionary <string, string>
{
{ "ChannelGroup", _channel.CurrentConfiguration.GroupName },
{ "MessageType", delivery.CurrentMessage.ActiveMessage.GetType().Name }
});
}
private void AuditReceive(IDeliveryContext context)
{
var messageId = context.CurrentMessage.MessageId;
foreach (var auditor in this.auditors)
{
Log.Debug("Routing delivery for message '{0}' for inspection to auditor of type '{1}'.", messageId, auditor.GetType());
auditor.AuditReceive(context);
}
}
private void AuditReceive(IDeliveryContext context)
{
var messageId = context.CurrentMessage.MessageId;
foreach (var auditor in this.auditors)
{
Log.Debug("Routing delivery for message '{0}' for inspection to auditor of type '{1}'.", messageId, auditor.GetType());
auditor.AuditReceive(context);
}
}
public DefaultHandlerContext(IDeliveryContext delivery)
{
if (delivery == null)
{
throw new ArgumentNullException("delivery");
}
this.delivery = delivery;
this.continueHandling = true;
}
public virtual void Handle(IDeliveryContext delivery)
{
Log.Debug("Creating new transaction scope associated for delivery.");
using (var scope = new TransactionScope(this.scopeOption, this.transactionOptions))
{
this.inner.Handle(delivery);
Log.Debug("Committing transaction scope associated with delivery.");
scope.Complete();
}
}
public virtual void AuditReceive(IDeliveryContext delivery)
{
if (delivery == null)
throw new ArgumentNullException("delivery");
var header = delivery.CurrentMessage.Headers.TryGetValue(DispatchStamp);
DateTime dispatched;
if (DateTime.TryParse(header, out dispatched))
delivery.CurrentMessage.Dispatched = dispatched.ToUniversalTime();
}
public virtual void Handle(IDeliveryContext delivery)
{
Log.Debug("Creating new transaction scope associated for delivery.");
using (var scope = new TransactionScope(this.scopeOption, this.transactionOptions))
{
this.inner.Handle(delivery);
Log.Debug("Committing transaction scope associated with delivery.");
scope.Complete();
}
}
public virtual void Handle(IDeliveryContext delivery)
{
if (delivery == null)
throw new ArgumentNullException("delivery");
Log.Debug("Channel message delivery received, routing to inner delivery handler.");
this.inner.Handle(delivery);
Log.Debug("Committing transaction associated with delivery.");
delivery.CurrentTransaction.Commit();
}
public virtual void Handle(IDeliveryContext delivery)
{
if (delivery == null)
{
throw new ArgumentNullException("delivery");
}
Log.Debug("Channel message delivery received, routing to inner delivery handler.");
this.inner.Handle(delivery);
Log.Debug("Committing transaction associated with delivery.");
delivery.CurrentTransaction.Commit();
}
protected virtual void Receive(IDeliveryContext context, Action <IDeliveryContext> callback)
{
try
{
this.AuditReceive(context);
Log.Verbose("Routing delivery to configured callback.");
this.currentContext = context;
callback(this);
}
finally
{
this.currentContext = null;
}
}
protected virtual void Receive(IDeliveryContext context, Action<IDeliveryContext> callback)
{
try
{
this.AuditReceive(context);
Log.Verbose("Routing delivery to configured callback.");
this.currentContext = context;
callback(this);
}
finally
{
this.currentContext = null;
}
}
public virtual void AuditReceive(IDeliveryContext delivery)
{
if (delivery == null)
{
throw new ArgumentNullException("delivery");
}
var header = delivery.CurrentMessage.Headers.TryGetValue(DispatchStamp);
DateTime dispatched;
if (DateTime.TryParse(header, out dispatched))
{
delivery.CurrentMessage.Dispatched = dispatched.ToUniversalTime();
}
}
public virtual void AuditSend(ChannelEnvelope envelope, IDeliveryContext delivery)
{
if (envelope == null)
throw new ArgumentNullException("envelope");
if (delivery != null && delivery.CurrentMessage == envelope.Message)
return;
var message = envelope.Message;
if (message == envelope.State)
return;
var headers = message.Headers;
headers[OriginHost] = Environment.MachineName.ToLowerInvariant();
headers[DispatchStamp] = SystemTime.UtcNow.ToIsoString();
}
protected virtual void Receive(IDeliveryContext context, Action<IDeliveryContext> callback)
{
try
{
Log.Verbose("Delivery received, attempting to create nested resolver.");
this.currentContext = context;
this.currentResolver = this.resolver.CreateNestedResolver();
callback(this);
}
finally
{
this.currentResolver.Dispose();
this.currentResolver = null;
this.currentContext = null;
}
}
public virtual void AuditSend(ChannelEnvelope envelope, IDeliveryContext delivery)
{
var current = this.GetCurrentContext(envelope);
if (current == null)
return;
var headers = envelope.Message.Headers;
var request = current.Request;
AppendHeader(headers, "useragent", request.UserAgent);
AppendHeader(headers, "client-ip", GetUserAddress(request));
AppendHeader(headers, "raw-url", request.RawUrl);
AppendHeader(headers, "http-method", request.HttpMethod);
AppendHeader(headers, "referring-url", AsString(request.UrlReferrer));
AppendHeader(headers, "request-stamp", current.Timestamp.ToUniversalTime().ToIsoString());
}
protected virtual void Receive(IDeliveryContext context, Action <IDeliveryContext> callback)
{
try
{
Log.Verbose("Delivery received, attempting to create nested resolver.");
this.currentContext = context;
this.currentResolver = this.resolver.CreateNestedResolver();
callback(this);
}
finally
{
Log.Verbose("Delivery completed, disposing nested resolver.");
this.currentResolver.TryDispose();
this.currentResolver = null;
this.currentContext = null;
}
}
private static IEnumerable <IMessageHandler <T> > TryResolve <T>(IDeliveryContext context)
{
var container = context.CurrentResolver.As <ILifetimeScope>();
try
{
return(container.Resolve <IEnumerable <IMessageHandler <T> > >());
}
catch (DependencyResolutionException e)
{
if (IsAutofacException(e))
{
throw;
}
throw e.InnerException;
}
}
public virtual void AuditSend(ChannelEnvelope envelope, IDeliveryContext delivery)
{
var current = this.GetCurrentContext(envelope);
if (current == null)
{
return;
}
var headers = envelope.Message.Headers;
var request = current.Request;
AppendHeader(headers, "useragent", request.UserAgent);
AppendHeader(headers, "client-ip", GetUserAddress(request));
AppendHeader(headers, "raw-url", request.RawUrl);
AppendHeader(headers, "hostname", (request.Url ?? EmptyUrl).Host);
AppendHeader(headers, "http-method", request.HttpMethod);
AppendHeader(headers, "referring-url", AsString(request.UrlReferrer));
AppendHeader(headers, "request-stamp", current.Timestamp.ToUniversalTime().ToIsoString());
}
public void AuditSend(ChannelEnvelope envelope, IDeliveryContext delivery)
{
if (!this.cloud)
return;
if (envelope == null)
throw new ArgumentNullException("envelope");
if (delivery != null && delivery.CurrentMessage == envelope.Message)
return;
var message = envelope.Message;
if (message == envelope.State)
return;
var headers = message.Headers;
headers[ProviderNameHeader] = ProviderName;
headers[FacilityNameHeader] = FacilityName;
headers[MachineIdHeader] = MachineId;
}
protected static bool Receive(IDeliveryContext delivery)
{
currentMessage = delivery.CurrentMessage.Messages.First();
return((++messagesReceived) > 0);
}
protected static void TryBuild(IDeliveryContext delivery)
{
Try(() => handlerContext = new DefaultHandlerContext(delivery));
}
void IConsumer <TestMessage> .Consume(TestMessage message, IDeliveryContext deliveryContext)
{
}
static ChannelEnvelope BuildEnvelope(IDeliveryContext delivery)
{
return new ChannelEnvelope(delivery.CurrentMessage, new[] { ChannelEnvelope.LoopbackAddress });
}
public void Consume(HelloWorldMessage message, IDeliveryContext deliveryContext)
{
Console.WriteLine("consuming message!");
}
public void Consume(CapitalizeMessage message, IDeliveryContext deliveryContext)
{
var upcased = message.Word.ToUpper();
deliveryContext.Reply(new CapitalizedMessage(upcased));
}
public PersonasControllerTest()
{
context = new FakeMemoryContext();
}
protected static void TryBuild(IDeliveryContext delivery)
{
Try(() => handlerContext = new DefaultHandlerContext(delivery));
}
public Context(IDeliveryContext deliveryContext, bool multiple, bool requeue)
{
DeliveryContext = deliveryContext;
_multiple = multiple;
_requeue = requeue;
}
public PersonaController(IDeliveryContext c)
{
context = c;
}
public PersonaController()
{
context = new DeliveryContext();
}
public void AuditReceive(IDeliveryContext delivery)
{
// no op
}
public void Consume(TestMessage message, IDeliveryContext deliveryContext)
{
}
public void Consume(HelloWorldMessage message, IDeliveryContext deliveryContext)
{
}
public void Consume(PubSubMessage message, IDeliveryContext deliveryContext)
{
Console.WriteLine(message.Body);
}
protected static bool Receive(IDeliveryContext delivery)
{
currentMessage = delivery.CurrentMessage.Messages.First();
return (++messagesReceived) > 0;
}
public virtual void AuditReceive(IDeliveryContext delivery)
{
// no op
}
