WithFallback() public méthode

Configure the current configuration with a secondary source.
Config can not have itself as fallback.
public WithFallback ( Config fallback ) : Config
fallback Config The configuration to use as a secondary source.
Résultat Config
Exemple #1
0
 private static ActorSystem CreateClient(Config commonConfig)
 {
     var config = commonConfig.WithFallback("akka.remote.helios.tcp.port = 9002");
     var system = ActorSystem.Create("Client", config);
     DeadRequestProcessingActor.Install(system);
     return system;
 }
Exemple #2
0
 public SqliteJournal(Config journalConfig) : base(journalConfig.WithFallback(Extension.DefaultJournalConfig))
 {
     var config = journalConfig.WithFallback(Extension.DefaultJournalConfig);
     QueryExecutor = new SqliteQueryExecutor(new QueryConfiguration(
         schemaName: null,
         journalEventsTableName: config.GetString("table-name"),
         metaTableName: config.GetString("metadata-table-name"),
         persistenceIdColumnName: "persistence_id",
         sequenceNrColumnName: "sequence_nr",
         payloadColumnName: "payload",
         manifestColumnName: "manifest",
         timestampColumnName: "timestamp",
         isDeletedColumnName: "is_deleted",
         tagsColumnName: "tags",
         orderingColumnName: "ordering",
         timeout: config.GetTimeSpan("connection-timeout")), 
             Context.System.Serialization, 
             GetTimestampProvider(config.GetString("timestamp-provider")));
 }
Exemple #3
0
 public virtual Deploy ParseConfig(string key, Config config)
 {
     var deployment = config.WithFallback(_default);
     var routerType = deployment.GetString("router");
     var router = CreateRouterConfig(routerType, deployment);
     var dispatcher = deployment.GetString("dispatcher");
     var mailbox = deployment.GetString("mailbox");
     var deploy = new Deploy(key, deployment, router, Deploy.NoScopeGiven, dispatcher, mailbox);
     return deploy;
 }
 public SqliteSnapshotStore(Config snapshotConfig) : base(snapshotConfig)
 {
     var config = snapshotConfig.WithFallback(Extension.DefaultSnapshotConfig);
     QueryExecutor = new SqliteSnapshotQueryExecutor(new QueryConfiguration(
         schemaName: null,
         snapshotTableName: "snapshot",
         persistenceIdColumnName: "persistence_id",
         sequenceNrColumnName: "sequence_nr",
         payloadColumnName: "payload",
         manifestColumnName: "manifest",
         timestampColumnName: "created_at",
         timeout: config.GetTimeSpan("connection-timeout")), 
         Context.System.Serialization);
 }
Exemple #5
0
        /// <summary>
        ///     Initializes a new instance of the <see cref="Settings" /> class.
        /// </summary>
        /// <param name="system">The system.</param>
        /// <param name="config">The configuration.</param>
        public Settings(ActorSystem system, Config config)
        {
            Config fallback = ConfigurationFactory.Default();

            Config merged = config == null ? fallback : config.WithFallback(fallback);

            System = system;
            Config = merged;

            ConfigVersion = Config.GetString("akka.version");
            ProviderClass = Config.GetString("akka.actor.provider");
            var providerType = Type.GetType(ProviderClass);
            if (providerType == null)
                throw new ConfigurationException(string.Format("'akka.actor.provider' is not a valid type name : '{0}'", ProviderClass));
            if (!typeof(ActorRefProvider).IsAssignableFrom(providerType))
                throw new ConfigurationException(string.Format("'akka.actor.provider' is not a valid actor ref provider: '{0}'", ProviderClass));
            
            SupervisorStrategyClass = Config.GetString("akka.actor.guardian-supervisor-strategy");

            CreationTimeout = Config.GetMillisDuration("akka.actor.creation-timeout");
            UnstartedPushTimeout = Config.GetMillisDuration("akka.actor.unstarted-push-timeout");

            SerializeAllMessages = Config.GetBoolean("akka.actor.serialize-messages");
            SerializeAllCreators = Config.GetBoolean("akka.actor.serialize-creators");

            LogLevel = Config.GetString("akka.loglevel");
            StdoutLogLevel = Config.GetString("akka.stdout-loglevel");
            Loggers = Config.GetStringList("akka.loggers");

            LoggerStartTimeout = Config.GetMillisDuration("akka.logger-startup-timeout");

            //handled
            LogConfigOnStart = Config.GetBoolean("akka.log-config-on-start");
            LogDeadLetters = 0;
            switch (Config.GetString("akka.log-dead-letters"))
            {
                case "on":
                case "true":
                    LogDeadLetters = int.MaxValue;
                    break;
                case "off":
                case "false":
                    LogDeadLetters = 0;
                    break;
                default:
                    LogDeadLetters = Config.GetInt("akka.log-dead-letters");
                    break;
            }
            LogDeadLettersDuringShutdown = Config.GetBoolean("akka.log-dead-letters-during-shutdown");
            AddLoggingReceive = Config.GetBoolean("akka.actor.debug.receive");
            DebugAutoReceive = Config.GetBoolean("akka.actor.debug.autoreceive");
            DebugLifecycle = Config.GetBoolean("akka.actor.debug.lifecycle");
            DebugEventStream = Config.GetBoolean("akka.actor.debug.event-stream");
            DebugUnhandledMessage = Config.GetBoolean("akka.actor.debug.unhandled");
            DebugRouterMisConfiguration = Config.GetBoolean("akka.actor.debug.router-misconfiguration");
            Home = Config.GetString("akka.home") ?? "";

            //TODO: dunno.. we dont have FiniteStateMachines, dont know what the rest is
            /*              
                final val FsmDebugEvent: Boolean = getBoolean("akka.actor.debug.fsm")
                final val SchedulerClass: String = getString("akka.scheduler.implementation")
                final val Daemonicity: Boolean = getBoolean("akka.daemonic")                
                final val DefaultVirtualNodesFactor: Int = getInt("akka.actor.deployment.default.virtual-nodes-factor")
             */
        }
 protected ClusterSpecBase(Config config) : base(config.WithFallback(BaseConfig))
 {
     
 }
