rosetta_queue 0.4.0

data/lib/rosetta_queue/core_ext/string.rb

@@ -0,0 +1,22 @@
+# Taken from ActiveSupport
+class String
+  def camelize(first_letter_in_uppercase = true)
+    if first_letter_in_uppercase
+      self.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+    else
+      self.first.downcase + camelize(self)[1..-1]
+    end
+  end
+
+  def classify
+    camelize(self.sub(/.*\./, ''))
+  end
+
+  def underscore
+    self.gsub(/::/, '/').
+         gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+         gsub(/([a-z\d])([A-Z])/,'\1_\2').
+         tr("-", "_").
+         downcase
+  end
+end

data/lib/rosetta_queue/core_ext/time.rb

@@ -0,0 +1,20 @@
+require 'time'
+
+class Time
+
+  DATE_FORMATS = {
+    :db           => "%Y-%m-%d %H:%M:%S",
+    :number       => "%Y%m%d%H%M%S",
+    :time         => "%H:%M",
+    :short        => "%d %b %H:%M",
+    :long         => "%B %d, %Y %H:%M",
+    :long_ordinal => lambda { |time| time.strftime("%B #{time.day.ordinalize}, %Y %H:%M") },
+    :rfc822       => lambda { |time| time.strftime("%a, %d %b %Y %H:%M:%S #{time.formatted_offset(false)}") }
+  }
+
+  def to_formatted_s(format = :default)
+    return to_default_s unless formatter = DATE_FORMATS[format]
+    formatter.respond_to?(:call) ? formatter.call(self).to_s : strftime(formatter)
+  end
+
+end

data/lib/rosetta_queue/destinations.rb

@@ -0,0 +1,33 @@
+module RosettaQueue
+
+  class Destinations
+
+    @dest = {}
+
+    class << self
+
+      def define
+        yield self
+      end
+
+      def clear
+        @dest.clear
+      end
+
+      def lookup(dest_name)
+        mapping = @dest[dest_name.to_sym]
+        raise "No destination mapping for '#{dest_name}' has been defined!" unless mapping
+        return mapping
+      end
+
+      def map(key, dest)
+        @dest[key] = dest
+      end
+
+      def queue_names
+        @dest.values
+      end
+    end
+
+  end
+end

data/lib/rosetta_queue/exception_handler.rb

@@ -0,0 +1,105 @@
+# == ExceptionHandler
+#
+# RQ allows you to register exception handlers for different parts of messaging.
+# The handlers can be a class with a ::handle method or simply a block.
+# In both cases the handler needs to accept as arguments the exception and
+# an additional info hash which contains useful information about the context
+# in which the error was raised (i.e. the message involved).
+#
+# An example of class exception handler:
+#
+#   class MessagingExceptionHandler
+#     def self.handle(exception, info)
+#       RosettaQueue.logger.error("An exception occurred when #{info[:action]} to/from #{info[:destination]}: \n#{e.message}\n#{e.backtrace.join("\n")}")
+#       RosettaQueue.logger.error("Message that caused exception:\n #{info[:message]}")
+#     end
+#   end
+#
+# You can register it like so:
+#
+#   RosettaQueue::ExceptionHandler.register(:all, MessagingExceptionHandler)
+#
+#
+# Instead of :all you can specify the :consuming or :publishing action.
+#
+# Or you can register a block like so:
+#
+#   RosettaQueue::ExceptionHandler.register(:all) do |exception, info|
+#     # ....
+#   end
+#
+# == Define DSL
+#
+# Like the other parts of RQ you can configure it with ::define (instead of using the
+# ::register call).  Here is an example of that using the block handler:
+#
+#  RosettaQueue::ExceptionHandler.define do |handler|
+#    handler.for(:all) do |exception, info|
+#      case exception
+#      when SomeSpecificError
+#        #.....
+#      else
+#        #...
+#        #...
+#      end
+#    end
+#
+#    handler.for(:consuming) do |exception, info|
+#      # this will be called just for consuming errors in 
+#      # addition to the :all one above
+#    end
+#  end
+#
+
+
+module RosettaQueue
+  class ExceptionHandler
+    class << self
+
+      def handle(messaging_action=:all, info_or_proc={})
+        yield
+      rescue Exception => e
+        handlers = handlers_for(messaging_action)
+        raise e if handlers.empty?
+        info = info_or_proc.respond_to?(:call) ? info_or_proc.call : info_or_proc
+        handlers.each { |h| h.handle(e, info) }
+      end
+
+
+      def define
+        yield self
+      end
+
+      def reset_handlers
+        @handlers = Hash.new { |h, k| h[k] = [] }
+      end
+
+      def register(messaging_action, handler_klass=nil, &block)
+        handler = handler_klass
+        if block_given?
+          def block.handle(*args)
+            call(*args)
+          end
+          handler = block
+        end
+
+        handlers[messaging_action] << handler
+      end
+
+      alias for register
+
+      private
+
+      def handlers
+        @handlers || reset_handlers
+      end
+
+      def handlers_for(messaging_action)
+        return handlers[:all] if messaging_action == :all
+
+        handlers[messaging_action] + handlers[:all]
+      end
+
+    end
+  end
+end

