qwirk 0.0.1

data/lib/qwirk/queue_adapter.rb

@@ -0,0 +1,3 @@
+require 'qwirk/queue_adapter/in_mem'
+require 'qwirk/queue_adapter/jms'
+require 'qwirk/queue_adapter/active_mq'

data/lib/qwirk/queue_adapter/active_mq.rb

@@ -0,0 +1,13 @@
+require 'activemq'
+require 'qwirk/queue_adapter/active_mq/publisher'
+require 'qwirk/queue_adapter/active_mq/worker_config'
+
+module Qwirk
+  module QueueAdapter
+    module ActiveMQ
+      def self.init(config)
+        JMS.init(config)
+      end
+    end
+  end
+end

data/lib/qwirk/queue_adapter/active_mq/publisher.rb

@@ -0,0 +1,12 @@
+module Qwirk
+  module QueueAdapter
+    module ActiveMQ
+      class Publisher < JMS::Publisher
+        def initialize(queue_adapter, queue_name, topic_name, options, response_options)
+          topic_name = "VirtualTopic.#{topic_name}" if topic_name
+          super(queue_adapter, queue_name, topic_name, options, response_options)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# Handle Messaging and Queuing using ActiveMQ
+module Qwirk
+  module QueueAdapter
+    module ActiveMQ
+      class WorkerConfig < JMS::WorkerConfig
+        def initialize(queue_adapter, parent, queue_name, topic_name, options, response_options)
+          if topic_name
+            queue_name = "Consumer.#{parent.name}.VirtualTopic.#{topic_name}"
+            topic_name = nil
+          end
+          super(queue_adapter, parent, queue_name, topic_name, options, response_options)
+        end
+      end
+    end
+  end
+end

data/lib/qwirk/queue_adapter/in_mem.rb

@@ -0,0 +1,7 @@
+require 'qwirk/queue_adapter/in_mem/factory'
+require 'qwirk/queue_adapter/in_mem/publisher'
+require 'qwirk/queue_adapter/in_mem/queue'
+require 'qwirk/queue_adapter/in_mem/reply_queue'
+require 'qwirk/queue_adapter/in_mem/topic'
+require 'qwirk/queue_adapter/in_mem/worker_config'
+require 'qwirk/queue_adapter/in_mem/worker'

data/lib/qwirk/queue_adapter/in_mem/factory.rb

@@ -0,0 +1,45 @@
+module Qwirk
+  module QueueAdapter
+    module InMem
+      module Factory
+        class << self
+          def init
+            @queue_hash             = {}
+            @topic_hash             = {}
+            @queue_hash_mutex       = Mutex.new
+            @topic_hash_mutex       = Mutex.new
+          end
+
+          def get_worker_queue(worker_name, queue_name, topic_name, queue_max_size)
+            if queue_name
+              @queue_hash_mutex.synchronize do
+                queue = @queue_hash[queue_name] ||= Queue.new(queue_name)
+                queue.max_size = queue_max_size
+                return queue
+              end
+            else
+              @topic_hash_mutex.synchronize do
+                topic = @topic_hash[topic_name] ||= Topic.new(topic_name)
+                return topic.get_worker_queue(worker_name, queue_max_size)
+              end
+            end
+          end
+
+          def get_publisher_queue(queue_name, topic_name)
+            if queue_name
+              @queue_hash_mutex.synchronize do
+                return @queue_hash[queue_name] ||= Queue.new(queue_name)
+              end
+            else
+              @topic_hash_mutex.synchronize do
+                return @topic_hash[topic_name] ||= Topic.new(topic_name)
+              end
+            end
+          end
+        end
+      end
+
+      Factory.init
+    end
+  end
+end

data/lib/qwirk/queue_adapter/in_mem/publisher.rb

