rjr 0.12.2 → 0.15.1

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rjr
 version: !ruby/object:Gem::Version
-  version: 0.12.2
+  version: 0.15.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,24 +9,24 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-18 00:00:00.000000000 Z
+date: 2013-05-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.3.0
+        version: 2.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.3.0
+        version: 2.0.0
 - !ruby/object:Gem::Dependency
   name: eventmachine
   requirement: !ruby/object:Gem::Requirement
@@ -68,40 +68,50 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- examples/web.rb
+- examples/tcp.rb
+- examples/server.rb
+- examples/ws.rb
+- examples/local.rb
+- examples/complete.rb
+- examples/amqp.rb
+- examples/client.rb
 - lib/rjr/semaphore.rb
-- lib/rjr/udp_node.rb
 - lib/rjr/em_adapter.rb
 - lib/rjr/errors.rb
-- lib/rjr/missing_node.rb
-- lib/rjr/inspect.rb
-- lib/rjr/ws_node.rb
-- lib/rjr/tcp_node.rb
-- lib/rjr/web_node.rb
 - lib/rjr/node.rb
-- lib/rjr/thread_pool2.rb
 - lib/rjr/common.rb
 - lib/rjr/thread_pool.rb
 - lib/rjr/message.rb
-- lib/rjr/tcp_node2.rb
-- lib/rjr/multi_node.rb
-- lib/rjr/local_node.rb
+- lib/rjr/stats.rb
+- lib/rjr/nodes/web.rb
+- lib/rjr/nodes/udp.rb
+- lib/rjr/nodes/tcp.rb
+- lib/rjr/nodes/ws.rb
+- lib/rjr/nodes/tcp2.rb
+- lib/rjr/nodes/local.rb
+- lib/rjr/nodes/amqp.rb
+- lib/rjr/nodes/easy.rb
+- lib/rjr/nodes/missing.rb
+- lib/rjr/nodes/multi.rb
 - lib/rjr/dispatcher.rb
-- lib/rjr/util.rb
-- lib/rjr/amqp_node.rb
-- lib/rjr.rb
 - specs/dispatcher_spec.rb
 - specs/node_spec.rb
-- specs/amqp_node_spec.rb
-- specs/tcp_node_spec.rb
-- specs/multi_node_spec.rb
-- specs/util_spec.rb
-- specs/local_node_spec.rb
-- specs/web_node_spec.rb
-- specs/ws_node_spec.rb
-- specs/inspect_spec.rb
+- specs/stats_spec.rb
+- specs/nodes/multi_spec.rb
+- specs/nodes/tcp_spec.rb
+- specs/nodes/web_spec.rb
+- specs/nodes/local_spec.rb
+- specs/nodes/amqp_spec.rb
+- specs/nodes/ws_spec.rb
+- specs/nodes/easy_spec.rb
 - specs/thread_pool_spec.rb
 - specs/message_spec.rb
 - specs/em_adapter_spec.rb
+- site/index.html
+- site/jquery-latest.js
+- site/json.js
+- site/jrw.js
 - LICENSE
 - Rakefile
 - README.md
@@ -127,9 +137,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.3
 requirements:
-- amqp gem is needed to use the amqp node
-- eventmachine_httpserver and em-http-request gems are needed to use the web node
-- em-websocket and em-websocket-client gems are needed to use the web socket node
+- The amqp gem and a running rabbitmq server is needed to use the amqp node
+- 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: 1.8.24
 signing_key: 

data/lib/rjr/amqp_node.rb

