#################### # Akka Config File # #################### # This file has all the default settings, so all these could be removed with no visible effect. # Modify as needed. akka { version = "2.0-SNAPSHOT" # Akka version, checked against the runtime version of Akka. enabled-modules = [] # Comma separated list of the enabled modules. Options: ["remote", "camel", "http"] time-unit = "seconds" # Time unit for all timeout properties throughout the config event-handlers = ["akka.event.EventHandler$DefaultListener"] # Event handlers to register at boot time (EventHandler$DefaultListener logs to STDOUT) event-handler-level = "INFO" # Options: ERROR, WARNING, INFO, DEBUG # These boot classes are loaded (and created) automatically when the Akka Microkernel boots up # Can be used to bootstrap your application(s) # Should be the FQN (Fully Qualified Name) of the boot class which needs to have a default constructor # boot = ["sample.camel.Boot", # "sample.rest.java.Boot", # "sample.rest.scala.Boot", # "sample.security.Boot"] boot = [] actor { timeout = 5 # Default timeout for Future based invocations # - Actor: !! && !!! # - UntypedActor: sendRequestReply && sendRequestReplyFuture # - TypedActor: methods with non-void return type serialize-messages = off # Does a deep clone of (non-primitive) messages to ensure immutability throughput = 5 # Default throughput for all ExecutorBasedEventDrivenDispatcher, set to 1 for complete fairness throughput-deadline-time = -1 # Default throughput deadline for all ExecutorBasedEventDrivenDispatcher, set to 0 or negative for no deadline dispatcher-shutdown-timeout = 1 # Using the akka.time-unit, how long dispatchers by default will wait for new actors until they shut down deployment { # ------------------------------- # -- all configuration options -- # ------------------------------- service-pi { # stateless actor with replication factor 3 and round-robin load-balancer router = "round-robin" # routing (load-balance) scheme to use # available: "direct", "round-robin", "random", "least-cpu", "least-ram", "least-messages" # or: fully qualified class name of the router class # default is "direct"; format = "akka.serialization.Format$Default$" clustered { # makes the actor available in the cluster registry # default (if omitted) is local non-clustered actor home = "node:test-1" # defines the hostname, IP-address or node name of the "home" node for clustered actor # available: "host:", "ip:" and "node:" # default is "host:localhost" replicas = 3 # number of actor replicas in the cluster # available: integer above 0 (1-N) or the string "auto" for auto-scaling # if "auto" is used then 'home' has no meaning # default is '1'; stateless = on # is the actor stateless or stateful # if turned 'on': actor is defined as stateless and can be load-balanced accordingly # if turned 'off' (or omitted): actor is defined as stateful which means replicatable through transaction log # default is 'off' } } # ---------------------------------- # -- variations of using defaults -- # ---------------------------------- service-ping-1 {} # local actor service-pong-2 { # stateful actor with replication factor 1 and default home address clustered {} } service-pong-2 { # stateless actor with replication factor 1 and routing 'direct' and default home address clustered { stateless = on } } service-pong-4 { # stateless autoscaled actor router = "least-cpu" clustered { home = "ip:0.0.0.0" replicas = "auto" stateless = on } } session-registry { # stateful, replicated actor with replication factor 3 clustered { home = "host:darkstar.lan" replicas = 3 } } } default-dispatcher { type = "GlobalExecutorBasedEventDriven" # Must be one of the following, all "Global*" are non-configurable # - ExecutorBasedEventDriven # - ExecutorBasedEventDrivenWorkStealing # - GlobalExecutorBasedEventDriven keep-alive-time = 60 # Keep alive time for threads core-pool-size-factor = 1.0 # No of core threads ... ceil(available processors * factor) max-pool-size-factor = 4.0 # Max no of threads ... ceil(available processors * factor) executor-bounds = -1 # Makes the Executor bounded, -1 is unbounded allow-core-timeout = on # Allow core threads to time out rejection-policy = "caller-runs" # abort, caller-runs, discard-oldest, discard throughput = 5 # Throughput for ExecutorBasedEventDrivenDispatcher, set to 1 for complete fairness throughput-deadline-time = -1 # Throughput deadline for ExecutorBasedEventDrivenDispatcher, set to 0 or negative for no deadline mailbox-capacity = -1 # If negative (or zero) then an unbounded mailbox is used (default) # If positive then a bounded mailbox is used and the capacity is set using the property # NOTE: setting a mailbox to 'blocking' can be a bit dangerous, could lead to deadlock, use with care # The following are only used for ExecutorBasedEventDriven and only if mailbox-capacity > 0 mailbox-push-timeout-time = 10 # Specifies the timeout to add a new message to a mailbox that is full - negative number means infinite timeout # (in unit defined by the time-unit property) } mailbox { file-based { directory-path = "./_mb" max-items = 2147483647 max-size = 2147483647 max-items = 2147483647 max-age = 0 max-journal-size = 16777216 # 16 * 1024 * 1024 max-memory-size = 134217728 # 128 * 1024 * 1024 max-journal-overflow = 10 max-journal-size-absolute = 9223372036854775807 discard-old-when-full = on keep-journal = on sync-journal = off } redis { hostname = "127.0.0.1" port = 6379 } zookeeper { server-addresses = "localhost:2181" session-timeout = 60 connection-timeout = 60 blocking-queue = on } beanstalk { hostname = "127.0.0.1" port = 11300 reconnect-window = 5 message-submit-delay = 0 message-submit-timeout = 5 message-time-to-live = 120 } } } cluster { name = "test-cluster" zookeeper-server-addresses = "localhost:2181" remote-server-port = 2552 max-time-to-wait-until-connected = 30 session-timeout = 60 connection-timeout = 60 use-compression = off replication { digest-type = "MAC" # Options: CRC32 (cheap & unsafe), MAC (expensive & secure using password) password = "secret" ensemble-size = 3 quorum-size = 2 } } stm { fair = on # Should global transactions be fair or non-fair (non fair yield better performance) max-retries = 1000 timeout = 5 # Default timeout for blocking transactions and transaction set (in unit defined by # the time-unit property) write-skew = true blocking-allowed = false interruptible = false speculative = true quick-release = true propagation = "requires" trace-level = "none" } http { hostname = "localhost" port = 9998 #If you are using akka.http.AkkaRestServlet filters = ["akka.security.AkkaSecurityFilterFactory"] # List with all jersey filters to use # resource-packages = ["sample.rest.scala", # "sample.rest.java", # "sample.security"] # List with all resource packages for your Jersey services resource-packages = [] # The authentication service to use. Need to be overridden (sample now) # authenticator = "sample.security.BasicAuthenticationService" authenticator = "N/A" # Uncomment if you are using the KerberosAuthenticationActor # kerberos { # servicePrincipal = "HTTP/localhost@EXAMPLE.COM" # keyTabLocation = "URL to keytab" # kerberosDebug = "true" # realm = "EXAMPLE.COM" # } kerberos { servicePrincipal = "N/A" keyTabLocation = "N/A" kerberosDebug = "N/A" realm = "" } # If you are using akka.http.AkkaMistServlet mist-dispatcher { #type = "GlobalExecutorBasedEventDriven" # Uncomment if you want to use a different dispatcher than the default one for Comet } connection-close = true # toggles the addition of the "Connection" response header with a "close" value root-actor-id = "_httproot" # the id of the actor to use as the root endpoint root-actor-builtin = true # toggles the use of the built-in root endpoint base class timeout = 1000 # the default timeout for all async requests (in ms) expired-header-name = "Async-Timeout" # the name of the response header to use when an async request expires expired-header-value = "expired" # the value of the response header to use when an async request expires } remote { # secure-cookie = "050E0A0D0D06010A00000900040D060F0C09060B" # generate your own with '$AKKA_HOME/scripts/generate_config_with_secure_cookie.sh' or using 'Crypt.generateSecureCookie' secure-cookie = "" compression-scheme = "zlib" # Options: "zlib" (lzf to come), leave out for no compression zlib-compression-level = 6 # Options: 0-9 (1 being fastest and 9 being the most compressed), default is 6 layer = "akka.remote.netty.NettyRemoteSupport" server { hostname = "localhost" # The hostname or IP that clients should connect to port = 2552 # The port clients should connect to. Default is 2552 (AKKA) message-frame-size = 1048576 # Increase this if you want to be able to send messages with large payloads connection-timeout = 1 require-cookie = off # Should the remote server require that it peers share the same secure-cookie (defined in the 'remote' section)? untrusted-mode = off # Enable untrusted mode for full security of server managed actors, allows untrusted clients to connect. backlog = 4096 # Sets the size of the connection backlog execution-pool-keepalive = 60 # Length in akka.time-unit how long core threads will be kept alive if idling execution-pool-size = 16 # Size of the core pool of the remote execution unit max-channel-memory-size = 0 # Maximum channel size, 0 for off max-total-memory-size = 0 # Maximum total size of all channels, 0 for off } client { buffering { retry-message-send-on-failure = on capacity = -1 # If negative (or zero) then an unbounded mailbox is used (default) # If positive then a bounded mailbox is used and the capacity is set using the property } reconnect-delay = 5 read-timeout = 10 message-frame-size = 1048576 reap-futures-delay = 5 reconnection-time-window = 600 # Maximum time window that a client should try to reconnect for } } }