Merge branch 'master' of github.com:Determinant/piztor

1 files changed, 234 insertions, 0 deletions

diff --git a/misc/server/piztor_server.py b/misc/server/piztor_server.py
new file mode 100644
index 0000000..81805b3
--- /dev/null
+++ b/misc/server/piztor_server.py
@@ -0,0 +1,234 @@
+import sqlalchemy
+import SocketServer, socket, select
+import struct
+import os
+
+from sqlalchemy import create_engine
+from sqlalchemy import Column, Integer, String, Float
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from random import randint
+
+engine = create_engine('sqlite:///t.sqlite', echo = False)
+Base = declarative_base()
+Session = sessionmaker(bind=engine)
+
+def get_hex(data):
+    return "".join([hex(ord(c))[2:].zfill(2) for c in data])
+
+class PiztorError(Exception):
+    def __init__(self, msg):
+        self.err_msg = msg
+    def __str__(self, msg):
+        return self.err_msg
+
+class ConnectionError(PiztorError):
+    pass
+
+class ReqReadError(ConnectionError):
+    def __init__(self):
+        super(ReqReadError, self).__init__("Error while reading request")
+
+class ReqInvalidError(ConnectionError):
+    def __init__(self):
+        super(ReqInvalidError, self).__init__("Invalid request")
+
+class TokenInvalidError(ConnectionError):
+    def __init__(self):
+        super(TokenInvalidError, self).__init__("Invalid token")
+
+class DataManager(object):
+    def __init__(self, piz_srv):
+        self.piz_srv = piz_srv
+
+class UserManager(DataManager):
+
+    class User(Base):
+        __tablename__ = 'users'
+        id = Column(Integer, primary_key = True)
+        gid = Column(Integer)
+        username = Column(String)
+        password = Column(String)
+        token = Column(Integer)
+
+    def get_user_by_token(self, token):
+        session = Session()
+        User = UserManager.User
+        entries = session.query(User).filter(User.token == token).all()
+        if len(entries) == 0:
+            raise TokenInvalidError()
+        return entries[0]
+
+    def authentication_handle(self, opt_type, data):
+        print "Parsing User Data"
+        pos = -1
+        for i in xrange(0, len(data)):
+            if data[i] == '\0':
+                print i
+                if pos != -1:
+                    raise ReqInvalidError()
+                pos = i
+                break
+        if pos == -1:
+            raise ReqInvalidError()
+        username = data[0:pos]  
+        password = data[pos + 1:]
+
+        print "Trying to login with following info:"
+        print (username, password)
+        
+        session = Session()
+        entries = session.query(UserManager.User). \
+            filter(UserManager.User.username == username).all()
+        if len(entries) == 0:
+            return struct.pack("!BLB", 0, 0, 1)
+        entry = entries[0]
+        if entry.password != password:  # Auth failed
+            print "Login failed!"
+            return struct.pack("!BLB", 0, 0, 1)
+        else:                           # Succeeded
+            print "Logged in sucessfully!"
+            entry.token = randint(0, 2147483647)
+            session.commit()
+            return struct.pack("!BLB", 0, entry.token, 0)
+        
+
+class MesgManager(DataManager):
+    def mesg_sending_handle(self, opt_type, data):
+        print "Parsing Mesg Data"
+        try:
+            if len(data) < 8:
+                raise ReqInvalidError()
+            sender_token, recv_id = struct.unpack("!LL", data[:8])
+            msg = data[8:]
+            print (sender_token, recv_id, msg)
+            return struct.pack("!B", 1)
+        except struct.error:
+            raise ReqInvalidError()
+
+class LocationManager(DataManager):
+
+    class LocationInfo(Base):
+        __tablename__ = "location_info"
+        uid = Column(Integer, primary_key = True)
+        lat = Column(Float(precesion = 64))
+        lng = Column(Float(precesion = 64))
+        # More: last_update
+
+    def location_update_handle(self, opt_type, data):
+        print "Parsing a Location Update"
+        try:
+            if len(data) < 8:
+                raise ReqInvalidError()
+            sender_token, lat, lng = struct.unpack("!Ldd", data)
+            print "Updating location data with following info:"
+            print (sender_token, lat, lng)
+
+            user = self.piz_srv. \
+                    user_mgr.get_user_by_token(sender_token)
+            session = Session()
+            LInfo = LocationManager.LocationInfo
+            q = session.query(LInfo).filter(LInfo.uid == user.id)
+            entry = q.first()
+            entry.lat = lat
+            entry.lng = lng
+            session.commit()
+            print "Location update succeeded!"
+            return struct.pack("!BB", 2, 0)
+        except TokenInvalidError:
+            print "Location update failed!"
+            return struct.pack("!BB", 2, 1)
+        except struct.error:
+            raise ReqInvalidError()
+
+    def location_request_handle(self, opt_type, data):
+        print "Parsing a Location Request"
+        try:
+            if len(data) != 8:
+                raise ReqInvalidError()
+            sender_token, gid = struct.unpack("!LL", data)
+            print "Requesting location data with following info:"
+            print (sender_token, gid)
+            session = Session()
+            UInfo = UserManager.User
+            LInfo = LocationManager.LocationInfo
+            user_list = session.query(UInfo).filter(UInfo.gid == gid).all()
+            reply = struct.pack("!BL", 3, len(user_list))
+            for user in user_list:
+                loc = session.query(LInfo).filter(LInfo.uid == user.id).first()
+                reply += struct.pack("!Ldd", user.id, loc.lat, loc.lng)
+            print get_hex(reply)
+            return reply
+        except struct.error:
+            raise ReqInvalidError()
+
+class PiztorServer():
+
+
+    class GenericHandler(SocketServer.StreamRequestHandler):
+
+        def handle(self):
+            print self.piz_srv
+            sock = self.request
+            sock.settimeout(100)
+#           sock.setblocking(0)
+            data = ""
+            try:
+                while True:
+#                   ready = select.select([sock], [], [], 10)
+#                   if not ready[0]:
+#                       raise ReqReadError()
+                    buff = sock.recv(4096)
+                    if len(buff) == 0:
+                        break   # terminated
+                    else:
+                        data += buff
+                sock.shutdown(socket.SHUT_RD)
+    
+                print "Got the data:" + get_hex(data)
+    
+                if len(data) < 1: 
+                    print "invalid length"
+                    raise ReqInvalidError()
+                opt_id = struct.unpack("!B", data[0])[0]
+                print opt_id
+                reply = self.piz_srv.mgr_map[opt_id](opt_id, data[1:])
+                sock.sendall(reply)
+            finally:
+                sock.close()
+
+    class ForkingEchoServer(SocketServer.ForkingMixIn, SocketServer.TCPServer):
+        pass
+
+    def __init__(self, host, port):
+        PiztorServer.GenericHandler.piz_srv = self
+        srv = PiztorServer.ForkingEchoServer((host, port), 
+                                            PiztorServer.GenericHandler)
+        srv.request_queue_size = 100
+#        srv.timeout = 2
+        self.server = srv
+
+        self.user_mgr = UserManager(self)
+        self.mesg_mgr = MesgManager(self)
+        self.location_mgr = LocationManager(self)
+    
+        self.mgr_map = [ self.user_mgr.authentication_handle, 
+                    self.mesg_mgr.mesg_sending_handle, 
+                    self.location_mgr.location_update_handle,
+                    self.location_mgr.location_request_handle] 
+    
+        Base.metadata.create_all(engine)
+
+
+    def run(self):
+        try:
+            self.server.serve_forever()
+        except KeyboardInterrupt:
+            print "Exiting..."
+            self.server.shutdown() 
+            print "Server shutdown"
+
+if __name__ == "__main__":
+    
+    ps = PiztorServer("localhost", 9999)
+    ps.run()