Remove skydb dependency on build/android/pylib

sky/tools/skydb

 #!/usr/bin/env python
 # 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.
 
 from skypy.skyserver import SkyServer
 import argparse
 import json
 import logging
 import os
 import pipes
 import re
 import requests
 import signal
 import skypy.paths
 import StringIO
 import subprocess
 import sys
 import time
 import urlparse
 
-SRC_ROOT = skypy.paths.Paths('ignored').src_root
-sys.path.insert(0, os.path.join(SRC_ROOT, 'build', 'android'))
-from pylib import android_commands
-from pylib import constants
-from pylib import forwarder
-
-
 SUPPORTED_MIME_TYPES = [
     'text/html',
     'text/sky',
     'text/plain',
 ]
 
 DEFAULT_SKY_COMMAND_PORT = 7777
 GDB_PORT = 8888
 SKY_SERVER_PORT = 9999
-PID_FILE_PATH = "/tmp/skydb.pids"
 DEFAULT_URL = "https://raw.githubusercontent.com/domokit/mojo/master/sky/examples/home.sky"
 
 ANDROID_PACKAGE = "org.chromium.mojo.shell"
 ANDROID_ACTIVITY = "%s/.MojoShellActivity" % ANDROID_PACKAGE
 ANDROID_APK_NAME = 'MojoShell.apk'
+
+PID_FILE_PATH = "/tmp/skydb.pids"
 CACHE_LINKS_PATH = '/tmp/mojo_cache_links'
 SYSTEM_LIBS_ROOT_PATH = '/tmp/device_libs'
 
+SRC_ROOT = skypy.paths.Paths('ignored').src_root
+ADB_PATH = os.path.join(SRC_ROOT,
+    'third_party/android_tools/sdk/platform-tools/adb')
+
 
 # FIXME: Move this into mopy.config
 def gn_args_from_build_dir(build_dir):
     gn_cmd = [
         'gn', 'args',
         build_dir,
         '--list', '--short'
     ]
     config = {}
     for line in subprocess.check_output(gn_cmd).strip().split('\n'):
@@ skipping 21 matching lines @@
 
     def _in_chromoting(self):
         return os.environ.get('CHROME_REMOTE_DESKTOP_SESSION', False)
 
     def _wrap_for_android(self, shell_args):
         # am shell --esa: (someone shoot me now)
         #  [--esa <EXTRA_KEY> <EXTRA_STRING_VALUE>[,<EXTRA_STRING_VALUE...]]
         #  (to embed a comma into a string escape it using "\,")
         escaped_args = map(lambda arg: arg.replace(',', '\\,'), shell_args)
         return [
-            'adb', 'shell',
+            ADB_PATH, 'shell',
             'am', 'start',
             '-W',
             '-S',
             '-a', 'android.intent.action.VIEW',
             '-n', ANDROID_ACTIVITY,
             # FIXME: This quoting is very error-prone.  Perhaps we should read
             # our args from a file instead?
             '--esa', 'parameters', ','.join(escaped_args),
         ]
 
     def _build_mojo_shell_command(self, args, is_android):
         content_handlers = ['%s,%s' % (mime_type, 'mojo:sky_viewer')
             for mime_type in SUPPORTED_MIME_TYPES]
 
         remote_command_port = self.pids.get('remote_sky_command_port', self.pids['sky_command_port'])
         remote_server_port = self.pids.get('remote_sky_server_port', self.pids['sky_server_port'])
 
         shell_args = [
             '--v=1',
             '--content-handlers=%s' % ','.join(content_handlers),
             '--url-mappings=mojo:window_manager=mojo:sky_debugger',
             '--args-for=mojo:sky_debugger_prompt %d' % remote_command_port,
             'mojo:window_manager',
         ]
 
+        if args.url_or_path:
+            shell_args.append(
+                '--args-for=mojo:window_manager %s' % self._url_from_args(args))
+
         # Map all mojo: urls to http: urls using the --origin command.
         build_dir_url = SkyServer.url_for_path(
             remote_server_port,
             self.pids['sky_server_root'],
             self.pids['build_dir'])
         shell_args += ['--origin=%s' % build_dir_url]
 
         # Desktop-only work-around for mojo crashing under chromoting.
         if not is_android and args.use_osmesa:
             shell_args.append(
                 '--args-for=mojo:native_viewport_service --use-osmesa')
 
         if is_android and args.gdb:
             shell_args.append('--wait_for_debugger')
 
         if 'remote_sky_server_port' in self.pids:
             shell_command = self._wrap_for_android(shell_args)
         else:
             shell_command = [self.paths.mojo_shell_path] + shell_args
 
         return shell_command
 
