qrpc 0.4.0 → 0.9.0

data/lib/qrpc/protocol/object/error.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+# (c) 2012 Martin Kozák (martinkozak@martinkozak.net)
+
+require "qrpc/general"
+require "qrpc/protocol/abstract/error"
+
+##
+# General QRPC module.
+#
+
+module QRPC
+    
+    ##
+    # Protocols helper module.
+    # @since 0.9.0
+    #
+    
+    module Protocol
+
+        ##
+        # Object protocol implementation.
+        # @since 0.9.0
+        #
+        
+        class Object
+        
+            ##
+            # Object error implementation.
+            # @since 0.9.0
+            #
+            
+            class Error < QRPC::Protocol::Abstract::Error
+                
+                ##
+                # Serializes object to the resultant form.
+                # @return [Error]  serialized form
+                #
+                
+                def serialize
+                    self
+                end
+                
+            end
+        end
+    end
+end

data/lib/qrpc/protocol/object/request.rb

@@ -0,0 +1,111 @@
+# encoding: utf-8
+# (c) 2011 Martin Kozák (martinkozak@martinkozak.net)
+
+require "qrpc/general"
+require "qrpc/protocol/abstract/request"
+
+##
+# General QRPC module.
+#
+
+module QRPC
+    
+    ##
+    # Protocols helper module.
+    # @since 0.9.0
+    #
+    
+    module Protocol
+
+        ##
+        # Object protocol implementation.
+        # @since 0.9.0
+        #
+        
+        class Object
+        
+            ##
+            # Object request implementation.
+            # @since 0.9.0
+            #
+            
+            class Request < QRPC::Protocol::Abstract::Request
+
+                ##
+                # Parses the data for new object.
+                #
+                # @param [String] raw  raw data
+                # @return [Request]  new request according to data
+                #
+                                
+                def self.parse(raw)
+                    self::new(raw.options)
+                end
+                                
+                ##
+                # Serializes object to the resultant form.
+                # @return [Request]  serialized form
+                #
+                
+                def serialize
+                    self
+                end
+                
+                ##
+                # Returns ID of the request.
+                # @return [Object] request ID
+                #
+                
+                def id
+                    @options.id
+                end
+                
+                ##
+                # Returns method identifier of the request.
+                # @return [Symbol]
+                #
+                
+                def method
+                    @options[:method]
+                end
+
+                ##
+                # Returns method params of the request.
+                # @return [Array]
+                #
+                
+                def params
+                    @options.arguments
+                end
+
+                ##
+                # Returns the QRPC request priority.
+                # @return [Integer]
+                #
+                 
+                def priority
+                    @options.priority
+                end
+
+                ##
+                # Returns the QRPC request client identifier.
+                # @return [Object]
+                #
+                 
+                def client
+                    @options.client_id.to_s
+                end
+                
+                ##
+                # Indicates, job is notification.
+                # @return [Boolean]
+                #
+                
+                def notification?
+                    @options.notification
+                end
+                
+            end
+        end
+    end
+end

data/lib/qrpc/protocol/object/response.rb

@@ -0,0 +1,93 @@
+# encoding: utf-8
+# (c) 2012 Martin Kozák (martinkozak@martinkozak.net)
+
+require "qrpc/general"
+require "qrpc/protocol/abstract/response"
+
+##
+# General QRPC module.
+#
+
+module QRPC
+    
+    ##
+    # Protocols helper module.
+    # @since 0.9.0
+    #
+    
+    module Protocol
+
+        ##
+        # Object protocol implementation.
+        # @since 0.9.0
+        #
+        
+        class Object
+        
+            ##
+            # Object response implementation.
+            # @since 0.9.0
+            #
+            
+            class Response < QRPC::Protocol::Abstract::Response
+
+                ##
+                # Parses the data for new object.
+                #
+                # @param [String] raw  raw data
+                # @return [Response]  new request according to data
+                #
+                                
+                def self.parse(raw)
+                    self::new(raw.options)
+                end
+
+                ##
+                # Serializes object to the resultant form.
+                # @return [Response]  serialized form
+                #
+                
+                def serialize
+                    self
+                end
+                
+                ##
+                # Returns ID of the response.
+                # @return [Object] response ID
+                #
+                
+                def id
+                    @options.request.id
+                end
+                
+                ##
+                # Indicates, error state of the response.
+                # @return [Boolean] error indication
+                #
+                
+                def error?
+                    not self.error.nil?
+                end
+                                  
+                ##
+                # Returns response error.
+                # @return [Exception] error object
+                #
+                
+                def error
+                    @options.error
+                end
+                
+                ##
+                # Returns response result.
+                # @return [Object] response result
+                #
+                
+                def result
+                    @options.result
+                end
+                             
+            end
+        end
+    end
+end

