capn_proto-rpc 0.1.1.alpha.rpc

data/ext/capn_proto/message_reader.h

@@ -0,0 +1,17 @@
+#ifndef MESSAGE_READER_H
+#define MESSAGE_READER_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class MessageReader {
+  public:
+    using WrappedType = capnp::MessageReader;
+    static void Init();
+    static WrappedType* unwrap(VALUE self);
+
+    static VALUE Class;
+  };
+}
+
+#endif /* MESSAGE_READER_H */

data/ext/capn_proto/nested_node_reader.cc

@@ -0,0 +1,42 @@
+#include "ruby_capn_proto.h"
+#include "nested_node_reader.h"
+#include "class_builder.h"
+#include "util.h"
+
+namespace ruby_capn_proto {
+  using WrappedType = capnp::schema::Node::NestedNode::Reader;
+  VALUE NestedNodeReader::Class;
+
+  void NestedNodeReader::Init() {
+    ClassBuilder("NestedNodeReader", rb_cObject).
+      defineAlloc(&alloc).
+      defineMethod("name", &name).
+      store(&Class);
+  }
+
+  VALUE NestedNodeReader::alloc(VALUE klass) {
+    return Data_Wrap_Struct(klass, NULL, free, ruby_xmalloc(sizeof(WrappedType)));
+  }
+
+  VALUE NestedNodeReader::create(WrappedType reader) {
+    VALUE rb_obj = alloc(Class);
+    WrappedType* wrapped = unwrap(rb_obj);
+    *wrapped = kj::mv(reader);
+    return rb_obj;
+  }
+
+  void NestedNodeReader::free(WrappedType* p) {
+    p->~Reader();
+    ruby_xfree(p);
+  }
+
+  WrappedType* NestedNodeReader::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+
+  VALUE NestedNodeReader::name(VALUE self) {
+    return Util::toRubyString(unwrap(self)->getName());
+  }
+}

data/ext/capn_proto/nested_node_reader.h

@@ -0,0 +1,21 @@
+#ifndef NESTED_NODE_READER_H
+#define NESTED_NODE_READER_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class NestedNodeReader {
+  public:
+    using WrappedType = capnp::schema::Node::NestedNode::Reader;
+    static void Init();
+    static VALUE alloc(VALUE klass);
+    static VALUE create(WrappedType reader);
+    static void free(WrappedType* p);
+    static WrappedType* unwrap(VALUE self);
+    static VALUE name(VALUE self);
+
+    static VALUE Class;
+  };
+}
+
+#endif /* NESTED_NODE_READER_H */

data/ext/capn_proto/parsed_schema.cc

@@ -0,0 +1,65 @@
+#include "ruby_capn_proto.h"
+#include "parsed_schema.h"
+#include "schema_node_reader.h"
+#include "struct_schema.h"
+#include "interface_schema.h"
+#include "class_builder.h"
+#include "util.h"
+
+namespace ruby_capn_proto {
+  using WrappedType = capnp::ParsedSchema;
+  VALUE ParsedSchema::Class;
+
+  void ParsedSchema::Init() {
+    ClassBuilder("ParsedSchema", rb_cObject).
+      defineAlloc(&alloc).
+      defineMethod("get_proto", &get_proto).
+      defineMethod("get_nested", &get_nested).
+      defineMethod("as_struct", &as_struct).
+      defineMethod("as_interface", &as_interface).
+      store(&Class);
+  }
+
+  void ParsedSchema::free(WrappedType* p) {
+    p->~ParsedSchema();
+    ruby_xfree(p);
+  }
+
+  VALUE ParsedSchema::alloc(VALUE klass) {
+    return Data_Wrap_Struct(klass, NULL, free, ruby_xmalloc(sizeof(WrappedType)));
+  }
+
+  WrappedType* ParsedSchema::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+
+  VALUE ParsedSchema::create(WrappedType schema, VALUE parent) {
+    VALUE rb_obj = alloc(Class);
+    WrappedType* wrapped_schema = unwrap(rb_obj);
+    *wrapped_schema = kj::mv(schema);
+
+    rb_iv_set(rb_obj, "parent", parent);
+
+    return rb_obj;
+  }
+
+  VALUE ParsedSchema::get_proto(VALUE self) {
+    return SchemaNodeReader::create(unwrap(self)->getProto(), self);
+  }
+
+  VALUE ParsedSchema::get_nested(VALUE self, VALUE rb_name) {
+    auto name = Util::toString(rb_name);
+    return create(unwrap(self)->getNested(name), self);
+  }
+
+  VALUE ParsedSchema::as_struct(VALUE self) {
+    return StructSchema::create(unwrap(self)->asStruct(), self);
+  }
+
+  VALUE ParsedSchema::as_interface(VALUE self) {
+    return InterfaceSchema::create(unwrap(self)->asInterface(), self);
+  }
+
+}

