make module context-aware

[mac-g]

Issue or Feature

I've been experimenting with worker threads in node.js recently and noticed that the canvas module does not appear to be context-aware. In other words, the module will load/instantiate once, but as soon as another thread attempts to require canvas for it's own use, the following error is thrown:

Error: Module did not self-register.
    at Object.Module._extensions..node (internal/modules/cjs/loader.js:840:18)
    at Module.load (internal/modules/cjs/loader.js:666:32)
    at tryModuleLoad (internal/modules/cjs/loader.js:606:12)
    at Function.Module._load (internal/modules/cjs/loader.js:598:3)
    at Module.require (internal/modules/cjs/loader.js:705:19)
    at require (internal/modules/cjs/helpers.js:14:16)
    at Object.<anonymous> (~/node_modules/canvas/lib/bindings.js:3:18)
    at Module._compile (internal/modules/cjs/loader.js:799:30)
    at Object.Module._extensions..js (internal/modules/cjs/loader.js:810:10)
    at Module.load (internal/modules/cjs/loader.js:666:32)

Steps to Reproduce

In main thread...

const {Worker} = require('worker_threads');
var worker1 = new Worker('./child-thread.js'); 
var worker2 = new Worker('./child-thread.js');
// etc.

In child-thread.js...

var Canvas = require('canvas');
var canvas = Canvas.createCanvas(200, 200);
var ctx = canvas.getContext('2d');
// etc.

References

Node.js documentation:
https://nodejs.org/api/addons.html#addons_context_aware_addons
Similar issue:
schroffl/node-lzo#11

Environment

• node-canvas version 2.4.1
• Mac OS 10.14.3
• node version 11.12.1

[LinusU]

PRs welcome 👍

[jgoralcz]

This would be an incredible addition to node-canvas. Not sure where to fully dive in and modify the code though 🤔

[ruiwei]

I'm having the same issue. Any solution yet?

[anshul-kai]

Nope. Need to fork processes and can't use worker threads.

[siddarthareddyt]

#1409 doesn't seem to fix this issue. Any plans to provide support for worker_threads?

[DePasqualeOrg]

I'm having the same issue. I'd love to be able to use node-canvas in multiple worker threads to improve performance. Anyone want to tackle this? Seems like it should be straightforward to solve:

https://github.com/nodejs/node/blob/master/doc/api/addons.md#context-aware-addons

[mistval]

This would be very useful.

[lateiskate]

I was redirected here. I'd really love for this to be a thing. Using child processes is very expensive unlike worker threads

[anna-rmrf]

This is needed

[mac-g]

Looks like I'll have a chance to maybe take a stab at this in a week while I'm on leave. No promises. Has anyone else had a chance to take a look at it? If so, I'd be great to avoid hours of re-discovery.

[lostrepo]

Maybe this will help.

I'm total noob in C++
But I use something like that to use h264 encoder in worker_threads

#include "v8.h"
#include <node.h>
#include <node_buffer.h>

using namespace v8;

Per NodeJS instance addon data

class AddonData {
	public:
	explicit AddonData(Isolate* isolate):
	wh(0) {
		// Ensure this per-addon-instance data is deleted at environment cleanup
		node::AddEnvironmentCleanupHook(isolate, DeleteInstance, this);
	}
	
	
	// Per-addon data
	int wh;
	// ... omitted
	// Node Buffer Object for YUV420 source
	MaybeLocal<Object> ab;
	// Node Buffer Object for h264 bitstream
	MaybeLocal<Object> bsiab;
	
	
	int createEncoder(){
		int rv	=	WelsCreateSVCEncoder(&encoder_);
	
		return encoder_ != NULL ? rv : 1;
	}

	void clean() {
		if (encoder_) {
			encoder_->Uninitialize();
			WelsDestroySVCEncoder(encoder_);
		}
	}
	
	
	static void abDeleteCb(char* data, void* hint) {
		delete reinterpret_cast<MaybeLocal<Object>*>(hint);
	}
	
	static void noDeleteCb(char* data, void* hint) {
		// do nothing
	}
	
	static void DeleteInstance(void* data) {
		AddonData* ndata	=	reinterpret_cast<AddonData*>(data);
		ndata->clean();
		
		delete ndata;
	}
};

Callback that accesses per NodeJS instance addon data

void encode(const FunctionCallbackInfo<Value>& info) {
	// Retrieve the per-addon-instance data
	AddonData* data	=	reinterpret_cast<AddonData*>(info.Data().As<External>()->Value());
	
	// encode YUV420 from buf
	data->encode();
	// construct h264 bitstream from bitstream info
	data->parseBitstreamInfo();
	
	data->bsiab	=	node::Buffer::New(info.GetIsolate(), (char*) data->bsi.data(), (size_t) data->bsiSize, AddonData::abDeleteCb, (void*) &data->bsiab);
	
	info.GetReturnValue().Set(data->bsiab.ToLocalChecked());
}

Per NodeJS instance module initializer (another method of initialization can be used too but this one was used in another addon that works with worker_threads and I'm total C++ noob)

extern "C" NODE_MODULE_EXPORT void
NODE_MODULE_INITIALIZER(Local<Object> exports, Local<Value> module, Local<Context> context) {
	Isolate* isolate	=	context->GetIsolate();
	
	
	// Create a new instance of `AddonData` for this instance of the addon and
	// tie its life cycle to that of the Node.js environment
	AddonData* data	=	new AddonData(isolate);
	
	// create encoder instance
	data->createEncoder();
	
	
	// Wrap the data in a `v8::External` so we can pass it to the method we expose
	Local<External> external = External::New(isolate, data);
	
	
	// ... omitted
	
	exports->Set(
		context,
		String::NewFromUtf8(isolate, "encode", NewStringType::kNormal).ToLocalChecked(),
		FunctionTemplate::New(isolate, encode, external)->GetFunction(context).ToLocalChecked()
	).FromJust();
}