public void EventAdapters_should_allow_implementing_only_the_read_side_IReadEventAdapter()
{
var adapters = EventAdapters.Create(_extendedActorSystem, _memoryConfig);
// read-side only adapter
var readAdapter = adapters.Get <ReadMeEvent>();
readAdapter.FromJournal(readAdapter.ToJournal(new ReadMeEvent()), "").Events.First().Should().Be("from-ReadMeEvent()");
}
public void EventAdapters_should_allow_implementing_only_the_write_side_IWriteEventAdapter()
{
var adapters = EventAdapters.Create(_extendedActorSystem, _memoryConfig);
// write-side only adapter
var writeAdapter = adapters.Get <WriteMeEvent>();
writeAdapter.FromJournal(writeAdapter.ToJournal(new WriteMeEvent()), "").Events.First().Should().Be("to-WriteMeEvent()");
}
public void EventAdapters_should_allow_read_write_ReadWriteEventAdapter()
{
var adapters = EventAdapters.Create(_extendedActorSystem, _memoryConfig);
var readWriteAdapter = adapters.Get <ReadWriteEvent>();
var events = readWriteAdapter.FromJournal(readWriteAdapter.ToJournal(new ReadWriteEvent()), "").Events
.Select(c => c.ToString())
.Should()
.BeEquivalentTo("from-to-ReadWriteEvent()", "again-to-ReadWriteEvent()");
}
private static EventAdapters CreateAdapters(ExtendedActorSystem system, string configPath)
{
var pluginConfig = system.Settings.Config.GetConfig(configPath);
if (pluginConfig.IsNullOrEmpty())
{
throw ConfigurationException.NullOrEmptyConfig <EventAdapters>(configPath);
}
return(EventAdapters.Create(system, pluginConfig));
}
public void EventAdapters_should_allow_combining_only_the_readside_CombinedReadEventAdapter()
{
var adapters = EventAdapters.Create(_extendedActorSystem, _memoryConfig);
// combined-read-side only adapter
var readAdapter = adapters.Get <ReadMeTwiceEvent>();
readAdapter.FromJournal(readAdapter.ToJournal(new ReadMeTwiceEvent()), "").Events
.Select(c => c.ToString())
.Should()
.BeEquivalentTo("from-ReadMeTwiceEvent()", "again-ReadMeTwiceEvent()");
}
[Fact] public void EventAdapters_should_fail_with_useful_message_when_binding_to_not_defined_adapter()
{
var badConfig = ConfigurationFactory.ParseString(@"
akka.persistence.journal.inmem {
event-adapter-bindings {
""System.Integer"" = undefined-adapter
}
}");
var combinedConfig = badConfig.GetConfig("akka.persistence.journal.inmem");
var ex = Assert.Throws <ArgumentException>(() => EventAdapters.Create(_extendedActorSystem, combinedConfig));
ex.Message.Contains("System.Integer was bound to undefined event-adapter: undefined-adapter").Should().BeTrue();
}
public void EventAdapters_should_pick_the_most_specific_adapter_available()
{
var adapters = EventAdapters.Create(_extendedActorSystem, _memoryConfig);
// sanity check: precise case, matching non-user classes
adapters.Get <string>().GetType().Should().Be(typeof(ExampleEventAdapter));
// pick adapter by implemented marker interface
adapters.Get <SampleEvent>().GetType().Should().Be(typeof(MarkerInterfaceAdapter));
// more general adapter matches as well, but most specific one should be picked
adapters.Get <PreciseAdapterEvent>().GetType().Should().Be(typeof(PreciseAdapter));
// no adapter defined for Long, should return identity adapter
adapters.Get <long>().GetType().Should().Be(typeof(IdentityEventAdapter));
}
public Linq2DbReadJournal(ExtendedActorSystem system,
Configuration.Config config, string configPath)
{
writePluginId = config.GetString("write-plugin");
//IDK Why we need this, but we do.
system.RegisterExtension(Persistence.Instance);
var persist = Persistence.Instance.Get(system);
eventAdapters = persist
.AdaptersFor(writePluginId);
readJournalConfig = new ReadJournalConfig(config);
this.system = system;
var connFact =
new AkkaPersistenceDataConnectionFactory(readJournalConfig);
_mat = Materializer.CreateSystemMaterializer(system,
ActorMaterializerSettings.Create(system),
"l2db-query-mat" + configPath);
readJournalDao = new ByteArrayReadJournalDao(
system.Scheduler.Advanced, _mat,
connFact, readJournalConfig,
new ByteArrayJournalSerializer(readJournalConfig,
system.Serialization,
readJournalConfig.PluginConfig.TagSeparator));
journalSequenceActor = system.ActorOf(Props.Create(() =>
new JournalSequenceActor(readJournalDao
,
readJournalConfig
.JournalSequenceRetrievalConfiguration)),
readJournalConfig.TableConfig.TableName +
"akka-persistence-linq2db-sequence-actor");
delaySource = Source.Tick(
TimeSpan.FromSeconds(0), readJournalConfig.RefreshInterval,
0L)
.Take(1);
}
public void EventAdapters_should_parse_configuration_and_resolve_adapter_definitions()
{
var adapters = EventAdapters.Create(_extendedActorSystem, _memoryConfig);
adapters.Get <IEventMarkerInterface>().GetType().Should().Be(typeof(MarkerInterfaceAdapter));
}
/// <summary>
/// TBD
/// </summary>
/// <param name="ref">TBD</param>
/// <param name="adapters">TBD</param>
/// <param name="config">TBD</param>
public PluginHolder(IActorRef @ref, EventAdapters adapters, Config config)
{
Ref = @ref;
Adapters = adapters;
Config = config;
}
private static EventAdapters CreateAdapters(ExtendedActorSystem system, string configPath)
{
var pluginConfig = system.Settings.Config.GetConfig(configPath);
return(EventAdapters.Create(system, pluginConfig));
}
protected WriteJournalBase()
{
_persistence = Persistence.Instance.Apply(Context.System);
_eventAdapters = _persistence.AdaptersFor(Self);
}
public PluginHolder(IActorRef @ref, EventAdapters adapters)
{
Ref = @ref;
Adapters = adapters;
}
private EventAdapters CreateAdapters(string configPath)
{
var pluginConfig = _system.Settings.Config.GetConfig(configPath);
return(EventAdapters.Create(_system, pluginConfig));
}
