modern_times 0.1.1 → 0.1.2

data/Rakefile

@@ -10,8 +10,9 @@ begin
     gemspec.authors = ['Brad Pardee', 'Reid Morrison']
     gemspec.email = ['bradpardee@gmail.com', 'rubywmq@gmail.com']
     gemspec.homepage = 'http://github.com/ClarityServices/modern_times'
-    gemspec.add_dependency 'jruby-hornetq', ['>= 0.3.2']
-    gemspec.add_dependency 'ClarityServices-jmxjr'
+    gemspec.add_dependency 'jruby-hornetq', ['>= 0.3.3']
+    gemspec.add_dependency 'jmx',  ['>= 0.6']
+    gemspec.add_dependency 'json'
   end
 rescue LoadError
   puts 'Jeweler not available. Install it with: gem install jeweler'

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.1.2

data/examples/requestor/.gitignore

@@ -0,0 +1,2 @@
+data
+*.state

data/examples/requestor/README

@@ -0,0 +1,11 @@
+# Step 1
+# Start a hornetq server (gem install jruby-hornetq if necessary)
+hornetq_server hornetq.yml server
+
+# Step 2
+# Start up the manager
+jruby manager.rb
+
+# Step 3
+# Request 'my string' get reversed
+jruby request.rb 'my string'

data/examples/requestor/hornetq.yml

@@ -0,0 +1,14 @@
+server:
+  :uri:                 hornetq://localhost
+  :data_directory:      ./data
+  :persistence_enabled: true
+  :security_enabled:    true
+  :cluster_user:        myuser
+  :cluster_password:    mypassword
+
+client:
+  :connection:
+    :uri:      hornetq://localhost
+  :session:
+    :username: myuser
+    :password: mypassword

data/examples/requestor/manager.rb

@@ -0,0 +1,15 @@
+# Allow examples to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../lib'
+
+require 'rubygems'
+require 'modern_times'
+require 'yaml'
+require 'reverse_echo_worker'
+
+config = YAML.load_file('hornetq.yml')
+ModernTimes::HornetQ::Client.init(config['client'])
+
+manager = ModernTimes::Manager.new
+manager.stop_on_signal
+manager.add(ReverseEchoWorker, 1, {})
+manager.join

data/examples/requestor/request.rb

@@ -0,0 +1,45 @@
+# Allow examples to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../lib'
+
+require 'rubygems'
+require 'modern_times'
+require 'yaml'
+require 'reverse_echo_worker'
+
+if ARGV.size < 1
+  $stderr.puts "Usage: {$0} <reverse-echo-string> [<timeout>] [<sleep-time>] [<simultaneous-count>]"
+  exit 1
+end
+
+$echo_string =  ARGV[0]
+$timeout     = (ARGV[1] || 4).to_f
+$sleep_time  = (ARGV[2] || 2).to_i
+$sim_count   = (ARGV[3] || 1).to_i
+
+config = YAML.load_file('hornetq.yml')
+ModernTimes::HornetQ::Client.init(config['client'])
+$requestor = ModernTimes::HornetQRequestor::Requestor.new(ReverseEchoWorker.address_name, :marshal => :string)
+
+def make_request(ident='')
+  puts "#{ident}Making request at #{Time.now.to_f}"
+  handle = $requestor.request("#{ident}#{$echo_string}", $timeout)
+  # Here's where we'd go off and do other work
+  sleep $sleep_time
+  puts "#{ident}Finished sleeping at #{Time.now.to_f}"
+  response = handle.read_response
+  puts "#{ident}Received at #{Time.now.to_f}: #{response}"
+rescue Exception => e
+  puts "#{ident}Exception: #{e.message}"
+end
+
+if $sim_count == 1
+  make_request
+else
+  threads = []
+  (1..$sim_count).each do |i|
+    threads << Thread.new(i) do |i|
+      make_request("Thread ##{i}: ")
+    end
+  end
+  threads.each {|t| t.join}
+end

data/examples/requestor/reverse_echo_worker.rb

@@ -0,0 +1,12 @@
+class ReverseEchoWorker < ModernTimes::HornetQRequestor::Worker
+  include ModernTimes::HornetQ::MarshalStrategy::String
+  
+  def request(obj)
+    puts "#{self}: Received #{obj} at #{Time.now}"
+    if obj =~ /^sleep (.*)/
+      sleep $1.to_f
+      puts "#{self}: Finished sleeping at #{Time.now}"
+    end
+    obj.reverse
+  end
+end

