Calling napi_call_function from a worker thread

[tinpotnick]

Hi,

I am trying to write a C++ addon. In the addon, it will create worker threads that will process network audio. When an event occurs in the worker thread I need to pass this back into the node application.

const project = require( "myaddon" )
project.on( () => {
  console.log( "Something happened in c++" )
} )

Then in C++ something like

void workerthread() {
  // Do something useful
  while( appisrunning ) {
    waitforsometihnguseful();
    napi_call_function( env, ... );
  }
}

I have seen in the documentation napi_call_threadsafe_function. I anticipate this works something like:

void calljscallback( params ) {
  napi_call_function( env, ... );
}

void workerthread() {
  // Do something useful
  while( appisrunning ) {
    waitforsometihnguseful();
    napi_call_threadsafe_function( calljscallback );
  }
}

1. What I am struggling to understand from the documents is calling napi_call_function thread-safe? Is the second pattern the expected way to perform a threadsafe callback?
2. In the C++ application, the call to project.on() which calls into C++ should it register as an async function somehow? - so the node application doesn't end. i.e. how do I prevent the application from quitting from C++?

[tinpotnick]

After some reading time. I think I have the answer.

To prevent node from exiting whilst the addon is busy:

Point 1

The section under Asynchronous thread-safe function calls in the main node addon page explains threads. i.e. only the node thread can call back into and goes on to explain it in detail. Not sure how I missed that.

Point 2

To stop node exiting when there is an async function being performed is to create some async work:

static void runworkcomplete( napi_env env, napi_status status, void *data ) {
  napi_value resolution;

  napi_create_string_utf8( env, "Server stopped", NAPI_AUTO_LENGTH, &resolution );
  napi_resolve_deferred( env, stoppingdefferedpromise, resolution );
}

static napi_value stopserver( napi_env env, napi_callback_info info ) {

  napi_value stoppingpromise;

  if( napi_ok != napi_create_promise( env, &stoppingdefferedpromise, &stoppingpromise ) ) {
    return NULL;
  }

  // Stop our server

  return stoppingpromise;
}

static napi_value startserver( napi_env env, napi_callback_info info ) {

  napi_value workname;
  napi_async_work workhandle;

  if( napi_ok != napi_create_string_utf8( env, "projectrtp", NAPI_AUTO_LENGTH, &workname ) ) {
    return NULL;
  }

  if( napi_ok != napi_create_async_work( env,
                                         NULL,
                                         workname,
                                         runwork,
                                         runworkcomplete,
                                         NULL, /*void* data,*/
                                         &workhandle ) ) {
    return NULL;
  }

  if( napi_ok != napi_queue_async_work( env, workhandle ) ) {
    return NULL;
  }

  return NULL;
}