recipe_tryjob: Allow test bypass.

scripts/slave/recipe_modules/recipe_tryjob/api.py

 # Copyright 2016 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.
 
 import collections
 import hashlib
 import json
 import re
 
 from recipe_engine import recipe_api
 
+RECIPE_TRYJOB_BYPASS_REASON_TAG = "Recipe-Tryjob-Bypass-Reason"
+
 #TODO(martiniss): make the recipe engine be able to dump the package as JSON so
 # we don't have to do this weird parsing.
 def parse_protobuf(lines):
   """Parse the protobuf text format just well enough to understand recipes.cfg.
 
   We don't use the protobuf library because we want to be as self-contained
   as possible in this bootstrap, so it can be simply vendored into a client
   repo.
 
   We assume all fields are repeated since we don't have a proto spec to work
@@ skipping 207 matching lines @@
     if patch:
       kwargs['rietveld'] = patch.server
       kwargs['issue'] = patch.issue
       kwargs['patchset'] = patch.patchset
     else:
       kwargs['patch'] = False
 
     self.m.bot_update.ensure_checkout(**kwargs)
     return repo_path
 
+  def get_fail_build_info(self, downstream_projects, patches):
+    fail_build = collections.defaultdict(lambda: True)
+
+    for proj, patch in patches.items():
+      patch_url = "%s/%s" % (patch.server, patch.issue)
+      desc = self.m.git_cl.get_description(
+          patch=patch_url, codereview='rietveld', suffix=proj)
+
+      assert desc.stdout is not None, "CL %s had no description!" % patch_url
+
+      bypass_reason = self.m.tryserver.get_footer(
+          RECIPE_TRYJOB_BYPASS_REASON_TAG, patch_text=desc.stdout)
+
+      fail_build[proj] = not bool(bypass_reason)
+
+    # Propogate Falses down the deps tree
+    queue = list(patches.keys())
+    while queue:
+      item = queue.pop(0)
+
+      if not fail_build[item]:
+        for downstream in downstream_projects.get(item, []):
+          fail_build[downstream] = False
+          queue.append(downstream)
+
+    return fail_build
 
   def simulation_test(self, proj, proj_config, repo_path, deps):
     """
     Args:
       proj: The luci-config project to simulation_test.
       proj_config: The recipes.cfg configuration for the project.
       repo_path: The path to the repository on disk.
       deps: Mapping from project name to Path. Passed into the recipes.py
         invocation via the "-O" options.
 
@@ skipping 39 matching lines @@
     # luci config project name to recipe config namedtuple
     recipe_configs = {}
 
     # List of all the projects we care about testing. luci-config names
     all_projects = set(p for p in url_mapping if p in PROJECTS_TO_TRY)
 
     recipe_configs = {
         p: self._get_project_config(p) for p in all_projects}
 
     deps, downstream_projects = get_deps_info(all_projects, recipe_configs)
+    should_fail_build_mapping = self.get_fail_build_info(
+        downstream_projects, patches)
 
     projs_to_test, locations = self._checkout_projects(
         root_dir, url_mapping, deps, downstream_projects, patches)
 
-    with self.m.step.defer_results():
-      for proj in projs_to_test:
-        deps_locs = {dep: locations[dep] for dep in deps[proj]}
+    failures = []
+    try:
+      with self.m.step.defer_results():
+        for proj in projs_to_test:
+          deps_locs = {dep: locations[dep] for dep in deps[proj]}
 
-        self.simulation_test(
-            proj, recipe_configs[proj], locations[proj], deps_locs)
+          simulation_result = self.simulation_test(
+              proj, recipe_configs[proj], locations[proj], deps_locs)
+
+          try:
+            simulation_result.get_result()
+          except recipe_api.StepFailure as f:
+            if should_fail_build_mapping.get(proj):

[Paweł Hajdan Jr., 2016/05/25 00:51:55]

Shouldn't we re-raise the exception here?

It's not obvious that AggregatedStepFailure would be raised if we catch
everything here, right?

Alternatively, always check failures for being non-empty, rather than only if we
catch AggregatedStepFailure.

WDYT?

[martiniss, 2016/05/25 17:36:30]

Re-raising the exception here would mean we don't run all the tests; I'd like to
run tests for every repo, so that they know exactly which ones broke. 
It does; see the three_patches_fail_not_ok test case.

[Paweł Hajdan Jr., 2016/05/25 17:58:10]

I think I understand this now.

defer_results results in the original exception (possibly raised by
self.simulation_test) getting caught, registered, and AggregatedStepFailure
thrown later.

With get_result we're explicitly looking at that exception. Makes sense.

+              failures.append(f)
+    except recipe_api.AggregatedStepFailure:
+      if failures:
+        raise
+
+
+
+