data/lib/rosetta_queue/exceptions.rb

@@ -0,0 +1,10 @@
+module RosettaQueue
+
+  class RosettaQueueError < StandardError; end
+  class DestinationNotFound < RosettaQueueError; end
+  class RosettaQueueVariableNotFound < RosettaQueueError; end
+  class CallbackNotImplemented < RosettaQueueError; end
+  class AdapterException < RosettaQueueError; end
+  class StopProcessingException < Interrupt; end
+
+end

data/lib/rosetta_queue/filters.rb

@@ -0,0 +1,58 @@
+# Example:
+# RosettaQueue::Filters.define do |filter_for|
+#   filter_for.receiving { |message| JSON.parse(message) }
+#   filter_for.sending { |hash| hash.to_json }
+# end
+
+
+module RosettaQueue
+  class Filters
+
+    class << self
+
+      def define
+        yield self
+      end
+
+      def reset
+        @receiving = nil
+        @sending = nil
+      end
+
+      def receiving(&receiving_filter)
+        @receiving = receiving_filter
+      end
+
+      def sending(&sending_filter)
+        @sending = sending_filter
+      end
+
+      def process_sending(message)
+        return message unless @sending
+        @sending.call(message)
+      end
+
+      def process_receiving(message)
+        return message unless @receiving
+        @receiving.call(message)
+      end
+
+      def safe_process_sending(message)
+        safe(:process_sending, message)
+      end
+
+      def safe_process_receiving(message)
+        safe(:process_receiving, message)
+      end
+
+      private
+
+      def safe(filter_call, message)
+        send(filter_call)
+      rescue StandardError
+        message
+      end
+
+    end
+  end
+end

data/lib/rosetta_queue/logger.rb

@@ -0,0 +1,27 @@
+require 'logger'
+
+module RosettaQueue
+  class MissingLogger < ::StandardError; end
+
+  def self.logger=(new_logger)
+    @logger = new_logger
+  end
+
+  def self.logger
+    return @logger if @logger
+    raise MissingLogger, "No logger has been set for RosettaQueue.  Please define one with RosettaQueue.logger=."
+  end
+
+end
+
+module RosettaQueue
+
+  class Logger < ::Logger
+
+    def format_message(severity, timestamp, progname, msg)
+      "[#{timestamp.to_formatted_s(:db)}] #{severity} -- : #{msg}\n"
+    end
+
+  end
+
+end

data/lib/rosetta_queue/message_handler.rb

@@ -0,0 +1,52 @@
+module RosettaQueue
+  module MessageHandler
+
+    module ClassMethods
+      attr_reader :destination, :options_hash
+
+      def options(options = {})
+        @options_hash = options
+      end
+
+      def publishes_to(destination)
+        @destination = destination
+      end
+
+      def subscribes_to(destination)
+        @destination = destination
+      end
+    end
+
+    def self.included(receiver)
+      receiver.extend(ClassMethods)
+    end
+
+    attr_accessor :adapter_proxy
+
+    def destination
+      self.class.destination
+    end
+
+    def options_hash
+      self.class.options_hash
+    end
+
+    def handle_message(unfiltered_message)
+      ExceptionHandler::handle(:publishing,
+        lambda {
+          { :message => Filters.safe_process_receiving(unfiltered_message),
+            :destination => destination,
+            :action => :consuming,
+            :options => options_hash
+          }
+        } ) do
+        on_message(Filters.process_receiving(unfiltered_message))
+      end
+    end
+
+    def ack
+      adapter_proxy.ack unless adapter_proxy.nil?
+    end
+
+  end
+end

