rjr 0.18.2 → 0.19.1

data/specs/request_spec.rb

@@ -0,0 +1,147 @@
+require 'rjr/request'
+
+module RJR
+  describe Request do
+    describe "#initialize" do
+      it "sets rjr method" do
+        request = Request.new :rjr_method => 'foobar'
+        request.rjr_method.should == 'foobar'
+      end
+
+      it "sets rjr method args" do
+        args = ['a', 'r', 'g']
+        request = Request.new :rjr_method_args => args
+        request.rjr_method_args.should == args
+      end
+
+      it "sets rjr headers" do
+        headers = {:h => :s}
+        request = Request.new :rjr_headers => headers
+        request.rjr_headers.should == headers
+      end
+
+      it "sets client ip" do
+        request = Request.new :rjr_client_ip => '127.0.0.1'
+        request.rjr_client_ip.should == '127.0.0.1'
+      end
+
+      it "sets client port" do
+        request = Request.new :rjr_client_port => 1234
+        request.rjr_client_port.should == 1234
+      end
+
+      it "sets callback" do
+        request = Request.new :rjr_callback => :cb
+        request.rjr_callback.should == :cb
+      end
+
+      it "sets node" do
+        request = Request.new :rjr_node => :node
+        request.rjr_node.should == :node
+      end
+
+      it "sets node id" do
+        request = Request.new :rjr_node_id => :node_id
+        request.rjr_node_id.should == :node_id
+      end
+
+      it "node type" do
+        request = Request.new :rjr_node_type => :node_type
+        request.rjr_node_type.should == :node_type
+      end
+
+      it "rjr handler" do
+        request = Request.new :rjr_handler => :handler
+        request.rjr_handler.should == :handler
+      end
+
+      it "initialies new RJR::Arguments object from argument list" do
+        args = ['a', 'r', 'g']
+        request = Request.new :rjr_method_args => args
+        request.rjr_method_args.should == args
+        request.rjr_args.should be_an_instance_of(Arguments)
+        request.rjr_args.args.should == args
+      end
+
+      it "sets default result to nil" do
+        Request.new.result.should be_nil
+      end
+    end
+
+    describe "#handle" do
+      it "invokes the registered handler with args" do
+        received = nil
+        handler = proc { |arg| received = arg }
+        request = Request.new :rjr_handler => handler,
+                              :rjr_method_args => ['foo']
+        request.handle
+        received.should == 'foo'
+      end
+
+      it "invokes registered handler in request contenxt" do
+        received = nil
+        handler = proc { |arg| received = @var }
+
+        request = Request.new :rjr_handler => handler
+        request.instance_variable_set(:@var, 'foo')
+        request.handle
+        received.should == 'foo'
+      end
+
+      it "returns the handler return value" do
+        handler = proc { |arg| 42 }
+        request = Request.new :rjr_handler => handler
+        request.handle.should == 42
+      end
+    end
+
+    describe "#to_json" do
+      it "returns the request in json format" do
+        request = Request.new :rjr_method => 'foobar',
+                              :rjr_method_args => [:a, :b],
+                              :rjr_headers => { :header1 => :val1 },
+                              :rjr_node_type => :local,
+                              :rjr_node_id => :loc1
+        j = request.to_json
+        j.should include('"json_class":"RJR::Request"')
+        j.should include('"rjr_method":"foobar"')
+        j.should include('"rjr_method_args":["a","b"]')
+        j.should include('"rjr_headers":{"header1":"val1"}')
+        j.should include('"rjr_node_type":"local"')
+        j.should include('"rjr_node_id":"loc1"')
+      end
+
+      it "includes the result in the json" do
+        request = Request.new
+        result = RJR::Result.new :result => 42,
+                                 :error_code => 123,
+                                 :error_msg  => 'error occurred',
+                                 :error_class => 'ArgumentError'
+        request.result = result
+
+        j = request.to_json
+        j.should include('"result":42')
+        j.should include('"error_code":123')
+        j.should include('"error_msg":"error occurred"')
+        j.should include('"error_class":"ArgumentError"')
+      end
+    end
+
+    describe "#json_create" do
+      it "returns a new request from json" do
+        j = '{"json_class":"RJR::Request","data":{"request":{"rjr_method":"foobar","rjr_method_args":["a","b"],"rjr_headers":{"foo":"bar"},"rjr_node_type":"local","rjr_node_id":"loc1"},"result":{"result":42,"error_code":null,"error_msg":null,"error_class":null}}}'
+        request = JSON.parse(j, :create_additions => true)
+
+        request.should be_an_instance_of(RJR::Request)
+        request.rjr_method.should == 'foobar'
+        request.rjr_method_args.should == ['a', 'b']
+        request.rjr_headers.should == { 'foo' => 'bar' }
+        request.rjr_node_type.should == 'local'
+        request.rjr_node_id.should == 'loc1'
+
+        request.result.should be_an_instance_of(RJR::Result)
+        request.result.result.should == 42
+      end
+    end
+  end # describe Request
+end # module RJR

