nodejs addon, how to invoke the registered callback function

[dreamyzhang]

• Node.js Version:6.9
• OS:linux
• Scope (install, code, runtime, meta, other?):addon
• Module (and version) (if relevant):addon

Like this problem here: [http://stackoverflow.com/questions/40856548/no-matching-function-for-call-to-persistentfunctionnewisolate-localfunct][1] , but when I using the callback function, it alaways coredump.

 class test : public node::ObjectWrap
 {
	 public:
		 void start();
		 static void on(const v8::FunctionCallbackInfo<v8::Value>& args);
		 std::map<string, v8::Persistent<v8::Function> > callback; 
 }

 //Register callback function
 void test::On(const FunctionCallbackInfo<Value>& args)
 {
	 Isolate* isolate = args.GetIsolate();
	 Local<String> eventName = args[0]->ToString(); 
	 Local<Function> cb = Local<Function>::Cast(args[1]); 
	 String::Utf8Value eNameUtf8(eventName); 
	 callback[*eNameUtf8].Reset(isolate, cb);
 } 

 void test::start()
 {
	 Isolate* isolate = Isolate::GetCurrent();
	 for(typeof(callback.begin()) it=callback.begin(); it!=callback.end(); it++)
	 { 
		 Local<Value> argv[1] = { Local<Value>::New(isolate, String::New(isolate, itr->first)) }; 
		 //How to call the registered callback function just now?
		 //will coredump on here
		 it->second.Call(Null(isolate), 1, argv); 
	 }
 }


 //test.js
 var t = require('bindings')('test')
 t.on("test1", function(){})
 t.on("test2", function(){})
 t.start()

[bnoordhuis]

If I had to guess, it's that you are missing a HandleScope somewhere. If that's not it, can you post full code?

[dreamyzhang]

#include <node.h>
#include "ThostFtdcMdSpiI.h"
namespace ctp
{
using v8::FunctionCallbackInfo;
using v8::Isolate;
using v8::Local;
using v8::Object;
using v8::Value;
using v8::Value;

void Create(const FunctionCallbackInfo<Value>& args)
{
 Test::NewInstance(args);
}

void Init(Local<Object> exports, Local<Object> module)
{
 Test::Init(exports->GetIsolate());
 NODE_SET_METHOD(module, "exports", Create);
}

NODE_MODULE(test, Init)
}


Test.h
namespace ctp
{
class Test : public node::ObjectWrap 
{
 public:
 static void test1(const v8::FunctionCallbackInfo<v8::Value>& args); 
 static void test2(const v8::FunctionCallbackInfo<v8::Value>& args); 
 static void On(const v8::FunctionCallbackInfo<v8::Value>& args);

 static void NewInstance(const v8::FunctionCallbackInfo<v8::Value>& args);
 static void Init(v8::Isolate* isolate);

 virtual void on_test1();
 virtual void on_test2();
 bool CanCallback(string event){
 if(callback_map.find(event) != callback_map.end()) return true;
 return false;
 }

 void SetCallback(string event, v8::Local<v8::Function>& cb, v8::Isolate* isolate)
 {
			callback_map[event].Reset(isolate, cb);
 }
 private:
 std::map<string, v8::Persistent<v8::Function> > callback_map;
 static set<string> m_event; 
 static v8::Persistent<v8::Function> constructor; 
 static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
};
}

test.cpp

#include "ThostFtdcMdSpiI.h"

namespace ctp
{
using v8::Exception;
using v8::Null;
using v8::Context;
using v8::Function;
using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
using v8::Isolate;
using v8::Local;
using v8::Number;
using v8::Object;
using v8::Persistent;
using v8::String;
using v8::Value;
using v8::Int32;
using v8::Boolean;
using v8::Handle;


set<string> Test::m_event; 
Persistent<Function> Test::constructor; 

void Test::Init(Isolate* isolate) 
{
 Local<FunctionTemplate> tpl = FunctionTemplate::New(isolate, New);
 tpl->SetClassName(String::NewFromUtf8(isolate, "Test"));
 tpl->InstanceTemplate()->SetInternalFieldCount(1);

 // Prototype
 NODE_SET_PROTOTYPE_METHOD(tpl, "test1", test1);
 NODE_SET_PROTOTYPE_METHOD(tpl, "test2", test2);
	NODE_SET_PROTOTYPE_METHOD(tpl, "on", On);
 constructor.Reset(isolate, tpl->GetFunction());
 m_event.insert("on_test1");
 m_event.insert("on_test2");
}

void Test::New(const FunctionCallbackInfo<Value>& args)
{
 Isolate* isolate = args.GetIsolate();
 
 if(args[0]->IsUndefined())
 {
 isolate->ThrowException(Exception::TypeError(String::NewFromUtf8(isolate, "Wrong arguments front register.")));
 return;
 }
 Local<String> sf = args[0]->ToString();
 String::Utf8Value front(sf);
 if(args.IsConstructCall())
 {
 // Invoked as constructor: `new MyObject(...)`
 Test* obj = new Test(*front);
 obj->Wrap(args.This());
 args.GetReturnValue().Set(args.This());
 }
 else
 {
 // Invoked as plain function `MyObject(...)`, turn into construct call
 const int argc = 1;
 Local<Value> argv[argc] = { args[0] };
 Local<Function> cons = Local<Function>::New(isolate, constructor);
 Local<Context> context = isolate->GetCurrentContext();
 Local<Object> instance = cons->NewInstance(context, argc, argv).ToLocalChecked();
 args.GetReturnValue().Set(instance);
 }
}

void Test::NewInstance(const FunctionCallbackInfo<Value>& args)
{
 Isolate* isolate = args.GetIsolate();
 const unsigned argc = 1;
 Handle<Value> argv[argc] = { args[0] };
 Local<Function> cons = Local<Function>::New(isolate, constructor);
 Local<Context> context = isolate->GetCurrentContext();
 Local<Object> instance = cons->NewInstance(context, argc, argv).ToLocalChecked();
 args.GetReturnValue().Set(instance);
}

void Test::On(const FunctionCallbackInfo<Value>& args)
{
 Isolate* isolate = args.GetIsolate();
 Test* obj = node::ObjectWrap::Unwrap<Test>(args.Holder());

 Local<String> eventName = args[0]->ToString();
 Local<Function> cb = Local<Function>::Cast(args[1]);

 String::Utf8Value eNameUtf8(eventName);
 std::set<string>::iterator eit = m_event.find(*eNameUtf8);
 if (eit == m_event.end()) 
 {
 isolate->ThrowException(Exception::TypeError(String::NewFromUtf8(isolate, "System has no register this event")));
 return;
 }

 if(obj->CanCallback(*eit))
 {
 isolate->ThrowException(Exception::TypeError(String::NewFromUtf8(isolate, "Callback is defined before")));
 return;
 }
 obj->SetCallback(*eNameUtf8, cb, isolate);
 args.GetReturnValue().Set(Number::New(isolate, 0));
}

void Test::test1(const FunctionCallbackInfo<Value>& args)
{
 Test* obj = node::ObjectWrap::Unwrap<Test>(args.Holder());
 Isolate* isolate = args.GetIsolate();
 const char* v = "1.1"
 args.GetReturnValue().Set(String::NewFromUtf8(isolate, v));
}

void Test::test1(const FunctionCallbackInfo<Value>& args)
{
 Test* obj = node::ObjectWrap::Unwrap<Test>(args.Holder());
 Isolate* isolate = args.GetIsolate();
	args.GetReturnValue().Set(String::NewFromUtf8(isolate, ""test1));
}

void Test::test2(const FunctionCallbackInfo<Value>& args)
{
 Isolate* isolate = args.GetIsolate();
 Test* obj = node::ObjectWrap::Unwrap<Test>(args.Holder());
	args.GetReturnValue().Set(Int32::New(isolate, "tets2"));
}
void Test::on_test1()
{
 Isolate* isolate = Isolate::GetCurrent();
 typeof(callback_map.begin()) it = callback_map.find("OnFrontConnected"); 
 if(it == callback_map.end()) return;
 it-second->Call(Null(isolate), 0, NULL); 
}

void Test::on_test2()
{
 Isolate* isolate = Isolate::GetCurrent();
 typeof(callback_map.begin()) it = callback_map.find("OnFrontDisconnected");
 if(it == callback_map.end()) return;

 Local<Value> argv[1] = { Local<Value>::New(isolate, Int32::New(isolate, nReason)) }; 
 it->second->Call(Null(isolate), 1, argv); 
}

invoke on_test2 an on_test1 on other thread, I think itmissing a HandleScope . but how to invoke on_tets1 and on_test2 in other thread.

[bnoordhuis]

invoke on_test2 an on_test1 on other thread

You cannot do that, calls into the VM may only be done from the main thread.

[dreamyzhang]

because itis a third-party service invoke on_test2 an on_test1 on other thread. I can only rewrite its callback function on_test1 and on_test2. So I need get the context in the callback function

[bnoordhuis]

Let me repeat: you absolutely cannot call into the VM from another thread. Look up uv_async_send(), you can use it to notify the main thread.

[dreamyzhang]

yeah, uv_async_init initializes a callback function, uv_async_send notify main loop exec the callback function。 or use uv_queue_work , work thread push the callback task to queue, and the main thread process queue to exec callback function.

[dreamyzhang]

(gdb)
#0 0x0000000000978f40 in v8::Function::Call(v8::Localv8::Value, int, v8::Localv8::Value) ()
#1 0x00007fc78bb65ec9 in ctp::WrapMd::MainOnFrontConnected() () from /home/ops/dreamy/node-ctp/build/Release/shifctp.node
#2 0x00007fc78bb63029 in ctp::CThostFtdcMdSpiI::_on_completed(uv_work_s, int) () from /home/ops/dreamy/node-ctp/build/Release/shifctp.node
#3 0x000000000122adc5 in uv__work_done (handle=0x7fc774021170) at ../deps/uv/src/threadpool.c:236
#4 0x000000000122cddb in uv__async_event (loop=0x1cdedc0 <default_loop_struct>, w=, nevents=) at ../deps/uv/src/unix/async.c:98
#5 0x000000000122ceb3 in uv__async_io (loop=0x1cdedc0 <default_loop_struct>, w=0x1cdef88 <default_loop_struct+456>, events=) at ../deps/uv/src/unix/async.c:138
#6 0x000000000123d480 in uv__io_poll (loop=loop@entry=0x1cdedc0 <default_loop_struct>, timeout=0) at ../deps/uv/src/unix/linux-core.c:380
#7 0x000000000122d996 in uv_run (loop=0x1cdedc0 <default_loop_struct>, mode=UV_RUN_ONCE) at ../deps/uv/src/unix/core.c:354
#8 0x0000000000fc1ba0 in node::Start(int, char**) ()
#9 0x00007fc78dd92b15 in __libc_start_main () from /lib64/libc.so.6
#10 0x00000000007a3a2d in _start ()
(gdb)
void WrapMd::MainOnFrontConnected()
{
Isolate* isolate = Isolate::GetCurrent();
Local argv[1] = {Local::New(isolate, Int32::New(isolate, 0))};
//std::map<string, v8::Localv8::Function > callback_map; === it->second
it->second->Call(Null(isolate), 1, argv);
}

use uv_queue_work , the stack indicate that the MainOnFrontConnected invoked in main thread loop. but comedump as before. why ?

[bnoordhuis]

Can you post your (complete, not abridged) updated code?

[dreamyzhang]

record the callback function:
std::map<string, v8::Persistentv8::Function > callback_map;
callback_map[event].Reset(isolate, cb);

use callback function:
typeof(callback_map.begin()) it = callback_map.find(event);
Local cb = Local::New(isolate, it->second);
cb->Call(Null(isolate), 4, argv);

this is will work。 but why save as std::map<string, v8::Persistentv8::Function > ， and When using need to cast to Local ？

[dreamyzhang]

All code amount is a bit big, bad upload。

[bnoordhuis]

Is your question why you need to save the callback as a Persistent<Function>? Because otherwise the value that cb points to is going to get garbage collected eventually.

[dreamyzhang]

yeah， thanks very much。 it is ok now。

[bnoordhuis]

Good to hear. I'll close this out.