rjr 0.12.2 → 0.15.1

data/lib/rjr/util.rb

@@ -1,104 +0,0 @@
-# High level rjr utility mechanisms
-#
-# Copyright (C) 2013 Mohammed Morsi <mo@morsi.org>
-# Licensed under the Apache License, Version 2.0
-
-require 'rjr/dispatcher'
-
-module RJR
-
-# Mixin providing utility methods to define rjr methods and messages
-module Definitions
-  # Define one or more rjr methods, parameters should be in the form
-  #   :id => Callable
-  #
-  # id may be a single id or an array of them
-  def rjr_method(args = {})
-    args.each { |k, v|
-      RJR::Dispatcher.add_handler(k.to_s, &v)
-    }
-    nil
-  end
-
-  # Define/retrieve rjr messages. When defining pass a hash
-  # of mesasge ids to options to use in the defintions, eg
-  #   :id  => { :foo => :bar }
-  #
-  # When retrieving simply specify the id
-  def rjr_message(args={})
-    if args.is_a?(Hash)
-      args.each { |k,v|
-        RJR::Definitions.message(k.to_s, v)
-      }
-      nil
-    else
-      RJR::Definitions.message(args.to_s)
-    end
-  end
-
-  # Helper providing access to messages
-  def self.message(k, v=nil)
-    @rjr_messages ||= {}
-    @rjr_messages[k] = v unless v.nil?
-    @rjr_messages[k]
-  end
-
-  # Reset message registry
-  def self.reset
-    # TODO also invoke 'Dispatcher.init_handlers' ?
-    @rjr_messages = {}
-  end
-
-  # Generate / return random message. Optionally specify the transport which
-  # the message must accept
-  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
-
-# Class to encapsulate any number of rjr nodes
-class EasyNode
-  def initialize(node_args = {})
-    nodes = node_args.keys.collect { |n|
-              case n
-              when :amqp then
-                RJR::AMQPNode.new  node_args[:amqp]
-              when :ws then
-                RJR::WSNode.new    node_args[:ws]
-              when :tcp then
-                RJR::TCPNode.new   node_args[:tcp]
-              when :www then
-                RJR::WebNode.new   node_args[:www]
-              end
-            }
-    @multi_node = RJR::MultiNode.new :nodes => nodes
-  end
-
-  def invoke_request(dst, method, *params)
-    # TODO allow selection of node, eg automatically deduce which node type to use from 'dst'
-    @multi_node.nodes.first.invoke_request(dst, method, *params)
-  end
-
-  # Stop node on the specified signal
-  def stop_on(signal)
-    Signal.trap(signal) {
-      @multi_node.stop
-    }
-    self
-  end
-
-  def listen
-    @multi_node.listen
-    self
-  end
-
-  def join
-    @multi_node.join
-    self
-  end
-end
-
-end # module RJR

data/lib/rjr/web_node.rb