data/lib/rosetta_queue/producer.rb

@@ -0,0 +1,21 @@
+module RosettaQueue
+
+  class Producer < Base
+    include MessageHandler
+
+    def self.publish(destination, message, options = {})
+      ExceptionHandler::handle(:publishing,
+        lambda {
+          {:message => Filters.safe_process_sending(message),
+           :action => :publishing,
+           :destination => destination,
+           :options => options}
+        }) do
+        RosettaQueue::Adapter.instance.send_message(
+          Destinations.lookup(destination),
+          Filters.process_sending(message),
+          options)
+      end
+    end
+  end
+end

data/lib/rosetta_queue/spec_helpers.rb

@@ -0,0 +1,5 @@
+require 'rosetta_queue/adapters/null'
+require 'rosetta_queue/adapters/fake'
+require 'rosetta_queue/spec_helpers/hash'
+require 'rosetta_queue/spec_helpers/publishing_matchers'
+require 'rosetta_queue/spec_helpers/helpers'

data/lib/rosetta_queue/spec_helpers/hash.rb

@@ -0,0 +1,21 @@
+class Hash
+  # To be used in conjuction with rspec's predicate matcher.
+  #
+  # For example, in story/feature or a functional spec you could say:
+  #
+  # expected_message =  {'name' => 'Advertiser'}
+  # expected_message.should be_published_to(:advertiser_create)
+  #
+  def published_to?(destination)
+    received_message = nil
+    begin
+      Timeout::timeout(2) { received_message = RosettaQueue::Consumer.receive(destination)}
+    rescue Timeout::Error
+      raise "#{destination} should have received a message but did not NOTE: make sure there are no other processes which are polling messages"
+    end
+
+    # calling should == is kinda wierd, I know.. but in order to get a decent error message it is needed
+    received_message.should ==  self
+  end
+
+end

data/lib/rosetta_queue/spec_helpers/helpers.rb

@@ -0,0 +1,47 @@
+module RosettaQueue
+  # Adds helpful methods when doing application level testing.
+  # If you are using cucumber just include it in your World in the env.rb file:
+  # World {|world| world.extend RosettaQueue::SpecHelpers }
+  module SpecHelpers
+    require 'open-uri'
+
+    # *Currently* only works with ActiveMQ being used as gateway.
+    # This will clear the queues defined in the RosettaQueue::Destinations mapping.
+    # TODO: Figure out a better spot for this to allow for other gateways...
+    def clear_queues
+      RosettaQueue::Destinations.queue_names.each do |name|
+        queue = name.gsub('/queue/','')
+        open("http://127.0.0.1:8161/admin/deleteDestination.action?JMSDestination=#{queue}&JMSDestinationType=queue")
+      end
+    end
+
+    # Publishes a given hash as json to the specified destination.
+    # Example:
+    # publish_message(expected_message, :to => :client_status, :options => {...})
+    # The :options will be passed to the publisher and are optional.
+    def publish_message(message, options)
+      options[:options] ||= {:persistent => false}
+      RosettaQueue::Producer.publish(options[:to], message, options[:options])
+    end
+
+    # Consumes the first message on queue of consumer that is passed in and uses the consumer to handle it.
+    # Example:
+    # consume_once_with ClientStatusConsumer
+    def consume_once_with(consumer)
+      consumer.new.handle_message(RosettaQueue::Consumer.receive(consumer.destination))
+    end
+
+    # Consumes the first message on queue and returns it.
+    # Example:
+    # message = consume_once :foo_queue
+    def consume_once(dest)
+      RosettaQueue::Consumer.receive(dest)
+    end
+
+    def consuming_from(destination)
+      sleep 1
+      Messaging::Consumer.receive(destination, :persistent => false).to_hash_from_json
+    end
+
+  end
+end

data/lib/rosetta_queue/spec_helpers/publishing_matchers.rb