@@ -1,330 +0,0 @@
-# RJR AMQP Endpoint
-#
-# Implements the RJR::Node interface to satisty JSON-RPC requests over the AMQP protocol
-#
-# Copyright (C) 2012 Mohammed Morsi <mo@morsi.org>
-# Licensed under the Apache License, Version 2.0
-
-skip_module = false
-begin
-require 'amqp'
-rescue LoadError
-  skip_module = true
-end
-
-if skip_module
-# TODO output: "amqp gem could not be loaded, skipping amqp node definition"
-require 'rjr/missing_node'
-RJR::AMQPNode = RJR::MissingNode
-
-else
-require 'rjr/node'
-require 'rjr/message'
-require 'rjr/dispatcher'
-require 'rjr/errors'
-require 'rjr/thread_pool2'
-
-module RJR
-
-# AMQP node callback interface, used to invoke json-rpc methods on a
-# remote node which previously invoked a method on the local one.
-#
-# After a node sends a json-rpc request to another, the either node may send
-# additional requests to each other via amqp through this callback interface
-# until the queues are closed
-class AMQPNodeCallback
-
-  # AMQPNodeCallback initializer
-  # @param [Hash] args the options to create the amqp node callback with
-  # @option args [AMQPNode] :node amqp node used to send/receive messages
-  # @option args [String]   :destination name of the queue to invoke callbacks on
-  def initialize(args = {})
-    @node        = args[:node]
-    @destination = args[:destination]
-  end
-
-  # Implementation of {RJR::NodeCallback#invoke}
-  def invoke(callback_method, *data)
-    msg = NotificationMessage.new :method => callback_method, :args => data, :headers => @message_headers
-    @node.publish(msg.to_s, :routing_key => @destination, :mandatory => true) { }
-  end
-end
-
-# AMQP node definition, implements the {RJR::Node} interface to
-# listen for and invoke json-rpc requests over
-# {http://en.wikipedia.org/wiki/Advanced_Message_Queuing_Protocol AMQP}.
-#
-# Clients should specify the amqp broker to connect to when initializing
-# a node and specify the remote queue when invoking requests.
-#
-# @example Listening for json-rpc requests over amqp
-#   # register rjr dispatchers (see RJR::Dispatcher)
-#   RJR::Dispatcher.add_handler('hello') { |name|
-#     "Hello #{name}!"
-#   }
-#
-#   # initialize node, listen, and block
-#   server = RJR::AMQPNode.new :node_id => 'server', :broker => 'localhost'
-#   server.listen
-#   server.join
-#
-# @example Invoking json-rpc requests over amqp
-#   client = RJR::AMQPNode.new :node_id => 'client', :broker => 'localhost'
-#   puts client.invoke_request('server-queue', 'hello', 'mo') # the queue name is set to "#{node_id}-queue"
-class  AMQPNode < RJR::Node
-  RJR_NODE_TYPE = :amqp
-
-  private
-
-  # Internal helper, handle message pulled off queue
-  def handle_message(metadata, msg)
-    if RequestMessage.is_request_message?(msg)
-      reply_to = metadata.reply_to
-      ThreadPool2Manager << ThreadPool2Job.new { handle_request(reply_to, msg, false) }
-
-    elsif NotificationMessage.is_notification_message?(msg)
-      reply_to = metadata.reply_to
-      ThreadPool2Manager << ThreadPool2Job.new { handle_request(reply_to, msg, true) }
-
-    elsif ResponseMessage.is_response_message?(msg)
-      handle_response(msg)
-
-    end
-  end
-
-  # Internal helper, handle request message pulled off queue
-  def handle_request(reply_to, message, notification=false)
-    msg    = notification ? NotificationMessage.new(:message => message, :headers => @message_headers) :
-                            RequestMessage.new(:message => message, :headers => @message_headers)
-    headers = @message_headers.merge(msg.headers) # append request message headers
-    result = Dispatcher.dispatch_request(msg.jr_method,
-                                         :method_args => msg.jr_args,
-                                         :headers => headers,
-                                         :client_ip => nil,    # since client doesn't directly connect to server, we can't leverage
-                                         :client_port => nil,  # client ip / port for requests received via the amqp node type
-                                         :rjr_node      => self,
-                                         :rjr_node_id   => @node_id,
-                                         :rjr_node_type => RJR_NODE_TYPE,
-                                         :rjr_callback =>
-                                           AMQPNodeCallback.new(:node => self,
-                                                                :exchange => @exchange,
-                                                                :destination => reply_to,
-                                                                :headers => headers))
-    unless notification
-      response = ResponseMessage.new(:id => msg.msg_id, :result => result, :headers => headers)
-      publish(response.to_s, :routing_key => reply_to) { }
-    end
-  end
-
-  # Internal helper, handle response message pulled off queue
-  def handle_response(message)
-    msg    = ResponseMessage.new(:message => message, :headers => @message_headers)
-    res = err = nil
-    begin
-      res = Dispatcher.handle_response(msg.result)
-    rescue Exception => e
-      err = e.to_s
-    end
-
-    @response_lock.synchronize{
-      result = [msg.msg_id, res]
-      result << err if !err.nil?
-      @responses << result
-      @response_cv.signal
-    }
-  end
-
-  # Initialize the amqp subsystem
-  def init_node(&on_init)
-     if !@conn.nil? && @conn.connected?
-       on_init.call
-       return
-     end
-
-     super
-     @conn = AMQP.connect(:host => @broker) do |*args|
-       on_init.call
-     end
-     @conn.on_tcp_connection_failure { puts "OTCF #{@node_id}" }
-
-     # TODO move the rest into connect callback ?
-
-     ### connect to qpid broker
-     @channel = AMQP::Channel.new(@conn)
-
-     # qpid constructs that will be created for node
-     @queue_name  = "#{@node_id.to_s}-queue"
-     @queue       = @channel.queue(@queue_name, :auto_delete => true)
-     @exchange    = @channel.default_exchange
-
-     @listening = false
-     #@disconnected = false
-
-     @exchange.on_return do |basic_return, metadata, payload|
-         puts "#{payload} was returned! reply_code = #{basic_return.reply_code}, reply_text = #{basic_return.reply_text}"
-         #@disconnected = true # FIXME member will be set on wrong class
-         connection_event(:error)
-         connection_event(:closed)
-     end
-  end
-
-  # Internal helper, block until response matching message id is received
-  def wait_for_result(message)
-    res = nil
-    while res.nil?
-      @response_lock.synchronize{
-        # FIXME throw err if more than 1 match found
-        res = @responses.select { |response| message.msg_id == response.first }.first
-        if !res.nil?
-          @responses.delete(res)
-
-        else
-          @response_cv.signal
-          @response_cv.wait @response_lock
-        end
-      }
-    end
-    return res
-  end
-
-  # Internal helper, run connection event handlers for specified event
-  # TODO these are only run when we fail to send message to queue, need to detect when that queue is shutdown & other events
-  def connection_event(event)
-    if @connection_event_handlers.keys.include?(event)
-      @connection_event_handlers[event].each { |h|
-        h.call self
-      }
-    end
-  end
-
-  # Internal helper, subscribe to messages using the amqp queue
-  def subscribe(*args, &bl)
-    return if @listening
-    @amqp_lock.synchronize {
-      @listening = true
-      @queue.subscribe do |metadata, msg|
-        bl.call metadata, msg
-      end
-    }
-    nil
-  end
-
-
-  public
-
-  # AMQPNode initializer
-  # @param [Hash] args the options to create the amqp node with
-  # @option args [String] :broker the amqp message broker which to connect to
-  def initialize(args = {})
-     super(args)
-     @broker    = args[:broker]
-     @connection_event_handlers = {:closed => [], :error => []}
-     @response_lock = Mutex.new
-     @response_cv   = ConditionVariable.new
-     @responses     = []
-     @amqp_lock     = Mutex.new
-  end
-
-  # Publish a message using the amqp exchange (*do* *not* *use*).
-  #
-  # XXX hack should be private, declared publically so as to be able to be used by {RJR::AMQPNodeCallback}
-  def publish(*args, &on_publish)
-    @amqp_lock.synchronize {
-      #raise RJR::Errors::ConnectionError.new("client unreachable") if @disconnected
-      @exchange.publish *args do |*cargs|
-        on_publish.call
-      end
-    }
-    nil
-  end
-
-  # Register connection event handler
-  # @param [:error, :close] event the event to register the handler for
-  # @param [Callable] handler block param to be added to array of handlers that are called when event occurs
-  # @yield [AMQPNode] self is passed to each registered handler when event occurs
-  def on(event, &handler)
-    if @connection_event_handlers.keys.include?(event)
-      @connection_event_handlers[event] << handler
-    end
-  end
-
-  # Instruct Node to start listening for and dispatching rpc requests.
-  #
-  # Implementation of {RJR::Node#listen}
-  def listen
-    em_run do
-      init_node {
-        # start receiving messages
-        subscribe { |metadata, msg|
-          handle_message(metadata, msg)
-        }
-      }
-    end
-  end
-
-  # Instructs node to send rpc request, and wait for and return response.
-  #
-  # Do not invoke directly from em event loop or callback as will block the message
-  # subscription used to receive responses
-  #
-  # @param [String] routing_key destination queue to send request to
-  # @param [String] rpc_method json-rpc method to invoke on destination
-  # @param [Array] args array of arguments to convert to json and invoke remote method wtih
-  # @return [Object] the json result retrieved from destination converted to a ruby object
-  # @raise [Exception] if the destination raises an exception, it will be converted to json and re-raised here 
-  def invoke_request(routing_key, rpc_method, *args)
-    message = RequestMessage.new :method => rpc_method,
-                                 :args   => args,
-                                 :headers => @message_headers
-    em_run do
-      init_node {
-        # begin listening for result
-        subscribe { |metadata, msg|
-          handle_message(metadata, msg)
-        }
-
-        publish(message.to_s, :routing_key => routing_key, :reply_to => @queue_name) { }
-      }
-    end
-
-    # TODO optional timeout for response
-    result = wait_for_result(message)
-
-    if result.size > 2
-      raise Exception, result[2]
-    end
-    return result[1]
-  end
-
-  # FIXME add method to instruct node to send rpc request, and immediately
-  #        return / ignoring response & also add method to collect response
-  #        at a later time
-
-  # Instructs node to send rpc notification (immadiately returns / no response is generated)
-  #
-  # @param [String] routing_key destination queue to send request to
-  # @param [String] rpc_method json-rpc method to invoke on destination
-  # @param [Array] args array of arguments to convert to json and invoke remote method wtih
-  def send_notification(routing_key, rpc_method, *args)
-    # will block until message is published
-    published_l = Mutex.new
-    published_c = ConditionVariable.new
-
-    invoked = false
-    message = NotificationMessage.new :method => rpc_method,
-                                      :args   => args,
-                                      :headers => @message_headers
-    em_run do
-      init_node {
-        publish(message.to_s, :routing_key => routing_key, :reply_to => @queue_name){
-          published_l.synchronize { invoked = true ; published_c.signal }
-        }
-      }
-    end
-    published_l.synchronize { published_c.wait published_l unless invoked }
-    nil
-  end
-
-end
-end
-end

