Raise Exception instead of failure when some steps fail.

master/skia_master_scripts/factory.py

 # Copyright (c) 2013 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 
 """Utility class to build the Skia master BuildFactory's.
 
 Based on gclient_factory.py and adds Skia-specific steps."""
 
 
@@ skipping 223 matching lines @@
         # b. All of the printing can noticeably slow down the master startup
         # c. The master prints so much output that it would be easy to miss the
         #    diff if we did print it.
         print 'Warning: Factory configuration for %s does not match ' \
               'expectation!' % self._builder_name
 
   def AddSlaveScript(self, script, description, args=None, timeout=None,
                      halt_on_failure=False, is_upload_step=False,
                      is_rebaseline_step=False, get_props_from_stdout=None,
                      workdir=None, do_step_if=None, always_run=False,
-                     flunk_on_failure=True):
+                     flunk_on_failure=True, exception_on_failure=False):
     """ Add a BuildStep consisting of a python script.
 
     script: which slave-side python script to run.
     description: string briefly describing the BuildStep.
     args: optional list of strings; arguments to pass to the script.
     timeout: optional integer; maximum time for the BuildStep to complete.
     halt_on_failure: boolean indicating whether to continue the build if this
         step fails.
     is_upload_step: boolean indicating whether this step should be skipped when
         the buildbot is not performing uploads.
     is_rebaseline_step: boolean indicating whether this step is required for
         rebaseline-only builds.
     get_props_from_stdout: optional dictionary. Keys are strings indicating
         build properties to set based on the output of this step. Values are
         strings containing regular expressions for parsing the property from
         the output of the step.
     workdir: optional string indicating the working directory in which to run
         the script. If this is provided, then the script must be given relative
         to this directory.
     do_step_if: optional, function which determines whether or not to run the
         step.
     always_run: boolean indicating whether this step should run even if a
         previous step which had halt_on_failure has failed.
     flunk_on_failure: boolean indicating whether the whole build fails if this
         step fails.
+    exception_on_failure: boolean indicating whether to raise an exception if
+        this step fails. This causes the step to go purple instead of red, and
+        causes the build to stop. Should be used if the build step's failure is
+        typically transient or results from an infrastructure failure rather
+        than a code change.
     """
     arguments = list(self._common_args)
     if args:
       arguments += args
     self._skia_cmd_obj.AddSlaveScript(
         script=script,
         args=arguments,
         description=description,
         timeout=timeout,
         halt_on_failure=halt_on_failure,
         is_upload_step=is_upload_step,
         is_rebaseline_step=is_rebaseline_step,
         get_props_from_stdout=get_props_from_stdout,
         workdir=workdir,
         do_step_if=do_step_if,
         always_run=always_run,
-        flunk_on_failure=flunk_on_failure)
+        flunk_on_failure=flunk_on_failure,
+        exception_on_failure=exception_on_failure)
 
   def AddFlavoredSlaveScript(self, script, args=None, **kwargs):
     """ Add a flavor-specific BuildStep.
 
     Finds a script to run by concatenating the flavor of this BuildFactory with
     the provided script name.
     """
     flavor_args = ['--flavor', self._flavor or 'default']
     self.AddSlaveScript(script, args=list(args or []) + flavor_args, **kwargs)
 
