qwirk 0.0.1

data/lib/qwirk/marshal_strategy.rb

@@ -0,0 +1,74 @@
+module Qwirk
+
+  # 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 MarshalStrategy
+
+    @options = {}
+
+    def self.find(marshaler)
+      if marshaler.nil?
+        return Ruby
+      else
+        val = @options[marshaler.to_sym]
+        return val if val
+      end
+      raise "Invalid marshal strategy: #{marshaler}"
+    end
+
+    def self.registered?(marshaler)
+      @options.has_key?(marshaler.to_sym)
+    end
+
+    # Allow user-defined marshal strategies.  It can either be passed a hash of sym => marshaler or a list of marshalers
+    # that define the to_sym method which will be used as the key.
+    def self.register(*marshalers)
+      if marshalers.size == 1 && marshalers[0].kind_of?(Hash)
+        marshalers[0].each do |key, marshaler|
+          raise "Invalid marshal strategy: #{marshaler}" unless valid?(marshaler)
+          @options[key] = marshaler
+        end
+      else
+        marshalers.each do |marshaler|
+          raise "Invalid marshal strategy: #{marshaler}" unless valid?(marshaler) && marshaler.respond_to?(:to_sym)
+          @options[marshaler.to_sym] = marshaler
+        end
+      end
+    end
+
+    def self.unregister(sym)
+      @options.delete(sym)
+    end
+
+    def self.valid?(marshaler)
+      return marshaler.respond_to?(:marshal_type) &&
+          marshaler.respond_to?(:marshal) &&
+          marshaler.respond_to?(:unmarshal)
+    end
+  end
+end
+
+require 'qwirk/marshal_strategy/bson'
+require 'qwirk/marshal_strategy/json'
+require 'qwirk/marshal_strategy/none'
+require 'qwirk/marshal_strategy/ruby'
+require 'qwirk/marshal_strategy/string'
+require 'qwirk/marshal_strategy/yaml'

data/lib/qwirk/marshal_strategy/bson.rb

@@ -0,0 +1,37 @@
+module Qwirk
+  module MarshalStrategy
+    module BSON
+      extend self
+      
+      def marshal_type
+        :bytes
+      end
+
+      def to_sym
+        :bson
+      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
+
+      MarshalStrategy.register(self)
+    end
+  end
+end

data/lib/qwirk/marshal_strategy/json.rb

@@ -0,0 +1,37 @@
+module Qwirk
+  module MarshalStrategy
+    module JSON
+      extend self
+
+      def marshal_type
+        :text
+      end
+
+      def to_sym
+        :json
+      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
+      
+      MarshalStrategy.register(self)
+    end
+  end
+end

data/lib/qwirk/marshal_strategy/none.rb

@@ -0,0 +1,26 @@
+module Qwirk
+  module MarshalStrategy
+    # Should only be used with InMem strategy
+    module None
+      extend self
+
+      def marshal_type
+        :bytes
+      end
+
+      def to_sym
+        :none
+      end
+
+      def marshal(object)
+        object
+      end
+
+      def unmarshal(msg)
+        msg
+      end
+
+      MarshalStrategy.register(self)
+    end
+  end
+end

data/lib/qwirk/marshal_strategy/ruby.rb

@@ -0,0 +1,26 @@
+module Qwirk
+  module MarshalStrategy
+    module Ruby
+      extend self
+
+      def marshal_type
+        :bytes
+      end
+
+      def to_sym
+        :ruby
+      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
+
+      MarshalStrategy.register(self)
+    end
+  end
+end

data/lib/qwirk/marshal_strategy/string.rb

@@ -0,0 +1,25 @@
+module Qwirk
+  module MarshalStrategy
+    module String
+      extend self
+
+      def marshal_type
+        :text
+      end
+
+      def to_sym
+        :string
+      end
+
+      def marshal(object)
+        object.to_s
+      end
+
+      def unmarshal(msg)
+        msg
+      end
+
+      MarshalStrategy.register(self)
+    end
+  end
+end

data/lib/qwirk/marshal_strategy/yaml.rb

@@ -0,0 +1,25 @@
+module Qwirk
+  module MarshalStrategy
+    module YAML
+      extend self
+
+      def marshal_type
+        :text
+      end
+
+      def to_sym
+        :yaml
+      end
+
+      def marshal(object)
+        object.to_yaml
+      end
+
+      def unmarshal(msg)
+        ::YAML.load(msg)
+      end
+
+      MarshalStrategy.register(self)
+    end
+  end
+end

