Add a diagnostic.getServerPort analysis server request.

pkg/analysis_server/lib/src/server/driver.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library driver;
 
 import 'dart:async';
 import 'dart:io';
 import 'dart:math';
 
 import 'package:analysis_server/src/analysis_server.dart';
 import 'package:analysis_server/src/plugin/server_plugin.dart';
 import 'package:analysis_server/src/provisional/completion/dart/completion_plugin.dart';
+import 'package:analysis_server/src/server/diagnostic_server.dart';
 import 'package:analysis_server/src/server/http_server.dart';
 import 'package:analysis_server/src/server/stdio_server.dart';
 import 'package:analysis_server/src/socket_server.dart';
 import 'package:analysis_server/starter.dart';
 import 'package:analyzer/file_system/physical_file_system.dart';
 import 'package:analyzer/instrumentation/file_instrumentation.dart';
 import 'package:analyzer/instrumentation/instrumentation.dart';
 import 'package:analyzer/plugin/resolver_provider.dart';
 import 'package:analyzer/src/dart/sdk/sdk.dart';
 import 'package:analyzer/src/generated/engine.dart';
@@ skipping 340 matching lines @@
     // TODO (danrubel) Remove this workaround
     // once the underlying VM and dart:io issue has been fixed.
     if (results[INTERNAL_DELAY_FREQUENCY] != null) {
       AnalysisServer.performOperationDelayFrequency =
           int.parse(results[INTERNAL_DELAY_FREQUENCY], onError: (_) => 0);
     }
 
     int port;
     bool serve_http = false;
     if (results[PORT_OPTION] != null) {
-      serve_http = true;
       try {
         port = int.parse(results[PORT_OPTION]);
+        serve_http = true;
       } on FormatException {
         print('Invalid port number: ${results[PORT_OPTION]}');
         print('');
         _printUsage(parser.parser);
         exitCode = 1;
         return;
       }
     }
 
     AnalysisServerOptions analysisServerOptions = new AnalysisServerOptions();
@@ skipping 50 matching lines @@
     String logFilePath = results[INSTRUMENTATION_LOG_FILE];
     if (logFilePath != null) {
       _rollLogFiles(logFilePath, 5);
       FileInstrumentationServer fileBasedServer =
           new FileInstrumentationServer(logFilePath);
       instrumentationServer = instrumentationServer != null
           ? new MulticastInstrumentationServer(
               [instrumentationServer, fileBasedServer])
           : fileBasedServer;
     }
-    InstrumentationService service =
+    InstrumentationService instrumentationService =
         new InstrumentationService(instrumentationServer);
-    service.logVersion(_readUuid(service), results[CLIENT_ID],
-        results[CLIENT_VERSION], AnalysisServer.VERSION, defaultSdk.sdkVersion);
-    AnalysisEngine.instance.instrumentationService = service;
+    instrumentationService.logVersion(
+        _readUuid(instrumentationService),
+        results[CLIENT_ID],
+        results[CLIENT_VERSION],
+        AnalysisServer.VERSION,
+        defaultSdk.sdkVersion);
+    AnalysisEngine.instance.instrumentationService = instrumentationService;
+
+    _DiagnosticServerImpl diagnosticServer = new _DiagnosticServerImpl();
+
     //
     // Create the sockets and start listening for requests.
     //
     socketServer = new SocketServer(
         analysisServerOptions,
         new DartSdkManager(defaultSdkPath, useSummaries),
         defaultSdk,
-        service,
+        instrumentationService,
+        diagnosticServer,
         serverPlugin,
         fileResolverProvider,
         packageResolverProvider,
         useSingleContextManager);
     httpServer = new HttpAnalysisServer(socketServer);
     stdioServer = new StdioAnalysisServer(socketServer);
     socketServer.userDefinedPlugins = _userDefinedPlugins;
 
+    diagnosticServer.httpServer = httpServer;
     if (serve_http) {
-      httpServer.serveHttp(port);
+      diagnosticServer.startOnPort(port);
     }
 
-    _captureExceptions(service, () {
+    _captureExceptions(instrumentationService, () {
       stdioServer.serveStdio().then((_) async {
         if (serve_http) {
           httpServer.close();
         }
-        await service.shutdown();
+        await instrumentationService.shutdown();
         exit(0);
       });
     },
         print:
             results[INTERNAL_PRINT_TO_CONSOLE] ? null : httpServer.recordPrint);
   }
 
   /**
    * Execute the given [callback] within a zone that will capture any unhandled
    * exceptions and both report them to the client and send them to the given
@@ skipping 156 matching lines @@
    */
   static void _rollLogFiles(String path, int numOld) {
     for (int i = numOld - 1; i >= 0; i--) {
       try {
         String oldPath = i == 0 ? path : '$path.$i';
         new File(oldPath).renameSync('$path.${i+1}');
       } catch (e) {}
     }
   }
 }
+
+/**
+ * Implements the [DiagnosticServer] class by wrapping an [HttpAnalysisServer].
+ */
+class _DiagnosticServerImpl extends DiagnosticServer {
+  HttpAnalysisServer httpServer;
+
+  _DiagnosticServerImpl();
+
+  Future startOnPort(int port) {
+    return httpServer.serveHttp(port);
+  }
+
+  @override
+  Future<int> getServerPort() => httpServer.serveHttp();
+}