modern_times 0.2.6 → 0.2.7

data/VERSION

@@ -1 +1 @@
-0.2.6
+0.2.7

data/examples/consumer/consumer.rb

@@ -0,0 +1,24 @@
+# Allow examples to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../lib'
+
+require 'rubygems'
+require 'erb'
+require 'modern_times'
+require 'yaml'
+
+if ARGV.size < 2
+  $stderr.puts "Usage: {$0} <message> <id>"
+end
+
+#ModernTimes::JMS::Publisher.setup_dummy_publishing([])
+#ModernTimes::JMS::Consumer.setup_dummy_receiving
+
+config = YAML.load(ERB.new(File.read(File.join(File.dirname(__FILE__), '..', 'jms.yml'))).result(binding))
+ModernTimes::JMS::Connection.init(config)
+publisher = ModernTimes::JMS::Publisher.new(:queue_name => 'Foo', :marshal => :string)
+consumer = ModernTimes::JMS::Consumer.new(:queue_name => 'Foo', :marshal => :string)
+
+publisher.publish(ARGV[0], :jms_correlation_id => ARGV[1])
+msg = consumer.receive(:jms_correlation_id => ARGV[1], :timeout => 30000)
+#msg = consumer.receive(:timeout => 1000)
+puts "msg=#{msg}"

data/lib/modern_times/jms/consumer.rb

@@ -0,0 +1,76 @@
+require 'jms'
+
+# Protocol independent class to handle Publishing
+module ModernTimes
+  module JMS
+    class Consumer
+      attr_reader :consumer_options, :persistent, :marshaler
+
+      # Parameters:
+      #   One of the following must be specified
+      #     :queue_name => String: Name of the Queue to publish to
+      #     :topic_name => String: Name of the Topic to publish to
+      #     :virtual_topic_name => String: Name of the Virtual Topic to publish to
+      #        (ActiveMQ only, see http://activemq.apache.org/virtual-destinations.html
+      #     :destination=> Explicit javax::Jms::Destination to use
+      #   Optional:
+      #     :persistent => true or false (defaults to false)
+      #     :marshal    => Symbol: One of :ruby, :string, or :json
+      #                 => Module: Module that defines marshal and unmarshal method
+      def initialize(options)
+        consumer_keys = [:queue_name, :topic_name, :virtual_topic_name, :destination]
+        @consumer_options = options.reject {|k,v| !consumer_keys.include?(k)}
+        raise "One of #{consumer_keys.join(',')} must be given in #{self.class.name}" if @consumer_options.empty?
+
+        # Save our @consumer_options for destination comparison when doing dummy_publish,
+        # but create the real options by translating virtual_topic_name to a real topic_name.
+        @real_consumer_options = @consumer_options.dup
+        virtual_topic_name = @real_consumer_options.delete(:virtual_topic_name)
+        @real_consumer_options[:topic_name] = "VirtualTopic.#{virtual_topic_name}" if virtual_topic_name
+        @marshaler = ModernTimes::MarshalStrategy.find(options[:marshal])
+      end
+
+      # Publish the given object to the address.
+      def receive(options={})
+        options = @real_consumer_options.merge(options)
+        correlation_id = options.delete(:jms_correlation_id)
+        options[:selector] = "JMSCorrelationID = '#{correlation_id}'" if correlation_id && !options[:selector]
+        timeout = options.delete(:timeout) || 0
+        obj = nil
+
+        Connection.session_pool.consumer(options) do |session, consumer|
+          message = consumer.get(:timeout => timeout)
+          obj = @marshaler.unmarshal(message.data) if message
+        end
+        return obj
+      end
+
+      # For non-configured Rails projects, The above publish method will be overridden to
+      # call this publish method instead which calls all the JMS workers that
+      # operate on the given address.
+      def dummy_receive(options={})
+        if correlation_id = options.delete(:jms_correlation_id)
+          return Publisher.dummy_cache(correlation_id)
+        else
+          # TODO: Pop off if no correlation id given
+        end
+      end
+
+      def to_s
+        "#{self.class.name}:#{@real_consumer_options.inspect}"
+      end
+
+      def self.setup_dummy_receiving
+        alias_method :real_receive, :receive
+        alias_method :receive, :dummy_receive
+      end
+
+      # For testing
+      def self.clear_dummy_receiving
+        alias_method :dummy_receive, :receive
+        alias_method :receive, :real_receive
+        #remove_method :real_receive
+      end
+    end
+  end
+end

data/lib/modern_times/jms/publisher.rb

