• Home
• org.akka-js
• akkajsactor_sjs0.6_2.12
• 1.2.5.26
• source code

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

kkajsactor_sjs0.6_2.12.1.2.5.26.source-code.application.conf Maven / Gradle / Ivy

akka {
  home = ""
  version = "2.5-SNAPSHOT"
  loggers = ["akka.event.JSDefaultLogger"]
  logging-filter = "akka.event.JSDefaultLoggingFilter"
  loggers-dispatcher = "akka.actor.default-dispatcher"
  logger-startup-timeout = 5s
  loglevel = "INFO"
  stdout-loglevel = "WARNING"
  log-config-on-start = off
  log-dead-letters = 10
  log-dead-letters-during-shutdown = on
  library-extensions = []
  extensions = []
  daemonic = off
  jvm-exit-on-fatal-error = on
  jvm-shutdown-hooks = off
  actor {
    provider = "akka.actor.JSLocalActorRefProvider"
    guardian-supervisor-strategy = "akka.actor.DefaultSupervisorStrategy"
    creation-timeout = 20s
    serialize-messages = off
    serialize-creators = off
    unstarted-push-timeout = 10s
    typed {
      timeout = 5s
      extensions = []
      library-extensions = []
    }
    router.type-mapping {
      from-code = "akka.routing.NoRouter"
      round-robin-pool = "akka.routing.RoundRobinPool"
      round-robin-group = "akka.routing.RoundRobinGroup"
      random-pool = "akka.routing.RandomPool"
      random-group = "akka.routing.RandomGroup"
      balancing-pool = "akka.routing.BalancingPool"
      smallest-mailbox-pool = "akka.routing.SmallestMailboxPool"
      broadcast-pool = "akka.routing.BroadcastPool"
      broadcast-group = "akka.routing.BroadcastGroup"
      scatter-gather-pool = "akka.routing.ScatterGatherFirstCompletedPool"
      scatter-gather-group = "akka.routing.ScatterGatherFirstCompletedGroup"
      tail-chopping-pool = "akka.routing.TailChoppingPool"
      tail-chopping-group = "akka.routing.TailChoppingGroup"
      consistent-hashing-pool = "akka.routing.ConsistentHashingPool"
      consistent-hashing-group = "akka.routing.ConsistentHashingGroup"
    }

    deployment {
      default {
        dispatcher = ""
        mailbox = ""
        router = "from-code"
        nr-of-instances = 1
        within = 5 seconds
        virtual-nodes-factor = 10
        tail-chopping-router {
          interval = 10 milliseconds
        }

        routees {
          paths = []
        }
        resizer {
          enabled = off
          lower-bound = 1
          upper-bound = 10
          pressure-threshold = 1
          rampup-rate = 0.2
          backoff-threshold = 0.3
          backoff-rate = 0.1.
          messages-per-resize = 10
        }

        optimal-size-exploring-resizer {
          enabled = off
          lower-bound = 1
          upper-bound = 10
          chance-of-ramping-down-when-full = 0.2
          action-interval = 5s
          downsize-after-underutilized-for = 72h
          explore-step-size = 0.1
          chance-of-exploration = 0.4
          downsize-ratio = 0.8.
          optimization-range = 16
          weight-of-latest-metric = 0.5
        }
      }
    }

    default-dispatcher {
      type = "Dispatcher"
      executor = "default-executor"
      default-executor {
        fallback = "fork-join-executor"
      }
      fork-join-executor {
        parallelism-min = 8
        parallelism-factor = 3.0
        parallelism-max = 64
        task-peeking-mode = "FIFO"
      }
      thread-pool-executor {
        keep-alive-time = 60s
        fixed-pool-size = off
        core-pool-size-min = 8
        core-pool-size-factor = 3.0
        core-pool-size-max = 64
        max-pool-size-min = 8
        max-pool-size-factor  = 3.0
        max-pool-size-max = 64
        task-queue-size = -1
        task-queue-type = "linked"
        allow-core-timeout = on
      }
      shutdown-timeout = 1s
      throughput = 5
      throughput-deadline-time = 0ms
      attempt-teamwork = on
      mailbox-requirement = ""
    }

    default-blocking-io-dispatcher {
      type = "Dispatcher"
      executor = "thread-pool-executor"
      throughput = 1
      thread-pool-executor {
        fixed-pool-size = 16
      }
    }

    default-mailbox {
      mailbox-type = "akka.dispatch.UnboundedMailbox"
      mailbox-capacity = 1000
      mailbox-push-timeout-time = 10s
      stash-capacity = -1
    }

    mailbox {
      requirements {
        "akka.dispatch.UnboundedMessageQueueSemantics" =
          akka.actor.mailbox.unbounded-queue-based
        "akka.dispatch.BoundedMessageQueueSemantics" =
          akka.actor.mailbox.bounded-queue-based
        "akka.dispatch.DequeBasedMessageQueueSemantics" =
          akka.actor.mailbox.unbounded-deque-based
        "akka.dispatch.UnboundedDequeBasedMessageQueueSemantics" =
          akka.actor.mailbox.unbounded-deque-based
        "akka.dispatch.BoundedDequeBasedMessageQueueSemantics" =
          akka.actor.mailbox.bounded-deque-based
        "akka.dispatch.MultipleConsumerSemantics" =
          akka.actor.mailbox.unbounded-queue-based
        "akka.dispatch.ControlAwareMessageQueueSemantics" =
          akka.actor.mailbox.unbounded-control-aware-queue-based
        "akka.dispatch.UnboundedControlAwareMessageQueueSemantics" =
          akka.actor.mailbox.unbounded-control-aware-queue-based
        "akka.dispatch.BoundedControlAwareMessageQueueSemantics" =
          akka.actor.mailbox.bounded-control-aware-queue-based
        "akka.event.LoggerMessageQueueSemantics" =
          akka.actor.mailbox.logger-queue
      }
      unbounded-queue-based {
        mailbox-type = "akka.dispatch.UnboundedMailbox"
      }
      bounded-queue-based {
        mailbox-type = "akka.dispatch.BoundedMailbox"
      }
      unbounded-deque-based {
        mailbox-type = "akka.dispatch.UnboundedDequeBasedMailbox"
      }
      bounded-deque-based {
        mailbox-type = "akka.dispatch.BoundedDequeBasedMailbox"
      }
      unbounded-control-aware-queue-based {
        mailbox-type = "akka.dispatch.UnboundedControlAwareMailbox"
      }
      bounded-control-aware-queue-based {
        mailbox-type = "akka.dispatch.BoundedControlAwareMailbox"
      }
      logger-queue {
        mailbox-type = "akka.event.LoggerMailboxType"
      }
    }

    debug {
      receive = off
      autoreceive = off
      lifecycle = off
      fsm = off
      event-stream = off
      unhandled = off
      router-misconfiguration = off
    }
    allow-java-serialization = off
    serializers {
      bytes = "akka.serialization.ByteArraySerializer"
    }
    serialization-bindings {
      "[B" = bytes
      "java.io.Serializable" = none
    }
    enable-additional-serialization-bindings = on
    additional-serialization-bindings {}
    warn-about-java-serializer-usage = on
    warn-on-no-serialization-verification = on
    serialization-identifiers {
      "akka.serialization.JavaSerializer" = 1
      "akka.serialization.ByteArraySerializer" = 4
    }
    dsl {
      inbox-size = 1000
      default-timeout = 5s
    }
  }
  scheduler {
    tick-duration = 10ms
    ticks-per-wheel = 512
    implementation = akka.actor.EventLoopScheduler
    shutdown-timeout = 5s
  }

  io {
    pinned-dispatcher {
      type = "PinnedDispatcher"
      executor = "thread-pool-executor"
      thread-pool-executor.allow-core-timeout = off
    }
    tcp {
      nr-of-selectors = 1
      max-channels = 256000
      selector-association-retries = 10
      batch-accept-limit = 10
      direct-buffer-size = 128 KiB
      direct-buffer-pool-limit = 1000
      register-timeout = 5s
      max-received-message-size = unlimited
      trace-logging = off
      selector-dispatcher = "akka.io.pinned-dispatcher"
      worker-dispatcher = "akka.actor.default-dispatcher"
      management-dispatcher = "akka.actor.default-dispatcher"
      file-io-dispatcher = "akka.actor.default-blocking-io-dispatcher"
      file-io-transferTo-limit = 512 KiB
      finish-connect-retries = 5
      windows-connection-abort-workaround-enabled = off
    }

    udp {
      nr-of-selectors = 1
      max-channels = 4096
      select-timeout = infinite
      selector-association-retries = 10
      receive-throughput = 3
      direct-buffer-size = 128 KiB
      direct-buffer-pool-limit = 1000
      trace-logging = off
      selector-dispatcher = "akka.io.pinned-dispatcher"
      worker-dispatcher = "akka.actor.default-dispatcher"
      management-dispatcher = "akka.actor.default-dispatcher"
    }

    udp-connected {
      nr-of-selectors = 1
      max-channels = 4096
      select-timeout = infinite
      selector-association-retries = 10
      receive-throughput = 3
      direct-buffer-size = 128 KiB
      direct-buffer-pool-limit = 1000
      trace-logging = off
      selector-dispatcher = "akka.io.pinned-dispatcher"
      worker-dispatcher = "akka.actor.default-dispatcher"
      management-dispatcher = "akka.actor.default-dispatcher"
    }

    dns {
      dispatcher = "akka.actor.default-dispatcher"
      resolver = "inet-address"
      inet-address {
        provider-object = "akka.io.InetAddressDnsProvider"
        positive-ttl = default
        negative-ttl = default
        cache-cleanup-interval = 120s
      }
    }
  }
  coordinated-shutdown {
    default-phase-timeout = 5 s
    terminate-actor-system = on
    exit-jvm = off
    run-by-jvm-shutdown-hook = on
    phases {
      before-service-unbind {
      }
      service-unbind {
        depends-on = [before-service-unbind]
      }
      service-requests-done {
        depends-on = [service-unbind]
      }
      service-stop {
        depends-on = [service-requests-done]
      }
      before-cluster-shutdown {
        depends-on = [service-stop]
      }
      cluster-sharding-shutdown-region {
        timeout = 10 s
        depends-on = [before-cluster-shutdown]
      }
      cluster-leave {
        depends-on = [cluster-sharding-shutdown-region]
      }
      cluster-exiting {
        timeout = 10 s
        depends-on = [cluster-leave]
      }
      cluster-exiting-done {
        depends-on = [cluster-exiting]
      }
      cluster-shutdown {
        depends-on = [cluster-exiting-done]
      }
      before-actor-system-terminate {
        depends-on = [cluster-shutdown]
      }
      actor-system-terminate {
        timeout = 10 s
        depends-on = [before-actor-system-terminate]
      }
    }
  }
  stream {
    materializer {
      initial-input-buffer-size = 4
      max-input-buffer-size = 16
      blocking-io-dispatcher = "akka.stream.default-blocking-io-dispatcher"
      dispatcher = ""
      subscription-timeout {
        mode = cancel
        timeout = 5s
      }
      debug-logging = off
      output-burst-limit = 1000
      auto-fusing = on
      max-fixed-buffer-size = 1000000000
      sync-processing-limit = 1000
      debug {
        fuzzing-mode = off
      }
      io {
        tcp {
          write-buffer-size = 16 KiB
        }
      }
      stream-ref {
        buffer-capacity = 32
        demand-redelivery-interval = 1 second
        subscription-timeout = 30 seconds
        final-termination-signal-deadline = 2 seconds
      }
    }
    blocking-io-dispatcher = "akka.stream.default-blocking-io-dispatcher"
    default-blocking-io-dispatcher {
      type = "Dispatcher"
      executor = "thread-pool-executor"
      throughput = 1
      thread-pool-executor {
        fixed-pool-size = 16
      }
    }
    testkit {
      all-stages-stopped-timeout = 10s
    }
  }
  ssl-config {
    protocol = "TLSv1.2"
  }
}