From 1b7a9bf149f35e142c32b081c4b183926625c061 Mon Sep 17 00:00:00 2001
From: Bryan English <bryan@bryanenglish.com>
Date: Mon, 23 Oct 2017 01:29:11 -0700
Subject: [PATCH] process: add isExiting

This replaces the previously undocumented `_exiting` property with a
read-only property giving the same information. Setting the property is
restricted to internals, to prevent tampering. Tampering could affect
nextTick behavior, for example.
---
 doc/api/process.md                           | 11 +++++++
 lib/internal/bootstrap_node.js               |  9 +++---
 lib/internal/process.js                      | 34 +++++++++++++++++---
 lib/internal/process/next_tick.js            |  4 +--
 src/env.h                                    |  2 +-
 src/node.cc                                  |  4 ++-
 test/parallel/test-next-tick-when-exiting.js |  8 ++++-
 7 files changed, 59 insertions(+), 13 deletions(-)

diff --git a/doc/api/process.md b/doc/api/process.md
index 54704e6775da5d..b13bc658872ad8 100644
--- a/doc/api/process.md
+++ b/doc/api/process.md
@@ -1208,6 +1208,17 @@ console.log(process.getgroups());         // [ 27, 30, 46, 1000 ]
 *Note*: This function is only available on POSIX platforms (i.e. not Windows
 or Android).
 
+## process.isExiting
+<!-- YAML
+added: REPLACEME
+-->
+
+* {boolean}
+
+This read-only boolean indicates if the process is currently exiting. That is,
+when the `exit` event has been fired and no further scheduled asynchronous code
+will run.
+
 ## process.kill(pid[, signal])
 <!-- YAML
 added: v0.0.6