data/ext/capn_proto/parsed_schema.h

@@ -0,0 +1,24 @@
+#ifndef PARSED_SCHEMA_H
+#define PARSED_SCHEMA_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class ParsedSchema {
+  public:
+    using WrappedType = capnp::ParsedSchema;
+    static void Init();
+    static VALUE alloc(VALUE klass);
+    static VALUE create(WrappedType schema, VALUE parent);
+    static void free(WrappedType* p);
+    static WrappedType* unwrap(VALUE self);
+    static VALUE get_proto(VALUE self);
+    static VALUE get_nested(VALUE self, VALUE name);
+    static VALUE as_struct(VALUE self);
+    static VALUE as_interface(VALUE self);
+
+    static VALUE Class;
+  };
+}
+
+#endif /* PARSED_SCHEMA_H */

data/ext/capn_proto/remote_promise.cc

@@ -0,0 +1,116 @@
+#include "ruby_capn_proto.h"
+#include "remote_promise.h"
+#include "dynamic_value_builder.h"
+#include "dynamic_struct_builder.h"
+#include "dynamic_struct_reader.h"
+#include "EzRpc_client.h"
+#include "interface_method.h"
+#include "exception.h"
+#include "class_builder.h"
+#include <ruby/thread.h>
+#include "util.h"
+
+namespace ruby_capn_proto {
+  using WrappedType = capnp::RemotePromise<capnp::DynamicStruct>;
+  VALUE RemotePromise::Class;
+
+  void RemotePromise::Init() {
+
+    ClassBuilder("RemotePromise", rb_cObject).
+      defineAlloc(&alloc).
+      defineMethod("request_and_send" , &request_and_send).
+      defineMethod("wait" , &wait).
+      store(&Class);
+  }
+
+  void RemotePromise::free(WrappedType* p) {
+    p->~RemotePromise();
+    ruby_xfree(p);
+  }
+
+  VALUE RemotePromise::alloc(VALUE klass) {
+    return Data_Wrap_Struct(klass, NULL, free, ruby_xmalloc(sizeof(WrappedType)));
+  }
+
+  WrappedType* RemotePromise::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+
+  VALUE RemotePromise::create(WrappedType& remote_promise) {
+
+    VALUE rb_obj = alloc(Class);
+    WrappedType* rb_promise = unwrap(rb_obj);
+    new (rb_promise) WrappedType(kj::mv(remote_promise));
+
+    return rb_obj;
+  }
+
+  VALUE RemotePromise::request_and_send(VALUE self, VALUE name_struct, VALUE method, VALUE data){
+    VALUE rb_client = rb_iv_get(self,"client");
+    try{
+      auto pipelinedClient = unwrap(self)->get(Util::toString(name_struct)).releaseAs<capnp::DynamicCapability>();
+      auto request = pipelinedClient.newRequest(*InterfaceMethod::unwrap(method));
+      setParam(&request,data);
+      auto promise = request.send();
+      VALUE new_remote_promise = create(promise);
+      return new_remote_promise;
+    }catch( kj::Exception t){
+      Exception::raise(t);
+    }
+  }
+
+  VALUE RemotePromise::wait(VALUE self, VALUE ezrpclient){
+    VALUE client = ezrpclient;
+
+    waitpacket p;
+    p.prom = unwrap(self);
+    p.client = EzRpcCapabilityClient::unwrap(client);
+    p.response = NULL;
+
+    // call waitIntern releasing the GIL
+    rb_thread_call_without_gvl(waitIntern, &p, RUBY_UBF_IO , 0);
+    return DynamicStructReader::create(*p.response,Qnil);
+  }
+
+  void * RemotePromise::waitIntern(void * p){
+    try {
+      waitpacket* pkt = (waitpacket*) p;
+      auto& waitscope = pkt->client->getWaitScope();
+      pkt->response = new capnp::Response<capnp::DynamicStruct>(pkt->prom->wait(waitscope));
+    }catch(kj::Exception t){
+      // adquire the lock to raise an exception on ruby
+      rb_thread_call_with_gvl(&Exception::raise,&t);
+    }
+  }
+
+  void RemotePromise::setParam(capnp::Request<capnp::DynamicStruct, capnp::DynamicStruct>* request, VALUE arys){
+    VALUE mainIter = rb_ary_pop(arys); // mainIter is now a array
+    while(mainIter != Qnil ){
+
+      VALUE val = rb_ary_pop(mainIter);    // value to assign
+      VALUE last = rb_ary_pop(mainIter);   // name of the field to assign to val
+      VALUE temp = rb_ary_shift(mainIter); // just to iterate
+
+      capnp::DynamicStruct::Builder builder = *request;
+
+      // follow the nodes indicated by the array
+      while( temp != Qnil && temp != last){
+        try{
+          builder = *DynamicStructBuilder::unwrap(DynamicValueBuilder::to_ruby(request->get(Util::toString(temp)),Qnil));
+          temp = rb_ary_shift(mainIter);
+        }catch(kj::Exception t){
+          Exception::raise(t);
+        }
+      }
+
+      // when arrived to last node make the assignation
+      VALUE rb_struct = DynamicStructBuilder::create(builder,Qnil,Qfalse);
+      DynamicStructBuilder::set(rb_struct,last,val);
+
+      mainIter = rb_ary_pop(arys);
+    }
+  }
+
+}