data/lib/qrpc/server.rb

@@ -1,11 +1,15 @@
 # encoding: utf-8
-require "qrpc/general"
-require "qrpc/server/job"
-require "qrpc/server/dispatcher"
-require "qrpc/locator"
+# (c) 2011 Martin Kozák (martinkozak@martinkozak.net)
+
 require "qrpc/protocol/qrpc-object"
-require "em-jack"
+require "qrpc/server/dispatcher"
+require "qrpc/server/job"
+require "qrpc/general"
+
+require "hash-utils/hash"   # >= 0.1.0
 require "eventmachine"
+require "em-batch"
+require "em-jack"
 require "base64"
 
 ##
@@ -95,6 +99,20 @@ module QRPC
         
         @output_used
         
+        ##
+        # Holds protocol instance.
+        # @since 0.9.0
+        #
+        
+        @protocol
+        
+        ##
+        # Indicates API methods synchronicity.
+        # @since 0.4.0
+        #
+        
+        @synchronicity
+        
         ##
         # Holds servers for finalizing.
         #
@@ -103,11 +121,16 @@ module QRPC
 
         ##
         # Constructor.
+        #
         # @param [Object] api some object which will be used as RPC API
+        # @param [Symbol] synchronicity  API methods synchronicity
+        # @param [QRPC::Protocol::Abstract] protocol  a protocol handling instance
         #
         
-        def initialize(api)
+        def initialize(api, synchronicity = :synchronous, protocol = QRPC::default_protocol)
             @api = api
+            @protocol = protocol
+            @synchronicity = synchronicity
             @output_name_cache = { }
             
             # Destructor
@@ -132,9 +155,9 @@ module QRPC
         
         def finalize!
             if not @input_queue.nil?
-                @input_queue.watch("default") do
-                    @input_queue.ignore(@input_name.to_s) do
-                        @input_queue.close
+                @input_queue.subscribe("default") do
+                    @input_queue.unsubscribe(@input_name.to_s) do
+                        @input_queue.close!
                     end
                 end
             end
@@ -171,58 +194,52 @@ module QRPC
         
         def start_listening(locator, opts = { })
             @locator = locator
-            @dispatcher = QRPC::Server::Dispatcher::new(opts[:max_jobs])
-            
+            @dispatcher = QRPC::Server::Dispatcher::new
+
             # Cache cleaning dispatcher
-            EM.add_periodic_timer(20) do
+            EM::add_periodic_timer(20) do
                 @output_name_cache.clear
             end
-            
+
             # Process input queue
             self.input_queue do |queue|
-                worker = Proc::new do
-                    @dispatcher.available? do
-                        queue.reserve do |job|
-                            self.process_job(job)
-                            job.delete()
-                            worker.call()
-                        end
-                    end
+                queue.pop(true) do |job|
+                    self.process_job(job)
                 end
-                
-                worker.call()
             end
         end
-        
+    
         ##
         # Returns input queue.
         # @param [Proc] block block to which will be input queue given
         #
         
         def input_queue(&block)
-            if not @input_queue
-                @input_queue = EMJack::Connection::new(:host => @locator.host, :port => @locator.port)
-                @input_queue.watch(self.input_name.to_s) do
-                    @input_queue.ignore("default") do
-                        block.call(@input_queue)
+            if @input_queue.nil?
+                @input_queue = @locator.input_queue 
+                @input_queue.subscribe(self.input_name.to_s) do
+                    @input_queue.unsubscribe("default") do
+                        yield @input_queue 
                     end
                 end
             else
-                block.call(@input_queue)
+                @input_queue.subscribe(self.input_name.to_s) do
+                    yield @input_queue
+                end
             end
         end
-        
+    
         ##
         # Returns output queue.
-        # @return [EMJack::Connection] output queue Beanstalk connection
+        # @param [Proc] block block to which will be output queue given
         #
         
