internal InMemoryMessageBusConfiguration(IMessageBusConfiguration configuration, PendingOperations pendingOperations)
{
Arg.NotNull(configuration, nameof(configuration));
Arg.NotNull(pendingOperations, nameof(pendingOperations));
inner = configuration;
PendingOperations = pendingOperations;
}
/// <summary>
/// Initializes a new instance of the <see cref="InMemoryMessageSender"/> class.
/// </summary>
/// <param name="observer">The <see cref="IObserver{T}">observer</see> that receives sent messages.</param>
/// <param name="pendingOperations">The object used to track <see cref="PendingOperations">pending operations</see>.</param>
public InMemoryMessageSender(IObserver <IMessageDescriptor> observer, PendingOperations pendingOperations)
{
Arg.NotNull(observer, nameof(observer));
Arg.NotNull(pendingOperations, nameof(pendingOperations));
Observer = observer;
PendingOperations = pendingOperations;
}
protected override void OnOperationFound(FileSystemOperation operation)
{
PendingOperations.Add(new OperationItem(operation));
if (ShouldUpdate())
{
RequestUpdate();
}
}
public MessageFilter(
IObserver <IMessageDescriptor> inner,
PendingOperations pendingOperations,
IClock clock,
ICollection <IMessageDescriptor> ignoredMessages)
{
this.inner = inner;
this.pendingOperations = pendingOperations;
this.clock = clock;
this.ignoredMessages = ignoredMessages;
}
public bool TryLightNext()
{
LightingOperation op;
lock (_Lock)
{
if (PendingOperations.Count == 0)
{
return(false);
}
op = PendingOperations[0];
PendingOperations.RemoveAt(0);
}
LightBox(op);
return(true);
}
public void EnqueueOperation(BoundingBox box, bool skyLight, bool initial = false)
{
lock (_Lock)
{
// Try to merge with existing operation
for (int i = PendingOperations.Count - 1; i > PendingOperations.Count - 5 && i > 0; i--)
{
var op = PendingOperations[i];
if (op.Box.Intersects(box))
{
op.Box = new BoundingBox(Vector3.Min(op.Box.Min, box.Min), Vector3.Max(op.Box.Max, box.Max));
return;
}
}
PendingOperations.Add(new LightingOperation {
SkyLight = skyLight, Box = box, Initial = initial
});
}
}
public void EnqueueOperation(BoundingBox box, bool skyLight, bool initial = false)
{
// Try to merge with existing operation
/*
* for (int i = PendingOperations.Count - 1; i > PendingOperations.Count - 5 && i > 0; i--)
* {
* var op = PendingOperations[i];
* if (op.Box.Intersects(box))
* {
* op.Box = new BoundingBox(Vector3.Min(op.Box.Min, box.Min), Vector3.Max(op.Box.Max, box.Max));
* return;
* }
* }
*/
PendingOperations.Enqueue(new LightingOperation {
SkyLight = skyLight, Box = box, Initial = initial
});
}
protected ScenarioTest(ITestOutputHelper output)
{
this.output = output;
var ignoredMessages = new List <IMessageDescriptor>();
var pendingOperations = new PendingOperations();
IgnoredMessages = ignoredMessages;
var container = CreateContainer(pendingOperations, ignoredMessages);
var configuration = new MessageBusConfigurationBuilder().HasServiceProvider(container).CreateConfiguration();
Bus = new InMemoryMessageBus(configuration, pendingOperations);
Setup = new ScenarioBuilder(Bus);
RegisterCommandHandlers(configuration);
RegisterEventReceivers(configuration);
RegisterSagas(configuration);
Bus.Start(new MessageObserver(output));
}
ServiceContainer CreateContainer(PendingOperations pendingOperations, ICollection <IMessageDescriptor> ignoredMessages)
{
var container = new ServiceContainer();
container.AddService(typeof(MessageFilter), (sc, t) => new MessageFilter((IObserver <IMessageDescriptor>)sc.GetRequiredService <IMessageReceiver>(), pendingOperations, Clock, ignoredMessages));
container.AddService(typeof(IClock), (sc, t) => Clock);
container.AddService(typeof(IMessageSender), (sc, t) => new InMemoryMessageSender(sc.GetRequiredService <MessageFilter>(), pendingOperations));
container.AddService(typeof(IMessageReceiver), (sc, t) => new InMemoryMessageReceiver());
container.AddService(typeof(IStoreSagaData), (sc, t) => new InMemorySagaStorage());
container.AddService(typeof(IMapPersistence), OnMapPersistence);
container.AddService(typeof(IEventStore <string>), (sc, t) => new InMemoryEventStore <string>(sc.GetRequiredService <IMapPersistence>().Map(nameof(Token))));
container.AddService(typeof(IRepository <string, Token>), (sc, t) => new Repository <string, Token>(sc.GetRequiredService <IEventStore <string> >()));
container.AddService(typeof(ITokenSecurity), (sc, t) => new TokenSecurity());
container.AddService(typeof(ITokenVault), (sc, t) => new TokenVault(sc.GetRequiredService <IRepository <string, Token> >(), Tokens));
container.AddService(typeof(ISaga <MintRequestData>), (sc, t) => new MintRequest());
container.AddService(typeof(ISaga <OrderData>), (sc, t) => new Order());
container.AddService(typeof(SagaMetadataCollection), (sc, t) => new SagaMetadataCollection(new[] { typeof(MintRequest), typeof(Order), typeof(PrintJob) }));
return(container);
}
public bool TryLightNext()
{
LightingOperation op;
if (PendingOperations.Count == 0)
{
return(false);
}
// TODO: Maybe a timeout or something?
bool dequeued = false;
while (!(dequeued = PendingOperations.TryDequeue(out op)) && PendingOperations.Count > 0)
{
;
}
if (dequeued)
{
LightBox(op);
}
return(dequeued);
}
public void Init()
{
_lastUpdate = DateTime.MinValue;
PendingOperations.Clear();
PendingErrors.Clear();
}
