lib: rewrite AsyncLocalStorage without async_hooks

PR-URL: https://github.com/nodejs/node/pull/48528
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Rafael Gonzaga <rafael.nunu@hotmail.com>
Reviewed-By: Chengzhong Wu <legendecas@gmail.com>
Reviewed-By: Santiago Gimeno <santiago.gimeno@gmail.com>
Reviewed-By: Gerhard Stöbich <deb2001-github@yahoo.de>

lib/internal/async_local_storage/async_hooks.js

@@ -0,0 +1,117 @@
+'use strict';
+
+const {
+  ArrayPrototypeIndexOf,
+  ArrayPrototypePush,
+  ArrayPrototypeSplice,
+  ObjectIs,
+  ReflectApply,
+  Symbol,
+} = primordials;
+
+const {
+  AsyncResource,
+  createHook,
+  executionAsyncResource,
+} = require('async_hooks');
+
+const storageList = [];
+const storageHook = createHook({
+  init(asyncId, type, triggerAsyncId, resource) {
+    const currentResource = executionAsyncResource();
+    // Value of currentResource is always a non null object
+    for (let i = 0; i < storageList.length; ++i) {
+      storageList[i]._propagate(resource, currentResource, type);
+    }
+  },
+});
+
+class AsyncLocalStorage {
+  constructor() {
+    this.kResourceStore = Symbol('kResourceStore');
+    this.enabled = false;
+  }
+
+  static bind(fn) {
+    return AsyncResource.bind(fn);
+  }
+
+  static snapshot() {
+    return AsyncLocalStorage.bind((cb, ...args) => cb(...args));
+  }
+
+  disable() {
+    if (this.enabled) {
+      this.enabled = false;
+      // If this.enabled, the instance must be in storageList
+      const index = ArrayPrototypeIndexOf(storageList, this);
+      ArrayPrototypeSplice(storageList, index, 1);
+      if (storageList.length === 0) {
+        storageHook.disable();
+      }
+    }
+  }
+
+  _enable() {
+    if (!this.enabled) {
+      this.enabled = true;
+      ArrayPrototypePush(storageList, this);
+      storageHook.enable();
+    }
+  }
+
+  // Propagate the context from a parent resource to a child one
+  _propagate(resource, triggerResource, type) {
+    const store = triggerResource[this.kResourceStore];
+    if (this.enabled) {
+      resource[this.kResourceStore] = store;
+    }
+  }
+
+  enterWith(store) {
+    this._enable();
+    const resource = executionAsyncResource();
+    resource[this.kResourceStore] = store;
+  }
+
+  run(store, callback, ...args) {
+    // Avoid creation of an AsyncResource if store is already active
+    if (ObjectIs(store, this.getStore())) {
+      return ReflectApply(callback, null, args);
+    }
+
+    this._enable();
+
+    const resource = executionAsyncResource();
+    const oldStore = resource[this.kResourceStore];
+
+    resource[this.kResourceStore] = store;
+
+    try {
+      return ReflectApply(callback, null, args);
+    } finally {
+      resource[this.kResourceStore] = oldStore;
+    }
+  }
+
+  exit(callback, ...args) {
+    if (!this.enabled) {
+      return ReflectApply(callback, null, args);
+    }
+    this.disable();
+    try {
+      return ReflectApply(callback, null, args);
+    } finally {
+      this._enable();
+    }
+  }
+
+  getStore() {
+    if (this.enabled) {
+      const resource = executionAsyncResource();
+      return resource[this.kResourceStore];
+    }
+  }
+}
+
+module.exports = AsyncLocalStorage;