data/lib/modern_times/base/supervisor.rb

@@ -1,15 +1,20 @@
 module ModernTimes
   module Base
     class Supervisor
-      attr_reader :manager, :worker_klass
+      attr_reader :manager, :worker_klass, :name, :worker_options
 
-      def initialize(manager, worker_klass, options)
-        @stopped       = false
-        @manager       = manager
-        @worker_klass  = worker_klass
-        @workers       = []
-        @worker_mutex  = Mutex.new
-        @failure_mutex = Mutex.new
+      # Create new supervisor to manage a number of similar workers
+      # supervisor_options are those options defined on the Worker's Supervisor line
+      # worker_options are options passed in when creating a new instance
+      def initialize(manager, worker_klass, supervisor_options, worker_options)
+        @stopped        = false
+        @manager        = manager
+        @worker_klass   = worker_klass
+        @name           = worker_options.delete(:name) || worker_klass.default_name
+        @worker_options = worker_options
+        @workers        = []
+        @worker_mutex   = Mutex.new
+        @failure_mutex  = Mutex.new
       end
 
       def worker_count
@@ -23,7 +28,7 @@ module ModernTimes
           curr_count = @workers.size
           if curr_count < count
             (curr_count...count).each do |index|
-              worker = @worker_klass.new
+              worker = @worker_klass.new(@worker_options)
               worker.supervisor = self
               worker.index = index
               if index == 0

data/lib/modern_times/base/worker.rb

@@ -1,7 +1,9 @@
+require 'json'
+
 module ModernTimes
   module Base
     class Worker
-      attr_accessor :name, :index, :supervisor, :thread
+      attr_accessor :index, :supervisor, :thread
 
       def self.supervisor(klass, options={})
 #        self.class_eval do
@@ -12,8 +14,8 @@ module ModernTimes
 #        end
         # TODO: This is nasty but I'm not sure how to create a dynamic class method within a scope
         eval <<-EOS
-          def self.create_supervisor(manager)
-            #{klass.name}.new(manager, self, #{options.inspect})
+          def self.create_supervisor(manager, worker_options)
+            #{klass.name}.new(manager, self, #{options.to_json}, worker_options)
           end
         EOS
       end
@@ -22,11 +24,6 @@ module ModernTimes
       supervisor Supervisor
 
       def initialize(opts={})
-        @name = opts[:name] || self.class.default_name
-      end
-
-      def name
-        @name
       end
 
       # One time initialization prior to first thread

data/lib/modern_times/hornetq/publisher.rb

@@ -4,6 +4,7 @@ require 'hornetq'
 module ModernTimes
   module HornetQ
     class Publisher
+      attr_reader :address
 
       # TODO: Possible performance enhancements on producer
       # setDisableMessageID()
@@ -31,22 +32,14 @@ module ModernTimes
       end
 
       # Publish the given object to the address.
-      def publish(object)
+      def publish(object, user_id=nil, props={})
         Client.session_pool.producer(@address) do |session, producer|
           message = marshal(session, object, @durable)
-          first_time = true
-          begin
-            producer.send(message)
-          rescue Java::org.hornetq.api.core.HornetQException => e
-            ModernTimes.logger.warn "Received producer exception: #{e.message} with code=#{e.cause.code}"
-            if first_time && e.cause.code == Java::org.hornetq.api.core.HornetQException::UNBLOCKED
-              ModernTimes.logger.info "Retrying the send"
-              first_time = false
-              retry
-            else
-              raise
-            end
+          message.user_id = user_id if user_id
+          props.each do |key, value|
+            message.putStringProperty(key, value)
           end
+          producer.send_with_retry(message)
         end
       end
 

data/lib/modern_times/hornetq/supervisor.rb

@@ -6,13 +6,16 @@ module ModernTimes
 
       attr_reader :message_count
 
-      def initialize(manager, worker_name, opts={})
-        super(manager, worker_name, opts)
+      def initialize(manager, worker_name, supervisor_options, worker_options)
+        super
         @message_count = 0
+        @message_count_mutex = Mutex.new
       end
 
       def incr_message_count
-        @message_count += 1
+        @message_count_mutex.synchronize do
+          @message_count += 1
+        end
       end
     end
   end

data/lib/modern_times/hornetq/supervisor_mbean.rb

@@ -1,12 +1,12 @@
 module ModernTimes
   module HornetQ
     class SupervisorMBean < ModernTimes::Base::SupervisorMBean
