packages/flutter_tools/lib/src/commands/fuchsia_reload.dart - mirrors/flutter - Git at Google

 // Copyright 2017 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.

 import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';

 import '../artifacts.dart';
 import '../base/common.dart';
 import '../base/context.dart';
 import '../base/file_system.dart';
 import '../base/io.dart';
 import '../base/process_manager.dart';
 import '../base/terminal.dart';
 import '../base/utils.dart';
 import '../bundle.dart' as bundle;
 import '../cache.dart';
 import '../context_runner.dart';
 import '../device.dart';
 import '../fuchsia/fuchsia_device.dart';
 import '../globals.dart';
 import '../resident_runner.dart';
 import '../run_hot.dart';
 import '../runner/flutter_command.dart';
 import '../vmservice.dart';

 // Usage:
 // With e.g. hello_mod already running, a HotRunner can be attached to it.
 //
 // From a Fuchsia in-tree build:
 // $ flutter fuchsia_reload --address 192.168.1.39 \
 //       --build-dir ~/fuchsia/out/x64 \
 //       --gn-target //topaz/examples/ui/hello_mod:hello_mod
 //
 // From out of tree:
 // $ flutter fuchsia_reload --address 192.168.1.39 \
 //       --mod_name hello_mod \
 //       --path /path/to/hello_mod
 //       --dot-packages /path/to/hello_mod_out/app.packages \
 //       --ssh-config /path/to/ssh_config \
 //       --target /path/to/hello_mod/lib/main.dart

 final String ipv4Loopback = InternetAddress.loopbackIPv4.address;

 class FuchsiaReloadCommand extends FlutterCommand {
   FuchsiaReloadCommand() {
     addBuildModeFlags(defaultToRelease: false);
     argParser.addOption('frontend-server',
       abbr: 'f',
       help: 'The frontend server location');
     argParser.addOption('address',
       abbr: 'a',
       help: 'Fuchsia device network name or address.');
     argParser.addOption('build-dir',
       abbr: 'b',
       defaultsTo: null,
       help: 'Fuchsia build directory, e.g. out/release-x86-64.');
     argParser.addOption('dot-packages',
       abbr: 'd',
       defaultsTo: null,
       help: 'Path to the mod\'s .packages file. Required if no'
             'GN target specified.');
     argParser.addOption('gn-target',
       abbr: 'g',
       help: 'GN target of the application, e.g //path/to/app:app.');
     argParser.addOption('isolate-number',
       abbr: 'i',
       help: 'To reload only one instance, specify the isolate number, e.g. '
             'the number in foo\$main-###### given by --list.');
     argParser.addFlag('list',
       abbr: 'l',
       defaultsTo: false,
       help: 'Lists the running modules. ');
     argParser.addOption('mod-name',
       abbr: 'm',
       help: 'Name of the flutter mod. If used with -g, overrides the name '
             'inferred from the GN target.');
     argParser.addOption('path',
       abbr: 'p',
       defaultsTo: null,
       help: 'Path to the flutter mod project.');
     argParser.addOption('ssh-config',
       abbr: 's',
       defaultsTo: null,
       help: 'Path to the Fuchsia target\'s ssh config file.');
     argParser.addOption('target',
       abbr: 't',
       defaultsTo: bundle.defaultMainPath,
       help: 'Target app path / main entry-point file. '
             'Relative to --path or --gn-target path, e.g. lib/main.dart.');
   }

   @override
   final String name = 'fuchsia_reload';

   @override
   final String description = 'Hot reload on Fuchsia.';

   String _modName;
   String _isolateNumber;
   String _fuchsiaProjectPath;
   String _target;
   String _address;
   String _dotPackagesPath;
   String _sshConfig;
   File _frontendServerSnapshot;

   bool _list;

   @override
   Future<FlutterCommandResult> runCommand() async {
     Cache.releaseLockEarly();
     await _validateArguments();
     await runInContext<void>(() async {
       // Find the network ports used on the device by VM service instances.
       final List<int> deviceServicePorts = await _getServicePorts();
       if (deviceServicePorts.isEmpty)
         throwToolExit('Couldn\'t find any running Observatory instances.');
       for (int port in deviceServicePorts)
         printTrace('Fuchsia service port: $port');

       // Set up ssh tunnels to forward the device ports to local ports.
       final List<_PortForwarder> forwardedPorts = await _forwardPorts(deviceServicePorts);
       // Wrap everything in try/finally to make sure we kill the ssh processes
       // doing the port forwarding.
       try {
         final List<int> servicePorts = forwardedPorts.map<int>((_PortForwarder pf) => pf.port).toList();

         if (_list) {
           await _listVMs(servicePorts);
           // Port forwarding stops when the command ends. Keep the program running
           // until directed by the user so that Observatory URLs that we print
           // continue to work.
           printStatus('Press Enter to exit.');
           await stdin.first;
           return null;
         }

         // Check that there are running VM services on the returned
         // ports, and find the Isolates that are running the target app.
         final String isolateName = '$_modName\$main$_isolateNumber';
         final List<int> targetPorts = await _filterPorts(servicePorts, isolateName);
         if (targetPorts.isEmpty)
           throwToolExit('No VMs found running $_modName.');
         for (int port in targetPorts)
           printTrace('Found $_modName at $port');

         // Set up a device and hot runner and attach the hot runner to the first
         // vm service we found.
         final List<String> fullAddresses =
             targetPorts.map<String>((int p) => '$ipv4Loopback:$p').toList();
         final List<Uri> observatoryUris = fullAddresses
             .map<Uri>((String a) => Uri.parse('http://$a'))
             .toList();
         final FuchsiaDevice device =
             FuchsiaDevice(fullAddresses[0], name: _address);
         final FlutterDevice flutterDevice = FlutterDevice(
           device,
           trackWidgetCreation: false,
           viewFilter: isolateName,
         );
         flutterDevice.observatoryUris = observatoryUris;
           final HotRunner hotRunner = HotRunner(<FlutterDevice>[flutterDevice],
           debuggingOptions: DebuggingOptions.enabled(getBuildInfo()),
           target: _target,
           projectRootPath: _fuchsiaProjectPath,
               packagesFilePath: _dotPackagesPath);
         printStatus('Connecting to $_modName');
         await hotRunner.attach();
       } finally {
         await Future.wait<void>(forwardedPorts.map<Future<void>>((_PortForwarder pf) => pf.stop()));
       }
     }, overrides: <Type, Generator>{
       Artifacts: () => OverrideArtifacts(parent: artifacts, frontendServer: _frontendServerSnapshot),
     });
     return null;
   }

   // A cache of VMService connections.
   final HashMap<int, VMService> _vmServiceCache = HashMap<int, VMService>();

   Future<VMService> _getVMService(int port) async {
     if (!_vmServiceCache.containsKey(port)) {
       final String addr = 'http://$ipv4Loopback:$port';
       final Uri uri = Uri.parse(addr);
       final VMService vmService = await VMService.connect(uri);
       _vmServiceCache[port] = vmService;
     }
     return _vmServiceCache[port];
   }

   Future<List<FlutterView>> _getViews(List<int> ports) async {
     final List<FlutterView> views = <FlutterView>[];
     for (int port in ports) {
       final VMService vmService = await _getVMService(port);
       await vmService.getVM();
       await vmService.refreshViews();
       views.addAll(vmService.vm.views);
     }
     return views;
   }

   // Find ports where there is a view isolate with the given name
   Future<List<int>> _filterPorts(List<int> ports, String viewFilter) async {
     printTrace('Looing for view $viewFilter');
     final List<int> result = <int>[];
     for (FlutterView v in await _getViews(ports)) {
       if (v.uiIsolate == null)
         continue;
       final Uri addr = v.owner.vmService.httpAddress;
       printTrace('At $addr, found view: ${v.uiIsolate.name}');
       if (v.uiIsolate.name.contains(viewFilter))
         result.add(addr.port);
     }
     return result;
   }

   String _vmServiceToString(VMService vmService, {int tabDepth = 0}) {
     final Uri addr = vmService.httpAddress;
     final String embedder = vmService.vm.embedder;
     final int numIsolates = vmService.vm.isolates.length;
     final String maxRSS = getSizeAsMB(vmService.vm.maxRSS);
     final String heapSize = getSizeAsMB(vmService.vm.heapAllocatedMemoryUsage);
     int totalNewUsed = 0;
     int totalNewCap = 0;
     int totalOldUsed = 0;
     int totalOldCap = 0;
     int totalExternal = 0;
     for (Isolate i in vmService.vm.isolates) {
       totalNewUsed += i.newSpace.used;
       totalNewCap += i.newSpace.capacity;
       totalOldUsed += i.oldSpace.used;
       totalOldCap += i.oldSpace.capacity;
       totalExternal += i.newSpace.external;
       totalExternal += i.oldSpace.external;
     }
     final String newUsed = getSizeAsMB(totalNewUsed);
     final String newCap = getSizeAsMB(totalNewCap);
     final String oldUsed = getSizeAsMB(totalOldUsed);
     final String oldCap = getSizeAsMB(totalOldCap);
     final String external = getSizeAsMB(totalExternal);
     final String tabs = '\t' * tabDepth;
     final String extraTabs = '\t' * (tabDepth + 1);
     final StringBuffer stringBuffer = StringBuffer(
       '$tabs${terminal.bolden('$embedder at $addr')}\n'
       '${extraTabs}RSS: $maxRSS\n'
       '${extraTabs}Native allocations: $heapSize\n'
       '${extraTabs}New Spaces: $newUsed of $newCap\n'
       '${extraTabs}Old Spaces: $oldUsed of $oldCap\n'
       '${extraTabs}External: $external\n'
       '${extraTabs}Isolates: $numIsolates\n'
     );
     for (Isolate isolate in vmService.vm.isolates) {
       stringBuffer.write(_isolateToString(isolate, tabDepth: tabDepth + 1));
     }
     return stringBuffer.toString();
   }

   String _isolateToString(Isolate isolate, {int tabDepth = 0}) {
     final Uri vmServiceAddr = isolate.owner.vmService.httpAddress;
     final String name = isolate.name;
     final String shortName = name.substring(0, name.indexOf('\$'));
     const String main = '\$main-';
     final String number = name.substring(name.indexOf(main) + main.length);

     // The Observatory requires somewhat non-standard URIs that the Uri class
     // can't build for us, so instead we build them by hand.
     final String isolateIdQuery = '?isolateId=isolates%2F$number';
     final String isolateAddr = '$vmServiceAddr/#/inspect$isolateIdQuery';
     final String debuggerAddr = '$vmServiceAddr/#/debugger$isolateIdQuery';

     final String newUsed = getSizeAsMB(isolate.newSpace.used);
     final String newCap = getSizeAsMB(isolate.newSpace.capacity);
     final String newFreq = '${isolate.newSpace.avgCollectionTime.inMilliseconds}ms';
     final String newPer = '${isolate.newSpace.avgCollectionPeriod.inSeconds}s';
     final String oldUsed = getSizeAsMB(isolate.oldSpace.used);
     final String oldCap = getSizeAsMB(isolate.oldSpace.capacity);
     final String oldFreq = '${isolate.oldSpace.avgCollectionTime.inMilliseconds}ms';
     final String oldPer = '${isolate.oldSpace.avgCollectionPeriod.inSeconds}s';
     final String external = getSizeAsMB(isolate.newSpace.external + isolate.oldSpace.external);
     final String tabs = '\t' * tabDepth;
     final String extraTabs = '\t' * (tabDepth + 1);
     return
       '$tabs${terminal.bolden(shortName)}\n'
       '${extraTabs}Isolate number: $number\n'
       '${extraTabs}Observatory: $isolateAddr\n'
       '${extraTabs}Debugger: $debuggerAddr\n'
       '${extraTabs}New gen: $newUsed used of $newCap, GC: $newFreq every $newPer\n'
       '${extraTabs}Old gen: $oldUsed used of $oldCap, GC: $oldFreq every $oldPer\n'
       '${extraTabs}External: $external\n';
   }

   Future<void> _listVMs(List<int> ports) async {
     for (int port in ports) {
       final VMService vmService = await _getVMService(port);
       await vmService.getVM();
       await vmService.refreshViews();
       printStatus(_vmServiceToString(vmService));
     }
   }

   Future<void> _validateArguments() async {
     final String fuchsiaBuildDir = argResults['build-dir'];
     final String gnTarget = argResults['gn-target'];
     _frontendServerSnapshot = fs.file(argResults['frontend-server']);

     if (!_frontendServerSnapshot.existsSync()) {
       throwToolExit('Must provide a frontend-server snapshot');
     }

     if (fuchsiaBuildDir != null) {
       if (gnTarget == null)
         throwToolExit('Must provide --gn-target when specifying --build-dir.');

       if (!_directoryExists(fuchsiaBuildDir))
         throwToolExit('Specified --build-dir "$fuchsiaBuildDir" does not exist.');

       _sshConfig = '$fuchsiaBuildDir/ssh-keys/ssh_config';
     }

     // If sshConfig path not available from the fuchsiaBuildDir, get from command line.
     _sshConfig ??= argResults['ssh-config'];
     if (_sshConfig == null)
       throwToolExit('Provide the path to the ssh config file with --ssh-config.');
     if (!_fileExists(_sshConfig))
       throwToolExit('Couldn\'t find ssh config file at $_sshConfig.');

     _address = argResults['address'];
     if (_address == null && fuchsiaBuildDir != null) {
       final ProcessResult result = await processManager.run(<String>['fx', 'netaddr', '--fuchsia']);
       if (result.exitCode == 0)
         _address = result.stdout.trim();
       else
         printStatus('netaddr failed:\nstdout: ${result.stdout}\nstderr: ${result.stderr}');
     }
     if (_address == null)
       throwToolExit('Give the address of the device running Fuchsia with --address.');

     _list = argResults['list'];
     if (_list) {
       // For --list, we only need the ssh config and device address.
       return;
     }

     String projectRoot;
     if (gnTarget != null) {
       if (fuchsiaBuildDir == null)
         throwToolExit('Must provide --build-dir when specifying --gn-target.');

       final List<String> targetInfo = _extractPathAndName(gnTarget);
       projectRoot = targetInfo[0];
       _modName = targetInfo[1];
       _fuchsiaProjectPath = '$fuchsiaBuildDir/../../$projectRoot';
     } else if (argResults['path'] != null) {
       _fuchsiaProjectPath = argResults['path'];
     }

     if (_fuchsiaProjectPath == null)
       throwToolExit('Provide the mod project path with --path.');
     if (!_directoryExists(_fuchsiaProjectPath))
       throwToolExit('Cannot locate project at $_fuchsiaProjectPath.');

     final String relativeTarget = argResults['target'];
     if (relativeTarget == null)
       throwToolExit('Give the application entry point with --target.');
     _target = '$_fuchsiaProjectPath/$relativeTarget';
     if (!_fileExists(_target))
       throwToolExit('Couldn\'t find application entry point at $_target.');

     if (argResults['mod-name'] != null)
       _modName = argResults['mod-name'];
     if (_modName == null)
       throwToolExit('Provide the mod name with --mod-name.');

     if (argResults['dot-packages'] != null) {
       _dotPackagesPath = argResults['dot-packages'];
     } else if (fuchsiaBuildDir != null) {
       final String packagesFileName = '${_modName}_dart_library.packages';
       _dotPackagesPath = '$fuchsiaBuildDir/dartlang/gen/$projectRoot/$packagesFileName';
     }
     if (_dotPackagesPath == null)
       throwToolExit('Provide the .packages path with --dot-packages.');
     if (!_fileExists(_dotPackagesPath))
       throwToolExit('Couldn\'t find .packages file at $_dotPackagesPath.');

     final String isolateNumber = argResults['isolate-number'];
     if (isolateNumber == null) {
       _isolateNumber = '';
     } else {
       _isolateNumber = '-$isolateNumber';
     }
   }

   List<String> _extractPathAndName(String gnTarget) {
     final String errorMessage =
       'fuchsia_reload --target "$gnTarget" should have the form: '
       '"//path/to/app:name"';
     // Separate strings like //path/to/target:app into [path/to/target, app]
     final int lastColon = gnTarget.lastIndexOf(':');
     if (lastColon < 0)
       throwToolExit(errorMessage);
     final String name = gnTarget.substring(lastColon + 1);
     // Skip '//' and chop off after :
     if ((gnTarget.length < 3) || (gnTarget[0] != '/') || (gnTarget[1] != '/'))
       throwToolExit(errorMessage);
     final String path = gnTarget.substring(2, lastColon);
     return <String>[path, name];
   }

   Future<List<_PortForwarder>> _forwardPorts(List<int> remotePorts) async {
     final List<_PortForwarder> forwarders = <_PortForwarder>[];
     for (int port in remotePorts) {
       final _PortForwarder f =
           await _PortForwarder.start(_sshConfig, _address, port);
       forwarders.add(f);
     }
     return forwarders;
   }

   Future<List<int>> _getServicePorts() async {
     final FuchsiaDeviceCommandRunner runner =
         FuchsiaDeviceCommandRunner(_address, _sshConfig);
     final List<String> lsOutput = await runner.run('ls /tmp/dart.services');
     final List<int> ports = <int>[];
     if (lsOutput != null) {
       for (String s in lsOutput) {
         final String trimmed = s.trim();
         final int lastSpace = trimmed.lastIndexOf(' ');
         final String lastWord = trimmed.substring(lastSpace + 1);
         if ((lastWord != '.') && (lastWord != '..')) {

           final int value = int.tryParse(lastWord);
           if (value != null)
             ports.add(value);
         }
       }
     }
     return ports;
   }

   bool _directoryExists(String path) {
     final Directory d = fs.directory(path);
     return d.existsSync();
   }

   bool _fileExists(String path) {
     final File f = fs.file(path);
     return f.existsSync();
   }
 }

 // Instances of this class represent a running ssh tunnel from the host to a
 // VM service running on a Fuchsia device. [process] is the ssh process running
 // the tunnel and [port] is the local port.
 class _PortForwarder {
   _PortForwarder._(this._remoteAddress,
                    this._remotePort,
                    this._localPort,
                    this._process,
                    this._sshConfig);

   final String _remoteAddress;
   final int _remotePort;
   final int _localPort;
   final Process _process;
   final String _sshConfig;

   int get port => _localPort;

   static Future<_PortForwarder> start(String sshConfig,
                                       String address,
                                       int remotePort) async {
     final int localPort = await _potentiallyAvailablePort();
     if (localPort == 0) {
       printStatus(
           '_PortForwarder failed to find a local port for $address:$remotePort');
       return _PortForwarder._(null, 0, 0, null, null);
     }
     const String dummyRemoteCommand = 'date';
     final List<String> command = <String>[
         'ssh', '-F', sshConfig, '-nNT', '-vvv', '-f',
         '-L', '$localPort:$ipv4Loopback:$remotePort', address, dummyRemoteCommand];
     printTrace("_PortForwarder running '${command.join(' ')}'");
     final Process process = await processManager.start(command);
     process.stderr
         .transform<String>(utf8.decoder)
         .transform<String>(const LineSplitter())
         .listen((String data) { printTrace(data); });
     // Best effort to print the exit code.
     process.exitCode.then<void>((int c) { // ignore: unawaited_futures
       printTrace("'${command.join(' ')}' exited with exit code $c");
     });
     printTrace('Set up forwarding from $localPort to $address:$remotePort');
     return _PortForwarder._(address, remotePort, localPort, process, sshConfig);
   }

   Future<void> stop() async {
     // Kill the original ssh process if it is still around.
     if (_process != null) {
       printTrace('_PortForwarder killing ${_process.pid} for port $_localPort');
       _process.kill();
     }
     // Cancel the forwarding request.
     final List<String> command = <String>[
         'ssh', '-F', _sshConfig, '-O', 'cancel', '-vvv',
         '-L', '$_localPort:$ipv4Loopback:$_remotePort', _remoteAddress];
     final ProcessResult result = await processManager.run(command);
     printTrace(command.join(' '));
     if (result.exitCode != 0) {
       printTrace('Command failed:\nstdout: ${result.stdout}\nstderr: ${result.stderr}');
     }
   }

   static Future<int> _potentiallyAvailablePort() async {
     int port = 0;
     ServerSocket s;
     try {
       s = await ServerSocket.bind(ipv4Loopback, 0);
       port = s.port;
     } catch (e) {
       // Failures are signaled by a return value of 0 from this function.
       printTrace('_potentiallyAvailablePort failed: $e');
     }
     if (s != null)
       await s.close();
     return port;
   }
 }

 class FuchsiaDeviceCommandRunner {
   FuchsiaDeviceCommandRunner(this._address, this._sshConfig);

   final String _address;
   final String _sshConfig;

   Future<List<String>> run(String command) async {
     final List<String> args = <String>['ssh', '-F', _sshConfig, _address, command];
     printTrace(args.join(' '));
     final ProcessResult result = await processManager.run(args);
     if (result.exitCode != 0) {
       printStatus('Command failed: $command\nstdout: ${result.stdout}\nstderr: ${result.stderr}');
       return null;
     }
     printTrace(result.stdout);
     return result.stdout.split('\n');
   }
 }
	// Copyright 2017 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.

	import 'dart:async';
	import 'dart:collection';
	import 'dart:convert';

	import '../artifacts.dart';
	import '../base/common.dart';
	import '../base/context.dart';
	import '../base/file_system.dart';
	import '../base/io.dart';
	import '../base/process_manager.dart';
	import '../base/terminal.dart';
	import '../base/utils.dart';
	import '../bundle.dart' as bundle;
	import '../cache.dart';
	import '../context_runner.dart';
	import '../device.dart';
	import '../fuchsia/fuchsia_device.dart';
	import '../globals.dart';
	import '../resident_runner.dart';
	import '../run_hot.dart';
	import '../runner/flutter_command.dart';
	import '../vmservice.dart';

	// Usage:
	// With e.g. hello_mod already running, a HotRunner can be attached to it.
	//
	// From a Fuchsia in-tree build:
	// $ flutter fuchsia_reload --address 192.168.1.39 \
	// --build-dir ~/fuchsia/out/x64 \
	// --gn-target //topaz/examples/ui/hello_mod:hello_mod
	//
	// From out of tree:
	// $ flutter fuchsia_reload --address 192.168.1.39 \
	// --mod_name hello_mod \
	// --path /path/to/hello_mod
	// --dot-packages /path/to/hello_mod_out/app.packages \
	// --ssh-config /path/to/ssh_config \
	// --target /path/to/hello_mod/lib/main.dart

	final String ipv4Loopback = InternetAddress.loopbackIPv4.address;

	class FuchsiaReloadCommand extends FlutterCommand {
	FuchsiaReloadCommand() {
	addBuildModeFlags(defaultToRelease: false);
	argParser.addOption('frontend-server',
	abbr: 'f',
	help: 'The frontend server location');
	argParser.addOption('address',
	abbr: 'a',
	help: 'Fuchsia device network name or address.');
	argParser.addOption('build-dir',
	abbr: 'b',
	defaultsTo: null,
	help: 'Fuchsia build directory, e.g. out/release-x86-64.');
	argParser.addOption('dot-packages',
	abbr: 'd',
	defaultsTo: null,
	help: 'Path to the mod\'s .packages file. Required if no'
	'GN target specified.');
	argParser.addOption('gn-target',
	abbr: 'g',
	help: 'GN target of the application, e.g //path/to/app:app.');
	argParser.addOption('isolate-number',
	abbr: 'i',
	help: 'To reload only one instance, specify the isolate number, e.g. '
	'the number in foo\$main-###### given by --list.');
	argParser.addFlag('list',
	abbr: 'l',
	defaultsTo: false,
	help: 'Lists the running modules. ');
	argParser.addOption('mod-name',
	abbr: 'm',
	help: 'Name of the flutter mod. If used with -g, overrides the name '
	'inferred from the GN target.');
	argParser.addOption('path',
	abbr: 'p',
	defaultsTo: null,
	help: 'Path to the flutter mod project.');
	argParser.addOption('ssh-config',
	abbr: 's',
	defaultsTo: null,
	help: 'Path to the Fuchsia target\'s ssh config file.');
	argParser.addOption('target',
	abbr: 't',
	defaultsTo: bundle.defaultMainPath,
	help: 'Target app path / main entry-point file. '
	'Relative to --path or --gn-target path, e.g. lib/main.dart.');
	}

	@override
	final String name = 'fuchsia_reload';

	@override
	final String description = 'Hot reload on Fuchsia.';

	String _modName;
	String _isolateNumber;
	String _fuchsiaProjectPath;
	String _target;
	String _address;
	String _dotPackagesPath;
	String _sshConfig;
	File _frontendServerSnapshot;

	bool _list;

	@override
	Future<FlutterCommandResult> runCommand() async {
	Cache.releaseLockEarly();
	await _validateArguments();
	await runInContext<void>(() async {
	// Find the network ports used on the device by VM service instances.
	final List<int> deviceServicePorts = await _getServicePorts();
	if (deviceServicePorts.isEmpty)
	throwToolExit('Couldn\'t find any running Observatory instances.');
	for (int port in deviceServicePorts)
	printTrace('Fuchsia service port: $port');

	// Set up ssh tunnels to forward the device ports to local ports.
	final List<_PortForwarder> forwardedPorts = await _forwardPorts(deviceServicePorts);
	// Wrap everything in try/finally to make sure we kill the ssh processes
	// doing the port forwarding.
	try {
	final List<int> servicePorts = forwardedPorts.map<int>((_PortForwarder pf) => pf.port).toList();

	if (_list) {
	await _listVMs(servicePorts);
	// Port forwarding stops when the command ends. Keep the program running
	// until directed by the user so that Observatory URLs that we print
	// continue to work.
	printStatus('Press Enter to exit.');
	await stdin.first;
	return null;
	}

	// Check that there are running VM services on the returned
	// ports, and find the Isolates that are running the target app.
	final String isolateName = '$_modName\$main$_isolateNumber';
	final List<int> targetPorts = await _filterPorts(servicePorts, isolateName);
	if (targetPorts.isEmpty)
	throwToolExit('No VMs found running $_modName.');
	for (int port in targetPorts)
	printTrace('Found $_modName at $port');

	// Set up a device and hot runner and attach the hot runner to the first
	// vm service we found.
	final List<String> fullAddresses =
	targetPorts.map<String>((int p) => '$ipv4Loopback:$p').toList();
	final List<Uri> observatoryUris = fullAddresses
	.map<Uri>((String a) => Uri.parse('http://$a'))
	.toList();
	final FuchsiaDevice device =
	FuchsiaDevice(fullAddresses[0], name: _address);
	final FlutterDevice flutterDevice = FlutterDevice(
	device,
	trackWidgetCreation: false,
	viewFilter: isolateName,
	);
	flutterDevice.observatoryUris = observatoryUris;
	final HotRunner hotRunner = HotRunner(<FlutterDevice>[flutterDevice],
	debuggingOptions: DebuggingOptions.enabled(getBuildInfo()),
	target: _target,
	projectRootPath: _fuchsiaProjectPath,
	packagesFilePath: _dotPackagesPath);
	printStatus('Connecting to $_modName');
	await hotRunner.attach();
	} finally {
	await Future.wait<void>(forwardedPorts.map<Future<void>>((_PortForwarder pf) => pf.stop()));
	}
	}, overrides: <Type, Generator>{
	Artifacts: () => OverrideArtifacts(parent: artifacts, frontendServer: _frontendServerSnapshot),
	});
	return null;
	}

	// A cache of VMService connections.
	final HashMap<int, VMService> _vmServiceCache = HashMap<int, VMService>();

	Future<VMService> _getVMService(int port) async {
	if (!_vmServiceCache.containsKey(port)) {
	final String addr = 'http://$ipv4Loopback:$port';
	final Uri uri = Uri.parse(addr);
	final VMService vmService = await VMService.connect(uri);
	_vmServiceCache[port] = vmService;
	}
	return _vmServiceCache[port];
	}

	Future<List<FlutterView>> _getViews(List<int> ports) async {
	final List<FlutterView> views = <FlutterView>[];
	for (int port in ports) {
	final VMService vmService = await _getVMService(port);
	await vmService.getVM();
	await vmService.refreshViews();
	views.addAll(vmService.vm.views);
	}
	return views;
	}

	// Find ports where there is a view isolate with the given name
	Future<List<int>> _filterPorts(List<int> ports, String viewFilter) async {
	printTrace('Looing for view $viewFilter');
	final List<int> result = <int>[];
	for (FlutterView v in await _getViews(ports)) {
	if (v.uiIsolate == null)
	continue;
	final Uri addr = v.owner.vmService.httpAddress;
	printTrace('At $addr, found view: ${v.uiIsolate.name}');
	if (v.uiIsolate.name.contains(viewFilter))
	result.add(addr.port);
	}
	return result;
	}

	String _vmServiceToString(VMService vmService, {int tabDepth = 0}) {
	final Uri addr = vmService.httpAddress;
	final String embedder = vmService.vm.embedder;
	final int numIsolates = vmService.vm.isolates.length;
	final String maxRSS = getSizeAsMB(vmService.vm.maxRSS);
	final String heapSize = getSizeAsMB(vmService.vm.heapAllocatedMemoryUsage);
	int totalNewUsed = 0;
	int totalNewCap = 0;
	int totalOldUsed = 0;
	int totalOldCap = 0;
	int totalExternal = 0;
	for (Isolate i in vmService.vm.isolates) {
	totalNewUsed += i.newSpace.used;
	totalNewCap += i.newSpace.capacity;
	totalOldUsed += i.oldSpace.used;
	totalOldCap += i.oldSpace.capacity;
	totalExternal += i.newSpace.external;
	totalExternal += i.oldSpace.external;
	}
	final String newUsed = getSizeAsMB(totalNewUsed);
	final String newCap = getSizeAsMB(totalNewCap);
	final String oldUsed = getSizeAsMB(totalOldUsed);
	final String oldCap = getSizeAsMB(totalOldCap);
	final String external = getSizeAsMB(totalExternal);
	final String tabs = '\t' * tabDepth;
	final String extraTabs = '\t' * (tabDepth + 1);
	final StringBuffer stringBuffer = StringBuffer(
	'$tabs${terminal.bolden('$embedder at $addr')}\n'
	'${extraTabs}RSS: $maxRSS\n'
	'${extraTabs}Native allocations: $heapSize\n'
	'${extraTabs}New Spaces: $newUsed of $newCap\n'
	'${extraTabs}Old Spaces: $oldUsed of $oldCap\n'
	'${extraTabs}External: $external\n'
	'${extraTabs}Isolates: $numIsolates\n'
	);
	for (Isolate isolate in vmService.vm.isolates) {
	stringBuffer.write(_isolateToString(isolate, tabDepth: tabDepth + 1));
	}
	return stringBuffer.toString();
	}

	String _isolateToString(Isolate isolate, {int tabDepth = 0}) {
	final Uri vmServiceAddr = isolate.owner.vmService.httpAddress;
	final String name = isolate.name;
	final String shortName = name.substring(0, name.indexOf('\$'));
	const String main = '\$main-';
	final String number = name.substring(name.indexOf(main) + main.length);

	// The Observatory requires somewhat non-standard URIs that the Uri class
	// can't build for us, so instead we build them by hand.
	final String isolateIdQuery = '?isolateId=isolates%2F$number';
	final String isolateAddr = '$vmServiceAddr/#/inspect$isolateIdQuery';
	final String debuggerAddr = '$vmServiceAddr/#/debugger$isolateIdQuery';

	final String newUsed = getSizeAsMB(isolate.newSpace.used);
	final String newCap = getSizeAsMB(isolate.newSpace.capacity);
	final String newFreq = '${isolate.newSpace.avgCollectionTime.inMilliseconds}ms';
	final String newPer = '${isolate.newSpace.avgCollectionPeriod.inSeconds}s';
	final String oldUsed = getSizeAsMB(isolate.oldSpace.used);
	final String oldCap = getSizeAsMB(isolate.oldSpace.capacity);
	final String oldFreq = '${isolate.oldSpace.avgCollectionTime.inMilliseconds}ms';
	final String oldPer = '${isolate.oldSpace.avgCollectionPeriod.inSeconds}s';
	final String external = getSizeAsMB(isolate.newSpace.external + isolate.oldSpace.external);
	final String tabs = '\t' * tabDepth;
	final String extraTabs = '\t' * (tabDepth + 1);
	return
	'$tabs${terminal.bolden(shortName)}\n'
	'${extraTabs}Isolate number: $number\n'
	'${extraTabs}Observatory: $isolateAddr\n'
	'${extraTabs}Debugger: $debuggerAddr\n'
	'${extraTabs}New gen: $newUsed used of $newCap, GC: $newFreq every $newPer\n'
	'${extraTabs}Old gen: $oldUsed used of $oldCap, GC: $oldFreq every $oldPer\n'
	'${extraTabs}External: $external\n';
	}

	Future<void> _listVMs(List<int> ports) async {
	for (int port in ports) {
	final VMService vmService = await _getVMService(port);
	await vmService.getVM();
	await vmService.refreshViews();
	printStatus(_vmServiceToString(vmService));
	}
	}

	Future<void> _validateArguments() async {
	final String fuchsiaBuildDir = argResults['build-dir'];
	final String gnTarget = argResults['gn-target'];
	_frontendServerSnapshot = fs.file(argResults['frontend-server']);

	if (!_frontendServerSnapshot.existsSync()) {
	throwToolExit('Must provide a frontend-server snapshot');
	}

	if (fuchsiaBuildDir != null) {
	if (gnTarget == null)
	throwToolExit('Must provide --gn-target when specifying --build-dir.');

	if (!_directoryExists(fuchsiaBuildDir))
	throwToolExit('Specified --build-dir "$fuchsiaBuildDir" does not exist.');

	_sshConfig = '$fuchsiaBuildDir/ssh-keys/ssh_config';
	}

	// If sshConfig path not available from the fuchsiaBuildDir, get from command line.
	_sshConfig ??= argResults['ssh-config'];
	if (_sshConfig == null)
	throwToolExit('Provide the path to the ssh config file with --ssh-config.');
	if (!_fileExists(_sshConfig))
	throwToolExit('Couldn\'t find ssh config file at $_sshConfig.');

	_address = argResults['address'];
	if (_address == null && fuchsiaBuildDir != null) {
	final ProcessResult result = await processManager.run(<String>['fx', 'netaddr', '--fuchsia']);
	if (result.exitCode == 0)
	_address = result.stdout.trim();
	else
	printStatus('netaddr failed:\nstdout: ${result.stdout}\nstderr: ${result.stderr}');
	}
	if (_address == null)
	throwToolExit('Give the address of the device running Fuchsia with --address.');

	_list = argResults['list'];
	if (_list) {
	// For --list, we only need the ssh config and device address.
	return;
	}

	String projectRoot;
	if (gnTarget != null) {
	if (fuchsiaBuildDir == null)
	throwToolExit('Must provide --build-dir when specifying --gn-target.');

	final List<String> targetInfo = _extractPathAndName(gnTarget);
	projectRoot = targetInfo[0];
	_modName = targetInfo[1];
	_fuchsiaProjectPath = '$fuchsiaBuildDir/../../$projectRoot';
	} else if (argResults['path'] != null) {
	_fuchsiaProjectPath = argResults['path'];
	}

	if (_fuchsiaProjectPath == null)
	throwToolExit('Provide the mod project path with --path.');
	if (!_directoryExists(_fuchsiaProjectPath))
	throwToolExit('Cannot locate project at $_fuchsiaProjectPath.');

	final String relativeTarget = argResults['target'];
	if (relativeTarget == null)
	throwToolExit('Give the application entry point with --target.');
	_target = '$_fuchsiaProjectPath/$relativeTarget';
	if (!_fileExists(_target))
	throwToolExit('Couldn\'t find application entry point at $_target.');

	if (argResults['mod-name'] != null)
	_modName = argResults['mod-name'];
	if (_modName == null)
	throwToolExit('Provide the mod name with --mod-name.');

	if (argResults['dot-packages'] != null) {
	_dotPackagesPath = argResults['dot-packages'];
	} else if (fuchsiaBuildDir != null) {
	final String packagesFileName = '${_modName}_dart_library.packages';
	_dotPackagesPath = '$fuchsiaBuildDir/dartlang/gen/$projectRoot/$packagesFileName';
	}
	if (_dotPackagesPath == null)
	throwToolExit('Provide the .packages path with --dot-packages.');
	if (!_fileExists(_dotPackagesPath))
	throwToolExit('Couldn\'t find .packages file at $_dotPackagesPath.');

	final String isolateNumber = argResults['isolate-number'];
	if (isolateNumber == null) {
	_isolateNumber = '';
	} else {
	_isolateNumber = '-$isolateNumber';
	}
	}

	List<String> _extractPathAndName(String gnTarget) {
	final String errorMessage =
	'fuchsia_reload --target "$gnTarget" should have the form: '
	'"//path/to/app:name"';
	// Separate strings like //path/to/target:app into [path/to/target, app]
	final int lastColon = gnTarget.lastIndexOf(':');
	if (lastColon < 0)
	throwToolExit(errorMessage);
	final String name = gnTarget.substring(lastColon + 1);
	// Skip '//' and chop off after :
	if ((gnTarget.length < 3) \|\| (gnTarget[0] != '/') \|\| (gnTarget[1] != '/'))
	throwToolExit(errorMessage);
	final String path = gnTarget.substring(2, lastColon);
	return <String>[path, name];
	}

	Future<List<_PortForwarder>> _forwardPorts(List<int> remotePorts) async {
	final List<_PortForwarder> forwarders = <_PortForwarder>[];
	for (int port in remotePorts) {
	final _PortForwarder f =
	await _PortForwarder.start(_sshConfig, _address, port);
	forwarders.add(f);
	}
	return forwarders;
	}

	Future<List<int>> _getServicePorts() async {
	final FuchsiaDeviceCommandRunner runner =
	FuchsiaDeviceCommandRunner(_address, _sshConfig);
	final List<String> lsOutput = await runner.run('ls /tmp/dart.services');
	final List<int> ports = <int>[];
	if (lsOutput != null) {
	for (String s in lsOutput) {
	final String trimmed = s.trim();
	final int lastSpace = trimmed.lastIndexOf(' ');
	final String lastWord = trimmed.substring(lastSpace + 1);
	if ((lastWord != '.') && (lastWord != '..')) {

	final int value = int.tryParse(lastWord);
	if (value != null)
	ports.add(value);
	}
	}
	}
	return ports;
	}

	bool _directoryExists(String path) {
	final Directory d = fs.directory(path);
	return d.existsSync();
	}

	bool _fileExists(String path) {
	final File f = fs.file(path);
	return f.existsSync();
	}
	}

	// Instances of this class represent a running ssh tunnel from the host to a
	// VM service running on a Fuchsia device. [process] is the ssh process running
	// the tunnel and [port] is the local port.
	class _PortForwarder {
	_PortForwarder._(this._remoteAddress,
	this._remotePort,
	this._localPort,
	this._process,
	this._sshConfig);

	final String _remoteAddress;
	final int _remotePort;
	final int _localPort;
	final Process _process;
	final String _sshConfig;

	int get port => _localPort;

	static Future<_PortForwarder> start(String sshConfig,
	String address,
	int remotePort) async {
	final int localPort = await _potentiallyAvailablePort();
	if (localPort == 0) {
	printStatus(
	'_PortForwarder failed to find a local port for $address:$remotePort');
	return _PortForwarder._(null, 0, 0, null, null);
	}
	const String dummyRemoteCommand = 'date';
	final List<String> command = <String>[
	'ssh', '-F', sshConfig, '-nNT', '-vvv', '-f',
	'-L', '$localPort:$ipv4Loopback:$remotePort', address, dummyRemoteCommand];
	printTrace("_PortForwarder running '${command.join(' ')}'");
	final Process process = await processManager.start(command);
	process.stderr
	.transform<String>(utf8.decoder)
	.transform<String>(const LineSplitter())
	.listen((String data) { printTrace(data); });
	// Best effort to print the exit code.
	process.exitCode.then<void>((int c) { // ignore: unawaited_futures
	printTrace("'${command.join(' ')}' exited with exit code $c");
	});
	printTrace('Set up forwarding from $localPort to $address:$remotePort');
	return _PortForwarder._(address, remotePort, localPort, process, sshConfig);
	}

	Future<void> stop() async {
	// Kill the original ssh process if it is still around.
	if (_process != null) {
	printTrace('_PortForwarder killing ${_process.pid} for port $_localPort');
	_process.kill();
	}
	// Cancel the forwarding request.
	final List<String> command = <String>[
	'ssh', '-F', _sshConfig, '-O', 'cancel', '-vvv',
	'-L', '$_localPort:$ipv4Loopback:$_remotePort', _remoteAddress];
	final ProcessResult result = await processManager.run(command);
	printTrace(command.join(' '));
	if (result.exitCode != 0) {
	printTrace('Command failed:\nstdout: ${result.stdout}\nstderr: ${result.stderr}');
	}
	}

	static Future<int> _potentiallyAvailablePort() async {
	int port = 0;
	ServerSocket s;
	try {
	s = await ServerSocket.bind(ipv4Loopback, 0);
	port = s.port;
	} catch (e) {
	// Failures are signaled by a return value of 0 from this function.
	printTrace('_potentiallyAvailablePort failed: $e');
	}
	if (s != null)
	await s.close();
	return port;
	}
	}

	class FuchsiaDeviceCommandRunner {
	FuchsiaDeviceCommandRunner(this._address, this._sshConfig);

	final String _address;
	final String _sshConfig;

	Future<List<String>> run(String command) async {
	final List<String> args = <String>['ssh', '-F', _sshConfig, _address, command];
	printTrace(args.join(' '));
	final ProcessResult result = await processManager.run(args);
	if (result.exitCode != 0) {
	printStatus('Command failed: $command\nstdout: ${result.stdout}\nstderr: ${result.stderr}');
	return null;
	}
	printTrace(result.stdout);
	return result.stdout.split('\n');
	}
	}