/// <summary> /// Handles processing the specified message with the context /// </summary> /// <param name="context">The context.</param> /// <param name="transportMessage">The transport message.</param> /// <returns></returns> public async Task Handle(IMessageContext context, IReceivedMessageInternal transportMessage) { using (var heartBeat = _heartBeatWorkerFactory.Create(context)) { try { await _methodToRun.HandleAsync(transportMessage, context.WorkerNotification).ConfigureAwait(false); _commitMessage.Commit(context); } // ReSharper disable once UncatchableException catch (ThreadAbortException) { heartBeat.Stop(); throw; } catch (OperationCanceledException) { heartBeat.Stop(); throw; } catch (Exception exception) { heartBeat.Stop(); _messageExceptionHandler.Handle(transportMessage, context, exception.InnerException ?? exception); } } }
public Task Respond(ChatContextHolder chatContextHolder, IMessageContext context) { return Task.Run(() => { foreach (LightPin pin in _lights) { pin.Set(context.Text, _pinManager); } LightPin[] allOn = _lights.Where(x => x.ContainsSection(context.Text) && x.IsOn(context.Text)).ToArray(); if (!allOn.Select(x => x.Color).Any()) { context.Respond(string.Format("{0} lights are now off", _lights.Where(x => x.ContainsSection(context.Text)) .Select(x => x.Section) .Distinct() .StringJoin())); } else { context.Respond(string.Format("{0} {1} lights are now on", allOn.Select(x => x.Section).Distinct().StringJoin(), allOn.Select(x => x.Color).Distinct().StringJoin())); } }); }
internal static MessageContext Enter(IDictionary<string, string> headers) { if (current != null) { #if DEBUG throw new InvalidOperationException( string.Format( @"Cannot establish new message context when one is already present! Stacktrace of when the current message context was created: {0}", current.StackTrace)); #else throw new InvalidOperationException( string.Format("Cannot establish new message context when one is already present")); #endif } var messageContext = new MessageContext(headers); current = messageContext; Established(current); return messageContext; }
/// <summary> /// Handles processing the specified message with the context /// </summary> /// <param name="context">The context.</param> /// <param name="transportMessage">The transport message.</param> /// <returns></returns> public bool Handle(IMessageContext context, IReceivedMessageInternal transportMessage) { using (var heartBeat = _heartBeatWorkerFactory.Create(context)) { try { _methodToRun.Handle(transportMessage, context.WorkerNotification); _commitMessage.Commit(context); return true; } // ReSharper disable once UncatchableException catch (ThreadAbortException) { heartBeat.Stop(); throw; } catch (OperationCanceledException) { heartBeat.Stop(); throw; } catch (Exception exception) { heartBeat.Stop(); _messageExceptionHandler.Handle(transportMessage, context, exception); } } return false; }
public void End(IServiceLocator childServiceLocator, IMessageContext messageContext, Exception ex) { if (ex == null) LogMessage("Commit"); else LogMessage("Rollback, reason: " + ex); }
/// <summary> /// Receives a new message. /// </summary> /// <param name="context">The context.</param> /// <returns></returns> public IReceivedMessageInternal ReceiveMessage(IMessageContext context) { context.Commit += ContextOnCommit; context.Rollback += ContextOnRollback; context.Cleanup += context_Cleanup; TimeSpan? timeout = null; IMessageId messageId = null; var rpc = context.Get(_headers.StandardHeaders.RpcContext); if (rpc?.Timeout != null) { timeout = rpc.Timeout; } if (rpc?.MessageId != null) { messageId = rpc.MessageId; } using ( var workSub = rpc?.MessageId != null && rpc.MessageId.HasValue ? _workSubFactory.Create(rpc.MessageId) : _workSubFactory.Create()) { while (true) { if (_cancelWork.Tokens.Any(m => m.IsCancellationRequested)) { return null; } var message = GetMessage(context, messageId); if (message != null && !message.Expired) { return message.Message; } if (_cancelWork.Tokens.Any(m => m.IsCancellationRequested)) { return null; } workSub.Reset(); message = GetMessage(context, messageId); if (message != null && !message.Expired) { return message.Message; } if (message != null && message.Expired) { continue; } if (workSub.Wait(timeout)) { continue; } return null; } } }
/// <summary> /// Updates the heart beat for a record. /// </summary> /// <param name="context">The context.</param> /// <returns></returns> public IHeartBeatStatus Send(IMessageContext context) { using (_timer.NewContext()) { return _handler.Send(context); } }
/// <summary> /// Get a validation message /// </summary> /// <param name="context">Context</param> /// <returns> /// String if found; otherwise <c>null</c>. /// </returns> public string GetMessage(IMessageContext context) { if (context.Attribute is CompareAttribute) return "The {0} and {1} fields to not match."; return null; }
/// <summary> /// Returns the next message, if any. /// </summary> /// <param name="context">The context.</param> /// <returns> /// A message if one is found; null otherwise /// </returns> public IReceivedMessageInternal GetMessage(IMessageContext context) { //if stopping, exit now if (_cancelToken.Tokens.Any(t => t.IsCancellationRequested)) { return null; } //check for a specific MessageID to pull IMessageId messageId = null; var rpc = context.Get(_configuration.HeaderNames.StandardHeaders.RpcContext); if (rpc?.MessageId != null && rpc.MessageId.HasValue) { messageId = rpc.MessageId; } //ask for the next message, or a specific message if we have a messageID var receivedTransportMessage = _receiveMessage.Handle(new ReceiveMessageQuery(messageId, _configuration.Routes)); //if no message (null) run the no message action and return if (receivedTransportMessage == null) { return null; } //set the message ID on the context for later usage context.MessageId = receivedTransportMessage.MesssageId; return receivedTransportMessage; }
/// <summary> /// Initializes a new instance of the <see cref="HeartBeatWorker" /> class. /// </summary> /// <param name="configuration">The configuration.</param> /// <param name="context">The context.</param> /// <param name="sendHeartBeat">The send heart beat.</param> /// <param name="threadPool">The thread pool.</param> /// <param name="log">The log.</param> /// <param name="heartBeatNotificationFactory">The heart beat notification factory.</param> public HeartBeatWorker(IHeartBeatConfiguration configuration, IMessageContext context, ISendHeartBeat sendHeartBeat, IHeartBeatThreadPool threadPool, ILogFactory log, IWorkerHeartBeatNotificationFactory heartBeatNotificationFactory) { Guard.NotNull(() => configuration, configuration); Guard.NotNull(() => context, context); Guard.NotNull(() => sendHeartBeat, sendHeartBeat); Guard.NotNull(() => threadPool, threadPool); Guard.NotNull(() => log, log); Guard.NotNull(() => heartBeatNotificationFactory, heartBeatNotificationFactory); _context = context; _checkTimespan = configuration.CheckTime; _sendHeartbeat = sendHeartBeat; _smartThreadPool = threadPool; _logger = log.Create(); _runningLock = new ReaderWriterLockSlim(); _stoppedLock = new ReaderWriterLockSlim(); _cancel = new CancellationTokenSource(); context.WorkerNotification.HeartBeat = heartBeatNotificationFactory.Create(_cancel.Token); }
protected Command(Guid aggregateId, int version, IMessageContext context) { AggregateId = aggregateId; UtcDate = SystemClock.UtcNow; Version = version; Metadata = context.Metadata; }
public void Publish(IMessage message, IMessageContext sender) { var messageTpye = message.GetType(); if (handlers.ContainsKey(messageTpye)) { foreach (var handler in handlers[messageTpye]) { dynamic instance = handlerFactory(handler); try { if (HasResponse(message)) { var result = instance.Handle((dynamic)(message.ToPublishedMessage(sender))); sender.Respond(result); } else instance.Handle((dynamic)(message.ToPublishedMessage(sender))); } catch (Exception ex) { sender.ErrorFormat("{0} , {1}", ex.Message, ex.StackTrace); } } } }
/// <summary> /// Initializes a new instance of the <see cref="MoveRecordToErrorQueueCommand" /> class. /// </summary> /// <param name="exception">The exception.</param> /// <param name="queueId">The queue identifier.</param> /// <param name="context">The context.</param> public MoveRecordToErrorQueueCommand(Exception exception, long queueId, IMessageContext context) { Guard.NotNull(() => context, context); Exception = exception; QueueId = queueId; MessageContext = context; }
/// <summary> /// messaging callback /// see com.db4o.messaging.MessageRecipient#ProcessMessage() /// </summary> public void ProcessMessage(IMessageContext con, object message) { if (message is StopServer) { Close(); } }
public HandleResult Handle(IMessageContext msg) { if (msg.IsInitiallyPolled) return HandleResult.Ignored; var update = msg.Update; if (update.Message.Chat.Id == -1001013065325) { var eva = new Regex(@"\b[eе]+[vв]+[aа]+\b", RegexOptions.IgnoreCase); if (eva.IsMatch(update.Message.Text ?? "")) { _ctx.BotApi.SendMessageAsync(-1001013065325, "чо"); return HandleResult.HandledCompletely; } if (update.Message.From.Id == 146268050) { var roll = new Random().Next(10); if (roll == 7) _ctx.BotApi.SendMessageAsync(-1001013065325, "юль, ну впиши по-братски"); return HandleResult.HandledCompletely; } } return HandleResult.Ignored; }
/// <summary> /// Commits the processed message, by deleting the message /// </summary> /// <param name="context">The context.</param> public void Commit(IMessageContext context) { if (context.MessageId != null && context.MessageId.HasValue) { _deleteMessageCommand.Handle(new DeleteMessageCommand((long)context.MessageId.Id.Value)); } }
/// <summary> /// Invoked when we have dequeued a message, but a failure occurred during re-assembly. /// </summary> /// <param name="context">The context.</param> /// <param name="exception">The exception.</param> public void Handle(IMessageContext context, PoisonMessageException exception) { if (context.MessageId != null && context.MessageId.HasValue) { _commandMoveRecord.Handle(new MoveRecordToErrorQueueCommand((RedisQueueId)context.MessageId)); } context.MessageId = null; }
public Task Respond(ChatContextHolder chatContextHolder, IMessageContext context) { var volumeLevel = ValueConverterHelper.ToInt(ExtractStartsWith(context, "set volume"),10); var result = string.Format("volume set to {0}", volumeLevel); _textToSpeech.Play(result); _volumeSetter.SetVolume(volumeLevel); return context.Respond(result); }
public MessageSender(IMessageContext context) { m_Context = context; m_MessageBuffer = new ConcurrentQueue<string>(); m_MessageThread = new Thread(OnThreadStarted); m_MessageThread.Start(); }
void IQueueMessageHandler.Handle(QueueMessage queueMessage, IMessageContext context) { var message = _jsonSerializer.Deserialize<EventStreamMessage>(Encoding.UTF8.GetString(queueMessage.Body)); var domainEventStreamMessage = ConvertToDomainEventStream(message); var processContext = new DomainEventStreamProcessContext(this, domainEventStreamMessage, queueMessage, context); var processingMessage = new ProcessingDomainEventStreamMessage(domainEventStreamMessage, processContext); _processor.Process(processingMessage); }
void IQueueMessageHandler.Handle(QueueMessage queueMessage, IMessageContext context) { var applicationMessageType = _typeNameProvider.GetType(queueMessage.Tag); var message = _jsonSerializer.Deserialize(Encoding.UTF8.GetString(queueMessage.Body), applicationMessageType) as IApplicationMessage; var processContext = new EQueueProcessContext(queueMessage, context); var processingMessage = new ProcessingApplicationMessage(message, processContext); _processor.Process(processingMessage); }
/// <summary> /// Commits the message associated with the message context /// </summary> /// <param name="context"></param> /// <returns></returns> public bool Commit(IMessageContext context) { var result = _handler.Commit(context); if (result) { _commitCounter.Increment(); } return result; }
public Command(IMessageContext messageContext, Exception ex = null) : base(messageContext) { if (ex != null) { Error = ex.GetBaseException().Message; StackTrace = ex.StackTrace; } }
public void Handle(QueueMessage message, IMessageContext context) { var count = Interlocked.Increment(ref _handledCount); if (count % 1000 == 0) { Console.WriteLine("Total handled {0} messages.", count); } context.OnMessageHandled(message); }
public MessageReceiver(IMessageContext context) { m_Context = context; m_Lock = new object(); m_MessageThread = new Thread(SubscribeAndWait); m_MessageThread.Start(); }
public Task HandleMessage(object content, IMessageContext messageContext, CancellationToken cancellationToken = default(CancellationToken)) { Log.DebugFormat("Handling message ID {0}...", messageContext.Headers.MessageId); HandledMessageQueue.Enqueue(content); messageContext.Acknowledge(); MessageReceivedEvent.Set(); return Task.FromResult(true); }
static void DecodeUserContextHeadersIfPossible(IBus bus, IMessageContext messageContext) { var headers = messageContext.Headers; if (!headers.ContainsKey(UserContextHeaderKey)) return; var encodedUserContext = (string) headers[UserContextHeaderKey]; messageContext.Items[UserContextItemKey] = Decode(encodedUserContext); }
/// <summary> /// Rolls back the message associated to the context /// </summary> /// <param name="context"></param> /// <returns> /// true if the message was rolled back /// </returns> public bool Rollback(IMessageContext context) { var result = _handler.Rollback(context); if (result) { _rollbackCounter.Increment(); } return result; }
public async Task Respond(ChatContextHolder chatContextHolder, IMessageContext context) { var oneLiner = RandomTextHelper.OneLiner.Split('.'); foreach (var message in oneLiner) { await context.Respond(message); await Task.Delay(5000); } }
/// <summary> /// Constructs the saga context, registering the context under the key /// <see cref="SagaContextItemKey"/> in the current message context /// (if one is available) /// </summary> public SagaContext(Guid id) { Id = id; if (MessageContext.HasCurrent) { messageContext = MessageContext.GetCurrent(); messageContext.Items[SagaContextItemKey] = this; } }
public Task Execute(IMessagingRoot root, IMessageContext context, DateTime utcNow) { var envelope = context.Envelope; return(envelope.Callback.MoveToScheduledUntil(utcNow.Add(Delay), envelope)); }
/// <summary> /// Aborts the current message processing pipeline by making the currently executing handler the last one. /// This means that any message handlers following the current one in the current pipeline will NOT be executed. /// If no errors occurred, the queue transaction will be committed as if everything is allright. /// This method can be used to ABORT message process to allow for a handler to FUNCTION AS A FILTER. /// </summary> public static void AbortDispatch(this IMessageContext messageContext) { messageContext.IncomingStepContext.Save(DispatchIncomingMessageStep.AbortDispatchContextKey, true); }
public async Task <bool> TryHandleAsync(IMessageContext context, CancellationToken cancellationToken = default) { switch (context.Event) { case MessageEvent.Create: break; default: return(false); } var content = context.Message.Content; // ignore urls in commands if (content.StartsWith(_settings.Discord.Prefix)) { return(false); } // match gallery urls var ids = GalleryUtility.ParseMany(content); if (ids.Length == 0) { return(false); } if (_logger.IsEnabled(LogLevel.Debug)) { _logger.LogDebug($"Matched galleries: {string.Join(", ", ids.Select((s, i) => $"{s}/{i}"))}"); } // send interactive using (context.BeginTyping()) { // send one interactive if only one id detected if (ids.Length == 1) { var(source, id) = ids[0]; Doujin doujin; using (var scope = _services.CreateScope()) { doujin = await scope.ServiceProvider .GetRequiredService <IDatabase>() .GetDoujinAsync(source, id, cancellationToken); } if (doujin == null) { await context.ReplyAsync("doujinNotFound"); } else { await _interactive.SendInteractiveAsync( new DoujinMessage(doujin), context, cancellationToken); } } // send as a list else { await _interactive.SendInteractiveAsync( new GalleryUrlDetectedMessage(ids), context, cancellationToken); } } return(true); }
public Task PublishAsync(IMessageContext messageContext, string topic, CancellationToken cancellationToken) { return(_producer.SendAsync(GetEQueueMessage(messageContext, topic), messageContext.Key, cancellationToken)); }
public void ProcessMessage(IMessageContext context, object message) { var sender = context.Sender; sender.Send("reply: " + message); }
protected async virtual Task ConsumeMessage(IMessageContext commandContext) { var command = commandContext.Message as ICommand; IMessageContext messageReply = null; if (command == null) { return; } var needRetry = command.NeedRetry; using (var scope = IoCFactory.Instance.CurrentContainer.CreateChildContainer()) { scope.RegisterInstance(typeof(IMessageContext), commandContext); var eventMessageStates = new List <MessageState>(); var messageStore = scope.Resolve <IMessageStore>(); var eventBus = scope.Resolve <IEventBus>(); var commandHasHandled = messageStore.HasCommandHandled(commandContext.MessageID); if (commandHasHandled) { messageReply = _messageQueueClient.WrapMessage(new MessageDuplicatelyHandled(), commandContext.MessageID, commandContext.ReplyToEndPoint); eventMessageStates.Add(new MessageState(messageReply)); } else { var messageHandlerType = _handlerProvider.GetHandlerTypes(command.GetType()).FirstOrDefault(); _logger.InfoFormat("Handle command, commandID:{0}", commandContext.MessageID); if (messageHandlerType == null) { messageReply = _messageQueueClient.WrapMessage(new NoHandlerExists(), commandContext.MessageID, commandContext.ReplyToEndPoint); eventMessageStates.Add(new MessageState(messageReply)); } else { object messageHandler = null; do { try { if (messageHandler == null) { messageHandler = scope.Resolve(messageHandlerType.Type); } using (var transactionScope = new TransactionScope(TransactionScopeOption.Required, new TransactionOptions { IsolationLevel = System.Transactions.IsolationLevel.ReadUncommitted }, TransactionScopeAsyncFlowOption.Enabled)) { if (messageHandlerType.IsAsync) { await((dynamic)messageHandler).Handle((dynamic)command) .ConfigureAwait(false); } else { await Task.Run(() => { ((dynamic)messageHandler).Handle((dynamic)command); }).ConfigureAwait(false); } messageReply = _messageQueueClient.WrapMessage(commandContext.Reply, commandContext.MessageID, commandContext.ReplyToEndPoint); eventMessageStates.Add(new MessageState(messageReply)); eventBus.GetEvents().ForEach(@event => { var topic = @event.GetTopic(); if (!string.IsNullOrEmpty(topic)) { topic = Configuration.Instance.FormatAppName(topic); } var eventContext = _messageQueueClient.WrapMessage(@event, commandContext.MessageID, topic, @event.Key); eventMessageStates.Add(new MessageState(eventContext)); }); messageStore.SaveCommand(commandContext, eventMessageStates.Select(s => s.MessageContext).ToArray()); transactionScope.Complete(); } needRetry = false; } catch (Exception e) { eventMessageStates.Clear(); if (e is OptimisticConcurrencyException && needRetry) { eventBus.ClearMessages(); } else { messageStore.Rollback(); messageReply = _messageQueueClient.WrapMessage(e.GetBaseException(), commandContext.MessageID, commandContext.ReplyToEndPoint); eventMessageStates.Add(new MessageState(messageReply)); eventBus.GetToPublishAnywayMessages().ForEach(@event => { var topic = @event.GetTopic(); if (!string.IsNullOrEmpty(topic)) { topic = Configuration.Instance.FormatAppName(topic); } var eventContext = _messageQueueClient.WrapMessage(@event, commandContext.MessageID, topic, @event.Key); eventMessageStates.Add(new MessageState(eventContext)); }); if (e is DomainException) { _logger.Warn(command.ToJson(), e); } else { _logger.Error(command.ToJson(), e); } messageStore.SaveFailedCommand(commandContext, e, eventMessageStates.Select(s => s.MessageContext).ToArray()); needRetry = false; } } } while (needRetry); } } try { if (_messagePublisher != null && eventMessageStates.Count > 0) { _messagePublisher.SendAsync(eventMessageStates.ToArray()); } } catch (Exception ex) { _logger.Error($"_messagePublisher SendAsync error", ex); } _removeMessageContext(commandContext); } }
public static void SetStateData <T>(this IMessageContext messageContext, string key, T data) { var stateDataKey = GetStateDataKey(key); messageContext.Set(stateDataKey, data); }
/// <summary> /// Clean up the message context when processing is done /// </summary> /// <param name="context">The context.</param> private void ContextCleanup(IMessageContext context) { context.Commit -= ContextOnCommit; context.Rollback -= ContextOnRollback; context.Cleanup -= Context_Cleanup; }
public CommandExecuteContext(IRepository repository, IAggregateStorage aggregateRootStorage, QueueMessage queueMessage, IMessageContext messageContext, CommandMessage commandMessage, SendReplyService sendReplyService) { _trackingAggregateRootDict = new ConcurrentDictionary <string, IAggregateRoot>(); _repository = repository; _aggregateRootStorage = aggregateRootStorage; _sendReplyService = sendReplyService; _queueMessage = queueMessage; _commandMessage = commandMessage; _messageContext = messageContext; }
private void AddMessageIdToMessageTracker(IMessageContext <AircraftLeftRunway> context) => _messageTracker.Ids.Add(context.MessageId);
public async Task <TagDTO[]> HandleAsync(IMessageContext context, GetTags query) { return((await _repository.GetTagsAsync(query.ApplicationId, query.IncidentId)).Select(ConvertTag).ToArray()); }
/// <summary> /// Handles a message that has failed processing /// </summary> /// <param name="message">The message.</param> /// <param name="context">The context.</param> /// <param name="exception">The exception.</param> public ReceiveMessagesErrorResult MessageFailedProcessing(IReceivedMessageInternal message, IMessageContext context, Exception exception) { //message failed to process if (context.MessageId == null || !context.MessageId.HasValue) { return(ReceiveMessagesErrorResult.NoActionPossible); } var info = _configuration.TransportConfiguration.RetryDelayBehavior.GetRetryAmount(exception); string exceptionType = null; if (info.ExceptionType != null) { exceptionType = info.ExceptionType.ToString(); } var bSendErrorQueue = false; if (string.IsNullOrEmpty(exceptionType) || info.MaxRetries <= 0) { bSendErrorQueue = true; } else { //determine how many times this exception has been seen for this message var metadata = _queryGetMetaData.Handle(new GetMetaDataQuery((RedisQueueId)context.MessageId)); var retries = metadata.ErrorTracking.GetExceptionCount(exceptionType); if (retries >= info.MaxRetries) { bSendErrorQueue = true; } else { context.Set(_headers.IncreaseQueueDelay, new RedisQueueDelay(info.Times[retries])); metadata.ErrorTracking.IncrementExceptionCount(exceptionType); _saveMetaData.Handle(new SaveMetaDataCommand((RedisQueueId)context.MessageId, metadata)); } } if (!bSendErrorQueue) { return(ReceiveMessagesErrorResult.Retry); } _commandMoveRecord.Handle( new MoveRecordToErrorQueueCommand <string>(exception, context.MessageId.Id.Value.ToString(), context)); //we are done doing any processing - remove the messageID to block other actions context.SetMessageAndHeaders(null, context.Headers); _log.LogError($"Message with ID {message.MessageId} has failed and has been moved to the error queue", exception); return(ReceiveMessagesErrorResult.Error); }
public static void Error(this IMessageContext context, string message) { context.Respond(new WriteToOutput(MessageType.Error, message)); }
public static void InfoFormat(this IMessageContext context, string message, params object[] args) { context.Respond(new WriteToOutput(MessageType.Info, string.Format(message, args))); }
public Task Handle(Envelope envelope, IMessageContext context) { return(context .Advanced .SendFailureAcknowledgement("I don't know how to process this message")); }
void RaiseMessageContextEstablished(IMessageContext messageContext) { events.RaiseMessageContextEstablished(this, messageContext); }
public MessageRepository(IMessageContext messageContext) { _context = messageContext; }
/// <summary> /// Rolls back the message associated to the context /// </summary> /// <param name="context"></param> /// <returns> /// true if the message was rolled back /// </returns> public bool Rollback(IMessageContext context) { context.RaiseRollback(); return(true); }
public static T GetStateData <T>(this IMessageContext messageContext, string key) where T : class { var stateDataKey = GetStateDataKey(key); return(messageContext.Get <T>(stateDataKey)); }
async Task IMessageHandler <B> .HandleMessage(B content, IMessageContext messageContext, CancellationToken cancellationToken) { await messageContext.SendReply("B", cancellationToken : cancellationToken); }
internal static void Set <T>(this IMessageContext messageContext, string key, T data) { messageContext.Headers[key] = SerializeToString(data); }
public Task Handle(Test command, IMessageContext context) => CompletedTask;
public Task SendAsync(IMessageContext messageContext, string queue, CancellationToken cancellationToken) { return(_producer.SendAsync(GetEQueueMessage(messageContext, queue), messageContext.Key, cancellationToken)); }
public Handler(IMessageContext messageContext, IBus bus, ManualResetEvent hasDeferredMessage) { _messageContext = messageContext; _bus = bus; _hasDeferredMessage = hasDeferredMessage; }
public MySaga(int targetMessageCount, IMessageContext messageContext, IBus bus) { _targetMessageCount = targetMessageCount; _messageContext = messageContext; _bus = bus; }
public void Dispose() { current = null; Disposed(); }
//made an interface 'context' so i can switch to any other context with those specified methods. public MessageRepository(IMessageContext context) { this.context = context; }
public SomeHandler(IMessageContext context) { this.context = context; }
public Task SendAsync(IMessageContext messageContext, string queue, CancellationToken cancellationToken) { return(Task.FromResult <object>(null)); }
public Task PublishAsync(IMessageContext messageContext, string topic, CancellationToken cancellationToken) { return(Task.FromResult <object>(null)); }