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)); }