data/specs/result_spec.rb

@@ -0,0 +1,144 @@
+require 'rjr/result'
+
+module RJR
+  describe Result do
+    describe "#initialize" do
+      it "initializes default attributes" do
+        result = Result.new
+        result.result.should be_nil
+        result.error_code.should be_nil
+        result.error_msg.should be_nil
+        result.error_class.should be_nil
+      end
+
+      it "stores result" do
+        result = Result.new :result => 'foobar'
+        result.result.should == 'foobar'
+      end
+
+      it "stores error" do
+        result = Result.new :error_code => 123, :error_msg => 'abc',
+                            :error_class => ArgumentError
+        result.error_code.should == 123
+        result.error_msg.should == 'abc'
+        result.error_class.should == ArgumentError
+      end
+
+      context "when an error code is not specified" do
+        it "should be marked as successful" do
+          result = Result.new
+          result.success.should == true
+          result.failed.should  == false
+        end
+      end
+
+      context "when an error code is specified" do
+        it "should be marked as failed" do
+          result = Result.new :error_code => 123
+          result.success.should == false
+          result.failed.should  == true
+        end
+      end
+    end # describe #initialize
+
+    describe "#==" do
+      context "all fields are equal" do
+        it "returns true" do
+          Result.new.should == Result.new
+          Result.new(:result => 1).should == Result.new(:result => 1)
+          Result.new(:error_code => 50).should == Result.new(:error_code => 50)
+        end
+      end
+
+      context "'success' is different" do
+        it "returns false" do
+          r1 = Result.new
+          r2 = Result.new
+          r1.success = true
+          r2.success = false
+          r1.should_not == r2
+        end
+      end
+
+      context "'failed' is different" do
+        it "returns false" do
+          r1 = Result.new
+          r2 = Result.new
+          r1.failed = true
+          r2.failed = false
+          r1.should_not == r2
+        end
+      end
+
+      context "'result' is different" do
+        it "returns false" do
+          r1 = Result.new
+          r2 = Result.new
+          r1.result = 1
+          r2.result = 2
+          r1.should_not == r2
+        end
+      end
+
+      context "'error_code' is different" do
+        it "returns false" do
+          r1 = Result.new
+          r2 = Result.new
+          r1.error_code = 1
+          r2.error_code = 2
+          r1.should_not == r2
+        end
+      end
+
+      context "'error_msg' is different" do
+        it "returns false" do
+          r1 = Result.new
+          r2 = Result.new
+          r1.error_msg = 'something'
+          r2.error_msg = 'bad'
+          r1.should_not == r2
+        end
+      end
+
+      context "'error_class' is different" do
+        it "returns false" do
+          r1 = Result.new
+          r2 = Result.new
+          r1.error_class = 'something'
+          r2.error_class = 'bad'
+          r1.should_not == r2
+        end
+      end
+    end # describe #==
+
+    describe "#invalid_request" do
+      it "is an instance of result" do
+        Result.invalid_request.should be_an_instance_of(Result)
+      end
+
+      it "has error code -32600" do
+        Result.invalid_request.error_code.should == -32600
+      end
+
+      it "has error message 'Invalid Request'" do
+        Result.invalid_request.error_msg.should == "Invalid Request"
+      end
+    end
+
+    describe "#method_not_found" do
+      it "is an instance of result" do
+        Result.method_not_found('foobar').should be_an_instance_of(Result)
+      end
+
+      it "has error code -32602" do
+        Result.method_not_found('foobar').error_code.should == -32602
+      end
+
+      it "has error message 'Method '<name>' not found'" do
+        Result.method_not_found('foobar').error_msg.should ==
+          "Method 'foobar' not found"
+      end
+    end
+
+  end # describe Result
+end # module RJR

