xonstat/views/submission.py

   1 import calendar
   2 import collections
   3 import datetime
   4 import logging
   5 import re
   6
   7 import pyramid.httpexceptions
   8 from sqlalchemy import Sequence
   9 from sqlalchemy.orm.exc import NoResultFound
  10 from xonstat.elo import EloProcessor
  11 from xonstat.models import DBSession, Server, Map, Game, PlayerGameStat, PlayerWeaponStat
  12 from xonstat.models import PlayerRank, PlayerCaptime, PlayerGameFragMatrix
  13 from xonstat.models import TeamGameStat, PlayerGameAnticheat, Player, Hashkey, PlayerNick
  14 from xonstat.util import strip_colors, qfont_decode, verify_request, weapon_map
  15
  16 log = logging.getLogger(__name__)
  17
  18
  19 class Submission(object):
  20     """Parses an incoming POST request for stats submissions."""
  21
  22     def __init__(self, body, headers):
  23         # a copy of the HTTP headers
  24         self.headers = headers
  25
  26         # a copy of the HTTP POST body
  27         self.body = body
  28
  29         # the submission code version (from the server)
  30         self.version = None
  31
  32         # the revision string of the server
  33         self.revision = None
  34
  35         # the game type played
  36         self.game_type_cd = None
  37
  38         # the active game mod
  39         self.mod = None
  40
  41         # the name of the map played
  42         self.map_name = None
  43
  44         # unique identifier (string) for a match on a given server
  45         self.match_id = None
  46
  47         # the name of the server
  48         self.server_name = None
  49
  50         # the number of cvars that were changed to be different than default
  51         self.impure_cvar_changes = None
  52
  53         # the port number the game server is listening on
  54         self.port_number = None
  55
  56         # how long the game lasted
  57         self.duration = None
  58
  59         # which ladder is being used, if any
  60         self.ladder = None
  61
  62         # players involved in the match (humans, bots, and spectators)
  63         self.players = []
  64
  65         # raw team events
  66         self.teams = []
  67
  68         # the parsing deque (we use this to allow peeking)
  69         self.q = collections.deque(self.body.split("\n"))
  70
  71         ############################################################################################
  72         # Below this point are fields useful in determining if the submission is valid or
  73         # performance optimizations that save us from looping over the events over and over again.
  74         ############################################################################################
  75
  76         # humans who played in the match
  77         self.humans = []
  78
  79         # bots who played in the match
  80         self.bots = []
  81
  82         # player indexes for those who played
  83         self.player_indexes = set()
  84
  85         # distinct weapons that we have seen fired
  86         self.weapons = set()
  87
  88         # has a human player fired a shot?
  89         self.human_fired_weapon = False
  90
  91         # does any human have a non-zero score?
  92         self.human_nonzero_score = False
  93
  94         # does any human have a fastest cap?
  95         self.human_fastest = False
  96
  97         self.parse()
  98
  99     def next_item(self):
 100         """Returns the next key:value pair off the queue."""
 101         try:
 102             items = self.q.popleft().strip().split(' ', 1)
 103             if len(items) == 1:
 104                 # Some keys won't have values, like 'L' records where the server isn't actually
 105                 # participating in any ladders. These can be safely ignored.
 106                 return None, None
 107             else:
 108                 return items
 109         except:
 110             return None, None
 111
 112     def add_weapon_fired(self, sub_key):
 113         """Adds a weapon to the set of weapons fired during the match (a set)."""
 114         self.weapons.add(sub_key.split("-")[1])
 115
 116     @staticmethod
 117     def is_human_player(player):
 118         """
 119         Determines if a given set of events correspond with a non-bot
 120         """
 121         return not player['P'].startswith('bot')
 122
 123     @staticmethod
 124     def played_in_game(player):
 125         """
 126         Determines if a given set of player events correspond with a player who
 127         played in the game (matches 1 and scoreboardvalid 1)
 128         """
 129         return 'matches' in player and 'scoreboardvalid' in player
 130
 131     def parse_player(self, key, pid):
 132         """Construct a player events listing from the submission."""
 133
 134         # all of the keys related to player records
 135         player_keys = ['i', 'n', 't', 'r', 'e']
 136
 137         player = {key: pid}
 138
 139         player_fired_weapon = False
 140         player_nonzero_score = False
 141         player_fastest = False
 142
 143         # Consume all following 'i' 'n' 't'  'e' records
 144         while len(self.q) > 0:
 145             (key, value) = self.next_item()
 146             if key is None and value is None:
 147                 continue
 148             elif key == 'e':
 149                 (sub_key, sub_value) = value.split(' ', 1)
 150                 player[sub_key] = sub_value
 151
 152                 if sub_key.endswith("cnt-fired"):
 153                     player_fired_weapon = True
 154                     self.add_weapon_fired(sub_key)
 155                 elif sub_key == 'scoreboard-score' and int(round(float(sub_value))) != 0:
 156                     player_nonzero_score = True
 157                 elif sub_key == 'scoreboard-fastest':
 158                     player_fastest = True
 159             elif key == 'n':
 160                 player[key] = unicode(value, 'utf-8')
 161             elif key in player_keys:
 162                 player[key] = value
 163             else:
 164                 # something we didn't expect - put it back on the deque
 165                 self.q.appendleft("{} {}".format(key, value))
 166                 break
 167
 168         played = self.played_in_game(player)
 169         human = self.is_human_player(player)
 170
 171         if played:
 172             self.player_indexes.add(int(player["i"]))
 173
 174         if played and human:
 175             self.humans.append(player)
 176
 177             if player_fired_weapon:
 178                 self.human_fired_weapon = True
 179
 180             if player_nonzero_score:
 181                 self.human_nonzero_score = True
 182
 183             if player_fastest:
 184                 self.human_fastest = True
 185
 186         elif played and not human:
 187             self.bots.append(player)
 188
 189         self.players.append(player)
 190
 191     def parse_team(self, key, tid):
 192         """Construct a team events listing from the submission."""
 193         team = {key: tid}
 194
 195         # Consume all following 'e' records
 196         while len(self.q) > 0 and self.q[0].startswith('e'):
 197             (_, value) = self.next_item()
 198             (sub_key, sub_value) = value.split(' ', 1)
 199             team[sub_key] = sub_value
 200
 201         self.teams.append(team)
 202
 203     def parse(self):
 204         """Parses the request body into instance variables."""
 205         while len(self.q) > 0:
 206             (key, value) = self.next_item()
 207             if key is None and value is None:
 208                 continue
 209             elif key == 'V':
 210                 self.version = value
 211             elif key == 'R':
 212                 self.revision = value
 213             elif key == 'G':
 214                 self.game_type_cd = value
 215             elif key == 'O':
 216                 self.mod = value
 217             elif key == 'M':
 218                 self.map_name = value
 219             elif key == 'I':
 220                 self.match_id = value
 221             elif key == 'S':
 222                 self.server_name = unicode(value, 'utf-8')
 223             elif key == 'C':
 224                 self.impure_cvar_changes = int(value)
 225             elif key == 'U':
 226                 self.port_number = int(value)
 227             elif key == 'D':
 228                 self.duration = datetime.timedelta(seconds=int(round(float(value))))
 229             elif key == 'L':
 230                 self.ladder = value
 231             elif key == 'Q':
 232                 self.parse_team(key, value)
 233             elif key == 'P':
 234                 self.parse_player(key, value)
 235             else:
 236                 raise Exception("Invalid submission")
 237
 238         return self
 239
 240     def __repr__(self):
 241         """Debugging representation of a submission."""
 242         return "game_type_cd: {}, mod: {}, players: {}, humans: {}, bots: {}, weapons: {}".format(
 243             self.game_type_cd, self.mod, len(self.players), len(self.humans), len(self.bots),
 244             self.weapons)
 245
 246
 247 def elo_submission_category(submission):
 248     """Determines the Elo category purely by what is in the submission data."""
 249     mod = submission.mod
 250
 251     vanilla_allowed_weapons = {"shotgun", "devastator", "blaster", "mortar", "vortex", "electro",
 252                                "arc", "hagar", "crylink", "machinegun"}
 253     insta_allowed_weapons = {"vaporizer", "blaster"}
 254     overkill_allowed_weapons = {"hmg", "vortex", "shotgun", "blaster", "machinegun", "rpc"}
 255
 256     if mod == "Xonotic":
 257         if len(submission.weapons - vanilla_allowed_weapons) == 0:
 258             return "vanilla"
 259     elif mod == "InstaGib":
 260         if len(submission.weapons - insta_allowed_weapons) == 0:
 261             return "insta"
 262     elif mod == "Overkill":
 263         if len(submission.weapons - overkill_allowed_weapons) == 0:
 264             return "overkill"
 265     else:
 266         return "general"
 267
 268     return "general"
 269
 270
 271 def is_blank_game(submission):
 272     """
 273     Determine if this is a blank game or not. A blank game is either:
 274
 275     1) a match that ended in the warmup stage, where accuracy events are not
 276     present (for non-CTS games)
 277
 278     2) a match in which no player made a positive or negative score AND was
 279     on the scoreboard
 280
 281     ... or for CTS, which doesn't record accuracy events
 282
 283     1) a match in which no player made a fastest lap AND was
 284     on the scoreboard
 285
 286     ... or for NB, in which not all maps have weapons
 287
 288     1) a match in which no player made a positive or negative score
 289     """
 290     if submission.game_type_cd == 'cts':
 291         return not submission.human_fastest
 292     elif submission.game_type_cd == 'nb':
 293         return not submission.human_nonzero_score
 294     else:
 295         return not (submission.human_nonzero_score and submission.human_fired_weapon)
 296
 297
 298 def has_required_metadata(submission):
 299     """Determines if a submission has all the required metadata fields."""
 300     return (submission.game_type_cd is not None
 301             and submission.map_name is not None
 302             and submission.match_id is not None
 303             and submission.server_name is not None)
 304
 305
 306 def is_supported_gametype(submission):
 307     """Determines if a submission is of a valid and supported game type."""
 308
 309     # if the type can be supported, but with version constraints, uncomment
 310     # here and add the restriction for a specific version below
 311     supported_game_types = (
 312             'as',
 313             'ca',
 314             # 'cq',
 315             'ctf',
 316             'cts',
 317             'dm',
 318             'dom',
 319             'duel',
 320             'ft', 'freezetag',
 321             'ka', 'keepaway',
 322             'kh',
 323             # 'lms',
 324             'nb', 'nexball',
 325             # 'rc',
 326             'rune',
 327             'tdm',
 328         )
 329
 330     is_supported = submission.game_type_cd in supported_game_types
 331
 332     # some game types were buggy before revisions, thus this additional filter
 333     if submission.game_type_cd == 'ca' and submission.version <= 5:
 334         is_supported = False
 335
 336     return is_supported
 337
 338
 339 def has_minimum_real_players(settings, submission):
 340     """
 341     Determines if the submission has enough human players to store in the database. The minimum
 342     setting comes from the config file under the setting xonstat.minimum_real_players.
 343     """
 344     try:
 345         minimum_required_players = int(settings.get("xonstat.minimum_required_players"))
 346     except:
 347         minimum_required_players = 2
 348
 349     # Make an exception for CTS since it can be done by individuals and there is no Elo anyway
 350     if submission.game_type_cd == "cts":
 351         minimum_required_players = 1
 352
 353     return len(submission.humans) >= minimum_required_players
 354
 355
 356 def do_precondition_checks(settings, submission):
 357     """Precondition checks for ALL gametypes. These do not require a database connection."""
 358     if not has_required_metadata(submission):
 359         msg = "Missing required game metadata"
 360         log.debug(msg)
 361         raise pyramid.httpexceptions.HTTPUnprocessableEntity(
 362             body=msg,
 363             content_type="text/plain"
 364         )
 365
 366     if submission.version is None:
 367         msg = "Invalid or incorrect game metadata provided"
 368         log.debug(msg)
 369         raise pyramid.httpexceptions.HTTPUnprocessableEntity(
 370             body=msg,
 371             content_type="text/plain"
 372         )
 373
 374     if not is_supported_gametype(submission):
 375         msg = "Unsupported game type ({})".format(submission.game_type_cd)
 376         log.debug(msg)
 377         raise pyramid.httpexceptions.HTTPOk(
 378             body=msg,
 379             content_type="text/plain"
 380         )
 381
 382     if not has_minimum_real_players(settings, submission):
 383         msg = "Not enough real players"
 384         log.debug(msg)
 385         raise pyramid.httpexceptions.HTTPOk(
 386             body=msg,
 387             content_type="text/plain"
 388         )
 389
 390     if is_blank_game(submission):
 391         msg = "Blank game"
 392         log.debug(msg)
 393         raise pyramid.httpexceptions.HTTPOk(
 394             body=msg,
 395             content_type="text/plain"
 396         )
 397
 398
 399 def get_remote_addr(request):
 400     """Get the Xonotic server's IP address"""
 401     if 'X-Forwarded-For' in request.headers:
 402         return request.headers['X-Forwarded-For']
 403     else:
 404         return request.remote_addr
 405
 406
 407 def should_do_weapon_stats(game_type_cd):
 408     """True of the game type should record weapon stats. False otherwise."""
 409     return game_type_cd not in {'cts'}
 410
 411
 412 def should_do_frag_matrix(game_type_cd):
 413     """True if the game type should record frag matrix values. False otherwise."""
 414     return game_type_cd in {
 415         'as', 'ca', 'ctf', 'dm', 'dom', 'ft', 'freezetag', 'ka', 'kh', 'rune', 'tdm',
 416     }
 417
 418
 419 def gametype_elo_eligible(game_type_cd):
 420     """True of the game type should process Elos. False otherwise."""
 421     return game_type_cd in {'duel', 'dm', 'ca', 'ctf', 'tdm', 'ka', 'ft'}
 422
 423
 424 def register_new_nick(session, player, new_nick):
 425     """
 426     Change the player record's nick to the newly found nick. Store the old
 427     nick in the player_nicks table for that player.
 428
 429     session - SQLAlchemy database session factory
 430     player - player record whose nick is changing
 431     new_nick - the new nickname
 432     """
 433     # see if that nick already exists
 434     stripped_nick = strip_colors(qfont_decode(player.nick))
 435     try:
 436         player_nick = session.query(PlayerNick).filter_by(
 437             player_id=player.player_id, stripped_nick=stripped_nick).one()
 438     except NoResultFound, e:
 439         # player_id/stripped_nick not found, create one
 440         # but we don't store "Anonymous Player #N"
 441         if not re.search('^Anonymous Player #\d+$', player.nick):
 442             player_nick = PlayerNick()
 443             player_nick.player_id = player.player_id
 444             player_nick.stripped_nick = stripped_nick
 445             player_nick.nick = player.nick
 446             session.add(player_nick)
 447
 448     # We change to the new nick regardless
 449     player.nick = new_nick
 450     player.stripped_nick = strip_colors(qfont_decode(new_nick))
 451     session.add(player)
 452
 453
 454 def update_fastest_cap(session, player_id, game_id, map_id, captime, mod):
 455     """
 456     Check the fastest cap time for the player and map. If there isn't
 457     one, insert one. If there is, check if the passed time is faster.
 458     If so, update!
 459     """
 460     # we don't record fastest cap times for bots or anonymous players
 461     if player_id <= 2:
 462         return
 463
 464     # see if a cap entry exists already
 465     # then check to see if the new captime is faster
 466     try:
 467         cur_fastest_cap = session.query(PlayerCaptime).filter_by(
 468             player_id=player_id, map_id=map_id, mod=mod).one()
 469
 470         # current captime is faster, so update
 471         if captime < cur_fastest_cap.fastest_cap:
 472             cur_fastest_cap.fastest_cap = captime
 473             cur_fastest_cap.game_id = game_id
 474             cur_fastest_cap.create_dt = datetime.datetime.utcnow()
 475             session.add(cur_fastest_cap)
 476
 477     except NoResultFound, e:
 478         # none exists, so insert
 479         cur_fastest_cap = PlayerCaptime(player_id, game_id, map_id, captime,
 480                 mod)
 481         session.add(cur_fastest_cap)
 482         session.flush()
 483
 484
 485 def update_server(server, name, hashkey, ip_addr, port, revision, impure_cvars):
 486     """
 487     Updates the server in the given DB session, if needed.
 488
 489     :param server: The found server instance.
 490     :param name: The incoming server name.
 491     :param hashkey: The incoming server hashkey.
 492     :param ip_addr: The incoming server IP address.
 493     :param port: The incoming server port.
 494     :param revision: The incoming server revision.
 495     :param impure_cvars: The incoming number of impure server cvars.
 496     :return: bool
 497     """
 498     # ensure the two int attributes are actually ints
 499     try:
 500         port = int(port)
 501     except:
 502         port = None
 503
 504     try:
 505         impure_cvars = int(impure_cvars)
 506     except:
 507         impure_cvars = 0
 508
 509     updated = False
 510     if name and server.name != name:
 511         server.name = name
 512         updated = True
 513     if hashkey and server.hashkey != hashkey:
 514         server.hashkey = hashkey
 515         updated = True
 516     if ip_addr and server.ip_addr != ip_addr:
 517         server.ip_addr = ip_addr
 518         updated = True
 519     if port and server.port != port:
 520         server.port = port
 521         updated = True
 522     if revision and server.revision != revision:
 523         server.revision = revision
 524         updated = True
 525     if impure_cvars and server.impure_cvars != impure_cvars:
 526         server.impure_cvars = impure_cvars
 527         server.pure_ind = True if impure_cvars == 0 else False
 528         updated = True
 529
 530     return updated
 531
 532
 533 def get_or_create_server(session, name, hashkey, ip_addr, revision, port, impure_cvars):
 534     """
 535     Find a server by name or create one if not found. Parameters:
 536
 537     session - SQLAlchemy database session factory
 538     name - server name of the server to be found or created
 539     hashkey - server hashkey
 540     ip_addr - the IP address of the server
 541     revision - the xonotic revision number
 542     port - the port number of the server
 543     impure_cvars - the number of impure cvar changes
 544     """
 545     servers_q = DBSession.query(Server).filter(Server.active_ind)
 546
 547     if hashkey:
 548         # if the hashkey is provided, we'll use that
 549         servers_q = servers_q.filter((Server.name == name) or (Server.hashkey == hashkey))
 550     else:
 551         # otherwise, it is just by name
 552         servers_q = servers_q.filter(Server.name == name)
 553
 554     # order by the hashkey, which means any hashkey match will appear first if there are multiple
 555     servers = servers_q.order_by(Server.hashkey, Server.create_dt).all()
 556
 557     if len(servers) == 0:
 558         server = Server(name=name, hashkey=hashkey)
 559         session.add(server)
 560         session.flush()
 561         log.debug("Created server {} with hashkey {}.".format(server.server_id, server.hashkey))
 562     else:
 563         server = servers[0]
 564         if len(servers) == 1:
 565             log.info("Found existing server {}.".format(server.server_id))
 566
 567         elif len(servers) > 1:
 568             server_id_list = ", ".join(["{}".format(s.server_id) for s in servers])
 569             log.warn("Multiple servers found ({})! Using the first one ({})."
 570                      .format(server_id_list, server.server_id))
 571
 572     if update_server(server, name, hashkey, ip_addr, port, revision, impure_cvars):
 573         session.add(server)
 574
 575     return server
 576
 577
 578 def get_or_create_map(session, name):
 579     """
 580     Find a map by name or create one if not found. Parameters:
 581
 582     session - SQLAlchemy database session factory
 583     name - map name of the map to be found or created
 584     """
 585     maps = session.query(Map).filter_by(name=name).order_by(Map.map_id).all()
 586
 587     if maps is None or len(maps) == 0:
 588         gmap = Map(name=name)
 589         session.add(gmap)
 590         session.flush()
 591         log.debug("Created map id {}: {}".format(gmap.map_id, gmap.name))
 592     elif len(maps) == 1:
 593         gmap = maps[0]
 594         log.debug("Found map id {}: {}".format(gmap.map_id, gmap.name))
 595     else:
 596         gmap = maps[0]
 597         map_id_list = ", ".join(["{}".format(m.map_id) for m in maps])
 598         log.warn("Multiple maps found for {} ({})! Using the first one.".format(name, map_id_list))
 599
 600     return gmap
 601
 602
 603 def create_game(session, game_type_cd, server_id, map_id, match_id, start_dt, duration, mod,
 604                 winner=None):
 605     """
 606     Creates a game. Parameters:
 607
 608     session - SQLAlchemy database session factory
 609     game_type_cd - the game type of the game being played
 610     mod - mods in use during the game
 611     server_id - server identifier of the server hosting the game
 612     map_id - map on which the game was played
 613     match_id - a unique match ID given by the server
 614     start_dt - when the game started (datetime object)
 615     duration - how long the game lasted
 616     winner - the team id of the team that won
 617     """
 618     seq = Sequence('games_game_id_seq')
 619     game_id = session.execute(seq)
 620     game = Game(game_id=game_id, start_dt=start_dt, game_type_cd=game_type_cd, server_id=server_id,
 621                 map_id=map_id, winner=winner)
 622     game.match_id = match_id
 623     game.mod = mod[:64]
 624
 625     # There is some drift between start_dt (provided by app) and create_dt
 626     # (default in the database), so we'll make them the same until this is
 627     # resolved.
 628     game.create_dt = start_dt
 629
 630     game.duration = duration
 631
 632     try:
 633         session.query(Game).filter(Game.server_id == server_id)\
 634             .filter(Game.match_id == match_id).one()
 635
 636         log.debug("Error: game with same server and match_id found! Ignoring.")
 637
 638         # if a game under the same server_id and match_id exists, this is a duplicate
 639         msg = "Duplicate game (pre-existing match_id)"
 640         log.debug(msg)
 641         raise pyramid.httpexceptions.HTTPOk(body=msg, content_type="text/plain")
 642
 643     except NoResultFound:
 644         # server_id/match_id combination not found. game is ok to insert
 645         session.add(game)
 646         session.flush()
 647         log.debug("Created game id {} on server {}, map {} at {}"
 648                   .format(game.game_id, server_id, map_id, start_dt))
 649
 650     return game
 651
 652
 653 def get_or_create_player(session=None, hashkey=None, nick=None):
 654     """
 655     Finds a player by hashkey or creates a new one (along with a
 656     corresponding hashkey entry. Parameters:
 657
 658     session - SQLAlchemy database session factory
 659     hashkey - hashkey of the player to be found or created
 660     nick - nick of the player (in case of a first time create)
 661     """
 662     # if we have a bot
 663     if re.search('^bot#\d+', hashkey):
 664         player = session.query(Player).filter_by(player_id=1).one()
 665     # if we have an untracked player
 666     elif re.search('^player#\d+$', hashkey):
 667         player = session.query(Player).filter_by(player_id=2).one()
 668     # else it is a tracked player
 669     else:
 670         # see if the player is already in the database
 671         # if not, create one and the hashkey along with it
 672         try:
 673             hk = session.query(Hashkey).filter_by(
 674                     hashkey=hashkey).one()
 675             player = session.query(Player).filter_by(
 676                     player_id=hk.player_id).one()
 677             log.debug("Found existing player {0} with hashkey {1}".format(
 678                 player.player_id, hashkey))
 679         except:
 680             player = Player()
 681             session.add(player)
 682             session.flush()
 683
 684             # if nick is given to us, use it. If not, use "Anonymous Player"
 685             # with a suffix added for uniqueness.
 686             if nick:
 687                 player.nick = nick[:128]
 688                 player.stripped_nick = strip_colors(qfont_decode(nick[:128]))
 689             else:
 690                 player.nick = "Anonymous Player #{0}".format(player.player_id)
 691                 player.stripped_nick = player.nick
 692
 693             hk = Hashkey(player_id=player.player_id, hashkey=hashkey)
 694             session.add(hk)
 695             log.debug("Created player {0} ({2}) with hashkey {1}".format(
 696                 player.player_id, hashkey, player.nick.encode('utf-8')))
 697
 698     return player
 699
 700
 701 def create_default_game_stat(session, game_type_cd):
 702     """Creates a blanked-out pgstat record for the given game type"""
 703
 704     # this is what we have to do to get partitioned records in - grab the
 705     # sequence value first, then insert using the explicit ID (vs autogenerate)
 706     seq = Sequence('player_game_stats_player_game_stat_id_seq')
 707     pgstat_id = session.execute(seq)
 708     pgstat = PlayerGameStat(player_game_stat_id=pgstat_id,
 709             create_dt=datetime.datetime.utcnow())
 710
 711     if game_type_cd == 'as':
 712         pgstat.kills = pgstat.deaths = pgstat.suicides = pgstat.collects = 0
 713
 714     if game_type_cd in 'ca' 'dm' 'duel' 'rune' 'tdm':
 715         pgstat.kills = pgstat.deaths = pgstat.suicides = 0
 716
 717     if game_type_cd == 'ctf':
 718         pgstat.kills = pgstat.captures = pgstat.pickups = pgstat.drops = 0
 719         pgstat.returns = pgstat.carrier_frags = 0
 720
 721     if game_type_cd == 'cts':
 722         pgstat.deaths = 0
 723
 724     if game_type_cd == 'dom':
 725         pgstat.kills = pgstat.deaths = pgstat.suicides = pgstat.pickups = 0
 726         pgstat.drops = 0
 727
 728     if game_type_cd == 'ft':
 729         pgstat.kills = pgstat.deaths = pgstat.suicides = pgstat.revivals = 0
 730
 731     if game_type_cd == 'ka':
 732         pgstat.kills = pgstat.deaths = pgstat.suicides = pgstat.pickups = 0
 733         pgstat.carrier_frags = 0
 734         pgstat.time = datetime.timedelta(seconds=0)
 735
 736     if game_type_cd == 'kh':
 737         pgstat.kills = pgstat.deaths = pgstat.suicides = pgstat.pickups = 0
 738         pgstat.captures = pgstat.drops = pgstat.pushes = pgstat.destroys = 0
 739         pgstat.carrier_frags = 0
 740
 741     if game_type_cd == 'nb':
 742         pgstat.kills = pgstat.deaths = pgstat.suicides = pgstat.captures = 0
 743         pgstat.drops = 0
 744
 745     return pgstat
 746
 747
 748 def create_game_stat(session, game, gmap, player, events):
 749     """Game stats handler for all game types"""
 750
 751     game_type_cd = game.game_type_cd
 752
 753     pgstat = create_default_game_stat(session, game_type_cd)
 754
 755     # these fields should be on every pgstat record
 756     pgstat.game_id       = game.game_id
 757     pgstat.player_id     = player.player_id
 758     pgstat.nick          = events.get('n', 'Anonymous Player')[:128]
 759     pgstat.stripped_nick = strip_colors(qfont_decode(pgstat.nick))
 760     pgstat.score         = int(round(float(events.get('scoreboard-score', 0))))
 761     pgstat.alivetime     = datetime.timedelta(seconds=int(round(float(events.get('alivetime', 0.0)))))
 762     pgstat.rank          = int(events.get('rank', None))
 763     pgstat.scoreboardpos = int(events.get('scoreboardpos', pgstat.rank))
 764
 765     wins = False
 766
 767     # gametype-specific stuff is handled here. if passed to us, we store it
 768     for (key,value) in events.items():
 769         if key == 'wins': wins = True
 770         if key == 't': pgstat.team = int(value)
 771
 772         if key == 'scoreboard-drops': pgstat.drops = int(value)
 773         if key == 'scoreboard-returns': pgstat.returns = int(value)
 774         if key == 'scoreboard-fckills': pgstat.carrier_frags = int(value)
 775         if key == 'scoreboard-pickups': pgstat.pickups = int(value)
 776         if key == 'scoreboard-caps': pgstat.captures = int(value)
 777         if key == 'scoreboard-score': pgstat.score = int(round(float(value)))
 778         if key == 'scoreboard-deaths': pgstat.deaths = int(value)
 779         if key == 'scoreboard-kills': pgstat.kills = int(value)
 780         if key == 'scoreboard-suicides': pgstat.suicides = int(value)
 781         if key == 'scoreboard-objectives': pgstat.collects = int(value)
 782         if key == 'scoreboard-captured': pgstat.captures = int(value)
 783         if key == 'scoreboard-released': pgstat.drops = int(value)
 784         if key == 'scoreboard-fastest':
 785             pgstat.fastest = datetime.timedelta(seconds=float(value)/100)
 786         if key == 'scoreboard-takes': pgstat.pickups = int(value)
 787         if key == 'scoreboard-ticks': pgstat.drops = int(value)
 788         if key == 'scoreboard-revivals': pgstat.revivals = int(value)
 789         if key == 'scoreboard-bctime':
 790             pgstat.time = datetime.timedelta(seconds=int(value))
 791         if key == 'scoreboard-bckills': pgstat.carrier_frags = int(value)
 792         if key == 'scoreboard-losses': pgstat.drops = int(value)
 793         if key == 'scoreboard-pushes': pgstat.pushes = int(value)
 794         if key == 'scoreboard-destroyed': pgstat.destroys = int(value)
 795         if key == 'scoreboard-kckills': pgstat.carrier_frags = int(value)
 796         if key == 'scoreboard-lives': pgstat.lives = int(value)
 797         if key == 'scoreboard-goals': pgstat.captures = int(value)
 798         if key == 'scoreboard-faults': pgstat.drops = int(value)
 799         if key == 'scoreboard-laps': pgstat.laps = int(value)
 800
 801         if key == 'avglatency': pgstat.avg_latency = float(value)
 802         if key == 'scoreboard-captime':
 803             pgstat.fastest = datetime.timedelta(seconds=float(value)/100)
 804             if game.game_type_cd == 'ctf':
 805                 update_fastest_cap(session, player.player_id, game.game_id,
 806                         gmap.map_id, pgstat.fastest, game.mod)
 807
 808     # there is no "winning team" field, so we have to derive it
 809     if wins and pgstat.team is not None and game.winner is None:
 810         game.winner = pgstat.team
 811         session.add(game)
 812
 813     session.add(pgstat)
 814
 815     return pgstat
 816
 817
 818 def create_anticheats(session, pgstat, game, player, events):
 819     """Anticheats handler for all game types"""
 820
 821     anticheats = []
 822
 823     # all anticheat events are prefixed by "anticheat"
 824     for (key,value) in events.items():
 825         if key.startswith("anticheat"):
 826             try:
 827                 ac = PlayerGameAnticheat(
 828                     player.player_id,
 829                     game.game_id,
 830                     key,
 831                     float(value)
 832                 )
 833                 anticheats.append(ac)
 834                 session.add(ac)
 835             except Exception as e:
 836                 log.debug("Could not parse value for key %s. Ignoring." % key)
 837
 838     return anticheats
 839
 840
 841 def create_default_team_stat(session, game_type_cd):
 842     """Creates a blanked-out teamstat record for the given game type"""
 843
 844     # this is what we have to do to get partitioned records in - grab the
 845     # sequence value first, then insert using the explicit ID (vs autogenerate)
 846     seq = Sequence('team_game_stats_team_game_stat_id_seq')
 847     teamstat_id = session.execute(seq)
 848     teamstat = TeamGameStat(team_game_stat_id=teamstat_id,
 849             create_dt=datetime.datetime.utcnow())
 850
 851     # all team game modes have a score, so we'll zero that out always
 852     teamstat.score = 0
 853
 854     if game_type_cd in 'ca' 'ft' 'ka':
 855         teamstat.rounds = 0
 856
 857     if game_type_cd == 'ctf':
 858         teamstat.caps = 0
 859
 860     return teamstat
 861
 862
 863 def create_team_stat(session, game, events):
 864     """Team stats handler for all game types"""
 865
 866     try:
 867         teamstat = create_default_team_stat(session, game.game_type_cd)
 868         teamstat.game_id = game.game_id
 869
 870         # we should have a team ID if we have a 'Q' event
 871         if re.match(r'^team#\d+$', events.get('Q', '')):
 872             team = int(events.get('Q').replace('team#', ''))
 873             teamstat.team = team
 874
 875         # gametype-specific stuff is handled here. if passed to us, we store it
 876         for (key,value) in events.items():
 877             if key == 'scoreboard-score': teamstat.score = int(round(float(value)))
 878             if key == 'scoreboard-caps': teamstat.caps = int(value)
 879             if key == 'scoreboard-goals': teamstat.caps = int(value)
 880             if key == 'scoreboard-rounds': teamstat.rounds = int(value)
 881
 882         session.add(teamstat)
 883     except Exception as e:
 884         raise e
 885
 886     return teamstat
 887
 888
 889 def create_weapon_stats(session, version, game, player, pgstat, events):
 890     """Weapon stats handler for all game types"""
 891     pwstats = []
 892
 893     # Version 1 of stats submissions doubled the data sent.
 894     # To counteract this we divide the data by 2 only for
 895     # POSTs coming from version 1.
 896     try:
 897         if version == 1:
 898             is_doubled = True
 899             log.debug('NOTICE: found a version 1 request, halving the weapon stats...')
 900         else:
 901             is_doubled = False
 902     except:
 903         is_doubled = False
 904
 905     for (key,value) in events.items():
 906         matched = re.search("acc-(.*?)-cnt-fired", key)
 907         if matched:
 908             weapon_cd = matched.group(1)
 909
 910             # Weapon names changed for 0.8. We'll convert the old
 911             # ones to use the new scheme as well.
 912             mapped_weapon_cd = weapon_map.get(weapon_cd, weapon_cd)
 913
 914             seq = Sequence('player_weapon_stats_player_weapon_stats_id_seq')
 915             pwstat_id = session.execute(seq)
 916             pwstat = PlayerWeaponStat()
 917             pwstat.player_weapon_stats_id = pwstat_id
 918             pwstat.player_id = player.player_id
 919             pwstat.game_id = game.game_id
 920             pwstat.player_game_stat_id = pgstat.player_game_stat_id
 921             pwstat.weapon_cd = mapped_weapon_cd
 922
 923             if 'n' in events:
 924                 pwstat.nick = events['n']
 925             else:
 926                 pwstat.nick = events['P']
 927
 928             if 'acc-' + weapon_cd + '-cnt-fired' in events:
 929                 pwstat.fired = int(round(float(
 930                         events['acc-' + weapon_cd + '-cnt-fired'])))
 931             if 'acc-' + weapon_cd + '-fired' in events:
 932                 pwstat.max = int(round(float(
 933                         events['acc-' + weapon_cd + '-fired'])))
 934             if 'acc-' + weapon_cd + '-cnt-hit' in events:
 935                 pwstat.hit = int(round(float(
 936                         events['acc-' + weapon_cd + '-cnt-hit'])))
 937             if 'acc-' + weapon_cd + '-hit' in events:
 938                 pwstat.actual = int(round(float(
 939                         events['acc-' + weapon_cd + '-hit'])))
 940             if 'acc-' + weapon_cd + '-frags' in events:
 941                 pwstat.frags = int(round(float(
 942                         events['acc-' + weapon_cd + '-frags'])))
 943
 944             if is_doubled:
 945                 pwstat.fired = pwstat.fired/2
 946                 pwstat.max = pwstat.max/2
 947                 pwstat.hit = pwstat.hit/2
 948                 pwstat.actual = pwstat.actual/2
 949                 pwstat.frags = pwstat.frags/2
 950
 951             session.add(pwstat)
 952             pwstats.append(pwstat)
 953
 954     return pwstats
 955
 956
 957 def get_ranks(session, player_ids, game_type_cd):
 958     """
 959     Gets the rank entries for all players in the given list, returning a dict
 960     of player_id -> PlayerRank instance. The rank entry corresponds to the
 961     game type of the parameter passed in as well.
 962     """
 963     ranks = {}
 964     for pr in session.query(PlayerRank).\
 965             filter(PlayerRank.player_id.in_(player_ids)).\
 966             filter(PlayerRank.game_type_cd == game_type_cd).\
 967             all():
 968                 ranks[pr.player_id] = pr
 969
 970     return ranks
 971
 972
 973 def update_player(session, player, events):
 974     """
 975     Updates a player record using the latest information.
 976     :param session: SQLAlchemy session
 977     :param player: Player model representing what is in the database right now (before updates)
 978     :param events: Dict of player events from the submission
 979     :return: player
 980     """
 981     nick = events.get('n', 'Anonymous Player')[:128]
 982     if nick != player.nick and not nick.startswith("Anonymous Player"):
 983         register_new_nick(session, player, nick)
 984
 985     return player
 986
 987
 988 def create_player(session, events):
 989     """
 990     Creates a new player from the list of events.
 991     :param session: SQLAlchemy session
 992     :param events: Dict of player events from the submission
 993     :return: Player
 994     """
 995     player = Player()
 996     session.add(player)
 997     session.flush()
 998
 999     nick = events.get('n', None)
