akka/repackaged-akka-jar/src/main/resources/stream_reference.conf

   1 #####################################
   2 # Akka Stream Reference Config File #
   3 #####################################
   4
   5 # eager creation of the system wide materializer
   6 akka.library-extensions += "akka.stream.SystemMaterializer$"
   7 akka {
   8   stream {
   9
  10     # Default materializer settings
  11     materializer {
  12
  13       # Initial size of buffers used in stream elements
  14       initial-input-buffer-size = 4
  15       # Maximum size of buffers used in stream elements
  16       max-input-buffer-size = 16
  17
  18       # Fully qualified config path which holds the dispatcher configuration
  19       # or full dispatcher configuration to be used by ActorMaterializer when creating Actors.
  20       dispatcher = "akka.actor.default-dispatcher"
  21
  22       # Fully qualified config path which holds the dispatcher configuration
  23       # or full dispatcher configuration to be used by stream operators that
  24       # perform blocking operations
  25       blocking-io-dispatcher = "akka.actor.default-blocking-io-dispatcher"
  26
  27       # Cleanup leaked publishers and subscribers when they are not used within a given
  28       # deadline
  29       subscription-timeout {
  30         # when the subscription timeout is reached one of the following strategies on
  31         # the "stale" publisher:
  32         # cancel - cancel it (via `onError` or subscribing to the publisher and
  33         #          `cancel()`ing the subscription right away
  34         # warn   - log a warning statement about the stale element (then drop the
  35         #          reference to it)
  36         # noop   - do nothing (not recommended)
  37         mode = cancel
  38
  39         # time after which a subscriber / publisher is considered stale and eligible
  40         # for cancelation (see `akka.stream.subscription-timeout.mode`)
  41         timeout = 5s
  42       }
  43
  44       # Enable additional troubleshooting logging at DEBUG log level
  45       debug-logging = off
  46
  47       # Maximum number of elements emitted in batch if downstream signals large demand
  48       output-burst-limit = 1000
  49
  50       # Enable automatic fusing of all graphs that are run. For short-lived streams
  51       # this may cause an initial runtime overhead, but most of the time fusing is
  52       # desirable since it reduces the number of Actors that are created.
  53       # Deprecated, since Akka 2.5.0, setting does not have any effect.
  54       auto-fusing = on
  55
  56       # Those stream elements which have explicit buffers (like mapAsync, mapAsyncUnordered,
  57       # buffer, flatMapMerge, Source.actorRef, Source.queue, etc.) will preallocate a fixed
  58       # buffer upon stream materialization if the requested buffer size is less than this
  59       # configuration parameter. The default is very high because failing early is better
  60       # than failing under load.
  61       #
  62       # Buffers sized larger than this will dynamically grow/shrink and consume more memory
  63       # per element than the fixed size buffers.
  64       max-fixed-buffer-size = 1000000000
  65
  66       # Maximum number of sync messages that actor can process for stream to substream communication.
  67       # Parameter allows to interrupt synchronous processing to get upstream/downstream messages.
  68       # Allows to accelerate message processing that happening within same actor but keep system responsive.
  69       sync-processing-limit = 1000
  70
  71       debug {
  72         # Enables the fuzzing mode which increases the chance of race conditions
  73         # by aggressively reordering events and making certain operations more
  74         # concurrent than usual.
  75         # This setting is for testing purposes, NEVER enable this in a production
  76         # environment!
  77         # To get the best results, try combining this setting with a throughput
  78         # of 1 on the corresponding dispatchers.
  79         fuzzing-mode = off
  80       }
  81
  82       io.tcp {
  83         # The outgoing bytes are accumulated in a buffer while waiting for acknowledgment
  84         # of pending write. This improves throughput for small messages (frames) without
  85         # sacrificing latency. While waiting for the ack the stage will eagerly pull
  86         # from upstream until the buffer exceeds this size. That means that the buffer may hold
  87         # slightly more bytes than this limit (at most one element more). It can be set to 0
  88         # to disable the usage of the buffer.
  89         write-buffer-size = 16 KiB
  90       }
  91
  92       # Time to wait for async materializer creation before throwing an exception
  93       creation-timeout = 20 seconds
  94
  95       //#stream-ref
  96       # configure defaults for SourceRef and SinkRef
  97       stream-ref {
  98         # Buffer of a SinkRef that is used to batch Request elements from the other side of the stream ref
  99         #
 100         # The buffer will be attempted to be filled eagerly even while the local stage did not request elements,
 101         # because the delay of requesting over network boundaries is much higher.
 102         buffer-capacity = 32
 103
 104         # Demand is signalled by sending a cumulative demand message ("requesting messages until the n-th sequence number)
 105         # Using a cumulative demand model allows us to re-deliver the demand message in case of message loss (which should
 106         # be very rare in any case, yet possible -- mostly under connection break-down and re-establishment).
 107         #
 108         # The semantics of handling and updating the demand however are in-line with what Reactive Streams dictates.
 109         #
 110         # In normal operation, demand is signalled in response to arriving elements, however if no new elements arrive
 111         # within `demand-redelivery-interval` a re-delivery of the demand will be triggered, assuming that it may have gotten lost.
 112         demand-redelivery-interval = 1 second
 113
 114         # Subscription timeout, during which the "remote side" MUST subscribe (materialize) the handed out stream ref.
 115         # This timeout does not have to be very low in normal situations, since the remote side may also need to
 116         # prepare things before it is ready to materialize the reference. However the timeout is needed to avoid leaking
 117         # in-active streams which are never subscribed to.
 118         subscription-timeout = 30 seconds
 119
 120         # In order to guard the receiving end of a stream ref from never terminating (since awaiting a Completion or Failed
 121         # message) after / before a Terminated is seen, a special timeout is applied once Terminated is received by it.
 122         # This allows us to terminate stream refs that have been targeted to other nodes which are Downed, and as such the
 123         # other side of the stream ref would never send the "final" terminal message.
 124         #
 125         # The timeout specifically means the time between the Terminated signal being received and when the local SourceRef
 126         # determines to fail itself, assuming there was message loss or a complete partition of the completion signal.
 127         final-termination-signal-deadline = 2 seconds
 128       }
 129       //#stream-ref
 130     }
 131
 132     # Deprecated, left here to not break Akka HTTP which refers to it
 133     blocking-io-dispatcher = "akka.actor.default-blocking-io-dispatcher"
 134
 135     # Deprecated, will not be used unless user code refer to it, use 'akka.stream.materializer.blocking-io-dispatcher'
 136     # instead, or if from code, prefer the 'ActorAttributes.IODispatcher' attribute
 137     default-blocking-io-dispatcher = "akka.actor.default-blocking-io-dispatcher"
 138   }
 139
 140   # configure overrides to ssl-configuration here (to be used by akka-streams, and akka-http – i.e. when serving https connections)
 141   ssl-config {
 142     protocol = "TLSv1.2"
 143   }
 144
 145   actor {
 146
 147     serializers {
 148       akka-stream-ref = "akka.stream.serialization.StreamRefSerializer"
 149     }
 150
 151     serialization-bindings {
 152       "akka.stream.SinkRef"                           = akka-stream-ref
 153       "akka.stream.SourceRef"                         = akka-stream-ref
 154       "akka.stream.impl.streamref.StreamRefsProtocol" = akka-stream-ref
 155     }
 156
 157     serialization-identifiers {
 158       "akka.stream.serialization.StreamRefSerializer" = 30
 159     }
 160   }
 161 }
 162
 163 # ssl configuration
 164 # folded in from former ssl-config-akka module
 165 ssl-config {
 166   logger = "com.typesafe.sslconfig.akka.util.AkkaLoggerBridge"
 167 }