-import datetime\r
-import logging\r
-import os\r
-import pyramid.httpexceptions\r
-import re\r
-import time\r
-from pyramid.response import Response\r
-from sqlalchemy import Sequence\r
-from sqlalchemy.orm.exc import MultipleResultsFound, NoResultFound\r
-from xonstat.d0_blind_id import d0_blind_id_verify\r
-from xonstat.models import *\r
-from xonstat.util import strip_colors, qfont_decode\r
-\r
-log = logging.getLogger(__name__)\r
-\r
-\r
-def is_blank_game(players):\r
- """Determine if this is a blank game or not. A blank game is either:\r
-\r
- 1) a match that ended in the warmup stage, where accuracy events are not\r
- present\r
-\r
- 2) a match in which no player made a positive or negative score AND was\r
- on the scoreboard\r
- """\r
- r = re.compile(r'acc-.*-cnt-fired')\r
- flg_nonzero_score = False\r
- flg_acc_events = False\r
-\r
- for events in players:\r
- if is_real_player(events):\r
- for (key,value) in events.items():\r
- if key == 'scoreboard-score' and value != '0':\r
- flg_nonzero_score = True\r
- if r.search(key):\r
- flg_acc_events = True\r
-\r
- return not (flg_nonzero_score and flg_acc_events)\r
-\r
-def get_remote_addr(request):\r
- """Get the Xonotic server's IP address"""\r
- if 'X-Forwarded-For' in request.headers:\r
- return request.headers['X-Forwarded-For']\r
- else:\r
- return request.remote_addr\r
-\r
-\r
-def is_supported_gametype(gametype):\r
- """Whether a gametype is supported or not"""\r
- flg_supported = True\r
-\r
- if gametype == 'cts' or gametype == 'lms':\r
- flg_supported = False\r
-\r
- return flg_supported\r
-\r
-\r
-def verify_request(request):\r
- try:\r
- (idfp, status) = d0_blind_id_verify(\r
- sig=request.headers['X-D0-Blind-Id-Detached-Signature'],\r
- querystring='',\r
- postdata=request.body)\r
-\r
- log.debug('\nidfp: {0}\nstatus: {1}'.format(idfp, status))\r
- except: \r
- idfp = None\r
- status = None\r
-\r
- return (idfp, status)\r
-\r
-\r
-def num_real_players(player_events, count_bots=False):\r
- """\r
- Returns the number of real players (those who played \r
- and are on the scoreboard).\r
- """\r
- real_players = 0\r
-\r
- for events in player_events:\r
- if is_real_player(events, count_bots):\r
- real_players += 1\r
-\r
- return real_players\r
-\r
-\r
-def has_minimum_real_players(settings, player_events):\r
- """\r
- Determines if the collection of player events has enough "real" players\r
- to store in the database. The minimum setting comes from the config file\r
- under the setting xonstat.minimum_real_players.\r
- """\r
- flg_has_min_real_players = True\r
-\r
- try:\r
- minimum_required_players = int(\r
- settings['xonstat.minimum_required_players'])\r
- except:\r
- minimum_required_players = 2\r
-\r
- real_players = num_real_players(player_events)\r
-\r
- #TODO: put this into a config setting in the ini file?\r
- if real_players < minimum_required_players:\r
- flg_has_min_real_players = False\r
-\r
- return flg_has_min_real_players\r
-\r
-\r
-def has_required_metadata(metadata):\r
- """\r
- Determines if a give set of metadata has enough data to create a game,\r
- server, and map with.\r
- """\r
- flg_has_req_metadata = True\r
-\r
- if 'T' not in metadata or\\r
- 'G' not in metadata or\\r
- 'M' not in metadata or\\r
- 'I' not in metadata or\\r
- 'S' not in metadata:\r
- flg_has_req_metadata = False\r
-\r
- return flg_has_req_metadata\r
-\r
-\r
-def is_real_player(events, count_bots=False):\r
- """\r
- Determines if a given set of player events correspond with a player who\r
-\r
- 1) is not a bot (P event does not look like a bot)\r
- 2) played in the game (matches 1)\r
- 3) was present at the end of the game (scoreboardvalid 1)\r
-\r
- Returns True if the player meets the above conditions, and false otherwise.\r
- """\r
- flg_is_real = False\r
-\r
- # removing 'joins' here due to bug, but it should be here\r
- if 'matches' in events and 'scoreboardvalid' in events:\r
- if (events['P'].startswith('bot') and count_bots) or \\r
- not events['P'].startswith('bot'):\r
- flg_is_real = True\r
-\r
- return flg_is_real\r
-\r
-\r
-def register_new_nick(session, player, new_nick):\r
- """\r
- Change the player record's nick to the newly found nick. Store the old\r
- nick in the player_nicks table for that player.\r
-\r
- session - SQLAlchemy database session factory\r
- player - player record whose nick is changing\r
- new_nick - the new nickname\r
- """\r
- # see if that nick already exists\r
- stripped_nick = strip_colors(player.nick)\r
- try:\r
- player_nick = session.query(PlayerNick).filter_by(\r
- player_id=player.player_id, stripped_nick=stripped_nick).one()\r
- except NoResultFound, e:\r
- # player_id/stripped_nick not found, create one\r
- # but we don't store "Anonymous Player #N"\r
- if not re.search('^Anonymous Player #\d+$', player.nick):\r
- player_nick = PlayerNick()\r
- player_nick.player_id = player.player_id\r
- player_nick.stripped_nick = player.stripped_nick\r
- player_nick.nick = player.nick\r
- session.add(player_nick)\r
-\r
- # We change to the new nick regardless\r
- player.nick = new_nick\r
- player.stripped_nick = strip_colors(new_nick)\r
- session.add(player)\r
-\r
-\r
-def get_or_create_server(session=None, name=None, hashkey=None, ip_addr=None,\r
- revision=None):\r
- """\r
- Find a server by name or create one if not found. Parameters:\r
-\r
- session - SQLAlchemy database session factory\r
- name - server name of the server to be found or created\r
- hashkey - server hashkey\r
- """\r
- try:\r
- # find one by that name, if it exists\r
- server = session.query(Server).filter_by(name=name).one()\r
-\r
- # store new hashkey\r
- if server.hashkey != hashkey:\r
- server.hashkey = hashkey\r
- session.add(server)\r
-\r
- # store new IP address\r
- if server.ip_addr != ip_addr:\r
- server.ip_addr = ip_addr\r
- session.add(server)\r
-\r
- # store new revision\r
- if server.revision != revision:\r
- server.revision = revision\r
- session.add(server)\r
-\r
- log.debug("Found existing server {0}".format(server.server_id))\r
-\r
- except MultipleResultsFound, e:\r
- # multiple found, so also filter by hashkey\r
- server = session.query(Server).filter_by(name=name).\\r
- filter_by(hashkey=hashkey).one()\r
- log.debug("Found existing server {0}".format(server.server_id))\r
-\r
- except NoResultFound, e:\r
- # not found, create one\r
- server = Server(name=name, hashkey=hashkey)\r
- session.add(server)\r
- session.flush()\r
- log.debug("Created server {0} with hashkey {1}".format(\r
- server.server_id, server.hashkey))\r
-\r
- return server\r
-\r
-\r
-def get_or_create_map(session=None, name=None):\r
- """\r
- Find a map by name or create one if not found. Parameters:\r
-\r
- session - SQLAlchemy database session factory\r
- name - map name of the map to be found or created\r
- """\r
- try:\r
- # find one by the name, if it exists\r
- gmap = session.query(Map).filter_by(name=name).one()\r
- log.debug("Found map id {0}: {1}".format(gmap.map_id, \r
- gmap.name))\r
- except NoResultFound, e:\r
- gmap = Map(name=name)\r
- session.add(gmap)\r
- session.flush()\r
- log.debug("Created map id {0}: {1}".format(gmap.map_id,\r
- gmap.name))\r
- except MultipleResultsFound, e:\r
- # multiple found, so use the first one but warn\r
- log.debug(e)\r
- gmaps = session.query(Map).filter_by(name=name).order_by(\r
- Map.map_id).all()\r
- gmap = gmaps[0]\r
- log.debug("Found map id {0}: {1} but found \\r
- multiple".format(gmap.map_id, gmap.name))\r
-\r
- return gmap\r
-\r
-\r
-def create_game(session=None, start_dt=None, game_type_cd=None, \r
- server_id=None, map_id=None, winner=None, match_id=None):\r
- """\r
- Creates a game. Parameters:\r
-\r
- session - SQLAlchemy database session factory\r
- start_dt - when the game started (datetime object)\r
- game_type_cd - the game type of the game being played\r
- server_id - server identifier of the server hosting the game\r
- map_id - map on which the game was played\r
- winner - the team id of the team that won\r
- """\r
- seq = Sequence('games_game_id_seq')\r
- game_id = session.execute(seq)\r
- game = Game(game_id=game_id, start_dt=start_dt, game_type_cd=game_type_cd,\r
- server_id=server_id, map_id=map_id, winner=winner)\r
- game.match_id = match_id\r
-\r
- try:\r
- session.query(Game).filter(Game.server_id==server_id).\\r
- filter(Game.match_id==match_id).one()\r
- # if a game under the same server and match_id found, \r
- # this is a duplicate game and can be ignored\r
- raise pyramid.httpexceptions.HTTPOk('OK')\r
- except NoResultFound, e:\r
- # server_id/match_id combination not found. game is ok to insert\r
- session.add(game)\r
- log.debug("Created game id {0} on server {1}, map {2} at \\r
- {3}".format(game.game_id, \r
- server_id, map_id, start_dt))\r
-\r
- return game\r
-\r
-\r
-def get_or_create_player(session=None, hashkey=None, nick=None):\r
- """\r
- Finds a player by hashkey or creates a new one (along with a\r
- corresponding hashkey entry. Parameters:\r
-\r
- session - SQLAlchemy database session factory\r
- hashkey - hashkey of the player to be found or created\r
- nick - nick of the player (in case of a first time create)\r
- """\r
- # if we have a bot\r
- if re.search('^bot#\d+$', hashkey) or re.search('^bot#\d+#', hashkey):\r
- player = session.query(Player).filter_by(player_id=1).one()\r
- # if we have an untracked player\r
- elif re.search('^player#\d+$', hashkey):\r
- player = session.query(Player).filter_by(player_id=2).one()\r
- # else it is a tracked player\r
- else:\r
- # see if the player is already in the database\r
- # if not, create one and the hashkey along with it\r
- try:\r
- hk = session.query(Hashkey).filter_by(\r
- hashkey=hashkey).one()\r
- player = session.query(Player).filter_by(\r
- player_id=hk.player_id).one()\r
- log.debug("Found existing player {0} with hashkey {1}".format(\r
- player.player_id, hashkey))\r
- except:\r
- player = Player()\r
- session.add(player)\r
- session.flush()\r
-\r
- # if nick is given to us, use it. If not, use "Anonymous Player"\r
- # with a suffix added for uniqueness.\r
- if nick:\r
- player.nick = nick[:128]\r
- player.stripped_nick = strip_colors(nick[:128])\r
- else:\r
- player.nick = "Anonymous Player #{0}".format(player.player_id)\r
- player.stripped_nick = player.nick\r
-\r
- hk = Hashkey(player_id=player.player_id, hashkey=hashkey)\r
- session.add(hk)\r
- log.debug("Created player {0} ({2}) with hashkey {1}".format(\r
- player.player_id, hashkey, player.nick.encode('utf-8')))\r
-\r
- return player\r
-\r
-def create_player_game_stat(session=None, player=None, \r
- game=None, player_events=None):\r
- """\r
- Creates game statistics for a given player in a given game. Parameters:\r
-\r
- session - SQLAlchemy session factory\r
- player - Player record of the player who owns the stats\r
- game - Game record for the game to which the stats pertain\r
- player_events - dictionary for the actual stats that need to be transformed\r
- """\r
-\r
- # in here setup default values (e.g. if game type is CTF then\r
- # set kills=0, score=0, captures=0, pickups=0, fckills=0, etc\r
- # TODO: use game's create date here instead of now()\r
- seq = Sequence('player_game_stats_player_game_stat_id_seq')\r
- pgstat_id = session.execute(seq)\r
- pgstat = PlayerGameStat(player_game_stat_id=pgstat_id, \r
- create_dt=datetime.datetime.utcnow())\r
-\r
- # set player id from player record\r
- pgstat.player_id = player.player_id\r
-\r
- #set game id from game record\r
- pgstat.game_id = game.game_id\r
-\r
- # all games have a score\r
- pgstat.score = 0\r
-\r
- if game.game_type_cd == 'dm' or game.game_type_cd == 'tdm' or game.game_type_cd == 'duel':\r
- pgstat.kills = 0\r
- pgstat.deaths = 0\r
- pgstat.suicides = 0\r
- elif game.game_type_cd == 'ctf':\r
- pgstat.kills = 0\r
- pgstat.captures = 0\r
- pgstat.pickups = 0\r
- pgstat.drops = 0\r
- pgstat.returns = 0\r
- pgstat.carrier_frags = 0\r
-\r
- for (key,value) in player_events.items():\r
- if key == 'n': pgstat.nick = value[:128]\r
- if key == 't': pgstat.team = value\r
- if key == 'rank': pgstat.rank = value\r
- if key == 'alivetime': \r
- pgstat.alivetime = datetime.timedelta(seconds=int(round(float(value))))\r
- if key == 'scoreboard-drops': pgstat.drops = value\r
- if key == 'scoreboard-returns': pgstat.returns = value\r
- if key == 'scoreboard-fckills': pgstat.carrier_frags = value\r
- if key == 'scoreboard-pickups': pgstat.pickups = value\r
- if key == 'scoreboard-caps': pgstat.captures = value\r
- if key == 'scoreboard-score': pgstat.score = value\r
- if key == 'scoreboard-deaths': pgstat.deaths = value\r
- if key == 'scoreboard-kills': pgstat.kills = value\r
- if key == 'scoreboard-suicides': pgstat.suicides = value\r
-\r
- # check to see if we had a name, and if\r
- # not use an anonymous handle\r
- if pgstat.nick == None:\r
- pgstat.nick = "Anonymous Player"\r
- pgstat.stripped_nick = "Anonymous Player"\r
-\r
- # otherwise process a nick change\r
- elif pgstat.nick != player.nick and player.player_id > 2:\r
- register_new_nick(session, player, pgstat.nick)\r
-\r
- # if the player is ranked #1 and it is a team game, set the game's winner\r
- # to be the team of that player\r
- # FIXME: this is a hack, should be using the 'W' field (not present)\r
- if pgstat.rank == '1' and pgstat.team:\r
- game.winner = pgstat.team\r
- session.add(game)\r
-\r
- session.add(pgstat)\r
-\r
- return pgstat\r
-\r
-\r
-def create_player_weapon_stats(session=None, player=None, \r
- game=None, pgstat=None, player_events=None):\r
- """\r
- Creates accuracy records for each weapon used by a given player in a\r
- given game. Parameters:\r
-\r
- session - SQLAlchemy session factory object\r
- player - Player record who owns the weapon stats\r
- game - Game record in which the stats were created\r
- pgstat - Corresponding PlayerGameStat record for these weapon stats\r
- player_events - dictionary containing the raw weapon values that need to be\r
- transformed\r
- """\r
- pwstats = []\r
-\r
- for (key,value) in player_events.items():\r
- matched = re.search("acc-(.*?)-cnt-fired", key)\r
- if matched:\r
- weapon_cd = matched.group(1)\r
- seq = Sequence('player_weapon_stats_player_weapon_stats_id_seq')\r
- pwstat_id = session.execute(seq)\r
- pwstat = PlayerWeaponStat()\r
- pwstat.player_weapon_stats_id = pwstat_id\r
- pwstat.player_id = player.player_id\r
- pwstat.game_id = game.game_id\r
- pwstat.player_game_stat_id = pgstat.player_game_stat_id\r
- pwstat.weapon_cd = weapon_cd\r
-\r
- if 'n' in player_events:\r
- pwstat.nick = player_events['n']\r
- else:\r
- pwstat.nick = player_events['P']\r
-\r
- if 'acc-' + weapon_cd + '-cnt-fired' in player_events:\r
- pwstat.fired = int(round(float(\r
- player_events['acc-' + weapon_cd + '-cnt-fired'])))\r
- if 'acc-' + weapon_cd + '-fired' in player_events:\r
- pwstat.max = int(round(float(\r
- player_events['acc-' + weapon_cd + '-fired'])))\r
- if 'acc-' + weapon_cd + '-cnt-hit' in player_events:\r
- pwstat.hit = int(round(float(\r
- player_events['acc-' + weapon_cd + '-cnt-hit'])))\r
- if 'acc-' + weapon_cd + '-hit' in player_events:\r
- pwstat.actual = int(round(float(\r
- player_events['acc-' + weapon_cd + '-hit'])))\r
- if 'acc-' + weapon_cd + '-frags' in player_events:\r
- pwstat.frags = int(round(float(\r
- player_events['acc-' + weapon_cd + '-frags'])))\r
-\r
- session.add(pwstat)\r
- pwstats.append(pwstat)\r
-\r
- return pwstats\r
-\r
-\r
-def parse_body(request):\r
- """\r
- Parses the POST request body for a stats submission\r
- """\r
- # storage vars for the request body\r
- game_meta = {}\r
- player_events = {}\r
- current_team = None\r
- players = []\r
-\r
- for line in request.body.split('\n'):\r
- try:\r
- (key, value) = line.strip().split(' ', 1)\r
-\r
- # Server (S) and Nick (n) fields can have international characters.\r
- # We convert to UTF-8.\r
- if key in 'S' 'n':\r
- value = unicode(value, 'utf-8')\r
-\r
- if key in 'V' 'T' 'G' 'M' 'S' 'C' 'R' 'W' 'I':\r
- game_meta[key] = value\r
-\r
- if key == 'P':\r
- # if we were working on a player record already, append\r
- # it and work on a new one (only set team info)\r
- if len(player_events) != 0:\r
- players.append(player_events)\r
- player_events = {}\r
-\r
- player_events[key] = value\r
-\r
- if key == 'e':\r
- (subkey, subvalue) = value.split(' ', 1)\r
- player_events[subkey] = subvalue\r
- if key == 'n':\r
- player_events[key] = value\r
- if key == 't':\r
- player_events[key] = value\r
- except:\r
- # no key/value pair - move on to the next line\r
- pass\r
-\r
- # add the last player we were working on\r
- if len(player_events) > 0:\r
- players.append(player_events)\r
-\r
- return (game_meta, players)\r
-\r
-\r
-def create_player_stats(session=None, player=None, game=None, \r
- player_events=None):\r
- """\r
- Creates player game and weapon stats according to what type of player\r
- """\r
- pgstat = create_player_game_stat(session=session, \r
- player=player, game=game, player_events=player_events)\r
-\r
- #TODO: put this into a config setting in the ini file?\r
- if not re.search('^bot#\d+$', player_events['P']):\r
- create_player_weapon_stats(session=session, \r
- player=player, game=game, pgstat=pgstat,\r
- player_events=player_events)\r
-\r
-\r
-def stats_submit(request):\r
- """\r
- Entry handler for POST stats submissions.\r
- """\r
- try:\r
- session = DBSession()\r
-\r
- log.debug("\n----- BEGIN REQUEST BODY -----\n" + request.body +\r
- "----- END REQUEST BODY -----\n\n")\r
-\r
- (idfp, status) = verify_request(request)\r
- if not idfp:\r
- log.debug("ERROR: Unverified request")\r
- raise pyramid.httpexceptions.HTTPUnauthorized("Unverified request")\r
-\r
- (game_meta, players) = parse_body(request) \r
-\r
- if not has_required_metadata(game_meta):\r
- log.debug("ERROR: Required game meta missing")\r
- raise pyramid.httpexceptions.HTTPUnprocessableEntity("Missing game meta")\r
-\r
- if not is_supported_gametype(game_meta['G']):\r
- log.debug("ERROR: Unsupported gametype")\r
- raise pyramid.httpexceptions.HTTPOk("OK")\r
-\r
- if not has_minimum_real_players(request.registry.settings, players):\r
- log.debug("ERROR: Not enough real players")\r
- raise pyramid.httpexceptions.HTTPOk("OK")\r
-\r
- if is_blank_game(players):\r
- log.debug("ERROR: Blank game")\r
- raise pyramid.httpexceptions.HTTPOk("OK")\r
-\r
- # the "duel" gametype is fake\r
- if num_real_players(players, count_bots=True) == 2 and \\r
- game_meta['G'] == 'dm':\r
- game_meta['G'] = 'duel'\r
-\r
-\r
- # fix for DTG, who didn't #ifdef WATERMARK to set the revision info\r
- try:\r
- revision = game_meta['R']\r
- except:\r
- revision = "unknown"\r
-\r
- server = get_or_create_server(session=session, hashkey=idfp, \r
- name=game_meta['S'], revision=revision,\r
- ip_addr=get_remote_addr(request))\r
-\r
- gmap = get_or_create_map(session=session, name=game_meta['M'])\r
-\r
- # FIXME: use the gmtime instead of utcnow() when the timezone bug is\r
- # fixed\r
- game = create_game(session=session, \r
- start_dt=datetime.datetime.utcnow(),\r
- #start_dt=datetime.datetime(\r
- #*time.gmtime(float(game_meta['T']))[:6]), \r
- server_id=server.server_id, game_type_cd=game_meta['G'], \r
- map_id=gmap.map_id, match_id=game_meta['I'])\r
-\r
- # find or create a record for each player\r
- # and add stats for each if they were present at the end\r
- # of the game\r
- for player_events in players:\r
- if 'n' in player_events:\r
- nick = player_events['n']\r
- else:\r
- nick = None\r
-\r
- if 'matches' in player_events and 'scoreboardvalid' \\r
- in player_events:\r
- player = get_or_create_player(session=session, \r
- hashkey=player_events['P'], nick=nick)\r
- log.debug('Creating stats for %s' % player_events['P'])\r
- create_player_stats(session=session, player=player, game=game, \r
- player_events=player_events)\r
-\r
- # update elos\r
- try:\r
- game.process_elos(session)\r
- except Exception as e:\r
- log.debug('Error (non-fatal): elo processing failed.')\r
-\r
- session.commit()\r
- log.debug('Success! Stats recorded.')\r
- return Response('200 OK')\r
- except Exception as e:\r
- session.rollback()\r
- return e\r
+import datetime
+import logging
+import os
+import pyramid.httpexceptions
+import re
+import time
+from pyramid.response import Response
+from sqlalchemy import Sequence
+from sqlalchemy.orm.exc import MultipleResultsFound, NoResultFound
+from xonstat.d0_blind_id import d0_blind_id_verify
+from xonstat.models import *
+from xonstat.util import strip_colors, qfont_decode
+
+log = logging.getLogger(__name__)
+
+
+def is_blank_game(players):
+ """Determine if this is a blank game or not. A blank game is either:
+
+ 1) a match that ended in the warmup stage, where accuracy events are not
+ present
+
+ 2) a match in which no player made a positive or negative score AND was
+ on the scoreboard
+ """
+ r = re.compile(r'acc-.*-cnt-fired')
+ flg_nonzero_score = False
+ flg_acc_events = False
+
+ for events in players:
+ if is_real_player(events):
+ for (key,value) in events.items():
+ if key == 'scoreboard-score' and value != '0':
+ flg_nonzero_score = True
+ if r.search(key):
+ flg_acc_events = True
+
+ return not (flg_nonzero_score and flg_acc_events)
+
+def get_remote_addr(request):
+ """Get the Xonotic server's IP address"""
+ if 'X-Forwarded-For' in request.headers:
+ return request.headers['X-Forwarded-For']
+ else:
+ return request.remote_addr
+
+
+def is_supported_gametype(gametype):
+ """Whether a gametype is supported or not"""
+ flg_supported = True
+
+ if gametype == 'cts' or gametype == 'lms':
+ flg_supported = False
+
+ return flg_supported
+
+
+def verify_request(request):
+ try:
+ (idfp, status) = d0_blind_id_verify(
+ sig=request.headers['X-D0-Blind-Id-Detached-Signature'],
+ querystring='',
+ postdata=request.body)
+
+ log.debug('\nidfp: {0}\nstatus: {1}'.format(idfp, status))
+ except:
+ idfp = None
+ status = None
+
+ return (idfp, status)
+
+
+def num_real_players(player_events, count_bots=False):
+ """
+ Returns the number of real players (those who played
+ and are on the scoreboard).
+ """
+ real_players = 0
+
+ for events in player_events:
+ if is_real_player(events, count_bots):
+ real_players += 1
+
+ return real_players
+
+
+def has_minimum_real_players(settings, player_events):
+ """
+ Determines if the collection of player events has enough "real" players
+ to store in the database. The minimum setting comes from the config file
+ under the setting xonstat.minimum_real_players.
+ """
+ flg_has_min_real_players = True
+
+ try:
+ minimum_required_players = int(
+ settings['xonstat.minimum_required_players'])
+ except:
+ minimum_required_players = 2
+
+ real_players = num_real_players(player_events)
+
+ #TODO: put this into a config setting in the ini file?
+ if real_players < minimum_required_players:
+ flg_has_min_real_players = False
+
+ return flg_has_min_real_players
+
+
+def has_required_metadata(metadata):
+ """
+ Determines if a give set of metadata has enough data to create a game,
+ server, and map with.
+ """
+ flg_has_req_metadata = True
+
+ if 'T' not in metadata or\
+ 'G' not in metadata or\
+ 'M' not in metadata or\
+ 'I' not in metadata or\
+ 'S' not in metadata:
+ flg_has_req_metadata = False
+
+ return flg_has_req_metadata
+
+
+def is_real_player(events, count_bots=False):
+ """
+ Determines if a given set of player events correspond with a player who
+
+ 1) is not a bot (P event does not look like a bot)
+ 2) played in the game (matches 1)
+ 3) was present at the end of the game (scoreboardvalid 1)
+
+ Returns True if the player meets the above conditions, and false otherwise.
+ """
+ flg_is_real = False
+
+ # removing 'joins' here due to bug, but it should be here
+ if 'matches' in events and 'scoreboardvalid' in events:
+ if (events['P'].startswith('bot') and count_bots) or \
+ not events['P'].startswith('bot'):
+ flg_is_real = True
+
+ return flg_is_real
+
+
+def register_new_nick(session, player, new_nick):
+ """
+ Change the player record's nick to the newly found nick. Store the old
+ nick in the player_nicks table for that player.
+
+ session - SQLAlchemy database session factory
+ player - player record whose nick is changing
+ new_nick - the new nickname
+ """
+ # see if that nick already exists
+ stripped_nick = strip_colors(player.nick)
+ try:
+ player_nick = session.query(PlayerNick).filter_by(
+ player_id=player.player_id, stripped_nick=stripped_nick).one()
+ except NoResultFound, e:
+ # player_id/stripped_nick not found, create one
+ # but we don't store "Anonymous Player #N"
+ if not re.search('^Anonymous Player #\d+$', player.nick):
+ player_nick = PlayerNick()
+ player_nick.player_id = player.player_id
+ player_nick.stripped_nick = player.stripped_nick
+ player_nick.nick = player.nick
+ session.add(player_nick)
+
+ # We change to the new nick regardless
+ player.nick = new_nick
+ player.stripped_nick = strip_colors(new_nick)
+ session.add(player)
+
+
+def get_or_create_server(session=None, name=None, hashkey=None, ip_addr=None,
+ revision=None):
+ """
+ Find a server by name or create one if not found. Parameters:
+
+ session - SQLAlchemy database session factory
+ name - server name of the server to be found or created
+ hashkey - server hashkey
+ """
+ try:
+ # find one by that name, if it exists
+ server = session.query(Server).filter_by(name=name).one()
+
+ # store new hashkey
+ if server.hashkey != hashkey:
+ server.hashkey = hashkey
+ session.add(server)
+
+ # store new IP address
+ if server.ip_addr != ip_addr:
+ server.ip_addr = ip_addr
+ session.add(server)
+
+ # store new revision
+ if server.revision != revision:
+ server.revision = revision
+ session.add(server)
+
+ log.debug("Found existing server {0}".format(server.server_id))
+
+ except MultipleResultsFound, e:
+ # multiple found, so also filter by hashkey
+ server = session.query(Server).filter_by(name=name).\
+ filter_by(hashkey=hashkey).one()
+ log.debug("Found existing server {0}".format(server.server_id))
+
+ except NoResultFound, e:
+ # not found, create one
+ server = Server(name=name, hashkey=hashkey)
+ session.add(server)
+ session.flush()
+ log.debug("Created server {0} with hashkey {1}".format(
+ server.server_id, server.hashkey))
+
+ return server
+
+
+def get_or_create_map(session=None, name=None):
+ """
+ Find a map by name or create one if not found. Parameters:
+
+ session - SQLAlchemy database session factory
+ name - map name of the map to be found or created
+ """
+ try:
+ # find one by the name, if it exists
+ gmap = session.query(Map).filter_by(name=name).one()
+ log.debug("Found map id {0}: {1}".format(gmap.map_id,
+ gmap.name))
+ except NoResultFound, e:
+ gmap = Map(name=name)
+ session.add(gmap)
+ session.flush()
+ log.debug("Created map id {0}: {1}".format(gmap.map_id,
+ gmap.name))
+ except MultipleResultsFound, e:
+ # multiple found, so use the first one but warn
+ log.debug(e)
+ gmaps = session.query(Map).filter_by(name=name).order_by(
+ Map.map_id).all()
+ gmap = gmaps[0]
+ log.debug("Found map id {0}: {1} but found \
+ multiple".format(gmap.map_id, gmap.name))
+
+ return gmap
+
+
+def create_game(session=None, start_dt=None, game_type_cd=None,
+ server_id=None, map_id=None, winner=None, match_id=None):
+ """
+ Creates a game. Parameters:
+
+ session - SQLAlchemy database session factory
+ start_dt - when the game started (datetime object)
+ game_type_cd - the game type of the game being played
+ server_id - server identifier of the server hosting the game
+ map_id - map on which the game was played
+ winner - the team id of the team that won
+ """
+ seq = Sequence('games_game_id_seq')
+ game_id = session.execute(seq)
+ game = Game(game_id=game_id, start_dt=start_dt, game_type_cd=game_type_cd,
+ server_id=server_id, map_id=map_id, winner=winner)
+ game.match_id = match_id
+
+ try:
+ session.query(Game).filter(Game.server_id==server_id).\
+ filter(Game.match_id==match_id).one()
+ # if a game under the same server and match_id found,
+ # this is a duplicate game and can be ignored
+ raise pyramid.httpexceptions.HTTPOk('OK')
+ except NoResultFound, e:
+ # server_id/match_id combination not found. game is ok to insert
+ session.add(game)
+ log.debug("Created game id {0} on server {1}, map {2} at \
+ {3}".format(game.game_id,
+ server_id, map_id, start_dt))
+
+ return game
+
+
+def get_or_create_player(session=None, hashkey=None, nick=None):
+ """
+ Finds a player by hashkey or creates a new one (along with a
+ corresponding hashkey entry. Parameters:
+
+ session - SQLAlchemy database session factory
+ hashkey - hashkey of the player to be found or created
+ nick - nick of the player (in case of a first time create)
+ """
+ # if we have a bot
+ if re.search('^bot#\d+$', hashkey) or re.search('^bot#\d+#', hashkey):
+ player = session.query(Player).filter_by(player_id=1).one()
+ # if we have an untracked player
+ elif re.search('^player#\d+$', hashkey):
+ player = session.query(Player).filter_by(player_id=2).one()
+ # else it is a tracked player
+ else:
+ # see if the player is already in the database
+ # if not, create one and the hashkey along with it
+ try:
+ hk = session.query(Hashkey).filter_by(
+ hashkey=hashkey).one()
+ player = session.query(Player).filter_by(
+ player_id=hk.player_id).one()
+ log.debug("Found existing player {0} with hashkey {1}".format(
+ player.player_id, hashkey))
+ except:
+ player = Player()
+ session.add(player)
+ session.flush()
+
+ # if nick is given to us, use it. If not, use "Anonymous Player"
+ # with a suffix added for uniqueness.
+ if nick:
+ player.nick = nick[:128]
+ player.stripped_nick = strip_colors(nick[:128])
+ else:
+ player.nick = "Anonymous Player #{0}".format(player.player_id)
+ player.stripped_nick = player.nick
+
+ hk = Hashkey(player_id=player.player_id, hashkey=hashkey)
+ session.add(hk)
+ log.debug("Created player {0} ({2}) with hashkey {1}".format(
+ player.player_id, hashkey, player.nick.encode('utf-8')))
+
+ return player
+
+def create_player_game_stat(session=None, player=None,
+ game=None, player_events=None):
+ """
+ Creates game statistics for a given player in a given game. Parameters:
+
+ session - SQLAlchemy session factory
+ player - Player record of the player who owns the stats
+ game - Game record for the game to which the stats pertain
+ player_events - dictionary for the actual stats that need to be transformed
+ """
+
+ # in here setup default values (e.g. if game type is CTF then
+ # set kills=0, score=0, captures=0, pickups=0, fckills=0, etc
+ # TODO: use game's create date here instead of now()
+ seq = Sequence('player_game_stats_player_game_stat_id_seq')
+ pgstat_id = session.execute(seq)
+ pgstat = PlayerGameStat(player_game_stat_id=pgstat_id,
+ create_dt=datetime.datetime.utcnow())
+
+ # set player id from player record
+ pgstat.player_id = player.player_id
+
+ #set game id from game record
+ pgstat.game_id = game.game_id
+
+ # all games have a score
+ pgstat.score = 0
+
+ if game.game_type_cd == 'dm' or game.game_type_cd == 'tdm' or game.game_type_cd == 'duel':
+ pgstat.kills = 0
+ pgstat.deaths = 0
+ pgstat.suicides = 0
+ elif game.game_type_cd == 'ctf':
+ pgstat.kills = 0
+ pgstat.captures = 0
+ pgstat.pickups = 0
+ pgstat.drops = 0
+ pgstat.returns = 0
+ pgstat.carrier_frags = 0
+
+ for (key,value) in player_events.items():
+ if key == 'n': pgstat.nick = value[:128]
+ if key == 't': pgstat.team = value
+ if key == 'rank': pgstat.rank = value
+ if key == 'alivetime':
+ pgstat.alivetime = datetime.timedelta(seconds=int(round(float(value))))
+ if key == 'scoreboard-drops': pgstat.drops = value
+ if key == 'scoreboard-returns': pgstat.returns = value
+ if key == 'scoreboard-fckills': pgstat.carrier_frags = value
+ if key == 'scoreboard-pickups': pgstat.pickups = value
+ if key == 'scoreboard-caps': pgstat.captures = value
+ if key == 'scoreboard-score': pgstat.score = value
+ if key == 'scoreboard-deaths': pgstat.deaths = value
+ if key == 'scoreboard-kills': pgstat.kills = value
+ if key == 'scoreboard-suicides': pgstat.suicides = value
+
+ # check to see if we had a name, and if
+ # not use an anonymous handle
+ if pgstat.nick == None:
+ pgstat.nick = "Anonymous Player"
+ pgstat.stripped_nick = "Anonymous Player"
+
+ # otherwise process a nick change
+ elif pgstat.nick != player.nick and player.player_id > 2:
+ register_new_nick(session, player, pgstat.nick)
+
+ # if the player is ranked #1 and it is a team game, set the game's winner
+ # to be the team of that player
+ # FIXME: this is a hack, should be using the 'W' field (not present)
+ if pgstat.rank == '1' and pgstat.team:
+ game.winner = pgstat.team
+ session.add(game)
+
+ session.add(pgstat)
+
+ return pgstat
+
+
+def create_player_weapon_stats(session=None, player=None,
+ game=None, pgstat=None, player_events=None):
+ """
+ Creates accuracy records for each weapon used by a given player in a
+ given game. Parameters:
+
+ session - SQLAlchemy session factory object
+ player - Player record who owns the weapon stats
+ game - Game record in which the stats were created
+ pgstat - Corresponding PlayerGameStat record for these weapon stats
+ player_events - dictionary containing the raw weapon values that need to be
+ transformed
+ """
+ pwstats = []
+
+ for (key,value) in player_events.items():
+ matched = re.search("acc-(.*?)-cnt-fired", key)
+ if matched:
+ weapon_cd = matched.group(1)
+ seq = Sequence('player_weapon_stats_player_weapon_stats_id_seq')
+ pwstat_id = session.execute(seq)
+ pwstat = PlayerWeaponStat()
+ pwstat.player_weapon_stats_id = pwstat_id
+ pwstat.player_id = player.player_id
+ pwstat.game_id = game.game_id
+ pwstat.player_game_stat_id = pgstat.player_game_stat_id
+ pwstat.weapon_cd = weapon_cd
+
+ if 'n' in player_events:
+ pwstat.nick = player_events['n']
+ else:
+ pwstat.nick = player_events['P']
+
+ if 'acc-' + weapon_cd + '-cnt-fired' in player_events:
+ pwstat.fired = int(round(float(
+ player_events['acc-' + weapon_cd + '-cnt-fired'])))
+ if 'acc-' + weapon_cd + '-fired' in player_events:
+ pwstat.max = int(round(float(
+ player_events['acc-' + weapon_cd + '-fired'])))
+ if 'acc-' + weapon_cd + '-cnt-hit' in player_events:
+ pwstat.hit = int(round(float(
+ player_events['acc-' + weapon_cd + '-cnt-hit'])))
+ if 'acc-' + weapon_cd + '-hit' in player_events:
+ pwstat.actual = int(round(float(
+ player_events['acc-' + weapon_cd + '-hit'])))
+ if 'acc-' + weapon_cd + '-frags' in player_events:
+ pwstat.frags = int(round(float(
+ player_events['acc-' + weapon_cd + '-frags'])))
+
+ session.add(pwstat)
+ pwstats.append(pwstat)
+
+ return pwstats
+
+
+def parse_body(request):
+ """
+ Parses the POST request body for a stats submission
+ """
+ # storage vars for the request body
+ game_meta = {}
+ player_events = {}
+ current_team = None
+ players = []
+
+ for line in request.body.split('\n'):
+ try:
+ (key, value) = line.strip().split(' ', 1)
+
+ # Server (S) and Nick (n) fields can have international characters.
+ # We convert to UTF-8.
+ if key in 'S' 'n':
+ value = unicode(value, 'utf-8')
+
+ if key in 'V' 'T' 'G' 'M' 'S' 'C' 'R' 'W' 'I':
+ game_meta[key] = value
+
+ if key == 'P':
+ # if we were working on a player record already, append
+ # it and work on a new one (only set team info)
+ if len(player_events) != 0:
+ players.append(player_events)
+ player_events = {}
+
+ player_events[key] = value
+
+ if key == 'e':
+ (subkey, subvalue) = value.split(' ', 1)
+ player_events[subkey] = subvalue
+ if key == 'n':
+ player_events[key] = value
+ if key == 't':
+ player_events[key] = value
+ except:
+ # no key/value pair - move on to the next line
+ pass
+
+ # add the last player we were working on
+ if len(player_events) > 0:
+ players.append(player_events)
+
+ return (game_meta, players)
+
+
+def create_player_stats(session=None, player=None, game=None,
+ player_events=None):
+ """
+ Creates player game and weapon stats according to what type of player
+ """
+ pgstat = create_player_game_stat(session=session,
+ player=player, game=game, player_events=player_events)
+
+ #TODO: put this into a config setting in the ini file?
+ if not re.search('^bot#\d+$', player_events['P']):
+ create_player_weapon_stats(session=session,
+ player=player, game=game, pgstat=pgstat,
+ player_events=player_events)
+
+
+def stats_submit(request):
+ """
+ Entry handler for POST stats submissions.
+ """
+ try:
+ session = DBSession()
+
+ log.debug("\n----- BEGIN REQUEST BODY -----\n" + request.body +
+ "----- END REQUEST BODY -----\n\n")
+
+ (idfp, status) = verify_request(request)
+ if not idfp:
+ log.debug("ERROR: Unverified request")
+ raise pyramid.httpexceptions.HTTPUnauthorized("Unverified request")
+
+ (game_meta, players) = parse_body(request)
+
+ if not has_required_metadata(game_meta):
+ log.debug("ERROR: Required game meta missing")
+ raise pyramid.httpexceptions.HTTPUnprocessableEntity("Missing game meta")
+
+ if not is_supported_gametype(game_meta['G']):
+ log.debug("ERROR: Unsupported gametype")
+ raise pyramid.httpexceptions.HTTPOk("OK")
+
+ if not has_minimum_real_players(request.registry.settings, players):
+ log.debug("ERROR: Not enough real players")
+ raise pyramid.httpexceptions.HTTPOk("OK")
+
+ if is_blank_game(players):
+ log.debug("ERROR: Blank game")
+ raise pyramid.httpexceptions.HTTPOk("OK")
+
+ # the "duel" gametype is fake
+ if num_real_players(players, count_bots=True) == 2 and \
+ game_meta['G'] == 'dm':
+ game_meta['G'] = 'duel'
+
+
+ # fix for DTG, who didn't #ifdef WATERMARK to set the revision info
+ try:
+ revision = game_meta['R']
+ except:
+ revision = "unknown"
+
+ server = get_or_create_server(session=session, hashkey=idfp,
+ name=game_meta['S'], revision=revision,
+ ip_addr=get_remote_addr(request))
+
+ gmap = get_or_create_map(session=session, name=game_meta['M'])
+
+ # FIXME: use the gmtime instead of utcnow() when the timezone bug is
+ # fixed
+ game = create_game(session=session,
+ start_dt=datetime.datetime.utcnow(),
+ #start_dt=datetime.datetime(
+ #*time.gmtime(float(game_meta['T']))[:6]),
+ server_id=server.server_id, game_type_cd=game_meta['G'],
+ map_id=gmap.map_id, match_id=game_meta['I'])
+
+ # find or create a record for each player
+ # and add stats for each if they were present at the end
+ # of the game
+ for player_events in players:
+ if 'n' in player_events:
+ nick = player_events['n']
+ else:
+ nick = None
+
+ if 'matches' in player_events and 'scoreboardvalid' \
+ in player_events:
+ player = get_or_create_player(session=session,
+ hashkey=player_events['P'], nick=nick)
+ log.debug('Creating stats for %s' % player_events['P'])
+ create_player_stats(session=session, player=player, game=game,
+ player_events=player_events)
+
+ # update elos
+ try:
+ game.process_elos(session)
+ except Exception as e:
+ log.debug('Error (non-fatal): elo processing failed.')
+
+ session.commit()
+ log.debug('Success! Stats recorded.')
+ return Response('200 OK')
+ except Exception as e:
+ session.rollback()
+ return e
projects / xonotic / xonstat.git / commitdiff