Exemple #7
0
        public static Config operator +(string configHocon, Config fallbackConfig)
        {
            Config config = ConfigurationFactory.ParseString(configHocon);

            return(config.WithFallback(fallbackConfig));
        }
Exemple #8
0
 public static Config SafeWithFallback(this Config config, Config fallback)
 {
     return(config == null ? fallback
         : ReferenceEquals(config, fallback) ? config
         : config.WithFallback(fallback));
 }
Exemple #9
0
        private static AkkaConfig LoadConfig(string environment, string configFile, IConfiguration configuration)
        {
            string akkaip   = configuration.GetSection("akkaip").Value ?? "127.0.0.1";
            string akkaport = configuration.GetSection("akkaport").Value ?? "5100";
            string akkaseed = configuration.GetSection("akkaseed").Value ?? "127.0.0.1:5100";
            string roles    = configuration.GetSection("roles").Value ?? "akkanet";

            var configFilePath = string.Format(configFile, environment.ToLower() != "production" ? string.Concat(".", environment) : "");

            if (File.Exists(configFilePath))
            {
                string akkaseed_array;
                if (akkaseed.Split(",").Length > 1)
                {
                    akkaseed_array = akkaseed.Split(",").Aggregate("[",
                                                                   (current, seed) => current + @"""" + seed + @""", ");
                    akkaseed_array += "]";
                }
                else
                {
                    akkaseed_array = "[\"" + akkaseed + "\"]";
                }

                string roles_array;
                if (roles.Split(",").Length > 1)
                {
                    roles_array = roles.Split(",").Aggregate("[",
                                                             (current, role) => current + @"""" + role + @""", ");
                    roles_array += "]";
                }
                else
                {
                    roles_array = "[\"" + roles + "\"]";
                }

                string customConfig = @"
                akka {
	                remote {
		                log-remote-lifecycle-events = debug
                        dot-netty.tcp {
                            port = $akkaport
			                hostname = $akkaip
                        }
                    }
	                cluster {
                        seed-nodes = $akkaseed
                        roles = $roles
                    }
                }    
                ".Replace("$akkaport", akkaport)
                                      .Replace("$akkaip", akkaip)
                                      .Replace("$akkaseed", akkaseed_array)
                                      .Replace("$roles", roles_array);

                AkkaConfig injectedClusterConfigString = customConfig;

                string configText = File.ReadAllText(configFilePath);

                var akkaConfig = ConfigurationFactory.ParseString(configText);

                var finalConfig = injectedClusterConfigString.WithFallback(akkaConfig);

                Console.WriteLine($"=== AkkaConfig:{configFilePath}\r\n{finalConfig}\r\n===");
                return(finalConfig);
            }
            return(ConfigurationFactory.Empty);
        }
 private static void CreateClusterNode(Config commonConfig, int port, params string[] roles)
 {
     var config = commonConfig
         .WithFallback("akka.remote.helios.tcp.port = " + port)
         .WithFallback("akka.cluster.roles = " + "[" + string.Join(",", roles) + "]");
     var system = ActorSystem.Create("BasicCluster", config);
     var cluster = Cluster.Get(system);
     var clusterNode = new ClusterNode
     {
         Context = new ClusterNodeContext
         {
             System = system,
             ClusterActorDiscovery = system.ActorOf(Props.Create(() => new ClusterActorDiscovery(cluster)),
                                                    "cluster_actor_discovery")
         },
         Roles = roles
     };
     InitClusterNode(clusterNode);
     _clusterNodes.Add(clusterNode);
 }
Exemple #11
0
        public static ActorSystem LaunchLighthouse(string ipAddress  = null, int?specifiedPort = null,
                                                   string systemName = null)
        {
            systemName = systemName ?? Environment.GetEnvironmentVariable("ACTORSYSTEM")?.Trim();


            // Set environment variables for use inside Akka.Bootstrap.Docker
            // If overrides were provided to this method.
            //if (!string.IsNullOrEmpty(ipAddress)) Environment.SetEnvironmentVariable("CLUSTER_IP", ipAddress);

            //if (specifiedPort != null)
            //    Environment.SetEnvironmentVariable("CLUSTER_PORT", specifiedPort.Value.ToString());

            var useDocker = !(IsNullOrEmpty(Environment.GetEnvironmentVariable("CLUSTER_IP")?.Trim()) ||
                              IsNullOrEmpty(Environment.GetEnvironmentVariable("CLUSTER_SEEDS")?.Trim()));

            var clusterConfig = ConfigurationFactory.ParseString(File.ReadAllText("akka.hocon"));

            if (useDocker)
            {
                clusterConfig = clusterConfig.BootstrapFromDocker();
            }

            var lighthouseConfig = clusterConfig.GetConfig("lighthouse");

            if (lighthouseConfig != null && IsNullOrEmpty(systemName))
            {
                systemName = lighthouseConfig.GetString("actorsystem", systemName);
            }

            ipAddress = clusterConfig.GetString("akka.remote.dot-netty.tcp.public-hostname", "127.0.0.1");
            var port = clusterConfig.GetInt("akka.remote.dot-netty.tcp.port");

            var sslEnabled  = clusterConfig.GetBoolean("akka.remote.dot-netty.tcp.enable-ssl");
            var selfAddress = sslEnabled ? new Address("akka.ssl.tcp", systemName, ipAddress.Trim(), port).ToString()
                    : new Address("akka.tcp", systemName, ipAddress.Trim(), port).ToString();

            /*
             * Sanity check
             */
            Console.WriteLine($"[Lighthouse] ActorSystem: {systemName}; IP: {ipAddress}; PORT: {port}");
            Console.WriteLine("[Lighthouse] Performing pre-boot sanity check. Should be able to parse address [{0}]",
                              selfAddress);
            Console.WriteLine("[Lighthouse] Parse successful.");


            var seeds = clusterConfig.GetStringList("akka.cluster.seed-nodes").ToList();

            AkkaConfig injectedClusterConfigString = null;


            if (!seeds.Contains(selfAddress))
            {
                seeds.Add(selfAddress);

                if (seeds.Count > 1)
                {
                    injectedClusterConfigString = seeds.Aggregate("akka.cluster.seed-nodes = [",
                                                                  (current, seed) => current + @"""" + seed + @""", ");
                    injectedClusterConfigString += "]";
                }
                else
                {
                    injectedClusterConfigString = "akka.cluster.seed-nodes = [\"" + selfAddress + "\"]";
                }
            }


            var finalConfig = injectedClusterConfigString != null
                ? injectedClusterConfigString
                              .WithFallback(clusterConfig)
                : clusterConfig;

            return(ActorSystem.Create(systemName, finalConfig));
        }
        public override Deploy ParseConfig(string key, Config config)
        {
            Config config2 = config;
            if (config.HasPath("cluster.enabled")
                && config.GetBoolean("cluster.enabled")
                && !config.HasPath("nr-of-instances"))
            {
                var maxTotalNrOfInstances = config
                    .WithFallback(Default)
                    .GetInt("cluster.max-total-nr-of-instances");
                config2 = ConfigurationFactory.ParseString("nr-of-instances=" + maxTotalNrOfInstances)
                    .WithFallback(config);
            }

            var deploy = base.ParseConfig(key, config2);
            if (deploy != null)
            {
                if (deploy.Config.GetBoolean("cluster.enabled"))
                {
                    if (deploy.Scope != Deploy.NoScopeGiven)
                        throw new ConfigurationException(string.Format("Cluster deployment can't be combined with scope [{0}]", deploy.Scope));
                    if (deploy.RouterConfig is RemoteRouterConfig)
                        throw new ConfigurationException(string.Format("Cluster deployment can't be combined with [{0}]", deploy.Config));

                    if (deploy.RouterConfig is Pool)
                    {
                        return
                            deploy.WithScope(scope: ClusterScope.Instance)
                                .WithRouterConfig(new ClusterRouterPool(deploy.RouterConfig as Pool,
                                    ClusterRouterPoolSettings.FromConfig(deploy.Config)));
                    }
                    else if (deploy.RouterConfig is Group)
                    {
                        return
                            deploy.WithScope(scope: ClusterScope.Instance)
                                .WithRouterConfig(new ClusterRouterGroup(deploy.RouterConfig as Group,
                                    ClusterRouterGroupSettings.FromConfig(deploy.Config)));
                    }
                    else
                    {
                        throw new ArgumentException(string.Format("Cluster-aware router can only wrap Pool or Group, got [{0}]", deploy.RouterConfig.GetType()));
                    }
                }
                else
                {
                    return deploy;
                }
            }
            else
            {
                return null;
            }
        }