Webpage for resource allocation

qiita_db/meta_util.py

@@ -566,6 +566,7 @@ def get_software_commands(active):
 
         for command in commands:
             software_commands[sname][sversion].append(command.name)
+        software_commands[sname] = dict(software_commands[sname])
 
     return dict(software_commands)
 
@@ -587,7 +588,6 @@ def update_resource_allocation_redis(active=True):
     for sname, versions in scommands.items():
         for version, commands in versions.items():
             for cname in commands:
-
                 col_name = "samples * columns"
                 df = retrieve_resource_data(cname, sname, version, COLUMNS)
                 if len(df) == 0:

qiita_pet/handlers/resources.py

@@ -0,0 +1,135 @@
+
+from tornado.gen import coroutine, Task
+from tornado.web import authenticated, HTTPError
+import json
+import ast
+from .base_handlers import BaseHandler
+from qiita_core.qiita_settings import r_client
+from qiita_core.util import execute_as_transaction
+
+commands = 'resources:commands'
+default_col_name = "samples * columns"
+
+
+class ResourcesHandler(BaseHandler):
+    def check_admin(self):
+        if self.current_user.level != "admin":
+            raise HTTPError(403, reason="%s does not have access to portal "
+                            "editing!" % self.current_user.id)
+
+    @execute_as_transaction
+    def _get_resources(self, cname, sname, version, col_name, callback):
+        resources = {}
+        vals = [
+            ('img_mem', r_client.get),
+            ('img_time', r_client.get),
+            ('time', r_client.get),
+            ('title_mem', r_client.get),
+            ('title_time', r_client.get)
+        ]
+        for k, f in vals:
+            redis_key = 'resources$#%s$#%s$#%s$#%s:%s' % (cname, sname,
+                                                          version, col_name, k)
+            resources[k] = f(redis_key)
+        callback(resources)
+
+    @execute_as_transaction
+    def _get_commands(self, callback):
+        res = r_client.get(commands)
+        callback(res)
+
+    @authenticated
+    @coroutine
+    @execute_as_transaction
+    def get(self):
+        self.check_admin()
+        commands = yield Task(self._get_commands)
+
+        commands_str = commands.decode('utf-8')
+        commands_dict = ast.literal_eval(commands_str)
+        commands_json = json.dumps(commands_dict)
+
+        self.render('resources.html',
+                    img_mem=None, img_time=None,
+                    time=None,
+                    mk=None, ma=None, mb=None,
+                    mmodel=None, mreal=None,
+                    mcalc=None, mfail=None,
+                    tk=None, ta=None, tb=None,
+                    tmodel=None, treal=None,
+                    tcalc=None, tfail=None,
+                    commands=commands_json,
+                    initial_load=True)
+
+    @authenticated
+    @coroutine
+    @execute_as_transaction
+    def post(self):
+        try:
+            data = json.loads(self.request.body)
+            software = data.get('software')
+            version = data.get('version')
+            command = data.get('command')
+
+            resources = yield Task(self._get_resources, command, software,
+                                   version, default_col_name)
+
+            mcof, mmodel, mreal, mcalc, mfail = list(
+                map(lambda x: x.split(b": ")[1].strip().decode('utf-8'),
+                    resources['title_mem'].split(b"\n")))
+
+            tcof, tmodel, treal, tcalc, tfail = list(
+                map(lambda x: x.split(b": ")[1].strip().decode('utf-8'),
+                    resources['title_time'].split(b"\n")))
+
+            mk, ma, mb = mcof.split("||")
+            tk, ta, tb = tcof.split("||")
+
+            response_data = {
+                "status": "success",
+                "img_mem": resources[
+                    'img_mem'].decode('utf-8') if isinstance(
+                    resources['img_mem'], bytes) else resources['img_mem'],
+                "img_time": resources[
+                    'img_time'].decode('utf-8') if isinstance(
+                    resources['img_time'], bytes) else resources['img_time'],
+                "time": resources[
+                    'time'].decode('utf-8') if isinstance(
+                    resources['time'], bytes) else resources['time'],
+                "mk": mk, "ma": ma, "mb": mb,
+                "tk": tk, "ta": ta, "tb": tb,
+                "mmodel": mmodel, "mreal": mreal,
+                "mcalc": mcalc, "mfail": mfail,
+                "tcof": tcof,
+                "tmodel": tmodel, "treal": treal,
+                "tcalc": tcalc, "tfail": tfail,
+                "initial_load": False
+            }
+            self.write(json.dumps(response_data))
+
+        except json.JSONDecodeError:
+            self.set_status(400)
+            self.finish({"error": "Invalid JSON data"})
+        except Exception as e:
+            import traceback
+            print(traceback.format_exc())
+            if resources['title_mem'] is None:
+                response_data = {
+                    "status": "no_data",
+                    "img_mem": None,
+                    "img_time": None,
+                    "time": None,
+                    "mk": None, "ma": None, "mb": None,
+                    "tk": None, "ta": None, "tb": None,
+                    "mmodel": None, "mreal": None,
+                    "mcalc": None, "mfail": None,
+                    "tcof": None,
+                    "tmodel": None, "treal": None,
+                    "tcalc": None, "tfail": None,
+                    "initial_load": False
+                }
+                self.set_status(200)
+                self.write(json.dumps(response_data))
+            else:
+                self.set_status(500)
+                self.finish({"error": str(e)})