rjr 0.18.2 → 0.19.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4d55a14977509a3c88cdd498f075666cb3e3bac3
-  data.tar.gz: d41f1a19c4750ec55392b1530499ddfea7832dbc
+  metadata.gz: 517f79e571aae798dcc24be8feacd2ef5cbc3606
+  data.tar.gz: 340a496e1f47092a7b01a4b1363bac1db87b9e81
 SHA512:
-  metadata.gz: 26d189aa6818b7b2046756be51fb112cabcd183e1a9d67ba7686ff75b99f459d70333c1504f049d995b2d5c518b86042a7b8542a16c16efc1c2e81304927cc86
-  data.tar.gz: 87c4581787d211a26b8e8dc99eb53413183032eb151c02ceb7f1bafb07648b299a7c63b9ef9fd62b55f40d21fc31b3eb54f2366bb69b84556c26e279e7fc3120
+  metadata.gz: 6b5e056c47862523e346cf2a47923146e0b15a3fb856071f20a4fa226d55fdb6046e5ec463c8aea4e356d96d49e707279d5b477549df2537041943aaa04513f7
+  data.tar.gz: 325453d870c227bd35826a3bab5933fc6a62e644f1efbb2d5de3f762e917b24e38908aa15cfad2d7d3aae2d6d2f8af8da57a7bf527f9558570a78412747c5b60

data/Rakefile

@@ -3,6 +3,8 @@
 # Copyright (C) 2010-2012 Mohammed Morsi <mo@morsi.org>
 # Licensed under the Apache License, Version 2.0
 
+# TODO fix travis build
+
 require "rspec/core/rake_task"
 
 desc "Run all specs"

data/bin/rjr-client

@@ -5,8 +5,8 @@
 # Licensed under the Apache License, Version 2.0
 
 require 'optparse'
-require 'rjr/common'
-require 'rjr/message'
+require 'rjr/core_ext'
+require 'rjr/util/logger'
 require 'rjr/nodes/easy'
 
 RJR::Logger.log_level = ::Logger::DEBUG
@@ -27,7 +27,8 @@ config = { :mode       =>                    :msg,
            :msg_id     =>                   :rand,
            :block      =>                   false,
            :interval   =>                       0,
-           :disconnect =>                   false}
+           :disconnect =>                   false,
+           :class      =>                'Object'}
 
 optparse = OptionParser.new do |opts|
   opts.on('-h', '--help', 'Display this help screen') do
@@ -59,6 +60,10 @@ optparse = OptionParser.new do |opts|
     config[:block] = !ret
   end
 
+  opts.on('-c', '--class [value]', 'Ruby class to extract messages from (default Class)') do |cls|
+    config[:class] = cls
+  end
+
   opts.on('-n', '--num number_of_messages', 'Number of messages to send to server (may be a number, :rand, or :indefinite)') do |n|
     config[:num_msg] = case n.to_s.intern
                        when :rand       then rand(MAX_MESSAGES)
@@ -68,7 +73,7 @@ optparse = OptionParser.new do |opts|
   end
 
   opts.on('--message ID', 'Message to send to server (rand to select random)') do |mid|
-    config[:msg_id] = mid.intern
+    config[:msg_id] = (mid == 'rand' ? :rand : mid)
   end
 
   opts.on('--interval seconds', 'Number of seconds after which to wait between requests (or rand)') do |s|
@@ -94,10 +99,13 @@ NODES = {config[:transport] => {:node_id    => config[:node_id],
                                 :keep_alive => true} }          # conditionally set keep alive?
 
 cdir          = File.dirname(__FILE__)
-client_path   = File.join(ENV['RJR_LOAD_PATH'] || File.join(cdir, '..', 'examples', 'client'))
+client_path   = File.join(ENV['RJR_LOAD_PATH'] ||
+                File.join(cdir, '..', 'examples', 'client'))
 
 ##########################################################
 
+msg_class = config[:class].to_class
+
 node = RJR::Nodes::Easy.new(NODES)
 client_path.split(':').each { |cp|
   node.dispatcher.add_modules(cp)
@@ -112,13 +120,14 @@ if config[:disconnect]
   }
 end
 
