qwirk 0.0.1

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

@@ -0,0 +1,59 @@
+# Handle Messaging and Queuing using JMS
+module Qwirk
+  module QueueAdapter
+    module InMem
+
+      # This is the InMem Adapter that corresponds to Qwirk::WorkerConfig (also known as parent)
+      class WorkerConfig
+        include Rumx::Bean
+
+        bean_reader   :queue_name,     :string,  'Name of the queue'
+        bean_reader   :queue_size,     :integer, 'Current count of messages in the queue'
+        bean_accessor :queue_max_size, :integer, 'Max messages allowed in the queue'
+
+        attr_reader   :stopped, :parent
+
+        def initialize(queue_adapter, parent, queue_name, topic_name, options, response_options)
+          @parent = parent
+          @queue_name = queue_name
+          @topic_name = topic_name
+          queue_max_size = options[:queue_max_size] || 100
+          @queue = Factory.get_worker_queue(parent.name, queue_name, topic_name, queue_max_size)
+        end
+
+        def default_marshal_sym
+          :none
+        end
+
+        def create_worker
+          Worker.new(@parent.name, @parent.marshaler, @queue, @queue_name, @topic_name)
+        end
+
+        def stop
+          return if @stopped
+          Qwirk.logger.debug { "Closing #{self}" }
+          @queue.stop
+          @stopped = true
+        end
+
+        ## End of required override methods for worker_config adapter
+
+        def queue_name
+          @queue.name
+        end
+
+        def queue_size
+          @queue.size
+        end
+
+        def queue_max_size
+          @queue.max_size
+        end
+
+        def queue_max_size=(max_size)
+          @queue.max_size = max_size
+        end
+      end
+    end
+  end
+end

data/lib/qwirk/queue_adapter/jms.rb

