AKKA 2.3.6 Scala 文档

配置

你开始使用Akka时可以不需要定义任何配置，因为Akka提供了合理的默认值。不过为了适应特定的运行环境，你可能需要修改设置来更改默认行为。可以修改的典型设置的例子：

  • 日志级别和后端记录器
  • 启用远程
  • 消息序列化
  • 路由器定义
  • 调度的调整

Akka使用Typesafe配置库，它同样也是你自己的应用或库的不错选择，不管你用不用Akka。这个库由Java实现，没有外部的依赖；本文后面将只对这个库有一些归纳，你应该查看其文档参考具体的使用（尤其是ConfigFactory）。

警告

如果你在Scala REPL的2.9.x系列版本中使用Akka，并且你不提供自己的ClassLoader给ActorSystem，则需要以“-Yrepl-sync”选项启动REPL来解决上下文ClassLoader的缺陷。

配置读取的地方

Akka的所有配置都保存在ActorSystem的实例中，或者换一种说法，从外界来看，ActorSystem是配置信息的唯一消费者。在构造一个actor系统时，你可以选择传进一个Config对象，如果不传则等效于传入ConfigFactory.load()（通过正确的类加载器）。粗略的讲，这意味着默认会解析classpath根目录下所有的application.conf，application.json和application.properties文件——请参考前面提到的文档以获取细节。然后actor系统会合并classpath根目录下的所有 reference.conf行成后备配置，也就是说，它在内部使用

  1.   appConfig.withFallback(ConfigFactory.defaultReference(classLoader))

其哲学是代码永远不包含缺省值，相反是依赖于随库提供的 reference.conf 中的配置。

系统属性中覆盖的配置具有最高优先级，参见HOCON 规范（靠近末尾的位置）。此外值得注意的是，应用程序配置——缺省为application——可以使用config.resource属性重写 （还有更多，请参阅配置文档）。

注意

如果你正在编写一个Akka 应用，将你的配置保存类路径的根目录下的application.conf文件中。如果你正在编写一个基于Akka的库，将其配置保存在JAR包根目录下的reference.conf文件中。

当使用JarJar,，OneJar，Assembly或任何jar打包命令（jar-bundler）

警告

Akka的配置方法重度依赖于这个理念——每一模块/jar都有它自己的 reference.conf文件，所有这些都将会被配置发现并加载。不幸的是，这也意味着如果你放置/合并多个jar到相同的 jar中，你也需要合并所有的reference.conf文件。否则所有的默认设置将会丢失，Akka将无法工作。

如果你使用 Maven 打包应用程序，你还可以使用Apache Maven Shade Plugin中对资源转换（Resource Transformers）的支持，来将所有构建类路径中的reference.conf合并为一个文件。

插件配置可能如下所示：

  1.     <plugin>
  2.      <groupId>org.apache.maven.plugins</groupId>
  3.      <artifactId>maven-shade-plugin</artifactId>
  4.      <version>1.5</version>
  5.      <executions>
  6.       <execution>
  7.        <phase>package</phase>
  8.        <goals>
  9.         <goal>shade</goal>
  10.        </goals>
  11.        <configuration>
  12.         <shadedArtifactAttached>true</shadedArtifactAttached>
  13.         <shadedClassifierName>allinone</shadedClassifierName>
  14.         <artifactSet>
  15.          <includes>
  16.           <include>*:*</include>
  17.          </includes>
  18.         </artifactSet>
  19.         <transformers>
  20.           <transformer
  21.            implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
  22.            <resource>reference.conf</resource>
  23.           </transformer>
  24.           <transformer
  25.            implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
  26.            <manifestEntries>
  27.             <Main-Class>akka.Main</Main-Class>
  28.            </manifestEntries>
  29.           </transformer>
  30.         </transformers>
  31.        </configuration>
  32.       </execution>
  33.      </executions>
  34.     </plugin>

自定义application.conf

