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