things.conf

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

  extensions {
    pre-enforcer-provider.extension-config.pre-enforcers = [
      "org.eclipse.ditto.policies.enforcement.pre.BlockedNamespacePreEnforcer",
      "org.eclipse.ditto.policies.enforcement.pre.CommandWithOptionalEntityPreEnforcer",
      "org.eclipse.ditto.policies.enforcement.pre.CreationRestrictionPreEnforcer"
    ]
    signal-transformers-provider.extension-config.signal-transformers = [
      "org.eclipse.ditto.things.service.enforcement.pre.ModifyToCreateThingTransformer", // always keep this as first transformer in order to guarantee that all following transformers know that the command is creating a policy instead of modifying it
      "org.eclipse.ditto.things.service.signaltransformation.placeholdersubstitution.ThingsPlaceholderSubstitution"
    ]
    snapshot-adapter = "org.eclipse.ditto.things.service.persistence.serializer.ThingMongoSnapshotAdapter"
  }

  mongodb {
    database = "things"
    database = ${?MONGO_DB_DATABASE}
  }

  persistence.operations.delay-after-persistence-actor-shutdown = 5s
  persistence.operations.delay-after-persistence-actor-shutdown = ${?DELAY_AFTER_PERSISTENCE_ACTOR_SHUTDOWN}

  things {

    # Logs for all incoming messages minimal information to enable message tracing throughout the system
    log-incoming-messages = true
    log-incoming-messages = ${?LOG_INCOMING_MESSAGES}

    thing {
      activity-check {
        # the interval of how long to keep an "inactive" Thing in memory:
        inactive-interval = 2h
        inactive-interval = ${?THING_ACTIVITY_CHECK_INTERVAL} # may be overridden with this environment variable

        # the interval of how long to keep an "inactive" deleted Thing in memory:
        deleted-interval = 5m
        deleted-interval = ${?THING_ACTIVITY_CHECK_DELETED_INTERVAL}
      }

      snapshot {
        # the interval when to do snapshot for a Thing which had changes to it
        interval = 15m
        interval = ${?THING_SNAPSHOT_INTERVAL} # may be overridden with this environment variable

        # the threshold after how many changes to a Thing to do a snapshot
        threshold = 500
        threshold = ${?THING_SNAPSHOT_THRESHOLD} # may be overridden with this environment variable
      }

      supervisor {
        exponential-backoff {
          min = 1s
          max = 120s
          random-factor = 1.0
          corrupted-receive-timeout = 600s
        }
      }

      cleanup {
        enabled = true
        enabled = ${?CLEANUP_ENABLED}

        quiet-period = 5m
        quiet-period = ${?CLEANUP_QUIET_PERIOD}

        interval = 3s
        interval = ${?CLEANUP_INTERVAL}

        timer-threshold = 150ms
        timer-threshold = ${?CLEANUP_TIMER_THRESHOLD}

        credits-per-batch = 3
        credits-per-batch = ${?CLEANUP_CREDITS_PER_BATCH}

        reads-per-query = 100
        reads-per-query = ${?CLEANUP_READS_PER_QUERY}

        writes-per-credit = 100
        writes-per-credit = ${?CLEANUP_WRITES_PER_CREDIT}

        delete-final-deleted-snapshot = false
        delete-final-deleted-snapshot = ${?CLEANUP_DELETE_FINAL_DELETED_SNAPSHOT}
      }
    }

    wot {
      http {
        # proxy config for retrieving WoT (Web of Things) ThingModels via HTTP
        proxy {
          enabled = false
          enabled = ${?THINGS_WOT_THING_MODEL_HTTP_PROXY_ENABLED}

          hostname = ${?THINGS_WOT_THING_MODEL_HTTP_PROXY_HOST}
          port = ${?THINGS_WOT_THING_MODEL_HTTP_PROXY_PORT}
          username = ${?THINGS_WOT_THING_MODEL_HTTP_PROXY_USERNAME}
          password = ${?THINGS_WOT_THING_MODEL_HTTP_PROXY_PASSWORD}
        }
      }

      cache {
        # how many thing models to cache
        maximum-size = 1000
        maximum-size = ${?THINGS_WOT_THING_MODEL_CACHE_SIZE}

        # prolonged on each cache access by that duration
        expire-after-access = 1d
        expire-after-access = ${?THINGS_WOT_THING_MODEL_CACHE_EXPIRE_AFTER_ACCESS}
      }

      to-thing-description {
        base-prefix = "http://localhost:8080"
        base-prefix = ${?THINGS_WOT_TO_THING_DESCRIPTION_BASE_PREFIX}

        json-template {
          "securityDefinitions": {
            "basic_sc": {
              "scheme": "basic",
              "in": "header"
            }
          },
          "security": "basic_sc"
          "support": "https://www.eclipse.org/ditto/"
        }

        placeholders {
          # add arbitrary placeholders to be resolved, e.g.:
          # FOO = "bar"
          # TM_REQUIRED = [
          #  "#/properties/status",
          #  "#/actions/toggle"
          # ]
        }

        add-created = true
        add-created = ${?THINGS_WOT_TO_THING_DESCRIPTION_ADD_CREATED}

        add-modified = false
        add-modified = ${?THINGS_WOT_TO_THING_DESCRIPTION_ADD_MODIFIED}
      }
    }
  }
}