data/ext/capn_proto/remote_promise.h

@@ -0,0 +1,30 @@
+#ifndef REMOTE_PROMISE_H
+#define REMOTE_PROMISE_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  typedef struct _waitpacket {
+    capnp::EzRpcClient* client;
+    capnp::RemotePromise<capnp::DynamicStruct>* prom;
+    capnp::Response<capnp::DynamicStruct>* response;
+  } waitpacket;
+
+  class RemotePromise {
+  public:
+    using WrappedType = capnp::RemotePromise<capnp::DynamicStruct>;
+    static void Init();
+    static VALUE alloc(VALUE klass);
+    static VALUE create(WrappedType& promise);
+    static void free(WrappedType* p);
+    static WrappedType* unwrap(VALUE self);
+    static VALUE request_and_send(VALUE self, VALUE struct_name, VALUE method, VALUE data);
+    static void setParam(capnp::Request<capnp::DynamicStruct, capnp::DynamicStruct>* request, VALUE arrays);
+    static VALUE wait(VALUE self, VALUE ezrpclient);
+    static void * waitIntern(void * p);
+    static VALUE Class;
+  };
+}
+
+
+#endif /* REMOTE_PROMISE_H */

data/ext/capn_proto/ruby_capability_server.cc

@@ -0,0 +1,23 @@
+#include "ruby_capn_proto.h"
+#include "call_context.h"
+#include "ruby_capability_server.h"
+#include <ruby/thread.h>
+#include "util.h"
+
+namespace capnp {
+  kj::Promise<void> RubyCapabilityServer::call(InterfaceSchema::Method method, CallContext<DynamicStruct, DynamicStruct> context) {
+    // just a dummy c++ server that calls methods on a passed ruby server.
+    
+    callPacket packet;
+    packet.methodName = method.getProto().getName().cStr();
+    packet.rb_context = ruby_capn_proto::CallContext::create(context);
+    packet.rb_server = this->server;
+    rb_thread_call_with_gvl(this->rbCall, &packet);
+    return kj::READY_NOW;
+  }
+
+  void * RubyCapabilityServer::rbCall(void * p){
+    auto * packet = (callPacket*) p;
+    rb_funcall( packet->rb_server, rb_intern( packet->methodName ), 1, packet->rb_context );
+  }
+}

data/ext/capn_proto/ruby_capability_server.h