1000     if nick:
1001         player.nick = nick[:128]
1002         player.stripped_nick = strip_colors(qfont_decode(player.nick))
1003     else:
1004         player.nick = "Anonymous Player #{0}".format(player.player_id)
1005         player.stripped_nick = player.nick
1006
1007     hk = Hashkey(player_id=player.player_id, hashkey=events.get('P', None))
1008     session.add(hk)
1009
1010     return player
1011
1012
1013 def get_or_create_players(session, events_by_hashkey):
1014     hashkeys = set(events_by_hashkey.keys())
1015     players_by_hashkey = {}
1016
1017     bot = session.query(Player).filter(Player.player_id == 1).one()
1018     anon = session.query(Player).filter(Player.player_id == 2).one()
1019
1020     # fill in the bots and anonymous players
1021     for hashkey in events_by_hashkey.keys():
1022         if hashkey.startswith("bot#"):
1023             players_by_hashkey[hashkey] = bot
1024             hashkeys.remove(hashkey)
1025         elif hashkey.startswith("player#"):
1026             players_by_hashkey[hashkey] = anon
1027             hashkeys.remove(hashkey)
1028
1029     # We are left with the "real" players and can now fetch them by their collective hashkeys.
1030     # Those that are returned here are pre-existing players who need to be updated.
1031     for p, hk in session.query(Player, Hashkey)\
1032             .filter(Player.player_id == Hashkey.player_id)\
1033             .filter(Hashkey.hashkey.in_(hashkeys))\
1034             .all():
1035                 log.debug("Found existing player {} with hashkey {}"
1036                           .format(p.player_id, hk.hashkey))
1037
1038                 player = update_player(session, p, events_by_hashkey[hk.hashkey])
1039                 players_by_hashkey[hk.hashkey] = player
1040                 hashkeys.remove(hk.hashkey)
1041
1042     # The remainder are the players we haven't seen before, so we need to create them.
1043     for hashkey in hashkeys:
1044         player = create_player(session, events_by_hashkey[hashkey])
1045
1046         log.debug("Created player {0} ({2}) with hashkey {1}"
1047                   .format(player.player_id, hashkey, player.nick.encode('utf-8')))
1048
1049         players_by_hashkey[hashkey] = player
1050
1051     return players_by_hashkey
1052
1053
1054 def create_frag_matrix(session, player_indexes, pgstat, events):
1055     """
1056     Construct a PlayerFragMatrix object from the events of a given player.
1057
1058     :param session: The DBSession we're adding objects to.
1059     :param player_indexes: The set of player indexes of those that actually played in the game.
1060     :param pgstat: The PlayerGameStat object of the player whose frag matrix we want to create.
1061     :param events: The raw player events of the above player.
1062     :return: PlayerFragMatrix
1063     """
1064     player_index = int(events.get("i", None))
1065
1066     # "kills-4" -> 4
1067     victim_index = lambda x: int(x.split("-")[1])
1068
1069     matrix = {victim_index(k): int(v) for (k, v) in events.items()
1070               if k.startswith("kills-") and victim_index(k) in player_indexes}
1071
1072     if len(matrix) > 0:
1073         pfm = PlayerGameFragMatrix(pgstat.game_id, pgstat.player_game_stat_id, pgstat.player_id,
1074                                    player_index, matrix)
1075
1076         session.add(pfm)
1077         return pfm
1078     else:
1079         return None
1080
1081
1082 def submit_stats(request):
1083     """
1084     Entry handler for POST stats submissions.
1085     """
1086     # placeholder for the actual session
1087     session = None
1088
1089     try:
1090         log.debug("\n----- BEGIN REQUEST BODY -----\n" + request.body +
1091                   "----- END REQUEST BODY -----\n\n")
1092
1093         (idfp, status) = verify_request(request)
1094         try:
1095             submission = Submission(request.body, request.headers)
1096         except:
1097             msg = "Invalid submission"
1098             log.debug(msg)
1099             raise pyramid.httpexceptions.HTTPUnprocessableEntity(
1100                 body=msg,
1101                 content_type="text/plain"
1102             )
1103
1104         do_precondition_checks(request.registry.settings, submission)
1105
1106         #######################################################################
1107         # Actual setup (inserts/updates) below here
1108         #######################################################################
1109         session = DBSession()
1110
1111         # All game types create Game, Server, Map, and Player records
1112         # the same way.
1113         server = get_or_create_server(
1114             session=session,
1115             hashkey=idfp,
1116             name=submission.server_name,
1117             revision=submission.revision,
1118             ip_addr=get_remote_addr(request),
1119             port=submission.port_number,
1120             impure_cvars=submission.impure_cvar_changes
1121         )
1122
1123         gmap = get_or_create_map(session, submission.map_name)
1124
1125         game = create_game(
1126             session=session,
1127             game_type_cd=submission.game_type_cd,
1128             mod=submission.mod,
1129             server_id=server.server_id,
1130             map_id=gmap.map_id,
1131             match_id=submission.match_id,
1132             start_dt=datetime.datetime.utcnow(),
1133             duration=submission.duration
1134         )
1135
1136         events_by_hashkey = {elem["P"]: elem for elem in submission.humans + submission.bots}
1137         players_by_hashkey = get_or_create_players(session, events_by_hashkey)
1138
1139         pgstats = []
1140         elo_pgstats = []
1141         player_ids = []
1142         hashkeys_by_player_id = {}
1143         for hashkey, player in players_by_hashkey.items():
1144             events = events_by_hashkey[hashkey]
1145
1146             pgstat = create_game_stat(session, game, gmap, player, events)
1147             pgstats.append(pgstat)
1148
1149             if should_do_frag_matrix(submission.game_type_cd):
1150                 create_frag_matrix(session, submission.player_indexes, pgstat, events)
1151
1152             # player ranking opt-out
1153             if 'r' in events and events['r'] == '0':
1154                 log.debug("Excluding player {} from ranking calculations (opt-out)"
1155                           .format(pgstat.player_id))
1156             else:
1157                 elo_pgstats.append(pgstat)
1158
1159             if player.player_id > 1:
1160                 create_anticheats(session, pgstat, game, player, events)
1161
1162             if player.player_id > 2:
1163                 player_ids.append(player.player_id)
1164                 hashkeys_by_player_id[player.player_id] = hashkey
1165
1166             if should_do_weapon_stats(submission.game_type_cd) and player.player_id > 1:
1167                 create_weapon_stats(session, submission.version, game, player, pgstat, events)
1168
1169         # player_ids for human players get stored directly on games for fast indexing
1170         game.players = player_ids
1171
1172         for events in submission.teams:
1173             create_team_stat(session, game, events)
1174
1175         if server.elo_ind and gametype_elo_eligible(submission.game_type_cd):
1176             ep = EloProcessor(session, game, elo_pgstats)
1177             ep.save(session)
1178             elos = ep.wip
1179         else:
1180             elos = {}
1181
1182         session.commit()
1183         log.debug('Success! Stats recorded.')
1184
1185         # ranks are fetched after we've done the "real" processing
1186         ranks = get_ranks(session, player_ids, submission.game_type_cd)
1187
1188         # plain text response
1189         request.response.content_type = 'text/plain'
1190
1191         return {
1192                 "now": calendar.timegm(datetime.datetime.utcnow().timetuple()),
1193                 "server": server,
1194                 "game": game,
1195                 "gmap": gmap,
1196                 "player_ids": player_ids,
1197                 "hashkeys": hashkeys_by_player_id,
1198                 "elos": elos,
1199                 "ranks": ranks,
1200         }
1201
1202     except Exception as e:
1203         if session:
1204             session.rollback()
1205         raise e