-    def _connect_to_device(self):
-        device = android_commands.AndroidCommands(
-            android_commands.GetAttachedDevices()[0])
-        device.EnableAdbRoot()
-        return device
-
     def sky_server_for_args(self, args):
         # FIXME: This is a hack.  sky_server should just take a build_dir
         # not a magical "configuration" name.
         configuration = os.path.basename(os.path.normpath(self.paths.build_dir))
         server_root = self._server_root_for_url(args.url_or_path)
         sky_server = SkyServer(self.paths, SKY_SERVER_PORT,
             configuration, server_root)
         return sky_server
 
     def _create_paths_for_build_dir(self, build_dir):
         # skypy.paths.Paths takes a root-relative build_dir argument. :(
         abs_build_dir = os.path.abspath(build_dir)
         root_relative_build_dir = os.path.relpath(abs_build_dir, SRC_ROOT)
         return skypy.paths.Paths(root_relative_build_dir)
 
     def _find_remote_pid_for_package(self, package):
-        ps_output = subprocess.check_output(['adb', 'shell', 'ps'])
+        ps_output = subprocess.check_output([ADB_PATH, 'shell', 'ps'])
         for line in ps_output.split('\n'):
             fields = line.split()
             if fields and fields[-1] == package:
                 return fields[1]
         return None
 
     def _find_install_location_for_package(self, package):
-        pm_command = ['adb', 'shell', 'pm', 'path', package]
+        pm_command = [ADB_PATH, 'shell', 'pm', 'path', package]
         pm_output = subprocess.check_output(pm_command)
         # e.g. package:/data/app/org.chromium.mojo.shell-1/base.apk
         return pm_output.split(':')[-1]
 
     def start_command(self, args):
         # FIXME: Lame that we use self for a command-specific variable.
         self.paths = self._create_paths_for_build_dir(args.build_dir)
         self.stop_command(None) # Quit any existing process.
 
         if not os.path.exists(self.paths.mojo_shell_path):
             print "mojo_shell not found in build_dir '%s'" % args.build_dir
             print "Are you sure you sure that's a valid build_dir location?"
             print "See skydb start --help for more info"
             sys.exit(2)
 
         # FIXME: This is probably not the right way to compute is_android
         # from the build directory?
         gn_args = gn_args_from_build_dir(self.paths.build_dir)
         is_android = 'android_sdk_version' in gn_args
 
         sky_server = self.sky_server_for_args(args)
         self.pids['sky_server_pid'] = sky_server.start()
         self.pids['sky_server_port'] = sky_server.port
         self.pids['sky_server_root'] = sky_server.root
 
         self.pids['build_dir'] = self.paths.build_dir
         self.pids['sky_command_port'] = args.command_port
 
         if is_android:
-            # Pray to the build/android gods in their misspelled tongue.
-            constants.SetOutputDirectort(self.paths.build_dir)
-
             # We could make installing conditional on an argument.
             apk_path = os.path.join(self.paths.build_dir, 'apks',
                 ANDROID_APK_NAME)
-            subprocess.check_call(['adb', 'install', '-r', apk_path])
+            subprocess.check_call([ADB_PATH, 'install', '-r', apk_path])
 
-            device = self._connect_to_device()
-            self.pids['device_serial'] = device.GetDevice()
-
-            forwarder.Forwarder.Map([(0, sky_server.port)], device)
-            device_http_port = forwarder.Forwarder.DevicePortForHostPort(
-                sky_server.port)
-            self.pids['remote_sky_server_port'] = device_http_port
+            port_string = 'tcp:%s' % sky_server.port
+            subprocess.check_call([
+                ADB_PATH, 'reverse', port_string, port_string
+            ])
+            self.pids['remote_sky_server_port'] = sky_server.port
 
             port_string = 'tcp:%s' % args.command_port
             subprocess.check_call([
-                'adb', 'forward', port_string, port_string
+                ADB_PATH, 'forward', port_string, port_string
             ])
             self.pids['remote_sky_command_port'] = args.command_port
 
         shell_command = self._build_mojo_shell_command(args, is_android)
 
         # On android we can't launch inside gdb, but rather have to attach.
         if not is_android and args.gdb:
             shell_command = ['gdbserver', ':%d' % GDB_PORT] + shell_command
 
         print ' '.join(map(pipes.quote, shell_command))
