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

   1 akka.actor.typed {
   2
   3   # List FQCN of `akka.actor.typed.ExtensionId`s which shall be loaded at actor system startup.
   4   # Should be on the format: 'extensions = ["com.example.MyExtId1", "com.example.MyExtId2"]' etc.
   5   # See the Akka Documentation for more info about Extensions
   6   extensions = []
   7
   8   # List FQCN of extensions which shall be loaded at actor system startup.
   9   # Library extensions are regular extensions that are loaded at startup and are
  10   # available for third party library authors to enable auto-loading of extensions when
  11   # present on the classpath. This is done by appending entries:
  12   # 'library-extensions += "Extension"' in the library `reference.conf`.
  13   #
  14   # Should not be set by end user applications in 'application.conf', use the extensions property for that
  15   #
  16   library-extensions = ${?akka.actor.typed.library-extensions} []
  17
  18   # Receptionist is started eagerly to allow clustered receptionist to gather remote registrations early on.
  19   library-extensions += "akka.actor.typed.receptionist.Receptionist$"
  20
  21   # While an actor is restarted (waiting for backoff to expire and children to stop)
  22   # incoming messages and signals are stashed, and delivered later to the newly restarted
  23   # behavior. This property defines the capacity in number of messages of the stash
  24   # buffer. If the capacity is exceed then additional incoming messages are dropped.
  25   restart-stash-capacity = 1000
  26
  27   # Typed mailbox defaults to the single consumber mailbox as balancing dispatcher is not supported
  28   default-mailbox {
  29     mailbox-type = "akka.dispatch.SingleConsumerOnlyUnboundedMailbox"
  30   }
  31 }
  32
  33 # Load typed extensions by a classic extension.
  34 akka.library-extensions += "akka.actor.typed.internal.adapter.ActorSystemAdapter$LoadTypedExtensions"
  35
  36 akka.actor {
  37   serializers {
  38     typed-misc = "akka.actor.typed.internal.MiscMessageSerializer"
  39     service-key = "akka.actor.typed.internal.receptionist.ServiceKeySerializer"
  40   }
  41
  42   serialization-identifiers {
  43     "akka.actor.typed.internal.MiscMessageSerializer" = 24
  44     "akka.actor.typed.internal.receptionist.ServiceKeySerializer" = 26
  45   }
  46
  47   serialization-bindings {
  48     "akka.actor.typed.ActorRef" = typed-misc
  49     "akka.actor.typed.internal.adapter.ActorRefAdapter" = typed-misc
  50     "akka.actor.typed.internal.receptionist.DefaultServiceKey" = service-key
  51   }
  52 }
  53
  54 # When using Akka Typed (having akka-actor-typed in classpath) the
  55 # akka.event.slf4j.Slf4jLogger is enabled instead of the DefaultLogger
  56 # even though it has not been explicitly defined in `akka.loggers`
  57 # configuration.
  58 #
  59 # Slf4jLogger will be used for all Akka classic logging via eventStream,
  60 # including logging from Akka internals. The Slf4jLogger is then using
  61 # an ordinary org.slf4j.Logger to emit the log events.
  62 #
  63 # The Slf4jLoggingFilter is also enabled automatically.
  64 #
  65 # This behavior can be disabled by setting this property to `off`.
  66 akka.use-slf4j = on
  67
  68 akka.reliable-delivery {
  69   producer-controller {
  70
  71     # To avoid head of line blocking from serialization and transfer
  72     # of large messages this can be enabled.
  73     # Large messages are chunked into pieces of the given size in bytes. The
  74     # chunked messages are sent separatetely and assembled on the consumer side.
  75     # Serialization and deserialization is performed by the ProducerController and
  76     # ConsumerController respectively instead of in the remote transport layer.
  77     chunk-large-messages = off
  78
  79     durable-queue {
  80       # The ProducerController uses this timeout for the requests to
  81       # the durable queue. If there is no reply within the timeout it
  82       # will be retried.
  83       request-timeout = 3s
  84
  85       # The ProducerController retries requests to the durable queue this
  86       # number of times before failing.
  87       retry-attempts = 10
  88
  89       # The ProducerController retries sending the first message with this interval
  90       # until it has been confirmed.
  91       resend-first-interval = 1s
  92     }
  93   }
  94
  95   consumer-controller {
  96     # Number of messages in flight between ProducerController and
  97     # ConsumerController. The ConsumerController requests for more messages
  98     # when half of the window has been used.
  99     flow-control-window = 50
 100
 101     # The ConsumerController resends flow control messages to the
 102     # ProducerController with the resend-interval-min, and increasing
 103     # it gradually to resend-interval-max when idle.
 104     resend-interval-min = 2s
 105     resend-interval-max = 30s
 106
 107     # If this is enabled lost messages will not be resent, but flow control is used.
 108     # This can be more efficient since messages don't have to be
 109     # kept in memory in the `ProducerController` until they have been
 110     # confirmed, but the drawback is that lost messages will not be delivered.
 111     only-flow-control = false
 112   }
 113
 114   work-pulling {
 115     producer-controller = ${akka.reliable-delivery.producer-controller}
 116     producer-controller {
 117       # Limit of how many messages that can be buffered when there
 118       # is no demand from the consumer side.
 119       buffer-size = 1000
 120
 121       # Ask timeout for sending message to worker until receiving Ack from worker
 122       internal-ask-timeout = 60s
 123
 124       # Chunked messages not implemented for work-pulling yet. Override to not
 125       # propagate property from akka.reliable-delivery.producer-controller.
 126       chunk-large-messages = off
 127     }
 128   }
 129 }