test.conf

ditto {
  mapping-strategy.implementation = "org.eclipse.ditto.thingsearch.api.ThingSearchMappingStrategies"
  mongodb {
    uri = "mongodb://localhost:27017/test"
    pool {
      max-size = 100
      max-wait-time = 30s
      max-wait-queue-size = 500000
    }
  }
  limits {
    # limiations for the "things-search" service
    things-search {
      default-page-size = 25
      # the allowed maximum page size limit - e.g. specified when doing a search via HTTP:
      # /api/1/search/things?filter=...&option=limit(0,200)
      max-page-size = 200
    }
  }
  things-search {
    query {
      mongodb.timeout = 5s
    }
    query-criteria-validator = "org.eclipse.ditto.thingsearch.service.persistence.query.validation.DefaultQueryCriteriaValidator"
    search-update-mapper.implementation = "org.eclipse.ditto.thingsearch.service.persistence.write.streaming.DefaultSearchUpdateMapper"
    search-update-observer.implementation = "org.eclipse.ditto.thingsearch.service.updater.actors.DefaultSearchUpdateObserver"
  }
}

akka {
  loggers = ["akka.event.slf4j.Slf4jLogger"]
  loglevel = "WARNING"
  logging-filter = "akka.event.slf4j.Slf4jLoggingFilter"

  # for log messages during the actor system is starting up and shutting down:
  stdout-loglevel = "WARNING"

  log-config-on-start = off

  actor {
    provider = "akka.cluster.ClusterActorRefProvider"
    enable-additional-serialization-bindings = on

    # this is only intended for testing.
    serialize-messages = off
    serialize-creators = off

    debug {
      lifecycle = on
    }

    guardian-supervisor-strategy = "akka.actor.StoppingSupervisorStrategy"

    deployment {
    }

    default-dispatcher {
      fork-join-executor {
        parallelism-min = 4
        parallelism-factor = 3.0
        parallelism-max = 32
        parallelism-max = ${?DEFAULT_DISPATCHER_PARALLELISM_MAX}
      }
    }

    serializers {
      json = "org.eclipse.ditto.internal.utils.cluster.JsonJsonifiableSerializer"
      cbor = "org.eclipse.ditto.internal.utils.cluster.CborJsonifiableSerializer"
      cbor-json-value = "org.eclipse.ditto.internal.utils.cluster.CborJsonValueSerializer"
      jackson-cbor = "akka.serialization.jackson.JacksonCborSerializer"
    }

    serialization-bindings {
      # Serialize Jsonifiable events with custom JSON serializer:
      "org.eclipse.ditto.base.model.json.Jsonifiable" = cbor
      "org.eclipse.ditto.base.model.exceptions.DittoRuntimeException" = cbor
      "org.eclipse.ditto.base.api.devops.signals.commands.DevOpsCommandResponse" = json # to ensure readability
      "org.eclipse.ditto.json.JsonValue" = cbor-json-value
      "org.eclipse.ditto.internal.utils.cluster.AkkaJacksonCborSerializable" = jackson-cbor
    }
  }

  remote {
    log-remote-lifecycle-events = on
    artery {
      enabled = on
      transport = tcp
    }
    artery.canonical {
      hostname = "127.0.0.1"
      hostname = ${?REMOTE_HOSTNAME}
      port = 0
      port = ${?RANDOM_TEST_PORT}
    }
    artery.bind {
      hostname = ${?BIND_HOSTNAME}
      port = ${?BIND_REMOTE_PORT}
    }
  }

  cluster {
    metrics.enabled = off
    seed-nodes = ["akka://AkkaTestSystem@"${akka.remote.artery.canonical.hostname}":"${akka.remote.artery.canonical.port}]

    roles = [
      "search",
      "blocked-namespaces-aware"
    ]
  }

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

    # duration of EventFilter.intercept waits after the block is finished until
    # all required messages are received
    filter-leeway = 3s

    # duration to wait in expectMsg and friends outside of within() block
    # by default
    single-expect-default = 5s

    # The timeout that is added as an implicit by DefaultTimeout trait
    default-timeout = 5s

    calling-thread-dispatcher {
      type = akka.testkit.CallingThreadDispatcherConfigurator
    }
  }
}

blocked-namespaces-dispatcher {
  type = Dispatcher
  executor = "fork-join-executor"
  fork-join-executor {
    # Min number of threads to cap factor-based parallelism number to
    parallelism-min = 4
    # Parallelism (threads) ... ceil(available processors * factor)
    parallelism-factor = 3.0
    # Max number of threads to cap factor-based parallelism number to
    parallelism-max = 32
    parallelism-max = ${?DEFAULT_DISPATCHER_PARALLELISM_MAX}
  }
  throughput = 5
}

search-updater-dispatcher {
  type = "Dispatcher"
  executor = "thread-pool-executor"
  thread-pool-executor {
    keep-alive-time = 60s
    fixed-pool-size = off
    max-pool-size-max = 256
    max-pool-size-max = ${?SEARCH_UPDATER_DISPATCHER_POOL_SIZE_MAX}
  }
}