pipe_rpc 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2ad289824f7ad565af6f419ddf007c4bd1745e37
+  data.tar.gz: d6511143979b1c2a998eb3072042a596d264307e
+SHA512:
+  metadata.gz: a13574ab492318a87acb1c82b5f74eb6a7a4e28e4022106725ce3c405de8a56528d08d54493386b0e5d4fb5e5a025d4d77577c3065aa0cea4081529076380542
+  data.tar.gz: eeeb48e3f988525d562d66a5cd64d3f88d7df8edef572f10d4df391b00a53616e7b08ed9935ccd05923b7321ff60fac816f091f15c0d0dfc1c59cd22335077a6

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+test.rb

data/.rakeTasks

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Settings><!--This file was automatically generated by Ruby plugin.
+You are allowed to: 
+1. Remove rake task
+2. Add existing rake tasks
+To add existing rake tasks automatically delete this file and reload the project.
+--><RakeGroup description="" fullCmd="" taksId="rake"><RakeTask description="Build local_rpc-0.1.0.gem into the pkg directory" fullCmd="build" taksId="build" /><RakeTask description="Build and install local_rpc-0.1.0.gem into system gems" fullCmd="install" taksId="install" /><RakeTask description="Create tag v0.1.0 and build and push local_rpc-0.1.0.gem to Rubygems" fullCmd="release" taksId="release" /><RakeGroup description="" fullCmd="" taksId="release"><RakeTask description="" fullCmd="release:guard_clean" taksId="guard_clean" /><RakeTask description="" fullCmd="release:rubygem_push" taksId="rubygem_push" /><RakeTask description="" fullCmd="release:source_control_push" taksId="source_control_push" /></RakeGroup></RakeGroup></Settings>

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper.rb

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.2.0

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,59 @@
+# PipeRpc
+
+PipeRpc was designed so parent und child processes can call each other's methods. It uses a json protocol similar to JSON-RPC.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'pipe_rpc'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install pipe_rpc
+
+## Usage
+
+```ruby
+require 'pipe_rpc'
+
+request_read, request_write = IO.pipe
+response_read, response_write = IO.pipe
+
+pid = fork do
+  request_write.close
+  response_read.close
+
+  class Server
+    def add(a, b)
+      a + b
+    end
+  end
+
+  hub = PipeRpc::Hub.new(input: request_read, output: response_write)
+  hub.add_server(default: Server.new)
+
+  loop do
+    hub.handle_message # blocks until message available
+  end
+end
+
+begin
+  request_read.close
+  response_write.close
+
+  hub = PipeRpc::Hub.new(output: request_write, input: response_read)
+  client = hub.client_for(:default)
+
+  puts client.add(3, 5)
+ensure
+  Process.kill 9, pid
+  Process.wait pid
+end
+```

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/hash.rb

@@ -0,0 +1,5 @@
+class Hash
+  def symbolize_keys
+    Hash[self.map{ |k,v| [(k.to_sym rescue k), v] }]
+  end
+end

data/lib/pipe_rpc/client.rb

@@ -0,0 +1,30 @@
+module PipeRpc
+  class Client < BasicObject
+    def initialize(hub, args = {})
+      @hub = hub
+      @server = args.fetch(:server, :default).to_sym
+    end
+
+    def method_missing(method, *args)
+      backtrace = ::Kernel.respond_to?(:caller) ? ::Kernel.caller(1) : []
+
+      @hub.request(server: @server, method: method, arguments: args) do |result|
+        if result.is_a? ::StandardError
+          result.set_backtrace(result.backtrace.to_a + backtrace.to_a) if result.respond_to? :set_backtrace
+          ::Kernel.raise result
+        else
+          result
+        end
+      end
+      # Method won't return until we got a result because @hub.request starts a loop and blocks!
+    end
+
+    def to_s
+      "<Client:#{@server.to_s}>"
+    end
+
+    def is_a?(object)
+      object == Client
+    end
+  end
+end

