[Findit] Collect failed output nodes of compile and link failures by strict regex

appengine/findit/waterfall/extractors.py

 # Copyright 2014 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 logging
 import os
 import re
 
 from waterfall import extractor_util
+from waterfall import waterfall_config
 from waterfall.extractor import Extractor
 from waterfall.failure_signal import FailureSignal
 
 
 class GeneralExtractor(Extractor):
   """A general extractor.
 
   It extracts file name and line numbers.
   """
   INDIRECT_LEAK_MARKER_PATTERN = re.compile(
@@ skipping 103 matching lines @@
   WINDOWS_LINK_FAILURE_PATTERN = re.compile(r'/OUT:([^\s-]+)')
 
   NINJA_FAILURE_END_LINE_PREFIX = 'ninja: build stopped'
   NINJA_ERROR_LINE_PREFIX = 'ninja: error'
   ERROR_LINE_END_PATTERN = re.compile(r'^\d+ errors? generated.')
   IOS_ERROR_LINE_START_PREFIX = 'CompileC'
 
   IOS_BUILDER_NAMES_FOR_COMPILE = ['iOS_Simulator_(dbg)', 'iOS_Device']
   MAC_MASTER_NAME_FOR_COMPILE = 'chromium.mac'
 
+  STRICT_COMPILE_FAILURE_PATTEN = re.compile(

[chanli, 2016/03/15 06:07:49]

nit: It seems that the first 2 lines of compile pattern are the same as link
pattern, maybe we can share them?

[stgao, 2016/03/15 18:32:21]

Done.

+      r'^FAILED: \S*/b/build/goma/gomacc '
+       '\S*third_party/llvm-build/Release\+Asserts/bin/clang\+\+ '
+       '-MMD -MF (obj/[^\s-]+\.o)\.d .* '
+       '-c ([^\s-]+(?:cc|c|cpp)) -o (obj/[^\s-]+\.o)$'

[chanli, 2016/03/15 06:07:49]

I think this one can be simplified a little as :
r'^FAILED: \S*/b/build/goma/gomacc '
 '\S*third_party/llvm-build/Release\+Asserts/bin/clang\+\+ '
'-MMD -MF (obj/[^\s-]+\.o)\.d .* '
 '-c ([^\s-]+(?:cc|c|cpp)) -o \1$'

And naturally if  'dep_obj_name' and 'target' are different, there will be no
match. So you don't need the comparison as well.

The only thing is it'll just be no match so you can't really log error.

WDYT?

[stgao, 2016/03/15 18:32:21]

Actually, I went with the \number approach before falling back to this one,
because it doesn't work for me.

Does it work for you? Or maybe my regex has some subtle bug with the \1?

+  )
+
+  STRICT_LINK_FAILURE_PATTEN = re.compile(

[lijeffrey, 2016/03/15 07:12:26]

I'm thinking, would it make sense to make these part of config too for a future
CL? In case the output changes or we find some cases where these regexes fail to
determine the target (which has happened to me before with mac) it may be useful
to be able to adjust them.

[stgao, 2016/03/15 18:32:21]

I'd not make them into the config. Because this is a temporary solution before
the next ninja release. Once ninja 1.7 is released, this CL will be reverted and
all such info will be from ninja directly through a build property in the build
json data.

And since this speeds up the try-job so much, I think the temporary solution
still worths it.

+      r'^FAILED: \S*/b/build/goma/gomacc '
+       '\S*third_party/llvm-build/Release\+Asserts/bin/clang\+\+ -Wl,.* '
+       '-o (\S+) -Wl,--start-group .*$'
+  )
+
+  def ExtractFailedOutputNodes(self, line, signal):
+    match = self.STRICT_COMPILE_FAILURE_PATTEN.match(line)
+    if match:
+      dep_obj_name = match.group(1)
+      source = match.group(2)
+      target = match.group(3)
+      if dep_obj_name == target:
+        signal.AddTarget({
+            'target': target,
+            'source': source,
+        })
+      else:
+        logging.error('Unexpected compile failure pattern:%s', line)
+    else:
+      match = self.STRICT_LINK_FAILURE_PATTEN.match(line)
+      if match:
+        target = match.group(1)
+        signal.AddTarget({
+            'target': target,
+        })
+
   def GetFailedTarget(self, line, signal):
     match = self.LINUX_FAILED_SOURCE_TARGET_PATTERN.search(line)
 
     if match:
       # For non-windows builds, build lines should contain either gomacc or
       # clang++, so only search for source/target files after the call to
       # gomacc/clang++ to avoid extracting false positives in the failure line.
       build_line_match = self.LINUX_BUILD_COMMAND_PATTERN.search(line)
       if not build_line_match:
         return
@@ skipping 50 matching lines @@
 
         if failure_started:
           if line.startswith(self.IOS_ERROR_LINE_START_PREFIX):
             failure_started = False
             for l in error_lines[:-4]:
               self.ExtractFiles(l, signal)
             error_lines = []
           else:
             error_lines.append(line)
     else:
+      strict_regex = waterfall_config.EnableStrictRegexForCompileLinkFailures(
+          master_name, bot_name)
       for line in failure_log.splitlines():
         if line.startswith(self.FAILURE_START_LINE_PREFIX):
-          self.GetFailedTarget(line, signal)
+          if strict_regex:
+            self.ExtractFailedOutputNodes(line, signal)

[chanli, 2016/03/15 06:07:49]

What if strict_regex is true but the line doesn't match any pattern?

[stgao, 2016/03/15 18:32:21]

Then we ignore and let "analyze" to figure out what to compile.
Because we are not 100% sure which "target" failed in that case.

With the strict regex, we know for sure which "target" failed.

+          else:
+            self.GetFailedTarget(line, signal)
           if not failure_started:
             failure_started = True
           continue  # pragma: no cover
         elif self.FAILURE_WITH_ERROR_PATTERN.match(line):
           # It is possible the target and source file associated with a compile
           # failure is logged outside a 'FAILED: ... 1 error generated' block,
           # so extract regardless of failure_started.
-          self.GetFailedTarget(line, signal)
+          if not strict_regex:
+            self.GetFailedTarget(line, signal)
         elif failure_started and self.ERROR_LINE_END_PATTERN.match(line):
           failure_started = False
         elif failure_started and line.startswith(
             self.NINJA_FAILURE_END_LINE_PREFIX):  # pragma: no cover
           break
         if failure_started or line.startswith(self.NINJA_ERROR_LINE_PREFIX):
           # either within the compile errors or is a ninja error.
           self.ExtractFiles(line, signal)
 
     return signal
@@ skipping 251 matching lines @@
 def ExtractSignal(master_name, bot_name, step_name, test_name, failure_log):
   """Uses an appropriate extractor to extract failure signals.
 
   Returns:
     A FailureSignal.
   """
   # Fall back to a general-but-maybe-not-accurate extractor.
   extractor_class = EXTRACTORS.get(step_name, GeneralExtractor)
   return extractor_class().Extract(
       failure_log, test_name, step_name, bot_name, master_name)