Chiebot-Mirror
/
grpc
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Update to nan 2.0

Browse Source
pull/3365/head
murgatroid99 10 years ago
parent e8659971a9
commit 2b09783f8a
17 changed files with 893 additions and 773 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      src/node/binding.gyp
  2. 36
      src/node/ext/byte_buffer.cc
  3. 6
      src/node/ext/byte_buffer.h
  4. 445
      src/node/ext/call.cc
  5. 57
      src/node/ext/call.h
  6. 178
      src/node/ext/channel.cc
  7. 10
      src/node/ext/channel.h
  8. 27
      src/node/ext/completion_queue_async_worker.cc
  9. 4
      src/node/ext/completion_queue_async_worker.h
  10. 192
      src/node/ext/credentials.cc
  11. 12
      src/node/ext/credentials.h
  12. 319
      src/node/ext/node_grpc.cc
  13. 202
      src/node/ext/server.cc
  14. 10
      src/node/ext/server.h
  15. 153
      src/node/ext/server_credentials.cc
  16. 12
      src/node/ext/server_credentials.h
  17. 2
      src/node/package.json

1
src/node/binding.gyp
Unescape View File

@ -8,7 +8,6 @@
'-std=c++0x', '-std=c++0x',
'-Wall', '-Wall',
'-pthread', '-pthread',
'-pedantic',
'-g', '-g',
'-zdefs', '-zdefs',
'-Werror', '-Werror',

36
src/node/ext/byte_buffer.cc
Unescape View File

@ -44,15 +44,16 @@
namespace grpc { namespace grpc {
namespace node { namespace node {
using v8::Context; using v8::Context;
using v8::Function; using v8::Function;
using v8::Handle; using v8::Local;
using v8::Object; using v8::Object;
using v8::Number; using v8::Number;
using v8::Value; using v8::Value;
grpc_byte_buffer *BufferToByteBuffer(Handle<Value> buffer) { grpc_byte_buffer *BufferToByteBuffer(Local<Value> buffer) {
NanScope(); Nan::HandleScope scope;
int length = ::node::Buffer::Length(buffer); int length = ::node::Buffer::Length(buffer);
char *data = ::node::Buffer::Data(buffer); char *data = ::node::Buffer::Data(buffer);
gpr_slice slice = gpr_slice_malloc(length); gpr_slice slice = gpr_slice_malloc(length);
@ -62,10 +63,10 @@ grpc_byte_buffer *BufferToByteBuffer(Handle<Value> buffer) {
return byte_buffer; return byte_buffer;
} }
Handle<Value> ByteBufferToBuffer(grpc_byte_buffer *buffer) { Local<Value> ByteBufferToBuffer(grpc_byte_buffer *buffer) {
NanEscapableScope(); Nan::EscapableHandleScope scope;
if (buffer == NULL) { if (buffer == NULL) {
return NanEscapeScope(NanNull()); return scope.Escape(Nan::Null());
} }
size_t length = grpc_byte_buffer_length(buffer); size_t length = grpc_byte_buffer_length(buffer);
char *result = reinterpret_cast<char *>(calloc(length, sizeof(char))); 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)); memcpy(result + offset, GPR_SLICE_START_PTR(next), GPR_SLICE_LENGTH(next));
offset += GPR_SLICE_LENGTH(next); offset += GPR_SLICE_LENGTH(next);
} }
return NanEscapeScope(MakeFastBuffer(NanNewBufferHandle(result, length))); return scope.Escape(MakeFastBuffer(
Nan::NewBuffer(result, length).ToLocalChecked()));
} }
Handle<Value> MakeFastBuffer(Handle<Value> slowBuffer) { Local<Value> MakeFastBuffer(Local<Value> slowBuffer) {
NanEscapableScope(); Nan::EscapableHandleScope scope;
Handle<Object> globalObj = NanGetCurrentContext()->Global(); Local<Object> globalObj = Nan::GetCurrentContext()->Global();
Handle<Function> bufferConstructor = Handle<Function>::Cast( Local<Function> bufferConstructor = Local<Function>::Cast(
globalObj->Get(NanNew("Buffer"))); globalObj->Get(Nan::New("Buffer").ToLocalChecked()));
Handle<Value> consArgs[3] = { Local<Value> consArgs[3] = {
slowBuffer, slowBuffer,
NanNew<Number>(::node::Buffer::Length(slowBuffer)), Nan::New<Number>(::node::Buffer::Length(slowBuffer)),
NanNew<Number>(0) Nan::New<Number>(0)
}; };
Handle<Object> fastBuffer = bufferConstructor->NewInstance(3, consArgs); Local<Object> fastBuffer = bufferConstructor->NewInstance(3, consArgs);
return NanEscapeScope(fastBuffer); return scope.Escape(fastBuffer);
} }
} // namespace node } // namespace node
} // namespace grpc } // namespace grpc

6
src/node/ext/byte_buffer.h
Unescape View File

@ -45,14 +45,14 @@ namespace node {
/* Convert a Node.js Buffer to grpc_byte_buffer. Requires that /* Convert a Node.js Buffer to grpc_byte_buffer. Requires that
::node::Buffer::HasInstance(buffer) */ ::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 */ /* 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 /* Convert a ::node::Buffer to a fast Buffer, as defined in the Node
Buffer documentation */ 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 node
} // namespace grpc } // namespace grpc

445
src/node/ext/call.cc
Unescape View File

