public void SqlEventStore_Deserializes_Events()
{
var id = Guid.NewGuid();
var events = new List <EventStream>
{
new EventStream
{
AggregateRootId = id,
DateCreated = DateTime.Now,
EventData = Resources.JsonSerializedDebitEvent,
Id = 1,
SequenceStart = 2,
SequenceEnd = 2
},
new EventStream
{
AggregateRootId = id,
DateCreated = DateTime.Now,
EventData = Resources.JsonSerializedNewAccountEvent,
Id = 1,
SequenceStart = 1,
SequenceEnd = 1
}
};
var database = new Mock <ISqlRepository>();
database.Setup(db => db.GetEventStream(It.IsAny <Guid>(), It.IsAny <long>())).Returns(events);
var store = new SqlEventStore
{
GetRepository = () => database.Object
};
var eventStream = store.GetEvents(id, 1).ToList();
Assert.AreEqual(2, eventStream.Count());
Assert.AreEqual(1, eventStream[0].Sequence);
Assert.AreEqual(2, eventStream[1].Sequence);
Assert.IsInstanceOf <AccountCreatedEvent>(eventStream[0]);
Assert.IsInstanceOf <AccountDebitedEvent>(eventStream[1]);
}
public void be_reidrated_from_database()
{
var eventStore = new SqlEventStore(new DomainEventJsonEventSerializer(), new FakeEventStamping());
var eventBus = new EventBus(new EventDispatcher(), eventStore);
var createdStagiaire = Student.Create("BOUDOUX", "Aurelien");
eventBus.Publish(createdStagiaire.UncommitedEvents);
var studentId = createdStagiaire.AggregateId;
var events = eventStore.GetEvents(studentId);
var student = new Student(new History(events));
student.Update("BOUDOUX", "Aurélien");
eventBus.Publish(student.UncommitedEvents);
var student1 = new Student(new History(eventStore.GetEvents(studentId)));
student1.Update("BOUDOUX", "Aurélien");
student1.UncommitedEvents.GetStream().Should().BeEmpty();
}
public static async Task Main(string[] args)
{
JsonSerializerSettings _jsonSerializerSettings = new JsonSerializerSettings()
{
TypeNameHandling = TypeNameHandling.All,
NullValueHandling = NullValueHandling.Ignore
};
string exchangeName = "CustomerManagement";
var eventRepository = new SqlEventStore();
DateTime fromDateTime = DateTime.Now.AddDays(-100);
var factory = new ConnectionFactory()
{
HostName = "10.100.8.67", Port = 5672, UserName = "******", Password = "******"
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.ExchangeDeclare(exchange: exchangeName, type: ExchangeType.Fanout);
do
{
var events = await eventRepository.GetAll(fromDateTime);
if (events?.Any() == true)
{
fromDateTime = events.Last().CreatedAt;
}
foreach (var item in events)
{
var domainEvent = JsonConvert.DeserializeObject(item.Data, _jsonSerializerSettings);
var body = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(domainEvent));
channel.BasicPublish(exchange: exchangeName,
routingKey: item.Name,
basicProperties: null,
body: body);
}
System.Threading.Thread.Sleep(1000);
} while (true);
}
}
private static async Task AppendBenchmark2Async(Func <ISqlEventStore, ISqlEventStore> configuration, int batchSize, TimeSpan timeout)
{
using (var db = new SqlLocalDB())
{
var es = new SqlEventStore(db.ConnectionString);
await es.Database.InitializeAsync();
var list = new List <UncommittedEvent>();
var sw = new Stopwatch();
var es2 = configuration(es);
int n = 0;
foreach (var e in GetUncommittedSource(1000, 100000))
{
list.Add(e);
if (!(list.Count < batchSize))
{
var batch = list.ToArray();
n += batch.Length;
list.Clear();
sw.Start();
await es2.AppendAsync(batch);
sw.Stop();
if (!(sw.Elapsed < timeout))
{
break;
}
}
}
Console.WriteLine($"{n / sw.Elapsed.TotalSeconds:N1} op/s");
}
}
public static void Run(string connStr)
{
IMessageSender sender = new SqlMessageSender(connStr, "dbo.messages");
ITextSerializer serializer = new JsonTextSerializer();
IEventStore eventStore = new SqlEventStore(connStr, "dbo.events");
IEventBus eventBus = new EventBus(sender, serializer);
IMetadataProvider metaProvider = new StandardMetadataProvider();
IEventSourcedRepository <AppointmentAggregate> repo = new
EventSourcedRepository <AppointmentAggregate>(eventStore, eventBus, serializer, metaProvider);
ICommandDispatcher cmdDispatcher = new CommandDispatcher();
cmdDispatcher.Register(new AppointmentCommandHandler(repo));
IMessageReceiver cmdReceiver = new SqlMessageReceiver(connStr, "dbo.messages");
CommandProcessor commandProcessor = new CommandProcessor(cmdReceiver, serializer, cmdDispatcher);
commandProcessor.Start();
}
public void SqlEventStore_Serialized_Events()
{
var database = new Mock <ISqlRepository>();
database.Setup(db => db.InsertEvents(It.IsAny <EventStream>()));
var store = new SqlEventStore
{
GetRepository = () => database.Object
};
var events = new List <DomainEvent>
{
new AccountCreatedEvent(Guid.NewGuid(), 100),
new AccountDebitedEvent(Guid.NewGuid(), 50)
};
store.Insert(Guid.NewGuid(), events);
database.Verify(db => db.InsertEvents(It.IsAny <EventStream>()), Times.Once);
}
public void Init()
{
_guidGenerator = new SequentialAtEndGuidGenerator();
MetaFactories.Add(new MetaFactory(new Meta("ApplicationName", "Tests")));
MetaFactories.Add(new MetaFactory(new Meta("Username", "Tester")));
var typeFactory = new DefaultTypeFactory(new MD5HashProvider(Encoding.UTF8));
var hash = typeFactory.GetHash(typeof(Created));
EventStore = new SqlEventStore(
new JsonSerializer(),
typeFactory,
Encoding.UTF8,
ConfigurationManager.ConnectionStrings["SqlEventStore"].ConnectionString);
var streamProcessor = new EventStreamProcessor <AccountAggregateRoot, AccountState>(new AggregateRootBuilder <AccountAggregateRoot, AccountState>(), new AggregateRootStateBuilder <AccountState>());
Repository = new EventStoreRepository <AccountAggregateRoot, AccountState>(EventStore, streamProcessor, _guidGenerator);
}
public void StoreFailsIfAggregeteTypesNotConsistentTest()
{
var testModel = new TestModel();
var sqlEventStoreA = new SqlEventStore(connectionString);
var events = testModel.AllEvents.Where(e => e.AggregateId == testModel.AggregateIds.First());
var aggregateId = events.First().AggregateId;
sqlEventStoreA.Store(aggregateId, events);
var commandId = Guid.NewGuid().ToString();
var nextEvents = new List <IEvent>();
var item = new StockItem("item", "123");
nextEvents.Add(EventFactory.Default.CreateEvent <Location, AdjustedIn>(aggregateId, events.Last().AggregateVersion + 1, commandId, commandId, new AdjustedIn($"adjustment_{Guid.NewGuid()}", aggregateId, item)));
nextEvents.Add(EventFactory.Default.CreateEvent <InventoryItem, InventoryItemCreated>(aggregateId, events.Last().AggregateVersion + 2, commandId, commandId, new InventoryItemCreated(aggregateId)));
nextEvents.Add(EventFactory.Default.CreateEvent <Location, AdjustedIn>(aggregateId, events.Last().AggregateVersion + 3, commandId, commandId, new AdjustedIn($"adjustment_{Guid.NewGuid()}", aggregateId, item)));
new SqlEventStore(connectionString).Store(aggregateId, nextEvents);
}
public static void Run(string connStr)
{
IMessageSender sender = new SqlMessageSender(connStr, "dbo.messages");
ITextSerializer serializer = new JsonTextSerializer();
IEventStore eventStore = new SqlEventStore(connStr, "dbo.events");
IEventBus eventBus = new EventBus(sender, serializer);
IMetadataProvider metaProvider = new StandardMetadataProvider();
IReadModelStorage <AppointmentReadModel> readModelStorage = new InMemeoryStorage <AppointmentReadModel>();
IEventSourcedRepository <AppointmentAggregate> repo = new
EventSourcedRepository <AppointmentAggregate>(eventStore, eventBus, serializer, metaProvider);
IEventDispatcher evtDispatcher = new EventDispatcher();
evtDispatcher.Register(new AppointmentEventHandler(readModelStorage));
var evtReceiver = new SqlEventReceiver(new SqlEventStore(connStr, "dbo.events"));
var eventProcessor = new EventProcessor(evtReceiver, serializer, evtDispatcher);
eventProcessor.Start();
}
static void Main(string[] args)
{
Initialize();
OptionSet p = new OptionSet()
.Add("u", u => update = true);
try
{
p.Parse(args);
}
catch (OptionException ex)
{
Console.WriteLine(ex.Message);
}
if (update)
{
var eventStore = new SqlEventStore(ServiceLocator.GetInstance<ITextSerializer>(), ServiceLocator.GetInstance<IEventBus>());
eventStore.Advanced.ReplayEvents();
}
Console.ReadLine();
}
public async Task TestMethod1()
{
var streamId = Guid.NewGuid();
var created = DateTimeOffset.Now;
var EventStore = new SqlEventStore(@"Server=tcp:wtxqsopwyb.database.windows.net,1433;Initial Catalog=event-store;Persist Security Info=False;User ID=john;Password=YCWJ^QNMZmmDF36F;MultipleActiveResultSets=False;Encrypt=True;TrustServerCertificate=False;Connection Timeout=30;");
await EventStore.Database.InitializeAsync();
// see https://docs.microsoft.com/en-us/azure/sql-database/sql-database-dtu-resource-limits
// S0
//await ForEachAsync(GetTestDataStream(10000), e => EventStore.AppendAsync(new[] { e }), 60);
// S3
//await ForEachAsync(GetTestDataStream(10000), e => EventStore.AppendAsync(new[] { e }), 200);
// S6
//await ForEachAsync(GetTestDataStream(10000), e => EventStore.AppendAsync(new[] { e }), 200);
// S9
await ForEachAsync(GetTestDataStream(10000), e => EventStore.AppendAsync(new[] { e }), 400);
}
public static void Main(string[] args)
{
using (var activator = new BuiltinHandlerActivator())
{
var commandHandlers = new CommandHandlers();
activator.Handle <CreateInventoryItem>(commandHandlers.Handle);
activator.Handle <CheckInItemsToInventory>(commandHandlers.Handle);
activator.Handle <DeactivateInventoryItem>(commandHandlers.Handle);
activator.Handle <RemoveItemsFromInventory>(commandHandlers.Handle);
activator.Handle <RenameInventoryItem>(commandHandlers.Handle);
var serverBus = Configure.With(activator)
.Transport(t => t.UseRabbitMq(rabbitMqConnectionString, "server"))
.Start();
var eventStore = new SqlEventStore(sqlConnectionString, serverBus);
var repository = new Repository <InventoryItem>(eventStore);
commandHandlers.Repository = repository;
serverBus.Subscribe <CreateInventoryItem>();
serverBus.Subscribe <CheckInItemsToInventory>();
serverBus.Subscribe <DeactivateInventoryItem>();
serverBus.Subscribe <RemoveItemsFromInventory>();
serverBus.Subscribe <RenameInventoryItem>();
while (true)
{
var key = Console.ReadKey();
if (key.KeyChar == 'q')
{
break;
}
}
}
}
public void save_event_in_database()
{
var store = new SqlEventStore(new DomainEventJsonEventSerializer(), new FakeEventStamping());
store.Save(new SqlTestEvent(Guid.NewGuid(), 1, "test"));
}
public void CanSafelyCallDisposeMultipleTimes()
{
using (var snapshotStore = new SqlEventStore(new SqlEventStoreDialect(SqlServerConnection.Name), new BinarySerializer(), new EventStoreSettings()))
{
snapshotStore.Dispose();
snapshotStore.Dispose();
}
}
public TestContext ArrangeWithNoSnapshotting()
{
Sut = new SqlEventStore(new ConnectionFactory(_evtStoreConfig), _evtStoreConfig, new JsonSerializer());
return(this);
}
public void ConfigureServices(IServiceCollection services)
{
try
{
services.AddCors();
services.AddMvc();
var sqlDb = new SqlDatabase(new EnvironmentVariable("HomeTaskManagementSqlConnection"));
services.AddSingleton(new MiniAuth(new EnvironmentVariable("HomeTaskManagementSecret")));
services.AddSingleton(new AppHealth(TimeSpan.FromMinutes(15), sqlDb));
var eventStore = new SqlEventStore(sqlDb, "HomeTask.Events");
var blobStore = new SqlBlobStore(sqlDb, "HomeTask.Blobs");
var messages = new Messages();
var users = new Users(new UsersTable(sqlDb));
services.AddSingleton(users);
var tasks = new Tasks(new TasksTable(sqlDb));
var accounts = new Accounts(eventStore);
services.AddSingleton(accounts);
var pledges = new Pledges(eventStore, users, accounts, new PledgeFundingSettings());
var assignments = new TaskAssignments(eventStore, tasks, users, new AssignmentSettings());
var taskInstances = new TaskInstances(new InMemoryTaskInstanceStore(), assignments, messages);
var treasury = new Treasury(blobStore, accounts);
services.AddSingleton(users);
services.AddSingleton(new AppCommands(new Dictionary <string, IRequest>(StringComparer.InvariantCultureIgnoreCase)
{
{ nameof(OpenAccount), new AdminOnly(new JsonRequest <OpenAccount>(x => accounts.Apply(x))) },
{ nameof(SetOverdraftPolicy), new AdminOnly(new JsonRequest <SetOverdraftPolicy>(x => accounts.Apply(x))) },
{ nameof(TransactionRequest), new AdminOnly(new JsonRequest <TransactionRequest>(x => accounts.Apply(x))) },
{ nameof(RegisterUser), new JsonRequest <RegisterUser>(x => users.Apply(x)) },
{ nameof(UnregisterUser), new JsonRequest <UnregisterUser>(x => users.Apply(x)) },
{ nameof(AddRoles), new AdminOnly(new JsonRequest <AddRoles>(x => users.Apply(x))) },
{ nameof(RemoveRoles), new AdminOnly(new JsonRequest <RemoveRoles>(x => users.Apply(x))) },
{ nameof(AssignTask), new AdminOnly(new JsonRequest <AssignTask>(x => assignments.Apply(x))) },
{ nameof(CreateTask), new AdminOnly(new JsonRequest <CreateTask>(x => tasks.Apply(x))) },
{ nameof(DeleteTask), new AdminOnly(new JsonRequest <DeleteTask>(x => tasks.Apply(x))) },
{ nameof(SetPledge), new AdminOnly(new JsonRequest <SetPledge>(x => pledges.Apply(x))) },
{ nameof(FundPledges), new ServiceOrAdmin(new JsonRequest <FundPledges>(x => pledges.Apply(x))) },
{ nameof(MarkTaskComplete), new ApproverOnly(new JsonRequest <MarkTaskComplete>(x => taskInstances.Apply(x))) },
{ nameof(MarkTaskNotComplete), new JsonRequest <MarkTaskNotComplete>(x => taskInstances.Apply(x)) },
{ nameof(MarkTaskFunded), new ServiceOrAdmin(new JsonRequest <MarkTaskFunded>(x => taskInstances.Apply(x))) },
{ nameof(ScheduleWorkItemsThrough), new ServiceOrAdmin(new JsonRequest <ScheduleWorkItemsThrough>(x => taskInstances.Apply(x))) },
{ nameof(WaiveTask), new AdminOnly(new JsonRequest <WaiveTask>(x => taskInstances.Apply(x))) },
{ nameof(RecordExpenditure), new JsonRequest <RecordExpenditure>(x => treasury.Apply(x)) }
}));
services.AddSingleton(new AppQueries(new Dictionary <string, IRequest>(StringComparer.InvariantCultureIgnoreCase)
{
{ "accounts", new ParameterlessRequest(() => accounts.GetAll().Select(x => new AccountBalance {
Name = users.Get(x.Id).Name, Balance = x.Balance
})) },
{ nameof(Account), new JsonRequest <GetById>(x => Response.Success(accounts.Get(x.Id))) }
}));
new AppRecurringTasks(
new FundPledgesDaily(pledges),
new MarkNotCompletedTasksDaily(taskInstances),
new ScheduleTasksDaily(taskInstances))
.Start();
new HandleTaskInstanceCompletionPayments(taskInstances, accounts, messages)
.Start();
new FundScheduledTasks(taskInstances, accounts, messages)
.Start();
}
catch (Exception e)
{
Console.WriteLine($"Fatal error in Startup: {e.Message}");
Debug.WriteLine($"Fatal error in Startup: {e.Message}");
Environment.Exit(-1);
}
}
private static async Task GetEnumerableStreamBenchmarkAsync(TimeSpan timeout)
{
using (var db = new SqlLocalDB())
{
var es = new SqlEventStore(db.ConnectionString);
await es.Database.InitializeAsync();
await es.WithBulkCopyAppend().AppendAsync(GetUncommittedSource(1000, 100000));
var streamIdSet = es.GetEnumerable().Select(x => x.StreamId).Distinct().ToList();
//
var fs = new[] {
"default",
"unknown",
};
var xs = new[] {
new List <double>(),
new List <double>(),
};
for (int k = 0; k < 10; k++)
{
var i = 0;
foreach (var f in new Func <ISqlEventStore, ISqlEventStore>[] {
x => x,
})
{
var y = f(es);
var sw = new Stopwatch();
var rnd = Randomness.Create();
int n = 0;
while (sw.Elapsed < timeout)
{
var streamId = streamIdSet[rnd.Next(streamIdSet.Count)];
var minSeq = 1;
var maxSeq = minSeq + rnd.Next(100);
sw.Start();
n += y.GetEnumerableStream(streamId, minSeq, maxSeq).Count();
sw.Stop();
}
var p = n / sw.Elapsed.TotalSeconds;
xs[i].Add(p);
i++;
}
Console.Write($"{k}");
for (int j = 0; j < 2; j++)
{
var p = xs[j][k];
var fit = Tuple.Create(0d, 0d);
if (xs[j].Count > 1)
{
fit = Fit.Line(Enumerable.Range(1, xs[j].Count).Select(x => (double)x).ToArray(), xs[j].ToArray());
}
Console.Write($" | {fs[j]}: {p,9:N1} op/s {fit.Item1,9:N1}+x*{fit.Item2,9:N1}");
}
Console.WriteLine();
}
}
}
