Merge "Record test case names when run a task using API"

7 files changed, 85 insertions, 66 deletions

diff --git a/api/database/handlers.py b/api/database/handlers.py
new file mode 100644
index 000000000..42979b529
--- /dev/null
+++ b/api/database/handlers.py
@@ -0,0 +1,31 @@
+##############################################################################
+# Copyright (c) 2016 Huawei Technologies Co.,Ltd and others.
+#
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Apache License, Version 2.0
+# which accompanies this distribution, and is available at
+# http://www.apache.org/licenses/LICENSE-2.0
+##############################################################################
+from api.database import db_session
+from api.database.models import Tasks
+
+
+class TasksHandler(object):
+
+    def insert(self, kwargs):
+        task = Tasks(**kwargs)
+        db_session.add(task)
+        db_session.commit()
+        return task
+
+    def update_status(self, task, status):
+        task.status = status
+        db_session.commit()
+
+    def update_error(self, task, error):
+        task.error = error
+        db_session.commit()
+
+    def get_task_by_taskid(self, task_id):
+        task = Tasks.query.filter_by(task_id=task_id).first()
+        return task
diff --git a/api/resources/release_action.py b/api/resources/release_action.py
index fda0ffd32..d4dc246ef 100644
--- a/api/resources/release_action.py
+++ b/api/resources/release_action.py
@@ -23,8 +23,8 @@ def runTestCase(args):
     except KeyError:
         return common_utils.error_handler('Lack of testcase argument')
 
-    testcase = os.path.join(conf.TEST_CASE_PATH,
-                            conf.TEST_CASE_PRE + testcase + '.yaml')
+    testcase_name = conf.TEST_CASE_PRE + testcase
+    testcase = os.path.join(conf.TEST_CASE_PATH, testcase_name + '.yaml')
 
     task_id = str(uuid.uuid4())
 
@@ -33,6 +33,10 @@ def runTestCase(args):
     logger.debug('The command_list is: %s', command_list)
 
     logger.debug('Start to execute command list')
-    common_utils.exec_command_task(command_list, task_id)
+    task_dict = {
+        'task_id': task_id,
+        'details': testcase_name
+    }
+    common_utils.exec_command_task(command_list, task_dict)
 
     return common_utils.result_handler('success', task_id)
diff --git a/api/resources/results.py b/api/resources/results.py
index 3de09fdc9..fd518958c 100644
--- a/api/resources/results.py
+++ b/api/resources/results.py
@@ -8,11 +8,10 @@
 ##############################################################################
 import logging
 import uuid
-import re
 
 from api.utils import influx as influx_utils
 from api.utils import common as common_utils
-from api import conf
+from api.database.handlers import TasksHandler
 
 logger = logging.getLogger(__name__)
 
@@ -23,39 +22,36 @@ def default(args):
 
 def getResult(args):
     try:
-        measurement = args['measurement']
         task_id = args['task_id']
 
-        if re.search("[^a-zA-Z0-9_-]", measurement):
-            raise ValueError('invalid measurement parameter')
-
         uuid.UUID(task_id)
     except KeyError:
-        message = 'measurement and task_id must be provided'
+        message = 'task_id must be provided'
         return common_utils.error_handler(message)
 
-    query_template = "select * from %s where task_id='%s'"
-    query_sql = query_template % ('tasklist', task_id)
-    data = common_utils.translate_to_str(influx_utils.query(query_sql))
+    task = TasksHandler().get_task_by_taskid(task_id)
 
     def _unfinished():
         return common_utils.result_handler(0, [])
 
     def _finished():
-        query_sql = query_template % (conf.TEST_CASE_PRE + measurement,
-                                      task_id)
-        data = common_utils.translate_to_str(influx_utils.query(query_sql))
-        if not data:
-            query_sql = query_template % (measurement, task_id)
+        testcases = task.details.split(',')
+
+        def get_data(testcase):
+            query_template = "select * from %s where task_id='%s'"
+            query_sql = query_template % (testcase, task_id)
             data = common_utils.translate_to_str(influx_utils.query(query_sql))
+            return data
+
+        result = {k: get_data(k) for k in testcases}
 
-        return common_utils.result_handler(1, data)
+        return common_utils.result_handler(1, result)
 
     def _error():
-        return common_utils.result_handler(2, data[0]['error'])
+        return common_utils.result_handler(2, task.error)
 
     try:
