domain: support promises

Fixes: #10724
PR-URL: #12489
Reviewed-By: Matthew Loring <[email protected]>
Reviewed-By: Julien Gilli <[email protected]>
Reviewed-By: Benjamin Gruenbaum <[email protected]>
Reviewed-By: James M Snell <[email protected]>
Reviewed-By: Ben Noordhuis <[email protected]>
Reviewed-By: Colin Ihrig <[email protected]>

doc/api/domain.md

@@ -1,4 +1,11 @@
 # Domain
+<!-- YAML
+changes:
+ - version: REPLACEME
+ pr-url: https://github.com/nodejs/node/pull/12489
+ description: Handlers for `Promise`s are now invoked in the domain in which
+ the first promise of a chain was created.
+-->
 
 > Stability: 0 - Deprecated
 
@@ -444,6 +451,49 @@ d.run(() => {
 In this example, the `d.on('error')` handler will be triggered, rather
 than crashing the program.
 
+## Domains and Promises
+
+As of Node REPLACEME, the handlers of Promises are run inside the domain in
+which the call to `.then` or `.catch` itself was made:
+
+```js
+const d1 = domain.create();
+const d2 = domain.create();
+
+let p;
+d1.run(() => {
+ p = Promise.resolve(42);
+});
+
+d2.run(() => {
+ p.then((v) => {
+ // running in d2
+ });
+});
+```
+
+A callback may be bound to a specific domain using [`domain.bind(callback)`][]:
+
+```js
+const d1 = domain.create();
+const d2 = domain.create();
+
+let p;
+d1.run(() => {
+ p = Promise.resolve(42);
+});
+
+d2.run(() => {
+ p.then(p.domain.bind((v) => {
+ // running in d1
+ }));
+});
+```
+
+Note that domains will not interfere with the error handling mechanisms for
+Promises, i.e. no `error` event will be emitted for unhandled Promise
+rejections.
+
 [`domain.add(emitter)`]: #domain_domain_add_emitter
 [`domain.bind(callback)`]: #domain_domain_bind_callback
 [`domain.dispose()`]: #domain_domain_dispose

src/node.cc

@@ -143,6 +143,7 @@ using v8::Number;
 using v8::Object;
 using v8::ObjectTemplate;
 using v8::Promise;
+using v8::PromiseHookType;
 using v8::PromiseRejectMessage;
 using v8::PropertyCallbackInfo;
 using v8::ScriptOrigin;
@@ -1114,6 +1115,58 @@ bool ShouldAbortOnUncaughtException(Isolate* isolate) {
 }
 
 
+void DomainPromiseHook(PromiseHookType type,
+ Local<Promise> promise,
+ Local<Value> parent,
+ void* arg) {
+ Environment* env = static_cast<Environment*>(arg);
+ Local<Context> context = env->context();
+
+ if (type == PromiseHookType::kResolve) return;
+ if (type == PromiseHookType::kInit && env->in_domain()) {
+ promise->Set(context,
+ env->domain_string(),
+ env->domain_array()->Get(context,
+ 0).ToLocalChecked()).FromJust();
+ return;
+ }
+
+ // Loosely based on node::MakeCallback().
+ Local<Value> domain_v =
+ promise->Get(context, env->domain_string()).ToLocalChecked();
+ if (!domain_v->IsObject())
+ return;
+
+ Local<Object> domain = domain_v.As<Object>();
+ if (domain->Get(context, env->disposed_string())
+ .ToLocalChecked()->IsTrue()) {
+ return;
+ }
+
+ if (type == PromiseHookType::kBefore) {
+ Local<Value> enter_v =
+ domain->Get(context, env->enter_string()).ToLocalChecked();
+ if (enter_v->IsFunction()) {
+ if (enter_v.As<Function>()->Call(context, domain, 0, nullptr).IsEmpty()) {
+ FatalError("node::PromiseHook",
+ "domain enter callback threw, please report this "
+ "as a bug in Node.js");
+ }
+ }
+ } else {
+ Local<Value> exit_v =
+ domain->Get(context, env->exit_string()).ToLocalChecked();
+ if (exit_v->IsFunction()) {
+ if (exit_v.As<Function>()->Call(context, domain, 0, nullptr).IsEmpty()) {
+ FatalError("node::MakeCallback",
+ "domain exit callback threw, please report this "
+ "as a bug in Node.js");
+ }
+ }
+ }
+}
+
+
 void SetupDomainUse(const FunctionCallbackInfo<Value>& args) {
  Environment* env = Environment::GetCurrent(args);
 
@@ -1153,9 +1206,12 @@ void SetupDomainUse(const FunctionCallbackInfo<Value>& args) {
  Local<ArrayBuffer> array_buffer =
  ArrayBuffer::New(env->isolate(), fields, sizeof(*fields) * fields_count);
 
+ env->AddPromiseHook(DomainPromiseHook, static_cast<void*>(env));
+
  args.GetReturnValue().Set(Uint32Array::New(array_buffer, 0, fields_count));
 }
 
+
 void RunMicrotasks(const FunctionCallbackInfo<Value>& args) {
  args.GetIsolate()->RunMicrotasks();
 }

test/parallel/test-domain-promise.js

@@ -0,0 +1,128 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const domain = require('domain');
+const fs = require('fs');
+const vm = require('vm');
+
+common.crashOnUnhandledRejection();
+
+{
+ const d = domain.create();
+
+ d.run(common.mustCall(() => {
+ Promise.resolve().then(common.mustCall(() => {
+ assert.strictEqual(process.domain, d);
+ }));
+ }));
+}
+
+{
+ const d = domain.create();
+
+ d.run(common.mustCall(() => {
+ Promise.resolve().then(() => {}).then(() => {}).then(common.mustCall(() => {
+ assert.strictEqual(process.domain, d);
+ }));
+ }));
+}
+
+{
+ const d = domain.create();
+
+ d.run(common.mustCall(() => {
+ vm.runInNewContext(`Promise.resolve().then(common.mustCall(() => {
+ assert.strictEqual(process.domain, d);
+ }));`, { common, assert, process, d });
+ }));
+}
+
+{
+ const d1 = domain.create();
+ const d2 = domain.create();
+ let p;
+ d1.run(common.mustCall(() => {
+ p = Promise.resolve(42);
+ }));
+
+ d2.run(common.mustCall(() => {
+ p.then(common.mustCall((v) => {
+ assert.strictEqual(process.domain, d2);
+ assert.strictEqual(p.domain, d1);
+ }));
+ }));
+}
+
+{
+ const d1 = domain.create();
+ const d2 = domain.create();
+ let p;
+ d1.run(common.mustCall(() => {
+ p = Promise.resolve(42);
+ }));
+
+ d2.run(common.mustCall(() => {
+ p.then(p.domain.bind(common.mustCall((v) => {
+ assert.strictEqual(process.domain, d1);
+ assert.strictEqual(p.domain, d1);
+ })));
+ }));
+}
+
+{
+ const d1 = domain.create();
+ const d2 = domain.create();
+ let p;
+ d1.run(common.mustCall(() => {
+ p = Promise.resolve(42);
+ }));
+
+ d1.run(common.mustCall(() => {
+ d2.run(common.mustCall(() => {
+ p.then(common.mustCall((v) => {
+ assert.strictEqual(process.domain, d2);
+ assert.strictEqual(p.domain, d1);
+ }));
+ }));
+ }));
+}
+
+{
+ const d1 = domain.create();
+ const d2 = domain.create();
+ let p;
+ d1.run(common.mustCall(() => {
+ p = Promise.reject(new Error('foobar'));
+ }));
+
+ d2.run(common.mustCall(() => {
+ p.catch(common.mustCall((v) => {
+ assert.strictEqual(process.domain, d2);
+ assert.strictEqual(p.domain, d1);
+ }));
+ }));
+}
+
+{
+ const d = domain.create();
+
+ d.run(common.mustCall(() => {
+ Promise.resolve().then(common.mustCall(() => {
+ setTimeout(common.mustCall(() => {
+ assert.strictEqual(process.domain, d);
+ }), 0);
+ }));
+ }));
+}
+
+{
+ const d = domain.create();
+
+ d.run(common.mustCall(() => {
+ Promise.resolve().then(common.mustCall(() => {
+ fs.readFile(__filename, common.mustCall(() => {
+ assert.strictEqual(process.domain, d);
+ }));
+ }));
+ }));
+}