#################### # 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 = "1.0-RC1" # 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 # 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"] 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 default-dispatcher { type = "GlobalExecutorBasedEventDriven" # Must be one of the following, all "Global*" are non-configurable # - Hawt # - ExecutorBasedEventDriven # - ExecutorBasedEventDrivenWorkStealing # - GlobalHawt # - 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 aggregate = off # Aggregate on/off for HawtDispatchers 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) } } 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" hooks = true jta-aware = off # Option 'on' means that if there JTA Transaction Manager available then the STM will # begin (or join), commit or rollback the JTA transaction. Default is 'off'. } jta { provider = "from-jndi" # Options: - "from-jndi" (means that Akka will try to detect a TransactionManager in the JNDI) # - "atomikos" (means that Akka will use the Atomikos based JTA impl in 'akka-jta', # e.g. you need the akka-jta JARs on classpath). timeout = 60 } http { hostname = "localhost" port = 9998 #If you are using akka.http.AkkaRestServlet filters = ["se.scalablesolutions.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 authenticator = "sample.security.BasicAuthenticationService" # The authentication service to use. Need to be overridden (sample now) # Uncomment if you are using the KerberosAuthenticationActor # kerberos { # servicePrincipal = "HTTP/localhost@EXAMPLE.COM" # keyTabLocation = "URL to keytab" # kerberosDebug = "true" # realm = "EXAMPLE.COM" # } #If you are using akka.http.AkkaMistServlet mist-dispatcher { #type = "Hawt" # 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_secure_cookie.sh' or using 'Crypt.generateSecureCookie' 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 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 = on # 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. } client { reconnect-delay = 5 read-timeout = 10 message-frame-size = 1048576 reconnection-time-window = 600 # Maximum time window that a client should try to reconnect for } } persistence { cassandra { hostname = "127.0.0.1" # IP address or hostname of one of the Cassandra cluster's seeds port = 9160 # Port to Cassandra consistency-level = "QUORUM" # Options: ZERO, ONE, QUORUM, DCQUORUM, DCQUORUMSYNC, ALL, ANY } mongodb { hostname = "127.0.0.1" # IP address or hostname of the MongoDB DB instance port = 27017 # Port to MongoDB dbname = "mydb" } redis { hostname = "127.0.0.1" # IP address or hostname of the Redis instance port = 6379 # Port to Redis } couchdb { url = "http://localhost:5984/testakka/" } hbase { zookeeper-quorum = "localhost" # A comma separated list of hostnames or IPs of the zookeeper quorum instances } voldemort { store { ref = "Refs" # Voldemort Store Used to Persist Refs. Use string serializer for keys, identity serializer for values maps = "Maps" # Voldemort Store Used to Persist Map Keys. Use identity serializer for keys, identity serializer for values vector = "Vectors" # Voldemort Store Used to Persist Vector Sizes. Use identity serializer for keys, identity serializer for values queue = "Queues" # Voldemort Store Used to Persist Vector Values. Use identity serializer for keys, identity serializer for values } client { # The KeyValue pairs under client are converted to java Properties and used to construct the Voldemort ClientConfig bootstrap_urls = "tcp://localhost:6666" # All Valid Voldemort Client properties are valid here, in string form } } riak { bucket { ref = "Refs" maps = "Maps" vector = "Vectors" queue = "Queues" } client { host = "localhost" port = 8087 #Default Riak Protobuf port } } memcached { client { addresses = "localhost:11211" #Formatted according to spymemcached "localhost:11211 otherhost:11211" etc.. } } simpledb { account { id = "YOU NEED TO PROVIDE AN AWS ID" secretKey = "YOU NEED TO PROVIDE AN AWS SECRETKEY" } client { #Defaults to default AWS ClientConfiguration timeout =50000 #maxconnections = maxretries = 10 #protocol = "HTTPS" | "HTTP" #sockettimeout 50000 #sendbuffer = 0 #receivebuffer = 0 #useragent = "AWS Java SDK-1.0.14" } domain { ref = "ref" map = "map" vector = "vector" queue = "queue" } } } }