modern_times 0.1.2 → 0.2.0

data/lib/modern_times/jms.rb

@@ -0,0 +1,23 @@
+require 'modern_times/jms/connection'
+require 'modern_times/jms/publisher'
+require 'modern_times/jms/supervisor_mbean'
+require 'modern_times/jms/supervisor'
+require 'modern_times/jms/worker'
+
+module ModernTimes
+  module JMS
+    def self.same_destination?(options1, options2)
+      if options1[:queue_name]
+        return options1[:queue_name]  == options2[:queue_name]
+      elsif options1[:topic_name]
+        return options1[:topic_name]  == options2[:topic_name]
+      elsif options1[:virtual_topic_name]
+        return options1[:virtual_topic_name]  == options2[:virtual_topic_name]
+      elsif options1[:destination]
+        return options1[:destination] == options2[:destination]
+      else
+        return false
+      end
+    end
+  end
+end

data/lib/modern_times/{hornetq/client.rb → jms/connection.rb}

@@ -1,16 +1,18 @@
-require 'hornetq'
+require 'jms'
 
 # Handle Messaging and Queuing
 module ModernTimes
-  module HornetQ
-    module Client
+  module JMS
+    module Connection
       # Singleton-ize
       extend self
 
       # Initialize the messaging system and connection pool for this VM
       def init(config)
         @config = config
-        @connection = ::HornetQ::Client::Connection.new(@config[:connection])
+        @inited = true
+        @connection = ::JMS::Connection.new(config)
+        @connection.start
         # Let's not create a session_pool unless we're going to use it
         @session_pool_mutex = Mutex.new
 
@@ -19,13 +21,13 @@ module ModernTimes
         end
       end
 
-      def invm?
-        @connection.invm?
+      def inited?
+        @inited
       end
 
       # Create a session targeted for a consumer (producers should use the session_pool)
       def create_consumer_session
-        @connection.create_session(config[:session])
+        connection.create_session(@config || {})
       end
 
       def session_pool
@@ -34,19 +36,24 @@ module ModernTimes
         @session_pool_mutex.synchronize do
           # if it's been created in between the above call and now, return it
           return @session_pool if @session_pool
-          return @session_pool = @connection.create_session_pool(config[:session])
+          return @session_pool = connection.create_session_pool(@config)
         end
       end
 
       def close
+        return if @closed
         ModernTimes.logger.info "Closing #{self.name}"
         @session_pool.close if @session_pool
-        @connection.close if @connection
+        if @connection
+          @connection.stop
+          @connection.close
+        end
+        @closed = true
       end
 
-      def config
-        raise "#{self.name} never had it's init method called" unless @config
-        @config
+      def connection
+        raise "#{self.name} never had it's init method called" unless @connection
+        @connection
       end
     end
   end

data/lib/modern_times/jms/publisher.rb

@@ -0,0 +1,91 @@
+require 'jms'
+
+# Protocol independent class to handle Publishing
+module ModernTimes
+  module JMS
+    class Publisher
+      attr_reader :producer_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)
+        producer_keys = [:queue_name, :topic_name, :virtual_topic_name, :destination]
+        @producer_options = options.reject {|k,v| !producer_keys.include?(k)}
+        raise "One of #{producer_keys.join(',')} must be given in #{self.class.name}" if @producer_options.empty?
+
+        # Save our @producer_options for destination comparison when doing dummy_publish,
+        # but create the real options by translating virtual_topic_name to a real topic_name.
+        @real_producer_options = @producer_options.dup
+        virtual_topic_name = @real_producer_options.delete(:virtual_topic_name)
+        @real_producer_options[:topic_name] = "VirtualTopic.#{virtual_topic_name}" if virtual_topic_name
+
+        # If we're in dummy mode, this probably won't be defined
+        #@persistent = options[:persistent] ? ::JMS::DeliveryMode::PERSISTENT : ::JMS::DeliveryMode::NON_PERSISTENT
+        @persistent = options[:persistent] ? :persistent : :non_persistent
+        @marshaler = ModernTimes::MarshalStrategy.find(options[:marshal])
+      end
+
+      # Publish the given object to the address.
+      def publish(object, props={})
+        message = nil
+        Connection.session_pool.producer(@real_producer_options) do |session, producer|
+          message = case @marshaler.marshal_type
+                      when :text
+                        session.create_text_message(@marshaler.marshal(object))
+                      when :bytes
+                        msg = session.create_bytes_message()
+                        msg.data = @marshaler.marshal(object)
+                        msg
+                      else raise "Invalid marshal type: #{@marshaler.marshal_type}"
+                    end
+          message.jms_delivery_mode_sym = @persistent
+          props.each do |key, value|
+            message.send("#{key}=", value)
+          end
+          # TODO: Is send_with_retry possible?
+          #producer.send_with_retry(message)
+          producer.send(message)
+        end
+        return message
+      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)
+        @@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
+      end
+
+      def to_s
+        "#{self.class.name}:#{@real_producer_options.inspect}"
+      end
+
+      def self.setup_dummy_publishing(workers)
+        @@worker_instances = workers.map {|worker| worker.new}
+        alias_method :real_publish, :publish
+        alias_method :publish, :dummy_publish
+      end
+
+      # For testing
+      def self.clear_dummy_publishing
+        alias_method :dummy_publish, :publish
+        alias_method :publish, :real_publish
+        #remove_method :real_publish
+      end
+    end
+  end
+end

