稳定性: 2 - 不稳定

javascript
// XXX WARNING!  BAD IDEA!

var d = require('domain').create(
d.on('error', function(er) {
  // The error won't crash the process, but what it does is worse!
  // Though we've prevented abrupt process restarting, we are leaking
  // resources like crazy if this ever happens.
  // This is no better than process.on('uncaughtException')!
  console.log('error, but oh well', er.message
}
d.run(function() {
  require('http').createServer(function(req, res) {
    handleRequest(req, res
  }).listen(PORT
}

javascript
// 好一些的做法!

var cluster = require('cluster'
var PORT = +process.env.PORT || 1337;

if (cluster.isMaster) {
  // In real life, you'd probably use more than just 2 workers,
  // and perhaps not put the master and worker in the same file.
  //
  // You can also of course get a bit fancier about logging, and
  // implement whatever custom logic you need to prevent DoS
  // attacks and other bad behavior.
  //
  // See the options in the cluster documentation.
  //
  // The important thing is that the master does very little,
  // increasing our resilience to unexpected errors.

  cluster.fork(
  cluster.fork(

  cluster.on('disconnect', function(worker) {
    console.error('disconnect!'
    cluster.fork(
  }

} else {
  // the worker
  //
  // This is where we put our bugs!

  var domain = require('domain'

  // See the cluster documentation for more details about using
  // worker processes to serve requests.  How it works, caveats, etc.

  var server = require('http').createServer(function(req, res) {
    var d = domain.create(
    d.on('error', function(er) {
      console.error('error', er.stack

      // Note: we're in dangerous territory!
      // By definition, something unexpected occurred,
      // which we probably didn't want.
      // Anything can happen now!  Be very careful!

      try {
        // make sure we close down within 30 seconds
        var killtimer = setTimeout(function() {
          process.exit(1
        }, 30000
        // But don't keep the process open just for that!
        killtimer.unref(

        // stop taking new requests.
        server.close(

        // Let the master know we're dead.  This will trigger a
        // 'disconnect' in the cluster master, and then it will fork
        // a new worker.
        cluster.worker.disconnect(

        // try to send an error to the request that triggered the problem
        res.statusCode = 500;
        res.setHeader('content-type', 'text/plain'
        res.end('Oops, there was a problem!\n'
      } catch (er2) {
        // oh well, not much we can do at this point.
        console.error('Error sending 500!', er2.stack
      }
    }

    // Because req and res were created before this domain existed,
    // we need to explicitly add them.
    // See the explanation of implicit vs explicit binding below.
    d.add(req
    d.add(res

    // Now run the handler function in the domain.
    d.run(function() {
      handleRequest(req, res
    }
  }
  server.listen(PORT
}

// This part isn't important.  Just an example routing thing.
// You'd put your fancy application logic here.
function handleRequest(req, res) {
  switch(req.url) {
    case '/error':
      // We do some async stuff, and then...
      setTimeout(function() {
        // Whoops!
        flerb.bark(
      }
      break;
    default:
      res.end('ok'
  }
}

// create a top-level domain for the server
var serverDomain = domain.create(

serverDomain.run(function() {
  // server is created in the scope of serverDomain
  http.createServer(function(req, res) {
    // req and res are also created in the scope of serverDomain
    // however, we'd prefer to have a separate domain for each request.
    // create it first thing, and add req and res to it.
    var reqd = domain.create(
    reqd.add(req
    reqd.add(res
    reqd.on('error', function(er) {
      console.error('Error', er, req.url
      try {
        res.writeHead(500
        res.end('Error occurred, sorry.'
      } catch (er) {
        console.error('Error sending 500', er, req.url
      }
    }
  }).listen(1337
}

var d = domain.create(
d.on('error', function(er) {
  console.error('Caught error!', er
}
d.run(function() {
  process.nextTick(function() {
    setTimeout(function() { // simulating some various async stuff
      fs.open('non-existent file', 'r', function(er, fd) {
        if (er) throw er;
        // proceed...
      }
    }, 100
  }
}

var d = domain.create(

function readSomeFile(filename, cb) {
  fs.readFile(filename, 'utf8', d.bind(function(er, data) {
    // if this throws, it will also be passed to the domain
    return cb(er, data ? JSON.parse(data) : null
  })
}

d.on('error', function(er) {
  // an error occurred somewhere.
  // if we throw it now, it will crash the program
  // with the normal line number and stack message.
}

var d = domain.create(

function readSomeFile(filename, cb) {
  fs.readFile(filename, 'utf8', d.intercept(function(data) {
    // note, the first argument is never passed to the
    // callback since it is assumed to be the 'Error' argument
    // and thus intercepted by the domain.

    // if this throws, it will also be passed to the domain
    // so the error-handling logic can be moved to the 'error'
    // event on the domain instead of being repeated throughout
    // the program.
    return cb(null, JSON.parse(data)
  })
}

d.on('error', function(er) {
  // an error occurred somewhere.
  // if we throw it now, it will crash the program
  // with the normal line number and stack message.
}

稳定性: 0 - 抛弃。通过域里设置的错误事件来显示的消除失败的 IO 操作。