firka/flutter
3
0
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

revert handle new Observatory URL (#7056)

Browse Source 
737a55ef3e
This commit is contained in:
Dan Rubel
2016-11-28 16:15:19 -05:00
committed by GitHub
parent f36b218ed3
commit fcf41fc737
12 changed files with 126 additions and 154 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
packages/flutter_tools/lib/src/android/android_device.dart
View File

@@ -259,15 +259,14 @@ class AndroidDevice extends Device {
return true;
}
Future<Uri> _forwardUriToNewPort(String service, Uri deviceUri, int port) async {
Future<int> _forwardPort(String service, int devicePort, int port) async {
try {
// Set up port forwarding for observatory.
port = await portForwarder.forward(deviceUri.port, hostPort: port);
Uri localUri = deviceUri.replace(port: port);
printTrace('$service listening on $localUri');
return localUri;
port = await portForwarder.forward(devicePort, hostPort: port);
printTrace('$service listening on http://127.0.0.1:$port');
return port;
} catch (e) {
printError('Unable to forward device port ${deviceUri.port} to $port: $e');
printError('Unable to forward port $port: $e');
}
return null;
}
@@ -356,35 +355,35 @@ class AndroidDevice extends Device {
printTrace('Waiting for observatory port to be available...');
try {
Uri observatoryDeviceUri, diagnosticDeviceUri;
int observatoryDevicePort, diagnosticDevicePort;
if (debuggingOptions.buildMode == BuildMode.debug) {
Future<List<Uri>> scrapeServiceUris = Future.wait(
<Future<Uri>>[observatoryDiscovery.nextUri(), diagnosticDiscovery.nextUri()]
Future<List<int>> scrapeServicePorts = Future.wait(
<Future<int>>[observatoryDiscovery.nextPort(), diagnosticDiscovery.nextPort()]
);
List<Uri> deviceUris = await scrapeServiceUris.timeout(new Duration(seconds: 20));
observatoryDeviceUri = deviceUris[0];
diagnosticDeviceUri = deviceUris[1];
List<int> devicePorts = await scrapeServicePorts.timeout(new Duration(seconds: 20));
observatoryDevicePort = devicePorts[0];
diagnosticDevicePort = devicePorts[1];
} else {
observatoryDeviceUri = await observatoryDiscovery.nextUri().timeout(new Duration(seconds: 20));
observatoryDevicePort = await observatoryDiscovery.nextPort().timeout(new Duration(seconds: 20));
}
printTrace('Observatory Uri on device: $observatoryDeviceUri');
printTrace('observatory port on device: $observatoryDevicePort');
int observatoryLocalPort = await debuggingOptions.findBestObservatoryPort();
// TODO(devoncarew): Remember the forwarding information (so we can later remove the
// port forwarding).
Uri observatoryLocalUri = await _forwardUriToNewPort(ProtocolDiscovery.kObservatoryService, observatoryDeviceUri, observatoryLocalPort);
observatoryLocalPort = await _forwardPort(ProtocolDiscovery.kObservatoryService, observatoryDevicePort, observatoryLocalPort);
Uri diagnosticLocalUri;
if (diagnosticDeviceUri != null) {
printTrace('Diagnostic Server Uri on device: $diagnosticDeviceUri');
int diagnosticLocalPort = await debuggingOptions.findBestDiagnosticPort();
diagnosticLocalUri = await _forwardUriToNewPort(ProtocolDiscovery.kDiagnosticService, diagnosticDeviceUri, diagnosticLocalPort);
int diagnosticLocalPort;
if (diagnosticDevicePort != null) {
printTrace('diagnostic port on device: $diagnosticDevicePort');
diagnosticLocalPort = await debuggingOptions.findBestDiagnosticPort();
diagnosticLocalPort = await _forwardPort(ProtocolDiscovery.kDiagnosticService, diagnosticDevicePort, diagnosticLocalPort);
}
return new LaunchResult.succeeded(
observatoryUri: observatoryLocalUri,
diagnosticUri: diagnosticLocalUri,
observatoryPort: observatoryLocalPort,
diagnosticPort: diagnosticLocalPort
);
} catch (error) {
if (error is TimeoutException)

4
packages/flutter_tools/lib/src/commands/daemon.dart
View File

@@ -359,8 +359,8 @@ class AppDomain extends Domain {
connectionInfoCompleter = new Completer<DebugConnectionInfo>();
connectionInfoCompleter.future.then((DebugConnectionInfo info) {
Map<String, dynamic> params = <String, dynamic>{
'port': info.httpUri.port,
'wsUri': info.wsUri.toString(),
'port': info.port,
'wsUri': info.wsUri
};
if (info.baseUri != null)
params['baseUri'] = info.baseUri;

10
packages/flutter_tools/lib/src/commands/trace.dart
View File

@@ -55,14 +55,10 @@ class TraceCommand extends FlutterCommand {
Future<Null> runCommand() async {
int observatoryPort = int.parse(argResults['debug-port']);
// TODO(danrubel): this will break if we move to the new observatory URL
// See https://github.com/flutter/flutter/issues/7038
Uri observatoryUri = Uri.parse('http://127.0.0.1:$observatoryPort');
Tracing tracing;
try {
tracing = await Tracing.connect(observatoryUri);
tracing = await Tracing.connect(observatoryPort);
} catch (error) {
throwToolExit('Error connecting to observatory: $error');
}
@@ -104,8 +100,8 @@ class TraceCommand extends FlutterCommand {
class Tracing {
Tracing(this.vmService);
static Future<Tracing> connect(Uri uri) {
return VMService.connect(uri).then((VMService observatory) => new Tracing(observatory));
static Future<Tracing> connect(int port) {
return VMService.connect(port).then((VMService observatory) => new Tracing(observatory));
}
final VMService vmService;

18
packages/flutter_tools/lib/src/device.dart
View File

@@ -296,22 +296,22 @@ class DebuggingOptions {
}
class LaunchResult {
LaunchResult.succeeded({ this.observatoryUri, this.diagnosticUri }) : started = true;
LaunchResult.failed() : started = false, observatoryUri = null, diagnosticUri = null;
LaunchResult.succeeded({ this.observatoryPort, this.diagnosticPort }) : started = true;
LaunchResult.failed() : started = false, observatoryPort = null, diagnosticPort = null;
bool get hasObservatory => observatoryUri != null;
bool get hasObservatory => observatoryPort != null;
final bool started;
final Uri observatoryUri;
final Uri diagnosticUri;
final int observatoryPort;
final int diagnosticPort;
@override
String toString() {
StringBuffer buf = new StringBuffer('started=$started');
if (observatoryUri != null)
buf.write(', observatory=$observatoryUri');
if (diagnosticUri != null)
buf.write(', diagnostic=$diagnosticUri');
if (observatoryPort != null)
buf.write(', observatory=$observatoryPort');
if (diagnosticPort != null)
buf.write(', diagnostic=$diagnosticPort');
return buf.toString();
}
}

12
packages/flutter_tools/lib/src/hot.dart
View File

@@ -108,7 +108,7 @@ class HotRunner extends ResidentRunner {
final String applicationBinary;
bool get prebuiltMode => applicationBinary != null;
Set<String> _dartDependencies;
Uri _observatoryUri;
int _observatoryPort;
AssetBundle _bundle;
AssetBundle get bundle => _bundle;
final bool benchmarkMode;
@@ -216,9 +216,9 @@ class HotRunner extends ResidentRunner {
return 2;
}
_observatoryUri = result.observatoryUri;
_observatoryPort = result.observatoryPort;
try {
await connectToServiceProtocol(_observatoryUri);
await connectToServiceProtocol(_observatoryPort);
} catch (error) {
printError('Error connecting to the service protocol: $error');
return 2;
@@ -230,8 +230,8 @@ class HotRunner extends ResidentRunner {
if (connectionInfoCompleter != null) {
connectionInfoCompleter.complete(
new DebugConnectionInfo(
httpUri: _observatoryUri,
wsUri: vmService.wsAddress,
port: _observatoryPort,
wsUri: 'ws://localhost:$_observatoryPort/ws',
baseUri: baseUri.toString()
)
);
@@ -533,7 +533,7 @@ class HotRunner extends ResidentRunner {
ansiAlternative: '$red$fire$bold To hot reload your app on the fly, '
'press "r" or F5. To restart the app entirely, press "R".$reset'
);
printStatus('The Observatory debugger and profiler is available at: $_observatoryUri');
printStatus('The Observatory debugger and profiler is available at: http://127.0.0.1:$_observatoryPort/');
if (details) {
printHelpDetails();
printStatus('To repeat this help message, press "h" or F1. To quit, press "q", F10, or Ctrl-C.');

71
packages/flutter_tools/lib/src/ios/devices.dart
View File

@@ -244,8 +244,8 @@ class IOSDevice extends Device {
}
int installationResult = -1;
Uri localObsUri;
Uri localDiagUri;
int localObsPort;
int localDiagPort;
if (!debuggingOptions.debuggingEnabled) {
// If debugging is not enabled, just launch the application and continue.
@@ -256,34 +256,30 @@ class IOSDevice extends Device {
// ports post launch.
printTrace("Debugging is enabled, connecting to observatory and the diagnostic server");
Future<Uri> forwardObsUri = _acquireAndForwardUriToNewPort(
app,
ProtocolDiscovery.kObservatoryService,
debuggingOptions.observatoryPort,
);
Future<Uri> forwardDiagUri;
Future<int> forwardObsPort = _acquireAndForwardPort(app,
ProtocolDiscovery.kObservatoryService,
debuggingOptions.observatoryPort);
Future<int> forwardDiagPort;
if (debuggingOptions.buildMode == BuildMode.debug) {
forwardDiagUri = _acquireAndForwardUriToNewPort(
app,
ProtocolDiscovery.kDiagnosticService,
debuggingOptions.diagnosticPort,
);
forwardDiagPort = _acquireAndForwardPort(app,
ProtocolDiscovery.kDiagnosticService,
debuggingOptions.diagnosticPort);
} else {
forwardDiagUri = new Future<Uri>.value(null);
forwardDiagPort = new Future<int>.value(null);
}
Future<int> launch = runCommandAndStreamOutput(launchCommand, trace: true);
List<Uri> uris = await launch.then((int result) async {
List<int> ports = await launch.then((int result) async {
installationResult = result;
if (result != 0) {
printTrace("Failed to launch the application on device.");
return <Uri>[null, null];
return <int>[null, null];
}
printTrace("Application launched on the device. Attempting to forward ports.");
return await Future.wait(<Future<Uri>>[forwardObsUri, forwardDiagUri])
return await Future.wait(<Future<int>>[forwardObsPort, forwardDiagPort])
.timeout(
kPortForwardTimeout,
onTimeout: () {
@@ -292,11 +288,11 @@ class IOSDevice extends Device {
);
});
printTrace("Observatory Uri on device: ${uris[0]}");
printTrace("Diagnostic Server Uri on device: ${uris[1]}");
printTrace("Local Observatory Port: ${ports[0]}");
printTrace("Local Diagnostic Server Port: ${ports[1]}");
localObsUri = uris[0];
localDiagUri = uris[1];
localObsPort = ports[0];
localDiagPort = ports[1];
}
if (installationResult != 0) {
@@ -307,25 +303,25 @@ class IOSDevice extends Device {
return new LaunchResult.failed();
}
return new LaunchResult.succeeded(observatoryUri: localObsUri, diagnosticUri: localDiagUri);
return new LaunchResult.succeeded(observatoryPort: localObsPort, diagnosticPort: localDiagPort);
}
Future<Uri> _acquireAndForwardUriToNewPort(
Future<int> _acquireAndForwardPort(
ApplicationPackage app,
String serviceName,
int localPort) async {
Duration stepTimeout = const Duration(seconds: 60);
Future<Uri> remote = new ProtocolDiscovery(getLogReader(app: app), serviceName).nextUri();
Future<int> remote = new ProtocolDiscovery(getLogReader(app: app), serviceName).nextPort();
Uri remoteUri = await remote.timeout(stepTimeout,
int remotePort = await remote.timeout(stepTimeout,
onTimeout: () {
printTrace("Timeout while attempting to retrieve remote Uri for $serviceName");
printTrace("Timeout while attempting to retrieve remote port for $serviceName");
return null;
});
if (remoteUri == null) {
printTrace("Could not read Uri on device for $serviceName");
if (remotePort == null) {
printTrace("Could not read port on device for $serviceName");
return null;
}
@@ -334,22 +330,19 @@ class IOSDevice extends Device {
printTrace("Auto selected local port to $localPort");
}
int forwardResult = await portForwarder
.forward(remoteUri.port, hostPort: localPort)
.timeout(stepTimeout, onTimeout: () {
printTrace("Timeout while atempting to foward port for $serviceName");
return null;
});
int forwardResult = await portForwarder.forward(remotePort,
hostPort: localPort).timeout(stepTimeout, onTimeout: () {
printTrace("Timeout while atempting to foward port for $serviceName");
return null;
});
if (forwardResult == null) {
printTrace("Could not foward remote $serviceName port $remoteUri to local port $localPort");
printTrace("Could not foward remote $serviceName port $remotePort to local port $localPort");
return null;
}
Uri forwardUri = remoteUri.replace(port: forwardResult);
printStatus('$serviceName listening on $forwardUri');
return forwardUri;
printStatus('$serviceName listening on http://127.0.0.1:$localPort');
return localPort;
}
@override

10
packages/flutter_tools/lib/src/ios/simulators.dart
View File

@@ -474,12 +474,12 @@ class IOSSimulator extends Device {
printTrace('Waiting for observatory port to be available...');
try {
Uri deviceUri = await observatoryDiscovery
.nextUri()
int devicePort = await observatoryDiscovery
.nextPort()
.timeout(new Duration(seconds: 20));
printTrace('Observatory Uri on simulator: $deviceUri');
printStatus('Observatory listening on $deviceUri');
return new LaunchResult.succeeded(observatoryUri: deviceUri);
printTrace('service protocol port = $devicePort');
printStatus('Observatory listening on http://127.0.0.1:$devicePort');
return new LaunchResult.succeeded(observatoryPort: devicePort);
} catch (error) {
if (error is TimeoutException)
printError('Timed out while waiting for a debug connection.');

25
packages/flutter_tools/lib/src/protocol_discovery.dart
View File

@@ -21,38 +21,37 @@ class ProtocolDiscovery {
final DeviceLogReader _logReader;
final String _serviceName;
Completer<Uri> _completer = new Completer<Uri>();
Completer<int> _completer = new Completer<int>();
StreamSubscription<String> _subscription;
/// The [Future] returned by this function will complete when the next service
/// Uri is found.
Future<Uri> nextUri() => _completer.future;
/// protocol port is found.
Future<int> nextPort() => _completer.future;
void cancel() {
_subscription.cancel();
}
void _onLine(String line) {
Uri uri;
int portNumber = 0;
if (line.contains('$_serviceName listening on http://')) {
RegExp portExp = new RegExp(r"http://\d+.\d+.\d+.\d+:\d+\S*");
try {
String match = portExp.stringMatch(line);
if (match != null)
uri = Uri.parse(match);
RegExp portExp = new RegExp(r"\d+.\d+.\d+.\d+:(\d+)");
String port = portExp.firstMatch(line).group(1);
portNumber = int.parse(port);
} catch (_) {
// Ignore errors.
}
}
if (uri != null)
_located(uri);
if (portNumber != 0)
_located(portNumber);
}
void _located(Uri uri) {
void _located(int port) {
assert(_completer != null);
assert(!_completer.isCompleted);
_completer.complete(uri);
_completer = new Completer<Uri>();
_completer.complete(port);
_completer = new Completer<int>();
}
}

12
packages/flutter_tools/lib/src/resident_runner.dart
View File

@@ -119,12 +119,12 @@ abstract class ResidentRunner {
_loggingSubscription = null;
}
Future<Null> connectToServiceProtocol(Uri uri) async {
Future<Null> connectToServiceProtocol(int port) async {
if (!debuggingOptions.debuggingEnabled) {
return new Future<Null>.error('Error the service protocol is not enabled.');
}
vmService = await VMService.connect(uri);
printTrace('Connected to service protocol: $uri');
vmService = await VMService.connect(port);
printTrace('Connected to service protocol on port $port');
await vmService.getVM();
// Refresh the view list.
@@ -287,9 +287,9 @@ String getMissingPackageHintForPlatform(TargetPlatform platform) {
}
class DebugConnectionInfo {
DebugConnectionInfo({ this.httpUri, this.wsUri, this.baseUri });
DebugConnectionInfo({ this.port, this.wsUri, this.baseUri });
final Uri httpUri;
final Uri wsUri;
final int port;
final String wsUri;
final String baseUri;
}

19
packages/flutter_tools/lib/src/run.dart
View File

@@ -119,16 +119,17 @@ class RunAndStayResident extends ResidentRunner {
startTime.stop();
// Connect to observatory.
if (debuggingOptions.debuggingEnabled) {
await connectToServiceProtocol(_result.observatoryUri);
if (_result.hasObservatory) {
int port = _result.observatoryPort;
connectionInfoCompleter?.complete(new DebugConnectionInfo(
port: port,
wsUri: 'ws://localhost:$port/ws'
));
}
if (_result.hasObservatory) {
connectionInfoCompleter?.complete(new DebugConnectionInfo(
httpUri: _result.observatoryUri,
wsUri: vmService.wsAddress,
));
// Connect to observatory.
if (debuggingOptions.debuggingEnabled) {
await connectToServiceProtocol(_result.observatoryPort);
}
printTrace('Application running.');
@@ -175,7 +176,7 @@ class RunAndStayResident extends ResidentRunner {
void printHelp({ @required bool details }) {
bool haveDetails = false;
if (_result.hasObservatory)
printStatus('The Observatory debugger and profiler is available at: ${_result.observatoryUri}');
printStatus('The Observatory debugger and profiler is available at: http://127.0.0.1:${_result.observatoryPort}/');
if (supportsServiceProtocol) {
haveDetails = true;
if (details)

19
packages/flutter_tools/lib/src/vmservice.dart
View File

@@ -14,7 +14,7 @@ import 'globals.dart';
/// A connection to the Dart VM Service.
class VMService {
VMService._(this.peer, this.httpAddress, this.wsAddress) {
VMService._(this.peer, this.port, this.httpAddress) {
_vm = new VM._empty(this);
peer.registerMethod('streamNotify', (rpc.Parameters event) {
@@ -23,24 +23,21 @@ class VMService {
}
/// Connect to '127.0.0.1' at [port].
static Future<VMService> connect(Uri httpUri) async {
String wsPath = httpUri.path;
if (!wsPath.endsWith('/'))
wsPath += '/';
wsPath += 'ws';
Uri wsUri = httpUri.replace(scheme: 'ws', path: wsPath);
static Future<VMService> connect(int port) async {
Uri uri = new Uri(scheme: 'ws', host: '127.0.0.1', port: port, path: 'ws');
WebSocket ws;
try {
ws = await WebSocket.connect(wsUri.toString());
ws = await WebSocket.connect(uri.toString());
} catch (e) {
return new Future<VMService>.error('Failed to connect to $wsUri\n $e');
return new Future<VMService>.error('Failed to connect to $uri\n $e');
}
rpc.Peer peer = new rpc.Peer(new IOWebSocketChannel(ws).cast());
peer.listen();
return new VMService._(peer, httpUri, wsUri);
Uri httpAddress = new Uri(scheme: 'http', host: '127.0.0.1', port: port);
return new VMService._(peer, port, httpAddress);
}
final Uri httpAddress;
final Uri wsAddress;
final int port;
final rpc.Peer peer;
VM _vm;

37
packages/flutter_tools/test/protocol_discovery_test.dart
View File

@@ -17,48 +17,35 @@ void main() {
new ProtocolDiscovery(logReader, ProtocolDiscovery.kObservatoryService);
// Get next port future.
Future<Uri> nextUri = discoverer.nextUri();
expect(nextUri, isNotNull);
Future<int> nextPort = discoverer.nextPort();
expect(nextPort, isNotNull);
// Inject some lines.
logReader.addLine('HELLO WORLD');
logReader.addLine('Observatory listening on http://127.0.0.1:9999');
// Await the port.
Uri uri = await nextUri;
expect(uri.port, 9999);
expect('$uri', 'http://127.0.0.1:9999');
expect(await nextPort, 9999);
// Get next port future.
nextUri = discoverer.nextUri();
nextPort = discoverer.nextPort();
logReader.addLine('Observatory listening on http://127.0.0.1:3333');
uri = await nextUri;
expect(uri.port, 3333);
expect('$uri', 'http://127.0.0.1:3333');
expect(await nextPort, 3333);
// Get next port future.
nextUri = discoverer.nextUri();
nextPort = discoverer.nextPort();
// Inject some bad lines.
logReader.addLine('Observatory listening on http://127.0.0.1');
logReader.addLine('Observatory listening on http://127.0.0.1:');
logReader.addLine('Observatory listening on http://127.0.0.1:apple');
Uri timeoutUri = Uri.parse('http://timeout');
Uri actualUri = await nextUri.timeout(
const Duration(milliseconds: 100), onTimeout: () => timeoutUri);
expect(actualUri, timeoutUri);
int port = await nextPort.timeout(
const Duration(milliseconds: 100), onTimeout: () => 77);
// Expect the timeout port.
expect(port, 77);
// Get next port future.
nextUri = discoverer.nextUri();
nextPort = discoverer.nextPort();
logReader.addLine('I/flutter : Observatory listening on http://127.0.0.1:52584');
uri = await nextUri;
expect(uri.port, 52584);
expect('$uri', 'http://127.0.0.1:52584');
// Get next port future.
nextUri = discoverer.nextUri();
logReader.addLine('I/flutter : Observatory listening on http://127.0.0.1:54804/PTwjm8Ii8qg=/');
uri = await nextUri;
expect(uri.port, 54804);
expect('$uri', 'http://127.0.0.1:54804/PTwjm8Ii8qg=/');
expect(await nextPort, 52584);
discoverer.cancel();
logReader.dispose();