+      r_attribute :message_count, :int, 'Total message count', :message_count
 
-      operation 'Total message count'
-      returns :int
       def message_count
         supervisor.message_count
       end
+
     end
   end
 end

data/lib/modern_times/hornetq/worker.rb

@@ -11,7 +11,8 @@ module ModernTimes
       
       attr_reader :session, :message_count
 
-      def initialize
+      def initialize(opts={})
+        super
         @status = 'initialized'
         @message_count = 0
       end
@@ -64,9 +65,7 @@ module ModernTimes
 
       # Start the event loop for handling messages off the queue
       def start
-        @session = Client.create_consumer_session
-        @consumer = @session.create_consumer(queue_name)
-        @session.start
+        session_init
         ModernTimes.logger.debug "#{self}: Starting receive loop"
         @status = nil
         while msg = @consumer.receive
@@ -102,6 +101,13 @@ module ModernTimes
       protected
       #########
 
+      # Create session information and allow extenders to initialize anything necessary prior to the event loop
+      def session_init
+        @session = Client.create_consumer_session
+        @consumer = @session.create_consumer(queue_name)
+        @session.start
+      end
+
       # Create a queue, assigned to the specified address
       # Every time a message arrives, the perform instance method
       # will be called. The parameter to the method is the Ruby

data/lib/modern_times/hornetq_requestor/request_handle.rb

@@ -0,0 +1,49 @@
+require 'timeout'
+
+module ModernTimes
+  module HornetQRequestor
+    class RequestHandle
+      def initialize(requestor, message_id, start, timeout)
+        @requestor   = requestor
+        @reply_queue = requestor.reply_queue
+        @message_id  = message_id
+        @start       = start
+        @timeout     = timeout
+      end
+
+      def read_response
+        message = nil
+        leftover_timeout = ((@start + @timeout - Time.now) * 1000).to_i
+        ModernTimes::HornetQ::Client.session_pool.session do |s|
+          consumer = nil
+          begin
+            consumer = s.create_consumer(@reply_queue, "#{MESSAGE_ID}='#{@message_id}'")
+            if leftover_timeout > 0
+              message = consumer.receive(leftover_timeout)
+            else
+              message = consumer.receive(1)
+            end
+            puts "funked at #{Time.now.to_f}" unless message
+            consumer.receive_immediate unless message
+          ensure
+            consumer.close if consumer
+          end
+        end
+        raise Timeout::Error, "Timeout waiting for message #{@message_id} on queue #{@reply_queue}" unless message
+        return @requestor.unmarshal(message)
+      end
+    end
+  end
+end
+
+#handle = Intercept::Client.async_cair(bank_account_array, tracking_number, timeout)
+#... do other stuff ...
+#begin
+#  # Following call will block until the queue receives the reply or what's left of the timeout expires
+#  intercept_statuses = handle.read_response
+#  ... process intercept statuses ...
+#rescue Timeout::Error => e
+#  Rails.logger.warn "We didn't receive a reply back on the queue in time"
+#rescue Intercept::Error => e
+#  Rails.logger.warn "Error during intercept call: #{e.message}"
+#end

data/lib/modern_times/hornetq_requestor/requestor.rb

@@ -0,0 +1,48 @@
+module ModernTimes
+  module HornetQRequestor
+    class Requestor < ModernTimes::HornetQ::Publisher
+      attr_reader :reply_queue
+
+      def initialize(address, options={})
+        super
+        @reply_queue = "#{address}.#{Java::java.util::UUID.randomUUID.toString}"
+        @reply_queue_simple = Java::org.hornetq.api.core.SimpleString.new(@reply_queue)
+        ModernTimes::HornetQ::Client.session_pool.session do |session|
+          session.create_temporary_queue(@reply_queue, @reply_queue)
+        end
+      end
+      
+      def request(object, timeout)
+        start = Time.now
+        message_id = Java::org.hornetq.utils.UUIDGenerator.instance.generateUUID.toString
+        publish(object,
+                nil,
+                MESSAGE_ID => message_id,
+                Java::OrgHornetqCoreClientImpl::ClientMessageImpl::REPLYTO_HEADER_NAME => @reply_queue_simple)
+                #HornetQMessage.CORRELATIONID_HEADER_NAME
+                #REPLY_QUEUE => @reply_queue,
+                #MESSAGE_ID  => message_id)
+        return RequestHandle.new(self, message_id, start, timeout)
+      end
+
+      # For non-configured Rails projects, The above request method will be overridden to
+      # call this request method instead which calls all the HornetQ workers that
+      # operate on the given address.
+      def dummy_request(object)
+        @@worker_instances.each do |worker|
+          if worker.kind_of?(Worker) && worker.address_name == address
+            ModernTimes.logger.debug "Dummy requesting #{object} to #{worker}"
+            return new OpenStruct(:read_response => worker.request(object))
+          end
+        end
+        raise "No worker to handle #{address} request of #{object}"
+      end
+
+      def self.setup_dummy_requesting(workers)
+        @@worker_instances = workers.map {|worker| worker.new}
+        alias_method :real_request, :request
+        alias_method :request, :dummy_request
+      end
+    end
+  end
+end