+
 # invoke request(s)
 0.upto(config[:num_msg]-1) { |i|
   # TODO implement mode == :rand
 
   # grab message (or rand message)
-  msg = (config[:msg_id] == :rand ? RJR::MessageUtil.rand_msg(config[:transport]) :
-                                    RJR::MessageUtil.message(config[:msg_id]))
+  msg = (config[:msg_id] == :rand ? msg_class.rand_message(config[:transport]) :
+                                    msg_class.message(config[:msg_id]))
 
   if msg.nil?
     puts "Invalid message id"
@@ -141,8 +150,6 @@ end
   res = node.invoke(config[:dst], msg[:method], *params)
 
   # verify and output result
-puts res
-puts msg[:result]
   ress = (msg[:result].nil? ? "" : (msg[:result].call(res) ? "passed" : "failed"))
   RJR::Logger.info "#{msg[:method]} result #{res} #{ress}"
 

data/bin/rjr-server

@@ -62,7 +62,8 @@ NODES = {:amqp  =>  {:node_id => config[:node_id], :broker => config[:broker]},
          :tcp   =>  {:node_id => config[:node_id], :host   => config[:host], :port => config[:tcp_port]}}
 
 cdir          = File.dirname(__FILE__)
-server_path   = File.join(ENV['RJR_LOAD_PATH'] || File.join(cdir, '..', 'examples', 'server'))
+server_path   = File.join(ENV['RJR_LOAD_PATH'] ||
+                File.join(cdir, '..', 'examples', 'server'))
 
 ##########################################################
 

data/examples/client.rb

@@ -3,30 +3,32 @@
 # Copyright (C) 2013 Mohammed Morsi <mo@morsi.org>
 # Licensed under the Apache License, Version 2.0
 
-include RJR::MessageMixins
+require 'rjr/util/has_messages'
 
-def dispatch_client(dispatcher)
+include RJR::HasMessages
+
+define_message "stress" do
+  { :method => 'stress',
+    :params => ["<CLIENT_ID>"],
+    :result => lambda { |r| r =~ /foobar.*/ } }
+end
+
+define_message "stress_callback" do
+  { :method => 'stress_callback',
+    :params => ["<CLIENT_ID>"],
+    :transports => [:tcp, :ws, :amqp],
+    :result => lambda { |r| r =~ /barfoo.*/ } }
+end
+
+define_message "messages" do
+  { :method => 'messages'}
+end
+
+def dispatch_examples_client(dispatcher)
   dispatcher.handle "client_callback" do |p|
     RJR::Logger.info "invoked client_callback method #{p}"
     #amqp_node.invoke_request('stress_test-queue', 'stress', "foozmoney#{client_id}")
     #amqp_node.stop
     nil
   end
-
-  define_message "stress" do
-    { :method => 'stress',
-      :params => ["<CLIENT_ID>"],
-      :result => lambda { |r| r =~ /foobar.*/ } }
-  end
-
-  define_message "stress_callback" do
-    { :method => 'stress_callback',
-      :params => ["<CLIENT_ID>"],
-      :transports => [:tcp, :ws, :amqp],
-      :result => lambda { |r| r =~ /barfoo.*/ } }
-  end
-
-  define_message "messages" do
-    { :method => 'messages'}
-  end
 end

data/examples/server.rb

@@ -3,7 +3,7 @@
 # Copyright (C) 2013 Mohammed Morsi <mo@morsi.org>
 # Licensed under the Apache License, Version 2.0
 
-def dispatch_server(dispatcher)
+def dispatch_examples_server(dispatcher)
   dispatcher.handle "messages" do |p|
     $messages.string.split("\n")
   end

data/examples/structured_server.rb

@@ -0,0 +1 @@
+# TODO server using HandlesMethods mixin

data/examples/tcp.rb

@@ -5,6 +5,7 @@
 # Licensed under the Apache License, Version 2.0
 
 require 'rjr/nodes/tcp'
+#require 'rjr/messages/compressed'
 
 server = RJR::Nodes::TCP.new :host => 'localhost', :port => 9789, :node_id => "server"
 server.dispatcher.handle('method') { |i|

data/lib/rjr/common.rb

@@ -4,7 +4,7 @@
 #
 # Copyright (C) 2011-2013 Mohammed Morsi <mo@morsi.org>
 # Licensed under the Apache License, Version 2.0
-require 'logger'
+
 require 'json'
 
 # Return a random uuid
@@ -25,229 +25,4 @@ def self.persistent_nodes
   }.compact
 end
 
-# 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
-def sputs(*args)
-  ::RJR::Logger.safe_exec {
-    puts *args
-  }
-end
-
-class Object
-  def eigenclass
-    class << self
-      self
-    end
-  end
-end
-
-if RUBY_VERSION < "1.9"
-# We extend object in ruby 1.9 to define 'instance_exec'
-#
-# {http://blog.jayfields.com/2006/09/ruby-instanceexec-aka-instanceeval.html Further reference}
-class Object
-  module InstanceExecHelper; end
-  include InstanceExecHelper
-  # Execute the specified block in the scope of the local object
-  # @param [Array] args array of args to be passed to block
-  # @param [Callable] block callable object to bind and invoke in the local namespace
-  def instance_exec(*args, &block)
-    begin
-      old_critical, Thread.critical = Thread.critical, true
-      n = 0
-      n += 1 while respond_to?(mname="__instance_exec#{n}")
-      InstanceExecHelper.module_eval{ define_method(mname, &block) }
-    ensure
-      Thread.critical = old_critical
-    end
-    begin
-      ret = send(mname, *args)
-    ensure
-      InstanceExecHelper.module_eval{ remove_method(mname) } rescue nil
-    end
-    ret
-  end
-end
-end
-
-# Two stage json parsing required, for more details
-# 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
-
-class Class
-  class << self
-    attr_accessor :whitelist_json_classes
-    attr_accessor :permitted_json_classes
-  end
-
-  def permit_json_create
-    Class.whitelist_json_classes = true
-    Class.permitted_json_classes ||= []
-    unless Class.permitted_json_classes.include?(self.name)
-      Class.permitted_json_classes << self.name
-    end
-  end
-end
-
-module RJR
-  def self.invalid_json_class?(jc)
-    Class.whitelist_json_classes ||= false
-
-    Class.whitelist_json_classes ?
-      # only permit classes user explicitly authorizes
-      !Class.permitted_json_classes.include?(jc) :
-
-      # allow any class
-      jc.to_s.split(/::/).inject(Object) do |p,c|
-        case
-        when c.empty?  then p
-        when p.constants.collect { |c| c.to_s }.include?(c)
-          then p.const_get(c)
-        else
-          nil
-        end
-      end.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
-  
-  def self.parse_json(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

data/lib/rjr/core_ext.rb

@@ -0,0 +1,63 @@
+# RJR Ruby Core Extensions
+#
+# Copyright (C) 2011-2014 Mohammed Morsi <mo@morsi.org>
+# Licensed under the Apache License, Version 2.0
+
+class String
+  # Safely convert string to ruby class it represents
+  def to_class
+    split(/::/).inject(Object) do |p,c|
+      case
+      when c.empty?  then p
+      when p.constants.collect { |c| c.to_s }.include?(c)
+        then p.const_get(c)
+      else
+        nil
+      end
+    end
+  end
+end
+
+if RUBY_VERSION < "1.9"
+# We extend object in ruby 1.9 to define 'instance_exec'
+#
+# {http://blog.jayfields.com/2006/09/ruby-instanceexec-aka-instanceeval.html Further reference}
+class Object
+  module InstanceExecHelper; end
+  include InstanceExecHelper
+  # Execute the specified block in the scope of the local object
+  # @param [Array] args array of args to be passed to block
+  # @param [Callable] block callable object to bind and invoke in the local namespace
+  def instance_exec(*args, &block)
+    begin
+      old_critical, Thread.critical = Thread.critical, true
+      n = 0
+      n += 1 while respond_to?(mname="__instance_exec#{n}")
+      InstanceExecHelper.module_eval{ define_method(mname, &block) }
+    ensure
+      Thread.critical = old_critical
+    end
+    begin
+      ret = send(mname, *args)
+    ensure
+      InstanceExecHelper.module_eval{ remove_method(mname) } rescue nil
+    end
+    ret
+  end
+end
+end
+
+class Class
+  class << self
+    attr_accessor :whitelist_json_classes
+    attr_accessor :permitted_json_classes
+  end
+
+  def permit_json_create
+    Class.whitelist_json_classes = true
+    Class.permitted_json_classes ||= []
+    unless Class.permitted_json_classes.include?(self.name)
+      Class.permitted_json_classes << self.name
+    end
+  end
+end