@@ skipping 19 matching lines @@
             self.pids['mojo_shell_pid'] = start_command_pid
 
         if args.gdb and is_android:
             # We push our own copy of gdbserver with the package since
             # the default gdbserver is a different version from our gdb.
             package_path = \
                 self._find_install_location_for_package(ANDROID_PACKAGE)
             gdb_server_path = os.path.join(
                 os.path.dirname(package_path), 'lib/arm/gdbserver')
             gdbserver_cmd = [
-                'adb', 'shell',
+                ADB_PATH, 'shell',
                 gdb_server_path, '--attach',
                 ':%d' % GDB_PORT,
                 str(self.pids['mojo_shell_pid'])
             ]
             print ' '.join(map(pipes.quote, gdbserver_cmd))
             self.pids['adb_shell_gdbserver_pid'] = \
                 subprocess.Popen(gdbserver_cmd).pid
 
             port_string = 'tcp:%d' % GDB_PORT
             subprocess.check_call([
-                'adb', 'forward', port_string, port_string
+                ADB_PATH, 'forward', port_string, port_string
             ])
             self.pids['remote_gdbserver_port'] = GDB_PORT
 
         if not args.gdb:
             if not self._wait_for_sky_command_port():
                 logging.error('Failed to start sky')
                 self.stop_command(None)
-            else:
-                self.load_command(args)
         else:
-            print 'No load issued, connect with gdb first and then run load.'
+            # We could just run gdb_attach_command here, but when I do that
+            # it auto-suspends in my zsh.  Unclear why.
+            # self.gdb_attach_command(args)
+            print "Run skydb gdb_attach to attach."
 
     def _kill_if_exists(self, key, name):
         pid = self.pids.pop(key, None)
         if not pid:
             logging.info('No pid for %s, nothing to do.' % name)
             return
         logging.info('Killing %s (%d).' % (name, pid))
         try:
             os.kill(pid, signal.SIGTERM)
         except OSError:
             logging.info('%s (%d) already gone.' % (name, pid))
 
     def stop_command(self, args):
         # TODO(eseidel): mojo_shell crashes when attempting graceful shutdown.
         # self._run_basic_command('/quit')
 
         self._kill_if_exists('sky_server_pid', 'sky_server')
 
-        # We could be much more surgical here:
         if 'remote_sky_server_port' in self.pids:
-            device = android_commands.AndroidCommands(
-                self.pids['device_serial'])
-            forwarder.Forwarder.UnmapAllDevicePorts(device)
+            port_string = 'tcp:%s' % self.pids['remote_sky_server_port']
+            subprocess.call([ADB_PATH, 'reverse', '--remove', port_string])
 
         if 'remote_sky_command_port' in self.pids:
             # adb forward --remove takes the *host* port, not the remote port.
             port_string = 'tcp:%s' % self.pids['sky_command_port']
-            subprocess.call(['adb', 'forward', '--remove', port_string])
+            subprocess.call([ADB_PATH, 'forward', '--remove', port_string])
 
             subprocess.call([
-                'adb', 'shell', 'am', 'force-stop', ANDROID_PACKAGE])
+                ADB_PATH, 'shell', 'am', 'force-stop', ANDROID_PACKAGE])
         else:
             # Only try to kill mojo_shell if it's running locally.
             self._kill_if_exists('mojo_shell_pid', 'mojo_shell')
 
         if 'remote_gdbserver_port' in self.pids:
             self._kill_if_exists('adb_shell_gdbserver_pid',
                 'adb shell gdbserver')
 
             port_string = 'tcp:%s' % self.pids['remote_gdbserver_port']
-            subprocess.call(['adb', 'forward', '--remove', port_string])
+            subprocess.call([ADB_PATH, 'forward', '--remove', port_string])
         self.pids = {} # Clear out our pid file.
 
