modern_times 0.1.2 → 0.2.0

data/lib/modern_times/jms_requestor/supervisor.rb

@@ -0,0 +1,45 @@
+module ModernTimes
+  module JMSRequestor
+    class Supervisor < ModernTimes::JMS::Supervisor
+
+      def initialize(manager, worker_name, supervisor_options, worker_options)
+        super
+      end
+
+      def average_response_time
+        count = 0
+        total = 0.0
+        workers.each do |w|
+          pair = w.total_time
+          count += pair.first
+          total += pair.last
+        end
+        return 0.0 if count == 0
+        return total / count
+      end
+
+      def min_response_time
+        min_time = nil
+        workers.each do |w|
+          wmin_time = w.min_time
+          min_time = wmin_time if wmin_time && (!min_time || wmin_time < min_time)
+        end
+        return min_time || 0.0
+      end
+
+      def max_response_time
+        max_time = 0.0
+        workers.each do |w|
+          wmax_time = w.max_time
+          max_time = wmax_time if wmax_time > max_time
+        end
+        return max_time
+      end
+
+      # Make JMSRequestor::SupervisorMBean our mbean
+      def create_mbean(domain)
+        SupervisorMBean.new(mbean_name(domain), mbean_description, self, {})
+      end
+    end
+  end
+end

data/lib/modern_times/jms_requestor/supervisor_mbean.rb

@@ -0,0 +1,21 @@
+module ModernTimes
+  module JMSRequestor
+    class SupervisorMBean < ModernTimes::JMS::SupervisorMBean
+      r_attribute :average_response_time, :float, 'Average response time', :average_response_time
+      r_attribute :min_response_time,     :float, 'Minimum response time', :min_response_time
+      r_attribute :max_response_time,     :float, 'Maximum response time', :max_response_time
+
+      def average_response_time
+        supervisor.average_response_time
+      end
+
+      def min_response_time
+        supervisor.min_response_time
+      end
+
+      def max_response_time
+        supervisor.max_response_time
+      end
+    end
+  end
+end

data/lib/modern_times/jms_requestor/worker.rb

@@ -0,0 +1,78 @@
+module ModernTimes
+  module JMSRequestor
+
+    # Base Worker Class for any class that will be processing messages from queues
+    module Worker
+      include ModernTimes::JMS::Worker
+
+      module ClassMethods
+        def create_supervisor(manager, worker_options)
+          Supervisor.new(manager, self, {}, worker_options)
+        end
+      end
+
+      def self.included(base)
+        # The price we pay for including rather than extending
+        base.extend(ModernTimes::Base::Worker::ClassMethods)
+        base.extend(ModernTimes::JMS::Worker::ClassMethods)
+        base.extend(ClassMethods)
+      end
+
+      def initialize(opts={})
+        super
+        @time_mutex = Mutex.new
+        @count      = 0
+        @min_time   = nil
+        @max_time   = 0.0
+        @total_time = 0.0
+      end
+
+      def perform(object)
+        start_time = Time.now
+        response = request(object)
+        response_time = Time.now - start_time
+        session.producer(:destination => message.reply_to) do |producer|
+          reply_message = session.message(self.class.marshaler.marshal(response))
+          reply_message.jms_correlation_id = message.jms_message_id
+          #producer.send_with_retry(reply_message)
+          producer.send(reply_message)
+        end
+        @time_mutex.synchronize do
+          @count      += 1
+          @total_time += response_time
+          @min_time    = response_time if !@min_time || response_time < @min_time
+          @max_time    = response_time if response_time > @max_time
+        end
+      end
+
+      def total_time
+        @time_mutex.synchronize do
+          retval = [@count, @total_time]
+          @count = 0
+          @total_time = 0.0
+          return retval
+        end
+      end
+
+      def min_time
+        @time_mutex.synchronize do
+          val = @min_time
+          @min_time = nil
+          return val
+        end
+      end
+
+      def max_time
+        @time_mutex.synchronize do
+          val = @max_time
+          @max_time = 0.0
+          return val
+        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/manager.rb

@@ -1,46 +1,51 @@
+require 'yaml'
+
 module ModernTimes
   class Manager
     attr_accessor :allowed_workers