@@ -1,266 +0,0 @@
-# RJR WWW Endpoint
-#
-# Implements the RJR::Node interface to satisty JSON-RPC requests over the HTTP protocol
-#
-# The web node does not support callbacks at the moment, though at some point we may
-# allow a client to specify an optional webserver to send callback requests to. (TODO)
-#
-# Copyright (C) 2012 Mohammed Morsi <mo@morsi.org>
-# Licensed under the Apache License, Version 2.0
-
-skip_module = false
-begin
-require 'evma_httpserver'
-require 'em-http-request'
-# TODO also support fallback clients ? (curb / net/http / etc)
-rescue LoadError
-  skip_module = true
-end
-
-if skip_module
-# TODO output: "curb/evma_httpserver gems could not be loaded, skipping web node definition"
-require 'rjr/missing_node'
-RJR::WebNode = RJR::MissingNode
-
-else
-require 'socket'
-
-require 'rjr/node'
-require 'rjr/message'
-require 'rjr/dispatcher'
-require 'rjr/thread_pool2'
-
-module RJR
-
-# Web node callback interface, *note* callbacks are not supported on the web
-# node and thus this currently does nothing
-class WebNodeCallback
-  def initialize()
-  end
-
-  def invoke(callback_method, *data)
-    # TODO throw error?
-  end
-end
-
-# @private
-# Helper class intialized by eventmachine encapsulating a http connection
-class WebRequestHandler < EventMachine::Connection
-  include EventMachine::HttpServer
-
-  RJR_NODE_TYPE = :web
-
-  # WebRequestHandler initializer.
-  #
-  # specify the WebNode establishing the connection
-  def initialize(*args)
-    @web_node = args[0]
-  end
-
-  # {EventMachine::Connection#process_http_request} callback, handle request messages
-  def process_http_request
-    # TODO support http protocols other than POST
-    msg = @http_post_content.nil? ? '' : @http_post_content
-    ThreadPool2Manager << ThreadPool2Job.new(msg) { |m| handle_request(m) }
-  end
-
-  private
-
-  # Internal helper, handle request message received
-  def handle_request(message)
-    msg    = nil
-    result = nil
-    notification = NotificationMessage.is_notification_message?(msg)
-
-    begin
-      client_port, client_ip = Socket.unpack_sockaddr_in(get_peername)
-      msg    = notification ? NotificationMessage.new(:message => message, :headers => @web_node.message_headers) :
-                              RequestMessage.new(:message => message, :headers => @web_node.message_headers)
-      headers = @web_node.message_headers.merge(msg.headers)
-      result = Dispatcher.dispatch_request(msg.jr_method,
-                                           :method_args => msg.jr_args,
-                                           :headers => headers,
-                                           :client_ip => client_ip,
-                                           :client_port => client_port,
-                                           :rjr_node      => @web_node,
-                                           :rjr_node_id   => @web_node.node_id,
-                                           :rjr_node_type => RJR_NODE_TYPE,
-                                           :rjr_callback => WebNodeCallback.new())
-    rescue JSON::ParserError => e
-      result = Result.invalid_request
-    end
-
-    msg_id = msg.nil? ? nil : msg.msg_id
-    response = ResponseMessage.new(:id => msg_id, :result => result, :headers => headers)
-
-    unless notification
-      resp = EventMachine::DelegatedHttpResponse.new(self)
-      #resp.status  = response.result.success ? 200 : 500
-      resp.status = 200
-      resp.content = response.to_s
-      resp.content_type "application/json"
-      resp.send_response
-    end
-  end
-end
-
-# Web node definition, listen for and invoke json-rpc requests via web requests
-#
-# Clients should specify the hostname / port when listening for requests and
-# when invoking them.
-#
-# *note* the RJR javascript client also supports sending / receiving json-rpc
-# messages over http
-#
-# @example Listening for json-rpc requests over tcp
-#   # register rjr dispatchers (see RJR::Dispatcher)
-#   RJR::Dispatcher.add_handler('hello') { |name|
-#     "Hello #{name}!"
-#   }
-#
-#   # initialize node, listen, and block
-#   server = RJR::WebNode.new :node_id => 'server', :host => 'localhost', :port => '7777'
-#   server.listen
-#   server.join
-#
-# @example Invoking json-rpc requests over http using rjr
-#   client = RJR::WebNode.new :node_id => 'client'
-#   puts client.invoke_request('http://localhost:7777', 'hello', 'mo')
-#
-# @example Invoking json-rpc requests over http using curl
-#   $ curl -X POST http://localhost:7777 -d '{"jsonrpc":"2.0","method":"hello","params":["mo"],"id":"123"}'
-#   > {"jsonrpc":"2.0","id":"123","result":"Hello mo!"}
-#
-class WebNode < RJR::Node
-  private
-
-  # Internal helper, handle response message received
-  def handle_response(http)
-    msg    = ResponseMessage.new(:message => http.response, :headers => @message_headers)
-    res = err = nil
-    begin
-      res = Dispatcher.handle_response(msg.result)
-    rescue Exception => e
-      err = e
-    end
-
-    @response_lock.synchronize {
-      result = [msg.msg_id, res]
-      result << err if !err.nil?
-      @responses << result
-      @response_cv.signal
-    }
-  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
-
-  public
-
-  # WebNode initializer
-  # @param [Hash] args the options to create the tcp node with
-  # @option args [String] :host the hostname/ip which to listen on
-  # @option args [Integer] :port the port which to listen on
-  def initialize(args = {})
-     super(args)
-     @host      = args[:host]
-     @port      = args[:port]
-
-     @response_lock = Mutex.new
-     @response_cv   = ConditionVariable.new
-     @responses     = []
-  end
-
-  # Register connection event handler,
-  #
-  # *note* Since web node connections aren't persistant, we don't 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?
-  end
-
-  # Instruct Node to start listening for and dispatching rpc requests
-  #
-  # Implementation of {RJR::Node#listen}
-  def listen
-    em_run do
-      EventMachine::start_server(@host, @port, WebRequestHandler, self)
-    end
-  end
-
-  # Instructs node to send rpc request, and wait for / return response
-  # @param [String] uri location of node to send request to, should be
-  #   in format of http://hostname:port
-  # @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 invoke_request(uri, rpc_method, *args)
-    message = RequestMessage.new :method => rpc_method,
-                                 :args   => args,
-                                 :headers => @message_headers
-    cb = lambda { |http|
-      # TODO handle errors
-      handle_response(http)
-    }
-
-    em_run do
-      http = EventMachine::HttpRequest.new(uri).post :body => message.to_s
-      http.errback  &cb
-      http.callback &cb
-    end
-
-    # will block until response message is received
-    # TODO optional timeout for response ?
-    result = wait_for_result(message)
-    if result.size > 2
-      raise Exception, result[2]
-    end
-    return result[1]
-  end
-
-  # Instructs node to send rpc notification (immadiately returns / no response is generated)
-  #
-  # @param [String] uri location of node to send request to, should be
-  #   in format of http://hostname:port
-  # @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(uri, 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
-    cb = lambda { |arg| published_l.synchronize { invoked = true ; published_c.signal }}
-    em_run do
-      http = EventMachine::HttpRequest.new(uri).post :body => message.to_s
-      http.errback  &cb
-      http.callback &cb
-    end
-    published_l.synchronize { published_c.wait published_l unless invoked }
-    nil
-  end
-end
-
-end # module RJR
-end