data/lib/rjr/inspect.rb

@@ -1,65 +0,0 @@
-# JSON-RPC method definitions providing access to inspect the internal
-# node state.
-#
-# Note this isn't included in the top level rjr module by default,
-# manually include this module to incorporate these additional rjr method
-# definitions into your node
-#
-# Copyright (C) 2013 Mohammed Morsi <mo@morsi.org>
-# Licensed under the Apache License, Version 2.0
-
-require 'rjr/util'
-include RJR::Definitions
-
-# Helper method to process user params / select stats
-def select_stats(*filter)
-  lf = []
-  while q = filter.shift
-    lf << 
-      case q
-      when 'on_node'    then
-        n = filter.shift 
-        lambda { |ds| ds.request.rjr_node_type.to_s == n}
-
-      when "for_method" then
-        m = filter.shift
-        lambda { |ds| ds.request.rjr_method == m}
-
-      when 'successful' then
-        lambda { |ds| ds.result.success }
-
-      when 'failed'     then
-        lambda { |ds| ds.result.failed  }
-
-      end
-  end
-
-  RJR::DispatcherStat.stats.select { |ds| lf.all? { |lf| lf.call(ds) } }
-end
- 
-rjr_method \
-  "rjr::dispatches" =>
-    # Retrieve all the dispatches this node served matching the specified criteri
-    lambda { |*filter| select_stats(*filter) },
-
-  "rjr::num_dispatches" =>
-    # Retrieve the number of dispatches this node served matching the specified criteria
-    lambda { |*filter| select_stats(*filter).size },
-
-  "rjr::status" =>
-    # Retrieve the overall status of this node
-    lambda {
-      {
-        # event machine
-        :event_machine => { :running => EMAdapter.running?,
-                            :thread_status => EMAdapter.reactor_thread.status,
-                            :connections => EventMachine.connection_count },
-
-        # thread pool
-        :thread_pool => { :running => ThreadPool2Manager.thread_pool.running?,
-                          :inspect => ThreadPool2Manager.thread_pool.inspect },
-      }
-    }
-
-  #:log =>
-  #  lambda {},