data/specs/thread_pool_spec.rb

@@ -1,5 +1,5 @@
 require 'thread'
-require 'rjr/thread_pool'
+require 'rjr/util/thread_pool'
 
 # TODO ? test ThreadPoolJob being_executed?, completed?, exec, handle_timeout!
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rjr
 version: !ruby/object:Gem::Version
-  version: 0.18.2
+  version: 0.19.1
 platform: ruby
 authors:
 - Mo Morsi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-18 00:00:00.000000000 Z
+date: 2014-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -68,17 +68,27 @@ files:
 - examples/local.rb
 - examples/complete.rb
 - examples/amqp.rb
+- examples/structured_server.rb
 - examples/client.rb
 - examples/unix.rb
-- lib/rjr/semaphore.rb
-- lib/rjr/em_adapter.rb
-- lib/rjr/errors.rb
-- lib/rjr/inspect.rb
+- lib/rjr/node_callback.rb
+- lib/rjr/messages/compressed.rb
+- lib/rjr/messages/response.rb
+- lib/rjr/messages/request.rb
+- lib/rjr/messages/notification.rb
+- lib/rjr/messages.rb
 - lib/rjr/version.rb
 - lib/rjr/node.rb
 - lib/rjr/common.rb
-- lib/rjr/thread_pool.rb
-- lib/rjr/message.rb
+- lib/rjr/util/logger.rb
+- lib/rjr/util/em_adapter.rb
+- lib/rjr/util/handles_methods.rb
+- lib/rjr/util/inspect.rb
+- lib/rjr/util/has_messages.rb
+- lib/rjr/util/thread_pool.rb
+- lib/rjr/util/json_parser.rb
+- lib/rjr/util/args.rb
+- lib/rjr/request.rb
 - lib/rjr/nodes/web.rb
 - lib/rjr/nodes/udp.rb
 - lib/rjr/nodes/tcp.rb
@@ -94,6 +104,8 @@ files:
 - lib/rjr/nodes/unix.rb
 - lib/rjr/nodes/missing.rb
 - lib/rjr/nodes/multi.rb
+- lib/rjr/core_ext.rb
+- lib/rjr/result.rb
 - lib/rjr/dispatcher.rb
 - site/index.html
 - site/jquery-latest.js
@@ -102,8 +114,18 @@ files:
 - LICENSE
 - Rakefile
 - README.md
+- specs/json_parser_spec.rb
+- specs/messages/response_spec.rb
+- specs/messages/request_spec.rb
+- specs/messages/notification_spec.rb
 - specs/dispatcher_spec.rb
+- specs/handles_methods_spec.rb
+- specs/has_messages_spec.rb
 - specs/node_spec.rb
+- specs/args_spec.rb
+- specs/request_spec.rb
+- specs/node_callbacks_spec.rb
+- specs/result_spec.rb
 - specs/nodes/unix_spec.rb
 - specs/nodes/multi_spec.rb
 - specs/nodes/tcp_spec.rb
@@ -114,7 +136,6 @@ files:
 - specs/nodes/easy_spec.rb
 - specs/inspect_spec.rb
 - specs/thread_pool_spec.rb
-- specs/message_spec.rb
 - specs/em_adapter_spec.rb
 - bin/rjr-server
 - bin/rjr-client
@@ -148,13 +169,23 @@ requirements:
 - The eventmachine_httpserver and em-http-request gems are needed to use the web node
 - The em-websocket and em-websocket-client gems are needed to use the web socket node
 rubyforge_project: 
-rubygems_version: 2.0.11
+rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
 summary: JSON RPC server and client library over amqp, websockets, http, etc
 test_files:
+- specs/json_parser_spec.rb
+- specs/messages/response_spec.rb
+- specs/messages/request_spec.rb
+- specs/messages/notification_spec.rb
 - specs/dispatcher_spec.rb
