Port Skia recipe to normal Python scripts, move to Skia repo

infra/bots/flavor/android_flavor.py

+#!/usr/bin/env python
+#
+# Copyright 2016 Google Inc.
+#
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+
+import android_devices
+import copy

[rmistry, 2016/02/18 15:29:21]

unused

[borenet, 2016/02/18 15:40:56]

Done.

+import default_flavor
+import os
+
+
+"""Android flavor utils, used for building for and running tests on Android."""
+
+
+class _ADBWrapper(object):
+  """Wrapper for ADB."""
+  def __init__(self, path_to_adb, serial, android_flavor):
+    self._adb = path_to_adb
+    self._serial = serial
+    self._wait_count = 0
+    self._android_flavor = android_flavor
+
+  def wait_for_device(self):
+    """Run 'adb wait-for-device'."""
+    self._wait_count += 1
+    cmd = [
+        os.path.join(self._android_flavor.android_bin, 'adb_wait_for_device'),
+        '-s', self._serial,
+    ]
+    self._android_flavor._bot_info.run(
+        cmd, env=self._android_flavor._default_env)
+
+  def maybe_wait_for_device(self):
+    """Run 'adb wait-for-device' if it hasn't already been run."""
+    if self._wait_count == 0:
+      self.wait_for_device()
+
+  def __call__(self, *args, **kwargs):
+    self.maybe_wait_for_device()
+    return self._android_flavor._bot_info.run(self._adb + args, **kwargs)
+
+
+class AndroidFlavorUtils(default_flavor.DefaultFlavorUtils):
+  def __init__(self, skia_api):
+    super(AndroidFlavorUtils, self).__init__(skia_api)
+    self.device = self._bot_info.spec['device_cfg']
+    slave_info = android_devices.SLAVE_INFO.get(
+        self._bot_info.slave_name,
+        android_devices.SLAVE_INFO['default'])
+    self.serial = slave_info.serial
+    self.android_bin = os.path.join(
+        self._bot_info.skia_dir, 'platform_tools', 'android', 'bin')
+    self._android_sdk_root = slave_info.android_sdk_root
+    self._adb = _ADBWrapper(
+        os.path.join(self._android_sdk_root, 'platform-tools', 'adb'),
+        self.serial,
+        self)
+    self._has_root = slave_info.has_root
+    self._default_env = {'ANDROID_SDK_ROOT': self._android_sdk_root,
+                         'ANDROID_HOME': self._android_sdk_root,
+                         'SKIA_ANDROID_VERBOSE_SETUP': '1'}
+
+  def step(self, name, cmd, env=None, **kwargs):
+    self._adb.maybe_wait_for_device()
+    args = [self.android_bin.join('android_run_skia'),
+            '--verbose',
+            '--logcat',
+            '-d', self.device,
+            '-s', self.serial,
+            '-t', self._bot_info.configuration,
+    ]
+    env = dict(env or {})
+    env.update(self._default_env)
+
+    return self._bot_info.run(self._bot_info.m.step, name=name, cmd=args + cmd,
+                              env=env, **kwargs)
+
+  def compile(self, target):
+    """Build the given target."""
+    env = dict(self._default_env)
+    ccache = self._bot_info.ccache
+    if ccache:
+      env['ANDROID_MAKE_CCACHE'] = ccache
+
+    cmd = [os.path.join(self.android_bin, 'android_ninja'), target,
+           '-d', self.device]
+    if 'Clang' in self._bot_info.name:
+      cmd.append('--clang')
+    self._bot_info.run(cmd, env=env)
+
+  def device_path_join(self, *args):
+    """Like os.path.join(), but for paths on a connected Android device."""
+    return '/'.join(args)
+
+  def device_path_exists(self, path):
+    """Like os.path.exists(), but for paths on a connected device."""
+    exists_str = 'FILE_EXISTS'
+    return exists_str in self._adb(
+        name='exists %s' % self._bot_info.m.path.basename(path),
+        serial=self.serial,
+        cmd=['shell', 'if', '[', '-e', path, '];',
+             'then', 'echo', exists_str + ';', 'fi'],
+        stdout=self._bot_info.m.raw_io.output(),
+        infra_step=True
+    ).stdout
+
+  def _remove_device_dir(self, path):
+    """Remove the directory on the device."""
+    self._adb(name='rmdir %s' % self._bot_info.m.path.basename(path),
+              serial=self.serial,
+              cmd=['shell', 'rm', '-r', path],
+              infra_step=True)
+    # Sometimes the removal fails silently. Verify that it worked.
+    if self.device_path_exists(path):
+      raise Exception('Failed to remove %s!' % path)  # pragma: no cover
+
+  def _create_device_dir(self, path):
+    """Create the directory on the device."""
+    self._adb(name='mkdir %s' % self._bot_info.m.path.basename(path),
+              serial=self.serial,
+              cmd=['shell', 'mkdir', '-p', path],
+              infra_step=True)
+
+  def copy_directory_contents_to_device(self, host_dir, device_dir):
+    """Like shutil.copytree(), but for copying to a connected device."""
+    self._bot_info.run(
+        self._bot_info.m.step,
+        name='push %s' % self._bot_info.m.path.basename(host_dir),
+        cmd=[self.android_bin.join('adb_push_if_needed'), '--verbose',
+             '-s', self.serial, host_dir, device_dir],
+        env=self._default_env,
+        infra_step=True)
+
+  def copy_directory_contents_to_host(self, device_dir, host_dir):
+    """Like shutil.copytree(), but for copying from a connected device."""
+    self._bot_info.run(
+        self._bot_info.m.step,
+        name='pull %s' % self._bot_info.m.path.basename(device_dir),
+        cmd=[self.android_bin.join('adb_pull_if_needed'), '--verbose',
+             '-s', self.serial, device_dir, host_dir],
+        env=self._default_env,
+        infra_step=True)
+
+  def copy_file_to_device(self, host_path, device_path):
+    """Like shutil.copyfile, but for copying to a connected device."""
+    self._adb(name='push %s' % self._bot_info.m.path.basename(host_path),
+              serial=self.serial,
+              cmd=['push', host_path, device_path],
+              infra_step=True)
+
+  def create_clean_device_dir(self, path):
+    """Like shutil.rmtree() + os.makedirs(), but on a connected device."""
+    self._remove_device_dir(path)
+    self._create_device_dir(path)
+
+  def install(self):
+    """Run device-specific installation steps."""
+    if self._has_root:
+      self._adb(name='adb root',
+                serial=self.serial,
+                cmd=['root'],
+                infra_step=True)
+      # Wait for the device to reconnect.
+      self._bot_info.run(
+          self._bot_info.m.step,
+          name='wait',
+          cmd=['sleep', '10'],
+          infra_step=True)
+      self._adb.wait_for_device()
+
+    # TODO(borenet): Set CPU scaling mode to 'performance'.
+    self._bot_info.run(self._bot_info.m.step,
+                       name='kill skia',
+                       cmd=[self.android_bin.join('android_kill_skia'),
+                            '--verbose', '-s', self.serial],
+                       env=self._default_env,
+                       infra_step=True)
+    if self._has_root:
+      self._adb(name='stop shell',
+                serial=self.serial,
+                cmd=['shell', 'stop'],
+                infra_step=True)
+
+    # Print out battery stats.
+    self._adb(name='starting battery stats',
+              serial=self.serial,
+              cmd=['shell', 'dumpsys', 'batteryproperties'],
+              infra_step=True)
+
+  def cleanup_steps(self):
+    """Run any device-specific cleanup steps."""
+    self._adb(name='final battery stats',
+              serial=self.serial,
+              cmd=['shell', 'dumpsys', 'batteryproperties'],
+              infra_step=True)
+    self._adb(name='reboot',
+              serial=self.serial,
+              cmd=['reboot'],
+              infra_step=True)
+    self._bot_info.run(
+        self._bot_info.m.step,
+        name='wait for reboot',
+        cmd=['sleep', '10'],
+        infra_step=True)
+    self._adb.wait_for_device()
+
+  def read_file_on_device(self, path, *args, **kwargs):
+    """Read the given file."""
+    return self._adb(name='read %s' % self._bot_info.m.path.basename(path),
+                     serial=self.serial,
+                     cmd=['shell', 'cat', path],
+                     stdout=self._bot_info.m.raw_io.output(),
+                     infra_step=True).stdout.rstrip()
+
+  def remove_file_on_device(self, path, *args, **kwargs):
+    """Delete the given file."""
+    return self._adb(name='rm %s' % self._bot_info.m.path.basename(path),
+                     serial=self.serial,
+                     cmd=['shell', 'rm', '-f', path],
+                     infra_step=True,
+                     *args,
+                     **kwargs)
+
+  def get_device_dirs(self):
+    """ Set the directories which will be used by the build steps."""
+    device_scratch_dir = self._adb(
+        name='get EXTERNAL_STORAGE dir',
+        serial=self.serial,
+        cmd=['shell', 'echo', '$EXTERNAL_STORAGE'],
+    )
+    prefix = self.device_path_join(device_scratch_dir, 'skiabot', 'skia_')
+    return default_flavor.DeviceDirs(
+        dm_dir=prefix + 'dm',
+        perf_data_dir=prefix + 'perf',
+        resource_dir=prefix + 'resources',
+        images_dir=prefix + 'images',
+        skp_dir=prefix + 'skp/skps',
+        tmp_dir=prefix + 'tmp_dir')
+