qrpc 0.4.0 → 0.9.0

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

@@ -0,0 +1,126 @@
+# encoding: utf-8
+# (c) 2011 Martin Kozák (martinkozak@martinkozak.net)
+
+require "abstract"
+require "qrpc/general"
+require "qrpc/protocol/abstract/object"
+
+##
+# General QRPC module.
+#
+
+module QRPC
+    
+    ##
+    # Protocols helper module.
+    # @since 0.9.0
+    #
+    
+    module Protocol
+
+        ##
+        # Abstract protocol implementation.
+        # @since 0.9.0
+        #
+        
+        class Abstract
+        
+            ##
+            # Abstract request implementation.
+            #
+            # @since 0.9.0
+            # @abstract
+            #
+            
+            class Request < Object
+              
+                ##
+                # Constructor.
+                #
+                # @param [Hash] init  initial options
+                # @abstract
+                #
+                
+                def initialize(init = { })
+                    super(init)
+                    if self.instance_of? Request
+                        not_implemented
+                    end
+                end
+
+                ##
+                # Parses the data for new object.
+                #
+                # @param [String] raw  raw data
+                # @return [Request]  new request according to data
+                # @abstract
+                #
+                                
+                def self.parse(raw)
+                    not_implemented
+                end
+                
+                ##
+                # Returns ID of the request.
+                #
+                # @return [Object] request ID
+                # @abstract
+                #
+                
+                def id
+                    not_implemented
+                end
+                
+                ##
+                # Returns method identifier of the request.
+                #
+                # @return Symbol
+                # @abstract
+                #
+                
+                def method
+                    not_implemented
+                end
+
+                ##
+                # Returns method params of the request.
+                #
+                # @return Array
+                # @abstract
+                #
+                
+                def params
+                    not_implemented
+                end
+
+                ##
+                # Returns the QRPC request priority.
+                # @return Integer
+                #
+                 
+                def priority
+                    not_implemented
+                end
+
+                ##
+                # Returns the QRPC request client identifier.
+                # @return Object
+                #
+                 
+                def client
+                    not_implemented
+                end
+                
+                ##
+                # Indicates, job is notification.
+                # @return Boolean
+                #
+                
+                def notification?
+                    not_implemented
+                end
+                
+            end
+        end
+    end
+end

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

@@ -0,0 +1,103 @@
+# encoding: utf-8
+# (c) 2011 Martin Kozák (martinkozak@martinkozak.net)
+
+require "abstract"
+require "qrpc/general"
+require "qrpc/protocol/abstract/object"
+
+##
+# General QRPC module.
+#
+
+module QRPC
+    
+    ##
+    # Protocols helper module.
+    # @since 0.9.0
+    #
+    
+    module Protocol
+
+        ##
+        # Abstract protocol implementation.
+        # @since 0.9.0
+        #
+        
+        class Abstract
+        
+            ##
+            # Abstract response implementation.
+            #
+            # @since 0.9.0
+            # @abstract
+            #
+            
+            class Response < Object
+              
+                ##
+                # Constructor.
+                #
+                # @param [Hash] init  initial options
+                # @abstract
+                #
+                
+                def initialize(init = { })
+                    super(init)
+                    if self.instance_of? Response
+                        not_implemented
+                    end
+                end
+                
+                ##
+                # Parses the data for new object.
+                #
+                # @param [String] raw  raw data
+                # @return [Response]  new response according to data
+                # @abstract
+                #
+                                
+                def self.parse(raw)
+                    not_implemented
+                end
+
+                ##
+                # Returns ID of the request.
+                # @return [Object] request ID
+                #
+                
+                def id
+                    not_implemented
+                end
+                
+                                  
+                ##
+                # Returns response error.
+                # @return [Exception] error object
+                #
+                
+                def error
+                    not_implemented
+                end            
+
+                ##
+                # Indicates, error state of the response.
+                # @return [Boolean] error indication
+                #
+                
+                def error?
+                    not_implemented
+                end
+                   
+                ##
+                # Returns response result.
+                # @return [Object] response result
+                #
+                
+                def result
+                    not_implemented
+                end
+                
+            end
+        end
+    end
+end