+- specs/handles_methods_spec.rb
+- specs/has_messages_spec.rb
 - specs/node_spec.rb
+- specs/args_spec.rb
+- specs/request_spec.rb
+- specs/node_callbacks_spec.rb
+- specs/result_spec.rb
 - specs/nodes/unix_spec.rb
 - specs/nodes/multi_spec.rb
 - specs/nodes/tcp_spec.rb
@@ -165,6 +196,5 @@ test_files:
 - specs/nodes/easy_spec.rb
 - specs/inspect_spec.rb
 - specs/thread_pool_spec.rb
-- specs/message_spec.rb
 - specs/em_adapter_spec.rb
 has_rdoc: 

data/lib/rjr/errors.rb

@@ -1,23 +0,0 @@
-# RJR Errors
-#
-# Copyright (C) 2012 Mohammed Morsi <mo@morsi.org>
-# Licensed under the Apache License, Version 2.0
-
-module RJR
-
-# The RJR::Errors module provides a mechanism to dynamically create errors
-# on demand as they are needed. At some point this will go away / be replaced
-# with a more rigidly / fixed defined error heirarchy.
-module Errors
-
-# Catches all Errors constants and define new RuntimeError subclass
-def self.const_missing(error_name)  # :nodoc:
-  if error_name.to_s =~ /Error\z/
-    const_set(error_name, Class.new(RuntimeError))
-  else
-    super
-  end
-end
-
-end
-end

data/lib/rjr/message.rb