data/lib/rjr/ws_node.rb

@@ -1,289 +0,0 @@
-# RJR WebSockets Endpoint
-#
-# Implements the RJR::Node interface to satisty JSON-RPC requests over the websockets protocol
-#
-# Copyright (C) 2012 Mohammed Morsi <mo@morsi.org>
-# Licensed under the Apache License, Version 2.0
-
-skip_module = false
-begin
-require 'em-websocket'
-require 'em-websocket-client'
-rescue LoadError
-  skip_module = true
-end
-
-if skip_module
-# TODO output: "ws dependencies could not be loaded, skipping ws node definition"
-require 'rjr/missing_node'
-RJR::WSNode = RJR::MissingNode
-
-else
-require 'socket'
-require 'rjr/node'
-require 'rjr/message'
-require 'rjr/dispatcher'
-require 'rjr/errors'
-require 'rjr/thread_pool2'
-
-module RJR
-
-# Web Socket node callback interface, used to invoke json-rpc methods
-# against a remote node via a web socket connection previously established
-#
-# After a node sends a json-rpc request to another, the either node may send
-# additional requests to each other via the socket already established until
-# it is closed on either end
-class WSNodeCallback
-  # WSNodeCallback initializer
-  # @param [Hash] args the options to create the websocket node callback with
-  # @option args [Socket] :socket socket connection used to send/receive messages
-  # @option args [Hash] :headers hash of rjr message headers present in client request when callback is established
-  def initialize(args = {})
-    @socket    = args[:socket]
-    @message_headers = args[:headers]
-  end
-
-  # Implementation of {RJR::NodeCallback#invoke}
-  def invoke(callback_method, *data)
-    msg = NotificationMessage.new :method => callback_method, :args => data, :headers => @message_headers
-    raise RJR::Errors::ConnectionError.new("websocket closed") if @socket.state == :closed
-    # TODO surround w/ begin/rescue block incase of other socket errors?
-    @socket.send(msg.to_s)
-  end
-end
-
-# Web socket node definition, listen for and invoke json-rpc requests via web sockets
-#
-# Clients should specify the hostname / port when listening for and invoking requests.
-#
-# *note* the RJR javascript client also supports sending / receiving json-rpc
-# messages over web sockets
-#
-# @example Listening for json-rpc requests over tcp
-#   # register rjr dispatchers (see RJR::Dispatcher)
-#   RJR::Dispatcher.add_handler('hello') { |name|
-#     "Hello #{name}!"
-#   }
-#
-#   # initialize node, listen, and block
-#   server = RJR::WSNode.new :node_id => 'server', :host => 'localhost', :port => '7777'
-#   server.listen
-#   server.join
-#
-# @example Invoking json-rpc requests over web sockets using rjr
-#   client = RJR::WsNode.new :node_id => 'client'
-#   puts client.invoke_request('ws://localhost:7777', 'hello', 'mo')
-#
-class WSNode < RJR::Node
-  RJR_NODE_TYPE = :ws
-
-  private
-
-  # Internal helper initialize new connection
-  def init_node(uri, &on_init)
-    connection = nil
-    @connections_lock.synchronize {
-      connection = @connections.find { |c|
-                     c.url == uri
-                   }
-      if connection.nil?
-        connection = EventMachine::WebSocketClient.connect(uri)
-        connection.callback do
-          on_init.call(connection)
-        end
-        @connections << connection
-        # TODO sleep until connected?
-      else
-        on_init.call(connection)
-      end
-    }
-    connection
-  end
-
-  # Internal helper handle messages
-  def handle_msg(endpoint, msg)
-    # TODO use messageutil incase of large messages?
-    if RequestMessage.is_request_message?(msg)
-      ThreadPool2Manager << ThreadPool2Job.new { handle_request(endpoint, msg, false) }
-
-    elsif NotificationMessage.is_notification_message?(msg)
-      ThreadPool2Manager << ThreadPool2Job.new { handle_request(endpoint, msg, true) }
-
-    elsif ResponseMessage.is_response_message?(msg)
-      handle_response(msg)
-
-    end
-  end
-
-  # Internal helper, handle request message received
-  def handle_request(endpoint, message, notification=false)
-    # XXX hack to handle client disconnection (should grap port/ip immediately on connection and use that)
-    client_port,client_ip = nil,nil
-    begin
-      client_port, client_ip = Socket.unpack_sockaddr_in(endpoint.get_peername)
-    rescue Exception=>e
-    end
-
-    msg    = notification ? NotificationMessage.new(:message => message, :headers => @message_headers) :
-                            RequestMessage.new(:message => message, :headers => @message_headers)
-    headers = @message_headers.merge(msg.headers)
-    result = Dispatcher.dispatch_request(msg.jr_method,
-                                         :method_args => msg.jr_args,
-                                         :headers => headers,
-                                         :client_ip => client_ip,
-                                         :client_port => client_port,
-                                         :rjr_node      => self,
-                                         :rjr_node_id   => @node_id,
-                                         :rjr_node_type => RJR_NODE_TYPE,
-                                         :rjr_callback =>
-                                           WSNodeCallback.new(:socket => endpoint,
-                                                              :headers => headers))
-    unless notification
-      response = ResponseMessage.new(:id => msg.msg_id, :result => result, :headers => headers)
-      endpoint.send(response.to_s)
-    end
-  end
-
-  # Internal helper, handle response message received
-  def handle_response(data)
-    msg    = ResponseMessage.new(:message => data, :headers => @message_headers)
-    res = err = nil
-    begin
-      res = Dispatcher.handle_response(msg.result)
-    rescue Exception => e
-      err = e
-    end
-
-    @response_lock.synchronize {
-      result = [msg.msg_id, res]
-      result << err if !err.nil?
-      @responses << result
-      @response_cv.signal
-    }
-  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
-
-
-  public
-  # WSNode initializer
-  # @param [Hash] args the options to create the web socket node with
-  # @option args [String] :host the hostname/ip which to listen on
-  # @option args [Integer] :port the port which to listen on
-  def initialize(args = {})
-     super(args)
-     @host      = args[:host]
-     @port      = args[:port]
-
-     @connections = []
-     @connections_lock = Mutex.new
-
-     @response_lock = Mutex.new
-     @response_cv   = ConditionVariable.new
-     @responses     = []
-
-     @connection_event_handlers = {:closed => [], :error => []}
-  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 [WSNode] 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
-      EventMachine::WebSocket.start(:host => @host, :port => @port) do |ws|
-        ws.onopen    { }
-        ws.onclose   {       @connection_event_handlers[:closed].each { |h| h.call self } }
-        ws.onerror   { |e|   @connection_event_handlers[:error].each  { |h| h.call self } }
-        ws.onmessage { |msg| handle_msg(ws, msg) }
-      end
-    end
-  end
-
-  # Instructs node to send rpc request, and wait for / return response
-  # @param [String] uri location of node to send request to, should be
-  #   in format of ws://hostname:port
-  # @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 invoke_request(uri, rpc_method, *args)
-    message = RequestMessage.new :method => rpc_method,
-                                 :args   => args,
-                                 :headers => @message_headers
-
-    em_run{
-      init_node(uri) do |c|
-        c.stream { |msg| handle_msg(c, msg) }
-
-        c.send_msg message.to_s
-      end
-    }
-
-    # TODO optional timeout for response ?
-    result = wait_for_result(message)
-
-    if result.size > 2
-      raise Exception, result[2]
-    end
-    return result[1]
-  end
-
-  # Instructs node to send rpc notification (immadiately returns / no response is generated)
-  #
-  # @param [String] uri location of node to send notification to, should be
-  #   in format of ws://hostname:port
-  # @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(uri, 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{
-      init_node(uri) do |c|
-        c.send_msg message.to_s
-
-        # XXX same bug w/ tcp node, due to nature of event machine
-        # we aren't guaranteed that message is actually written to socket
-        # here, process must be kept alive until data is sent or will be lost
-        published_l.synchronize { invoked = true ; published_c.signal }
-      end
-    }
-    published_l.synchronize { published_c.wait published_l unless invoked }
-    nil
-  end
-end
-
-end # module RJR
-end