data/lib/pipe_rpc/error.rb

@@ -0,0 +1,6 @@
+module PipeRpc
+  class Error < RuntimeError; end
+  class InternalError < Error; end
+  class NoServerError < Error; end
+  class ReflectedError < Error; end
+end

data/lib/pipe_rpc/error_response.rb

@@ -0,0 +1,77 @@
+module PipeRpc
+  class ErrorResponse
+    def initialize(args = {})
+      @id = args.fetch(:id, nil)
+      error = args.fetch(:error)
+      @code = error.fetch(:code)
+      @message = msg_for(@code) || error.fetch(:message, 'Unknown error')
+      @data = error.fetch(:data, nil)
+    end
+
+    attr_reader :id, :code, :message, :data
+
+    def to_h
+      { id: id, error: { code: code, message: message, data: data } }
+    end
+
+    def native_error(request = nil)
+      @request = request
+      error_for(@code)
+    end
+
+    def result_for(*args)
+      native_error(*args)
+    end
+
+    private
+
+    def msg_for(code)
+      case code
+      when -32700 then 'Parse error'
+      when -32600 then 'Invalid Request'
+      when -32601 then 'Method not found'
+      when -32602 then 'Invalid arguments'
+      when -32603 then 'Internal error'
+      when -32604 then 'Server not found'
+      when -32605 then 'Reflected error'
+      else nil
+      end
+    end
+
+    def error_for(code)
+      case code
+      when -32601 then no_method_error
+      when -32602 then argument_error
+      when -32604 then no_server_error
+      when -32605 then reflected_error
+      else internal_error
+      end
+    end
+
+    def no_method_error
+      method = @data.fetch(:method)
+      args = @data.fetch(:args)
+      NoMethodError.new("undefined method `#{method}' for <Client:#{@request.server}>", method, args)
+    end
+
+    def argument_error
+      ArgumentError.new(@data.fetch(:message))
+    end
+
+    def no_server_error
+      NoServerError.new("undefined server `#{@request.server}'")
+    end
+
+    def internal_error
+      InternalError.new("#{@data[:message]}").tap do |error|
+        error.set_backtrace(@data[:backtrace]) if error.respond_to? :set_backtrace
+      end
+    end
+
+    def reflected_error
+      ReflectedError.new("#{@data[:message]}").tap do |error|
+        error.set_backtrace(@data[:backtrace]) if error.respond_to? :set_backtrace
+      end
+    end
+  end
+end

data/lib/pipe_rpc/hub/message.rb

@@ -0,0 +1,57 @@
+module PipeRpc
+  class Hub
+    class Message
+      def initialize(hub, message)
+        @hub = hub
+        @message = message
+      end
+
+      def notification?
+        @message.has_key? :method and not id?
+      end
+
+      def request?
+        @message.has_key? :method and id?
+      end
+
+      def response?
+        (result? or error_message?) and id?
+      end
+
+      def error?
+        error_message? and not id?
+      end
+
+      def handler
+        @handler ||= type.new(@message)
+      rescue => e
+        @hub.send_error(id: nil, code: -32600, data: { message: e.message })
+        nil
+      end
+
+      private
+
+      def result?
+        @message.has_key? :result
+      end
+
+      def error_message?
+        @message.has_key? :error
+      end
+
+      def type
+        if error_message?
+          ErrorResponse
+        elsif result?
+          ResultResponse
+        else
+          Request
+        end
+      end
+
+      def id?
+        not @message[:id].nil?
+      end
+    end
+  end
+end

data/lib/pipe_rpc/hub/requester.rb