@@ -1,351 +0,0 @@
-# RJR Message
-#
-# Representations of json-rpc messages in accordance with the standard
-#
-# Copyright (C) 2012-2013 Mohammed Morsi <mo@morsi.org>
-# Licensed under the Apache License, Version 2.0
-
-require 'json'
-require 'rjr/common'
-
-module RJR
-
-# Message sent from client to server to invoke a json-rpc method
-class RequestMessage
-  # Message string received from the source
-  attr_accessor :json_message
-
-  # Method source is invoking on the destination
-  attr_accessor :jr_method
-
-  # Arguments source is passing to destination method
-  attr_accessor :jr_args
-
-  # ID of the message in accordance w/ json-rpc specification
-  attr_accessor :msg_id
-
-  # Optional headers to add to json outside of standard json-rpc request
-  attr_accessor :headers
-
-  # RJR Request Message initializer
-  #
-  # This should be invoked with one of two argument sets. If creating a new message
-  # to send to the server, specify :method, :args, and :headers to include in the message
-  # (message id will be autogenerated). If handling an new request message sent from the
-  # client, simply specify :message and optionally any additional headers (they will 
-  # be merged with the headers contained in the message)
-  #
-  # @param [Hash] args options to set on request
-  # @option args [String] :message json string received from sender
-  # @option args [Hash] :headers optional headers to set in request and subsequent messages
-  # @option args [String] :method method to invoke on server
-  # @option args [Array<Object>] :args to pass to server method, all must be convertable to/from json
-  def initialize(args = {})
-    if args.has_key?(:message)
-      begin
-        @json_message = args[:message]
-        request = RJR.parse_json(@json_message)
-        @jr_method = request['method']
-        @jr_args   = request['params']
-        @msg_id    = request['id']
-        @headers   = args.has_key?(:headers) ? {}.merge!(args[:headers]) : {}
-
-        request.keys.select { |k|
-          !['jsonrpc', 'id', 'method', 'params'].include?(k)
-        }.each { |k| @headers[k] = request[k] }
-
-      rescue Exception => e
-        #puts "Exception Parsing Request #{e}"
-        raise e
-      end
-
-    elsif args.has_key?(:method)
-      @jr_method = args[:method]
-      @jr_args   = args[:args]
-      @headers   = args[:headers]
-      @msg_id    = gen_uuid
-
-    end
-  end
-
-  # Class helper to determine if the specified string is a valid json-rpc
-  # method request
-  # @param [String] message string message to check
-  # @return [true,false] indicating if message is request message
-  def self.is_request_message?(message)
-    begin
-       # FIXME log error
-       parsed = RJR.parse_json(message)
-       parsed.has_key?('method') && parsed.has_key?('id')
-    rescue Exception => e
-      false
-    end
-  end
-
-  # Convert request message to string json format
-  def to_s
-    request = { 'jsonrpc' => '2.0',
-                'method' => @jr_method,
-                'params' => @jr_args }
-    request['id'] = @msg_id unless @msg_id.nil?
-    request.merge!(@headers) unless @headers.nil?
-    request.to_json.to_s
-  end
-
-end
-
-# Message sent from server to client in response to json-rpc request message
-class ResponseMessage
-  # Message string received from the source
-  attr_accessor :json_message
-
-  # ID of the message in accordance w/ json-rpc specification
-  attr_accessor :msg_id
-
-  # Result encapsulated in the response message
-  # @see RJR::Result
-  attr_accessor :result
-
-  # Optional headers to add to json outside of standard json-rpc request
-  attr_accessor :headers
-
-  # ResponseMessage initializer
-  #
-  # This should be invoked with one of two argument sets. If creating a new message
-  # to send to the client, specify :id, :result, and :headers to include in the message.
-  # If handling an new request message sent from the client, simply specify :message
-  # and optionally any additional headers (they will be merged with the headers contained
-  # in the message)
-  #
-  # @param [Hash] args options to set on request
-  # @option args [String] :message json string received from sender
-  # @option args [Hash] :headers optional headers to set in request and subsequent messages
-  # @option args [String] :id id to set in response message, should be same as that in received message
-  # @option args [RJR::Result] :result result of json-rpc method invocation
-  def initialize(args = {})
-    if args.has_key?(:message)
-      @json_message  = args[:message]
-      response = RJR.parse_json(@json_message)
-      @msg_id  = response['id']
-      @result   = Result.new
-      @result.success   = response.has_key?('result')
-      @result.failed    = !response.has_key?('result')
-      @headers   = args.has_key?(:headers) ? {}.merge!(args[:headers]) : {}
-
-      if @result.success
-        @result.result = response['result']
-
-      elsif response.has_key?('error')
-        @result.error_code = response['error']['code']
-        @result.error_msg  = response['error']['message']
-        @result.error_class = response['error']['class']  # TODO safely constantize this ?
-
-      end
-
-      response.keys.select { |k|
-        !['jsonrpc', 'id', 'result', 'error'].include?(k)
-      }.each { |k| @headers[k] = response[k] }
-
-    elsif args.has_key?(:result)
-      @msg_id  = args[:id]
-      @result  = args[:result]
-      @headers = args[:headers]
-
-    #else
-    #  raise ArgumentError, "must specify :message or :result"
-
-    end
-
-  end
-
-  # Class helper to determine if the specified string is a valid json-rpc
-  # method response
-  # @param [String] message string message to check
-  # @return [true,false] indicating if message is response message
-  def self.is_response_message?(message)
-    begin
-      json = RJR.parse_json(message)
-      json.has_key?('result') || json.has_key?('error')
-    rescue Exception => e
-      # FIXME log error
-      puts e.to_s
-      false
-    end
-  end
-
-  # Convert request message to string json format
-  def to_s
-    s = ''
-    if result.success
-      s =    {'jsonrpc' => '2.0',
-              'id'      => @msg_id,
-              'result'  => @result.result}
-
-    else
-      s =    {'jsonrpc' => '2.0',
-              'id'      => @msg_id,
-              'error'   => { 'code'    => @result.error_code,
-                             'message' => @result.error_msg,
-                             'class'   => @result.error_class}}
-    end
-
-    s.merge! @headers unless headers.nil?
-    return s.to_json.to_s
-  end
-end
-
-# Message sent to a jsonrpc node to invoke a rpc method but
-# indicate the result should _not_ be returned
-class NotificationMessage
-  # Message string received from the source
-  attr_accessor :json_message
-
-  # Method source is invoking on the destination
-  attr_accessor :jr_method
-
-  # Arguments source is passing to destination method
-  attr_accessor :jr_args
-
-  # Optional headers to add to json outside of standard json-rpc request
-  attr_accessor :headers
-
-  # RJR Notification Message initializer
-  #
-  # This should be invoked with one of two argument sets. If creating a new message
-  # to send to the server, specify :method, :args, and :headers to include in the message
-  # If handling an new request message sent from the client, simply specify :message and
-  # optionally any additional headers (they will be merged with the headers contained in
-  # the message)
-  # 
-  # No message id will be generated in accordance w/ the jsonrpc standard
-  #
-  # @param [Hash] args options to set on request
-  # @option args [String] :message json string received from sender
-  # @option args [Hash] :headers optional headers to set in request and subsequent messages
-  # @option args [String] :method method to invoke on server
-  # @option args [Array<Object>] :args to pass to server method, all must be convertable to/from json
-  def initialize(args = {})
-    if args.has_key?(:message)
-      begin
-        @json_message = args[:message]
-        notification = RJR.parse_json(@json_message)
-        @jr_method = notification['method']
-        @jr_args   = notification['params']
-        @headers   = args.has_key?(:headers) ? {}.merge!(args[:headers]) : {}
-
-        notification.keys.select { |k|
-          !['jsonrpc', 'method', 'params'].include?(k)
-        }.each { |k| @headers[k] = notification[k] }
-
-      rescue Exception => e
-        #puts "Exception Parsing Notification #{e}"
-        raise e
-      end
-
-    elsif args.has_key?(:method)
-      @jr_method = args[:method]
-      @jr_args   = args[:args]
-      @headers   = args[:headers]
-
-    end
-  end
-
-  # Class helper to determine if the specified string is a valid json-rpc
-  # notification
-  #
-  # @param [String] message string message to check
-  # @return [true,false] indicating if message is a notification message
-  def self.is_notification_message?(message)
-    begin
-       # FIXME log error
-       parsed = RJR.parse_json(message)
-       parsed.has_key?('method') && !parsed.has_key?('id')
-    rescue Exception => e
-      false
-    end
-  end
-
-  # Convert notification message to string json format
-  def to_s
-    notification = { 'jsonrpc' => '2.0',
-                     'method' => @jr_method,
-                     'params' => @jr_args }
-    notification.merge!(@headers) unless @headers.nil?
-    notification.to_json.to_s
-  end
-
-end
-
-# Helper utilities for messages
-class MessageUtil
-  # Retrieve and return a single json message from a data string.
-  #
-  # Returns the message and remaining portion of the data string,
-  # if message is found, else nil
-  #
-  # XXX really don't like having to do this, but a quick solution
-  # to the issue of multiple messages appearing in one tcp data packet.
-  #
-  # TODO efficiency can probably be optimized
-  # in the case closing '}' hasn't arrived yet
-  def self.retrieve_json(data) 
-    return nil if data.nil? || data.empty?
-    start  = 0
-    start += 1 until start == data.length || data[start].chr == '{'
-    on = mi = 0 
-    start.upto(data.length - 1).each { |i|
-      if data[i].chr == '{'
-        on += 1
-      elsif data[i].chr == '}'
-        on -= 1
-      end
-
-      if on == 0
-        mi = i
-        break
-      end
-    }
-    
-    return nil if mi == 0
-    return data[start..mi], data[(mi+1)..-1]
-  end
-
-  # Mechanism to register / retrieve preformatted message
-  #
-  # @param [Symbol] id id of message to get / set
-  # @param [String] msg optional preformatted message to store
-  # @return [String] json rpc message
-  def self.message(id, msg=nil)
-    @rjr_messages ||= {}
-    @rjr_messages[id] = msg unless msg.nil?
-    @rjr_messages[id]
-  end
-
-  # Clear preformatted messages
-  def self.clear
-    @rjr_messages = {}
-  end
-
-  # Return random message from registry.
-  #
-  # Optionally specify the transport which the message must accept
-  #   (TODO turn this into a generic selection callback)
-  def self.rand_msg(transport = nil)
-    @rjr_messages ||= {}
-    messages = @rjr_messages.select { |mid,m| m[:transports].nil? || transport.nil? ||
-                                              m[:transports].include?(transport) }
-    messages[messages.keys[rand(messages.keys.size)]]
-  end
-
-end # MessageUtil
-
-# Module providing helper methods for messages
-module MessageMixins
-
-  # Wrapper around MessageUtil.message
-  def define_message(name, &bl)
-    MessageUtil.message(name, bl.call)
-  end
-end
-
-end