rjr 0.18.2 → 0.19.1

data/lib/rjr/util/handles_methods.rb

@@ -0,0 +1,115 @@
+# RJR HandlesMethods Mixin
+#
+# Copyright (C) 2014 Mohammed Morsi <mo@morsi.org>
+# Licensed under the Apache License, Version 2.0
+
+module RJR
+
+# Mixin adding methods allowing developer to specify JSON-RPC
+# methods which to dispatch to.
+#
+# @example Defining a structured JSON-RPC method handler
+#   class MyMethodHandler
+#     include RJR::HandlesMethods
+#
+#     jr_method :do_something
+#
+#     def handle(*params)
+#       'return value'
+#     end
+#   end
+#
+#   node = RJR::Nodes::TCP.new :host => '0.0.0.0', :port => 8888
+#   MyMethodHandler.dispatch_to(node.dispatcher)
+#   node.listen.join
+#
+#   # clients can now invoke the 'do_something' json-rpc method by
+#   # issuing requests to the target host / port
+#
+module HandlesMethods
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  # Override w/ custom handler logic
+  def handle
+  end
+
+  module ClassMethods
+    attr_accessor :jr_handlers
+
+    # Return the handler method matching the argument set
+    def extract_handler_method(args)
+      handler = nil
+
+      if method_defined?(args.last)
+        handler = args.last
+        args.delete_at(-1)
+
+      else
+        handler = :handle
+      end
+
+      [handler, args]
+    end
+
+    # Return bool indicating if handler exists for the specified method
+    def has_handler_for?(handler_method)
+      @jr_handlers ||= {}
+      @jr_handlers.has_key?(handler_method)
+    end
+
+    # Returns handler for specified method
+    def handler_for(handler_method)
+      @jr_handlers[handler_method]
+    end
+
+    # Create handler for specified method.
+    #
+    # Creates a proc that gets evaluated via instance_exec in request
+    def create_handler_for(handler_method)
+      @jr_handlers ||= {}
+      handler_class = self
+
+      @jr_handlers[handler_method] = proc { |*args|
+        # instantiate new handler instance
+        jr_instance = handler_class.new
+
+        # setup scope to include request variables
+        instance_variables.each { |iv|
+          jr_instance.instance_variable_set(iv, instance_variable_get(iv))
+        }
+
+        # invoke handler method
+        jr_instance.method(handler_method).call *args
+      }
+    end
+
+    # Register one or more json-rpc methods.
+    #
+    # Invoke w/ list of method signatures to match in dispatcher
+    # w/ optional id of local method to dispatch to. If no method
+    # specified, the :handle method will be used
+    def jr_method(*args)
+      @jr_method_args  ||= []
+      @jr_method_args  << args
+    end
+
+    # Register locally stored methods w/ the specified dispatcher
+    def dispatch_to(dispatcher)
+      @jr_method_args.each { |args|
+        # copy args so original is preserved
+        handler_method, jr_methods =
+          extract_handler_method(Array.new(args))
+        jr_methods.map! { |m| m.to_s }
+
+        handler = has_handler_for?(handler_method) ?
+                       handler_for(handler_method) :
+                create_handler_for(handler_method)
+
+        dispatcher.handle jr_methods, handler
+      }
+    end
+  end # module ClassMethods
+end # module HandlesMethods 
+end # module RJR

data/lib/rjr/util/has_messages.rb