@@ -0,0 +1,144 @@
+module RosettaQueue
+  module Matchers
+
+    class PublishAMessageTo
+
+      def initialize(expected_queue_name, options=nil)
+        @options = options || {}
+        @how_many_messages_expected = (@options[:exactly] || 1).to_i
+        @expected_queue_name = expected_queue_name
+        @expected_queue = expected_queue_name.is_a?(Symbol) ? RosettaQueue::Destinations.lookup(expected_queue_name) : expected_queue_name
+      end
+
+      def matches?(lambda_to_run)
+        #given
+        RosettaQueue::Adapter.stub!(:instance).and_return(fake_adapter = RosettaQueue::Gateway::FakeAdapter.new)
+        #when
+        lambda_to_run.call
+        #then
+        @actual_queues = fake_adapter.queues
+        @number_of_messages_published = @actual_queues.select{ |q| q == @expected_queue}.size
+        @number_of_messages_published == @how_many_messages_expected
+      end
+
+      def failure_message
+        "expected #{message_plural} published to the #{@expected_queue.inspect} queue but #{@number_of_messages_published} messages were"
+      end
+
+      def negative_failure_message
+        "expected ##{message_plural} NOT to be published to the #{@expected_queue.inspect} queue but that queue was published to #{@number_of_messages_published} times"
+      end
+
+      def description
+        "publish #{message_plural} to the '#{@expected_queue_name}' queue"
+      end
+
+    private
+      def message_plural
+        @how_many_messages_expected == 1 ? "a message" : "#{@how_many_messages_expected} messages"
+      end
+    end
+
+    def publish_a_message_to(expected_queue)
+      PublishAMessageTo.new(expected_queue)
+    end
+
+    alias :publish_message_to :publish_a_message_to
+
+    def publish_messages_to(expected_queue, options)
+      PublishAMessageTo.new(expected_queue, options)
+    end
+
+    class PublishMessageMatcher
+
+
+      def matches?(lambda_to_run)
+        #given
+        RosettaQueue::Adapter.stub!(:instance).and_return(fake_adapter = RosettaQueue::Gateway::FakeAdapter.new)
+        #when
+        lambda_to_run.call
+        #then
+        message = fake_adapter.messages_sent_to(@expected_queue).first || ''
+        @actual_message = message
+      end
+
+      protected
+      def extract_options(options)
+        if (expected_queue_name = options[:to])
+          @expected_queue = expected_queue_name.is_a?(Symbol) ? RosettaQueue::Destinations.lookup(expected_queue_name) : expected_queue_name
+        end
+      end
+    end
+
+    class PublishMessageWith < PublishMessageMatcher
+
+      def initialize(message_subset, options)
+        @message_subset = message_subset
+        extract_options(options)
+      end
+
+      def matches?(lambda_to_run)
+        super
+        Spec::Mocks::ArgumentConstraints::HashIncludingConstraint.new(@message_subset) == @actual_message
+      end
+
+      def failure_message
+        if @actual_message.blank?
+          "expected #{@message_subset.inspect} to be contained in a message but no message was published"
+        else
+          "expected #{@message_subset.inspect} to be contained in the message: #{@actual_message.inspect}"
+        end
+      end
+
+      def negative_failure_message
+        "expected #{@message_subset.inspect} not to be contained in the message but was"
+      end
+
+      def description
+        "publish a message with #{@message_subset.inspect}"
+      end
+
+    end
+
+    def publish_message_with(message_subset, options={})
+      PublishMessageWith.new(message_subset, options)
+    end
+
+
+    class PublishMessage < PublishMessageMatcher
+
+      def initialize(expected_message, options)
+        @expected_message = expected_message
+        extract_options(options)
+      end
+
+      def matches?(lambda_to_run)
+        super
+        @actual_message == @expected_message
+      end
+
+      def failure_message
+        if @actual_message.blank?
+          "expected #{@expected_message.inspect} to be published but no message was"
+        else
+          "expected #{@expected_message.inspect} to be published but the following was instead: #{@actual_message.inspect}"
+        end
+      end
+
+      def negative_failure_message
+        "expected #{@expected_message.inspect} not to be published but it was"
+      end
+
+      def description
+        "publish the message: #{@expected_message.inspect}"
+      end
+
+    end
+
+    def publish_message(exact_expected_message, options={})
+      PublishMessage.new(exact_expected_message, options)
+    end
+
+  end
+end
+