akka {
  version = "1.3.1"

  enabled-modules = ["remote", "http", "amqp"]

  time-unit = "seconds"

  event-handlers = ["akka.event.EventHandler$DefaultListener", "akka.event.slf4j.Slf4jEventHandler"] # event handlers to register at boot time (EventHandler$DefaultListener logs to STDOUT)
  event-handler-level = "DEBUG" # 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:        ? and ask
                                       #    - UntypedActor: ask
                                       #    - 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

    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
      task-queue-size = -1             # Specifies the bounded capacity of the task queue (< 1 == unbounded)
      task-queue-type = "linked"       # Specifies which type of task queue will be used, can be "array" or "linked" (default)
      allow-core-timeout = on          # Allow core threads to time out
      rejection-policy = "sane"        # sane, 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)
    }

    debug {
      receive = "false"       # enable function of Actor.loggable(), which is
                              # to log any received message at DEBUG level
      autoreceive = "false"   # enable DEBUG logging of all AutoReceiveMessages
                              # (Kill, PoisonPill and the like)
      lifecycle = "false"     # enable DEBUG logging of actor lifecycle changes
    }

  remote {
    # secure-cookie = "050E0A0D0D06010A00000900040D060F0C09060B" # generate your own with '$AKKA_HOME/scripts/generate_config_with_secure_cookie.sh' or using 'Crypt.generateSecureCookie'
    secure-cookie = ""

    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 = 100     # Number in time-unit
      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 = off # Buffer outbound messages when send failed, if off you'll get an exception instead
        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                  # Number in time-unit
      read-timeout = 120                   # Number in time-unit
      message-frame-size = 1048576         # Size in bytes
      reap-futures-delay = 5               # Number in time-unit
      reconnection-time-window = 600 # Maximum time window that a client should try to reconnect for
    }
  }

  test {
    timefactor = "1.0"    # factor by which to scale timeouts during tests, e.g. to account for shared build system load
  }
}

# spray-can config
spray-can {
  server {
    port = 8888
    service-actor-id = "spray-root-service"
    timeout-actor-id = "spray-root-service" # we want to handle timeouts with the same service actor
    request-timeout = 3000 # require all requests to be completed within 3 seconds
  }
}