+    def _url_from_args(self, args):
+        if urlparse.urlparse(args.url_or_path).scheme:
+            return args.url_or_path
+        # The load happens on the remote device, use the remote port.
+        remote_sky_server_port = self.pids.get('remote_sky_server_port',
+            self.pids['sky_server_port'])
+        return SkyServer.url_for_path(remote_sky_server_port,
+            self.pids['sky_server_root'], args.url_or_path)
+
     def load_command(self, args):
-        if not urlparse.urlparse(args.url_or_path).scheme:
-            # The load happens on the remote device, use the remote port.
-            remote_sky_server_port = self.pids.get('remote_sky_server_port',
-                self.pids['sky_server_port'])
-            url = SkyServer.url_for_path(remote_sky_server_port,
-                    self.pids['sky_server_root'], args.url_or_path)
-        else:
-            url = args.url_or_path
-        self._run_basic_command('/load', url)
+        self._run_basic_command('/load', self._url_from_args(args))
 
     def _read_mojo_map(self):
         # TODO(eseidel): Does not work for android.
         mojo_map_path = "/tmp/mojo_shell.%d.maps" % self.pids['mojo_shell_pid']
         with open(mojo_map_path, 'r') as maps_file:
             lines = maps_file.read().strip().split('\n')
             return dict(map(lambda line: line.split(' '), lines))
 
     def stop_tracing_command(self, args):
         file_name = args.file_name
@@ skipping 90 matching lines @@
                 time.sleep(1)
 
     def logcat_command(self, args):
         TAGS = [
             'AndroidHandler',
             'MojoMain',
             'MojoShellActivity',
             'MojoShellApplication',
             'chromium',
         ]
-        subprocess.call(['adb', 'logcat', '-d', '-s'] + TAGS)
+        subprocess.call([ADB_PATH, 'logcat', '-d', '-s'] + TAGS)
 
     def _pull_system_libraries(self, system_libs_root):
         # Pull down the system libraries this pid has already mapped in.
         # TODO(eseidel): This does not handle dynamic loads.
         library_cacher_path = os.path.join(
             self.paths.sky_tools_directory, 'android_library_cacher.py')
         subprocess.call([
             library_cacher_path, system_libs_root, self.pids['mojo_shell_pid']
         ])
 
@@ skipping 48 matching lines @@
 
             # TODO(eseidel): We need to look up the toolchain somehow?
             gdb_path = os.path.join(SRC_ROOT, 'third_party/android_tools/ndk/'
                 'toolchains/arm-linux-androideabi-4.9/prebuilt/linux-x86_64/'
                 'bin/arm-linux-androideabi-gdb')
 
         # Set solib-search-path after letting android modify symbol_search_paths
         eval_commands.append(
             'set solib-search-path %s' % ':'.join(symbol_search_paths))
 
-        exec_command = ['/usr/bin/strace', '-o', 'trace.txt', gdb_path]
+        exec_command = [gdb_path]
         for command in eval_commands:
             exec_command += ['--eval-command', command]
 
         print " ".join(exec_command)
 
         # Write out our pid file before we exec ourselves.
         self._write_pid_file(PID_FILE_PATH, self.pids)
 
         # Exec gdb directly to avoid python intercepting symbols, etc.
         os.execv(exec_command[0], exec_command)
 
     def print_crash_command(self, args):
-        logcat_cmd = ['adb', 'logcat', '-d']
+        logcat_cmd = [ADB_PATH, 'logcat', '-d']
         logcat = subprocess.Popen(logcat_cmd, stdout=subprocess.PIPE)
 
         stack_path = os.path.join(SRC_ROOT,
             'tools', 'android_stack_parser', 'stack')
         stack = subprocess.Popen([stack_path, '-'], stdin=logcat.stdout)
         logcat.wait()
         stack.wait()
 
     def pids_command(self, args):
         print json.dumps(self.pids, indent=1)
@@ skipping 65 matching lines @@
         load_parser.set_defaults(func=self.load_command)
 
         args = parser.parse_args()
         args.func(args)
 
         self._write_pid_file(PID_FILE_PATH, self.pids)
 
 
 if __name__ == '__main__':
     SkyDebugger().main()