data/lib/qwirk/publish_handle.rb

@@ -0,0 +1,170 @@
+require 'timeout'
+
+module Qwirk
+  class PublishHandle
+    def initialize(publisher, adapter_info, start)
+      @producer    = publisher
+      @adapter_info = adapter_info
+      @start        = start
+    end
+
+    # Waits the given timeout for a response message on the queue.
+    #
+    # If called w/o a block:
+    #   Returns the message
+    #   Returns nil on timeout
+    #   Raises RemoteException on a remote exception
+    #
+    # If called with a block, for instance:
+    #   handle.read_response(timeout) do |response|
+    #     response.on_message 'CharCount' do |hash|
+    #       puts "CharCount returned #{hash.inspect}"
+    #     end
+    #     response.on_message 'Length', 'Reverse' do |val|
+    #       puts "#{response.name} returned #{val}"
+    #     end
+    #     response.on_message 'ExceptionRaiser' do |val|
+    #       puts "#{response.name} didn't raise an exception but returned #{val}"
+    #     end
+    #     response.on_timeout 'Reverse' do
+    #       puts "Reverse has it's own timeout handler"
+    #     end
+    #     response.on_timeout do
+    #       puts "#{response.name} did not respond in time"
+    #     end
+    #     response.on_remote_exception 'ExceptionRaiser' do
+    #       puts "It figures that ExceptionRaiser would raise an exception"
+    #     end
+    #     response.on_remote_exception do |e|
+    #       puts "#{response.name} raised an exception #{e.message}\n\t#{e.backtrace.join("\n\t")}"
+    #     end
+    #   end
+    #
+    # The specified blocks will be called for each response.  For instance, LengthWorker#request
+    # might return 4 and "Length returned 4" would be displayed.  If it failed to respond within the
+    # timeout, then "Length did no respond in time" would be displayed.
+    # For Workers that raise an exception, they will either be handled by their specific handler if it exists or
+    # the default exception handler.  If that doesn't exist either, then the RemoteException will be raised for the
+    # whole read_response call.  Timeouts will also be handled by the default timeout handler unless a specific one
+    # is specified.  All messages must have a specific handler specified because the call won't return until all
+    # specified handlers either return, timeout, or return an exception.
+    #
+    def read_response(timeout, &block)
+      raise "Invalid call to read_response for #{@producer}, not setup for responding" unless @producer.response_options
+      # Creates a block for reading the responses for a given message_id (adapter_info).  The block will be passed an object
+      # that responds to timeout_read(timeout) with a [original_message_id, response_message, worker_name] tri or nil if no message is read.
+      # This is used in the RPC mechanism where a publish might wait for 1 or more workers to respond.
+      @producer.adapter.with_response(@adapter_info) do |consumer|
+        if block_given?
+          return read_multiple_response(consumer, timeout, &block)
+        else
+          response = read_single_response(consumer, timeout)
+          raise response if response.kind_of?(Qwirk::RemoteException)
+          return response
+        end
+      end
+    end
+
+    #######
+    private
+    #######
+
+    def read_single_response(consumer, timeout)
+      leftover_timeout = @start + timeout - Time.now
+      message_id, response, @worker_name = consumer.timeout_read(leftover_timeout)
+      return response
+    end
+
+    def read_multiple_response(consumer, timeout, &block)
+      worker_response = WorkerResponse.new(@start)
+      yield worker_response
+
+      until worker_response.done? do
+        response = read_single_response(consumer, timeout)
+        if !response
+          worker_response.make_timeout_calls
+          return
+        end
+        if response.kind_of?(Qwirk::RemoteException)
+          worker_response.make_exception_call(@worker_name, response)
+        else
+          worker_response.make_message_call(@worker_name, response)
+        end
+      end
+    end
+
+    class WorkerResponse
+      attr_reader :name, :start
+
+      def initialize(start)
+        @start                   = start
+        @message_hash            = {}
+        @timeout_hash            = {}
+        @exception_hash          = {}
+        @default_timeout_block   = nil
+        @default_exception_block = nil
+        @done_array              = []
+      end
+
+      # Msecs since publish
+      def msec_delta
+        (Time.now - @start) * 1000
+      end
+
+      def on_message(*names, &block)
+        raise 'Must explicitly define all message handlers so we know that we\'re done' if names.empty?
+        names.each {|name| @message_hash[name] = block}
+      end
+
+      def on_timeout(*names, &block)
+        if names.empty?
+          @default_timeout_block = block
+        else
+          names.each {|name| @timeout_hash[name] = block}
+        end
+      end
+
+      def on_remote_exception(*names, &block)
+        if names.empty?
+          @default_exception_block = block
+        else
+          names.each {|name| @exception_hash[name] = block}
+        end
+        @remote_exception_block = block
+      end
+
+      def make_message_call(name, obj)
+        # Give the client access to the name
+        @name = name
+        block = @message_hash[name]
+        block.call(obj) if block
+        @done_array << name
+      end
+
+      def done?
+        (@message_hash.keys - @done_array).empty?
+      end
+
+      def make_timeout_calls
+        @timeouts = @message_hash.keys - @done_array
+        @timeouts.each do |name|
+          # Give the client access to the name
+          @name = name
+          block = @timeout_hash[name] || @default_timeout_block
+          block.call if block
+        end
+      end
+
+      def make_exception_call(name, e)
+        @name = name
+        block = @exception_hash[name] || @default_exception_block
+        if block
+          block.call(e)
+          @done_array << name
+        else
+          raise e
+        end
+      end
+    end
+  end
+end