data/lib/rjr.rb

@@ -1,16 +0,0 @@
-# rjr - Ruby Json Rpc
-#
-# Copyright (C) 2010-2012 Mohammed Morsi <mo@morsi.org>
-# Licensed under the Apache License, Version 2.0
-
-# rjr - Ruby Json Rpc
-module RJR ; end
-
-require 'rjr/amqp_node'
-require 'rjr/tcp_node'
-require 'rjr/web_node'
-require 'rjr/ws_node'
-require 'rjr/local_node'
-require 'rjr/multi_node'
-
-require 'rjr/util'

data/specs/amqp_node_spec.rb

@@ -1,31 +0,0 @@
-require 'rjr/amqp_node'
-require 'rjr/dispatcher'
-
-describe RJR::AMQPNode do
-  it "should invoke and satisfy amqp requests" do
-    server = RJR::AMQPNode.new :node_id => 'amqp', :broker => 'localhost'
-    client = RJR::AMQPNode.new :node_id => 'client', :broker => 'localhost'
-
-    foozbar_invoked = false
-    RJR::Dispatcher.init_handlers
-    RJR::Dispatcher.add_handler('foozbar') { |param|
-      @client_ip.should == nil
-      @client_port.should == nil
-      @rjr_node.should == server
-      @rjr_node_id.should == 'amqp'
-      @rjr_node_type.should == :amqp
-      param.should == 'myparam'
-      foozbar_invoked = true
-      'retval'
-    }
-
-    server.listen
-    res = client.invoke_request 'amqp-queue', 'foozbar', 'myparam'
-    server.halt
-    server.join
-    res.should == 'retval'
-    foozbar_invoked.should == true
-  end
-
-  # TODO ensure closed / error event handlers are invoked
-end