akka {
  cluster {
    sharding {
      role = ${ditto.service-name}

      passivation {
        # don't passivate shards by default as Ditto AbstractPersistenceActor decides that on its own -
        # default is "default-idle-strategy" with "idle-entity.timeout = 120s":
        strategy = "off"
      }
    }

    roles = [
      "things",
      "thing-event-aware",
      "live-signal-aware",
      "acks-aware",
      "ddata-aware",
      "blocked-namespaces-aware"
    ]
  }

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

}

akka-contrib-mongodb-persistence-things-journal {
  class = "akka.contrib.persistence.mongodb.MongoJournal"
  plugin-dispatcher = "thing-journal-persistence-dispatcher"

  circuit-breaker {
    max-failures = 5 # if an exception during persisting an event/snapshot occurs this often -- a successful write resets the counter
    max-failures = ${?BREAKER_MAXTRIES}
    call-timeout = 5s # MongoDB Timeouts causing the circuitBreaker to open
    call-timeout = ${?BREAKER_TIMEOUT}
    reset-timeout = 3s # after this time in "Open" state, the cicuitBreaker is "Half-opened" again
    reset-timeout = ${?BREAKER_RESET}
  }

  overrides {
    journal-collection = "things_journal"
    journal-index = "things_journal_index"

    realtime-collection = "things_realtime"
    metadata-collection = "things_metadata"
  }

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

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

akka-contrib-mongodb-persistence-things-snapshots {
  class = "akka.contrib.persistence.mongodb.MongoSnapshots"
  plugin-dispatcher = "thing-snaps-persistence-dispatcher"

  circuit-breaker {
    max-failures = 5 # if an exception during persisting an event/snapshot occurs this often -- a successful write resets the counter
    max-failures = ${?SNAPSHOT_BREAKER_MAXTRIES}
    call-timeout = 10s # MongoDB Timeouts causing the circuitBreaker to open
    call-timeout = ${?SNAPSHOT_BREAKER_TIMEOUT}
    reset-timeout = 6s # after this time in "Open" state, the cicuitBreaker is "Half-opened" again
    reset-timeout = ${?SNAPSHOT_BREAKER_RESET}
  }

  overrides {
    snaps-collection = "things_snaps"
    snaps-index = "things_snaps_index"
  }
}

thing-journal-persistence-dispatcher {
  type = Dispatcher
  # which mailbox to use
  mailbox-type = "org.eclipse.ditto.things.service.persistence.actors.ThingPersistenceActorMailbox"
  mailbox-capacity = 100
  mailbox-capacity = ${?THING_PERSISTENCE_ACTOR_MAILBOX_SIZE}
  executor = "fork-join-executor"
  fork-join-executor {
    parallelism-min = 4
    parallelism-factor = 3.0
    parallelism-max = 32
    parallelism-max = ${?DEFAULT_DISPATCHER_PARALLELISM_MAX}
  }
  throughput = 5
}

thing-snaps-persistence-dispatcher {
  type = Dispatcher
  # which mailbox to use
  mailbox-type = "org.eclipse.ditto.things.service.persistence.actors.ThingPersistenceActorMailbox"
  mailbox-capacity = 100
  mailbox-capacity = ${?THING_PERSISTENCE_ACTOR_MAILBOX_SIZE}
  executor = "fork-join-executor"
  fork-join-executor {
    parallelism-min = 4
    parallelism-factor = 3.0
    parallelism-max = 32
    parallelism-max = ${?DEFAULT_DISPATCHER_PARALLELISM_MAX}
  }
  throughput = 5
}

wot-dispatcher {
  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
}

akka.contrib.persistence.mongodb.mongo {

  collection-cache {
    journal {
      class = "org.eclipse.ditto.internal.utils.persistence.mongo.DittoMongoCollectionCache"
      expire-after-write = 1h // check each collection every hour whether it was created correctly
      expire-after-write = ${?MONGO_COLLECTION_CACHE_JOURNAL_TTL}
      max-size = 1000 // namespace collections cached per node
      max-size = ${?MONGO_COLLECTION_CACHE_JOURNAL_MAX_SIZE}
    }

    snaps {
      class = "org.eclipse.ditto.internal.utils.persistence.mongo.DittoMongoCollectionCache"
      expire-after-write = 1h
      expire-after-write = ${?MONGO_COLLECTION_CACHE_SNAPS_TTL}
      max-size = 1000
      max-size = ${?MONGO_COLLECTION_CACHE_SNAPS_MAX_SIZE}
    }
  }
}

include "things-extension.conf"