[git fast commit] 02. Feb 2019 - 22:23:29

NetworkListener.py

@@ -1,5 +1,6 @@
 import socket
 from threading import Thread
+import NetworkParser
 
 TCP_IP      = '127.0.0.1'
 TCP_PORT    = 7041
@@ -13,10 +14,9 @@ def listen():
     while True:
         conn, addr = s.accept();
         Thread(target=t_listen,args=(conn,)).start();
-        t_listen(conn);
 
 def t_listen(conn):
-    while True:
+    data = conn.recv(BUFFER_SIZE).decode('utf-8')
-        line = conn.recv(BUFFER_SIZE).decode('utf-8')
+    ret = NetworkParser.handleInput(data)
-        if not line:
+    conn.send(ret)
-            continue
+    conn.close()

NetworkParser.py

@@ -5,63 +5,34 @@ import StorrageBackend as SB
 from threading import Thread
 import PSQL
 
-TCP_IP      = '127.0.0.1'
+def handleInput(data):
-TCP_PORT    = 7051
-BUFFER_SIZE = 1024
-
-def listen():
-    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-    s.bind((TCP_IP, TCP_PORT))
-    s.listen(5)
-    while True:
-        conn, addr = s.accept()
-        Thread(target=t_listen_wrapper,args=(conn,)).start()
-
-def t_listen_wrapper(conn):
-        try:
-            t_listen(conn)
-        except RuntimeError as e:
-            conn.send(b'503 (Database not in sync)')
-        finally:
-            conn.close()
-
-
-def t_listen(conn):
         no_log_in_console = False
-
+        data, ident = get_event_ident(data)
-        data = conn.recv(BUFFER_SIZE)
-        data = str(data,'utf-8')
-        data,ident = get_event_ident(data)
         tmp = ''
 
-
         if data.startswith("quality,"):
             t1, t2 = parse_teams(data.lstrip("quality,"))
             tmp  = TS.quality(t1.values(),t2.values(),t1.keys(), t2.keys())
         elif data.startswith("balance,"):
             s    = data.lstrip("balance,")
             tmp  = TS.balance(parse_players(s), get_buddies(s))
-        elif data.startswith("balancelol,"):
-            s    = data.lstrip("balancelol,")
-            tmp  = TS.balance(parse_players(s,lol=True), get_buddies(s))
         elif data.startswith("player,"):
             # legacy format support
             p = Player.DummyPlayer(data.lstrip("player,").rstrip("\n"))
             tmp = TS.get_player_rating(p)
-        elif data.startswith("playerinfo,"):
-            tag, sid, name = data.split(",")
-            tmp = "RATING_SINGLE," + TS.get_player_rating_rich(sid, name)
         elif data.startswith("find,"):
             tmp = find_player(data.rstrip("\n").lstrip("find,"))
         elif data.startswith("buddies,"):
             tmp = str(get_buddies())
+        elif data.startswith("forceRankReload"):
+            SB.updatePlayerRanks(force=True)
+            tmp = "Updated"
         elif data.startswith("dump"):
             no_log_in_console = True
             topN = 0
             if "," in data:
                 topN = int(data.split(",")[1])
-            tmp = SB.dump_rating(topN)
+            tmp = SB.dumpRatings(topN)
         elif data.startswith("stats"):
             tmp = "Clean: {}\nDirty: {}\n".format(TS.clean_rounds,TS.dirty_rounds)
         elif data.startswith("getteam,"):
@@ -75,9 +46,7 @@ def t_listen(conn):
         ret = str(ident+str(tmp)).encode('utf-8')
         if not no_log_in_console and ret:
             print(ret)
-
+        return ret
-        conn.send(ret)
-        conn.close()
 
 def get_event_ident(data):
     if data.startswith("player_connected"):
@@ -218,6 +187,9 @@ def find_player(string):
         if string in SB.known_players:
             return TS.get_player_rating(string, string)
     else:
-       tmp = SB.fuzzy_find_player(string)
+        tmp = SB.fuzzy_find_player(string)
-       return TS.get_player_rating(tmp)
+        string = ""
-
+        for tup in tmp:
+            p = tup[1]
+            string += "{}\n".format(TS.get_player_rating(p, p.name))
+        return string

StorrageBackend.py

@@ -60,18 +60,20 @@ def sync_from_database(players):
         else:
             known_players.update({Player.DummyPlayer(p.steamid, p.name):Player.PlayerForDatabase(None,None,None,player=p)})
 
-def sync_to_database(players,win):
+def sync_to_database(players, win):
-    global last_rank_update
-    global player_ranks
-
     for p in players:
         known_players[p].rating = players[p]
         if win:
             known_players[p].wins += 1
         known_players[p].games += 1
+    updatePlayerRanks()
 
-    # update player ranks #
+
-    if last_rank_update - datetime.now() > timedelta(seconds=240):
+def updatePlayerRanks(force=False):
+    global last_rank_update
+    global player_ranks
+
+    if force or last_rank_update - datetime.now() > timedelta(seconds=240):
         last_rank_update = datetime.now()
         s = sorted(known_players.values(),key=lambda x: TS.get_env().expose(x.rating),reverse=True)
         rank = 1
@@ -105,5 +107,5 @@ def fuzzy_find_player(name):
                 tup_list += [(sim,p)]
         finally:
             TS.unlock()
-        return sorted(tup_list,key=lambda x: x[0],reverse=True)[0][1]
+        tmp = sorted(tup_list, key=lambda x: x[0], reverse=True)
-
+        return list(filter(lambda x: x[0] > 80, tmp))

TrueSkillWrapper.py

@@ -114,19 +114,11 @@ def balance(players, buddies=None):
             i += 1
         return ret
 
-def get_player_rating(p):
+def get_player_rating(sid, name="NOTFOUND"):
-        try:
-            p = StorrageBackend.known_players[p]
-            tmp = int(env.expose(p.rating))
-            return "Rating of '{}' : {} ({}% won)".format(p.name,tmp,p.winratio())
-        except KeyError:
-            return "No Rating (yet)."
-
-def get_player_rating(sid, name):
         try:
             p = StorrageBackend.known_players[sid]
             tmp = int(env.expose(p.rating))
-            return "Rating of '{}' : {} (Rank: {})".format(name, tmp, StorrageBackend.get_player_rank(p))
+            return "Rating of '{}' : {} (Rank: {})".format(p.name, tmp, StorrageBackend.get_player_rank(p))
         except KeyError:
             return "Rating of '{}' : No Rating (yet).".format(name)
 

startInsurgency.py

@@ -4,6 +4,7 @@ import NetworkParser
 import FileReader
 import argparse
 import StorrageBackend
+import NetworkListener
 
 parser = argparse.ArgumentParser(description='Insurgency rating python backend server')
 parser.add_argument('files', metavar='FILE', type=str, nargs='+',\
@@ -19,6 +20,7 @@ parser.add_argument('--no-follow','-nf',dest='nofollow', action='store_const',\
 parser.add_argument('--one-thread', dest='oneThread', action='store_const',\
                 const=True, default=False, \
                 help="run everything in main thread (implies no-follow)")
+
 if __name__ == "__main__":
         args = parser.parse_args()
         FileReader.readfiles( args.files ,\
@@ -29,6 +31,7 @@ if __name__ == "__main__":
             for l in StorrageBackend.dumpRatings().split("\n"):
                 print(l)
         if not args.parse_only:
-            Query.listen()
+            print("Starting network-listener")
+            NetworkListener.listen()
         else:
             sys.exit(0)