async_hooks: rename initTriggerId

AndreasMadsen · evanlucas · commit 2a4f849c39c8 · 2018-01-15T06:42:17.000-06:00
rename initTriggerId to defaultTriggerAsyncId such it matches the rest of our naming. Backport-PR-URL: #18079 PR-URL: #17273 Reviewed-By: Matteo Collina <matteo.collina@gmail.com> Reviewed-By: James M Snell <jasnell@gmail.com>
diff --git a/lib/_http_client.js b/lib/_http_client.js
@@ -579,7 +579,7 @@ function responseKeepAlive(res, req) {
     socket.removeListener('error', socketErrorListener);
     socket.once('error', freeSocketErrorListener);
     // There are cases where _handle === null. Avoid those. Passing null to
-    // nextTick() will call initTriggerId() to retrieve the id.
+    // nextTick() will call getDefaultTriggerAsyncId() to retrieve the id.
     const asyncId = socket._handle ? socket._handle.getAsyncId() : null;
     // Mark this socket as available, AFTER user-added end
     // handlers have a chance to run.
diff --git a/lib/async_hooks.js b/lib/async_hooks.js
@@ -19,7 +19,7 @@ const {
   disableHooks,
   // Sensitive Embedder API
   newUid,
-  initTriggerId,
+  getDefaultTriggerAsyncId,
   setInitTriggerId,
   emitInit,
   emitBefore,
@@ -152,7 +152,7 @@ class AsyncResource {
     if (typeof opts === 'number') {
       opts = { triggerAsyncId: opts, requireManualDestroy: false };
     } else if (opts.triggerAsyncId === undefined) {
-      opts.triggerAsyncId = initTriggerId();
+      opts.triggerAsyncId = getDefaultTriggerAsyncId();
     }
 
     // Unlike emitInitScript, AsyncResource doesn't supports null as the
@@ -245,7 +245,7 @@ Object.defineProperty(module.exports, 'newUid', {
 
 Object.defineProperty(module.exports, 'initTriggerId', {
   get: internalUtil.deprecate(function() {
-    return initTriggerId;
+    return getDefaultTriggerAsyncId;
   }, 'async_hooks.initTriggerId is deprecated. ' +
      'Use the AsyncResource default instead.', 'DEP0085')
 });
diff --git a/lib/dgram.js b/lib/dgram.js
@@ -28,7 +28,7 @@ const dns = require('dns');
 const util = require('util');
 const { isUint8Array } = require('internal/util/types');
 const EventEmitter = require('events');
-const { setInitTriggerId } = require('internal/async_hooks');
+const { setDefaultTriggerAsyncId } = require('internal/async_hooks');
 const { UV_UDP_REUSEADDR } = process.binding('constants').os;
 const { async_id_symbol } = process.binding('async_wrap');
 const { nextTick } = require('internal/process/next_tick');
@@ -479,7 +479,7 @@ function doSend(ex, self, ip, list, address, port, callback) {
   // node::SendWrap isn't instantiated and attached to the JS instance of
   // SendWrap above until send() is called. So don't set the init trigger id
   // until now.
-  setInitTriggerId(self[async_id_symbol]);
+  setDefaultTriggerAsyncId(self[async_id_symbol]);
   var err = self._handle.send(req,
                               list,
                               list.length,
diff --git a/lib/internal/async_hooks.js b/lib/internal/async_hooks.js
@@ -14,10 +14,10 @@ const async_wrap = process.binding('async_wrap');
  *  kTriggerAsyncId: The trigger_async_id of the resource responsible for
  *    the current execution stack.
  *  kAsyncIdCounter: Incremental counter tracking the next assigned async_id.
- *  kInitTriggerAsyncId: Written immediately before a resource's constructor
+ *  kDefaultTriggerAsyncId: Written immediately before a resource's constructor
  *    that sets the value of the init()'s triggerAsyncId. The order of
  *    retrieving the triggerAsyncId value is passing directly to the
- *    constructor -> value set in kInitTriggerAsyncId -> executionAsyncId of
+ *    constructor -> value set in kDefaultTriggerAsyncId -> executionAsyncId of
  *    the current resource.
  */
 const { async_hook_fields, async_id_fields } = async_wrap;
@@ -61,7 +61,7 @@ const active_hooks = {
 // for a given step, that step can bail out early.
 const { kInit, kBefore, kAfter, kDestroy, kPromiseResolve,
         kCheck, kExecutionAsyncId, kAsyncIdCounter,
-        kInitTriggerAsyncId } = async_wrap.constants;
+        kDefaultTriggerAsyncId } = async_wrap.constants;
 
 // Used in AsyncHook and AsyncResource.
 const init_symbol = Symbol('init');
@@ -242,25 +242,25 @@ function newUid() {
   return ++async_id_fields[kAsyncIdCounter];
 }
 
-
 // Return the triggerAsyncId meant for the constructor calling it. It's up to
 // the user to safeguard this call and make sure it's zero'd out when the
 // constructor is complete.
-function initTriggerId() {
-  var triggerAsyncId = async_id_fields[kInitTriggerAsyncId];
+function getDefaultTriggerAsyncId() {
+  var defaultTriggerAsyncId = async_id_fields[kDefaultTriggerAsyncId];
   // Reset value after it's been called so the next constructor doesn't
   // inherit it by accident.
-  async_id_fields[kInitTriggerAsyncId] = 0;
-  if (triggerAsyncId <= 0)
-    triggerAsyncId = async_id_fields[kExecutionAsyncId];
-  return triggerAsyncId;
+  async_id_fields[kDefaultTriggerAsyncId] = 0;
+  // If defaultTriggerAsyncId isn't set, use the executionAsyncId
+  if (defaultTriggerAsyncId <= 0)
+    defaultTriggerAsyncId = async_id_fields[kExecutionAsyncId];
+  return defaultTriggerAsyncId;
 }
 
 
-function setInitTriggerId(triggerAsyncId) {
+function setDefaultTriggerAsyncId(triggerAsyncId) {
   // CHECK(Number.isSafeInteger(triggerAsyncId))
   // CHECK(triggerAsyncId > 0)
-  async_id_fields[kInitTriggerAsyncId] = triggerAsyncId;
+  async_id_fields[kDefaultTriggerAsyncId] = triggerAsyncId;
 }
 
 
@@ -279,13 +279,13 @@ function emitInitScript(asyncId, type, triggerAsyncId, resource) {
     return;
 
   // This can run after the early return check b/c running this function
-  // manually means that the embedder must have used initTriggerId().
+  // manually means that the embedder must have used getDefaultTriggerAsyncId().
   if (triggerAsyncId === null) {
-    triggerAsyncId = initTriggerId();
+    triggerAsyncId = getDefaultTriggerAsyncId();
   } else {
-    // If a triggerAsyncId was passed, any kInitTriggerAsyncId still must be
+    // If a triggerAsyncId was passed, any kDefaultTriggerAsyncId still must be
     // null'd.
-    async_id_fields[kInitTriggerAsyncId] = 0;
+    async_id_fields[kDefaultTriggerAsyncId] = 0;
   }
 
   emitInitNative(asyncId, type, triggerAsyncId, resource);
@@ -337,8 +337,8 @@ module.exports = {
   disableHooks,
   // Sensitive Embedder API
   newUid,
-  initTriggerId,
-  setInitTriggerId,
+  getDefaultTriggerAsyncId,
+  setDefaultTriggerAsyncId,
   emitInit: emitInitScript,
   emitBefore: emitBeforeScript,
   emitAfter: emitAfterScript,
diff --git a/lib/internal/bootstrap_node.js b/lib/internal/bootstrap_node.js
@@ -368,14 +368,14 @@
     // Internal functions needed to manipulate the stack.
     const { clearAsyncIdStack, asyncIdStackSize } = async_wrap;
     const { kAfter, kExecutionAsyncId,
-            kInitTriggerAsyncId } = async_wrap.constants;
+            kDefaultTriggerAsyncId } = async_wrap.constants;
 
     process._fatalException = function(er) {
       var caught;
 
-      // It's possible that kInitTriggerAsyncId was set for a constructor call
-      // that threw and was never cleared. So clear it now.
-      async_id_fields[kInitTriggerAsyncId] = 0;
+      // It's possible that kDefaultTriggerAsyncId was set for a constructor
+      // call that threw and was never cleared. So clear it now.
+      async_id_fields[kDefaultTriggerAsyncId] = 0;
 
       if (exceptionHandlerState.captureFn !== null) {
         exceptionHandlerState.captureFn(er);
diff --git a/lib/internal/process/next_tick.js b/lib/internal/process/next_tick.js
@@ -48,7 +48,7 @@ function setupNextTick() {
   const promises = require('internal/process/promises');
   const errors = require('internal/errors');
   const emitPendingUnhandledRejections = promises.setup(scheduleMicrotasks);
-  const initTriggerId = async_hooks.initTriggerId;
+  const getDefaultTriggerAsyncId = async_hooks.getDefaultTriggerAsyncId;
   // Two arrays that share state between C++ and JS.
   const { async_hook_fields, async_id_fields } = async_wrap;
   // Used to change the state of the async id stack.
@@ -210,7 +210,7 @@ function setupNextTick() {
     nextTickQueue.push(new TickObject(callback,
                                       args,
                                       ++async_id_fields[kAsyncIdCounter],
-                                      initTriggerId()));
+                                      getDefaultTriggerAsyncId()));
   }
 
   // `internalNextTick()` will not enqueue any callback when the process is
@@ -237,7 +237,7 @@ function setupNextTick() {
     }
 
     if (triggerAsyncId === null)
-      triggerAsyncId = initTriggerId();
+      triggerAsyncId = getDefaultTriggerAsyncId();
     // In V8 6.2, moving tickInfo & async_id_fields[kAsyncIdCounter] into the
     // TickObject incurs a significant performance penalty in the
     // next-tick-breadth-args benchmark (revisit later)
diff --git a/lib/net.js b/lib/net.js
@@ -43,7 +43,7 @@ const { TCPConnectWrap } = process.binding('tcp_wrap');
 const { PipeConnectWrap } = process.binding('pipe_wrap');
 const { ShutdownWrap, WriteWrap } = process.binding('stream_wrap');
 const { async_id_symbol } = process.binding('async_wrap');
-const { newUid, setInitTriggerId } = require('internal/async_hooks');
+const { newUid, setDefaultTriggerAsyncId } = require('internal/async_hooks');
 const { nextTick } = require('internal/process/next_tick');
 const errors = require('internal/errors');
 const dns = require('dns');
@@ -301,7 +301,7 @@ function onSocketFinish() {
   // node::ShutdownWrap isn't instantiated and attached to the JS instance of
   // ShutdownWrap above until shutdown() is called. So don't set the init
   // trigger id until now.
-  setInitTriggerId(this[async_id_symbol]);
+  setDefaultTriggerAsyncId(this[async_id_symbol]);
   var err = this._handle.shutdown(req);
 
   if (err)
@@ -939,7 +939,7 @@ function internalConnect(
     // node::TCPConnectWrap isn't instantiated and attached to the JS instance
     // of TCPConnectWrap above until connect() is called. So don't set the init
     // trigger id until now.
-    setInitTriggerId(self[async_id_symbol]);
+    setDefaultTriggerAsyncId(self[async_id_symbol]);
     if (addressType === 4)
       err = self._handle.connect(req, address, port);
     else
@@ -952,7 +952,7 @@ function internalConnect(
     // node::PipeConnectWrap isn't instantiated and attached to the JS instance
     // of PipeConnectWrap above until connect() is called. So don't set the
     // init trigger id until now.
-    setInitTriggerId(self[async_id_symbol]);
+    setDefaultTriggerAsyncId(self[async_id_symbol]);
     err = self._handle.connect(req, address, afterConnect);
   }
 
@@ -1091,7 +1091,7 @@ function lookupAndConnect(self, options) {
   debug('connect: dns options', dnsopts);
   self._host = host;
   var lookup = options.lookup || dns.lookup;
-  setInitTriggerId(self[async_id_symbol]);
+  setDefaultTriggerAsyncId(self[async_id_symbol]);
   lookup(host, dnsopts, function emitLookup(err, ip, addressType) {
     self.emit('lookup', err, ip, addressType, host);
 
diff --git a/lib/timers.js b/lib/timers.js
@@ -34,7 +34,7 @@ const kOnTimeout = TimerWrap.kOnTimeout | 0;
 // Two arrays that share state between C++ and JS.
 const { async_hook_fields, async_id_fields } = async_wrap;
 const {
-  initTriggerId,
+  getDefaultTriggerAsyncId,
   // The needed emit*() functions.
   emitInit,
   emitBefore,
@@ -181,7 +181,7 @@ function insert(item, unrefed) {
   if (!item[async_id_symbol] || item._destroyed) {
     item._destroyed = false;
     item[async_id_symbol] = ++async_id_fields[kAsyncIdCounter];
-    item[trigger_async_id_symbol] = initTriggerId();
+    item[trigger_async_id_symbol] = getDefaultTriggerAsyncId();
     if (async_hook_fields[kInit] > 0) {
       emitInit(item[async_id_symbol],
                'Timeout',
@@ -552,7 +552,7 @@ function Timeout(callback, after, args, isRepeat) {
   this._destroyed = false;
 
   this[async_id_symbol] = ++async_id_fields[kAsyncIdCounter];
-  this[trigger_async_id_symbol] = initTriggerId();
+  this[trigger_async_id_symbol] = getDefaultTriggerAsyncId();
   if (async_hook_fields[kInit] > 0) {
     emitInit(this[async_id_symbol],
              'Timeout',
@@ -769,7 +769,7 @@ function Immediate(callback, args) {
   this._destroyed = false;
 
   this[async_id_symbol] = ++async_id_fields[kAsyncIdCounter];
-  this[trigger_async_id_symbol] = initTriggerId();
+  this[trigger_async_id_symbol] = getDefaultTriggerAsyncId();
   if (async_hook_fields[kInit] > 0) {
     emitInit(this[async_id_symbol],
              'Immediate',
diff --git a/src/async_wrap.cc b/src/async_wrap.cc
@@ -310,7 +310,7 @@ static void PromiseHook(PromiseHookType type, Local<Promise> promise,
       }
       // get id from parentWrap
       double trigger_async_id = parent_wrap->get_async_id();
-      env->set_init_trigger_async_id(trigger_async_id);
+      env->set_default_trigger_async_id(trigger_async_id);
     }
 
     wrap = PromiseWrap::New(env, promise, parent_wrap, silent);
@@ -541,9 +541,10 @@ void AsyncWrap::Initialize(Local<Object> target,
   //
   // kAsyncUid: Maintains the state of the next unique id to be assigned.
   //
-  // kInitTriggerAsyncId: Write the id of the resource responsible for a
+  // kDefaultTriggerAsyncId: Write the id of the resource responsible for a
   //   handle's creation just before calling the new handle's constructor.
-  //   After the new handle is constructed kInitTriggerAsyncId is set back to 0.
+  //   After the new handle is constructed kDefaultTriggerAsyncId is set back
+  //   to 0.
   FORCE_SET_TARGET_FIELD(target,
                          "async_id_fields",
                          env->async_hooks()->async_id_fields().GetJSArray());
@@ -563,7 +564,7 @@ void AsyncWrap::Initialize(Local<Object> target,
   SET_HOOKS_CONSTANT(kExecutionAsyncId);
   SET_HOOKS_CONSTANT(kTriggerAsyncId);
   SET_HOOKS_CONSTANT(kAsyncIdCounter);
-  SET_HOOKS_CONSTANT(kInitTriggerAsyncId);
+  SET_HOOKS_CONSTANT(kDefaultTriggerAsyncId);
 #undef SET_HOOKS_CONSTANT
   FORCE_SET_TARGET_FIELD(target, "constants", constants);
 
@@ -676,7 +677,7 @@ void AsyncWrap::EmitDestroy(Environment* env, double async_id) {
 void AsyncWrap::AsyncReset(double execution_async_id, bool silent) {
   async_id_ =
     execution_async_id == -1 ? env()->new_async_id() : execution_async_id;
-  trigger_async_id_ = env()->get_init_trigger_async_id();
+  trigger_async_id_ = env()->get_default_trigger_async_id();
 
   switch (provider_type()) {
 #define V(PROVIDER)                                                           \
@@ -777,7 +778,7 @@ async_context EmitAsyncInit(Isolate* isolate,
 
   // Initialize async context struct
   if (trigger_async_id == -1)
-    trigger_async_id = env->get_init_trigger_async_id();
+    trigger_async_id = env->get_default_trigger_async_id();
 
   async_context context = {
     env->new_async_id(),  // async_id_
diff --git a/src/connection_wrap.cc b/src/connection_wrap.cc
@@ -49,7 +49,7 @@ void ConnectionWrap<WrapType, UVType>::OnConnection(uv_stream_t* handle,
   };
 
   if (status == 0) {
-    env->set_init_trigger_async_id(wrap_data->get_async_id());
+    env->set_default_trigger_async_id(wrap_data->get_async_id());
     // Instantiate the client javascript object and handle.
     Local<Object> client_obj = WrapType::Instantiate(env,
                                                      wrap_data,
diff --git a/src/env-inl.h b/src/env-inl.h
@@ -440,17 +440,18 @@ inline double Environment::trigger_async_id() {
   return async_hooks()->async_id_fields()[AsyncHooks::kTriggerAsyncId];
 }
 
-inline double Environment::get_init_trigger_async_id() {
-  AliasedBuffer<double, v8::Float64Array>& async_id_fields =
-    async_hooks()->async_id_fields();
-  double tid = async_id_fields[AsyncHooks::kInitTriggerAsyncId];
-  async_id_fields[AsyncHooks::kInitTriggerAsyncId] = 0;
-  if (tid <= 0) tid = execution_async_id();
-  return tid;
-}
-
-inline void Environment::set_init_trigger_async_id(const double id) {
-  async_hooks()->async_id_fields()[AsyncHooks::kInitTriggerAsyncId] = id;
+inline double Environment::get_default_trigger_async_id() {
+  double default_trigger_async_id =
+    async_hooks()->async_id_fields()[AsyncHooks::kDefaultTriggerAsyncId];
+  async_hooks()->async_id_fields()[AsyncHooks::kDefaultTriggerAsyncId] = 0;
+  // If defaultTriggerAsyncId isn't set, use the executionAsyncId
+  if (default_trigger_async_id <= 0)
+    default_trigger_async_id = execution_async_id();
+  return default_trigger_async_id;
+}
+
+inline void Environment::set_default_trigger_async_id(const double id) {
+  async_hooks()->async_id_fields()[AsyncHooks::kDefaultTriggerAsyncId] = id;
 }
 
 inline double* Environment::heap_statistics_buffer() const {
diff --git a/src/env.h b/src/env.h
@@ -389,7 +389,7 @@ class Environment {
       kExecutionAsyncId,
       kTriggerAsyncId,
       kAsyncIdCounter,
-      kInitTriggerAsyncId,
+      kDefaultTriggerAsyncId,
       kUidFieldsCount,
     };
 
@@ -565,8 +565,8 @@ class Environment {
   inline double new_async_id();
   inline double execution_async_id();
   inline double trigger_async_id();
-  inline double get_init_trigger_async_id();
-  inline void set_init_trigger_async_id(const double id);
+  inline double get_default_trigger_async_id();
+  inline void set_default_trigger_async_id(const double id);
 
   // List of id's that have been destroyed and need the destroy() cb called.
   inline std::vector<double>* destroy_async_id_list();
diff --git a/src/stream_base.cc b/src/stream_base.cc
diff --git a/src/tcp_wrap.cc b/src/tcp_wrap.cc
diff --git a/src/udp_wrap.cc b/src/udp_wrap.cc
