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));
})
);
}
