introduce recipe_exception in result.proto

recipe_engine/loader.py

 # Copyright 2016 The LUCI Authors. All rights reserved.
 # Use of this source code is governed under the Apache License, Version 2.0
 # that can be found in the LICENSE file.
 
 import collections
+import functools
 import imp
 import inspect
 import os
 import sys
 
 from . import env
 
 from .config import ConfigContext, ConfigGroupSchema
 from .config_types import Path, ModuleBasePath, PackageRepoBasePath
 from .config_types import RecipeScriptBasePath
 from .config_types import RECIPE_MODULE_PREFIX
 from .recipe_api import RecipeApiPlain, RecipeScriptApi
 from .recipe_api import _UnresolvedRequirement
 from .recipe_api import BoundProperty
 from .recipe_api import UndefinedPropertyException, PROPERTY_SENTINEL
+from .recipe_api import StepFailure
 from .recipe_test_api import RecipeTestApi, DisabledTestData
+from .types import StepDataAttributeError
+import subprocess42
 
 
 class LoaderError(Exception):
   """Raised when something goes wrong loading recipes or modules."""
 
 
 class NoSuchRecipe(LoaderError):
   """Raised by load_recipe is recipe is not found."""
   def __init__(self, recipe):
     super(NoSuchRecipe, self).__init__('No such recipe: %s' % recipe)
 
 
+class RecipeException(Exception):
+  """Raised when an unhandeled exception is raised in a recipe."""
+  def __init__(self, inner_exception, traceback):
+    self.inner_exception = inner_exception
+    self.traceback = traceback
+    super(RecipeException, self).__init__(inner_exception.message)
+
+
 class RecipeScript(object):
   """Holds dict of an evaluated recipe script."""
 
   def __init__(self, recipe_globals, path):
     self.path = path
     self._recipe_globals = recipe_globals
 
     self.run_steps, self.gen_tests = [
         recipe_globals.get(k) for k in ('RunSteps', 'GenTests')]
 
@@ skipping 25 matching lines @@
     return self._recipe_globals['LOADED_DEPS']
 
   @property
   def RETURN_SCHEMA(self):
     return self._recipe_globals.get('RETURN_SCHEMA')
 
   def run(self, api, properties):
     """
     Run this recipe, with the given api and property arguments.
     Check the return value, if we have a RETURN_SCHEMA.
+
+    Raises:
+      RecipeException if an unhandled exception happened in the recipe.
+      TypeError if recipe did not return an expected result.
     """
+
+    orig_run_steps = self.run_steps
+
+    def run_steps(*args, **kwargs):
+      try:
+        return orig_run_steps(*args, **kwargs)
+      except (
+          StepFailure,
+          StepDataAttributeError,
+          subprocess42.TimeoutExpired):
+        raise
+      except Exception as ex:
+        raise RecipeException(ex, sys.exc_info()[2])
+
     recipe_result = invoke_with_properties(
-      self.run_steps, properties, self.PROPERTIES, api=api)
+      run_steps, properties, self.PROPERTIES,
+      inspectable_obj=orig_run_steps,
+      api=api)
 
     if self.RETURN_SCHEMA:
       if not recipe_result:
         raise ValueError("Recipe %s did not return a value." % self.name)
       return recipe_result.as_jsonish(True)
     else:
       return None
 
   @classmethod
   def from_script_path(cls, script_path, universe_view):
@@ skipping 447 matching lines @@
         "Missing property value for '{}'.".format(prop_name))
 
     prop = prop_defs[prop_name]
     props.append(prop.interpret(all_props.get(
       prop_name, PROPERTY_SENTINEL)))
 
   return callable_obj(*props, **additional_args)
 
 
 def invoke_with_properties(callable_obj, all_props, prop_defs,
-                           **additional_args):
+                           inspectable_obj=None, **additional_args):
   """
   Invokes callable with filtered, type-checked properties.
 
   Args:
     callable_obj: The function to call, or class to instantiate.
                   This supports passing in either RunSteps, or a recipe module,
                   which is a class.
     all_props: A dictionary containing all the properties (strings) currently
                defined in the system.
     prop_defs: A dictionary of property name to property definitions
                (BoundProperty) for this callable.
+    inspectable_obj: a function to inspect instead of callable_obj.
+                     Useful when callback_obj is wrapped.
     additional_args: kwargs to pass through to the callable.
                      Note that the names of the arguments can correspond to
                      positional arguments as well.
 
   Returns:
     The result of calling callable with the filtered properties
     and additional arguments.
   """
   # Check that we got passed BoundProperties, and not Properties
 
+  inspectable_obj = inspectable_obj or callable_obj
+
 
   # To detect when they didn't specify a property that they have as a
   # function argument, list the arguments, through inspection,
   # and then comparing this list to the provided properties. We use a list
   # instead of a dict because getargspec returns a list which we would have to
   # convert to a dictionary, and the benefit of the dictionary is pretty small.
-  if inspect.isclass(callable_obj):
-    arg_names = inspect.getargspec(callable_obj.__init__).args
+  if inspect.isclass(inspectable_obj):
+    arg_names = inspect.getargspec(inspectable_obj.__init__).args
 
     arg_names.pop(0)
   else:
-    arg_names = inspect.getargspec(callable_obj).args
+    arg_names = inspect.getargspec(inspectable_obj).args
   return _invoke_with_properties(callable_obj, all_props, prop_defs, arg_names,
                                  **additional_args)
 
 
 def create_recipe_api(toplevel_package, toplevel_deps, recipe_script_path,
                       engine, test_data=DisabledTestData()):
   def instantiator(mod, deps):
     kwargs = {
       'module': mod,
       # TODO(luqui): test_data will need to use canonical unique names.
@@ skipping 69 matching lines @@
   for k,v in toplevel_deps.iteritems():
     setattr(api, k, mapper.instantiate(v))
   return api
 
 
 def _resolve_requirement(req, engine):
   if req._typ == 'client':
     return engine._get_client(req._name)
   else:
     raise ValueError('Unknown requirement type [%s]' % (req._typ,))