Data loading over socket.

dsst/dsst_server/data_access/mapping.py

@@ -0,0 +1,33 @@
+from dsst_server.data_access import sql
+from common import models
+
+
+def map_base_fields(cls, db_model):
+    model = cls()
+    attrs = [attr for attr in db_model._meta.fields]
+    for attr in attrs:
+        setattr(model, attr, getattr(db_model, attr))
+    return model
+
+
+def db_to_enemy(enemy: 'sql.Enemy'):
+    return map_base_fields(models.Enemy, enemy)
+
+
+def db_to_player(player: 'sql.Player'):
+    model = map_base_fields(models.Player, player)
+    return model
+
+
+def db_to_episode(episode: 'sql.Episode'):
+    model = map_base_fields(models.Episode, episode)
+    model.players = [db_to_player(player) for player in episode.players]
+    model.deaths = []
+    model.victories = []
+
+
+def db_to_season(season: 'sql.Season'):
+    model = map_base_fields(models.Season, season)
+    model.enemies = [db_to_enemy(enemy) for enemy in season.enemies]
+    model.episodes = [db_to_episode(ep) for ep in season.episodes]
+    return model

dsst/dsst_server/func_proxy.py

@@ -0,0 +1,6 @@
+from dsst_server.write_functions import WriteFunctions
+from dsst_server.read_functions import ReadFunctions
+
+
+class FunctionProxy(WriteFunctions, ReadFunctions):
+    pass

dsst/dsst_server/read_functions.py

@@ -0,0 +1,19 @@
+from dsst_server.data_access import sql, sql_func, mapping
+from common import models
+from playhouse import shortcuts
+
+
+class ReadFunctions:
+
+    @staticmethod
+    def load_seasons(*_):
+        return [mapping.db_to_season(season) for season in sql.Season.select()]
+
+    @staticmethod
+    def load_seasons_all(*_):
+        return [shortcuts.model_to_dict(season, backrefs=True, max_depth=2) for season in sql.Season.select()]
+
+    @staticmethod
+    def load_players(*_):
+        return [mapping.db_to_player(player) for player in sql.Player.select()]
+

dsst/dsst_server/server.py

@@ -1,8 +1,14 @@
 import pickle
 import socket
 
-from data_access import sql
+import sys
+
+import os
+
 from common import util, models
+from dsst_server import read_functions, write_functions
+from dsst_server.func_proxy import FunctionProxy
+from dsst_server.data_access import sql
 
 PORT = 12345
 HOST = socket.gethostname()
@@ -17,6 +23,13 @@ class DsstServer:
         self.socket_server.bind((HOST, PORT))
         print(f'Bound socket to {PORT} on host {HOST}')
 
+        self.read_actions = util.list_class_methods(read_functions.ReadFunctions)
+        self.write_actions = util.list_class_methods(write_functions.WriteFunctions)
+        sql.db.init('dsst', user='dsst', password='dsst')
+
+        self.key_access = {'a': self.read_actions,
+                           'b': self.read_actions + self.write_actions}
+
     def run(self):
         self.socket_server.listen(5)
         print('Socket is listening')
@@ -27,16 +40,39 @@ class DsstServer:
                 print(f'Connection from {address}')
                 data = util.recv_msg(client)
                 request = pickle.loads(data)
-                print(f'Received data: {request}')
-                dummy = models.Player()
-                dummy.name = 'Player 1'
-                dummy.hex_id = '0xC2'
-                dummy.deaths = [1, 2, 3]
-                util.send_msg(client, pickle.dumps(dummy))
+                print(f'Request: {request}')
+                # Validate auth key in request
+                key = request.get('auth_key')
+                if key not in self.key_access:
+                    util.send_msg(client, pickle.dumps({'success': False, 'message': 'Auth Key invalid'}))
+                    print(f'Rejected request from {address}. Auth key invalid ({key})')
+                    continue
+                # Check read functions
+                action_name = request.get('action')
+                if action_name in self.key_access[key]:
+                    action = getattr(FunctionProxy, action_name)
+                    value = action(request.get('args'))
+                    response = {'success': True, 'data': value}
+                    util.send_msg(client, pickle.dumps(response))
+                    continue
+                else:
+                    msg = f'Action does not exist on server ({request.get("action")})'
+                    util.send_msg(client, pickle.dumps({'success': False, 'message': msg}))
+            except Exception as e:
+                print(e)
             finally:
                 client.close()
                 print('Connection to client closed')
 
+
 if __name__ == '__main__':
     server = DsstServer()
-    server.run()
+    try:
+        server.run()
+    except KeyboardInterrupt:
+        print('Server stopped')
+        server.socket_server.close()
+        try:
+            sys.exit(0)
+        except SystemExit:
+            os._exit(0)

dsst/dsst_server/write_functions.py

@@ -0,0 +1,8 @@
+from common import models
+
+
+class WriteFunctions:
+
+    @staticmethod
+    def create_season(season: 'models.Season'):
+        return 'Season created.'