All files / lib/internal/process execution.js

98.22% Statements 221/225
94.23% Branches 49/52
100% Functions 9/9
98.22% Lines 221/225

Press n or j to go to the next uncovered block, b, p or k for the previous block.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 22634x 34x 34x 34x 34x 34x 34x 34x 34x 34x 34x 34x 34x 34x 34x 34x 34x 34x 34x 34x 34x 34x 34x 34x 34x 34x 34x 34x 34x 34x 7170x 7170x 7170x 7170x 6x 6x 6x 6x 6x 7170x 34x 55x 55x 1x 1x 54x 54x 54x 55x 34x 658x 658x 658x 658x 658x 658x 658x 658x 658x 658x 658x 658x 658x 658x 658x 658x 658x 658x 658x 658x 658x 658x 658x 658x 658x 656x 656x 656x 656x 656x 2x 2x 2x 658x 658x 98x 98x 98x 596x 596x 596x 658x 34x 34x 34x 34x 34x 34x 32464x 32464x 23347x 23347x 23347x 23347x 23347x 32464x 1x 1x 28093x 1x 1x 9115x 9115x 9115x 9115x 9115x 32464x 34x 263x 263x 263x 34x 1212x 34x 34x 34x 34x 34x 34x 34x 34x 34x 1254x 1254x 1254x 1254x 1254x 1509x 1509x 1509x 1509x 1509x 1509x 1509x 1509x 1509x 1509x 1509x 1509x 4x 4x 4x 4x 4x 4x 4x 4x 1509x     1509x 1509x 1509x 1509x 1509x 1107x 1507x 279x 279x 279x 279x 278x 278x 278x 278x 279x     279x 279x 1224x 1224x 1224x 1224x 1224x 1224x 1225x 1112x 2074x 2074x 2074x 1110x 1110x 1112x 1112x 1224x 1224x 1224x 1224x 1224x 1254x 1254x 34x 25x 25x 25x 25x 25x 24x 25x 25x 25x 25x 25x 25x 34x 34x 34x 34x 34x 34x 34x 34x 34x 34x  
'use strict';
 
const {
  globalThis,
} = primordials;
 
const path = require('path');
 
const {
  codes: {
    ERR_INVALID_ARG_TYPE,
    ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET,
    ERR_EVAL_ESM_CANNOT_PRINT,
  },
} = require('internal/errors');
 
const {
  executionAsyncId,
  clearDefaultTriggerAsyncId,
  clearAsyncIdStack,
  hasAsyncIdStack,
  afterHooksExist,
  emitAfter,
  popAsyncContext,
} = require('internal/async_hooks');
 
// shouldAbortOnUncaughtToggle is a typed array for faster
// communication with JS.
const { shouldAbortOnUncaughtToggle } = internalBinding('util');
 
function tryGetCwd() {
  try {
    return process.cwd();
  } catch {
    // getcwd(3) can fail if the current working directory has been deleted.
    // Fall back to the directory name of the (absolute) executable path.
    // It's not really correct but what are the alternatives?
    return path.dirname(process.execPath);
  }
}
 
function evalModule(source, print) {
  if (print) {
    throw new ERR_EVAL_ESM_CANNOT_PRINT();
  }
  const { loadESM } = require('internal/process/esm_loader');
  const { handleMainPromise } = require('internal/modules/run_main');
  return handleMainPromise(loadESM((loader) => loader.eval(source)));
}
 
function evalScript(name, body, breakFirstLine, print) {
  const CJSModule = require('internal/modules/cjs/loader').Module;
  const { kVmBreakFirstLineSymbol } = require('internal/util');
  const { pathToFileURL } = require('url');
 
  const cwd = tryGetCwd();
  const origModule = globalThis.module;  // Set e.g. when called from the REPL.
 
  const module = new CJSModule(name);
  module.filename = path.join(cwd, name);
  module.paths = CJSModule._nodeModulePaths(cwd);
 
  const asyncESM = require('internal/process/esm_loader');
  const baseUrl = pathToFileURL(module.filename).href;
 
  // Create wrapper for cache entry
  const script = `
    globalThis.module = module;
    globalThis.exports = exports;
    globalThis.__dirname = __dirname;
    globalThis.require = require;
    return (main) => main();
  `;
  globalThis.__filename = name;
  const result = module._compile(script, `${name}-wrapper`)(() =>
    require('vm').runInThisContext(body, {
      filename: name,
      displayErrors: true,
      [kVmBreakFirstLineSymbol]: !!breakFirstLine,
      importModuleDynamically(specifier, _, importAssertions) {
        const loader = asyncESM.esmLoader;
        return loader.import(specifier, baseUrl, importAssertions);
      }
    }));
  if (print) {
    const { log } = require('internal/console/global');
    log(result);
  }
 
  if (origModule !== undefined)
    globalThis.module = origModule;
}
 
