lila/conf/base.conf

mongodb {
  uri = "mongodb://127.0.0.1:27017/lichess"
  image.collection = "image"
}
net {
  domain = "localhost:9663"
  socket.domain = ${net.domain}
  asset.domain = ${net.domain}
  protocol = "http://"
  base_url = ${net.protocol}${net.domain}
  ip = "127.0.0.1"
  email = "contact@lichess.org"
  crawlable = false
  ratelimit = true
}
play {
  application.loader=LilaAppLoader
  modules.disabled+="play.api.mvc.CookiesModule"
  modules.enabled+="play.api.mvc.LegacyCookiesModule"
  server {
    netty {
      # The maximum length of the initial line. This effectively restricts the maximum length of a URL that the server will
      # accept, the initial line consists of the method (3-7 characters), the URL, and the HTTP version (8 characters),
      # including typical whitespace, the maximum URL length will be this number - 18.
      maxInitialLineLength = 2048 # 4096

      # The maximum length of the HTTP headers. The most common effect of this is a restriction in cookie length, including
      # number of cookies and size of cookie values.
      maxHeaderSize = 4096 # 8192
    }
  }
  http {
    parser.maxMemoryBuffer=1MB
  }
  ws {
    useragent = "lichess.org"
    compressionEnabled = true
    timeout {
      connection = 5 seconds
      idle = 5 minutes
      request = 5 minutes
    }
  }
  crypto {
    secret="CiebwjgIM9cHQ;I?Xk:sfqDJ;BhIe:jsL?r=?IPF[saf>s^r0]?0grUq4>q?5mP^"
  }
}
session {
  cookieName = "lila2"
  maxAge = 365 days
}
app {
  scheduler {
    disabled = false
    debug = false
  }
  renderer.name = "renderer"
  web_path = "public"
  forcedev = false
  stage = false
}
api {
  token = secret
  influx_event = {
    endpoint = "http://monitor.lichess.ovh:8086/write?db=events"
    env = "dev"
  }
}
chessground {
  animation {
    duration = 250 ms
  }
}
editor {
  animation.duration = ${chessground.animation.duration}
}
accessibility {
  blind {
    cookie {
      name = "mBzamRgfXgRBSnXB"
      salt = "WWcTbz5xxaHU4d96"
      max_age = 31536000 # one year
    }
  }
}
prismic {
  api_url = "https://lichess-clone.cdn.prismic.io/api"
}
blog {
  prismic {
    api_url = ${prismic.api_url}
  }
  last_post_cache.ttl = 5 minutes
}
chat {
  collection {
    chat = chat
    timeout = chat_timeout
  }
  max_lines = 200
  net.domain = ${net.domain}
  actor.name = chat
  timeout {
    duration = 15 minutes
    check_every = 15 seconds
  }
}
puzzle {
  mongodb {
    uri = "mongodb://127.0.0.1:27017/lichess"
  }
  collection {
    puzzle = puzzle
    round = puzzle_round2
    vote = puzzle_vote
    head = puzzle_head
  }
  api.token = ${api.token}
  selector {
    puzzle_id_min = 61053 # puzzle 61052 is bad
  }
  animation.duration = ${chessground.animation.duration}
}
coordinate {
  collection {
    score = coordinate_score
  }
}
event {
  collection {
    event = event
  }
}
video {
  collection {
    video = video
    view = video_view
  }
  sheet {
    url = "https://spreadsheets.google.com/feeds/list/1qYU1XhvC8TlBggXEkjI481ieNGyYGmMTy97A9iboyrM/2/public/values?alt=json"
    delay = 3 hour
  }
  youtube {
    url = "https://www.googleapis.com/youtube/v3/videos"
    api_key = ""
    max = 50
    delay = 20 minutes
  }
}
search {
  enabled = false
  writeable = true
  endpoint = "http://localhost:9673"
}
teamSearch {
  index = team
  actor.name = team-search
}
relation {
  collection {
    relation = relation
  }
  actor {
    name = relation
    notify_freq = 2 seconds
  }
  limit {
    follow = 300
    block = 500
  }
}
bookmark {
  collection.bookmark = bookmark
  actor.name = bookmark
}
geoip {
  file = "data/GeoLite2-City.mmdb"
  cache_ttl = 20 minutes
}
security {
  collection.security = security
  collection.print_ban = print_ban
  collection.firewall = firewall
  flood.duration = 60 seconds
  geoip = ${geoip}
  password_reset {
    secret = "???"
  }
  email_confirm {
    enabled = false
    secret = "???"
    cookie = "email_confirm"
  }
  email_change {
    secret = "???"
  }
  login_token {
    secret = "???"
  }
  tor {
    provider_url = "https://check.torproject.org/cgi-bin/TorBulkExitList.py?ip="${net.ip}"&port=80"
    refresh_delay = 1 hour
  }
  disposable_email {
    provider_url = "https://raw.githubusercontent.com/ornicar/disposable/publish/domains.txt"
    refresh_delay = 10 minutes
  }
  dns_api {
    url = "https://cloudflare-dns.com/dns-query"
    timeout = 5 seconds
  }
  check_mail_api {
    url = "https://mailcheck.p.rapidapi.com/"
    key = ""
  }
  recaptcha = ${recaptcha}
  mailgun = ${mailgun}
  net {
    domain = ${net.domain}
    base_url = ${net.base_url}
  }
  ipintel.email = "-"
}
oauth {
  mongodb {
    uri = ${mongodb.uri}
  }
  collection {
    access_token = oauth_access_token
    app = oauth_client
  }
}
recaptcha {
  endpoint = "https://www.google.com/recaptcha/api/siteverify"
  public_key = "6LcxLTUUAAAAAFwWrEgEehMJ6VXrtVOKIifTLGoW"
  private_key = ""
  enabled = false
}
shutup {
  collection.shutup = shutup
  actor.name = shutup
}
playban {
  collection.playban = playban
}
perfStat {
  collection.perf_stat = "perf_stat"
}
push {
  collection {
    device = push_device
    subscription = push_subscription
  }
  web {
    vapid_public_key = "BNHCgAkTcPNY/+QTW2Ccoo+SHTQ9+cTVa8bQQOqFPIBFedYZxJ3ih+GWBaFI2XmMb4PtdGv0e2l+8kYy3sZUGuY="
    url = "http://push.lichess.ovh:9054"
  }
  onesignal {
    url = "https://onesignal.com/api/v1/notifications"
    app_id = ""
    key = ""
  }
  firebase {
    url = "https://fcm.googleapis.com/v1/projects/lichess-1366/messages:send"
    json = ""
  }
}
mod {
  collection {
    modlog = modlog
    player_assessment = player_assessment
    boosting = boosting
    gaming_history = mod_gaming_history
  }
  boosting.nb_games_to_mark = 5
  boosting.ratio_games_to_mark = 0.01
  actor.name = mod
}
report {
  collection.report = report2
  actor.name = report
  score.threshold = 50
}
i18n {
  web_path.relative = ${app.web_path}/trans
  net.domain = ${net.domain}
}
detectlanguage.api {
  url = "https://ws.detectlanguage.com/0.2/detect"
  key = ""
}
mailgun {
  api {
    url = ""
    key = ""
  }
  sender = "lichess.org <noreply@lichess.org>"
  reply_to = "lichess.org <noreply@lichess.org>"
}
timeline {
  collection {
    unsub = timeline_unsub
    entry = timeline_entry
  }
  user {
    display_max = 12
    actor.name = user-timeline
  }
}
game {
  paginator.maxPerPage = 12
  collection {
    game = game5
    crosstable = crosstable2
    matchup = matchup
  }
  captcher {
    name = captcher
    duration = 15 seconds
  }
  uciMemoTtl = 3 minutes
  pngUrl = "http://boardimage.lichess.ovh:8080/board.png"
  pngSize = 1024
}
streamer {
  collection.streamer = "streamer"
  collection.image = ${mongodb.image.collection}
  paginator.max_per_page = 12
  streaming {
    google.api_key = ""
    keyword = "lichess.org"
    twitch.client_id = ""
  }
}
explorer {
  endpoint = "https://explorer.lichess.ovh"
  internal_endpoint = "http://explorer.lichess.ovh"
  tablebase = {
    endpoint = "https://tablebase.lichess.ovh"
  }
}
gameSearch {
  index = game
  paginator.max_per_page = 12
  actor.name = game-search
}
round {
  active.ttl = 40 seconds
  animation.duration = ${chessground.animation.duration}
  moretime = 15 seconds
  collection {
    note = game_note
    forecast = forecast
    alarm = round_alarm
  }
  net.domain = ${net.domain}
}
tournament {
  collection {
    tournament = tournament2
    player = tournament_player
    pairing = tournament_pairing
    leaderboard = tournament_leaderboard
  }
  history.message.ttl = 20 seconds
  sri.timeout = 7 seconds # small to avoid missed events
  api_actor.name = tournament-api
  pairing.delay = 3.1 seconds
  leaderboard.cache.ttl = 1 hour
  net.domain = ${net.domain}
}
simul {
  collection {
    simul = simul
  }
  created.cache.ttl = 2 seconds
  feature.views = 10000 # max frontpage views of simul per host per day
}
forum {
  topic.max_per_page = 10
  post.max_per_page = 10
  public_categ_ids = [
    general-chess-discussion
    game-analysis
    lichess-feedback
    off-topic-discussion
  ]
}
forumSearch {
  index = forum
  paginator.max_per_page = 10
  actor.name = forum-search
}
message {
  thread.max_per_page = 30
  collection.thread = m_thread
}
coach {
  collection.coach = coach
  collection.review = coach_review
  collection.image = ${mongodb.image.collection}
}
memo {
  collection {
    cache = cache
    config = flag
  }
}
redis {
  uri = "redis://127.0.0.1"
  # uri = "redis-socket:///var/run/redis/redis-server.sock"
}
socket {
  redis = ${redis}
}
setup.max_playing = 200
evalCache {
  collection.evalCache = eval_cache
}
user {
  cached.nb.ttl = 10 minutes
  online.ttl = 7 seconds
  collection {
    user = user4
    note = note
    trophy = trophy
    trophyKind = trophyKind
    ranking = ranking
  }
  password.bpass {
    secret = "9qEYN0ThHer1KWLNekA76Q=="
  }
}
fishnet {
  redis = ${redis}
  collection {
    analysis = fishnet_analysis
    client = fishnet_client
  }
  offline_mode = true # any client can provide moves and analysis
  actor.name = fishnet
  analysis.nodes = 4000000
  move.plies = 300
  client_min_version = "1.15.10"
}
application {
  global="lila.app.Global"
}
insight {
  mongodb {
    uri = "mongodb://127.0.0.1:27017/lichess-insight"
    mongo-async-driver = {}
  }
}
notify {
  collection.notify = notify
  actor.name = notify
}
learn {
  collection.progress = learn_progress
}
simulation {
  enabled = false
  players = 300
  watchers = 200
}
slack.incoming.url = ""
plan {
  stripe {
    endpoint="https://api.stripe.com/v1"
    keys {
      public="pk_test_31E5TIuGtMs4ojhzMIMu8oIc"
      secret="sk_test_erAQMvv5cF90WXUFlkv7Tke0"
    }
  }
  paypal {
    ipn_key=""
  }
  collection {
    patron = plan_patron
    charge = plan_charge
  }
}
hub {
  actor {
    game {
      search = ${gameSearch.actor.name}
    }
    renderer = ${app.renderer.name}
    captcher = ${game.captcher.name}
    forum {
      search = ${forumSearch.actor.name}
    }
    team.search = ${teamSearch.actor.name}
    fishnet = ${fishnet.actor.name}
    tournament.api = ${tournament.api_actor.name}
    timeline {
      user = ${timeline.user.actor.name}
    }
    bookmark = ${bookmark.actor.name}
    relation = ${relation.actor.name}
    report = ${report.actor.name}
    shutup = ${shutup.actor.name}
    mod = ${mod.actor.name}
    chat = ${chat.actor.name}
    notify = ${notify.actor.name}
  }
}

