modern_times 0.1.2 → 0.2.0

data/examples/requestor/hornetq.yml

@@ -1,14 +0,0 @@
-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/simple/hornetq.yml

@@ -1,14 +0,0 @@
-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/lib/modern_times/hornetq.rb

@@ -1,11 +0,0 @@
-require 'modern_times/hornetq/client'
-require 'modern_times/hornetq/marshal_strategy'
-require 'modern_times/hornetq/publisher'
-require 'modern_times/hornetq/supervisor_mbean'
-require 'modern_times/hornetq/supervisor'
-require 'modern_times/hornetq/worker'
-
-module ModernTimes
-  module HornetQ
-  end
-end

data/lib/modern_times/hornetq/marshal_strategy.rb

@@ -1,3 +0,0 @@
-require 'modern_times/hornetq/marshal_strategy/json'
-require 'modern_times/hornetq/marshal_strategy/ruby'
-require 'modern_times/hornetq/marshal_strategy/string'

data/lib/modern_times/hornetq/marshal_strategy/json.rb

@@ -1,17 +0,0 @@
-module ModernTimes
-  module HornetQ
-    module MarshalStrategy
-      module JSON
-        def marshal(session, object, durable)
-          message = session.create_message(::HornetQ::Client::Message::TEXT_TYPE, durable)
-          message.body = object.to_json
-          message
-        end
-
-        def unmarshal(msg)
-          JSON::Parser.new(msg.body).parse
-        end
-      end
-    end
-  end
-end

data/lib/modern_times/hornetq/marshal_strategy/ruby.rb

@@ -1,17 +0,0 @@
-module ModernTimes
-  module HornetQ
-    module MarshalStrategy
-      module Ruby
-        def marshal(session, object, durable)
-          message = session.create_message(::HornetQ::Client::Message::BYTES_TYPE, durable)
-          message.body = ::Marshal.dump(object)
-          message
-        end
-
-        def unmarshal(msg)
-          ::Marshal.load(msg.body)
-        end
-      end
-    end
-  end
-end

data/lib/modern_times/hornetq/marshal_strategy/string.rb

@@ -1,17 +0,0 @@
-module ModernTimes
-  module HornetQ
-    module MarshalStrategy
-      module String
-        def marshal(session, object, durable)
-          message = session.create_message(::HornetQ::Client::Message::TEXT_TYPE, durable)
-          message.body = object.to_s
-          message
-        end
-
-        def unmarshal(msg)
-          msg.body
-        end
-      end
-    end
-  end
-end

data/lib/modern_times/hornetq/publisher.rb

@@ -1,65 +0,0 @@
-require 'hornetq'
-
-# Protocol independent class to handle Publishing
-module ModernTimes
-  module HornetQ
-    class Publisher
-      attr_reader :address
-
-      # TODO: Possible performance enhancements on producer
-      # setDisableMessageID()
-      # setDisableMessageTimeStamp()
-      # See http://hornetq.sourceforge.net/docs/hornetq-2.1.2.Final/user-manual/en/html/perf-tuning.html
-      # Create producer pool as per above section 46.6?
-      def initialize(address, options={})
-        @address = address
-        @durable = !!options[:durable]
-        if options[:marshal].nil?
-          marshal_module = MarshalStrategy::Ruby
-        elsif options[:marshal].kind_of? Symbol
-          marshal_module = case options[:marshal]
-                             when :ruby   then MarshalStrategy::Ruby
-                             when :string then MarshalStrategy::String
-                             when :json   then MarshalStrategy::JSON
-                             else raise "Invalid marshal strategy: #{options[:marshal]}"
-                           end
-        elsif options[:marshal].kind_of? Module
-          marshal_module = options[:marshal]
-        else
-          raise "Invalid marshal strategy: #{options[:marshal]}"
-        end
-        self.extend marshal_module
-      end
-
-      # Publish the given object to the address.
-      def publish(object, user_id=nil, props={})
-        Client.session_pool.producer(@address) do |session, producer|
-          message = marshal(session, object, @durable)
-          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
-
-      # For non-configured Rails projects, The above publish method will be overridden to
-      # call this publish method instead which calls all the HornetQ workers that
-      # operate on the given address.
-      def dummy_publish(object)
-        @@worker_instances.each do |worker|
-          if worker.kind_of?(Worker) && worker.address_name == @address
-            ModernTimes.logger.debug "Dummy publishing #{object} to #{worker}"
-            worker.perform(object)
-          end
-        end
-      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
-    end
-  end
-end

