Complete class LAVA

	modified:   art_post_script.py

1 files changed, 70 insertions, 220 deletions

diff --git a/art_post_script.py b/art_post_script.py
index a09e841..6c13a06 100755
--- a/art_post_script.py
+++ b/art_post_script.py
@@ -69,6 +69,14 @@ class TestJobParseError(Exception):
         return repr(self.job_id)
 
 
+class RestRequestError(Exception):
+    def __init__(self, reason):
+        self.reason = reason
+
+    def __str__(self):
+        return repr(self.reason)
+
+
 class LinaroAndroidBuildSystem(object):
     def __init__(self, base_url, build_job,
                  username=None, password=None):
@@ -80,16 +88,17 @@ class LinaroAndroidBuildSystem(object):
         try:
             self.jenkins    = Jenkins(self.base_url, self.username, self.password)
             self.project    = self.jenkins[self.build_job]
-        except Exception as e:
-            logger.warning("Can not get Jenkins job: %s" % self.build_job)
+        except:
+            logger.error("Can not get Jenkins job: %s" % self.build_job)
+            raise
 
     def get_build(self, build_no):
         try:
             build = self.project.get_build(build_no)
             return build
-        except Exception as e:
+        except:
             logger.error("Can not get build: #%d" % build_no)
-            exit(-1)
+            raise
 
     def get_build_test_job_ids(self, build_no):
         logger.info("Querying build #%d test job ids from Jenkins build job: %s" % 
@@ -104,8 +113,10 @@ class LinaroAndroidBuildSystem(object):
         manifest_file_name = "pinned-manifest.xml"
         rest_url = "%s/job/%s/%d/artifact/%s" % (self.base_url, self.build_job, build_no, manifest_file_name)
         manifest = requests.get(rest_url, auth=(self.username, self.password))
-
-        return manifest.content
+        if manifest.status_code != 200:
+           raise RestRequestError("[%s] %s" % (manifest.status_code, manifest.reason))
+        else:
+            return manifest.content
 
     def get_build_gerrit_parameters(self, build_no):
         gerrit_param = { "GERRIT_CHANGE_ID": "",
@@ -113,12 +124,16 @@ class LinaroAndroidBuildSystem(object):
                          "GERRIT_CHANGE_NUMBER": "",
                          "GERRIT_CHANGE_URL": "" }
         rest_url = "%s/job/%s/%d/api/json" % (self.base_url, self.build_job, build_no)
+        req = requests.get(rest_url, auth=(self.username, self.password))
+        if req.status_code != 200:
+            raise RestRequestError("[%s] %s" % (manifest.status_code, manifest.reason))
+        else:
+            build_info = req.json()
         try:
-            req      = requests.get(rest_url, auth=(self.username, self.password)).json()
-            params   = (a['parameters'] for a in req['actions'] if 'parameters' in a).next()
+            params   = (a['parameters'] for a in build_info['actions'] if 'parameters' in a).next()
         except:
             logger.error("Can not get build: #%d parameters." % build_no)
-            exit(-1)
+            raise
         for p in params:
             if p['name'] in gerrit_param:
                 gerrit_param[p['name']] = p['value']
@@ -136,234 +151,64 @@ class LAVA(object):
             self.server      = xmlrpclib.ServerProxy(server_url)
         except:
             logger.warning("Can not connect to LAVA server: %s" % lava_server)
-            exit(-1)
+            raise
 
     def get_job_info(self, job_no):
-        job_info = {}
+        job_info = { "board": "",
+                     "board_config": "",
+                     "test_name": "",
+                     "test_result": [] }
         try:
             job_status      = self.server.scheduler.job_status(job_no)
-        except Exception as e:
+        except:
             logger.warning("Can not get any information for test job: %s" % job_no)
+            raise
 
         if job_status['job_status'] != 'Complete':
             logger.warning("!!Job #%s is not completed.\n\tJob status: %s!! " % (job_no, job_status['job_status']))
         else:
-            job_detail                  = self.server.scheduler.job_details(job_no)
-            job_info['job_no']          = job_no
-            job_info['result_link']     = job_detail['_results_link']
-            job_info['result_bundle']   = json.loads(self.server.dashboard.get(job_status['bundle_sha1'])['content'])
-            if any(t['test_id'] == 'bionic_libc_tests' for t in job_info['result_bundle']['test_runs']):
-                job_info['type']    = "lava_test"
-            elif any(t['test_id'] == 'cts-host' for t in job_info['result_bundle']['test_runs']):
-                job_info['type']    = "cts"
-            elif any(t['test_id'] == 'lava-android-benchmark-target' or t['test_id'] == 'wa2-host-postprocessing'
-                 for t in job_info['result_bundle']['test_runs']):
-                job_info['type']    = "benchmark"
+            result_bundle = json.loads(self.server.dashboard.get(job_status['bundle_sha1'])['content'])
+            try:
+                target = (t for t in result_bundle['test_runs'] if t['test_id'] == 'multinode-target' or
+                          t['test_id'] == 'lava-android-benchmark-target').next()
+                host = (t for t in result_bundle['test_runs'] if t['test_id'] == 'art-microbenchmarks' or
+                            t['test_id'] == 'lava-android-benchmark-host').next()
+            except:
+                logger.warning("Job #s seems not be a complete job, can not get test result" % job_no)
+                raise
+            # Get target device name
+            job_info['board']        = target['attributes']['target']
+            job_info['board_config'] = target['attributes']['target']
+            # Get test name
+            if host['test_id'] == 'lava-android-benchmark-host':
+                src = (s for s in host['software_context']['sources'] if 'test_params' in s).next()
+                job_info['test_name'] = ast.literal_eval(src['test_params'])['TEST_NAME']
             else:
-                job_info['type']    = "other"
-
-        return job_info
-
-
-class Report(object):
-    def __init__(self):
-        self.compiler_version       = "GCC 4.9\nGCC 4.8"
-        self.firmware_version       = "3.11"
-        self.android_version        = "5.1.1 Lollipop"
-        self.kernel_version         = "4.10.79"
-        self.cts_tests                    = {}
-        self.cts_tests['total_pkgs']      = 0
-        self.cts_tests['total_passed']    = 0
-        self.cts_tests['total_failed']    = 0
-        self.cts_tests['total_skipped']   = 0
-        self.cts_tests['total_pass_rate'] = 0
-        self.cts_tests['test_pkgs']       = []
-#        self.cts_tests = {
-#            "total_pkgs":     2000,
-#            "total_passed":   1950,
-#            "total_failed":   50,
-#            "total_pass_rate": 98,
-#            test_pkgs: [
-#               {"package_name": "android.app",
-#                "total": 100,
-#                "passed": 90,
-#                "failed": 5,
-#                "skipped": 5,
-#                "pass_rate": 85
-#               }
-#            ]
-#        }
-        self.lava_tests = {
-            "result_link": "",
-            "test_cases": []
-        }
-#        self.lava_tests = {
-#            "result_link": "RESULT BUNDLE URL",
-#            "test_cases": [
-#                {"test_id"  : "busybox",
-#                 "Pass"     : 12,
-#                 "Fail"     : 5,
-#                 "Skip"     : 5,
-#                 "Unknown"  : 5,
-#                 "failed_test_cases" : "ls, pwd"}
-#            ]
-#        }
-        self.benchmark_tests = []
-#        self.benchmark_tests = [
-#            {"test_id"  : "Pi",
-#             "status"   : "Pass",
-#             "result_link"    : "RESULT BUNDLE URL",
-#             "sub_tests": [
-#                    {"test_id"  : "Pi sub - 1",
-#                     "result"   : "Pass",
-#                     "score"    : "100ms"},
-#                    {"test_id"  : "Pi sub - 2",
-#                     "result"   : "Pass",
-#                     "score"    : "100ms"}
-#             ]
-#            }
-
-    def set_compiler_version(self, compiler_version):
-        #ToDo create similar method for each property
-        self.compiler_version = compiler_version
-
-    def set_firmware_version(self, firmware_version):
-        self.firmware_version = firmware_version
-
-    def set_android_version(self, android_version):
-        self.android_version = android_version
-
-    def set_kernel_version(self, kernel_version):
-        self.kernel_version = kernel_version
-
-    def parse_lava_test(self, job_info):
-        logger.info("Parsing lava test job #%s" % job_info['job_no'])
-        lava_tests  = {}
-        lava_tests['result_link'] = job_info['result_link']
-        lava_tests['test_cases']  = []
-        for test_run in job_info['result_bundle']['test_runs']:
-            if test_run['test_id'] == 'lava':
-                continue
-            # Count passed and failed test cases
-            test_case                      = {}
-            test_case['Pass']              = 0
-            test_case['Fail']              = 0
-            test_case['Skip']              = 0
-            test_case['Unknown']           = 0
-            test_case['failed_test_cases'] = ""
-            test_case['test_id']           = test_run['test_id']
-            for test_result in test_run['test_results']:
-                result = test_result['result'].title()
-                if(result == 'Fail'):
-                    test_case['failed_test_cases'] += "\n%s" % test_result['test_case_id']
-                exec("test_case['%s'] = test_case['%s'] + 1" % (result, result))
-            lava_tests['test_cases'].append(test_case)
-            self.lava_tests = lava_tests
-
-    def parse_benchmark_test(self, job_info):
-        logger.info("Parsing benchmark test job #%s" % job_info['job_no'])
-        benchmark_test = {}
-        sub_tests      = []
-        try:
-            test_run = (t for t in job_info['result_bundle']['test_runs']
-                        if t['test_id'] == 'lava-android-benchmark-host' or
-                           t['test_id'] == 'wa2-host-postprocessing').next()
-            src = (s for s in test_run['software_context']['sources'] if 'test_params' in s).next()
-        except Exception as e:
-            logger.warning("\tJob %s seems not be a completed job." % job_info['job_no'])
-            raise TestJobParseError(job_info['job_no'])
-
-        if test_run['test_id'] == 'lava-android-benchmark-host':
-            benchmark_test['test_id'] = ast.literal_eval(src['test_params'])['TEST_NAME']
-        else:
-            benchmark_test['test_id'] = ast.literal_eval(src['test_params'])['JOB_NAME']
-        benchmark_test['result_link']   = job_info['result_link']
-        for test in test_run['test_results']:
-            if not str(test['test_case_id']).startswith('lava-test-shell'):
-                test_case = {}
-                test_case['score']   = ""
-                test_case['test_id'] = test['test_case_id']
-                test_case['result']  = test['result'].upper()
-                if 'measurement' in test:
-                    test_case['score'] = "%s %s" % (test['measurement'], test['units'])
-                sub_tests.append(test_case)
-        if len(sub_tests) > 0:
-            benchmark_test['status'] = "PASS"
-        else:
-            benchmark_test['status'] = "FAIL"
-        benchmark_test['sub_tests'] = sub_tests
-    
-        self.benchmark_tests.append(benchmark_test)
+                job_info['test_name'] = host['test_id']
+            # Get test result
+            for t in host['test_results']:
+                if 'measurement' in t:
+                    test_case = { "name": t['test_case_id'],
+                                  "measurement" : t['measurement'] }
+                    job_info['test_result'].append(test_case)
+
+            return job_info
 
-    def parse_cts(self, job_info):
-        logger.info("Parsing cts test job #%s" % job_info['job_no'])
-        attachment = None
-        try:
-            test_run   = (r for r in job_info['result_bundle']['test_runs']
-                          if r['test_id'] == 'cts-host').next()
-            attachment = (a for a in test_run['attachments']
-                          if a['pathname'].startswith('android-cts')).next()
-        except Exception as e:
-            logger.warning("\tJob %s seems not be a completed job." % job_info['job_no'])
-            raise TestJobParseError(job_info['job_no'])
-
-        if attachment is not None:
-            try:
-                infile = StringIO(attachment['content'])
-                outfile = StringIO()
-                base64.decode(infile, outfile)
-                compressed = zipfile.ZipFile(outfile)
-                compressed.extractall()
-            except Exception as e:
-                logger.warning("\tCan not extract attachment: %s" % attachment['pathname'])
-            CTS_TEST_RESULT_DIR = "./%s" % attachment['pathname'].split('/')[-1].split('.zip')[0]
-            CTS_RESULT_FILE     = "%s/%s" % (CTS_TEST_RESULT_DIR, CTS_RESULT_FILE_NAME)
-            tree = ET.parse(CTS_RESULT_FILE)
-            root = tree.getroot()
-            for pkg in root.iter("TestPackage"):
-                cts_test = {}
-                cts_test['package_name'] = pkg.get('appPackageName')
-                cts_test['total']        = len(pkg.findall(".//Test"))
-                cts_test['passed']       = len(pkg.findall(".//Test[@result='pass']"))
-                cts_test['failed']       = len(pkg.findall(".//Test[@result='fail']"))
-                cts_test['skipped']      = len(pkg.findall(".//Test[@result='skip']"))
-                cts_test['pass_rate']    = 100 * cts_test['passed']/cts_test['total']
-                self.cts_tests['test_pkgs'].append(cts_test)
-            shutil.rmtree(CTS_TEST_RESULT_DIR)
-        else:
-            logger.warning("\tNo attachment in it")
-
-    def to_dict(self):
-        # Calculate numbers of CTS tests
-        for pkg in self.cts_tests['test_pkgs']:
-            self.cts_tests['total_pkgs']    += pkg['total']
-            self.cts_tests['total_passed']  += pkg['passed']
-            self.cts_tests['total_failed']  += pkg['failed']
-            self.cts_tests['total_skipped'] += pkg['skipped']
-        if self.cts_tests['total_pkgs'] != 0:
-            self.cts_tests['total_pass_rate'] = 100 * self.cts_tests['total_passed']/self.cts_tests['total_pkgs']
-
-        return {
-            "kernel_version"        : self.kernel_version,
-            "compiler_version"      : self.compiler_version,
-            "firmware_version"      : self.firmware_version,
-            "android_version"       : self.android_version,
-            "cts_tests"             : self.cts_tests,
-            "lava_tests"            : self.lava_tests,
-            "benchmark_tests"       : self.benchmark_tests
-        }
 
 if __name__ == '__main__':
 
     # Replace these authentication credential with environment variables
+    # Define them by ourselves
     JENKINS_USERNAME = "arthur.she@linaro.org"
-    JENKINS_PASSWORD = ""
+    JENKINS_PASSWORD = "iamsir321"
     LAVA_USERNAME    = "arthur.she"
-    LAVA_TOKEN       = ""
+    LAVA_TOKEN       = "a6eajjn85bp11n87u30oaxb11ewn687843btsdw63wc3gt10t72rqj4x3bi0bd0czuqotz8rp2w3moa5gja5r03u920f0duux10z78t7fcdslqi8omaxtnsgttgfcfs7"
 
     parser          = argparse.ArgumentParser()
     parser.add_argument("-u", "--build-url", dest="build_url", required=True,
                         help="Specify the Jenkins build job url. This is MANDATORY.")
+    parser.add_argument("-db", "--backend-db", dest="backend_db", required=True,
+                        help="Specify the backend database url. This is MANDATORY.")
 
     args = parser.parse_args()
 
@@ -373,15 +218,20 @@ if __name__ == '__main__':
         url = args.build_url
     ul = url.split('/')
     jenkins_build_number = ul[-2]
+#    jenkins_build_number = 1000
     jenkins_project      = ul[-3]
     jenkins_base_url     = '/'.join(ul[:-4])
 
     logger.info("build_no: %s\nproj: %s\nbase_url: %s" % (jenkins_build_number, jenkins_project, jenkins_base_url))
 
-    jenkins = LinaroAndroidBuildSystem(jenkins_base_url, jenkins_project, JENKINS_USERNAME, JENKINS_PASSWORD)
-    test_job_ids = jenkins.get_build_test_job_ids(int(jenkins_build_number))
+    try:
+        jenkins = LinaroAndroidBuildSystem(jenkins_base_url, jenkins_project, JENKINS_USERNAME, JENKINS_PASSWORD)
+        test_job_ids = jenkins.get_build_test_job_ids(int(jenkins_build_number))
+    except Exception as e:
+        print e
+        exit(-1)
     print(test_job_ids)
     gerrit_param = jenkins.get_build_gerrit_parameters(int(jenkins_build_number))
     print(gerrit_param)
-    man = jenkins.get_build_manifest(int(jenkins_build_number))
-    print(man)
+#    man = jenkins.get_build_manifest(int(jenkins_build_number))
+#    print(man)