data/lib/modern_times/jms/supervisor.rb

@@ -0,0 +1,19 @@
+module ModernTimes
+  module JMS
+    class Supervisor < ModernTimes::Base::Supervisor
+
+      def initialize(manager, worker_name, supervisor_options, worker_options)
+        super
+      end
+
+      def message_counts
+        workers.map { |w| w.message_count }
+      end
+
+      # Make JMS::SupervisorMBean our mbean
+      def create_mbean(domain)
+        SupervisorMBean.new(mbean_name(domain), mbean_description, self, {})
+      end
+    end
+  end
+end

data/lib/modern_times/jms/supervisor_mbean.rb

@@ -0,0 +1,11 @@
+module ModernTimes
+  module JMS
+    class SupervisorMBean < ModernTimes::Base::SupervisorMBean
+      r_attribute :message_counts, :list, 'Message counts for the workers', :message_counts
+
+      def message_counts
+        java.util.ArrayList.new(supervisor.message_counts)
+      end
+    end
+  end
+end

data/lib/modern_times/jms/worker.rb

@@ -0,0 +1,166 @@
+module ModernTimes
+  module JMS
+  
+    # Base Worker Class for any class that will be processing messages from topics or queues
+    # By default, it will consume messages from a queue with the class name minus the Worker postfix.
+    # For example, the queue call is unneccessary as it will default to a value of 'Foo' anyways:
+    #  class FooWorker < ModernTimes::JMS::Worker
+    #    queue 'Foo'
+    #    def perform(obj)
+    #      # Perform work on obj
+    #    end
+    #  end
+    #
+    # A topic can be specified using virtual_topic as follows (ActiveMQ only).  Multiple separate workers can
+    # subscribe to the same topic (under ActiveMQ - see http://activemq.apache.org/virtual-destinations.html):
+    #  class FooWorker < ModernTimes::JMS::Worker
+    #    virtual_topic 'Zulu'
+    #    def perform(obj)
+    #      # Perform work on obj
+    #    end
+    #  end
+    #
+    # Filters can also be specified within the class:
+    #  class FooWorker < ModernTimes::JMS::Worker
+    #    filter 'age > 30'
+    #    def perform(obj)
+    #      # Perform work on obj
+    #    end
+    #  end
+    #
+    #
+    module Worker
+      include ModernTimes::Base::Worker
+
+      attr_reader :session, :message, :message_count
+
+      module ClassMethods
+        def create_supervisor(manager, worker_options)
+          Supervisor.new(manager, self, {}, worker_options)
+        end
+
+        def marshal(option)
+          @marshaler = ModernTimes::MarshalStrategy.find(option)
+        end
+
+        def destination_options
+          options = dest_options.dup
+          # Default the queue name to the Worker name if a destinations hasn't been specified
+          if options.keys.select {|k| [:virtual_topic_name, :queue_name, :destination].include?(k)}.empty?
+            options[:queue_name] = default_name
+          end
+          return options
+        end
+
+        def virtual_topic(name, opts={})
+          # ActiveMQ only
+          dest_options[:virtual_topic_name] = name.to_s
+        end
+
+        def queue(name, opts={})
+          dest_options[:queue_name] = name.to_s
+        end
+
+        def dest_options
+          @dest_options ||= {}
+        end
+
+        def marshaler
+          # Default to ruby marshaling, but extenders can override as necessary
+          @marshaler ||= ModernTimes::MarshalStrategy::Ruby
+        end
+      end
+
+      def self.included(base)
+        base.extend(ModernTimes::Base::Worker::ClassMethods)
+        base.extend(ClassMethods)
+      end
+
+      def initialize(opts={})
+        super
+        @status = 'initialized'
+        @message_count = 0
+      end
+
+      def setup
+      end
+
+      def status
+        @status || "Processing message #{message_count}"
+      end
+
+      def real_destination_options
+        options = self.class.destination_options
+        virtual_topic_name = options.delete(:virtual_topic_name)
+        options[:queue_name] = "Consumer.#{name}.VirtualTopic.#{virtual_topic_name}" if virtual_topic_name
+        return options
+      end
+
+      def on_message(message)
+        @message = message
+        object = self.class.marshaler.unmarshal(message.data)
+        ModernTimes.logger.debug "#{self}: Received Object: #{object}" if ModernTimes.logger.debug?
+        perform(object)
+        ModernTimes.logger.debug "#{self}: Finished processing message" if ModernTimes.logger.debug?
+        ModernTimes.logger.flush if ModernTimes.logger.respond_to?(:flush)
+      rescue Exception => e
+        ModernTimes.logger.error "#{self}: Messaging Exception: #{e.inspect}\n#{e.backtrace.inspect}"
+      rescue java.lang.Exception => e
+        ModernTimes.logger.error "#{self}: Java Messaging Exception: #{e.inspect}\n#{e.backtrace.inspect}"
+      end
+
+      def perform(object)
+        raise "#{self}: Need to override perform method in #{self.class.name} in order to act on #{object}"
+      end
+
+      def to_s
+        "#{real_destination_options.to_a.join('=>')}:#{index}"
+      end
+
+      # Start the event loop for handling messages off the queue
+      def start
+        @session = Connection.create_consumer_session
+        @consumer = @session.consumer(real_destination_options)
+        @session.start
+
+        ModernTimes.logger.debug "#{self}: Starting receive loop"
+        @status = nil
+        while msg = @consumer.receive
+          @message_count += 1
+          on_message(msg)
+          msg.acknowledge
+        end
+        @status = 'Exited'
+        ModernTimes.logger.info "#{self}: Exiting"
+      rescue javax.jms.IllegalStateException => e
+        #if e.cause.code == Java::org.jms.api.core.JMSException::OBJECT_CLOSED
+          # Normal exit
+          @status = 'Exited'
+          ModernTimes.logger.info "#{self}: Exiting due to close"
+        #else
+        #  @status = "Exited with JMS exception #{e.message}"
+        #  ModernTImes.logger.error "#{self} JMSException: #{e.message}\n#{e.backtrace.join("\n")}"
+        #end
+      rescue Exception => e
+        @status = "Exited with exception #{e.message}"
+        ModernTimes.logger.error "#{self}: Exception, thread terminating: #{e.message}\n\t#{e.backtrace.join("\n\t")}"
+      rescue java.lang.Exception => e
+        @status = "Exited with java exception #{e.message}"
+        ModernTimes.logger.error "#{self}: Java exception, thread terminating: #{e.message}\n\t#{e.backtrace.join("\n\t")}"
+      end
+
+      def stop
+        @consumer.close if @consumer
+        @session.close if @session
+      end
+
+      #########
+      protected
+      #########
+
+      # Create session information and allow extenders to initialize anything necessary prior to the event loop
+      def session_init
+      end
+    end
+  end
+end