@@ -0,0 +1,50 @@
+require 'yaml'
+
+require 'qwirk/queue_adapter/jms/connection'
+require 'qwirk/queue_adapter/jms/publisher'
+require 'qwirk/queue_adapter/jms/worker_config'
+require 'qwirk/queue_adapter/jms/worker'
+
+module Qwirk
+  module QueueAdapter
+    module JMS
+      def self.init(config)
+        Connection.new(config)
+      end
+
+      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
+
+      def self.create_message(session, marshaled_object, marshal_type)
+        case marshal_type
+          when :text
+            session.create_text_message(marshaled_object)
+          when :bytes
+            msg = session.create_bytes_message()
+            msg.data = marshaled_object
+            msg
+          else raise "Invalid marshal type: #{marshal_type}"
+        end
+      end
+
+      def self.parse_response(message)
+        if error_yaml = message['qwirk:exception']
+          return Qwirk::RemoteException.from_hash(YAML.load(error_yaml))
+        end
+        marshaler = Qwirk::MarshalStrategy.find(message['qwirk:marshal'] || :ruby)
+        return marshaler.unmarshal(message.data)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+require 'jms'
+
+# Handle Messaging and Queuing
+module Qwirk
+  module QueueAdapter
+    module JMS
+      class Connection
+        # Initialize the messaging system and connection pool for this VM
+        def initialize(config)
+          @config = config
+          @connection = ::JMS::Connection.new(config)
+          @session_pool = @connection.create_session_pool(@config)
+          @connection.start
+
+          at_exit do
+            close
+          end
+        end
+
+        # Create a session targeted for a consumer (producers should use the session_pool)
+        def create_session
+          @connection.create_session(@config || {})
+        end
+
+        def session_pool
+          @session_pool
+        end
+
+        def close
+          return if @closed
+          Qwirk.logger.info "Closing JMS connection"
+          @session_pool.close if @session_pool
+          if @connection
+            @connection.stop
+            @connection.close
+          end
+          @closed = true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# Handle Messaging and Queuing using JMS
+module Qwirk
+  module QueueAdapter
+    module JMS
+      class Consumer
+        attr_reader :stopped
+
+        def initialize(connection, options)
+          @options = options
+          @session = connection.create_session
+          @consumer = @session.consumer(@options)
+          @session.start
+          @stopped = false
+        end
+
+        def receive
+          @message = @consumer.receive
+          return nil unless @message
+          return JMS.parse_response(@message)
+        end
+
+        def acknowledge_message
+          @message.acknowledge
+        end
+
+        def stop
+          return if @stopped
+          Qwirk.logger.info "Stopping consumer for #{@options.inspect}"
+          # Don't clobber the session before a reply
+          @consumer.close if @consumer
+          @session.close if @session
+          @stopped = true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+# Handle Messaging and Queuing using JMS
+module Qwirk
+  module QueueAdapter
+    module JMS
+      class Publisher
+
+        #attr_reader :persistent, :marshaler, :reply_queue
+
+        def initialize(queue_adapter, queue_name, topic_name, options, response_options)
+          @connection                = queue_adapter.adapter_info
+          response_options         ||= {}
+          @dest_options              = {:queue_name => queue_name} if queue_name
+          @dest_options              = {:topic_name => topic_name} if topic_name
+          @persistent_sym            = options[:persistent] ? :persistent : :non_persistent
+          @time_to_live              = options[:time_to_live]
+          @response_time_to_live_str = response_options[:time_to_live] && response_options[:time_to_live].to_s
+          @response_persistent_str   = nil
+          @response_persistent_str   = (!!response_options[:persistent]).to_s unless response_options[:persistent].nil?
+
+          @connection.session_pool.session do |session|
+            # TODO: Use sync attribute so these queues aren't constantly created.
+            @dest_queue = session.create_destination(@dest_options)
+            if response_options
+              reply_queue_name = response_options[:queue_name] || :temporary
+              @reply_queue = session.create_destination(:queue_name => reply_queue_name)
+            end
+          end
+        end
+
+        def default_marshal_sym
+          :ruby
+        end
+
+        # Publish the given object and return the message_id.
+        # TODO: Too hackish to include task_id in here, think of a better solution
+        def publish(marshaled_object, marshaler, task_id, props)
+          message = nil
+          @connection.session_pool.producer(:destination => @dest_queue) do |session, producer|
+            producer.time_to_live                  = @time_to_live if @time_to_live
+            producer.delivery_mode_sym             = @persistent_sym
+            message = JMS.create_message(session, marshaled_object, marshaler.marshal_type)
+            message.jms_reply_to                   = @reply_queue if @reply_queue
+            message['qwirk:marshal']               = marshaler.to_sym.to_s
+            message['qwirk:response:time_to_live'] = @response_time_to_live_str if @response_time_to_live_str
+            message['qwirk:response:persistent']   = @response_persistent_str unless @response_persistent_str.nil?
+            message['QwirkTaskID']                 = task_id if task_id
+            props.each do |key, value|
+              message.send("#{key}=", value)
+            end
+            producer.send(message)
+          end
+          # Return the adapter_info which for JMS is the message_id.  This value will be sent to with_response below.
+          return message.jms_message_id
+        end
+
+        # See Qwirk::PublishHandle#read_response for the requirements for this method.
+        def with_response(message_id, &block)
+          raise "Invalid call to with_response for #{self}, not setup for responding" unless @reply_queue
+          options = { :destination => @reply_queue, :selector => "JMSCorrelationID = '#{message_id}'" }
+          @connection.session_pool.consumer(options) do |session, consumer|
+            yield MyConsumer.new(consumer)
+          end
+        end
+
+        # See Qwirk::Publisher#create_task_consumer for the requirements for this method.
+        def create_producer_consumer_pair(task_id, marshaler)
+          producer = MyTaskProducer.new(self, @reply_queue, task_id, marshaler)
+          consumer = Consumer.new(@connection, :destination => reply_queue, :selector => "QwirkTaskID = '#{task_id}'")
+          return producer, consumer
+        end
+
+        def create_fail_producer_consumer_pair(task_id, marshaler)
+          fail_queue = nil
+          @connection.session_pool.session do |session|
+            fail_queue = session.create_destination(:queue_name => :temporary)
+          end
+          producer = MyTaskProducer.new(self, fail_queue, task_id, marshaler)
+          consumer = Consumer.new(@connection, :destination => reply_queue, :selector => "QwirkTaskID = '#{task_id}'")
+          return producer, consumer
+        end
+
+        def to_s
+          "Publisher: #{@dest_options.inspect}"
+        end
+
+        #######
+        private
+        #######
+
+        class MyConsumer
+          attr_reader :worker_name
+
+          def initialize(consumer)
+            @consumer = consumer
+          end
+
+          def timeout_read(timeout)
+            msec = (timeout * 1000).to_i
+            if msec > 100
+              message = @consumer.receive(msec)
+            else
+              #message = @consumer.receive_no_wait
+              message = @consumer.receive(100)
+            end
+            return nil unless message
+            message.acknowledge
+            return [message.jms_correlation_id, JMS.parse_response(message), message['qwirk:worker']]
+          end
+        end
+
+        class MyTaskProducer
+          def initialize(publisher, reply_queue, task_id, marshaler)
+            @publisher   = publisher
+            @reply_queue = reply_queue
+            @task_id     = task_id
+            @marshaler   = marshaler
+          end
+
+          def send(marshaled_object)
+            @publisher.publish(marshaled_object, @marshaler, @task_id, {})
+          end
+        end
+      end
+    end
+  end
+end

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

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

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