aboutsummaryrefslogtreecommitdiffhomepage
path: root/src/node
diff options
context:
space:
mode:
Diffstat (limited to 'src/node')
-rw-r--r--src/node/binding.gyp1
-rw-r--r--src/node/ext/byte_buffer.cc36
-rw-r--r--src/node/ext/byte_buffer.h6
-rw-r--r--src/node/ext/call.cc445
-rw-r--r--src/node/ext/call.h59
-rw-r--r--src/node/ext/channel.cc178
-rw-r--r--src/node/ext/channel.h10
-rw-r--r--src/node/ext/completion_queue_async_worker.cc27
-rw-r--r--src/node/ext/completion_queue_async_worker.h4
-rw-r--r--src/node/ext/credentials.cc192
-rw-r--r--src/node/ext/credentials.h12
-rw-r--r--src/node/ext/node_grpc.cc319
-rw-r--r--src/node/ext/server.cc202
-rw-r--r--src/node/ext/server.h10
-rw-r--r--src/node/ext/server_credentials.cc153
-rw-r--r--src/node/ext/server_credentials.h12
-rw-r--r--src/node/package.json2
17 files changed, 894 insertions, 774 deletions
diff --git a/src/node/binding.gyp b/src/node/binding.gyp
index 734dc8410b..a644030932 100644
--- a/src/node/binding.gyp
+++ b/src/node/binding.gyp
@@ -8,7 +8,6 @@
'-std=c++0x',
'-Wall',
'-pthread',
- '-pedantic',
'-g',
'-zdefs',
'-Werror',
diff --git a/src/node/ext/byte_buffer.cc b/src/node/ext/byte_buffer.cc
index fe7735d429..e1786ddba7 100644
--- a/src/node/ext/byte_buffer.cc
+++ b/src/node/ext/byte_buffer.cc
@@ -44,15 +44,16 @@
namespace grpc {
namespace node {
+
using v8::Context;
using v8::Function;
-using v8::Handle;
+using v8::Local;
using v8::Object;
using v8::Number;
using v8::Value;
-grpc_byte_buffer *BufferToByteBuffer(Handle<Value> buffer) {
- NanScope();
+grpc_byte_buffer *BufferToByteBuffer(Local<Value> buffer) {
+ Nan::HandleScope scope;
int length = ::node::Buffer::Length(buffer);
char *data = ::node::Buffer::Data(buffer);
gpr_slice slice = gpr_slice_malloc(length);
@@ -62,10 +63,10 @@ grpc_byte_buffer *BufferToByteBuffer(Handle<Value> buffer) {
return byte_buffer;
}
-Handle<Value> ByteBufferToBuffer(grpc_byte_buffer *buffer) {
- NanEscapableScope();
+Local<Value> ByteBufferToBuffer(grpc_byte_buffer *buffer) {
+ Nan::EscapableHandleScope scope;
if (buffer == NULL) {
- return NanEscapeScope(NanNull());
+ return scope.Escape(Nan::Null());
}
size_t length = grpc_byte_buffer_length(buffer);
char *result = reinterpret_cast<char *>(calloc(length, sizeof(char)));
@@ -77,21 +78,22 @@ Handle<Value> ByteBufferToBuffer(grpc_byte_buffer *buffer) {
memcpy(result + offset, GPR_SLICE_START_PTR(next), GPR_SLICE_LENGTH(next));
offset += GPR_SLICE_LENGTH(next);
}
- return NanEscapeScope(MakeFastBuffer(NanBufferUse(result, length)));
+ return scope.Escape(MakeFastBuffer(
+ Nan::NewBuffer(result, length).ToLocalChecked()));
}
-Handle<Value> MakeFastBuffer(Handle<Value> slowBuffer) {
- NanEscapableScope();
- Handle<Object> globalObj = NanGetCurrentContext()->Global();
- Handle<Function> bufferConstructor = Handle<Function>::Cast(
- globalObj->Get(NanNew("Buffer")));
- Handle<Value> consArgs[3] = {
+Local<Value> MakeFastBuffer(Local<Value> slowBuffer) {
+ Nan::EscapableHandleScope scope;
+ Local<Object> globalObj = Nan::GetCurrentContext()->Global();
+ Local<Function> bufferConstructor = Local<Function>::Cast(
+ globalObj->Get(Nan::New("Buffer").ToLocalChecked()));
+ Local<Value> consArgs[3] = {
slowBuffer,
- NanNew<Number>(::node::Buffer::Length(slowBuffer)),
- NanNew<Number>(0)
+ Nan::New<Number>(::node::Buffer::Length(slowBuffer)),
+ Nan::New<Number>(0)
};
- Handle<Object> fastBuffer = bufferConstructor->NewInstance(3, consArgs);
- return NanEscapeScope(fastBuffer);
+ Local<Object> fastBuffer = bufferConstructor->NewInstance(3, consArgs);
+ return scope.Escape(fastBuffer);
}
} // namespace node
} // namespace grpc
diff --git a/src/node/ext/byte_buffer.h b/src/node/ext/byte_buffer.h
index 5083674d39..55bc0ab377 100644
--- a/src/node/ext/byte_buffer.h
+++ b/src/node/ext/byte_buffer.h
@@ -45,14 +45,14 @@ namespace node {
/* Convert a Node.js Buffer to grpc_byte_buffer. Requires that
::node::Buffer::HasInstance(buffer) */
-grpc_byte_buffer *BufferToByteBuffer(v8::Handle<v8::Value> buffer);
+grpc_byte_buffer *BufferToByteBuffer(v8::Local<v8::Value> buffer);
/* Convert a grpc_byte_buffer to a Node.js Buffer */
-v8::Handle<v8::Value> ByteBufferToBuffer(grpc_byte_buffer *buffer);
+v8::Local<v8::Value> ByteBufferToBuffer(grpc_byte_buffer *buffer);
/* Convert a ::node::Buffer to a fast Buffer, as defined in the Node
Buffer documentation */
-v8::Handle<v8::Value> MakeFastBuffer(v8::Handle<v8::Value> slowBuffer);
+v8::Local<v8::Value> MakeFastBuffer(v8::Local<v8::Value> slowBuffer);
} // namespace node
} // namespace grpc
diff --git a/src/node/ext/call.cc b/src/node/ext/call.cc
index 49b306202b..b08a9f96d8 100644
--- a/src/node/ext/call.cc
+++ b/src/node/ext/call.cc
@@ -54,52 +54,61 @@ using std::vector;
namespace grpc {
namespace node {
+using Nan::Callback;
+using Nan::EscapableHandleScope;
+using Nan::HandleScope;
+using Nan::Maybe;
+using Nan::MaybeLocal;
+using Nan::ObjectWrap;
+using Nan::Persistent;
+using Nan::Utf8String;
+
using v8::Array;
using v8::Boolean;
using v8::Exception;
using v8::External;
using v8::Function;
using v8::FunctionTemplate;
-using v8::Handle;
-using v8::HandleScope;
using v8::Integer;
using v8::Local;
using v8::Number;
using v8::Object;
using v8::ObjectTemplate;
-using v8::Persistent;
using v8::Uint32;
using v8::String;
using v8::Value;
-NanCallback *Call::constructor;
+Callback *Call::constructor;
Persistent<FunctionTemplate> Call::fun_tpl;
bool EndsWith(const char *str, const char *substr) {
return strcmp(str+strlen(str)-strlen(substr), substr) == 0;
}
-bool CreateMetadataArray(Handle<Object> metadata, grpc_metadata_array *array,
+bool CreateMetadataArray(Local<Object> metadata, grpc_metadata_array *array,
shared_ptr<Resources> resources) {
- NanScope();
+ HandleScope scope;
grpc_metadata_array_init(array);
- Handle<Array> keys(metadata->GetOwnPropertyNames());
+ Local<Array> keys = Nan::GetOwnPropertyNames(metadata).ToLocalChecked();
for (unsigned int i = 0; i < keys->Length(); i++) {
- Handle<String> current_key(keys->Get(i)->ToString());
- if (!metadata->Get(current_key)->IsArray()) {
+ Local<String> current_key = Nan::To<String>(
+ Nan::Get(keys, i).ToLocalChecked()).ToLocalChecked();
+ Local<Value> value_array = Nan::Get(metadata, current_key).ToLocalChecked();
+ if (!value_array->IsArray()) {
return false;
}
- array->capacity += Local<Array>::Cast(metadata->Get(current_key))->Length();
+ array->capacity += Local<Array>::Cast(value_array)->Length();
}
array->metadata = reinterpret_cast<grpc_metadata*>(
gpr_malloc(array->capacity * sizeof(grpc_metadata)));
for (unsigned int i = 0; i < keys->Length(); i++) {
- Handle<String> current_key(keys->Get(i)->ToString());
- NanUtf8String *utf8_key = new NanUtf8String(current_key);
- resources->strings.push_back(unique_ptr<NanUtf8String>(utf8_key));
- Handle<Array> values = Local<Array>::Cast(metadata->Get(current_key));
+ Local<String> current_key(keys->Get(i)->ToString());
+ Utf8String *utf8_key = new Utf8String(current_key);
+ resources->strings.push_back(unique_ptr<Utf8String>(utf8_key));
+ Local<Array> values = Local<Array>::Cast(
+ Nan::Get(metadata, current_key).ToLocalChecked());
for (unsigned int j = 0; j < values->Length(); j++) {
- Handle<Value> value = values->Get(j);
+ Local<Value> value = Nan::Get(values, j).ToLocalChecked();
grpc_metadata *current = &array->metadata[array->count];
current->key = **utf8_key;
// Only allow binary headers for "-bin" keys
@@ -107,18 +116,16 @@ bool CreateMetadataArray(Handle<Object> metadata, grpc_metadata_array *array,
if (::node::Buffer::HasInstance(value)) {
current->value = ::node::Buffer::Data(value);
current->value_length = ::node::Buffer::Length(value);
- Persistent<Value> *handle = new Persistent<Value>();
- NanAssignPersistent(*handle, value);
- resources->handles.push_back(unique_ptr<PersistentHolder>(
- new PersistentHolder(handle)));
+ PersistentValue *handle = new PersistentValue(value);
+ resources->handles.push_back(unique_ptr<PersistentValue>(handle));
} else {
return false;
}
} else {
if (value->IsString()) {
- Handle<String> string_value = value->ToString();
- NanUtf8String *utf8_value = new NanUtf8String(string_value);
- resources->strings.push_back(unique_ptr<NanUtf8String>(utf8_value));
+ Local<String> string_value = Nan::To<String>(value).ToLocalChecked();
+ Utf8String *utf8_value = new Utf8String(string_value);
+ resources->strings.push_back(unique_ptr<Utf8String>(utf8_value));
current->value = **utf8_value;
current->value_length = string_value->Length();
} else {
@@ -131,8 +138,8 @@ bool CreateMetadataArray(Handle<Object> metadata, grpc_metadata_array *array,
return true;
}
-Handle<Value> ParseMetadata(const grpc_metadata_array *metadata_array) {
- NanEscapableScope();
+Local<Value> ParseMetadata(const grpc_metadata_array *metadata_array) {
+ EscapableHandleScope scope;
grpc_metadata *metadata_elements = metadata_array->metadata;
size_t length = metadata_array->count;
std::map<const char*, size_t> size_map;
@@ -142,34 +149,39 @@ Handle<Value> ParseMetadata(const grpc_metadata_array *metadata_array) {
const char *key = metadata_elements[i].key;
if (size_map.count(key)) {
size_map[key] += 1;
+ } else {
+ size_map[key] = 1;
}
index_map[key] = 0;
}
- Handle<Object> metadata_object = NanNew<Object>();
+ Local<Object> metadata_object = Nan::New<Object>();
for (unsigned int i = 0; i < length; i++) {
grpc_metadata* elem = &metadata_elements[i];
- Handle<String> key_string = NanNew(elem->key);
- Handle<Array> array;
- if (metadata_object->Has(key_string)) {
- array = Handle<Array>::Cast(metadata_object->Get(key_string));
+ Local<String> key_string = Nan::New(elem->key).ToLocalChecked();
+ Local<Array> array;
+ MaybeLocal<Value> maybe_array = Nan::Get(metadata_object, key_string);
+ if (maybe_array.IsEmpty() || !maybe_array.ToLocalChecked()->IsArray()) {
+ array = Nan::New<Array>(size_map[elem->key]);
+ Nan::Set(metadata_object, key_string, array);
} else {
- array = NanNew<Array>(size_map[elem->key]);
- metadata_object->Set(key_string, array);
+ array = Local<Array>::Cast(maybe_array.ToLocalChecked());
}
if (EndsWith(elem->key, "-bin")) {
- array->Set(index_map[elem->key],
- NanNewBufferHandle(elem->value, elem->value_length));
+ Nan::Set(array, index_map[elem->key],
+ Nan::CopyBuffer(elem->value,
+ elem->value_length).ToLocalChecked());
} else {
- array->Set(index_map[elem->key], NanNew(elem->value));
+ Nan::Set(array, index_map[elem->key],
+ Nan::New(elem->value).ToLocalChecked());
}
index_map[elem->key] += 1;
}
- return NanEscapeScope(metadata_object);
+ return scope.Escape(metadata_object);
}
-Handle<Value> Op::GetOpType() const {
- NanEscapableScope();
- return NanEscapeScope(NanNew<String>(GetTypeString()));
+Local<Value> Op::GetOpType() const {
+ EscapableHandleScope scope;
+ return scope.Escape(Nan::New(GetTypeString()).ToLocalChecked());
}
Op::~Op() {
@@ -177,17 +189,22 @@ Op::~Op() {
class SendMetadataOp : public Op {
public:
- Handle<Value> GetNodeValue() const {
- NanEscapableScope();
- return NanEscapeScope(NanTrue());
+ Local<Value> GetNodeValue() const {
+ EscapableHandleScope scope;
+ return scope.Escape(Nan::True());
}
- bool ParseOp(Handle<Value> value, grpc_op *out,
+ bool ParseOp(Local<Value> value, grpc_op *out,
shared_ptr<Resources> resources) {
if (!value->IsObject()) {
return false;
}
grpc_metadata_array array;
- if (!CreateMetadataArray(value->ToObject(), &array, resources)) {
+ MaybeLocal<Object> maybe_metadata = Nan::To<Object>(value);
+ if (maybe_metadata.IsEmpty()) {
+ return false;
+ }
+ if (!CreateMetadataArray(maybe_metadata.ToLocalChecked(),
+ &array, resources)) {
return false;
}
out->data.send_initial_metadata.count = array.count;
@@ -202,27 +219,28 @@ class SendMetadataOp : public Op {
class SendMessageOp : public Op {
public:
- Handle<Value> GetNodeValue() const {
- NanEscapableScope();
- return NanEscapeScope(NanTrue());
+ Local<Value> GetNodeValue() const {
+ EscapableHandleScope scope;
+ return scope.Escape(Nan::True());
}
- bool ParseOp(Handle<Value> value, grpc_op *out,
+ bool ParseOp(Local<Value> value, grpc_op *out,
shared_ptr<Resources> resources) {
if (!::node::Buffer::HasInstance(value)) {
return false;
}
- Handle<Object> object_value = value->ToObject();
- if (object_value->HasOwnProperty(NanNew("grpcWriteFlags"))) {
- Handle<Value> flag_value = object_value->Get(NanNew("grpcWriteFlags"));
+ Local<Object> object_value = Nan::To<Object>(value).ToLocalChecked();
+ MaybeLocal<Value> maybe_flag_value = Nan::Get(
+ object_value, Nan::New("grpcWriteFlags").ToLocalChecked());
+ if (!maybe_flag_value.IsEmpty()) {
+ Local<Value> flag_value = maybe_flag_value.ToLocalChecked();
if (flag_value->IsUint32()) {
- out->flags = flag_value->Uint32Value() & GRPC_WRITE_USED_MASK;
+ Maybe<uint32_t> maybe_flag = Nan::To<uint32_t>(flag_value);
+ out->flags = maybe_flag.FromMaybe(0) & GRPC_WRITE_USED_MASK;
}
}
out->data.send_message = BufferToByteBuffer(value);
- Persistent<Value> *handle = new Persistent<Value>();
- NanAssignPersistent(*handle, value);
- resources->handles.push_back(unique_ptr<PersistentHolder>(
- new PersistentHolder(handle)));
+ PersistentValue *handle = new PersistentValue(value);
+ resources->handles.push_back(unique_ptr<PersistentValue>(handle));
return true;
}
protected:
@@ -233,11 +251,11 @@ class SendMessageOp : public Op {
class SendClientCloseOp : public Op {
public:
- Handle<Value> GetNodeValue() const {
- NanEscapableScope();
- return NanEscapeScope(NanTrue());
+ Local<Value> GetNodeValue() const {
+ EscapableHandleScope scope;
+ return scope.Escape(Nan::True());
}
- bool ParseOp(Handle<Value> value, grpc_op *out,
+ bool ParseOp(Local<Value> value, grpc_op *out,
shared_ptr<Resources> resources) {
return true;
}
@@ -249,39 +267,55 @@ class SendClientCloseOp : public Op {
class SendServerStatusOp : public Op {
public:
- Handle<Value> GetNodeValue() const {
- NanEscapableScope();
- return NanEscapeScope(NanTrue());
+ Local<Value> GetNodeValue() const {
+ EscapableHandleScope scope;
+ return scope.Escape(Nan::True());
}
- bool ParseOp(Handle<Value> value, grpc_op *out,
+ bool ParseOp(Local<Value> value, grpc_op *out,
shared_ptr<Resources> resources) {
if (!value->IsObject()) {
return false;
}
- Handle<Object> server_status = value->ToObject();
- if (!server_status->Get(NanNew("metadata"))->IsObject()) {
+ Local<Object> server_status = Nan::To<Object>(value).ToLocalChecked();
+ MaybeLocal<Value> maybe_metadata = Nan::Get(
+ server_status, Nan::New("metadata").ToLocalChecked());
+ if (maybe_metadata.IsEmpty()) {
+ return false;
+ }
+ if (!maybe_metadata.ToLocalChecked()->IsObject()) {
+ return false;
+ }
+ Local<Object> metadata = Nan::To<Object>(
+ maybe_metadata.ToLocalChecked()).ToLocalChecked();
+ MaybeLocal<Value> maybe_code = Nan::Get(server_status,
+ Nan::New("code").ToLocalChecked());
+ if (maybe_code.IsEmpty()) {
return false;
}
- if (!server_status->Get(NanNew("code"))->IsUint32()) {
+ if (!maybe_code.ToLocalChecked()->IsUint32()) {
return false;
}
- if (!server_status->Get(NanNew("details"))->IsString()) {
+ uint32_t code = Nan::To<uint32_t>(maybe_code.ToLocalChecked()).FromJust();
+ MaybeLocal<Value> maybe_details = Nan::Get(
+ server_status, Nan::New("details").ToLocalChecked());
+ if (maybe_details.IsEmpty()) {
return false;
}
+ if (!maybe_details.ToLocalChecked()->IsString()) {
+ return false;
+ }
+ Local<String> details = Nan::To<String>(
+ maybe_details.ToLocalChecked()).ToLocalChecked();
grpc_metadata_array array;
- if (!CreateMetadataArray(server_status->Get(NanNew("metadata"))->
- ToObject(),
- &array, resources)) {
+ if (!CreateMetadataArray(metadata, &array, resources)) {
return false;
}
out->data.send_status_from_server.trailing_metadata_count = array.count;
out->data.send_status_from_server.trailing_metadata = array.metadata;
out->data.send_status_from_server.status =
- static_cast<grpc_status_code>(
- server_status->Get(NanNew("code"))->Uint32Value());
- NanUtf8String *str = new NanUtf8String(
- server_status->Get(NanNew("details")));
- resources->strings.push_back(unique_ptr<NanUtf8String>(str));
+ static_cast<grpc_status_code>(code);
+ Utf8String *str = new Utf8String(details);
+ resources->strings.push_back(unique_ptr<Utf8String>(str));
out->data.send_status_from_server.status_details = **str;
return true;
}
@@ -301,12 +335,12 @@ class GetMetadataOp : public Op {
grpc_metadata_array_destroy(&recv_metadata);
}
- Handle<Value> GetNodeValue() const {
- NanEscapableScope();
- return NanEscapeScope(ParseMetadata(&recv_metadata));
+ Local<Value> GetNodeValue() const {
+ EscapableHandleScope scope;
+ return scope.Escape(ParseMetadata(&recv_metadata));
}
- bool ParseOp(Handle<Value> value, grpc_op *out,
+ bool ParseOp(Local<Value> value, grpc_op *out,
shared_ptr<Resources> resources) {
out->data.recv_initial_metadata = &recv_metadata;
return true;
@@ -331,12 +365,12 @@ class ReadMessageOp : public Op {
grpc_byte_buffer_destroy(recv_message);
}
}
- Handle<Value> GetNodeValue() const {
- NanEscapableScope();
- return NanEscapeScope(ByteBufferToBuffer(recv_message));
+ Local<Value> GetNodeValue() const {
+ EscapableHandleScope scope;
+ return scope.Escape(ByteBufferToBuffer(recv_message));
}
- bool ParseOp(Handle<Value> value, grpc_op *out,
+ bool ParseOp(Local<Value> value, grpc_op *out,
shared_ptr<Resources> resources) {
out->data.recv_message = &recv_message;
return true;
@@ -364,7 +398,7 @@ class ClientStatusOp : public Op {
gpr_free(status_details);
}
- bool ParseOp(Handle<Value> value, grpc_op *out,
+ bool ParseOp(Local<Value> value, grpc_op *out,
shared_ptr<Resources> resources) {
out->data.recv_status_on_client.trailing_metadata = &metadata_array;
out->data.recv_status_on_client.status = &status;
@@ -373,15 +407,18 @@ class ClientStatusOp : public Op {
return true;
}
- Handle<Value> GetNodeValue() const {
- NanEscapableScope();
- Handle<Object> status_obj = NanNew<Object>();
- status_obj->Set(NanNew("code"), NanNew<Number>(status));
+ Local<Value> GetNodeValue() const {
+ EscapableHandleScope scope;
+ Local<Object> status_obj = Nan::New<Object>();
+ Nan::Set(status_obj, Nan::New("code").ToLocalChecked(),
+ Nan::New<Number>(status));
if (status_details != NULL) {
- status_obj->Set(NanNew("details"), NanNew(status_details));
+ Nan::Set(status_obj, Nan::New("details").ToLocalChecked(),
+ Nan::New(status_details).ToLocalChecked());
}
- status_obj->Set(NanNew("metadata"), ParseMetadata(&metadata_array));
- return NanEscapeScope(status_obj);
+ Nan::Set(status_obj, Nan::New("metadata").ToLocalChecked(),
+ ParseMetadata(&metadata_array));
+ return scope.Escape(status_obj);
}
protected:
std::string GetTypeString() const {
@@ -396,12 +433,12 @@ class ClientStatusOp : public Op {
class ServerCloseResponseOp : public Op {
public:
- Handle<Value> GetNodeValue() const {
- NanEscapableScope();
- return NanEscapeScope(NanNew<Boolean>(cancelled));
+ Local<Value> GetNodeValue() const {
+ EscapableHandleScope scope;
+ return scope.Escape(Nan::New<Boolean>(cancelled));
}
- bool ParseOp(Handle<Value> value, grpc_op *out,
+ bool ParseOp(Local<Value> value, grpc_op *out,
shared_ptr<Resources> resources) {
out->data.recv_close_on_server.cancelled = &cancelled;
return true;
@@ -416,7 +453,7 @@ class ServerCloseResponseOp : public Op {
int cancelled;
};
-tag::tag(NanCallback *callback, OpVec *ops,
+tag::tag(Callback *callback, OpVec *ops,
shared_ptr<Resources> resources) :
callback(callback), ops(ops), resources(resources){
}
@@ -426,19 +463,19 @@ tag::~tag() {
delete ops;
}
-Handle<Value> GetTagNodeValue(void *tag) {
- NanEscapableScope();
+Local<Value> GetTagNodeValue(void *tag) {
+ EscapableHandleScope scope;
struct tag *tag_struct = reinterpret_cast<struct tag *>(tag);
- Handle<Object> tag_obj = NanNew<Object>();
+ Local<Object> tag_obj = Nan::New<Object>();
for (vector<unique_ptr<Op> >::iterator it = tag_struct->ops->begin();
it != tag_struct->ops->end(); ++it) {
Op *op_ptr = it->get();
- tag_obj->Set(op_ptr->GetOpType(), op_ptr->GetNodeValue());
+ Nan::Set(tag_obj, op_ptr->GetOpType(), op_ptr->GetNodeValue());
}
- return NanEscapeScope(tag_obj);
+ return scope.Escape(tag_obj);
}
-NanCallback *GetTagCallback(void *tag) {
+Callback *GetTagCallback(void *tag) {
struct tag *tag_struct = reinterpret_cast<struct tag *>(tag);
return tag_struct->callback;
}
@@ -455,140 +492,149 @@ Call::~Call() {
grpc_call_destroy(wrapped_call);
}
-void Call::Init(Handle<Object> exports) {
- NanScope();
- Local<FunctionTemplate> tpl = NanNew<FunctionTemplate>(New);
- tpl->SetClassName(NanNew("Call"));
+void Call::Init(Local<Object> exports) {
+ HandleScope scope;
+ Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(New);
+ tpl->SetClassName(Nan::New("Call").ToLocalChecked());
tpl->InstanceTemplate()->SetInternalFieldCount(1);
- NanSetPrototypeTemplate(tpl, "startBatch",
- NanNew<FunctionTemplate>(StartBatch)->GetFunction());
- NanSetPrototypeTemplate(tpl, "cancel",
- NanNew<FunctionTemplate>(Cancel)->GetFunction());
- NanSetPrototypeTemplate(
- tpl, "cancelWithStatus",
- NanNew<FunctionTemplate>(CancelWithStatus)->GetFunction());
- NanSetPrototypeTemplate(tpl, "getPeer",
- NanNew<FunctionTemplate>(GetPeer)->GetFunction());
- NanAssignPersistent(fun_tpl, tpl);
- Handle<Function> ctr = tpl->GetFunction();
- exports->Set(NanNew("Call"), ctr);
- constructor = new NanCallback(ctr);
+ Nan::SetPrototypeMethod(tpl, "startBatch", StartBatch);
+ Nan::SetPrototypeMethod(tpl, "cancel", Cancel);
+ Nan::SetPrototypeMethod(tpl, "cancelWithStatus", CancelWithStatus);
+ Nan::SetPrototypeMethod(tpl, "getPeer", GetPeer);
+ fun_tpl.Reset(tpl);
+ Local<Function> ctr = Nan::GetFunction(tpl).ToLocalChecked();
+ Nan::Set(exports, Nan::New("Call").ToLocalChecked(), ctr);
+ constructor = new Callback(ctr);
}
-bool Call::HasInstance(Handle<Value> val) {
- NanScope();
- return NanHasInstance(fun_tpl, val);
+bool Call::HasInstance(Local<Value> val) {
+ HandleScope scope;
+ return Nan::New(fun_tpl)->HasInstance(val);
}
-Handle<Value> Call::WrapStruct(grpc_call *call) {
- NanEscapableScope();
+Local<Value> Call::WrapStruct(grpc_call *call) {
+ EscapableHandleScope scope;
if (call == NULL) {
- return NanEscapeScope(NanNull());
+ return scope.Escape(Nan::Null());
}
const int argc = 1;
- Handle<Value> argv[argc] = {NanNew<External>(reinterpret_cast<void *>(call))};
- return NanEscapeScope(constructor->GetFunction()->NewInstance(argc, argv));
+ Local<Value> argv[argc] = {Nan::New<External>(
+ reinterpret_cast<void *>(call))};
+ MaybeLocal<Object> maybe_instance = Nan::NewInstance(
+ constructor->GetFunction(), argc, argv);
+ if (maybe_instance.IsEmpty()) {
+ return scope.Escape(Nan::Null());
+ } else {
+ return scope.Escape(maybe_instance.ToLocalChecked());
+ }
}
NAN_METHOD(Call::New) {
- NanScope();
-
- if (args.IsConstructCall()) {
+ if (info.IsConstructCall()) {
Call *call;
- if (args[0]->IsExternal()) {
- Handle<External> ext = args[0].As<External>();
+ if (info[0]->IsExternal()) {
+ Local<External> ext = info[0].As<External>();
// This option is used for wrapping an existing call
grpc_call *call_value =
reinterpret_cast<grpc_call *>(ext->Value());
call = new Call(call_value);
} else {
- if (!Channel::HasInstance(args[0])) {
- return NanThrowTypeError("Call's first argument must be a Channel");
+ if (!Channel::HasInstance(info[0])) {
+ return Nan::ThrowTypeError("Call's first argument must be a Channel");
}
- if (!args[1]->IsString()) {
- return NanThrowTypeError("Call's second argument must be a string");
+ if (!info[1]->IsString()) {
+ return Nan::ThrowTypeError("Call's second argument must be a string");
}
- if (!(args[2]->IsNumber() || args[2]->IsDate())) {
- return NanThrowTypeError(
+ if (!(info[2]->IsNumber() || info[2]->IsDate())) {
+ return Nan::ThrowTypeError(
"Call's third argument must be a date or a number");
}
// These arguments are at the end because they are optional
grpc_call *parent_call = NULL;
- if (Call::HasInstance(args[4])) {
- Call *parent_obj = ObjectWrap::Unwrap<Call>(args[4]->ToObject());
+ if (Call::HasInstance(info[4])) {
+ Call *parent_obj = ObjectWrap::Unwrap<Call>(
+ Nan::To<Object>(info[4]).ToLocalChecked());
parent_call = parent_obj->wrapped_call;
- } else if (!(args[4]->IsUndefined() || args[4]->IsNull())) {
- return NanThrowTypeError(
+ } else if (!(info[4]->IsUndefined() || info[4]->IsNull())) {
+ return Nan::ThrowTypeError(
"Call's fifth argument must be another call, if provided");
}
gpr_uint32 propagate_flags = GRPC_PROPAGATE_DEFAULTS;
- if (args[5]->IsUint32()) {
- propagate_flags = args[5]->Uint32Value();
- } else if (!(args[5]->IsUndefined() || args[5]->IsNull())) {
- return NanThrowTypeError(
+ if (info[5]->IsUint32()) {
+ propagate_flags = Nan::To<uint32_t>(info[5]).FromJust();
+ } else if (!(info[5]->IsUndefined() || info[5]->IsNull())) {
+ return Nan::ThrowTypeError(
"Call's sixth argument must be propagate flags, if provided");
}
- Handle<Object> channel_object = args[0]->ToObject();
+ Local<Object> channel_object = Nan::To<Object>(info[0]).ToLocalChecked();
Channel *channel = ObjectWrap::Unwrap<Channel>(channel_object);
if (channel->GetWrappedChannel() == NULL) {
- return NanThrowError("Call cannot be created from a closed channel");
+ return Nan::ThrowError("Call cannot be created from a closed channel");
}
- NanUtf8String method(args[1]);
- double deadline = args[2]->NumberValue();
+ Utf8String method(info[1]);
+ double deadline = Nan::To<double>(info[2]).FromJust();
grpc_channel *wrapped_channel = channel->GetWrappedChannel();
grpc_call *wrapped_call;
- if (args[3]->IsString()) {
- NanUtf8String host_override(args[3]);
+ if (info[3]->IsString()) {
+ Utf8String host_override(info[3]);
wrapped_call = grpc_channel_create_call(
wrapped_channel, parent_call, propagate_flags,
CompletionQueueAsyncWorker::GetQueue(), *method,
*host_override, MillisecondsToTimespec(deadline), NULL);
- } else if (args[3]->IsUndefined() || args[3]->IsNull()) {
+ } else if (info[3]->IsUndefined() || info[3]->IsNull()) {
wrapped_call = grpc_channel_create_call(
wrapped_channel, parent_call, propagate_flags,
CompletionQueueAsyncWorker::GetQueue(), *method,
NULL, MillisecondsToTimespec(deadline), NULL);
} else {
- return NanThrowTypeError("Call's fourth argument must be a string");
+ return Nan::ThrowTypeError("Call's fourth argument must be a string");
}
call = new Call(wrapped_call);
- args.This()->SetHiddenValue(NanNew("channel_"), channel_object);
+ info.This()->SetHiddenValue(Nan::New("channel_").ToLocalChecked(),
+ channel_object);
}
- call->Wrap(args.This());
- NanReturnValue(args.This());
+ call->Wrap(info.This());
+ info.GetReturnValue().Set(info.This());
} else {
const int argc = 4;
- Local<Value> argv[argc] = {args[0], args[1], args[2], args[3]};
- NanReturnValue(constructor->GetFunction()->NewInstance(argc, argv));
+ Local<Value> argv[argc] = {info[0], info[1], info[2], info[3]};
+ MaybeLocal<Object> maybe_instance = constructor->GetFunction()->NewInstance(
+ argc, argv);
+ if (maybe_instance.IsEmpty()) {
+ // There's probably a pending exception
+ return;
+ } else {
+ info.GetReturnValue().Set(maybe_instance.ToLocalChecked());
+ }
}
}
NAN_METHOD(Call::StartBatch) {
- NanScope();
- if (!HasInstance(args.This())) {
- return NanThrowTypeError("startBatch can only be called on Call objects");
+ if (!Call::HasInstance(info.This())) {
+ return Nan::ThrowTypeError("startBatch can only be called on Call objects");
}
- if (!args[0]->IsObject()) {
- return NanThrowError("startBatch's first argument must be an object");
+ if (!info[0]->IsObject()) {
+ return Nan::ThrowError("startBatch's first argument must be an object");
}
- if (!args[1]->IsFunction()) {
- return NanThrowError("startBatch's second argument must be a callback");
+ if (!info[1]->IsFunction()) {
+ return Nan::ThrowError("startBatch's second argument must be a callback");
}
- Handle<Function> callback_func = args[1].As<Function>();
- Call *call = ObjectWrap::Unwrap<Call>(args.This());
+ Local<Function> callback_func = info[1].As<Function>();
+ Call *call = ObjectWrap::Unwrap<Call>(info.This());
shared_ptr<Resources> resources(new Resources);
- Handle<Object> obj = args[0]->ToObject();
- Handle<Array> keys = obj->GetOwnPropertyNames();
+ Local<Object> obj = Nan::To<Object>(info[0]).ToLocalChecked();
+ Local<Array> keys = Nan::GetOwnPropertyNames(obj).ToLocalChecked();
size_t nops = keys->Length();
vector<grpc_op> ops(nops);
unique_ptr<OpVec> op_vector(new OpVec());
for (unsigned int i = 0; i < nops; i++) {
unique_ptr<Op> op;
- if (!keys->Get(i)->IsUint32()) {
- return NanThrowError(
+ MaybeLocal<Value> maybe_key = Nan::Get(keys, i);
+ if (maybe_key.IsEmpty() || (!maybe_key.ToLocalChecked()->IsUint32())) {
+ return Nan::ThrowError(
"startBatch's first argument's keys must be integers");
}
- uint32_t type = keys->Get(i)->Uint32Value();
+ uint32_t type = Nan::To<uint32_t>(maybe_key.ToLocalChecked()).FromJust();
ops[i].op = static_cast<grpc_op_type>(type);
ops[i].flags = 0;
ops[i].reserved = NULL;
@@ -618,67 +664,64 @@ NAN_METHOD(Call::StartBatch) {
op.reset(new ServerCloseResponseOp());
break;
default:
- return NanThrowError("Argument object had an unrecognized key");
+ return Nan::ThrowError("Argument object had an unrecognized key");
}
if (!op->ParseOp(obj->Get(type), &ops[i], resources)) {
- return NanThrowTypeError("Incorrectly typed arguments to startBatch");
+ return Nan::ThrowTypeError("Incorrectly typed arguments to startBatch");
}
op_vector->push_back(std::move(op));
}
- NanCallback *callback = new NanCallback(callback_func);
+ Callback *callback = new Callback(callback_func);
grpc_call_error error = grpc_call_start_batch(
call->wrapped_call, &ops[0], nops, new struct tag(
callback, op_vector.release(), resources), NULL);
if (error != GRPC_CALL_OK) {
- return NanThrowError(nanErrorWithCode("startBatch failed", error));
+ return Nan::ThrowError(nanErrorWithCode("startBatch failed", error));
}
CompletionQueueAsyncWorker::Next();
- NanReturnUndefined();
}
NAN_METHOD(Call::Cancel) {
- NanScope();
- if (!HasInstance(args.This())) {
- return NanThrowTypeError("cancel can only be called on Call objects");
+ if (!Call::HasInstance(info.This())) {
+ return Nan::ThrowTypeError("cancel can only be called on Call objects");
}
- Call *call = ObjectWrap::Unwrap<Call>(args.This());
+ Call *call = ObjectWrap::Unwrap<Call>(info.This());
grpc_call_error error = grpc_call_cancel(call->wrapped_call, NULL);
if (error != GRPC_CALL_OK) {
- return NanThrowError(nanErrorWithCode("cancel failed", error));
+ return Nan::ThrowError(nanErrorWithCode("cancel failed", error));
}
- NanReturnUndefined();
}
NAN_METHOD(Call::CancelWithStatus) {
- NanScope();
- if (!HasInstance(args.This())) {
- return NanThrowTypeError("cancel can only be called on Call objects");
+ Nan::HandleScope scope;
+ if (!HasInstance(info.This())) {
+ return Nan::ThrowTypeError("cancel can only be called on Call objects");
}
- if (!args[0]->IsUint32()) {
- return NanThrowTypeError(
+ if (!info[0]->IsUint32()) {
+ return Nan::ThrowTypeError(
"cancelWithStatus's first argument must be a status code");
}
- if (!args[1]->IsString()) {
- return NanThrowTypeError(
+ if (!info[1]->IsString()) {
+ return Nan::ThrowTypeError(
"cancelWithStatus's second argument must be a string");
}
- Call *call = ObjectWrap::Unwrap<Call>(args.This());
- grpc_status_code code = static_cast<grpc_status_code>(args[0]->Uint32Value());
- NanUtf8String details(args[0]);
+ Call *call = ObjectWrap::Unwrap<Call>(info.This());
+ grpc_status_code code = static_cast<grpc_status_code>(
+ Nan::To<uint32_t>(info[0]).FromJust());
+ Utf8String details(info[0]);
grpc_call_cancel_with_status(call->wrapped_call, code, *details, NULL);
- NanReturnUndefined();
}
NAN_METHOD(Call::GetPeer) {
- NanScope();
- if (!HasInstance(args.This())) {
- return NanThrowTypeError("getPeer can only be called on Call objects");
+ Nan::HandleScope scope;
+ if (!HasInstance(info.This())) {
+ return Nan::ThrowTypeError("getPeer can only be called on Call objects");
}
- Call *call = ObjectWrap::Unwrap<Call>(args.This());
+ Call *call = ObjectWrap::Unwrap<Call>(info.This());
char *peer = grpc_call_get_peer(call->wrapped_call);
- Handle<Value> peer_value = NanNew(peer);
+ Local<Value> peer_value = Nan::New(peer).ToLocalChecked();
gpr_free(peer);
- NanReturnValue(peer_value);
+ info.GetReturnValue().Set(peer_value);
}
} // namespace node
diff --git a/src/node/ext/call.h b/src/node/ext/call.h
index a01f03489e..2f8e1f17aa 100644
--- a/src/node/ext/call.h
+++ b/src/node/ext/call.h
@@ -51,6 +51,8 @@ namespace node {
using std::unique_ptr;
using std::shared_ptr;
+typedef Nan::Persistent<v8::Value, Nan::CopyablePersistentTraits<v8::Value>> PersistentValue;
+
/**
* Helper function for throwing errors with a grpc_call_error value.
* Modified from the answer by Gus Goose to
@@ -58,41 +60,26 @@ using std::shared_ptr;
*/
inline v8::Local<v8::Value> nanErrorWithCode(const char *msg,
grpc_call_error code) {
- NanEscapableScope();
- v8::Local<v8::Object> err = NanError(msg).As<v8::Object>();
- err->Set(NanNew("code"), NanNew<v8::Uint32>(code));
- return NanEscapeScope(err);
+ Nan::EscapableHandleScope scope;
+ v8::Local<v8::Object> err = Nan::Error(msg).As<v8::Object>();
+ Nan::Set(err, Nan::New("code").ToLocalChecked(), Nan::New<v8::Uint32>(code));
+ return scope.Escape(err);
}
-v8::Handle<v8::Value> ParseMetadata(const grpc_metadata_array *metadata_array);
-
-class PersistentHolder {
- public:
- explicit PersistentHolder(v8::Persistent<v8::Value> *persist) :
- persist(persist) {
- }
-
- ~PersistentHolder() {
- NanDisposePersistent(*persist);
- delete persist;
- }
-
- private:
- v8::Persistent<v8::Value> *persist;
-};
+v8::Local<v8::Value> ParseMetadata(const grpc_metadata_array *metadata_array);
struct Resources {
- std::vector<unique_ptr<NanUtf8String> > strings;
- std::vector<unique_ptr<PersistentHolder> > handles;
+ std::vector<unique_ptr<Nan::Utf8String> > strings;
+ std::vector<unique_ptr<PersistentValue> > handles;
};
class Op {
public:
- virtual ~Op();
- virtual v8::Handle<v8::Value> GetNodeValue() const = 0;
- virtual bool ParseOp(v8::Handle<v8::Value> value, grpc_op *out,
+ virtual v8::Local<v8::Value> GetNodeValue() const = 0;
+ virtual bool ParseOp(v8::Local<v8::Value> value, grpc_op *out,
shared_ptr<Resources> resources) = 0;
- v8::Handle<v8::Value> GetOpType() const;
+ virtual ~Op();
+ v8::Local<v8::Value> GetOpType() const;
protected:
virtual std::string GetTypeString() const = 0;
@@ -100,27 +87,27 @@ class Op {
typedef std::vector<unique_ptr<Op>> OpVec;
struct tag {
- tag(NanCallback *callback, OpVec *ops,
+ tag(Nan::Callback *callback, OpVec *ops,
shared_ptr<Resources> resources);
~tag();
- NanCallback *callback;
+ Nan::Callback *callback;
OpVec *ops;
shared_ptr<Resources> resources;
};
-v8::Handle<v8::Value> GetTagNodeValue(void *tag);
+v8::Local<v8::Value> GetTagNodeValue(void *tag);
-NanCallback *GetTagCallback(void *tag);
+Nan::Callback *GetTagCallback(void *tag);
void DestroyTag(void *tag);
/* Wrapper class for grpc_call structs. */
-class Call : public ::node::ObjectWrap {
+class Call : public Nan::ObjectWrap {
public:
- static void Init(v8::Handle<v8::Object> exports);
- static bool HasInstance(v8::Handle<v8::Value> val);
+ static void Init(v8::Local<v8::Object> exports);
+ static bool HasInstance(v8::Local<v8::Value> val);
/* Wrap a grpc_call struct in a javascript object */
- static v8::Handle<v8::Value> WrapStruct(grpc_call *call);
+ static v8::Local<v8::Value> WrapStruct(grpc_call *call);
private:
explicit Call(grpc_call *call);
@@ -135,9 +122,9 @@ class Call : public ::node::ObjectWrap {
static NAN_METHOD(Cancel);
static NAN_METHOD(CancelWithStatus);
static NAN_METHOD(GetPeer);
- static NanCallback *constructor;
+ static Nan::Callback *constructor;
// Used for typechecking instances of this javascript class
- static v8::Persistent<v8::FunctionTemplate> fun_tpl;
+ static Nan::Persistent<v8::FunctionTemplate> fun_tpl;
grpc_call *wrapped_call;
};
diff --git a/src/node/ext/channel.cc b/src/node/ext/channel.cc
index 9aed96bbf5..6eb1e77688 100644
--- a/src/node/ext/channel.cc
+++ b/src/node/ext/channel.cc
@@ -48,21 +48,27 @@
namespace grpc {
namespace node {
+using Nan::Callback;
+using Nan::EscapableHandleScope;
+using Nan::HandleScope;
+using Nan::Maybe;
+using Nan::MaybeLocal;
+using Nan::ObjectWrap;
+using Nan::Persistent;
+using Nan::Utf8String;
+
using v8::Array;
using v8::Exception;
using v8::Function;
using v8::FunctionTemplate;
-using v8::Handle;
-using v8::HandleScope;
using v8::Integer;
using v8::Local;
using v8::Number;
using v8::Object;
-using v8::Persistent;
using v8::String;
using v8::Value;
-NanCallback *Channel::constructor;
+Callback *Channel::constructor;
Persistent<FunctionTemplate> Channel::fun_tpl;
Channel::Channel(grpc_channel *channel) : wrapped_channel(channel) {}
@@ -73,88 +79,89 @@ Channel::~Channel() {
}
}
-void Channel::Init(Handle<Object> exports) {
- NanScope();
- Local<FunctionTemplate> tpl = NanNew<FunctionTemplate>(New);
- tpl->SetClassName(NanNew("Channel"));
+void Channel::Init(Local<Object> exports) {
+ Nan::HandleScope scope;
+ Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(New);
+ tpl->SetClassName(Nan::New("Channel").ToLocalChecked());
tpl->InstanceTemplate()->SetInternalFieldCount(1);
- NanSetPrototypeTemplate(tpl, "close",
- NanNew<FunctionTemplate>(Close)->GetFunction());
- NanSetPrototypeTemplate(tpl, "getTarget",
- NanNew<FunctionTemplate>(GetTarget)->GetFunction());
- NanSetPrototypeTemplate(
- tpl, "getConnectivityState",
- NanNew<FunctionTemplate>(GetConnectivityState)->GetFunction());
- NanSetPrototypeTemplate(
- tpl, "watchConnectivityState",
- NanNew<FunctionTemplate>(WatchConnectivityState)->GetFunction());
- NanAssignPersistent(fun_tpl, tpl);
- Handle<Function> ctr = tpl->GetFunction();
- constructor = new NanCallback(ctr);
- exports->Set(NanNew("Channel"), ctr);
+ Nan::SetPrototypeMethod(tpl, "close", Close);
+ Nan::SetPrototypeMethod(tpl, "getTarget", GetTarget);
+ Nan::SetPrototypeMethod(tpl, "getConnectivityState", GetConnectivityState);
+ Nan::SetPrototypeMethod(tpl, "watchConnectivityState",
+ WatchConnectivityState);
+ fun_tpl.Reset(tpl);
+ Local<Function> ctr = Nan::GetFunction(tpl).ToLocalChecked();
+ Nan::Set(exports, Nan::New("Channel").ToLocalChecked(), ctr);
+ constructor = new Callback(ctr);
}
-bool Channel::HasInstance(Handle<Value> val) {
- NanScope();
- return NanHasInstance(fun_tpl, val);
+bool Channel::HasInstance(Local<Value> val) {
+ HandleScope scope;
+ return Nan::New(fun_tpl)->HasInstance(val);
}
grpc_channel *Channel::GetWrappedChannel() { return this->wrapped_channel; }
NAN_METHOD(Channel::New) {
- NanScope();
-
- if (args.IsConstructCall()) {
- if (!args[0]->IsString()) {
- return NanThrowTypeError(
+ if (info.IsConstructCall()) {
+ if (!info[0]->IsString()) {
+ return Nan::ThrowTypeError(
"Channel expects a string, a credential and an object");
}
grpc_channel *wrapped_channel;
// Owned by the Channel object
- NanUtf8String host(args[0]);
+ Utf8String host(info[0]);
grpc_credentials *creds;
- if (!Credentials::HasInstance(args[1])) {
- return NanThrowTypeError(
+ if (!Credentials::HasInstance(info[1])) {
+ return Nan::ThrowTypeError(
"Channel's second argument must be a credential");
}
Credentials *creds_object = ObjectWrap::Unwrap<Credentials>(
- args[1]->ToObject());
+ Nan::To<Object>(info[1]).ToLocalChecked());
creds = creds_object->GetWrappedCredentials();
grpc_channel_args *channel_args_ptr;
- if (args[2]->IsUndefined()) {
+ if (info[2]->IsUndefined()) {
channel_args_ptr = NULL;
wrapped_channel = grpc_insecure_channel_create(*host, NULL, NULL);
- } else if (args[2]->IsObject()) {
- Handle<Object> args_hash(args[2]->ToObject()->Clone());
- Handle<Array> keys(args_hash->GetOwnPropertyNames());
+ } else if (info[2]->IsObject()) {
+ Local<Object> args_hash = Nan::To<Object>(info[2]).ToLocalChecked();
+ Local<Array> keys(Nan::GetOwnPropertyNames(args_hash).ToLocalChecked());
grpc_channel_args channel_args;
channel_args.num_args = keys->Length();
channel_args.args = reinterpret_cast<grpc_arg *>(
calloc(channel_args.num_args, sizeof(grpc_arg)));
/* These are used to keep all strings until then end of the block, then
destroy them */
- std::vector<NanUtf8String *> key_strings(keys->Length());
- std::vector<NanUtf8String *> value_strings(keys->Length());
+ std::vector<Nan::Utf8String *> key_strings(keys->Length());
+ std::vector<Nan::Utf8String *> value_strings(keys->Length());
for (unsigned int i = 0; i < channel_args.num_args; i++) {
- Handle<String> current_key(keys->Get(i)->ToString());
- Handle<Value> current_value(args_hash->Get(current_key));
- key_strings[i] = new NanUtf8String(current_key);
+ MaybeLocal<String> maybe_key = Nan::To<String>(
+ Nan::Get(keys, i).ToLocalChecked());
+ if (maybe_key.IsEmpty()) {
+ free(channel_args.args);
+ return Nan::ThrowTypeError("Arg keys must be strings");
+ }
+ Local<String> current_key = maybe_key.ToLocalChecked();
+ Local<Value> current_value = Nan::Get(args_hash,
+ current_key).ToLocalChecked();
+ key_strings[i] = new Nan::Utf8String(current_key);
channel_args.args[i].key = **key_strings[i];
if (current_value->IsInt32()) {
channel_args.args[i].type = GRPC_ARG_INTEGER;
- channel_args.args[i].value.integer = current_value->Int32Value();
+ channel_args.args[i].value.integer = Nan::To<int32_t>(
+ current_value).FromJust();
} else if (current_value->IsString()) {
channel_args.args[i].type = GRPC_ARG_STRING;
- value_strings[i] = new NanUtf8String(current_value);
+ value_strings[i] = new Nan::Utf8String(current_value);
channel_args.args[i].value.string = **value_strings[i];
} else {
free(channel_args.args);
- return NanThrowTypeError("Arg values must be strings");
+ return Nan::ThrowTypeError("Arg values must be strings");
}
}
channel_args_ptr = &channel_args;
} else {
- return NanThrowTypeError("Channel expects a string and an object");
+ return Nan::ThrowTypeError("Channel expects a string and an object");
}
if (creds == NULL) {
wrapped_channel = grpc_insecure_channel_create(*host, channel_args_ptr,
@@ -167,73 +174,79 @@ NAN_METHOD(Channel::New) {
free(channel_args_ptr->args);
}
Channel *channel = new Channel(wrapped_channel);
- channel->Wrap(args.This());
- NanReturnValue(args.This());
+ channel->Wrap(info.This());
+ info.GetReturnValue().Set(info.This());
+ return;
} else {
const int argc = 3;
- Local<Value> argv[argc] = {args[0], args[1], args[2]};
- NanReturnValue(constructor->GetFunction()->NewInstance(argc, argv));
+ Local<Value> argv[argc] = {info[0], info[1], info[2]};
+ MaybeLocal<Object> maybe_instance = constructor->GetFunction()->NewInstance(
+ argc, argv);
+ if (maybe_instance.IsEmpty()) {
+ // There's probably a pending exception
+ return;
+ } else {
+ info.GetReturnValue().Set(maybe_instance.ToLocalChecked());
+ }
}
}
NAN_METHOD(Channel::Close) {
- NanScope();
- if (!HasInstance(args.This())) {
- return NanThrowTypeError("close can only be called on Channel objects");
+ if (!HasInstance(info.This())) {
+ return Nan::ThrowTypeError("close can only be called on Channel objects");
}
- Channel *channel = ObjectWrap::Unwrap<Channel>(args.This());
+ Channel *channel = ObjectWrap::Unwrap<Channel>(info.This());
if (channel->wrapped_channel != NULL) {
grpc_channel_destroy(channel->wrapped_channel);
channel->wrapped_channel = NULL;
}
- NanReturnUndefined();
}
NAN_METHOD(Channel::GetTarget) {
- NanScope();
- if (!HasInstance(args.This())) {
- return NanThrowTypeError("getTarget can only be called on Channel objects");
+ if (!HasInstance(info.This())) {
+ return Nan::ThrowTypeError("getTarget can only be called on Channel objects");
}
- Channel *channel = ObjectWrap::Unwrap<Channel>(args.This());
- NanReturnValue(NanNew(grpc_channel_get_target(channel->wrapped_channel)));
+ Channel *channel = ObjectWrap::Unwrap<Channel>(info.This());
+ info.GetReturnValue().Set(Nan::New(
+ grpc_channel_get_target(channel->wrapped_channel)).ToLocalChecked());
}
NAN_METHOD(Channel::GetConnectivityState) {
- NanScope();
- if (!HasInstance(args.This())) {
- return NanThrowTypeError(
+ if (!HasInstance(info.This())) {
+ return Nan::ThrowTypeError(
"getConnectivityState can only be called on Channel objects");
}
- Channel *channel = ObjectWrap::Unwrap<Channel>(args.This());
- int try_to_connect = (int)args[0]->Equals(NanTrue());
- NanReturnValue(grpc_channel_check_connectivity_state(channel->wrapped_channel,
- try_to_connect));
+ Channel *channel = ObjectWrap::Unwrap<Channel>(info.This());
+ int try_to_connect = (int)info[0]->Equals(Nan::True());
+ info.GetReturnValue().Set(
+ grpc_channel_check_connectivity_state(channel->wrapped_channel,
+ try_to_connect));
}
NAN_METHOD(Channel::WatchConnectivityState) {
- NanScope();
- if (!HasInstance(args.This())) {
- return NanThrowTypeError(
+ if (!HasInstance(info.This())) {
+ return Nan::ThrowTypeError(
"watchConnectivityState can only be called on Channel objects");
}
- if (!args[0]->IsUint32()) {
- return NanThrowTypeError(
+ if (!info[0]->IsUint32()) {
+ return Nan::ThrowTypeError(
"watchConnectivityState's first argument must be a channel state");
}
- if (!(args[1]->IsNumber() || args[1]->IsDate())) {
- return NanThrowTypeError(
+ if (!(info[1]->IsNumber() || info[1]->IsDate())) {
+ return Nan::ThrowTypeError(
"watchConnectivityState's second argument must be a date or a number");
}
- if (!args[2]->IsFunction()) {
- return NanThrowTypeError(
+ if (!info[2]->IsFunction()) {
+ return Nan::ThrowTypeError(
"watchConnectivityState's third argument must be a callback");
}
grpc_connectivity_state last_state =
- static_cast<grpc_connectivity_state>(args[0]->Uint32Value());
- double deadline = args[1]->NumberValue();
- Handle<Function> callback_func = args[2].As<Function>();
- NanCallback *callback = new NanCallback(callback_func);
- Channel *channel = ObjectWrap::Unwrap<Channel>(args.This());
+ static_cast<grpc_connectivity_state>(
+ Nan::To<uint32_t>(info[0]).FromJust());
+ double deadline = Nan::To<double>(info[1]).FromJust();
+ Local<Function> callback_func = info[2].As<Function>();
+ Nan::Callback *callback = new Callback(callback_func);
+ Channel *channel = ObjectWrap::Unwrap<Channel>(info.This());
unique_ptr<OpVec> ops(new OpVec());
grpc_channel_watch_connectivity_state(
channel->wrapped_channel, last_state, MillisecondsToTimespec(deadline),
@@ -242,7 +255,6 @@ NAN_METHOD(Channel::WatchConnectivityState) {
ops.release(),
shared_ptr<Resources>(nullptr)));
CompletionQueueAsyncWorker::Next();
- NanReturnUndefined();
}
} // namespace node
diff --git a/src/node/ext/channel.h b/src/node/ext/channel.h
index 458f71d093..0062fd03f4 100644
--- a/src/node/ext/channel.h
+++ b/src/node/ext/channel.h
@@ -42,10 +42,10 @@ namespace grpc {
namespace node {
/* Wrapper class for grpc_channel structs */
-class Channel : public ::node::ObjectWrap {
+class Channel : public Nan::ObjectWrap {
public:
- static void Init(v8::Handle<v8::Object> exports);
- static bool HasInstance(v8::Handle<v8::Value> val);
+ static void Init(v8::Local<v8::Object> exports);
+ static bool HasInstance(v8::Local<v8::Value> val);
/* This is used to typecheck javascript objects before converting them to
this type */
static v8::Persistent<v8::Value> prototype;
@@ -66,8 +66,8 @@ class Channel : public ::node::ObjectWrap {
static NAN_METHOD(GetTarget);
static NAN_METHOD(GetConnectivityState);
static NAN_METHOD(WatchConnectivityState);
- static NanCallback *constructor;
- static v8::Persistent<v8::FunctionTemplate> fun_tpl;
+ static Nan::Callback *constructor;
+ static Nan::Persistent<v8::FunctionTemplate> fun_tpl;
grpc_channel *wrapped_channel;
};
diff --git a/src/node/ext/completion_queue_async_worker.cc b/src/node/ext/completion_queue_async_worker.cc
index bf2cd946a5..3a79f7c45d 100644
--- a/src/node/ext/completion_queue_async_worker.cc
+++ b/src/node/ext/completion_queue_async_worker.cc
@@ -46,9 +46,8 @@ namespace node {
const int max_queue_threads = 2;
using v8::Function;
-using v8::Handle;
+using v8::Local;
using v8::Object;
-using v8::Persistent;
using v8::Value;
grpc_completion_queue *CompletionQueueAsyncWorker::queue;
@@ -57,7 +56,7 @@ int CompletionQueueAsyncWorker::current_threads;
int CompletionQueueAsyncWorker::waiting_next_calls;
CompletionQueueAsyncWorker::CompletionQueueAsyncWorker()
- : NanAsyncWorker(NULL) {}
+ : Nan::AsyncWorker(NULL) {}
CompletionQueueAsyncWorker::~CompletionQueueAsyncWorker() {}
@@ -72,42 +71,42 @@ void CompletionQueueAsyncWorker::Execute() {
grpc_completion_queue *CompletionQueueAsyncWorker::GetQueue() { return queue; }
void CompletionQueueAsyncWorker::Next() {
- NanScope();
+ Nan::HandleScope scope;
if (current_threads < max_queue_threads) {
CompletionQueueAsyncWorker *worker = new CompletionQueueAsyncWorker();
- NanAsyncQueueWorker(worker);
+ Nan::AsyncQueueWorker(worker);
} else {
waiting_next_calls += 1;
}
}
-void CompletionQueueAsyncWorker::Init(Handle<Object> exports) {
- NanScope();
+void CompletionQueueAsyncWorker::Init(Local<Object> exports) {
+ Nan::HandleScope scope;
current_threads = 0;
waiting_next_calls = 0;
queue = grpc_completion_queue_create(NULL);
}
void CompletionQueueAsyncWorker::HandleOKCallback() {
- NanScope();
+ Nan::HandleScope scope;
if (waiting_next_calls > 0) {
waiting_next_calls -= 1;
CompletionQueueAsyncWorker *worker = new CompletionQueueAsyncWorker();
- NanAsyncQueueWorker(worker);
+ Nan::AsyncQueueWorker(worker);
} else {
current_threads -= 1;
}
- NanCallback *callback = GetTagCallback(result.tag);
- Handle<Value> argv[] = {NanNull(), GetTagNodeValue(result.tag)};
+ Nan::Callback *callback = GetTagCallback(result.tag);
+ Local<Value> argv[] = {Nan::Null(), GetTagNodeValue(result.tag)};
callback->Call(2, argv);
DestroyTag(result.tag);
}
void CompletionQueueAsyncWorker::HandleErrorCallback() {
- NanScope();
- NanCallback *callback = GetTagCallback(result.tag);
- Handle<Value> argv[] = {NanError(ErrorMessage())};
+ Nan::HandleScope scope;
+ Nan::Callback *callback = GetTagCallback(result.tag);
+ Local<Value> argv[] = {Nan::Error(ErrorMessage())};
callback->Call(1, argv);
diff --git a/src/node/ext/completion_queue_async_worker.h b/src/node/ext/completion_queue_async_worker.h
index 27fedf2fce..6e54116765 100644
--- a/src/node/ext/completion_queue_async_worker.h
+++ b/src/node/ext/completion_queue_async_worker.h
@@ -42,7 +42,7 @@ namespace node {
/* A worker that asynchronously calls completion_queue_next, and queues onto the
node event loop a call to the function stored in the event's tag. */
-class CompletionQueueAsyncWorker : public NanAsyncWorker {
+class CompletionQueueAsyncWorker : public Nan::AsyncWorker {
public:
CompletionQueueAsyncWorker();
@@ -59,7 +59,7 @@ class CompletionQueueAsyncWorker : public NanAsyncWorker {
static void Next();
/* Initialize the CompletionQueueAsyncWorker class */
- static void Init(v8::Handle<v8::Object> exports);
+ static void Init(v8::Local<v8::Object> exports);
protected:
/* Called when Execute has succeeded (completed without setting an error
diff --git a/src/node/ext/credentials.cc b/src/node/ext/credentials.cc
index c3b04dcea7..4f41c92f6a 100644
--- a/src/node/ext/credentials.cc
+++ b/src/node/ext/credentials.cc
@@ -41,20 +41,26 @@
namespace grpc {
namespace node {
+using Nan::Callback;
+using Nan::EscapableHandleScope;
+using Nan::HandleScope;
+using Nan::Maybe;
+using Nan::MaybeLocal;
+using Nan::ObjectWrap;
+using Nan::Persistent;
+using Nan::Utf8String;
+
using v8::Exception;
using v8::External;
using v8::Function;
using v8::FunctionTemplate;
-using v8::Handle;
-using v8::HandleScope;
using v8::Integer;
using v8::Local;
using v8::Object;
using v8::ObjectTemplate;
-using v8::Persistent;
using v8::Value;
-NanCallback *Credentials::constructor;
+Nan::Callback *Credentials::constructor;
Persistent<FunctionTemplate> Credentials::fun_tpl;
Credentials::Credentials(grpc_credentials *credentials)
@@ -64,40 +70,52 @@ Credentials::~Credentials() {
grpc_credentials_release(wrapped_credentials);
}
-void Credentials::Init(Handle<Object> exports) {
- NanScope();
- Local<FunctionTemplate> tpl = NanNew<FunctionTemplate>(New);
- tpl->SetClassName(NanNew("Credentials"));
+void Credentials::Init(Local<Object> exports) {
+ HandleScope scope;
+ Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(New);
+ tpl->SetClassName(Nan::New("Credentials").ToLocalChecked());
tpl->InstanceTemplate()->SetInternalFieldCount(1);
- NanAssignPersistent(fun_tpl, tpl);
- Handle<Function> ctr = tpl->GetFunction();
- ctr->Set(NanNew("createDefault"),
- NanNew<FunctionTemplate>(CreateDefault)->GetFunction());
- ctr->Set(NanNew("createSsl"),
- NanNew<FunctionTemplate>(CreateSsl)->GetFunction());
- ctr->Set(NanNew("createComposite"),
- NanNew<FunctionTemplate>(CreateComposite)->GetFunction());
- ctr->Set(NanNew("createGce"),
- NanNew<FunctionTemplate>(CreateGce)->GetFunction());
- ctr->Set(NanNew("createIam"),
- NanNew<FunctionTemplate>(CreateIam)->GetFunction());
- ctr->Set(NanNew("createInsecure"),
- NanNew<FunctionTemplate>(CreateInsecure)->GetFunction());
- constructor = new NanCallback(ctr);
- exports->Set(NanNew("Credentials"), ctr);
+ fun_tpl.Reset(tpl);
+ Local<Function> ctr = Nan::GetFunction(tpl).ToLocalChecked();
+ Nan::Set(ctr, Nan::New("createDefault").ToLocalChecked(),
+ Nan::GetFunction(
+ Nan::New<FunctionTemplate>(CreateDefault)).ToLocalChecked());
+ Nan::Set(ctr, Nan::New("createSsl").ToLocalChecked(),
+ Nan::GetFunction(
+ Nan::New<FunctionTemplate>(CreateSsl)).ToLocalChecked());
+ Nan::Set(ctr, Nan::New("createComposite").ToLocalChecked(),
+ Nan::GetFunction(
+ Nan::New<FunctionTemplate>(CreateComposite)).ToLocalChecked());
+ Nan::Set(ctr, Nan::New("createGce").ToLocalChecked(),
+ Nan::GetFunction(
+ Nan::New<FunctionTemplate>(CreateGce)).ToLocalChecked());
+ Nan::Set(ctr, Nan::New("createIam").ToLocalChecked(),
+ Nan::GetFunction(
+ Nan::New<FunctionTemplate>(CreateIam)).ToLocalChecked());
+ Nan::Set(ctr, Nan::New("createInsecure").ToLocalChecked(),
+ Nan::GetFunction(
+ Nan::New<FunctionTemplate>(CreateInsecure)).ToLocalChecked());
+ Nan::Set(exports, Nan::New("Credentials").ToLocalChecked(), ctr);
+ constructor = new Nan::Callback(ctr);
}
-bool Credentials::HasInstance(Handle<Value> val) {
- NanScope();
- return NanHasInstance(fun_tpl, val);
+bool Credentials::HasInstance(Local<Value> val) {
+ HandleScope scope;
+ return Nan::New(fun_tpl)->HasInstance(val);
}
-Handle<Value> Credentials::WrapStruct(grpc_credentials *credentials) {
- NanEscapableScope();
+Local<Value> Credentials::WrapStruct(grpc_credentials *credentials) {
+ EscapableHandleScope scope;
const int argc = 1;
- Handle<Value> argv[argc] = {
- NanNew<External>(reinterpret_cast<void *>(credentials))};
- return NanEscapeScope(constructor->GetFunction()->NewInstance(argc, argv));
+ Local<Value> argv[argc] = {
+ Nan::New<External>(reinterpret_cast<void *>(credentials))};
+ MaybeLocal<Object> maybe_instance = Nan::NewInstance(
+ constructor->GetFunction(), argc, argv);
+ if (maybe_instance.IsEmpty()) {
+ return scope.Escape(Nan::Null());
+ } else {
+ return scope.Escape(maybe_instance.ToLocalChecked());
+ }
}
grpc_credentials *Credentials::GetWrappedCredentials() {
@@ -105,115 +123,123 @@ grpc_credentials *Credentials::GetWrappedCredentials() {
}
NAN_METHOD(Credentials::New) {
- NanScope();
-
- if (args.IsConstructCall()) {
- if (!args[0]->IsExternal()) {
- return NanThrowTypeError(
+ if (info.IsConstructCall()) {
+ if (!info[0]->IsExternal()) {
+ return Nan::ThrowTypeError(
"Credentials can only be created with the provided functions");
}
- Handle<External> ext = args[0].As<External>();
+ Local<External> ext = info[0].As<External>();
grpc_credentials *creds_value =
reinterpret_cast<grpc_credentials *>(ext->Value());
Credentials *credentials = new Credentials(creds_value);
- credentials->Wrap(args.This());
- NanReturnValue(args.This());
+ credentials->Wrap(info.This());
+ info.GetReturnValue().Set(info.This());
+ return;
} else {
const int argc = 1;
- Local<Value> argv[argc] = {args[0]};
- NanReturnValue(constructor->GetFunction()->NewInstance(argc, argv));
+ Local<Value> argv[argc] = {info[0]};
+ MaybeLocal<Object> maybe_instance = constructor->GetFunction()->NewInstance(
+ argc, argv);
+ if (maybe_instance.IsEmpty()) {
+ // There's probably a pending exception
+ return;
+ } else {
+ info.GetReturnValue().Set(maybe_instance.ToLocalChecked());
+ }
}
}
NAN_METHOD(Credentials::CreateDefault) {
- NanScope();
grpc_credentials *creds = grpc_google_default_credentials_create();
if (creds == NULL) {
- NanReturnNull();
+ info.GetReturnValue().SetNull();
+ } else {
+ info.GetReturnValue().Set(WrapStruct(creds));
}
- NanReturnValue(WrapStruct(creds));
}
NAN_METHOD(Credentials::CreateSsl) {
- NanScope();
char *root_certs = NULL;
grpc_ssl_pem_key_cert_pair key_cert_pair = {NULL, NULL};
- if (::node::Buffer::HasInstance(args[0])) {
- root_certs = ::node::Buffer::Data(args[0]);
- } else if (!(args[0]->IsNull() || args[0]->IsUndefined())) {
- return NanThrowTypeError("createSsl's first argument must be a Buffer");
+ if (::node::Buffer::HasInstance(info[0])) {
+ root_certs = ::node::Buffer::Data(info[0]);
+ } else if (!(info[0]->IsNull() || info[0]->IsUndefined())) {
+ return Nan::ThrowTypeError("createSsl's first argument must be a Buffer");
}
- if (::node::Buffer::HasInstance(args[1])) {
- key_cert_pair.private_key = ::node::Buffer::Data(args[1]);
- } else if (!(args[1]->IsNull() || args[1]->IsUndefined())) {
- return NanThrowTypeError(
+ if (::node::Buffer::HasInstance(info[1])) {
+ key_cert_pair.private_key = ::node::Buffer::Data(info[1]);
+ } else if (!(info[1]->IsNull() || info[1]->IsUndefined())) {
+ return Nan::ThrowTypeError(
"createSSl's second argument must be a Buffer if provided");
}
- if (::node::Buffer::HasInstance(args[2])) {
- key_cert_pair.cert_chain = ::node::Buffer::Data(args[2]);
- } else if (!(args[2]->IsNull() || args[2]->IsUndefined())) {
- return NanThrowTypeError(
+ if (::node::Buffer::HasInstance(info[2])) {
+ key_cert_pair.cert_chain = ::node::Buffer::Data(info[2]);
+ } else if (!(info[2]->IsNull() || info[2]->IsUndefined())) {
+ return Nan::ThrowTypeError(
"createSSl's third argument must be a Buffer if provided");
}
grpc_credentials *creds = grpc_ssl_credentials_create(
root_certs, key_cert_pair.private_key == NULL ? NULL : &key_cert_pair,
NULL);
if (creds == NULL) {
- NanReturnNull();
+ info.GetReturnValue().SetNull();
+ } else {
+ info.GetReturnValue().Set(WrapStruct(creds));
}
- NanReturnValue(WrapStruct(creds));
}
NAN_METHOD(Credentials::CreateComposite) {
- NanScope();
- if (!HasInstance(args[0])) {
- return NanThrowTypeError(
+ if (!HasInstance(info[0])) {
+ return Nan::ThrowTypeError(
"createComposite's first argument must be a Credentials object");
}
- if (!HasInstance(args[1])) {
- return NanThrowTypeError(
+ if (!HasInstance(info[1])) {
+ return Nan::ThrowTypeError(
"createComposite's second argument must be a Credentials object");
}
- Credentials *creds1 = ObjectWrap::Unwrap<Credentials>(args[0]->ToObject());
- Credentials *creds2 = ObjectWrap::Unwrap<Credentials>(args[1]->ToObject());
+ Credentials *creds1 = ObjectWrap::Unwrap<Credentials>(
+ Nan::To<Object>(info[0]).ToLocalChecked());
+ Credentials *creds2 = ObjectWrap::Unwrap<Credentials>(
+ Nan::To<Object>(info[1]).ToLocalChecked());
grpc_credentials *creds = grpc_composite_credentials_create(
creds1->wrapped_credentials, creds2->wrapped_credentials, NULL);
if (creds == NULL) {
- NanReturnNull();
+ info.GetReturnValue().SetNull();
+ } else {
+ info.GetReturnValue().Set(WrapStruct(creds));
}
- NanReturnValue(WrapStruct(creds));
}
NAN_METHOD(Credentials::CreateGce) {
- NanScope();
+ Nan::HandleScope scope;
grpc_credentials *creds = grpc_google_compute_engine_credentials_create(NULL);
if (creds == NULL) {
- NanReturnNull();
+ info.GetReturnValue().SetNull();
+ } else {
+ info.GetReturnValue().Set(WrapStruct(creds));
}
- NanReturnValue(WrapStruct(creds));
}
NAN_METHOD(Credentials::CreateIam) {
- NanScope();
- if (!args[0]->IsString()) {
- return NanThrowTypeError("createIam's first argument must be a string");
+ if (!info[0]->IsString()) {
+ return Nan::ThrowTypeError("createIam's first argument must be a string");
}
- if (!args[1]->IsString()) {
- return NanThrowTypeError("createIam's second argument must be a string");
+ if (!info[1]->IsString()) {
+ return Nan::ThrowTypeError("createIam's second argument must be a string");
}
- NanUtf8String auth_token(args[0]);
- NanUtf8String auth_selector(args[1]);
+ Utf8String auth_token(info[0]);
+ Utf8String auth_selector(info[1]);
grpc_credentials *creds =
grpc_google_iam_credentials_create(*auth_token, *auth_selector, NULL);
if (creds == NULL) {
- NanReturnNull();
+ info.GetReturnValue().SetNull();
+ } else {
+ info.GetReturnValue().Set(WrapStruct(creds));
}
- NanReturnValue(WrapStruct(creds));
}
NAN_METHOD(Credentials::CreateInsecure) {
- NanScope();
- NanReturnValue(WrapStruct(NULL));
+ info.GetReturnValue().Set(WrapStruct(NULL));
}
} // namespace node
diff --git a/src/node/ext/credentials.h b/src/node/ext/credentials.h
index 62957e61c3..1b211175d4 100644
--- a/src/node/ext/credentials.h
+++ b/src/node/ext/credentials.h
@@ -43,12 +43,12 @@ namespace grpc {
namespace node {
/* Wrapper class for grpc_credentials structs */
-class Credentials : public ::node::ObjectWrap {
+class Credentials : public Nan::ObjectWrap {
public:
- static void Init(v8::Handle<v8::Object> exports);
- static bool HasInstance(v8::Handle<v8::Value> val);
+ static void Init(v8::Local<v8::Object> exports);
+ static bool HasInstance(v8::Local<v8::Value> val);
/* Wrap a grpc_credentials struct in a javascript object */
- static v8::Handle<v8::Value> WrapStruct(grpc_credentials *credentials);
+ static v8::Local<v8::Value> WrapStruct(grpc_credentials *credentials);
/* Returns the grpc_credentials struct that this object wraps */
grpc_credentials *GetWrappedCredentials();
@@ -69,9 +69,9 @@ class Credentials : public ::node::ObjectWrap {
static NAN_METHOD(CreateFake);
static NAN_METHOD(CreateIam);
static NAN_METHOD(CreateInsecure);
- static NanCallback *constructor;
+ static Nan::Callback *constructor;
// Used for typechecking instances of this javascript class
- static v8::Persistent<v8::FunctionTemplate> fun_tpl;
+ static Nan::Persistent<v8::FunctionTemplate> fun_tpl;
grpc_credentials *wrapped_credentials;
};
diff --git a/src/node/ext/node_grpc.cc b/src/node/ext/node_grpc.cc
index 0cf30da922..caca0fc452 100644
--- a/src/node/ext/node_grpc.cc
+++ b/src/node/ext/node_grpc.cc
@@ -43,171 +43,194 @@
#include "credentials.h"
#include "server_credentials.h"
-using v8::Handle;
+using v8::Local;
using v8::Value;
using v8::Object;
using v8::Uint32;
using v8::String;
-void InitStatusConstants(Handle<Object> exports) {
- NanScope();
- Handle<Object> status = NanNew<Object>();
- exports->Set(NanNew("status"), status);
- Handle<Value> OK(NanNew<Uint32, uint32_t>(GRPC_STATUS_OK));
- status->Set(NanNew("OK"), OK);
- Handle<Value> CANCELLED(NanNew<Uint32, uint32_t>(GRPC_STATUS_CANCELLED));
- status->Set(NanNew("CANCELLED"), CANCELLED);
- Handle<Value> UNKNOWN(NanNew<Uint32, uint32_t>(GRPC_STATUS_UNKNOWN));
- status->Set(NanNew("UNKNOWN"), UNKNOWN);
- Handle<Value> INVALID_ARGUMENT(
- NanNew<Uint32, uint32_t>(GRPC_STATUS_INVALID_ARGUMENT));
- status->Set(NanNew("INVALID_ARGUMENT"), INVALID_ARGUMENT);
- Handle<Value> DEADLINE_EXCEEDED(
- NanNew<Uint32, uint32_t>(GRPC_STATUS_DEADLINE_EXCEEDED));
- status->Set(NanNew("DEADLINE_EXCEEDED"), DEADLINE_EXCEEDED);
- Handle<Value> NOT_FOUND(NanNew<Uint32, uint32_t>(GRPC_STATUS_NOT_FOUND));
- status->Set(NanNew("NOT_FOUND"), NOT_FOUND);
- Handle<Value> ALREADY_EXISTS(
- NanNew<Uint32, uint32_t>(GRPC_STATUS_ALREADY_EXISTS));
- status->Set(NanNew("ALREADY_EXISTS"), ALREADY_EXISTS);
- Handle<Value> PERMISSION_DENIED(
- NanNew<Uint32, uint32_t>(GRPC_STATUS_PERMISSION_DENIED));
- status->Set(NanNew("PERMISSION_DENIED"), PERMISSION_DENIED);
- Handle<Value> UNAUTHENTICATED(
- NanNew<Uint32, uint32_t>(GRPC_STATUS_UNAUTHENTICATED));
- status->Set(NanNew("UNAUTHENTICATED"), UNAUTHENTICATED);
- Handle<Value> RESOURCE_EXHAUSTED(
- NanNew<Uint32, uint32_t>(GRPC_STATUS_RESOURCE_EXHAUSTED));
- status->Set(NanNew("RESOURCE_EXHAUSTED"), RESOURCE_EXHAUSTED);
- Handle<Value> FAILED_PRECONDITION(
- NanNew<Uint32, uint32_t>(GRPC_STATUS_FAILED_PRECONDITION));
- status->Set(NanNew("FAILED_PRECONDITION"), FAILED_PRECONDITION);
- Handle<Value> ABORTED(NanNew<Uint32, uint32_t>(GRPC_STATUS_ABORTED));
- status->Set(NanNew("ABORTED"), ABORTED);
- Handle<Value> OUT_OF_RANGE(
- NanNew<Uint32, uint32_t>(GRPC_STATUS_OUT_OF_RANGE));
- status->Set(NanNew("OUT_OF_RANGE"), OUT_OF_RANGE);
- Handle<Value> UNIMPLEMENTED(
- NanNew<Uint32, uint32_t>(GRPC_STATUS_UNIMPLEMENTED));
- status->Set(NanNew("UNIMPLEMENTED"), UNIMPLEMENTED);
- Handle<Value> INTERNAL(NanNew<Uint32, uint32_t>(GRPC_STATUS_INTERNAL));
- status->Set(NanNew("INTERNAL"), INTERNAL);
- Handle<Value> UNAVAILABLE(NanNew<Uint32, uint32_t>(GRPC_STATUS_UNAVAILABLE));
- status->Set(NanNew("UNAVAILABLE"), UNAVAILABLE);
- Handle<Value> DATA_LOSS(NanNew<Uint32, uint32_t>(GRPC_STATUS_DATA_LOSS));
- status->Set(NanNew("DATA_LOSS"), DATA_LOSS);
+void InitStatusConstants(Local<Object> exports) {
+ Nan::HandleScope scope;
+ Local<Object> status = Nan::New<Object>();
+ Nan::Set(exports, Nan::New("status").ToLocalChecked(), status);
+ Local<Value> OK(Nan::New<Uint32, uint32_t>(GRPC_STATUS_OK));
+ Nan::Set(status, Nan::New("OK").ToLocalChecked(), OK);
+ Local<Value> CANCELLED(Nan::New<Uint32, uint32_t>(GRPC_STATUS_CANCELLED));
+ Nan::Set(status, Nan::New("CANCELLED").ToLocalChecked(), CANCELLED);
+ Local<Value> UNKNOWN(Nan::New<Uint32, uint32_t>(GRPC_STATUS_UNKNOWN));
+ Nan::Set(status, Nan::New("UNKNOWN").ToLocalChecked(), UNKNOWN);
+ Local<Value> INVALID_ARGUMENT(
+ Nan::New<Uint32, uint32_t>(GRPC_STATUS_INVALID_ARGUMENT));
+ Nan::Set(status, Nan::New("INVALID_ARGUMENT").ToLocalChecked(),
+ INVALID_ARGUMENT);
+ Local<Value> DEADLINE_EXCEEDED(
+ Nan::New<Uint32, uint32_t>(GRPC_STATUS_DEADLINE_EXCEEDED));
+ Nan::Set(status, Nan::New("DEADLINE_EXCEEDED").ToLocalChecked(),
+ DEADLINE_EXCEEDED);
+ Local<Value> NOT_FOUND(Nan::New<Uint32, uint32_t>(GRPC_STATUS_NOT_FOUND));
+ Nan::Set(status, Nan::New("NOT_FOUND").ToLocalChecked(), NOT_FOUND);
+ Local<Value> ALREADY_EXISTS(
+ Nan::New<Uint32, uint32_t>(GRPC_STATUS_ALREADY_EXISTS));
+ Nan::Set(status, Nan::New("ALREADY_EXISTS").ToLocalChecked(), ALREADY_EXISTS);
+ Local<Value> PERMISSION_DENIED(
+ Nan::New<Uint32, uint32_t>(GRPC_STATUS_PERMISSION_DENIED));
+ Nan::Set(status, Nan::New("PERMISSION_DENIED").ToLocalChecked(),
+ PERMISSION_DENIED);
+ Local<Value> UNAUTHENTICATED(
+ Nan::New<Uint32, uint32_t>(GRPC_STATUS_UNAUTHENTICATED));
+ Nan::Set(status, Nan::New("UNAUTHENTICATED").ToLocalChecked(),
+ UNAUTHENTICATED);
+ Local<Value> RESOURCE_EXHAUSTED(
+ Nan::New<Uint32, uint32_t>(GRPC_STATUS_RESOURCE_EXHAUSTED));
+ Nan::Set(status, Nan::New("RESOURCE_EXHAUSTED").ToLocalChecked(),
+ RESOURCE_EXHAUSTED);
+ Local<Value> FAILED_PRECONDITION(
+ Nan::New<Uint32, uint32_t>(GRPC_STATUS_FAILED_PRECONDITION));
+ Nan::Set(status, Nan::New("FAILED_PRECONDITION").ToLocalChecked(),
+ FAILED_PRECONDITION);
+ Local<Value> ABORTED(Nan::New<Uint32, uint32_t>(GRPC_STATUS_ABORTED));
+ Nan::Set(status, Nan::New("ABORTED").ToLocalChecked(), ABORTED);
+ Local<Value> OUT_OF_RANGE(
+ Nan::New<Uint32, uint32_t>(GRPC_STATUS_OUT_OF_RANGE));
+ Nan::Set(status, Nan::New("OUT_OF_RANGE").ToLocalChecked(), OUT_OF_RANGE);
+ Local<Value> UNIMPLEMENTED(
+ Nan::New<Uint32, uint32_t>(GRPC_STATUS_UNIMPLEMENTED));
+ Nan::Set(status, Nan::New("UNIMPLEMENTED").ToLocalChecked(), UNIMPLEMENTED);
+ Local<Value> INTERNAL(Nan::New<Uint32, uint32_t>(GRPC_STATUS_INTERNAL));
+ Nan::Set(status, Nan::New("INTERNAL").ToLocalChecked(), INTERNAL);
+ Local<Value> UNAVAILABLE(Nan::New<Uint32, uint32_t>(GRPC_STATUS_UNAVAILABLE));
+ Nan::Set(status, Nan::New("UNAVAILABLE").ToLocalChecked(), UNAVAILABLE);
+ Local<Value> DATA_LOSS(Nan::New<Uint32, uint32_t>(GRPC_STATUS_DATA_LOSS));
+ Nan::Set(status, Nan::New("DATA_LOSS").ToLocalChecked(), DATA_LOSS);
}
-void InitCallErrorConstants(Handle<Object> exports) {
- NanScope();
- Handle<Object> call_error = NanNew<Object>();
- exports->Set(NanNew("callError"), call_error);
- Handle<Value> OK(NanNew<Uint32, uint32_t>(GRPC_CALL_OK));
- call_error->Set(NanNew("OK"), OK);
- Handle<Value> ERROR(NanNew<Uint32, uint32_t>(GRPC_CALL_ERROR));
- call_error->Set(NanNew("ERROR"), ERROR);
- Handle<Value> NOT_ON_SERVER(
- NanNew<Uint32, uint32_t>(GRPC_CALL_ERROR_NOT_ON_SERVER));
- call_error->Set(NanNew("NOT_ON_SERVER"), NOT_ON_SERVER);
- Handle<Value> NOT_ON_CLIENT(
- NanNew<Uint32, uint32_t>(GRPC_CALL_ERROR_NOT_ON_CLIENT));
- call_error->Set(NanNew("NOT_ON_CLIENT"), NOT_ON_CLIENT);
- Handle<Value> ALREADY_INVOKED(
- NanNew<Uint32, uint32_t>(GRPC_CALL_ERROR_ALREADY_INVOKED));
- call_error->Set(NanNew("ALREADY_INVOKED"), ALREADY_INVOKED);
- Handle<Value> NOT_INVOKED(
- NanNew<Uint32, uint32_t>(GRPC_CALL_ERROR_NOT_INVOKED));
- call_error->Set(NanNew("NOT_INVOKED"), NOT_INVOKED);
- Handle<Value> ALREADY_FINISHED(
- NanNew<Uint32, uint32_t>(GRPC_CALL_ERROR_ALREADY_FINISHED));
- call_error->Set(NanNew("ALREADY_FINISHED"), ALREADY_FINISHED);
- Handle<Value> TOO_MANY_OPERATIONS(
- NanNew<Uint32, uint32_t>(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS));
- call_error->Set(NanNew("TOO_MANY_OPERATIONS"), TOO_MANY_OPERATIONS);
- Handle<Value> INVALID_FLAGS(
- NanNew<Uint32, uint32_t>(GRPC_CALL_ERROR_INVALID_FLAGS));
- call_error->Set(NanNew("INVALID_FLAGS"), INVALID_FLAGS);
+void InitCallErrorConstants(Local<Object> exports) {
+ Nan::HandleScope scope;
+ Local<Object> call_error = Nan::New<Object>();
+ Nan::Set(exports, Nan::New("callError").ToLocalChecked(), call_error);
+ Local<Value> OK(Nan::New<Uint32, uint32_t>(GRPC_CALL_OK));
+ Nan::Set(call_error, Nan::New("OK").ToLocalChecked(), OK);
+ Local<Value> ERROR(Nan::New<Uint32, uint32_t>(GRPC_CALL_ERROR));
+ Nan::Set(call_error, Nan::New("ERROR").ToLocalChecked(), ERROR);
+ Local<Value> NOT_ON_SERVER(
+ Nan::New<Uint32, uint32_t>(GRPC_CALL_ERROR_NOT_ON_SERVER));
+ Nan::Set(call_error, Nan::New("NOT_ON_SERVER").ToLocalChecked(),
+ NOT_ON_SERVER);
+ Local<Value> NOT_ON_CLIENT(
+ Nan::New<Uint32, uint32_t>(GRPC_CALL_ERROR_NOT_ON_CLIENT));
+ Nan::Set(call_error, Nan::New("NOT_ON_CLIENT").ToLocalChecked(),
+ NOT_ON_CLIENT);
+ Local<Value> ALREADY_INVOKED(
+ Nan::New<Uint32, uint32_t>(GRPC_CALL_ERROR_ALREADY_INVOKED));
+ Nan::Set(call_error, Nan::New("ALREADY_INVOKED").ToLocalChecked(),
+ ALREADY_INVOKED);
+ Local<Value> NOT_INVOKED(
+ Nan::New<Uint32, uint32_t>(GRPC_CALL_ERROR_NOT_INVOKED));
+ Nan::Set(call_error, Nan::New("NOT_INVOKED").ToLocalChecked(), NOT_INVOKED);
+ Local<Value> ALREADY_FINISHED(
+ Nan::New<Uint32, uint32_t>(GRPC_CALL_ERROR_ALREADY_FINISHED));
+ Nan::Set(call_error, Nan::New("ALREADY_FINISHED").ToLocalChecked(),
+ ALREADY_FINISHED);
+ Local<Value> TOO_MANY_OPERATIONS(
+ Nan::New<Uint32, uint32_t>(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS));
+ Nan::Set(call_error, Nan::New("TOO_MANY_OPERATIONS").ToLocalChecked(),
+ TOO_MANY_OPERATIONS);
+ Local<Value> INVALID_FLAGS(
+ Nan::New<Uint32, uint32_t>(GRPC_CALL_ERROR_INVALID_FLAGS));
+ Nan::Set(call_error, Nan::New("INVALID_FLAGS").ToLocalChecked(),
+ INVALID_FLAGS);
}
-void InitOpTypeConstants(Handle<Object> exports) {
- NanScope();
- Handle<Object> op_type = NanNew<Object>();
- exports->Set(NanNew("opType"), op_type);
- Handle<Value> SEND_INITIAL_METADATA(
- NanNew<Uint32, uint32_t>(GRPC_OP_SEND_INITIAL_METADATA));
- op_type->Set(NanNew("SEND_INITIAL_METADATA"), SEND_INITIAL_METADATA);
- Handle<Value> SEND_MESSAGE(
- NanNew<Uint32, uint32_t>(GRPC_OP_SEND_MESSAGE));
- op_type->Set(NanNew("SEND_MESSAGE"), SEND_MESSAGE);
- Handle<Value> SEND_CLOSE_FROM_CLIENT(
- NanNew<Uint32, uint32_t>(GRPC_OP_SEND_CLOSE_FROM_CLIENT));
- op_type->Set(NanNew("SEND_CLOSE_FROM_CLIENT"), SEND_CLOSE_FROM_CLIENT);
- Handle<Value> SEND_STATUS_FROM_SERVER(
- NanNew<Uint32, uint32_t>(GRPC_OP_SEND_STATUS_FROM_SERVER));
- op_type->Set(NanNew("SEND_STATUS_FROM_SERVER"), SEND_STATUS_FROM_SERVER);
- Handle<Value> RECV_INITIAL_METADATA(
- NanNew<Uint32, uint32_t>(GRPC_OP_RECV_INITIAL_METADATA));
- op_type->Set(NanNew("RECV_INITIAL_METADATA"), RECV_INITIAL_METADATA);
- Handle<Value> RECV_MESSAGE(
- NanNew<Uint32, uint32_t>(GRPC_OP_RECV_MESSAGE));
- op_type->Set(NanNew("RECV_MESSAGE"), RECV_MESSAGE);
- Handle<Value> RECV_STATUS_ON_CLIENT(
- NanNew<Uint32, uint32_t>(GRPC_OP_RECV_STATUS_ON_CLIENT));
- op_type->Set(NanNew("RECV_STATUS_ON_CLIENT"), RECV_STATUS_ON_CLIENT);
- Handle<Value> RECV_CLOSE_ON_SERVER(
- NanNew<Uint32, uint32_t>(GRPC_OP_RECV_CLOSE_ON_SERVER));
- op_type->Set(NanNew("RECV_CLOSE_ON_SERVER"), RECV_CLOSE_ON_SERVER);
+void InitOpTypeConstants(Local<Object> exports) {
+ Nan::HandleScope scope;
+ Local<Object> op_type = Nan::New<Object>();
+ Nan::Set(exports, Nan::New("opType").ToLocalChecked(), op_type);
+ Local<Value> SEND_INITIAL_METADATA(
+ Nan::New<Uint32, uint32_t>(GRPC_OP_SEND_INITIAL_METADATA));
+ Nan::Set(op_type, Nan::New("SEND_INITIAL_METADATA").ToLocalChecked(),
+ SEND_INITIAL_METADATA);
+ Local<Value> SEND_MESSAGE(
+ Nan::New<Uint32, uint32_t>(GRPC_OP_SEND_MESSAGE));
+ Nan::Set(op_type, Nan::New("SEND_MESSAGE").ToLocalChecked(), SEND_MESSAGE);
+ Local<Value> SEND_CLOSE_FROM_CLIENT(
+ Nan::New<Uint32, uint32_t>(GRPC_OP_SEND_CLOSE_FROM_CLIENT));
+ Nan::Set(op_type, Nan::New("SEND_CLOSE_FROM_CLIENT").ToLocalChecked(),
+ SEND_CLOSE_FROM_CLIENT);
+ Local<Value> SEND_STATUS_FROM_SERVER(
+ Nan::New<Uint32, uint32_t>(GRPC_OP_SEND_STATUS_FROM_SERVER));
+ Nan::Set(op_type, Nan::New("SEND_STATUS_FROM_SERVER").ToLocalChecked(),
+ SEND_STATUS_FROM_SERVER);
+ Local<Value> RECV_INITIAL_METADATA(
+ Nan::New<Uint32, uint32_t>(GRPC_OP_RECV_INITIAL_METADATA));
+ Nan::Set(op_type, Nan::New("RECV_INITIAL_METADATA").ToLocalChecked(),
+ RECV_INITIAL_METADATA);
+ Local<Value> RECV_MESSAGE(
+ Nan::New<Uint32, uint32_t>(GRPC_OP_RECV_MESSAGE));
+ Nan::Set(op_type, Nan::New("RECV_MESSAGE").ToLocalChecked(), RECV_MESSAGE);
+ Local<Value> RECV_STATUS_ON_CLIENT(
+ Nan::New<Uint32, uint32_t>(GRPC_OP_RECV_STATUS_ON_CLIENT));
+ Nan::Set(op_type, Nan::New("RECV_STATUS_ON_CLIENT").ToLocalChecked(),
+ RECV_STATUS_ON_CLIENT);
+ Local<Value> RECV_CLOSE_ON_SERVER(
+ Nan::New<Uint32, uint32_t>(GRPC_OP_RECV_CLOSE_ON_SERVER));
+ Nan::Set(op_type, Nan::New("RECV_CLOSE_ON_SERVER").ToLocalChecked(),
+ RECV_CLOSE_ON_SERVER);
}
-void InitPropagateConstants(Handle<Object> exports) {
- NanScope();
- Handle<Object> propagate = NanNew<Object>();
- exports->Set(NanNew("propagate"), propagate);
- Handle<Value> DEADLINE(NanNew<Uint32, uint32_t>(GRPC_PROPAGATE_DEADLINE));
- propagate->Set(NanNew("DEADLINE"), DEADLINE);
- Handle<Value> CENSUS_STATS_CONTEXT(
- NanNew<Uint32, uint32_t>(GRPC_PROPAGATE_CENSUS_STATS_CONTEXT));
- propagate->Set(NanNew("CENSUS_STATS_CONTEXT"), CENSUS_STATS_CONTEXT);
- Handle<Value> CENSUS_TRACING_CONTEXT(
- NanNew<Uint32, uint32_t>(GRPC_PROPAGATE_CENSUS_TRACING_CONTEXT));
- propagate->Set(NanNew("CENSUS_TRACING_CONTEXT"), CENSUS_TRACING_CONTEXT);
- Handle<Value> CANCELLATION(
- NanNew<Uint32, uint32_t>(GRPC_PROPAGATE_CANCELLATION));
- propagate->Set(NanNew("CANCELLATION"), CANCELLATION);
- Handle<Value> DEFAULTS(NanNew<Uint32, uint32_t>(GRPC_PROPAGATE_DEFAULTS));
- propagate->Set(NanNew("DEFAULTS"), DEFAULTS);
+void InitPropagateConstants(Local<Object> exports) {
+ Nan::HandleScope scope;
+ Local<Object> propagate = Nan::New<Object>();
+ Nan::Set(exports, Nan::New("propagate").ToLocalChecked(), propagate);
+ Local<Value> DEADLINE(Nan::New<Uint32, uint32_t>(GRPC_PROPAGATE_DEADLINE));
+ Nan::Set(propagate, Nan::New("DEADLINE").ToLocalChecked(), DEADLINE);
+ Local<Value> CENSUS_STATS_CONTEXT(
+ Nan::New<Uint32, uint32_t>(GRPC_PROPAGATE_CENSUS_STATS_CONTEXT));
+ Nan::Set(propagate, Nan::New("CENSUS_STATS_CONTEXT").ToLocalChecked(),
+ CENSUS_STATS_CONTEXT);
+ Local<Value> CENSUS_TRACING_CONTEXT(
+ Nan::New<Uint32, uint32_t>(GRPC_PROPAGATE_CENSUS_TRACING_CONTEXT));
+ Nan::Set(propagate, Nan::New("CENSUS_TRACING_CONTEXT").ToLocalChecked(),
+ CENSUS_TRACING_CONTEXT);
+ Local<Value> CANCELLATION(
+ Nan::New<Uint32, uint32_t>(GRPC_PROPAGATE_CANCELLATION));
+ Nan::Set(propagate, Nan::New("CANCELLATION").ToLocalChecked(), CANCELLATION);
+ Local<Value> DEFAULTS(Nan::New<Uint32, uint32_t>(GRPC_PROPAGATE_DEFAULTS));
+ Nan::Set(propagate, Nan::New("DEFAULTS").ToLocalChecked(), DEFAULTS);
}
-void InitConnectivityStateConstants(Handle<Object> exports) {
- NanScope();
- Handle<Object> channel_state = NanNew<Object>();
- exports->Set(NanNew("connectivityState"), channel_state);
- Handle<Value> IDLE(NanNew<Uint32, uint32_t>(GRPC_CHANNEL_IDLE));
- channel_state->Set(NanNew("IDLE"), IDLE);
- Handle<Value> CONNECTING(NanNew<Uint32, uint32_t>(GRPC_CHANNEL_CONNECTING));
- channel_state->Set(NanNew("CONNECTING"), CONNECTING);
- Handle<Value> READY(NanNew<Uint32, uint32_t>(GRPC_CHANNEL_READY));
- channel_state->Set(NanNew("READY"), READY);
- Handle<Value> TRANSIENT_FAILURE(
- NanNew<Uint32, uint32_t>(GRPC_CHANNEL_TRANSIENT_FAILURE));
- channel_state->Set(NanNew("TRANSIENT_FAILURE"), TRANSIENT_FAILURE);
- Handle<Value> FATAL_FAILURE(
- NanNew<Uint32, uint32_t>(GRPC_CHANNEL_FATAL_FAILURE));
- channel_state->Set(NanNew("FATAL_FAILURE"), FATAL_FAILURE);
+void InitConnectivityStateConstants(Local<Object> exports) {
+ Nan::HandleScope scope;
+ Local<Object> channel_state = Nan::New<Object>();
+ Nan::Set(exports, Nan::New("connectivityState").ToLocalChecked(),
+ channel_state);
+ Local<Value> IDLE(Nan::New<Uint32, uint32_t>(GRPC_CHANNEL_IDLE));
+ Nan::Set(channel_state, Nan::New("IDLE").ToLocalChecked(), IDLE);
+ Local<Value> CONNECTING(Nan::New<Uint32, uint32_t>(GRPC_CHANNEL_CONNECTING));
+ Nan::Set(channel_state, Nan::New("CONNECTING").ToLocalChecked(), CONNECTING);
+ Local<Value> READY(Nan::New<Uint32, uint32_t>(GRPC_CHANNEL_READY));
+ Nan::Set(channel_state, Nan::New("READY").ToLocalChecked(), READY);
+ Local<Value> TRANSIENT_FAILURE(
+ Nan::New<Uint32, uint32_t>(GRPC_CHANNEL_TRANSIENT_FAILURE));
+ Nan::Set(channel_state, Nan::New("TRANSIENT_FAILURE").ToLocalChecked(),
+ TRANSIENT_FAILURE);
+ Local<Value> FATAL_FAILURE(
+ Nan::New<Uint32, uint32_t>(GRPC_CHANNEL_FATAL_FAILURE));
+ Nan::Set(channel_state, Nan::New("FATAL_FAILURE").ToLocalChecked(),
+ FATAL_FAILURE);
}
-void InitWriteFlags(Handle<Object> exports) {
- NanScope();
- Handle<Object> write_flags = NanNew<Object>();
- exports->Set(NanNew("writeFlags"), write_flags);
- Handle<Value> BUFFER_HINT(NanNew<Uint32, uint32_t>(GRPC_WRITE_BUFFER_HINT));
- write_flags->Set(NanNew("BUFFER_HINT"), BUFFER_HINT);
- Handle<Value> NO_COMPRESS(NanNew<Uint32, uint32_t>(GRPC_WRITE_NO_COMPRESS));
- write_flags->Set(NanNew("NO_COMPRESS"), NO_COMPRESS);
+void InitWriteFlags(Local<Object> exports) {
+ Nan::HandleScope scope;
+ Local<Object> write_flags = Nan::New<Object>();
+ Nan::Set(exports, Nan::New("writeFlags").ToLocalChecked(), write_flags);
+ Local<Value> BUFFER_HINT(Nan::New<Uint32, uint32_t>(GRPC_WRITE_BUFFER_HINT));
+ Nan::Set(write_flags, Nan::New("BUFFER_HINT").ToLocalChecked(), BUFFER_HINT);
+ Local<Value> NO_COMPRESS(Nan::New<Uint32, uint32_t>(GRPC_WRITE_NO_COMPRESS));
+ Nan::Set(write_flags, Nan::New("NO_COMPRESS").ToLocalChecked(), NO_COMPRESS);
}
-void init(Handle<Object> exports) {
- NanScope();
+void init(Local<Object> exports) {
+ Nan::HandleScope scope;
grpc_init();
InitStatusConstants(exports);
InitCallErrorConstants(exports);
diff --git a/src/node/ext/server.cc b/src/node/ext/server.cc
index 32a8ff55b1..87363fc446 100644
--- a/src/node/ext/server.cc
+++ b/src/node/ext/server.cc
@@ -50,6 +50,15 @@
namespace grpc {
namespace node {
+using Nan::Callback;
+using Nan::EscapableHandleScope;
+using Nan::HandleScope;
+using Nan::Maybe;
+using Nan::MaybeLocal;
+using Nan::ObjectWrap;
+using Nan::Persistent;
+using Nan::Utf8String;
+
using std::unique_ptr;
using v8::Array;
using v8::Boolean;
@@ -57,16 +66,13 @@ using v8::Date;
using v8::Exception;
using v8::Function;
using v8::FunctionTemplate;
-using v8::Handle;
-using v8::HandleScope;
using v8::Local;
using v8::Number;
using v8::Object;
-using v8::Persistent;
using v8::String;
using v8::Value;
-NanCallback *Server::constructor;
+Nan::Callback *Server::constructor;
Persistent<FunctionTemplate> Server::fun_tpl;
class NewCallOp : public Op {
@@ -82,22 +88,26 @@ class NewCallOp : public Op {
grpc_metadata_array_destroy(&request_metadata);
}
- Handle<Value> GetNodeValue() const {
- NanEscapableScope();
+ Local<Value> GetNodeValue() const {
+ Nan::EscapableHandleScope scope;
if (call == NULL) {
- return NanEscapeScope(NanNull());
+ return scope.Escape(Nan::Null());
}
- Handle<Object> obj = NanNew<Object>();
- obj->Set(NanNew("call"), Call::WrapStruct(call));
- obj->Set(NanNew("method"), NanNew(details.method));
- obj->Set(NanNew("host"), NanNew(details.host));
- obj->Set(NanNew("deadline"),
- NanNew<Date>(TimespecToMilliseconds(details.deadline)));
- obj->Set(NanNew("metadata"), ParseMetadata(&request_metadata));
- return NanEscapeScope(obj);
+ Local<Object> obj = Nan::New<Object>();
+ Nan::Set(obj, Nan::New("call").ToLocalChecked(), Call::WrapStruct(call));
+ Nan::Set(obj, Nan::New("method").ToLocalChecked(),
+ Nan::New(details.method).ToLocalChecked());
+ Nan::Set(obj, Nan::New("host").ToLocalChecked(),
+ Nan::New(details.host).ToLocalChecked());
+ Nan::Set(obj, Nan::New("deadline").ToLocalChecked(),
+ Nan::New<Date>(
+ TimespecToMilliseconds(details.deadline)).ToLocalChecked());
+ Nan::Set(obj, Nan::New("metadata").ToLocalChecked(),
+ ParseMetadata(&request_metadata));
+ return scope.Escape(obj);
}
- bool ParseOp(Handle<Value> value, grpc_op *out,
+ bool ParseOp(Local<Value> value, grpc_op *out,
shared_ptr<Resources> resources) {
return true;
}
@@ -124,35 +134,25 @@ Server::~Server() {
grpc_completion_queue_destroy(this->shutdown_queue);
}
-void Server::Init(Handle<Object> exports) {
- NanScope();
- Local<FunctionTemplate> tpl = NanNew<FunctionTemplate>(New);
- tpl->SetClassName(NanNew("Server"));
+void Server::Init(Local<Object> exports) {
+ HandleScope scope;
+ Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(New);
+ tpl->SetClassName(Nan::New("Server").ToLocalChecked());
tpl->InstanceTemplate()->SetInternalFieldCount(1);
- NanSetPrototypeTemplate(tpl, "requestCall",
- NanNew<FunctionTemplate>(RequestCall)->GetFunction());
-
- NanSetPrototypeTemplate(
- tpl, "addHttp2Port",
- NanNew<FunctionTemplate>(AddHttp2Port)->GetFunction());
-
- NanSetPrototypeTemplate(tpl, "start",
- NanNew<FunctionTemplate>(Start)->GetFunction());
-
- NanSetPrototypeTemplate(tpl, "tryShutdown",
- NanNew<FunctionTemplate>(TryShutdown)->GetFunction());
- NanSetPrototypeTemplate(
- tpl, "forceShutdown",
- NanNew<FunctionTemplate>(ForceShutdown)->GetFunction());
-
- NanAssignPersistent(fun_tpl, tpl);
- Handle<Function> ctr = tpl->GetFunction();
- constructor = new NanCallback(ctr);
- exports->Set(NanNew("Server"), ctr);
+ Nan::SetPrototypeMethod(tpl, "requestCall", RequestCall);
+ Nan::SetPrototypeMethod(tpl, "addHttp2Port", AddHttp2Port);
+ Nan::SetPrototypeMethod(tpl, "start", Start);
+ Nan::SetPrototypeMethod(tpl, "tryShutdown", TryShutdown);
+ Nan::SetPrototypeMethod(tpl, "forceShutdown", ForceShutdown);
+ fun_tpl.Reset(tpl);
+ Local<Function> ctr = Nan::GetFunction(tpl).ToLocalChecked();
+ Nan::Set(exports, Nan::New("Server").ToLocalChecked(), ctr);
+ constructor = new Callback(ctr);
}
-bool Server::HasInstance(Handle<Value> val) {
- return NanHasInstance(fun_tpl, val);
+bool Server::HasInstance(Local<Value> val) {
+ HandleScope scope;
+ return Nan::New(fun_tpl)->HasInstance(val);
}
void Server::ShutdownServer() {
@@ -165,64 +165,77 @@ void Server::ShutdownServer() {
}
NAN_METHOD(Server::New) {
- NanScope();
-
/* If this is not a constructor call, make a constructor call and return
the result */
- if (!args.IsConstructCall()) {
+ if (!info.IsConstructCall()) {
const int argc = 1;
- Local<Value> argv[argc] = {args[0]};
- NanReturnValue(constructor->GetFunction()->NewInstance(argc, argv));
+ Local<Value> argv[argc] = {info[0]};
+ MaybeLocal<Object> maybe_instance = constructor->GetFunction()->NewInstance(
+ argc, argv);
+ if (maybe_instance.IsEmpty()) {
+ // There's probably a pending exception
+ return;
+ } else {
+ info.GetReturnValue().Set(maybe_instance.ToLocalChecked());
+ return;
+ }
}
grpc_server *wrapped_server;
grpc_completion_queue *queue = CompletionQueueAsyncWorker::GetQueue();
- if (args[0]->IsUndefined()) {
+ if (info[0]->IsUndefined()) {
wrapped_server = grpc_server_create(NULL, NULL);
- } else if (args[0]->IsObject()) {
- Handle<Object> args_hash(args[0]->ToObject());
- Handle<Array> keys(args_hash->GetOwnPropertyNames());
+ } else if (info[0]->IsObject()) {
+ Local<Object> args_hash = Nan::To<Object>(info[0]).ToLocalChecked();
+ Local<Array> keys = Nan::GetOwnPropertyNames(args_hash).ToLocalChecked();
grpc_channel_args channel_args;
channel_args.num_args = keys->Length();
channel_args.args = reinterpret_cast<grpc_arg *>(
calloc(channel_args.num_args, sizeof(grpc_arg)));
/* These are used to keep all strings until then end of the block, then
destroy them */
- std::vector<NanUtf8String *> key_strings(keys->Length());
- std::vector<NanUtf8String *> value_strings(keys->Length());
+ std::vector<Utf8String *> key_strings(keys->Length());
+ std::vector<Utf8String *> value_strings(keys->Length());
for (unsigned int i = 0; i < channel_args.num_args; i++) {
- Handle<String> current_key(keys->Get(i)->ToString());
- Handle<Value> current_value(args_hash->Get(current_key));
- key_strings[i] = new NanUtf8String(current_key);
+ MaybeLocal<String> maybe_key = Nan::To<String>(
+ Nan::Get(keys, i).ToLocalChecked());
+ if (maybe_key.IsEmpty()) {
+ free(channel_args.args);
+ return Nan::ThrowTypeError("Arg keys must be strings");
+ }
+ Local<String> current_key = maybe_key.ToLocalChecked();
+ Local<Value> current_value = Nan::Get(args_hash,
+ current_key).ToLocalChecked();
+ key_strings[i] = new Utf8String(current_key);
channel_args.args[i].key = **key_strings[i];
if (current_value->IsInt32()) {
channel_args.args[i].type = GRPC_ARG_INTEGER;
- channel_args.args[i].value.integer = current_value->Int32Value();
+ channel_args.args[i].value.integer = Nan::To<int32_t>(
+ current_value).FromJust();
} else if (current_value->IsString()) {
channel_args.args[i].type = GRPC_ARG_STRING;
- value_strings[i] = new NanUtf8String(current_value);
+ value_strings[i] = new Utf8String(current_value);
channel_args.args[i].value.string = **value_strings[i];
} else {
free(channel_args.args);
- return NanThrowTypeError("Arg values must be strings");
+ return Nan::ThrowTypeError("Arg values must be strings");
}
}
wrapped_server = grpc_server_create(&channel_args, NULL);
free(channel_args.args);
} else {
- return NanThrowTypeError("Server expects an object");
+ return Nan::ThrowTypeError("Server expects an object");
}
grpc_server_register_completion_queue(wrapped_server, queue, NULL);
Server *server = new Server(wrapped_server);
- server->Wrap(args.This());
- NanReturnValue(args.This());
+ server->Wrap(info.This());
+ info.GetReturnValue().Set(info.This());
}
NAN_METHOD(Server::RequestCall) {
- NanScope();
- if (!HasInstance(args.This())) {
- return NanThrowTypeError("requestCall can only be called on a Server");
+ if (!HasInstance(info.This())) {
+ return Nan::ThrowTypeError("requestCall can only be called on a Server");
}
- Server *server = ObjectWrap::Unwrap<Server>(args.This());
+ Server *server = ObjectWrap::Unwrap<Server>(info.This());
NewCallOp *op = new NewCallOp();
unique_ptr<OpVec> ops(new OpVec());
ops->push_back(unique_ptr<Op>(op));
@@ -230,79 +243,74 @@ NAN_METHOD(Server::RequestCall) {
server->wrapped_server, &op->call, &op->details, &op->request_metadata,
CompletionQueueAsyncWorker::GetQueue(),
CompletionQueueAsyncWorker::GetQueue(),
- new struct tag(new NanCallback(args[0].As<Function>()), ops.release(),
+ new struct tag(new Callback(info[0].As<Function>()), ops.release(),
shared_ptr<Resources>(nullptr)));
if (error != GRPC_CALL_OK) {
- return NanThrowError(nanErrorWithCode("requestCall failed", error));
+ return Nan::ThrowError(nanErrorWithCode("requestCall failed", error));
}
CompletionQueueAsyncWorker::Next();
- NanReturnUndefined();
}
NAN_METHOD(Server::AddHttp2Port) {
- NanScope();
- if (!HasInstance(args.This())) {
- return NanThrowTypeError(
+ if (!HasInstance(info.This())) {
+ return Nan::ThrowTypeError(
"addHttp2Port can only be called on a Server");
}
- if (!args[0]->IsString()) {
- return NanThrowTypeError(
+ if (!info[0]->IsString()) {
+ return Nan::ThrowTypeError(
"addHttp2Port's first argument must be a String");
}
- if (!ServerCredentials::HasInstance(args[1])) {
- return NanThrowTypeError(
+ if (!ServerCredentials::HasInstance(info[1])) {
+ return Nan::ThrowTypeError(
"addHttp2Port's second argument must be ServerCredentials");
}
- Server *server = ObjectWrap::Unwrap<Server>(args.This());
+ Server *server = ObjectWrap::Unwrap<Server>(info.This());
ServerCredentials *creds_object = ObjectWrap::Unwrap<ServerCredentials>(
- args[1]->ToObject());
+ Nan::To<Object>(info[1]).ToLocalChecked());
grpc_server_credentials *creds = creds_object->GetWrappedServerCredentials();
int port;
if (creds == NULL) {
port = grpc_server_add_insecure_http2_port(server->wrapped_server,
- *NanUtf8String(args[0]));
+ *Utf8String(info[0]));
} else {
port = grpc_server_add_secure_http2_port(server->wrapped_server,
- *NanUtf8String(args[0]),
+ *Utf8String(info[0]),
creds);
}
- NanReturnValue(NanNew<Number>(port));
+ info.GetReturnValue().Set(Nan::New<Number>(port));
}
NAN_METHOD(Server::Start) {
- NanScope();
- if (!HasInstance(args.This())) {
- return NanThrowTypeError("start can only be called on a Server");
+ Nan::HandleScope scope;
+ if (!HasInstance(info.This())) {
+ return Nan::ThrowTypeError("start can only be called on a Server");
}
- Server *server = ObjectWrap::Unwrap<Server>(args.This());
+ Server *server = ObjectWrap::Unwrap<Server>(info.This());
grpc_server_start(server->wrapped_server);
- NanReturnUndefined();
}
NAN_METHOD(Server::TryShutdown) {
- NanScope();
- if (!HasInstance(args.This())) {
- return NanThrowTypeError("tryShutdown can only be called on a Server");
+ Nan::HandleScope scope;
+ if (!HasInstance(info.This())) {
+ return Nan::ThrowTypeError("tryShutdown can only be called on a Server");
}
- Server *server = ObjectWrap::Unwrap<Server>(args.This());
+ Server *server = ObjectWrap::Unwrap<Server>(info.This());
unique_ptr<OpVec> ops(new OpVec());
grpc_server_shutdown_and_notify(
server->wrapped_server,
CompletionQueueAsyncWorker::GetQueue(),
- new struct tag(new NanCallback(args[0].As<Function>()), ops.release(),
+ new struct tag(new Nan::Callback(info[0].As<Function>()), ops.release(),
shared_ptr<Resources>(nullptr)));
CompletionQueueAsyncWorker::Next();
- NanReturnUndefined();
}
NAN_METHOD(Server::ForceShutdown) {
- NanScope();
- if (!HasInstance(args.This())) {
- return NanThrowTypeError("forceShutdown can only be called on a Server");
+ Nan::HandleScope scope;
+ if (!HasInstance(info.This())) {
+ return Nan::ThrowTypeError("forceShutdown can only be called on a Server");
}
- Server *server = ObjectWrap::Unwrap<Server>(args.This());
+ Server *server = ObjectWrap::Unwrap<Server>(info.This());
server->ShutdownServer();
- NanReturnUndefined();
}
} // namespace node
diff --git a/src/node/ext/server.h b/src/node/ext/server.h
index e7d5c3fb11..ab5fc210e8 100644
--- a/src/node/ext/server.h
+++ b/src/node/ext/server.h
@@ -44,14 +44,14 @@ namespace node {
/* Wraps grpc_server as a JavaScript object. Provides a constructor
and wrapper methods for grpc_server_create, grpc_server_request_call,
grpc_server_add_http2_port, and grpc_server_start. */
-class Server : public ::node::ObjectWrap {
+class Server : public Nan::ObjectWrap {
public:
/* Initializes the Server class and exposes the constructor and
wrapper methods to JavaScript */
- static void Init(v8::Handle<v8::Object> exports);
+ static void Init(v8::Local<v8::Object> exports);
/* Tests whether the given value was constructed by this class's
JavaScript constructor */
- static bool HasInstance(v8::Handle<v8::Value> val);
+ static bool HasInstance(v8::Local<v8::Value> val);
private:
explicit Server(grpc_server *server);
@@ -69,8 +69,8 @@ class Server : public ::node::ObjectWrap {
static NAN_METHOD(Start);
static NAN_METHOD(TryShutdown);
static NAN_METHOD(ForceShutdown);
- static NanCallback *constructor;
- static v8::Persistent<v8::FunctionTemplate> fun_tpl;
+ static Nan::Callback *constructor;
+ static Nan::Persistent<v8::FunctionTemplate> fun_tpl;
grpc_server *wrapped_server;
grpc_completion_queue *shutdown_queue;
diff --git a/src/node/ext/server_credentials.cc b/src/node/ext/server_credentials.cc
index b1201eb664..5e922bd877 100644
--- a/src/node/ext/server_credentials.cc
+++ b/src/node/ext/server_credentials.cc
@@ -41,22 +41,28 @@
namespace grpc {
namespace node {
+using Nan::Callback;
+using Nan::EscapableHandleScope;
+using Nan::HandleScope;
+using Nan::Maybe;
+using Nan::MaybeLocal;
+using Nan::ObjectWrap;
+using Nan::Persistent;
+using Nan::Utf8String;
+
using v8::Array;
using v8::Exception;
using v8::External;
using v8::Function;
using v8::FunctionTemplate;
-using v8::Handle;
-using v8::HandleScope;
using v8::Integer;
using v8::Local;
using v8::Object;
using v8::ObjectTemplate;
-using v8::Persistent;
using v8::String;
using v8::Value;
-NanCallback *ServerCredentials::constructor;
+Nan::Callback *ServerCredentials::constructor;
Persistent<FunctionTemplate> ServerCredentials::fun_tpl;
ServerCredentials::ServerCredentials(grpc_server_credentials *credentials)
@@ -66,33 +72,41 @@ ServerCredentials::~ServerCredentials() {
grpc_server_credentials_release(wrapped_credentials);
}
-void ServerCredentials::Init(Handle<Object> exports) {
- NanScope();
- Local<FunctionTemplate> tpl = NanNew<FunctionTemplate>(New);
- tpl->SetClassName(NanNew("ServerCredentials"));
+void ServerCredentials::Init(Local<Object> exports) {
+ Nan::HandleScope scope;
+ Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(New);
+ tpl->SetClassName(Nan::New("ServerCredentials").ToLocalChecked());
tpl->InstanceTemplate()->SetInternalFieldCount(1);
- NanAssignPersistent(fun_tpl, tpl);
- Handle<Function> ctr = tpl->GetFunction();
- ctr->Set(NanNew("createSsl"),
- NanNew<FunctionTemplate>(CreateSsl)->GetFunction());
- ctr->Set(NanNew("createInsecure"),
- NanNew<FunctionTemplate>(CreateInsecure)->GetFunction());
- constructor = new NanCallback(ctr);
- exports->Set(NanNew("ServerCredentials"), ctr);
+ Local<Function> ctr = tpl->GetFunction();
+ Nan::Set(ctr, Nan::New("createSsl").ToLocalChecked(),
+ Nan::GetFunction(
+ Nan::New<FunctionTemplate>(CreateSsl)).ToLocalChecked());
+ Nan::Set(ctr, Nan::New("createInsecure").ToLocalChecked(),
+ Nan::GetFunction(
+ Nan::New<FunctionTemplate>(CreateInsecure)).ToLocalChecked());
+ fun_tpl.Reset(tpl);
+ constructor = new Nan::Callback(ctr);
+ Nan::Set(exports, Nan::New("ServerCredentials").ToLocalChecked(), ctr);
}
-bool ServerCredentials::HasInstance(Handle<Value> val) {
- NanScope();
- return NanHasInstance(fun_tpl, val);
+bool ServerCredentials::HasInstance(Local<Value> val) {
+ Nan::HandleScope scope;
+ return Nan::New(fun_tpl)->HasInstance(val);
}
-Handle<Value> ServerCredentials::WrapStruct(
+Local<Value> ServerCredentials::WrapStruct(
grpc_server_credentials *credentials) {
- NanEscapableScope();
+ Nan::EscapableHandleScope scope;
const int argc = 1;
- Handle<Value> argv[argc] = {
- NanNew<External>(reinterpret_cast<void *>(credentials))};
- return NanEscapeScope(constructor->GetFunction()->NewInstance(argc, argv));
+ Local<Value> argv[argc] = {
+ Nan::New<External>(reinterpret_cast<void *>(credentials))};
+ MaybeLocal<Object> maybe_instance = Nan::NewInstance(
+ constructor->GetFunction(), argc, argv);
+ if (maybe_instance.IsEmpty()) {
+ return scope.Escape(Nan::Null());
+ } else {
+ return scope.Escape(maybe_instance.ToLocalChecked());
+ }
}
grpc_server_credentials *ServerCredentials::GetWrappedServerCredentials() {
@@ -100,96 +114,103 @@ grpc_server_credentials *ServerCredentials::GetWrappedServerCredentials() {
}
NAN_METHOD(ServerCredentials::New) {
- NanScope();
-
- if (args.IsConstructCall()) {
- if (!args[0]->IsExternal()) {
- return NanThrowTypeError(
+ if (info.IsConstructCall()) {
+ if (!info[0]->IsExternal()) {
+ return Nan::ThrowTypeError(
"ServerCredentials can only be created with the provide functions");
}
- Handle<External> ext = args[0].As<External>();
+ Local<External> ext = info[0].As<External>();
grpc_server_credentials *creds_value =
reinterpret_cast<grpc_server_credentials *>(ext->Value());
ServerCredentials *credentials = new ServerCredentials(creds_value);
- credentials->Wrap(args.This());
- NanReturnValue(args.This());
+ credentials->Wrap(info.This());
+ info.GetReturnValue().Set(info.This());
} else {
const int argc = 1;
- Local<Value> argv[argc] = {args[0]};
- NanReturnValue(constructor->GetFunction()->NewInstance(argc, argv));
+ Local<Value> argv[argc] = {info[0]};
+ MaybeLocal<Object> maybe_instance = constructor->GetFunction()->NewInstance(
+ argc, argv);
+ if (maybe_instance.IsEmpty()) {
+ // There's probably a pending exception
+ return;
+ } else {
+ info.GetReturnValue().Set(maybe_instance.ToLocalChecked());
+ }
}
}
NAN_METHOD(ServerCredentials::CreateSsl) {
- // TODO: have the node API support multiple key/cert pairs.
- NanScope();
+ Nan::HandleScope scope;
char *root_certs = NULL;
- if (::node::Buffer::HasInstance(args[0])) {
- root_certs = ::node::Buffer::Data(args[0]);
- } else if (!(args[0]->IsNull() || args[0]->IsUndefined())) {
- return NanThrowTypeError(
+ if (::node::Buffer::HasInstance(info[0])) {
+ root_certs = ::node::Buffer::Data(info[0]);
+ } else if (!(info[0]->IsNull() || info[0]->IsUndefined())) {
+ return Nan::ThrowTypeError(
"createSSl's first argument must be a Buffer if provided");
}
- if (!args[1]->IsArray()) {
- return NanThrowTypeError(
+ if (!info[1]->IsArray()) {
+ return Nan::ThrowTypeError(
"createSsl's second argument must be a list of objects");
}
int force_client_auth = 0;
- if (args[2]->IsBoolean()) {
- force_client_auth = (int)args[2]->BooleanValue();
- } else if (!(args[2]->IsUndefined() || args[2]->IsNull())) {
- return NanThrowTypeError(
+ if (info[2]->IsBoolean()) {
+ force_client_auth = (int)Nan::To<bool>(info[2]).FromJust();
+ } else if (!(info[2]->IsUndefined() || info[2]->IsNull())) {
+ return Nan::ThrowTypeError(
"createSsl's third argument must be a boolean if provided");
}
- Handle<Array> pair_list = Local<Array>::Cast(args[1]);
+ Local<Array> pair_list = Local<Array>::Cast(info[1]);
uint32_t key_cert_pair_count = pair_list->Length();
grpc_ssl_pem_key_cert_pair *key_cert_pairs = new grpc_ssl_pem_key_cert_pair[
key_cert_pair_count];
- Handle<String> key_key = NanNew("private_key");
- Handle<String> cert_key = NanNew("cert_chain");
+ Local<String> key_key = Nan::New("private_key").ToLocalChecked();
+ Local<String> cert_key = Nan::New("cert_chain").ToLocalChecked();
for(uint32_t i = 0; i < key_cert_pair_count; i++) {
- if (!pair_list->Get(i)->IsObject()) {
+ Local<Value> pair_val = Nan::Get(pair_list, i).ToLocalChecked();
+ if (!pair_val->IsObject()) {
delete key_cert_pairs;
- return NanThrowTypeError("Key/cert pairs must be objects");
+ return Nan::ThrowTypeError("Key/cert pairs must be objects");
}
- Handle<Object> pair_obj = pair_list->Get(i)->ToObject();
- if (!pair_obj->HasOwnProperty(key_key)) {
+ Local<Object> pair_obj = Nan::To<Object>(pair_val).ToLocalChecked();
+ MaybeLocal<Value> maybe_key = Nan::Get(pair_obj, key_key);
+ if (maybe_key.IsEmpty()) {
delete key_cert_pairs;
- return NanThrowTypeError(
+ return Nan::ThrowTypeError(
"Key/cert pairs must have a private_key and a cert_chain");
}
- if (!pair_obj->HasOwnProperty(cert_key)) {
+ MaybeLocal<Value> maybe_cert = Nan::Get(pair_obj, cert_key);
+ if (maybe_cert.IsEmpty()) {
delete key_cert_pairs;
- return NanThrowTypeError(
+ return Nan::ThrowTypeError(
"Key/cert pairs must have a private_key and a cert_chain");
}
- if (!::node::Buffer::HasInstance(pair_obj->Get(key_key))) {
+ if (!::node::Buffer::HasInstance(maybe_key.ToLocalChecked())) {
delete key_cert_pairs;
- return NanThrowTypeError("private_key must be a Buffer");
+ return Nan::ThrowTypeError("private_key must be a Buffer");
}
- if (!::node::Buffer::HasInstance(pair_obj->Get(cert_key))) {
+ if (!::node::Buffer::HasInstance(maybe_cert.ToLocalChecked())) {
delete key_cert_pairs;
- return NanThrowTypeError("cert_chain must be a Buffer");
+ return Nan::ThrowTypeError("cert_chain must be a Buffer");
}
key_cert_pairs[i].private_key = ::node::Buffer::Data(
- pair_obj->Get(key_key));
+ maybe_key.ToLocalChecked());
key_cert_pairs[i].cert_chain = ::node::Buffer::Data(
- pair_obj->Get(cert_key));
+ maybe_cert.ToLocalChecked());
}
grpc_server_credentials *creds = grpc_ssl_server_credentials_create(
root_certs, key_cert_pairs, key_cert_pair_count, force_client_auth, NULL);
delete key_cert_pairs;
if (creds == NULL) {
- NanReturnNull();
+ info.GetReturnValue().SetNull();
+ } else {
+ info.GetReturnValue().Set(WrapStruct(creds));
}
- NanReturnValue(WrapStruct(creds));
}
NAN_METHOD(ServerCredentials::CreateInsecure) {
- NanScope();
- NanReturnValue(WrapStruct(NULL));
+ info.GetReturnValue().Set(WrapStruct(NULL));
}
} // namespace node
diff --git a/src/node/ext/server_credentials.h b/src/node/ext/server_credentials.h
index 63903f663c..bf279e481c 100644
--- a/src/node/ext/server_credentials.h
+++ b/src/node/ext/server_credentials.h
@@ -43,12 +43,12 @@ namespace grpc {
namespace node {
/* Wrapper class for grpc_server_credentials structs */
-class ServerCredentials : public ::node::ObjectWrap {
+class ServerCredentials : public Nan::ObjectWrap {
public:
- static void Init(v8::Handle<v8::Object> exports);
- static bool HasInstance(v8::Handle<v8::Value> val);
+ static void Init(v8::Local<v8::Object> exports);
+ static bool HasInstance(v8::Local<v8::Value> val);
/* Wrap a grpc_server_credentials struct in a javascript object */
- static v8::Handle<v8::Value> WrapStruct(grpc_server_credentials *credentials);
+ static v8::Local<v8::Value> WrapStruct(grpc_server_credentials *credentials);
/* Returns the grpc_server_credentials struct that this object wraps */
grpc_server_credentials *GetWrappedServerCredentials();
@@ -64,9 +64,9 @@ class ServerCredentials : public ::node::ObjectWrap {
static NAN_METHOD(New);
static NAN_METHOD(CreateSsl);
static NAN_METHOD(CreateInsecure);
- static NanCallback *constructor;
+ static Nan::Callback *constructor;
// Used for typechecking instances of this javascript class
- static v8::Persistent<v8::FunctionTemplate> fun_tpl;
+ static Nan::Persistent<v8::FunctionTemplate> fun_tpl;
grpc_server_credentials *wrapped_credentials;
};
diff --git a/src/node/package.json b/src/node/package.json
index ff93e91185..22f94757ce 100644
--- a/src/node/package.json
+++ b/src/node/package.json
@@ -27,7 +27,7 @@
"dependencies": {
"bindings": "^1.2.0",
"lodash": "^3.9.3",
- "nan": "^1.5.0",
+ "nan": "^2.0.0",
"protobufjs": "^4.0.0"
},
"devDependencies": {
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-19 08:09:59 +0000