public static void Run()
{
var clusterVNode = EmbeddedVNodeBuilder
.AsSingleNode()
.RunInMemory()
.WithWorkerThreads(1)
.Build();
clusterVNode.StartAsync(true).Wait();
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Information()
.MinimumLevel.Override("Microsoft", LogEventLevel.Debug)
.WriteTo.Console()
.CreateLogger();
var loggerFactory = new LoggerFactory().AddSerilog(Log.Logger);
var eventTypeProvider = new DefaultEventTypeProvider <EventCountAggregate>(() => new[] { typeof(EventCountOne), typeof(EventCountTwo) });;
var eventCountActor = EventStoreEmbeddedStatefulActorBuilder <EventCountStatefulActor, EventCountAggregate, DemoSystemRegistry>
.Create(clusterVNode, Do.GetConnectionSettings(), ActorConfiguration.Default, loggerFactory)
.WithReadAllFromStartCache(
eventTypeProvider: eventTypeProvider,
getCatchupEventStoreCacheConfigurationBuilder: builder => builder.KeepAppliedEventsOnAggregate = true)
.Build();
Do.Run(eventCountActor);
}
public void ConfigureServices(IServiceCollection services)
{
var eventTypeProvider = new DefaultEventTypeProvider <SomeDataAggregate>(() => new[] { typeof(SomeData) });
services.AddSingleton <IEventStoreBus, EventStoreBus>();
services.AddWorld(TestHealthChecksMvcTestBed.TestBed.ClusterVNode, TestHealthChecksMvcTestBed.TestBed.ConnectionSettings)
.AddEventStoreStatefulActor <TestStatefulActorOneMvc, SomeDataAggregate>(ActorConfiguration.Default)
.WithReadAllFromStartCache(
catchupEventStoreCacheConfigurationBuilder: (configuration) => configuration.KeepAppliedEventsOnAggregate = true,
eventTypeProvider: eventTypeProvider)
.WithBus <IEventStoreBus>((actor, bus) => actor.SubscribeFromEndToAllStreams())
.CreateActor()
.AddEventStoreStatefulActor <TestBusRegistrationStatefullActor, SomeDataAggregate>(ActorConfiguration.Default)
.WithReadAllFromStartCache(
catchupEventStoreCacheConfigurationBuilder: (configuration) => configuration.KeepAppliedEventsOnAggregate = true,
eventTypeProvider: eventTypeProvider)
.WithBus <IEventStoreBus>((actor, bus) => actor.SubscribeFromEndToAllStreams())
.CreateActor()
.AddStatelessActor <TestStatelessActorOneMvc>(ActorConfiguration.Default)
.WithBus <IEventStoreBus>((actor, bus) => actor.SubscribeFromEndToAllStreams())
.CreateActor();
}
public static void Run()
{
var eventTypeProvider = new DefaultEventTypeProvider <EventCountAggregate>(() => new[] { typeof(EventCountOne), typeof(EventCountTwo) });;
var fileSystemSnapshotProvider = new FileSystemSnapshotProvider <EventCountAggregate>();
var defaultSnapshotStrategy = new DefaultSnapshotStrategy(5);
var eventCountActorWithSnapshot = EventStoreStatefulActorBuilder <EventCountStatefulActor, EventCountAggregate, DemoSystemRegistry>
.Create(StaticData.EventStoreUrl, Do.GetConnectionSettings(), ActorConfiguration.Default)
.WithReadOneStreamFromStartCache(StaticData.EntityOne,
eventTypeProvider: eventTypeProvider,
getMultipleStreamsCatchupCacheConfiguration: builder =>
{
builder.KeepAppliedEventsOnAggregate = true;
},
snapshotStore: fileSystemSnapshotProvider,
snapshotStrategy: defaultSnapshotStrategy)
.Build();
var eventCountActor = EventStoreStatefulActorBuilder <EventCountStatefulActor, EventCountAggregate, DemoSystemRegistry>
.Create(StaticData.EventStoreUrl, Do.GetConnectionSettings(), ActorConfiguration.Default)
.WithReadOneStreamFromStartCache(StaticData.EntityOne,
eventTypeProvider: eventTypeProvider,
getMultipleStreamsCatchupCacheConfiguration: builder =>
{
builder.KeepAppliedEventsOnAggregate = true;
})
.Build();
Do.Run(eventCountActor, eventCountActorWithSnapshot);
}
public static void Run()
{
var eventTypeProvider = new DefaultEventTypeProvider <EventCountAggregate>(() => new[] { typeof(EventCountOne), typeof(EventCountTwo) });;
var eventCountActor = EventStoreStatefulActorBuilder <EventCountStatefulActor, EventCountAggregate, DemoSystemRegistry>
.Create(StaticData.EventStoreUrl, Do.GetConnectionSettings(), ActorConfiguration.Default)
.WithReadManyStreamsFromStartCache(
new[] { StaticData.EntityOne, StaticData.EntityTwo, StaticData.EntityThree },
eventTypeProvider: eventTypeProvider,
getMultipleStreamsCatchupCacheConfiguration: builder => builder.KeepAppliedEventsOnAggregate = true)
.Build();
Do.Run(eventCountActor);
}
public async Task ShouldRunAnIntegrationScenario()
{
var url = new Uri("tcp://*****:*****@localhost:1113");
var userCredentials = new UserCredentials("admin", "changeit");
var connectionSettings = ConnectionSettings.Create()
.UseDebugLogger()
.DisableTls()
.SetDefaultUserCredentials(userCredentials)
.KeepRetrying()
.Build();
var defaultEventTypeProvider = new DefaultEventTypeProvider <CurrencyPair>(() => new[] { typeof(CurrencyPairPriceChanged), typeof(CurrencyPairStateChanged) });
var traderOne = EventStoreStatefulActorBuilder <Trader, CurrencyPair, TestRegistry> .Create(url, connectionSettings, ActorConfiguration.Default)
.WithReadAllFromStartCache(eventTypeProvider: defaultEventTypeProvider,
getCatchupEventStoreCacheConfigurationBuilder: (configuration) => configuration.KeepAppliedEventsOnAggregate = true)
.Build();
await Task.Delay(2000);
Assert.IsTrue(traderOne.State.IsConnected);
var traderTwo = EventStoreStatefulActorBuilder <Trader, CurrencyPair, TestRegistry> .Create(url, connectionSettings, ActorConfiguration.Default)
.WithReadAllFromStartCache(eventTypeProvider: defaultEventTypeProvider,
getCatchupEventStoreCacheConfigurationBuilder: (configuration) => configuration.KeepAppliedEventsOnAggregate = true)
.Build();
await Task.Delay(500);
Assert.IsTrue(traderTwo.State.IsConnected);
await Task.Delay(4000);
var eurodolOne = traderOne.State.GetCurrent("EUR/USD");
var eurodolTwo = traderTwo.State.GetCurrent("EUR/USD");
var chunnelOne = traderOne.State.GetCurrent("EUR/GBP");
var chunnelTwo = traderTwo.State.GetCurrent("EUR/GBP");
Assert.Greater(eurodolOne.AppliedEvents.Length, 0);
Assert.Greater(eurodolTwo.AppliedEvents.Length, 0);
Assert.Greater(chunnelOne.AppliedEvents.Length, 0);
Assert.Greater(chunnelTwo.AppliedEvents.Length, 0);
}
public static void Run()
{
var clusterVNode = EmbeddedVNodeBuilder
.AsSingleNode()
.RunInMemory()
.WithWorkerThreads(1)
.Build();
clusterVNode.StartAsync(true).Wait();
var eventTypeProvider = new DefaultEventTypeProvider <EventCountAggregate>(() => new[] { typeof(EventCountOne), typeof(EventCountTwo) });;
var eventCountActor = EventStoreEmbeddedStatefulActorBuilder <EventCountStatefulActor, EventCountAggregate, DemoSystemRegistry>
.Create(clusterVNode, Do.GetConnectionSettings(), ActorConfiguration.Default)
.WithReadAllFromEndCache(
eventTypeProvider: eventTypeProvider,
getSubscribeFromEndCacheConfiguration: builder => builder.KeepAppliedEventsOnAggregate = true)
.Build();
Do.Run(eventCountActor);
}
static void Main(string[] _)
{
{
WebAppBuilder.Create <Program>(
configureServiceCollection: (anabasisContext, serviceCollection, configurationRoot) =>
{
var connectionSettings = ConnectionSettings
.Create()
.DisableTls()
.DisableServerCertificateValidation()
.EnableVerboseLogging()
.UseDebugLogger()
.KeepReconnecting()
.KeepRetrying()
.SetDefaultUserCredentials(StaticData.UserCredentials);
var tradeDataEventProvider = new DefaultEventTypeProvider <Trade>(() => new[] { typeof(TradeCreated), typeof(TradeStatusChanged) });
var marketDataEventProvider = new DefaultEventTypeProvider <MarketData>(() => new[] { typeof(MarketDataChanged) });
serviceCollection.AddSingleton <IMarketDataBus, MarketDataBus>();
serviceCollection.AddSingleton <IEventStoreBus, EventStoreBus>();
serviceCollection.AddWorld("ConnectTo=tcp://admin:changeit@localhost:1113; HeartBeatTimeout=1500; VerboseLogging=false; OperationTimeout=60000; UseSslConnection=false;", connectionSettings)
.AddStatelessActor <TradeService>(ActorConfiguration.Default)
.WithBus <IEventStoreBus>((actor, bus) =>
{
actor.SubscribeFromEndToAllStreams();
})
.CreateActor()
.AddEventStoreStatefulActor <TradePriceUpdateService, Trade>(ActorConfiguration.Default)
.WithReadAllFromStartCache(eventTypeProvider: tradeDataEventProvider)
.WithBus <IEventStoreBus>((actor, bus) =>
{
actor.SubscribeFromEndToAllStreams();
})
.WithBus <IMarketDataBus>((actor, bus) =>
{
actor.SubscribeMarketDataBus();
})
.CreateActor()
.AddEventStoreStatefulActor <TradeSink, Trade>(ActorConfiguration.Default)
.WithReadAllFromStartCache(eventTypeProvider: tradeDataEventProvider)
.CreateActor()
.AddStatelessActor <MarketDataSink>(ActorConfiguration.Default)
.WithBus <IMarketDataBus>((actor, bus) =>
{
actor.SubscribeMarketDataBus();
})
.CreateActor();
serviceCollection.AddHostedService <HostedService>();
},
configureApplicationBuilder: (anabasisContext, app) =>
{
app.UseWorld();
})
.Build()
.Run();
}
}
static void Main(string[] args)
{
//var dispatchQueue = new DispatchQueue<int>(new DispatchQueueConfiguration<int>((i=>
//{
// throw new Exception("boom");
//}),1,1));
//dispatchQueue.Enqueue(1);
Task.Run(() =>
{
var connectionSettings = StaticData.GetConnectionSettings();
var tradeDataEventProvider = new DefaultEventTypeProvider <Trade>(() => new[] { typeof(TradeCreated), typeof(TradeStatusChanged) });
var marketDataEventProvider = new DefaultEventTypeProvider <MarketData>(() => new[] { typeof(MarketDataChanged) });
var tradeService = EventStoreEmbeddedStatelessActorBuilder <TradeService, DemoSystemRegistry>
.Create(StaticData.ClusterVNode, connectionSettings, ActorConfiguration.Default)
.WithBus <IEventStoreBus>((actor, bus) =>
{
actor.SubscribeFromEndToAllStreams();
})
.Build();
var tradePriceUpdateService = EventStoreEmbeddedStatefulActorBuilder <TradePriceUpdateService, Trade, DemoSystemRegistry>
.Create(StaticData.ClusterVNode, connectionSettings, ActorConfiguration.Default)
.WithReadAllFromStartCache(eventTypeProvider: tradeDataEventProvider)
.WithBus <IEventStoreBus>((actor, bus) =>
{
actor.SubscribeFromEndToAllStreams();
})
.WithBus <IMarketDataBus>((actor, bus) =>
{
actor.SubscribeMarketDataBus();
})
.Build();
var tradeSink = EventStoreEmbeddedStatefulActorBuilder <TradeSink, Trade, DemoSystemRegistry>
.Create(StaticData.ClusterVNode, connectionSettings, ActorConfiguration.Default)
.WithReadAllFromStartCache(eventTypeProvider: tradeDataEventProvider)
.Build();
var marketDataSink = StatelessActorBuilder <MarketDataSink, DemoSystemRegistry>
.Create(ActorConfiguration.Default)
.WithBus <IMarketDataBus>((actor, bus) =>
{
actor.SubscribeMarketDataBus();
})
.Build();
var marketDataCache = marketDataSink.CurrentPrices.Connect();
var tradeCache = tradeSink.State.AsObservableCache().Connect();
tradeCache.PrintTradeChanges();
marketDataCache.PrintMarketDataChanges();
});
Console.Read();
}
public async Task ShouldBuildFromActorBuilderAndRunActors()
{
var defaultEventTypeProvider = new DefaultEventTypeProvider <SomeDataAggregate>(() => new[] { typeof(SomeData) });
var testActorAutoBuildOne = EventStoreEmbeddedStatefulActorBuilder <TestStatefulActorOne, SomeDataAggregate, SomeRegistry> .Create(_clusterVNode, _connectionSettings, ActorConfiguration.Default, _loggerFactory)
.WithReadAllFromStartCache(
getCatchupEventStoreCacheConfigurationBuilder: (conf) => conf.KeepAppliedEventsOnAggregate = true,
eventTypeProvider: new DefaultEventTypeProvider <SomeDataAggregate>(() => new[] { typeof(SomeData) }))
.WithBus <IEventStoreBus>((actor, bus) =>
{
actor.SubscribeFromEndToAllStreams();
actor.SubscribeToPersistentSubscriptionStream(_streamId2, _groupIdOne);
})
.Build();
var testActorAutoBuildTwo = EventStoreEmbeddedStatefulActorBuilder <TestAggregatedActorTwo, SomeDataAggregate, SomeRegistry> .Create(_clusterVNode, _connectionSettings, ActorConfiguration.Default, _loggerFactory)
.WithReadAllFromStartCache(
getCatchupEventStoreCacheConfigurationBuilder: (conf) => conf.KeepAppliedEventsOnAggregate = true,
eventTypeProvider: new DefaultEventTypeProvider <SomeDataAggregate>(() => new[] { typeof(SomeData) }))
.WithBus <IEventStoreBus>((actor, bus) =>
{
actor.SubscribeFromEndToAllStreams();
})
.Build();
await testActorAutoBuildTwo.EmitEventStore(new SomeMoreData(_correlationId, "some-stream"));
await Task.Delay(1000);
Assert.AreEqual(1, testActorAutoBuildOne.Events.Count);
await testActorAutoBuildTwo.EmitEventStore(new SomeMoreData(_correlationId, _streamId2));
await Task.Delay(1500);
Assert.AreEqual(3, testActorAutoBuildOne.Events.Count);
var aggregateOne = Guid.NewGuid();
var aggregateTwo = Guid.NewGuid();
await testActorAutoBuildOne.EmitEventStore(new SomeData($"{aggregateOne}", _correlationId));
await testActorAutoBuildOne.EmitEventStore(new SomeData($"{aggregateTwo}", _correlationId));
await Task.Delay(500);
Assert.AreEqual(2, testActorAutoBuildOne.State.GetCurrents().Length);
Assert.AreEqual(2, testActorAutoBuildTwo.State.GetCurrents().Length);
Assert.AreEqual(1, testActorAutoBuildOne.State.GetCurrent($"{aggregateOne}").AppliedEvents.Length);
Assert.AreEqual(1, testActorAutoBuildTwo.State.GetCurrent($"{aggregateTwo}").AppliedEvents.Length);
await testActorAutoBuildOne.EmitEventStore(new SomeData($"{aggregateOne}", _correlationId));
await testActorAutoBuildOne.EmitEventStore(new SomeData($"{aggregateTwo}", _correlationId));
await Task.Delay(1000);
Assert.AreEqual(2, testActorAutoBuildOne.State.GetCurrents().Length);
Assert.AreEqual(2, testActorAutoBuildTwo.State.GetCurrents().Length);
Assert.AreEqual(2, testActorAutoBuildOne.State.GetCurrent($"{aggregateOne}").AppliedEvents.Length);
Assert.AreEqual(2, testActorAutoBuildTwo.State.GetCurrent($"{aggregateTwo}").AppliedEvents.Length);
testActorAutoBuildOne.Dispose();
testActorAutoBuildTwo.Dispose();
}
