akka-remote
1.#####################################
2.# Akka Remote Reference Config File #
3.#####################################
4.
5.# This is the reference config file that contains all the default settings.
6.# Make your edits/overrides in your application.conf.
7.
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.
10.#
11.# For the configuration of the new remoting implementation (Artery) please look
12.# at the bottom section of this file as it is listed separately.
13.
14.akka {
15.
16. actor {
17.
18. serializers {
19. akka-containers = "akka.remote.serialization.MessageContainerSerializer"
20. akka-misc = "akka.remote.serialization.MiscMessageSerializer"
21. artery = "akka.remote.serialization.ArteryMessageSerializer"
22. proto = "akka.remote.serialization.ProtobufSerializer"
23. daemon-create = "akka.remote.serialization.DaemonMsgCreateSerializer"
24. primitive-long = "akka.remote.serialization.LongSerializer"
25. primitive-int = "akka.remote.serialization.IntSerializer"
26. primitive-string = "akka.remote.serialization.StringSerializer"
27. primitive-bytestring = "akka.remote.serialization.ByteStringSerializer"
28. akka-system-msg = "akka.remote.serialization.SystemMessageSerializer"
29. }
30.
31. serialization-bindings {
32. "akka.actor.ActorSelectionMessage" = akka-containers
33.
34. "akka.remote.DaemonMsgCreate" = daemon-create
35.
36. "akka.remote.artery.ArteryMessage" = artery
37.
38. # Since akka.protobuf.Message does not extend Serializable but
39. # GeneratedMessage does, need to use the more specific one here in order
40. # to avoid ambiguity.
41. "akka.protobuf.GeneratedMessage" = proto
42.
43. # Since com.google.protobuf.Message does not extend Serializable but
44. # GeneratedMessage does, need to use the more specific one here in order
45. # to avoid ambiguity.
46. # This com.google.protobuf serialization binding is only used if the class can be loaded,
47. # i.e. com.google.protobuf dependency has been added in the application project.
48. "com.google.protobuf.GeneratedMessage" = proto
49.
50. "java.util.Optional" = akka-misc
51. }
52.
53. # For the purpose of preserving protocol backward compatibility these bindings are not
54. # included by default. They can be enabled with enable-additional-serialization-bindings=on.
55. # They are enabled by default if akka.remote.artery.enabled=on.
56. additional-serialization-bindings {
57. "akka.actor.Identify" = akka-misc
58. "akka.actor.ActorIdentity" = akka-misc
59. "scala.Some" = akka-misc
60. "scala.None$" = akka-misc
61. "akka.actor.Status$Success" = akka-misc
62. "akka.actor.Status$Failure" = akka-misc
63. "akka.actor.ActorRef" = akka-misc
64. "akka.actor.PoisonPill$" = akka-misc
65. "akka.actor.Kill$" = akka-misc
66. "akka.remote.RemoteWatcher$Heartbeat$" = akka-misc
67. "akka.remote.RemoteWatcher$HeartbeatRsp" = akka-misc
68. "akka.actor.ActorInitializationException" = akka-misc
69.
70. "akka.dispatch.sysmsg.SystemMessage" = akka-system-msg
71.
72. "java.lang.String" = primitive-string
73. "akka.util.ByteString$ByteString1C" = primitive-bytestring
74. "akka.util.ByteString$ByteString1" = primitive-bytestring
75. "akka.util.ByteString$ByteStrings" = primitive-bytestring
76. "java.lang.Long" = primitive-long
77. "scala.Long" = primitive-long
78. "java.lang.Integer" = primitive-int
79. "scala.Int" = primitive-int
80.
81. # Java Serializer is by default used for exceptions.
82. # It's recommended that you implement custom serializer for exceptions that are
83. # sent remotely, e.g. in akka.actor.Status.Failure for ask replies. You can add
84. # binding to akka-misc (MiscMessageSerializerSpec) for the exceptions that have
85. # a constructor with single message String or constructor with message String as
86. # first parameter and cause Throwable as second parameter. Note that it's not
87. # safe to add this binding for general exceptions such as IllegalArgumentException
88. # because it may have a subclass without required constructor.
89. "java.lang.Throwable" = java
90. "akka.actor.IllegalActorStateException" = akka-misc
91. "akka.actor.ActorKilledException" = akka-misc
92. "akka.actor.InvalidActorNameException" = akka-misc
93. "akka.actor.InvalidMessageException" = akka-misc
94. }
95.
96. serialization-identifiers {
97. "akka.remote.serialization.ProtobufSerializer" = 2
98. "akka.remote.serialization.DaemonMsgCreateSerializer" = 3
99. "akka.remote.serialization.MessageContainerSerializer" = 6
100. "akka.remote.serialization.MiscMessageSerializer" = 16
101. "akka.remote.serialization.ArteryMessageSerializer" = 17
102. "akka.remote.serialization.LongSerializer" = 18
103. "akka.remote.serialization.IntSerializer" = 19
104. "akka.remote.serialization.StringSerializer" = 20
105. "akka.remote.serialization.ByteStringSerializer" = 21
106. "akka.remote.serialization.SystemMessageSerializer" = 22
107. }
108.
109. deployment {
110.
111. default {
112.
113. # if this is set to a valid remote address, the named actor will be
114. # deployed at that node e.g. "akka.tcp://sys@host:port"
115. remote = ""
116.
117. target {
118.
119. # A list of hostnames and ports for instantiating the children of a
120. # router
121. # The format should be on "akka.tcp://sys@host:port", where:
122. # - sys is the remote actor system name
123. # - hostname can be either hostname or IP address the remote actor
124. # should connect to
125. # - port should be the port for the remote server on the other node
126. # The number of actor instances to be spawned is still taken from the
127. # nr-of-instances setting as for local routers; the instances will be
128. # distributed round-robin among the given nodes.
129. nodes = []
130.
131. }
132. }
133. }
134. }
135.
136. remote {
137. ### Settings shared by classic remoting and Artery (the new implementation of remoting)
138.
139. # If set to a nonempty string remoting will use the given dispatcher for
140. # its internal actors otherwise the default dispatcher is used. Please note
141. # that since remoting can load arbitrary 3rd party drivers (see
142. # "enabled-transport" and "adapters" entries) it is not guaranteed that
143. # every module will respect this setting.
144. use-dispatcher = "akka.remote.default-remote-dispatcher"
145.
146. # Settings for the failure detector to monitor connections.
147. # For TCP it is not important to have fast failure detection, since
148. # most connection failures are captured by TCP itself.
149. # The default DeadlineFailureDetector will trigger if there are no heartbeats within
150. # the duration heartbeat-interval + acceptable-heartbeat-pause, i.e. 20 seconds
151. # with the default settings.
152. transport-failure-detector {
153.
154. # FQCN of the failure detector implementation.
155. # It must implement akka.remote.FailureDetector and have
156. # a public constructor with a com.typesafe.config.Config and
157. # akka.actor.EventStream parameter.
158. implementation-class = "akka.remote.DeadlineFailureDetector"
159.
160. # How often keep-alive heartbeat messages should be sent to each connection.
161. heartbeat-interval = 4 s
162.
163. # Number of potentially lost/delayed heartbeats that will be
164. # accepted before considering it to be an anomaly.
165. # A margin to the `heartbeat-interval` is important to be able to survive sudden,
166. # occasional, pauses in heartbeat arrivals, due to for example garbage collect or
167. # network drop.
168. acceptable-heartbeat-pause = 16 s
169. }
170.
171. # Settings for the Phi accrual failure detector (http://www.jaist.ac.jp/~defago/files/pdf/IS_RR_2004_010.pdf
172. # [Hayashibara et al]) used for remote death watch.
173. # The default PhiAccrualFailureDetector will trigger if there are no heartbeats within
174. # the duration heartbeat-interval + acceptable-heartbeat-pause + threshold_adjustment,
175. # i.e. around 12.5 seconds with default settings.
176. watch-failure-detector {
177.
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"
183.
184. # How often keep-alive heartbeat messages should be sent to each connection.
185. heartbeat-interval = 1 s
186.
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
193.
194. # Number of the samples of inter-heartbeat arrival times to adaptively
195. # calculate the failure timeout for connections.
196. max-sample-size = 200
197.
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
203.
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
210.
211.
212. # How often to check for nodes marked as unreachable by the failure
213. # detector
214. unreachable-nodes-reaper-interval = 1s
215.
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 = 1 s
220.
221. }
222.
223. # remote deployment configuration section
224. deployment {
225. # If true, will only allow specific classes to be instanciated on this system via remote deployment
226. enable-whitelist = off
227.
228. whitelist = []
229. }
230.
231. ### Configuration for classic remoting
232.
233. # Timeout after which the startup of the remoting subsystem is considered
234. # to be failed. Increase this value if your transport drivers (see the
235. # enabled-transports section) need longer time to be loaded.
236. startup-timeout = 10 s
237.
238. # Timout after which the graceful shutdown of the remoting subsystem is
239. # considered to be failed. After the timeout the remoting system is
240. # forcefully shut down. Increase this value if your transport drivers
241. # (see the enabled-transports section) need longer time to stop properly.
242. shutdown-timeout = 10 s
243.
244. # Before shutting down the drivers, the remoting subsystem attempts to flush
245. # all pending writes. This setting controls the maximum time the remoting is
246. # willing to wait before moving on to shut down the drivers.
247. flush-wait-on-shutdown = 2 s
248.
249. # Reuse inbound connections for outbound messages
250. use-passive-connections = on
251.
252. # Controls the backoff interval after a refused write is reattempted.
253. # (Transports may refuse writes if their internal buffer is full)
254. backoff-interval = 5 ms
255.
256. # Acknowledgment timeout of management commands sent to the transport stack.
257. command-ack-timeout = 30 s
258.
259. # The timeout for outbound associations to perform the handshake.
260. # If the transport is akka.remote.netty.tcp or akka.remote.netty.ssl
261. # the configured connection-timeout for the transport will be used instead.
262. handshake-timeout = 15 s
263.
264. ### Security settings
265.
266. # Enable untrusted mode for full security of server managed actors, prevents
267. # system messages to be send by clients, e.g. messages like 'Create',
268. # 'Suspend', 'Resume', 'Terminate', 'Supervise', 'Link' etc.
269. untrusted-mode = off
270.
271. # When 'untrusted-mode=on' inbound actor selections are by default discarded.
272. # Actors with paths defined in this white list are granted permission to receive actor
273. # selections messages.
274. # E.g. trusted-selection-paths = ["/user/receptionist", "/user/namingService"]
275. trusted-selection-paths = []
276.
277. # Should the remote server require that its peers share the same
278. # secure-cookie (defined in the 'remote' section)? Secure cookies are passed
279. # between during the initial handshake. Connections are refused if the initial
280. # message contains a mismatching cookie or the cookie is missing.
281. require-cookie = off
282.
283. # Deprecated since 2.4-M1
284. secure-cookie = ""
285.
286. ### Logging
287.
288. # If this is "on", Akka will log all inbound messages at DEBUG level,
289. # if off then they are not logged
290. log-received-messages = off
291.
292. # If this is "on", Akka will log all outbound messages at DEBUG level,
293. # if off then they are not logged
294. log-sent-messages = off
295.
296. # Sets the log granularity level at which Akka logs remoting events. This setting
297. # can take the values OFF, ERROR, WARNING, INFO, DEBUG, or ON. For compatibility
298. # reasons the setting "on" will default to "debug" level. Please note that the effective
299. # logging level is still determined by the global logging level of the actor system:
300. # for example debug level remoting events will be only logged if the system
301. # is running with debug level logging.
302. # Failures to deserialize received messages also fall under this flag.
303. log-remote-lifecycle-events = on
304.
305. # Logging of message types with payload size in bytes larger than
306. # this value. Maximum detected size per message type is logged once,
307. # with an increase threshold of 10%.
308. # By default this feature is turned off. Activate it by setting the property to
309. # a value in bytes, such as 1000b. Note that for all messages larger than this
310. # limit there will be extra performance and scalability cost.
311. log-frame-size-exceeding = off
312.
313. # Log warning if the number of messages in the backoff buffer in the endpoint
314. # writer exceeds this limit. It can be disabled by setting the value to off.
315. log-buffer-size-exceeding = 50000
316.
317.
318.
319. # After failed to establish an outbound connection, the remoting will mark the
320. # address as failed. This configuration option controls how much time should
321. # be elapsed before reattempting a new connection. While the address is
322. # gated, all messages sent to the address are delivered to dead-letters.
323. # Since this setting limits the rate of reconnects setting it to a
324. # very short interval (i.e. less than a second) may result in a storm of
325. # reconnect attempts.
326. retry-gate-closed-for = 5 s
327.
328. # After catastrophic communication failures that result in the loss of system
329. # messages or after the remote DeathWatch triggers the remote system gets
330. # quarantined to prevent inconsistent behavior.
331. # This setting controls how long the Quarantine marker will be kept around
332. # before being removed to avoid long-term memory leaks.
333. # WARNING: DO NOT change this to a small value to re-enable communication with
334. # quarantined nodes. Such feature is not supported and any behavior between
335. # the affected systems after lifting the quarantine is undefined.
336. prune-quarantine-marker-after = 5 d
337.
338. # If system messages have been exchanged between two systems (i.e. remote death
339. # watch or remote deployment has been used) a remote system will be marked as
340. # quarantined after the two system has no active association, and no
341. # communication happens during the time configured here.
342. # The only purpose of this setting is to avoid storing system message redelivery
343. # data (sequence number state, etc.) for an undefined amount of time leading to long
344. # term memory leak. Instead, if a system has been gone for this period,
345. # or more exactly
346. # - there is no association between the two systems (TCP connection, if TCP transport is used)
347. # - neither side has been attempting to communicate with the other
348. # - there are no pending system messages to deliver
349. # for the amount of time configured here, the remote system will be quarantined and all state
350. # associated with it will be dropped.
351. quarantine-after-silence = 5 d
352.
353. # This setting defines the maximum number of unacknowledged system messages
354. # allowed for a remote system. If this limit is reached the remote system is
355. # declared to be dead and its UID marked as tainted.
356. system-message-buffer-size = 20000
357.
358. # This setting defines the maximum idle time after an individual
359. # acknowledgement for system messages is sent. System message delivery
360. # is guaranteed by explicit acknowledgement messages. These acks are
361. # piggybacked on ordinary traffic messages. If no traffic is detected
362. # during the time period configured here, the remoting will send out
363. # an individual ack.
364. system-message-ack-piggyback-timeout = 0.3 s
365.
366. # This setting defines the time after internal management signals
367. # between actors (used for DeathWatch and supervision) that have not been
368. # explicitly acknowledged or negatively acknowledged are resent.
369. # Messages that were negatively acknowledged are always immediately
370. # resent.
371. resend-interval = 2 s
372.
373. # Maximum number of unacknowledged system messages that will be resent
374. # each 'resend-interval'. If you watch many (> 1000) remote actors you can
375. # increase this value to for example 600, but a too large limit (e.g. 10000)
376. # may flood the connection and might cause false failure detection to trigger.
377. # Test such a configuration by watching all actors at the same time and stop
378. # all watched actors at the same time.
379. resend-limit = 200
380.
381. # WARNING: this setting should not be not changed unless all of its consequences
382. # are properly understood which assumes experience with remoting internals
383. # or expert advice.
384. # This setting defines the time after redelivery attempts of internal management
385. # signals are stopped to a remote system that has been not confirmed to be alive by
386. # this system before.
387. initial-system-message-delivery-timeout = 3 m
388.
389. ### Transports and adapters
390.
391. # List of the transport drivers that will be loaded by the remoting.
392. # A list of fully qualified config paths must be provided where
393. # the given configuration path contains a transport-class key
394. # pointing to an implementation class of the Transport interface.
395. # If multiple transports are provided, the address of the first
396. # one will be used as a default address.
397. enabled-transports = ["akka.remote.netty.tcp"]
398.
399. # Transport drivers can be augmented with adapters by adding their
400. # name to the applied-adapters setting in the configuration of a
401. # transport. The available adapters should be configured in this
402. # section by providing a name, and the fully qualified name of
403. # their corresponding implementation. The class given here
404. # must implement akka.akka.remote.transport.TransportAdapterProvider
405. # and have public constructor without parameters.
406. adapters {
407. gremlin = "akka.remote.transport.FailureInjectorProvider"
408. trttl = "akka.remote.transport.ThrottlerProvider"
409. }
410.
411. ### Default configuration for the Netty based transport drivers
412.
413. netty.tcp {
414. # The class given here must implement the akka.remote.transport.Transport
415. # interface and offer a public constructor which takes two arguments:
416. # 1) akka.actor.ExtendedActorSystem
417. # 2) com.typesafe.config.Config
418. transport-class = "akka.remote.transport.netty.NettyTransport"
419.
420. # Transport drivers can be augmented with adapters by adding their
421. # name to the applied-adapters list. The last adapter in the
422. # list is the adapter immediately above the driver, while
423. # the first one is the top of the stack below the standard
424. # Akka protocol
425. applied-adapters = []
426.
427. transport-protocol = tcp
428.
429. # The default remote server port clients should connect to.
430. # Default is 2552 (AKKA), use 0 if you want a random available port
431. # This port needs to be unique for each actor system on the same machine.
432. port = 2552
433.
434. # The hostname or ip clients should connect to.
435. # InetAddress.getLocalHost.getHostAddress is used if empty
436. hostname = ""
437.
438. # Use this setting to bind a network interface to a different port
439. # than remoting protocol expects messages at. This may be used
440. # when running akka nodes in a separated networks (under NATs or docker containers).
441. # Use 0 if you want a random available port. Examples:
442. #
443. # akka.remote.netty.tcp.port = 2552
444. # akka.remote.netty.tcp.bind-port = 2553
445. # Network interface will be bound to the 2553 port, but remoting protocol will
446. # expect messages sent to port 2552.
447. #
448. # akka.remote.netty.tcp.port = 0
449. # akka.remote.netty.tcp.bind-port = 0
450. # Network interface will be bound to a random port, and remoting protocol will
451. # expect messages sent to the bound port.
452. #
453. # akka.remote.netty.tcp.port = 2552
454. # akka.remote.netty.tcp.bind-port = 0
455. # Network interface will be bound to a random port, but remoting protocol will
456. # expect messages sent to port 2552.
457. #
458. # akka.remote.netty.tcp.port = 0
459. # akka.remote.netty.tcp.bind-port = 2553
460. # Network interface will be bound to the 2553 port, and remoting protocol will
461. # expect messages sent to the bound port.
462. #
463. # akka.remote.netty.tcp.port = 2552
464. # akka.remote.netty.tcp.bind-port = ""
465. # Network interface will be bound to the 2552 port, and remoting protocol will
466. # expect messages sent to the bound port.
467. #
468. # akka.remote.netty.tcp.port if empty
469. bind-port = ""
470.
471. # Use this setting to bind a network interface to a different hostname or ip
472. # than remoting protocol expects messages at.
473. # Use "0.0.0.0" to bind to all interfaces.
474. # akka.remote.netty.tcp.hostname if empty
475. bind-hostname = ""
476.
477. # Enables SSL support on this transport
478. enable-ssl = false
479.
480. # Sets the connectTimeoutMillis of all outbound connections,
481. # i.e. how long a connect may take until it is timed out
482. connection-timeout = 15 s
483.
484. # If set to "<id.of.dispatcher>" then the specified dispatcher
485. # will be used to accept inbound connections, and perform IO. If "" then
486. # dedicated threads will be used.
487. # Please note that the Netty driver only uses this configuration and does
488. # not read the "akka.remote.use-dispatcher" entry. Instead it has to be
489. # configured manually to point to the same dispatcher if needed.
490. use-dispatcher-for-io = ""
491.
492. # Sets the high water mark for the in and outbound sockets,
493. # set to 0b for platform default
494. write-buffer-high-water-mark = 0b
495.
496. # Sets the low water mark for the in and outbound sockets,
497. # set to 0b for platform default
498. write-buffer-low-water-mark = 0b
499.
500. # Sets the send buffer size of the Sockets,
501. # set to 0b for platform default
502. send-buffer-size = 256000b
503.
504. # Sets the receive buffer size of the Sockets,
505. # set to 0b for platform default
506. receive-buffer-size = 256000b
507.
508. # Maximum message size the transport will accept, but at least
509. # 32000 bytes.
510. # Please note that UDP does not support arbitrary large datagrams,
511. # so this setting has to be chosen carefully when using UDP.
512. # Both send-buffer-size and receive-buffer-size settings has to
513. # be adjusted to be able to buffer messages of maximum size.
514. maximum-frame-size = 128000b
515.
516. # Sets the size of the connection backlog
517. backlog = 4096
518.
519. # Enables the TCP_NODELAY flag, i.e. disables Nagle’s algorithm
520. tcp-nodelay = on
521.
522. # Enables TCP Keepalive, subject to the O/S kernel’s configuration
523. tcp-keepalive = on
524.
525. # Enables SO_REUSEADDR, which determines when an ActorSystem can open
526. # the specified listen port (the meaning differs between *nix and Windows)
527. # Valid values are "on", "off" and "off-for-windows"
528. # due to the following Windows bug: http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4476378
529. # "off-for-windows" of course means that it's "on" for all other platforms
530. tcp-reuse-addr = off-for-windows
531.
532. # Used to configure the number of I/O worker threads on server sockets
533. server-socket-worker-pool {
534. # Min number of threads to cap factor-based number to
535. pool-size-min = 2
536.
537. # The pool size factor is used to determine thread pool size
538. # using the following formula: ceil(available processors * factor).
539. # Resulting size is then bounded by the pool-size-min and
540. # pool-size-max values.
541. pool-size-factor = 1.0
542.
543. # Max number of threads to cap factor-based number to
544. pool-size-max = 2
545. }
546.
547. # Used to configure the number of I/O worker threads on client sockets
548. client-socket-worker-pool {
549. # Min number of threads to cap factor-based number to
550. pool-size-min = 2
551.
552. # The pool size factor is used to determine thread pool size
553. # using the following formula: ceil(available processors * factor).
554. # Resulting size is then bounded by the pool-size-min and
555. # pool-size-max values.
556. pool-size-factor = 1.0
557.
558. # Max number of threads to cap factor-based number to
559. pool-size-max = 2
560. }
561.
562.
563. }
564.
565. netty.udp = ${akka.remote.netty.tcp}
566. netty.udp {
567. transport-protocol = udp
568. }
569.
570. netty.ssl = ${akka.remote.netty.tcp}
571. netty.ssl = {
572. # Enable SSL/TLS encryption.
573. # This must be enabled on both the client and server to work.
574. enable-ssl = true
575.
576. security {
577. # This is the Java Key Store used by the server connection
578. key-store = "keystore"
579.
580. # This password is used for decrypting the key store
581. key-store-password = "changeme"
582.
583. # This password is used for decrypting the key
584. key-password = "changeme"
585.
586. # This is the Java Key Store used by the client connection
587. trust-store = "truststore"
588.
589. # This password is used for decrypting the trust store
590. trust-store-password = "changeme"
591.
592. # Protocol to use for SSL encryption, choose from:
593. # TLS 1.2 is available since JDK7, and default since JDK8:
594. # https://blogs.oracle.com/java-platform-group/entry/java_8_will_use_tls
595. protocol = "TLSv1.2"
596.
597. # Example: ["TLS_RSA_WITH_AES_128_CBC_SHA", "TLS_RSA_WITH_AES_256_CBC_SHA"]
598. # You need to install the JCE Unlimited Strength Jurisdiction Policy
599. # Files to use AES 256.
600. # More info here:
601. # http://docs.oracle.com/javase/7/docs/technotes/guides/security/SunProviders.html#SunJCEProvider
602. enabled-algorithms = ["TLS_RSA_WITH_AES_128_CBC_SHA"]
603.
604. # There are three options, in increasing order of security:
605. # "" or SecureRandom => (default)
606. # "SHA1PRNG" => Can be slow because of blocking issues on Linux
607. # "AES128CounterSecureRNG" => fastest startup and based on AES encryption
608. # algorithm
609. # "AES256CounterSecureRNG"
610. #
611. # The following are deprecated in Akka 2.4. They use one of 3 possible
612. # seed sources, depending on availability: /dev/random, random.org and
613. # SecureRandom (provided by Java)
614. # "AES128CounterInetRNG"
615. # "AES256CounterInetRNG" (Install JCE Unlimited Strength Jurisdiction
616. # Policy Files first)
617. # Setting a value here may require you to supply the appropriate cipher
618. # suite (see enabled-algorithms section above)
619. random-number-generator = ""
620.
621. # Require mutual authentication between TLS peers
622. #
623. # Without mutual authentication only the peer that actively establishes a connection (TLS client side)
624. # checks if the passive side (TLS server side) sends over a trusted certificate. With the flag turned on,
625. # the passive side will also request and verify a certificate from the connecting peer.
626. #
627. # To prevent man-in-the-middle attacks you should enable this setting. For compatibility reasons it is
628. # still set to 'off' per default.
629. #
630. # Note: Nodes that are configured with this setting to 'on' might not be able to receive messages from nodes that
631. # run on older versions of akka-remote. This is because in older versions of Akka the active side of the remoting
632. # connection will not send over certificates.
633. #
634. # However, starting from the version this setting was added, even with this setting "off", the active side
635. # (TLS client side) will use the given key-store to send over a certificate if asked. A rolling upgrades from
636. # older versions of Akka can therefore work like this:
637. # - upgrade all nodes to an Akka version supporting this flag, keeping it off
638. # - then switch the flag on and do again a rolling upgrade of all nodes
639. # The first step ensures that all nodes will send over a certificate when asked to. The second
640. # step will ensure that all nodes finally enforce the secure checking of client certificates.
641. require-mutual-authentication = off
642. }
643. }
644.
645. ### Default configuration for the failure injector transport adapter
646.
647. gremlin {
648. # Enable debug logging of the failure injector transport adapter
649. debug = off
650. }
651.
652. ### Default dispatcher for the remoting subsystem
653.
654. default-remote-dispatcher {
655. type = Dispatcher
656. executor = "fork-join-executor"
657. fork-join-executor {
658. parallelism-min = 2
659. parallelism-factor = 0.5
660. parallelism-max = 16
661. }
662. throughput = 10
663. }
664.
665. backoff-remote-dispatcher {
666. type = Dispatcher
667. executor = "fork-join-executor"
668. fork-join-executor {
669. # Min number of threads to cap factor-based parallelism number to
670. parallelism-min = 2
671. parallelism-max = 2
672. }
673. }
674. }
675.}
akka-remote (artery)
1.#####################################
2.# Akka Remote Reference Config File #
3.#####################################
4.
5.# This is the reference config file that contains all the default settings.
6.# Make your edits/overrides in your application.conf.
7.
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.
10.#
11.# For the configuration of the new remoting implementation (Artery) please look
12.# at the bottom section of this file as it is listed separately.
13.
14.akka {
15.
16. actor {
17.
18. serializers {
19. akka-containers = "akka.remote.serialization.MessageContainerSerializer"
20. akka-misc = "akka.remote.serialization.MiscMessageSerializer"
21. artery = "akka.remote.serialization.ArteryMessageSerializer"
22. proto = "akka.remote.serialization.ProtobufSerializer"
23. daemon-create = "akka.remote.serialization.DaemonMsgCreateSerializer"
24. primitive-long = "akka.remote.serialization.LongSerializer"
25. primitive-int = "akka.remote.serialization.IntSerializer"
26. primitive-string = "akka.remote.serialization.StringSerializer"
27. primitive-bytestring = "akka.remote.serialization.ByteStringSerializer"
28. akka-system-msg = "akka.remote.serialization.SystemMessageSerializer"
29. }
30.
31. serialization-bindings {
32. "akka.actor.ActorSelectionMessage" = akka-containers
33.
34. "akka.remote.DaemonMsgCreate" = daemon-create
35.
36. "akka.remote.artery.ArteryMessage" = artery
37.
38. # Since akka.protobuf.Message does not extend Serializable but
39. # GeneratedMessage does, need to use the more specific one here in order
40. # to avoid ambiguity.
41. "akka.protobuf.GeneratedMessage" = proto
42.
43. # Since com.google.protobuf.Message does not extend Serializable but
44. # GeneratedMessage does, need to use the more specific one here in order
45. # to avoid ambiguity.
46. # This com.google.protobuf serialization binding is only used if the class can be loaded,
47. # i.e. com.google.protobuf dependency has been added in the application project.
48. "com.google.protobuf.GeneratedMessage" = proto
49.
50. "java.util.Optional" = akka-misc
51. }
52.
53. # For the purpose of preserving protocol backward compatibility these bindings are not
54. # included by default. They can be enabled with enable-additional-serialization-bindings=on.
55. # They are enabled by default if akka.remote.artery.enabled=on.
56. additional-serialization-bindings {
57. "akka.actor.Identify" = akka-misc
58. "akka.actor.ActorIdentity" = akka-misc
59. "scala.Some" = akka-misc
60. "scala.None$" = akka-misc
61. "akka.actor.Status$Success" = akka-misc
62. "akka.actor.Status$Failure" = akka-misc
63. "akka.actor.ActorRef" = akka-misc
64. "akka.actor.PoisonPill$" = akka-misc
65. "akka.actor.Kill$" = akka-misc
66. "akka.remote.RemoteWatcher$Heartbeat$" = akka-misc
67. "akka.remote.RemoteWatcher$HeartbeatRsp" = akka-misc
68. "akka.actor.ActorInitializationException" = akka-misc
69.
70. "akka.dispatch.sysmsg.SystemMessage" = akka-system-msg
71.
72. "java.lang.String" = primitive-string
73. "akka.util.ByteString$ByteString1C" = primitive-bytestring
74. "akka.util.ByteString$ByteString1" = primitive-bytestring
75. "akka.util.ByteString$ByteStrings" = primitive-bytestring
76. "java.lang.Long" = primitive-long
77. "scala.Long" = primitive-long
78. "java.lang.Integer" = primitive-int
79. "scala.Int" = primitive-int
80.
81. # Java Serializer is by default used for exceptions.
82. # It's recommended that you implement custom serializer for exceptions that are
83. # sent remotely, e.g. in akka.actor.Status.Failure for ask replies. You can add
84. # binding to akka-misc (MiscMessageSerializerSpec) for the exceptions that have
85. # a constructor with single message String or constructor with message String as
86. # first parameter and cause Throwable as second parameter. Note that it's not
87. # safe to add this binding for general exceptions such as IllegalArgumentException
88. # because it may have a subclass without required constructor.
89. "java.lang.Throwable" = java
90. "akka.actor.IllegalActorStateException" = akka-misc
91. "akka.actor.ActorKilledException" = akka-misc
92. "akka.actor.InvalidActorNameException" = akka-misc
93. "akka.actor.InvalidMessageException" = akka-misc
94. }
95.
96. serialization-identifiers {
97. "akka.remote.serialization.ProtobufSerializer" = 2
98. "akka.remote.serialization.DaemonMsgCreateSerializer" = 3
99. "akka.remote.serialization.MessageContainerSerializer" = 6
100. "akka.remote.serialization.MiscMessageSerializer" = 16
101. "akka.remote.serialization.ArteryMessageSerializer" = 17
102. "akka.remote.serialization.LongSerializer" = 18
103. "akka.remote.serialization.IntSerializer" = 19
104. "akka.remote.serialization.StringSerializer" = 20
105. "akka.remote.serialization.ByteStringSerializer" = 21
106. "akka.remote.serialization.SystemMessageSerializer" = 22
107. }
108.
109. deployment {
110.
111. default {
112.
113. # if this is set to a valid remote address, the named actor will be
114. # deployed at that node e.g. "akka.tcp://sys@host:port"
115. remote = ""
116.
117. target {
118.
119. # A list of hostnames and ports for instantiating the children of a
120. # router
121. # The format should be on "akka.tcp://sys@host:port", where:
122. # - sys is the remote actor system name
123. # - hostname can be either hostname or IP address the remote actor
124. # should connect to
125. # - port should be the port for the remote server on the other node
126. # The number of actor instances to be spawned is still taken from the
127. # nr-of-instances setting as for local routers; the instances will be
128. # distributed round-robin among the given nodes.
129. nodes = []
130.
131. }
132. }
133. }
134. }
135.
136. remote {
137. ### Settings shared by classic remoting and Artery (the new implementation of remoting)
138.
139. # If set to a nonempty string remoting will use the given dispatcher for
140. # its internal actors otherwise the default dispatcher is used. Please note
141. # that since remoting can load arbitrary 3rd party drivers (see
142. # "enabled-transport" and "adapters" entries) it is not guaranteed that
143. # every module will respect this setting.
144. use-dispatcher = "akka.remote.default-remote-dispatcher"
145.
146. # Settings for the failure detector to monitor connections.
147. # For TCP it is not important to have fast failure detection, since
148. # most connection failures are captured by TCP itself.
149. # The default DeadlineFailureDetector will trigger if there are no heartbeats within
150. # the duration heartbeat-interval + acceptable-heartbeat-pause, i.e. 20 seconds
151. # with the default settings.
152. transport-failure-detector {
153.
154. # FQCN of the failure detector implementation.
155. # It must implement akka.remote.FailureDetector and have
156. # a public constructor with a com.typesafe.config.Config and
157. # akka.actor.EventStream parameter.
158. implementation-class = "akka.remote.DeadlineFailureDetector"
159.
160. # How often keep-alive heartbeat messages should be sent to each connection.
161. heartbeat-interval = 4 s
162.
163. # Number of potentially lost/delayed heartbeats that will be
164. # accepted before considering it to be an anomaly.
165. # A margin to the `heartbeat-interval` is important to be able to survive sudden,
166. # occasional, pauses in heartbeat arrivals, due to for example garbage collect or
167. # network drop.
168. acceptable-heartbeat-pause = 16 s
169. }
170.
171. # Settings for the Phi accrual failure detector (http://www.jaist.ac.jp/~defago/files/pdf/IS_RR_2004_010.pdf
172. # [Hayashibara et al]) used for remote death watch.
173. # The default PhiAccrualFailureDetector will trigger if there are no heartbeats within
174. # the duration heartbeat-interval + acceptable-heartbeat-pause + threshold_adjustment,
175. # i.e. around 12.5 seconds with default settings.
176. watch-failure-detector {
177.
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"
183.
184. # How often keep-alive heartbeat messages should be sent to each connection.
185. heartbeat-interval = 1 s
186.
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
193.
194. # Number of the samples of inter-heartbeat arrival times to adaptively
195. # calculate the failure timeout for connections.
196. max-sample-size = 200
197.
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
203.
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
210.
211.
212. # How often to check for nodes marked as unreachable by the failure
213. # detector
214. unreachable-nodes-reaper-interval = 1s
215.
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 = 1 s
220.
221. }
222.
223. # remote deployment configuration section
224. deployment {
225. # If true, will only allow specific classes to be instanciated on this system via remote deployment
226. enable-whitelist = off
227.
228. whitelist = []
229. }
230.
231. ### Configuration for Artery, the reimplementation of remoting
232. artery {
233.
234. # Enable the new remoting with this flag
235. enabled = off
236.
237. # Canonical address is the address other clients should connect to.
238. # Artery transport will expect messages to this address.
239. canonical {
240.
241. # The default remote server port clients should connect to.
242. # Default is 25520, use 0 if you want a random available port
243. # This port needs to be unique for each actor system on the same machine.
244. port = 25520
245.
246. # Hostname clients should connect to. Can be set to an ip, hostname
247. # or one of the following special values:
248. # "<getHostAddress>" InetAddress.getLocalHost.getHostAddress
249. # "<getHostName>" InetAddress.getLocalHost.getHostName
250. #
251. hostname = "<getHostAddress>"
252. }
253.
254. # Use these settings to bind a network interface to a different address
255. # than artery expects messages at. This may be used when running Akka
256. # nodes in a separated networks (under NATs or in containers). If canonical
257. # and bind addresses are different, then network configuration that relays
258. # communications from canonical to bind addresses is expected.
259. bind {
260.
261. # Port to bind a network interface to. Can be set to a port number
262. # of one of the following special values:
263. # 0 random available port
264. # "" akka.remote.artery.canonical.port
265. #
266. port = ""
267.
268. # Hostname to bind a network interface to. Can be set to an ip, hostname
269. # or one of the following special values:
270. # "0.0.0.0" all interfaces
271. # "" akka.remote.artery.canonical.hostname
272. # "<getHostAddress>" InetAddress.getLocalHost.getHostAddress
273. # "<getHostName>" InetAddress.getLocalHost.getHostName
274. #
275. hostname = ""
276. }
277.
278. # Actor paths to use the large message stream for when a message
279. # is sent to them over remoting. The large message stream dedicated
280. # is separate from "normal" and system messages so that sending a
281. # large message does not interfere with them.
282. # Entries should be the full path to the actor. Wildcards in the form of "*"
283. # can be supplied at any place and matches any name at that segment -
284. # "/user/supervisor/actor/*" will match any direct child to actor,
285. # while "/supervisor/*/child" will match any grandchild to "supervisor" that
286. # has the name "child"
287. # Messages sent to ActorSelections will not be passed through the large message
288. # stream, to pass such messages through the large message stream the selections
289. # but must be resolved to ActorRefs first.
290. large-message-destinations = []
291.
292. # Enable untrusted mode, which discards inbound system messages, PossiblyHarmful and
293. # ActorSelection messages. E.g. remote watch and remote deployment will not work.
294. # ActorSelection messages can be enabled for specific paths with the trusted-selection-paths
295. untrusted-mode = off
296.
297. # When 'untrusted-mode=on' inbound actor selections are by default discarded.
298. # Actors with paths defined in this white list are granted permission to receive actor
299. # selections messages.
300. # E.g. trusted-selection-paths = ["/user/receptionist", "/user/namingService"]
301. trusted-selection-paths = []
302.
303. # If this is "on", all inbound remote messages will be logged at DEBUG level,
304. # if off then they are not logged
305. log-received-messages = off
306.
307. # If this is "on", all outbound remote messages will be logged at DEBUG level,
308. # if off then they are not logged
309. log-sent-messages = off
310.
311. advanced {
312.
313. # Maximum serialized message size, including header data.
314. maximum-frame-size = 256 KiB
315.
316. # Direct byte buffers are reused in a pool with this maximum size.
317. # Each buffer has the size of 'maximum-frame-size'.
318. # This is not a hard upper limit on number of created buffers. Additional
319. # buffers will be created if needed, e.g. when using many outbound
320. # associations at the same time. Such additional buffers will be garbage
321. # collected, which is not as efficient as reusing buffers in the pool.
322. buffer-pool-size = 128
323.
324. # Maximum serialized message size for the large messages, including header data.
325. # See 'large-message-destinations'.
326. maximum-large-frame-size = 2 MiB
327.
328. # Direct byte buffers for the large messages are reused in a pool with this maximum size.
329. # Each buffer has the size of 'maximum-large-frame-size'.
330. # See 'large-message-destinations'.
331. # This is not a hard upper limit on number of created buffers. Additional
332. # buffers will be created if needed, e.g. when using many outbound
333. # associations at the same time. Such additional buffers will be garbage
334. # collected, which is not as efficient as reusing buffers in the pool.
335. large-buffer-pool-size = 32
336.
337. # For enabling testing features, such as blackhole in akka-remote-testkit.
338. test-mode = off
339.
340. # Settings for the materializer that is used for the remote streams.
341. materializer = ${akka.stream.materializer}
342.
343. # If set to a nonempty string artery will use the given dispatcher for
344. # the ordinary and large message streams, otherwise the default dispatcher is used.
345. use-dispatcher = "akka.remote.default-remote-dispatcher"
346.
347. # If set to a nonempty string remoting will use the given dispatcher for
348. # the control stream, otherwise the default dispatcher is used.
349. # It can be good to not use the same dispatcher for the control stream as
350. # the dispatcher for the ordinary message stream so that heartbeat messages
351. # are not disturbed.
352. use-control-stream-dispatcher = ""
353.
354. # Controls whether to start the Aeron media driver in the same JVM or use external
355. # process. Set to 'off' when using external media driver, and then also set the
356. # 'aeron-dir'.
357. embedded-media-driver = on
358.
359. # Directory used by the Aeron media driver. It's mandatory to define the 'aeron-dir'
360. # if using external media driver, i.e. when 'embedded-media-driver = off'.
361. # Embedded media driver will use a this directory, or a temporary directory if this
362. # property is not defined (empty).
363. aeron-dir = ""
364.
365. # Whether to delete aeron embeded driver directory upon driver stop.
366. delete-aeron-dir = yes
367.
368. # Level of CPU time used, on a scale between 1 and 10, during backoff/idle.
369. # The tradeoff is that to have low latency more CPU time must be used to be
370. # able to react quickly on incoming messages or send as fast as possible after
371. # backoff backpressure.
372. # Level 1 strongly prefer low CPU consumption over low latency.
373. # Level 10 strongly prefer low latency over low CPU consumption.
374. idle-cpu-level = 5
375.
376. # WARNING: This feature is not supported yet. Don't use other value than 1.
377. # It requires more hardening and performance optimizations.
378. # Number of outbound lanes for each outbound association. A value greater than 1
379. # means that serialization can be performed in parallel for different destination
380. # actors. The selection of lane is based on consistent hashing of the recipient
381. # ActorRef to preserve message ordering per receiver.
382. outbound-lanes = 1
383.
384. # WARNING: This feature is not supported yet. Don't use other value than 1.
385. # It requires more hardening and performance optimizations.
386. # Total number of inbound lanes, shared among all inbound associations. A value
387. # greater than 1 means that deserialization can be performed in parallel for
388. # different destination actors. The selection of lane is based on consistent
389. # hashing of the recipient ActorRef to preserve message ordering per receiver.
390. inbound-lanes = 1
391.
392. # Size of the send queue for outgoing messages. Messages will be dropped if
393. # the queue becomes full. This may happen if you send a burst of many messages
394. # without end-to-end flow control. Note that there is one such queue per
395. # outbound association. The trade-off of using a larger queue size is that
396. # it consumes more memory, since the queue is based on preallocated array with
397. # fixed size.
398. outbound-message-queue-size = 3072
399.
400. # Size of the send queue for outgoing control messages, such as system messages.
401. # If this limit is reached the remote system is declared to be dead and its UID
402. # marked as quarantined.
403. # The trade-off of using a larger queue size is that it consumes more memory,
404. # since the queue is based on preallocated array with fixed size.
405. outbound-control-queue-size = 3072
406.
407. # Size of the send queue for outgoing large messages. Messages will be dropped if
408. # the queue becomes full. This may happen if you send a burst of many messages
409. # without end-to-end flow control. Note that there is one such queue per
410. # outbound association. The trade-off of using a larger queue size is that
411. # it consumes more memory, since the queue is based on preallocated array with
412. # fixed size.
413. outbound-large-message-queue-size = 256
414.
415. # This setting defines the maximum number of unacknowledged system messages
416. # allowed for a remote system. If this limit is reached the remote system is
417. # declared to be dead and its UID marked as quarantined.
418. system-message-buffer-size = 20000
419.
420. # unacknowledged system messages are re-delivered with this interval
421. system-message-resend-interval = 1 second
422.
423. # The timeout for outbound associations to perform the handshake.
424. # This timeout must be greater than the 'image-liveness-timeout'.
425. handshake-timeout = 20 s
426.
427. # incomplete handshake attempt is retried with this interval
428. handshake-retry-interval = 1 second
429.
430. # handshake requests are performed periodically with this interval,
431. # also after the handshake has been completed to be able to establish
432. # a new session with a restarted destination system
433. inject-handshake-interval = 1 second
434.
435. # messages that are not accepted by Aeron are dropped after retrying for this period
436. give-up-message-after = 60 seconds
437.
438. # System messages that are not acknowledged after re-sending for this period are
439. # dropped and will trigger quarantine. The value should be longer than the length
440. # of a network partition that you need to survive.
441. give-up-system-message-after = 6 hours
442.
443. # during ActorSystem termination the remoting will wait this long for
444. # an acknowledgment by the destination system that flushing of outstanding
445. # remote messages has been completed
446. shutdown-flush-timeout = 1 second
447.
448. # See 'inbound-max-restarts'
449. inbound-restart-timeout = 5 seconds
450.
451. # Max number of restarts within 'inbound-restart-timeout' for the inbound streams.
452. # If more restarts occurs the ActorSystem will be terminated.
453. inbound-max-restarts = 5
454.
455. # See 'outbound-max-restarts'
456. outbound-restart-timeout = 5 seconds
457.
458. # Max number of restarts within 'outbound-restart-timeout' for the outbound streams.
459. # If more restarts occurs the ActorSystem will be terminated.
460. outbound-max-restarts = 5
461.
462. # Stop outbound stream of a quarantined association after this idle timeout, i.e.
463. # when not used any more.
464. stop-quarantined-after-idle = 3 seconds
465.
466. # Timeout after which aeron driver has not had keepalive messages
467. # from a client before it considers the client dead.
468. client-liveness-timeout = 20 seconds
469.
470. # Timeout for each the INACTIVE and LINGER stages an aeron image
471. # will be retained for when it is no longer referenced.
472. # This timeout must be less than the 'handshake-timeout'.
473. image-liveness-timeout = 10 seconds
474.
475. # Timeout after which the aeron driver is considered dead
476. # if it does not update its C'n'C timestamp.
477. driver-timeout = 20 seconds
478.
479. flight-recorder {
480. // FIXME it should be enabled by default when we have a good solution for naming the files
481. enabled = off
482. # Controls where the flight recorder file will be written. There are three options:
483. # 1. Empty: a file will be generated in the temporary directory of the OS
484. # 2. A relative or absolute path ending with ".afr": this file will be used
485. # 3. A relative or absolute path: this directory will be used, the file will get a random file name
486. destination = ""
487. }
488.
489. # compression of common strings in remoting messages, like actor destinations, serializers etc
490. compression {
491.
492. actor-refs {
493. # Max number of compressed actor-refs
494. # Note that compression tables are "rolling" (i.e. a new table replaces the old
495. # compression table once in a while), and this setting is only about the total number
496. # of compressions within a single such table.
497. # Must be a positive natural number.
498. max = 256
499.
500. # interval between new table compression advertisements.
501. # this means the time during which we collect heavy-hitter data and then turn it into a compression table.
502. advertisement-interval = 1 minute # TODO find good number as default, for benchmarks trigger immediately
503. }
504. manifests {
505. # Max number of compressed manifests
506. # Note that compression tables are "rolling" (i.e. a new table replaces the old
507. # compression table once in a while), and this setting is only about the total number
508. # of compressions within a single such table.
509. # Must be a positive natural number.
510. max = 256
511.
512. # interval between new table compression advertisements.
513. # this means the time during which we collect heavy-hitter data and then turn it into a compression table.
514. advertisement-interval = 1 minute # TODO find good number as default, for benchmarks trigger immediately
515. }
516. }
517.
518. # List of fully qualified class names of remote instruments which should
519. # be initialized and used for monitoring of remote messages.
520. # The class must extend akka.remote.artery.RemoteInstrument and
521. # have a public constructor with empty parameters or one ExtendedActorSystem
522. # parameter.
523. # A new instance of RemoteInstrument will be created for each encoder and decoder.
524. # It's only called from the stage, so if it dosn't delegate to any shared instance
525. # it doesn't have to be thread-safe.
526. # Refer to `akka.remote.artery.RemoteInstrument` for more information.
527. instruments = ${?akka.remote.artery.advanced.instruments} []
528. }
529. }
530. }
531.
532.}
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 {
- test {
-
factor by which to scale timeouts during tests, e.g. to account for shared
-
build system load
- timefactor = 1.0
-
duration of EventFilter.intercept waits after the block is finished until
-
all required messages are received
- filter-leeway = 3s
-
duration to wait in expectMsg and friends outside of within() block
-
by default
- single-expect-default = 3s
-
The timeout that is added as an implicit by DefaultTimeout trait
- default-timeout = 5s
- calling-thread-dispatcher {
type = akka.testkit.CallingThreadDispatcherConfigurator- }
- }
- actor.serialization-bindings {
- "akka.testkit.JavaSerializable" = java
- }
33.}
