Dart Web Server: prevent crash

Question

Id'like to develop a web services + web sockets server using dart but the problem is I can't ensure the server's high availability because of uncatched exceptions in isolates.

Of course, I have try-catched my main function, but this is not enough.

If an exception occurs in the then() part of a future, the server will crash.

Which means that ONE flawd request can put the server down.

I realize that this is an open issue but is there any way to acknoledge any crash WITHOUT crashing the VM so that the server can continue serving other requests ?

Thank you.

Answer 1

What I've done in the past is use the main isolate to launch a child isolate which hosts the actual web server. When you launch an isolate, you can pass in an "uncaught exception" handler to the child isolate (I also think you should be able to register one at the top-level as well, to prevent this particular issue, as referenced by the issue in the original question).

Example:

import 'dart:isolate';

void main() {
  // Spawn a child isolate
  spawnFunction(isolateMain, uncaughtExceptionHandler);
}

void isolateMain() {
  // this is the "real" entry point of your app
  // setup http servers and listen etc...
}

bool uncaughtExceptionHandler(ex) {
  // TODO: add logging!
  // respawn a new child isolate.
  spawnFunction(isolateMain, uncaughtException);
  return true; // we've handled the uncaught exception
}

Answer 2

Chris Buckett gave you a good way to restart your server when it fails. However, you still don't want your server to go down.

The try-catch only works for synchronous code.

doSomething() {
  try {
    someSynchronousFunc();

    someAsyncFunc().then(() => print('foo'));
  } catch (e) {
    // ...
  }
}

When your async method completes or fails, it happens "long" after the program is done with the doSomething method.

When you write asynchronous code, it's generally a good idea to start a method by returning a future:

Future doSomething() {
  return new Future(() {
    // your code here.
    var a = b + 5; // throws and is caught.

    return someAsyncCall(); // Errors are forwarded if you return the Future directly.
  });
}

This ensures that if you have code that throws, it catches them and the caller can then catchError() them.

If you write this way, you have much less crashes, assuming that you have some error handling at the top level at least.

Whenever you are calling a method that returns a Future, either return it directly (like shown above) or catchError() for it so that you are handling the possible errors locally.

There's a great lengthy article on the homepage that you should read.