+    attr_reader   :supervisors
 
     def initialize(config={})
       @stopped = false
       @config = config
-      @domain = config[:domain] || 'ModernTimes'
+      @domain = config[:domain] || ModernTimes::DEFAULT_DOMAIN
       @supervisors = []
       @jmx_server = JMX::MBeanServer.new
-      bean = ManagerMBean.new("#{@domain}.Manager", "Manager", self)
-      @jmx_server.register_mbean(bean, "#{@domain}:type=Manager")
+      bean = ManagerMBean.new(@domain, self)
+      @jmx_server.register_mbean(bean, ModernTimes.manager_mbean_object_name(@domain))
       self.persist_file = config[:persist_file]
     end
 
-    def add(worker_klass, num_workers, worker_options)
+    def add(worker_klass, num_workers, worker_options={})
       ModernTimes.logger.info "Starting #{worker_klass} with #{num_workers} workers with options #{worker_options.inspect}"
       unless worker_klass.kind_of?(Class)
         begin
           worker_klass = Object.const_get(worker_klass.to_s)
         rescue
-          raise ModernTimes::Exception.new("Invalid class: #{worker_klass}")
+          raise ModernTimes::Exception, "Invalid class: #{worker_klass}"
         end
       end
       if @allowed_workers && !@allowed_workers.include?(worker_klass)
-        raise ModernTimes::Exception.new("Error: #{worker_klass.name} is not an allowed worker")
+        raise ModernTimes::Exception, "Error: #{worker_klass.name} is not an allowed worker"
       end
       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=#{supervisor.name},type=Worker")
-      ModernTimes.logger.info "Started #{worker_klass.name} with #{num_workers} workers"
+      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.name}: #{e.message}\n\t#{e.backtrace.join("\n\t")}"
+      ModernTimes.logger.error "Exception trying to add #{worker_klass}: #{e.message}\n\t#{e.backtrace.join("\n\t")}"
+      raise
     rescue java.lang.Exception => e
       ModernTimes.logger.error "Java exception trying to add #{worker_klass.name}: #{e.message}\n\t#{e.backtrace.join("\n\t")}"
+      raise
     end
 
+    # TODO: Get rid of this or prevent worker thread creation until it's been called?
     def start
       return if @started
       @started = true
-
     end
 
     def stop

data/lib/modern_times/manager_mbean.rb

@@ -5,8 +5,8 @@ module ModernTimes
     attr_reader :manager
     r_attribute :allowed_workers, :list, 'Allowed workers'
 
-    def initialize(name, description, manager)
-      super(name, description)
+    def initialize(domain, manager)
+      super(ModernTimes.manager_mbean_name(domain), 'Manager')
       @manager = manager
     end
 
@@ -17,12 +17,19 @@ module ModernTimes
     end
 
     operation 'Start worker'
-    parameter :string, "worker", "The worker class to start"
-    parameter :int, "count", "Number of workers"
+    parameter :string, 'worker',  'The worker class to start'
+    parameter :int,    'count',   'Number of workers'
+    parameter :string, 'options', 'Hash of options in json format (optional)'
     returns :string
-    def start_worker(worker, count)
-      ModernTimes.logger.debug "Attempting to start #{worker} with count=#{count}"
-      manager.add(worker, count, {})
+    def start_worker(worker, count, options)
+      ModernTimes.logger.debug "Attempting to start #{worker} with count=#{count} and options=#{options}"
+      opts = {}
+      unless options.empty?
+        require 'json'
+        opts_string_keys = ::JSON::Parser.new(options).parse
+        opts_string_keys.each { |k,v| opts[k.to_sym] = v }
+      end
+      manager.add(worker, count, opts)
       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/marshal_strategy.rb