data/lib/rjr/local_node.rb

@@ -1,150 +0,0 @@
-# RJR Local Endpoint
-#
-# Implements the RJR::Node interface to satisty JSON-RPC requests via local method calls
-#
-# Copyright (C) 2012 Mohammed Morsi <mo@morsi.org>
-# Licensed under the Apache License, Version 2.0
-
-require 'rjr/node'
-require 'rjr/message'
-require 'rjr/dispatcher'
-require 'rjr/errors'
-
-module RJR
-
-# Local node callback interface, used to invoke local json-rpc method handlers
-class LocalNodeCallback
-  # LocalNodeCallback initializer
-  # @param [Hash] args the options to create the local node callback with
-  # @option args [LocalNode] :node local node used to send/receive messages
-  def initialize(args = {})
-    @node        = args[:node]
-  end
-
-  # Implementation of {RJR::NodeCallback#invoke}
-  def invoke(callback_method, *data)
-    # TODO any exceptions from handler will propagate here, surround w/ begin/rescue block
-    # TODO support local_node 'disconnections' via RJR::ConnectionError & triggering mechanism
-    ThreadPool2Manager <<
-      ThreadPool2Job.new(callback_method, data) { |m|
-        @node.local_dispatch(callback_method, *data)
-      }
-  end
-end
-
-# Local node definition, implements the {RJR::Node} interface to
-# listen for and invoke json-rpc requests via local handlers
-#
-# This is useful for situations in which you would like to invoke registered
-# json-rpc handlers locally, enforcing the same constraints as
-# you would on a json-rpc request coming in remotely.
-#
-# @example Listening for and dispatching json-rpc requests locally
-#   RJR::Dispatcher.add_handler('hello') { |name|
-#     @rjr_node_type == :local ? "Hello superuser #{name}" : "Hello #{name}!"
-#   }
-#
-#   # initialize node and invoke request
-#   node = RJR::LocalNode.new :node_id => 'node'
-#   node.invoke_request('hello', 'mo')
-#
-class LocalNode < RJR::Node
-  RJR_NODE_TYPE = :local
-
-  # allows clients to override the node type for the local node
-  attr_accessor :node_type
-
-  # Helper method to locally dispatch method/args
-  #
-  # TODO would like to make private but needed in LocalNodeCallback
-  def local_dispatch(rpc_method, *args)
-    # create request from args
-    0.upto(args.size).each { |i| args[i] = args[i].to_s if args[i].is_a?(Symbol) }
-    message = RequestMessage.new :method => rpc_method,
-                                 :args   => args,
-                                 :headers => @message_headers
-
-    # here we serialize / unserialze messages to/from json to
-    # ensure local node complies to same json-rpc restrictions as other nodes
-    message = RequestMessage.new :message => message.to_s,
-                                 :headers => @message_headers
-
-    result = Dispatcher.dispatch_request(message.jr_method,
-                                         :method_args => message.jr_args,
-                                         :headers => @message_headers,
-                                         :rjr_node      => self,
-                                         :rjr_node_id   => @node_id,
-                                         :rjr_node_type => @node_type,
-                                         :rjr_callback =>
-                                           LocalNodeCallback.new(:node => self,
-                                                                 :headers => @message_headers))
-
-    # create response message from result
-    response = ResponseMessage.new(:id => message.msg_id,
-                                   :result => result,
-                                   :headers => @message_headers)
-
-    # same comment on serialization/unserialization as above
-    response = ResponseMessage.new(:message => response.to_s,
-                                   :headers => @message_headers)
-
-    response
-  end
-
-  # LocalNode initializer
-  # @param [Hash] args the options to create the local node with
-  def initialize(args = {})
-     super(args)
-     @node_type = RJR_NODE_TYPE
-  end
-
-  # register connection event handler,
-  # *note* Until we support manual disconnections of the local node, we don't have to do anything here
-  #
-  # @param [:error, :close] event the event to register the handler for
-  # @param [Callable] handler block param to be added to array of handlers that are called when event occurs
-  # @yield [LocalNode] self is passed to each registered handler when event occurs
-  def on(event, &handler)
-    # TODO raise error (for the time being)?
-  end
-
-  # Instruct Node to start listening for and dispatching rpc requests
-  #
-  # Currently does nothing as method handlers can be invoked directly upon invoke_request
-  def listen
-  end
-
-  # Instructs node to send rpc request, and wait for and return response
-  #
-  # If strictly confirming to other nodes, use event machine to launch
-  # a thread pool job to dispatch request and block on result.
-  # Optimized for performance reasons but recognize the semantics of using
-  # the local node will be somewhat different.
-  #
-  # @param [String] rpc_method json-rpc method to invoke on destination
-  # @param [Array] args array of arguments to convert to json and invoke remote method wtih
-  # @return [Object] the json result retrieved from destination converted to a ruby object
-  # @raise [Exception] if the destination raises an exception, it will be converted to json and re-raised here 
-  def invoke_request(rpc_method, *args)
-    res = local_dispatch(rpc_method, *args) 
-    return Dispatcher.handle_response(res.result)
-  end
-
-  # Instructs node to send rpc notification (immediately returns / no response is generated)
-  #
-  # Same performance comment as invoke_request above
-  #
-  # @param [String] rpc_method json-rpc method to invoke on destination
-  # @param [Array] args array of arguments to convert to json and invoke remote method wtih
-  def send_notification(rpc_method, *args)
-    # TODO run in thread & immediately return?
-    begin
-      local_dispatch(rpc_method, *args)
-    rescue
-    end
-    nil
-  end
-
-
-end
-end