mirror of
https://github.com/musix-org/musix-oss
synced 2024-12-23 22:33:17 +00:00
314 lines
9.5 KiB
C++
314 lines
9.5 KiB
C++
|
/*
|
||
|
*
|
||
|
* Copyright 2015 gRPC authors.
|
||
|
*
|
||
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
||
|
* you may not use this file except in compliance with the License.
|
||
|
* You may obtain a copy of the License at
|
||
|
*
|
||
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||
|
*
|
||
|
* Unless required by applicable law or agreed to in writing, software
|
||
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
|
* See the License for the specific language governing permissions and
|
||
|
* limitations under the License.
|
||
|
*
|
||
|
*/
|
||
|
|
||
|
#include <memory>
|
||
|
|
||
|
#include "server.h"
|
||
|
|
||
|
#include <nan.h>
|
||
|
#include <node.h>
|
||
|
|
||
|
#include <vector>
|
||
|
#include "call.h"
|
||
|
#include "completion_queue.h"
|
||
|
#include "grpc/grpc.h"
|
||
|
#include "grpc/grpc_security.h"
|
||
|
#include "grpc/support/log.h"
|
||
|
#include "server_credentials.h"
|
||
|
#include "slice.h"
|
||
|
#include "timeval.h"
|
||
|
|
||
|
namespace grpc {
|
||
|
namespace node {
|
||
|
|
||
|
using Nan::Callback;
|
||
|
using Nan::EscapableHandleScope;
|
||
|
using Nan::HandleScope;
|
||
|
using Nan::Maybe;
|
||
|
using Nan::MaybeLocal;
|
||
|
using Nan::ObjectWrap;
|
||
|
using Nan::Persistent;
|
||
|
using Nan::Utf8String;
|
||
|
|
||
|
using std::unique_ptr;
|
||
|
using v8::Array;
|
||
|
using v8::Boolean;
|
||
|
using v8::Date;
|
||
|
using v8::Exception;
|
||
|
using v8::External;
|
||
|
using v8::Function;
|
||
|
using v8::FunctionTemplate;
|
||
|
using v8::Local;
|
||
|
using v8::Number;
|
||
|
using v8::Object;
|
||
|
using v8::String;
|
||
|
using v8::Value;
|
||
|
|
||
|
Nan::Callback *Server::constructor;
|
||
|
Persistent<FunctionTemplate> Server::fun_tpl;
|
||
|
|
||
|
static Persistent<Function> shutdown_cb;
|
||
|
|
||
|
class ServerShutdownOp : public Op {
|
||
|
public:
|
||
|
ServerShutdownOp(Server *server) : server(server) {}
|
||
|
|
||
|
~ServerShutdownOp() {}
|
||
|
|
||
|
Local<Value> GetNodeValue() const {
|
||
|
EscapableHandleScope scope;
|
||
|
return scope.Escape(server->handle());
|
||
|
}
|
||
|
|
||
|
bool ParseOp(Local<Value> value, grpc_op *out) { return true; }
|
||
|
bool IsFinalOp() { return false; }
|
||
|
void OnComplete(bool success) {
|
||
|
if (success) {
|
||
|
server->FinishShutdown();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
Server *server;
|
||
|
|
||
|
protected:
|
||
|
std::string GetTypeString() const { return "try_shutdown"; }
|
||
|
};
|
||
|
|
||
|
class NewCallOp : public Op {
|
||
|
public:
|
||
|
NewCallOp() {
|
||
|
call = NULL;
|
||
|
grpc_call_details_init(&details);
|
||
|
grpc_metadata_array_init(&request_metadata);
|
||
|
}
|
||
|
|
||
|
~NewCallOp() {
|
||
|
grpc_call_details_destroy(&details);
|
||
|
grpc_metadata_array_destroy(&request_metadata);
|
||
|
}
|
||
|
|
||
|
Local<Value> GetNodeValue() const {
|
||
|
Nan::EscapableHandleScope scope;
|
||
|
if (call == NULL) {
|
||
|
return scope.Escape(Nan::Null());
|
||
|
}
|
||
|
Local<Object> obj = Nan::New<Object>();
|
||
|
Nan::Set(obj, Nan::New("call").ToLocalChecked(), Call::WrapStruct(call));
|
||
|
// TODO(murgatroid99): Use zero-copy string construction instead
|
||
|
Nan::Set(obj, Nan::New("method").ToLocalChecked(),
|
||
|
CopyStringFromSlice(details.method));
|
||
|
Nan::Set(obj, Nan::New("host").ToLocalChecked(),
|
||
|
CopyStringFromSlice(details.host));
|
||
|
Nan::Set(obj, Nan::New("deadline").ToLocalChecked(),
|
||
|
Nan::New<Date>(TimespecToMilliseconds(details.deadline))
|
||
|
.ToLocalChecked());
|
||
|
Nan::Set(obj, Nan::New("metadata").ToLocalChecked(),
|
||
|
ParseMetadata(&request_metadata));
|
||
|
return scope.Escape(obj);
|
||
|
}
|
||
|
|
||
|
bool ParseOp(Local<Value> value, grpc_op *out) { return true; }
|
||
|
bool IsFinalOp() { return false; }
|
||
|
void OnComplete(bool success) {}
|
||
|
|
||
|
grpc_call *call;
|
||
|
grpc_call_details details;
|
||
|
grpc_metadata_array request_metadata;
|
||
|
|
||
|
protected:
|
||
|
std::string GetTypeString() const { return "new_call"; }
|
||
|
};
|
||
|
|
||
|
NAN_METHOD(ShutdownCallback) {
|
||
|
HandleScope scope;
|
||
|
if (!info[0]->IsNull()) {
|
||
|
return Nan::ThrowError("forceShutdown failed somehow");
|
||
|
}
|
||
|
}
|
||
|
|
||
|
Server::Server(grpc_server *server) :
|
||
|
wrapped_server(server), is_shutdown(false) {}
|
||
|
|
||
|
Server::~Server() { grpc_server_destroy(this->wrapped_server); }
|
||
|
|
||
|
void Server::Init(Local<Object> exports) {
|
||
|
HandleScope scope;
|
||
|
Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(New);
|
||
|
tpl->SetClassName(Nan::New("Server").ToLocalChecked());
|
||
|
tpl->InstanceTemplate()->SetInternalFieldCount(1);
|
||
|
Nan::SetPrototypeMethod(tpl, "requestCall", RequestCall);
|
||
|
Nan::SetPrototypeMethod(tpl, "addHttp2Port", AddHttp2Port);
|
||
|
Nan::SetPrototypeMethod(tpl, "start", Start);
|
||
|
Nan::SetPrototypeMethod(tpl, "tryShutdown", TryShutdown);
|
||
|
Nan::SetPrototypeMethod(tpl, "forceShutdown", ForceShutdown);
|
||
|
fun_tpl.Reset(tpl);
|
||
|
Local<Function> ctr = Nan::GetFunction(tpl).ToLocalChecked();
|
||
|
Nan::Set(exports, Nan::New("Server").ToLocalChecked(), ctr);
|
||
|
constructor = new Callback(ctr);
|
||
|
Local<FunctionTemplate> shutdown_tpl =
|
||
|
Nan::New<FunctionTemplate>(ShutdownCallback);
|
||
|
shutdown_cb.Reset(Nan::GetFunction(shutdown_tpl).ToLocalChecked());
|
||
|
}
|
||
|
|
||
|
bool Server::HasInstance(Local<Value> val) {
|
||
|
HandleScope scope;
|
||
|
return Nan::New(fun_tpl)->HasInstance(val);
|
||
|
}
|
||
|
|
||
|
void Server::FinishShutdown() {
|
||
|
is_shutdown = true;
|
||
|
running_self_ref.Reset();
|
||
|
}
|
||
|
|
||
|
void Server::ShutdownServer() {
|
||
|
Nan::HandleScope scope;
|
||
|
if (!this->is_shutdown) {
|
||
|
Callback *shutdown_callback =
|
||
|
new Callback(Nan::New(shutdown_cb));
|
||
|
ServerShutdownOp *op = new ServerShutdownOp(this);
|
||
|
unique_ptr<OpVec> ops(new OpVec());
|
||
|
ops->push_back(unique_ptr<Op>(op));
|
||
|
|
||
|
grpc_server_shutdown_and_notify(
|
||
|
this->wrapped_server, GetCompletionQueue(),
|
||
|
new struct tag(shutdown_callback, ops.release(), NULL, Nan::Null()));
|
||
|
grpc_server_cancel_all_calls(this->wrapped_server);
|
||
|
CompletionQueueNext();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
NAN_METHOD(Server::New) {
|
||
|
/* If this is not a constructor call, make a constructor call and return
|
||
|
the result */
|
||
|
if (!info.IsConstructCall()) {
|
||
|
const int argc = 1;
|
||
|
Local<Value> argv[argc] = {info[0]};
|
||
|
MaybeLocal<Object> maybe_instance =
|
||
|
Nan::NewInstance(constructor->GetFunction(), argc, argv);
|
||
|
if (maybe_instance.IsEmpty()) {
|
||
|
// There's probably a pending exception
|
||
|
return;
|
||
|
} else {
|
||
|
info.GetReturnValue().Set(maybe_instance.ToLocalChecked());
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
grpc_server *wrapped_server;
|
||
|
grpc_completion_queue *queue = GetCompletionQueue();
|
||
|
grpc_channel_args *channel_args;
|
||
|
if (!ParseChannelArgs(info[0], &channel_args)) {
|
||
|
DeallocateChannelArgs(channel_args);
|
||
|
return Nan::ThrowTypeError(
|
||
|
"Server options must be an object with "
|
||
|
"string keys and integer or string values");
|
||
|
}
|
||
|
wrapped_server = grpc_server_create(channel_args, NULL);
|
||
|
DeallocateChannelArgs(channel_args);
|
||
|
grpc_server_register_completion_queue(wrapped_server, queue, NULL);
|
||
|
Server *server = new Server(wrapped_server);
|
||
|
server->Wrap(info.This());
|
||
|
info.GetReturnValue().Set(info.This());
|
||
|
}
|
||
|
|
||
|
NAN_METHOD(Server::RequestCall) {
|
||
|
if (!HasInstance(info.This())) {
|
||
|
return Nan::ThrowTypeError("requestCall can only be called on a Server");
|
||
|
}
|
||
|
Server *server = ObjectWrap::Unwrap<Server>(info.This());
|
||
|
NewCallOp *op = new NewCallOp();
|
||
|
unique_ptr<OpVec> ops(new OpVec());
|
||
|
ops->push_back(unique_ptr<Op>(op));
|
||
|
grpc_call_error error = grpc_server_request_call(
|
||
|
server->wrapped_server, &op->call, &op->details, &op->request_metadata,
|
||
|
GetCompletionQueue(), GetCompletionQueue(),
|
||
|
new struct tag(new Callback(info[0].As<Function>()), ops.release(), NULL,
|
||
|
Nan::Null()));
|
||
|
if (error != GRPC_CALL_OK) {
|
||
|
return Nan::ThrowError(nanErrorWithCode("requestCall failed", error));
|
||
|
}
|
||
|
CompletionQueueNext();
|
||
|
}
|
||
|
|
||
|
NAN_METHOD(Server::AddHttp2Port) {
|
||
|
if (!HasInstance(info.This())) {
|
||
|
return Nan::ThrowTypeError("addHttp2Port can only be called on a Server");
|
||
|
}
|
||
|
if (!info[0]->IsString()) {
|
||
|
return Nan::ThrowTypeError(
|
||
|
"addHttp2Port's first argument must be a String");
|
||
|
}
|
||
|
if (!ServerCredentials::HasInstance(info[1])) {
|
||
|
return Nan::ThrowTypeError(
|
||
|
"addHttp2Port's second argument must be ServerCredentials");
|
||
|
}
|
||
|
Server *server = ObjectWrap::Unwrap<Server>(info.This());
|
||
|
ServerCredentials *creds_object = ObjectWrap::Unwrap<ServerCredentials>(
|
||
|
Nan::To<Object>(info[1]).ToLocalChecked());
|
||
|
grpc_server_credentials *creds = creds_object->GetWrappedServerCredentials();
|
||
|
int port;
|
||
|
if (creds == NULL) {
|
||
|
port = grpc_server_add_insecure_http2_port(server->wrapped_server,
|
||
|
*Utf8String(info[0]));
|
||
|
} else {
|
||
|
port = grpc_server_add_secure_http2_port(server->wrapped_server,
|
||
|
*Utf8String(info[0]), creds);
|
||
|
}
|
||
|
info.GetReturnValue().Set(Nan::New<Number>(port));
|
||
|
}
|
||
|
|
||
|
NAN_METHOD(Server::Start) {
|
||
|
Nan::HandleScope scope;
|
||
|
if (!HasInstance(info.This())) {
|
||
|
return Nan::ThrowTypeError("start can only be called on a Server");
|
||
|
}
|
||
|
Server *server = ObjectWrap::Unwrap<Server>(info.This());
|
||
|
server->running_self_ref.Reset(info.This());
|
||
|
grpc_server_start(server->wrapped_server);
|
||
|
}
|
||
|
|
||
|
NAN_METHOD(Server::TryShutdown) {
|
||
|
Nan::HandleScope scope;
|
||
|
if (!HasInstance(info.This())) {
|
||
|
return Nan::ThrowTypeError("tryShutdown can only be called on a Server");
|
||
|
}
|
||
|
if (!info[0]->IsFunction()) {
|
||
|
return Nan::ThrowError("tryShutdown's argument must be a callback");
|
||
|
}
|
||
|
Server *server = ObjectWrap::Unwrap<Server>(info.This());
|
||
|
ServerShutdownOp *op = new ServerShutdownOp(server);
|
||
|
unique_ptr<OpVec> ops(new OpVec());
|
||
|
ops->push_back(unique_ptr<Op>(op));
|
||
|
grpc_server_shutdown_and_notify(
|
||
|
server->wrapped_server, GetCompletionQueue(),
|
||
|
new struct tag(new Nan::Callback(info[0].As<Function>()), ops.release(),
|
||
|
NULL, Nan::Null()));
|
||
|
CompletionQueueNext();
|
||
|
}
|
||
|
|
||
|
NAN_METHOD(Server::ForceShutdown) {
|
||
|
Nan::HandleScope scope;
|
||
|
if (!HasInstance(info.This())) {
|
||
|
return Nan::ThrowTypeError("forceShutdown can only be called on a Server");
|
||
|
}
|
||
|
Server *server = ObjectWrap::Unwrap<Server>(info.This());
|
||
|
server->ShutdownServer();
|
||
|
}
|
||
|
|
||
|
} // namespace node
|
||
|
} // namespace grpc
|