/// <summary>
        /// Registry for entities to be processed using the given actor system
        /// </summary>
        /// <param name="actorSystem"></param>
        public ShardedEntityRegistry(ActorSystem actorSystem)
        {
            ActorSystem = actorSystem;

            var persistenceConfig = ActorSystem.Settings.Config
                                    .WithFallback(@"wyvern.persistence {}")
                                    .GetConfig("wyvern.persistence");

            AskTimeout        = persistenceConfig.GetTimeSpan("ask-timeout", 5.0d.seconds(), false);
            MaxNumberOfShards = Math.Max(persistenceConfig.GetInt("max-number-of-shards", 1), 1);
            var role = persistenceConfig.GetString("run-entities-on-role", "");

            Role          = string.IsNullOrWhiteSpace(role) ? Option <string> .None : new Option <string>(role);
            SnapshotAfter = persistenceConfig.GetInt("snapshot-after", 100);

            Sharding         = ClusterSharding.Get(ActorSystem);
            ShardingSettings = ClusterShardingSettings
                               .Create(ActorSystem)
                               .WithRole(Role.Value);

            QueryPluginId = new Option <string>(SqlReadJournal.Identifier);

            var persistence = SqlServerPersistence.Get(ActorSystem);

            EventsByTagQuery = PersistenceQuery.Get(ActorSystem)
                               .ReadJournalFor <SqlReadJournal>(SqlReadJournal.Identifier);
            EventsByPersistenceIdQuery = PersistenceQuery.Get(ActorSystem)
                                         .ReadJournalFor <SqlReadJournal>(SqlReadJournal.Identifier);

            //var journalConfig = persistence.DefaultJournalConfig;
            //var sqlJournal = new SqlServerJournal(journalConfig);

            ExtractShardId = obj =>
            {
                switch (obj)
                {
                case IShardId i:
                    return($"{i.ShardId}");

                case CommandEnvelope commandEnvelope:
                    return(commandEnvelope.EntityId.ToShardId(MaxNumberOfShards));

                default:
                    throw new InvalidOperationException("Cannot derive shard identifier from unknown type");
                }
            };
            ExtractEntityId = obj =>
            {
                switch (obj)
                {
                case CommandEnvelope commandEnvelope:
                    return(($"{commandEnvelope.EntityId}", commandEnvelope.Payload).ToTuple());

                default:
                    throw new InvalidOperationException("Cannot derive entity identifier from unknown type");
                }
            };
        }
        static void Main(string[] args)
        {
            ActorSystem actorSystem = ActorSystem.Create(Keys.BankingSystemName);

            SqlServerPersistence.Get(actorSystem);

            IActorRef banker = actorSystem.ActorOf <Actors.Banker>(Keys.BankerActorName);

            Console.WriteLine("Bank has opened");

            while (true)
            {
                Console.ReadKey();
            }
        }
Example #3
0
        public void Should_SqlServer_snapshot_has_default_config()
        {
            SqlServerPersistence.Get(Sys);
            var config = Sys.Settings.Config.GetConfig("akka.persistence.snapshot-store.sql-server");

            config.Should().NotBeNull();
            config.GetString("class").Should().Be("Akka.Persistence.SqlServer.Snapshot.SqlServerSnapshotStore, Akka.Persistence.SqlServer");
            config.GetString("plugin-dispatcher").Should().Be(Dispatchers.DefaultDispatcherId);
            config.GetString("connection-string").Should().BeEmpty();
            config.GetString("connection-string-name").Should().BeNullOrEmpty();
            config.GetTimeSpan("connection-timeout").Should().Be(30.Seconds());
            config.GetString("schema-name").Should().Be("dbo");
            config.GetString("table-name").Should().Be("SnapshotStore");
            config.GetBoolean("auto-initialize").Should().BeFalse();
        }
Example #4
0
        public void Should_SqlServer_journal_has_default_config()
        {
            SqlServerPersistence.Get(Sys);
            var config = Sys.Settings.Config.GetConfig("akka.persistence.journal.sql-server");

            config.Should().NotBeNull();
            config.GetString("class").Should().Be("Akka.Persistence.SqlServer.Journal.SqlServerJournal, Akka.Persistence.SqlServer");
            config.GetString("plugin-dispatcher").Should().Be(Dispatchers.DefaultDispatcherId);
            config.GetString("connection-string").Should().BeEmpty();
            config.GetString("connection-string-name").Should().BeNullOrEmpty();
            config.GetTimeSpan("connection-timeout").Should().Be(30.Seconds());
            config.GetString("schema-name").Should().Be("dbo");
            config.GetString("table-name").Should().Be("EventJournal");
            config.GetString("metadata-table-name").Should().Be("Metadata");
            config.GetBoolean("auto-initialize").Should().BeFalse();
            config.GetString("timestamp-provider").Should().Be("Akka.Persistence.Sql.Common.Journal.DefaultTimestampProvider, Akka.Persistence.Sql.Common");
        }
Example #5
0
        static void Main(string[] args)
        {
            using (var system = ActorSystem.Create("PersistenceSystem")) {
                SqlServerPersistence.Init(system);
                var manager = system.ActorOf <BookingManager>("booking-manager");

                var bookingReadView = system.ActorOf(Props.Create(() => new BookingView("7072401234")));

                //manager.Tell(new InitializeBooking {
                //    BookingNo = "7072401234",
                //    CustomerNumber = "12345",
                //    Departure = DateTime.Now,
                //    Route = "GOT-FRE"
                //});

                //manager.Tell(new BookingConfirmed { BookingNo = "7072401234" });
                //manager.Tell(new BookingCancelled { BookingNo = "7072401234" });

                system.AwaitTermination();
            }
        }
 public SqlServerSnapshotStore()
 {
     _extension = SqlServerPersistence.Get(Context.System);
     QueryBuilder = new SqlServerSnapshotQueryBuilder(_extension.SnapshotSettings);
     QueryMapper = new SqlServerQueryMapper(Context.System.Serialization);
 }
Example #7
0
 public SqlServerSnapshotStore()
 {
     _extension   = SqlServerPersistence.Get(Context.System);
     QueryBuilder = new SqlServerSnapshotQueryBuilder(_extension.SnapshotSettings);
     QueryMapper  = new SqlServerQueryMapper(Context.System.Serialization);
 }