// Default values for configuration read by classes in jicofo-selector. Defaults for other jicofo.* sections live in
// the reference.conf of the module that owns them (jicofo-common, jicofo).
jicofo {
  // Configuration related to jitsi-videobridge
  bridge {
    // The maximum number of participants in a single conference to put on one bridge (use -1 for no maximum).
    max-bridge-participants = 80
    // The maximum number of participants that a single conference may add to a single bridge within
    // [max-bridge-participants-interval]. A bridge which has reached this limit is considered overloaded *for that
    // conference only* when selecting a bridge for a new participant; other conferences, and all other bridge-level
    // logic (stress, sorting, load redistribution) are unaffected.
    //
    // This limits the overshoot that happens when a conference bursts: a bridge reports its stress level only every
    // 5-10 seconds, so during a burst of joins the reported stress is stale by construction and jicofo can keep
    // selecting the same bridge long after it is full. Note this is a limit on the *rate* at which a conference grows
    // on a bridge, so it does not affect a conference which grows slowly (where the stress feedback has caught up),
    // and it does not affect many small conferences sharing a bridge (each has a low rate of its own).
    //
    // Use -1 to disable. A suggested value for a production deployment is 30 (with the default 1 minute interval).
    // Note that [max-bridge-participants] remains in effect as a hard limit.
    max-bridge-participants-per-interval = -1
    // The interval over which [max-bridge-participants-per-interval] is enforced. It should comfortably cover the
    // interval at which bridges report their stress level (5-10 seconds).
    max-bridge-participants-interval = 1 minute
    // The default assumed average stress per participant. This value is only used when a bridge does not report its
    // own value.
    average-participant-stress = 0.01
    // The assumed time that an endpoint takes to start contributing fully to the load on a bridge. To avoid allocating
    // a burst of endpoints to the same bridge, the bridge stress is adjusted by adding the number of new endpoints
    // in the last [participant-rampup-time] multiplied by [average-participant-stress].
    participant-rampup-interval = 20 seconds
    // The stress level above which a bridge is considered overstressed.
    stress-threshold = 0.8
    // The amount of to wait before retrying using a failed bridge.
    failure-reset-threshold = 1 minute
    // The bridge selection strategy. The built-in strategies are:
    // SingleBridgeSelectionStrategy: Use the least loaded bridge, do not split a conference between bridges (Octo).
    // SplitBridgeSelectionStrategy: Use a separate bridge for each participant (for testing).
    // RegionBasedBridgeSelectionStrategy: Attempt to put each participant in a bridge in their local region (i.e. use
    //    Octo for geo-location).
    // IntraRegionBridgeSelectionStrategy: Use additional bridges only when a bridge becomes overloaded (i.e. use Octo
    // only for load balancing). This hasn't been tested much; use RegionBasedBridgeSelectionStrategy unless there's a
    // reason not to.
    // VisitorSelectionStrategy: Use separate strategies and bridges for visitors and participants.  In this case,
    // visitor-selection-strategy and participant-selection-strategy should be defined
    //
    // Additionally, you can use the fully qualified class name for custom BridgeSelectionStrategy implementations.
    selection-strategy = SingleBridgeSelectionStrategy

    // Uncomment and define these if your primary selection strategy is VisitorSelectionStrategy
    # visitor-selection-strategy = RegionBasedBridgeSelectionStrategy
    # participant-selection-strategy = RegionBasedBridgeSelectionStrategy

    // The topology selection strategy.
    topology-strategy = SingleMeshTopologyStrategy

    // A partition of regions into groups that are "close" to each other (regions not specified here will be assumed
    // to be in a group of their own). When selecting a bridge for a region R, existing conference bridge in R's group
    // of regions will all be considered to match the region.
    // For example, with the sample values below, if a conference has a bridge in "us-east" and a participant in
    // "us-west" joins, the bridge in "us-east" will be used because "us-east" and "us-west" are in the same group.
    // region-groups = [
    //   [ "us-east", "us-west" ],
    //   [ "eu-central", "eu-west"]
    // ]
    health-checks {
      // Whether jicofo should perform periodic health checks to the connected bridges.
      enabled = true
      // The interval at which to perform health checks.
      interval = 10 seconds
      // When a health checks times out, jicofo will retry and only consider it fail after the retry fails. This
      // configures the delay between the original health check timing out and the second health check being sent.
      // It is a duration and defaults to half the [interval].
      # retry-delay = 5 seconds

      // Use the lack of presence to infer unhealthy status instead of sending explicit health check requests.
      use-presence = false

      // A bridge will be consider unhealthy unless we've received its presence in that period.
      presence-timeout = 45 seconds
    }

    // The JID of the MUC to be used as a brewery for bridge instances.
    # brewery-jid = jvbbrewery@example.com

    // The XMPP connection to use to communicate with Jitsi Videobridge instances.
    // Either `Client` or `Service` (case-sensitive). See the corresponding XMPP connection configuration under `xmpp`.
    // Note that if no separate Service connection has been configured, all services will automatically use the
    // Client connection.
    xmpp-connection-name = Service

    // Detect bridge failure based on endpoints that request a restart due to an ICE failure.
    ice-failure-detection {
      enabled = false
      // Count the number of restart requests in the last `interval`.
      interval = 2 minutes
      // The minimum number of endpoints on the bridge before this check is enabled.
      min-endpoints = 30
      // The threshold, in terms of fraction of endpoints that requested a restart in the last `interval`, above which
      // the bridge will be considered failing ICE.
      threshold = 0.1
      // Once the "failing ICE" state is entered, the bridge will stay in it at least this long (refreshed as long as
      // the condition is met).
      timeout = 10 minutes
    }
    load-redistribution {
      // Whether automatic redistribution of endpoints away from overloaded bridges is enabled.
      enabled = false
      // The interval at which to run.
      interval = 1 minute
      // The threshold above which to redistribute endpoints away from a bridge. This needs to be higher than
      // jicofo.bridge.stress-threshold.
      stress-threshold = 0.9
      // The amount of time to wait before moving more endpoints away from a bridge.
      timeout = 3 minutes
      // The number of endpoints to move away from a bridge at a time.
      endpoints = 10
    }
  }

  transcription {
    # A templated URL to use for backend (non-jigasi) transcription. The strings "{{MEEETING_ID}}" and "{{REGION}}"
    # will be replaced with the unique meeting ID and the region of the bridge used for transcription. The region is
    # optional. Note no whitespace is allowed in the templates, they have to match exactly.
    // url-template = "wss://{{REGION}}.example.com/recorder/{{MEETING_ID}}"

    # HTTP headers to include when connecting to the transcription service. These can include authentication tokens,
    # API keys, content type specifications, etc.
    http-headers {
      // "Authorization" = "Bearer your-api-key"
      // "Sec-Websocket-Protocol" = "my proto"
    }

    # Ping configuration for the transcription service connection
    ping {
      # Whether to enable ping messages
      enabled = true
      # Interval between ping messages
      interval = 10 seconds
      # Timeout for ping responses
      timeout = 3 seconds
    }
  }

  translation {
    # A templated URL for the live-translation websocket. "{{MEETING_ID}}" and "{{REGION}}" are substituted (REGION is
    # optional, set to the bridge's region). When unset, live translation is disabled. No whitespace in the templates.
    // url-template = "wss://{{REGION}}.example.com/translate/{{MEETING_ID}}"

    # HTTP headers to include when connecting to the translation service.
    http-headers {
      // "Authorization" = "Bearer your-api-key"
    }

    # How translation connects are placed on bridges:
    #   per-source    - each sender's audio is translated by a connect on its own (local) bridge. A sender requesting
    #                   more than max-languages-per-connect target languages is split across multiple connects on that
    #                   bridge, so a bridge has one or more websockets per source.
    #   single-bridge - a single connect on one selected bridge handles all sources and languages (mirrors the
    #                   transcriber selection).
    mode = "per-source"

    # The maximum number of target languages handled by a single translation connect. ONLY applies in "per-source"
    # mode; a sender requesting more languages is split across multiple connects on its bridge. Ignored in
    # "single-bridge" mode.
    max-languages-per-connect = 5

    # Ping configuration for the translation service connection (keepalive to avoid idle-timeout).
    ping {
      # Whether to enable ping messages
      enabled = true
      # Interval between ping messages
      interval = 10 seconds
      # Timeout for ping responses
      timeout = 3 seconds
    }
  }
}