capn_proto-rpc 0.1.1.alpha.rpc

data/examples/example.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+$: << File.expand_path("../../lib", __FILE__)
+$: << File.expand_path("../../ext", __FILE__)
+require 'capn_proto'
+
+ADDRESSBOOK_SCHEMA = File.expand_path("../addressbook.capnp", __FILE__);
+MESSAGE = File.expand_path("../addressbook.bin", __FILE__);
+
+module AddressBook extend CapnProto::SchemaLoader
+  load_schema(ADDRESSBOOK_SCHEMA)
+end
+
+def print_address_book(file)
+  addresses = AddressBook::AddressBook.read_from(file)
+
+  addresses.people.each do |person|
+    puts "#{person.name} : #{person.email}"
+    person.phones.each do |phone|
+      puts "#{phone.type} : #{phone.number}"
+    end
+
+    which = person.employment.which
+    puts which
+
+    if which == "unemployed"
+      puts "unemployed"
+    elsif which == 'employer'
+      puts "employer: #{person.employment.employer}"
+    elsif which == "school"
+      puts "student at: #{person.employment.school}"
+    elsif which == "selfEmployed"
+      puts "self employed"
+    end
+  end
+end
+
+file = File.open(MESSAGE, "rb")
+print_address_book(file)

data/ext/capn_proto/.ycm_extra_conf.py

@@ -0,0 +1,65 @@
+# vim: ts=2 et sw=2 sts=2
+
+import os
+import ycm_core
+import glob
+import subprocess
+
+def RubyInclude():
+  cmd = ["ruby", "-e", "print RbConfig::CONFIG['rubyhdrdir']"]
+  process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+  rubyhdrdir = process.stdout.read()
+  return rubyhdrdir
+
+flags = [
+'-Wall',
+'-Wextra',
+'-Werror',
+'-fexceptions',
+'-Wc++98-compat',
+'-std=c++11',
+'-x', 'c++',
+'-I', '.',
+'-I', '/usr/local/include',
+'-I', RubyInclude(),
+]
+
+def DirectoryOfThisScript():
+  return os.path.dirname( os.path.abspath( __file__ ) )
+
+def MakeRelativePathsInFlagsAbsolute( flags, working_directory ):
+  if not working_directory:
+    return list( flags )
+  new_flags = []
+  make_next_absolute = False
+  path_flags = [ '-isystem', '-I', '-iquote', '--sysroot=' ]
+  for flag in flags:
+    new_flag = flag
+
+    if make_next_absolute:
+      make_next_absolute = False
+      if not flag.startswith( '/' ):
+        new_flag = os.path.join( working_directory, flag )
+
+    for path_flag in path_flags:
+      if flag == path_flag:
+        make_next_absolute = True
+        break
+
+      if flag.startswith( path_flag ):
+        path = flag[ len( path_flag ): ]
+        new_flag = path_flag + os.path.join( working_directory, path )
+        break
+
+    if new_flag:
+      new_flags.append( new_flag )
+  return new_flags
+
+def FlagsForFile( filename ):
+  relative_to = DirectoryOfThisScript()
+  final_flags = MakeRelativePathsInFlagsAbsolute( flags, relative_to )
+
+  return {
+    'flags': final_flags,
+    'do_cache': True
+  }

data/ext/capn_proto/EzRpc_client.cc

