fixed #38

Author: blokhin

tests/berlinium/asleep_client.py

@@ -1,13 +1,18 @@
 #!/usr/bin/env python
+
+import sys
 import time
 import logging
+
 import websocket
-import json
+
+import ujson as json
 
 import set_path
 from tilde.core.settings import settings
 
-logging.basicConfig(level=logging.DEBUG)
+
+logging.basicConfig(level=logging.INFO)
 START_TIME = time.time()
 
 class RespHandler(object):
@@ -27,10 +32,12 @@ def on_message(self, ws, message):
         else:
             logging.info("Client done in: %1.2f sc" % (time.time() - START_TIME))
             ws.close()
+            sys.exit(0)
 
     @classmethod
     def on_error(self, ws, error):
         logging.debug(error)
+        sys.exit(1)
 
     @classmethod
     def on_close(self, ws):

tests/berlinium/asleep_server.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-import json
+
 import time
 import logging
 
@@ -9,30 +9,29 @@
 from sockjs.tornado import SockJSRouter
 
 import set_path
-from tilde.core.settings import settings, connect_database
+from tilde.core.settings import settings
 from tilde.core.api import API
-from tilde.berlinium.block_impl import Connection
+from tilde.berlinium import Async_Connection
 
 
-Tilde = API()
+logging.basicConfig(level=logging.INFO)
 
+Tilde = API()
 settings['debug_regime'] = False
-logging.basicConfig(level=logging.DEBUG)
 
 class SleepTester:
     @staticmethod
-    def login(req, session_id):
-        Connection.Clients[session_id].authorized = True
-        Connection.Clients[session_id].db = connect_database(settings, default_actions=False, scoped=True)
+    def login(req, client_id, db_session):
+        Connection.Clients[client_id].authorized = True
         return "OK", None
 
     @staticmethod
-    def sleep(req, session_id):
+    def sleep(req, client_id, db_session):
         result, error = '', None
         try: req = float(req)
         except: return result, 'Not a number!'
 
-        current_engine = Connection.Clients[session_id].db.get_bind()
+        current_engine = db_session.get_bind()
 
         if settings['db']['engine'] == 'postgresql':
             current_engine.execute(text('SELECT pg_sleep(:i)'), **{'i': req})
@@ -43,16 +42,18 @@ def sleep(req, session_id):
             c = conn.cursor()
             c.execute('SELECT sq_sleep(%s)' % req)
 
-        result = Tilde.count(Connection.Clients[session_id].db)
+        result = Tilde.count(db_session)
         return result, error
 
 if __name__ == "__main__":
+    Connection = Async_Connection
     Connection.GUIProvider = SleepTester
     DuplexRouter = SockJSRouter(Connection)
     application = web.Application(DuplexRouter.urls, debug=False)
     application.listen(settings['webport'], address='0.0.0.0')
 
-    logging.debug("Server started")
+    logging.info("DB is %s" % settings['db']['engine'])
+    logging.info("Connections are %s" % Connection.Type)
+    logging.info("Server started")
 
-    try: ioloop.IOLoop.instance().start()
-    except KeyboardInterrupt: pass
+    ioloop.IOLoop.instance().start()

tests/berlinium/asleep_test.py

@@ -1,17 +1,25 @@
 #!/usr/bin/env python
+
 import os, sys
 import time
 import subprocess
 
-
 if __name__ == "__main__":
-    bd = os.path.dirname(os.path.realpath(os.path.abspath(__file__)))
-    dmn = subprocess.Popen([sys.executable, os.path.join(bd, 'asleep_server.py')], env=os.environ.copy())
+    try:
+        prcnum = int(sys.argv[1])
+    except (IndexError, ValueError):
+        sys.exit("Usage: script #processes")
+
+    basedir = os.path.dirname(os.path.realpath(os.path.abspath(__file__)))
+    daemon = subprocess.Popen([sys.executable, os.path.join(basedir, 'asleep_server.py')])
     time.sleep(2) # wait for initialization
 