dbplugin = disabled
ehcacheplugin = disabled

akka {
  loggers = ["akka.event.slf4j.Slf4jLogger"]
  loglevel = INFO
  stdout-loglevel = INFO
  log-config-on-start = off
  log-dead-letters-during-shutdown = off
}

kamon {
  metric {
    tick-interval = 20 second
    track-unmatched-entities = yes
    filters {
      trace {
        includes = [ "**" ]
        excludes = [ ]
      }
    }
  }

  influxdb {
    hostname = "127.0.0.1"
    port = 8086

    # The maximum packet size for one POST request, set to 0 to disable batching
    max-packet-size = 16384

    # The protocol, either http or udp
    protocol = "udp"

    # The measurements will be named ${application-name}-timers and -counters
    application-name = "dev"

    # Allow users to override the name of the hostname reported by kamon. When changed, the hostname tag will be
    # the value given here.
    hostname-override = none

    # For histograms, which percentiles to count
    percentiles = [25.0, 50.0, 75.0, 95.0, 99.0]

    # Subscription patterns used to select which metrics will be pushed to InfluxDB. Note that first, metrics
    # collection for your desired entities must be activated under the kamon.metrics.filters settings.
    subscriptions {
      histogram       = [ "**" ]
      min-max-counter = [ "**" ]
      gauge           = [ "**" ]
      counter         = [ "**" ]
      trace           = [ "**" ]
      trace-segment   = [ "**" ]
      akka-actor      = [ "**" ]
      akka-dispatcher = [ "**" ]
      akka-router     = [ "**" ]
      system-metric   = [ "**" ]
      http-server     = [ "**" ]
    }
  }

  modules {
    kamon-influxdb {
      auto-start = no
    }
  }
}