public static DataEventAction <T, TData> RetryLater <T, TData>(this DataEventAction <T, TData> eventAction)
where T : SagaStateMachine <T>, ISaga
where TData : class
{
eventAction.Call((saga, message) => ContextStorage.MessageContext <TData>().RetryLater());
return(eventAction);
}
/// <summary>
/// Send a message to an endpoint
/// </summary>
/// <typeparam name="T">The message type</typeparam>
/// <param name="endpoint">The destination endpoint</param>
/// <param name="message">The message to send</param>
public static void Send <T>(this IEndpoint endpoint, T message)
where T : class
{
SendContext <T> context = ContextStorage.CreateSendContext(message);
endpoint.Send(context);
}
public void Send <T>(T message)
where T : class
{
ISendContext <T> context = ContextStorage.CreateSendContext(message);
Send(context);
}
public override void Consume(TMessage message)
{
base.Consume(message);
var reply = FastActivator <TReplyMessage> .Create(message.CorrelationId);
ContextStorage.Context().Respond(reply);
}
public static DataEventAction <T, TData> RespondWith <T, TData, TMessage>(this DataEventAction <T, TData> eventAction, Func <T, TData, TMessage> action)
where T : SagaStateMachine <T>, ISaga
where TData : class
where TMessage : class
{
eventAction.Call((saga, message) => ContextStorage.Context().Respond(action(saga, message)));
return(eventAction);
}
/// <summary>
/// Send a message to an endpoint
/// </summary>
/// <typeparam name="T">The message type</typeparam>
/// <param name="endpoint">The destination endpoint</param>
/// <param name="message">The message to send</param>
/// <param name="contextCallback">A callback method to modify the send context for the message</param>
public static void Send <T>(this IEndpoint endpoint, T message, Action <ISendContext <T> > contextCallback)
where T : class
{
SendContext <T> context = ContextStorage.CreateSendContext(message);
contextCallback(context);
endpoint.Send(context);
}
public void Execute(Composer composer, TInstance instance, TData value)
{
composer.Execute(() =>
{
IConsumeContext <TData> context = ContextStorage.MessageContext <TData>();
context.RetryLater();
});
}
public void Send <T>(T message, Action <ISendContext <T> > contextCallback)
where T : class
{
ISendContext <T> context = ContextStorage.CreateSendContext(message);
contextCallback(context);
Send(context);
}
static void RewriteResponseAddress(Uri responseAddress)
{
var context = ContextStorage.MessageContext <Distributed <TMessage> >() as ConsumeContext <Distributed <TMessage> >;
if (context != null)
{
context.SetResponseAddress(responseAddress);
}
}
public void Execute(Composer composer, TInstance instance, TData value)
{
composer.Execute(() =>
{
IConsumeContext <TData> context = ContextStorage.MessageContext <TData>();
TMessage message = _messageFactory(instance, context);
context.Respond(message, _contextCallback);
});
}
public void Execute(Composer composer, TInstance instance, TData value)
{
composer.Execute(() =>
{
IConsumeContext <TData> context = ContextStorage.MessageContext <TData>();
TMessage message = _messageFactory(instance, context);
instance.Bus.PublishRequest(message, configurator => _configurator(instance, context, configurator));
});
}
public static EventActivityBinder <TInstance, TData> Publish <TInstance, TData, TMessage>(
this EventActivityBinder <TInstance, TData> source,
Func <TInstance, IConsumeContext <TData>, TData, TMessage> messageFactory)
where TInstance : class, SagaStateMachineInstance
where TData : class
where TMessage : class
{
Func <TInstance, TData, TMessage> factory =
(i, d) => messageFactory(i, ContextStorage.MessageContext <TData>(), d);
return(source.Add(new PublishActivity <TInstance, TData, TMessage>(factory, x => { })));
}
/// <summary>
/// Publishes a message to all subscribed consumers for the message type
/// </summary>
/// <typeparam name="T">The type of the message</typeparam>
/// <param name="message">The messages to be published</param>
/// <param name="contextCallback">The callback to perform operations on the context</param>
public void Publish <T>(T message, Action <IPublishContext <T> > contextCallback)
where T : class
{
PublishContext <T> context = ContextStorage.CreatePublishContext(message);
context.SetSourceAddress(Endpoint.Address.Uri);
contextCallback(context);
IList <Exception> exceptions = new List <Exception>();
int publishedCount = 0;
foreach (var consumer in OutboundPipeline.Enumerate(context))
{
try
{
consumer(context);
publishedCount++;
}
catch (Exception ex)
{
_log.Error(string.Format("'{0}' threw an exception publishing message '{1}'",
consumer.GetType().FullName, message.GetType().FullName), ex);
exceptions.Add(ex);
}
}
context.Complete();
if (publishedCount == 0)
{
context.NotifyNoSubscribers();
}
_eventChannel.Send(new MessagePublished
{
MessageType = typeof(T),
ConsumerCount = publishedCount,
Duration = context.Duration,
});
if (exceptions.Count > 0)
{
throw new PublishException(typeof(T), exceptions);
}
}
public void Consume(IGetMessageTraceList message)
{
IConsumeContext <IGetMessageTraceList> context = ContextStorage.MessageContext <IGetMessageTraceList>();
Uri responseAddress = context.ResponseAddress;
if (responseAddress == null)
{
return;
}
int count = message.Count;
IEndpoint responseEndpoint = context.Bus.GetEndpoint(responseAddress);
_fiber.Add(() => SendLastTraceMessagesTo(responseEndpoint, count));
}
public void Consume(TResponse message)
{
CommandInstance instance;
lock (_commands)
if (!_commands.TryGetValue(message.CorrelationId, out instance))
{
Interlocked.Increment(ref _unknownCommands);
return;
}
instance.ResponseCreatedAt = message.CreatedAt;
instance.ResponseReceivedAt = SystemUtil.UtcNow;
instance.Worker = ContextStorage.Context().SourceAddress;
Interlocked.Increment(ref _responseCount);
_received.Set();
}
public override void Receive(Func <IReceiveContext, Action <IReceiveContext> > callback, TimeSpan timeout)
{
GuardAgainstDisposed();
StompMessage message;
if (!_messages.TryDequeue(out message))
{
Thread.Sleep(50);
return;
}
using (var ms = new MemoryStream(Encoding.UTF8.GetBytes(message.Body)))
{
var context = new ConsumeContext(ms);
context.SetMessageId(message["id"]);
if (SpecialLoggers.Messages.IsInfoEnabled)
{
SpecialLoggers.Messages.InfoFormat("RECV:{0}:{1}", Address, context.MessageId);
}
using (ContextStorage.CreateContextScope(context))
{
var receive = callback(context);
if (receive != null)
{
receive(context);
}
else
{
if (SpecialLoggers.Messages.IsInfoEnabled)
{
SpecialLoggers.Messages.InfoFormat("SKIP:{0}:{1}", Address, context.MessageId);
}
}
}
}
}
public static TResult Context <TResult>(this IServiceBus bus, Func <IConsumeContext, TResult> contextCallback)
{
return(ContextStorage.Context(contextCallback));
}
public static void Context(this IServiceBus bus, Action <IConsumeContext> contextCallback)
{
ContextStorage.Context(contextCallback);
}
public static IConsumeContext <T> MessageContext <T>(this IServiceBus bus)
where T : class
{
return(ContextStorage.MessageContext <T>());
}
public static IConsumeContext <T> MessageContext <T>(this Consumes <T> .All instance)
where T : class
{
return(ContextStorage.MessageContext <T>());
}
public static IConsumeContext Context(this IServiceBus bus)
{
return(ContextStorage.Context());
}
public static IConsumeContext Context(this IConsumer instance)
{
return(ContextStorage.Context());
}
public void Consume(SimpleRequestMessage message)
{
ContextStorage.Context().Respond(new SimpleResponseMessage(message.CorrelationId));
}
