test.conf

ditto {
  mapping-strategy.implementation = "org.eclipse.ditto.things.api.ThingsMappingStrategies"

  extensions {
    pre-enforcer-provider {
      extension-class = org.eclipse.ditto.policies.enforcement.pre.PreEnforcerProvider
      extension-config = {
        pre-enforcers = [
          "org.eclipse.ditto.policies.enforcement.pre.BlockedNamespacePreEnforcer",
          "org.eclipse.ditto.policies.enforcement.pre.CommandWithOptionalEntityPreEnforcer"
        ]
      }
    }
    snapshot-adapter = {
      extension-class = "org.eclipse.ditto.things.service.persistence.serializer.ThingMongoSnapshotAdapter"
    }
  }

  mongodb {
    uri = "mongodb://localhost:27017/test"
  }

  things {

    include "thing-test"

    log-incoming-messages = true

    wot {
      http {
        proxy {
          enabled = false
        }
      }
      cache {
        maximum-size = 10
      }
    }
  }

  enforcement {
    buffer-size = 1337

    ask-with-retry {
      ask-timeout = 33s
    }

    global-live-response-dispatching = true
  }
  caches {
    ask-timeout = 10s

    id {
      maximum-size = 80000
      expire-after-write = 15m
      expire-after-access = 15m
    }

    enforcer {
      maximum-size = 20000
      expire-after-write = 15m
      expire-after-access = 15m
    }
  }
}

pekko {
  loggers = ["org.apache.pekko.event.slf4j.Slf4jLogger"]
  loglevel = "INFO"
  logging-filter = "org.apache.pekko.event.DefaultLoggingFilter"
  logger-startup-timeout = 60s

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

  log-config-on-start = off

  actor {
    serializers {
      bson = "org.eclipse.ditto.internal.utils.test.mongo.BsonDocumentSerializer"
    }
    serialization-bindings {
      "org.bson.BsonDocument" = bson
    }
  }

  cluster {
    roles = [
      "things",
      "thing-event-aware",
      "live-signal-aware",
      "acks-aware",
      "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 = 3s

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

    calling-thread-dispatcher {
      type = org.apache.pekko.testkit.CallingThreadDispatcherConfigurator
    }
  }
}

pekko.contrib.persistence.mongodb.mongo {
  driver = "pekko.contrib.persistence.mongodb.driver.ScalaDriverPersistenceExtension"
}

pekko.persistence {
  journal.auto-start-journals = [
    "pekko-contrib-mongodb-persistence-things-journal"
  ]
  snapshot-store.auto-start-snapshot-stores = [
    "pekko-contrib-mongodb-persistence-things-snapshots"
  ]
}

pekko-contrib-mongodb-persistence-things-journal {
  class = "org.apache.pekko.persistence.inmemory.journal.InMemoryAsyncWriteJournal"
  plugin-dispatcher = "thing-persistence-dispatcher"

  ask-timeout = 10s

  event-adapters {
    mongodbobject = "org.eclipse.ditto.things.service.persistence.serializer.ThingMongoEventAdapter"
  }

  event-adapter-bindings {
    "org.eclipse.ditto.base.model.signals.events.Event" = mongodbobject
    "org.bson.BsonValue" = mongodbobject
  }
}

pekko-contrib-mongodb-persistence-things-snapshots {
  class = "org.apache.pekko.persistence.inmemory.snapshot.InMemorySnapshotStore"
  plugin-dispatcher = "thing-persistence-dispatcher"

  ask-timeout = 10s
}

thing-persistence-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
  }
  throughput = 2
}

wot-dispatcher {
  type = Dispatcher
  executor = "thread-pool-executor"
}
wot-dispatcher-cache-loader {
  type = Dispatcher
  executor = "thread-pool-executor"
}

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
}