@@ -0,0 +1,47 @@
+require 'modern_times/marshal_strategy/bson'
+require 'modern_times/marshal_strategy/json'
+require 'modern_times/marshal_strategy/ruby'
+require 'modern_times/marshal_strategy/string'
+
+# Defines some default marshaling strategies for use in marshaling/unmarshaling objects
+# written and read via jms.  Implementing classes must define the following methods:
+#
+#   # Return symbol
+#   #  :text  if session.create_text_message should be used to generate the JMS message
+#   #  :bytes if session.create_bytes_message should be used to generate the JMS message
+#   def marshal_type
+#     # Return either :text or :bytes
+#     :text
+#   end
+#
+#   # Defines the conversion to wire format by the publisher of the message
+#   def marshal(object)
+#     # Operate on object and convert to message format
+#   end
+#
+#   # Defines the conversion from wire format by the consumer of the message
+#   def unmarshal(msg)
+#     # Operate on message to convert it from wire protocol back to object format
+#   end
+
+module ModernTimes
+  module MarshalStrategy
+    def self.find(marshal_option)
+      if marshal_option.nil?
+        return Ruby
+      elsif marshal_option.kind_of? Symbol
+        return case marshal_option
+                 when :ruby   then Ruby
+                 when :string then String
+                 when :json   then JSON
+                 when :bson   then BSON
+                 else raise "Invalid marshal strategy: #{options[:marshal]}"
+               end
+      elsif marshal_option.respond_to?(:marshal_type)
+        return marshal_option
+      else
+        raise "Invalid marshal strategy: #{marshal_option}"
+      end
+    end
+  end
+end

data/lib/modern_times/marshal_strategy/bson.rb

@@ -0,0 +1,31 @@
+module ModernTimes
+  module MarshalStrategy
+    module BSON
+      extend self
+      
+      def marshal_type
+        :bytes
+      end
+
+      begin
+        require 'bson'
+        def marshal(object)
+          ::BSON.serialize(object).to_s
+        end
+
+        def unmarshal(msg)
+          ::BSON.deserialize(msg)
+        end
+
+      rescue LoadError => e
+        def marshal(object)
+          raise 'Error: BSON marshaling specified but bson gem has not been installed'
+        end
+
+        def unmarshal(msg)
+          raise 'Error: BSON marshaling specified but bson gem has not been installed'
+        end
+      end
+    end
+  end
+end

data/lib/modern_times/marshal_strategy/json.rb

@@ -0,0 +1,30 @@
+module ModernTimes
+  module MarshalStrategy
+    module JSON
+      extend self
+
+      def marshal_type
+        :text
+      end
+
+      begin
+        require 'json'
+        def marshal(object)
+          object.to_json
+        end
+
+        def unmarshal(msg)
+          ::JSON::Parser.new(msg).parse
+        end
+      rescue LoadError => e
+        def marshal(object)
+          raise 'Error: JSON marshaling specified but json gem has not been installed'
+        end
+
+        def unmarshal(msg)
+          raise 'Error: JSON marshaling specified but json gem has not been installed'
+        end
+      end
+    end
+  end
+end

data/lib/modern_times/marshal_strategy/ruby.rb

@@ -0,0 +1,20 @@
+module ModernTimes
+  module MarshalStrategy
+    module Ruby
+      extend self
+
+      def marshal_type
+        :bytes
+      end
+
+      def marshal(object)
+        ::Marshal.dump(object)
+      end
+
+      def unmarshal(msg)
+        msg = ::String.from_java_bytes(msg) unless msg.kind_of?(::String)
+        ::Marshal.load(msg)
+      end
+    end
+  end
+end

data/lib/modern_times/marshal_strategy/string.rb

@@ -0,0 +1,19 @@
+module ModernTimes
+  module MarshalStrategy
+    module String
+      extend self
+
+      def marshal_type
+        :text
+      end
+
+      def marshal(object)
+        object.to_s
+      end
+
+      def unmarshal(msg)
+        msg
+      end
+    end
+  end
+end

data/lib/modern_times/railsable.rb

@@ -1,20 +1,22 @@
 module ModernTimes
   module Railsable
     def init_rails
-      if cfg = YAML.load_file(File.join(Rails.root, "config", "hornetq.yml"))[Rails.env]
+      if @cfg = YAML.load_file(File.join(Rails.root, "config", "jms.yml"))[Rails.env]
         ModernTimes.logger.info "Messaging Enabled"
