async_hooks: move lookupResourceWithStorage() into executionAsyncReso…

…urce() Signed-off-by: Darshan Sen <darshan.sen@postman.com>
nodejs · Nov 7, 2021 · 9d8b234 · 9d8b234
1 parent 12abaf7
commit 9d8b234
Show file tree

Hide file tree

Showing 2 changed files with 55 additions and 62 deletions.
diff --git a/lib/async_hooks.js b/lib/async_hooks.js
@@ -252,65 +252,10 @@ class AsyncResource {
   }
 }
 
-let _tls_wrap;
-
-function lazyLoadTlsWrap() {
-  _tls_wrap ??= require('_tls_wrap');
-}
-
-let dgram;
-
-function lazyLoadDgram() {
-  dgram ??= require('dgram');
-}
-
-let internal_dgram;
-
-function lazyLoadInternalDgram() {
-  internal_dgram ??= require('internal/dgram');
-}
-
-let net;
-
-function lazyLoadNet() {
-  net ??= require('net');
-}
-
-function lookupResourceWithStorage() {
-  // When a TCP/UDP object is created, its owner_symbol is uninitialized, so
-  // calling executionAsyncResource() would return the TCP/UDP object itself.
-  // So the store is initially saved on the TCP/UDP object. Later on, when the
-  // Socket/TLSSocket object is created, the TCP/UDP object is wrapped by the
-  // Socket/TLSSocket object in the _handle property and the owner_symbol of the
-  // TCP/UDP object is set to the corresponding Socket/TLSSocket object. So
-  // calling executionAsyncResource() now would return the Socket/TLSSocket
-  // object, which does not contain the storage that was saved initially. Hence,
-  // in the case of a Socket/TLSSocket object, we must use the underlying
-  // TCP/UDP object, if available, for storage.
-
-  lazyLoadDgram();
-  lazyLoadInternalDgram();
-  lazyLoadNet();
-  lazyLoadTlsWrap();
-
-  let resource = executionAsyncResource();
-
-  if ((resource instanceof net.Socket ||
-       resource instanceof _tls_wrap.TLSSocket) &&
-      resource._handle != null) {
-    resource = resource._handle;
-  } else if (resource instanceof dgram.Socket &&
-             resource[internal_dgram.kStateSymbol].handle != null) {
-    resource = resource[internal_dgram.kStateSymbol].handle;
-  }
-
-  return resource;
-}
-
 const storageList = [];
 const storageHook = createHook({
   init(asyncId, type, triggerAsyncId, resource) {
-    const currentResource = lookupResourceWithStorage();
+    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);
@@ -354,7 +299,7 @@ class AsyncLocalStorage {
 
   enterWith(store) {
     this._enable();
-    const resource = lookupResourceWithStorage();
+    const resource = executionAsyncResource();
     resource[this.kResourceStore] = store;
   }
 
@@ -366,7 +311,7 @@ class AsyncLocalStorage {
 
     this._enable();
 
-    const resource = lookupResourceWithStorage();
+    const resource = executionAsyncResource();
     const oldStore = resource[this.kResourceStore];
 
     resource[this.kResourceStore] = store;
@@ -392,7 +337,7 @@ class AsyncLocalStorage {
 
   getStore() {
     if (this.enabled) {
-      const resource = lookupResourceWithStorage();
+      const resource = executionAsyncResource();
       return resource[this.kResourceStore];
     }
   }

diff --git a/lib/internal/async_hooks.js b/lib/internal/async_hooks.js
@@ -141,6 +141,30 @@ setCallbackTrampoline(callbackTrampoline);
 
 const topLevelResource = {};
 
+let _tls_wrap;
+
+function lazyLoadTlsWrap() {
+  _tls_wrap ??= require('_tls_wrap');
+}
+
+let dgram;
+
+function lazyLoadDgram() {
+  dgram ??= require('dgram');
+}
+
+let internal_dgram;
+
+function lazyLoadInternalDgram() {
+  internal_dgram ??= require('internal/dgram');
+}
+
+let net;
+
+function lazyLoadNet() {
+  net ??= require('net');
+}
+
 function executionAsyncResource() {
   // Indicate to the native layer that this function is likely to be used,
   // in which case it will inform JS about the current async resource via
@@ -149,9 +173,33 @@ function executionAsyncResource() {
 
   const index = async_hook_fields[kStackLength] - 1;
   if (index === -1) return topLevelResource;
-  const resource = execution_async_resources[index] ||
-    executionAsyncResource_(index);
-  return lookupPublicResource(resource);
+  let resource = execution_async_resources[index] ||
+                 executionAsyncResource_(index);
+  resource = lookupPublicResource(resource);
+
+  // When a TCP/UDP object is created, its owner_symbol is uninitialized, so the
+  // store is saved on the TCP/UDP object. Later on, when the Socket/TLSSocket
+  // object is created, the TCP/UDP object is wrapped by the Socket/TLSSocket
+  // object in the handle and the owner_symbol of the TCP/UDP object is set to
+  // the corresponding Socket/TLSSocket object. Hence, in the case of a
+  // Socket/TLSSocket object, we must use the underlying TCP/UDP object, if
+  // available, for storage.
+
+  lazyLoadDgram();
+  lazyLoadInternalDgram();
+  lazyLoadNet();
+  lazyLoadTlsWrap();
+
+  if ((resource instanceof net.Socket ||
+       resource instanceof _tls_wrap.TLSSocket) &&
+      resource._handle != null) {
+    resource = resource._handle;
+  } else if (resource instanceof dgram.Socket &&
+             resource[internal_dgram.kStateSymbol].handle != null) {
+    resource = resource[internal_dgram.kStateSymbol].handle;
+  }
+
+  return resource;
 }
 
 function inspectExceptionValue(e) {