一个自定义的`application.conf可能看起来像这样：

  1.   # In this file you can override any option defined in the reference files.
  2.   # Copy in parts of the reference files and modify as you please.
  4.   akka {
  6.     # Loggers to register at boot time (akka.event.Logging$DefaultLogger logs
  7.     # to STDOUT)
  8.     loggers = ["akka.event.slf4j.Slf4jLogger"]
  10.     # Log level used by the configured loggers (see "loggers") as soon
  11.     # as they have been started; before that, see "stdout-loglevel"
  12.     # Options: OFF, ERROR, WARNING, INFO, DEBUG
  13.     loglevel = "DEBUG"
  15.     # Log level for the very basic logger activated during ActorSystem startup.
  16.     # This logger prints the log messages to stdout (System.out).
  17.     # Options: OFF, ERROR, WARNING, INFO, DEBUG
  18.     stdout-loglevel = "DEBUG"
  20.     actor {
  21.       provider = "akka.cluster.ClusterActorRefProvider"
  23.       default-dispatcher {
  24.         # Throughput for default Dispatcher, set to 1 for as fair as possible
  25.         throughput = 10
  26.       }
  27.     }
  29.     remote {
  30.       # The port clients should connect to. Default is 2552.
  31.       netty.tcp.port = 4711
  32.     }
  33.   }

包含文件

有时包含另一个配置文件内容的能力是非常有用的，例如假设你有一个application.conf包含所有环境独立设置，然后使用特定环境的设置覆写。

用-Dconfig.resource=/dev.conf制定系统属性，将会加载dev.conf文件，并包含application.conf

dev.conf:

  1.   include "application"
  3.   akka {
  4.     loglevel = "DEBUG"
  5.   }

更高级的包括和替换机制的解释在HOCON规范中。

配置日志

如果系统或配置属性akka.log-config-on-start 被设置为 on，则在actor系统启动的时候，就完成了INFO级别的日志设置。当你不能确定使用何种配置时，这很有用。

如果有疑问，你也可以在创建actor系统之前或之后，很容易很方便地检查配置对象：

  1.   Welcome to Scala version @scalaVersion@ (Java HotSpot(TM) 64-Bit Server VM, Java 1.6.0_27).
  2.   Type in expressions to have them evaluated.
  3.   Type :help for more information.
  5.   scala> import com.typesafe.config._
  6.   import com.typesafe.config._
  8.   scala> ConfigFactory.parseString("a.b=12")
  9.   res0: com.typesafe.config.Config = Config(SimpleConfigObject({"a" : {"b" : 12}}))
  11.   scala> res0.root.render
  12.   res1: java.lang.String =
  13.   {
  14.       # String: 1
  15.       "a" : {
  16.           # String: 1
  17.           "b" : 12
  18.       }
  19.   }

展示结果中，每个项目前会有评论展示这个配置的起源（对应的文件和行数），并展示已存在的评论，如配置参考中的。actor系统合并参考并解析后形成的设置，可以这样显示：

  1.   final ActorSystem system = ActorSystem.create();
  2.   System.out.println(system.settings());
  3.   // this is a shortcut for system.settings().config().root().render()

谈一谈类加载器

在配置文件的几个地方，可以通过制定类的全名来让Akka实例化该类。这是通过Java反射完成的，相应地用到了一个ClassLoader。在具有挑战性的环境中，如应用容器和OSGi绑定中，选择正确的类加载器并不总是一件简单的事情，Akka的现行做法是每个 ActorSystem 实现存储当前线程的上下文类加载器（如果可用，否则就使用他自己的加载器this.getClass.getClassLoader），并使用它为所有的反射访问服务。这意味着Akka放在引导类路径（boot class path）下，会从奇怪的地方产生NullPointerException： 这里就是不支持。

应用特定设置

配置也可用于应用程序特定的设置。一个好的实践是将这些设置放在一个扩展中，像下面的章节所描述的：

配置多个ActorSystem

如果你有一个以上的ActorSystem（或你正在写一个库，有可能有一个独立于应用的 ActorSystem） 你可能想要为每个系统进行单独配置。

由于 ConfigFactory.load() 会合并classpath中所有匹配名称的资源, 最简单的方式是利用这一功能并在配置树中区分actor系统:

  1.   myapp1 {
  2.     akka.loglevel = "WARNING"
  3.     my.own.setting = 43
  4.   }
  5.   myapp2 {
  6.     akka.loglevel = "ERROR"
  7.     app2.setting = "appname"
  8.   }
  9.   my.own.setting = 42
  10.   my.other.setting = "hello"
  1.   val config = ConfigFactory.load()
  2.   val app1 = ActorSystem("MyApp1", config.getConfig("myapp1").withFallback(config))
  3.   val app2 = ActorSystem("MyApp2",
  4.     config.getConfig("myapp2").withOnlyPath("akka").withFallback(config))

这两个例子演示了“提升子树”技巧的不同变种: 第一种情况下，actor系统获得的配置是

  1.   akka.loglevel = "WARNING"
  2.   my.own.setting = 43
  3.   my.other.setting = "hello"
  4.   // plus myapp1 and myapp2 subtrees

而在第二种情况下，只有 “akka” 子树被提升了，结果如下:

  1.   akka.loglevel = "ERROR"
  2.   my.own.setting = 42
  3.   my.other.setting = "hello"
  4.   // plus myapp1 and myapp2 subtrees

注意

这个配置文件库非常强大，这里不可能解释其所有的功能。特别是如何在配置文件中包含其它的配置文件 (在包含文件Including files中有一个简单的例子) 以及通过路径替换来复制部分配置树。

你也可以在初始化ActorSystem时，通过代码的形式，使用其它方法来指定和解析配置信息。

  1. import akka.actor.ActorSystem
  2. import com.typesafe.config.ConfigFactory
  3.     val customConf = ConfigFactory.parseString("""
  4.       akka.actor.deployment {
  5.         /my-service {
  6.           router = round-robin-pool
  7.           nr-of-instances = 3
  8.         }
  9.       }
  10.       """)
  11.     // ConfigFactory.load sandwiches customConfig between default reference
  12.     // config and default overrides, and then resolves it.
  13.     val system = ActorSystem("MySystem", ConfigFactory.load(customConf))

从自定义位置读取配置

你可以使用代码或系统属性，来替换或补充application.conf 。

如果你使用的方法是ConfigFactory.load()（Akka默认方式），你可以通过定义-Dconfig.resource=whatever、-Dconfig.file=whatever或 -Dconfig.url=whatever替换 application.conf。

在-Dconfig.resource和相关选项指定的替换配置文件中，如果你还想使用application.{conf,json,properties}，可以使用include "application"。在include "application"之前指定的设置会被包含进来的文件内容重写，同理所包含文件的内容也会被之后的内容重写。

在代码中，有很多自定义选项。

ConfigFactory.load()有几个重载；这些重载允许你指定夹在 系统属性（重写）和默认值（来自reference.conf）之间的配置，并替换通常的application.{conf,json,properties}和-Dconfig.file相关选项。

ConfigFactory.load() 最简单的变体需要资源基本名称（application之外的）；如myname.conf、myname.json和myname.properties而不是application.{conf,json,properties}。

最灵活的变体是以一个Config对象为参数，你可以使用ConfigFactory中的任何方法加载。例如，你可以在代码中使用ConfigFactory.parseString()处理一个配置字符串，或者你可以使用ConfigFactory.parseMap()创建一个映射，或者也可以加载一个文件。

你也可以将自定义的配置与通常的配置组合起来，像这样：

  1. // make a Config with just your special setting
  2. Config myConfig =
  3.   ConfigFactory.parseString("something=somethingElse");
  4. // load the normal config stack (system props,
  5. // then application.conf, then reference.conf)
  6. Config regularConfig =
  7.   ConfigFactory.load();
  8. // override regular stack with myConfig
  9. Config combined =
  10.   myConfig.withFallback(regularConfig);
  11. // put the result in between the overrides
  12. // (system props) and defaults again
  13. Config complete =
  14.   ConfigFactory.load(combined);
  15. // create ActorSystem
  16. ActorSystem system =
  17.   ActorSystem.create("myname", complete);

使用Config对象时，请牢记这个蛋糕有三"层"：

  • ConfigFactory.defaultOverrides()（系统属性）
  • 应用设置
  • ConfigFactory.defaultReference()（reference.conf）

正常的目标是要自定义中间一层，不管其他两个。

  • ConfigFactory.load()加载整个堆栈
  • ConfigFactory.load()的重载允许你指定一个不同的中间层
  • ConfigFactory.parse()变体加载单个文件或资源

要叠加两层，可使用override.withFallback(fallback)；请努力保持系统属性（defaultOverrides()）在顶部，reference.conf （defaultReference()）在底部。

要记住，通常你只需要在application.conf添加一个include语句，而不是编写代码。在application.conf顶部引入的将被application.conf其余部分覆盖，而那些在底部的设置将覆盖以前的内容。

Actor部署配置

可以在配置的akka.actor.deployment节中定义特定actor的部署设置。在部署部分有可能定义这些事物——调度器、邮箱、路由器设置和远程部署。在相应主题的章节中详细介绍了配置的这些特性。一个例子，可以如下所示：

  1. akka.actor.deployment {
  3.   # '/user/actorA/actorB' is a remote deployed actor
  4.   /actorA/actorB {
  5.     remote = "akka.tcp://sampleActorSystem@127.0.0.1:2553"
  6.   }
  8.   # all direct children of '/user/actorC' have a dedicated dispatcher
  9.   "/actorC/*" {
  10.     dispatcher = my-dispatcher
  11.   }
  13.   # '/user/actorD/actorE' has a special priority mailbox
  14.   /actorD/actorE {
  15.     mailbox = prio-mailbox
  16.   }
  18.   # '/user/actorF/actorG/actorH' is a random pool
  19.   /actorF/actorG/actorH {
  20.     router = random-pool
  21.     nr-of-instances = 5
  22.   }
  23. }
  25. my-dispatcher {
  26.   fork-join-executor.parallelism-min = 10
  27.   fork-join-executor.parallelism-max = 10
  28. }
  29. prio-mailbox {
  30.   mailbox-type = "a.b.MyPrioMailbox"
  31. }

一个指定actor部署部分的设置是通过其相对 /user的路径来标识的。

你可以使用星号作为通配符匹配actor的路径部分，所以你可以指定：/*/sampleActor将匹配该树形结构中那个级别上的所有sampleActor。你也能把通配符放在最后来匹配某一级别的所有actor：/someParent/*。非通配符匹配总是有更高的优先级，所以：/foo/bar比/foo/* 更具体，并且只有最高优先的匹配才会被使用。请注意它不能用于部分匹配，像这样：/foo*/bar、/f*o/bar 等。

参考配置清单

每个Akka模块都有保存默认值的“reference”配置文件。

akka-actor
  1. ####################################
  2. # Akka Actor Reference Config File #
  3. ####################################
  5. # This is the reference config file that contains all the default settings.
  6. # Make your edits/overrides in your application.conf.
  8. akka {
  9.   # Akka version, checked against the runtime version of Akka.
  10.   version = "2.3.6"
  12.   # Home directory of Akka, modules in the deploy directory will be loaded
  13.   home = ""
  15.   # Loggers to register at boot time (akka.event.Logging$DefaultLogger logs
  16.   # to STDOUT)
  17.   loggers = ["akka.event.Logging$DefaultLogger"]
  19.   # Loggers are created and registered synchronously during ActorSystem
  20.   # start-up, and since they are actors, this timeout is used to bound the
  21.   # waiting time
  22.   logger-startup-timeout = 5s
  24.   # Log level used by the configured loggers (see "loggers") as soon
  25.   # as they have been started; before that, see "stdout-loglevel"
  26.   # Options: OFF, ERROR, WARNING, INFO, DEBUG
  27.   loglevel = "INFO"
  29.   # Log level for the very basic logger activated during ActorSystem startup.
  30.   # This logger prints the log messages to stdout (System.out).
  31.   # Options: OFF, ERROR, WARNING, INFO, DEBUG
  32.   stdout-loglevel = "WARNING"
  34.   # Log the complete configuration at INFO level when the actor system is started.
  35.   # This is useful when you are uncertain of what configuration is used.
  36.   log-config-on-start = off
  38.   # Log at info level when messages are sent to dead letters.
  39.   # Possible values:
  40.   # on: all dead letters are logged
  41.   # off: no logging of dead letters
  42.   # n: positive integer, number of dead letters that will be logged
  43.   log-dead-letters = 10
  45.   # Possibility to turn off logging of dead letters while the actor system
  46.   # is shutting down. Logging is only done when enabled by 'log-dead-letters'
  47.   # setting.
  48.   log-dead-letters-during-shutdown = on
  50.   # List FQCN of extensions which shall be loaded at actor system startup.
  51.   # Should be on the format: 'extensions = ["foo", "bar"]' etc.
  52.   # See the Akka Documentation for more info about Extensions
  53.   extensions = []
  55.   # Toggles whether threads created by this ActorSystem should be daemons or not
  56.   daemonic = off
  58.   # JVM shutdown, System.exit(-1), in case of a fatal error,
  59.   # such as OutOfMemoryError
  60.   jvm-exit-on-fatal-error = on
  62.   actor {
  64.     # FQCN of the ActorRefProvider to be used; the below is the built-in default,
  65.     # another one is akka.remote.RemoteActorRefProvider in the akka-remote bundle.
  66.     provider = "akka.actor.LocalActorRefProvider"
  68.     # The guardian "/user" will use this class to obtain its supervisorStrategy.
  69.     # It needs to be a subclass of akka.actor.SupervisorStrategyConfigurator.
  70.     # In addition to the default there is akka.actor.StoppingSupervisorStrategy.
  71.     guardian-supervisor-strategy = "akka.actor.DefaultSupervisorStrategy"
  73.     # Timeout for ActorSystem.actorOf
  74.     creation-timeout = 20s
  76.     # Frequency with which stopping actors are prodded in case they had to be
  77.     # removed from their parents
  78.     reaper-interval = 5s
  80.     # Serializes and deserializes (non-primitive) messages to ensure immutability,
  81.     # this is only intended for testing.
  82.     serialize-messages = off
  84.     # Serializes and deserializes creators (in Props) to ensure that they can be
  85.     # sent over the network, this is only intended for testing. Purely local deployments
  86.     # as marked with deploy.scope == LocalScope are exempt from verification.
  87.     serialize-creators = off
  89.     # Timeout for send operations to top-level actors which are in the process
  90.     # of being started. This is only relevant if using a bounded mailbox or the
  91.     # CallingThreadDispatcher for a top-level actor.
  92.     unstarted-push-timeout = 10s
  94.     typed {
  95.       # Default timeout for typed actor methods with non-void return type
  96.       timeout = 5s
  97.     }
  99.     # Mapping between ´deployment.router' short names to fully qualified class names
  100.     router.type-mapping {
  101.       from-code = "akka.routing.NoRouter"
  102.       round-robin-pool = "akka.routing.RoundRobinPool"
  103.       round-robin-group = "akka.routing.RoundRobinGroup"
  104.       random-pool = "akka.routing.RandomPool"
  105.       random-group = "akka.routing.RandomGroup"
  106.       balancing-pool = "akka.routing.BalancingPool"
  107.       smallest-mailbox-pool = "akka.routing.SmallestMailboxPool"
  108.       broadcast-pool = "akka.routing.BroadcastPool"
  109.       broadcast-group = "akka.routing.BroadcastGroup"
  110.       scatter-gather-pool = "akka.routing.ScatterGatherFirstCompletedPool"
  111.       scatter-gather-group = "akka.routing.ScatterGatherFirstCompletedGroup"
  112.       tail-chopping-pool = "akka.routing.TailChoppingPool"
  113.       tail-chopping-group = "akka.routing.TailChoppingGroup"
  114.       consistent-hashing-pool = "akka.routing.ConsistentHashingPool"
  115.       consistent-hashing-group = "akka.routing.ConsistentHashingGroup"
  116.     }
  118.     deployment {
  120.       # deployment id pattern - on the format: /parent/child etc.
  121.       default {
  123.         # The id of the dispatcher to use for this actor.
  124.         # If undefined or empty the dispatcher specified in code
  125.         # (Props.withDispatcher) is used, or default-dispatcher if not
  126.         # specified at all.
  127.         dispatcher = ""
  129.         # The id of the mailbox to use for this actor.
  130.         # If undefined or empty the default mailbox of the configured dispatcher
  131.         # is used or if there is no mailbox configuration the mailbox specified
  132.         # in code (Props.withMailbox) is used.
  133.         # If there is a mailbox defined in the configured dispatcher then that
  134.         # overrides this setting.
  135.         mailbox = ""
  137.         # routing (load-balance) scheme to use
  138.         # - available: "from-code", "round-robin", "random", "smallest-mailbox",
  139.         #              "scatter-gather", "broadcast"
  140.         # - or:        Fully qualified class name of the router class.
  141.         #              The class must extend akka.routing.CustomRouterConfig and
  142.         #              have a public constructor with com.typesafe.config.Config
  143.         #              and optional akka.actor.DynamicAccess parameter.
  144.         # - default is "from-code";
  145.         # Whether or not an actor is transformed to a Router is decided in code
  146.         # only (Props.withRouter). The type of router can be overridden in the
  147.         # configuration; specifying "from-code" means that the values specified
  148.         # in the code shall be used.
  149.         # In case of routing, the actors to be routed to can be specified
  150.         # in several ways:
  151.         # - nr-of-instances: will create that many children
  152.         # - routees.paths: will route messages to these paths using ActorSelection,
  153.         #   i.e. will not create children
  154.         # - resizer: dynamically resizable number of routees as specified in
  155.         #   resizer below
  156.         router = "from-code"
  158.         # number of children to create in case of a router;
  159.         # this setting is ignored if routees.paths is given
  160.         nr-of-instances = 1
  162.         # within is the timeout used for routers containing future calls
  163.         within = 5 seconds
  165.         # number of virtual nodes per node for consistent-hashing router
  166.         virtual-nodes-factor = 10
  168.         tail-chopping-router {
  169.           # interval is duration between sending message to next routee
  170.           interval = 10 milliseconds
  171.         }
  173.         routees {
  174.           # Alternatively to giving nr-of-instances you can specify the full
  175.           # paths of those actors which should be routed to. This setting takes
  176.           # precedence over nr-of-instances
  177.           paths = []
  178.         }
  180.         # To use a dedicated dispatcher for the routees of the pool you can
  181.         # define the dispatcher configuration inline with the property name
  182.         # 'pool-dispatcher' in the deployment section of the router.
  183.         # For example:
  184.         # pool-dispatcher {
  185.         #   fork-join-executor.parallelism-min = 5
  186.         #   fork-join-executor.parallelism-max = 5
  187.         # }
  189.         # Routers with dynamically resizable number of routees; this feature is
  190.         # enabled by including (parts of) this section in the deployment
  191.         resizer {
  193.           enabled = off
  195.           # The fewest number of routees the router should ever have.
  196.           lower-bound = 1
  198.           # The most number of routees the router should ever have.
  199.           # Must be greater than or equal to lower-bound.
  200.           upper-bound = 10
  202.           # Threshold used to evaluate if a routee is considered to be busy
  203.           # (under pressure). Implementation depends on this value (default is 1).
  204.           # 0:   number of routees currently processing a message.
  205.           # 1:   number of routees currently processing a message has
  206.           #      some messages in mailbox.
  207.           # > 1: number of routees with at least the configured pressure-threshold
  208.           #      messages in their mailbox. Note that estimating mailbox size of
  209.           #      default UnboundedMailbox is O(N) operation.
  210.           pressure-threshold = 1
  212.           # Percentage to increase capacity whenever all routees are busy.
  213.           # For example, 0.2 would increase 20% (rounded up), i.e. if current
  214.           # capacity is 6 it will request an increase of 2 more routees.
  215.           rampup-rate = 0.2
  217.           # Minimum fraction of busy routees before backing off.
  218.           # For example, if this is 0.3, then we'll remove some routees only when
  219.           # less than 30% of routees are busy, i.e. if current capacity is 10 and
  220.           # 3 are busy then the capacity is unchanged, but if 2 or less are busy
  221.           # the capacity is decreased.
  222.           # Use 0.0 or negative to avoid removal of routees.
  223.           backoff-threshold = 0.3
  225.           # Fraction of routees to be removed when the resizer reaches the
  226.           # backoffThreshold.
  227.           # For example, 0.1 would decrease 10% (rounded up), i.e. if current
  228.           # capacity is 9 it will request an decrease of 1 routee.
  229.           backoff-rate = 0.1
  231.           # Number of messages between resize operation.
  232.           # Use 1 to resize before each message.
  233.           messages-per-resize = 10
  234.         }
  235.       }
  236.     }
  238.     default-dispatcher {
  239.       # Must be one of the following
  240.       # Dispatcher, PinnedDispatcher, or a FQCN to a class inheriting
  241.       # MessageDispatcherConfigurator with a public constructor with
  242.       # both com.typesafe.config.Config parameter and
  243.       # akka.dispatch.DispatcherPrerequisites parameters.
  244.       # PinnedDispatcher must be used together with executor=thread-pool-executor.
  245.       type = "Dispatcher"
  247.       # Which kind of ExecutorService to use for this dispatcher
  248.       # Valid options:
  249.       #  - "default-executor" requires a "default-executor" section
  250.       #  - "fork-join-executor" requires a "fork-join-executor" section
  251.       #  - "thread-pool-executor" requires a "thread-pool-executor" section
  252.       #  - A FQCN of a class extending ExecutorServiceConfigurator
  253.       executor = "default-executor"
  255.       # This will be used if you have set "executor = "default-executor"".
  256.       # If an ActorSystem is created with a given ExecutionContext, this
  257.       # ExecutionContext will be used as the default executor for all
  258.       # dispatchers in the ActorSystem configured with
  259.       # executor = "default-executor". Note that "default-executor"
  260.       # is the default value for executor, and therefore used if not
  261.       # specified otherwise. If no ExecutionContext is given,
  262.       # the executor configured in "fallback" will be used.
  263.       default-executor {
  264.         fallback = "fork-join-executor"
  265.       }
  267.       # This will be used if you have set "executor = "fork-join-executor""
  268.       fork-join-executor {
  269.         # Min number of threads to cap factor-based parallelism number to
  270.         parallelism-min = 8
  272.         # The parallelism factor is used to determine thread pool size using the
  273.         # following formula: ceil(available processors * factor). Resulting size
  274.         # is then bounded by the parallelism-min and parallelism-max values.
  275.         parallelism-factor = 3.0
  277.         # Max number of threads to cap factor-based parallelism number to
  278.         parallelism-max = 64
  279.       }
  281.       # This will be used if you have set "executor = "thread-pool-executor""
  282.       thread-pool-executor {
  283.         # Keep alive time for threads
  284.         keep-alive-time = 60s
  286.         # Min number of threads to cap factor-based core number to
  287.         core-pool-size-min = 8
  289.         # The core pool size factor is used to determine thread pool core size
  290.         # using the following formula: ceil(available processors * factor).
  291.         # Resulting size is then bounded by the core-pool-size-min and
  292.         # core-pool-size-max values.
  293.         core-pool-size-factor = 3.0
  295.         # Max number of threads to cap factor-based number to
  296.         core-pool-size-max = 64
  298.         # Minimum number of threads to cap factor-based max number to
  299.         # (if using a bounded task queue)
  300.         max-pool-size-min = 8
  302.         # Max no of threads (if using a bounded task queue) is determined by
  303.         # calculating: ceil(available processors * factor)
  304.         max-pool-size-factor  = 3.0
  306.         # Max number of threads to cap factor-based max number to
  307.         # (if using a  bounded task queue)
  308.         max-pool-size-max = 64
  310.         # Specifies the bounded capacity of the task queue (< 1 == unbounded)
  311.         task-queue-size = -1
  313.         # Specifies which type of task queue will be used, can be "array" or
  314.         # "linked" (default)
  315.         task-queue-type = "linked"
  317.         # Allow core threads to time out
  318.         allow-core-timeout = on
  319.       }
  321.       # How long time the dispatcher will wait for new actors until it shuts down
  322.       shutdown-timeout = 1s
  324.       # Throughput defines the number of messages that are processed in a batch
  325.       # before the thread is returned to the pool. Set to 1 for as fair as possible.
  326.       throughput = 5
  328.       # Throughput deadline for Dispatcher, set to 0 or negative for no deadline
  329.       throughput-deadline-time = 0ms
  331.       # For BalancingDispatcher: If the balancing dispatcher should attempt to
  332.       # schedule idle actors using the same dispatcher when a message comes in,
  333.       # and the dispatchers ExecutorService is not fully busy already.
  334.       attempt-teamwork = on
  336.       # If this dispatcher requires a specific type of mailbox, specify the
  337.       # fully-qualified class name here; the actually created mailbox will
  338.       # be a subtype of this type. The empty string signifies no requirement.
  339.       mailbox-requirement = ""
  340.     }
  342.     default-mailbox {
  343.       # FQCN of the MailboxType. The Class of the FQCN must have a public
  344.       # constructor with
  345.       # (akka.actor.ActorSystem.Settings, com.typesafe.config.Config) parameters.
  346.       mailbox-type = "akka.dispatch.UnboundedMailbox"
  348.       # If the mailbox is bounded then it uses this setting to determine its
  349.       # capacity. The provided value must be positive.
  350.       # NOTICE:
  351.       # Up to version 2.1 the mailbox type was determined based on this setting;
  352.       # this is no longer the case, the type must explicitly be a bounded mailbox.
  353.       mailbox-capacity = 1000
  355.       # If the mailbox is bounded then this is the timeout for enqueueing
  356.       # in case the mailbox is full. Negative values signify infinite
  357.       # timeout, which should be avoided as it bears the risk of dead-lock.
  358.       mailbox-push-timeout-time = 10s
  360.       # For Actor with Stash: The default capacity of the stash.
  361.       # If negative (or zero) then an unbounded stash is used (default)
  362.       # If positive then a bounded stash is used and the capacity is set using
  363.       # the property
  364.       stash-capacity = -1
  365.     }
  367.     mailbox {
  368.       # Mapping between message queue semantics and mailbox configurations.
  369.       # Used by akka.dispatch.RequiresMessageQueue[T] to enforce different
  370.       # mailbox types on actors.
  371.       # If your Actor implements RequiresMessageQueue[T], then when you create
  372.       # an instance of that actor its mailbox type will be decided by looking
  373.       # up a mailbox configuration via T in this mapping
  374.       requirements {
  375.         "akka.dispatch.UnboundedMessageQueueSemantics" =
  376.           akka.actor.mailbox.unbounded-queue-based
  377.         "akka.dispatch.BoundedMessageQueueSemantics" =
  378.           akka.actor.mailbox.bounded-queue-based
  379.         "akka.dispatch.DequeBasedMessageQueueSemantics" =
  380.           akka.actor.mailbox.unbounded-deque-based
  381.         "akka.dispatch.UnboundedDequeBasedMessageQueueSemantics" =
  382.           akka.actor.mailbox.unbounded-deque-based
  383.         "akka.dispatch.BoundedDequeBasedMessageQueueSemantics" =
  384.           akka.actor.mailbox.bounded-deque-based
  385.         "akka.dispatch.MultipleConsumerSemantics" =
  386.           akka.actor.mailbox.unbounded-queue-based
  387.       }
  389.       unbounded-queue-based {
  390.         # FQCN of the MailboxType, The Class of the FQCN must have a public
  391.         # constructor with (akka.actor.ActorSystem.Settings,
  392.         # com.typesafe.config.Config) parameters.
  393.         mailbox-type = "akka.dispatch.UnboundedMailbox"
  394.       }
  396.       bounded-queue-based {
  397.         # FQCN of the MailboxType, The Class of the FQCN must have a public
  398.         # constructor with (akka.actor.ActorSystem.Settings,
  399.         # com.typesafe.config.Config) parameters.
  400.         mailbox-type = "akka.dispatch.BoundedMailbox"
  401.       }
  403.       unbounded-deque-based {
  404.         # FQCN of the MailboxType, The Class of the FQCN must have a public
  405.         # constructor with (akka.actor.ActorSystem.Settings,
  406.         # com.typesafe.config.Config) parameters.
  407.         mailbox-type = "akka.dispatch.UnboundedDequeBasedMailbox"
  408.       }
  410.       bounded-deque-based {
  411.         # FQCN of the MailboxType, The Class of the FQCN must have a public
  412.         # constructor with (akka.actor.ActorSystem.Settings,
  413.         # com.typesafe.config.Config) parameters.
  414.         mailbox-type = "akka.dispatch.BoundedDequeBasedMailbox"
  415.       }
  416.     }
  418.     debug {
  419.       # enable function of Actor.loggable(), which is to log any received message
  420.       # at DEBUG level, see the “Testing Actor Systems” section of the Akka
  421.       # Documentation at http://akka.io/docs
  422.       receive = off
  424.       # enable DEBUG logging of all AutoReceiveMessages (Kill, PoisonPill et.c.)
  425.       autoreceive = off
  427.       # enable DEBUG logging of actor lifecycle changes
  428.       lifecycle = off
  430.       # enable DEBUG logging of all LoggingFSMs for events, transitions and timers
  431.       fsm = off
  433.       # enable DEBUG logging of subscription changes on the eventStream
  434.       event-stream = off
  436.       # enable DEBUG logging of unhandled messages
  437.       unhandled = off
  439.       # enable WARN logging of misconfigured routers
  440.       router-misconfiguration = off
  441.     }
  443.     # Entries for pluggable serializers and their bindings.
  444.     serializers {
  445.       java = "akka.serialization.JavaSerializer"
  446.       bytes = "akka.serialization.ByteArraySerializer"
  447.     }
  449.     # Class to Serializer binding. You only need to specify the name of an
  450.     # interface or abstract base class of the messages. In case of ambiguity it
  451.     # is using the most specific configured class, or giving a warning and
  452.     # choosing the “first” one.
  453.     #
  454.     # To disable one of the default serializers, assign its class to "none", like
  455.     # "java.io.Serializable" = none
  456.     serialization-bindings {
  457.       "[B" = bytes
  458.       "java.io.Serializable" = java
  459.     }
  461.     # Configuration items which are used by the akka.actor.ActorDSL._ methods
  462.     dsl {
  463.       # Maximum queue size of the actor created by newInbox(); this protects
  464.       # against faulty programs which use select() and consistently miss messages
  465.       inbox-size = 1000
  467.       # Default timeout to assume for operations like Inbox.receive et al
  468.       default-timeout = 5s
  469.     }
  470.   }
  472.   # Used to set the behavior of the scheduler.
  473.   # Changing the default values may change the system behavior drastically so make
  474.   # sure you know what you're doing! See the Scheduler section of the Akka
  475.   # Documentation for more details.
  476.   scheduler {
  477.     # The LightArrayRevolverScheduler is used as the default scheduler in the
  478.     # system. It does not execute the scheduled tasks on exact time, but on every
  479.     # tick, it will run everything that is (over)due. You can increase or decrease
  480.     # the accuracy of the execution timing by specifying smaller or larger tick
  481.     # duration. If you are scheduling a lot of tasks you should consider increasing
  482.     # the ticks per wheel.
  483.     # Note that it might take up to 1 tick to stop the Timer, so setting the
  484.     # tick-duration to a high value will make shutting down the actor system
  485.     # take longer.
  486.     tick-duration = 10ms
  488.     # The timer uses a circular wheel of buckets to store the timer tasks.
  489.     # This should be set such that the majority of scheduled timeouts (for high
  490.     # scheduling frequency) will be shorter than one rotation of the wheel
  491.     # (ticks-per-wheel * ticks-duration)
  492.     # THIS MUST BE A POWER OF TWO!
  493.     ticks-per-wheel = 512
  495.     # This setting selects the timer implementation which shall be loaded at
  496.     # system start-up.
  497.     # The class given here must implement the akka.actor.Scheduler interface
  498.     # and offer a public constructor which takes three arguments:
  499.     #  1) com.typesafe.config.Config
  500.     #  2) akka.event.LoggingAdapter
  501.     #  3) java.util.concurrent.ThreadFactory
  502.     implementation = akka.actor.LightArrayRevolverScheduler
  504.     # When shutting down the scheduler, there will typically be a thread which
  505.     # needs to be stopped, and this timeout determines how long to wait for
  506.     # that to happen. In case of timeout the shutdown of the actor system will
  507.     # proceed without running possibly still enqueued tasks.
  508.     shutdown-timeout = 5s
  509.   }
  511.   io {
  513.     # By default the select loops run on dedicated threads, hence using a
  514.     # PinnedDispatcher
  515.     pinned-dispatcher {
  516.       type = "PinnedDispatcher"
  517.       executor = "thread-pool-executor"
  518.       thread-pool-executor.allow-core-pool-timeout = off
  519.     }
  521.     tcp {
  523.       # The number of selectors to stripe the served channels over; each of
  524.       # these will use one select loop on the selector-dispatcher.
  525.       nr-of-selectors = 1
  527.       # Maximum number of open channels supported by this TCP module; there is
  528.       # no intrinsic general limit, this setting is meant to enable DoS
  529.       # protection by limiting the number of concurrently connected clients.
  530.       # Also note that this is a "soft" limit; in certain cases the implementation
  531.       # will accept a few connections more or a few less than the number configured
  532.       # here. Must be an integer > 0 or "unlimited".
  533.       max-channels = 256000
  535.       # When trying to assign a new connection to a selector and the chosen
  536.       # selector is at full capacity, retry selector choosing and assignment
  537.       # this many times before giving up
  538.       selector-association-retries = 10
  540.       # The maximum number of connection that are accepted in one go,
  541.       # higher numbers decrease latency, lower numbers increase fairness on
  542.       # the worker-dispatcher
  543.       batch-accept-limit = 10
  545.       # The number of bytes per direct buffer in the pool used to read or write
  546.       # network data from the kernel.
  547.       direct-buffer-size = 128 KiB
  549.       # The maximal number of direct buffers kept in the direct buffer pool for
  550.       # reuse.
  551.       direct-buffer-pool-limit = 1000
  553.       # The duration a connection actor waits for a `Register` message from
  554.       # its commander before aborting the connection.
  555.       register-timeout = 5s
  557.       # The maximum number of bytes delivered by a `Received` message. Before
  558.       # more data is read from the network the connection actor will try to
  559.       # do other work.
  560.       max-received-message-size = unlimited
  562.       # Enable fine grained logging of what goes on inside the implementation.
  563.       # Be aware that this may log more than once per message sent to the actors
  564.       # of the tcp implementation.
  565.       trace-logging = off
  567.       # Fully qualified config path which holds the dispatcher configuration
  568.       # to be used for running the select() calls in the selectors
  569.       selector-dispatcher = "akka.io.pinned-dispatcher"
  571.       # Fully qualified config path which holds the dispatcher configuration
  572.       # for the read/write worker actors
  573.       worker-dispatcher = "akka.actor.default-dispatcher"
  575.       # Fully qualified config path which holds the dispatcher configuration
  576.       # for the selector management actors
  577.       management-dispatcher = "akka.actor.default-dispatcher"
  579.       # Fully qualified config path which holds the dispatcher configuration
  580.       # on which file IO tasks are scheduled
  581.       file-io-dispatcher = "akka.actor.default-dispatcher"
  583.       # The maximum number of bytes (or "unlimited") to transfer in one batch
  584.       # when using `WriteFile` command which uses `FileChannel.transferTo` to
  585.       # pipe files to a TCP socket. On some OS like Linux `FileChannel.transferTo`
  586.       # may block for a long time when network IO is faster than file IO.
  587.       # Decreasing the value may improve fairness while increasing may improve
  588.       # throughput.
  589.       file-io-transferTo-limit = 512 KiB
  591.       # The number of times to retry the `finishConnect` call after being notified about
  592.       # OP_CONNECT. Retries are needed if the OP_CONNECT notification doesn't imply that
  593.       # `finishConnect` will succeed, which is the case on Android.
  594.       finish-connect-retries = 5
  595.     }
  597.     udp {
  599.       # The number of selectors to stripe the served channels over; each of
  600.       # these will use one select loop on the selector-dispatcher.
  601.       nr-of-selectors = 1
  603.       # Maximum number of open channels supported by this UDP module Generally
  604.       # UDP does not require a large number of channels, therefore it is
  605.       # recommended to keep this setting low.
  606.       max-channels = 4096
  608.       # The select loop can be used in two modes:
  609.       # - setting "infinite" will select without a timeout, hogging a thread
  610.       # - setting a positive timeout will do a bounded select call,
  611.       #   enabling sharing of a single thread between multiple selectors
  612.       #   (in this case you will have to use a different configuration for the
  613.       #   selector-dispatcher, e.g. using "type=Dispatcher" with size 1)
  614.       # - setting it to zero means polling, i.e. calling selectNow()
  615.       select-timeout = infinite
  617.       # When trying to assign a new connection to a selector and the chosen
  618.       # selector is at full capacity, retry selector choosing and assignment
  619.       # this many times before giving up
  620.       selector-association-retries = 10
  622.       # The maximum number of datagrams that are read in one go,
  623.       # higher numbers decrease latency, lower numbers increase fairness on
  624.       # the worker-dispatcher
  625.       receive-throughput = 3
  627.       # The number of bytes per direct buffer in the pool used to read or write
  628.       # network data from the kernel.
  629.       direct-buffer-size = 128 KiB
  631.       # The maximal number of direct buffers kept in the direct buffer pool for
  632.       # reuse.
  633.       direct-buffer-pool-limit = 1000
  635.       # The maximum number of bytes delivered by a `Received` message. Before
  636.       # more data is read from the network the connection actor will try to
  637.       # do other work.
  638.       received-message-size-limit = unlimited
  640.       # Enable fine grained logging of what goes on inside the implementation.
  641.       # Be aware that this may log more than once per message sent to the actors
  642.       # of the tcp implementation.
  643.       trace-logging = off
  645.       # Fully qualified config path which holds the dispatcher configuration
  646.       # to be used for running the select() calls in the selectors
  647.       selector-dispatcher = "akka.io.pinned-dispatcher"
  649.       # Fully qualified config path which holds the dispatcher configuration
  650.       # for the read/write worker actors
  651.       worker-dispatcher = "akka.actor.default-dispatcher"
  653.       # Fully qualified config path which holds the dispatcher configuration
  654.       # for the selector management actors
  655.       management-dispatcher = "akka.actor.default-dispatcher"
  656.     }
  658.     udp-connected {
  660.       # The number of selectors to stripe the served channels over; each of
  661.       # these will use one select loop on the selector-dispatcher.
  662.       nr-of-selectors = 1
  664.       # Maximum number of open channels supported by this UDP module Generally
  665.       # UDP does not require a large number of channels, therefore it is
  666.       # recommended to keep this setting low.
  667.       max-channels = 4096
  669.       # The select loop can be used in two modes:
  670.       # - setting "infinite" will select without a timeout, hogging a thread
  671.       # - setting a positive timeout will do a bounded select call,
  672.       #   enabling sharing of a single thread between multiple selectors
  673.       #   (in this case you will have to use a different configuration for the
  674.       #   selector-dispatcher, e.g. using "type=Dispatcher" with size 1)
  675.       # - setting it to zero means polling, i.e. calling selectNow()
  676.       select-timeout = infinite
  678.       # When trying to assign a new connection to a selector and the chosen
  679.       # selector is at full capacity, retry selector choosing and assignment
  680.       # this many times before giving up
  681.       selector-association-retries = 10
  683.       # The maximum number of datagrams that are read in one go,
  684.       # higher numbers decrease latency, lower numbers increase fairness on
  685.       # the worker-dispatcher
  686.       receive-throughput = 3
  688.       # The number of bytes per direct buffer in the pool used to read or write
  689.       # network data from the kernel.
  690.       direct-buffer-size = 128 KiB
  692.       # The maximal number of direct buffers kept in the direct buffer pool for
  693.       # reuse.
  694.       direct-buffer-pool-limit = 1000
  696.       # The maximum number of bytes delivered by a `Received` message. Before
  697.       # more data is read from the network the connection actor will try to
  698.       # do other work.
  699.       received-message-size-limit = unlimited
  701.       # Enable fine grained logging of what goes on inside the implementation.
  702.       # Be aware that this may log more than once per message sent to the actors
  703.       # of the tcp implementation.
  704.       trace-logging = off
  706.       # Fully qualified config path which holds the dispatcher configuration
  707.       # to be used for running the select() calls in the selectors
  708.       selector-dispatcher = "akka.io.pinned-dispatcher"
  710.       # Fully qualified config path which holds the dispatcher configuration
  711.       # for the read/write worker actors
  712.       worker-dispatcher = "akka.actor.default-dispatcher"
  714.       # Fully qualified config path which holds the dispatcher configuration
  715.       # for the selector management actors
  716.       management-dispatcher = "akka.actor.default-dispatcher"
  717.     }
  719.   }
  722. }
akka-agent
  1. ####################################
  2. # Akka Agent Reference Config File #
  3. ####################################
  5. # This is the reference config file that contains all the default settings.
  6. # Make your edits/overrides in your application.conf.
  8. akka {
  9.   agent {
  11.     # The dispatcher used for agent-send-off actor
  12.     send-off-dispatcher {
  13.       executor = thread-pool-executor
  14.       type = PinnedDispatcher
  15.     }
  17.     # The dispatcher used for agent-alter-off actor
  18.     alter-off-dispatcher {
  19.       executor = thread-pool-executor
  20.       type = PinnedDispatcher
  21.     }
  22.   }
  23. }
akka-camel
  1. ####################################
  2. # Akka Camel Reference Config File #
  3. ####################################
  5. # This is the reference config file that contains all the default settings.
  6. # Make your edits/overrides in your application.conf.
  8. akka {
  9.   camel {
  10.     # FQCN of the ContextProvider to be used to create or locate a CamelContext
  11.     # it must implement akka.camel.ContextProvider and have a no-arg constructor
  12.     # the built-in default create a fresh DefaultCamelContext
  13.     context-provider = akka.camel.DefaultContextProvider
  15.     # Whether JMX should be enabled or disabled for the Camel Context
  16.     jmx = off
  17.     # enable/disable streaming cache on the Camel Context
  18.     streamingCache = on
  19.     consumer {
  20.       # Configured setting which determines whether one-way communications
  21.       # between an endpoint and this consumer actor
  22.       # should be auto-acknowledged or application-acknowledged.
  23.       # This flag has only effect when exchange is in-only.
  24.       auto-ack = on
  26.       # When endpoint is out-capable (can produce responses) reply-timeout is the
  27.       # maximum time the endpoint can take to send the response before the message
  28.       # exchange fails. This setting is used for out-capable, in-only,
  29.       # manually acknowledged communication.
  30.       reply-timeout = 1m
  32.       # The duration of time to await activation of an endpoint.
  33.       activation-timeout = 10s
  34.     }
  36.     #Scheme to FQCN mappings for CamelMessage body conversions
  37.     conversions {
  38.       "file" = "java.io.InputStream"
  39.     }
  40.   }
  41. }
akka-cluster
  1. ######################################
  2. # Akka Cluster Reference Config File #
  3. ######################################
  5. # This is the reference config file that contains all the default settings.
  6. # Make your edits/overrides in your application.conf.
  8. akka {
  10.   cluster {
  11.     # Initial contact points of the cluster.
  12.     # The nodes to join automatically at startup.
  13.     # Comma separated full URIs defined by a string on the form of
  14.     # "akka.tcp://system@hostname:port"
  15.     # Leave as empty if the node is supposed to be joined manually.
  16.     seed-nodes = []
  18.     # how long to wait for one of the seed nodes to reply to initial join request
  19.     seed-node-timeout = 5s
  21.     # If a join request fails it will be retried after this period.
  22.     # Disable join retry by specifying "off".
  23.     retry-unsuccessful-join-after = 10s
  25.     # Should the 'leader' in the cluster be allowed to automatically mark
  26.     # unreachable nodes as DOWN after a configured time of unreachability?
  27.     # Using auto-down implies that two separate clusters will automatically be
  28.     # formed in case of network partition.
  29.     # Disable with "off" or specify a duration to enable auto-down.
  30.     auto-down-unreachable-after = off
  32.     # deprecated in 2.3, use 'auto-down-unreachable-after' instead
  33.     auto-down = off
  35.     # The roles of this member. List of strings, e.g. roles = ["A", "B"].
  36.     # The roles are part of the membership information and can be used by
  37.     # routers or other services to distribute work to certain member types,
  38.     # e.g. front-end and back-end nodes.
  39.     roles = []
  41.     role {
  42.       # Minimum required number of members of a certain role before the leader
  43.       # changes member status of 'Joining' members to 'Up'. Typically used together
  44.       # with 'Cluster.registerOnMemberUp' to defer some action, such as starting
  45.       # actors, until the cluster has reached a certain size.
  46.       # E.g. to require 2 nodes with role 'frontend' and 3 nodes with role 'backend':
  47.       #   frontend.min-nr-of-members = 2
  48.       #   backend.min-nr-of-members = 3
  49.       #<role-name>.min-nr-of-members = 1
  50.     }
  52.     # Minimum required number of members before the leader changes member status
  53.     # of 'Joining' members to 'Up'. Typically used together with
  54.     # 'Cluster.registerOnMemberUp' to defer some action, such as starting actors,
  55.     # until the cluster has reached a certain size.
  56.     min-nr-of-members = 1
  58.     # Enable/disable info level logging of cluster events
  59.     log-info = on
  61.     # Enable or disable JMX MBeans for management of the cluster
  62.     jmx.enabled = on
  64.     # how long should the node wait before starting the periodic tasks
  65.     # maintenance tasks?
  66.     periodic-tasks-initial-delay = 1s
  68.     # how often should the node send out gossip information?
  69.     gossip-interval = 1s
  71.     # discard incoming gossip messages if not handled within this duration
  72.     gossip-time-to-live = 2s
  74.     # how often should the leader perform maintenance tasks?
  75.     leader-actions-interval = 1s
  77.     # how often should the node move nodes, marked as unreachable by the failure
  78.     # detector, out of the membership ring?
  79.     unreachable-nodes-reaper-interval = 1s
  81.     # How often the current internal stats should be published.
  82.     # A value of 0s can be used to always publish the stats, when it happens.
  83.     # Disable with "off".
  84.     publish-stats-interval = off
  86.     # The id of the dispatcher to use for cluster actors. If not specified
  87.     # default dispatcher is used.
  88.     # If specified you need to define the settings of the actual dispatcher.
  89.     use-dispatcher = ""
  91.     # Gossip to random node with newer or older state information, if any with
  92.     # this probability. Otherwise Gossip to any random live node.
  93.     # Probability value is between 0.0 and 1.0. 0.0 means never, 1.0 means always.
  94.     gossip-different-view-probability = 0.8
  96.     # Reduced the above probability when the number of nodes in the cluster
  97.     # greater than this value.
  98.     reduce-gossip-different-view-probability = 400
  100.     # Settings for the Phi accrual failure detector (http://ddg.jaist.ac.jp/pub/HDY+04.pdf
  101.     # [Hayashibara et al]) used by the cluster subsystem to detect unreachable
  102.     # members.
  103.     failure-detector {
  105.       # FQCN of the failure detector implementation.
  106.       # It must implement akka.remote.FailureDetector and have
  107.       # a public constructor with a com.typesafe.config.Config and
  108.       # akka.actor.EventStream parameter.
  109.       implementation-class = "akka.remote.PhiAccrualFailureDetector"
  111.       # How often keep-alive heartbeat messages should be sent to each connection.
  112.       heartbeat-interval = 1 s
  114.       # Defines the failure detector threshold.
  115.       # A low threshold is prone to generate many wrong suspicions but ensures
  116.       # a quick detection in the event of a real crash. Conversely, a high
  117.       # threshold generates fewer mistakes but needs more time to detect
  118.       # actual crashes.
  119.       threshold = 8.0
  121.       # Number of the samples of inter-heartbeat arrival times to adaptively
  122.       # calculate the failure timeout for connections.
  123.       max-sample-size = 1000
  125.       # Minimum standard deviation to use for the normal distribution in
  126.       # AccrualFailureDetector. Too low standard deviation might result in
  127.       # too much sensitivity for sudden, but normal, deviations in heartbeat
  128.       # inter arrival times.
  129.       min-std-deviation = 100 ms
  131.       # Number of potentially lost/delayed heartbeats that will be
  132.       # accepted before considering it to be an anomaly.
  133.       # This margin is important to be able to survive sudden, occasional,
  134.       # pauses in heartbeat arrivals, due to for example garbage collect or
  135.       # network drop.
  136.       acceptable-heartbeat-pause = 3 s
  138.       # Number of member nodes that each member will send heartbeat messages to,
  139.       # i.e. each node will be monitored by this number of other nodes.
  140.       monitored-by-nr-of-members = 5
  142.       # After the heartbeat request has been sent the first failure detection
  143.       # will start after this period, even though no heartbeat mesage has
  144.       # been received.
  145.       expected-response-after = 5 s
  147.     }
  149.     metrics {
  150.       # Enable or disable metrics collector for load-balancing nodes.
  151.       enabled = on
  153.       # FQCN of the metrics collector implementation.
  154.       # It must implement akka.cluster.MetricsCollector and
  155.       # have public constructor with akka.actor.ActorSystem parameter.
  156.       # The default SigarMetricsCollector uses JMX and Hyperic SIGAR, if SIGAR
  157.       # is on the classpath, otherwise only JMX.
  158.       collector-class = "akka.cluster.SigarMetricsCollector"
  160.       # How often metrics are sampled on a node.
  161.       # Shorter interval will collect the metrics more often.
  162.       collect-interval = 3s
  164.       # How often a node publishes metrics information.
  165.       gossip-interval = 3s
  167.       # How quickly the exponential weighting of past data is decayed compared to
  168.       # new data. Set lower to increase the bias toward newer values.
  169.       # The relevance of each data sample is halved for every passing half-life
  170.       # duration, i.e. after 4 times the half-life, a data sample’s relevance is
  171.       # reduced to 6% of its original relevance. The initial relevance of a data
  172.       # sample is given by 1 – 0.5 ^ (collect-interval / half-life).
  173.       # See http://en.wikipedia.org/wiki/Moving_average#Exponential_moving_average
  174.       moving-average-half-life = 12s
  175.     }
  177.     # If the tick-duration of the default scheduler is longer than the
  178.     # tick-duration configured here a dedicated scheduler will be used for
  179.     # periodic tasks of the cluster, otherwise the default scheduler is used.
  180.     # See akka.scheduler settings for more details.
  181.     scheduler {
  182.       tick-duration = 33ms
  183.       ticks-per-wheel = 512
  184.     }
  186.   }
  188.   # Default configuration for routers
  189.   actor.deployment.default {
  190.     # MetricsSelector to use
  191.     # - available: "mix", "heap", "cpu", "load"
  192.     # - or: Fully qualified class name of the MetricsSelector class.
  193.     #       The class must extend akka.cluster.routing.MetricsSelector
  194.     #       and have a public constructor with com.typesafe.config.Config
  195.     #       parameter.
  196.     # - default is "mix"
  197.     metrics-selector = mix
  198.   }
  199.   actor.deployment.default.cluster {
  200.     # enable cluster aware router that deploys to nodes in the cluster
  201.     enabled = off
  203.     # Maximum number of routees that will be deployed on each cluster
  204.     # member node.
  205.     # Note that nr-of-instances defines total number of routees, but
  206.     # number of routees per node will not be exceeded, i.e. if you
  207.     # define nr-of-instances = 50 and max-nr-of-instances-per-node = 2
  208.     # it will deploy 2 routees per new member in the cluster, up to
  209.     # 25 members.
  210.     max-nr-of-instances-per-node = 1
  212.     # Defines if routees are allowed to be located on the same node as
  213.     # the head router actor, or only on remote nodes.
  214.     # Useful for master-worker scenario where all routees are remote.
  215.     allow-local-routees = on
  217.     # Deprecated in 2.3, use routees.paths instead
  218.     routees-path = ""
  220.     # Use members with specified role, or all members if undefined or empty.
  221.     use-role = ""
  223.   }
  225.   # Protobuf serializer for cluster messages
  226.   actor {
  227.     serializers {
  228.       akka-cluster = "akka.cluster.protobuf.ClusterMessageSerializer"
  229.     }
  231.     serialization-bindings {
  232.       "akka.cluster.ClusterMessage" = akka-cluster
  233.     }
  235.     router.type-mapping {
  236.       adaptive-pool = "akka.cluster.routing.AdaptiveLoadBalancingPool"
  237.       adaptive-group = "akka.cluster.routing.AdaptiveLoadBalancingGroup"
  238.     }
  239.   }
  241. }
akka-multi-node-testkit
  1. #############################################
  2. # Akka Remote Testing Reference Config File #
  3. #############################################
  5. # This is the reference config file that contains all the default settings.
  6. # Make your edits/overrides in your application.conf.
  8. akka {
  9.   testconductor {
  11.     # Timeout for joining a barrier: this is the maximum time any participants
  12.     # waits for everybody else to join a named barrier.
  13.     barrier-timeout = 30s
  15.     # Timeout for interrogation of TestConductor’s Controller actor
  16.     query-timeout = 5s
  18.     # Threshold for packet size in time unit above which the failure injector will
  19.     # split the packet and deliver in smaller portions; do not give value smaller
  20.     # than HashedWheelTimer resolution (would not make sense)
  21.     packet-split-threshold = 100ms
  23.     # amount of time for the ClientFSM to wait for the connection to the conductor
  24.     # to be successful
  25.     connect-timeout = 20s
  27.     # Number of connect attempts to be made to the conductor controller
  28.     client-reconnects = 10
  30.     # minimum time interval which is to be inserted between reconnect attempts
  31.     reconnect-backoff = 1s
  33.     netty {
  34.       # (I&O) Used to configure the number of I/O worker threads on server sockets
  35.       server-socket-worker-pool {
  36.         # Min number of threads to cap factor-based number to
  37.         pool-size-min = 1
  39.         # The pool size factor is used to determine thread pool size
  40.         # using the following formula: ceil(available processors * factor).
  41.         # Resulting size is then bounded by the pool-size-min and
  42.         # pool-size-max values.
  43.         pool-size-factor = 1.0
  45.         # Max number of threads to cap factor-based number to
  46.         pool-size-max = 2
  47.       }
  49.       # (I&O) Used to configure the number of I/O worker threads on client sockets
  50.       client-socket-worker-pool {
  51.         # Min number of threads to cap factor-based number to
  52.         pool-size-min = 1
  54.         # The pool size factor is used to determine thread pool size
  55.         # using the following formula: ceil(available processors * factor).
  56.         # Resulting size is then bounded by the pool-size-min and
  57.         # pool-size-max values.
  58.         pool-size-factor = 1.0
  60.         # Max number of threads to cap factor-based number to
  61.         pool-size-max = 2
  62.       }
  63.     }
  64.   }
  65. }
akka-persistence
  1. ##########################################
  2. # Akka Persistence Reference Config File #
  3. ##########################################
  7. akka {
  9.   # Protobuf serialization for persistent messages
  10.   actor {
  12.     serializers {
  14.       akka-persistence-snapshot = "akka.persistence.serialization.SnapshotSerializer"
  15.       akka-persistence-message = "akka.persistence.serialization.MessageSerializer"
  16.     }
  18.     serialization-bindings {
  20.       "akka.persistence.serialization.Snapshot" = akka-persistence-snapshot
  21.       "akka.persistence.serialization.Message" = akka-persistence-message
  22.     }
  23.   }
  25.   persistence {
  27.     journal {
  29.       # Maximum size of a persistent message batch written to the journal.
  30.       max-message-batch-size = 200
  32.       # Maximum size of a confirmation batch written to the journal.
  33.       max-confirmation-batch-size = 10000
  35.       # Maximum size of a deletion batch written to the journal.
  36.       max-deletion-batch-size = 10000
  38.       # Path to the journal plugin to be used
  39.       plugin = "akka.persistence.journal.leveldb"
  41.       # In-memory journal plugin.
  42.       inmem {
  44.         # Class name of the plugin.
  45.         class = "akka.persistence.journal.inmem.InmemJournal"
  47.         # Dispatcher for the plugin actor.
  48.         plugin-dispatcher = "akka.actor.default-dispatcher"
  49.       }
  51.       # LevelDB journal plugin.
  52.       leveldb {
  54.         # Class name of the plugin.
  55.         class = "akka.persistence.journal.leveldb.LeveldbJournal"
  57.         # Dispatcher for the plugin actor.
  58.         plugin-dispatcher = "akka.persistence.dispatchers.default-plugin-dispatcher"
  60.         # Dispatcher for message replay.
  61.         replay-dispatcher = "akka.persistence.dispatchers.default-replay-dispatcher"
  63.         # Storage location of LevelDB files.
  64.         dir = "journal"
  66.         # Use fsync on write
  67.         fsync = on
  69.         # Verify checksum on read.
  70.         checksum = off
  72.         # Native LevelDB (via JNI) or LevelDB Java port
  73.         native = on
  74.       }
  76.       # Shared LevelDB journal plugin (for testing only).
  77.       leveldb-shared {
  79.         # Class name of the plugin.
  80.         class = "akka.persistence.journal.leveldb.SharedLeveldbJournal"
  82.         # Dispatcher for the plugin actor.
  83.         plugin-dispatcher = "akka.actor.default-dispatcher"
  85.         # timeout for async journal operations
  86.         timeout = 10s
  88.         store {
  90.           # Dispatcher for shared store actor.
  91.           store-dispatcher = "akka.persistence.dispatchers.default-plugin-dispatcher"
  93.           # Dispatcher for message replay.
  94.           replay-dispatcher = "akka.persistence.dispatchers.default-plugin-dispatcher"
  96.           # Storage location of LevelDB files.
  97.           dir = "journal"
  99.           # Use fsync on write
  100.           fsync = on
  102.           # Verify checksum on read.
  103.           checksum = off
  105.           # Native LevelDB (via JNI) or LevelDB Java port
  106.           native = on
  107.         }
  108.       }
  109.     }
  111.     snapshot-store {
  113.       # Path to the snapshot store plugin to be used
  114.       plugin = "akka.persistence.snapshot-store.local"
  116.       # Local filesystem snapshot store plugin.
  117.       local {
  119.         # Class name of the plugin.
  120.         class = "akka.persistence.snapshot.local.LocalSnapshotStore"
  122.         # Dispatcher for the plugin actor.
  123.         plugin-dispatcher = "akka.persistence.dispatchers.default-plugin-dispatcher"
  125.         # Dispatcher for streaming snapshot IO.
  126.         stream-dispatcher = "akka.persistence.dispatchers.default-stream-dispatcher"
  128.         # Storage location of snapshot files.
  129.         dir = "snapshots"
  130.       }
  131.     }
  133.     view {
  135.       # Automated incremental view update.
  136.       auto-update = on
  138.       # Interval between incremental updates
  139.       auto-update-interval = 5s
  141.       # Maximum number of messages to replay per incremental view update. Set to
  142.       # -1 for no upper limit.
  143.       auto-update-replay-max = -1
  144.     }
  146.     at-least-once-delivery {
  147.       # Interval between redelivery attempts
  148.       redeliver-interval = 5s
  150.       # After this number of delivery attempts a `ReliableRedelivery.UnconfirmedWarning`
  151.       # message will be sent to the actor.
  152.       warn-after-number-of-unconfirmed-attempts = 5
  154.       # Maximum number of unconfirmed messages that an actor with AtLeastOnceDelivery is
  155.       # allowed to hold in memory.
  156.       max-unconfirmed-messages = 100000
  157.     }
  159.     dispatchers {
  160.       default-plugin-dispatcher {
  161.         type = PinnedDispatcher
  162.         executor = "thread-pool-executor"
  163.       }
  164.       default-replay-dispatcher {
  165.         type = Dispatcher
  166.         executor = "fork-join-executor"
  167.         fork-join-executor {
  168.           parallelism-min = 2
  169.           parallelism-max = 8
  170.         }
  171.       }
  172.       default-stream-dispatcher {
  173.         type = Dispatcher
  174.         executor = "fork-join-executor"
  175.         fork-join-executor {
  176.           parallelism-min = 2
  177.           parallelism-max = 8
  178.         }
  179.       }
  180.     }
  181.   }
  182. }
akka-remote
  1. #####################################
  2. # Akka Remote Reference Config File #
  3. #####################################
  5. # This is the reference config file that contains all the default settings.
  6. # Make your edits/overrides in your application.conf.
  8. # comments about akka.actor settings left out where they are already in akka-
  9. # actor.jar, because otherwise they would be repeated in config rendering.
  11. akka {
  13.   actor {
  15.     serializers {
  16.       akka-containers = "akka.remote.serialization.MessageContainerSerializer"
  17.       proto = "akka.remote.serialization.ProtobufSerializer"
  18.       daemon-create = "akka.remote.serialization.DaemonMsgCreateSerializer"
  19.     }
  22.     serialization-bindings {
  23.       # Since com.google.protobuf.Message does not extend Serializable but
  24.       # GeneratedMessage does, need to use the more specific one here in order
  25.       # to avoid ambiguity
  26.       "akka.actor.ActorSelectionMessage" = akka-containers
  27.       "com.google.protobuf.GeneratedMessage" = proto
  28.       "akka.remote.DaemonMsgCreate" = daemon-create
  29.     }
  31.     deployment {
  33.       default {
  35.         # if this is set to a valid remote address, the named actor will be
  36.         # deployed at that node e.g. "akka.tcp://sys@host:port"
  37.         remote = ""
  39.         target {
  41.           # A list of hostnames and ports for instantiating the children of a
  42.           # router
  43.           #   The format should be on "akka.tcp://sys@host:port", where:
  44.           #    - sys is the remote actor system name
  45.           #    - hostname can be either hostname or IP address the remote actor
  46.           #      should connect to
  47.           #    - port should be the port for the remote server on the other node
  48.           # The number of actor instances to be spawned is still taken from the
  49.           # nr-of-instances setting as for local routers; the instances will be
  50.           # distributed round-robin among the given nodes.
  51.           nodes = []
  53.         }
  54.       }
  55.     }
  56.   }
  58.   remote {
  60.     ### General settings
  62.     # Timeout after which the startup of the remoting subsystem is considered
  63.     # to be failed. Increase this value if your transport drivers (see the
  64.     # enabled-transports section) need longer time to be loaded.
  65.     startup-timeout = 10 s
  67.     # Timout after which the graceful shutdown of the remoting subsystem is
  68.     # considered to be failed. After the timeout the remoting system is
  69.     # forcefully shut down. Increase this value if your transport drivers
  70.     # (see the enabled-transports section) need longer time to stop properly.
  71.     shutdown-timeout = 10 s
  73.     # Before shutting down the drivers, the remoting subsystem attempts to flush
  74.     # all pending writes. This setting controls the maximum time the remoting is
  75.     # willing to wait before moving on to shut down the drivers.
  76.     flush-wait-on-shutdown = 2 s
  78.     # Reuse inbound connections for outbound messages
  79.     use-passive-connections = on
  81.     # Controls the backoff interval after a refused write is reattempted.
  82.     # (Transports may refuse writes if their internal buffer is full)
  83.     backoff-interval = 5 ms
  85.     # Acknowledgment timeout of management commands sent to the transport stack.
  86.     command-ack-timeout = 30 s
  88.     # If set to a nonempty string remoting will use the given dispatcher for
  89.     # its internal actors otherwise the default dispatcher is used. Please note
  90.     # that since remoting can load arbitrary 3rd party drivers (see
  91.     # "enabled-transport" and "adapters" entries) it is not guaranteed that
  92.     # every module will respect this setting.
  93.     use-dispatcher = "akka.remote.default-remote-dispatcher"
  95.     ### Security settings
  97.     # Enable untrusted mode for full security of server managed actors, prevents
  98.     # system messages to be send by clients, e.g. messages like 'Create',
  99.     # 'Suspend', 'Resume', 'Terminate', 'Supervise', 'Link' etc.
  100.     untrusted-mode = off
  102.     # When 'untrusted-mode=on' inbound actor selections are by default discarded.
  103.     # Actors with paths defined in this white list are granted permission to receive actor
  104.     # selections messages.
  105.     # E.g. trusted-selection-paths = ["/user/receptionist", "/user/namingService"]
  106.     trusted-selection-paths = []
  108.     # Should the remote server require that its peers share the same
  109.     # secure-cookie (defined in the 'remote' section)? Secure cookies are passed
  110.     # between during the initial handshake. Connections are refused if the initial
  111.     # message contains a mismatching cookie or the cookie is missing.
  112.     require-cookie = off
  114.     # Generate your own with the script availbale in
  115.     # '$AKKA_HOME/scripts/generate_config_with_secure_cookie.sh' or using
  116.     # 'akka.util.Crypt.generateSecureCookie'
  117.     secure-cookie = ""
  119.     ### Logging
  121.     # If this is "on", Akka will log all inbound messages at DEBUG level,
  122.     # if off then they are not logged
  123.     log-received-messages = off
  125.     # If this is "on", Akka will log all outbound messages at DEBUG level,
  126.     # if off then they are not logged
  127.     log-sent-messages = off
  129.     # Sets the log granularity level at which Akka logs remoting events. This setting
  130.     # can take the values OFF, ERROR, WARNING, INFO, DEBUG, or ON. For compatibility
  131.     # reasons the setting "on" will default to "debug" level. Please note that the effective
  132.     # logging level is still determined by the global logging level of the actor system:
  133.     # for example debug level remoting events will be only logged if the system
  134.     # is running with debug level logging.
  135.     # Failures to deserialize received messages also fall under this flag.
  136.     log-remote-lifecycle-events = on
  138.     # Logging of message types with payload size in bytes larger than
  139.     # this value. Maximum detected size per message type is logged once,
  140.     # with an increase threshold of 10%.
  141.     # By default this feature is turned off. Activate it by setting the property to
  142.     # a value in bytes, such as 1000b. Note that for all messages larger than this
  143.     # limit there will be extra performance and scalability cost.
  144.     log-frame-size-exceeding = off
  146.     # Log warning if the number of messages in the backoff buffer in the endpoint
  147.     # writer exceeds this limit. It can be disabled by setting the value to off.
  148.     log-buffer-size-exceeding = 50000
  150.     ### Failure detection and recovery
  152.     # Settings for the failure detector to monitor connections.
  153.     # For TCP it is not important to have fast failure detection, since
  154.     # most connection failures are captured by TCP itself.
  155.     transport-failure-detector {
  157.       # FQCN of the failure detector implementation.
  158.       # It must implement akka.remote.FailureDetector and have
  159.       # a public constructor with a com.typesafe.config.Config and
  160.       # akka.actor.EventStream parameter.
  161.       implementation-class = "akka.remote.DeadlineFailureDetector"
  163.       # How often keep-alive heartbeat messages should be sent to each connection.
  164.       heartbeat-interval = 4 s
  166.       # Number of potentially lost/delayed heartbeats that will be
  167.       # accepted before considering it to be an anomaly.
  168.       # A margin to the `heartbeat-interval` is important to be able to survive sudden,
  169.       # occasional, pauses in heartbeat arrivals, due to for example garbage collect or
  170.       # network drop.
  171.       acceptable-heartbeat-pause = 20 s
  172.     }
  174.     # Settings for the Phi accrual failure detector (http://ddg.jaist.ac.jp/pub/HDY+04.pdf
  175.     # [Hayashibara et al]) used for remote death watch.
  176.     watch-failure-detector {
  178.       # FQCN of the failure detector implementation.
  179.       # It must implement akka.remote.FailureDetector and have
  180.       # a public constructor with a com.typesafe.config.Config and
  181.       # akka.actor.EventStream parameter.
  182.       implementation-class = "akka.remote.PhiAccrualFailureDetector"
  184.       # How often keep-alive heartbeat messages should be sent to each connection.
  185.       heartbeat-interval = 1 s
  187.       # Defines the failure detector threshold.
  188.       # A low threshold is prone to generate many wrong suspicions but ensures
  189.       # a quick detection in the event of a real crash. Conversely, a high
  190.       # threshold generates fewer mistakes but needs more time to detect
  191.       # actual crashes.
  192.       threshold = 10.0
  194.       # Number of the samples of inter-heartbeat arrival times to adaptively
  195.       # calculate the failure timeout for connections.
  196.       max-sample-size = 200
  198.       # Minimum standard deviation to use for the normal distribution in
  199.       # AccrualFailureDetector. Too low standard deviation might result in
  200.       # too much sensitivity for sudden, but normal, deviations in heartbeat
  201.       # inter arrival times.
  202.       min-std-deviation = 100 ms
  204.       # Number of potentially lost/delayed heartbeats that will be
  205.       # accepted before considering it to be an anomaly.
  206.       # This margin is important to be able to survive sudden, occasional,
  207.       # pauses in heartbeat arrivals, due to for example garbage collect or
  208.       # network drop.
  209.       acceptable-heartbeat-pause = 10 s
  212.       # How often to check for nodes marked as unreachable by the failure
  213.       # detector
  214.       unreachable-nodes-reaper-interval = 1s
  216.       # After the heartbeat request has been sent the first failure detection
  217.       # will start after this period, even though no heartbeat mesage has
  218.       # been received.
  219.       expected-response-after = 3 s
  221.     }
  223.     # After failed to establish an outbound connection, the remoting will mark the
  224.     # address as failed. This configuration option controls how much time should
  225.     # be elapsed before reattempting a new connection. While the address is
  226.     # gated, all messages sent to the address are delivered to dead-letters.
  227.     # Since this setting limits the rate of reconnects setting it to a
  228.     # very short interval (i.e. less than a second) may result in a storm of
  229.     # reconnect attempts.
  230.     retry-gate-closed-for = 5 s
  232.     # After catastrophic communication failures that result in the loss of system
  233.     # messages or after the remote DeathWatch triggers the remote system gets
  234.     # quarantined to prevent inconsistent behavior.
  235.     # This setting controls how long the Quarantine marker will be kept around
  236.     # before being removed to avoid long-term memory leaks.
  237.     # WARNING: DO NOT change this to a small value to re-enable communication with
  238.     # quarantined nodes. Such feature is not supported and any behavior between
  239.     # the affected systems after lifting the quarantine is undefined.
  240.     prune-quarantine-marker-after = 5 d
  242.     # This setting defines the maximum number of unacknowledged system messages
  243.     # allowed for a remote system. If this limit is reached the remote system is
  244.     # declared to be dead and its UID marked as tainted.
  245.     system-message-buffer-size = 1000
  247.     # This setting defines the maximum idle time after an individual
  248.     # acknowledgement for system messages is sent. System message delivery
  249.     # is guaranteed by explicit acknowledgement messages. These acks are
  250.     # piggybacked on ordinary traffic messages. If no traffic is detected
  251.     # during the time period configured here, the remoting will send out
  252.     # an individual ack.
  253.     system-message-ack-piggyback-timeout = 0.3 s
  255.     # This setting defines the time after internal management signals
  256.     # between actors (used for DeathWatch and supervision) that have not been
  257.     # explicitly acknowledged or negatively acknowledged are resent.
  258.     # Messages that were negatively acknowledged are always immediately
  259.     # resent.
  260.     resend-interval = 2 s
  262.     # WARNING: this setting should not be not changed unless all of its consequences
  263.     # are properly understood which assumes experience with remoting internals
  264.     # or expert advice.
  265.     # This setting defines the time after redelivery attempts of internal management
  266.     # signals are stopped to a remote system that has been not confirmed to be alive by
  267.     # this system before.
  268.     initial-system-message-delivery-timeout = 3 m
  270.     ### Transports and adapters
  272.     # List of the transport drivers that will be loaded by the remoting.
  273.     # A list of fully qualified config paths must be provided where
  274.     # the given configuration path contains a transport-class key
  275.     # pointing to an implementation class of the Transport interface.
  276.     # If multiple transports are provided, the address of the first
  277.     # one will be used as a default address.
  278.     enabled-transports = ["akka.remote.netty.tcp"]
  280.     # Transport drivers can be augmented with adapters by adding their
  281.     # name to the applied-adapters setting in the configuration of a
  282.     # transport. The available adapters should be configured in this
  283.     # section by providing a name, and the fully qualified name of
  284.     # their corresponding implementation. The class given here
  285.     # must implement akka.akka.remote.transport.TransportAdapterProvider
  286.     # and have public constructor without parameters.
  287.     adapters {
  288.       gremlin = "akka.remote.transport.FailureInjectorProvider"
  289.       trttl = "akka.remote.transport.ThrottlerProvider"
  290.     }
  292.     ### Default configuration for the Netty based transport drivers
  294.     netty.tcp {
  295.       # The class given here must implement the akka.remote.transport.Transport
  296.       # interface and offer a public constructor which takes two arguments:
  297.       #  1) akka.actor.ExtendedActorSystem
  298.       #  2) com.typesafe.config.Config
  299.       transport-class = "akka.remote.transport.netty.NettyTransport"
  301.       # Transport drivers can be augmented with adapters by adding their
  302.       # name to the applied-adapters list. The last adapter in the
  303.       # list is the adapter immediately above the driver, while
  304.       # the first one is the top of the stack below the standard
  305.       # Akka protocol
  306.       applied-adapters = []
  308.       transport-protocol = tcp
  310.       # The default remote server port clients should connect to.
  311.       # Default is 2552 (AKKA), use 0 if you want a random available port
  312.       # This port needs to be unique for each actor system on the same machine.
  313.       port = 2552
  315.       # The hostname or ip to bind the remoting to,
  316.       # InetAddress.getLocalHost.getHostAddress is used if empty
  317.       hostname = ""
  319.       # Enables SSL support on this transport
  320.       enable-ssl = false
  322.       # Sets the connectTimeoutMillis of all outbound connections,
  323.       # i.e. how long a connect may take until it is timed out
  324.       connection-timeout = 15 s
  326.       # If set to "<id.of.dispatcher>" then the specified dispatcher
  327.       # will be used to accept inbound connections, and perform IO. If "" then
  328.       # dedicated threads will be used.
  329.       # Please note that the Netty driver only uses this configuration and does
  330.       # not read the "akka.remote.use-dispatcher" entry. Instead it has to be
  331.       # configured manually to point to the same dispatcher if needed.
  332.       use-dispatcher-for-io = ""
  334.       # Sets the high water mark for the in and outbound sockets,
  335.       # set to 0b for platform default
  336.       write-buffer-high-water-mark = 0b
  338.       # Sets the low water mark for the in and outbound sockets,
  339.       # set to 0b for platform default
  340.       write-buffer-low-water-mark = 0b
  342.       # Sets the send buffer size of the Sockets,
  343.       # set to 0b for platform default
  344.       send-buffer-size = 256000b
  346.       # Sets the receive buffer size of the Sockets,
  347.       # set to 0b for platform default
  348.       receive-buffer-size = 256000b
  350.       # Maximum message size the transport will accept, but at least
  351.       # 32000 bytes.
  352.       # Please note that UDP does not support arbitrary large datagrams,
  353.       # so this setting has to be chosen carefully when using UDP.
  354.       # Both send-buffer-size and receive-buffer-size settings has to
  355.       # be adjusted to be able to buffer messages of maximum size.
  356.       maximum-frame-size = 128000b
  358.       # Sets the size of the connection backlog
  359.       backlog = 4096
  361.       # Enables the TCP_NODELAY flag, i.e. disables Nagle’s algorithm
  362.       tcp-nodelay = on
  364.       # Enables TCP Keepalive, subject to the O/S kernel’s configuration
  365.       tcp-keepalive = on
  367.       # Enables SO_REUSEADDR, which determines when an ActorSystem can open
  368.       # the specified listen port (the meaning differs between *nix and Windows)
  369.       # Valid values are "on", "off" and "off-for-windows"
  370.       # due to the following Windows bug: http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4476378
  371.       # "off-for-windows" of course means that it's "on" for all other platforms
  372.       tcp-reuse-addr = off-for-windows
  374.       # Used to configure the number of I/O worker threads on server sockets
  375.       server-socket-worker-pool {
  376.         # Min number of threads to cap factor-based number to
  377.         pool-size-min = 2
  379.         # The pool size factor is used to determine thread pool size
  380.         # using the following formula: ceil(available processors * factor).
  381.         # Resulting size is then bounded by the pool-size-min and
  382.         # pool-size-max values.
  383.         pool-size-factor = 1.0
  385.         # Max number of threads to cap factor-based number to
  386.         pool-size-max = 2
  387.       }
  389.       # Used to configure the number of I/O worker threads on client sockets
  390.       client-socket-worker-pool {
  391.         # Min number of threads to cap factor-based number to
  392.         pool-size-min = 2
  394.         # The pool size factor is used to determine thread pool size
  395.         # using the following formula: ceil(available processors * factor).
  396.         # Resulting size is then bounded by the pool-size-min and
  397.         # pool-size-max values.
  398.         pool-size-factor = 1.0
  400.         # Max number of threads to cap factor-based number to
  401.         pool-size-max = 2
  402.       }
  405.     }
  407.     netty.udp = ${akka.remote.netty.tcp}
  408.     netty.udp {
  409.       transport-protocol = udp
  410.     }
  412.     netty.ssl = ${akka.remote.netty.tcp}
  413.     netty.ssl = {
  414.       # Enable SSL/TLS encryption.
  415.       # This must be enabled on both the client and server to work.
  416.       enable-ssl = true
  418.       security {
  419.         # This is the Java Key Store used by the server connection
  420.         key-store = "keystore"
  422.         # This password is used for decrypting the key store
  423.         key-store-password = "changeme"
  425.         # This password is used for decrypting the key
  426.         key-password = "changeme"
  428.         # This is the Java Key Store used by the client connection
  429.         trust-store = "truststore"
  431.         # This password is used for decrypting the trust store
  432.         trust-store-password = "changeme"
  434.         # Protocol to use for SSL encryption, choose from:
  435.         # Java 6 & 7:
  436.         #   'SSLv3', 'TLSv1'
  437.         # Java 7:
  438.         #   'TLSv1.1', 'TLSv1.2'
  439.         protocol = "TLSv1"
  441.         # Example: ["TLS_RSA_WITH_AES_128_CBC_SHA", "TLS_RSA_WITH_AES_256_CBC_SHA"]
  442.         # You need to install the JCE Unlimited Strength Jurisdiction Policy
  443.         # Files to use AES 256.
  444.         # More info here:
  445.         # http://docs.oracle.com/javase/7/docs/technotes/guides/security/SunProviders.html#SunJCEProvider
  446.         enabled-algorithms = ["TLS_RSA_WITH_AES_128_CBC_SHA"]
  448.         # There are three options, in increasing order of security:
  449.         # "" or SecureRandom => (default)
  450.         # "SHA1PRNG" => Can be slow because of blocking issues on Linux
  451.         # "AES128CounterSecureRNG" => fastest startup and based on AES encryption
  452.         # algorithm
  453.         # "AES256CounterSecureRNG"
  454.         # The following use one of 3 possible seed sources, depending on
  455.         # availability: /dev/random, random.org and SecureRandom (provided by Java)
  456.         # "AES128CounterInetRNG"
  457.         # "AES256CounterInetRNG" (Install JCE Unlimited Strength Jurisdiction
  458.         # Policy Files first)
  459.         # Setting a value here may require you to supply the appropriate cipher
  460.         # suite (see enabled-algorithms section above)
  461.         random-number-generator = ""
  462.       }
  463.     }
  465.     ### Default configuration for the failure injector transport adapter
  467.     gremlin {
  468.       # Enable debug logging of the failure injector transport adapter
  469.       debug = off
  470.     }
  472.     ### Default dispatcher for the remoting subsystem
  474.     default-remote-dispatcher {
  475.       type = Dispatcher
  476.       executor = "fork-join-executor"
  477.       fork-join-executor {
  478.         # Min number of threads to cap factor-based parallelism number to
  479.         parallelism-min = 2
  480.         parallelism-max = 2
  481.       }
  482.     }
  484.     backoff-remote-dispatcher {
  485.       type = Dispatcher
  486.       executor = "fork-join-executor"
  487.       fork-join-executor {
  488.         # Min number of threads to cap factor-based parallelism number to
  489.         parallelism-min = 2
  490.         parallelism-max = 2
  491.       }
  492.     }
  495.   }
  497. }
akka-testkit
  1. ######################################
  2. # Akka Testkit Reference Config File #
  3. ######################################
  5. # This is the reference config file that contains all the default settings.
  6. # Make your edits/overrides in your application.conf.
  8. akka {
  9.   test {
  10.     # factor by which to scale timeouts during tests, e.g. to account for shared
  11.     # build system load
  12.     timefactor =  1.0
  14.     # duration of EventFilter.intercept waits after the block is finished until
  15.     # all required messages are received
  16.     filter-leeway = 3s
  18.     # duration to wait in expectMsg and friends outside of within() block
  19.     # by default
  20.     single-expect-default = 3s
  22.     # The timeout that is added as an implicit by DefaultTimeout trait
  23.     default-timeout = 5s
  25.     calling-thread-dispatcher {
  26.       type = akka.testkit.CallingThreadDispatcherConfigurator
  27.     }
  28.   }
  29. }
akka-zeromq
  1. #####################################
  2. # Akka ZeroMQ Reference Config File #
  3. #####################################
  5. # This is the reference config file that contains all the default settings.
  6. # Make your edits/overrides in your application.conf.
  8. akka {
  10.   zeromq {
  12.     # The default timeout for a poll on the actual zeromq socket.
  13.     poll-timeout = 100ms
  15.     # Timeout for creating a new socket
  16.     new-socket-timeout = 5s
  18.     socket-dispatcher {
  19.       # A zeromq socket needs to be pinned to the thread that created it.
  20.       # Changing this value results in weird errors and race conditions within
  21.       # zeromq
  22.       executor = thread-pool-executor
  23.       type = "PinnedDispatcher"
  24.       thread-pool-executor.allow-core-timeout = off
  25.     }
  26.   }
  27. }