mongodb {
  uri = "mongodb://127.0.0.1:27017/lichess"
  mongo-async-driver = {}
}
net {
  domain = "lichess.org"
  protocol = "http://"
  base_url = ${net.protocol}${net.domain}
  ip = "5.196.91.160"
  asset {
    domain = ${net.domain}
    version = 883
  }
}
forcedev = false
play {
  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
    }
  }
  i18n {
    langs=[en,fr,ru,de,tr,sr,lv,bs,da,es,ro,it,fi,uk,pt,pl,nl,vi,sv,cs,sk,hu,ca,sl,az,nn,eo,tp,el,fp,lt,nb,et,hy,af,hi,ar,zh,gl,hr,mk,id,ja,bg,th,fa,he,mr,mn,cy,gd,ga,sq,be,ka,sw,ps,is,kk,io,gu,fo,eu,bn,id,la,jv,ky,pi,as,le,ta,sa,ml,kn,ko,mg,kb,zu,ur,yo,tl,fy,jb]
  }
  http {
    session {
      cookieName = "lila2"
      maxAge = 365 days
    }
  }
  ws {
    useragent = ${net.base_url}
    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^"
  }
  akka.actor-system = "lila"
}
app {
  scheduler {
    disabled = false
    debug = false
  }
  renderer.name = "renderer"
  router.name = "router"
  web_path = "public"
  casual_only = false
}
api {
  token = secret
}
cli {
  username = "thibault"
}
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.cdn.prismic.io/api"
}
blog {
  prismic {
    api_url = ${prismic.api_url}
    collection = blog
  }
  notify {
    delay = 20 minutes
    sender = "lichess-blog"
  }
  last_post_cache.ttl = 10 minutes
  rss {
    email = "lichess.contact@gmail.com"
  }
}
qa {
  collection {
    question = qa_question
    answer = qa_answer
  }
  notifier.sender = lichess-qa
}
donation {
  collection.donation = donation
  monthly_goal = 119900
  server_donors = [ drazak, jaldus, intenex, thibault ]
}
chat {
  collection.chat = chat
  max_lines = 50
  net.domain = ${net.domain}
  actor.name = chat
}
puzzle {
  mongodb {
    uri = "mongodb://127.0.0.1:27017/lichess"
    mongo-async-driver = {}
  }
  collection {
    puzzle = puzzle
    attempt = puzzle_attempt
  }
  api.token = ${api.token}
  selector {
    anon_min_rating = 30
    max_attempts = 10000
  }
  animation.duration = ${chessground.animation.duration}
  png.exec_path = "submodules/boardcreator"
}
coordinate {
  collection {
    score = coordinate_score
  }
}
opening {
  collection {
    opening = opening
    attempt = opening_attempt
    name = opening_name
  }
  selector {
    tolerance = {
      step = 160
      max = 1000
    }
    modulo = 20000
  }
  animation.duration = ${chessground.animation.duration}
  api.token = ${api.token}
}
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"
}
team {
  collection{
    team = team
    member = team_member
    request = team_request
  }
  notifier.sender = lichess-team
  paginator.max_per_page = 15
  paginator.max_user_per_page = 24
}
teamSearch {
  index = team
  paginator.max_per_page = ${team.paginator.max_per_page}
  actor.name = team-search
}
relation {
  collection {
    relation = relation
  }
  actor {
    name = relation
    notify_freq = 2 seconds
  }
  limit {
    follow = 300
    block = 500
  }
}
pref {
  collection.pref = pref
  cache.ttl = 30 minutes
}
bookmark {
  collection.bookmark = bookmark
  paginator.max_per_page = ${game.paginator.max_per_page}
  actor.name = bookmark
}
analyse {
  collection.analysis = analysis2
  net.domain = ${net.domain}
  cached.nb.ttl = ${game.cached.nb.ttl}
  paginator.max_per_page = ${game.paginator.max_per_page}
  actor.name = analyser
}
geoip {
  file = ""
  cache_ttl = 1 hour
}
security {
  collection.security = security
  flood.duration = 60 seconds
  firewall {
    enabled=true
    cached.ips.ttl = 10 minutes
    cookie {
      enabled = false
      name=fEKHA4zI74ZrZrom
    }
    collection.firewall = firewall
  }
  geoip = ${geoip}
  password_reset {
    mailgun = ${mailgun}
    secret = "???"
  }
  email_confirm {
    enabled = false
    mailgun = ${mailgun}
    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-email-domains/master/index.json"
    refresh_delay = 10 minutes
  }
  recaptcha = ${recaptcha}
  whois {
    key = "matewithknightandbishop"
  }
}
recaptcha {
  endpoint = "https://www.google.com/recaptcha/api/siteverify"
  public_key = "6LeMhwsTAAAAAElD4KwTo_IUmqIXqx7hkSLLaNSP"
  private_key = ""
}
shutup {
  collection.shutup = shutup
  actor.name = shutup
}
playban {
  collection.playban = playban
}
worldMap {
  geoip = ${geoip}
}
perfStat {
  collection.perf_stat = "perf_stat"
}
push {
  collection.device = push_device
  google {
    url = "https://android.googleapis.com/gcm/send"
    key = ""
  }
  apple {
    enabled = false
    cert = zpns.p12
    password = ""
  }
}
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 = report
  actor.name = report
}
i18n {
  web_path.relative = ${app.web_path}/trans
  file_path.relative = "conf"
  upstream.url_pattern = "http://en.lichess.org/translation/fetch/%d"
  hide_calls.cookie {
    name="hide_i18n_calls"
    max_age=604800 # one week
  }
  collection.translation = translation
  request_handler.protocol = ${net.protocol}
  context.git {
    url = "git://github.com/ornicar/lila.wiki.git"
    file = "translation_context.md"
  }
  cdn_domain = ${net.asset.domain}
  call.threshold = 4500
}
detectlanguage.api {
  url = "http://ws.detectlanguage.com/0.2/detect"
  key = "???"
}
mailgun {
  api {
    url = "???"
    key = "???"
  }
  sender = "lichess.org <noreply@mail.lichess.org>"
  base_url = ${net.base_url}
}
lobby {
  message.ttl = 30 seconds
  orphan_hook.ttl = 5 seconds
  socket {
    name = lobby-socket
    uid.ttl = ${site.socket.uid.ttl}
  }
  actor.name = lobby-actor
  net.domain = ${net.domain}
  broom_period = 1.5 second
  resync_ids_period = 25 seconds
  collection.seek = seek
  collection.seek_archive = seek_archive
  seek {
    max_per_page = 14
    max_per_user = 5
  }
}
timeline {
  collection {
    unsub = timeline_unsub
    entry = timeline_entry
  }
  user {
    display_max = 12
    actor.name = user-timeline
  }
}
game {
  cached.nb.ttl = 1 hour
  paginator.max_per_page = 9
  collection {
    game = game5
    crosstable = crosstable
  }
  js_path {
    raw = public/javascripts/big.js
    compiled = public/compiled/big.js
  }
  captcher {
    name = captcher
    duration = 7 seconds
  }
  net.base_url = ${net.base_url}
  uci_memo.ttl = 2 minutes
  pdf.exec_path = "submodules/pdfexporter"
  png.exec_path = "submodules/boardcreator"
}
tv {
  featured {
    select = 3 seconds
  }
  streaming {
    search = 20 seconds
    google.api_key = ""
    keyword = "lichess.org"
  }
}
explorer {
  endpoint = "http://expl.lichess.org"
  index_flow = false
  mass_import = {
    endpoint = "http://expl.lichess.org"
  }
}
gameSearch {
  index = game
  paginator.max_per_page = ${game.paginator.max_per_page}
  actor.name = game-search
}
round {
  active.ttl = 30 seconds
  uid.timeout = 10 seconds
  finisher.lock.timeout = 20 seconds
  animation.duration = ${chessground.animation.duration}
  moretime = 15 seconds
  casual_only = ${app.casual_only}
  player {
    disconnect.timeout = 90 seconds
    ragequit.timeout = 10 seconds
  }
  socket {
    name = round-socket
    timeout = 30 seconds
  }
  actor.map.name = round-map
  channel.move_time.name = round-move-time
  collection {
    note = game_note
    history = round_history
    forecast = forecast
  }
  net.domain = ${net.domain}
}
tournament {
  collection {
    tournament = tournament2
    player = tournament_player
    pairing = tournament_pairing
    leaderboard = tournament_leaderboard
  }
  history.message.ttl = 30 seconds
  uid.timeout = 7 seconds # small to avoid missed events
  socket {
    name = tournament-socket
    timeout = 2 minutes
  }
  organizer.name = tournament-organizer
  reminder.name = tournament-reminder
  sequencer {
    timeout = 10 minutes
  }
  pairing.delay = 3.1 seconds
  created.cache.ttl = 2 seconds
  leaderboard.cache.ttl = 1 hour
  ranking.cache.ttl = 1 hour
  net.domain = ${net.domain}
}
simul {
  collection {
    simul = simul
  }
  sequencer {
    timeout = 10 minutes
  }
  socket {
    name = simul-socket
    timeout = 5 minutes
  }
  created.cache.ttl = 2 seconds
  history.message.ttl = 30 seconds
  uid.timeout = 7 seconds # small to avoid missed events
  actor.name = simul
}
forum {
  topic.max_per_page = 10
  post.max_per_page = 10
  recent {
    ttl = 1 hour
    nb = 20
  }
  collection {
    categ = f_categ
    topic = f_topic
    post = f_post
  }
  public_categ_ids = [
    general-chess-discussion
    game-analysis
    lichess-feedback
    off-topic-discussion
  ]
  actor.name = forum
}
forumSearch {
  index = forum
  paginator.max_per_page = 10
  actor.name = forum-search
}
message {
  thread.max_per_page = 30
  collection.thread = m_thread
  actor.name = message
  lichess_senders = [
    lichess
    ${blog.notify.sender}
    ${qa.notifier.sender}
    ${team.notifier.sender}
  ]
}
memo {
  collection {
    cache = cache
  }
}
setup {
  friend.memo.ttl = 1 day
  casual_only = ${app.casual_only}
  collection {
    user_config = config
    anon_config = config_anon
  }
}
challenge {
  collection.challenge = challenge
  max_per_user = 20
  socket {
    name = challenge-socket
    timeout = 1 minute
  }
  history.message.ttl = 40 seconds
  uid.timeout = 7 seconds
}
site {
  socket {
    name = site-socket
    uid.ttl = 10 seconds
  }
}
user {
  paginator.max_per_page = 40
  cached.nb.ttl = 10 minutes
  online.ttl = 7 seconds
  collection {
    user = user4
    note = note
    trophy = trophy
    ranking = ranking
  }
}
history {
  collection.history = history3
  cached.rating_chart.ttl = 1 hour
}
fishnet {
  collection {
    analysis = fishnet_analysis
    client = fishnet_client
  }
  offline_mode = true # any client can provide moves and analysis
  actor.name = fishnet
}
application {
  global="lila.app.Global"
}
wiki {
  collection.page = wiki
  git.url = "git://github.com/ornicar/lichess.wiki.git"
  markdown_path = "/usr/bin/markdown"
}
importer {
  delay = 50 milliseconds
}
mobile.app.version = "1.3.0"
insight {
  mongodb {
    uri = "mongodb://127.0.0.1:27017/lichess-insight"
    mongo-async-driver = {}
  }
  collection {
    entry = insight
    user_cache = insight_user_cache
  }
}
simulation {
  enabled = false
  players = 300
  watchers = 200
}
slack {
  incoming {
    url = ""
    default_channel = tavern
  }
}
hub {
  actor {
    game {
      search = ${gameSearch.actor.name}
    }
    renderer = ${app.renderer.name}
    captcher = ${game.captcher.name}
    forum {
      actor = ${forum.actor.name}
      search = ${forumSearch.actor.name}
    }
    team {
      search = ${teamSearch.actor.name}
    }
    messenger = ${message.actor.name}
    router = ${app.router.name}
    fishnet = ${fishnet.actor.name}
    tournament.organizer = ${tournament.organizer.name}
    timeline {
      user = ${timeline.user.actor.name}
    }
    bookmark = ${bookmark.actor.name}
    round {
      map = ${round.actor.map.name}
    }
    lobby = ${lobby.actor.name}
    relation = ${relation.actor.name}
    report = ${report.actor.name}
    shutup = ${shutup.actor.name}
    mod = ${mod.actor.name}
    chat = ${chat.actor.name}
    analyser = ${analyse.actor.name}
    move_broadcast = ${socket.move_broadcast.name}
    user_register = ${socket.user_register.name}
    simul = ${simul.actor.name}
  }
  socket {
    lobby = ${lobby.socket.name}
    site = ${site.socket.name}
    round = ${round.socket.name}
    tournament = ${tournament.socket.name}
    simul = ${simul.socket.name}
    challenge = ${challenge.socket.name}
    hub = ${socket.hub.name}
  }
  channel {
    round.move_time = ${round.channel.move_time.name}
  }
}