-        ModernTimes::HornetQ::Client.init(cfg)
-        @is_hornetq_enabled = true
+        ModernTimes::JMS::Connection.init(@cfg)
+        @is_jms_enabled = true
 
-        # Need to start the HornetQ Server in this VM
-        if ModernTimes::HornetQ::Client.invm?
-          @server = ::HornetQ::Server.create_server('hornetq://invm')
+        # Need to start the JMS Server in this VM
+        # TODO: Still want to support this?
+        if false
+        #if ModernTimes::JMS::Connection.invm?
+          @server = ::JMS::Server.create_server('vm://127.0.0.1')
           @server.start
 
           # Handle messages within this process
           @manager = ModernTimes::Manager.new
           # TODO: Formatting of configured workers in invm state with name and options
-          if worker_cfg = cfg[:workers]
+          if worker_cfg = @cfg[:workers]
             worker_cfg.each do |klass, count|
               @manager.add(klass, count, {})
             end
@@ -38,20 +40,19 @@ module ModernTimes
 
       else
         Rails.logger.info "Messaging disabled"
-        @is_hornetq_enabled = false
-        ModernTimes::HornetQ::Publisher.setup_dummy_publishing(rails_workers)
+        @is_jms_enabled = false
+        ModernTimes::JMS::Publisher.setup_dummy_publishing(rails_workers)
+        ModernTimes::JMSRequestor::Requestor.setup_dummy_publishing(rails_workers)
       end
     end
 
     def create_rails_manager
-      cfg = YAML.load_file(File.join(Rails.root, "config", "hornetq.yml"))[Rails.env]
-      raise "No valid configuration" unless cfg
-      ModernTimes::HornetQ::Client.init(cfg)
-
+      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
       manager.stop_on_signal
       manager.allowed_workers = rails_workers
-      manager.persist_file = cfg[:persist_file] || File.join(Rails.root, "log", "modern_times.persist")
+      manager.persist_file = @cfg[:persist_file] || File.join(Rails.root, "log", "modern_times.persist")
       return manager
     end
 
@@ -68,66 +69,8 @@ module ModernTimes
       #raise "No worker config file #{file}" unless File.exist?(file)
     end
 
-    def hornetq_enabled?
-      @is_hornetq_enabled
+    def jms_enabled?
+      @is_jms_enabled
     end
   end
 end
-
-
-## Protocol independent class to handle Messaging and Queuing
-#module Messaging
-#  class Client
-#
-#    # Publish to the specified address
-#    #   If the supplied object is kind_of? String, then a string is published
-#    #   Otherwise the Ruby Object is unmarshaled and sent as a Binary message
-#
-#    # Asynchronously invoke the supplied method
-#    #
-#    # Example:
-#    #   Messaging::Client.async(Dashboard, :update_dashboard_for_inquiry, xml_response)
-#    def self.async(klass, method, *param)
-#      @@session_pool.producer(self.async_address) do |session, producer|
-#        request = AsyncRequest.new
-#        request.klass = if klass.kind_of?(String)
-#          klass
-#        elsif klass.kind_of?(Symbol)
-#          klass.to_s
-#        else
-#          klass.name.to_s
-#        end
-#        request.method = method
-#        request.params = *param
-#        message = session.create_message(4,false) #HornetQ::Client::Message::BYTES_TYPE
-#        message['format'] = 'ruby'
-#        message.body = Marshal.dump(request)
-#        producer.send(message)
-#      end
-#    end
-#
-#    private
-#    # Call the specified class passing in the required parameters
-#    # If the method matches a class method, it is called, otherwise
-#    # an instance of the class is created and the method is called
-#    # on the new instance
-#    #
-#    # Note: Instance methods are more expensive because the class is instantiated
-#    #       for every call
-#    def self.async_on_message(request)
-#      klass = request.klass.constantize
-#      method = request.method.to_sym
-#      if klass.respond_to?(method, false)
-#        klass.send(method, *request.params)
-#      else
-#        klass.new.send(method, *request.params)
-#      end
-#    end
-#
-#    # Passed as the request message, used to hold all required parameters
-#    class AsyncRequest
-#      attr_accessor :klass, :method, :params
-#    end
-#
-#  end
-#end