-        status = data[0]['status']
+        status = task.status
 
         switcher = {
             0: _unfinished,
diff --git a/api/resources/samples_action.py b/api/resources/samples_action.py
index 545447aec..df6db17ee 100644
--- a/api/resources/samples_action.py
+++ b/api/resources/samples_action.py
@@ -19,11 +19,11 @@ logger = logging.getLogger(__name__)
 def runTestCase(args):
     try:
         opts = args.get('opts', {})
-        testcase = args['testcase']
+        testcase_name = args['testcase']
     except KeyError:
         return common_utils.error_handler('Lack of testcase argument')
 
-    testcase = os.path.join(conf.SAMPLE_PATH, testcase + '.yaml')
+    testcase = os.path.join(conf.SAMPLE_PATH, testcase_name + '.yaml')
 
     task_id = str(uuid.uuid4())
 
@@ -32,6 +32,10 @@ def runTestCase(args):
     logger.debug('The command_list is: %s', command_list)
 
     logger.debug('Start to execute command list')
-    common_utils.exec_command_task(command_list, task_id)
+    task_dict = {
+        'task_id': task_id,
+        'details': testcase_name
+    }
+    common_utils.exec_command_task(command_list, task_dict)
 
     return common_utils.result_handler('success', task_id)
diff --git a/api/utils/common.py b/api/utils/common.py
index e3e64a72b..6971c6dfe 100644
--- a/api/utils/common.py
+++ b/api/utils/common.py
@@ -40,8 +40,8 @@ def get_command_list(command_list, opts, args):
     return command_list
 
 
-def exec_command_task(command_list, task_id):   # pragma: no cover
-    daemonthread = DaemonThread(YardstickCLI().api, (command_list, task_id))
+def exec_command_task(command_list, task_dict):   # pragma: no cover
+    daemonthread = DaemonThread(YardstickCLI().api, (command_list, task_dict))
     daemonthread.start()
 
 
diff --git a/api/utils/daemonthread.py b/api/utils/daemonthread.py
index 47c0b9108..19182c429 100644
--- a/api/utils/daemonthread.py
+++ b/api/utils/daemonthread.py
@@ -8,11 +8,10 @@
 ##############################################################################
 import threading
 import os
-import datetime
 import errno
 
 from api import conf
-from api.utils.influx import write_data_tasklist
+from api.database.handlers import TasksHandler
 
 
 class DaemonThread(threading.Thread):
@@ -21,19 +20,24 @@ class DaemonThread(threading.Thread):
         super(DaemonThread, self).__init__(target=method, args=args)
         self.method = method
         self.command_list = args[0]
-        self.task_id = args[1]
+        self.task_dict = args[1]
 
     def run(self):
-        timestamp = datetime.datetime.now()
+        self.task_dict['status'] = 0
+        task_id = self.task_dict['task_id']
 
         try:
-            write_data_tasklist(self.task_id, timestamp, 0)
-            self.method(self.command_list, self.task_id)
-            write_data_tasklist(self.task_id, timestamp, 1)
+            task_handler = TasksHandler()
+            task = task_handler.insert(self.task_dict)
+
+            self.method(self.command_list, task_id)
+
+            task_handler.update_status(task, 1)
         except Exception as e:
-            write_data_tasklist(self.task_id, timestamp, 2, error=str(e))
+            task_handler.update_status(task, 2)
+            task_handler.update_error(task, str(e))
         finally:
-            _handle_testsuite_file(self.task_id)
+            _handle_testsuite_file(task_id)
 
 
 def _handle_testsuite_file(task_id):
diff --git a/api/utils/influx.py b/api/utils/influx.py
index 9366ed3e9..d4b070fb4 100644
--- a/api/utils/influx.py
+++ b/api/utils/influx.py
@@ -7,10 +7,10 @@
 # http://www.apache.org/licenses/LICENSE-2.0
 ##############################################################################
 import logging
+import ConfigParser
 from urlparse import urlsplit
 
 from influxdb import InfluxDBClient
-import ConfigParser
 
 from api import conf
 
@@ -21,46 +21,26 @@ def get_data_db_client():
     parser = ConfigParser.ConfigParser()
     try:
         parser.read(conf.OUTPUT_CONFIG_FILE_PATH)
-        dispatcher = parser.get('DEFAULT', 'dispatcher')
 
-        if 'influxdb' != dispatcher:
+        if 'influxdb' != parser.get('DEFAULT', 'dispatcher'):
             raise RuntimeError
 
-        ip = _get_ip(parser.get('dispatcher_influxdb', 'target'))
-        username = parser.get('dispatcher_influxdb', 'username')
-        password = parser.get('dispatcher_influxdb', 'password')
-        db_name = parser.get('dispatcher_influxdb', 'db_name')
-        return InfluxDBClient(ip, conf.PORT, username, password, db_name)
+        return _get_client(parser)
     except ConfigParser.NoOptionError:
         logger.error('can not find the key')
         raise
 
 
-def _get_ip(url):
-    return urlsplit(url).hostname
+def _get_client(parser):
+    ip = _get_ip(parser.get('dispatcher_influxdb', 'target'))
+    username = parser.get('dispatcher_influxdb', 'username')
+    password = parser.get('dispatcher_influxdb', 'password')
+    db_name = parser.get('dispatcher_influxdb', 'db_name')
+    return InfluxDBClient(ip, conf.PORT, username, password, db_name)
 
 
-def _write_data(measurement, field, timestamp, tags):
-    point = {
-        'measurement': measurement,
-        'fields': field,
-        'time': timestamp,
-        'tags': tags
-    }
-
-    try:
-        client = get_data_db_client()
-
-        logger.debug('Start to write data: %s', point)
-        client.write_points([point])
-    except RuntimeError:
-        logger.debug('dispatcher is not influxdb')
-
-
-def write_data_tasklist(task_id, timestamp, status, error=''):
-    field = {'status': status, 'error': error}
-    tags = {'task_id': task_id}
-    _write_data('tasklist', field, timestamp, tags)
+def _get_ip(url):
+    return urlsplit(url).hostname
 
 
 def query(query_sql):