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