Make Node.js exit regardless of a native module async call pending - node.js

Question

I'm writing a Napi-based module for Node.js.
The module uses WINAPI WaitForSingleObject(pid). The blocking WINAPI call is wrapped in Napi::AsyncWorker.
The issue
The async call prevents Node.js from exiting. I want Node.js to exit when it has nothing else to do, like it does with child_process.unref(). So I want to unref the async call from the Node.js event loop.

Answer 1

I don't have time to make a NPM package of it, but here is my solution. The solution is valid for all blocking system calls (that put the calling thread to the waiting state, like Sleep() does).
The idea is to:
Use std::thread for the blocking WINAPI call.
Use napi_threadsafe_function to call back from the new thread to Javascript safely.
Use napi_unref_threadsafe_function to unref the async operation from Node.js event loop.
More details:
For safe simultaneous calls, create a new void* context with thread-specific data and pass it around (supported by N-API).
For the unreffed napi_threadsafe_function, finalizer is supported. Stop the waiting thread here to prevent crash messages upon Node.js exit.
I use the C N-API and C++ node-addon-api interchangeably. Unfortunately a pure C++ solution is impossible at the time of writing because napi_unref_threadsafe_function is only available from the C API.
addon.cc:
#include <napi.h>
#include <node_api.h>
#include <windows.h>
#include <tlhelp32.h>
#include <sstream>
#include <string>
#include <iostream>
#include <thread>
using namespace std;
using namespace Napi;
struct my_context {
std::thread nativeThread;
HANDLE hStopEvent;
napi_threadsafe_function tsfn;
};
std::string WaitForPid(int pid, my_context* context, bool* stopped) {
HANDLE process = OpenProcess(SYNCHRONIZE, FALSE, pid);
if (process == NULL)
{
std::stringstream stream;
stream << "OpenProcess failed: " << (int)GetLastError();
return stream.str();
}
context->hStopEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
if (process == NULL)
{
std::stringstream stream;
stream << "CreateEvent failed: " << (int)GetLastError();
return stream.str();
}
HANDLE hEvents[2] = {process, context->hStopEvent};
DWORD waitResult = WaitForMultipleObjects(2, hEvents, FALSE, INFINITE);
if (waitResult == WAIT_FAILED)
{
std::stringstream stream;
stream << "WaitForSingleObject failed: " << (int)GetLastError();
return stream.str();
} else if (waitResult == WAIT_OBJECT_0 + 1) {
*stopped = true;
}
return std::string();
}
Value WaitForProcessToExit(CallbackInfo &info)
{
Env env = info.Env();
if (info.Length() < 3) {
TypeError::New(env, "Wrong number of arguments").ThrowAsJavaScriptException();
return env.Null();
}
if (!info[0].IsNumber() || !info[1].IsBoolean() || !info[2].IsFunction()) {
TypeError::New(env, "Wrong arguments").ThrowAsJavaScriptException();
return env.Null();
}
int pid = info[0].As<Number>().Int32Value();
bool unref = info[1].As<Boolean>();
Function func = info[2].As<Function>();
// Do async stuff
my_context* context = new my_context();
NAPI_THROW_IF_FAILED(env, napi_create_threadsafe_function(
(napi_env) env,
(napi_value) func,
NULL,
(napi_value) String::New(env, "WaitForProcessToExit"),
0,
1,
NULL,
[](napi_env env, void* finalize_data, void* finalize_hint /* Context attached to the TSFN */) {
SetEvent(((my_context*)finalize_hint)->hStopEvent);
((my_context*)finalize_hint)->nativeThread.join();
delete finalize_hint;
},
context, // Context attached to the TSFN
[](napi_env env, napi_value js_callback, void* context, void* data) {
std::string* error = (std::string*)data;
// Transform native data into JS data, passing it to the provided `js_callback` (the TSFN's JavaScript function)
napi_status status = napi_ok;
napi_value global;
status = napi_get_global(env, &global);
if (status != napi_ok)
{
std::cout << "napi_get_global failed" << std::endl;
}
napi_value result;
if (error->empty()) {
status = napi_call_function(env, global, js_callback, 0, NULL, &result);
} else {
napi_value values[] = { (napi_value)Error::New(env, *error).Value() };
status = napi_call_function(env, global, js_callback, 1, values, &result);
}
delete data;
if (status != napi_ok)
{
std::cout << "napi_call_function failed" << std::endl;
}
status = napi_release_threadsafe_function(((my_context*)context)->tsfn, napi_tsfn_release);
if (status != napi_ok)
{
std::cout << "napi_release_threadsafe_function failed" << std::endl;
}
},
&(context->tsfn)), env.Undefined());
context->nativeThread = std::thread([pid, context] {
bool stopped = false;
std::string error = WaitForPid(pid, context, &stopped);
if (stopped) {
return;
}
napi_status status = napi_call_threadsafe_function(context->tsfn, new std::string(error), napi_tsfn_blocking);
if (status != napi_ok)
{
std::cout << "napi_call_threadsafe_function failed" << std::endl;
}
});
if (unref) {
NAPI_THROW_IF_FAILED(env, napi_unref_threadsafe_function((napi_env) env, context->tsfn), env.Undefined());
}
return env.Undefined();
}
Object Init(Env env, Object exports)
{
exports.Set(String::New(env, "WaitForProcessToExit"), Function::New(env, Winapi::WaitForProcessToExit));
return exports;
}
NODE_API_MODULE(hello, Init)