socket {
  hub.name = socket.hub
  move_broadcast.name = socket.move-broadcast
  user_register.name = socket.user-register
  population.name = socket.population
}

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 = 2 second
    track-unmatched-entities = no
    filters {
      trace {
        includes = [ ]
        excludes = [ ]
      }
    }
  }

 statsd {
    hostname = "127.0.0.1"
    port = 8125

    # value must be equal or greater than the kamon.metrics.tick-interval setting
    flush-interval = 2 second

    # Max packet size for UDP metrics data sent to StatsD
    max-packet-size = 2048 bytes

    subscriptions {
      histogram       = [ "**" ]
      min-max-counter = [ "**" ]
      gauge           = [ "**" ]
      counter         = [ "**" ]
      trace           = [ "**" ]
      trace-segment   = [ "**" ]
      system-metric   = [ "**" ]
      http-server     = [ "**" ]
    }

    metric-key-generator = lila.api.KeepDotsMetricKeyGenerator

    simple-metric-key-generator {

      # Application prefix for all metrics pushed to StatsD. The default namespacing scheme for metrics follows
      # this pattern: application.host.entity.entity-name.metric-name
      application = "local"

      # application.entity.entity-name.metric-name
      include-hostname = false

      metric-name-normalization-strategy = keep-dots
    }
  }

  modules {
    kamon-statsd {
      auto-start = no
      requires-aspectj = no
      extension-id = "kamon.statsd.StatsD"
    }
  }
}