Add support for Node 12, 14 & update dependencies

.circleci/config.yml

@@ -0,0 +1,30 @@
+version: 2
+jobs:
+  build:
+    docker:
+      - image: circleci/node:14.13.0
+
+    steps:
+      - checkout
+      - restore_cache:
+          name: Restore Yarn Package Cache
+          keys:
+            - yarn-packages-{{ checksum "yarn.lock" }}
+
+      - run:
+          name: Install Dependencies
+          command: yarn install --frozen-lockfile
+      - save_cache:
+          name: Save Yarn Package Cache
+          key: yarn-packages-{{ checksum "yarn.lock" }}
+          paths:
+            - ~/.cache/yarn
+      - run:
+          name: lint
+          command: yarn lint
+      - run:
+          name: test
+          command: yarn unit
+      - run:
+          name: release
+          command: yarn semantic-release

.gitignore

@@ -2,3 +2,5 @@ build/
 .lock-wscript
 node_modules
 npm-debug.log
+
+.idea/

.mocharc.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports = {
+  ui: 'qunit',
+  reporter: 'spec',
+  timeout: 2000,
+}

.travis.yml

@@ -1,10 +1,10 @@
-sudo: false
 language: node_js
+os: linux
+dist: bionic
 node_js:
-  - "6"
-  - "5"
-  - "4"
-  - "0.12"
+  - "14"
+  - "12"
+  - "10"
 env:
   - CXX=g++-4.8
 addons:

CHANGELOG.md

@@ -1,3 +1,11 @@
+4.0.0 / 2020-10-03
+------------------
+- add support for Node 12 and 14
+- drop support for all Node versions before 10 and Node 11
+- port from NaN to node-addon-api
+- throw JS errors for all system call failures
+- updated Mocha tests
+
 3.0.0 / 2016-09-11
 ------------------
 - port to NaN [#31]

README.md

@@ -7,8 +7,6 @@ Node.js - kexec
 
 This module causes your current Node.js process to be replaced by the process invoked by the parameter of this function. It's like the Ruby exec function. It currently does not work on Windows.
 
-Fully compatible with Node.js version v0.10 and v0.11.
-
 
 Usage
 -----

binding.gyp

@@ -2,14 +2,11 @@
   'targets': [
     {
       'target_name': 'kexec',
+      'cflags!': [ '-fno-exceptions' ],
+      'cflags_cc!': [ '-fno-exceptions' ],
       'sources': [ 'src/kexec.cc' ],
-      'defines': [
-        '<!@(node -v |grep "v[^0]" > /dev/null && echo "__NODE_GE_V4__" || true)',
-        '<!@(node -v |grep "v0\.1[12]" > /dev/null && echo "__NODE_V0_11_OR_12__" || true)',
-        '<!@(command -v iojs > /dev/null && echo "__NODE_V0_11_OR_12__" || true)',
-        '<!@(node -v |grep "v0\.10" > /dev/null && echo "__NODE_V0_10__" || true)',
-      ],
-      "include_dirs": ["<!(node -e \"require('nan')\")"]
+      'include_dirs': [ "<!@(node -p \"require('node-addon-api').include\")" ],
+      'defines': [ 'NAPI_DISABLE_CPP_EXCEPTIONS' ],
     }
   ]
 }

demo/demovp-pids.js

@@ -2,4 +2,4 @@ var kexec = require('../')
 
 console.log(process.pid + ' - PID before exec')
 
-kexec('sh', [ '-c', 'echo "$$ - PID after exec"' ])
+kexec('sh', ['-c', 'echo "$$ - PID after exec"'])

demo/demovp.js

@@ -1,2 +1,2 @@
 var kexec = require('../')
-kexec('less', [ '/etc/fstab' ])
+kexec('less', ['/etc/fstab'])

index.js

@@ -1 +1 @@
-module.exports = require('./build/Release/kexec.node').kexec
+module.exports = require('bindings')('kexec.node').kexec

package.json