data/lib/qwirk/publisher.rb

@@ -0,0 +1,67 @@
+# Protocol independent class to handle Publishing
+module Qwirk
+  class Publisher
+    include Rumx::Bean
+
+    #attr_reader :producer_options, :persistent, :reply_queue
+    attr_reader :response_options, :adapter, :marshaler
+
+    bean_attr_reader :tasks, :hash, 'Hash of the latest tasks', :hash_type => :bean
+
+    # Parameters:
+    #   One of the following must be specified
+    #     :queue_name            => String: Name of the Queue to publish to
+    #     :topic_name            => String: Name of the Topic to publish to
+    #   Optional:
+    #     :time_to_live          => expiration time in ms for the message (JMS)
+    #     :persistent            => true or false (defaults to false) (JMS)
+    #     :marshal               => Symbol: One of :ruby, :string, :json, :bson, :yaml or any registered types (See Qwirk::MarshalStrategy), defaults to :ruby
+    #     :response              => if true or a hash of response options, a temporary reply queue will be setup for handling responses
+    #       :time_to_live        => expiration time in ms for the response message(s) (JMS))
+    #       :persistent          => true or false for the response message(s), set to false if you don't want timed out messages ending up in the DLQ (defaults to true unless time_to_live is set)
+    def initialize(queue_adapter, options)
+      options = options.dup
+      @queue_name = options.delete(:queue_name)
+      @topic_name = options.delete(:topic_name)
+      raise "One of :queue_name or :topic_name must be given in #{self.class.name}" if !@queue_name && !@topic_name
+
+      @response_options = options.delete(:response)
+      # response_options should only be a hash or the values true or false
+      @response_options = {} if @response_options && !@response_options.kind_of?(Hash)
+
+      @tasks            = {}
+      @adapter          = queue_adapter.create_adapter_publisher(@queue_name, @topic_name, options, @response_options)
+      marshal_sym       = options[:marshal] || :ruby
+      @marshaler        = Qwirk::MarshalStrategy.find(marshal_sym)
+    end
+
+    # Publish the given object to the address.
+    def publish(object, props={})
+      start = Time.now
+      marshaled_object = @marshaler.marshal(object)
+      adapter_info = @adapter.publish(marshaled_object, @marshaler, nil, props)
+      return PublishHandle.new(self, adapter_info, start)
+    end
+
+    # Creates a producer/consumer pair for writing and reading responses for a given task.  It will return a pair of
+    # [producer, consumer].  The producer will publish objects specifically for the task.  The consumer is an object that responds_to
+    # receive which will return a [message_id, response object] and acknowledge_message which will acknowledge the
+    # last message read.  It should also respond to stop which will interrupt any receive calls causing it to return nil.
+    def create_producer_consumer_pair(task)
+      @tasks[task.task_id] = task
+      @adapter.create_producer_consumer_pair(task.task_id, @marshaler)
+    end
+
+    def to_s
+      "#{self.class.name}:#{@queue_name || @topic_name}"
+    end
+
+    def default_fail_queue_name
+      Qwirk.fail_queue_name(@queue_name || @topic_name)
+    end
+
+    def create_fail_queue_consumer(fail_queue_name=nil)
+      fail_queue_name ||= default_fail_queue_name
+    end
+  end
+end