test.conf

akka {
  remote.artery.canonical.port = 0
  loggers = ["akka.event.slf4j.Slf4jLogger"]
  loglevel = "WARNING"
  logging-filter = "akka.event.slf4j.Slf4jLoggingFilter"
  log-dead-letters = 0

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

  log-config-on-start = off

  actor {
    provider = cluster
    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}
      }
    }
  }

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

  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 {
    # "java.io.Serializable" = none
    # 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
  }

  extensions = [
    "akka.cluster.pubsub.DistributedPubSub"
  ]

  http {
    server {
      server-header = "" # default: akka-http/${akka.http.version}
      max-connections = 4096 # default: 1024
      backlog = 100 # default: 100
      request-timeout = 60s
      raw-request-uri-header = on # default: off

      parsing {
        max-uri-length = 8k # default: 2k
        max-content-length = 10m # default: 8m
        illegal-header-warnings = off # default: on
        error-logging-verbosity = simple # default: full
        uri-parsing-mode = relaxed # default: strict
      }
    }

    host-connection-pool {
      # The maximum number of open requests accepted into the pool across all
      # materializations of any of its client flows.
      # Protects against (accidentally) overloading a single pool with too many client flow materializations.
      # Note that with N concurrent materializations the max number of open request in the pool
      # will never exceed N * max-connections * pipelining-limit.
      # Must be a power of 2 and > 0!
      max-open-requests = 1024 # default: 32

      # The time after which an idle connection pool (without pending requests)
      # will automatically terminate itself. Set to `infinite` to completely disable idle timeouts.
      idle-timeout = 60s # default: 30s
    }
  }
}

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 = akka.testkit.CallingThreadDispatcherConfigurator
  }
}

ditto {
  mapping-strategy.implementation = "org.eclipse.ditto.gateway.service.util.GatewayMappingStrategies"

  gateway {
    include "gateway-http-test"

    cluster {
      # as a rule of thumb: should be factor ten of the amount of cluster nodes available
      # be aware that it must be the same as for all other services (e.g. search-updater)
      number-of-shards = 30
    }

    streaming {
      sse {
        authorization-enforcer = "org.eclipse.ditto.gateway.service.streaming.NoOpAuthorizationEnforcer"
        connection-supervisor = "org.eclipse.ditto.gateway.service.endpoints.routes.sse.NoOpSseConnectionSupervisor"
        event-sniffer = "org.eclipse.ditto.gateway.service.endpoints.routes.sse.NoOpSseEventSniffer"
      }
      websocket {
        # the max queue size of how many inflight Commands a single Websocket client can have
        subscriber.backpressure-queue-size = 100

        # the max buffer size of how many outstanding CommandResponses and Events a single Websocket client can have
        # additionally CommandResponses and Events are dropped if this size is reached
        publisher.backpressure-buffer-size = 200
        # The provider enforcer for WebSocket connections
        authorization-enforcer = "org.eclipse.ditto.gateway.service.streaming.NoOpAuthorizationEnforcer"
        config-provider = "org.eclipse.ditto.gateway.service.endpoints.routes.websocket.NoOpWebSocketConfigProvider"
        connection-supervisor = "org.eclipse.ditto.gateway.service.endpoints.routes.websocket.NoOpWebSocketSupervisor"
        incoming-event-sniffer = "org.eclipse.ditto.gateway.service.endpoints.routes.websocket.NoOpIncomingWebSocketEventSniffer"
        outgoing-event-sniffer = "org.eclipse.ditto.gateway.service.endpoints.routes.websocket.NoOpOutgoingWebSocketEventSniffer"
      }
    }

    enforcer {
      # the interval of how long to keep an "inactive" PolicyEnforcer in memory:
      cache.interval = 2h

      # the interval of when to manually sync the underlying Policy of the PolicyEnforcer
      sync.interval = 15m

      # the internal timeout when retrieving the Policy or the ACL or when waiting for a CommandResponse
      internal.ask.timeout = 5s
    }

    command {
      default-timeout = 1m
      max-timeout = 1m
    }

    message {
      default-timeout = 10s
      max-timeout = 1m
    }

    claim-message {
      default-timeout = 1m
      max-timeout = 10m
    }

    authentication {
      oauth {
        jwt-authorization-subjects-provider = "org.eclipse.ditto.gateway.service.security.authentication.jwt.DittoJwtAuthorizationSubjectsProvider"
        jwt-authentication-result-provider = "org.eclipse.ditto.gateway.service.security.authentication.jwt.DefaultJwtAuthenticationResultProvider"
        openid-connect-issuers = {
          example = {
            issuer = "https://some-issuer.org/auth/realms/iot-suite"
            auth-subjects = [
              "myTestSubj"
            ]
          }
        }
      }
      # configures HTTP for different authentication mechanisms: IM3, JWT (e.g. Google), ...
      http {
        # proxy config
        proxy {
          enabled = false
        }
      }

      pre-authentication {
        enabled = true
      }

      devops {
        secured = true
        password = ${?secrets.devops_password.value}
        statusPassword = ${?secrets.status_password.value}
      }
    }

    health-check {
      enabled = false
      interval = 60s
      service.timeout = 10s

      cluster-roles.enabled = false
    }

    messaging {
      reconnection-delay = 1s

      metrics {
        enabled = false
      }
    }

    public-health {
      cache-timeout = 20s
    }

    cache {
      publickeys {
        maxentries = 32
        expiry = 60m
      }
    }

    http {
      request-timeout = 5s
      custom-api-routes-provider = "org.eclipse.ditto.gateway.service.endpoints.routes.NoopCustomApiRoutesProvider"
      bind-flow-provider = "org.eclipse.ditto.gateway.service.endpoints.routes.LoggingHttpBindFlowProvider"
    }
  }
}

secrets {
  devops_password {
    value = "devops!"
  }

  status_password {
    value = "status!"
  }
}

sharding-dispatcher {
  type = Dispatcher
  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 # default is 5
}

authentication-dispatcher {
  type = Dispatcher
  executor = "thread-pool-executor"
  thread-pool-executor {
    // or in Akka 2.4.2+
    fixed-pool-size = 16
  }
  throughput = 100
}