Aquarium

  cp $CONF_SRC/logback.xml $DIST/conf|| fail "copying logback.xml"

  cp $CONF_SRC/policy.yaml $DIST/conf || fail "copying policy.yaml"

    echo "nohup java $JAVA_OPTS -cp $CLASSPATH $AQUARIUM_PROP $JBOOT_MAIN_CLASS -lib $AQUARIUM_LIB $AQUARIUM_MAIN_CLASS > $AQUARIUM_LOGFILE"

    nohup java $JAVA_OPTS -cp $CLASSPATH $AQUARIUM_PROP $JBOOT_MAIN_CLASS -lib $AQUARIUM_LIB $AQUARIUM_MAIN_CLASS > $AQUARIUM_LOGFILE 2>&1 &

    echo $! > $PID_FILE

    echo "PID="`cat $PID_FILE`

          throw new AquariumException("%s = %s is not a folder".format(Keys.events_store_folder, canonicalFolder))

import gr.grnet.aquarium.util.isRunningTests

import com.ckkloverdos.maybe.{MaybeEither, Failed, Just}

    // http://logback.qos.ch/manual/joran.html

    LoggerFactory.getILoggerFactory match {

      case context: LoggerContext ⇒

        MaybeEither {

          val joran = new JoranConfigurator

          joran.setContext(context)

          context.reset()

          joran.doConfigure(ResourceLocator.LOGBACK_XML_FILE)

          logger.info("Logging subsystem configured from {}", ResourceLocator.LOGBACK_XML_FILE)

        } match {

          case Just(_) ⇒

            StatusPrinter.printInCaseOfErrorsOrWarnings(context)

          case Failed(e) ⇒

            StatusPrinter.print(context)

            throw new AquariumException(e, "Could not configure logging from %s".format(ResourceLocator.LOGBACK_XML_FILE))

        }

      case _ ⇒

    }

    mc.eventsStoreFolder match {

      case Just(folder) ⇒

        logger.info("{} = {}", Configurator.Keys.events_store_folder, folder)

      case failed @ Failed(e) ⇒

        throw e

      case _ ⇒

    for {

      prop <- PropsToShow

    } {

    logStarting("Aquarium from %s", ResourceLocator.AQUARIUM_HOME_FOLDER)

 * Used to locate configuration files.

  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 = []

    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"

      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

  }

}