Update package to run in the most recent version of node

.gitignore

@@ -13,4 +13,5 @@ results
 
 node_modules
 npm-debug.log
-build
+build
+package-lock.json

README.md

@@ -7,6 +7,8 @@ Tripwire contains a native extension of node.js and currently supports Windows,
 
 Install with:
 
+Make sure you've installed all the [necessary build tools](https://github.com/TooTallNate/node-gyp#installation) for your platform, then invoke:
+
 ```
 npm install tripwire
 ```

install.js

@@ -1,6 +1,6 @@
-if (process.platform !== 'win32') {
-    require('child_process').spawn('node-gyp', ['rebuild'], {
-        cwd: __dirname,
-        stdio: 'inherit'
-    }).on('close', process.exit).on('error', console.log);
-}
+let majorVersion = parseInt(process.versions.node.split('.')[0]);
+
+if (!(process.platform === 'win32' && majorVersion >= 8 && majorVersion <= 11)) {
+	let exec_process = require('child_process').exec("node-gyp configure build");
+	exec_process.stdout.pipe(process.stdout);
+}

lib/tripwire.js

@@ -1,14 +1,16 @@
-var native_path = process.env.TRIPWIRE_NATIVE;
-if (!native_path) {
-    if (process.platform === 'win32') {
-    	if (process.version.match(/^v4\./))
-	        native_path = './native/win32/4.0/' + process.arch + '/tripwire';
-    	else if (process.version.match(/^v0\.12/))
-	        native_path = './native/win32/0.12/' + process.arch + '/tripwire';
-	    else
-	    	native_path = './native/win32/0.10/' + process.arch + '/tripwire';
-    }
-    else
-        native_path = require('path').join(__dirname, '../build/Release/tripwire');
+function get_native_path() {
+	var native_path = process.env.TRIPWIRE_NATIVE;
+
+	if (!native_path) {
+		let majorVersion = parseInt(process.versions.node.split('.')[0]);
+
+		if (process.platform === 'win32' && majorVersion >= 8 && majorVersion <= 12)
+			native_path = './native/win32/' + majorVersion + '/' + process.arch + '/tripwire';
+		else
+			native_path = require('path').join(__dirname, '../build/Release/tripwire');
+	}
+
+	return native_path;
 }
-module.exports = require(native_path);
+
+module.exports = require(get_native_path());

package.json

@@ -7,22 +7,34 @@
   },
   "version": "4.2.0-pre",
   "description": "Break out from scripts blocking node.js event loop",
-  "tags" : ["event loop", "hang"],
+  "tags": [
+    "event loop",
+    "hang"
+  ],
   "main": "./lib/tripwire.js",
-  "engines": { "node": "0.10.x || 0.12.x || 4.x" },
-  "licenses": [ { "type": "Apache", "url": "http://www.apache.org/licenses/LICENSE-2.0" } ],
+  "engines": {
+    "node": "0.10.x || 0.12.x || 4.x"
+  },
+  "licenses": [
+    {
+      "type": "Apache",
+      "url": "http://www.apache.org/licenses/LICENSE-2.0"
+    }
+  ],
   "homepage": "https://github.com/tjanczuk/tripwire",
   "dependencies": {
-    "nan": "^2.0.8"
+    "child_process": "^1.0.2",
+    "deasync": "^0.1.14",
+    "nan": "^2.14.0"
   },
   "repository": {
     "type": "git",
     "url": "[email protected]:tjanczuk/tripwire.git"
   },
-  "bugs" : {
-    "url" : "http://github.com/tjanczuk/tripwire/issues"
+  "bugs": {
+    "url": "http://github.com/tjanczuk/tripwire/issues"
   },
   "scripts": {
     "install": "node install.js"
   }
-}
+}

recompile_windows_binaries.bat

@@ -0,0 +1,36 @@
+mkdir "lib\native\win32\8\x64\"
+mkdir "lib\native\win32\9\x64\"
+mkdir "lib\native\win32\10\x64\"
+mkdir "lib\native\win32\11\x64\"
+mkdir "lib\native\win32\12\x64\"
+
+mkdir "lib\native\win32\8\ia32\"
+mkdir "lib\native\win32\9\ia32\"
+mkdir "lib\native\win32\10\ia32\"
+mkdir "lib\native\win32\11\ia32\"
+mkdir "lib\native\win32\12\ia32\"
+
+call node-gyp clean configure build --arch=x64 --target=v8.16.0
+move /Y "build\Release\tripwire.node" "lib\native\win32\8\x64\"
+call node-gyp clean configure build --arch=ia32 --target=v8.16.0
+move /Y "build\Release\tripwire.node" "lib\native\win32\8\ia32\"
+
+call node-gyp clean configure build --arch=x64 --target=v9.11.2
+move /Y "build\Release\tripwire.node" "lib\native\win32\9\x64\"
+call node-gyp clean configure build --arch=ia32 --target=v9.11.2
+move /Y "build\Release\tripwire.node" "lib\native\win32\9\ia32\"
+
+call node-gyp clean configure build --arch=x64 --build_v8_with_gn=false --target=v10.16.0
+move /Y "build\Release\tripwire.node" "lib\native\win32\10\x64\"
+call node-gyp clean configure build --arch=ia32 --build_v8_with_gn=false --target=v10.16.0
+move /Y "build\Release\tripwire.node" "lib\native\win32\10\ia32\"
+
+call node-gyp clean configure build --arch=x64 --build_v8_with_gn=false --target=v11.15.0
+move /Y "build\Release\tripwire.node" "lib\native\win32\11\x64\"
+call node-gyp clean configure build --arch=ia32 --build_v8_with_gn=false --target=v11.15.0
+move /Y "build\Release\tripwire.node" "lib\native\win32\11\ia32\"
+
+call node-gyp clean configure build --arch=x64 --build_v8_with_gn=false --target=v12.7.0
+move /Y "build\Release\tripwire.node" "lib\native\win32\12\x64\"
+call node-gyp clean configure build --arch=ia32 --build_v8_with_gn=false --target=v12.7.0
+move /Y "build\Release\tripwire.node" "lib\native\win32\12\ia32\"

