+import calendar
import datetime
import logging
-import os
-import pyramid.httpexceptions
import re
-import time
-import sqlalchemy.sql.expression as expr
-from calendar import timegm
-from pyramid.response import Response
+
+import pyramid.httpexceptions
from sqlalchemy import Sequence
from sqlalchemy.orm.exc import MultipleResultsFound, NoResultFound
from xonstat.elo import EloProcessor
-from xonstat.models import *
+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.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:
return pwstats
+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):
"""
Entry handler for POST stats submissions.
except Exception as e:
raise e
- if should_do_elos(game_type_cd):
+ 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.')
+ # 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" : timegm(datetime.datetime.utcnow().timetuple()),
+ "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:
projects / xonotic / xonstat.git / blobdiff