grpc
/
grpc-node
mirror of https://github.com/grpc/grpc-node.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge github.com:grpc/grpc into cpparena

This commit is contained in:
Craig Tiller 2017-04-19 14:40:20 -07:00
parent 8934a59db0 e5a36589a6
commit db70eca069
20 changed files with 186 additions and 221 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
ext/byte_buffer.cc
View File

@ -33,10 +33,10 @@
#include <string.h> #include <string.h>
#include <node.h>
#include <nan.h> #include <nan.h>
#include "grpc/grpc.h" #include <node.h>
#include "grpc/byte_buffer_reader.h" #include "grpc/byte_buffer_reader.h"
#include "grpc/grpc.h"
#include "grpc/slice.h" #include "grpc/slice.h"
#include "byte_buffer.h" #include "byte_buffer.h"

2
ext/byte_buffer.h
View File

@ -36,8 +36,8 @@
#include <string.h> #include <string.h>
#include <node.h>
#include <nan.h> #include <nan.h>
#include <node.h>
#include "grpc/grpc.h" #include "grpc/grpc.h"
namespace grpc { namespace grpc {

5
ext/call.cc
View File

@ -332,7 +332,6 @@ class SendServerStatusOp : public Op {
out->data.send_status_from_server.status_details = &this->details; out->data.send_status_from_server.status_details = &this->details;
return true; return true;
} }
bool IsFinalOp() { return true; } bool IsFinalOp() { return true; }
void OnComplete(bool success) {} void OnComplete(bool success) {}
@ -359,7 +358,6 @@ class GetMetadataOp : public Op {
out->data.recv_initial_metadata.recv_initial_metadata = &recv_metadata; out->data.recv_initial_metadata.recv_initial_metadata = &recv_metadata;
return true; return true;
} }
bool IsFinalOp() { return false; } bool IsFinalOp() { return false; }
void OnComplete(bool success) {} void OnComplete(bool success) {}
@ -387,7 +385,6 @@ class ReadMessageOp : public Op {
out->data.recv_message.recv_message = &recv_message; out->data.recv_message.recv_message = &recv_message;
return true; return true;
} }
bool IsFinalOp() { return false; } bool IsFinalOp() { return false; }
void OnComplete(bool success) {} void OnComplete(bool success) {}
@ -422,7 +419,6 @@ class ClientStatusOp : public Op {
ParseMetadata(&metadata_array)); ParseMetadata(&metadata_array));
return scope.Escape(status_obj); return scope.Escape(status_obj);
} }
bool IsFinalOp() { return true; } bool IsFinalOp() { return true; }
void OnComplete(bool success) {} void OnComplete(bool success) {}
@ -446,7 +442,6 @@ class ServerCloseResponseOp : public Op {
out->data.recv_close_on_server.cancelled = &cancelled; out->data.recv_close_on_server.cancelled = &cancelled;
return true; return true;
} }
bool IsFinalOp() { return false; } bool IsFinalOp() { return false; }
void OnComplete(bool success) {} void OnComplete(bool success) {}

3
ext/call.h
View File