src/tripwire.cc

@@ -9,16 +9,28 @@ unsigned int tripwireThreshold;
 Nan::Persistent<v8::Value> context;
 int terminated;
 v8::Isolate* isolate;
+bool shouldThrowException = true;
+bool useRealTime = false;
+
+bool hasTimeoutCallback = false;
+v8::Local<v8::Value> argv[] {Nan::Null()};
+Nan::Callback timeoutCallback;
 
 #if (NODE_MODULE_VERSION >= NODE_0_12_MODULE_VERSION)
 void interruptCallback(v8::Isolate* isolate, void* data) 
 {
     Nan::RunScript(Nan::CompileScript(Nan::New<v8::String>(
         "process.nextTick(function () { throw new Error('Blocked event loop'); });"
-    ).ToLocalChecked()).ToLocalChecked());
+        ).ToLocalChecked()
+    ).ToLocalChecked());
 }
 #endif
 
+void timeoutCallbackCaller(v8::Isolate* isolate, void* data)
+{
+   Nan::Call(timeoutCallback, 1, argv);
+}
+
 NAN_METHOD(clearTripwire)
 {
     // Seting tripwireThreshold to 0 indicates to the worker process that
@@ -35,18 +47,18 @@ NAN_METHOD(clearTripwire)
 NAN_METHOD(resetTripwire)
 {
     Nan::EscapableHandleScope scope;
-	if (0 == info.Length() || !info[0]->IsUint32()) {
+	if (0 == info.Length()  || Nan::To<v8::Uint32>(info[0]).IsEmpty()) {
         Nan::ThrowError("First agument must be an integer time threshold in milliseconds.");
         info.GetReturnValue().SetUndefined();
     }
-    else if (0 == info[0]->ToUint32()->Value()) {
+    else if (0 == Nan::To<v8::Uint32>(info[0]).ToLocalChecked()->Value()) {
         Nan::ThrowError("The time threshold for blocking operations must be greater than 0.");
         info.GetReturnValue().SetUndefined();
     }
     else {
     	clearTripwire(info);
 
-    	tripwireThreshold = info[0]->ToUint32()->Value();
+    	tripwireThreshold = Nan::To<v8::Uint32>(info[0]).ToLocalChecked()->Value();
         isolate = info.GetIsolate();
     	if (info.Length() > 1) 
     	{
@@ -71,20 +83,79 @@ NAN_METHOD(getContext)
     	info.GetReturnValue().SetUndefined();
 }
 
+NAN_METHOD(setShouldThrowException)
+{
+    Nan::EscapableHandleScope scope;
+
+    if(info.Length() == 0 || Nan::To<v8::Boolean>(info[0]).IsEmpty()) {
+        Nan::ThrowError("First agument must be a boolean.");
+        info.GetReturnValue().SetUndefined();
+    }
+    else {
+        shouldThrowException = Nan::To<v8::Boolean>(info[0]).ToLocalChecked()->IsTrue();
+    }
+}
+
+NAN_METHOD(setUseRealTime)
+{
+    Nan::EscapableHandleScope scope;
+
+    if(info.Length() == 0 || Nan::To<v8::Boolean>(info[0]).IsEmpty()) {
+        Nan::ThrowError("First agument must be a boolean.");
+        info.GetReturnValue().SetUndefined();
+    }
+    else {
+        useRealTime = Nan::To<v8::Boolean>(info[0]).ToLocalChecked()->IsTrue();
+    }
+}
+
+NAN_METHOD(setTimeoutCallback)
+{
+    Nan::EscapableHandleScope scope;
+
+     if(info.Length() == 0 || Nan::To<v8::Function>(info[0]).IsEmpty()) {
+        Nan::ThrowError("First agument must be a function.");
+        info.GetReturnValue().SetUndefined();
+    }
+    else {
+        hasTimeoutCallback = true;
+        const v8::Local<v8::Function> func = Nan::To<v8::Function>(info[0]).ToLocalChecked();
+        timeoutCallback.Reset(func);
+    }
+}
+
+void cleanUpFunction(void*)
+{
+    timeoutCallback.Reset();
+}
+
 NAN_MODULE_INIT(init) 
 {
     initCore();
     isolate = v8::Isolate::GetCurrent();
+    v8::Local<v8::Context> context = v8::Context::New(isolate);
     terminated = 0;
     Nan::Set(target,
         Nan::New<v8::String>("resetTripwire").ToLocalChecked(),
-        Nan::New<v8::FunctionTemplate>(resetTripwire)->GetFunction());
+        Nan::New<v8::FunctionTemplate>(resetTripwire)->GetFunction(context).ToLocalChecked());
     Nan::Set(target,
         Nan::New<v8::String>("clearTripwire").ToLocalChecked(),
-        Nan::New<v8::FunctionTemplate>(clearTripwire)->GetFunction());
+        Nan::New<v8::FunctionTemplate>(clearTripwire)->GetFunction(context).ToLocalChecked());
     Nan::Set(target,
         Nan::New<v8::String>("getContext").ToLocalChecked(),
-        Nan::New<v8::FunctionTemplate>(getContext)->GetFunction());
+        Nan::New<v8::FunctionTemplate>(getContext)->GetFunction(context).ToLocalChecked());
+
+    Nan::Set(target,
+        Nan::New<v8::String>("setShouldThrowException").ToLocalChecked(),
+        Nan::New<v8::FunctionTemplate>(setShouldThrowException)->GetFunction(context).ToLocalChecked());
+    Nan::Set(target,
+        Nan::New<v8::String>("setUseRealTime").ToLocalChecked(),
+        Nan::New<v8::FunctionTemplate>(setUseRealTime)->GetFunction(context).ToLocalChecked());
+    Nan::Set(target,
+        Nan::New<v8::String>("setTimeoutCallback").ToLocalChecked(),
+        Nan::New<v8::FunctionTemplate>(setTimeoutCallback)->GetFunction(context).ToLocalChecked());
+
+    node::AtExit(cleanUpFunction, NULL);
 }
 
 NODE_MODULE(tripwire, init);

src/tripwire_linux.cc

@@ -13,6 +13,12 @@ pthread_cond_t tripwireCondition = PTHREAD_COND_INITIALIZER;
 extern unsigned int tripwireThreshold;
 extern int terminated;
 extern v8::Isolate* isolate;
+
+extern bool shouldThrowException;
+extern bool hasTimeoutCallback;
+extern void timeoutCallbackCaller(v8::Isolate *isolate, void *data);
+
+
 #if (NODE_MODULE_VERSION >= NODE_0_12_MODULE_VERSION)
 extern void interruptCallback(v8::Isolate *isolate, void *data);
 #endif
@@ -24,6 +30,7 @@ void* tripwireWorker(void* data)
 	int skipTimeCapture = 0;
 	struct timespec timeout;
 	struct rusage start, end;
+    unsigned int elapsedMs = 0;
 
 	// This thread monitors the elapsed CPU utilization time of the node.js thread and forces V8 to terminate
 	// execution if it exceeds the preconfigured tripwireThreshold.
@@ -53,9 +60,10 @@ void* tripwireWorker(void* data)
 		}
 		else
 		{
+            unsigned int remainingTime = tripwireThreshold < elapsedMs ? 0 : tripwireThreshold - elapsedMs;
 			clock_gettime(CLOCK_REALTIME, &timeout);
-			timeout.tv_sec += tripwireThreshold / 1000;
-			timeout.tv_nsec += (tripwireThreshold % 1000) * 1000000;
+			timeout.tv_sec += remainingTime / 1000;
+			timeout.tv_nsec += (remainingTime % 1000) * 1000000;
 			waitResult = pthread_cond_timedwait(&tripwireCondition, &tripwireMutex, &timeout);
 		}
 		pthread_mutex_unlock(&tripwireMutex);
@@ -83,7 +91,7 @@ void* tripwireWorker(void* data)
 
 				// Process execution times are reported in seconds and microseconds. Convert to milliseconds.
 
-				unsigned int elapsedMs = 
+				elapsedMs = 
 					((end.ru_utime.tv_sec - start.ru_utime.tv_sec) + (end.ru_stime.tv_sec - start.ru_stime.tv_sec)) 
 					* 1000
 					+ ((end.ru_utime.tv_usec - start.ru_utime.tv_usec) + (end.ru_stime.tv_usec - start.ru_stime.tv_usec)) 
@@ -97,9 +105,18 @@ void* tripwireWorker(void* data)
 				if (elapsedMs >= tripwireThreshold)
 				{
 					terminated = 1;
-                    v8::V8::TerminateExecution(isolate);
+                    isolate->TerminateExecution();
+
+					if(hasTimeoutCallback)
+					{
+						isolate->RequestInterrupt(timeoutCallbackCaller, NULL);
+					}
+
 #if (NODE_MODULE_VERSION >= NODE_0_12_MODULE_VERSION)
-                    isolate->RequestInterrupt(interruptCallback, NULL);
+					if(shouldThrowException)
+					{
+                    	isolate->RequestInterrupt(interruptCallback, NULL);
+					}
 #endif
 				}
 				else