qwirk 0.0.1 → 0.1.0

data/lib/qwirk/queue_adapter/jms/worker.rb

@@ -1,89 +0,0 @@
-# Handle Messaging and Queuing using JMS
-module Qwirk
-  module QueueAdapter
-    module JMS
-      class Worker
-        def initialize(worker_config)
-          @worker_config = worker_config
-          @name          = worker_config.parent.name
-          @marshaler     = worker_config.parent.marshaler
-          @session       = worker_config.connection.create_session
-          @consumer      = @session.consumer(worker_config.destination)
-          @session.start
-        end
-
-        def receive_message
-          @consumer.receive
-        end
-
-        def acknowledge_message(msg)
-          msg.acknowledge
-        end
-
-        def send_response(original_message, marshaled_object)
-          do_send_response(@marshaler, original_message, marshaled_object)
-        end
-
-        def send_exception(original_message, e)
-          @string_marshaler ||= MarshalStrategy.find(:string)
-          do_send_response(@string_marshaler, original_message, "Exception: #{e.message}") do |reply_message|
-            reply_message['qwirk:exception'] = Qwirk::RemoteException.new(e).to_hash.to_yaml
-          end
-        end
-
-        def message_to_object(msg)
-          marshaler = Qwirk::MarshalStrategy.find(msg['qwirk:marshal'] || :ruby)
-          return marshaler.unmarshal(msg.data)
-        end
-
-        def handle_failure(message, fail_queue_name)
-          @session.producer(:queue_name => fail_queue_name) do |producer|
-            # TODO: Can't add attribute to read-only message?
-            #message['qwirk:exception'] = Qwirk::RemoteException.new(e).to_hash.to_yaml
-            producer.send(message)
-          end
-        end
-
-        def stop
-          puts "in jms worker stop"
-          return if @stopped
-          Qwirk.logger.info "Stopping JMS worker #{@name}"
-          # Don't clobber the session before a reply
-          @consumer.close if @consumer
-          @session.close if @session
-          @stopped = true
-        end
-
-        private
-
-        def do_send_response(marshaler, original_message, marshaled_object)
-          return false unless original_message.reply_to
-          begin
-            @session.producer(:destination => original_message.reply_to) do |producer|
-              # For time_to_live and jms_deliver_mode, first use the local response_options if they're' set, otherwise
-              # use the value from the original_message attributes if they're' set
-              time_to_live = @time_to_live || original_message['qwirk:response:time_to_live']
-              persistent   = @persistent
-              persistent = (original_message['qwirk:response:persistent'] == 'true') if persistent.nil? && original_message['qwirk:response:persistent']
-              # If persistent isn't set anywhere, then default to true unless time_to_live has been set
-              persistent = !time_to_live if persistent.nil?
-              # The reply is persistent if we explicitly set it or if we don't expire
-              producer.delivery_mode_sym = persistent ? :persistent : :non_persistent
-              producer.time_to_live = time_to_live.to_i if time_to_live
-              reply_message = Qwirk::QueueAdapter::JMS.create_message(@session, marshaled_object, marshaler.marshal_type)
-              reply_message.jms_correlation_id = original_message.jms_message_id
-              reply_message['qwirk:marshal'] = marshaler.to_sym.to_s
-              reply_message['qwirk:worker']  = @name
-              reply_message['QwirkTaskID']   = original_message['QwirkTaskID'] if original_message['QwirkTaskID']
-              yield reply_message if block_given?
-              producer.send(reply_message)
-            end
-          rescue Exception => e
-            Qwirk.logger.error {"Error attempting to send response: #{e.message}\n\t#{e.backtrace.join("\n\t")}"}
-          end
-          return true
-        end
-      end
-    end
-  end
-end

data/lib/qwirk/queue_adapter/jms/worker_config.rb