@@ -47,19 +47,24 @@ module ModernTimes
           #producer.send_with_retry(message)
           producer.send(message)
         end
-        return message
+        return message.jms_message_id
       end
 
       # For non-configured Rails projects, The above publish method will be overridden to
       # call this publish method instead which calls all the JMS workers that
       # operate on the given address.
-      def dummy_publish(object)
+      def dummy_publish(object, props={})
+        @@message_id += 1
         @@worker_instances.each do |worker|
           if worker.kind_of?(Worker) && ModernTimes::JMS.same_destination?(@producer_options, worker.class.destination_options)
             ModernTimes.logger.debug "Dummy publishing #{object} to #{worker}"
             worker.perform(object)
           end
         end
+        if correlation_id = props[:jms_correlation_id]
+          @@dummy_cache[correlation_id] = object
+        end
+        return @@message_id
       end
 
       def to_s
@@ -67,6 +72,8 @@ module ModernTimes
       end
 
       def self.setup_dummy_publishing(workers)
+        @@message_id = 0
+        @@dummy_cache = {}
         @@worker_instances = workers.map {|worker| worker.new}
         alias_method :real_publish, :publish
         alias_method :publish, :dummy_publish
@@ -78,6 +85,10 @@ module ModernTimes
         alias_method :publish, :real_publish
         #remove_method :real_publish
       end
+
+      def self.dummy_cache(correlation_id)
+        @@dummy_cache.delete(correlation_id)
+      end
     end
   end
 end

data/lib/modern_times/jms.rb

@@ -1,4 +1,5 @@
 require 'modern_times/jms/connection'
+require 'modern_times/jms/consumer'
 require 'modern_times/jms/publisher'
 require 'modern_times/jms/supervisor_mbean'
 require 'modern_times/jms/supervisor'

data/lib/modern_times/jms_requestor/request_handle.rb

@@ -4,10 +4,10 @@ require 'yaml'
 module ModernTimes
   module JMSRequestor
     class RequestHandle
-      def initialize(requestor, message, start, timeout, &reconstruct_block)
+      def initialize(requestor, jms_message_id, start, timeout, &reconstruct_block)
         @requestor         = requestor
         @reply_queue       = requestor.reply_queue
-        @message           = message
+        @jms_message_id    = jms_message_id
         @start             = start
         @timeout           = timeout
         @reconstruct_block = reconstruct_block
@@ -15,7 +15,7 @@ module ModernTimes
 
       def read_response
         response = nil
-        opts = { :destination => @reply_queue, :selector => "JMSCorrelationID = '#{@message.jms_message_id}'" }
+        opts = { :destination => @reply_queue, :selector => "JMSCorrelationID = '#{@jms_message_id}'" }
         #opts = { :destination => @reply_queue }
         #opts = {:queue_name => 'foobarzulu'}
         ModernTimes::JMS::Connection.session_pool.consumer(opts) do |session, consumer|
@@ -27,7 +27,7 @@ module ModernTimes
             response = consumer.receive(100)
           end
         end
-        raise Timeout::Error, "Timeout waiting for for response from message #{@message.jms_message_id} on queue #{@reply_queue}" unless response
+        raise Timeout::Error, "Timeout waiting for for response from message #{@jms_message_id} on queue #{@reply_queue}" unless response
         if error_yaml = response['Exception']
           raise ModernTimes::RemoteException.from_hash(YAML.load(error_yaml))
         end

data/lib/modern_times/jms_requestor/requestor.rb

@@ -16,8 +16,8 @@ module ModernTimes
       
       def request(object, timeout, &reconstruct_block)
         start = Time.now
-        message = publish(object, :jms_reply_to => @reply_queue)
-        return RequestHandle.new(self, message, start, timeout, &reconstruct_block)
+        jms_message_id = publish(object, :jms_reply_to => @reply_queue)
+        return RequestHandle.new(self, jms_message_id, start, timeout, &reconstruct_block)
       end
 
       # For non-configured Rails projects, The above request method will be overridden to

data/lib/modern_times/manager.rb

@@ -11,11 +11,17 @@ module ModernTimes
       @config = config
       @domain = config[:domain] || ModernTimes::DEFAULT_DOMAIN
       @supervisors = []
-      @jmx_server = JMX::MBeanServer.new
-      bean = ManagerMBean.new(@domain, self)
-      @jmx_server.register_mbean(bean, ModernTimes.manager_mbean_object_name(@domain))
       self.persist_file = config[:persist_file]
       self.worker_file  = config[:worker_file]
