kkajstestkit_sjs1_2.13.2.2.6.14.source-code.application.conf Maven / Gradle / Ivy
The newest version!
akka {
home = ""
version = "2.5-SNAPSHOT"
loggers = ["akka.testkit.TestEventListener"]
logging-filter = "akka.event.JSDefaultLoggingFilter"
loggers-dispatcher = "akka.actor.default-dispatcher"
logger-startup-timeout = 5s
loglevel = "INFO"
stdout-loglevel = "WARNING"
log-config-on-start = off
log-dead-letters = 10
log-dead-letters-during-shutdown = on
log-dead-letters-suspend-duration = 5 minutes
library-extensions = []
extensions = []
daemonic = off
jvm-exit-on-fatal-error = on
actor {
provider = "akka.actor.JSLocalActorRefProvider"
guardian-supervisor-strategy = "akka.actor.DefaultSupervisorStrategy"
creation-timeout = 20s
serialize-messages = off
serialize-creators = off
unstarted-push-timeout = 10s
typed {
timeout = 5s
extensions = []
library-extensions = []
restart-stash-capacity = 1000
default-mailbox {
mailbox-type = "akka.dispatch.SingleConsumerOnlyUnboundedMailbox"
}
}
router.type-mapping {
from-code = "akka.routing.NoRouter"
round-robin-pool = "akka.routing.RoundRobinPool"
round-robin-group = "akka.routing.RoundRobinGroup"
random-pool = "akka.routing.RandomPool"
random-group = "akka.routing.RandomGroup"
balancing-pool = "akka.routing.BalancingPool"
smallest-mailbox-pool = "akka.routing.SmallestMailboxPool"
broadcast-pool = "akka.routing.BroadcastPool"
broadcast-group = "akka.routing.BroadcastGroup"
scatter-gather-pool = "akka.routing.ScatterGatherFirstCompletedPool"
scatter-gather-group = "akka.routing.ScatterGatherFirstCompletedGroup"
tail-chopping-pool = "akka.routing.TailChoppingPool"
tail-chopping-group = "akka.routing.TailChoppingGroup"
consistent-hashing-pool = "akka.routing.ConsistentHashingPool"
consistent-hashing-group = "akka.routing.ConsistentHashingGroup"
}
deployment {
default {
dispatcher = ""
mailbox = ""
router = "from-code"
nr-of-instances = 1
within = 5 seconds
virtual-nodes-factor = 10
tail-chopping-router {
interval = 10 milliseconds
}
routees {
paths = []
}
resizer {
enabled = off
lower-bound = 1
upper-bound = 10
pressure-threshold = 1
rampup-rate = 0.2
backoff-threshold = 0.3
backoff-rate = 0.1.
messages-per-resize = 10
}
optimal-size-exploring-resizer {
enabled = off
lower-bound = 1
upper-bound = 10
chance-of-ramping-down-when-full = 0.2
action-interval = 5s
downsize-after-underutilized-for = 72h
explore-step-size = 0.1
chance-of-exploration = 0.4
downsize-ratio = 0.8.
optimization-range = 16
weight-of-latest-metric = 0.5
}
}
}
default-dispatcher {
type = "Dispatcher"
executor = "default-executor"
default-executor {
fallback = "fork-join-executor"
}
fork-join-executor {
parallelism-min = 8
parallelism-factor = 3.0
parallelism-max = 64
task-peeking-mode = "FIFO"
}
thread-pool-executor {
keep-alive-time = 60s
fixed-pool-size = off
core-pool-size-min = 8
core-pool-size-factor = 3.0
core-pool-size-max = 64
max-pool-size-min = 8
max-pool-size-factor = 3.0
max-pool-size-max = 64
task-queue-size = -1
task-queue-type = "linked"
allow-core-timeout = on
}
shutdown-timeout = 1s
throughput = 5
throughput-deadline-time = 0ms
attempt-teamwork = on
mailbox-requirement = ""
}
default-blocking-io-dispatcher {
type = "Dispatcher"
executor = "thread-pool-executor"
throughput = 1
thread-pool-executor {
fixed-pool-size = 16
}
}
default-mailbox {
mailbox-type = "akka.dispatch.UnboundedMailbox"
mailbox-capacity = 1000
mailbox-push-timeout-time = 10s
stash-capacity = -1
}
mailbox {
requirements {
"akka.dispatch.UnboundedMessageQueueSemantics" =
akka.actor.mailbox.unbounded-queue-based
"akka.dispatch.BoundedMessageQueueSemantics" =
akka.actor.mailbox.bounded-queue-based
"akka.dispatch.DequeBasedMessageQueueSemantics" =
akka.actor.mailbox.unbounded-deque-based
"akka.dispatch.UnboundedDequeBasedMessageQueueSemantics" =
akka.actor.mailbox.unbounded-deque-based
"akka.dispatch.BoundedDequeBasedMessageQueueSemantics" =
akka.actor.mailbox.bounded-deque-based
"akka.dispatch.MultipleConsumerSemantics" =
akka.actor.mailbox.unbounded-queue-based
"akka.dispatch.ControlAwareMessageQueueSemantics" =
akka.actor.mailbox.unbounded-control-aware-queue-based
"akka.dispatch.UnboundedControlAwareMessageQueueSemantics" =
akka.actor.mailbox.unbounded-control-aware-queue-based
"akka.dispatch.BoundedControlAwareMessageQueueSemantics" =
akka.actor.mailbox.bounded-control-aware-queue-based
"akka.event.LoggerMessageQueueSemantics" =
akka.actor.mailbox.logger-queue
}
unbounded-queue-based {
mailbox-type = "akka.dispatch.UnboundedMailbox"
}
bounded-queue-based {
mailbox-type = "akka.dispatch.BoundedMailbox"
}
unbounded-deque-based {
mailbox-type = "akka.dispatch.UnboundedDequeBasedMailbox"
}
bounded-deque-based {
mailbox-type = "akka.dispatch.BoundedDequeBasedMailbox"
}
unbounded-control-aware-queue-based {
mailbox-type = "akka.dispatch.UnboundedControlAwareMailbox"
}
bounded-control-aware-queue-based {
mailbox-type = "akka.dispatch.BoundedControlAwareMailbox"
}
logger-queue {
mailbox-type = "akka.event.LoggerMailboxType"
}
}
debug {
receive = off
autoreceive = off
lifecycle = off
fsm = off
event-stream = off
unhandled = off
router-misconfiguration = off
}
allow-java-serialization = off
serializers {}
serialization-bindings {}
enable-additional-serialization-bindings = off
additional-serialization-bindings {}
warn-about-java-serializer-usage = off
warn-on-no-serialization-verification = off
serialization-identifiers {}
dsl {
inbox-size = 1000
default-timeout = 5s
}
}
scheduler {
tick-duration = 10ms
ticks-per-wheel = 512
implementation = akka.actor.EventLoopScheduler
shutdown-timeout = 5s
}
io {
pinned-dispatcher {
type = "PinnedDispatcher"
executor = "thread-pool-executor"
thread-pool-executor.allow-core-timeout = off
}
tcp {
nr-of-selectors = 1
max-channels = 256000
selector-association-retries = 10
batch-accept-limit = 10
direct-buffer-size = 128 KiB
direct-buffer-pool-limit = 1000
register-timeout = 5s
max-received-message-size = unlimited
trace-logging = off
selector-dispatcher = "akka.io.pinned-dispatcher"
worker-dispatcher = "akka.actor.default-dispatcher"
management-dispatcher = "akka.actor.default-dispatcher"
file-io-dispatcher = "akka.actor.default-blocking-io-dispatcher"
file-io-transferTo-limit = 512 KiB
finish-connect-retries = 5
windows-connection-abort-workaround-enabled = off
}
udp {
nr-of-selectors = 1
max-channels = 4096
select-timeout = infinite
selector-association-retries = 10
receive-throughput = 3
direct-buffer-size = 128 KiB
direct-buffer-pool-limit = 1000
trace-logging = off
selector-dispatcher = "akka.io.pinned-dispatcher"
worker-dispatcher = "akka.actor.default-dispatcher"
management-dispatcher = "akka.actor.default-dispatcher"
}
udp-connected {
nr-of-selectors = 1
max-channels = 4096
select-timeout = infinite
selector-association-retries = 10
receive-throughput = 3
direct-buffer-size = 128 KiB
direct-buffer-pool-limit = 1000
trace-logging = off
selector-dispatcher = "akka.io.pinned-dispatcher"
worker-dispatcher = "akka.actor.default-dispatcher"
management-dispatcher = "akka.actor.default-dispatcher"
}
dns {
dispatcher = "akka.actor.default-dispatcher"
resolver = "inet-address"
inet-address {
provider-object = "akka.io.InetAddressDnsProvider"
positive-ttl = default
negative-ttl = default
cache-cleanup-interval = 120s
}
}
}
coordinated-shutdown {
default-phase-timeout = 5 s
terminate-actor-system = on
exit-jvm = off
run-by-jvm-shutdown-hook = on
phases {
before-service-unbind {
}
service-unbind {
depends-on = [before-service-unbind]
}
service-requests-done {
depends-on = [service-unbind]
}
service-stop {
depends-on = [service-requests-done]
}
before-cluster-shutdown {
depends-on = [service-stop]
}
cluster-sharding-shutdown-region {
timeout = 10 s
depends-on = [before-cluster-shutdown]
}
cluster-leave {
depends-on = [cluster-sharding-shutdown-region]
}
cluster-exiting {
timeout = 10 s
depends-on = [cluster-leave]
}
cluster-exiting-done {
depends-on = [cluster-exiting]
}
cluster-shutdown {
depends-on = [cluster-exiting-done]
}
before-actor-system-terminate {
depends-on = [cluster-shutdown]
}
actor-system-terminate {
timeout = 10 s
depends-on = [before-actor-system-terminate]
}
}
}
stream {
materializer {
creation-timeout = 20s
initial-input-buffer-size = 4
max-input-buffer-size = 16
blocking-io-dispatcher = "akka.stream.default-blocking-io-dispatcher"
dispatcher = ""
subscription-timeout {
mode = cancel
timeout = 5s
}
debug-logging = off
output-burst-limit = 1000
auto-fusing = on
max-fixed-buffer-size = 1000000000
sync-processing-limit = 1000
debug {
fuzzing-mode = off
}
io {
tcp {
write-buffer-size = 16 KiB
}
}
stream-ref {
buffer-capacity = 32
demand-redelivery-interval = 1 second
subscription-timeout = 30 seconds
final-termination-signal-deadline = 2 seconds
}
}
blocking-io-dispatcher = "akka.stream.default-blocking-io-dispatcher"
default-blocking-io-dispatcher {
type = "Dispatcher"
executor = "thread-pool-executor"
throughput = 1
thread-pool-executor {
fixed-pool-size = 16
}
}
testkit {
all-stages-stopped-timeout = 10s
}
}
test {
# factor by which to scale timeouts during tests, e.g. to account for shared
# build system load
timefactor = 5.0
# duration of EventFilter.intercept waits after the block is finished until
# all required messages are received
filter-leeway = 6s
# duration to wait in expectMsg and friends outside of within() block
# by default
single-expect-default = 6s
# The timeout that is added as an implicit by DefaultTimeout trait
default-timeout = 8s
calling-thread-dispatcher {
type = akka.testkit.CallingThreadDispatcherConfigurator
}
}
}