@@ -0,0 +1,31 @@
+module PipeRpc
+  class Hub
+    class Requester
+      def initialize(hub)
+        @hub = hub
+        @requests = {}
+        @uid = 0
+      end
+
+      def next_uid
+        @uid += 1
+      end
+
+      def notification(signature)
+        Request.new(signature)
+      end
+
+      def request(signature, &on_response)
+        request = Request.new(signature.merge(id: next_uid))
+        @requests[request.id] = { request: request, on_response: on_response }
+        request
+      end
+
+      def handle_response(response)
+        request = @requests.delete(response.id)
+        raise InternalError.new("no request for response(id: #{response.id})") unless request
+        request[:on_response].call response.result_for(request[:request])
+      end
+    end
+  end
+end

data/lib/pipe_rpc/hub/responder.rb

@@ -0,0 +1,90 @@
+module PipeRpc
+  class Hub
+    class Responder
+      def initialize(hub)
+        @hub = hub
+        @servers = {}
+      end
+
+      def add_server(servers)
+        servers.each{ |name, server| @servers[name.to_sym] = server }
+      end
+
+      def rmv_server(server_name)
+        @servers.delete(server_name.to_sym)
+      end
+
+      def on_request(&on_request)
+        @on_request = on_request
+      end
+
+      def handle_notification(notification)
+        handle_request(notification) {}
+      end
+
+      def handle_request(request, &on_result)
+        id, server, method, args = request.id, @servers[request.server], request.method, request.arguments
+
+        unless server
+          @hub.send_error(id: id, code: -32604)
+          return
+        end
+
+        async = proc do |result|
+          on_result.call ResultResponse.new(id: id, result: result)
+        end
+
+        @on_request.call(server, method, args) if @on_request
+
+        # methods returning the async block as result state that they are asynchronous!
+        method_lineno = __LINE__+1
+        result = server.__send__(method, *args, &async)
+
+        # directly return result for synchronous calls
+        async.call(result) unless result == async
+
+      rescue NoMethodError => e
+        backtrace = e.backtrace.to_a
+        code = itself_caused_no_method_error?(backtrace, method_lineno) ? -32601 : -32603
+        @hub.send_error(id: id, code: code, data: { message: e.message, method: e.name,
+              args: e.args, backtrace: backtrace })
+
+      rescue ArgumentError => e
+        backtrace = e.backtrace.to_a
+        code = itself_caused_argument_error?(backtrace, method_lineno) ? -32602 : -32603
+        @hub.send_error(id: id, code: code, data: { message: e.message, backtrace: backtrace })
+
+      rescue InternalError => e # raised on the other side
+        backtrace = e.backtrace.to_a
+        @hub.send_error(id: id, code: -32605, data: { message: e.message, backtrace: backtrace })
+
+      rescue => e
+        backtrace = e.backtrace.to_a
+        @hub.send_error(id: id, code: -32603, data: { message: e.message, backtrace: backtrace })
+      end
+
+      private
+
+      def itself_caused_no_method_error?(backtrace, ref_lineno)
+        if Object.const_defined?(:MRUBY_VERSION)
+          !backtrace[0]
+        else
+          itself_caused_error?(backtrace[0], ref_lineno)
+        end
+      end
+
+      def itself_caused_argument_error?(backtrace, ref_lineno)
+        if Object.const_defined?(:MRUBY_VERSION)
+          !backtrace[0]
+        else
+          itself_caused_error?(backtrace[1], ref_lineno)
+        end
+      end
+
+      def itself_caused_error?(backtrace_loc, ref_lineno)
+        file, lineno, = backtrace_loc.split(':')
+        (file == __FILE__) and (lineno.to_i == ref_lineno)
+      end
+    end
+  end
+end

data/lib/pipe_rpc/hub.rb