@@ -1,38 +0,0 @@
-# Handle Messaging and Queuing using JMS
-module Qwirk
-  module QueueAdapter
-    module JMS
-      class WorkerConfig
-        include Rumx::Bean
-
-        #bean_reader :queue_size,     :integer, 'Current count of messages in the queue'
-
-        attr_reader :connection, :parent, :destination, :marshaler, :time_to_live, :persistent, :stopped
-
-        def initialize(queue_adapter, parent, queue_name, topic_name, options, response_options)
-          @connection   = queue_adapter.adapter_info
-          @parent       = parent
-          @destination  = {:queue_name => queue_name} if queue_name
-          @destination  = {:topic_name => topic_name} if topic_name
-          # Time in msec until the message gets discarded, should be more than the timeout on the requestor side
-          @time_to_live = response_options[:time_to_live]
-          @persistent   = response_options[:persistent]
-        end
-
-        # Default marshal type for the response
-        def default_marshal_sym
-          :ruby
-        end
-
-        def create_worker
-          Worker.new(self)
-        end
-
-        def stop
-          puts "in jms worker config stop"
-          @stopped = true
-        end
-      end
-    end
-  end
-end

data/lib/qwirk/version.rb

@@ -1,3 +0,0 @@
-module Qwirk
-  VERSION = '0.0.1'
-end

data/lib/qwirk/worker_config.rb

