android: Make buildbot able to use a custom manifest.

test/lib/TestGyp.py

 # Copyright (c) 2012 Google Inc. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """
 TestGyp.py:  a testing framework for GYP integration tests.
 """
 
 import collections
 from contextlib import contextmanager
 import itertools
 import os
+import random
 import re
 import shutil
 import stat
 import subprocess
 import sys
 import tempfile
+import time
 
 import TestCmd
 import TestCommon
 from TestCommon import __all__
 
 __all__.extend([
   'TestGyp',
 ])
 
 
@@ skipping 516 matching lines @@
     """
     print '%s failed%s' % (' '.join(command), ': %s' % msg if msg else '')
     print self.banner('STDOUT ')
     stdout.seek(0)
     print stdout.read()
     print self.banner('STDERR ')
     stderr.seek(0)
     print stderr.read()
     self.fail_test()
 
-  def _call_adb(self, command):
+  def _call_adb(self, command, timeout=15, retry=3):

[jbudorick, 2014/08/22 05:10:48]

I should've done this to begin with. Thanks for doing it.

nit: "retry" implies that it's the number of times the command will be retried
on failure (i.e., what our scripts do in the main repo), but it's actually just
the number of tries here.

     """ Calls the provided adb command.
 
     If the command fails, the test fails.
 
     Args:
       command: The adb command to call.
     Returns:
       The command's output.
     """
     with tempfile.TemporaryFile(bufsize=0) as adb_out:
       with tempfile.TemporaryFile(bufsize=0) as adb_err:
         adb_command = [self._adb_path]
         if self._device_serial:
           adb_command += ['-s', self._device_serial]
         is_shell = (command[0] == 'shell')
         if is_shell:
           command = [command[0], '%s; echo "\n$?";' % ' '.join(command[1:])]
         adb_command += command
-        if subprocess.call(adb_command, stdout=adb_out, stderr=adb_err) != 0:
-          self._adb_failure(adb_command, None, adb_out, adb_err)
-        else:
+
+        for attempt in xrange(1, retry + 1):
           adb_out.seek(0)
-          output = adb_out.read()
-          if is_shell:
-            output = output.splitlines(True)
+          adb_out.truncate(0)
+          adb_err.seek(0)
+          adb_err.truncate(0)
+          proc = subprocess.Popen(adb_command, stdout=adb_out, stderr=adb_err)
+          deadline = time.time() + timeout
+          timed_out = False
+          while proc.poll() is None and not timed_out:
+            time.sleep(1)
+            timed_out = time.time() > deadline
+          if timed_out:
+            print 'Timeout for command %s (attempt %d of %s)' % (
+                adb_command, attempt, retry)
             try:
-              output[-2] = output[-2].rstrip('\r\n')
-              output, rc = (''.join(output[:-1]), int(output[-1]))
-            except ValueError:
-              self._adb_failure(adb_command, 'unexpected output format',
-                                adb_out, adb_err)
-            if rc != 0:
-              self._adb_failure(adb_command, 'exited with %d' % rc, adb_out,
-                                adb_err)
-          return output
+              proc.kill()
+            except:
+              pass
+          else:

[jbudorick, 2014/08/22 05:10:48]

This only retries on timeouts, not failures. Is that what we want to do?

+            break
+
+        if proc.returncode != 0:  # returncode is None in the case of a timeout.
+          self._adb_failure(
+              adb_command, 'retcode=%s' % proc.returncode, adb_out, adb_err)
+          return
+
+        adb_out.seek(0)
+        output = adb_out.read()
+        if is_shell:
+          output = output.splitlines(True)
+          try:
+            output[-2] = output[-2].rstrip('\r\n')
+            output, rc = (''.join(output[:-1]), int(output[-1]))
+          except ValueError:
+            self._adb_failure(adb_command, 'unexpected output format',
+                              adb_out, adb_err)
+          if rc != 0:
+            self._adb_failure(adb_command, 'exited with %d' % rc, adb_out,
+                              adb_err)
+        return output
 
   def run_built_executable(self, name, *args, **kw):
     """
     Runs an executable program built from a gyp-generated configuration.
     """
     match = kw.pop('match', self.match)
 
     executable_file = self.built_file_path(name, type=self.EXECUTABLE, **kw)
     if executable_file not in self._to_install:
       self.fail_test()
@@ skipping 12 matching lines @@
             os.path.join(os.environ['ANDROID_BUILD_TOP'], i))
         dest = '%s/%s' % (storage, os.path.basename(a))
         self._call_adb(['push', os.path.abspath(a), dest])
         installed.add(dest)
         if i == executable_file:
           device_executable = dest
           self._call_adb(['shell', 'chmod', '755', device_executable])
 
       out = self._call_adb(
           ['shell', 'LD_LIBRARY_PATH=$LD_LIBRARY_PATH:%s' % storage,
-           device_executable])
+           device_executable],
+          timeout=60,
+          retry=1)
       out = out.replace('\r\n', '\n')
       self._complete(out, kw.pop('stdout', None), None, None, None, match)
     finally:
       if len(installed):
         self._call_adb(['shell', 'rm'] + list(installed))
 
   def match_single_line(self, lines = None, expected_line = None):
     """
     Checks that specified line appears in the text.
     """
@@ skipping 676 matching lines @@
 
 def TestGyp(*args, **kw):
   """
   Returns an appropriate TestGyp* instance for a specified GYP format.
   """
   format = kw.pop('format', os.environ.get('TESTGYP_FORMAT'))
   for format_class in format_class_list:
     if format == format_class.format:
       return format_class(*args, **kw)
   raise Exception, "unknown format %r" % format