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):
     """ 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

[bradn, 2014/08/22 16:13:32]

I assume there's no need for exponential backoff?

+          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:
+            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