const exceptionHandlerState = {
  captureFn: null,
  reportFlag: false
};
 
function setUncaughtExceptionCaptureCallback(fn) {
  if (fn === null) {
    exceptionHandlerState.captureFn = fn;
    shouldAbortOnUncaughtToggle[0] = 1;
    process.report.reportOnUncaughtException = exceptionHandlerState.reportFlag;
    return;
  }
  if (typeof fn !== 'function') {
    throw new ERR_INVALID_ARG_TYPE('fn', ['Function', 'null'], fn);
  }
  if (exceptionHandlerState.captureFn !== null) {
    throw new ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET();
  }
  exceptionHandlerState.captureFn = fn;
  shouldAbortOnUncaughtToggle[0] = 0;
  exceptionHandlerState.reportFlag =
    process.report.reportOnUncaughtException === true;
  process.report.reportOnUncaughtException = false;
}
 
function hasUncaughtExceptionCaptureCallback() {
  return exceptionHandlerState.captureFn !== null;
}
 
function noop() {}
 
// XXX(joyeecheung): for some reason this cannot be defined at the top-level
// and exported to be written to process._fatalException, it has to be
// returned as an *anonymous function* wrapped inside a factory function,
// otherwise it breaks the test-timers.setInterval async hooks test -
// this may indicate that node::errors::TriggerUncaughtException() should
// fix up the callback scope before calling into process._fatalException,
// or this function should take extra care of the async hooks before it
// schedules a setImmediate.
function createOnGlobalUncaughtException() {
  // The C++ land node::errors::TriggerUncaughtException() will
  // exit the process if it returns false, and continue execution if it
  // returns true (which indicates that the exception is handled by the user).
  return (er, fromPromise) => {
    // It's possible that defaultTriggerAsyncId was set for a constructor
    // call that threw and was never cleared. So clear it now.
    clearDefaultTriggerAsyncId();
 
    // If diagnostic reporting is enabled, call into its handler to see
    // whether it is interested in handling the situation.
    // Ignore if the error is scoped inside a domain.
    // use == in the checks as we want to allow for null and undefined
    if (er == null || er.domain == null) {
      try {
        const report = internalBinding('report');
        if (report != null && report.shouldReportOnUncaughtException()) {
          report.writeReport(
            typeof er?.message === 'string' ?
              er.message :
              'Exception',
            'Exception',
            null,
            er ?? {});
        }
      } catch {
        // Ignore the exception. Diagnostic reporting is unavailable.
      }
    }
 
    const type = fromPromise ? 'unhandledRejection' : 'uncaughtException';
    process.emit('uncaughtExceptionMonitor', er, type);
    if (exceptionHandlerState.captureFn !== null) {
      exceptionHandlerState.captureFn(er);
    } else if (!process.emit('uncaughtException', er, type)) {
      // If someone handled it, then great. Otherwise, die in C++ land
      // since that means that we'll exit the process, emit the 'exit' event.
      try {
        if (!process._exiting) {
          process._exiting = true;
          process.exitCode = 1;
          process.emit('exit', 1);
        }
      } catch {
        // Nothing to be done about it at this point.
      }
      return false;
    }
 
    // If we handled an error, then make sure any ticks get processed
    // by ensuring that the next Immediate cycle isn't empty.
    require('timers').setImmediate(noop);
 
    // Emit the after() hooks now that the exception has been handled.
    if (afterHooksExist()) {
      do {
        const asyncId = executionAsyncId();
        if (asyncId === 0)
          popAsyncContext(0);
        else
          emitAfter(asyncId);
      } while (hasAsyncIdStack());
    }
    // And completely empty the id stack, including anything that may be
    // cached on the native side.
    clearAsyncIdStack();
 
    return true;
  };
}
 
function readStdin(callback) {
  process.stdin.setEncoding('utf8');
 
  let code = '';
  process.stdin.on('data', (d) => {
    code += d;
  });
 
  process.stdin.on('end', () => {
    callback(code);
  });
}
 
module.exports = {
  readStdin,
  tryGetCwd,
  evalModule,
  evalScript,
  onGlobalUncaughtException: createOnGlobalUncaughtException(),
  setUncaughtExceptionCaptureCallback,
  hasUncaughtExceptionCaptureCallback
};