qwirk 0.0.1 → 0.1.0

data/examples/task/publisher.rb

@@ -1,25 +0,0 @@
-require 'rumx'
-require 'qwirk'
-
-class Publisher
-  include Rumx::Bean
-
-  bean_attr_reader   :tasks, :list,    'Tasks', :list_type => :bean
-
-  bean_operation :perform_task, :void, 'Perform task which will send <count> messages to the worker and write the output to <output_file>', [
-      [ :task_id,     :string,  'Id for this task ',                         'task1'        ],
-      [ :count,       :integer, 'Count of messages',                         1000           ],
-      [ :message,     :string,  'String portion of the message to send',     'M'            ],
-      [ :sleep_time,  :float,   'Time to sleep between messages',            0.0            ],
-      [ :output_file, :string,  'Output file to write returned messages to', 'messages.out' ]
-  ]
-
-  def initialize(adapter_key)
-    @adapter_key = adapter_key
-    @tasks       = []
-  end
-
-  def perform_task(task_id, count, message, sleep_time, output_file)
-    @tasks << Task.new(@adapter_key, task_id, count, message, sleep_time, output_file)
-  end
-end

data/examples/task/qwirk_persist.yml

@@ -1,5 +0,0 @@
---- 
-Foo: 
-  :min_count: 2
-  :max_count: 100
-  :sleep_time: 0.1

data/examples/task/task.rb

@@ -1,36 +0,0 @@
-require 'rumx'
-require 'qwirk'
-
-class Task
-  include Qwirk::Task
-
-  def initialize(adapter_key, task_id, total_count, message, sleep_time, output_file)
-    publisher = Qwirk[adapter_key].create_publisher(:queue_name => 'Foo', :marshal => :bson, :persistent => false, :response => {:time_to_live => 10000, :marshal => :string})
-    super(publisher, task_id, total_count)
-    @out = File.open(output_file, 'w')
-    (1..total_count).each do |i|
-      obj = {'count' => i, 'message' => message}
-      #puts "Publishing object: #{obj.inspect}"
-      publish(obj)
-      sleep sleep_time
-    end
-    finished_publishing
-  end
-
-  def on_response(request, response)
-    #puts "For request #{request}, got response #{response}"
-    @out.puts response
-  end
-
-  def on_exception(request, exception)
-    puts "For request #{request} got exception #{exception.message}"
-  end
-
-  def on_update()
-  end
-
-  def on_done
-    @out.close
-    puts "We're done"
-  end
-end

data/lib/qwirk/queue_adapter.rb

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

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

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

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

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

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

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

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

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

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