zmqjsonrpc 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 275b2e7bd02313197bd72c9791bfb20774a8f0c7
+  data.tar.gz: 32c9c8d5bba102217c2f19472575e8d893821de2
+SHA512:
+  metadata.gz: 3d636755631636c90c151348753be54440f0b2ff212a1a712f111514bcf2a1a615c48e81a366ad7d08a9a5c4c3ffc496e038bda0a7903cbd03215c81650af5bf
+  data.tar.gz: b6c77e276528cf85b0040aa7e71ef0fceb3105bd5caadf8511b573aad9e90923c4905df61cc56d1b72858d411f84a6f37649756e71676d0f17904405215b3c3d

data/.gitignore

@@ -0,0 +1,3 @@
+*.gem
+.vagrant
+.DS_Store

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in simplejsonrpc.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,23 @@
+PATH
+  remote: .
+  specs:
+    simplejsonrpc (0.1)
+      ffi-rzmq (~> 2.0.4)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ffi (1.9.6)
+    ffi-rzmq (2.0.4)
+      ffi-rzmq-core (>= 1.0.1)
+    ffi-rzmq-core (1.0.3)
+      ffi (~> 1.9)
+    rake (10.4.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  rake
+  simplejsonrpc!

data/README.md

@@ -0,0 +1,61 @@
+# zmqjsonrpc
+
+This gem implements a very simple [JSON RPC 2.0](http://www.jsonrpc.org/specification) client and server which uses zeroMQ for transport.
+Let's not talk to much, let's see some code:
+
+```ruby
+  require 'rubygems'
+  require 'zmqjsonrpc'
+  
+  # client request to a running server
+  client = ZmqJsonRpc::Client.new("tcp://127.0.0.1:49200")
+  client.some_method(1, "b", [1,{a:1}])
+```
+
+```ruby
+  require 'rubygems'
+  require 'zmqjsonrpc'
+
+  class Proxy
+    def some_method(a,b,c)
+      # do you thing
+      return ["xyz", 77]
+    end
+  end
+
+  # blocking server
+  proxy = Proxy.new()
+  server = ZmqJsonRpc::Server.new(proxy, "tcp://*:49200")
+  server.server_loop
+  
+  # -or- dispatch a thread
+  server = ZmqJsonRpc::Server.new(proxy, "tcp://*:49200")
+  thread = Thread.new {
+    server.server_loop
+  }
+  # and cancel the thread if you want to shut the server down
+  thread.exit
+```
+
+## Resources
+
+* The [JSON RPC 2.0 Spec](http://www.jsonrpc.org/specification)
+* The used [ZeroMQ gem](https://github.com/chuckremes/ffi-rzmq) and [good examples](http://github.com/andrewvc/learn-ruby-zeromq)
+* [Gem making](http://guides.rubygems.org/make-your-own-gem/)
+
+## Stuff left to do
+
+* Add support for by-name parameters (see [the spec](http://www.jsonrpc.org/specification#parameter_structures))
+* Add individual exception classes in the client.
+* Send different error codes if something goes wrong in the server.
+* Keep the client connection alive instead of re-establishing every time.
+* Add more tests.
+
+## Licence
+
+This code is released under the terms of MIT License.
+
+## Contribute
+
+Please do so! Just send a messahe or send a pull request.
+Especially, adding webrick for transport would be nice.

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/Vagrantfile

@@ -0,0 +1,31 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+provision = <<SCRIPT
+# Update system
+sudo apt-get -y update
+sudo apt-get -y upgrade
+sudo apt-get -y install build-essential git
+
+# ruby
+sudo apt-get -y install ruby2.0 ruby2.0-dev bundler rake
+sudo ln -sf /usr/bin/ruby2.0 /usr/bin/ruby # make ruby 2 default
+sudo ln -sf /usr/bin/gem2.0 /usr/bin/gem
+sudo ln -sf /usr/bin/irb2.0 /usr/bin/irb
+
+# install tools for development
+sudo apt-get -y install vim man
+
+# install dependencies
+sudo apt-get install libzmq3 libzmq3-dev
+SCRIPT
+
+Vagrant.configure("2") do |config|
+  config.vm.box = "ubuntu/trusty64"
+  config.vm.hostname = "simplejsonrpc"
+  config.vm.provision :shell, inline: provision
+
+  config.vm.provider "virtualbox" do |vb|
+    vb.name = "simplejsonrpc"
+  end
+end

data/lib/simple_json_rpc/client.rb

@@ -0,0 +1,63 @@
+require 'json'
+require 'securerandom'
+
+module ZmqJsonRpc
+  class ClientError < RuntimeError
+  end
+  
+  # You shall instanciate this class with a connect string which follows the zeroMQ conventions: http://api.zeromq.org/2-1:zmq-connect
+  # After connecting you can call any method on this class and it will be sent to the server.
+  # If something goes wrong ZmqJsonRpc::ClientError is thrown.
+  # timeout is measured in milliseconds.
+  # 
+  # NOTE
+  # The client does not keep the connection alive. For each request, a new connection is esablished and torn down after the response.
+  # This could become a performance issue.
+  class Client
+    def initialize(connect="tcp://127.0.0.1:49200", timeout=10000)
+      @connect = connect
+      @timeout = timeout
+    end
+
+    def send_rpc(method, params=[])
+      begin
+        # connect socket
+        @context = ZMQ::Context.new(1)
+        @socket = @context.socket(ZMQ::REQ)
+        @socket.connect(@connect)
+        @socket.setsockopt(ZMQ::SNDTIMEO, @timeout)
+        @socket.setsockopt(ZMQ::RCVTIMEO, @timeout)
+
+        # build and send request
+        req_id = SecureRandom.uuid
+        request = {
+          id: req_id,
+          jsonrpc: "2.0",
+          method: method.to_s,
+          params: params
+        }        
+        rc = @socket.send_string(request.to_json) # this will always succeed, even if the server is not reachable.
+
+        # interpret response
+        response = ''
+        rc = @socket.recv_string(response)
+        raise "Could talk to the server (server unreachable? time out?)" if rc < 0
+        resjson = JSON.parse(response)
+        # check response
+        raise "Response's id did not match the sent id" if resjson["id"] != req_id
+        raise "Response's version number is not supported (#{resjson["jsonrpc"]})" if resjson["jsonrpc"].strip != "2.0"
+        raise "Server returned error (#{resjson["error"]["code"] || "?"}): #{resjson["error"]["message"]}\n#{resjson["error"]["data"]}" if resjson["error"]
+        
+        return resjson["result"]
+      rescue => e
+        raise ClientError, e.message
+      ensure
+        @socket.close rescue ''
+      end
+    end
+    
+    def method_missing(meth, *args, &block)
+      self.send_rpc(meth, args)
+    end
+  end
+end

data/lib/simple_json_rpc/server.rb

@@ -0,0 +1,87 @@
+require 'ffi-rzmq'
+require 'json'
+
+module ZmqJsonRpc
+  # This class implements the server:
+  #
+  # USE
+  #   class Proxy
+  #     def some_method(a,b)
+  #       return [a,b,{"XXXX"=> 1}]
+  #     end
+  #   end
+  #   server = ZmqJsonRpc::Server.new(Proxy.new())
+  #   server.server_loop
+  # 
+  #
+  # If you want a non blocking server do
+  #   server = ZmqJsonRpc::Server.new(Proxy.new())
+  #   thread = Thread.new {
+  #     server.server_loop
+  #   }
+  #  # later either do
+  #  thread.join # waiting for the server to finish -- which is never!
+  #  # or
+  #  thread.exit # or end the thread
+  class Server
+    # For errors the spec says:
+    # The error codes from and including -32768 to -32000 are reserved for pre-defined errors. Any code within this range, but not defined explicitly below is reserved for future use. The error codes are nearly the same as those suggested for XML-RPC at the following url: http://xmlrpc-epi.sourceforge.net/specs/rfc.fault_codes.php
+    #
+    # For details on the zmq gem, please see https://github.com/chuckremes/ffi-rzmq (best to look in the code)
+    def initialize(proxy, connect="tcp://*:49200", logger=nil)
+      @connect = connect
+      @proxy = proxy
+      @logger = logger
+    end
+  
+    def handle_request(request)
+      begin
+        req_id = nil
+        rpc = JSON.parse(request)
+        raise "Received unsupprted jsonrpc version (#{rpc['jsonrpc']})" if rpc["jsonrpc"].strip != "2.0"
+        rid = rpc["id"]
+        method = rpc["method"]
+        params = rpc["params"]
+
+        @logger.info "Received JSON RPC request: #{method}(#{params.collect {|p| p.inspect}.join(", ")})" unless @logger.nil?
+        result = @proxy.send(method.to_sym, *params)
+        response = {
+          id: rid,
+          jsonrpc: "2.0",
+          result: result
+        }
+        return response.to_json
+      rescue => e
+        # If there is more time to spare, we could implement the actual error codes here.
+        @logger.warn "Returning error for RPC request: #{e.message})" unless @logger.nil?
+        response = {
+          id: rid,
+          jsonrpc: "2.0",
+          error: {
+            code: 32603,
+            message: e.message,
+            data: e.backtrace.inspect
+          }
+        }
+        return response.to_json
+      end
+    end
+
+    def server_loop
+      @context = ZMQ::Context.new(1)
+      @socket = @context.socket(ZMQ::REP)
+      @socket.bind(@connect)
+      begin
+        loop do
+          request = ''
+          rc = @socket.recv_string(request)
+          response = handle_request(request)
+          @socket.send_string(response)
+        end
+      ensure
+        @socket.close
+        # @context.terminate
+      end
+    end
+  end
+end

data/lib/zmqjsonrpc.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require "simple_json_rpc/client"
+require "simple_json_rpc/server"
+
+module ZmqJsonRpc
+end

data/test/test_client_server.rb

@@ -0,0 +1,52 @@
+require 'test/unit'
+require "logger"
+require "stringio"
+require_relative '../lib/zmqjsonrpc'
+
+class TestClientServer < Test::Unit::TestCase
+  def setup
+    @buffer = StringIO.new
+    @logger = Logger.new(@buffer)
+    @logger.level = Logger::WARN
+  end
+  
+  def assert_empty_log
+    @buffer.seek(0)
+    assert_equal @buffer.read, "", "Server log included warnings."
+  end
+  
+  def test_client_with_server
+    proxy_class = Class.new() do
+      def initialize(test_case)
+        @test_case = test_case
+        @method_was_called = false
+      end
+      def method_was_called?
+        return @method_was_called
+      end
+
+      def some_method(a,b,c)
+        @test_case.assert_equal a, 1
+        @test_case.assert_equal b, "b"
+        @test_case.assert_equal c, [1,{"a" => 1}]
+        @method_was_called = true
+        return "abc"
+      end
+    end
+
+    proxy = proxy_class.new(self)
+    server = ZmqJsonRpc::Server.new(proxy, "tcp://*:49200", @logger)
+    thread = Thread.new {
+      server.server_loop
+    }
+    client = ZmqJsonRpc::Client.new("tcp://127.0.0.1:49200")
+    assert_equal client.some_method(1, "b", [1,{a:1}]), "abc"
+    assert proxy.method_was_called?, "Server method was not called"
+
+    assert_raise ZmqJsonRpc::ClientError do
+      client.fishy_method()
+    end
+
+    thread.exit
+  end
+end

data/zmqjsonrpc.gemspec

@@ -0,0 +1,24 @@
+# more info here: http://guides.rubygems.org/specification-reference/
+
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "zmqjsonrpc"
+  spec.version       = "0.1"
+  spec.authors       = ["Tom Rothe"]
+  spec.email         = ["tom@bisdn.de"]
+  spec.description   = 'Simple JSON RPC 2.0 client and server via zmq.'
+  spec.summary       = 'ZeroMQ JSON RPC client and server.'
+  spec.homepage      = "https://github.com/bisdn/zmqjsonrpc"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.test_files    = Dir.glob('test/*.rb')
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency("ffi-rzmq", "~> 2.0.4")
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: zmqjsonrpc
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Tom Rothe
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi-rzmq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.4
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+description: Simple JSON RPC 2.0 client and server via zmq.
+email:
+- tom@bisdn.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- Vagrantfile
+- lib/simple_json_rpc/client.rb
+- lib/simple_json_rpc/server.rb
+- lib/zmqjsonrpc.rb
+- test/test_client_server.rb
+- zmqjsonrpc.gemspec
+homepage: https://github.com/bisdn/zmqjsonrpc
+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.0.14
+signing_key: 
+specification_version: 4
+summary: ZeroMQ JSON RPC client and server.
+test_files:
+- test/test_client_server.rb