@@ -0,0 +1,104 @@
+module PipeRpc
+  class Hub
+    def initialize(args)
+      @channel = args[:input]
+      @socket = Socket.new(self, args)
+      @requester = Requester.new(self)
+      @responder = Responder.new(self)
+      @clients = {}
+      self.loop_iteration = nil
+    end
+
+    attr_reader :channel
+    attr_accessor :logger
+
+    def log(msg)
+      if logger == :reflect
+        notify(server: :reflect_logger, method: :log, arguments: [msg])
+      elsif logger.respond_to? :debug
+        logger.debug msg
+      elsif logger
+        logger.call msg
+      end
+    end
+
+    def add_server(servers)
+      @responder.add_server(servers)
+    end
+
+    def rmv_server(server_name)
+      @responder.rmv_server(server_name)
+    end
+
+    def on_incoming_request(&on_request)
+      @responder.on_request(&on_request)
+    end
+
+    def client_for(server_name)
+      @clients[server_name] ||= Client.new(self, server: server_name)
+    end
+
+    def loop_iteration=(proc)
+      @loop_iteration = proc
+    end
+
+    def on_sent(&on_sent)
+      @socket.on_write(&on_sent)
+    end
+
+    def on_received(&on_received)
+      @socket.on_read(&on_received)
+    end
+
+    def notify(signature)
+      @socket.write @requester.notification(signature)
+    end
+
+    def request(signature, &on_result)
+      result = nil
+      result_ready = false
+
+      request = @requester.request(signature) do |*response|
+        result = on_result.call(*response)
+        result_ready = true
+      end
+      @socket.write request
+
+      loop do
+        return result if result_ready
+        @loop_iteration ? @loop_iteration.call : handle_message
+      end
+    end
+
+    def send_error(error = {})
+      @socket.write ErrorResponse.new(id: error.delete(:id), error: error)
+    end
+
+    def handle_message
+      message = next_message # blocks
+
+      return unless message
+
+      if message.notification?
+        @responder.handle_notification(message.handler)
+      elsif message.request?
+        @responder.handle_request(message.handler) { |response| @socket.write response }
+      elsif message.response?
+        @requester.handle_response(message.handler)
+      elsif message.error?
+        raise message.handler.native_error
+      else
+        send_error(id: nil, code: -32600, data: { message: 'no request, result or error' })
+      end
+    end
+
+    private
+
+    def next_message
+      Message.new(self, @socket.read) # blocks
+    rescue => e
+      send_error(id: nil, code: -32700, data: { message: e.message })
+      nil
+    end
+  end
+end

data/lib/pipe_rpc/request.rb

@@ -0,0 +1,16 @@
+module PipeRpc
+  class Request
+    def initialize(args)
+      @server = args.fetch(:server, :default).to_sym
+      @method = args.fetch(:method).to_sym
+      @arguments = args.fetch(:arguments, [])
+      @id = args.fetch(:id, nil)
+    end
+
+    attr_reader :server, :method, :arguments, :id
+
+    def to_h
+      { server: server, method: method, arguments: arguments, id: id }
+    end
+  end
+end

data/lib/pipe_rpc/result_response.rb

@@ -0,0 +1,32 @@
+module PipeRpc
+  class ResultResponse
+    def initialize(args = {})
+      @result = sanitize(args.fetch(:result))
+      @id = args.fetch(:id)
+    end
+
+    attr_reader :result, :id
+
+    def result_for(request)
+      result
+    end
+
+    def to_h
+      { id: id, result: result }
+    end
+
+    private
+
+    def sanitize(result)
+      if true == result or false == result or nil == result or result.is_a?(String) or result.is_a?(Numeric)
+        result
+      elsif result.is_a?(Array)
+        result.map{ |v| sanitize(v) }
+      elsif result.is_a?(Hash)
+        Hash[result.map{ |k,v| [sanitize(k), sanitize(v)] }]
+      else
+        result.to_s
+      end
+    end
+  end
+end

data/lib/pipe_rpc/socket.rb