@@ -0,0 +1,52 @@
+#include "ruby_capn_proto.h"
+#include "EzRpc_client.h"
+#include "capability_client.h"
+#include "dynamic_capability_client.h"
+#include "class_builder.h"
+#include "exception.h"
+#include "util.h"
+
+namespace ruby_capn_proto {
+  using WrappedType = capnp::EzRpcClient;
+  VALUE EzRpcCapabilityClient::Class;
+
+  void EzRpcCapabilityClient::Init() {
+    ClassBuilder("EzRpcClient", rb_cObject).
+      defineAlloc(&alloc).
+      defineMethod("client", &make_dynamic).
+      defineMethod("initialize" , &create).
+      store(&Class);
+  }
+
+  void EzRpcCapabilityClient::free(WrappedType* p) {
+    ruby_xfree(p);
+  }
+
+  VALUE EzRpcCapabilityClient::alloc(VALUE klass) {
+    return Data_Wrap_Struct(klass, NULL, free, ruby_xmalloc(sizeof(WrappedType)));
+  }
+
+  WrappedType* EzRpcCapabilityClient::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+
+  VALUE EzRpcCapabilityClient::create(VALUE self, VALUE dir, VALUE interschema) {
+
+    WrappedType* rb_self = unwrap(self);
+    new (rb_self) capnp::EzRpcClient(Util::toString(dir));
+
+    //store the InterfaceSchema
+    rb_iv_set(self,"schema",interschema);
+
+    return self;
+  }
+
+  VALUE EzRpcCapabilityClient::make_dynamic(VALUE self){
+    VALUE rb_schema = rb_iv_get(self,"schema");
+    VALUE rb_cap = CapabilityClient::create(unwrap(self)->getMain());
+    return DynamicCapabilityClient::create(rb_cap,rb_schema);
+  }
+
+}

data/ext/capn_proto/EzRpc_client.h

@@ -0,0 +1,21 @@
+#ifndef EZRPC_CAPABILITY_CLIENT_H
+#define EXRPC_CAPABILITY_CLIENT_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class EzRpcCapabilityClient {
+  public:
+    using WrappedType = capnp::EzRpcClient;
+    static void Init();
+    static VALUE alloc(VALUE klass);
+    static VALUE create(VALUE self, VALUE dir, VALUE schema);
+    static void free(WrappedType* p);
+    static WrappedType* unwrap(VALUE self);
+    static VALUE make_dynamic(VALUE self);
+    static VALUE Class;
+  };
+}
+
+
+#endif /* EZRPC_CAPABILITY_CLIENT_H */

data/ext/capn_proto/EzRpc_server.cc

@@ -0,0 +1,79 @@
+#include "ruby_capn_proto.h"
+#include "EzRpc_server.h"
+#include "ruby_capability_server.h"
+#include "interface_schema.h"
+#include "exception.h"
+#include "class_builder.h"
+#include <ruby/thread.h>
+#include "util.h"
+
+namespace ruby_capn_proto {
+  using WrappedType = capnp::EzRpcServer;
+  VALUE EzRpcCapabilityServer::Class;
+
+  void EzRpcCapabilityServer::Init() {
+    ClassBuilder("EzRpcServer", rb_cObject).
+      defineAlloc(&alloc).
+      defineMethod("run" , &process).
+      defineMethod("initialize" , &create).
+      store(&Class);
+  }
+
+  void EzRpcCapabilityServer::free(WrappedType* p) {
+    ruby_xfree(p);
+  }
+
+  VALUE EzRpcCapabilityServer::alloc(VALUE klass) {
+    return Data_Wrap_Struct(klass, NULL, free, ruby_xmalloc(sizeof(WrappedType)));
+  }
+
+  WrappedType* EzRpcCapabilityServer::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+
+  VALUE EzRpcCapabilityServer::create(VALUE self, VALUE rb_capServer, VALUE dir) {
+
+    VALUE interschema = rb_iv_get(rb_capServer,"@schema");
+    auto schema = InterfaceSchema::unwrap(interschema);
+
+    WrappedType* rb_self = unwrap(self);
+    new (rb_self) capnp::EzRpcServer( kj::heap<capnp::RubyCapabilityServer>(*schema, rb_capServer) , Util::toString(dir) );
+
+    return self;
+  }
+
+  VALUE EzRpcCapabilityServer::process(VALUE self){
+    try{
+      loopCall l;
+      auto server = unwrap(self);
+      auto to_fulfill = kj::heap<kj::PromiseFulfillerPair<void>>(kj::newPromiseAndFulfiller<void>());
+      l.waitscope = &server->getWaitScope();
+      l.promisepair = to_fulfill.get();
+      rb_thread_call_without_gvl(loopServer, &l, stopLoopServer , l.promisepair);
+    }catch ( kj::Exception t ){
+      Exception::raise(t);
+    }
+    return Qtrue;
+  }
+
+  void * EzRpcCapabilityServer::loopServer(void * p){
+    try {
+      auto* loopcall = (loopCall*) p;
+      loopcall->promisepair->promise.wait(*(loopcall->waitscope));
+    }catch( kj::Exception t ){
+      //adquire the lock to raise a ruby exception
+      rb_thread_call_with_gvl(&Exception::raise,&t);
+    }
+  }
+
+  void EzRpcCapabilityServer::stopLoopServer(void *p){
+    try {
+      auto* promisefulfiller = (kj::PromiseFulfillerPair<void>*) p;
+      promisefulfiller->fulfiller->fulfill();
+    }catch( kj::Exception t ){
+      Exception::raise(t);
+    }
+  }
+}

data/ext/capn_proto/EzRpc_server.h

@@ -0,0 +1,32 @@
+#ifndef EZRPC_CAPABILITY_SERVER_H
+#define EZRPC_CAPABILITY_SERVER_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+
+  typedef struct _loopCall{
+    kj::WaitScope* waitscope;
+    kj::PromiseFulfillerPair<void>* promisepair;
+  } loopCall;
+
+  class EzRpcCapabilityServer {
+  public:
+    using WrappedType = capnp::EzRpcServer;
+    static void Init();
+    static VALUE alloc(VALUE klass);
+    static VALUE create(VALUE self, VALUE rb_server, VALUE dir);
+    static void free(WrappedType* p);
+    static WrappedType* unwrap(VALUE self);
+    static VALUE process(VALUE self);
+    static void * loopServer(void* p);
+    static void stopLoopServer(void* p);
+    // schema and rb_server to make new RubyCapabilityServer on the fly
+    static capnp::InterfaceSchema* schema(VALUE self);
+    static VALUE rb_server(VALUE self);
+    static VALUE Class;
+  };
+}
+
+
+#endif /* EZRPC_CAPABILITY_SERVER_H */

data/ext/capn_proto/call_context.cc

@@ -0,0 +1,67 @@
+#include "ruby_capn_proto.h"
+#include "call_context.h"
+#include "dynamic_struct_reader.h"
+#include "dynamic_struct_builder.h"
+#include "class_builder.h"
+#include "util.h"
+
+namespace ruby_capn_proto {
+  using WrappedType = capnp::CallContext<capnp::DynamicStruct, capnp::DynamicStruct>;
+  VALUE CallContext::Class;
+
+  void CallContext::Init() {
+    ClassBuilder("CallContext" , rb_cObject).
+      defineAlloc(&alloc).
+      defineMethod("getParams" , &getParams).
+      defineMethod("releaseParams" , &releaseParams).
+      defineMethod("getResults" , &getResults).
+      defineMethod("initResults" , &initResults).
+      defineMethod("setResults" , &setResults).
+      store(&Class);
+  }
+
+  void CallContext::free(WrappedType* p) {
+    p->~CallContext();
+    ruby_xfree(p);
+  }
+
+  VALUE CallContext::alloc(VALUE klass) {
+    return Data_Wrap_Struct(klass, NULL, free, ruby_xmalloc(sizeof(WrappedType)));
+  }
+
+  WrappedType* CallContext::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+
+  VALUE CallContext::create(WrappedType context) {
+    VALUE rb_obj = alloc(Class);
+    WrappedType* wrapped_context = unwrap(rb_obj);
+    *wrapped_context = kj::mv(context);
+    return rb_obj;
+  }
+
+  VALUE CallContext::getParams(VALUE self) {
+    return DynamicStructReader::create(unwrap(self)->getParams(),Qnil);
+  }
+
+  VALUE CallContext::releaseParams(VALUE self) {
+    unwrap(self)->releaseParams();
+    return Qtrue;
+  }
+
+  VALUE CallContext::getResults(VALUE self) {
+    return DynamicStructBuilder::create(unwrap(self)->getResults(), Qnil, Qtrue);
+  }
+
+  VALUE CallContext::initResults(VALUE self) {
+    return DynamicStructBuilder::create(unwrap(self)->initResults(), Qnil, Qtrue );
+  }
+
+  VALUE CallContext::setResults(VALUE self, VALUE structReader) {
+    // maybe check the type of structReader?
+    unwrap(self)->setResults( *DynamicStructReader::unwrap(structReader) );
+    return Qtrue;
+  }
+}

data/ext/capn_proto/call_context.h

@@ -0,0 +1,25 @@
+#ifndef CONTEXT_H
+#define CONTEXT_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class CallContext {
+  public:
+    using WrappedType = capnp::CallContext<capnp::DynamicStruct, capnp::DynamicStruct>;
+    static void Init();
+    static VALUE alloc(VALUE klass);
+    static void free(WrappedType* p);
+    static VALUE create(WrappedType context);
+    static WrappedType* unwrap(VALUE self);
+    static VALUE getParams(VALUE self);
+    static VALUE releaseParams(VALUE self);
+    static VALUE getResults(VALUE self);
+    static VALUE initResults(VALUE self);
+    static VALUE setResults(VALUE self, VALUE structBuilder);
+
+    static VALUE Class;
+  };
+}
+
+#endif /* CONTEXT_H */

data/ext/capn_proto/capability_client.cc

@@ -0,0 +1,47 @@
+#include "ruby_capn_proto.h"
+#include "capability_client.h"
+#include "dynamic_capability_client.h"
+#include "exception.h"
+#include "class_builder.h"
+#include "util.h"
+
+namespace ruby_capn_proto {
+  using WrappedType = capnp::Capability::Client;
+  VALUE CapabilityClient::Class;
+
+  void CapabilityClient::Init() {
+    ClassBuilder("CapabilityClient", rb_cObject).
+      defineAlloc(&alloc).
+      defineMethod("to_dynamic" , &to_dynamic).
+      store(&Class);
+  }
+
+  void CapabilityClient::free(WrappedType* p) {
+    p->~Client();
+    ruby_xfree(p);
+  }
+
+  VALUE CapabilityClient::alloc(VALUE klass) {
+    return Data_Wrap_Struct(klass, NULL, free, ruby_xmalloc(sizeof(WrappedType)));
+  }
+
+  WrappedType* CapabilityClient::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+
+  VALUE CapabilityClient::create(WrappedType native_client ) {
+
+    VALUE self = alloc(Class);
+    WrappedType* rb_self = unwrap(self);
+    new (rb_self) capnp::Capability::Client(native_client);
+
+    return self;
+  }
+
+  VALUE CapabilityClient::to_dynamic(VALUE self, VALUE schema){
+    return DynamicCapabilityClient::create(self,schema);
+  }
+
+}

data/ext/capn_proto/capability_client.h

@@ -0,0 +1,21 @@
+#ifndef CAPABILITY_CLIENT_H
+#define CAPABILITY_CLIENT_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class CapabilityClient {
+  public:
+    using WrappedType = capnp::Capability::Client;
+    static void Init();
+    static VALUE alloc(VALUE klass);
+    static VALUE create(WrappedType native_client);
+    static void free(WrappedType* p);
+    static WrappedType* unwrap(VALUE self);
+    static VALUE to_dynamic(VALUE self, VALUE schema);
+    static VALUE Class;
+  };
+}
+
+
+#endif /* CAPABILITY_CLIENT_H */