public CurrentBalanceFromSubsriptionReadModelBuilder(SqlReadJournal journal, AccountBalanceDatabase database) { this.journal = journal; this.database = database; Receive <EventEnvelope>(OnEvent); }
private static Config Initialize(PostgresFixture fixture) { //need to make sure db is created before the tests start DbUtils.Initialize(fixture); return(ConfigurationFactory.ParseString($@" akka.persistence.journal.plugin = ""akka.persistence.journal.postgresql"" akka.persistence.journal.postgresql {{ event-adapters {{ color-tagger = ""Akka.Persistence.TCK.Query.ColorFruitTagger, Akka.Persistence.TCK"" }} event-adapter-bindings = {{ ""System.String"" = color-tagger }} class = ""Akka.Persistence.PostgreSql.Journal.PostgreSqlJournal, Akka.Persistence.PostgreSql"" plugin-dispatcher = ""akka.actor.default-dispatcher"" auto-initialize = on connection-string = ""{DbUtils.ConnectionString}"" refresh-interval = 1s }} akka.test.single-expect-default = 10s") .WithFallback(PostgreSqlPersistence.DefaultConfiguration()) .WithFallback(SqlReadJournal.DefaultConfiguration()) .WithFallback(Persistence.DefaultConfig())); }
static BatchingSqlServerEventsByTagSpec() { DbUtils.Initialize(); var conf = ConfigurationFactory.ParseString($@" akka.loglevel = INFO akka.test.single-expect-default = 10s akka.persistence.journal.plugin = ""akka.persistence.journal.sql-server"" akka.persistence.journal.sql-server {{ event-adapters {{ color-tagger = ""Akka.Persistence.TCK.Query.ColorFruitTagger, Akka.Persistence.TCK"" }} event-adapter-bindings = {{ ""System.String"" = color-tagger }} class = ""Akka.Persistence.SqlServer.Journal.SqlServerJournal, Akka.Persistence.SqlServer"" plugin-dispatcher = ""akka.actor.default-dispatcher"" table-name = EventJournal schema-name = dbo auto-initialize = on connection-string = """ + DbUtils.ConnectionString + @""" refresh-interval = 1s }}"); SpecConfig = conf.WithFallback(SqlReadJournal.DefaultConfiguration()); }
public BookQueryService(SqlReadJournal readJournal, ActorSystem actorSystem) { this.readJournal = readJournal; this.actorSystem = actorSystem; var source = readJournal.EventsByTag("book"); var mat = ActorMaterializer.Create(actorSystem); source.RunForeach(envelope => Handle(envelope.Event), mat); }
public ReportingActor() { Behavior = new BehaviorQueue(Become); // obtain read journal by plugin id _readJournal = PersistenceQuery.Get(Context.System).ReadJournalFor <SqlReadJournal>(SqlReadJournal.Identifier); Behavior.Become(Initializing, nameof(Initializing)); _dependencies = Context.System.GetReportingExtension().GetDependencies(); _log = Context.GetLogger(); }
public void Sql_query_EventsByPersistenceId_should_return_empty_stream_for_journal_from_SequenceNr_greater_than_HighestSequenceNr() { SqlReadJournal queries = Sys.ReadJournalFor <SqlReadJournal>(SqlReadJournal.Identifier); var pref = Setup("l"); var src = queries.CurrentEventsByPersistenceId("l", 4, 3); src.Select(x => x.Event).RunWith(this.SinkProbe <object>(), _materializer).Request(1).ExpectComplete(); }
public void Sql_query_EventsByPersistenceId_should_return_empty_stream_for_empty_journal_from_0_to_0() { SqlReadJournal queries = Sys.ReadJournalFor <SqlReadJournal>(SqlReadJournal.Identifier); var pref = SetupEmpty("k2"); var src = queries.CurrentEventsByPersistenceId("k2", 0, 0); src.Select(x => x.Event).RunWith(this.SinkProbe <object>(), _materializer).Request(1).ExpectComplete(); }
public void Sql_query_EventsByPersistenceId_should_find_existing_events_up_to_a_sequence_number() { SqlReadJournal queries = Sys.ReadJournalFor <SqlReadJournal>(SqlReadJournal.Identifier); var pref = Setup("b"); var src = queries.CurrentEventsByPersistenceId("b", 0L, 2L); var probe = src.Select(x => x.Event).RunWith(this.SinkProbe <object>(), _materializer) .Request(5) .ExpectNext("b-1", "b-2") .ExpectComplete(); }
public ConnectionHandler(Stream pStream, CancellationToken pCancellationToken) { _cancellationToken = pCancellationToken; _readJournal = PersistenceQuery .Get(Context.System).ReadJournalFor <SqlReadJournal>("akka.persistence.query.journal.sql"); _materializer = ActorMaterializer.Create(Context.System); _writer = new StreamWriter(pStream) { NewLine = "\n" }; }
public void Sql_query_EventsByPersistenceId_should_return_empty_stream_for_cleaned_journal_from_0_to_MaxLong() { SqlReadJournal queries = Sys.ReadJournalFor <SqlReadJournal>(SqlReadJournal.Identifier); var pref = Setup("g1"); pref.Tell(new TestActor.DeleteCommand(3)); AwaitAssert(() => ExpectMsg("3-deleted")); var src = queries.CurrentEventsByPersistenceId("g1", 0, long.MaxValue); src.Select(x => x.Event).RunWith(this.SinkProbe <object>(), _materializer).Request(1).ExpectComplete(); }
public void Sql_query_EventsByPersistenceId_should_return_remaining_values_after_partial_journal_cleanup() { SqlReadJournal queries = Sys.ReadJournalFor <SqlReadJournal>(SqlReadJournal.Identifier); var pref = Setup("h"); pref.Tell(new TestActor.DeleteCommand(2)); AwaitAssert(() => ExpectMsg("2-deleted")); var src = queries.CurrentEventsByPersistenceId("h", 0, long.MaxValue); src.Select(x => x.Event).RunWith(this.SinkProbe <object>(), _materializer).Request(1).ExpectNext("h-3").ExpectComplete(); }
public static Config Config(int id) => ConfigurationFactory.ParseString($@" akka.loglevel = INFO akka.persistence.journal.plugin = ""akka.persistence.journal.sqlite"" akka.persistence.journal.sqlite {{ class = ""Akka.Persistence.Sqlite.Journal.BatchingSqliteJournal, Akka.Persistence.Sqlite"" plugin-dispatcher = ""akka.actor.default-dispatcher"" table-name = event_journal metadata-table-name = journal_metadata auto-initialize = on connection-string = ""Datasource=memdb-journal-batch-currenteventsbypersistenceid-{id}.db;Mode=Memory;Cache=Shared"" refresh-interval = 1s }} akka.test.single-expect-default = 10s") .WithFallback(SqlReadJournal.DefaultConfiguration());
public void Sql_query_EventsByPersistenceId_should_find_existing_events() { SqlReadJournal queries = Sys.ReadJournalFor <SqlReadJournal>(SqlReadJournal.Identifier); var pref = Setup("a"); var src = queries.CurrentEventsByPersistenceId("a", 0, long.MaxValue); var probe = src.Select(x => x.Event).RunWith(this.SinkProbe <object>(), _materializer); probe.Request(2) .ExpectNext("a-1", "a-2") .ExpectNoMsg(TimeSpan.FromMilliseconds(500)); probe.Request(2) .ExpectNext("a-3") .ExpectComplete(); }
public void Sql_live_query_EventsByPersistenceId_should_find_new_events_up_to_SequenceNr() { SqlReadJournal queries = Sys.ReadJournalFor <SqlReadJournal>(SqlReadJournal.Identifier); var pref = Setup("d"); var src = queries.EventsByPersistenceId("d", 0, 4); var probe = src.Select(x => x.Event).RunWith(this.SinkProbe <object>(), _materializer) .Request(5) .ExpectNext("d-1", "d-2", "d-3"); pref.Tell("d-4"); ExpectMsg("d-4-done"); probe.ExpectNext("d-4").ExpectComplete(); }
public void Sql_live_query_EventsByPersistenceId_should_find_new_events() { SqlReadJournal queries = Sys.ReadJournalFor <SqlReadJournal>(SqlReadJournal.Identifier); var pref = Setup("c"); var src = queries.EventsByPersistenceId("c", 0, long.MaxValue); var probe = src.Select(x => x.Event).RunWith(this.SinkProbe <object>(), _materializer) .Request(5) .ExpectNext("c-1", "c-2", "c-3"); pref.Tell("c-4"); ExpectMsg("c-4-done"); probe.ExpectNext("c-4"); }
public static Config InitConfig(SqlServerFixture fixture) { DbUtils.Initialize(fixture.ConnectionString); return(ConfigurationFactory.ParseString($@" akka.loglevel = INFO akka.test.single-expect-default = 10s akka.persistence.journal.plugin = ""akka.persistence.journal.sql-server"" akka.persistence.journal.sql-server {{ class = ""Akka.Persistence.SqlServer.Journal.BatchingSqlServerJournal, Akka.Persistence.SqlServer"" plugin-dispatcher = ""akka.actor.default-dispatcher"" schema-name = dbo auto-initialize = on connection-string = ""{DbUtils.ConnectionString}"" refresh-interval = 1s }}") .WithFallback(SqlReadJournal.DefaultConfiguration())); }
public void Sql_query_EventsByPersistenceId_should_not_see_new_events_after_demand_request() { SqlReadJournal queries = Sys.ReadJournalFor <SqlReadJournal>(SqlReadJournal.Identifier); var pref = Setup("f"); var src = queries.CurrentEventsByPersistenceId("f", 0L, long.MaxValue); var probe = src.Select(x => x.Event).RunWith(this.SinkProbe <object>(), _materializer) .Request(2) .ExpectNext("f-1", "f-2") .ExpectNoMsg(TimeSpan.FromMilliseconds(100)) as TestSubscriber.Probe <object>; pref.Tell("f-4"); ExpectMsg("f-4-done"); probe.ExpectNoMsg(TimeSpan.FromMilliseconds(100)); probe.Request(5) .ExpectNext("f-3") .ExpectComplete(); // f-4 not seen }
static void Main(string[] args) { var hocon = ConfigurationFactory.ParseString(File.ReadAllText("reference.conf")); var actorSystem = ActorSystem.Create("ClusterShardingViewer", hocon.WithFallback(SqlReadJournal.DefaultConfiguration())); actorSystem.Log.Info("Starting up..."); var readJournal = actorSystem.ReadJournalFor <SqlReadJournal>(SqlReadJournal.Identifier); var query = readJournal.CurrentEventsByPersistenceId("/system/sharding/fubersCoordinator/singleton/coordinator", 0, 330); query.RunForeach(e => { Console.WriteLine("{0}: {1}", e.SequenceNr, e.Event); }, actorSystem.Materializer()); Console.ReadLine(); }
public static Config Config(int id) => ConfigurationFactory.ParseString($@" akka.loglevel = INFO akka.persistence.journal.plugin = ""akka.persistence.journal.sqlite"" akka.persistence.journal.sqlite {{ event-adapters {{ color-tagger = ""Akka.Persistence.Sql.TestKit.ColorTagger, Akka.Persistence.Sql.TestKit"" }} event-adapter-bindings = {{ ""System.String"" = color-tagger }} class = ""Akka.Persistence.Sqlite.Journal.BatchingSqliteJournal, Akka.Persistence.Sqlite"" plugin-dispatcher = ""akka.actor.default-dispatcher"" table-name = event_journal metadata-table-name = journal_metadata auto-initialize = on connection-string = ""FullUri=file:memdb-journal-{id}.db?mode=memory&cache=shared;"" refresh-interval = 1s }} akka.test.single-expect-default = 10s") .WithFallback(SqlReadJournal.DefaultConfiguration());
private static Config Initialize(PostgresFixture fixture) { //need to make sure db is created before the tests start DbUtils.Initialize(fixture); return(ConfigurationFactory.ParseString($@" akka.persistence.journal.plugin = ""akka.persistence.journal.postgresql"" akka.persistence.journal.postgresql {{ class = ""Akka.Persistence.PostgreSql.Journal.PostgreSqlJournal, Akka.Persistence.PostgreSql"" plugin-dispatcher = ""akka.actor.default-dispatcher"" table-name = event_journal auto-initialize = on connection-string = ""{DbUtils.ConnectionString}"" refresh-interval = 1s }} akka.test.single-expect-default = 10s") .WithFallback(PostgreSqlPersistence.DefaultConfiguration()) .WithFallback(SqlReadJournal.DefaultConfiguration()) .WithFallback(Persistence.DefaultConfig())); }
public static Config Config(int id) => ConfigurationFactory.ParseString($@" akka.loglevel = INFO akka.persistence.journal.plugin = ""akka.persistence.journal.sqlite"" akka.persistence.journal.sqlite {{ event-adapters {{ color-tagger = ""Akka.Persistence.TCK.Query.ColorFruitTagger, Akka.Persistence.TCK"" }} event-adapter-bindings = {{ ""System.String"" = color-tagger }} class = ""Akka.Persistence.Sqlite.Journal.SqliteJournal, Akka.Persistence.Sqlite"" plugin-dispatcher = ""akka.actor.default-dispatcher"" table-name = event_journal metadata-table-name = journal_metadata auto-initialize = on connection-string = ""Filename=file:memdb-journal-currenteventsbytag-{id}.db;Mode=Memory;Cache=Shared"" refresh-interval = 1s }} akka.test.single-expect-default = 10s") .WithFallback(SqlReadJournal.DefaultConfiguration());
static BatchingSqlServerEventsByPersistenceIdSpec() { DbUtils.Initialize(); var conf = ConfigurationFactory.ParseString($@" akka.loglevel = DEBUG akka.test.single-expect-default = 10s akka.persistence.journal.plugin = ""akka.persistence.journal.sql-server"" akka.persistence.journal.sql-server {{ class = ""Akka.Persistence.SqlServer.Journal.BatchingSqlServerJournal, Akka.Persistence.SqlServer"" plugin-dispatcher = ""akka.actor.default-dispatcher"" table-name = EventJournal schema-name = dbo auto-initialize = on connection-string = """ + DbUtils.ConnectionString + @""" refresh-interval = 1s }}"); SpecConfig = conf.WithFallback(SqlReadJournal.DefaultConfiguration()); }
public static Props props(SqlReadJournal readJournal) => Props.Create(() => new BookLibrarianLookup(readJournal));
public void Sql_query_EventsByPersistenceId_should_implement_standard_EventsByTagQuery() { SqlReadJournal queries = Sys.ReadJournalFor <SqlReadJournal>(SqlReadJournal.Identifier); (queries is IEventsByPersistenceIdQuery).Should().BeTrue(); }
public static Props Create(SqlReadJournal journal, AccountBalanceDatabase database) => Props.Create(() => new CurrentBalanceFromSubsriptionReadModelBuilder(journal, database));
protected EventsByTagSpec(Config config, ITestOutputHelper output) : base(config, output: output) { _materializer = Sys.Materializer(); _queries = Sys.ReadJournalFor <SqlReadJournal>(SqlReadJournal.Identifier); }
public BookLibrarianLookup(SqlReadJournal journal) { readJournal = journal; readJournal.PersistenceIds().RunForeach(id => knownIds.Add(id), mat); }
public BookViewBuilder(IResumableProjection resumableProjection) { _resumableProjection = resumableProjection; _storageContext = new StorageContext(); var self = Self; SqlReadJournal queries = PersistenceQuery.Get(Context.System) .ReadJournalFor <SqlReadJournal>(SqlReadJournal.Identifier); Receive <Option <long> >(option => { var materializer = ActorMaterializer.Create(Context.System); var eventsByTag = queries.EventsByTag("book", new Sequence(option.Value)); eventsByTag .SelectAsync(1, x => self.Ask(x)) .Recover(exception => { Console.WriteLine(exception); return(Option <object> .None); }) .Select(x => (Sequence)x) .SelectAsync(1, x => _resumableProjection.StoreLatestOffset("book-view", x.Value)) .RunWith(Sink.Ignore <bool>(), materializer); }); Receive <EventEnvelope>(envelope => envelope.Event.Match() .With <BookCreated>(bookCreated => { var updateDefinition = new UpdateDefinitionBuilder <BookReadModel>() .SetOnInsert(model => model.Title, bookCreated.Title) .SetOnInsert(model => model.Author, bookCreated.Author) .SetOnInsert(model => model.Tags, bookCreated.Tags) .SetOnInsert(model => model.Cost, bookCreated.Cost) .SetOnInsert(model => model.InventoryAmount, bookCreated.InventoryAmount) .SetOnInsert(model => model.SequenceNr, envelope.SequenceNr); var updateOptions = new UpdateOptions { IsUpsert = true }; _storageContext.Books .UpdateOneAsync(x => x.Id == bookCreated.Id, updateDefinition, updateOptions) .PipeTo(Sender, Self, () => envelope.Offset, exception => new Status.Failure(exception)); }) .With <TagAdded>(tagAdded => { var updateDefinition = new UpdateDefinitionBuilder <BookReadModel>() .Push(model => model.Tags, tagAdded.Tag) .Set(model => model.SequenceNr, envelope.SequenceNr); _storageContext.Books .FindOneAndUpdateAsync(ShouldBeApplied(tagAdded.Id, envelope.SequenceNr), updateDefinition) .PipeTo(Sender, Self, () => envelope.Offset, exception => new Status.Failure(exception)); }) .With <TagRemoved>(tagRemoved => { var updateDefinition = new UpdateDefinitionBuilder <BookReadModel>() .Pull(model => model.Tags, tagRemoved.Tag) .Set(model => model.SequenceNr, envelope.SequenceNr); _storageContext.Books .FindOneAndUpdateAsync(ShouldBeApplied(tagRemoved.Id, envelope.SequenceNr), updateDefinition) .PipeTo(Sender, Self, () => envelope.Offset, exception => new Status.Failure(exception)); }) ); }