X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fxonstat.git;a=blobdiff_plain;f=xonstat%2Fviews%2Fsubmission.py;h=55e1fd73245c047c476a679496cb48971830b466;hp=fbfb960f1b455f9145c8bf320e1be53c84f503bc;hb=5a605fae688cc083f82227364014dd0e6b9e4988;hpb=11483abc82d6f88bc8dcc91f951fbeb65286e71e diff --git a/xonstat/views/submission.py b/xonstat/views/submission.py index fbfb960..55e1fd7 100644 --- a/xonstat/views/submission.py +++ b/xonstat/views/submission.py @@ -392,33 +392,14 @@ def get_remote_addr(request): return request.remote_addr -def num_real_players(player_events): - """ - 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) and played_in_game(events): - real_players += 1 - - return real_players - - def should_do_weapon_stats(game_type_cd): """True of the game type should record weapon stats. False otherwise.""" - return game_type_cd not in 'CTS' + return game_type_cd not in {'cts'} def gametype_elo_eligible(game_type_cd): """True of the game type should process Elos. False otherwise.""" - elo_game_types = ('duel', 'dm', 'ca', 'ctf', 'tdm', 'ka', 'ft') - - if game_type_cd in elo_game_types: - return True - else: - return False + return game_type_cd in {'duel', 'dm', 'ca', 'ctf', 'tdm', 'ka', 'ft'} def register_new_nick(session, player, new_nick): @@ -575,54 +556,50 @@ def get_or_create_server(session, name, hashkey, ip_addr, revision, port, impure return server -def get_or_create_map(session=None, name=None): +def get_or_create_map(session, name): """ 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: + maps = session.query(Map).filter_by(name=name).order_by(Map.map_id).all() + + if maps is None or len(maps) == 0: 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)) + log.debug("Created map id {}: {}".format(gmap.map_id, gmap.name)) + elif len(maps) == 1: + gmap = maps[0] + log.debug("Found map id {}: {}".format(gmap.map_id, gmap.name)) + else: + gmap = maps[0] + map_id_list = ", ".join(["{}".format(m.map_id) for m in maps]) + log.warn("Multiple maps found for {} ({})! Using the first one.".format(name, map_id_list)) return gmap -def create_game(session, start_dt, game_type_cd, server_id, map_id, - match_id, duration, mod, winner=None): +def create_game(session, game_type_cd, server_id, map_id, match_id, start_dt, duration, mod, + winner=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 + mod - mods in use during the game 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 + match_id - a unique match ID given by the server + start_dt - when the game started (datetime object) duration - how long the game lasted - mod - mods in use during the game + 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 = 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 game.mod = mod[:64] @@ -631,27 +608,25 @@ def create_game(session, start_dt, game_type_cd, server_id, map_id, # resolved. game.create_dt = start_dt - try: - game.duration = datetime.timedelta(seconds=int(round(float(duration)))) - except: - pass + game.duration = duration try: - session.query(Game).filter(Game.server_id==server_id).\ - filter(Game.match_id==match_id).one() + session.query(Game).filter(Game.server_id == server_id)\ + .filter(Game.match_id == match_id).one() log.debug("Error: game with same server and match_id found! Ignoring.") - # 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: + # if a game under the same server_id and match_id exists, this is a duplicate + msg = "Duplicate game (pre-existing match_id)" + log.debug(msg) + raise pyramid.httpexceptions.HTTPOk(body=msg, content_type="text/plain") + + except NoResultFound: # server_id/match_id combination not found. game is ok to insert session.add(game) session.flush() - log.debug("Created game id {0} on server {1}, map {2} at \ - {3}".format(game.game_id, - server_id, map_id, start_dt)) + log.debug("Created game id {} on server {}, map {} at {}" + .format(game.game_id, server_id, map_id, start_dt)) return game @@ -761,7 +736,7 @@ def create_default_game_stat(session, game_type_cd): return pgstat -def create_game_stat(session, game_meta, game, server, gmap, player, events): +def create_game_stat(session, game, gmap, player, events): """Game stats handler for all game types""" game_type_cd = game.game_type_cd @@ -778,11 +753,6 @@ def create_game_stat(session, game_meta, game, server, gmap, player, events): pgstat.rank = int(events.get('rank', None)) pgstat.scoreboardpos = int(events.get('scoreboardpos', pgstat.rank)) - if pgstat.nick != player.nick \ - and player.player_id > 2 \ - and pgstat.nick != 'Anonymous Player': - register_new_nick(session, player, pgstat.nick) - wins = False # gametype-specific stuff is handled here. if passed to us, we store it @@ -907,7 +877,7 @@ def create_team_stat(session, game, events): return teamstat -def create_weapon_stats(session, game_meta, game, player, pgstat, events): +def create_weapon_stats(session, version, game, player, pgstat, events): """Weapon stats handler for all game types""" pwstats = [] @@ -915,7 +885,6 @@ def create_weapon_stats(session, game_meta, game, player, pgstat, events): # To counteract this we divide the data by 2 only for # POSTs coming from version 1. try: - version = int(game_meta['V']) if version == 1: is_doubled = True log.debug('NOTICE: found a version 1 request, halving the weapon stats...') @@ -992,6 +961,87 @@ def get_ranks(session, player_ids, game_type_cd): return ranks +def update_player(session, player, events): + """ + Updates a player record using the latest information. + :param session: SQLAlchemy session + :param player: Player model representing what is in the database right now (before updates) + :param events: Dict of player events from the submission + :return: player + """ + nick = events.get('n', 'Anonymous Player')[:128] + if nick != player.nick and not nick.startswith("Anonymous Player"): + register_new_nick(session, player, nick) + + return player + + +def create_player(session, events): + """ + Creates a new player from the list of events. + :param session: SQLAlchemy session + :param events: Dict of player events from the submission + :return: Player + """ + player = Player() + session.add(player) + session.flush() + + nick = events.get('n', None) + if nick: + player.nick = nick[:128] + player.stripped_nick = strip_colors(qfont_decode(player.nick)) + else: + player.nick = "Anonymous Player #{0}".format(player.player_id) + player.stripped_nick = player.nick + + hk = Hashkey(player_id=player.player_id, hashkey=events.get('P', None)) + session.add(hk) + + return player + + +def get_or_create_players(session, events_by_hashkey): + hashkeys = set(events_by_hashkey.keys()) + players_by_hashkey = {} + + bot = session.query(Player).filter(Player.player_id == 1).one() + anon = session.query(Player).filter(Player.player_id == 2).one() + + # fill in the bots and anonymous players + for hashkey in events_by_hashkey.keys(): + if hashkey.startswith("bot#"): + players_by_hashkey[hashkey] = bot + hashkeys.remove(hashkey) + elif hashkey.startswith("player#"): + players_by_hashkey[hashkey] = anon + hashkeys.remove(hashkey) + + # We are left with the "real" players and can now fetch them by their collective hashkeys. + # Those that are returned here are pre-existing players who need to be updated. + for p, hk in session.query(Player, Hashkey)\ + .filter(Player.player_id == Hashkey.player_id)\ + .filter(Hashkey.hashkey.in_(hashkeys))\ + .all(): + log.debug("Found existing player {} with hashkey {}" + .format(p.player_id, hk.hashkey)) + + player = update_player(session, p, events_by_hashkey[hk.hashkey]) + players_by_hashkey[hk.hashkey] = player + hashkeys.remove(hk.hashkey) + + # The remainder are the players we haven't seen before, so we need to create them. + for hashkey in hashkeys: + player = create_player(session, events_by_hashkey[hashkey]) + + log.debug("Created player {0} ({2}) with hashkey {1}" + .format(player.player_id, hashkey, player.nick.encode('utf-8'))) + + players_by_hashkey[hashkey] = player + + return players_by_hashkey + + def submit_stats(request): """ Entry handler for POST stats submissions. @@ -1004,88 +1054,69 @@ def submit_stats(request): "----- END REQUEST BODY -----\n\n") (idfp, status) = verify_request(request) - (game_meta, raw_players, raw_teams) = parse_stats_submission(request.body) - revision = game_meta.get('R', 'unknown') - duration = game_meta.get('D', None) - - # only players present at the end of the match are eligible for stats - raw_players = filter(played_in_game, raw_players) - - do_precondition_checks(request, game_meta, raw_players) + submission = Submission(request.body, request.headers) - # the "duel" gametype is fake - if len(raw_players) == 2 \ - and num_real_players(raw_players) == 2 \ - and game_meta['G'] == 'dm': - game_meta['G'] = 'duel' + do_precondition_checks(request.registry.settings, submission) #---------------------------------------------------------------------- # Actual setup (inserts/updates) below here #---------------------------------------------------------------------- session = DBSession() - game_type_cd = game_meta['G'] - # All game types create Game, Server, Map, and Player records # the same way. server = get_or_create_server( - session = session, - hashkey = idfp, - name = game_meta['S'], - revision = revision, - ip_addr = get_remote_addr(request), - port = game_meta.get('U', None), - impure_cvars = game_meta.get('C', 0)) - - gmap = get_or_create_map( - session = session, - name = game_meta['M']) + session=session, + hashkey=idfp, + name=submission.server_name, + revision=submission.revision, + ip_addr=get_remote_addr(request), + port=submission.port_number, + impure_cvars=submission.impure_cvar_changes + ) + + gmap = get_or_create_map(session, submission.map_name) game = create_game( - session = session, - start_dt = datetime.datetime.utcnow(), - server_id = server.server_id, - game_type_cd = game_type_cd, - map_id = gmap.map_id, - match_id = game_meta['I'], - duration = duration, - mod = game_meta.get('O', None)) + session=session, + game_type_cd=submission.game_type_cd, + mod=submission.mod, + server_id=server.server_id, + map_id=gmap.map_id, + match_id=submission.match_id, + start_dt=datetime.datetime.utcnow(), + duration=submission.duration + ) + + events_by_hashkey = {elem["P"]: elem for elem in submission.humans + submission.bots} + get_or_create_players(session, game, gmap, events_by_hashkey) # keep track of the players we've seen player_ids = [] pgstats = [] hashkeys = {} - for events in raw_players: - player = get_or_create_player( - session = session, - hashkey = events['P'], - nick = events.get('n', None)) - - pgstat = create_game_stat(session, game_meta, game, server, - gmap, player, events) + for events in submission.humans + submission.bots: + player = get_or_create_player(session, events['P'], events.get('n', None)) + pgstat = create_game_stat(session, game, gmap, player, events) pgstats.append(pgstat) if player.player_id > 1: - anticheats = create_anticheats(session, pgstat, game, player, events) + create_anticheats(session, pgstat, game, player, events) if player.player_id > 2: player_ids.append(player.player_id) hashkeys[player.player_id] = events['P'] - if should_do_weapon_stats(game_type_cd) and player.player_id > 1: - pwstats = create_weapon_stats(session, game_meta, game, player, - pgstat, events) + if should_do_weapon_stats(submission.game_type_cd) and player.player_id > 1: + create_weapon_stats(session, submission.version, game, player, pgstat, events) # store them on games for easy access game.players = player_ids - for events in raw_teams: - try: - teamstat = create_team_stat(session, game, events) - except Exception as e: - raise e + for events in submission.teams: + create_team_stat(session, game, events) - if server.elo_ind and gametype_elo_eligible(game_type_cd): + if server.elo_ind and gametype_elo_eligible(submission.game_type_cd): ep = EloProcessor(session, game, pgstats) ep.save(session) @@ -1093,20 +1124,20 @@ def submit_stats(request): log.debug('Success! Stats recorded.') # ranks are fetched after we've done the "real" processing - ranks = get_ranks(session, player_ids, game_type_cd) + ranks = get_ranks(session, player_ids, submission.game_type_cd) # plain text response request.response.content_type = 'text/plain' return { - "now" : calendar.timegm(datetime.datetime.utcnow().timetuple()), - "server" : server, - "game" : game, - "gmap" : gmap, - "player_ids" : player_ids, - "hashkeys" : hashkeys, - "elos" : ep.wip, - "ranks" : ranks, + "now": calendar.timegm(datetime.datetime.utcnow().timetuple()), + "server": server, + "game": game, + "gmap": gmap, + "player_ids": player_ids, + "hashkeys": hashkeys, + "elos": ep.wip, + "ranks": ranks, } except Exception as e: