/* * * Copyright 2015, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are * met: * * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above * copyright notice, this list of conditions and the following disclaimer * in the documentation and/or other materials provided with the * distribution. * * Neither the name of Google Inc. nor the names of its * contributors may be used to endorse or promote products derived from * this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * */ #ifndef NET_GRPC_NODE_CALL_H_ #define NET_GRPC_NODE_CALL_H_ #include #include #include #include #include "grpc/grpc.h" #include "grpc/support/log.h" #include "channel.h" namespace grpc { namespace node { using std::unique_ptr; using std::shared_ptr; /** * Helper function for throwing errors with a grpc_call_error value. * Modified from the answer by Gus Goose to * http://stackoverflow.com/questions/31794200. */ inline v8::Local nanErrorWithCode(const char *msg, grpc_call_error code) { NanEscapableScope(); v8::Local err = NanError(msg).As(); err->Set(NanNew("code"), NanNew(code)); return NanEscapeScope(err); } v8::Handle ParseMetadata(const grpc_metadata_array *metadata_array); class PersistentHolder { public: explicit PersistentHolder(v8::Persistent *persist) : persist(persist) { } ~PersistentHolder() { NanDisposePersistent(*persist); delete persist; } private: v8::Persistent *persist; }; struct Resources { std::vector > strings; std::vector > handles; }; class Op { public: virtual v8::Handle GetNodeValue() const = 0; virtual bool ParseOp(v8::Handle value, grpc_op *out, shared_ptr resources) = 0; v8::Handle GetOpType() const; protected: virtual std::string GetTypeString() const = 0; }; typedef std::vector> OpVec; struct tag { tag(NanCallback *callback, OpVec *ops, shared_ptr resources); ~tag(); NanCallback *callback; OpVec *ops; shared_ptr resources; }; v8::Handle GetTagNodeValue(void *tag); NanCallback *GetTagCallback(void *tag); void DestroyTag(void *tag); /* Wrapper class for grpc_call structs. */ class Call : public ::node::ObjectWrap { public: static void Init(v8::Handle exports); static bool HasInstance(v8::Handle val); /* Wrap a grpc_call struct in a javascript object */ static v8::Handle WrapStruct(grpc_call *call); private: explicit Call(grpc_call *call); ~Call(); // Prevent copying Call(const Call &); Call &operator=(const Call &); static NAN_METHOD(New); static NAN_METHOD(StartBatch); static NAN_METHOD(Cancel); static NAN_METHOD(GetPeer); static NanCallback *constructor; // Used for typechecking instances of this javascript class static v8::Persistent fun_tpl; grpc_call *wrapped_call; }; } // namespace node } // namespace grpc #endif // NET_GRPC_NODE_CALL_H_