-        def output_queue
+        def output_queue(&block)
             if @output_queue.nil?
-                @output_queue = EMJack::Connection::new(:host => @locator.host, :port => @locator.port)
+                @output_queue = @locator.output_queue
+            else
+                @output_queue
             end
-            
-            return @output_queue
         end
         
         ##
@@ -236,7 +253,7 @@ module QRPC
             client_index = client.to_sym
             
             if not @output_name_cache.include? client_index
-               output_name = QRPC::QUEUE_PREFIX.dup << "-" << client.to_s << "-" << QRPC::QUEUE_POSTFIX_OUTPUT
+               output_name = QRPC::QUEUE_PREFIX + "-" + client.to_s + "-" + QRPC::QUEUE_POSTFIX_OUTPUT
                output_name = output_name.to_sym
                @output_name_cache[client_index] = output_name
             else
@@ -255,7 +272,7 @@ module QRPC
         
         def input_name
             if @input_name.nil?
-                @input_name = (QRPC::QUEUE_PREFIX.dup << "-" << @locator.queue << "-" << QRPC::QUEUE_POSTFIX_INPUT).to_sym
+                @input_name = (QRPC::QUEUE_PREFIX + "-" + @locator.queue_name + "-" + QRPC::QUEUE_POSTFIX_INPUT).to_sym
             end
             
             return @input_name
@@ -270,16 +287,14 @@ module QRPC
         #
         
         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
+            our_job = QRPC::Server::Job::new(@api, @synchronicity, job, @protocol)
+            if not our_job.request.notification?
+                our_job.callback do |result|
+                    output_name = self.output_name(our_job.client)
+                    output_queue = self.output_queue
+                    output_queue.use(output_name.to_s) do
+                        output_queue.push(result, our_job.priority)
+                    end
                 end
             end
             

data/lib/qrpc/server/dispatcher.rb

@@ -1,12 +1,15 @@
 # encoding: utf-8
-require "depq"
-
 
 ##
 # General QRPC module.
 #
 
 module QRPC
+  
+    ##
+    # Queue RPC server.
+    #
+    
     class Server
         
         ##
@@ -15,120 +18,15 @@ module QRPC
         
         class Dispatcher
         
-            ##
-            # Holds running EM fibers count.
-            #
-            
-            @count
-            
-            ##
-            # Holds unprocessed jobs queue.
-            #
-            
-            @queue
-            
-            ##
-            # Holds max jobs count.
-            #
-            
-            @max_jobs
-            
-            ##
-            # Holds "full state" locking mutex.
-            #
-            
-            @mutex
-            
-            ##
-            # Constructor.
-            #
-            
-            def initialize(max_jobs = 0)
-                @count = 0
-                @queue = Depq::new
-                @mutex = Mutex::new
-                @max_jobs = max_jobs
-                
-                if @max_jobs.nil?
-                    @max_jobs = 0
-                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 self.available?
-                    self.process_next!
-                    @count += 1
-                    self.regulate!
-                end
-            end
-            
-            ##
-            # Sets up next job for processing.
-            #
-            
-            def process_next!
-                job = @queue.pop
-                job.callback do
-                    if self.available? and not @queue.empty?
-                        self.process_next!
-                    else
-                        @count -= 1
-                        self.regulate!
-                    end
-                end
-
                 job.process!
             end
             
-            ##
-            # Indicates free space is available in dispatcher.
-            #
-            # If block is given, locks to time space in dispatcher is 
-            # available so works as synchronization primitive by this 
-            # way.
-            #
-            # @overload available?
-            #   @return [Boolean] +true+ if it is, +false+ in otherwise
-            # @overload available?(&block)
-            #   @param [Proc] block synchronized block
-            #
-            
-            def available?(&block)
-                if block.nil?
-                    return ((@count < @max_jobs) or (@max_jobs == 0))
-                else
-                    @mutex.synchronize(&block)
-                end
-            end
-            
-            
-            protected
-            
-            ##
-            # Regulates by locking the dispatcher it if it's full.
-            #
-            
-            def regulate!
-                if self.available?
-                    if @mutex.locked?
-                        @mutex.unlock
-                    end
-                else
-                    @mutex.try_lock
-                end
-            end
-            
         end
     end
 end