@ -54,52 +54,61 @@ using std::vector;
namespace grpc { namespace grpc {
namespace node { 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::Array;
using v8::Boolean; using v8::Boolean;
using v8::Exception; using v8::Exception;
using v8::External; using v8::External;
using v8::Function; using v8::Function;
using v8::FunctionTemplate; using v8::FunctionTemplate;
using v8::Handle;
using v8::HandleScope;
using v8::Integer; using v8::Integer;
using v8::Local; using v8::Local;
using v8::Number; using v8::Number;
using v8::Object; using v8::Object;
using v8::ObjectTemplate; using v8::ObjectTemplate;
using v8::Persistent;
using v8::Uint32; using v8::Uint32;
using v8::String; using v8::String;
using v8::Value; using v8::Value;
NanCallback *Call::constructor; Callback *Call::constructor;
Persistent<FunctionTemplate> Call::fun_tpl; Persistent<FunctionTemplate> Call::fun_tpl;
bool EndsWith(const char *str, const char *substr) { bool EndsWith(const char *str, const char *substr) {
return strcmp(str+strlen(str)-strlen(substr), substr) == 0; 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) { shared_ptr<Resources> resources) {
NanScope(); HandleScope scope;
grpc_metadata_array_init(array); 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++) { for (unsigned int i = 0; i < keys->Length(); i++) {
Handle<String> current_key(keys->Get(i)->ToString()); Local<String> current_key = Nan::To<String>(
if (!metadata->Get(current_key)->IsArray()) { Nan::Get(keys, i).ToLocalChecked()).ToLocalChecked();
Local<Value> value_array = Nan::Get(metadata, current_key).ToLocalChecked();
if (!value_array->IsArray()) {
return false; 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*>( array->metadata = reinterpret_cast<grpc_metadata*>(
gpr_malloc(array->capacity * sizeof(grpc_metadata))); gpr_malloc(array->capacity * sizeof(grpc_metadata)));
for (unsigned int i = 0; i < keys->Length(); i++) { for (unsigned int i = 0; i < keys->Length(); i++) {
Handle<String> current_key(keys->Get(i)->ToString()); Local<String> current_key(keys->Get(i)->ToString());
NanUtf8String *utf8_key = new NanUtf8String(current_key); Utf8String *utf8_key = new Utf8String(current_key);
resources->strings.push_back(unique_ptr<NanUtf8String>(utf8_key)); resources->strings.push_back(unique_ptr<Utf8String>(utf8_key));
Handle<Array> values = Local<Array>::Cast(metadata->Get(current_key)); Local<Array> values = Local<Array>::Cast(
Nan::Get(metadata, current_key).ToLocalChecked());
for (unsigned int j = 0; j < values->Length(); j++) { 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]; grpc_metadata *current = &array->metadata[array->count];
current->key = **utf8_key; current->key = **utf8_key;
// Only allow binary headers for "-bin" keys // 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)) { if (::node::Buffer::HasInstance(value)) {
current->value = ::node::Buffer::Data(value); current->value = ::node::Buffer::Data(value);
current->value_length = ::node::Buffer::Length(value); current->value_length = ::node::Buffer::Length(value);
Persistent<Value> *handle = new Persistent<Value>(); PersistentValue *handle = new PersistentValue(value);
NanAssignPersistent(*handle, value); resources->handles.push_back(unique_ptr<PersistentValue>(handle));
resources->handles.push_back(unique_ptr<PersistentHolder>(
new PersistentHolder(handle)));
} else { } else {
return false; return false;
} }
} else { } else {
if (value->IsString()) { if (value->IsString()) {
Handle<String> string_value = value->ToString(); Local<String> string_value = Nan::To<String>(value).ToLocalChecked();
NanUtf8String *utf8_value = new NanUtf8String(string_value); Utf8String *utf8_value = new Utf8String(string_value);
resources->strings.push_back(unique_ptr<NanUtf8String>(utf8_value)); resources->strings.push_back(unique_ptr<Utf8String>(utf8_value));
current->value = **utf8_value; current->value = **utf8_value;
current->value_length = string_value->Length(); current->value_length = string_value->Length();
} else { } else {
@ -131,8 +138,8 @@ bool CreateMetadataArray(Handle<Object> metadata, grpc_metadata_array *array,
return true; return true;
} }
Handle<Value> ParseMetadata(const grpc_metadata_array *metadata_array) { Local<Value> ParseMetadata(const grpc_metadata_array *metadata_array) {
NanEscapableScope(); EscapableHandleScope scope;
grpc_metadata *metadata_elements = metadata_array->metadata; grpc_metadata *metadata_elements = metadata_array->metadata;
size_t length = metadata_array->count; size_t length = metadata_array->count;
std::map<const char*, size_t> size_map; std::map<const char*, size_t> size_map;
@ -142,49 +149,59 @@ Handle<Value> ParseMetadata(const grpc_metadata_array *metadata_array) {
const char *key = metadata_elements[i].key; const char *key = metadata_elements[i].key;
if (size_map.count(key)) { if (size_map.count(key)) {
size_map[key] += 1; size_map[key] += 1;
} else {
size_map[key] = 1;
} }
index_map[key] = 0; 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++) { for (unsigned int i = 0; i < length; i++) {
grpc_metadata* elem = &metadata_elements[i]; grpc_metadata* elem = &metadata_elements[i];
Handle<String> key_string = NanNew(elem->key); Local<String> key_string = Nan::New(elem->key).ToLocalChecked();
Handle<Array> array; Local<Array> array;
if (metadata_object->Has(key_string)) { MaybeLocal<Value> maybe_array = Nan::Get(metadata_object, key_string);
array = Handle<Array>::Cast(metadata_object->Get(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 { } else {
array = NanNew<Array>(size_map[elem->key]); array = Local<Array>::Cast(maybe_array.ToLocalChecked());
metadata_object->Set(key_string, array);
} }
if (EndsWith(elem->key, "-bin")) { if (EndsWith(elem->key, "-bin")) {
array->Set(index_map[elem->key], Nan::Set(array, index_map[elem->key],
NanNewBufferHandle(elem->value, elem->value_length)); Nan::CopyBuffer(elem->value,
elem->value_length).ToLocalChecked());
} else { } 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; index_map[elem->key] += 1;
} }
return NanEscapeScope(metadata_object); return scope.Escape(metadata_object);
} }
Handle<Value> Op::GetOpType() const { Local<Value> Op::GetOpType() const {
NanEscapableScope(); EscapableHandleScope scope;
return NanEscapeScope(NanNew<String>(GetTypeString())); return scope.Escape(Nan::New(GetTypeString()).ToLocalChecked());
} }
class SendMetadataOp : public Op { class SendMetadataOp : public Op {
public: public:
Handle<Value> GetNodeValue() const { Local<Value> GetNodeValue() const {
NanEscapableScope(); EscapableHandleScope scope;
return NanEscapeScope(NanTrue()); 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) { shared_ptr<Resources> resources) {
if (!value->IsObject()) { if (!value->IsObject()) {
return false; return false;
} }
grpc_metadata_array array; 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; return false;
} }
out->data.send_initial_metadata.count = array.count; out->data.send_initial_metadata.count = array.count;
@ -199,27 +216,28 @@ class SendMetadataOp : public Op {
class SendMessageOp : public Op { class SendMessageOp : public Op {
public: public:
Handle<Value> GetNodeValue() const { Local<Value> GetNodeValue() const {
NanEscapableScope(); EscapableHandleScope scope;
return NanEscapeScope(NanTrue()); 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) { shared_ptr<Resources> resources) {
if (!::node::Buffer::HasInstance(value)) { if (!::node::Buffer::HasInstance(value)) {
return false; return false;
} }
Handle<Object> object_value = value->ToObject(); Local<Object> object_value = Nan::To<Object>(value).ToLocalChecked();
if (object_value->HasOwnProperty(NanNew("grpcWriteFlags"))) { MaybeLocal<Value> maybe_flag_value = Nan::Get(
Handle<Value> flag_value = object_value->Get(NanNew("grpcWriteFlags")); object_value, Nan::New("grpcWriteFlags").ToLocalChecked());
if (!maybe_flag_value.IsEmpty()) {
Local<Value> flag_value = maybe_flag_value.ToLocalChecked();
if (flag_value->IsUint32()) { 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); out->data.send_message = BufferToByteBuffer(value);
Persistent<Value> *handle = new Persistent<Value>(); PersistentValue *handle = new PersistentValue(value);
NanAssignPersistent(*handle, value); resources->handles.push_back(unique_ptr<PersistentValue>(handle));
resources->handles.push_back(unique_ptr<PersistentHolder>(
new PersistentHolder(handle)));
return true; return true;
} }
protected: protected:
@ -230,11 +248,11 @@ class SendMessageOp : public Op {
class SendClientCloseOp : public Op { class SendClientCloseOp : public Op {
public: public:
Handle<Value> GetNodeValue() const { Local<Value> GetNodeValue() const {
NanEscapableScope(); EscapableHandleScope scope;
return NanEscapeScope(NanTrue()); 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) { shared_ptr<Resources> resources) {
return true; return true;
} }
@ -246,39 +264,55 @@ class SendClientCloseOp : public Op {
class SendServerStatusOp : public Op { class SendServerStatusOp : public Op {
public: public:
Handle<Value> GetNodeValue() const { Local<Value> GetNodeValue() const {
NanEscapableScope(); EscapableHandleScope scope;
return NanEscapeScope(NanTrue()); 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) { shared_ptr<Resources> resources) {
if (!value->IsObject()) { if (!value->IsObject()) {
return false; return false;
} }
Handle<Object> server_status = value->ToObject(); Local<Object> server_status = Nan::To<Object>(value).ToLocalChecked();
if (!server_status->Get(NanNew("metadata"))->IsObject()) { 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; return false;
} }
if (!server_status->Get(NanNew("code"))->IsUint32()) { if (!maybe_code.ToLocalChecked()->IsUint32()) {
return false; 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; return false;
} }
if (!maybe_details.ToLocalChecked()->IsString()) {
return false;
}
Local<String> details = Nan::To<String>(
maybe_details.ToLocalChecked()).ToLocalChecked();
grpc_metadata_array array; grpc_metadata_array array;
if (!CreateMetadataArray(server_status->Get(NanNew("metadata"))-> if (!CreateMetadataArray(metadata, &array, resources)) {
ToObject(),
&array, resources)) {
return false; return false;
} }
out->data.send_status_from_server.trailing_metadata_count = array.count; 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.trailing_metadata = array.metadata;
out->data.send_status_from_server.status = out->data.send_status_from_server.status =
static_cast<grpc_status_code>( static_cast<grpc_status_code>(code);
server_status->Get(NanNew("code"))->Uint32Value()); Utf8String *str = new Utf8String(details);
NanUtf8String *str = new NanUtf8String( resources->strings.push_back(unique_ptr<Utf8String>(str));
server_status->Get(NanNew("details")));
resources->strings.push_back(unique_ptr<NanUtf8String>(str));
out->data.send_status_from_server.status_details = **str; out->data.send_status_from_server.status_details = **str;
return true; return true;
} }
@ -298,12 +332,12 @@ class GetMetadataOp : public Op {
grpc_metadata_array_destroy(&recv_metadata); grpc_metadata_array_destroy(&recv_metadata);
} }
Handle<Value> GetNodeValue() const { Local<Value> GetNodeValue() const {
NanEscapableScope(); EscapableHandleScope scope;
return NanEscapeScope(ParseMetadata(&recv_metadata)); 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) { shared_ptr<Resources> resources) {
out->data.recv_initial_metadata = &recv_metadata; out->data.recv_initial_metadata = &recv_metadata;
return true; return true;
@ -328,12 +362,12 @@ class ReadMessageOp : public Op {
gpr_free(recv_message); gpr_free(recv_message);
} }
} }
Handle<Value> GetNodeValue() const { Local<Value> GetNodeValue() const {
NanEscapableScope(); EscapableHandleScope scope;
return NanEscapeScope(ByteBufferToBuffer(recv_message)); 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) { shared_ptr<Resources> resources) {
out->data.recv_message = &recv_message; out->data.recv_message = &recv_message;
return true; return true;
@ -361,7 +395,7 @@ class ClientStatusOp : public Op {
gpr_free(status_details); gpr_free(status_details);
} }
bool ParseOp(Handle<Value> value, grpc_op *out, bool ParseOp(Local<Value> value, grpc_op *out,
shared_ptr<Resources> resources) { shared_ptr<Resources> resources) {
out->data.recv_status_on_client.trailing_metadata = &metadata_array; out->data.recv_status_on_client.trailing_metadata = &metadata_array;
out->data.recv_status_on_client.status = &status; out->data.recv_status_on_client.status = &status;
@ -370,15 +404,18 @@ class ClientStatusOp : public Op {
return true; return true;
} }
Handle<Value> GetNodeValue() const { Local<Value> GetNodeValue() const {
NanEscapableScope(); EscapableHandleScope scope;
Handle<Object> status_obj = NanNew<Object>(); Local<Object> status_obj = Nan::New<Object>();
status_obj->Set(NanNew("code"), NanNew<Number>(status)); Nan::Set(status_obj, Nan::New("code").ToLocalChecked(),
Nan::New<Number>(status));
if (status_details != NULL) { 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)); Nan::Set(status_obj, Nan::New("metadata").ToLocalChecked(),
return NanEscapeScope(status_obj); ParseMetadata(&metadata_array));
return scope.Escape(status_obj);
} }
protected: protected:
std::string GetTypeString() const { std::string GetTypeString() const {
@ -393,12 +430,12 @@ class ClientStatusOp : public Op {
class ServerCloseResponseOp : public Op { class ServerCloseResponseOp : public Op {
public: public:
Handle<Value> GetNodeValue() const { Local<Value> GetNodeValue() const {
NanEscapableScope(); EscapableHandleScope scope;
return NanEscapeScope(NanNew<Boolean>(cancelled)); 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) { shared_ptr<Resources> resources) {
out->data.recv_close_on_server.cancelled = &cancelled; out->data.recv_close_on_server.cancelled = &cancelled;
return true; return true;
@ -413,7 +450,7 @@ class ServerCloseResponseOp : public Op {
int cancelled; int cancelled;
}; };
tag::tag(NanCallback *callback, OpVec *ops, tag::tag(Callback *callback, OpVec *ops,
shared_ptr<Resources> resources) : shared_ptr<Resources> resources) :
callback(callback), ops(ops), resources(resources){ callback(callback), ops(ops), resources(resources){
} }
@ -423,19 +460,19 @@ tag::~tag() {
delete ops; delete ops;
} }
Handle<Value> GetTagNodeValue(void *tag) { Local<Value> GetTagNodeValue(void *tag) {
NanEscapableScope(); EscapableHandleScope scope;
struct tag *tag_struct = reinterpret_cast<struct tag *>(tag); 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(); for (vector<unique_ptr<Op> >::iterator it = tag_struct->ops->begin();
it != tag_struct->ops->end(); ++it) { it != tag_struct->ops->end(); ++it) {
Op *op_ptr = it->get(); 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); struct tag *tag_struct = reinterpret_cast<struct tag *>(tag);
return tag_struct->callback; return tag_struct->callback;
} }
@ -452,140 +489,149 @@ Call::~Call() {
grpc_call_destroy(wrapped_call); grpc_call_destroy(wrapped_call);
} }
void Call::Init(Handle<Object> exports) { void Call::Init(Local<Object> exports) {
NanScope(); HandleScope scope;
Local<FunctionTemplate> tpl = NanNew<FunctionTemplate>(New); Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(New);
tpl->SetClassName(NanNew("Call")); tpl->SetClassName(Nan::New("Call").ToLocalChecked());
tpl->InstanceTemplate()->SetInternalFieldCount(1); tpl->InstanceTemplate()->SetInternalFieldCount(1);
NanSetPrototypeTemplate(tpl, "startBatch", Nan::SetPrototypeMethod(tpl, "startBatch", StartBatch);
NanNew<FunctionTemplate>(StartBatch)->GetFunction()); Nan::SetPrototypeMethod(tpl, "cancel", Cancel);
NanSetPrototypeTemplate(tpl, "cancel", Nan::SetPrototypeMethod(tpl, "cancelWithStatus", CancelWithStatus);
NanNew<FunctionTemplate>(Cancel)->GetFunction()); Nan::SetPrototypeMethod(tpl, "getPeer", GetPeer);
NanSetPrototypeTemplate( fun_tpl.Reset(tpl);
tpl, "cancelWithStatus", Local<Function> ctr = Nan::GetFunction(tpl).ToLocalChecked();
NanNew<FunctionTemplate>(CancelWithStatus)->GetFunction()); Nan::Set(exports, Nan::New("Call").ToLocalChecked(), ctr);
NanSetPrototypeTemplate(tpl, "getPeer", constructor = new Callback(ctr);
NanNew<FunctionTemplate>(GetPeer)->GetFunction());
NanAssignPersistent(fun_tpl, tpl);
Handle<Function> ctr = tpl->GetFunction();
exports->Set(NanNew("Call"), ctr);
constructor = new NanCallback(ctr);
} }
bool Call::HasInstance(Handle<Value> val) { bool Call::HasInstance(Local<Value> val) {
NanScope(); HandleScope scope;
return NanHasInstance(fun_tpl, val); return Nan::New(fun_tpl)->HasInstance(val);
} }
Handle<Value> Call::WrapStruct(grpc_call *call) { Local<Value> Call::WrapStruct(grpc_call *call) {
NanEscapableScope(); EscapableHandleScope scope;
if (call == NULL) { if (call == NULL) {
return NanEscapeScope(NanNull()); return scope.Escape(Nan::Null());
} }
const int argc = 1; const int argc = 1;
Handle<Value> argv[argc] = {NanNew<External>(reinterpret_cast<void *>(call))}; Local<Value> argv[argc] = {Nan::New<External>(
return NanEscapeScope(constructor->GetFunction()->NewInstance(argc, argv)); 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) { NAN_METHOD(Call::New) {
NanScope(); if (info.IsConstructCall()) {
if (args.IsConstructCall()) {
Call *call; Call *call;
if (args[0]->IsExternal()) { if (info[0]->IsExternal()) {
Handle<External> ext = args[0].As<External>(); Local<External> ext = info[0].As<External>();
// This option is used for wrapping an existing call // This option is used for wrapping an existing call
grpc_call *call_value = grpc_call *call_value =
reinterpret_cast<grpc_call *>(ext->Value()); reinterpret_cast<grpc_call *>(ext->Value());
call = new Call(call_value); call = new Call(call_value);
} else { } else {
if (!Channel::HasInstance(args[0])) { if (!Channel::HasInstance(info[0])) {
return NanThrowTypeError("Call's first argument must be a Channel"); return Nan::ThrowTypeError("Call's first argument must be a Channel");
} }
if (!args[1]->IsString()) { if (!info[1]->IsString()) {
return NanThrowTypeError("Call's second argument must be a string"); return Nan::ThrowTypeError("Call's second argument must be a string");
} }
if (!(args[2]->IsNumber() || args[2]->IsDate())) { if (!(info[2]->IsNumber() || info[2]->IsDate())) {
return NanThrowTypeError( return Nan::ThrowTypeError(
"Call's third argument must be a date or a number"); "Call's third argument must be a date or a number");
} }
// These arguments are at the end because they are optional // These arguments are at the end because they are optional
grpc_call *parent_call = NULL; grpc_call *parent_call = NULL;
if (Call::HasInstance(args[4])) { if (Call::HasInstance(info[4])) {
Call *parent_obj = ObjectWrap::Unwrap<Call>(args[4]->ToObject()); Call *parent_obj = ObjectWrap::Unwrap<Call>(
Nan::To<Object>(info[4]).ToLocalChecked());
parent_call = parent_obj->wrapped_call; parent_call = parent_obj->wrapped_call;
} else if (!(args[4]->IsUndefined() || args[4]->IsNull())) { } else if (!(info[4]->IsUndefined() || info[4]->IsNull())) {
return NanThrowTypeError( return Nan::ThrowTypeError(
"Call's fifth argument must be another call, if provided"); "Call's fifth argument must be another call, if provided");
} }
gpr_uint32 propagate_flags = GRPC_PROPAGATE_DEFAULTS; gpr_uint32 propagate_flags = GRPC_PROPAGATE_DEFAULTS;
if (args[5]->IsUint32()) { if (info[5]->IsUint32()) {
propagate_flags = args[5]->Uint32Value(); propagate_flags = Nan::To<uint32_t>(info[5]).FromJust();
} else if (!(args[5]->IsUndefined() || args[5]->IsNull())) { } else if (!(info[5]->IsUndefined() || info[5]->IsNull())) {
return NanThrowTypeError( return Nan::ThrowTypeError(
"Call's sixth argument must be propagate flags, if provided"); "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); Channel *channel = ObjectWrap::Unwrap<Channel>(channel_object);
if (channel->GetWrappedChannel() == NULL) { 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]); Utf8String method(info[1]);
double deadline = args[2]->NumberValue(); double deadline = Nan::To<double>(info[2]).FromJust();
grpc_channel *wrapped_channel = channel->GetWrappedChannel(); grpc_channel *wrapped_channel = channel->GetWrappedChannel();
grpc_call *wrapped_call; grpc_call *wrapped_call;
if (args[3]->IsString()) { if (info[3]->IsString()) {
NanUtf8String host_override(args[3]); Utf8String host_override(info[3]);
wrapped_call = grpc_channel_create_call( wrapped_call = grpc_channel_create_call(
wrapped_channel, parent_call, propagate_flags, wrapped_channel, parent_call, propagate_flags,
CompletionQueueAsyncWorker::GetQueue(), *method, CompletionQueueAsyncWorker::GetQueue(), *method,
*host_override, MillisecondsToTimespec(deadline), NULL); *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_call = grpc_channel_create_call(
wrapped_channel, parent_call, propagate_flags, wrapped_channel, parent_call, propagate_flags,
CompletionQueueAsyncWorker::GetQueue(), *method, CompletionQueueAsyncWorker::GetQueue(), *method,
NULL, MillisecondsToTimespec(deadline), NULL); NULL, MillisecondsToTimespec(deadline), NULL);
} else { } 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); 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()); call->Wrap(info.This());
NanReturnValue(args.This()); info.GetReturnValue().Set(info.This());
} else { } else {
const int argc = 4; const int argc = 4;
Local<Value> argv[argc] = {args[0], args[1], args[2], args[3]}; Local<Value> argv[argc] = {info[0], info[1], info[2], info[3]};
NanReturnValue(constructor->GetFunction()->NewInstance(argc, argv)); 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) { NAN_METHOD(Call::StartBatch) {
NanScope(); if (!Call::HasInstance(info.This())) {
if (!HasInstance(args.This())) { return Nan::ThrowTypeError("startBatch can only be called on Call objects");
return NanThrowTypeError("startBatch can only be called on Call objects");
} }
if (!args[0]->IsObject()) { if (!info[0]->IsObject()) {
return NanThrowError("startBatch's first argument must be an object"); return Nan::ThrowError("startBatch's first argument must be an object");
} }
if (!args[1]->IsFunction()) { if (!info[1]->IsFunction()) {
return NanThrowError("startBatch's second argument must be a callback"); return Nan::ThrowError("startBatch's second argument must be a callback");
} }
Handle<Function> callback_func = args[1].As<Function>(); Local<Function> callback_func = info[1].As<Function>();
Call *call = ObjectWrap::Unwrap<Call>(args.This()); Call *call = ObjectWrap::Unwrap<Call>(info.This());
shared_ptr<Resources> resources(new Resources); shared_ptr<Resources> resources(new Resources);
Handle<Object> obj = args[0]->ToObject(); Local<Object> obj = Nan::To<Object>(info[0]).ToLocalChecked();
Handle<Array> keys = obj->GetOwnPropertyNames(); Local<Array> keys = Nan::GetOwnPropertyNames(obj).ToLocalChecked();
size_t nops = keys->Length(); size_t nops = keys->Length();
vector<grpc_op> ops(nops); vector<grpc_op> ops(nops);
unique_ptr<OpVec> op_vector(new OpVec()); unique_ptr<OpVec> op_vector(new OpVec());
for (unsigned int i = 0; i < nops; i++) { for (unsigned int i = 0; i < nops; i++) {
unique_ptr<Op> op; unique_ptr<Op> op;
if (!keys->Get(i)->IsUint32()) { MaybeLocal<Value> maybe_key = Nan::Get(keys, i);
return NanThrowError( if (maybe_key.IsEmpty() || (!maybe_key.ToLocalChecked()->IsUint32())) {
return Nan::ThrowError(
"startBatch's first argument's keys must be integers"); "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].op = static_cast<grpc_op_type>(type);
ops[i].flags = 0; ops[i].flags = 0;
ops[i].reserved = NULL; ops[i].reserved = NULL;
@ -615,67 +661,64 @@ NAN_METHOD(Call::StartBatch) {
op.reset(new ServerCloseResponseOp()); op.reset(new ServerCloseResponseOp());
break; break;
default: 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)) { 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)); 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( grpc_call_error error = grpc_call_start_batch(
call->wrapped_call, &ops[0], nops, new struct tag( call->wrapped_call, &ops[0], nops, new struct tag(
callback, op_vector.release(), resources), NULL); callback, op_vector.release(), resources), NULL);
if (error != GRPC_CALL_OK) { if (error != GRPC_CALL_OK) {
return NanThrowError(nanErrorWithCode("startBatch failed", error)); return Nan::ThrowError(nanErrorWithCode("startBatch failed", error));
} }
CompletionQueueAsyncWorker::Next(); CompletionQueueAsyncWorker::Next();
NanReturnUndefined();
} }
NAN_METHOD(Call::Cancel) { NAN_METHOD(Call::Cancel) {
NanScope(); if (!Call::HasInstance(info.This())) {
if (!HasInstance(args.This())) { return Nan::ThrowTypeError("cancel can only be called on Call objects");
return NanThrowTypeError("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); grpc_call_error error = grpc_call_cancel(call->wrapped_call, NULL);
if (error != GRPC_CALL_OK) { if (error != GRPC_CALL_OK) {
return NanThrowError(nanErrorWithCode("cancel failed", error)); return Nan::ThrowError(nanErrorWithCode("cancel failed", error));
} }
NanReturnUndefined();
} }
NAN_METHOD(Call::CancelWithStatus) { NAN_METHOD(Call::CancelWithStatus) {
NanScope(); Nan::HandleScope scope;
if (!HasInstance(args.This())) { if (!HasInstance(info.This())) {
return NanThrowTypeError("cancel can only be called on Call objects"); return Nan::ThrowTypeError("cancel can only be called on Call objects");
} }
if (!args[0]->IsUint32()) { if (!info[0]->IsUint32()) {
return NanThrowTypeError( return Nan::ThrowTypeError(
"cancelWithStatus's first argument must be a status code"); "cancelWithStatus's first argument must be a status code");
} }
if (!args[1]->IsString()) { if (!info[1]->IsString()) {
return NanThrowTypeError( return Nan::ThrowTypeError(
"cancelWithStatus's second argument must be a string"); "cancelWithStatus's second argument must be a string");
} }
Call *call = ObjectWrap::Unwrap<Call>(args.This()); Call *call = ObjectWrap::Unwrap<Call>(info.This());
grpc_status_code code = static_cast<grpc_status_code>(args[0]->Uint32Value()); grpc_status_code code = static_cast<grpc_status_code>(
NanUtf8String details(args[0]); Nan::To<uint32_t>(info[0]).FromJust());
Utf8String details(info[0]);
grpc_call_cancel_with_status(call->wrapped_call, code, *details, NULL); grpc_call_cancel_with_status(call->wrapped_call, code, *details, NULL);
NanReturnUndefined();
} }
NAN_METHOD(Call::GetPeer) { NAN_METHOD(Call::GetPeer) {
NanScope(); Nan::HandleScope scope;
if (!HasInstance(args.This())) { if (!HasInstance(info.This())) {
return NanThrowTypeError("getPeer can only be called on Call objects"); 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); 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); gpr_free(peer);
NanReturnValue(peer_value); info.GetReturnValue().Set(peer_value);
} }
} // namespace node } // namespace node

57
src/node/ext/call.h
Unescape View File

@ -51,6 +51,8 @@ namespace node {
using std::unique_ptr; using std::unique_ptr;
using std::shared_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. * Helper function for throwing errors with a grpc_call_error value.
* Modified from the answer by Gus Goose to * Modified from the answer by Gus Goose to
@ -58,40 +60,25 @@ using std::shared_ptr;
*/ */
inline v8::Local<v8::Value> nanErrorWithCode(const char *msg, inline v8::Local<v8::Value> nanErrorWithCode(const char *msg,
grpc_call_error code) { grpc_call_error code) {
NanEscapableScope(); Nan::EscapableHandleScope scope;
v8::Local<v8::Object> err = NanError(msg).As<v8::Object>(); v8::Local<v8::Object> err = Nan::Error(msg).As<v8::Object>();
err->Set(NanNew("code"), NanNew<v8::Uint32>(code)); Nan::Set(err, Nan::New("code").ToLocalChecked(), Nan::New<v8::Uint32>(code));
return NanEscapeScope(err); return scope.Escape(err);
} }
v8::Handle<v8::Value> ParseMetadata(const grpc_metadata_array *metadata_array); v8::Local<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;
};
struct Resources { struct Resources {
std::vector<unique_ptr<NanUtf8String> > strings; std::vector<unique_ptr<Nan::Utf8String> > strings;
std::vector<unique_ptr<PersistentHolder> > handles; std::vector<unique_ptr<PersistentValue> > handles;
}; };
class Op { class Op {
public: public:
virtual v8::Handle<v8::Value> GetNodeValue() const = 0; virtual v8::Local<v8::Value> GetNodeValue() const = 0;
virtual bool ParseOp(v8::Handle<v8::Value> value, grpc_op *out, virtual bool ParseOp(v8::Local<v8::Value> value, grpc_op *out,
shared_ptr<Resources> resources) = 0; shared_ptr<Resources> resources) = 0;
v8::Handle<v8::Value> GetOpType() const; v8::Local<v8::Value> GetOpType() const;
protected: protected:
virtual std::string GetTypeString() const = 0; virtual std::string GetTypeString() const = 0;
@ -100,27 +87,27 @@ class Op {
typedef std::vector<unique_ptr<Op>> OpVec; typedef std::vector<unique_ptr<Op>> OpVec;
struct tag { struct tag {
tag(NanCallback *callback, OpVec *ops, tag(Nan::Callback *callback, OpVec *ops,
shared_ptr<Resources> resources); shared_ptr<Resources> resources);
~tag(); ~tag();
NanCallback *callback; Nan::Callback *callback;
OpVec *ops; OpVec *ops;
shared_ptr<Resources> resources; 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); void DestroyTag(void *tag);
/* Wrapper class for grpc_call structs. */ /* Wrapper class for grpc_call structs. */
class Call : public ::node::ObjectWrap { class Call : public Nan::ObjectWrap {
public: public:
static void Init(v8::Handle<v8::Object> exports); static void Init(v8::Local<v8::Object> exports);
static bool HasInstance(v8::Handle<v8::Value> val); static bool HasInstance(v8::Local<v8::Value> val);
/* Wrap a grpc_call struct in a javascript object */ /* 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: private:
explicit Call(grpc_call *call); explicit Call(grpc_call *call);
@ -135,9 +122,9 @@ class Call : public ::node::ObjectWrap {
static NAN_METHOD(Cancel); static NAN_METHOD(Cancel);
static NAN_METHOD(CancelWithStatus); static NAN_METHOD(CancelWithStatus);
static NAN_METHOD(GetPeer); static NAN_METHOD(GetPeer);
static NanCallback *constructor; static Nan::Callback *constructor;
// Used for typechecking instances of this javascript class // 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; grpc_call *wrapped_call;
}; };

178
src/node/ext/channel.cc
Unescape View File

@ -48,21 +48,27 @@
namespace grpc { namespace grpc {
namespace node { 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::Array;
using v8::Exception; using v8::Exception;
using v8::Function; using v8::Function;
using v8::FunctionTemplate; using v8::FunctionTemplate;
using v8::Handle;
using v8::HandleScope;
using v8::Integer; using v8::Integer;
using v8::Local; using v8::Local;
using v8::Number; using v8::Number;
using v8::Object; using v8::Object;
using v8::Persistent;
using v8::String; using v8::String;
using v8::Value; using v8::Value;
NanCallback *Channel::constructor; Callback *Channel::constructor;
Persistent<FunctionTemplate> Channel::fun_tpl; Persistent<FunctionTemplate> Channel::fun_tpl;
Channel::Channel(grpc_channel *channel) : wrapped_channel(channel) {} Channel::Channel(grpc_channel *channel) : wrapped_channel(channel) {}
@ -73,88 +79,89 @@ Channel::~Channel() {
} }
} }
void Channel::Init(Handle<Object> exports) { void Channel::Init(Local<Object> exports) {
NanScope(); Nan::HandleScope scope;
Local<FunctionTemplate> tpl = NanNew<FunctionTemplate>(New); Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(New);
tpl->SetClassName(NanNew("Channel")); tpl->SetClassName(Nan::New("Channel").ToLocalChecked());
tpl->InstanceTemplate()->SetInternalFieldCount(1); tpl->InstanceTemplate()->SetInternalFieldCount(1);
NanSetPrototypeTemplate(tpl, "close", Nan::SetPrototypeMethod(tpl, "close", Close);
NanNew<FunctionTemplate>(Close)->GetFunction()); Nan::SetPrototypeMethod(tpl, "getTarget", GetTarget);
NanSetPrototypeTemplate(tpl, "getTarget", Nan::SetPrototypeMethod(tpl, "getConnectivityState", GetConnectivityState);
NanNew<FunctionTemplate>(GetTarget)->GetFunction()); Nan::SetPrototypeMethod(tpl, "watchConnectivityState",
NanSetPrototypeTemplate( WatchConnectivityState);
tpl, "getConnectivityState", fun_tpl.Reset(tpl);
NanNew<FunctionTemplate>(GetConnectivityState)->GetFunction()); Local<Function> ctr = Nan::GetFunction(tpl).ToLocalChecked();
NanSetPrototypeTemplate( Nan::Set(exports, Nan::New("Channel").ToLocalChecked(), ctr);
tpl, "watchConnectivityState", constructor = new Callback(ctr);
NanNew<FunctionTemplate>(WatchConnectivityState)->GetFunction());
NanAssignPersistent(fun_tpl, tpl);
Handle<Function> ctr = tpl->GetFunction();
constructor = new NanCallback(ctr);
exports->Set(NanNew("Channel"), ctr);
} }
bool Channel::HasInstance(Handle<Value> val) { bool Channel::HasInstance(Local<Value> val) {
NanScope(); HandleScope scope;
return NanHasInstance(fun_tpl, val); return Nan::New(fun_tpl)->HasInstance(val);
} }
grpc_channel *Channel::GetWrappedChannel() { return this->wrapped_channel; } grpc_channel *Channel::GetWrappedChannel() { return this->wrapped_channel; }
NAN_METHOD(Channel::New) { NAN_METHOD(Channel::New) {
NanScope(); if (info.IsConstructCall()) {
if (!info[0]->IsString()) {
if (args.IsConstructCall()) { return Nan::ThrowTypeError(
if (!args[0]->IsString()) {
return NanThrowTypeError(
"Channel expects a string, a credential and an object"); "Channel expects a string, a credential and an object");
} }
grpc_channel *wrapped_channel; grpc_channel *wrapped_channel;
// Owned by the Channel object // Owned by the Channel object
NanUtf8String host(args[0]); Utf8String host(info[0]);
grpc_credentials *creds; grpc_credentials *creds;
if (!Credentials::HasInstance(args[1])) { if (!Credentials::HasInstance(info[1])) {
return NanThrowTypeError( return Nan::ThrowTypeError(
"Channel's second argument must be a credential"); "Channel's second argument must be a credential");
} }
Credentials *creds_object = ObjectWrap::Unwrap<Credentials>( Credentials *creds_object = ObjectWrap::Unwrap<Credentials>(
args[1]->ToObject()); Nan::To<Object>(info[1]).ToLocalChecked());
creds = creds_object->GetWrappedCredentials(); creds = creds_object->GetWrappedCredentials();
grpc_channel_args *channel_args_ptr; grpc_channel_args *channel_args_ptr;
if (args[2]->IsUndefined()) { if (info[2]->IsUndefined()) {
channel_args_ptr = NULL; channel_args_ptr = NULL;
wrapped_channel = grpc_insecure_channel_create(*host, NULL, NULL); wrapped_channel = grpc_insecure_channel_create(*host, NULL, NULL);
} else if (args[2]->IsObject()) { } else if (info[2]->IsObject()) {
Handle<Object> args_hash(args[2]->ToObject()->Clone()); Local<Object> args_hash = Nan::To<Object>(info[2]).ToLocalChecked();
Handle<Array> keys(args_hash->GetOwnPropertyNames()); Local<Array> keys(Nan::GetOwnPropertyNames(args_hash).ToLocalChecked());
grpc_channel_args channel_args; grpc_channel_args channel_args;
channel_args.num_args = keys->Length(); channel_args.num_args = keys->Length();
channel_args.args = reinterpret_cast<grpc_arg *>( channel_args.args = reinterpret_cast<grpc_arg *>(
calloc(channel_args.num_args, sizeof(grpc_arg))); calloc(channel_args.num_args, sizeof(grpc_arg)));
/* These are used to keep all strings until then end of the block, then /* These are used to keep all strings until then end of the block, then
destroy them */ destroy them */
std::vector<NanUtf8String *> key_strings(keys->Length()); std::vector<Nan::Utf8String *> key_strings(keys->Length());
std::vector<NanUtf8String *> value_strings(keys->Length()); std::vector<Nan::Utf8String *> value_strings(keys->Length());
for (unsigned int i = 0; i < channel_args.num_args; i++) { for (unsigned int i = 0; i < channel_args.num_args; i++) {
Handle<String> current_key(keys->Get(i)->ToString()); MaybeLocal<String> maybe_key = Nan::To<String>(
Handle<Value> current_value(args_hash->Get(current_key)); Nan::Get(keys, i).ToLocalChecked());
key_strings[i] = new NanUtf8String(current_key); 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]; channel_args.args[i].key = **key_strings[i];
if (current_value->IsInt32()) { if (current_value->IsInt32()) {
channel_args.args[i].type = GRPC_ARG_INTEGER; 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()) { } else if (current_value->IsString()) {
channel_args.args[i].type = GRPC_ARG_STRING; 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]; channel_args.args[i].value.string = **value_strings[i];
} else { } else {
free(channel_args.args); free(channel_args.args);
return NanThrowTypeError("Arg values must be strings"); return Nan::ThrowTypeError("Arg values must be strings");
} }
} }
channel_args_ptr = &channel_args; channel_args_ptr = &channel_args;
} else { } else {
return NanThrowTypeError("Channel expects a string and an object"); return Nan::ThrowTypeError("Channel expects a string and an object");
} }
if (creds == NULL) { if (creds == NULL) {
wrapped_channel = grpc_insecure_channel_create(*host, channel_args_ptr, wrapped_channel = grpc_insecure_channel_create(*host, channel_args_ptr,
@ -167,73 +174,79 @@ NAN_METHOD(Channel::New) {
free(channel_args_ptr->args); free(channel_args_ptr->args);
} }
Channel *channel = new Channel(wrapped_channel); Channel *channel = new Channel(wrapped_channel);
channel->Wrap(args.This()); channel->Wrap(info.This());
NanReturnValue(args.This()); info.GetReturnValue().Set(info.This());
return;
} else { } else {
const int argc = 3; const int argc = 3;
Local<Value> argv[argc] = {args[0], args[1], args[2]}; Local<Value> argv[argc] = {info[0], info[1], info[2]};
NanReturnValue(constructor->GetFunction()->NewInstance(argc, argv)); 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) { NAN_METHOD(Channel::Close) {
NanScope(); if (!HasInstance(info.This())) {
if (!HasInstance(args.This())) { return Nan::ThrowTypeError("close can only be called on Channel objects");
return NanThrowTypeError("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) { if (channel->wrapped_channel != NULL) {
grpc_channel_destroy(channel->wrapped_channel); grpc_channel_destroy(channel->wrapped_channel);
channel->wrapped_channel = NULL; channel->wrapped_channel = NULL;
} }
NanReturnUndefined();
} }
NAN_METHOD(Channel::GetTarget) { NAN_METHOD(Channel::GetTarget) {
NanScope(); if (!HasInstance(info.This())) {
if (!HasInstance(args.This())) { return Nan::ThrowTypeError("getTarget can only be called on Channel objects");
return NanThrowTypeError("getTarget can only be called on Channel objects");
} }
Channel *channel = ObjectWrap::Unwrap<Channel>(args.This()); Channel *channel = ObjectWrap::Unwrap<Channel>(info.This());
NanReturnValue(NanNew(grpc_channel_get_target(channel->wrapped_channel))); info.GetReturnValue().Set(Nan::New(
grpc_channel_get_target(channel->wrapped_channel)).ToLocalChecked());
} }
NAN_METHOD(Channel::GetConnectivityState) { NAN_METHOD(Channel::GetConnectivityState) {
NanScope(); if (!HasInstance(info.This())) {
if (!HasInstance(args.This())) { return Nan::ThrowTypeError(
return NanThrowTypeError(
"getConnectivityState can only be called on Channel objects"); "getConnectivityState can only be called on Channel objects");
} }
Channel *channel = ObjectWrap::Unwrap<Channel>(args.This()); Channel *channel = ObjectWrap::Unwrap<Channel>(info.This());
int try_to_connect = (int)args[0]->Equals(NanTrue()); int try_to_connect = (int)info[0]->Equals(Nan::True());
NanReturnValue(grpc_channel_check_connectivity_state(channel->wrapped_channel, info.GetReturnValue().Set(
try_to_connect)); grpc_channel_check_connectivity_state(channel->wrapped_channel,
try_to_connect));
} }
NAN_METHOD(Channel::WatchConnectivityState) { NAN_METHOD(Channel::WatchConnectivityState) {
NanScope(); if (!HasInstance(info.This())) {
if (!HasInstance(args.This())) { return Nan::ThrowTypeError(
return NanThrowTypeError(
"watchConnectivityState can only be called on Channel objects"); "watchConnectivityState can only be called on Channel objects");
} }
if (!args[0]->IsUint32()) { if (!info[0]->IsUint32()) {
return NanThrowTypeError( return Nan::ThrowTypeError(
"watchConnectivityState's first argument must be a channel state"); "watchConnectivityState's first argument must be a channel state");
} }
if (!(args[1]->IsNumber() || args[1]->IsDate())) { if (!(info[1]->IsNumber() || info[1]->IsDate())) {
return NanThrowTypeError( return Nan::ThrowTypeError(
"watchConnectivityState's second argument must be a date or a number"); "watchConnectivityState's second argument must be a date or a number");
} }
if (!args[2]->IsFunction()) { if (!info[2]->IsFunction()) {
return NanThrowTypeError( return Nan::ThrowTypeError(
"watchConnectivityState's third argument must be a callback"); "watchConnectivityState's third argument must be a callback");
} }
grpc_connectivity_state last_state = grpc_connectivity_state last_state =
static_cast<grpc_connectivity_state>(args[0]->Uint32Value()); static_cast<grpc_connectivity_state>(
double deadline = args[1]->NumberValue(); Nan::To<uint32_t>(info[0]).FromJust());
Handle<Function> callback_func = args[2].As<Function>(); double deadline = Nan::To<double>(info[1]).FromJust();
NanCallback *callback = new NanCallback(callback_func); Local<Function> callback_func = info[2].As<Function>();
Channel *channel = ObjectWrap::Unwrap<Channel>(args.This()); Nan::Callback *callback = new Callback(callback_func);
Channel *channel = ObjectWrap::Unwrap<Channel>(info.This());
unique_ptr<OpVec> ops(new OpVec()); unique_ptr<OpVec> ops(new OpVec());
grpc_channel_watch_connectivity_state( grpc_channel_watch_connectivity_state(
channel->wrapped_channel, last_state, MillisecondsToTimespec(deadline), channel->wrapped_channel, last_state, MillisecondsToTimespec(deadline),
@ -242,7 +255,6 @@ NAN_METHOD(Channel::WatchConnectivityState) {
ops.release(), ops.release(),
shared_ptr<Resources>(nullptr))); shared_ptr<Resources>(nullptr)));
CompletionQueueAsyncWorker::Next(); CompletionQueueAsyncWorker::Next();
NanReturnUndefined();
} }
} // namespace node } // namespace node

10
src/node/ext/channel.h
Unescape View File

@ -42,10 +42,10 @@ namespace grpc {
namespace node { namespace node {
/* Wrapper class for grpc_channel structs */ /* Wrapper class for grpc_channel structs */
class Channel : public ::node::ObjectWrap { class Channel : public Nan::ObjectWrap {
public: public:
static void Init(v8::Handle<v8::Object> exports); static void Init(v8::Local<v8::Object> exports);
static bool HasInstance(v8::Handle<v8::Value> val); static bool HasInstance(v8::Local<v8::Value> val);
/* This is used to typecheck javascript objects before converting them to /* This is used to typecheck javascript objects before converting them to
this type */ this type */
static v8::Persistent<v8::Value> prototype; static v8::Persistent<v8::Value> prototype;
@ -66,8 +66,8 @@ class Channel : public ::node::ObjectWrap {
static NAN_METHOD(GetTarget); static NAN_METHOD(GetTarget);
static NAN_METHOD(GetConnectivityState); static NAN_METHOD(GetConnectivityState);
static NAN_METHOD(WatchConnectivityState); static NAN_METHOD(WatchConnectivityState);
static NanCallback *constructor; static Nan::Callback *constructor;
static v8::Persistent<v8::FunctionTemplate> fun_tpl; static Nan::Persistent<v8::FunctionTemplate> fun_tpl;
grpc_channel *wrapped_channel; grpc_channel *wrapped_channel;
}; };

27
src/node/ext/completion_queue_async_worker.cc
Unescape View File

@ -46,9 +46,8 @@ namespace node {
const int max_queue_threads = 2; const int max_queue_threads = 2;
using v8::Function; using v8::Function;
using v8::Handle; using v8::Local;
using v8::Object; using v8::Object;
using v8::Persistent;
using v8::Value; using v8::Value;
grpc_completion_queue *CompletionQueueAsyncWorker::queue; grpc_completion_queue *CompletionQueueAsyncWorker::queue;
@ -57,7 +56,7 @@ int CompletionQueueAsyncWorker::current_threads;
int CompletionQueueAsyncWorker::waiting_next_calls; int CompletionQueueAsyncWorker::waiting_next_calls;
CompletionQueueAsyncWorker::CompletionQueueAsyncWorker() CompletionQueueAsyncWorker::CompletionQueueAsyncWorker()
: NanAsyncWorker(NULL) {} : Nan::AsyncWorker(NULL) {}
CompletionQueueAsyncWorker::~CompletionQueueAsyncWorker() {} CompletionQueueAsyncWorker::~CompletionQueueAsyncWorker() {}
@ -72,42 +71,42 @@ void CompletionQueueAsyncWorker::Execute() {
grpc_completion_queue *CompletionQueueAsyncWorker::GetQueue() { return queue; } grpc_completion_queue *CompletionQueueAsyncWorker::GetQueue() { return queue; }
void CompletionQueueAsyncWorker::Next() { void CompletionQueueAsyncWorker::Next() {
NanScope(); Nan::HandleScope scope;
if (current_threads < max_queue_threads) { if (current_threads < max_queue_threads) {
CompletionQueueAsyncWorker *worker = new CompletionQueueAsyncWorker(); CompletionQueueAsyncWorker *worker = new CompletionQueueAsyncWorker();
NanAsyncQueueWorker(worker); Nan::AsyncQueueWorker(worker);
} else { } else {
waiting_next_calls += 1; waiting_next_calls += 1;
} }
} }
void CompletionQueueAsyncWorker::Init(Handle<Object> exports) { void CompletionQueueAsyncWorker::Init(Local<Object> exports) {
NanScope(); Nan::HandleScope scope;
current_threads = 0; current_threads = 0;
waiting_next_calls = 0; waiting_next_calls = 0;
queue = grpc_completion_queue_create(NULL); queue = grpc_completion_queue_create(NULL);
} }
void CompletionQueueAsyncWorker::HandleOKCallback() { void CompletionQueueAsyncWorker::HandleOKCallback() {
NanScope(); Nan::HandleScope scope;
if (waiting_next_calls > 0) { if (waiting_next_calls > 0) {
waiting_next_calls -= 1; waiting_next_calls -= 1;
CompletionQueueAsyncWorker *worker = new CompletionQueueAsyncWorker(); CompletionQueueAsyncWorker *worker = new CompletionQueueAsyncWorker();
NanAsyncQueueWorker(worker); Nan::AsyncQueueWorker(worker);
} else { } else {
current_threads -= 1; current_threads -= 1;
} }
NanCallback *callback = GetTagCallback(result.tag); Nan::Callback *callback = GetTagCallback(result.tag);
Handle<Value> argv[] = {NanNull(), GetTagNodeValue(result.tag)}; Local<Value> argv[] = {Nan::Null(), GetTagNodeValue(result.tag)};
callback->Call(2, argv); callback->Call(2, argv);
DestroyTag(result.tag); DestroyTag(result.tag);
} }
void CompletionQueueAsyncWorker::HandleErrorCallback() { void CompletionQueueAsyncWorker::HandleErrorCallback() {
NanScope(); Nan::HandleScope scope;
NanCallback *callback = GetTagCallback(result.tag); Nan::Callback *callback = GetTagCallback(result.tag);
Handle<Value> argv[] = {NanError(ErrorMessage())}; Local<Value> argv[] = {Nan::Error(ErrorMessage())};
callback->Call(1, argv); callback->Call(1, argv);

4
src/node/ext/completion_queue_async_worker.h
Unescape View File

@ -42,7 +42,7 @@ namespace node {
/* A worker that asynchronously calls completion_queue_next, and queues onto the /* 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. */ node event loop a call to the function stored in the event's tag. */
class CompletionQueueAsyncWorker : public NanAsyncWorker { class CompletionQueueAsyncWorker : public Nan::AsyncWorker {
public: public:
CompletionQueueAsyncWorker(); CompletionQueueAsyncWorker();
@ -59,7 +59,7 @@ class CompletionQueueAsyncWorker : public NanAsyncWorker {
static void Next(); static void Next();
/* Initialize the CompletionQueueAsyncWorker class */ /* Initialize the CompletionQueueAsyncWorker class */
static void Init(v8::Handle<v8::Object> exports); static void Init(v8::Local<v8::Object> exports);
protected: protected:
/* Called when Execute has succeeded (completed without setting an error /* Called when Execute has succeeded (completed without setting an error

192
src/node/ext/credentials.cc
Unescape View File

@ -41,20 +41,26 @@
namespace grpc { namespace grpc {
namespace node { 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::Exception;
using v8::External; using v8::External;
using v8::Function; using v8::Function;
using v8::FunctionTemplate; using v8::FunctionTemplate;
using v8::Handle;
using v8::HandleScope;
using v8::Integer; using v8::Integer;
using v8::Local; using v8::Local;
using v8::Object; using v8::Object;
using v8::ObjectTemplate; using v8::ObjectTemplate;
using v8::Persistent;
using v8::Value; using v8::Value;
NanCallback *Credentials::constructor; Nan::Callback *Credentials::constructor;
Persistent<FunctionTemplate> Credentials::fun_tpl; Persistent<FunctionTemplate> Credentials::fun_tpl;
Credentials::Credentials(grpc_credentials *credentials) Credentials::Credentials(grpc_credentials *credentials)
@ -64,40 +70,52 @@ Credentials::~Credentials() {
grpc_credentials_release(wrapped_credentials); grpc_credentials_release(wrapped_credentials);
} }
void Credentials::Init(Handle<Object> exports) { void Credentials::Init(Local<Object> exports) {
NanScope(); HandleScope scope;
Local<FunctionTemplate> tpl = NanNew<FunctionTemplate>(New); Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(New);
tpl->SetClassName(NanNew("Credentials")); tpl->SetClassName(Nan::New("Credentials").ToLocalChecked());
tpl->InstanceTemplate()->SetInternalFieldCount(1); tpl->InstanceTemplate()->SetInternalFieldCount(1);
NanAssignPersistent(fun_tpl, tpl); fun_tpl.Reset(tpl);
Handle<Function> ctr = tpl->GetFunction(); Local<Function> ctr = Nan::GetFunction(tpl).ToLocalChecked();
ctr->Set(NanNew("createDefault"), Nan::Set(ctr, Nan::New("createDefault").ToLocalChecked(),
NanNew<FunctionTemplate>(CreateDefault)->GetFunction()); Nan::GetFunction(
ctr->Set(NanNew("createSsl"), Nan::New<FunctionTemplate>(CreateDefault)).ToLocalChecked());
NanNew<FunctionTemplate>(CreateSsl)->GetFunction()); Nan::Set(ctr, Nan::New("createSsl").ToLocalChecked(),
ctr->Set(NanNew("createComposite"), Nan::GetFunction(
NanNew<FunctionTemplate>(CreateComposite)->GetFunction()); Nan::New<FunctionTemplate>(CreateSsl)).ToLocalChecked());
ctr->Set(NanNew("createGce"), Nan::Set(ctr, Nan::New("createComposite").ToLocalChecked(),
NanNew<FunctionTemplate>(CreateGce)->GetFunction()); Nan::GetFunction(
ctr->Set(NanNew("createIam"), Nan::New<FunctionTemplate>(CreateComposite)).ToLocalChecked());
NanNew<FunctionTemplate>(CreateIam)->GetFunction()); Nan::Set(ctr, Nan::New("createGce").ToLocalChecked(),
ctr->Set(NanNew("createInsecure"), Nan::GetFunction(
NanNew<FunctionTemplate>(CreateInsecure)->GetFunction()); Nan::New<FunctionTemplate>(CreateGce)).ToLocalChecked());
constructor = new NanCallback(ctr); Nan::Set(ctr, Nan::New("createIam").ToLocalChecked(),
exports->Set(NanNew("Credentials"), ctr); 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) { bool Credentials::HasInstance(Local<Value> val) {
NanScope(); HandleScope scope;
return NanHasInstance(fun_tpl, val); return Nan::New(fun_tpl)->HasInstance(val);
} }
Handle<Value> Credentials::WrapStruct(grpc_credentials *credentials) { Local<Value> Credentials::WrapStruct(grpc_credentials *credentials) {
NanEscapableScope(); EscapableHandleScope scope;
const int argc = 1; const int argc = 1;
Handle<Value> argv[argc] = { Local<Value> argv[argc] = {
NanNew<External>(reinterpret_cast<void *>(credentials))}; Nan::New<External>(reinterpret_cast<void *>(credentials))};
return NanEscapeScope(constructor->GetFunction()->NewInstance(argc, argv)); 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() { grpc_credentials *Credentials::GetWrappedCredentials() {
@ -105,115 +123,123 @@ grpc_credentials *Credentials::GetWrappedCredentials() {
} }
NAN_METHOD(Credentials::New) { NAN_METHOD(Credentials::New) {
NanScope(); if (info.IsConstructCall()) {
if (!info[0]->IsExternal()) {
if (args.IsConstructCall()) { return Nan::ThrowTypeError(
if (!args[0]->IsExternal()) {
return NanThrowTypeError(
"Credentials can only be created with the provided functions"); "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 = grpc_credentials *creds_value =
reinterpret_cast<grpc_credentials *>(ext->Value()); reinterpret_cast<grpc_credentials *>(ext->Value());
Credentials *credentials = new Credentials(creds_value); Credentials *credentials = new Credentials(creds_value);
credentials->Wrap(args.This()); credentials->Wrap(info.This());
NanReturnValue(args.This()); info.GetReturnValue().Set(info.This());
return;
} else { } else {
const int argc = 1; const int argc = 1;
Local<Value> argv[argc] = {args[0]}; Local<Value> argv[argc] = {info[0]};
NanReturnValue(constructor->GetFunction()->NewInstance(argc, argv)); 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) { NAN_METHOD(Credentials::CreateDefault) {
NanScope();
grpc_credentials *creds = grpc_google_default_credentials_create(); grpc_credentials *creds = grpc_google_default_credentials_create();
if (creds == NULL) { if (creds == NULL) {
NanReturnNull(); info.GetReturnValue().SetNull();
} else {
info.GetReturnValue().Set(WrapStruct(creds));
} }
NanReturnValue(WrapStruct(creds));
} }
NAN_METHOD(Credentials::CreateSsl) { NAN_METHOD(Credentials::CreateSsl) {
NanScope();
char *root_certs = NULL; char *root_certs = NULL;
grpc_ssl_pem_key_cert_pair key_cert_pair = {NULL, NULL}; grpc_ssl_pem_key_cert_pair key_cert_pair = {NULL, NULL};
if (::node::Buffer::HasInstance(args[0])) { if (::node::Buffer::HasInstance(info[0])) {
root_certs = ::node::Buffer::Data(args[0]); root_certs = ::node::Buffer::Data(info[0]);
} else if (!(args[0]->IsNull() || args[0]->IsUndefined())) { } else if (!(info[0]->IsNull() || info[0]->IsUndefined())) {
return NanThrowTypeError("createSsl's first argument must be a Buffer"); return Nan::ThrowTypeError("createSsl's first argument must be a Buffer");
} }
if (::node::Buffer::HasInstance(args[1])) { if (::node::Buffer::HasInstance(info[1])) {
key_cert_pair.private_key = ::node::Buffer::Data(args[1]); key_cert_pair.private_key = ::node::Buffer::Data(info[1]);
} else if (!(args[1]->IsNull() || args[1]->IsUndefined())) { } else if (!(info[1]->IsNull() || info[1]->IsUndefined())) {
return NanThrowTypeError( return Nan::ThrowTypeError(
"createSSl's second argument must be a Buffer if provided"); "createSSl's second argument must be a Buffer if provided");
} }
if (::node::Buffer::HasInstance(args[2])) { if (::node::Buffer::HasInstance(info[2])) {
key_cert_pair.cert_chain = ::node::Buffer::Data(args[2]); key_cert_pair.cert_chain = ::node::Buffer::Data(info[2]);
} else if (!(args[2]->IsNull() || args[2]->IsUndefined())) { } else if (!(info[2]->IsNull() || info[2]->IsUndefined())) {
return NanThrowTypeError( return Nan::ThrowTypeError(
"createSSl's third argument must be a Buffer if provided"); "createSSl's third argument must be a Buffer if provided");
} }
grpc_credentials *creds = grpc_ssl_credentials_create( grpc_credentials *creds = grpc_ssl_credentials_create(
root_certs, key_cert_pair.private_key == NULL ? NULL : &key_cert_pair, root_certs, key_cert_pair.private_key == NULL ? NULL : &key_cert_pair,
NULL); NULL);
if (creds == NULL) { if (creds == NULL) {
NanReturnNull(); info.GetReturnValue().SetNull();
} else {
info.GetReturnValue().Set(WrapStruct(creds));
} }
NanReturnValue(WrapStruct(creds));
} }
NAN_METHOD(Credentials::CreateComposite) { NAN_METHOD(Credentials::CreateComposite) {
NanScope(); if (!HasInstance(info[0])) {
if (!HasInstance(args[0])) { return Nan::ThrowTypeError(
return NanThrowTypeError(
"createComposite's first argument must be a Credentials object"); "createComposite's first argument must be a Credentials object");
} }
if (!HasInstance(args[1])) { if (!HasInstance(info[1])) {
return NanThrowTypeError( return Nan::ThrowTypeError(
"createComposite's second argument must be a Credentials object"); "createComposite's second argument must be a Credentials object");
} }
Credentials *creds1 = ObjectWrap::Unwrap<Credentials>(args[0]->ToObject()); Credentials *creds1 = ObjectWrap::Unwrap<Credentials>(
Credentials *creds2 = ObjectWrap::Unwrap<Credentials>(args[1]->ToObject()); Nan::To<Object>(info[0]).ToLocalChecked());
Credentials *creds2 = ObjectWrap::Unwrap<Credentials>(
Nan::To<Object>(info[1]).ToLocalChecked());
grpc_credentials *creds = grpc_composite_credentials_create( grpc_credentials *creds = grpc_composite_credentials_create(
creds1->wrapped_credentials, creds2->wrapped_credentials, NULL); creds1->wrapped_credentials, creds2->wrapped_credentials, NULL);
if (creds == NULL) { if (creds == NULL) {
NanReturnNull(); info.GetReturnValue().SetNull();
} else {
info.GetReturnValue().Set(WrapStruct(creds));
} }
NanReturnValue(WrapStruct(creds));
} }
NAN_METHOD(Credentials::CreateGce) { NAN_METHOD(Credentials::CreateGce) {
NanScope(); Nan::HandleScope scope;
grpc_credentials *creds = grpc_google_compute_engine_credentials_create(NULL); grpc_credentials *creds = grpc_google_compute_engine_credentials_create(NULL);
if (creds == NULL) { if (creds == NULL) {
NanReturnNull(); info.GetReturnValue().SetNull();
} else {
info.GetReturnValue().Set(WrapStruct(creds));
} }
NanReturnValue(WrapStruct(creds));
} }
NAN_METHOD(Credentials::CreateIam) { NAN_METHOD(Credentials::CreateIam) {
NanScope(); if (!info[0]->IsString()) {
if (!args[0]->IsString()) { return Nan::ThrowTypeError("createIam's first argument must be a string");
return NanThrowTypeError("createIam's first argument must be a string");
} }
if (!args[1]->IsString()) { if (!info[1]->IsString()) {
return NanThrowTypeError("createIam's second argument must be a string"); return Nan::ThrowTypeError("createIam's second argument must be a string");
} }
NanUtf8String auth_token(args[0]); Utf8String auth_token(info[0]);
NanUtf8String auth_selector(args[1]); Utf8String auth_selector(info[1]);
grpc_credentials *creds = grpc_credentials *creds =
grpc_google_iam_credentials_create(*auth_token, *auth_selector, NULL); grpc_google_iam_credentials_create(*auth_token, *auth_selector, NULL);
if (creds == NULL) { if (creds == NULL) {
NanReturnNull(); info.GetReturnValue().SetNull();
} else {
info.GetReturnValue().Set(WrapStruct(creds));
} }
NanReturnValue(WrapStruct(creds));
} }
NAN_METHOD(Credentials::CreateInsecure) { NAN_METHOD(Credentials::CreateInsecure) {
NanScope(); info.GetReturnValue().Set(WrapStruct(NULL));
NanReturnValue(WrapStruct(NULL));
} }
} // namespace node } // namespace node

12
src/node/ext/credentials.h
Unescape View File

@ -43,12 +43,12 @@ namespace grpc {
namespace node { namespace node {
/* Wrapper class for grpc_credentials structs */ /* Wrapper class for grpc_credentials structs */
class Credentials : public ::node::ObjectWrap { class Credentials : public Nan::ObjectWrap {
public: public:
static void Init(v8::Handle<v8::Object> exports); static void Init(v8::Local<v8::Object> exports);
static bool HasInstance(v8::Handle<v8::Value> val); static bool HasInstance(v8::Local<v8::Value> val);
/* Wrap a grpc_credentials struct in a javascript object */ /* 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 */ /* Returns the grpc_credentials struct that this object wraps */
grpc_credentials *GetWrappedCredentials(); grpc_credentials *GetWrappedCredentials();
@ -69,9 +69,9 @@ class Credentials : public ::node::ObjectWrap {
static NAN_METHOD(CreateFake); static NAN_METHOD(CreateFake);
static NAN_METHOD(CreateIam); static NAN_METHOD(CreateIam);
static NAN_METHOD(CreateInsecure); static NAN_METHOD(CreateInsecure);
static NanCallback *constructor; static Nan::Callback *constructor;
// Used for typechecking instances of this javascript class // 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; grpc_credentials *wrapped_credentials;
}; };

319
src/node/ext/node_grpc.cc
Unescape View File

@ -43,171 +43,194 @@
#include "credentials.h" #include "credentials.h"
#include "server_credentials.h" #include "server_credentials.h"
using v8::Handle; using v8::Local;
using v8::Value; using v8::Value;
using v8::Object; using v8::Object;
using v8::Uint32; using v8::Uint32;
using v8::String; using v8::String;
void InitStatusConstants(Handle<Object> exports) { void InitStatusConstants(Local<Object> exports) {
NanScope(); Nan::HandleScope scope;
Handle<Object> status = NanNew<Object>(); Local<Object> status = Nan::New<Object>();
exports->Set(NanNew("status"), status); Nan::Set(exports, Nan::New("status").ToLocalChecked(), status);
Handle<Value> OK(NanNew<Uint32, uint32_t>(GRPC_STATUS_OK)); Local<Value> OK(Nan::New<Uint32, uint32_t>(GRPC_STATUS_OK));
status->Set(NanNew("OK"), OK); Nan::Set(status, Nan::New("OK").ToLocalChecked(), OK);
Handle<Value> CANCELLED(NanNew<Uint32, uint32_t>(GRPC_STATUS_CANCELLED)); Local<Value> CANCELLED(Nan::New<Uint32, uint32_t>(GRPC_STATUS_CANCELLED));
status->Set(NanNew("CANCELLED"), CANCELLED); Nan::Set(status, Nan::New("CANCELLED").ToLocalChecked(), CANCELLED);
Handle<Value> UNKNOWN(NanNew<Uint32, uint32_t>(GRPC_STATUS_UNKNOWN)); Local<Value> UNKNOWN(Nan::New<Uint32, uint32_t>(GRPC_STATUS_UNKNOWN));
status->Set(NanNew("UNKNOWN"), UNKNOWN); Nan::Set(status, Nan::New("UNKNOWN").ToLocalChecked(), UNKNOWN);
Handle<Value> INVALID_ARGUMENT( Local<Value> INVALID_ARGUMENT(
NanNew<Uint32, uint32_t>(GRPC_STATUS_INVALID_ARGUMENT)); Nan::New<Uint32, uint32_t>(GRPC_STATUS_INVALID_ARGUMENT));
status->Set(NanNew("INVALID_ARGUMENT"), INVALID_ARGUMENT); Nan::Set(status, Nan::New("INVALID_ARGUMENT").ToLocalChecked(),
Handle<Value> DEADLINE_EXCEEDED( INVALID_ARGUMENT);
NanNew<Uint32, uint32_t>(GRPC_STATUS_DEADLINE_EXCEEDED)); Local<Value> DEADLINE_EXCEEDED(
status->Set(NanNew("DEADLINE_EXCEEDED"), DEADLINE_EXCEEDED); Nan::New<Uint32, uint32_t>(GRPC_STATUS_DEADLINE_EXCEEDED));
Handle<Value> NOT_FOUND(NanNew<Uint32, uint32_t>(GRPC_STATUS_NOT_FOUND)); Nan::Set(status, Nan::New("DEADLINE_EXCEEDED").ToLocalChecked(),
status->Set(NanNew("NOT_FOUND"), NOT_FOUND); DEADLINE_EXCEEDED);
Handle<Value> ALREADY_EXISTS( Local<Value> NOT_FOUND(Nan::New<Uint32, uint32_t>(GRPC_STATUS_NOT_FOUND));
NanNew<Uint32, uint32_t>(GRPC_STATUS_ALREADY_EXISTS)); Nan::Set(status, Nan::New("NOT_FOUND").ToLocalChecked(), NOT_FOUND);
status->Set(NanNew("ALREADY_EXISTS"), ALREADY_EXISTS); Local<Value> ALREADY_EXISTS(
Handle<Value> PERMISSION_DENIED( Nan::New<Uint32, uint32_t>(GRPC_STATUS_ALREADY_EXISTS));
NanNew<Uint32, uint32_t>(GRPC_STATUS_PERMISSION_DENIED)); Nan::Set(status, Nan::New("ALREADY_EXISTS").ToLocalChecked(), ALREADY_EXISTS);
status->Set(NanNew("PERMISSION_DENIED"), PERMISSION_DENIED); Local<Value> PERMISSION_DENIED(
Handle<Value> UNAUTHENTICATED( Nan::New<Uint32, uint32_t>(GRPC_STATUS_PERMISSION_DENIED));
NanNew<Uint32, uint32_t>(GRPC_STATUS_UNAUTHENTICATED)); Nan::Set(status, Nan::New("PERMISSION_DENIED").ToLocalChecked(),
status->Set(NanNew("UNAUTHENTICATED"), UNAUTHENTICATED); PERMISSION_DENIED);
Handle<Value> RESOURCE_EXHAUSTED( Local<Value> UNAUTHENTICATED(
NanNew<Uint32, uint32_t>(GRPC_STATUS_RESOURCE_EXHAUSTED)); Nan::New<Uint32, uint32_t>(GRPC_STATUS_UNAUTHENTICATED));
status->Set(NanNew("RESOURCE_EXHAUSTED"), RESOURCE_EXHAUSTED); Nan::Set(status, Nan::New("UNAUTHENTICATED").ToLocalChecked(),
Handle<Value> FAILED_PRECONDITION( UNAUTHENTICATED);
NanNew<Uint32, uint32_t>(GRPC_STATUS_FAILED_PRECONDITION)); Local<Value> RESOURCE_EXHAUSTED(
status->Set(NanNew("FAILED_PRECONDITION"), FAILED_PRECONDITION); Nan::New<Uint32, uint32_t>(GRPC_STATUS_RESOURCE_EXHAUSTED));
Handle<Value> ABORTED(NanNew<Uint32, uint32_t>(GRPC_STATUS_ABORTED)); Nan::Set(status, Nan::New("RESOURCE_EXHAUSTED").ToLocalChecked(),
status->Set(NanNew("ABORTED"), ABORTED); RESOURCE_EXHAUSTED);
Handle<Value> OUT_OF_RANGE( Local<Value> FAILED_PRECONDITION(
NanNew<Uint32, uint32_t>(GRPC_STATUS_OUT_OF_RANGE)); Nan::New<Uint32, uint32_t>(GRPC_STATUS_FAILED_PRECONDITION));
status->Set(NanNew("OUT_OF_RANGE"), OUT_OF_RANGE); Nan::Set(status, Nan::New("FAILED_PRECONDITION").ToLocalChecked(),
Handle<Value> UNIMPLEMENTED( FAILED_PRECONDITION);
NanNew<Uint32, uint32_t>(GRPC_STATUS_UNIMPLEMENTED)); Local<Value> ABORTED(Nan::New<Uint32, uint32_t>(GRPC_STATUS_ABORTED));
status->Set(NanNew("UNIMPLEMENTED"), UNIMPLEMENTED); Nan::Set(status, Nan::New("ABORTED").ToLocalChecked(), ABORTED);
Handle<Value> INTERNAL(NanNew<Uint32, uint32_t>(GRPC_STATUS_INTERNAL)); Local<Value> OUT_OF_RANGE(
status->Set(NanNew("INTERNAL"), INTERNAL); Nan::New<Uint32, uint32_t>(GRPC_STATUS_OUT_OF_RANGE));
Handle<Value> UNAVAILABLE(NanNew<Uint32, uint32_t>(GRPC_STATUS_UNAVAILABLE)); Nan::Set(status, Nan::New("OUT_OF_RANGE").ToLocalChecked(), OUT_OF_RANGE);
status->Set(NanNew("UNAVAILABLE"), UNAVAILABLE); Local<Value> UNIMPLEMENTED(
Handle<Value> DATA_LOSS(NanNew<Uint32, uint32_t>(GRPC_STATUS_DATA_LOSS)); Nan::New<Uint32, uint32_t>(GRPC_STATUS_UNIMPLEMENTED));
status->Set(NanNew("DATA_LOSS"), DATA_LOSS); 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) { void InitCallErrorConstants(Local<Object> exports) {
NanScope(); Nan::HandleScope scope;
Handle<Object> call_error = NanNew<Object>(); Local<Object> call_error = Nan::New<Object>();
exports->Set(NanNew("callError"), call_error); Nan::Set(exports, Nan::New("callError").ToLocalChecked(), call_error);
Handle<Value> OK(NanNew<Uint32, uint32_t>(GRPC_CALL_OK)); Local<Value> OK(Nan::New<Uint32, uint32_t>(GRPC_CALL_OK));
call_error->Set(NanNew("OK"), OK); Nan::Set(call_error, Nan::New("OK").ToLocalChecked(), OK);
Handle<Value> ERROR(NanNew<Uint32, uint32_t>(GRPC_CALL_ERROR)); Local<Value> ERROR(Nan::New<Uint32, uint32_t>(GRPC_CALL_ERROR));
call_error->Set(NanNew("ERROR"), ERROR); Nan::Set(call_error, Nan::New("ERROR").ToLocalChecked(), ERROR);
Handle<Value> NOT_ON_SERVER( Local<Value> NOT_ON_SERVER(
NanNew<Uint32, uint32_t>(GRPC_CALL_ERROR_NOT_ON_SERVER)); Nan::New<Uint32, uint32_t>(GRPC_CALL_ERROR_NOT_ON_SERVER));
call_error->Set(NanNew("NOT_ON_SERVER"), NOT_ON_SERVER); Nan::Set(call_error, Nan::New("NOT_ON_SERVER").ToLocalChecked(),
Handle<Value> NOT_ON_CLIENT( NOT_ON_SERVER);
NanNew<Uint32, uint32_t>(GRPC_CALL_ERROR_NOT_ON_CLIENT)); Local<Value> NOT_ON_CLIENT(
call_error->Set(NanNew("NOT_ON_CLIENT"), NOT_ON_CLIENT); Nan::New<Uint32, uint32_t>(GRPC_CALL_ERROR_NOT_ON_CLIENT));
Handle<Value> ALREADY_INVOKED( Nan::Set(call_error, Nan::New("NOT_ON_CLIENT").ToLocalChecked(),
NanNew<Uint32, uint32_t>(GRPC_CALL_ERROR_ALREADY_INVOKED)); NOT_ON_CLIENT);
call_error->Set(NanNew("ALREADY_INVOKED"), ALREADY_INVOKED); Local<Value> ALREADY_INVOKED(
Handle<Value> NOT_INVOKED( Nan::New<Uint32, uint32_t>(GRPC_CALL_ERROR_ALREADY_INVOKED));
NanNew<Uint32, uint32_t>(GRPC_CALL_ERROR_NOT_INVOKED)); Nan::Set(call_error, Nan::New("ALREADY_INVOKED").ToLocalChecked(),
call_error->Set(NanNew("NOT_INVOKED"), NOT_INVOKED); ALREADY_INVOKED);
Handle<Value> ALREADY_FINISHED( Local<Value> NOT_INVOKED(
NanNew<Uint32, uint32_t>(GRPC_CALL_ERROR_ALREADY_FINISHED)); Nan::New<Uint32, uint32_t>(GRPC_CALL_ERROR_NOT_INVOKED));
call_error->Set(NanNew("ALREADY_FINISHED"), ALREADY_FINISHED); Nan::Set(call_error, Nan::New("NOT_INVOKED").ToLocalChecked(), NOT_INVOKED);
Handle<Value> TOO_MANY_OPERATIONS( Local<Value> ALREADY_FINISHED(
NanNew<Uint32, uint32_t>(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS)); Nan::New<Uint32, uint32_t>(GRPC_CALL_ERROR_ALREADY_FINISHED));
call_error->Set(NanNew("TOO_MANY_OPERATIONS"), TOO_MANY_OPERATIONS); Nan::Set(call_error, Nan::New("ALREADY_FINISHED").ToLocalChecked(),
Handle<Value> INVALID_FLAGS( ALREADY_FINISHED);
NanNew<Uint32, uint32_t>(GRPC_CALL_ERROR_INVALID_FLAGS)); Local<Value> TOO_MANY_OPERATIONS(
call_error->Set(NanNew("INVALID_FLAGS"), INVALID_FLAGS); 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) { void InitOpTypeConstants(Local<Object> exports) {
NanScope(); Nan::HandleScope scope;
Handle<Object> op_type = NanNew<Object>(); Local<Object> op_type = Nan::New<Object>();
exports->Set(NanNew("opType"), op_type); Nan::Set(exports, Nan::New("opType").ToLocalChecked(), op_type);
Handle<Value> SEND_INITIAL_METADATA( Local<Value> SEND_INITIAL_METADATA(
NanNew<Uint32, uint32_t>(GRPC_OP_SEND_INITIAL_METADATA)); Nan::New<Uint32, uint32_t>(GRPC_OP_SEND_INITIAL_METADATA));
op_type->Set(NanNew("SEND_INITIAL_METADATA"), SEND_INITIAL_METADATA); Nan::Set(op_type, Nan::New("SEND_INITIAL_METADATA").ToLocalChecked(),
Handle<Value> SEND_MESSAGE( SEND_INITIAL_METADATA);
NanNew<Uint32, uint32_t>(GRPC_OP_SEND_MESSAGE)); Local<Value> SEND_MESSAGE(
op_type->Set(NanNew("SEND_MESSAGE"), SEND_MESSAGE); Nan::New<Uint32, uint32_t>(GRPC_OP_SEND_MESSAGE));
Handle<Value> SEND_CLOSE_FROM_CLIENT( Nan::Set(op_type, Nan::New("SEND_MESSAGE").ToLocalChecked(), SEND_MESSAGE);
NanNew<Uint32, uint32_t>(GRPC_OP_SEND_CLOSE_FROM_CLIENT)); Local<Value> SEND_CLOSE_FROM_CLIENT(
op_type->Set(NanNew("SEND_CLOSE_FROM_CLIENT"), SEND_CLOSE_FROM_CLIENT); Nan::New<Uint32, uint32_t>(GRPC_OP_SEND_CLOSE_FROM_CLIENT));
Handle<Value> SEND_STATUS_FROM_SERVER( Nan::Set(op_type, Nan::New("SEND_CLOSE_FROM_CLIENT").ToLocalChecked(),
NanNew<Uint32, uint32_t>(GRPC_OP_SEND_STATUS_FROM_SERVER)); SEND_CLOSE_FROM_CLIENT);
op_type->Set(NanNew("SEND_STATUS_FROM_SERVER"), SEND_STATUS_FROM_SERVER); Local<Value> SEND_STATUS_FROM_SERVER(
Handle<Value> RECV_INITIAL_METADATA( Nan::New<Uint32, uint32_t>(GRPC_OP_SEND_STATUS_FROM_SERVER));
NanNew<Uint32, uint32_t>(GRPC_OP_RECV_INITIAL_METADATA)); Nan::Set(op_type, Nan::New("SEND_STATUS_FROM_SERVER").ToLocalChecked(),
op_type->Set(NanNew("RECV_INITIAL_METADATA"), RECV_INITIAL_METADATA); SEND_STATUS_FROM_SERVER);
Handle<Value> RECV_MESSAGE( Local<Value> RECV_INITIAL_METADATA(
NanNew<Uint32, uint32_t>(GRPC_OP_RECV_MESSAGE)); Nan::New<Uint32, uint32_t>(GRPC_OP_RECV_INITIAL_METADATA));
op_type->Set(NanNew("RECV_MESSAGE"), RECV_MESSAGE); Nan::Set(op_type, Nan::New("RECV_INITIAL_METADATA").ToLocalChecked(),
Handle<Value> RECV_STATUS_ON_CLIENT( RECV_INITIAL_METADATA);
NanNew<Uint32, uint32_t>(GRPC_OP_RECV_STATUS_ON_CLIENT)); Local<Value> RECV_MESSAGE(
op_type->Set(NanNew("RECV_STATUS_ON_CLIENT"), RECV_STATUS_ON_CLIENT); Nan::New<Uint32, uint32_t>(GRPC_OP_RECV_MESSAGE));
Handle<Value> RECV_CLOSE_ON_SERVER( Nan::Set(op_type, Nan::New("RECV_MESSAGE").ToLocalChecked(), RECV_MESSAGE);
NanNew<Uint32, uint32_t>(GRPC_OP_RECV_CLOSE_ON_SERVER)); Local<Value> RECV_STATUS_ON_CLIENT(
op_type->Set(NanNew("RECV_CLOSE_ON_SERVER"), RECV_CLOSE_ON_SERVER); 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) { void InitPropagateConstants(Local<Object> exports) {
NanScope(); Nan::HandleScope scope;
Handle<Object> propagate = NanNew<Object>(); Local<Object> propagate = Nan::New<Object>();
exports->Set(NanNew("propagate"), propagate); Nan::Set(exports, Nan::New("propagate").ToLocalChecked(), propagate);
Handle<Value> DEADLINE(NanNew<Uint32, uint32_t>(GRPC_PROPAGATE_DEADLINE)); Local<Value> DEADLINE(Nan::New<Uint32, uint32_t>(GRPC_PROPAGATE_DEADLINE));
propagate->Set(NanNew("DEADLINE"), DEADLINE); Nan::Set(propagate, Nan::New("DEADLINE").ToLocalChecked(), DEADLINE);
Handle<Value> CENSUS_STATS_CONTEXT( Local<Value> CENSUS_STATS_CONTEXT(
NanNew<Uint32, uint32_t>(GRPC_PROPAGATE_CENSUS_STATS_CONTEXT)); Nan::New<Uint32, uint32_t>(GRPC_PROPAGATE_CENSUS_STATS_CONTEXT));
propagate->Set(NanNew("CENSUS_STATS_CONTEXT"), CENSUS_STATS_CONTEXT); Nan::Set(propagate, Nan::New("CENSUS_STATS_CONTEXT").ToLocalChecked(),
Handle<Value> CENSUS_TRACING_CONTEXT( CENSUS_STATS_CONTEXT);
NanNew<Uint32, uint32_t>(GRPC_PROPAGATE_CENSUS_TRACING_CONTEXT)); Local<Value> CENSUS_TRACING_CONTEXT(
propagate->Set(NanNew("CENSUS_TRACING_CONTEXT"), CENSUS_TRACING_CONTEXT); Nan::New<Uint32, uint32_t>(GRPC_PROPAGATE_CENSUS_TRACING_CONTEXT));
Handle<Value> CANCELLATION( Nan::Set(propagate, Nan::New("CENSUS_TRACING_CONTEXT").ToLocalChecked(),
NanNew<Uint32, uint32_t>(GRPC_PROPAGATE_CANCELLATION)); CENSUS_TRACING_CONTEXT);
propagate->Set(NanNew("CANCELLATION"), CANCELLATION); Local<Value> CANCELLATION(
Handle<Value> DEFAULTS(NanNew<Uint32, uint32_t>(GRPC_PROPAGATE_DEFAULTS)); Nan::New<Uint32, uint32_t>(GRPC_PROPAGATE_CANCELLATION));
propagate->Set(NanNew("DEFAULTS"), DEFAULTS); 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) { void InitConnectivityStateConstants(Local<Object> exports) {
NanScope(); Nan::HandleScope scope;
Handle<Object> channel_state = NanNew<Object>(); Local<Object> channel_state = Nan::New<Object>();
exports->Set(NanNew("connectivityState"), channel_state); Nan::Set(exports, Nan::New("connectivityState").ToLocalChecked(),
Handle<Value> IDLE(NanNew<Uint32, uint32_t>(GRPC_CHANNEL_IDLE)); channel_state);
channel_state->Set(NanNew("IDLE"), IDLE); Local<Value> IDLE(Nan::New<Uint32, uint32_t>(GRPC_CHANNEL_IDLE));
Handle<Value> CONNECTING(NanNew<Uint32, uint32_t>(GRPC_CHANNEL_CONNECTING)); Nan::Set(channel_state, Nan::New("IDLE").ToLocalChecked(), IDLE);
channel_state->Set(NanNew("CONNECTING"), CONNECTING); Local<Value> CONNECTING(Nan::New<Uint32, uint32_t>(GRPC_CHANNEL_CONNECTING));
Handle<Value> READY(NanNew<Uint32, uint32_t>(GRPC_CHANNEL_READY)); Nan::Set(channel_state, Nan::New("CONNECTING").ToLocalChecked(), CONNECTING);
channel_state->Set(NanNew("READY"), READY); Local<Value> READY(Nan::New<Uint32, uint32_t>(GRPC_CHANNEL_READY));
Handle<Value> TRANSIENT_FAILURE( Nan::Set(channel_state, Nan::New("READY").ToLocalChecked(), READY);
NanNew<Uint32, uint32_t>(GRPC_CHANNEL_TRANSIENT_FAILURE)); Local<Value> TRANSIENT_FAILURE(
channel_state->Set(NanNew("TRANSIENT_FAILURE"), TRANSIENT_FAILURE); Nan::New<Uint32, uint32_t>(GRPC_CHANNEL_TRANSIENT_FAILURE));
Handle<Value> FATAL_FAILURE( Nan::Set(channel_state, Nan::New("TRANSIENT_FAILURE").ToLocalChecked(),
NanNew<Uint32, uint32_t>(GRPC_CHANNEL_FATAL_FAILURE)); TRANSIENT_FAILURE);
channel_state->Set(NanNew("FATAL_FAILURE"), FATAL_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) { void InitWriteFlags(Local<Object> exports) {
NanScope(); Nan::HandleScope scope;
Handle<Object> write_flags = NanNew<Object>(); Local<Object> write_flags = Nan::New<Object>();
exports->Set(NanNew("writeFlags"), write_flags); Nan::Set(exports, Nan::New("writeFlags").ToLocalChecked(), write_flags);
Handle<Value> BUFFER_HINT(NanNew<Uint32, uint32_t>(GRPC_WRITE_BUFFER_HINT)); Local<Value> BUFFER_HINT(Nan::New<Uint32, uint32_t>(GRPC_WRITE_BUFFER_HINT));
write_flags->Set(NanNew("BUFFER_HINT"), BUFFER_HINT); Nan::Set(write_flags, Nan::New("BUFFER_HINT").ToLocalChecked(), BUFFER_HINT);
Handle<Value> NO_COMPRESS(NanNew<Uint32, uint32_t>(GRPC_WRITE_NO_COMPRESS)); Local<Value> NO_COMPRESS(Nan::New<Uint32, uint32_t>(GRPC_WRITE_NO_COMPRESS));
write_flags->Set(NanNew("NO_COMPRESS"), NO_COMPRESS); Nan::Set(write_flags, Nan::New("NO_COMPRESS").ToLocalChecked(), NO_COMPRESS);
} }
void init(Handle<Object> exports) { void init(Local<Object> exports) {
NanScope(); Nan::HandleScope scope;
grpc_init(); grpc_init();
InitStatusConstants(exports); InitStatusConstants(exports);
InitCallErrorConstants(exports); InitCallErrorConstants(exports);

202
src/node/ext/server.cc
Unescape View File

@ -50,6 +50,15 @@
namespace grpc { namespace grpc {
namespace node { 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 std::unique_ptr;
using v8::Array; using v8::Array;
using v8::Boolean; using v8::Boolean;
@ -57,16 +66,13 @@ using v8::Date;
using v8::Exception; using v8::Exception;
using v8::Function; using v8::Function;
using v8::FunctionTemplate; using v8::FunctionTemplate;
using v8::Handle;
using v8::HandleScope;
using v8::Local; using v8::Local;
using v8::Number; using v8::Number;
using v8::Object; using v8::Object;
using v8::Persistent;
using v8::String; using v8::String;
using v8::Value; using v8::Value;
NanCallback *Server::constructor; Nan::Callback *Server::constructor;
Persistent<FunctionTemplate> Server::fun_tpl; Persistent<FunctionTemplate> Server::fun_tpl;
class NewCallOp : public Op { class NewCallOp : public Op {
@ -82,22 +88,26 @@ class NewCallOp : public Op {
grpc_metadata_array_destroy(&request_metadata); grpc_metadata_array_destroy(&request_metadata);
} }
Handle<Value> GetNodeValue() const { Local<Value> GetNodeValue() const {
NanEscapableScope(); Nan::EscapableHandleScope scope;
if (call == NULL) { if (call == NULL) {
return NanEscapeScope(NanNull()); return scope.Escape(Nan::Null());
} }
Handle<Object> obj = NanNew<Object>(); Local<Object> obj = Nan::New<Object>();
obj->Set(NanNew("call"), Call::WrapStruct(call)); Nan::Set(obj, Nan::New("call").ToLocalChecked(), Call::WrapStruct(call));
obj->Set(NanNew("method"), NanNew(details.method)); Nan::Set(obj, Nan::New("method").ToLocalChecked(),
obj->Set(NanNew("host"), NanNew(details.host)); Nan::New(details.method).ToLocalChecked());
obj->Set(NanNew("deadline"), Nan::Set(obj, Nan::New("host").ToLocalChecked(),
NanNew<Date>(TimespecToMilliseconds(details.deadline))); Nan::New(details.host).ToLocalChecked());
obj->Set(NanNew("metadata"), ParseMetadata(&request_metadata)); Nan::Set(obj, Nan::New("deadline").ToLocalChecked(),
return NanEscapeScope(obj); 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) { shared_ptr<Resources> resources) {
return true; return true;
} }
@ -124,35 +134,25 @@ Server::~Server() {
grpc_completion_queue_destroy(this->shutdown_queue); grpc_completion_queue_destroy(this->shutdown_queue);
} }
void Server::Init(Handle<Object> exports) { void Server::Init(Local<Object> exports) {
NanScope(); HandleScope scope;
Local<FunctionTemplate> tpl = NanNew<FunctionTemplate>(New); Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(New);
tpl->SetClassName(NanNew("Server")); tpl->SetClassName(Nan::New("Server").ToLocalChecked());
tpl->InstanceTemplate()->SetInternalFieldCount(1); tpl->InstanceTemplate()->SetInternalFieldCount(1);
NanSetPrototypeTemplate(tpl, "requestCall", Nan::SetPrototypeMethod(tpl, "requestCall", RequestCall);
NanNew<FunctionTemplate>(RequestCall)->GetFunction()); Nan::SetPrototypeMethod(tpl, "addHttp2Port", AddHttp2Port);
Nan::SetPrototypeMethod(tpl, "start", Start);
NanSetPrototypeTemplate( Nan::SetPrototypeMethod(tpl, "tryShutdown", TryShutdown);
tpl, "addHttp2Port", Nan::SetPrototypeMethod(tpl, "forceShutdown", ForceShutdown);
NanNew<FunctionTemplate>(AddHttp2Port)->GetFunction()); fun_tpl.Reset(tpl);
Local<Function> ctr = Nan::GetFunction(tpl).ToLocalChecked();
NanSetPrototypeTemplate(tpl, "start", Nan::Set(exports, Nan::New("Server").ToLocalChecked(), ctr);
NanNew<FunctionTemplate>(Start)->GetFunction()); constructor = new Callback(ctr);
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);
} }
bool Server::HasInstance(Handle<Value> val) { bool Server::HasInstance(Local<Value> val) {
return NanHasInstance(fun_tpl, val); HandleScope scope;
return Nan::New(fun_tpl)->HasInstance(val);
} }
void Server::ShutdownServer() { void Server::ShutdownServer() {
@ -165,64 +165,77 @@ void Server::ShutdownServer() {
} }
NAN_METHOD(Server::New) { NAN_METHOD(Server::New) {
NanScope();
/* If this is not a constructor call, make a constructor call and return /* If this is not a constructor call, make a constructor call and return
the result */ the result */
if (!args.IsConstructCall()) { if (!info.IsConstructCall()) {
const int argc = 1; const int argc = 1;
Local<Value> argv[argc] = {args[0]}; Local<Value> argv[argc] = {info[0]};
NanReturnValue(constructor->GetFunction()->NewInstance(argc, argv)); 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_server *wrapped_server;
grpc_completion_queue *queue = CompletionQueueAsyncWorker::GetQueue(); grpc_completion_queue *queue = CompletionQueueAsyncWorker::GetQueue();
if (args[0]->IsUndefined()) { if (info[0]->IsUndefined()) {
wrapped_server = grpc_server_create(NULL, NULL); wrapped_server = grpc_server_create(NULL, NULL);
} else if (args[0]->IsObject()) { } else if (info[0]->IsObject()) {
Handle<Object> args_hash(args[0]->ToObject()); Local<Object> args_hash = Nan::To<Object>(info[0]).ToLocalChecked();
Handle<Array> keys(args_hash->GetOwnPropertyNames()); Local<Array> keys = Nan::GetOwnPropertyNames(args_hash).ToLocalChecked();
grpc_channel_args channel_args; grpc_channel_args channel_args;
channel_args.num_args = keys->Length(); channel_args.num_args = keys->Length();
channel_args.args = reinterpret_cast<grpc_arg *>( channel_args.args = reinterpret_cast<grpc_arg *>(
calloc(channel_args.num_args, sizeof(grpc_arg))); calloc(channel_args.num_args, sizeof(grpc_arg)));
/* These are used to keep all strings until then end of the block, then /* These are used to keep all strings until then end of the block, then
destroy them */ destroy them */
std::vector<NanUtf8String *> key_strings(keys->Length()); std::vector<Utf8String *> key_strings(keys->Length());
std::vector<NanUtf8String *> value_strings(keys->Length()); std::vector<Utf8String *> value_strings(keys->Length());
for (unsigned int i = 0; i < channel_args.num_args; i++) { for (unsigned int i = 0; i < channel_args.num_args; i++) {
Handle<String> current_key(keys->Get(i)->ToString()); MaybeLocal<String> maybe_key = Nan::To<String>(
Handle<Value> current_value(args_hash->Get(current_key)); Nan::Get(keys, i).ToLocalChecked());
key_strings[i] = new NanUtf8String(current_key); 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]; channel_args.args[i].key = **key_strings[i];
if (current_value->IsInt32()) { if (current_value->IsInt32()) {
channel_args.args[i].type = GRPC_ARG_INTEGER; 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()) { } else if (current_value->IsString()) {
channel_args.args[i].type = GRPC_ARG_STRING; 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]; channel_args.args[i].value.string = **value_strings[i];
} else { } else {
free(channel_args.args); 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); wrapped_server = grpc_server_create(&channel_args, NULL);
free(channel_args.args); free(channel_args.args);
} else { } else {
return NanThrowTypeError("Server expects an object"); return Nan::ThrowTypeError("Server expects an object");
} }
grpc_server_register_completion_queue(wrapped_server, queue, NULL); grpc_server_register_completion_queue(wrapped_server, queue, NULL);
Server *server = new Server(wrapped_server); Server *server = new Server(wrapped_server);
server->Wrap(args.This()); server->Wrap(info.This());
NanReturnValue(args.This()); info.GetReturnValue().Set(info.This());
} }
NAN_METHOD(Server::RequestCall) { NAN_METHOD(Server::RequestCall) {
NanScope(); if (!HasInstance(info.This())) {
if (!HasInstance(args.This())) { return Nan::ThrowTypeError("requestCall can only be called on a Server");
return NanThrowTypeError("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(); NewCallOp *op = new NewCallOp();
unique_ptr<OpVec> ops(new OpVec()); unique_ptr<OpVec> ops(new OpVec());
ops->push_back(unique_ptr<Op>(op)); 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, server->wrapped_server, &op->call, &op->details, &op->request_metadata,
CompletionQueueAsyncWorker::GetQueue(), CompletionQueueAsyncWorker::GetQueue(),
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))); shared_ptr<Resources>(nullptr)));
if (error != GRPC_CALL_OK) { if (error != GRPC_CALL_OK) {
return NanThrowError(nanErrorWithCode("requestCall failed", error)); return Nan::ThrowError(nanErrorWithCode("requestCall failed", error));
} }
CompletionQueueAsyncWorker::Next(); CompletionQueueAsyncWorker::Next();
NanReturnUndefined();
} }
NAN_METHOD(Server::AddHttp2Port) { NAN_METHOD(Server::AddHttp2Port) {
NanScope(); if (!HasInstance(info.This())) {
if (!HasInstance(args.This())) { return Nan::ThrowTypeError(
return NanThrowTypeError(
"addHttp2Port can only be called on a Server"); "addHttp2Port can only be called on a Server");
} }
if (!args[0]->IsString()) { if (!info[0]->IsString()) {
return NanThrowTypeError( return Nan::ThrowTypeError(
"addHttp2Port's first argument must be a String"); "addHttp2Port's first argument must be a String");
} }
if (!ServerCredentials::HasInstance(args[1])) { if (!ServerCredentials::HasInstance(info[1])) {
return NanThrowTypeError( return Nan::ThrowTypeError(
"addHttp2Port's second argument must be ServerCredentials"); "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>( ServerCredentials *creds_object = ObjectWrap::Unwrap<ServerCredentials>(
args[1]->ToObject()); Nan::To<Object>(info[1]).ToLocalChecked());
grpc_server_credentials *creds = creds_object->GetWrappedServerCredentials(); grpc_server_credentials *creds = creds_object->GetWrappedServerCredentials();
int port; int port;
if (creds == NULL) { if (creds == NULL) {
port = grpc_server_add_insecure_http2_port(server->wrapped_server, port = grpc_server_add_insecure_http2_port(server->wrapped_server,
*NanUtf8String(args[0])); *Utf8String(info[0]));
} else { } else {
port = grpc_server_add_secure_http2_port(server->wrapped_server, port = grpc_server_add_secure_http2_port(server->wrapped_server,
*NanUtf8String(args[0]), *Utf8String(info[0]),
creds); creds);
} }
NanReturnValue(NanNew<Number>(port)); info.GetReturnValue().Set(Nan::New<Number>(port));
} }
NAN_METHOD(Server::Start) { NAN_METHOD(Server::Start) {
NanScope(); Nan::HandleScope scope;
if (!HasInstance(args.This())) { if (!HasInstance(info.This())) {
return NanThrowTypeError("start can only be called on a Server"); 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); grpc_server_start(server->wrapped_server);
NanReturnUndefined();
} }
NAN_METHOD(Server::TryShutdown) { NAN_METHOD(Server::TryShutdown) {
NanScope(); Nan::HandleScope scope;
if (!HasInstance(args.This())) { if (!HasInstance(info.This())) {
return NanThrowTypeError("tryShutdown can only be called on a Server"); 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()); unique_ptr<OpVec> ops(new OpVec());
grpc_server_shutdown_and_notify( grpc_server_shutdown_and_notify(
server->wrapped_server, server->wrapped_server,
CompletionQueueAsyncWorker::GetQueue(), 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))); shared_ptr<Resources>(nullptr)));
CompletionQueueAsyncWorker::Next(); CompletionQueueAsyncWorker::Next();
NanReturnUndefined();
} }
NAN_METHOD(Server::ForceShutdown) { NAN_METHOD(Server::ForceShutdown) {
NanScope(); Nan::HandleScope scope;
if (!HasInstance(args.This())) { if (!HasInstance(info.This())) {
return NanThrowTypeError("forceShutdown can only be called on a Server"); 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(); server->ShutdownServer();
NanReturnUndefined();
} }
} // namespace node } // namespace node

10
src/node/ext/server.h
Unescape View File

@ -44,14 +44,14 @@ namespace node {
/* Wraps grpc_server as a JavaScript object. Provides a constructor /* Wraps grpc_server as a JavaScript object. Provides a constructor
and wrapper methods for grpc_server_create, grpc_server_request_call, and wrapper methods for grpc_server_create, grpc_server_request_call,
grpc_server_add_http2_port, and grpc_server_start. */ grpc_server_add_http2_port, and grpc_server_start. */
class Server : public ::node::ObjectWrap { class Server : public Nan::ObjectWrap {
public: public:
/* Initializes the Server class and exposes the constructor and /* Initializes the Server class and exposes the constructor and
wrapper methods to JavaScript */ 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 /* Tests whether the given value was constructed by this class's
JavaScript constructor */ JavaScript constructor */
static bool HasInstance(v8::Handle<v8::Value> val); static bool HasInstance(v8::Local<v8::Value> val);
private: private:
explicit Server(grpc_server *server); explicit Server(grpc_server *server);
@ -69,8 +69,8 @@ class Server : public ::node::ObjectWrap {
static NAN_METHOD(Start); static NAN_METHOD(Start);
static NAN_METHOD(TryShutdown); static NAN_METHOD(TryShutdown);
static NAN_METHOD(ForceShutdown); static NAN_METHOD(ForceShutdown);
static NanCallback *constructor; static Nan::Callback *constructor;
static v8::Persistent<v8::FunctionTemplate> fun_tpl; static Nan::Persistent<v8::FunctionTemplate> fun_tpl;
grpc_server *wrapped_server; grpc_server *wrapped_server;
grpc_completion_queue *shutdown_queue; grpc_completion_queue *shutdown_queue;

153
src/node/ext/server_credentials.cc
Unescape View File

@ -41,22 +41,28 @@
namespace grpc { namespace grpc {
namespace node { 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::Array;
using v8::Exception; using v8::Exception;
using v8::External; using v8::External;
using v8::Function; using v8::Function;
using v8::FunctionTemplate; using v8::FunctionTemplate;
using v8::Handle;
using v8::HandleScope;
using v8::Integer; using v8::Integer;
using v8::Local; using v8::Local;
using v8::Object; using v8::Object;
using v8::ObjectTemplate; using v8::ObjectTemplate;
using v8::Persistent;
using v8::String; using v8::String;
using v8::Value; using v8::Value;
NanCallback *ServerCredentials::constructor; Nan::Callback *ServerCredentials::constructor;
Persistent<FunctionTemplate> ServerCredentials::fun_tpl; Persistent<FunctionTemplate> ServerCredentials::fun_tpl;
ServerCredentials::ServerCredentials(grpc_server_credentials *credentials) ServerCredentials::ServerCredentials(grpc_server_credentials *credentials)
@ -66,33 +72,41 @@ ServerCredentials::~ServerCredentials() {
grpc_server_credentials_release(wrapped_credentials); grpc_server_credentials_release(wrapped_credentials);
} }
void ServerCredentials::Init(Handle<Object> exports) { void ServerCredentials::Init(Local<Object> exports) {
NanScope(); Nan::HandleScope scope;
Local<FunctionTemplate> tpl = NanNew<FunctionTemplate>(New); Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(New);
tpl->SetClassName(NanNew("ServerCredentials")); tpl->SetClassName(Nan::New("ServerCredentials").ToLocalChecked());
tpl->InstanceTemplate()->SetInternalFieldCount(1); tpl->InstanceTemplate()->SetInternalFieldCount(1);
NanAssignPersistent(fun_tpl, tpl); Local<Function> ctr = tpl->GetFunction();
Handle<Function> ctr = tpl->GetFunction(); Nan::Set(ctr, Nan::New("createSsl").ToLocalChecked(),
ctr->Set(NanNew("createSsl"), Nan::GetFunction(
NanNew<FunctionTemplate>(CreateSsl)->GetFunction()); Nan::New<FunctionTemplate>(CreateSsl)).ToLocalChecked());
ctr->Set(NanNew("createInsecure"), Nan::Set(ctr, Nan::New("createInsecure").ToLocalChecked(),
NanNew<FunctionTemplate>(CreateInsecure)->GetFunction()); Nan::GetFunction(
constructor = new NanCallback(ctr); Nan::New<FunctionTemplate>(CreateInsecure)).ToLocalChecked());
exports->Set(NanNew("ServerCredentials"), ctr); fun_tpl.Reset(tpl);
constructor = new Nan::Callback(ctr);
Nan::Set(exports, Nan::New("ServerCredentials").ToLocalChecked(), ctr);
} }
bool ServerCredentials::HasInstance(Handle<Value> val) { bool ServerCredentials::HasInstance(Local<Value> val) {
NanScope(); Nan::HandleScope scope;
return NanHasInstance(fun_tpl, val); return Nan::New(fun_tpl)->HasInstance(val);
} }
Handle<Value> ServerCredentials::WrapStruct( Local<Value> ServerCredentials::WrapStruct(
grpc_server_credentials *credentials) { grpc_server_credentials *credentials) {
NanEscapableScope(); Nan::EscapableHandleScope scope;
const int argc = 1; const int argc = 1;
Handle<Value> argv[argc] = { Local<Value> argv[argc] = {
NanNew<External>(reinterpret_cast<void *>(credentials))}; Nan::New<External>(reinterpret_cast<void *>(credentials))};
return NanEscapeScope(constructor->GetFunction()->NewInstance(argc, argv)); 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() { grpc_server_credentials *ServerCredentials::GetWrappedServerCredentials() {
@ -100,96 +114,103 @@ grpc_server_credentials *ServerCredentials::GetWrappedServerCredentials() {
} }
NAN_METHOD(ServerCredentials::New) { NAN_METHOD(ServerCredentials::New) {
NanScope(); if (info.IsConstructCall()) {
if (!info[0]->IsExternal()) {
if (args.IsConstructCall()) { return Nan::ThrowTypeError(
if (!args[0]->IsExternal()) {
return NanThrowTypeError(
"ServerCredentials can only be created with the provide functions"); "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 = grpc_server_credentials *creds_value =
reinterpret_cast<grpc_server_credentials *>(ext->Value()); reinterpret_cast<grpc_server_credentials *>(ext->Value());
ServerCredentials *credentials = new ServerCredentials(creds_value); ServerCredentials *credentials = new ServerCredentials(creds_value);
credentials->Wrap(args.This()); credentials->Wrap(info.This());
NanReturnValue(args.This()); info.GetReturnValue().Set(info.This());
} else { } else {
const int argc = 1; const int argc = 1;
Local<Value> argv[argc] = {args[0]}; Local<Value> argv[argc] = {info[0]};
NanReturnValue(constructor->GetFunction()->NewInstance(argc, argv)); 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) { NAN_METHOD(ServerCredentials::CreateSsl) {
// TODO: have the node API support multiple key/cert pairs. Nan::HandleScope scope;
NanScope();
char *root_certs = NULL; char *root_certs = NULL;
if (::node::Buffer::HasInstance(args[0])) { if (::node::Buffer::HasInstance(info[0])) {
root_certs = ::node::Buffer::Data(args[0]); root_certs = ::node::Buffer::Data(info[0]);
} else if (!(args[0]->IsNull() || args[0]->IsUndefined())) { } else if (!(info[0]->IsNull() || info[0]->IsUndefined())) {
return NanThrowTypeError( return Nan::ThrowTypeError(
"createSSl's first argument must be a Buffer if provided"); "createSSl's first argument must be a Buffer if provided");
} }
if (!args[1]->IsArray()) { if (!info[1]->IsArray()) {
return NanThrowTypeError( return Nan::ThrowTypeError(
"createSsl's second argument must be a list of objects"); "createSsl's second argument must be a list of objects");
} }
int force_client_auth = 0; int force_client_auth = 0;
if (args[2]->IsBoolean()) { if (info[2]->IsBoolean()) {
force_client_auth = (int)args[2]->BooleanValue(); force_client_auth = (int)Nan::To<bool>(info[2]).FromJust();
} else if (!(args[2]->IsUndefined() || args[2]->IsNull())) { } else if (!(info[2]->IsUndefined() || info[2]->IsNull())) {
return NanThrowTypeError( return Nan::ThrowTypeError(
"createSsl's third argument must be a boolean if provided"); "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(); 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[ grpc_ssl_pem_key_cert_pair *key_cert_pairs = new grpc_ssl_pem_key_cert_pair[
key_cert_pair_count]; key_cert_pair_count];
Handle<String> key_key = NanNew("private_key"); Local<String> key_key = Nan::New("private_key").ToLocalChecked();
Handle<String> cert_key = NanNew("cert_chain"); Local<String> cert_key = Nan::New("cert_chain").ToLocalChecked();
for(uint32_t i = 0; i < key_cert_pair_count; i++) { 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; 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(); Local<Object> pair_obj = Nan::To<Object>(pair_val).ToLocalChecked();
if (!pair_obj->HasOwnProperty(key_key)) { MaybeLocal<Value> maybe_key = Nan::Get(pair_obj, key_key);
if (maybe_key.IsEmpty()) {
delete key_cert_pairs; delete key_cert_pairs;
return NanThrowTypeError( return Nan::ThrowTypeError(
"Key/cert pairs must have a private_key and a cert_chain"); "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; delete key_cert_pairs;
return NanThrowTypeError( return Nan::ThrowTypeError(
"Key/cert pairs must have a private_key and a cert_chain"); "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; 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; 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( 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( 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( grpc_server_credentials *creds = grpc_ssl_server_credentials_create(
root_certs, key_cert_pairs, key_cert_pair_count, force_client_auth, NULL); root_certs, key_cert_pairs, key_cert_pair_count, force_client_auth, NULL);
delete key_cert_pairs; delete key_cert_pairs;
if (creds == NULL) { if (creds == NULL) {
NanReturnNull(); info.GetReturnValue().SetNull();
} else {
info.GetReturnValue().Set(WrapStruct(creds));
} }
NanReturnValue(WrapStruct(creds));
} }
NAN_METHOD(ServerCredentials::CreateInsecure) { NAN_METHOD(ServerCredentials::CreateInsecure) {
NanScope(); info.GetReturnValue().Set(WrapStruct(NULL));
NanReturnValue(WrapStruct(NULL));
} }
} // namespace node } // namespace node

12
src/node/ext/server_credentials.h
Unescape View File

@ -43,12 +43,12 @@ namespace grpc {
namespace node { namespace node {
/* Wrapper class for grpc_server_credentials structs */ /* Wrapper class for grpc_server_credentials structs */
class ServerCredentials : public ::node::ObjectWrap { class ServerCredentials : public Nan::ObjectWrap {
public: public:
static void Init(v8::Handle<v8::Object> exports); static void Init(v8::Local<v8::Object> exports);
static bool HasInstance(v8::Handle<v8::Value> val); static bool HasInstance(v8::Local<v8::Value> val);
/* Wrap a grpc_server_credentials struct in a javascript object */ /* 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 */ /* Returns the grpc_server_credentials struct that this object wraps */
grpc_server_credentials *GetWrappedServerCredentials(); grpc_server_credentials *GetWrappedServerCredentials();
@ -64,9 +64,9 @@ class ServerCredentials : public ::node::ObjectWrap {
static NAN_METHOD(New); static NAN_METHOD(New);
static NAN_METHOD(CreateSsl); static NAN_METHOD(CreateSsl);
static NAN_METHOD(CreateInsecure); static NAN_METHOD(CreateInsecure);
static NanCallback *constructor; static Nan::Callback *constructor;
// Used for typechecking instances of this javascript class // 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; grpc_server_credentials *wrapped_credentials;
}; };

2
src/node/package.json
Unescape View File

@ -27,7 +27,7 @@
"dependencies": { "dependencies": {
"bindings": "^1.2.0", "bindings": "^1.2.0",
"lodash": "^3.9.3", "lodash": "^3.9.3",
"nan": "^1.5.0", "nan": "^2.0.0",
"protobufjs": "^4.0.0" "protobufjs": "^4.0.0"
}, },
"devDependencies": { "devDependencies": {

Write Preview
Loading…
Cancel
Save