Make change to actually upload to app engine.

tools/testing/perf_testing/run_perf_tests.py

 #!/usr/bin/python
 
 # Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 # for details. All rights reserved. Use of this source code is governed by a
 # BSD-style license that can be found in the LICENSE file.
 
 import datetime
 import math             
 try:            
   from matplotlib.font_manager import FontProperties            
@@ skipping 254 matching lines @@
     suites = []
     for name in self.suite_names:
       suites += [TestBuilder.make_test(name, self)]
 
     if not self.no_build and self.sync_and_build(suites) == 1:
       return # The build is broken.
 
     for test in suites:
       test.run()
 
+    if not self.no_upload:
+      self.upload_to_app_engine(TestBuilder.available_suite_names())
+
 
 class Test(object):
   """The base class to provide shared code for different tests we will run and
   graph. At a high level, each test has three visitors (the tester, the
   file_processor and the grapher) that perform operations on the test object."""
 
   def __init__(self, result_folder_name, platform_list, variants,
                values_list, test_runner, tester, file_processor, grapher,
                extra_metrics=['Geo-Mean'], build_targets=['create_sdk']):
     """Args:
@@ skipping 392 matching lines @@
               '--timeout', '600', '--mode', 'perf'], self.test.trace_file, 
               append=True)
 
   class CommonBrowserFileProcessor(Processor):
     def process_file(self, afile):
       """Comb through the html to find the performance results.
       Returns: True if we successfully posted our data to storage and/or we can
           delete the trace file."""
       os.chdir(os.path.join(DART_INSTALL_LOCATION, 'tools',
                             'testing', 'perf_testing'))
-      if self.test.test_runner.no_upload:
-        return
       parts = afile.split('-')
       browser = parts[2]
       version = parts[3]
       f = open(os.path.join(self.test.result_folder_name, afile))
       lines = f.readlines()
       line = ''
       i = 0
       revision_num = 0
       while '<div id="results">' not in line and i < len(lines):
         if 'Revision' in line:
@@ skipping 19 matching lines @@
         name_and_score = result.split(':')
         if len(name_and_score) < 2:
           break
         name = name_and_score[0].strip()
         score = name_and_score[1].strip()
         if version == 'js' or version == 'v8':
           version = 'js'
         bench_dict = self.test.values_dict[browser][version]
         bench_dict[name] += [float(score)]
         self.test.revision_dict[browser][version][name] += [revision_num]
-        if self.should_report_results(afile):
+        if self.should_report_results(afile) and \
+            not self.test.test_runner.no_upload:
           upload_success = upload_success and self.report_results(
               name, score, browser, version, revision_num, self.SCORE)
         else:
           upload_success = False
 
       f.close()
       self.calculate_geometric_mean(browser, version, revision_num)
       return upload_success
 
 
@@ skipping 125 matching lines @@
         version = version.replace('frog', 'dart')
       version = version.replace('_','&')
       tags = DromaeoTester.get_valid_dromaeo_tags()
       return '|'.join([ '%s&%s' % (version, tag) for tag in tags])
 
 
   class DromaeoFileProcessor(Processor):
     def process_file(self, afile):
       """Comb through the html to find the performance results.
       Returns: True if we successfully posted our data to storage."""
-      if self.test.test_runner.no_upload:
-        return
       parts = afile.split('-')
       browser = parts[2]
       version = parts[3]
 
       bench_dict = self.test.values_dict[browser][version]
 
       f = open(os.path.join(self.test.result_folder_name, afile))
       lines = f.readlines()
       i = 0
       revision_num = 0
@@ skipping 13 matching lines @@
           for suite_result in suite_results:
             results = re.findall(r'<li>(.*?)</li>', suite_result)
             if results:
               for result in results:
                 r = re.match(result_pattern, result)
                 name = DromaeoTester.legalize_filename(r.group(1).strip(':'))
                 score = float(r.group(2))
                 bench_dict[name] += [float(score)]
                 self.test.revision_dict[browser][version][name] += \
                     [revision_num]
-                if self.should_report_results(afile):
+                if self.should_report_results(afile) and \
+                    not self.test.test_runner.no_upload:
                   upload_success = upload_success and self.report_results(
                       name, score, browser, version, revision_num, self.SCORE)
                 else:
                   upload_success = False
 
       f.close()
       self.calculate_geometric_mean(browser, version, revision_num)
       return upload_success
 
 
@@ skipping 80 matching lines @@
 
   class DromaeoSizeProcessor(Processor):
     def process_file(self, afile):
       """Pull all the relevant information out of a given tracefile.
 
       Args:
         afile: is the filename string we will be processing.
       Returns: True if we successfully posted our data to storage."""
       os.chdir(os.path.join(DART_INSTALL_LOCATION, 'tools',
           'testing', 'perf_testing'))
-      if self.test.test_runner.no_upload:
-        return
       f = open(os.path.join(self.test.result_folder_name, afile))
       tabulate_data = False
       revision_num = 0
       revision_pattern = r'Revision: (\d+)'
       result_pattern = r'Size \((\w+), ([a-zA-Z0-9-]+)\): (\d+)'
 
       upload_success = True
       for line in f.readlines():
         rev = re.match(revision_pattern, line.strip())
         if rev:
           revision_num = int(rev.group(1))
           continue
 
         result = re.match(result_pattern, line.strip())
         if result:
           variant = result.group(1)
           metric = result.group(2)
           num = result.group(3)
           if num.find('.') == -1:
             num = int(num)
           else:
             num = float(num)
           self.test.values_dict['commandline'][variant][metric] += [num]
           self.test.revision_dict['commandline'][variant][metric] += \
               [revision_num]
-          if self.should_report_results(afile):
+          if self.should_report_results(afile) and \
+              not self.test.test_runner.no_upload:
             upload_success = upload_success and self.report_results(
                 metric, num, 'commandline', variant, revision_num,
                 self.CODE_SIZE)
           else:
             upload_success = False
 
       f.close()
       return upload_success
 
   class DromaeoSizeGrapher(Grapher):
@@ skipping 82 matching lines @@
   class CompileProcessor(Processor):
 
     def process_file(self, afile):
       """Pull all the relevant information out of a given tracefile.
 
       Args:
         afile: is the filename string we will be processing.
       Returns: True if we successfully posted our data to storage."""
       os.chdir(os.path.join(DART_INSTALL_LOCATION, 'tools',
           'testing', 'perf_testing'))
-      if self.test.test_runner.no_upload:
-        return
       f = open(os.path.join(self.test.result_folder_name, afile))
       tabulate_data = False
       revision_num = 0
       upload_success = True
       for line in f.readlines():
         tokens = line.split()
         if 'Revision' in line:
           revision_num = int(line.split()[1])
         else:
           for metric in self.test.values_list:
             if metric in line:
               num = tokens[0]
               if num.find('.') == -1:
                 num = int(num)
               else:
                 num = float(num)
               self.test.values_dict['commandline']['frog'][metric] += [num]
               self.test.revision_dict['commandline']['frog'][metric] += \
                   [revision_num]
               score_type = self.CODE_SIZE
               if 'Compiling' in metric or 'Bootstrapping' in metric:
                 score_type = self.COMPILE_TIME
-              if self.should_report_results(afile):
+              if self.should_report_results(afile) and \
+                  not self.test.test_runner.no_upload:
+                if num < self.test.failure_threshold[metric]:
+                  num = 0
                 upload_success = upload_success and self.report_results(
                     metric, num, 'commandline', 'frog', revision_num,
                     score_type)
               else:
                 upload_success = False
       if revision_num != 0:
         for metric in self.test.values_list:
           self.test.revision_dict['commandline']['frog'][metric].pop()
           self.test.revision_dict['commandline']['frog'][metric] += \
               [revision_num]
@@ skipping 36 matching lines @@
     while True:
       if runner.has_new_code():
         runner.run_test_sequence()
       else:
         time.sleep(200)
   else:
     runner.run_test_sequence()
 
 if __name__ == '__main__':
   main()