Split skydb trace into start_tracing and stop_tracing

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
@@ skipping 270 matching lines @@
             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._send_command_to_sky('/quit')
+        # 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)
 
         if 'remote_sky_command_port' in self.pids:
@@ skipping 17 matching lines @@
 
     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._send_command_to_sky('/load', url)
+        self._run_basic_command('/load', url)
 
     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
+        trace = self._send_command_to_sky('/stop_tracing').content
+        with open(file_name, "wb") as trace_file:
+            trace_file.write(trace)
+        print "Trace saved in %s" % file_name
+
     def stop_profiling_command(self, args):
-        self._send_command_to_sky('/stop_profiling')
+        self._run_basic_command('/stop_profiling')
         mojo_map = self._read_mojo_map()
 
         # TODO(eseidel): We should have a helper for resolving urls, etc.
         remote_server_port = self.pids.get('remote_sky_server_port', self.pids['sky_server_port'])
         build_dir_url = SkyServer.url_for_path(
             remote_server_port,
             self.pids['sky_server_root'],
             self.pids['build_dir'])
 
         # Map /tmp cache paths to urls and then to local build_dir paths.
@@ skipping 23 matching lines @@
     def _command_base_url(self):
         return 'http://localhost:%s' % self.pids['sky_command_port']
 
     def _send_command_to_sky(self, command_path, payload=None):
         url = 'http://localhost:%s%s' % (
             self.pids['sky_command_port'], command_path)
         if payload:
             response = requests.post(url, payload)
         else:
             response = requests.get(url)
-        print response.text
+        return response
+
+    def _run_basic_command(self, command_path, payload=None):
+        print self._send_command_to_sky(command_path, payload=payload).text
 
     # FIXME: These could be made into a context object with __enter__/__exit__.
     def _load_pid_file(self, path):
         try:
             with open(path, 'r') as pid_file:
                 return json.load(pid_file)
         except:
             if os.path.exists(path):
                 logging.warn('Failed to read pid file: %s' % path)
             return {}
 
     def _write_pid_file(self, path, pids):
         try:
             with open(path, 'w') as pid_file:
                 json.dump(pids, pid_file, indent=2, sort_keys=True)
         except:
             logging.warn('Failed to write pid file: %s' % path)
 
     def _add_basic_command(self, subparsers, name, url_path, help_text):
         parser = subparsers.add_parser(name, help=help_text)
-        command = lambda args: self._send_command_to_sky(url_path)
+        command = lambda args: self._run_basic_command(url_path)
         parser.set_defaults(func=command)
 
     def _wait_for_sky_command_port(self):
         tries = 0
         while True:
             try:
-                self._send_command_to_sky('/')
+                self._run_basic_command('/')
                 return True
             except:
                 tries += 1
                 if tries == 3:
                     logging.warn('Still waiting for sky on port %s' %
                         self.pids['sky_command_port'])
                 if tries > 10:
                     return False
                 time.sleep(1)
 
@@ skipping 135 matching lines @@
         logcat_parser.set_defaults(func=self.logcat_command)
 
         print_crash_parser = subparsers.add_parser('print_crash',
             help=('dump (and symbolicate) recent crash-stacks'))
         print_crash_parser.set_defaults(func=self.print_crash_command)
 
         gdb_attach_parser = subparsers.add_parser('gdb_attach',
             help='launch gdb and attach to gdbserver launched from start --gdb')
         gdb_attach_parser.set_defaults(func=self.gdb_attach_command)
 
-        self._add_basic_command(subparsers, 'trace', '/trace',
-            'toggle tracing')
+        self._add_basic_command(subparsers, 'start_tracing', '/start_tracing',
+            'starts tracing the running sky instance')
         self._add_basic_command(subparsers, 'reload', '/reload',
             'reload the current page')
         self._add_basic_command(subparsers, 'inspect', '/inspect',
             'start the inspector on the current page (Linux only)')
         self._add_basic_command(subparsers, 'start_profiling', '/start_profiling',
             'starts profiling the running sky instance (Linux only)')
 
+        stop_tracing_parser = subparsers.add_parser('stop_tracing',
+            help='stops tracing the running sky instance')
+        stop_tracing_parser.add_argument('file_name', type=str, default='sky_viewer.trace')
+        stop_tracing_parser.set_defaults(func=self.stop_tracing_command)
+
         stop_profiling_parser = subparsers.add_parser('stop_profiling',
             help='stops profiling the running sky instance (Linux only)')
         stop_profiling_parser.set_defaults(func=self.stop_profiling_command)
 
         load_parser = subparsers.add_parser('load',
             help='load a new page in the currently running sky')
         load_parser.add_argument('url_or_path', type=str)
         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()