@ -37,14 +37,13 @@
#include <memory> #include <memory>
#include <vector> #include <vector>
#include <node.h>
#include <nan.h> #include <nan.h>
#include <node.h>
#include "grpc/grpc.h" #include "grpc/grpc.h"
#include "grpc/support/log.h" #include "grpc/support/log.h"
#include "channel.h" #include "channel.h"
namespace grpc { namespace grpc {
namespace node { namespace node {

55
ext/call_credentials.cc
View File

@ -31,17 +31,17 @@
* *
*/ */
#include <node.h>
#include <nan.h> #include <nan.h>
#include <node.h>
#include <uv.h> #include <uv.h>
#include <queue> #include <queue>
#include "call.h"
#include "call_credentials.h"
#include "grpc/grpc.h" #include "grpc/grpc.h"
#include "grpc/grpc_security.h" #include "grpc/grpc_security.h"
#include "grpc/support/log.h" #include "grpc/support/log.h"
#include "call_credentials.h"
#include "call.h"
namespace grpc { namespace grpc {
namespace node { namespace node {
@ -86,15 +86,15 @@ void CallCredentials::Init(Local<Object> exports) {
fun_tpl.Reset(tpl); fun_tpl.Reset(tpl);
Local<Function> ctr = Nan::GetFunction(tpl).ToLocalChecked(); Local<Function> ctr = Nan::GetFunction(tpl).ToLocalChecked();
Nan::Set(ctr, Nan::New("createFromPlugin").ToLocalChecked(), Nan::Set(ctr, Nan::New("createFromPlugin").ToLocalChecked(),
Nan::GetFunction( Nan::GetFunction(Nan::New<FunctionTemplate>(CreateFromPlugin))
Nan::New<FunctionTemplate>(CreateFromPlugin)).ToLocalChecked()); .ToLocalChecked());
Nan::Set(exports, Nan::New("CallCredentials").ToLocalChecked(), ctr); Nan::Set(exports, Nan::New("CallCredentials").ToLocalChecked(), ctr);
constructor = new Nan::Callback(ctr); constructor = new Nan::Callback(ctr);
Local<FunctionTemplate> callback_tpl = Local<FunctionTemplate> callback_tpl =
Nan::New<FunctionTemplate>(PluginCallback); Nan::New<FunctionTemplate>(PluginCallback);
plugin_callback = new Callback( plugin_callback =
Nan::GetFunction(callback_tpl).ToLocalChecked()); new Callback(Nan::GetFunction(callback_tpl).ToLocalChecked());
} }
bool CallCredentials::HasInstance(Local<Value> val) { bool CallCredentials::HasInstance(Local<Value> val) {
@ -110,8 +110,8 @@ Local<Value> CallCredentials::WrapStruct(grpc_call_credentials *credentials) {
} }
Local<Value> argv[argc] = { Local<Value> argv[argc] = {
Nan::New<External>(reinterpret_cast<void *>(credentials))}; Nan::New<External>(reinterpret_cast<void *>(credentials))};
MaybeLocal<Object> maybe_instance = Nan::NewInstance( MaybeLocal<Object> maybe_instance =
constructor->GetFunction(), argc, argv); Nan::NewInstance(constructor->GetFunction(), argc, argv);
if (maybe_instance.IsEmpty()) { if (maybe_instance.IsEmpty()) {
return scope.Escape(Nan::Null()); return scope.Escape(Nan::Null());
} else { } else {
@ -160,8 +160,6 @@ NAN_METHOD(CallCredentials::Compose) {
info.GetReturnValue().Set(WrapStruct(creds)); info.GetReturnValue().Set(WrapStruct(creds));
} }
NAN_METHOD(CallCredentials::CreateFromPlugin) { NAN_METHOD(CallCredentials::CreateFromPlugin) {
if (!info[0]->IsFunction()) { if (!info[0]->IsFunction()) {
return Nan::ThrowTypeError( return Nan::ThrowTypeError(
@ -172,9 +170,7 @@ NAN_METHOD(CallCredentials::CreateFromPlugin) {
state->callback = new Nan::Callback(info[0].As<Function>()); state->callback = new Nan::Callback(info[0].As<Function>());
state->pending_callbacks = new std::queue<plugin_callback_data *>(); state->pending_callbacks = new std::queue<plugin_callback_data *>();
uv_mutex_init(&state->plugin_mutex); uv_mutex_init(&state->plugin_mutex);
uv_async_init(uv_default_loop(), uv_async_init(uv_default_loop(), &state->plugin_async, SendPluginCallback);
&state->plugin_async,
SendPluginCallback);
uv_unref((uv_handle_t *)&state->plugin_async); uv_unref((uv_handle_t *)&state->plugin_async);
state->plugin_async.data = state; state->plugin_async.data = state;
@ -183,8 +179,8 @@ NAN_METHOD(CallCredentials::CreateFromPlugin) {
plugin.destroy = plugin_destroy_state; plugin.destroy = plugin_destroy_state;
plugin.state = reinterpret_cast<void *>(state); plugin.state = reinterpret_cast<void *>(state);
plugin.type = ""; plugin.type = "";
grpc_call_credentials *creds = grpc_metadata_credentials_create_from_plugin( grpc_call_credentials *creds =
plugin, NULL); grpc_metadata_credentials_create_from_plugin(plugin, NULL);
info.GetReturnValue().Set(WrapStruct(creds)); info.GetReturnValue().Set(WrapStruct(creds));
} }
@ -206,26 +202,27 @@ NAN_METHOD(PluginCallback) {
return Nan::ThrowTypeError( return Nan::ThrowTypeError(
"The callback's fourth argument must be an object"); "The callback's fourth argument must be an object");
} }
grpc_status_code code = static_cast<grpc_status_code>( grpc_status_code code =
Nan::To<uint32_t>(info[0]).FromJust()); static_cast<grpc_status_code>(Nan::To<uint32_t>(info[0]).FromJust());
Utf8String details_utf8_str(info[1]); Utf8String details_utf8_str(info[1]);
char *details = *details_utf8_str; char *details = *details_utf8_str;
grpc_metadata_array array; grpc_metadata_array array;
grpc_metadata_array_init(&array); grpc_metadata_array_init(&array);
Local<Object> callback_data = Nan::To<Object>(info[3]).ToLocalChecked(); Local<Object> callback_data = Nan::To<Object>(info[3]).ToLocalChecked();
if (!CreateMetadataArray(Nan::To<Object>(info[2]).ToLocalChecked(), if (!CreateMetadataArray(Nan::To<Object>(info[2]).ToLocalChecked(), &array)) {
&array)){
return Nan::ThrowError("Failed to parse metadata"); return Nan::ThrowError("Failed to parse metadata");
} }
grpc_credentials_plugin_metadata_cb cb = grpc_credentials_plugin_metadata_cb cb =
reinterpret_cast<grpc_credentials_plugin_metadata_cb>( reinterpret_cast<grpc_credentials_plugin_metadata_cb>(
Nan::Get(callback_data, Nan::Get(callback_data, Nan::New("cb").ToLocalChecked())
Nan::New("cb").ToLocalChecked() .ToLocalChecked()
).ToLocalChecked().As<External>()->Value()); .As<External>()
->Value());
void *user_data = void *user_data =
Nan::Get(callback_data, Nan::Get(callback_data, Nan::New("user_data").ToLocalChecked())
Nan::New("user_data").ToLocalChecked() .ToLocalChecked()
).ToLocalChecked().As<External>()->Value(); .As<External>()
->Value();
cb(user_data, array.metadata, array.count, code, details); cb(user_data, array.metadata, array.count, code, details);
DestroyMetadataArray(&array); DestroyMetadataArray(&array);
} }
@ -247,11 +244,9 @@ NAUV_WORK_CB(SendPluginCallback) {
Nan::New<v8::External>(data->user_data)); Nan::New<v8::External>(data->user_data));
const int argc = 3; const int argc = 3;
v8::Local<v8::Value> argv[argc] = { v8::Local<v8::Value> argv[argc] = {
Nan::New(data->service_url).ToLocalChecked(), Nan::New(data->service_url).ToLocalChecked(), callback_data,
callback_data,
// Get Local<Function> from Nan::Callback* // Get Local<Function> from Nan::Callback*
**plugin_callback **plugin_callback};
};
Nan::Callback *callback = state->callback; Nan::Callback *callback = state->callback;
callback->Call(argc, argv); callback->Call(argc, argv);
delete data; delete data;

2
ext/call_credentials.h
View File

@ -36,8 +36,8 @@
#include <queue> #include <queue>
#include <node.h>
#include <nan.h> #include <nan.h>
#include <node.h>
#include <uv.h> #include <uv.h>
#include "grpc/grpc_security.h" #include "grpc/grpc_security.h"

54
ext/channel.cc
View File

@ -35,15 +35,15 @@
#include "grpc/support/log.h" #include "grpc/support/log.h"
#include <node.h>
#include <nan.h> #include <nan.h>
#include "grpc/grpc.h" #include <node.h>
#include "grpc/grpc_security.h"
#include "call.h" #include "call.h"
#include "channel.h" #include "channel.h"
#include "channel_credentials.h"
#include "completion_queue.h" #include "completion_queue.h"
#include "completion_queue_async_worker.h" #include "completion_queue_async_worker.h"
#include "channel_credentials.h" #include "grpc/grpc.h"
#include "grpc/grpc_security.h"
#include "timeval.h" #include "timeval.h"
namespace grpc { namespace grpc {
@ -82,8 +82,8 @@ bool ParseChannelArgs(Local<Value> args_val,
*channel_args_ptr = NULL; *channel_args_ptr = NULL;
return false; return false;
} }
grpc_channel_args *channel_args = reinterpret_cast<grpc_channel_args*>( grpc_channel_args *channel_args =
malloc(sizeof(grpc_channel_args))); reinterpret_cast<grpc_channel_args *>(malloc(sizeof(grpc_channel_args)));
*channel_args_ptr = channel_args; *channel_args_ptr = channel_args;
Local<Object> args_hash = Nan::To<Object>(args_val).ToLocalChecked(); Local<Object> args_hash = Nan::To<Object>(args_val).ToLocalChecked();
Local<Array> keys = Nan::GetOwnPropertyNames(args_hash).ToLocalChecked(); Local<Array> keys = Nan::GetOwnPropertyNames(args_hash).ToLocalChecked();
@ -104,16 +104,16 @@ bool ParseChannelArgs(Local<Value> args_val,
} else if (value->IsString()) { } else if (value->IsString()) {
Utf8String val_str(value); Utf8String val_str(value);
channel_args->args[i].type = GRPC_ARG_STRING; channel_args->args[i].type = GRPC_ARG_STRING;
channel_args->args[i].value.string = reinterpret_cast<char*>( channel_args->args[i].value.string =
calloc(val_str.length() + 1,sizeof(char))); reinterpret_cast<char *>(calloc(val_str.length() + 1, sizeof(char)));
memcpy(channel_args->args[i].value.string, memcpy(channel_args->args[i].value.string, *val_str,
*val_str, val_str.length() + 1); val_str.length() + 1);
} else { } else {
// The value does not match either of the accepted types // The value does not match either of the accepted types
return false; return false;
} }
channel_args->args[i].key = reinterpret_cast<char*>( channel_args->args[i].key =
calloc(key_str.length() + 1, sizeof(char))); reinterpret_cast<char *>(calloc(key_str.length() + 1, sizeof(char)));
memcpy(channel_args->args[i].key, *key_str, key_str.length() + 1); memcpy(channel_args->args[i].key, *key_str, key_str.length() + 1);
} }
return true; return true;
@ -190,12 +190,13 @@ NAN_METHOD(Channel::New) {
grpc_channel_args *channel_args_ptr = NULL; grpc_channel_args *channel_args_ptr = NULL;
if (!ParseChannelArgs(info[2], &channel_args_ptr)) { if (!ParseChannelArgs(info[2], &channel_args_ptr)) {
DeallocateChannelArgs(channel_args_ptr); DeallocateChannelArgs(channel_args_ptr);
return Nan::ThrowTypeError("Channel options must be an object with " return Nan::ThrowTypeError(
"Channel options must be an object with "
"string keys and integer or string values"); "string keys and integer or string values");
} }
if (creds == NULL) { if (creds == NULL) {
wrapped_channel = grpc_insecure_channel_create(*host, channel_args_ptr, wrapped_channel =
NULL); grpc_insecure_channel_create(*host, channel_args_ptr, NULL);
} else { } else {
wrapped_channel = wrapped_channel =
grpc_secure_channel_create(creds, *host, channel_args_ptr, NULL); grpc_secure_channel_create(creds, *host, channel_args_ptr, NULL);
@ -208,8 +209,8 @@ NAN_METHOD(Channel::New) {
} else { } else {
const int argc = 3; const int argc = 3;
Local<Value> argv[argc] = {info[0], info[1], info[2]}; Local<Value> argv[argc] = {info[0], info[1], info[2]};
MaybeLocal<Object> maybe_instance = Nan::NewInstance( MaybeLocal<Object> maybe_instance =
constructor->GetFunction(), argc, argv); Nan::NewInstance(constructor->GetFunction(), argc, argv);
if (maybe_instance.IsEmpty()) { if (maybe_instance.IsEmpty()) {
// There's probably a pending exception // There's probably a pending exception
return; return;
@ -232,11 +233,13 @@ NAN_METHOD(Channel::Close) {
NAN_METHOD(Channel::GetTarget) { NAN_METHOD(Channel::GetTarget) {
if (!HasInstance(info.This())) { if (!HasInstance(info.This())) {
return Nan::ThrowTypeError("getTarget can only be called on Channel objects"); return Nan::ThrowTypeError(
"getTarget can only be called on Channel objects");
} }
Channel *channel = ObjectWrap::Unwrap<Channel>(info.This()); Channel *channel = ObjectWrap::Unwrap<Channel>(info.This());
info.GetReturnValue().Set(Nan::New( info.GetReturnValue().Set(
grpc_channel_get_target(channel->wrapped_channel)).ToLocalChecked()); Nan::New(grpc_channel_get_target(channel->wrapped_channel))
.ToLocalChecked());
} }
NAN_METHOD(Channel::GetConnectivityState) { NAN_METHOD(Channel::GetConnectivityState) {
@ -246,9 +249,8 @@ NAN_METHOD(Channel::GetConnectivityState) {
} }
Channel *channel = ObjectWrap::Unwrap<Channel>(info.This()); Channel *channel = ObjectWrap::Unwrap<Channel>(info.This());
int try_to_connect = (int)info[0]->Equals(Nan::True()); int try_to_connect = (int)info[0]->Equals(Nan::True());
info.GetReturnValue().Set( info.GetReturnValue().Set(grpc_channel_check_connectivity_state(
grpc_channel_check_connectivity_state(channel->wrapped_channel, channel->wrapped_channel, try_to_connect));
try_to_connect));
} }
NAN_METHOD(Channel::WatchConnectivityState) { NAN_METHOD(Channel::WatchConnectivityState) {
@ -268,8 +270,7 @@ NAN_METHOD(Channel::WatchConnectivityState) {
return Nan::ThrowTypeError( 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>(
static_cast<grpc_connectivity_state>(
Nan::To<uint32_t>(info[0]).FromJust()); Nan::To<uint32_t>(info[0]).FromJust());
double deadline = Nan::To<double>(info[1]).FromJust(); double deadline = Nan::To<double>(info[1]).FromJust();
Local<Function> callback_func = info[2].As<Function>(); Local<Function> callback_func = info[2].As<Function>();
@ -279,8 +280,7 @@ NAN_METHOD(Channel::WatchConnectivityState) {
grpc_channel_watch_connectivity_state( grpc_channel_watch_connectivity_state(
channel->wrapped_channel, last_state, MillisecondsToTimespec(deadline), channel->wrapped_channel, last_state, MillisecondsToTimespec(deadline),
GetCompletionQueue(), GetCompletionQueue(),
new struct tag(callback, new struct tag(callback, ops.release(), NULL, Nan::Null()));
ops.release(), NULL, Nan::Null()));
CompletionQueueNext(); CompletionQueueNext();
} }

2
ext/channel.h
View File

@ -34,8 +34,8 @@
#ifndef NET_GRPC_NODE_CHANNEL_H_ #ifndef NET_GRPC_NODE_CHANNEL_H_
#define NET_GRPC_NODE_CHANNEL_H_ #define NET_GRPC_NODE_CHANNEL_H_
#include <node.h>
#include <nan.h> #include <nan.h>
#include <node.h>
#include "grpc/grpc.h" #include "grpc/grpc.h"
namespace grpc { namespace grpc {

27
ext/channel_credentials.cc
View File

@ -33,12 +33,12 @@
#include <node.h> #include <node.h>
#include "call.h"
#include "call_credentials.h"
#include "channel_credentials.h"
#include "grpc/grpc.h" #include "grpc/grpc.h"
#include "grpc/grpc_security.h" #include "grpc/grpc_security.h"
#include "grpc/support/log.h" #include "grpc/support/log.h"
#include "channel_credentials.h"
#include "call_credentials.h"
#include "call.h"
namespace grpc { namespace grpc {
namespace node { namespace node {
@ -80,12 +80,12 @@ void ChannelCredentials::Init(Local<Object> exports) {
Nan::SetPrototypeMethod(tpl, "compose", Compose); Nan::SetPrototypeMethod(tpl, "compose", Compose);
fun_tpl.Reset(tpl); fun_tpl.Reset(tpl);
Local<Function> ctr = Nan::GetFunction(tpl).ToLocalChecked(); Local<Function> ctr = Nan::GetFunction(tpl).ToLocalChecked();
Nan::Set(ctr, Nan::New("createSsl").ToLocalChecked(), Nan::Set(
Nan::GetFunction( ctr, Nan::New("createSsl").ToLocalChecked(),
Nan::New<FunctionTemplate>(CreateSsl)).ToLocalChecked()); Nan::GetFunction(Nan::New<FunctionTemplate>(CreateSsl)).ToLocalChecked());
Nan::Set(ctr, Nan::New("createInsecure").ToLocalChecked(), Nan::Set(ctr, Nan::New("createInsecure").ToLocalChecked(),
Nan::GetFunction( Nan::GetFunction(Nan::New<FunctionTemplate>(CreateInsecure))
Nan::New<FunctionTemplate>(CreateInsecure)).ToLocalChecked()); .ToLocalChecked());
Nan::Set(exports, Nan::New("ChannelCredentials").ToLocalChecked(), ctr); Nan::Set(exports, Nan::New("ChannelCredentials").ToLocalChecked(), ctr);
constructor = new Nan::Callback(ctr); constructor = new Nan::Callback(ctr);
} }
@ -101,8 +101,8 @@ Local<Value> ChannelCredentials::WrapStruct(
const int argc = 1; const int argc = 1;
Local<Value> argv[argc] = { Local<Value> argv[argc] = {
Nan::New<External>(reinterpret_cast<void *>(credentials))}; Nan::New<External>(reinterpret_cast<void *>(credentials))};
MaybeLocal<Object> maybe_instance = Nan::NewInstance( MaybeLocal<Object> maybe_instance =
constructor->GetFunction(), argc, argv); Nan::NewInstance(constructor->GetFunction(), argc, argv);
if (maybe_instance.IsEmpty()) { if (maybe_instance.IsEmpty()) {
return scope.Escape(Nan::Null()); return scope.Escape(Nan::Null());
} else { } else {
@ -179,11 +179,10 @@ NAN_METHOD(ChannelCredentials::Compose) {
return Nan::ThrowTypeError( return Nan::ThrowTypeError(
"compose's first argument must be a CallCredentials object"); "compose's first argument must be a CallCredentials object");
} }
ChannelCredentials *self = ObjectWrap::Unwrap<ChannelCredentials>( ChannelCredentials *self =
info.This()); ObjectWrap::Unwrap<ChannelCredentials>(info.This());
if (self->wrapped_credentials == NULL) { if (self->wrapped_credentials == NULL) {
return Nan::ThrowTypeError( return Nan::ThrowTypeError("Cannot compose insecure credential");
"Cannot compose insecure credential");
} }
CallCredentials *other = ObjectWrap::Unwrap<CallCredentials>( CallCredentials *other = ObjectWrap::Unwrap<CallCredentials>(
Nan::To<Object>(info[0]).ToLocalChecked()); Nan::To<Object>(info[0]).ToLocalChecked());

2
ext/channel_credentials.h
View File

@ -34,8 +34,8 @@
#ifndef NET_GRPC_NODE_CHANNEL_CREDENTIALS_H_ #ifndef NET_GRPC_NODE_CHANNEL_CREDENTIALS_H_
#define NET_GRPC_NODE_CHANNEL_CREDENTIALS_H_ #define NET_GRPC_NODE_CHANNEL_CREDENTIALS_H_
#include <node.h>
#include <nan.h> #include <nan.h>
#include <node.h>
#include "grpc/grpc.h" #include "grpc/grpc.h"
#include "grpc/grpc_security.h" #include "grpc/grpc_security.h"

2
ext/completion_queue.h
View File

@ -31,8 +31,8 @@
* *
*/ */
#include <v8.h>
#include <grpc/grpc.h> #include <grpc/grpc.h>
#include <v8.h>
namespace grpc { namespace grpc {
namespace node { namespace node {

83
ext/node_grpc.cc
View File

@ -33,8 +33,8 @@
#include <queue> #include <queue>
#include <node.h>
#include <nan.h> #include <nan.h>
#include <node.h>
#include <v8.h> #include <v8.h>
#include "grpc/grpc.h" #include "grpc/grpc.h"
#include "grpc/grpc_security.h" #include "grpc/grpc_security.h"
@ -53,12 +53,12 @@ extern "C" {
#include "call_credentials.h" #include "call_credentials.h"
#include "channel.h" #include "channel.h"
#include "channel_credentials.h" #include "channel_credentials.h"
#include "server.h" #include "completion_queue.h"
#include "completion_queue_async_worker.h" #include "completion_queue_async_worker.h"
#include "server.h"
#include "server_credentials.h" #include "server_credentials.h"
#include "slice.h" #include "slice.h"
#include "timeval.h" #include "timeval.h"
#include "completion_queue.h"
using grpc::node::CreateSliceFromString; using grpc::node::CreateSliceFromString;
@ -188,8 +188,7 @@ void InitOpTypeConstants(Local<Object> exports) {
Nan::New<Uint32, uint32_t>(GRPC_OP_SEND_INITIAL_METADATA)); Nan::New<Uint32, uint32_t>(GRPC_OP_SEND_INITIAL_METADATA));
Nan::Set(op_type, Nan::New("SEND_INITIAL_METADATA").ToLocalChecked(), Nan::Set(op_type, Nan::New("SEND_INITIAL_METADATA").ToLocalChecked(),
SEND_INITIAL_METADATA); SEND_INITIAL_METADATA);
Local<Value> SEND_MESSAGE( Local<Value> SEND_MESSAGE(Nan::New<Uint32, uint32_t>(GRPC_OP_SEND_MESSAGE));
Nan::New<Uint32, uint32_t>(GRPC_OP_SEND_MESSAGE));
Nan::Set(op_type, Nan::New("SEND_MESSAGE").ToLocalChecked(), SEND_MESSAGE); Nan::Set(op_type, Nan::New("SEND_MESSAGE").ToLocalChecked(), SEND_MESSAGE);
Local<Value> SEND_CLOSE_FROM_CLIENT( Local<Value> SEND_CLOSE_FROM_CLIENT(
Nan::New<Uint32, uint32_t>(GRPC_OP_SEND_CLOSE_FROM_CLIENT)); Nan::New<Uint32, uint32_t>(GRPC_OP_SEND_CLOSE_FROM_CLIENT));
@ -203,8 +202,7 @@ void InitOpTypeConstants(Local<Object> exports) {
Nan::New<Uint32, uint32_t>(GRPC_OP_RECV_INITIAL_METADATA)); Nan::New<Uint32, uint32_t>(GRPC_OP_RECV_INITIAL_METADATA));
Nan::Set(op_type, Nan::New("RECV_INITIAL_METADATA").ToLocalChecked(), Nan::Set(op_type, Nan::New("RECV_INITIAL_METADATA").ToLocalChecked(),
RECV_INITIAL_METADATA); RECV_INITIAL_METADATA);
Local<Value> RECV_MESSAGE( Local<Value> RECV_MESSAGE(Nan::New<Uint32, uint32_t>(GRPC_OP_RECV_MESSAGE));
Nan::New<Uint32, uint32_t>(GRPC_OP_RECV_MESSAGE));
Nan::Set(op_type, Nan::New("RECV_MESSAGE").ToLocalChecked(), RECV_MESSAGE); Nan::Set(op_type, Nan::New("RECV_MESSAGE").ToLocalChecked(), RECV_MESSAGE);
Local<Value> RECV_STATUS_ON_CLIENT( Local<Value> RECV_STATUS_ON_CLIENT(
Nan::New<Uint32, uint32_t>(GRPC_OP_RECV_STATUS_ON_CLIENT)); Nan::New<Uint32, uint32_t>(GRPC_OP_RECV_STATUS_ON_CLIENT));
@ -252,8 +250,7 @@ void InitConnectivityStateConstants(Local<Object> exports) {
Nan::New<Uint32, uint32_t>(GRPC_CHANNEL_TRANSIENT_FAILURE)); Nan::New<Uint32, uint32_t>(GRPC_CHANNEL_TRANSIENT_FAILURE));
Nan::Set(channel_state, Nan::New("TRANSIENT_FAILURE").ToLocalChecked(), Nan::Set(channel_state, Nan::New("TRANSIENT_FAILURE").ToLocalChecked(),
TRANSIENT_FAILURE); TRANSIENT_FAILURE);
Local<Value> FATAL_FAILURE( Local<Value> FATAL_FAILURE(Nan::New<Uint32, uint32_t>(GRPC_CHANNEL_SHUTDOWN));
Nan::New<Uint32, uint32_t>(GRPC_CHANNEL_SHUTDOWN));
Nan::Set(channel_state, Nan::New("FATAL_FAILURE").ToLocalChecked(), Nan::Set(channel_state, Nan::New("FATAL_FAILURE").ToLocalChecked(),
FATAL_FAILURE); FATAL_FAILURE);
} }
@ -282,13 +279,11 @@ void InitLogConstants(Local<Object> exports) {
NAN_METHOD(MetadataKeyIsLegal) { NAN_METHOD(MetadataKeyIsLegal) {
if (!info[0]->IsString()) { if (!info[0]->IsString()) {
return Nan::ThrowTypeError( return Nan::ThrowTypeError("headerKeyIsLegal's argument must be a string");
"headerKeyIsLegal's argument must be a string");
} }
Local<String> key = Nan::To<String>(info[0]).ToLocalChecked(); Local<String> key = Nan::To<String>(info[0]).ToLocalChecked();
grpc_slice slice = CreateSliceFromString(key); grpc_slice slice = CreateSliceFromString(key);
info.GetReturnValue().Set(static_cast<bool>( info.GetReturnValue().Set(static_cast<bool>(grpc_header_key_is_legal(slice)));
grpc_header_key_is_legal(slice)));
grpc_slice_unref(slice); grpc_slice_unref(slice);
} }
@ -299,8 +294,8 @@ NAN_METHOD(MetadataNonbinValueIsLegal) {
} }
Local<String> value = Nan::To<String>(info[0]).ToLocalChecked(); Local<String> value = Nan::To<String>(info[0]).ToLocalChecked();
grpc_slice slice = CreateSliceFromString(value); grpc_slice slice = CreateSliceFromString(value);
info.GetReturnValue().Set(static_cast<bool>( info.GetReturnValue().Set(
grpc_header_nonbin_value_is_legal(slice))); static_cast<bool>(grpc_header_nonbin_value_is_legal(slice)));
grpc_slice_unref(slice); grpc_slice_unref(slice);
} }
@ -311,8 +306,7 @@ NAN_METHOD(MetadataKeyIsBinary) {
} }
Local<String> key = Nan::To<String>(info[0]).ToLocalChecked(); Local<String> key = Nan::To<String>(info[0]).ToLocalChecked();
grpc_slice slice = CreateSliceFromString(key); grpc_slice slice = CreateSliceFromString(key);
info.GetReturnValue().Set(static_cast<bool>( info.GetReturnValue().Set(static_cast<bool>(grpc_is_binary_header(slice)));
grpc_is_binary_header(slice)));
grpc_slice_unref(slice); grpc_slice_unref(slice);
} }
@ -354,11 +348,13 @@ NAUV_WORK_CB(LogMessagesCallback) {
args.pop(); args.pop();
Local<Value> file = Nan::New(arg->core_args.file).ToLocalChecked(); Local<Value> file = Nan::New(arg->core_args.file).ToLocalChecked();
Local<Value> line = Nan::New<Uint32, uint32_t>(arg->core_args.line); Local<Value> line = Nan::New<Uint32, uint32_t>(arg->core_args.line);
Local<Value> severity = Nan::New( Local<Value> severity =
gpr_log_severity_string(arg->core_args.severity)).ToLocalChecked(); Nan::New(gpr_log_severity_string(arg->core_args.severity))
.ToLocalChecked();
Local<Value> message = Nan::New(arg->core_args.message).ToLocalChecked(); Local<Value> message = Nan::New(arg->core_args.message).ToLocalChecked();
Local<Value> timestamp = Nan::New<v8::Date>( Local<Value> timestamp =
grpc::node::TimespecToMilliseconds(arg->timestamp)).ToLocalChecked(); Nan::New<v8::Date>(grpc::node::TimespecToMilliseconds(arg->timestamp))
.ToLocalChecked();
const int argc = 5; const int argc = 5;
Local<Value> argv[argc] = {file, line, severity, message, timestamp}; Local<Value> argv[argc] = {file, line, severity, message, timestamp};
grpc_logger_state.callback->Call(argc, argv); grpc_logger_state.callback->Call(argc, argv);
@ -388,8 +384,7 @@ void init_logger() {
memset(&grpc_logger_state, 0, sizeof(logger_state)); memset(&grpc_logger_state, 0, sizeof(logger_state));
grpc_logger_state.pending_args = new std::queue<log_args *>(); grpc_logger_state.pending_args = new std::queue<log_args *>();
uv_mutex_init(&grpc_logger_state.mutex); uv_mutex_init(&grpc_logger_state.mutex);
uv_async_init(uv_default_loop(), uv_async_init(uv_default_loop(), &grpc_logger_state.async,
&grpc_logger_state.async,
LogMessagesCallback); LogMessagesCallback);
uv_unref((uv_handle_t *)&grpc_logger_state.async); uv_unref((uv_handle_t *)&grpc_logger_state.async);
grpc_logger_state.logger_set = false; grpc_logger_state.logger_set = false;
@ -416,11 +411,10 @@ NAN_METHOD(SetDefaultLoggerCallback) {
NAN_METHOD(SetLogVerbosity) { NAN_METHOD(SetLogVerbosity) {
if (!info[0]->IsUint32()) { if (!info[0]->IsUint32()) {
return Nan::ThrowTypeError( return Nan::ThrowTypeError("setLogVerbosity's argument must be a number");
"setLogVerbosity's argument must be a number");
} }
gpr_log_severity severity = static_cast<gpr_log_severity>( gpr_log_severity severity =
Nan::To<uint32_t>(info[0]).FromJust()); static_cast<gpr_log_severity>(Nan::To<uint32_t>(info[0]).FromJust());
gpr_set_log_verbosity(severity); gpr_set_log_verbosity(severity);
} }
@ -453,28 +447,25 @@ void init(Local<Object> exports) {
// Attach a few utility functions directly to the module // Attach a few utility functions directly to the module
Nan::Set(exports, Nan::New("metadataKeyIsLegal").ToLocalChecked(), Nan::Set(exports, Nan::New("metadataKeyIsLegal").ToLocalChecked(),
Nan::GetFunction( Nan::GetFunction(Nan::New<FunctionTemplate>(MetadataKeyIsLegal))
Nan::New<FunctionTemplate>(MetadataKeyIsLegal)).ToLocalChecked()); .ToLocalChecked());
Nan::Set(exports, Nan::New("metadataNonbinValueIsLegal").ToLocalChecked(), Nan::Set(
Nan::GetFunction( exports, Nan::New("metadataNonbinValueIsLegal").ToLocalChecked(),
Nan::New<FunctionTemplate>(MetadataNonbinValueIsLegal) Nan::GetFunction(Nan::New<FunctionTemplate>(MetadataNonbinValueIsLegal))
).ToLocalChecked()); .ToLocalChecked());
Nan::Set(exports, Nan::New("metadataKeyIsBinary").ToLocalChecked(), Nan::Set(exports, Nan::New("metadataKeyIsBinary").ToLocalChecked(),
Nan::GetFunction( Nan::GetFunction(Nan::New<FunctionTemplate>(MetadataKeyIsBinary))
Nan::New<FunctionTemplate>(MetadataKeyIsBinary) .ToLocalChecked());
).ToLocalChecked());
Nan::Set(exports, Nan::New("setDefaultRootsPem").ToLocalChecked(), Nan::Set(exports, Nan::New("setDefaultRootsPem").ToLocalChecked(),
Nan::GetFunction( Nan::GetFunction(Nan::New<FunctionTemplate>(SetDefaultRootsPem))
Nan::New<FunctionTemplate>(SetDefaultRootsPem) .ToLocalChecked());
).ToLocalChecked()); Nan::Set(
Nan::Set(exports, Nan::New("setDefaultLoggerCallback").ToLocalChecked(), exports, Nan::New("setDefaultLoggerCallback").ToLocalChecked(),
Nan::GetFunction( Nan::GetFunction(Nan::New<FunctionTemplate>(SetDefaultLoggerCallback))
Nan::New<FunctionTemplate>(SetDefaultLoggerCallback) .ToLocalChecked());
).ToLocalChecked());
Nan::Set(exports, Nan::New("setLogVerbosity").ToLocalChecked(), Nan::Set(exports, Nan::New("setLogVerbosity").ToLocalChecked(),
Nan::GetFunction( Nan::GetFunction(Nan::New<FunctionTemplate>(SetLogVerbosity))
Nan::New<FunctionTemplate>(SetLogVerbosity) .ToLocalChecked());
).ToLocalChecked());
} }
NODE_MODULE(grpc_node, init) NODE_MODULE(grpc_node, init)

28
ext/server.cc
View File

@ -111,14 +111,9 @@ class NewCallOp : public Op {
return scope.Escape(obj); return scope.Escape(obj);
} }
bool ParseOp(Local<Value> value, grpc_op *out) { bool ParseOp(Local<Value> value, grpc_op *out) { return true; }
return true; bool IsFinalOp() { return false; }
} void OnComplete(bool success) {}
bool IsFinalOp() {
return false;
}
void OnComplete(bool success) {
}
grpc_call *call; grpc_call *call;
grpc_call_details details; grpc_call_details details;
@ -137,19 +132,17 @@ class TryShutdownOp: public Op {
EscapableHandleScope scope; EscapableHandleScope scope;
return scope.Escape(Nan::New(server_persist)); return scope.Escape(Nan::New(server_persist));
} }
bool ParseOp(Local<Value> value, grpc_op *out) { bool ParseOp(Local<Value> value, grpc_op *out) { return true; }
return true; bool IsFinalOp() { return false; }
}
bool IsFinalOp() {
return false;
}
void OnComplete(bool success) { void OnComplete(bool success) {
if (success) { if (success) {
server->DestroyWrappedServer(); server->DestroyWrappedServer();
} }
} }
protected: protected:
std::string GetTypeString() const { return "try_shutdown"; } std::string GetTypeString() const { return "try_shutdown"; }
private: private:
Server *server; Server *server;
Nan::Persistent<v8::Value, Nan::CopyablePersistentTraits<v8::Value>> Nan::Persistent<v8::Value, Nan::CopyablePersistentTraits<v8::Value>>
@ -227,10 +220,9 @@ NAN_METHOD(Server::RequestCall) {
ops->push_back(unique_ptr<Op>(op)); ops->push_back(unique_ptr<Op>(op));
grpc_call_error error = grpc_server_request_call( grpc_call_error error = grpc_server_request_call(
server->wrapped_server, &op->call, &op->details, &op->request_metadata, server->wrapped_server, &op->call, &op->details, &op->request_metadata,
GetCompletionQueue(), GetCompletionQueue(), GetCompletionQueue(),
GetCompletionQueue(), new struct tag(new Callback(info[0].As<Function>()), ops.release(), NULL,
new struct tag(new Callback(info[0].As<Function>()), ops.release(), Nan::Null()));
NULL, Nan::Null()));
if (error != GRPC_CALL_OK) { if (error != GRPC_CALL_OK) {
return Nan::ThrowError(nanErrorWithCode("requestCall failed", error)); return Nan::ThrowError(nanErrorWithCode("requestCall failed", error));
} }

2
ext/server.h
View File

@ -34,8 +34,8 @@
#ifndef NET_GRPC_NODE_SERVER_H_ #ifndef NET_GRPC_NODE_SERVER_H_
#define NET_GRPC_NODE_SERVER_H_ #define NET_GRPC_NODE_SERVER_H_
#include <node.h>
#include <nan.h> #include <nan.h>
#include <node.h>
#include "grpc/grpc.h" #include "grpc/grpc.h"
namespace grpc { namespace grpc {

18
ext/server_credentials.cc
View File

@ -78,12 +78,12 @@ void ServerCredentials::Init(Local<Object> exports) {
tpl->SetClassName(Nan::New("ServerCredentials").ToLocalChecked()); tpl->SetClassName(Nan::New("ServerCredentials").ToLocalChecked());
tpl->InstanceTemplate()->SetInternalFieldCount(1); tpl->InstanceTemplate()->SetInternalFieldCount(1);
Local<Function> ctr = tpl->GetFunction(); Local<Function> ctr = tpl->GetFunction();
Nan::Set(ctr, Nan::New("createSsl").ToLocalChecked(), Nan::Set(
Nan::GetFunction( ctr, Nan::New("createSsl").ToLocalChecked(),
Nan::New<FunctionTemplate>(CreateSsl)).ToLocalChecked()); Nan::GetFunction(Nan::New<FunctionTemplate>(CreateSsl)).ToLocalChecked());
Nan::Set(ctr, Nan::New("createInsecure").ToLocalChecked(), Nan::Set(ctr, Nan::New("createInsecure").ToLocalChecked(),
Nan::GetFunction( Nan::GetFunction(Nan::New<FunctionTemplate>(CreateInsecure))
Nan::New<FunctionTemplate>(CreateInsecure)).ToLocalChecked()); .ToLocalChecked());
fun_tpl.Reset(tpl); fun_tpl.Reset(tpl);
constructor = new Nan::Callback(ctr); constructor = new Nan::Callback(ctr);
Nan::Set(exports, Nan::New("ServerCredentials").ToLocalChecked(), ctr); Nan::Set(exports, Nan::New("ServerCredentials").ToLocalChecked(), ctr);
@ -100,8 +100,8 @@ Local<Value> ServerCredentials::WrapStruct(
const int argc = 1; const int argc = 1;
Local<Value> argv[argc] = { Local<Value> argv[argc] = {
Nan::New<External>(reinterpret_cast<void *>(credentials))}; Nan::New<External>(reinterpret_cast<void *>(credentials))};
MaybeLocal<Object> maybe_instance = Nan::NewInstance( MaybeLocal<Object> maybe_instance =
constructor->GetFunction(), argc, argv); Nan::NewInstance(constructor->GetFunction(), argc, argv);
if (maybe_instance.IsEmpty()) { if (maybe_instance.IsEmpty()) {
return scope.Escape(Nan::Null()); return scope.Escape(Nan::Null());
} else { } else {
@ -160,8 +160,8 @@ NAN_METHOD(ServerCredentials::CreateSsl) {
} }
Local<Array> pair_list = Local<Array>::Cast(info[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 =
key_cert_pair_count]; new grpc_ssl_pem_key_cert_pair[key_cert_pair_count];
Local<String> key_key = Nan::New("private_key").ToLocalChecked(); Local<String> key_key = Nan::New("private_key").ToLocalChecked();
Local<String> cert_key = Nan::New("cert_chain").ToLocalChecked(); Local<String> cert_key = Nan::New("cert_chain").ToLocalChecked();

2
ext/server_credentials.h
View File

@ -34,8 +34,8 @@
#ifndef NET_GRPC_NODE_SERVER_CREDENTIALS_H_ #ifndef NET_GRPC_NODE_SERVER_CREDENTIALS_H_
#define NET_GRPC_NODE_SERVER_CREDENTIALS_H_ #define NET_GRPC_NODE_SERVER_CREDENTIALS_H_
#include <node.h>
#include <nan.h> #include <nan.h>
#include <node.h>
#include "grpc/grpc.h" #include "grpc/grpc.h"
#include "grpc/grpc_security.h" #include "grpc/grpc_security.h"

31
ext/server_uv.cc
View File

@ -35,8 +35,8 @@
#include "server.h" #include "server.h"
#include <node.h>
#include <nan.h> #include <nan.h>
#include <node.h>
#include "grpc/grpc.h" #include "grpc/grpc.h"
#include "grpc/support/time.h" #include "grpc/support/time.h"
@ -60,22 +60,14 @@ static Callback *shutdown_callback = NULL;
class ServerShutdownOp : public Op { class ServerShutdownOp : public Op {
public: public:
ServerShutdownOp(grpc_server *server): server(server) { ServerShutdownOp(grpc_server *server) : server(server) {}
}
~ServerShutdownOp() { ~ServerShutdownOp() {}
}
Local<Value> GetNodeValue() const { Local<Value> GetNodeValue() const { return Nan::Null(); }
return Nan::Null();
}
bool ParseOp(Local<Value> value, grpc_op *out) { bool ParseOp(Local<Value> value, grpc_op *out) { return true; }
return true; bool IsFinalOp() { return false; }
}
bool IsFinalOp() {
return false;
}
void OnComplete(bool success) { void OnComplete(bool success) {
/* Because cancel_all_calls was called, we assume that shutdown_and_notify /* Because cancel_all_calls was called, we assume that shutdown_and_notify
completes successfully */ completes successfully */
@ -88,12 +80,9 @@ class ServerShutdownOp : public Op {
std::string GetTypeString() const { return "shutdown"; } std::string GetTypeString() const { return "shutdown"; }
}; };
Server::Server(grpc_server *server) : wrapped_server(server) { Server::Server(grpc_server *server) : wrapped_server(server) {}
}
Server::~Server() { Server::~Server() { this->ShutdownServer(); }
this->ShutdownServer();
}
NAN_METHOD(ServerShutdownCallback) { NAN_METHOD(ServerShutdownCallback) {
if (!info[0]->IsNull()) { if (!info[0]->IsNull()) {
@ -107,8 +96,8 @@ void Server::ShutdownServer() {
if (shutdown_callback == NULL) { if (shutdown_callback == NULL) {
Local<FunctionTemplate> callback_tpl = Local<FunctionTemplate> callback_tpl =
Nan::New<FunctionTemplate>(ServerShutdownCallback); Nan::New<FunctionTemplate>(ServerShutdownCallback);
shutdown_callback = new Callback( shutdown_callback =
Nan::GetFunction(callback_tpl).ToLocalChecked()); new Callback(Nan::GetFunction(callback_tpl).ToLocalChecked());
} }
ServerShutdownOp *op = new ServerShutdownOp(this->wrapped_server); ServerShutdownOp *op = new ServerShutdownOp(this->wrapped_server);

28
ext/slice.cc
View File

@ -31,10 +31,10 @@
* *
*/ */
#include <node.h>
#include <nan.h>
#include <grpc/slice.h> #include <grpc/slice.h>
#include <grpc/support/alloc.h> #include <grpc/support/alloc.h>
#include <nan.h>
#include <node.h>
#include "slice.h" #include "slice.h"
@ -73,28 +73,32 @@ grpc_slice CreateSliceFromString(const Local<String> source) {
grpc_slice CreateSliceFromBuffer(const Local<Value> source) { grpc_slice CreateSliceFromBuffer(const Local<Value> source) {
// Prerequisite: ::node::Buffer::HasInstance(source) // Prerequisite: ::node::Buffer::HasInstance(source)
Nan::HandleScope scope; Nan::HandleScope scope;
return grpc_slice_new_with_user_data(::node::Buffer::Data(source), return grpc_slice_new_with_user_data(
::node::Buffer::Length(source), ::node::Buffer::Data(source), ::node::Buffer::Length(source),
buffer_destroy_func, buffer_destroy_func, new PersistentValue(source));
new PersistentValue(source));
} }
Local<String> CopyStringFromSlice(const grpc_slice slice) { Local<String> CopyStringFromSlice(const grpc_slice slice) {
Nan::EscapableHandleScope scope; Nan::EscapableHandleScope scope;
if (GRPC_SLICE_LENGTH(slice) == 0) { if (GRPC_SLICE_LENGTH(slice) == 0) {
return scope.Escape(Nan::EmptyString()); return scope.Escape(Nan::EmptyString());
} }
return scope.Escape(Nan::New<String>( return scope.Escape(
const_cast<char *>(reinterpret_cast<const char *>(GRPC_SLICE_START_PTR(slice))), Nan::New<String>(const_cast<char *>(reinterpret_cast<const char *>(
GRPC_SLICE_LENGTH(slice)).ToLocalChecked()); GRPC_SLICE_START_PTR(slice))),
GRPC_SLICE_LENGTH(slice))
.ToLocalChecked());
} }
Local<Value> CreateBufferFromSlice(const grpc_slice slice) { Local<Value> CreateBufferFromSlice(const grpc_slice slice) {
Nan::EscapableHandleScope scope; Nan::EscapableHandleScope scope;
grpc_slice *slice_ptr = new grpc_slice; grpc_slice *slice_ptr = new grpc_slice;
*slice_ptr = grpc_slice_ref(slice); *slice_ptr = grpc_slice_ref(slice);
return scope.Escape(Nan::NewBuffer( return scope.Escape(
const_cast<char *>(reinterpret_cast<const char *>(GRPC_SLICE_START_PTR(*slice_ptr))), Nan::NewBuffer(
GRPC_SLICE_LENGTH(*slice_ptr), SliceFreeCallback, slice_ptr).ToLocalChecked()); const_cast<char *>(
reinterpret_cast<const char *>(GRPC_SLICE_START_PTR(*slice_ptr))),
GRPC_SLICE_LENGTH(*slice_ptr), SliceFreeCallback, slice_ptr)
.ToLocalChecked());
} }
} // namespace node } // namespace node

7
ext/slice.h
View File

@ -31,14 +31,15 @@
* *
*/ */
#include <node.h>
#include <nan.h>
#include <grpc/slice.h> #include <grpc/slice.h>
#include <nan.h>
#include <node.h>
namespace grpc { namespace grpc {
namespace node { namespace node {
typedef Nan::Persistent<v8::Value, Nan::CopyablePersistentTraits<v8::Value>> PersistentValue; typedef Nan::Persistent<v8::Value, Nan::CopyablePersistentTraits<v8::Value>>
PersistentValue;
grpc_slice CreateSliceFromString(const v8::Local<v8::String> source); grpc_slice CreateSliceFromString(const v8::Local<v8::String> source);

2
ext/timeval.cc
View File

@ -31,8 +31,8 @@
* *
*/ */
#include <limits>
#include <cstdint> #include <cstdint>
#include <limits>
#include "grpc/grpc.h" #include "grpc/grpc.h"
#include "grpc/support/time.h" #include "grpc/support/time.h"