data/lib/modern_times/jms_requestor.rb

@@ -0,0 +1,10 @@
+require 'modern_times/jms_requestor/request_handle'
+require 'modern_times/jms_requestor/requestor'
+require 'modern_times/jms_requestor/supervisor_mbean'
+require 'modern_times/jms_requestor/supervisor'
+require 'modern_times/jms_requestor/worker'
+
+module ModernTimes
+  module JMSRequestor
+  end
+end

data/lib/modern_times/jms_requestor/request_handle.rb

@@ -0,0 +1,33 @@
+require 'timeout'
+
+module ModernTimes
+  module JMSRequestor
+    class RequestHandle
+      def initialize(requestor, message, start, timeout)
+        @requestor   = requestor
+        @reply_queue = requestor.reply_queue
+        @message     = message
+        @start       = start
+        @timeout     = timeout
+      end
+
+      def read_response
+        response = nil
+        opts = { :destination => @reply_queue, :selector => "JMSCorrelationID = '#{@message.jms_message_id}'" }
+        #opts = { :destination => @reply_queue }
+        #opts = {:queue_name => 'foobarzulu'}
+        ModernTimes::JMS::Connection.session_pool.consumer(opts) do |session, consumer|
+          leftover_timeout = ((@start + @timeout - Time.now) * 1000).to_i
+          if leftover_timeout > 100
+            response = consumer.receive(leftover_timeout)
+          else
+            #response = consumer.receive_no_wait
+            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
+        return @requestor.marshaler.unmarshal(response.data)
+      end
+    end
+  end
+end

data/lib/modern_times/jms_requestor/requestor.rb

@@ -0,0 +1,45 @@
+module ModernTimes
+  module JMSRequestor
+    class Requestor < ModernTimes::JMS::Publisher
+      attr_reader :reply_queue
+
+      def initialize(options)
+        super
+        ModernTimes::JMS::Connection.session_pool.session do |session|
+          @reply_queue = session.create_destination(:queue_name => :temporary)
+        end
+      end
+      
+      def request(object, timeout)
+        start = Time.now
+        message = publish(object, :jms_reply_to => @reply_queue)
+        return RequestHandle.new(self, message, 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 JMS workers that
+      # operate on the given address.
+      def dummy_request(object, timeout)
+        @@worker_instances.each do |worker|
+          if worker.kind_of?(Worker) && ModernTimes::JMS.same_destination?(producer_options, worker.destination_options)
+            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
+
+      # For testing
+      def self.clear_dummy_requesting
+        alias_method :dummy_request, :request
+        alias_method :request, :real_request
+      end
+    end
+  end
+end