Пример #1
0
            public async Task PublishEvents()
            {
                var streams = TripStream.RandomStreams(5);

                while (streams.Any())
                {
                    var count = 0;
                    using (var session = _store.LightweightSession())
                    {
                        foreach (var stream in streams.ToArray())
                        {
                            if (stream.TryCheckOutEvents(out var events))
                            {
                                count += events.Length;
                                session.Events.Append(stream.StreamId, events);
                            }

                            if (stream.IsFinishedPublishing())
                            {
                                streams.Remove(stream);
                            }
                        }

                        await session.SaveChangesAsync();

                        Console.WriteLine($"Wrote {count} events at {DateTime.Now.ToShortTimeString()}");
                    }
                }
            }
Пример #2
0
        public async Task PublishEvents()
        {
            var streams = TripStream.RandomStreams(5);

            while (streams.Any())
            {
                var count   = 0;
                var options = SessionOptions.ForDatabase(_database);

                await using var session = _store.OpenSession(options);
                foreach (var stream in streams.ToArray())
                {
                    if (stream.TryCheckOutEvents(out var events))
                    {
                        count += events.Length;
                        session.Events.Append(stream.StreamId, events);
                    }

                    if (stream.IsFinishedPublishing())
                    {
                        streams.Remove(stream);
                    }
                }

                await session.SaveChangesAsync();

                _board.Update(_name, count);
            }
        }
Пример #3
0
        public async Task conditional_deletes_through_lambda_conditions_on_aggregate()
        {
            var shortTrip    = new TripStream().TravelIsUnder(200);
            var longTrip     = new TripStream().TravelIsOver(2000);
            var initialCount = shortTrip.Events.Count + longTrip.Events.Count;

            _output.WriteLine($"Initially publishing {initialCount} events");

            var projection = new TestingSupport.TripProjection();

            projection.ProjectionName = "Trip";

            StoreOptions(x => x.Projections.Add(projection, ProjectionLifecycle.Async), true);

            var agent = await StartDaemon();



            var waiter1 = agent.Tracker.WaitForShardState("Trip:All", initialCount);

            using (var session = theStore.LightweightSession())
            {
                session.Events.Append(shortTrip.StreamId, shortTrip.Events.ToArray());
                session.Events.Append(longTrip.StreamId, longTrip.Events.ToArray());
                await session.SaveChangesAsync();
            }

            await waiter1;

            // This should not trigger a delete
            theSession.Events.Append(shortTrip.StreamId, new VacationOver());

            // This should trigger a delete
            theSession.Events.Append(longTrip.StreamId, new VacationOver());

            await theSession.SaveChangesAsync();

            var totalNumberOfEvents = initialCount + 2;
            var waiter2             = agent.Tracker.WaitForShardState(new ShardState("Trip:All", totalNumberOfEvents), 30.Seconds());

            await waiter2;



            using var query = theStore.QuerySession();

            (await query.LoadAsync <Trip>(shortTrip.StreamId)).ShouldNotBeNull();
            (await query.LoadAsync <Trip>(longTrip.StreamId)).ShouldBeNull();
        }