@@ -0,0 +1,98 @@
+module Qwirk
+  module QueueAdapter
+    module InMem
+      class Publisher
+
+        def initialize(queue_adapter, queue_name, topic_name, options, response_options)
+          @queue_name, @topic_name, @options, @response_options = queue_name, topic_name, options, response_options
+          @queue = Factory.get_publisher_queue(queue_name, topic_name)
+        end
+
+        def default_marshal_sym
+          :none
+        end
+
+        # Publish the given object and return the reply_queue as the adapter_info.
+        def publish(marshaled_object, marshaler, task_id, props)
+          # Since we're in-memory, we'll just unmarshal the object so there is less info to carry around
+          object = marshaler.unmarshal(marshaled_object)
+          reply_queue = nil
+          if @response_options
+            reply_queue = ReplyQueue.new("#{@queue}:#{object.to_s}")
+          end
+          @queue.write([object, reply_queue])
+          # Return the object to get sent to with_response below.
+          return reply_queue
+        end
+
+        # See Qwirk::PublishHandle#read_response for the requirements for this method.
+        def with_response(reply_queue, &block)
+          raise "Could not find reply_queue for #{@queue}" unless reply_queue
+          yield reply_queue
+        end
+
+        # See Qwirk::Publisher#create_producer_consumer_pair for the requirements for this method
+        def create_producer_consumer_pair(task_id, marshaler)
+          consumer_queue          = Queue.new("#{@queue}:#{task_id}")
+          consumer_queue.max_size = @response_options[:queue_max_size] || 100
+          producer                = MyTaskProducer.new(@queue, consumer_queue, marshaler, @response_options)
+          consumer                = MyTaskConsumer.new(@queue, consumer_queue)
+          return producer, consumer
+        end
+
+        def create_fail_producer_consumer_pair(task_id, marshaler)
+          consumer_queue          = Queue.new("#{@queue}Fail:#{task_id}")
+          # TODO: Unlimitied queue or some form of exception on maximum
+          consumer_queue.max_size = -1
+          producer = MyTaskProducer.new(@queue, consumer_queue, marshaler, {})
+          consumer  = MyTaskConsumer.new(@queue, consumer_queue)
+          return producer, consumer
+        end
+
+        private
+
+        class MyTaskProducer
+          def initialize(producer_queue, consumer_queue, marshaler, response_options)
+            @producer_queue   = producer_queue
+            @consumer_queue   = consumer_queue
+            @marshaler        = marshaler
+            @response_options = response_options
+          end
+
+          def send(marshaled_object)
+            object = @marshaler.unmarshal(marshaled_object)
+            @producer_queue.write([object, @consumer_queue])
+            return object.object_id
+          end
+        end
+
+        class MyTaskConsumer
+          attr_reader :stopped
+
+          def initialize(producer_queue, consumer_queue)
+            @producer_queue = producer_queue
+            @consumer_queue = consumer_queue
+            @stopped = false
+          end
+
+          def receive
+            message_id, response, worker_name = @consumer_queue.read(self)
+            return nil unless response
+            return [message_id, response]
+          end
+
+          def acknowledge_message
+          end
+
+          def stop
+            return if @stopped
+            Qwirk.logger.info "Stopping Task worker #{@consumer_queue}"
+            # Don't clobber the session before a reply
+            @producer_queue.interrupt_read
+            @stopped = true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/qwirk/queue_adapter/in_mem/queue.rb

@@ -0,0 +1,88 @@
+module Qwirk
+  module QueueAdapter
+    module InMem
+
+      class Queue
+        # TODO: Look into reimplementing using a Ruby Queue which is probably better performant
+        # Size of the queue before it write-blocks.  If 0, messages will be dropped.  If -1, then it's unlimited.
+        # TODO: Should implement a queue_full_strategy which would be publish_block, drop_oldest, drop_newest
+        attr_accessor :name, :max_size
+
+        def initialize(name)
+          @name                   = name
+          @max_size               = 0
+          @outstanding_hash_mutex = Mutex.new
+          @read_condition         = ConditionVariable.new
+          @write_condition        = ConditionVariable.new
+          @stop_condition         = ConditionVariable.new
+          @array                  = []
+          @stopped                = false
+        end
+
+        def size
+          @array.size
+        end
+
+        def stop
+          @stopped = true
+          @outstanding_hash_mutex.synchronize do
+            @write_condition.broadcast
+            until @array.empty?
+              @stop_condition.wait(@outstanding_hash_mutex)
+            end
+            @read_condition.broadcast
+          end
+        end
+
+        def interrupt_read
+          @outstanding_hash_mutex.synchronize do
+            @read_condition.broadcast
+          end
+        end
+
+        # Block read until a message or we get stopped.  stoppable is an object that responds to stopped (a worker or some kind of consumer)
+        def read(stoppable)
+          @outstanding_hash_mutex.synchronize do
+            until @stopped  || stoppable.stopped do
+              unless @array.empty?
+                @write_condition.signal
+                return @array.shift
+              end
+              @read_condition.wait(@outstanding_hash_mutex)
+            end
+            return if stoppable.stopped
+            # We're not persistent, so even though we're stopped we're going to allow our stoppables to keep reading until the queue's empty
+            unless @array.empty?
+              @stop_condition.signal
+              return @array.shift
+            end
+          end
+          return nil
+        end
+
+        def write(obj)
+          @outstanding_hash_mutex.synchronize do
+            # We just drop the message if no workers have been configured yet
+            while !@stopped
+              if @max_size == 0
+                Qwirk.logger.warn "No worker for queue #{@name}, dropping message #{obj.inspect}"
+                return
+              end
+              if @max_size < 0 || @array.size < @max_size
+                @array << obj
+                @read_condition.signal
+                return
+              end
+              # TODO: Let's allow various write_full_modes such as :block, :remove_oldest, ? (Currently only blocks)
+              @write_condition.wait(@outstanding_hash_mutex)
+            end
+          end
+        end
+
+        def to_s
+          "queue:#{@name}"
+        end
+      end
+    end
+  end
+end

