qrpc 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+   gem "json-rpc-objects", ">= 0.1.2"
+   gem "depq", ">= 0.4"
+   gem "em-beanstalk", ">= 0.0.10"
+   gem "eventmachine", ">= 0.12.10"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+end

data/Gemfile.lock

@@ -0,0 +1,36 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    addressable (2.2.2)
+    depq (0.4)
+    em-beanstalk (0.0.10)
+      eventmachine
+    eventmachine (0.12.10)
+    git (1.2.5)
+    hash-utils (0.3.0)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    json-rpc-objects (0.1.3)
+      addressable (>= 2.2.2)
+      hash-utils (>= 0.3.0)
+      multitype-introspection (>= 0.1.0)
+      types (>= 0.1.0)
+      yajl-ruby (>= 0.7.8)
+    multitype-introspection (0.1.0)
+    rake (0.8.7)
+    types (0.1.0)
+      multitype-introspection (>= 0.1.0)
+    yajl-ruby (0.7.9)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  depq (>= 0.4)
+  em-beanstalk (>= 0.0.10)
+  eventmachine (>= 0.12.10)
+  jeweler (~> 1.5.2)
+  json-rpc-objects (>= 0.1.2)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Martin Kozák
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,126 @@
+QRPC
+====
+
+**QRPC** currently implements queued JSON-RPC server which works as 
+normal RPC server, but through queue interface, so allows highly 
+scalable, distributed and asynchronous remote API implementation and 
+fast data processing. 
+
+It's based on [eventmachine][1] and [beanstalkd][2] so it's fast and 
+thread safe. 
+
+### Protocol
+
+It utilizes [JSON-RPC][3] protocol in versions both [1.1][4] and [2.0][5].
+Adds special data member `qrpc` with few options appropriate for queue 
+processing. Typicall request looks in Ruby hash notation like:
+    
+    {
+        "jsonrpc" => "2.0",
+        "method" => "subtract",
+        "params" => [2, 1],
+        "id" => <some unique job id>,
+        "qrpc" => {
+            "version" => "1.0",
+            "client" => <some unique client id>,
+            "priority" => 30
+        }
+    }
+    
+The last `priority` member is optional, others are expected to be 
+present including them which are optional in classic JSON-RPC. 
+Default priority is 50.
+
+Typical response looks like:
+
+    {
+        "jsonrpc" => "2.0",
+        "result" => 1,
+        "id" => <some unique job id>,
+        "qrpc" => {
+            "version" => "1.0",
+        }
+    }
+    
+And in case of exception:
+
+    {
+        "jsonrpc" => "2.0",
+        "error" => {
+            "code" => <some code>,
+            "message" => <some message>,
+            "data" => {
+                "name" => <exception class name>,
+                "message" => <exception message>,
+                "backtrace" => <array of Base64 encoded strings>,
+                "dump" => {
+                    "raw" => <Base 54 encoded marshaled exception object>,
+                    "format" => "Ruby"
+                }
+            }
+        },
+        
+        "id" => <some unique job id>,
+        "qrpc" => {
+            "version" => "1.0",
+        }
+    }
+    
+Both `backtrace` and `dump` members are optional.
+
+    
+### Usage
+
+Usage is simple. Look example:
+
+    require "qrpc/server"
+    
+    class Foo
+        def subtract(x, y)
+            x - y
+        end
+    end
+
+    server = QRPC::Server::new(Foo::new)
+    server.listen! QRPC::Locator::new("test")
+    
+This creates an instance of `Foo` which will serve as API, creates
+locator of the queue *test* at default server *localhost:11300*. Queue 
+name will be remapped to the real name *qrpc-test-input*. After call to 
+`#listen!`, it will run eventmachine and start listening for calls. If 
+you want to run it inside already run eventmachine, simply call 
+`#start_listening` with the same parameters.
+
+Calls processing is thread safe because of eventmachine concept 
+similar to fibers. Default number at one time processed jobs is 20,
+but it can be changed by setting `:max_jobs => <number>` to `#listen!` 
+or `#start_listening`.
+
+Reponse will be put to the same queue server, to queue named 
+`qrpc-<client identifier>-output`, with structure described above. 
+Client isn't implemented at this time.
+
+Contributing
+------------
+
+1. Fork it.
+2. Create a branch (`git checkout -b 20101220-my-change`).
+3. Commit your changes (`git commit -am "Added something"`).
+4. Push to the branch (`git push origin 20101220-my-change`).
+5. Create an [Issue][6] with a link to your branch.
+6. Enjoy a refreshing Diet Coke and wait.
+
+
+Copyright
+---------
+
+Copyright &copy; 2011 [Martin Kozák][7]. See `LICENSE.txt` for
+further details.
+
+[1]: http://rubyeventmachine.com/
+[2]: http://kr.github.com/beanstalkd/
+[3]: http://en.wikipedia.org/wiki/JSON-RPC
+[4]: http://groups.google.com/group/json-rpc/web/json-rpc-1-1-alt
+[5]: http://groups.google.com/group/json-rpc/web/json-rpc-2-0
+[6]: http://github.com/martinkozak/qrpc/issues
+[7]: http://www.martinkozak.net/

