public CashMachineFrontend()
{
SqlitePersistence.Get(ActorSystem);
this.cashMachine = ActorSystem.ActorOf(Props.Create(() => new Actors.CashMachine(this)), Keys.CashMachineActorName);
InitializeComponent();
}
public SqliteJournalSpec(ITestOutputHelper output)
: base(CreateSpecConfig("Filename=file:memdb-journal-" + counter.IncrementAndGet() + ".db;Mode=Memory;Cache=Shared"), "SqliteJournalSpec", output)
{
SqlitePersistence.Get(Sys);
Initialize();
}
public SqliteSnapshotStoreSpec(ITestOutputHelper output)
: base(CreateSpecConfig("FullUri=file:memdb-snapshot-" + counter.IncrementAndGet() + ".db?mode=memory&cache=shared;"), "SqliteSnapshotStoreSpec", output)
{
SqlitePersistence.Get(Sys);
Initialize();
}
public BatchingSqliteJournalSpec(ITestOutputHelper output)
: base(CreateSpecConfig("FullUri=file:memdb-journal-" + counter.IncrementAndGet() + ".db?mode=memory&cache=shared;"), "BatchingSqliteJournalSpec", output)
{
SqlitePersistence.Get(Sys);
Initialize();
}
public void Sqlite_JournalSettings_default_should_contain_default_config()
{
var config = SqlitePersistence.Get(Sys).DefaultJournalConfig;
var settings = new JournalSettings(config);
// values should be correct
settings.ConnectionString.Should().Be(string.Empty);
settings.ConnectionStringName.Should().Be(string.Empty);
settings.ConnectionTimeout.Should().Equals(TimeSpan.FromSeconds(30));
settings.JournalTableName.Should().Equals("event_journal");
settings.SchemaName.Should().BeNull();
settings.MetaTableName.Should().Equals("journal_metadata");
settings.TimestampProvider.Should().Be("Akka.Persistence.Sql.Common.Journal.DefaultTimestampProvider, Akka.Persistence.Sql.Common");
settings.AutoInitialize.Should().BeFalse();
// values should reflect configuration
settings.ConnectionString.Should().Equals(config.GetString("connection-string"));
settings.ConnectionStringName.Should().Equals(config.GetString("connection-string-name"));
settings.ConnectionTimeout.Should().Equals(config.GetTimeSpan("connection-timeout"));
settings.JournalTableName.Should().Equals(config.GetString("table-name"));
settings.SchemaName.Should().Equals(config.GetString("schema-name", null));
settings.MetaTableName.Should().Equals(config.GetString("metadata-table-name"));
settings.TimestampProvider.Should().Be(config.GetString("timestamp-provider"));
settings.AutoInitialize.Should().Equals(config.GetBoolean("auto-initialize"));
}
public static void Main(string[] args)
{
string qos = args[0];
string topic_root = args[1];
string client_id = args[2];
int maxNumber = Int32.Parse(args[3]);
// Console.WriteLine("{0} starting", client_id);
MqttQos Qos = ParseQos(qos);
using (var numbersPersistence = new NumbersPersistence(client_id + ".sqlite3"))
{
using (var clientPersistence = new SqlitePersistence(numbersPersistence.conn))
// using (var p = new InMemoryPersistence())
{
var client = new MqttClient(numbersPersistence, clientPersistence, topic_root, client_id, Qos, maxNumber);
while (!client.Finished)
{
try
{
client.Run();
}
catch (Exception ex)
{
Console.WriteLine("{0} : {1}", client_id, ex.ToString());
}
Thread.Sleep(TimeSpan.FromSeconds(1));
}
}
}
Console.WriteLine("{0} done", client_id);
}
public BatchingSqliteJournalSpec(ITestOutputHelper output)
: base(CreateSpecConfig($"Datasource=memdb-journal-batch-{counter.IncrementAndGet()}.db;Mode=Memory;Cache=Shared"), "BatchingSqliteJournalSpec", output)
{
SqlitePersistence.Get(Sys);
Initialize();
}
private ActorSystem CreateActorSystem(Config config, IActorSystemDependencyResolver dependencyResolver)
{
var actorSystem = ActorSystem.Create("actor-system", config);
dependencyResolver.RegisterDependencyResolver(actorSystem);
SqlitePersistence.Get(actorSystem);
return(actorSystem);
}
private Config LoadConfiguration(string configFileName)
{
var defaultConfig = ConfigurationFactory.Default();
var persistenceConfig = SqlitePersistence.DefaultConfiguration();
var actualConfiguration = ConfigurationFactory.ParseString(configFileName);
var config = actualConfiguration.WithFallback(persistenceConfig.WithFallback(defaultConfig));
return(config);
}
static void Main(string[] args)
{
var system = ActorSystem.Create(Guid.NewGuid().ToString(), ConfigurationFactory.Load());
SqlitePersistence.Get(system);
var config = system.Settings.Config.GetConfig("akka.persistence.journal.sqlite");
var setup = new BatchingSqliteJournalSetup(config);
Console.WriteLine("If running properly, BatchingSqliteJournalSetup.ConnectionString should return 'myDB://MyConnectionString'.");
Console.WriteLine($"Connection string is: {setup.ConnectionString}");
}
static void Main(string[] args)
{
var system = ActorSystem.Create("ComicsServer");
SqlitePersistence.Get(system);
var issues = system.ActorOf <IssuesActor>("issues");
Console.WriteLine($"Created {issues.Path}");
Console.ReadLine();
}
public AutomaticCluster(ActorSystem system)
{
_system = system;
_cluster = Cluster.Get(system);
_persistence = SqlitePersistence.Get(system);
_dbHelper = new DbHelper(() =>
{
var conn = new SQLiteConnection(_persistence.DefaultJournalConfig.GetString("connection-string"));
conn.Open();
return conn;
});
}
public AutomaticCluster(ActorSystem system)
{
_system = system;
_cluster = Cluster.Get(system);
_persistence = SqlitePersistence.Get(system);
_dbHelper = new DbHelper(() =>
{
var conn = new SQLiteConnection(_persistence.JournalSettings.ConnectionString);
conn.Open();
return conn;
});
}
public AutomaticCluster(ActorSystem system)
{
_system = system;
_cluster = Cluster.Get(system);
_persistence = SqlitePersistence.Get(system);
_dbHelper = new DbHelper(() =>
{
var conn = new SQLiteConnection(_persistence.DefaultJournalConfig.GetString("connection-string"));
conn.Open();
return(conn);
});
}
public AutomaticCluster(ActorSystem system)
{
_system = system;
_cluster = Cluster.Get(system);
_persistence = SqlitePersistence.Get(system);
_dbHelper = new DbHelper(() =>
{
var conn = new SQLiteConnection(_persistence.JournalSettings.ConnectionString);
conn.Open();
return(conn);
});
}
public AutomaticCluster(ActorSystem system)
{
_system = system;
_cluster = Cluster.Get(system);
_persistence = SqlitePersistence.Get(system);
_dbHelper = new DbHelper(() =>
{
var str = _system.Settings.Config.GetString("akka.persistence.journal.sqlite.connection-string");
var conn = new SqliteConnection(str);
conn.Open();
return(conn);
});
}
public void batcher_decorator()
{
var options = BuildOptions();
var store = new SqlitePersistence(options);
_persistence.Add(store);
store.InitAsync(CancellationToken.None).Wait();
var persistenceBatcher = new PersistenceBatchAppendDecorator(store, BatchSize, FlushTimeout);
TaskWorker.Run(persistenceBatcher, _iterations).GetAwaiter().GetResult();
persistenceBatcher.Dispose();
}
static async Task Main(string[] args)
{
var config = ConfigurationFactory.ParseString(await File.ReadAllTextAsync("app.conf"))
.WithFallback(ClusterSingletonManager.DefaultConfig());
using (var system = ActorSystem.Create("sharded-cluster-system", config))
{
var cluster = Cluster.Get(system);
var persistence = SqlitePersistence.Get(system);
await RunExample(system);
Console.ReadLine();
}
}
public void Should_sqlite_snapshot_has_default_config()
{
SqlitePersistence.Get(Sys);
var config = Sys.Settings.Config.GetConfig("akka.persistence.snapshot-store.sqlite");
Assert.NotNull(config);
Assert.Equal("Akka.Persistence.Sqlite.Snapshot.SqliteSnapshotStore, Akka.Persistence.Sqlite", config.GetString("class"));
Assert.Equal("akka.actor.default-dispatcher", config.GetString("plugin-dispatcher"));
Assert.Equal(string.Empty, config.GetString("connection-string"));
Assert.Equal(string.Empty, config.GetString("connection-string-name"));
Assert.Equal(TimeSpan.FromSeconds(30), config.GetTimeSpan("connection-timeout"));
Assert.Equal("snapshot_store", config.GetString("table-name"));
Assert.False(config.GetBoolean("auto-initialize"));
}
public CartSystem()
{
var config = ConfigurationFactory.ParseString(@"
akka.persistence.journal.plugin=""akka.persistence.journal.sqlite""
akka.persistence.journal.sqlite.connection-string=""Data Source=c:\\users\\andrew\\desktop\\akka.db;""
akka.persistence.journal.sqlite.auto-initialize=true
akka.persistence.snapshot-store.plugin=""akka.persistence.snapshot-store.sqlite""
akka.persistence.snapshot-store.sqlite.connection-string=""Data Source=c:\\users\\andrew\\desktop\\akka.db;""
akka.persistence.snapshot-store.sqlite.auto-initialize=true
}");
_system = ActorSystem.Create("CartActorSystem", config);
SqlitePersistence.Get(_system);
_queryActor = _system.ActorOf(QueryActor.CreateProps(), "queryActor");
_commandActor = _system.ActorOf(CommandActor.CreateProps(_queryActor), "commandActor");
}
public void Should_sqlite_journal_has_default_config()
{
SqlitePersistence.Get(Sys);
var config = Sys.Settings.Config.GetConfig("akka.persistence.journal.sqlite");
Assert.NotNull(config);
Assert.Equal("Akka.Persistence.Sqlite.Journal.SqliteJournal, Akka.Persistence.Sqlite", config.GetString("class"));
Assert.Equal("akka.actor.default-dispatcher", config.GetString("plugin-dispatcher"));
Assert.Equal(string.Empty, config.GetString("connection-string"));
Assert.Equal(string.Empty, config.GetString("connection-string-name"));
Assert.Equal(TimeSpan.FromSeconds(30), config.GetTimeSpan("connection-timeout"));
Assert.Equal("event_journal", config.GetString("table-name"));
Assert.Equal("journal_metadata", config.GetString("metadata-table-name"));
Assert.False(config.GetBoolean("auto-initialize"));
Assert.Equal("Akka.Persistence.Sql.Common.Journal.DefaultTimestampProvider, Akka.Persistence.Sql.Common", config.GetString("timestamp-provider"));
}
public void Should_override_default_Sqlite_fallback_values()
{
SqlitePersistence.Get(Sys);
var journalConfig = Sys.Settings.Config.GetConfig("akka.persistence.journal.sqlite");
Assert.Equal(TimeSpan.FromSeconds(25), journalConfig.GetTimeSpan("connection-timeout"));
Assert.Equal("event_journal", journalConfig.GetString("table-name"));
Assert.Equal("journal_metadata", journalConfig.GetString("metadata-table-name"));
var snapshotConfig = Sys.Settings.Config.GetConfig("akka.persistence.snapshot-store.sqlite");
Assert.False(snapshotConfig.IsNullOrEmpty());
Assert.Equal("DataSource=AkkaSnapShotfxR16.db", snapshotConfig.GetString("connection-string"));
Assert.Equal(TimeSpan.FromSeconds(25), snapshotConfig.GetTimeSpan("connection-timeout"));
Assert.Equal("snapshot_store", snapshotConfig.GetString("table-name"));
}
private IPersistence Create()
{
Connect();
_logger.LogInformation("Starting test #{number}", _testRunId);
_options = new SqlitePersistenceOptions(LoggerFactory)
{
ConnectionString = ConnectionString,
StreamsTableName = "streams_" + _testRunId + "_" + GetType().Name,
Serializer = new JsonMsSqlSerializer()
};
_sqlPersistence = new SqlitePersistence(_options);
_sqlPersistence.DestroyAllAsync(CancellationToken.None).Wait();
_sqlPersistence.InitAsync(CancellationToken.None).Wait();
_logger.LogInformation("Test #{number} started", _testRunId);
return(_sqlPersistence);
}
public static async Task Main(string[] args)
{
#region Console shutdown setup
var exitEvent = new ManualResetEvent(false);
Console.CancelKeyPress += (sender, eventArgs) =>
{
eventArgs.Cancel = true;
exitEvent.Set();
};
AppDomain.CurrentDomain.ProcessExit += (sender, eventArgs) =>
{
exitEvent.Set();
};
#endregion
var config = ConfigurationFactory.ParseString(await File.ReadAllTextAsync("app.conf"))
.BootstrapFromDocker()
.WithFallback(ClusterSingletonManager.DefaultConfig())
.WithFallback(SqlitePersistence.DefaultConfiguration());
var system = ActorSystem.Create("sharded-cluster-system", config);
var sharding = ClusterSharding.Get(system);
var shardRegion = await sharding.StartAsync(
typeName : "customer",
entityPropsFactory : e => Props.Create(() => new Customer(e)),
settings : ClusterShardingSettings.Create(system),
messageExtractor : new MessageExtractor(10));
var cluster = Cluster.Get(system);
cluster.RegisterOnMemberUp(() =>
{
ProduceMessages(system, shardRegion);
});
exitEvent.WaitOne();
await system.Terminate();
}
public AppEngine()
{
var pathToDb = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "sample.db");
if (File.Exists(pathToDb))
{
File.Delete(pathToDb);
}
var options = new SqlitePersistenceOptions(new NStore.Core.Logging.NStoreNullLoggerFactory())
{
ConnectionString = $"Data Source={pathToDb}",
Serializer = new TypeAsSchemaJsonSerializer()
};
var persitence = new SqlitePersistence(options);
_streams = new StreamsFactory(persitence);
SQLitePCL.Batteries_V2.Init();
persitence.InitAsync(CancellationToken.None).GetAwaiter().GetResult();
}
protected IPersistence Create(bool dropOnInit)
{
Connect();
_logger.LogInformation("Starting test #{number}", _testRunId);
var options = new SqlitePersistenceOptions(LoggerFactory)
{
ConnectionString = ConnectionString,
StreamsTableName = "streams_" + _testRunId + "_" + GetType().Name,
Serializer = new JsonSqliteSerializer()
};
var sqlPersistence = new SqlitePersistence(options);
if (dropOnInit)
{
sqlPersistence.DestroyAllAsync(CancellationToken.None).Wait();
}
sqlPersistence.InitAsync(CancellationToken.None).Wait();
_logger.LogInformation("Test #{number} started", _testRunId);
return(sqlPersistence);
}
public void Sqlite_SnapshotStoreSettings_default_should_contain_default_config()
{
var config = SqlitePersistence.Get(Sys).DefaultSnapshotConfig;
var settings = new SnapshotStoreSettings(config);
// values should be correct
settings.ConnectionString.Should().Be(string.Empty);
settings.ConnectionStringName.Should().Be(string.Empty);
settings.ConnectionTimeout.Should().Equals(TimeSpan.FromSeconds(30));
settings.SchemaName.Should().BeNull();
settings.TableName.Should().Equals("snapshot");
settings.AutoInitialize.Should().BeFalse();
settings.DefaultSerializer.Should().BeNull();
settings.FullTableName.Should().Equals(settings.TableName);
// values should reflect configuration
settings.ConnectionString.Should().Equals(config.GetString("connection-string"));
settings.ConnectionStringName.Should().Equals(config.GetString("connection-string-name"));
settings.ConnectionTimeout.Should().Equals(config.GetTimeSpan("connection-timeout"));
settings.SchemaName.Should().Equals(config.GetString("schema-name", null));
settings.TableName.Should().Equals(config.GetString("table-name"));
settings.AutoInitialize.Should().Equals(config.GetBoolean("auto-initialize"));
settings.DefaultSerializer.Should().Equals(config.GetString("serializer", null));
}
public void ActorRecoversItsStateWithEventsWhenRestarted()
{
var config = Configuration.ConfigurationFactory.ParseString(@"
akka
{
persistence
{
journal
{
plugin = ""akka.persistence.journal.sqlite""
auto-start-journals = [""akka.persistence.journal.sqlite""]
sqlite
{
class = ""Akka.Persistence.Sqlite.Journal.SqliteJournal, Akka.Persistence.Sqlite""
connection-string = ""data source=C:\\SQLite\\Databases\\AkkaNetTestsEventStore.db""
auto-initialize : on
}
}
}
}
");
var sys = ActorSystem.Create("my-sys", config.WithFallback(ConfigurationFactory.Default()));
SqlitePersistence.Get(sys); // Initialize the extension.
var pa = sys.ActorOf <PersistentActor>();
pa.Tell(new Cmd("cmd 0"));
pa.Tell(new Cmd("cmd 1"));
pa.Tell("restart");
ExpectMsg("I'm being restarted.");
pa.Tell("print");
//ExpectMsg("cmd 0 - num of events before: 0, cmd 1 - num of events before: 1");
ExpectMsg <string>(msg => msg.Contains("cmd 0") && msg.Contains("cmd 1"));
pa.Tell("count");
ExpectMsg <int>(count => count == 2);
}
public SqliteSnapshotStore()
{
_extension = SqlitePersistence.Get(Context.System);
QueryBuilder = new QueryBuilder(_extension.SnapshotSettings);
QueryMapper = new SqliteQueryMapper(Context.System.Serialization);
}
public SqliteSnapshotStore()
{
_extension = SqlitePersistence.Get(Context.System);
QueryBuilder = new QueryBuilder(_extension.SnapshotSettings);
QueryMapper = new SqliteQueryMapper(Context.System.Serialization);
}
public SqliteJournal()
{
_extension = SqlitePersistence.Get(Context.System);
}