@@ -0,0 +1,21 @@
+#include "ruby_capn_proto.h"
+
+namespace capnp {
+  // helper struct to use rb_thread_call_with_gvl
+  typedef struct _callPacket {
+    const char* methodName;
+    VALUE rb_context;
+    VALUE rb_server;
+  } callPacket;
+
+  class RubyCapabilityServer : public DynamicCapability::Server {
+
+  private:
+    VALUE server;
+
+  public:
+    RubyCapabilityServer( InterfaceSchema interface, VALUE server ): DynamicCapability::Server(interface) { this->server = server; }
+    kj::Promise<void> call( InterfaceSchema::Method method, CallContext<DynamicStruct, DynamicStruct> context );
+    static void * rbCall(void * p); // to be called with rb_thread_call_with_gvl
+  };
+}

data/ext/capn_proto/ruby_capn_proto.cc

@@ -0,0 +1,4 @@
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+}

data/ext/capn_proto/ruby_capn_proto.h

@@ -0,0 +1,42 @@
+#ifndef RUBY_CAPN_PROTO_H
+#define RUBY_CAPN_PROTO_H
+
+#include <iostream>
+#include <vector>
+
+#include <kj/common.h>
+#include <kj/array.h>
+#include <kj/debug.h>
+
+#include <capnp/any.h>
+#include <capnp/serialize.h>
+#include <capnp/serialize-packed.h>
+#include <capnp/message.h>
+#include <capnp/schema-parser.h>
+#include <capnp/schema.h>
+#include <capnp/message.h>
+#include <capnp/dynamic.h>
+
+#include <capnp/ez-rpc.h>
+
+#include <ruby.h>
+#ifdef __
+#undef __
+#endif
+#ifdef HAVE_RUBY_ENCODING_H
+#include "ruby/encoding.h"
+#endif
+
+#if defined(RUBY_METHOD_FUNC)
+# undef RUBY_METHOD_FUNC
+# if RUBY_VERSION_CODE <= 166
+    extern "C" typedef VALUE (*RUBY_METHOD_FUNC)();
+# else
+    extern "C" typedef VALUE (*RUBY_METHOD_FUNC)(ANYARGS);
+# endif
+#endif
+
+namespace ruby_capn_proto {
+}
+
+#endif /* RUBY_CAPN_PROTO_H */

data/ext/capn_proto/schema_node_reader.cc

@@ -0,0 +1,59 @@
+#include "ruby_capn_proto.h"
+#include "schema_node_reader.h"
+#include "list_nested_node_reader.h"
+#include "class_builder.h"
+
+namespace ruby_capn_proto {
+  using WrappedType = capnp::schema::Node::Reader;
+  VALUE SchemaNodeReader::Class;
+
+  void SchemaNodeReader::Init() {
+    ClassBuilder("SchemaNodeReader", rb_cObject).
+      defineAlloc(&alloc).
+      defineMethod("nested_nodes", &get_nested_nodes).
+      defineMethod("struct?", &is_struct).
+      defineMethod("interface?", &is_interface).
+      store(&Class);
+  }
+
+  VALUE SchemaNodeReader::alloc(VALUE klass) {
+    return Data_Wrap_Struct(klass, NULL, free, ruby_xmalloc(sizeof(WrappedType)));
+  }
+
+  VALUE SchemaNodeReader::create(WrappedType reader, VALUE parent) {
+    VALUE rb_obj = alloc(Class);
+    WrappedType* wrapped = unwrap(rb_obj);
+    *wrapped = kj::mv(reader);
+
+    rb_iv_set(rb_obj, "parent", parent);
+
+    return rb_obj;
+  }
+
+  void SchemaNodeReader::free(WrappedType* p) {
+    p->~Reader();
+    ruby_xfree(p);
+  }
+
+  WrappedType* SchemaNodeReader::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+
+  VALUE SchemaNodeReader::get_nested_nodes(VALUE self) {
+    return ListNestedNodeReader::create(unwrap(self)->getNestedNodes(), self);
+  }
+
+  VALUE SchemaNodeReader::is_struct(VALUE self) {
+    return unwrap(self)->isStruct() ? Qtrue : Qfalse;
+  }
+
+  VALUE SchemaNodeReader::is_interface(VALUE self) {
+    return unwrap(self)->isInterface() ? Qtrue : Qfalse;
+  }
+
+  VALUE SchemaNodeReader::is_enum(VALUE self) {
+    return unwrap(self)->isEnum() ? Qtrue : Qfalse;
+  }
+}