@@ -0,0 +1,45 @@
+module PipeRpc
+  class Socket
+    def initialize(hub, args = {})
+      @hub = hub
+      @input = args.fetch(:input)
+      @output = args.fetch(:output)
+      on_write{}
+      on_read{}
+    end
+
+    def read
+      symbolize_message_keys(JSON.load(@input.gets)).tap do |message|
+        next if message[:server] == 'reflect_logger'
+        @hub.log "received: #{message.inspect}"
+        @on_read.call(message)
+      end
+    end
+
+    def write(obj)
+      raise InternalError.new('Output pipe broke') if @output.closed?
+      @output.puts(JSON.dump(obj.to_h.tap do |message|
+        next if @hub.logger == :reflect
+        @hub.log "sent: #{message.inspect}"
+        @on_write.call(message)
+      end))
+    end
+
+    def on_write(&on_write)
+      @on_write = on_write || proc{}
+    end
+
+    def on_read(&on_read)
+      @on_read = on_read || proc{}
+    end
+
+    private
+
+    def symbolize_message_keys(message)
+      hash = message.symbolize_keys
+      hash[:error] = hash[:error].symbolize_keys if hash[:error]
+      hash[:error][:data] = hash[:error][:data].symbolize_keys if hash[:error] and hash[:error][:data]
+      hash
+    end
+  end
+end

data/lib/pipe_rpc/version.rb

@@ -0,0 +1,3 @@
+module PipeRpc
+  VERSION = "0.2.0"
+end

data/lib/pipe_rpc.rb

@@ -0,0 +1,16 @@
+module PipeRpc
+end
+
+require 'json'
+require_relative 'hash'
+require_relative "pipe_rpc/version"
+require_relative "pipe_rpc/error"
+require_relative "pipe_rpc/request"
+require_relative "pipe_rpc/result_response"
+require_relative "pipe_rpc/error_response"
+require_relative "pipe_rpc/socket"
+require_relative "pipe_rpc/client"
+require_relative "pipe_rpc/hub"
+require_relative "pipe_rpc/hub/message"
+require_relative "pipe_rpc/hub/requester"
+require_relative "pipe_rpc/hub/responder"

data/pipe_rpc.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pipe_rpc/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "pipe_rpc"
+  spec.version       = PipeRpc::VERSION
+  spec.authors       = ["Christopher Aue"]
+  spec.email         = ["mail@christopheraue.net"]
+
+  spec.summary       = %q{RPC between parent and child process over pipes}
+  spec.description   = %q{PipeRpc was designed so parent und child processes can call each other's
+                          methods. It uses a json protocol similar to JSON-RPC.}
+  spec.homepage      = "https://github.com/christopheraue/ruby-pipe_rpc"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "json"
+  spec.add_development_dependency "bundler", "~> 1.8"
+  spec.add_development_dependency "rspec", "~> 3.4"
+  spec.add_development_dependency "rspec-its"
+  spec.add_development_dependency "rspec-mocks-matchers-send_message", "~> 0.2"
+end

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: pipe_rpc
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Christopher Aue
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-mocks-matchers-send_message
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+description: |-
+  PipeRpc was designed so parent und child processes can call each other's
+                            methods. It uses a json protocol similar to JSON-RPC.
+email:
+- mail@christopheraue.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rakeTasks"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- lib/hash.rb
+- lib/pipe_rpc.rb
+- lib/pipe_rpc/client.rb
+- lib/pipe_rpc/error.rb
+- lib/pipe_rpc/error_response.rb
+- lib/pipe_rpc/hub.rb
+- lib/pipe_rpc/hub/message.rb
+- lib/pipe_rpc/hub/requester.rb
+- lib/pipe_rpc/hub/responder.rb
+- lib/pipe_rpc/request.rb
+- lib/pipe_rpc/result_response.rb
+- lib/pipe_rpc/socket.rb
+- lib/pipe_rpc/version.rb
+- pipe_rpc.gemspec
+homepage: https://github.com/christopheraue/ruby-pipe_rpc
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: RPC between parent and child process over pipes
+test_files: []