1 files changed, 0 insertions, 342 deletions
diff --git a/src/node/ext/server.cc b/src/node/ext/server.cc
deleted file mode 100644
index c6ab5e1895..0000000000
--- a/src/node/ext/server.cc
+++ /dev/null
@@ -1,342 +0,0 @@
-/*
- *
- * 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 Callback *shutdown_callback = NULL;
-
-class ServerShutdownOp : public Op {
- public:
-  ServerShutdownOp(grpc_server *server) : server(server) {}
-
-  ~ServerShutdownOp() {}
-
-  Local<Value> GetNodeValue() const { return Nan::Null(); }
-
-  bool ParseOp(Local<Value> value, grpc_op *out) { return true; }
-  bool IsFinalOp() { return false; }
-  void OnComplete(bool success) {
-    /* Because cancel_all_calls was called, we assume that shutdown_and_notify
-       completes successfully */
-    grpc_server_destroy(server);
-  }
-
-  grpc_server *server;
-
- protected:
-  std::string GetTypeString() const { return "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"; }
-};
-
-class TryShutdownOp : public Op {
- public:
-  TryShutdownOp(Server *server, Local<Value> server_value) : server(server) {
-    server_persist.Reset(server_value);
-  }
-  Local<Value> GetNodeValue() const {
-    EscapableHandleScope scope;
-    return scope.Escape(Nan::New(server_persist));
-  }
-  bool ParseOp(Local<Value> value, grpc_op *out) { return true; }
-  bool IsFinalOp() { return false; }
-  void OnComplete(bool success) {
-    if (success) {
-      server->DestroyWrappedServer();
-    }
-  }
-
- protected:
-  std::string GetTypeString() const { return "try_shutdown"; }
-
- private:
-  Server *server;
-  Nan::Persistent<v8::Value, Nan::CopyablePersistentTraits<v8::Value>>
-      server_persist;
-};
-
-Server::Server(grpc_server *server) : wrapped_server(server) {}
-
-Server::~Server() { this->ShutdownServer(); }
-
-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);
-}
-
-bool Server::HasInstance(Local<Value> val) {
-  HandleScope scope;
-  return Nan::New(fun_tpl)->HasInstance(val);
-}
-
-void Server::DestroyWrappedServer() {
-  if (this->wrapped_server != NULL) {
-    grpc_server_destroy(this->wrapped_server);
-    this->wrapped_server = NULL;
-  }
-}
-
-NAN_METHOD(ServerShutdownCallback) {
-  if (!info[0]->IsNull()) {
-    return Nan::ThrowError("forceShutdown failed somehow");
-  }
-}
-
-void Server::ShutdownServer() {
-  Nan::HandleScope scope;
-  if (this->wrapped_server != NULL) {
-    if (shutdown_callback == NULL) {
-      Local<FunctionTemplate> callback_tpl =
-          Nan::New<FunctionTemplate>(ServerShutdownCallback);
-      shutdown_callback =
-          new Callback(Nan::GetFunction(callback_tpl).ToLocalChecked());
-    }
-
-    ServerShutdownOp *op = new ServerShutdownOp(this->wrapped_server);
-    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(new Callback(**shutdown_callback), ops.release(), NULL,
-                       Nan::Null()));
-    grpc_server_cancel_all_calls(this->wrapped_server);
-    CompletionQueueNext();
-    this->wrapped_server = NULL;
-  }
-}
-
-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());
-  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");
-  }
-  Server *server = ObjectWrap::Unwrap<Server>(info.This());
-  if (server->wrapped_server == NULL) {
-    // Server is already shut down. Call callback immediately.
-    Nan::Callback callback(info[0].As<Function>());
-    callback.Call(0, {});
-    return;
-  }
-  TryShutdownOp *op = new TryShutdownOp(server, info.This());
-  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