-    for i in range(5):
-        subprocess.Popen([sys.executable, os.path.join(bd, 'asleep_client.py')], env=os.environ.copy())
-        time.sleep(0.5)
+    children = []
+    for i in range(prcnum):
+        children.append( subprocess.Popen([sys.executable, os.path.join(basedir, 'asleep_client.py')]) )
+
+    time.sleep(prcnum + 2)
+    daemon.terminate()
 
-    time.sleep(7)
-    dmn.terminate()
+    for i in children:
+        assert i.poll() == 0

tests/berlinium/basic_client.py

@@ -1,6 +1,9 @@
 #!/usr/bin/env python
+
+import sys
 import time
 import logging
+
 import bcrypt
 import websocket
 
@@ -11,49 +14,45 @@
 from tilde.core.settings import settings
 
 
-logging.basicConfig(level=logging.DEBUG)
+logging.basicConfig(level=logging.INFO)
 
 START_TIME = time.time()
 
 USER, PASS = 'test', 'test'
 
 class RespHandler(object):
+    @classmethod
+    def on_error(self, ws, error):
+        logging.error(error)
+        sys.exit(1)
+
+    @classmethod
+    def on_close(self, ws):
+        logging.debug("Closed")
+        ws.close()
+
     @classmethod
     def on_open(self, ws):
         logging.debug("Opened")
         pwhash = bcrypt.hashpw(PASS, bcrypt.gensalt())
-        to_send = {'act': 'login', 'req': {'user': USER, 'pass': pwhash}}
-        ws.send(json.dumps(to_send))
+        ws.send(json.dumps({'act': 'login', 'req': {'user': USER, 'pass': pwhash}}))
 
     @classmethod
     def on_message(self, ws, message):
-        logging.info("Received: %s" % message[:100])
+        logging.debug("Received: %s" % message[:100])
         message = json.loads(message)
 
         if message['act'] == 'login':
             if message['result'] == 'OK':
-                to_send = {'act': 'tags', 'req': {'tids':0}}
-                ws.send(json.dumps(to_send))
+                ws.send(json.dumps({'act': 'sleep', 'req': 3}))
             else:
-                logging.info("Auth failed!")
-
-        elif message['act'] == 'tags':
-            logging.info(message['result'])
-            to_send = {'act': 'sleep', 'req': 4}
-            ws.send(json.dumps(to_send))
+                logging.error("Auth failed!")
+                sys.exit(1)
 
         elif message['act'] == 'sleep':
-            logging.info("Client done in: %1.2f sc" % (time.time() - START_TIME))
+            logging.info("Client done in %1.2f sc" % (time.time() - START_TIME))
             ws.close()
-
-    @classmethod
-    def on_error(self, ws, error):
-        logging.error(error)
-
-    @classmethod
-    def on_close(self, ws):
-        logging.debug("Closed")
-        ws.close()
+            sys.exit(0)
 
 
 if __name__ == "__main__":
@@ -63,4 +62,5 @@ def on_close(self, ws):
                                 on_message = RespHandler.on_message,
                                 on_error = RespHandler.on_error,
                                 on_close = RespHandler.on_close)
+    logging.debug("Started")
     ws.run_forever()

tests/berlinium/basic_server.py

@@ -1,4 +1,5 @@
 #!/usr/bin/env python
+
 import time
 import logging
 
@@ -8,10 +9,10 @@
 from sockjs.tornado import SockJSRouter
 
 import set_path
-from tilde.core.settings import settings, connect_database
+from tilde.core.settings import settings
 from tilde.core.api import API
 import tilde.core.model as model
-from tilde.berlinium import Connection, add_redirection
+from tilde.berlinium import Async_Connection, add_redirection
 
 
 logging.basicConfig(level=logging.INFO)
@@ -22,7 +23,7 @@
 
 class TildeGUIProvider:
     @staticmethod
-    def login(req, session_id):
+    def login(req, client_id, db_session):
         result, error = None, None
         if not isinstance(req, dict): return result, 'Invalid request!'
 
@@ -36,59 +37,25 @@ def login(req, session_id):
 
         if user != USER or not pass_match:
             return result, 'Unauthorized!'
