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

©2013 OpenDaylight, A Linux Foundation Collaborative Project. All Rights Reserved.
OpenDaylight is a registered trademark of The OpenDaylight Project, Inc.
Linux Foundation and OpenDaylight are registered trademarks of the Linux Foundation.
Linux is a registered trademark of Linus Torvalds.