@@ -1,187 +0,0 @@
-require 'rumx'
-
-module Qwirk
-  class WorkerConfig
-    include Rumx::Bean
-
-    attr_reader        :name, :marshaler
-
-    bean_reader        :count,               :integer, 'Current number of workers'
-    bean_attr_accessor :min_count,           :integer, 'Min number of workers allowed', :config_item => true
-    bean_attr_accessor :max_count,           :integer, 'Max number of workers allowed', :config_item => true
-    bean_attr_accessor :idle_worker_timeout, :integer, 'Timeout where an idle worker will be removed from the worker pool and it\'s resources closed (0 for no removal)', :config_item => true
-    bean_attr_accessor :max_read_threshold,  :float,   'Threshold where a new worker will be added if none of the workers have had to wait this amount of time on a read', :config_item => true
-    # The adapter refers to the corresponding class in Qwirk::QueueAdapter::<type>::WorkerConfig
-    bean_attr_reader   :adapter,             :bean,    'Adapter for worker queue interface'
-    bean_attr_reader   :timer,               :bean,    'Track the times for this worker'
-    bean_attr_accessor :log_times,           :boolean, 'Log the times for this worker'
-
-    # Define the default config values for the attributes all workers will share.  These will be sent as options to the constructor
-    def self.initial_default_config
-      {:min_count => 0, :max_count => 0, :idle_worker_timeout => 60, :max_read_threshold => 1.0}
-    end
-
-    # Create new WorkerConfig to manage workers of a common class
-    def initialize(queue_adapter, name, manager, worker_class, default_options, options)
-      @name             = name
-      @manager          = manager
-      @worker_class     = worker_class
-      @workers          = []
-      @stopped          = false
-      @min_count        = 0
-      @max_count        = 0
-      @index_count      = 0
-      @index_mutex      = Mutex.new
-      @worker_mutex     = Mutex.new
-      @worker_condition = ConditionVariable.new
-      response_options  = worker_class.queue_options[:response] || {}
-      @adapter          = queue_adapter.create_adapter_worker_config(self, worker_class.queue_name(@name), worker_class.topic_name, worker_class.queue_options, response_options)
-      # Defines how we will marshal the response
-      marshal_sym       = (response_options[:marshal] || @adapter.default_marshal_sym)
-      @marshaler        = MarshalStrategy.find(marshal_sym)
-      @log_times        = queue_adapter.log_times
-
-      #Qwirk.logger.debug { "options=#{options.inspect}" }
-      default_options.each do |key, value|
-        begin
-          send(key.to_s+'=', value)
-        rescue Exception => e
-          # Let config_reader's set a default value
-          begin
-            instance_variable_set("@#{key}", value)
-          rescue Exception => e
-            Qwirk.logger.warn "WARNING: During initialization of #{worker_class.name} config=#{@name}, default assignment of #{key}=#{value} was invalid"
-          end
-        end
-      end
-      # Run the specified options after the default options, so that codependant options don't get overwritten (like min_count/max_count)
-      options.each do |key, value|
-        begin
-          send(key.to_s+'=', value)
-        rescue Exception => e
-          Qwirk.logger.warn "WARNING: During initialization of #{worker_class.name} config=#{@name}, assignment of #{key}=#{value} was invalid"
-        end
-      end
-    end
-
-    def count
-      @worker_mutex.synchronize { return @workers.size }
-    end
-
-    def min_count=(new_min_count)
-      return if @min_count == new_min_count
-      raise "#{@worker_class.name}-#{@name}: Can't change count since we've been stopped" if @stopped
-      Qwirk.logger.info "#{@worker_class.name}: Changing min number of workers from #{@min_count} to #{new_min_count}"
-      self.max_count = new_min_count if @max_count < new_min_count
-      @worker_mutex.synchronize do
-        add_worker while @workers.size < new_min_count
-        @min_count = new_min_count
-      end
-    end
-
-    def max_count=(new_max_count)
-      return if @max_count == new_max_count
-      raise "#{@worker_class.name}-#{@name}: Can't change count since we've been stopped" if @stopped
-      Qwirk.logger.info "#{@worker_class.name}: Changing max number of workers from #{@max_count} to #{new_max_count}"
-      self.min_count = new_max_count if @min_count > new_max_count
-      @min_count = 1 if @min_count == 0 && new_max_count > 0
-      @worker_mutex.synchronize do
-        @timer ||= Rumx::Beans::TimerAndError.new
-        if @workers.size > new_max_count
-          @workers[new_max_count..-1].each { |worker| worker.stop }
-          while @workers.size > new_max_count
-            @workers.last.stop
-            @worker_condition.wait(@worker_mutex)
-          end
-        end
-        @max_count = new_max_count
-      end
-    end
-
-    def stop
-      Qwirk.logger.debug { "In Base worker_config stop" }
-      # First stop the adapter.  For InMem, this will not return until all the messages in the queue have
-      # been processed since these messages are not persistent.
-      @adapter.stop
-      @worker_mutex.synchronize do
-        @workers.each { |worker| worker.stop }
-        while @workers.size > 0
-          @worker_condition.wait(@worker_mutex)
-        end
-        @stopped = true
-      end
-    end
-
-    def worker_stopped(worker)
-      remove_worker(worker)
-    end
-
-    # Override rumx bean method
-    def bean_attributes_changed
-      super
-      @manager.save_persist_state
-    end
-
-    def marshal_response(object)
-      @marshaler.marshal(object)
-    end
-
-    def unmarshal_response(marshaled_object)
-      @marshaler.unmarshal(marshaled_object)
-    end
-
-    def periodic_call(poll_time)
-      now = Time.now
-      add_new_worker = true
-      worker_stopped = false
-      @worker_mutex.synchronize do
-        # reverse_each to remove later workers first
-        @workers.reverse_each do |worker|
-          start_worker_time = worker.start_worker_time
-          start_read_time = worker.start_read_time
-          if !start_read_time || (now - start_worker_time) < (poll_time + @max_read_threshold)
-            #Qwirk.logger.debug { "#{self}: Skipping newly created worker" }
-            add_new_worker = false
-            next
-          end
-          end_read_time = worker.start_processing_time
-          # If the processing time is actually from the previous processing, then we're probably still waiting for the read to complete.
-          if !end_read_time || end_read_time < start_read_time
-            if !worker_stopped && @workers.size > @min_count && (now - start_read_time) > @idle_worker_timeout
-              worker.stop
-              worker_stopped = true
-            end
-            end_read_time = now
-          end
-          #Qwirk.logger.debug { "#{self}: start=#{start_read_time} end=#{end_read_time} thres=#{@max_read_threshold} add_new_worker=#{add_new_worker}" }
-          add_new_worker = false if (end_read_time - start_read_time) > @max_read_threshold
-        end
-        add_worker if add_new_worker && @workers.size < @max_count
-      end
-    end
-
-    def to_s
-      @name
-    end
-
-    private
-
-    def add_worker
-      worker = @worker_class.new
-      worker.start(@index_count, self)
-      Qwirk.logger.debug {"#{self}: Adding worker #{worker}"}
-      @index_mutex.synchronize { @index_count += 1 }
-      @workers << worker
-    rescue Exception => e
-      Qwirk.logger.error("Unable to add #{@worker_class} worker: #{e.message}\n\t#{e.backtrace.join("\n\t")}")
-    end
-
-    def remove_worker(worker)
-      Qwirk.logger.debug {"#{self}: Deleting worker #{worker}"}
-      @worker_mutex.synchronize do
-        @workers.delete(worker)
-        @worker_condition.broadcast
-      end
-    end
-  end
-end