-        Connection.Clients[session_id].authorized = True
-        Connection.Clients[session_id].db = connect_database(settings, default_actions=False, scoped=True)
-        return "OK", None
-
-    @staticmethod
-    def tags(req, session_id):
-        result, error = [], None
-        if not isinstance(req, dict): return result, 'Invalid request!'
-
-        if not 'tids' in req: tids = None # NB json may contain nulls
-        else: tids = req['tids']
-
-        if not tids:
-            for tid, cid, topic in Connection.Clients[session_id].db.query(model.uiTopic.tid, model.uiTopic.cid, model.uiTopic.topic).all():
-                # TODO assure there are checksums for every tid
-                try: match = [x for x in Tilde.hierarchy if x['cid'] == cid][0]
-                except IndexError: return None, 'Schema and data do not match: different versions of code and database?'
-
-                if not match.get('has_facet'): continue
-
-                sort = 1000 if not 'sort' in match else match['sort']
+        Connection.Clients[client_id].authorized = True
 
-                ready_topic = {'tid': tid, 'topic': topic, 'sort': 0}
-
-                for n, tag in enumerate(result):
-                    if tag['category'] == match['category']:
-                        result[n]['content'].append( ready_topic )
-                        break
-                else: result.append({'cid': match['cid'], 'category': match['category'], 'sort': sort, 'content': [ ready_topic ]})
-
-            result.sort(key=lambda x: x['sort'])
-            result = {'blocks': result, 'cats': Tilde.supercategories}
-
-        return result, error
+        return "OK", None
 
     @staticmethod
-    def sleep(req, session_id):
+    def sleep(req, client_id, db_session):
         result, error = '', None
         try: req = float(req)
         except: return result, 'Not a number!'
 
         time.sleep(req)
 
-        result = Tilde.count(Connection.Clients[session_id].db)
+        result = Tilde.count(db_session)
 
         return result, error
 
-    @staticmethod
-    def example(req, session_id):
-        result, error = '', None
-        return result, error
 
 if __name__ == "__main__":
+    Connection = Async_Connection # test with: select * from pg_stat_activity;
     Connection.GUIProvider = TildeGUIProvider
     DuplexRouter = SockJSRouter(Connection)
 
@@ -98,7 +65,9 @@ def example(req, session_id):
     )
     application.listen(settings['webport'], address='0.0.0.0')
 
-    logging.debug("Server started")
+    logging.info("DB is %s" % settings['db']['engine'])
+    logging.info("Connections are %s" % Connection.Type)
+    logging.info("Server started")
 
     try: ioloop.IOLoop.instance().start()
     except KeyboardInterrupt: pass

tests/berlinium/basic_test.py

@@ -1,17 +1,25 @@
 #!/usr/bin/env python
+
 import os, sys
 import time
 import subprocess
 
-
 if __name__ == "__main__":
-    bd = os.path.dirname(os.path.realpath(os.path.abspath(__file__)))
-    dmn = subprocess.Popen([sys.executable, os.path.join(bd, 'basic_server.py')], env=os.environ.copy())
+    try:
+        prcnum = int(sys.argv[1])
+    except (IndexError, ValueError):
+        sys.exit("Usage: script #processes")
+
+    basedir = os.path.dirname(os.path.realpath(os.path.abspath(__file__)))
+    daemon = subprocess.Popen([sys.executable, os.path.join(basedir, 'basic_server.py')])
     time.sleep(2) # wait for initialization
 
-    for i in range(5):
-        subprocess.Popen([sys.executable, os.path.join(bd, 'basic_client.py')], env=os.environ.copy())
-        time.sleep(0.5)
+    children = []
+    for i in range(prcnum):
+        children.append( subprocess.Popen([sys.executable, os.path.join(basedir, 'basic_client.py')]) )
+
+    time.sleep(prcnum + 2)
+    daemon.terminate()
 
-    time.sleep(7)
-    dmn.terminate()
+    for i in children:
+        assert i.poll() == 0