data/lib/modern_times/hornetq_requestor/worker.rb

@@ -0,0 +1,29 @@
+module ModernTimes
+  module HornetQRequestor
+
+    # Base Worker Class for any class that will be processing messages from queues
+    class Worker < ModernTimes::HornetQ::Worker
+      # Make HornetQRequestor::Supervisor our supervisor
+      #supervisor Supervisor
+
+      def on_message(message)
+        @reply_queue = message.get_string_property(Java::OrgHornetqCoreClientImpl::ClientMessageImpl::REPLYTO_HEADER_NAME)
+        @message_id = message.get_string_property(MESSAGE_ID)
+        super
+      end
+
+      def perform(object)
+        response = request(object)
+        session.producer(@reply_queue) do |producer|
+          reply_message = marshal(session, response, false)
+          reply_message.put_string_property(MESSAGE_ID, @message_id)
+          producer.send_with_retry(reply_message)
+        end
+      end
+
+      def request(object)
+        raise "#{self}: Need to override request method in #{self.class.name} in order to act on #{object}"
+      end
+    end
+  end
+end

data/lib/modern_times/hornetq_requestor.rb

@@ -0,0 +1,9 @@
+require 'modern_times/hornetq_requestor/request_handle'
+require 'modern_times/hornetq_requestor/requestor'
+require 'modern_times/hornetq_requestor/worker'
+
+module ModernTimes
+  module HornetQRequestor
+    MESSAGE_ID = 'ModernTimesMessageId'
+  end
+end

data/lib/modern_times/manager.rb

@@ -3,13 +3,14 @@ module ModernTimes
     attr_accessor :allowed_workers
 
     def initialize(config={})
+      @stopped = false
       @config = config
       @domain = config[:domain] || 'ModernTimes'
       @supervisors = []
       @jmx_server = JMX::MBeanServer.new
       bean = ManagerMBean.new("#{@domain}.Manager", "Manager", self)
       @jmx_server.register_mbean(bean, "#{@domain}:type=Manager")
-      persist_file = config[:persist_file]
+      self.persist_file = config[:persist_file]
     end
 
     def add(worker_klass, num_workers, worker_options)
@@ -24,11 +25,11 @@ module ModernTimes
       if @allowed_workers && !@allowed_workers.include?(worker_klass)
         raise ModernTimes::Exception.new("Error: #{worker_klass.name} is not an allowed worker")
       end
-      supervisor = worker_klass.create_supervisor(self)
+      supervisor = worker_klass.create_supervisor(self, worker_options)
       mbean = supervisor.create_mbean(@domain)
       @supervisors << supervisor
       supervisor.worker_count = num_workers
-      @jmx_server.register_mbean(mbean, "#{@domain}:worker=#{worker_klass.name},type=Worker")
+      @jmx_server.register_mbean(mbean, "#{@domain}:worker=#{supervisor.name},type=Worker")
       ModernTimes.logger.info "Started #{worker_klass.name} with #{num_workers} workers"
     rescue Exception => e
       ModernTimes.logger.error "Exception trying to add #{worker_klass.name}: #{e.message}\n\t#{e.backtrace.join("\n\t")}"
@@ -69,8 +70,12 @@ module ModernTimes
       @persist_file = file
       if File.exist?(file)
         hash = YAML.load_file(file)
-        hash.each do |worker_klass, count|
-          add(worker_klass, count)
+        hash.each do |worker_name, worker_hash|
+          klass   = worker_hash[:klass]
+          count   = worker_hash[:count]
+          options = worker_hash[:options]
+          options[:name] = worker_name
+          add(klass, count, options)
         end
       end
     end
@@ -79,9 +84,10 @@ module ModernTimes
       return unless @persist_file
       hash = {}
       @supervisors.each do |supervisor|