data/Rakefile

@@ -0,0 +1,37 @@
+# encoding: utf-8
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "qrpc"
+  gem.homepage = "http://github.com/martinkozak/qrpc"
+  gem.license = "MIT"
+  gem.summary = 'Queued JSON-RPC server. Works as normal RPC server, but through queue interface, so allows highly scalable, distributed and asynchronous remote API implementation and fast data processing. It\'s based on eventmachine and beanstalkd, so it\'s fast and thread safe.'
+  gem.email = "martinkozak@martinkozak.net"
+  gem.authors = ["Martin Kozák"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "qrpc #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/TODO.md

@@ -0,0 +1 @@
+* general queue interface for ability to use more queue servers.

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/qrpc/locator.rb

@@ -0,0 +1,101 @@
+# encoding: utf-8
+
+
+##
+# General QRPC module.
+#
+
+module QRPC
+    
+    ##
+    # Resource locator.
+    #
+    
+    class Locator
+    
+        ##
+        # Contains queue name.
+        #
+        
+        @queue
+        attr_accessor :queue
+        
+        ##
+        # Contains host.
+        #
+        
+        @host
+        attr_accessor :host
+        
+        ##
+        # Contains port.
+        #
+        
+        @port
+        attr_accessor :port
+        
+        ##
+        # Parser.
+        #
+        
+        PARSER = /^(.+)@(.+)(?:\:(\d+))?$/
+        
+        ##
+        # Default port.
+        #
+        
+        DEFAULT_PORT = 11300
+        
+        ##
+        # Constructor.
+        #
+        # @param [String, Symbol] queue queue name
+        # @param [String] host host name
+        # @param [Integer] port port of the host
+        #
+        
+        def initialize(queue, host = "localhost", port = 11300)
+            @queue = queue.to_s
+            @host = host
+            @port = port
+        end
+        
+        ##
+        # Parses the locator.
+        # Excpects form <queue>@<host>:<port>. Port is optional.
+        #
+        # @param [String] string locator in string form
+        # @return [QRPC::Locator] new instance
+        #
+        
+        def self.parse(string)
+            match = string.match(self::PARSER)
+            
+            queue = match[1]
+            host = match[2]
+            
+            if match.length == 3
+                port = match[3]
+            else
+                port = self::DEFAULT_PORT
+            end
+            
+            port = port.to_i
+            
+            ##
+            
+            return self::new(queue, host, port);
+        end
+        
+        ##
+        # Converts back to string.
+        # @return [String] locator in string form
+        #
+        
+        def to_s
+            @queue.dup << "@" << @host << ":" << @port.to_s
+        end
+        
+    end
+    
+end

data/lib/qrpc/server/dispatcher.rb

@@ -0,0 +1,87 @@
+# encoding: utf-8
+require "depq"
+
+
+##
+# General QRPC module.
+#
+
+module QRPC
+    class Server
+        
+        ##
+        # Queue RPC job.
+        #
+        
+        class Dispatcher
+        
+            ##
+            # Holds running EM fibers count.
+            #
+            
+            @count
+            
+            ##
+            # Holds unprocessed jobs queue.
+            #
+            
+            @queue
+            
+            ##
+            # Holds max jobs count.
+            #
+            
+            @max_jobs
+            
+            ##
+            # Constructor.
+            #
+            
+            def initialize(max_jobs = 20)
+                @count = 0
+                @queue = Depq::new
+                @max_jobs = max_jobs
+                
+                if @max_jobs.nil?
+                    @max_jobs = 20
+                end
+            end
+            
+            ##
+            # Puts job to dispatcher.
+            # @param [QRPC::Server::Job] job job for dispatching
+            #
+            
+            def put(job)
+                begin
+                    @queue.put(job, job.priority)
+                rescue ::Exception => e
+                    return
+                end
+                
+                if @count < @max_jobs
+                    self.process_next!
+                    @count += 1
+                end
+            end
+            
+            ##
+            # Sets up next job for processing.
+            #
+            
+            def process_next!
+                job = @queue.pop
+                job.callback do
+                    if (@count < @max_jobs) and not @queue.empty?
+                        self.process_next!
+                    else
+                        @count -= 1
+                    end
+                end
+
+                job.process!
+            end
+            
+        end
+    end
+end

data/lib/qrpc/server/job.rb

@@ -0,0 +1,145 @@
+# encoding: utf-8
+require "eventmachine"
+require "json-rpc-objects/request"
+require "json-rpc-objects/response"
+require "json-rpc-objects/error"
+
+
+##
+# General QRPC module.
+#
+
+module QRPC
+    class Server
+
+        ##
+        # Queue RPC job.
+        #
+        
+        class Job
+            include EM::Deferrable
+            
+            ##
+            # Indicates default priority.
+            #
+            
+            DEFAULT_PRIORITY = 50
+            
+            ##
+            # Holds beanstalk job.
+            #
+            
+            @job
+            
+            ##
+            # Holds JSON-RPC request.
+            #
+            
+            @request
+            
+            ##
+            # Holds API object.
+            #
+            
+            @api
+            
+            ##
+            # Constructor.
+            #
+            # @param [Object] object which will serve as API
+            # @param [EM::Beanstalk::Job] job beanstalk job
+            #
+            
+            def initialize(api, job)
+                @api = api
+                @job = job
+            end
+            
+            ##
+            # Starts processing.
+            #
+            
+            def process!
+                result = nil
+                error = nil
+                request = self.request
+                
+                begin
+                    result = @api.send(request.method, *request.params)
+                rescue ::Exception => e
+                    error = self.generate_error(request, e)
+                end
+
+                response = request.class::version.response::create(result, error, :id => request.id)
+                response.qrpc = { :version => :"1.0" }
+                
+                @job.delete()
+                self.set_deferred_status(:succeeded, response.to_json)
+            end
+            
+            ##
+            # Returns job in request form.
+            # @return [JsonRpcObjects::Generic::Object] request associated to job
+            #
+            
+            def request
+                if @request.nil?
+                    @request = JsonRpcObjects::Request::parse(@job.body)
+                end
+                
+                return @request
+            end
+            
+            ##
+            # Returns job priority according to request.
+            #
+            # Default priority is 50. You can scale up and down according
+            # to your needs in fact without limits.
+            #
+            # @return [Integer] priority level
+            #
+            
+            def priority
+                priority = self.request.qrpc["priority"]
+                if priority.nil?
+                    priority = self.class::DEFAULT_PRIORITY
+                else
+                    priority = priority.to_i
+                end
+                
+                return priority
+            end
+            
+            ##
+            # Returns client identifier.
+            # @return [String] client identifier
+            #
+            
+            def client
+                self.request.qrpc["client"]
+            end
+            
+            
+            protected
+            
+            ##
+            # Generates error from exception.
+            #
+            
+            def generate_error(request, exception)
+                data = {
+                    :name => exception.class.name,
+                    :message => exception.message,
+                    :backtrace => exception.backtrace.map { |s| Base64.encode64(s) },
+                    :dump => {
+                        :raw => Base64.encode64(Marshal.dump(exception)),
+                        :format => :Ruby,
+                    }
+                }
+                
+                request.class::version.error::create(100, "exception raised during processing the request", :error => data)
+            end
+              
+        end
+    end
+end

data/lib/qrpc/server.rb

@@ -0,0 +1,264 @@
+# encoding: utf-8
+require "qrpc/server/job"
+require "qrpc/server/dispatcher"
+require "qrpc/locator"
+require "em-beanstalk"
+require "eventmachine"
+require "base64"
+
+
+##
+# General QRPC module.
+#
+
+module QRPC
+    
+    ##
+    # Queue RPC server.
+    #
+    
+    class Server
+    
+        ##
+        # Prefix for handled queues.
+        #
+        
+        QRPC_PREFIX = "qrpc"
+        
+        ##
+        # Input queue postfix.
+        #
+        
+        QRPC_POSTFIX_INPUT = "input"
+        
+        ##
+        # Output queue postfix.
+        #
+        
+        QRPC_POSTFIX_OUTPUT = "output"
+
+        ##
+        # Holds API instance.
+        #
+        
+        @api
+        
+        ##
+        # Holds input locator.
+        #
+        
+        @locator
+        
+        ##
+        # Holds output queue name.
+        #
+        
+        @output_name
+        
+        ##
+        # Holds input queue instance.
+        #
+        
+        @input_queue
+        
+        ##
+        # Holds output queue instance.
+        #
+        
+        @output_queue
+        
+        ##
+        # Holds job dispatcher.
+        #
+        
+        @dispatcher
+        
+        ##
+        # Cache of output names.
+        #
+        
+        @output_name_cache
+        
+        ##
+        # Indicates currently used output queue.
+        #
+        
+        @output_used
+        
+        ##
+        # Holds servers for finalizing.
+        #
+        
+        @@servers = { }
+
+        ##
+        # Constructor.
+        # @param [Object] api some object which will be used as RPC API
+        #
+        
+        def initialize(api)
+            @api = api
+            @output_name_cache = { }
+            
+            # Destructor
+            ObjectSpace.define_finalizer(self, self.class.method(:finalize).to_proc)
+            @@servers[self.object_id] = self
+        end
+        
+        ##
+        # Finalizer handler.
+        # @param [Integer] id id of finalized instance
+        #
+        
+        def self.finalize(id)
+            if @@servers.has_key? id
+                @@servers[id].finalize!
+            end
+        end
+        
+        ##
+        # Destructor.
+        #
+        
+        def finalize!
+            if @input_queue
+                @input_queue.watch("default") do
+                    @input_queue.ignore(@input_name) do
+                        @input_queue.close
+                    end
+                end
+            end
+            
+            if @output_queue
+                @output_queue.use("default") do
+                    @output_queue.close
+                end
+            end
+        end
+        
+
+        ##
+        # Listens to the queue.
+        # (Blocking call which starts eventmachine.)
+        #
+        # @param [QRPC::Locator] locator of the input queue
+        # @param [Hash] opts options for the server
+        #
+
+        def listen!(locator, opts = { })
+            EM.run do
+                self.start_listening(locator, opts)
+            end
+        end
+        
+        ##
+        # Starts listening to the queue.
+        # (Blocking queue which expect, eventmachine is started.)        
+        #
+        # @param [QRPC::Locator] locator of the input queue
+        # @param [Hash] opts options for the server
+        #
+        
+        def start_listening(locator, opts)
+            @locator = locator
+            @locator.queue = self.class::QRPC_PREFIX.dup << "-" << @locator.queue << "-" << self.class::QRPC_POSTFIX_INPUT
+            @dispatcher = QRPC::Server::Dispatcher::new(opts[:max_jobs])
+            
+            # Cache cleaning dispatcher
+            EM.add_periodic_timer(20) do
+                @output_name_cache.clear
+            end
+            
+            # Process input queue
+            self.input_queue do |queue|
+                queue.each_job do |job|
+                    self.process_job(job)
+                end
+            end
+        end
+        
+        ##
+        #
+        
+        ##
+        # Returns input queue.
+        # (Callable from EM only.)
+        #
+        # @param [Proc] block block to which will be input queue given
+        #
+        
+        def input_queue(&block)
+            if not @input_queue
+                @input_queue = EM::Beanstalk::new(:host => @locator.host, :port => @locator.port)
+                @input_queue.watch(@locator.queue) do
+                    @input_queue.ignore("default") do
+                        block.call(@input_queue)
+                    end
+                end
+            else
+                block.call(@input_queue)
+            end
+        end
+        
+        ##
+        # Returns output queue.
+        # (Callable from EM only.)
+        #
+        # @return [EM::Beanstalk] output queue Beanstalk connection
+        #
+        
+        def output_queue
+            if not @output_queue
+                @output_queue = EM::Beanstalk::new(:host => @locator.host, :port => @locator.port)
+            end
+            
+            return @output_queue
+        end
+        
+        ##
+        # Returns output name for client name.
+        #
+        # @param [String, Symbol] client  client identifier
+        # @return [Symbol] output name
+        #
+        
+        def output_name(client)
+            client_index = client.to_sym
+            
+            if not @output_name_cache.include? client_index
+               output_name = self.class::QRPC_PREFIX.dup << "-" << client.to_s << "-" << self.class::QRPC_POSTFIX_OUTPUT
+               output_name = output_name.to_sym
+               @output_name_cache[client_index] = output_name
+            else
+                output_name = @output_name_cache[client_index]
+            end
+               
+            return output_name
+        end
+        
+        
+        protected
+        
+        ##
+        # Process one job.
+        #
+        
+        def process_job(job)
+            our_job = QRPC::Server::Job::new(@api, job) 
+            our_job.callback do |result|
+                call = Proc::new { self.output_queue.put(result, :priority => our_job.priority) }
+                output_name = self.output_name(our_job.client)
+
+                if @output_used != output_name 
+                    @output_used = output_name
+                    self.output_queue.use(output_name.to_s, &call)
+                else
+                    call.call
+                end
+            end
+            
+            @dispatcher.put(our_job)
+        end
+        
+    end
+end

data/qrpc.gemspec

@@ -0,0 +1,69 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{qrpc}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Martin Kozák"]
+  s.date = %q{2011-01-18}
+  s.email = %q{martinkozak@martinkozak.net}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "TODO.md",
+    "VERSION",
+    "lib/qrpc/locator.rb",
+    "lib/qrpc/server.rb",
+    "lib/qrpc/server/dispatcher.rb",
+    "lib/qrpc/server/job.rb",
+    "qrpc.gemspec",
+    "test-client.rb",
+    "test-server.rb"
+  ]
+  s.homepage = %q{http://github.com/martinkozak/qrpc}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Queued JSON-RPC server. Works as normal RPC server, but through queue interface, so allows highly scalable, distributed and asynchronous remote API implementation and fast data processing. It's based on eventmachine and beanstalkd, so it's fast and thread safe.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<json-rpc-objects>, [">= 0.1.2"])
+      s.add_runtime_dependency(%q<depq>, [">= 0.4"])
+      s.add_runtime_dependency(%q<em-beanstalk>, [">= 0.0.10"])
+      s.add_runtime_dependency(%q<eventmachine>, [">= 0.12.10"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+    else
+      s.add_dependency(%q<json-rpc-objects>, [">= 0.1.2"])
+      s.add_dependency(%q<depq>, [">= 0.4"])
+      s.add_dependency(%q<em-beanstalk>, [">= 0.0.10"])
+      s.add_dependency(%q<eventmachine>, [">= 0.12.10"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    end
+  else
+    s.add_dependency(%q<json-rpc-objects>, [">= 0.1.2"])
+    s.add_dependency(%q<depq>, [">= 0.4"])
+    s.add_dependency(%q<em-beanstalk>, [">= 0.0.10"])
+    s.add_dependency(%q<eventmachine>, [">= 0.12.10"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+  end
+end
+

data/test-client.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+require "beanstalk-client"
+require "json-rpc-objects/request"
+
+b = Beanstalk::Pool::new(["localhost:11300"])
+req1 = JsonRpcObjects::Request::create(:subtract, [2, 3], :id => "job1", :qrpc => { :version => "1.0", :client => :cc })
+req2 = JsonRpcObjects::Request::create(:something_bad, nil, :id => "job2", :qrpc => { :version => "1.0", :client => :cc, :priority => 20 })
+
+b.use("qrpc-test-input")
+b.watch("qrpc-cc-output")
+b.put(req1.to_json)
+b.put(req2.to_json)
+
+job = b.reserve
+puts job.body
+job.delete
+
+job = b.reserve
+puts job.body
+job.delete
+
+=begin
+100.times do
+    b.put(req1.to_json)
+    job = b.reserve
+    puts job.body
+    job.delete
+end
+=end

data/test-server.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+$:.push("./lib")
+
+class Foo
+    def subtract(x, y)
+        x - y
+    end
+end
+
+
+require "qrpc/server"
+server = QRPC::Server::new(Foo::new)
+server.listen! QRPC::Locator::new("test")

metadata

@@ -0,0 +1,168 @@
+--- !ruby/object:Gem::Specification 
+name: qrpc
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- "Martin Koz\xC3\xA1k"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-18 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json-rpc-objects
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 1
+        - 2
+        version: 0.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: depq
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 4
+        version: "0.4"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: em-beanstalk
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 0
+        - 10
+        version: 0.0.10
+  type: :runtime
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 12
+        - 10
+        version: 0.12.10
+  type: :runtime
+  prerelease: false
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 5
+        - 2
+        version: 1.5.2
+  type: :development
+  prerelease: false
+  version_requirements: *id006
+description: 
+email: martinkozak@martinkozak.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.md
+files: 
+- .document
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- TODO.md
+- VERSION
+- lib/qrpc/locator.rb
+- lib/qrpc/server.rb
+- lib/qrpc/server/dispatcher.rb
+- lib/qrpc/server/job.rb
+- qrpc.gemspec
+- test-client.rb
+- test-server.rb
+has_rdoc: true
+homepage: http://github.com/martinkozak/qrpc
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -3341094115904611072
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Queued JSON-RPC server. Works as normal RPC server, but through queue interface, so allows highly scalable, distributed and asynchronous remote API implementation and fast data processing. It's based on eventmachine and beanstalkd, so it's fast and thread safe.
+test_files: []
+