+import calendar
import datetime
import logging
-import os
-import pyramid.httpexceptions
import re
-import time
-import sqlalchemy.sql.expression as expr
-from pyramid.response import Response
+
+import pyramid.httpexceptions
from sqlalchemy import Sequence
from sqlalchemy.orm.exc import MultipleResultsFound, NoResultFound
-from xonstat.elo import process_elos
-from xonstat.models import *
+from xonstat.elo import EloProcessor
+from xonstat.models import DBSession, Server, Map, Game, PlayerGameStat, PlayerWeaponStat
+from xonstat.models import PlayerRank, PlayerCaptime
+from xonstat.models import TeamGameStat, PlayerGameAnticheat, Player, Hashkey, PlayerNick
from xonstat.util import strip_colors, qfont_decode, verify_request, weapon_map
-
log = logging.getLogger(__name__)
return True
-def should_do_elos(game_type_cd):
+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')
session.add(player)
-def update_fastest_cap(session, player_id, game_id, map_id, captime):
+def update_fastest_cap(session, player_id, game_id, map_id, captime, mod):
"""
Check the fastest cap time for the player and map. If there isn't
one, insert one. If there is, check if the passed time is faster.
# then check to see if the new captime is faster
try:
cur_fastest_cap = session.query(PlayerCaptime).filter_by(
- player_id=player_id, map_id=map_id).one()
+ player_id=player_id, map_id=map_id, mod=mod).one()
# current captime is faster, so update
if captime < cur_fastest_cap.fastest_cap:
except NoResultFound, e:
# none exists, so insert
- cur_fastest_cap = PlayerCaptime(player_id, game_id, map_id, captime)
+ cur_fastest_cap = PlayerCaptime(player_id, game_id, map_id, captime,
+ mod)
session.add(cur_fastest_cap)
session.flush()
-def get_or_create_server(session, name, hashkey, ip_addr, revision, port,
- impure_cvars):
+def update_server(server, name, hashkey, ip_addr, port, revision, impure_cvars):
"""
- 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
- ip_addr - the IP address of the server
- revision - the xonotic revision number
- port - the port number of the server
- impure_cvars - the number of impure cvar changes
+ Updates the server in the given DB session, if needed.
+
+ :param server: The found server instance.
+ :param name: The incoming server name.
+ :param hashkey: The incoming server hashkey.
+ :param ip_addr: The incoming server IP address.
+ :param port: The incoming server port.
+ :param revision: The incoming server revision.
+ :param impure_cvars: The incoming number of impure server cvars.
+ :return: bool
"""
- server = None
-
+ # ensure the two int attributes are actually ints
try:
port = int(port)
except:
port = None
- try:
+ try:
impure_cvars = int(impure_cvars)
except:
impure_cvars = 0
- # finding by hashkey is preferred, but if not we will fall
- # back to using name only, which can result in dupes
- if hashkey is not None:
- servers = session.query(Server).\
- filter_by(hashkey=hashkey).\
- order_by(expr.desc(Server.create_dt)).limit(1).all()
-
- if len(servers) > 0:
- server = servers[0]
- log.debug("Found existing server {0} by hashkey ({1})".format(
- server.server_id, server.hashkey))
- else:
- servers = session.query(Server).\
- filter_by(name=name).\
- order_by(expr.desc(Server.create_dt)).limit(1).all()
+ updated = False
+ if name and server.name != name:
+ server.name = name
+ updated = True
+ if hashkey and server.hashkey != hashkey:
+ server.hashkey = hashkey
+ updated = True
+ if ip_addr and server.ip_addr != ip_addr:
+ server.ip_addr = ip_addr
+ updated = True
+ if port and server.port != port:
+ server.port = port
+ updated = True
+ if revision and server.revision != revision:
+ server.revision = revision
+ updated = True
+ if impure_cvars and server.impure_cvars != impure_cvars:
+ server.impure_cvars = impure_cvars
+ server.pure_ind = True if impure_cvars == 0 else False
+ updated = True
- if len(servers) > 0:
- server = servers[0]
- log.debug("Found existing server {0} by name".format(server.server_id))
+ return updated
- # still haven't found a server by hashkey or name, so we need to create one
- if server is None:
- 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))
- # detect changed fields
- if server.name != name:
- server.name = name
- session.add(server)
+def get_or_create_server(session, name, hashkey, ip_addr, revision, port, impure_cvars):
+ """
+ Find a server by name or create one if not found. Parameters:
- if server.hashkey != hashkey:
- server.hashkey = hashkey
- session.add(server)
+ session - SQLAlchemy database session factory
+ name - server name of the server to be found or created
+ hashkey - server hashkey
+ ip_addr - the IP address of the server
+ revision - the xonotic revision number
+ port - the port number of the server
+ impure_cvars - the number of impure cvar changes
+ """
+ servers_q = DBSession.query(Server).filter(Server.active_ind)
- if server.ip_addr != ip_addr:
- server.ip_addr = ip_addr
- session.add(server)
+ if hashkey:
+ # if the hashkey is provided, we'll use that
+ servers_q = servers_q.filter((Server.name == name) or (Server.hashkey == hashkey))
+ else:
+ # otherwise, it is just by name
+ servers_q = servers_q.filter(Server.name == name)
- if server.port != port:
- server.port = port
- session.add(server)
+ # order by the hashkey, which means any hashkey match will appear first if there are multiple
+ servers = servers_q.order_by(Server.hashkey, Server.create_dt).all()
- if server.revision != revision:
- server.revision = revision
+ if len(servers) == 0:
+ server = Server(name=name, hashkey=hashkey)
session.add(server)
+ session.flush()
+ log.debug("Created server {} with hashkey {}.".format(server.server_id, server.hashkey))
+ else:
+ server = servers[0]
+ if len(servers) == 1:
+ log.info("Found existing server {}.".format(server.server_id))
- if server.impure_cvars != impure_cvars:
- server.impure_cvars = impure_cvars
- if impure_cvars > 0:
- server.pure_ind = False
- else:
- server.pure_ind = True
+ elif len(servers) > 1:
+ server_id_list = ", ".join(["{}".format(s.server_id) for s in servers])
+ log.warn("Multiple servers found ({})! Using the first one ({})."
+ .format(server_id_list, server.server_id))
+
+ if update_server(server, name, hashkey, ip_addr, port, revision, impure_cvars):
session.add(server)
return server
game.match_id = match_id
game.mod = mod[:64]
+ # There is some drift between start_dt (provided by app) and create_dt
+ # (default in the database), so we'll make them the same until this is
+ # resolved.
+ game.create_dt = start_dt
+
try:
game.duration = datetime.timedelta(seconds=int(round(float(duration))))
except:
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):
+ if 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):
pgstat.fastest = datetime.timedelta(seconds=float(value)/100)
if game.game_type_cd == 'ctf':
update_fastest_cap(session, player.player_id, game.game_id,
- gmap.map_id, pgstat.fastest)
+ gmap.map_id, pgstat.fastest, game.mod)
# there is no "winning team" field, so we have to derive it
if wins and pgstat.team is not None and game.winner is None:
for (key,value) in events.items():
if key == 'scoreboard-score': teamstat.score = int(round(float(value)))
if key == 'scoreboard-caps': teamstat.caps = int(value)
+ if key == 'scoreboard-goals': teamstat.caps = int(value)
if key == 'scoreboard-rounds': teamstat.rounds = int(value)
session.add(teamstat)
return pwstats
-def create_elos(session, game):
- """Elo handler for all game types."""
- try:
- process_elos(game, session)
- except Exception as e:
- log.debug('Error (non-fatal): elo processing failed.')
+def get_ranks(session, player_ids, game_type_cd):
+ """
+ Gets the rank entries for all players in the given list, returning a dict
+ of player_id -> PlayerRank instance. The rank entry corresponds to the
+ game type of the parameter passed in as well.
+ """
+ ranks = {}
+ for pr in session.query(PlayerRank).\
+ filter(PlayerRank.player_id.in_(player_ids)).\
+ filter(PlayerRank.game_type_cd == game_type_cd).\
+ all():
+ ranks[pr.player_id] = pr
+
+ return ranks
def submit_stats(request):
# keep track of the players we've seen
player_ids = []
+ pgstats = []
+ hashkeys = {}
for events in raw_players:
player = get_or_create_player(
session = session,
pgstat = create_game_stat(session, game_meta, game, server,
gmap, player, events)
+ pgstats.append(pgstat)
if player.player_id > 1:
- anticheats = create_anticheats(session, pgstat, game, player,
- events)
+ anticheats = 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,
except Exception as e:
raise e
- if should_do_elos(game_type_cd):
- create_elos(session, game)
+ if server.elo_ind and gametype_elo_eligible(game_type_cd):
+ ep = EloProcessor(session, game, pgstats)
+ ep.save(session)
session.commit()
log.debug('Success! Stats recorded.')
- return Response('200 OK')
+
+ # ranks are fetched after we've done the "real" processing
+ ranks = get_ranks(session, player_ids, 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,
+ }
+
except Exception as e:
if session:
session.rollback()