@@ skipping 129 matching lines @@
       self.Make(target=build_target,
                 description=_COMPILE_NO_WERR_PREFIX + \
                     utils.UnderscoresToCapWords(build_target),
                 flunk_on_failure=True,
                 halt_on_failure=True,
                 do_step_if=ShouldRetryWithoutWarnings)
 
   def Install(self):
     """ Install the compiled executables. """
     self.AddFlavoredSlaveScript(script='install.py', description='Install',
-                                halt_on_failure=True)
+                                halt_on_failure=True, exception_on_failure=True)
 
   def DownloadSKPs(self):
     """ Download the SKPs. """
     self.AddSlaveScript(script='download_skps.py', description='DownloadSKPs',
-                        halt_on_failure=True)
+                        halt_on_failure=True, exception_on_failure=True)
 
   def DownloadSKImageFiles(self):
     """ Download image files for running skimage. """
     self.AddSlaveScript(script='download_skimage_files.py',
                         description='DownloadSKImageFiles',
-                        halt_on_failure=True)
+                        halt_on_failure=True, exception_on_failure=True)
 
   def DownloadBaselines(self):
     """ Download the GM baselines. """
     self.AddSlaveScript(script='download_baselines.py',
-                        description='DownloadBaselines', halt_on_failure=True)
+                        description='DownloadBaselines', halt_on_failure=True,
+                        exception_on_failure=True)
 
   def RunTests(self):
     """ Run the unit tests. """
     self.AddFlavoredSlaveScript(script='run_tests.py', description='RunTests')
 
   def RunDecodingTests(self):
     """ Run tests of image decoders. """
     self.AddFlavoredSlaveScript(script='run_decoding_tests.py',
                                 description='RunDecodingTests')
 
   def RunGM(self):
     """ Run the "GM" tool, saving the images to disk. """
     self.AddFlavoredSlaveScript(script='run_gm.py', description='GenerateGMs',
                                 is_rebaseline_step=True)
 
   def PreRender(self):
     """ Step to run before the render steps. """
-    self.AddFlavoredSlaveScript(script='prerender.py', description='PreRender')
+    self.AddFlavoredSlaveScript(script='prerender.py', description='PreRender',
+                                exception_on_failure=True)
 
   def RenderPictures(self):
     """ Run the "render_pictures" tool to generate images from .skp's. """
     self.AddFlavoredSlaveScript(script='render_pictures.py',
                                 description='RenderPictures')
 
   def RenderPdfs(self):
     """ Run the "render_pdfs" tool to generate pdfs from .skp's. """
     self.AddFlavoredSlaveScript(script='render_pdfs.py',
                                 description='RenderPdfs')
 
   def PostRender(self):
     """ Step to run after the render steps. """
     self.AddFlavoredSlaveScript(script='postrender.py',
-                                description='PostRender')
+                                description='PostRender',
+                                exception_on_failure=True)
 
   def PreBench(self):
     """ Step to run before the benchmarking steps. """
-    self.AddFlavoredSlaveScript(script='prebench.py', description='PreBench')
+    self.AddFlavoredSlaveScript(script='prebench.py',
+                                description='PreBench',
+                                exception_on_failure=True)
 
   def PostBench(self):
     """ Step to run after the benchmarking steps. """
-    self.AddFlavoredSlaveScript(script='postbench.py', description='PostBench')
+    self.AddFlavoredSlaveScript(script='postbench.py',
+                                description='PostBench',
+                                exception_on_failure=True)
 
   def CompareGMs(self):
     """Compare the actually-generated GM images to the checked-in baselines."""
-    self.AddSlaveScript(script='compare_gms.py', description='CompareGMs',
+    self.AddSlaveScript(script='compare_gms.py',
+                        description='CompareGMs',
                         is_rebaseline_step=True)
   
   def CompareAndUploadWebpageGMs(self):
     """Compare the actually-generated images from render_pictures to their
     expectations and upload the actual images if needed."""
     self.AddSlaveScript(script='compare_and_upload_webpage_gms.py',
                         description='CompareAndUploadWebpageGMs',
                         is_rebaseline_step=True)
 
   def RunBench(self):
@@ skipping 15 matching lines @@
     """ Update the buildbot scripts on the build slave. """
     self.AddSlaveScript(
         script=self.TargetPath.join('..', '..', '..', '..',
                                     '..', 'slave',
                                     'skia_slave_scripts',
                                     'update_scripts.py'),
         description='UpdateScripts',
         halt_on_failure=True,
         get_props_from_stdout={'buildbot_revision':
                                    'Skiabot scripts updated to (\w+)'},
-        workdir='build')
+        workdir='build',
+        exception_on_failure=True)
 
   def Update(self):
     """ Update the Skia code on the build slave. """
     args = ['--gclient_solutions', '"%s"' % self._gclient_solutions]
     self.AddSlaveScript(
         script=self.TargetPath.join('..', '..', '..', '..', '..', 'slave',
                                    'skia_slave_scripts', 'update.py'),
         description='Update',
         args=args,
         timeout=None,
         halt_on_failure=True,
         is_upload_step=False,
         is_rebaseline_step=True,
         get_props_from_stdout={'got_revision':'Skia updated to (\w+)'},
-        workdir='build')
+        workdir='build',
+        exception_on_failure=True)
 
   def ApplyPatch(self, alternate_workdir=None, alternate_script=None):
     """ Apply a patch to the Skia code on the build slave. """
     def _GetPatch(build):
       """Find information about the patch (if any) to apply.
 
       Returns:
           An encoded string containing a tuple of the form (level, url) which
               indicates where to go to download the patch.
       """
