public static void ForwardUsingOriginalContext(this SendContext target, ConsumeContext source) { // target.SetRequestId(source.RequestId); // target.SetConversationId(source.ConversationId); // target.SetCorrelationId(source.CorrelationId); // target.SetSourceAddress(source.SourceAddress); // target.SetResponseAddress(source.ResponseAddress); // target.SetFaultAddress(source.FaultAddress); // target.SetNetwork(source.Network); // if (source.ExpirationTime.HasValue) // target.SetExpirationTime(source.ExpirationTime.Value); // target.SetRetryCount(source.RetryCount); // // foreach (var header in source.Headers) // target.SetHeader(header.Key, header.Value); // // string inputAddress = source.InputAddress != null // ? source.InputAddress.ToString() // : source.DestinationAddress != null // ? source.DestinationAddress.ToString() // : null; // // if (!string.IsNullOrEmpty(inputAddress)) // target.SetHeader("mt.forwarder.uri", source.DestinationAddress.ToString()); }
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 ICommand ParseMessage(ConsumeContext<IChat> message) { if (message == null) throw new ArgumentNullException(nameof(message)); var what = message.Message.What; if (IsCommand(what)) { //Regex for splitting a string using space when not surrounded by single or double quotes var regex = new Regex("[^\\s\"']+|\"[^\"]*\"|'[^']*'"); //MatchCollection var matches = regex.Matches(message.Message.What); var arr = Regex.Matches(message.Message.What, "[^\\s\"']+|\"[^\"]*\"|'[^']*'") .Cast<Match>() .Select(m => m.Value) .ToArray(); var command = arr[0]; var arguments = new List<Tuple<string, string>>(); string data = null; if (arr.Length > 1) { for (var i = 1; i < arr.Length; i++) { if (IsArgument(arr[i])) { var argument = arr[i]; string value = null; if (arr.Length >= i + 2) { value = arr[i + 1]; i++; } arguments.Add(new Tuple<string, string>(argument, value)); } else if (IsData(arr[i])) { data = arr[i]; } } } switch (command.ToLower()) { case "/message": return new MessageCommand(arguments, data); case "/who": return new WhoCommand(); default: throw new InvalidOperationException(command); } } else { return new ComputerMessageCommand(message.Message.What); } }
Task BeginWorkflow(ConsumeContext<IExampleEvent> exampleEvent) { return Task.Run(() => { var builder = new RoutingSlipBuilder(NewId.NextGuid()); builder.AddActivity(_exampleCourierActivity.ActivityName, _exampleCourierActivity.GetExecuteUri(), exampleEvent); RoutingSlip routingSlip = builder.Build(); _bus.Execute(routingSlip); }); }
public void CorrelatedMessageShouldFindTheCorrectSaga() { var repository = new MongoDbStateMachineSagaRepository<TestSaga>(this._db); var initiatePolicy = new InitiatingSagaPolicy<TestSaga, InitiateSimpleSaga>(x => x.CorrelationId, x => false); var message = new InitiateSimpleSaga(this._sagaId); var context = new ConsumeContext<InitiateSimpleSaga>(ReceiveContext.Empty(), message); repository.GetSaga(context, message.CorrelationId, this.GetHandlers, initiatePolicy).Each(x => x(context)); List<TestSaga> sagas = repository.ByCorrelationId(this._sagaId).ToList(); Assert.AreEqual(1, sagas.Count); Assert.IsNotNull(sagas[0]); Assert.AreEqual(this._sagaId, sagas[0].CorrelationId); }
public void A_correlated_message_should_find_the_correct_saga() { var repository = new RavenDbSagaRepository<TestSaga>(_store); var ping = new PingMessage(_sagaId); var initiatePolicy = new InitiatingSagaPolicy<TestSaga, InitiateSimpleSaga>(x => x.CorrelationId, x => false); var message = new InitiateSimpleSaga(_sagaId); IConsumeContext<InitiateSimpleSaga> context = new ConsumeContext<InitiateSimpleSaga>(ReceiveContext.Empty(), message); ; repository.GetSaga(context, message.CorrelationId, GetHandlers, initiatePolicy) .Each(x => x(context)); List<TestSaga> sagas = repository.Where(x => x.CorrelationId == _sagaId).ToList(); Assert.AreEqual(1, sagas.Count); Assert.IsNotNull(sagas[0]); Assert.AreEqual(_sagaId, sagas[0].CorrelationId); }
public async Task BookMeeting(ConsumeContext<BookMeeting> context) { var builder = new RoutingSlipBuilder(NewId.NextGuid()); builder.AddActivity(_settings.ReserveRoomActivityName, _settings.ReserveRoomExecuteAddress, new { ReservationApiKey = "secret" }); builder.AddActivity(_settings.FetchAvatarActivityName, _settings.FetchAvatarExecuteAddress); builder.SetVariables(new { context.Message.EmailAddress, context.Message.StartTime, context.Message.Duration, context.Message.RoomCapacity }); var routingSlip = builder.Build(); await context.Execute(routingSlip); }
public Task Consume(ConsumeContext <PingMessage> context) { return(TaskUtil.Completed); }
static ConsumeContext <TMessage> MergeContext(ConsumeContext <TMessage> input, ConsumeContext context) { var result = context as ConsumeContext <TMessage>; return(result ?? new MessageConsumeContext <TMessage>(context, input.Message)); }
protected override async Task <SkillLevelItem> DoExecute(SkillLevelChangeActiveContract message, ConsumeContext <SkillLevelChangeActiveContract> context) { var found = await _repository.DiscoverAsync(message.ToUpdate); found.IsActive = message.IsActive.Value; await _repository.Update(found); return(_mapper.Map <SkillLevelItem>(found)); }
public MassTransitFutureConsumeContext(BehaviorContext <FutureState> context, ConsumeContext consumeContext, TMessage message) : base(context, consumeContext) { Message = message; }
public Task Consume(ConsumeContext <BrxzUpdatedMessage> context) { throw new NotImplementedException(); }
public Task ConsumeFault(ConsumeContext <T> context, Exception exception) { return(ForEachAsync(x => x.ConsumeFault(context, exception))); }
public async Task NotifyConsumed <T>(ConsumeContext <T> context, TimeSpan duration, string consumerType) where T : class { }
public bool TryGetMessage <T>(out ConsumeContext <T> consumeContext) where T : class { consumeContext = this as ConsumeContext <T>; return(consumeContext != null); }
public Task Consume(ConsumeContext <Message> context) { Console.WriteLine($"Receive message value: {context.Message.Value}"); return(Task.CompletedTask); }
public Task Consume(ConsumeContext <ShipmentRegistered> context) { logger.LogDebug($"Shipment was registered: {context.Message.ShipmentId}"); return(Task.CompletedTask); }
/// <summary> /// 消费Hello集成事件 /// </summary> /// <param name="context">消费上下文</param> /// <returns>任务</returns> public async Task Consume(ConsumeContext <IHelloIntegrationEvent> context) { await Console.Out.WriteLineAsync($"Hello1消费了Hello集成事件:{context.Message.Text}"); }
public async Task Consume(ConsumeContext <TestSomeActionExecuted> context) { await Console.Out.WriteLineAsync($"Received: ID={context.Message.Id}, Msg='{context.Message.Message}', {context.Message.CreatedDate}, {@context.DestinationAddress.PathAndQuery}"); }
private static Task Handler(ConsumeContext<DriveToOrder> context) { return Handler(context.Message); }
private static Task Handler(ConsumeContext<Person> context) { return Handler(context.Message); }
public async Task NotifyFaulted <T>(ConsumeContext <T> context, TimeSpan duration, string consumerType, Exception exception) where T : class { }
public Task Consume(ConsumeContext <C> context) { return(TaskUtil.Completed); }
public Task Consume(ConsumeContext <CancelOrder> context) { return(_handler.HandleAsync(context.Message)); }
public Task Consume(ConsumeContext <TestMessage> context) { Console.WriteLine($"Received {context.Message.Text}"); return(Task.FromResult(0)); }
public PublishTestStartedActivity(ConsumeContext context) { _context = context; }
public Task Consume(ConsumeContext <TestMessage> context) { _semaphore.Release(); _onMessage(context.Message); return(Task.CompletedTask); }
public async Task Consume(ConsumeContext <Fault <ISimpleMessage> > context) { logger.LogInformation("Exception: {0}", context.Message.Exceptions.First().ExceptionType); }
public async Task Consume(ConsumeContext <T> context) { await Handle(new MessageContext <T>(context.Message, context.CorrelationId?.ToString())); }
public Task Consume(ConsumeContext <IAlgortihmsInfo> ctx) { _numberOfTasks++; Console.WriteLine("Number of task = " + _numberOfTasks); var bestTspRes = new TspResult(); var tspDataFilePath = ctx.Message.TspDataFilePath; var dataModel = new DataModel(tspDataFilePath); double bestDistance = Double.MaxValue; List <Location> tempTour = new List <Location>(dataModel.Data); List <Location> tempTourSec = new List <Location>(dataModel.Data); double tempDistance = 0; int counter = 0; var phaseFirstTimeInSeconds = ctx.Message.PhaseFirstTimeInSeconds; var phaseSecTimeInSeconds = ctx.Message.PhaseSecTimeInSeconds; tempTour.Shuffle(); // first parent tempTourSec.Shuffle(); // sec parent Stopwatch sw = new Stopwatch(); sw.Start(); while (sw.Elapsed.TotalSeconds < phaseFirstTimeInSeconds) { counter++; if (counter % 2 == 0) { tempTour.Shuffle(); if ((tempDistance = Utils.DistanceSum(tempTour)) < bestDistance) { bestTspRes.BestTour = new List <Location>(tempTour); bestDistance = tempDistance; RespondResults(ctx, bestTspRes.BestTour, bestDistance, counter); } } else { tempTourSec.Shuffle(); if ((tempDistance = Utils.DistanceSum(tempTourSec)) < bestDistance) { bestTspRes.BestTour = new List <Location>(tempTourSec); bestDistance = tempDistance; RespondResults(ctx, bestTspRes.BestTour, bestDistance, counter); } } } Console.WriteLine("Second stage started ..."); sw.Restart(); while (sw.Elapsed.TotalSeconds < phaseSecTimeInSeconds) { counter++; tempTour.SwapEdges(); if ((tempDistance = Utils.DistanceSum(tempTour)) < bestDistance) { bestTspRes.BestTour = new List <Location>(tempTour); bestDistance = tempDistance; RespondResults(ctx, bestTspRes.BestTour, bestDistance, counter); } } Console.WriteLine("the shortest found traveling salesman route:"); Console.WriteLine("Distance = " + bestDistance); Console.WriteLine("Solution Count = " + counter); Console.WriteLine("Task ID = " + ctx.Message.TaskId); RespondResults(ctx, bestTspRes.BestTour, bestDistance, counter); return(Task.FromResult(0)); }
public Task Consume(ConsumeContext <PingMessage> context) { throw new ConsumerException("Consumer always throws!"); }
public async Task Consume(ConsumeContext <IGuildSubscribedByUser> context) { await _hubContext.Groups.AddToGroupAsync(context.Message.ConnectionId, context.Message.GuildId.ToString()); }
public async Task Consume(ConsumeContext<AnotherMessageInterface> context) { _last = context.Message; _received.Set(); }
public ExecutePubmedSearchCommandActivity(ConsumeContext consumeContext, MessageBusConfig busConfig) { _consumeContext = consumeContext; _busConfig = busConfig; }
public void ShouldStartNewProcessManagerWithConsumerContext() { // Arrange _mockContainer.Setup(x => x.GetHandlerTypes(typeof(IMessageHandler<FakeMessage1>))).Returns(new List<HandlerReference> { new HandlerReference { HandlerType = typeof(FakeProcessManager1), MessageType = typeof(FakeMessage1) } }); _mockContainer.Setup(x => x.GetHandlerTypes(typeof(IStartProcessManager<FakeMessage1>))).Returns(new List<HandlerReference> { new HandlerReference { HandlerType = typeof(FakeProcessManager1), MessageType = typeof(FakeMessage1) } }); var processManager = new FakeProcessManager1(); _mockContainer.Setup(x => x.GetInstance(typeof(FakeProcessManager1))).Returns(processManager); var data = new FakeProcessManagerData { User = "******" }; var mockPersistanceData = new Mock<IPersistanceData<FakeProcessManagerData>>(); mockPersistanceData.Setup(x => x.Data).Returns(data); _mockProcessManagerFinder.Setup(x => x.FindData<FakeProcessManagerData>(It.IsAny<IProcessManagerPropertyMapper>(), It.IsAny<Message>())).Returns(mockPersistanceData.Object); var processManagerProcessor = new ProcessManagerProcessor(_mockProcessManagerFinder.Object, _mockContainer.Object); var context = new ConsumeContext(); // Act processManagerProcessor.ProcessMessage<FakeMessage1>(JsonConvert.SerializeObject(new FakeMessage1(Guid.NewGuid()) { Username = "******" }), context); // Assert // Data.User is set by the ProcessManagers Execute method Assert.Equal(context, processManager.Context); }
public EventCorrelationExpressionConverter(ConsumeContext <TMessage> context) { _context = context; }
async Task Handle(ConsumeContext<A> context) { }
public async Task Should_have_published_the_job_completed_event() { ConsumeContext <JobCompleted> completed = await _completed; }
public Task Consume(ConsumeContext <SomethingHappened> context) { Console.WriteLine("Consumed the message."); return(Task.FromResult(0)); }
public Task PostConsume(ConsumeContext <T> context) { return(ForEachAsync(x => x.PostConsume(context))); }
public void ShouldStartExistingProcessManagerWithConsumerContext() { // Arrange var id = Guid.NewGuid(); var message = new FakeMessage2(id) { Email = "*****@*****.**" }; var data = new FakeProcessManagerData { User = "******" }; var mockPersistanceData = new Mock<IPersistanceData<FakeProcessManagerData>>(); mockPersistanceData.Setup(x => x.Data).Returns(data); _mockContainer.Setup(x => x.GetHandlerTypes(typeof(IMessageHandler<FakeMessage2>))).Returns(new List<HandlerReference> { new HandlerReference { HandlerType = typeof(FakeProcessManager1), MessageType = typeof(FakeMessage2) } }); var processManager = new FakeProcessManager1(); _mockContainer.Setup(x => x.GetInstance(typeof(FakeProcessManager1))).Returns(processManager); _mockProcessManagerFinder.Setup(x => x.FindData<FakeProcessManagerData>(It.IsAny<ProcessManagerPropertyMapper>(), It.Is<FakeMessage2>(m => m.CorrelationId == id))).Returns(mockPersistanceData.Object); var processManagerProcessor = new ProcessManagerProcessor(_mockProcessManagerFinder.Object, _mockContainer.Object); var context = new ConsumeContext(); // Act processManagerProcessor.ProcessMessage<FakeMessage2>(JsonConvert.SerializeObject(message), context); // Assert Assert.Equal(context, processManager.Context); }
public Task Send(ConsumeContext <T> context, IPipe <ConsumeContext <T> > next) { _validator.Validate(context.Message); return(next.Send(context)); }
protected override void ConfigureInputQueueEndpoint(IInMemoryReceiveEndpointConfigurator configurator) { _count = 0; configurator.Handler<Interval>(async context => { Interlocked.Increment(ref _count); _lastInterval = context; }); _done = Handled<Done>(configurator); _doneAgain = Handled<DoneAgain>(configurator); }
public async Task Consume(ConsumeContext <A> context) { await context.RespondAsync(new B { Success = true }); }