-        hash[supervisor.worker_name] = {
-          :worker_count => supervisor.worker_count,
-          :options      => supervisor.worker_options
+        hash[supervisor.name] = {
+          :klass   => supervisor.worker_klass.name,
+          :count   => supervisor.worker_count,
+          :options => supervisor.worker_options
         }
       end
       File.open(@persist_file, 'w') do |out|

data/lib/modern_times/manager_mbean.rb

@@ -3,18 +3,17 @@ require 'jmx'
 module ModernTimes
   class ManagerMBean < RubyDynamicMBean
     attr_reader :manager
-    rw_attribute :foobar, :int, "Number of workers"
+    r_attribute :allowed_workers, :list, 'Allowed workers'
 
     def initialize(name, description, manager)
       super(name, description)
       @manager = manager
     end
 
-    operation 'Allowed workers'
-    returns :list
     def allowed_workers
       all = manager.allowed_workers || ['No Restrictions']
-      all.map {|worker_klass| worker_klass.name }
+      all = all.map {|worker_klass| worker_klass.name }
+      java.util.ArrayList.new(all)
     end
 
     operation 'Start worker'
@@ -23,7 +22,7 @@ module ModernTimes
     returns :string
     def start_worker(worker, count)
       ModernTimes.logger.debug "Attempting to start #{worker} with count=#{count}"
-      manager.add(worker, count)
+      manager.add(worker, count, {})
       return 'Successfuly started'
     rescue Exception => e
       ModernTimes.logger.error "Exception starting worker #{worker}: {e.message}\n\t#{e.backtrace.join("\n\t")}"

data/lib/modern_times.rb

@@ -2,6 +2,7 @@ require 'rubygems'
 require 'modern_times/exception'
 require 'modern_times/base'
 require 'modern_times/hornetq'
+require 'modern_times/hornetq_requestor'
 require 'modern_times/manager_mbean'
 require 'modern_times/manager'
 require 'modern_times/loggable'

metadata

@@ -2,7 +2,7 @@
 name: modern_times
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors: 
   - Brad Pardee
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-14 00:00:00 -04:00
+date: 2011-03-24 00:00:00 -04:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency 
@@ -22,20 +22,31 @@ dependencies:
       requirements: 
         - - ">="
           - !ruby/object:Gem::Version 
-            version: 0.3.2
+            version: 0.3.3
     type: :runtime
     version_requirements: *id001
   - !ruby/object:Gem::Dependency 
-    name: ClarityServices-jmxjr
+    name: jmx
     prerelease: false
     requirement: &id002 !ruby/object:Gem::Requirement 
       none: false
       requirements: 
         - - ">="
           - !ruby/object:Gem::Version 
-            version: "0"
+            version: "0.6"
     type: :runtime
     version_requirements: *id002
+  - !ruby/object:Gem::Dependency 
+    name: json
+    prerelease: false
+    requirement: &id003 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    type: :runtime
+    version_requirements: *id003
 description: Generic asynchronous task library
 email: 
   - bradpardee@gmail.com
@@ -52,6 +63,12 @@ files:
   - README.rdoc
   - Rakefile
   - VERSION
+  - examples/requestor/.gitignore
+  - examples/requestor/README
+  - examples/requestor/hornetq.yml
+  - examples/requestor/manager.rb
+  - examples/requestor/request.rb
+  - examples/requestor/reverse_echo_worker.rb
   - examples/simple/.gitignore
   - examples/simple/README
   - examples/simple/bar_worker.rb
@@ -75,6 +92,10 @@ files:
   - lib/modern_times/hornetq/supervisor.rb
   - lib/modern_times/hornetq/supervisor_mbean.rb
   - lib/modern_times/hornetq/worker.rb
+  - lib/modern_times/hornetq_requestor.rb
+  - lib/modern_times/hornetq_requestor/request_handle.rb
+  - lib/modern_times/hornetq_requestor/requestor.rb
+  - lib/modern_times/hornetq_requestor/worker.rb
   - lib/modern_times/loggable.rb
   - lib/modern_times/manager.rb
   - lib/modern_times/manager_mbean.rb
@@ -113,6 +134,9 @@ signing_key:
 specification_version: 3
 summary: Asynchronous task library
 test_files: 
+  - examples/requestor/manager.rb
+  - examples/requestor/request.rb
+  - examples/requestor/reverse_echo_worker.rb
   - examples/simple/bar_worker.rb
   - examples/simple/baz_worker.rb
   - examples/simple/manager.rb