@@ skipping 20 matching lines @@
         return str((1, patch)).encode()
       else:
         patch = 'None'
       return patch
 
     if not bool(alternate_workdir) == bool(alternate_script):
       raise ValueError('alternate_workdir and alternate_script must be provided'
                        ' together.')
     args = ['--patch', WithProperties('%(patch)s', patch=_GetPatch)]
     if alternate_script:
-      self.AddSlaveScript(script=alternate_script, description='ApplyPatch',
-                          args=args, halt_on_failure=True,
-                          workdir=alternate_workdir)
+      self.AddSlaveScript(script=alternate_script,
+                          description='ApplyPatch',
+                          args=args,
+                          halt_on_failure=True,
+                          workdir=alternate_workdir,
+                          exception_on_failure=True)
     else:
-      self.AddSlaveScript(script='apply_patch.py', description='ApplyPatch',
-                          args=args, halt_on_failure=True)
+      self.AddSlaveScript(script='apply_patch.py',
+                          description='ApplyPatch',
+                          args=args,
+                          halt_on_failure=True,
+                          exception_on_failure=True)
 
   def UpdateSteps(self):
     """ Update the Skia sources. """
     self.UpdateScripts()
     self.Update()
     if self._do_patch_step:
       self.ApplyPatch()
 
   def UploadBenchResults(self):
     """ Upload bench results (performance data). """
     self.AddSlaveScript(script='upload_bench_results.py',
-                        description='UploadBenchResults')
+                        description='UploadBenchResults',
+                        exception_on_failure=True)
 
   def UploadBenchResultsToAppEngine(self):
     """ Upload bench results (performance data) to AppEngine. """
     self.AddSlaveScript(script='upload_bench_results_appengine.py',
-                        description='UploadBenchResultsToAppengine')
+                        description='UploadBenchResultsToAppengine',
+                        exception_on_failure=True)
 
   def UploadWebpagePictureBenchResults(self):
     """ Upload webpage picture bench results (performance data). """
     self.AddSlaveScript(script='upload_webpage_picture_bench_results.py',
-                        description='UploadWebpagePictureBenchResults')
+                        description='UploadWebpagePictureBenchResults',
+                        exception_on_failure=True)
 
 
   def UploadGMResults(self):
     """ Upload the images generated by GM """
     args = ['--autogen_svn_username_file', self._autogen_svn_username_file,
             '--autogen_svn_password_file', self._autogen_svn_password_file]
     self.AddSlaveScript(script='upload_gm_results.py', args=args,
                         description='UploadGMResults', timeout=5400,
-                        is_rebaseline_step=True)
+                        is_rebaseline_step=True,
+                        exception_on_failure=True)
 
   def UploadSKImageResults(self):
     self.AddSlaveScript(script='upload_skimage_results.py',
-                        description="UploadSKImageResults")
+                        description='UploadSKImageResults',
+                        exception_on_failure=True)
 
   def CommonSteps(self, clobber=None):
     """ Steps which are run at the beginning of all builds. """
     self.UpdateSteps()
     self.DownloadSKPs()
     self.Compile(clobber)
     self.Install()
 
   def NonPerfSteps(self):
     """ Add correctness testing BuildSteps. """
@@ skipping 77 matching lines @@
         # Perf-only builder.
         if not self._perf_output_basedir:
           raise ValueError(
               'BuildPerfOnly requires perf_output_basedir to be defined.')
         if self._configuration != CONFIG_RELEASE:
           raise ValueError('BuildPerfOnly should run in %s configuration.' %
                            CONFIG_RELEASE)
         self.PerfSteps()
     self.Validate()
     return self