@@ -1,6 +1,6 @@
 {
   "name": "kexec",
-  "version": "3.0.0",
+  "version": "4.0.0",
   "description": "Replace your Node.js process with another process. Like Ruby exec.",
   "homepage": "https://github.com/jprichardson/node-kexec",
   "repository": {
@@ -10,7 +10,8 @@
   "scripts": {
     "lint": "standard",
     "test": "npm run lint && npm run unit",
-    "unit": "mocha"
+    "unit": "mocha",
+    "semantic-release": "semantic-release"
   },
   "keywords": [
     "exec",
@@ -22,13 +23,15 @@
   "license": "MIT",
   "main": "./index",
   "engines": {
-    "node": ">=0.10"
+    "node": ">=10"
   },
   "devDependencies": {
-    "mocha": "^2.3.3",
-    "standard": "^8.0.0"
+    "mocha": "^8.3.2",
+    "semantic-release": "^19.0.3",
+    "standard": "^14.3.4"
   },
   "dependencies": {
-    "nan": "^2.4.0"
+    "bindings": "^1.5.0",
+    "node-addon-api": "^3.1.0"
   }
 }

src/kexec.cc

@@ -1,117 +1,90 @@
-#include <cstdio>
-#include <stdlib.h>
-#include <string.h>
-#if defined(__NODE_V0_11_OR_12__) || defined(__NODE_GE_V4__)
-#include <fcntl.h>
-#endif
-
-//#ifdef __POSIX__
-#include <unistd.h>
-/*#else
-#include <process.h>
-#endif*/
-
-#include <nan.h>
-
-
-using v8::Array;
-using v8::FunctionTemplate;
-using v8::Handle;
-using v8::Integer;
-using v8::Local;
-using v8::Object;
-using v8::String;
+#include <napi.h>
 
+#include <sstream>
+#include <string>
+#include <vector>
 
-static int clear_cloexec (int desc)
-{
-    int flags = fcntl (desc, F_GETFD, 0);
-    if (flags <  0)
-        return flags; //return if reading failed
+#include <unistd.h>
+#include <fcntl.h>
 
-    flags &= ~FD_CLOEXEC; //clear FD_CLOEXEC bit
-    return fcntl (desc, F_SETFD, flags);
+static void invalidArgs(Napi::Env env) {
+    Napi::TypeError::New(env, "invalid arguments: expected string or string, Array<string>").ThrowAsJavaScriptException();
 }
 
-static int do_exec(char *argv[])
-{
-        clear_cloexec(0); //stdin
-        clear_cloexec(1); //stdout
-        clear_cloexec(2); //stderr
-        return execvp(argv[0], argv);
+static void operationError(Napi::Env env, const char *operation, int code) {
+   std::ostringstream msg;
+   msg << operation << " failed with code " << code;
+   Napi::Error::New(env, msg.str()).ThrowAsJavaScriptException();
 }
 
-NAN_METHOD(kexec) {
-    /*
-     * Steve Blott: 17 Jan, 2014
-     *              Temporary comment by way of explanation...
-     *              To be deleted.
-     *
-     * With a single argument:
-     *   - pass it to execvp as "sh -c 'args[0]'"
-     *   - this is the existing usage
-     *
-     * With exactly two arguments:
-     *   - the first is the command name
-     *   - the second is an array of arguments
-     *     ...as in process.child_process.spawn()
-     *
-     * This approach is not great, but it allows the established usage to
-     * coexist with direct execvp-usage, and avoids making any changes to the
-     * established API.
-     */
-
-    if ( 1 == info.Length() && info[0]->IsString() )
-    {
-        String::Utf8Value str(info[0]);
-        char* argv[] = { const_cast<char *>("/bin/sh"), const_cast<char *>("-c"), *str, NULL};
+void Kexec(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
 
-        int err = do_exec(argv);
-
-        info.GetReturnValue().Set(Nan::New<Integer>(err));
+    if (info.Length() < 1 || info.Length() > 2 || !info[0].IsString()) {
+        invalidArgs(env);
+        return;
     }
-
-    if ( 2 == info.Length() && info[0]->IsString() && info[1]->IsArray() )
-    {
-        String::Utf8Value str(info[0]);
-
-        // Substantially copied from:
-        // https://github.com/joyent/node/blob/2944e03/src/node_child_process.cc#L92-104
-        Local<Array> argv_handle = Local<Array>::Cast(info[1]);
-        int argc = argv_handle->Length();
-
-        int argv_length = argc + 1 + 1;
-        char **argv = new char*[argv_length];
-
-        argv[0] = *str;
-        argv[argv_length-1] = NULL;
-        for (int i = 0; i < argc; i++) {
-            String::Utf8Value arg(argv_handle->Get(Nan::New<Integer>(i))->ToString());
-            argv[i+1] = strdup(*arg);
+    // Hold onto a reference to the std::string, to ensure the backing store for the c_str value isn't de-allocated.
+    std::string strCmd = info[0].As<Napi::String>().Utf8Value();
+    char *cmd = const_cast<char*>(strCmd.c_str());
+
+    char **argv;
+    if (1 == info.Length()) {
+        argv = new char*[4];
+        argv[0] = const_cast<char *>("/bin/sh");
+        argv[1] = const_cast<char *>("-c");
+        argv[2] = cmd;
+        argv[3] = NULL;
+    } else {
+        if (!info[1].IsArray()) {
+            invalidArgs(env);
+             return;
         }
+        Napi::Array argsFromJS = info[1].As<Napi::Array>();
+        const int numArgs = argsFromJS.Length();
+
+        std::vector<std::string> strArgs(numArgs);
+        argv = new char*[numArgs + 2];
+        argv[0] = cmd;
+        for (int argIdx = 0; argIdx < numArgs; ++argIdx) {
+            Napi::Value arg = argsFromJS[argIdx];
+            if (!arg.IsString()) {
+                invalidArgs(env);
+                return;
+            }
+            strArgs[argIdx] = arg.As<Napi::String>().Utf8Value();
+            argv[argIdx + 1] = const_cast<char *>(strArgs[argIdx].c_str());
+        }
+        argv[numArgs + 1] = NULL;
+    }
 
-        int err = do_exec(argv);
-
-        // Failed...!
-        // FIXME: It might be better to raise an exception here.
-        for (int i = 0; i < argc; i++)
-            free(argv[i+1]);
-        delete [] argv;
+    // Run setfd on descriptors 0 through 2
+    for (int descriptor = 0; descriptor <= 2; ++descriptor) {
+        int flags = fcntl (descriptor, F_GETFD, 0);
+        if (flags <  0) {
+            operationError(env, "fcntl GETFD", flags);
+            return;
+        }
 
-        info.GetReturnValue().Set(Nan::New<Integer>(err));
+        flags &= ~FD_CLOEXEC; //clear FD_CLOEXEC bit
+        int setfdErrCode = fcntl (descriptor, F_SETFD, flags);
+        if (setfdErrCode) {
+            operationError(env, "fcntl SETFD", setfdErrCode);
+            return;
+        }
     }
 
-    return Nan::ThrowTypeError("kexec: invalid arguments");
-}
+    int execvpErrCode = execvp(argv[0], argv);
 
+    // Because of the exec, we only get here if there's a failure.
+    delete [] argv;
 
-#define EXPORT(name, symbol) exports->Set( \
-  Nan::New<String>(name).ToLocalChecked(), \
-  Nan::New<FunctionTemplate>(symbol)->GetFunction() \
-)
+    operationError(env, "execvp", execvpErrCode);
+}
 
-void init (Handle<Object> exports) {
-    EXPORT("kexec", kexec);
+Napi::Object Init(Napi::Env env, Napi::Object exports) {
+  exports.Set(Napi::String::New(env, "kexec"), Napi::Function::New(env, Kexec));
+  return exports;
 }
 
-NODE_MODULE(kexec, init);
+NODE_API_MODULE(kexec, Init)