data/lib/qrpc/protocol/json-rpc.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+# (c) 2011 Martin Kozák (martinkozak@martinkozak.net)
+
+require "qrpc/protocol/abstract"
+
+##
+# General QRPC module.
+#
+
+module QRPC
+    
+    ##
+    # Protocols helper module.
+    # @since 0.9.0
+    #
+    
+    module Protocol
+
+        ##
+        # JSON-RPC protocol implementation.
+        # @since 0.9.0
+        #
+        
+        class JsonRpc < Abstract
+        end
+               
+    end
+end
+
+require "qrpc/protocol/json-rpc/error"
+require "qrpc/protocol/json-rpc/request"
+require "qrpc/protocol/json-rpc/response"

data/lib/qrpc/protocol/json-rpc/error.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+# (c) 2011 Martin Kozák (martinkozak@martinkozak.net)
+
+require "qrpc/general"
+require "qrpc/protocol/abstract/error"
+require "qrpc/protocol/json-rpc/native/exception-data"
+
+##
+# General QRPC module.
+#
+
+module QRPC
+    
+    ##
+    # Protocols helper module.
+    # @since 0.9.0
+    #
+    
+    module Protocol
+
+        ##
+        # JSON-RPC protocol implementation.
+        # @since 0.9.0
+        #
+        
+        class JsonRpc
+        
+            ##
+            # JSON-RPC error implementation.
+            # @since 0.9.0
+            #
+            
+            class Error < QRPC::Protocol::Abstract::Error
+              
+                ##
+                # Holds native object.
+                #
+                
+                @native 
+                
+                ##
+                # Returns the native object.
+                # @return [JsonRpcObjects::Generic::Error]  native response object
+                #
+                
+                def native
+                    if @native.nil?
+                        exception = @options.exception
+                        request = @options.request
+                        data = QRPC::Protocol::JsonRpc::Native::ExceptionData::create(exception)
+                        
+                        @native = request.native.class::version.error::create(100, "exception raised during processing the request", :error => data.output)
+                        @native.serializer = @options.serializer
+                    end
+                    
+                    @native
+                end
+                
+                ##
+                # Serializes object to the resultant form.
+                # @return [String]  serialized form
+                #
+                
+                def serialize
+                    self.native.serialize
+                end
+                                
+            end
+        end
+    end
+end

data/lib/qrpc/protocol/json-rpc/native/exception-data.rb