@@ -0,0 +1,50 @@
+# RJR HasMessages Mixin
+#
+# Copyright (C) 2014 Mohammed Morsi <mo@morsi.org>
+# Licensed under the Apache License, Version 2.0
+
+module RJR
+
+# Mixin adding methods allowing developer to define performatted
+# messages on a class. After they are defined they may be retrieved,
+# manipulated, and sent to the server at any time
+module HasMessages
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  # Wrapper around HasMessages#message
+  def define_message(name, &bl)
+    self.class.message(name, bl.call)
+  end
+
+  module ClassMethods
+    # 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 message(id, msg=nil)
+      @rjr_messages ||= {}
+      @rjr_messages[id] = msg unless msg.nil?
+      @rjr_messages[id]
+    end
+
+    # Clear preformatted messages
+    def clear_messages
+      @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 rand_message(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
+end # module HasMessages
+end # module RJR

data/lib/rjr/{inspect.rb → util/inspect.rb}

@@ -51,7 +51,7 @@ def select_stats(dispatcher, *filter)
 end
 
 # Add inspection methods to specified dispatcher
-def dispatch_rjr_inspect(dispatcher)
+def dispatch_rjr_util_inspect(dispatcher)
   # Retrieve all the dispatches this node served matching the specified criteri
   dispatcher.handle "rjr::dispatches" do |filter|
     select_stats(dispatcher, *filter) 

data/lib/rjr/util/json_parser.rb

@@ -0,0 +1,101 @@
+# RJR JSON Parser
+#
+# Copyright (C) 2014 Mohammed Morsi <mo@morsi.org>
+# Licensed under the Apache License, Version 2.0
+
+require 'json'
+require 'rjr/common'
+
+module RJR
+
+# Provides utilities / helpers to parse json in a sane/safe manner
+class JSONParser
+
+  # Extract 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
+  #
+  # TODO efficiency can probably be optimized in the case closing '}'
+  # hasn't arrived yet
+  #
+  # FIXME if uneven brackets appears in string data (such as in params)
+  # this will break, detect when in string and ignore in counts
+  def self.extract_json_from(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
+
+  # Return bool indicating if json class is invalid in context
+  # of rjr & cannot be parsed.
+  #
+  # An invalid class is one not on whitelist if enabled or one
+  # not in ruby class heirachy.
+  #
+  # Implements a safe mechanism which to validate json data
+  # to parse
+  def self.invalid_json_class?(jc)
+    Class.whitelist_json_classes ||= false
+    Class.whitelist_json_classes ?
+      !Class.permitted_json_classes.include?(jc) : jc.to_s.to_class.nil?
+  end
+
+  def self.validate_json_hash(jh)
+    jh.each { |k,v|
+      if k == ::JSON.create_id && invalid_json_class?(v)
+        raise ArgumentError, "can't create json class #{v}"
+      elsif v.is_a?(Array)
+        validate_json_array(v)
+      elsif v.is_a?(Hash)
+        validate_json_hash(v)
+      end
+    }
+  end
+
+  def self.validate_json_array(ja)
+    ja.each { |jai|
+      if jai.is_a?(Array)
+        validate_json_array(jai)
+      elsif jai.is_a?(Hash)
+        validate_json_hash(jai)
+      end
+    }
+  end
+  
+  # Two stage json parser.
+  # For more details why this is required see json issue:
+  #   https://github.com/flori/json/issues/179
+  #
+  # FIXME this will only work for json >= 1.7.6 where
+  # create_additions is defined
+  def self.parse(js)
+    jp = ::JSON.parse js, :create_additions => false
+    if jp.is_a?(Array)
+      validate_json_array(jp)
+    elsif jp.is_a?(Hash)
+      validate_json_hash(jp)
+    else
+      return jp
+    end
+    ::JSON.parse js, :create_additions => true
+  end
+
+end # class JSONParser
+end # module RJR

data/lib/rjr/util/logger.rb

@@ -0,0 +1,128 @@
+# RJR Logger Class
+#
+# Copyright (C) 2011-2014 Mohammed Morsi <mo@morsi.org>
+# Licensed under the Apache License, Version 2.0
+
+require 'logger'
+
+module RJR
+
+# Logger helper class.
+#
+# Encapsulates the standard ruby logger in a thread safe manner. Dispatches
+# class methods to an internally tracked logger to provide global access.
+#
+# TODO handle logging errors (log size too big, logrotate, etc)
+#
+# @example
+#   RJR::Logger.info 'my message'
+#   RJR::Logger.warn 'my warning'
+class Logger
+  private
+    def self._instantiate_logger
+       if @logger.nil?
+         #STDOUT.sync = true
+         output = @log_to || ENV['RJR_LOG'] || STDOUT
+         @logger = ::Logger.new(output)
+         @logger.level = @log_level || ::Logger::FATAL
+         @logger_mutex = Mutex.new
+         @filters = []
+         @highlights = []
+       end
+    end
+
+  public
+
+    # Add method which to call on every log message to determine
+    # if messages should be included/excluded
+    def self.add_filter(filter)
+      @logger_mutex.synchronize{
+        @filters << filter
+      }
+    end
+
+    # Add a method which to call on every log message to determine
+    # if message should be highlighted
+    def self.highlight(hlight)
+      @logger_mutex.synchronize{
+        @highlights << hlight
+      }
+    end
+
+    def self.method_missing(method_id, *args)
+       _instantiate_logger
+       @logger_mutex.synchronize {
+         args = args.first if args.first.is_a?(Array)
+         args.each { |a|
+           # run highlights / filters against output before
+           # sending formatted output to logger
+           # TODO allow user to customize highlight mechanism/text
+           na = @highlights.any? { |h| h.call a } ?
+                  "\e[1m\e[31m#{a}\e[0m\e[0m" : a
+           @logger.send(method_id, na) if @filters.all? { |f| f.call a }
+         }
+       }
+    end
+
+    def self.safe_exec(*args, &bl)
+      _instantiate_logger
+      @logger_mutex.synchronize {
+        bl.call *args
+      }
+    end
+
+    def self.logger
+       _instantiate_logger
+       @logger
+    end
+
+    # Set log destination
+    # @param dst destination which to log to (file name, STDOUT, etc)
+    def self.log_to(dst)
+      @log_to = dst
+      @logger = nil
+      _instantiate_logger
+    end
+
+    # Set log level.
+    # @param level one of the standard rails log levels (default fatal)
+    def self.log_level=(level)
+      _instantiate_logger
+      if level.is_a?(String)
+        level = case level
+                when 'debug' then
+                  ::Logger::DEBUG
+                when 'info' then
+                  ::Logger::INFO
+                when 'warn' then
+                  ::Logger::WARN
+                when 'error' then
+                  ::Logger::ERROR
+                when 'fatal' then
+                  ::Logger::FATAL
+                end
+      end
+      @log_level    = level
+      @logger.level = level
+    end
+
+    # Return true if log level is set to debug, else false
+    def self.debug?
+      @log_level == ::Logger::DEBUG
+    end
+end
+
+end # module RJR
+
+# Serialized puts, uses logger lock to serialize puts output.
+# Definiting it in Kernel as 'puts' is defined there
+#
+# Though this could go in core_ext, since it's pretty specific
+# to RJR logger, adding here
+module Kernel
+  def sputs(*args)
+    ::RJR::Logger.safe_exec {
+      puts *args
+    }
+  end
+end

data/lib/rjr/{thread_pool.rb → util/thread_pool.rb}

@@ -3,6 +3,8 @@
 # Copyright (C) 2010-2013 Mohammed Morsi <mo@morsi.org>
 # Licensed under the Apache License, Version 2.0
 
+require 'thread'
+
 module RJR
 
 # Work item to be executed in a thread launched by {ThreadPool}.

data/lib/rjr/version.rb

@@ -1,3 +1,3 @@
 module RJR
-  VERSION = '0.18.2'
+  VERSION = '0.19.1'
 end

data/site/jrw.js

@@ -318,7 +318,7 @@ RJR.WsNode.prototype = {
 
   // Close socket connection
   close : function(){
-    this.socket.close();
+    if(this.socket) this.socket.close();
   },
 
   // Invoke request on socket, may be invoked before or after socket is opened.

data/specs/args_spec.rb

@@ -0,0 +1,144 @@
+require 'rjr/util/args'
+
+module RJR
+  describe Arguments do
+    describe "#intialize" do
+      it "initializes arguments" do
+        a = Arguments.new :args => [42]
+        a.args.should == [42]
+      end
+    end
+
+    describe "#validate!" do
+      context "acceptable is a hash" do
+        context "at least one argument not in acceptable hash keys" do
+          it "raises an ArgumentError" do
+            a = Arguments.new :args => ['invalid', 42]
+            expect {
+              a.validate! 'valid' => 1
+            }.to raise_error(ArgumentError)
+          end
+        end
+
+        context "all arguments are in acceptable hash keys" do
+          it "does not raise an error" do
+            a = Arguments.new :args => ['valid', 42]
+            expect {
+              a.validate! 'valid' => 1
+            }.not_to raise_error
+          end
+        end
+
+        context "no arguments" do
+          it "does not raise an error" do
+            a = Arguments.new
+            expect {
+              a.validate! 'valid' => 1
+            }.not_to raise_error
+          end
+        end
+
+        it "converts acceptable keys to strings before comparison" do
+           a = Arguments.new :args => ['valid', 42]
+           expect {
+             a.validate! :valid => 1
+           }.not_to raise_error
+        end
+
+        it "skips over # of arguments specified by acceptable hash values" do
+           a = Arguments.new :args => ['valid', 42]
+           expect {
+             a.validate! :valid => 1
+           }.not_to raise_error
+
+           expect {
+             a.validate! :valid => 0
+           }.to raise_error(ArgumentError)
+        end
+      end
+
+      context "acceptable is an array" do
+        context "at least one argument not on acceptable list" do
+          it "raises an ArgumentError" do
+            a = Arguments.new :args => ['invalid']
+            expect {
+              a.validate! 'valid'
+            }.to raise_error(ArgumentError)
+          end
+        end
+
+        context "all arguments on acceptable list" do
+          it "does not raise an error" do
+            a = Arguments.new :args => ['valid']
+            expect {
+              a.validate! 'valid'
+            }.not_to raise_error
+          end
+        end
+
+        context "no arguments" do
+          it "does not raise an error" do
+            a = Arguments.new
+            expect {
+              a.validate! 'valid'
+            }.not_to raise_error
+          end
+        end
+
+        it "converts acceptable list to strings before comparison" do
+          a = Arguments.new :args => ['valid']
+          expect {
+            a.validate! :valid
+          }.not_to raise_error
+        end
+      end
+    end
+
+    describe "#extract" do
+      before(:each) do
+        @a = Arguments.new :args => ['match1', 'val1', 'val2',
+                                     'match2', 'val2', 'match3']
+      end
+
+      it "returns extracted map key & following values from arguments" do
+        result = @a.extract 'match1' => 2, 'match3' => 0
+        result.should == [['match1', 'val1', 'val2'], ['match3']]
+      end
+
+      it "matches symbollic map keys" do
+        result = @a.extract :match2 => 1
+        result.should == [['match2', 'val2']]
+      end
+    end
+
+    describe "#specifies?" do
+      context "arguments includes tag" do
+        it "returns true" do
+          a = Arguments.new :args => ['with_id', 42]
+          a.specifies?('with_id').should be_true
+        end
+      end
+
+      context "arguments does not include tag" do
+        it "returns false" do
+          a = Arguments.new :args => ['with_id', 42]
+          a.specifies?('with_name').should be_false
+        end
+      end
+    end
+
+    describe "#specifier_for" do
+      it "returns argument at index of tag + 1" do
+        a = Arguments.new :args => ['with_id', 42]
+        a.specifier_for('with_id').should == 42
+      end
+
+      context "arguments do not specify tag" do
+        it "returns nil" do
+          a = Arguments.new :args => ['with_id', 42]
+          a.specifier_for('with_name').should be_nil
+        end
+      end
+    end
+  end # describe Arguments
+end # module RJR