VM restart + shutdown fixes

runtime/observatory/lib/src/elements/debugger.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 debugger_page_element;
 
 import 'dart:async';
 import 'dart:html';
 import 'observatory_element.dart';
 import 'package:observatory/app.dart';
@@ skipping 1069 matching lines @@
   }
 
   String helpShort = 'Refresh debugging information of various sorts';
 
   String helpLong =
       'Refresh debugging information of various sorts.\n'
       '\n'
       'Syntax: refresh <subcommand>\n';
 }
 
+class VmRestartCommand extends DebuggerCommand {
+  VmRestartCommand(Debugger debugger) : super(debugger, 'restart', []);
+
+  Future handleModalInput(String line) async {
+    if (line == 'yes') {
+      debugger.console.printRed('Restarting VM...');
+      await debugger.vm.restart();
+      debugger.input.exitMode();
+    } else if (line == 'no') {
+      debugger.console.printRed('VM restart canceled.');
+      debugger.input.exitMode();
+    } else {
+      debugger.console.printRed("Please type 'yes' or 'no'");
+    }
+  }
+
+  Future run(List<String> args) async {
+    debugger.input.enterMode('Restart vm? (yes/no)', handleModalInput);
+  }
+
+  String helpShort = 'Restart a Dart virtual machine';
+
+  String helpLong =
+      'Restart a Dart virtual machine.\n'
+      '\n'
+      'Syntax: vm restart\n';
+}
+
+class VmCommand extends DebuggerCommand {
+  VmCommand(Debugger debugger) : super(debugger, 'vm', [
+      new VmRestartCommand(debugger),
+  ]);
+
+  Future run(List<String> args) async {
+    debugger.console.print("'vm' expects a subcommand (see 'help vm')");
+  }
+
+  String helpShort = 'Manage a Dart virtual machine';
+
+  String helpLong =
+      'Manage a Dart virtual machine.\n'
+      '\n'
+      'Syntax: vm <subcommand>\n';
+}
+
 class _ConsoleStreamPrinter {
   ObservatoryDebugger _debugger;
 
   _ConsoleStreamPrinter(this._debugger);
   Level _minimumLogLevel = Level.OFF;
   String _savedStream;
   String _savedIsolate;
   String _savedLine;
   List<String> _buffer = [];
 
@@ skipping 127 matching lines @@
         new IsolateCommand(this),
         new LogCommand(this),
         new PauseCommand(this),
         new PrintCommand(this),
         new RefreshCommand(this),
         new SetCommand(this),
         new SmartNextCommand(this),
         new StepCommand(this),
         new SyncNextCommand(this),
         new UpCommand(this),
+        new VmCommand(this),
     ]);
     _consolePrinter = new _ConsoleStreamPrinter(this);
   }
 
   void _loadSettings() {
     _upIsDown = settings.get('up-is-down');
   }
 
   VM get vm => page.app.vm;
 
   void updateIsolate(Isolate iso) {
     _isolate = iso;
     if (_isolate != null) {
       if ((breakOnException != iso.exceptionsPauseInfo) &&
           (iso.exceptionsPauseInfo != null)) {
         breakOnException = iso.exceptionsPauseInfo;
         console.print("Now pausing for exceptions: $breakOnException");
       }
 
       _isolate.reload().then((response) {
+        if (response.isSentinel) {
+          // The isolate has gone away.  The IsolateExit event will
+          // clear the isolate for the debugger page.
+          return;
+        }
         // TODO(turnidge): Currently the debugger relies on all libs
         // being loaded.  Fix this.
         var pending = [];
-        for (var lib in _isolate.libraries) {
+        for (var lib in response.libraries) {
           if (!lib.loaded) {
             pending.add(lib.load());
           }
         }
         Future.wait(pending).then((_) {
-          _refreshStack(isolate.pauseEvent).then((_) {
-            reportStatus();
-          });
-        }).catchError((_) {
-          // Error loading libraries, try and display stack.
-          _refreshStack(isolate.pauseEvent).then((_) {
-            reportStatus();
-          });
+          refreshStack();
+        }).catchError((e) {
+          print("UNEXPECTED ERROR $e");
+          reportStatus();
         });
       });
     } else {
       reportStatus();
     }
   }
 
   set isolate(Isolate iso) {
     // Setting the page's isolate will trigger updateIsolate to be called.
     //
     // TODO(turnidge): Rework ownership of the ObservatoryDebugger in another
     // change.
     page.isolate = iso;
   }
   Isolate get isolate => _isolate;
   Isolate _isolate;
 
   void init() {
     console.newline();
     console.printBold("Type 'h' for help");
     // Wait a bit and if polymer still hasn't set up the isolate,
     // report this to the user.
     new Timer(const Duration(seconds:1), () {
       if (isolate == null) {
         reportStatus();
       }
     });
   }
 
-  Future refreshStack() {
-    return _refreshStack(isolate.pauseEvent).then((_) {
+  Future refreshStack() async {
+    try {
+      if (_isolate != null) {
+        await _refreshStack(_isolate.pauseEvent);
+      }
+      flushStdio();
       reportStatus();
-    });
+    } catch (e, st) {
+      console.printRed("Unexpected error in refreshStack: $e\n$st");
+    }
   }
 
   bool isolatePaused() {
     // TODO(turnidge): Stop relying on the isolate to track the last
     // pause event.  Since we listen to events directly in the
     // debugger, this could introduce a race.
     return (isolate != null &&
             isolate.pauseEvent != null &&
             isolate.pauseEvent.kind != ServiceEvent.kResume);
   }
 
   void warnOutOfDate() {
     // Wait a bit, then tell the user that the stack may be out of date.
     new Timer(const Duration(seconds:2), () {
       if (!isolatePaused()) {
         stackElement.isSampled = true;
       }
     });
   }
 
   Future<ServiceMap> _refreshStack(ServiceEvent pauseEvent) {
     return isolate.getStack().then((result) {
+      if (result.isSentinel) {
+        // The isolate has gone away.  The IsolateExit event will
+        // clear the isolate for the debugger page.
+        return;
+      }
       stack = result;
-      // TODO(turnidge): Replace only the changed part of the stack to
-      // reduce flicker.
       stackElement.updateStack(stack, pauseEvent);
       if (stack['frames'].length > 0) {
         currentFrame = 0;
       } else {
         currentFrame = null;
       }
       input.focus();
     });
   }
 
@@ skipping 15 matching lines @@
 
   void _reportPause(ServiceEvent event) {
     if (event.kind == ServiceEvent.kPauseStart) {
       console.print(
           "Paused at isolate start "
           "(type 'continue' [F7] or 'step' [F10] to start the isolate')");
     } else if (event.kind == ServiceEvent.kPauseExit) {
       console.print(
           "Paused at isolate exit "
           "(type 'continue' or [F7] to exit the isolate')");
-    }
-    if (stack['frames'].length > 0) {
+    } else if (stack['frames'].length > 0) {
       Frame frame = stack['frames'][0];
       var script = frame.location.script;
       script.load().then((_) {
         var line = script.tokenToLine(frame.location.tokenPos);
         var col = script.tokenToCol(frame.location.tokenPos);
         if (event.breakpoint != null) {
           var bpId = event.breakpoint.number;
           console.print('Paused at breakpoint ${bpId} at '
                         '${script.name}:${line}:${col}');
         } else if (event.exception != null) {
@@ skipping 43 matching lines @@
     }
   }
 
   void onEvent(ServiceEvent event) {
     switch(event.kind) {
       case ServiceEvent.kIsolateStart:
         {
           var iso = event.owner;
           console.print(
               "Isolate ${iso.number} '${iso.name}' has been created");
+          if (isolate == null) {
+            console.print("Switching to isolate ${iso.number} '${iso.name}'");
+            isolate = iso;
+          }
         }
         break;
 
       case ServiceEvent.kIsolateExit:
         {
           var iso = event.owner;
           if (iso == isolate) {
-            console.print("The current isolate has exited");
+            console.print("The current isolate ${iso.number} '${iso.name}' "
+                          "has exited");
+            var isolates = vm.isolates;
+            if (isolates.length > 0) {
+              var newIsolate = isolates.first;
+              console.print("Switching to isolate "
+                            "${newIsolate.number} '${newIsolate.name}'");
+              isolate = newIsolate;
+            } else {
+              isolate = null;
+            }
           } else {
             console.print(
                 "Isolate ${iso.number} '${iso.name}' has exited");
           }
         }
         break;
 
       case ServiceEvent.kDebuggerSettingsUpdate:
         if (breakOnException != event.exceptions) {
           breakOnException = event.exceptions;
@@ skipping 236 matching lines @@
       return new Future.value(null);
     }
   }
 }
 
 @CustomTag('debugger-page')
 class DebuggerPageElement extends ObservatoryElement {
   @published Isolate isolate;
 
   isolateChanged(oldValue) {
-    if (isolate != null) {
-      debugger.updateIsolate(isolate);
-    }
+    debugger.updateIsolate(isolate);
   }
   ObservatoryDebugger debugger = new ObservatoryDebugger();
 
   DebuggerPageElement.created() : super.created() {
     debugger.page = this;
   }
 
   StreamSubscription _resizeSubscription;
   Future<StreamSubscription> _isolateSubscriptionFuture;
   Future<StreamSubscription> _debugSubscriptionFuture;
@@ skipping 534 matching lines @@
     consoleTextElement.children.clear();
   }
 }
 
 @CustomTag('debugger-input')
 class DebuggerInputElement extends ObservatoryElement {
   @published Isolate isolate;
   @published String text = '';
   @observable ObservatoryDebugger debugger;
   @observable bool busy = false;
+  @observable String modalPrompt = null;
+  var modalCallback = null;
+
+  void enterMode(String prompt, callback) {
+    assert(prompt == null);
+    modalPrompt = prompt;
+    modalCallback = callback;
+  }
+
+  void exitMode() {
+    assert(prompt != null);
+    modalPrompt = null;
+    modalCallback = null;
+  }
 
   @override
   void ready() {
     super.ready();
     var textBox = $['textBox'];
     textBox.select();
     textBox.onKeyDown.listen((KeyboardEvent e) {
         if (busy) {
           e.preventDefault();
           return;
         }
         busy = true;
-        switch (e.keyCode) {
+        if (modalCallback != null) {
+          if (e.keyCode == KeyCode.ENTER) {
+            var response = text;
+            modalCallback(response).whenComplete(() {
+              text = '';
+              busy = false;
+            });
+          } else {
+            busy = false;
+          }
+          return;
+        }
+        switch (e.keyCode) {
           case KeyCode.TAB:
             e.preventDefault();
             int cursorPos = textBox.selectionStart;
             debugger.complete(text.substring(0, cursorPos)).then((completion) {
               text = completion + text.substring(cursorPos);
               // TODO(turnidge): Move the cursor to the end of the
               // completion, rather than the end of the string.
             }).whenComplete(() {
               busy = false;
             });
@@ skipping 75 matching lines @@
                 busy = false;
               });
             } else {
               busy = false;
             }
             break;
 
           default:
             busy = false;
             break;
-        }
+        }
       });
   }
 
   void focus() {
     $['textBox'].focus();
   }
 
   DebuggerInputElement.created() : super.created();
 }