data/lib/qwirk/queue_adapter/in_mem/reply_queue.rb

@@ -0,0 +1,56 @@
+module Qwirk
+  module QueueAdapter
+    module InMem
+
+      class ReplyQueue
+        def initialize(name)
+          @name                   = name
+          @outstanding_hash_mutex = Mutex.new
+          @read_condition         = ConditionVariable.new
+          @array                  = []
+        end
+
+        def timeout_read(timeout)
+          @outstanding_hash_mutex.synchronize do
+            return @array.shift unless @array.empty?
+            timed_read_condition_wait(timeout)
+            return @array.shift
+          end
+          return nil
+        end
+
+        def write(obj)
+          @outstanding_hash_mutex.synchronize do
+            @array << obj
+            @read_condition.signal
+            return
+          end
+        end
+
+        def to_s
+          "reply_queue:#{@name}"
+        end
+
+        #######
+        private
+        #######
+
+        if RUBY_PLATFORM == 'jruby' || RUBY_VERSION[0,3] != '1.8'
+          def timed_read_condition_wait(timeout)
+            # This method not available in MRI 1.8
+            @read_condition.wait(@outstanding_hash_mutex, timeout)
+          end
+        else
+          require 'timeout'
+          def timed_read_condition_wait(timeout)
+            Timeout.timeout(timeout) do
+              @read_condition.wait(@outstanding_hash_mutex)
+            end
+          rescue Timeout::Error => e
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/qwirk/queue_adapter/in_mem/topic.rb

@@ -0,0 +1,48 @@
+module Qwirk
+  module QueueAdapter
+    module InMem
+
+      class Topic
+        def initialize(name)
+          @name            = name
+          @outstanding_hash_mutex           = Mutex.new
+          @worker_hash     = {}
+          @stopped         = false
+        end
+
+        def get_worker_queue(worker_name, queue_max_size)
+          @outstanding_hash_mutex.synchronize do
+            queue = @worker_hash[worker_name] ||= Queue.new("#{@name}:#{worker_name}")
+            queue.max_size = queue_max_size
+            return queue
+          end
+        end
+
+        def stop
+          @stopped = true
+          @worker_hash.each_value do |queue|
+            queue.stop
+          end
+        end
+
+        def read
+          raise "topic should not have been read for #{name}"
+        end
+
+        def write(obj)
+          @outstanding_hash_mutex.synchronize do
+            @worker_hash.each_value do |queue|
+              if !@stopped
+                queue.write(obj)
+              end
+            end
+          end
+        end
+
+        def to_s
+          "topic:#{@name}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# Handle Messaging and Queuing using JMS
+module Qwirk
+  module QueueAdapter
+    module InMem
+      class Worker
+        attr_reader :stopped
+
+        def initialize(name, marshaler, queue, queue_name, topic_name)
+          @name       = name
+          @marshaler  = marshaler
+          @queue      = queue
+          @queue_name = queue_name
+          @topic_name = topic_name
+        end
+
+        def receive_message
+          message, @reply_queue = @queue.read(self)
+          return message
+        end
+
+        def acknowledge_message(message)
+        end
+
+        def send_response(original_message, marshaled_object)
+          # We unmarshal so our workers get consistent messages regardless of the adapter
+          do_send_response(original_message, @marshaler.unmarshal(marshaled_object))
+        end
+
+        def send_exception(original_message, e)
+          # TODO: I think exceptions should be recreated fully so no need for marshal/unmarshal?
+          do_send_response(original_message, Qwirk::RemoteException.new(e))
+        end
+
+        def message_to_object(msg)
+          # The publisher has already unmarshaled the object to save hassle here.
+          return msg
+        end
+
+        def handle_failure(message, fail_queue_name)
+          # TODO: Mode for persisting to flat file?
+          Qwirk.logger.warn("Dropping message that failed: #{message}")
+        end
+
+        def stop
+          return if @stopped
+          @stopped = true
+          Qwirk.logger.debug { "Stopping #{self}" }
+          @queue.interrupt_read
+        end
+
+        ## End of required override methods for worker adapter
+        private
+
+        def do_send_response(original_message, object)
+          puts "Returning #{object} to queue #{@reply_queue}"
+          return unless @reply_queue
+          @reply_queue.write([original_message.object_id, object, @name])
+          return true
+        end
+      end
+    end
+  end
+end