diff --git a/lib/internal/bootstrap_node.js b/lib/internal/bootstrap_node.js
index c75578f7692068..5315fe383633f9 100644
--- a/lib/internal/bootstrap_node.js
+++ b/lib/internal/bootstrap_node.js
@@ -10,6 +10,7 @@
 (function(process) {
   let internalBinding;
   const exceptionHandlerState = { captureFn: null };
+  let _process;
 
   function startup() {
     const EventEmitter = NativeModule.require('events');
@@ -33,7 +34,8 @@
 
     setupGlobalVariables();
 
-    const _process = NativeModule.require('internal/process');
+    _process = NativeModule.require('internal/process');
+    _process.setIsExiting(false);
     _process.setupConfig(NativeModule._source);
     _process.setupSignalHandlers();
     _process.setupUncaughtExceptionCapture(exceptionHandlerState);
@@ -302,7 +304,6 @@
 
     global.Buffer = NativeModule.require('buffer').Buffer;
     process.domain = null;
-    process._exiting = false;
   }
 
   function setupGlobalTimeouts() {
@@ -391,8 +392,8 @@
       // since that means that we'll exit the process, emit the 'exit' event
       if (!caught) {
         try {
-          if (!process._exiting) {
-            process._exiting = true;
+          if (!process.isExiting) {
+            _process.setIsExiting(true);
             process.emit('exit', 1);
           }
         } catch (er) {
diff --git a/lib/internal/process.js b/lib/internal/process.js
index e58b83d21631ff..c796633b632298 100644
--- a/lib/internal/process.js
+++ b/lib/internal/process.js
@@ -3,6 +3,11 @@
 const errors = require('internal/errors');
 const util = require('util');
 const constants = process.binding('constants').os.signals;
+const {
+  getHiddenValue,
+  setHiddenValue,
+  is_exiting_private_symbol: kIsExitingSymbol
+} = process.binding('util');
 
 const assert = process.assert = function(x, msg) {
   if (!x) throw new errors.Error('ERR_ASSERTION', msg || 'assertion error');
@@ -138,12 +143,24 @@ function setupConfig(_source) {
 
 function setupKillAndExit() {
 
+  Object.defineProperty(process, 'isExiting', {
+    enumerable: true,
+    configurable: false,
+    get: getIsExiting
+  });
+
+  Object.defineProperty(process, '_exiting', {
+    enumerable: true,
+    configurable: false,
+    get: getIsExiting
+  });
+
   process.exit = function(code) {
     if (code || code === 0)
       process.exitCode = code;
 
-    if (!process._exiting) {
-      process._exiting = true;
+    if (!process.isExiting) {
+      setIsExiting(true);
       process.emit('exit', process.exitCode || 0);
     }
     process.reallyExit(process.exitCode || 0);
@@ -247,7 +264,6 @@ function setupRawDebug() {
   };
 }
 
-
 function setupUncaughtExceptionCapture(exceptionHandlerState) {
   // This is a typed array for faster communication with JS.
   const shouldAbortOnUncaughtToggle = process._shouldAbortOnUncaughtToggle;
@@ -275,6 +291,14 @@ function setupUncaughtExceptionCapture(exceptionHandlerState) {
   };
 }
 
+function setIsExiting(isExiting) {
+  setHiddenValue(process, kIsExitingSymbol, isExiting);
+}
+
+function getIsExiting() {
+  return getHiddenValue(process, kIsExitingSymbol);
+}
+
 module.exports = {
   setup_performance,
   setup_cpuUsage,
@@ -285,5 +309,7 @@ module.exports = {
   setupSignalHandlers,
   setupChannel,
   setupRawDebug,
-  setupUncaughtExceptionCapture
+  setupUncaughtExceptionCapture,
+  setIsExiting,
+  getIsExiting
 };
diff --git a/lib/internal/process/next_tick.js b/lib/internal/process/next_tick.js
index 260aa70b431b86..b24e1ade8febb5 100644
--- a/lib/internal/process/next_tick.js
+++ b/lib/internal/process/next_tick.js
@@ -188,7 +188,7 @@ function setupNextTick() {
     if (typeof callback !== 'function')
       throw new errors.TypeError('ERR_INVALID_CALLBACK');
 
-    if (process._exiting)
+    if (process.isExiting)
       return;
 
     var args;
@@ -221,7 +221,7 @@ function setupNextTick() {
     // CHECK(Number.isSafeInteger(triggerAsyncId) || triggerAsyncId === null)
     // CHECK(triggerAsyncId > 0 || triggerAsyncId === null)
 
-    if (process._exiting)
+    if (process.isExiting)
       return;
 
     var args;
diff --git a/src/env.h b/src/env.h
index 47723baa7859ff..c40202d5bb2b5d 100644
--- a/src/env.h
+++ b/src/env.h
@@ -90,6 +90,7 @@ class ModuleWrap;
   V(contextify_context_private_symbol, "node:contextify:context")             \
   V(contextify_global_private_symbol, "node:contextify:global")               \
   V(decorated_private_symbol, "node:decorated")                               \
+  V(is_exiting_private_symbol, "node:isExiting")                              \
   V(npn_buffer_private_symbol, "node:npnBuffer")                              \
   V(selected_npn_buffer_private_symbol, "node:selectedNpnBuffer")             \
   V(domain_private_symbol, "node:domain")                                     \
@@ -145,7 +146,6 @@ class ModuleWrap;
   V(errno_string, "errno")                                                    \
   V(error_string, "error")                                                    \
   V(events_string, "_events")                                                 \
-  V(exiting_string, "_exiting")                                               \
   V(exit_code_string, "exitCode")                                             \
   V(exit_string, "exit")                                                      \
   V(expire_string, "expire")                                                  \
diff --git a/src/node.cc b/src/node.cc
index ed2f0c14ff3c59..3e1d9c5bdafb18 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -4294,7 +4294,9 @@ int EmitExit(Environment* env) {
   HandleScope handle_scope(env->isolate());
   Context::Scope context_scope(env->context());
   Local<Object> process_object = env->process_object();
-  process_object->Set(env->exiting_string(), True(env->isolate()));
+  process_object->SetPrivate(env->context(),
+                             env->is_exiting_private_symbol(),
+                             True(env->isolate()));
 
   Local<String> exitCode = env->exit_code_string();
   int code = process_object->Get(exitCode)->Int32Value();
diff --git a/test/parallel/test-next-tick-when-exiting.js b/test/parallel/test-next-tick-when-exiting.js
index b64befa8578579..7584e8c097b71e 100644
--- a/test/parallel/test-next-tick-when-exiting.js
+++ b/test/parallel/test-next-tick-when-exiting.js
@@ -3,8 +3,14 @@
 require('../common');
 const assert = require('assert');
 
+const isExitingDesc = Object.getOwnPropertyDescriptor(process, 'isExiting');
+assert.ok(!('set' in isExitingDesc));
+assert.ok('get' in isExitingDesc);
+assert.strictEqual(isExitingDesc.configurable, false);
+assert.strictEqual(isExitingDesc.enumerable, true);
+
 process.on('exit', () => {
-  assert.strictEqual(process._exiting, true, 'process._exiting was not set!');
+  assert.strictEqual(process.isExiting, true, 'process.isExiting was not set!');
 
   process.nextTick(() => {
     assert.fail('process is exiting, should not be called.');