@@ -0,0 +1,247 @@
+# encoding: utf-8
+# (c) 2011 Martin Kozák (martinkozak@martinkozak.net)
+
+require "qrpc/protocol/json-rpc/native/qrpc-object"
+require "json-rpc-objects/generic/object"
+require "qrpc/protocol/json-rpc"
+require "qrpc/general"
+require "base64"
+
+##
+# General QRPC module.
+#
+
+module QRPC
+    
+    ##
+    # JSON RPC helper module.
+    # @since 0.2.0
+    #
+
+    module Protocol
+
+        ##
+        # JSON-RPC protocol implementation.
+        # @since 0.9.0
+        #
+        
+        class JsonRpc
+
+            ##
+            # Native JSON-RPC classes.
+            # @since 0.9.0
+            #
+            
+            module Native
+                      
+                ##
+                # Exception data QRPC JSON-RPC object.
+                # @since 0.2.0
+                #
+                
+                class ExceptionData < JsonRpcObjects::Generic::Object
+                
+                    ##
+                    # Holds JSON-RPC version indication.
+                    #
+                    
+                    VERSION = QRPC::Protocol::JsonRpc::Native::QrpcObject::VERSION
+                    
+                    ##
+                    # Holds exception name.
+                    # @return [Symbol]
+                    #
+                    
+                    attr_accessor :name
+                    @name
+                    
+                    ##
+                    # Holds exception message.
+                    # @return [String]
+                    #
+                    
+                    attr_accessor :message
+                    @message
+                    
+                    ##
+                    # Holds backtrace. See readme for structure details.
+                    # @return [Array]
+                    #
+                    
+                    attr_accessor :backtrace
+                    @backtrace
+                    
+                    ##
+                    # Holds native dump. See readme for structure details.
+                    # @return [Class]
+                    #
+                    
+                    attr_accessor :dump
+                    @dump
+                    
+                    ##
+                    # Indicates, data are encoded and should be decoded.
+                    #
+                    
+                    @__encoded
+                    
+                    ##
+                    # Creates new QRPC JSON-RPC object.
+                    #
+                    # @overload create(exception, nil, opts = { })
+                    #   Creates from exception.
+                    #   @param [Exception] exception exception object
+                    #   @param [NilClass] nil (not applicable)
+                    #   @param [Hash] opts optional members of object
+                    # @overload create(name, message, opts = { })
+                    #   Creates from exception description.
+                    #   @param [Symbol, String] name exception name
+                    #   @param [Object] exception message
+                    #   @param [Hash] opts optional members of object
+                    # @return [QRPC::Protocol::ExceptionData]  new instance
+                    #
+                    
+                    def self.create(arg1, message = nil, opts = { })
+                        if arg1.kind_of? ::Exception
+                            mode = :decoded
+                            data = {
+                                :name => arg1.class.name,
+                                :message => arg1.message,
+                                :backtrace => arg1.backtrace,
+                                :dump => {
+                                    "format" => "ruby",
+                                    "object" => arg1
+                                }
+                            }
+                        else
+                            mode = :encoded
+                            data = {
+                                :name => arg1,
+                                :message => message
+                            }
+                        end
+                        
+                        data.merge! opts
+                        return self::new(data, mode)
+                    end
+                    
+                    ##
+                    # Constructor.
+                    # @param [Hash] data for initializing the object
+                    #
+                    
+                    def initialize(data, mode = :encoded)
+                        @__encoded = (mode == :encoded)
+                        super(data)
+                    end
+                    
+                    ##
+                    # Checks correctness of the object data.
+                    #
+                    
+                    def check!
+                        self.normalize!
+        
+                        if not @name.kind_of? Symbol
+                            raise Exception::new("Exception name is expected to be Symbol or convertable to symbol.")
+                        end
+                        
+                        if not @backtrace.nil? and not @backtrace.kind_of? Array
+                            raise Exception::new("Backtrace is expected to be an Array.")
+                        end
+                        
+                        if not @dump.nil? 
+                            if @dump.object.nil? and @dump.raw.nil?
+                                raise Exception::new("Either object or RAW form of the dump must be set if dump is set.")
+                            elsif @dump.format.nil? or not @dump.format.kind_of? Symbol
+                                raise Exception::new("Dump format must be set and must be Symbol.")
+                            end
+                        end
+                    end
+                                
+                    ##
+                    # Renders data to output form.
+                    # @return [Hash] with data of object
+                    #
+        
+                    def output
+                        result = { 
+                            "name" => @name.to_s,
+                            "message" => @message,
+                        }
+                        
+                        # Backtrace
+                        if @backtrace.kind_of? Array
+                            result["backtrace"] = @backtrace.map { |i| Base64.encode64(i) }
+                        end
+                           
+                        # Dump
+                        if not @dump.nil?
+                            result["dump"] = {
+                                "format" => @dump.format,
+                            }
+                            
+                            if not dump.object.nil?
+                                raw = Base64.encode64(Marshal.dump(dump.object))
+                            else
+                                raw = dump.raw
+                            end
+                            
+                            result["dump"]["raw"] = raw
+                        end
+                        
+                        return result
+                    end
+               
+        
+                    protected
+                    
+                    ##
+                    # Assigns data.
+                    #
+        
+                    def data=(value, mode = nil)
+                        data = __convert_data(value, mode)
+                        
+                        # Required
+                        @name = data[:name]
+                        @message = data[:message]
+                        
+                        # Backtrace
+                        backtrace = data[:backtrace]
+                        
+                        if @__encoded and (backtrace.kind_of? Array)
+                            @backtrace = backtrace.map { |i| Base64.decode64(i) }
+                        end
+                        
+                        # Dump
+                        dump = data[:dump]
+                           
+                        if dump.kind_of? Hash
+                            @dump = Struct::new(:format, :raw, :object)::new(dump["format"].downcase.to_sym, dump["raw"], dump["object"])
+                            
+                            if not @dump.raw.nil? and @dump.object.nil? and (@dump.format == :ruby)
+                                @dump.object = Marshal.load(Base64.decode64(@dump.raw))
+                            end
+                        end
+                        
+                    end
+        
+                    ##
+                    # Converts data to standard (defined) format.
+                    #
+                    
+                    def normalize!
+                        @name = @name.to_sym
+                        
+                        if not @dump.nil?
+                            @dump.format = @dump.format.to_sym
+                        end
+                    end
+                    
+                end
+                        
+            end
+        end
+    end
+end