Some re-organization to the analysis server diagnostics pages.

pkg/analysis_server/lib/src/status/get_handler2.dart

 // Copyright (c) 2016, 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.
 
 import 'dart:convert';
 import 'dart:io';
 import 'dart:math';
 
 import 'package:analysis_server/plugin/protocol/protocol.dart' hide Element;
 import 'package:analysis_server/src/analysis_server.dart';
 import 'package:analysis_server/src/domain_completion.dart';
 import 'package:analysis_server/src/domain_diagnostic.dart';
 import 'package:analysis_server/src/domain_execution.dart';
 import 'package:analysis_server/src/services/completion/completion_performance.dart';
 import 'package:analysis_server/src/socket_server.dart';
 import 'package:analysis_server/src/status/get_handler.dart';
 import 'package:analyzer/exception/exception.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/source/error_processor.dart';
 import 'package:analyzer/source/sdk_ext.dart';
 import 'package:analyzer/src/context/source.dart';
 import 'package:analyzer/src/dart/analysis/driver.dart';
 import 'package:analyzer/src/dart/sdk/sdk.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/utilities_general.dart';
 import 'package:analyzer/src/services/lint.dart';
 import 'package:analyzer/task/model.dart';
+import 'package:path/path.dart' as path;
 import 'package:plugin/plugin.dart';
 
 /**
  * A function that can be used to generate HTML output into the given [buffer].
  * The HTML that is generated must be valid (special characters must already be
  * encoded).
  */
 typedef void HtmlGenerator(StringBuffer buffer);
 
 /**
@@ skipping 150 matching lines @@
 
   /**
    * Return a response displaying overall performance information.
    */
   void _returnAnalysisPerformance(HttpRequest request) {
     AnalysisServer analysisServer = _server.analysisServer;
     if (analysisServer == null) {
       return _returnFailure(request, 'Analysis server is not running');
     }
     _writeResponse(request, (StringBuffer buffer) {
-      _writePage(buffer, 'Analysis Server - Analysis Performance', [],
-          (StringBuffer buffer) {
+      _writePage(buffer, 'Analysis Performance', [], (StringBuffer buffer) {
         buffer.write('<h3>Analysis Performance</h3>');
         _writeTwoColumns(buffer, (StringBuffer buffer) {
           //
           // Write performance tags.
           //
           buffer.write('<p><b>Performance tag data</b></p>');
           buffer.write(
               '<table style="border-collapse: separate; border-spacing: 10px 5px;">');
           _writeRow(buffer, ['Time (in ms)', 'Percent', 'Tag name'],
               header: true);
@@ skipping 68 matching lines @@
 
   /**
    * Return a response displaying overall performance information.
    */
   void _returnCommunicationPerformance(HttpRequest request) {
     AnalysisServer analysisServer = _server.analysisServer;
     if (analysisServer == null) {
       return _returnFailure(request, 'Analysis server is not running');
     }
     _writeResponse(request, (StringBuffer buffer) {
-      _writePage(buffer, 'Analysis Server - Communication Performance', [],
+      _writePage(buffer, 'Communication Performance', [],
           (StringBuffer buffer) {
         buffer.write('<h3>Communication Performance</h3>');
         _writeTwoColumns(buffer, (StringBuffer buffer) {
           ServerPerformance perf = analysisServer.performanceDuringStartup;
           int requestCount = perf.requestCount;
           num averageLatency = requestCount > 0
               ? (perf.requestLatency / requestCount).round()
               : 0;
           int maximumLatency = perf.maxLatency;
           num slowRequestPercent = requestCount > 0
@@ skipping 45 matching lines @@
     });
   }
 
   /**
    * Return a response displaying code completion information.
    */
   void _returnCompletionInfo(HttpRequest request) {
     String value = request.requestedUri.queryParameters['index'];
     int index = value != null ? int.parse(value, onError: (_) => 0) : 0;
     _writeResponse(request, (StringBuffer buffer) {
-      _writePage(buffer, 'Analysis Server - Completion Stats', [],
-          (StringBuffer buffer) {
+      _writePage(buffer, 'Completion Stats', [], (StringBuffer buffer) {
         _writeCompletionPerformanceDetail(buffer, index);
         _writeCompletionPerformanceList(buffer);
       });
     });
   }
 
   /**
    * Return a response containing information about a single source file in the
    * cache.
    */
@@ skipping 71 matching lines @@
       _writeOption(buffer, 'Preserve comments', options.preserveComments);
       _writeOption(buffer, 'Strong mode', options.strongMode);
       _writeOption(buffer, 'Strong mode hints', options.strongModeHints);
       if (writeAdditionalOptions != null) {
         writeAdditionalOptions(buffer);
       }
       buffer.write('</p>');
     }
 
     _writeResponse(request, (StringBuffer buffer) {
-      _writePage(
-          buffer, 'Analysis Server - Context', ['Context: $contextFilter'],
+      String contextName = path.basename(contextFilter);
+      _writePage(buffer, 'Context: $contextName', [contextFilter],
           (StringBuffer buffer) {
         buffer.write('<h3>Configuration</h3>');
 
         _writeColumns(buffer, <HtmlGenerator>[
           (StringBuffer buffer) {
             buffer.write('<p><b>Context Options</b></p>');
             writeOptions(buffer, driver.analysisOptions);
           },
           (StringBuffer buffer) {
             buffer.write('<p><b>SDK Context Options</b></p>');
@@ skipping 71 matching lines @@
 //          exceptions.forEach((CaughtException exception) {
 //            _writeException(buffer, exception);
 //          });
 //        }
       });
     });
   }
 
   void _returnFailure(HttpRequest request, String message) {
     _writeResponse(request, (StringBuffer buffer) {
-      _writePage(buffer, 'Analysis Server - Failure', [],
-          (StringBuffer buffer) {
+      _writePage(buffer, 'Failure', [], (StringBuffer buffer) {
         buffer.write(HTML_ESCAPE.convert(message));
       });
     });
   }
 
   void _returnOverlayContents(HttpRequest request) {
     String path = request.requestedUri.queryParameters[PATH_PARAM];
     if (path == null) {
       return _returnFailure(request, 'Query parameter $PATH_PARAM required');
     }
     String contents = _overlayContents[path];
 
     _writeResponse(request, (StringBuffer buffer) {
-      _writePage(buffer, 'Analysis Server - Overlay', [],
-          (StringBuffer buffer) {
+      _writePage(buffer, 'Overlay', [], (StringBuffer buffer) {
         buffer.write('<pre>${HTML_ESCAPE.convert(contents)}</pre>');
       });
     });
   }
 
   /**
    * Return a response displaying overlays information.
    */
   void _returnOverlaysInfo(HttpRequest request) {
     AnalysisServer analysisServer = _server.analysisServer;
     if (analysisServer == null) {
       return _returnFailure(request, 'Analysis server is not running');
     }
 
     _writeResponse(request, (StringBuffer buffer) {
-      _writePage(buffer, 'Analysis Server - Overlays', [],
-          (StringBuffer buffer) {
+      _writePage(buffer, 'Overlay information', [], (StringBuffer buffer) {
         buffer.write('<table border="1">');
         _overlayContents.clear();
         ContentCache overlayState = analysisServer.overlayState;
         overlayState.accept((String fullName, int stamp, String contents) {
           buffer.write('<tr>');
           String link =
               makeLink(OVERLAY_PATH, {PATH_PARAM: fullName}, fullName);
           DateTime time = new DateTime.fromMillisecondsSinceEpoch(stamp);
           _writeRow(buffer, [link, time]);
           _overlayContents[fullName] = contents;
         });
         int count = _overlayContents.length;
-        buffer.write('<tr><td colspan="2">Total: $count entries.</td></tr>');
+        buffer.write('<tr><td colspan="2">Total: $count entries</td></tr>');
         buffer.write('</table>');
       });
     });
   }
 
   /**
    * Return a response indicating the status of the analysis server.
    */
   void _returnServerStatus(HttpRequest request) {
     _writeResponse(request, (StringBuffer buffer) {
-      _writePage(buffer, 'Analysis Server - Status', [], (StringBuffer buffer) {
+      _writePage(buffer, 'Status', [], (StringBuffer buffer) {
         if (_writeServerStatus(buffer)) {
           _writeAnalysisStatus(buffer);
           _writeEditStatus(buffer);
           _writeExecutionStatus(buffer);
           _writePluginStatus(buffer);
           _writeRecentOutput(buffer);
         }
       });
     });
   }
@@ skipping 19 matching lines @@
         ${makeLink(STATUS_PATH, {}, 'the main status page')}.
         </p>''');
       });
     });
   }
 
   /**
    * Return a two digit decimal representation of the given non-negative integer
    * [value].
    */
-  String _twoDigit(int value) {
-    if (value < 10) {
-      return '0$value';
-    }
-    return value.toString();
-  }
+  String _twoDigit(int value) => value.toString().padLeft(2, '0');
 
   /**
    * Write the status of the analysis domain (on the main status page) to the
    * given [buffer] object.
    */
   void _writeAnalysisStatus(StringBuffer buffer) {
     AnalysisServer analysisServer = _server.analysisServer;
     Map<Folder, AnalysisDriver> driverMap = analysisServer.driverMap;
     List<Folder> folders = driverMap.keys.toList();
     folders.sort((Folder first, Folder second) =>
         first.shortName.compareTo(second.shortName));
 
     buffer.write('<h3>Analysis Domain</h3>');
     _writeTwoColumns(buffer, (StringBuffer buffer) {
       buffer.write('<p>Using package resolver provider: ');
       buffer.write(_server.packageResolverProvider != null);
       buffer.write('</p>');
-      buffer.write('<p>');
-      buffer.write(makeLink(OVERLAYS_PATH, {}, 'All overlay information'));
-      buffer.write('</p>');
+      buffer.write(makeLink(OVERLAYS_PATH, {}, 'Overlay information'));
 
       buffer.write('<p><b>Analysis Contexts</b></p>');
-      buffer.write('<p>');
       bool first = true;
       folders.forEach((Folder folder) {
         if (first) {
           first = false;
         } else {
           buffer.write('<br>');
         }
         String key = folder.shortName;
         buffer.write(makeLink(CONTEXT_PATH, {CONTEXT_QUERY_PARAM: folder.path},
             key, _hasException(driverMap[folder])));
         if (!folder.getChild('.packages').exists) {
-          buffer.write(' <small>[no .packages file]</small>');
+          buffer.write(' [no .packages file]');
         }
       });
-      buffer.write('</p>');
 
       int freq = AnalysisServer.performOperationDelayFrequency;
       String delay = freq > 0 ? '1 ms every $freq ms' : 'off';
 
       buffer.write('<p><b>Performance Data</b></p>');
-      buffer.write('<p>Perform operation delay: $delay</p>');
-      buffer.write('<p>');
-      buffer.write(makeLink(ANALYSIS_PERFORMANCE_PATH, {}, 'Task data'));
-      buffer.write('</p>');
+      buffer.write(
+          makeLink(ANALYSIS_PERFORMANCE_PATH, {}, 'Analysis performance'));
+      buffer.write('<br>');
+      buffer.write('Perform operation delay: $delay');
+      buffer.write('<br>');
     }, (StringBuffer buffer) {
       _writeSubscriptionMap(
           buffer, AnalysisService.VALUES, analysisServer.analysisServices);
     });
   }
 
   /**
    * Write multiple columns of information to the given [buffer], where the list
    * of [columns] functions are used to generate the content of those columns.
    */
@@ skipping 112 matching lines @@
         then there will be only one number in this column.''');
   }
 
   /**
    * Write the status of the edit domain (on the main status page) to the given
    * [buffer].
    */
   void _writeEditStatus(StringBuffer buffer) {
     buffer.write('<h3>Edit Domain</h3>');
     _writeTwoColumns(buffer, (StringBuffer buffer) {
-      buffer.write('<p><b>Performance Data</b></p>');
-      buffer.write('<p>');
-      buffer.write(makeLink(COMPLETION_PATH, {}, 'Completion data'));
-      buffer.write('</p>');
+      buffer.write(makeLink(COMPLETION_PATH, {}, 'Completion stats'));
     }, (StringBuffer buffer) {});
   }
 
   /**
    * Write a representation of the given [caughtException] to the given
    * [buffer]. If [isCause] is `true`, then the exception was a cause for
    * another exception.
    */
   void _writeException(StringBuffer buffer, CaughtException caughtException,
       {bool isCause: false}) {
@@ skipping 34 matching lines @@
         (RequestHandler handler) => handler is ExecutionDomainHandler,
         orElse: () => null);
     Set<ExecutionService> services = new Set<ExecutionService>();
     if (handler.onFileAnalyzed != null) {
       services.add(ExecutionService.LAUNCH_DATA);
     }
 
     if (handler != null) {
       buffer.write('<h3>Execution Domain</h3>');
       _writeTwoColumns(buffer, (StringBuffer buffer) {
+        buffer.write('<br>');
+      }, (StringBuffer buffer) {
         _writeSubscriptionList(buffer, ExecutionService.VALUES, services);
-      }, (StringBuffer buffer) {});
+      });
     }
   }
 
   /**
    * Write to the given [buffer] a representation of the given [map] of strings
    * to strings.
    */
   void _writeMapOfStringToString(StringBuffer buffer, Map<String, String> map) {
     List<String> keys = map.keys.toList();
     keys.sort();
@@ skipping 38 matching lines @@
     String date = "${now.month}/${now.day}/${now.year}";
     String time =
         "${now.hour}:${_twoDigit(now.minute)}:${_twoDigit(now.second)}.${now.millisecond}";
 
     buffer.write('<!DOCTYPE html>');
     buffer.write('<html>');
     buffer.write('<head>');
     buffer.write('<meta charset="utf-8">');
     buffer.write(
         '<meta name="viewport" content="width=device-width, initial-scale=1.0">');
-    buffer.write('<title>$title</title>');
+    buffer.write('<title>Analysis Server</title>');
     buffer.write('<style>');
     buffer.write('a {color: #0000DD; text-decoration: none;}');
     buffer.write('a:link.error {background-color: #FFEEEE;}');
     buffer.write('a:visited.error {background-color: #FFEEEE;}');
     buffer.write('a:hover.error {background-color: #FFEEEE;}');
     buffer.write('a:active.error {background-color: #FFEEEE;}');
     buffer.write(
-        'h3 {background-color: #DDDDDD; margin-top: 0em; margin-bottom: 0em;}');
-    buffer.write('p {margin-top: 0.5em; margin-bottom: 0.5em;}');
+        'div.subtitle {float: right; font-weight: normal; font-size: 1rem;}');
+    buffer.write('h2 {margin-top: 0;}');
+    buffer.write('h3 {border-bottom: 1px #DDD solid; margin-bottom: 0em;}');
+    buffer.write('p {margin-top: 0.5em; margin-bottom: 0;}');
     buffer.write(
         'p.commentary {margin-top: 1em; margin-bottom: 1em; margin-left: 2em; font-style: italic;}');
 //    response.write('span.error {text-decoration-line: underline; text-decoration-color: red; text-decoration-style: wavy;}');
     buffer.write(
         'table.column {border: 0px solid black; width: 100%; table-layout: fixed;}');
     buffer.write('td.column {vertical-align: top; width: 50%;}');
     buffer.write('td.right {text-align: right;}');
     buffer.write('th {text-align: left; vertical-align:top;}');
     buffer.write('tr {vertical-align:top;}');
     buffer.write('</style>');
     buffer.write('</head>');
 
     buffer.write('<body>');
-    buffer.write(
-        '<h2>$title <small><small>(as of $time on $date)</small></small></h2>');
+    buffer.write('<h2>$title <div class="subtitle">$date, $time</div></h2>');
     if (subtitles != null && subtitles.isNotEmpty) {
-      buffer.write('<blockquote>');
       bool first = true;
       for (String subtitle in subtitles) {
         if (first) {
           first = false;
         } else {
           buffer.write('<br>');
         }
         buffer.write('<b>');
         buffer.write(subtitle);
         buffer.write('</b>');
       }
-      buffer.write('</blockquote>');
     }
     try {
       body(buffer);
     } catch (exception, stackTrace) {
       buffer.write('<h3>Exception while creating page</h3>');
       _writeException(buffer, new CaughtException(exception, stackTrace));
     }
     buffer.write('</body>');
     buffer.write('</html>');
   }
@@ skipping 71 matching lines @@
         String className = classes[min(i, maxClassIndex)];
         if (className != null) {
           classAttribute = ' class="$className"';
         }
       }
       if (header) {
         buffer.write('<th$classAttribute>');
       } else {
         buffer.write('<td$classAttribute>');
       }
-      buffer.write(columns[i]);
+      if (columns[i] is int) {
+        buffer.write(_writeWithSeparators(columns[i]));
+      } else {
+        buffer.write(columns[i]);
+      }
       if (header) {
         buffer.write('</th>');
       } else {
         buffer.write('</td>');
       }
     }
     buffer.write('</tr>');
   }
 
   /**
    * Write the status of the service domain (on the main status page) to the
    * given [response] object.
    */
   bool _writeServerStatus(StringBuffer buffer) {
     AnalysisServer analysisServer = _server.analysisServer;
     Set<ServerService> services = analysisServer.serverServices;
 
     buffer.write('<h3>Server Domain</h3>');
     _writeTwoColumns(buffer, (StringBuffer buffer) {
+      buffer.write('<p><b>State</b></p>');
       if (analysisServer == null) {
         buffer.write('Status: <span style="color:red">Not running</span>');
         return;
       }
-      buffer.write('<p>');
       buffer.write('Status: Running<br>');
       buffer.write('New analysis driver: ');
       buffer.write(analysisServer.options.enableNewAnalysisDriver);
       buffer.write('<br>');
       buffer.write('Instrumentation: ');
       if (AnalysisEngine.instance.instrumentationService.isActive) {
         buffer.write('<span style="color:red">Active</span>');
       } else {
         buffer.write('Inactive');
       }
       buffer.write('<br>');
-      buffer.write('Server version: ');
-      buffer.write(AnalysisServer.VERSION);
-      buffer.write('<br>');
-      buffer.write('SDK: ');
-      buffer.write(Platform.version);
-      buffer.write('<br>');
       buffer.write('Process ID: ');
       buffer.write(pid);
-      buffer.write('</p>');
 
       buffer.write('<p><b>Performance Data</b></p>');
-      buffer.write('<p>');
       buffer.write(makeLink(
           COMMUNICATION_PERFORMANCE_PATH, {}, 'Communication performance'));
-      buffer.write('</p>');
     }, (StringBuffer buffer) {
       _writeSubscriptionList(buffer, ServerService.VALUES, services);
+      buffer.write('<p><b>Versions</b></p>');
+      buffer.write('Dart SDK: ${Platform.version}<br>');
+      buffer.write('Analysis server version: ${AnalysisServer.VERSION}<br>');
     });
     return analysisServer != null;
   }
 
   /**
    * Write a representation of the given [stackTrace] to the given [buffer].
    */
   void _writeStackTrace(StringBuffer buffer, StackTrace stackTrace) {
     if (stackTrace != null) {
       String trace = stackTrace.toString().replaceAll('#', '<br>#');
@@ skipping 24 matching lines @@
 
   /**
    * Given a [service] that could be subscribed to and a set of paths that are
    * subscribed to the services ([subscribedPaths]), write a representation of
    * the service to the given [buffer].
    */
   void _writeSubscriptionInMap(
       StringBuffer buffer, Enum service, Set<String> subscribedPaths) {
     buffer.write('<p>');
     buffer.write(service.name);
-    buffer.write('</p>');
-    if (subscribedPaths == null || subscribedPaths.isEmpty) {
-      buffer.write('none');
-    } else {
+    buffer.write('<br>');
+    if (subscribedPaths != null && subscribedPaths.isNotEmpty) {
       List<String> paths = subscribedPaths.toList();
       paths.sort();
       for (String path in paths) {
-        buffer.write('<p>');
-        buffer.write(path);
-        buffer.write('</p>');
+        buffer.write('$path<br>');
       }
     }
+    buffer.write('</p>');
   }
 
   /**
    * Given a list containing all of the services that can be subscribed to in a
    * single domain ([allServices]) and a set of the services that are actually
    * subscribed to ([subscribedServices]), write a representation of the
    * subscriptions to the given [buffer].
    */
   void _writeSubscriptionList(StringBuffer buffer, List<Enum> allServices,
       Set<Enum> subscribedServices) {
     buffer.write('<p><b>Subscriptions</b></p>');
-    buffer.write('<p>');
     for (Enum service in allServices) {
       _writeSubscriptionInList(buffer, service, subscribedServices);
+      buffer.write('<br>');
     }
-    buffer.write('</p>');
   }
 
   /**
    * Given a list containing all of the services that can be subscribed to in a
    * single domain ([allServices]) and a set of the services that are actually
    * subscribed to ([subscribedServices]), write a representation of the
    * subscriptions to the given [buffer].
    */
   void _writeSubscriptionMap(StringBuffer buffer, List<Enum> allServices,
       Map<Enum, Set<String>> subscribedServices) {
@@ skipping 24 matching lines @@
    * 'error'.
    */
   static String makeLink(
       String path, Map<String, String> params, String innerHtml,
       [bool hasError = false]) {
     Uri uri = params.isEmpty
         ? new Uri(path: path)
         : new Uri(path: path, queryParameters: params);
     String href = HTML_ESCAPE.convert(uri.toString());
     String classAttribute = hasError ? ' class="error"' : '';
-    return '<a href="$href"$classAttribute>$innerHtml</a>';
+    return '<a href="$href" $classAttribute>$innerHtml</a>';
   }
 }
+
+String _writeWithSeparators(int value) {
+  // TODO(devoncarew): Replace with the implementation from package:intl.
+  String str = value.toString();
+  int pos = 3;
+  while (str.length > pos) {
+    int len = str.length;
+    str = '${str.substring(0, len - pos)},${str.substring(len - pos)}';
+    pos += 4;
+  }
+  return str;
+}