+      @allowed_workers = config[:allowed_workers]
+      stop_on_signal if config[:stop_on_signal]
+      @dummy_host = config[:dummy_host]
+      # Unless specifically unconfigured (i.e., Rails.env == test), then enable jmx
+      if config[:jmx] != false
+        @jmx_server = JMX::MBeanServer.new
+        bean = ManagerMBean.new(@domain, self)
+        @jmx_server.register_mbean(bean, ModernTimes.manager_mbean_object_name(@domain))
+      end
     end
 
     def add(worker_klass, num_workers, worker_options={})
@@ -32,10 +38,12 @@ module ModernTimes
       end
       supervisor = worker_klass.create_supervisor(self, worker_options)
       raise "A supervisor with name #{supervisor.name} already exists" if find_supervisor(supervisor.name)
-      mbean = supervisor.create_mbean(@domain)
       @supervisors << supervisor
       supervisor.worker_count = num_workers
-      @jmx_server.register_mbean(mbean, "#{@domain}:worker=#{supervisor.name},type=Worker")
+      if @jmx_server
+        mbean = supervisor.create_mbean(@domain)
+        @jmx_server.register_mbean(mbean, "#{@domain}:worker=#{supervisor.name},type=Worker")
+      end
       ModernTimes.logger.info "Started #{worker_klass.name} named #{supervisor.name} with #{num_workers} workers"
     rescue Exception => e
       ModernTimes.logger.error "Exception trying to add #{worker_klass}: #{e.message}\n\t#{e.backtrace.join("\n\t")}"

data/lib/modern_times/railsable.rb

@@ -47,20 +47,30 @@ module ModernTimes
         Rails.logger.info "Messaging disabled"
         @is_jms_enabled = false
         ModernTimes::JMS::Publisher.setup_dummy_publishing(rails_workers)
+        ModernTimes::JMS::Consumer.setup_dummy_receiving
         ModernTimes::JMSRequestor::Requestor.setup_dummy_requesting(rails_workers)
       end
     end
 
-    def create_rails_manager
+    def create_rails_manager(manager_config={})
       # Take advantage of nil and false values for boolean
       raise 'init_rails has not been called, modify your config/environment.rb to include this call' if @is_jms_enabled.nil?
       raise 'Messaging is not enabled, modify your config/jms.yml file' unless @is_jms_enabled
-      manager = ModernTimes::Manager.new
+      default_config = {
+          :persist_file    => File.join(Rails.root, "log", "modern_times.persist"),
+          :worker_file     => File.join(Rails.root, "config", "workers.yml"),
+          :jmx             => Rails.env != 'test',
+          :stop_on_signal  => true,
+          :dummy_host      => Rails.env,
+          :allowed_workers => rails_workers,
+      }
+
+      manager = ModernTimes::Manager.new(default_config.merge(manager_config))
       manager.stop_on_signal
       manager.allowed_workers = rails_workers
-      manager.persist_file = @config[:persist_file] || File.join(Rails.root, "log", "modern_times.persist")
+      manager.persist_file = manager_config[:persist_file] || File.join(Rails.root, "log", "modern_times.persist")
       manager.dummy_host = Rails.env
-      manager.worker_file = @config[:worker_file] || File.join(Rails.root, "config", "workers.yml")
+      manager.worker_file = manager_config[:worker_file] || File.join(Rails.root, "config", "workers.yml")
       return manager
     end
 

metadata

@@ -2,7 +2,7 @@
 name: modern_times
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.2.6
+  version: 0.2.7
 platform: ruby
 authors: 
   - Brad Pardee
@@ -53,6 +53,7 @@ files:
   - Rakefile
   - VERSION
   - examples/README
+  - examples/consumer/consumer.rb
   - examples/jms.yml
   - examples/requestor/.gitignore
   - examples/requestor/README
@@ -72,6 +73,7 @@ files:
   - lib/modern_times/base/worker.rb
   - lib/modern_times/jms.rb
   - lib/modern_times/jms/connection.rb
+  - lib/modern_times/jms/consumer.rb
   - lib/modern_times/jms/publisher.rb
   - lib/modern_times/jms/supervisor.rb
   - lib/modern_times/jms/supervisor_mbean.rb
@@ -130,6 +132,7 @@ signing_key:
 specification_version: 3
 summary: Asynchronous task library
 test_files: 
+  - examples/consumer/consumer.rb
   - examples/exception_test/bar_worker.rb
   - examples/exception_test/base_worker.rb
   - examples/exception_test/manager.rb