data/lib/modern_times/hornetq/supervisor.rb

@@ -1,22 +0,0 @@
-module ModernTimes
-  module HornetQ
-    class Supervisor < ModernTimes::Base::Supervisor
-      # Make HornetQ::SupervisorMBean our mbean
-      mbean SupervisorMBean
-
-      attr_reader :message_count
-
-      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_mutex.synchronize do
-          @message_count += 1
-        end
-      end
-    end
-  end
-end

data/lib/modern_times/hornetq/supervisor_mbean.rb

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

data/lib/modern_times/hornetq/worker.rb

@@ -1,127 +0,0 @@
-module ModernTimes
-  module HornetQ
-  
-    # Base Worker Class for any class that will be processing messages from queues
-    class Worker < ModernTimes::Base::Worker
-      # Default to ruby marshaling, but extenders can override as necessary
-      include MarshalStrategy::Ruby
-
-      # Make HornetQ::Supervisor our supervisor
-      supervisor Supervisor
-      
-      attr_reader :session, :message_count
-
-      def initialize(opts={})
-        super
-        @status = 'initialized'
-        @message_count = 0
-      end
-
-      def setup
-        session = Client.create_consumer_session
-        session.create_queue_ignore_exists(address_name, queue_name, false)
-        session.close
-      end
-
-      def status
-        @status || "Processing message #{message_count}"
-      end
-
-      def on_message(message)
-        object = unmarshal(message)
-        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 self.address_name
-        @address_name ||= default_name
-      end
-
-      def self.queue_name
-        @queue_name ||= default_name
-      end
-
-      def address_name
-        self.class.address_name
-      end
-
-      def queue_name
-        self.class.queue_name
-      end
-
-      def to_s
-        "#{address_name}:#{queue_name}:#{index}"
-      end
-
-      # Start the event loop for handling messages off the queue
-      def start
-        session_init
-        ModernTimes.logger.debug "#{self}: Starting receive loop"
-        @status = nil
-        while msg = @consumer.receive
-          @message_count += 1
-          supervisor.incr_message_count
-          on_message(msg)
-          msg.acknowledge
-        end
-        @status = 'Exited'
-        ModernTimes.logger.info "Exiting #{self}"
-      rescue Java::org.hornetq.api.core.HornetQException => e
-        if e.cause.code == Java::org.hornetq.api.core.HornetQException::OBJECT_CLOSED
-          # Normal exit
-          @status = 'Exited'
-          ModernTimes.logger.info "#{self}: Exiting due to close"
-        else
-          @status = "Exited with HornetQ exception #{e.message}"
-          ModernTImes.logger.error "#{self} HornetQException: #{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
-        @session.close if @session
-      end
-
-      #########
-      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
-      # object supplied when the message was sent
-      def self.address(address_name, opts={})
-        @address_name = address_name.to_s
-        #Messaging::Client.on_message(address, queue_name) do |object|
-        #  self.send(method.to_sym, object)
-        #end
-      end
-
-      def self.queue(queue_name, opts={})
-        @queue_name = queue_name.to_s
-      end
-    end
-  end
-end

data/lib/modern_times/hornetq_requestor.rb

@@ -1,9 +0,0 @@
-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/hornetq_requestor/request_handle.rb

@@ -1,49 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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