rosetta_queue 0.4.0

data/History.txt

@@ -0,0 +1,38 @@
+== 0.4.x (git)
+
+== 0.4.0
+ === New features
+ * Allows for custom exception handling logic to be registered for publishing and consuming actions. See ExceptionHandler for more info. (Ben Mabey)
+  * RQ was doing a blanket rescue for publishing and consuming and then logging the errors.  If you still want this behaviour you will need to register a block/class to do that. Again, see ExceptionHandler for more details.
+ * Added core time extension when ActiveSupport not present. (Chris Wyckoff)
+ === Bufixes
+ * Closing the connection after publishing message now instead of unsubscribing. (Chris Wyckoff)
+
+
+== 0.2.0
+ === New features
+  * Synchronous AMQP adapter (Chris Wyckoff - Lead Media Partners)
+    * Uses celldee's synchronous AMQP client, 'Bunny'.
+  * Added .delete method to Consumer class (Chris Wyckoff - Lead Media Partners)
+    * Allows user to purge a queue.
+    * Works for AMQP adapters only.
+ === Bufixes
+  * client :ack now working. (Chris Wyckoff - Lead Media Partners)
+
+== 0.1.4
+
+ === New features
+  * Removed dependency on ActiveSupport and brought over needed String methods. (Derek and Matt - Greenview Data, Inc.)
+  * Safer shutdown in ThreadedManager (Rob Sanheim - Relevance)
+  * Beanstalk Adaper (David Brady - Lead Media Partners)
+    * Still needs some work to have it take advantage of beanstalk's subscribe functionality.
+  * Synchronous AMQP adapter
+    * Uses celldee's synchronous AMQP client, 'Bunny'.
+  * Added .delete method to Consumer class
+    * Allows user to purge a queue.
+    * Works for AMQP adapters only.
+  * Beanstalk Adaper (David Brady)
+    * Still needs some work to have it take advantage of beanstalk's subscribe functionality.
+
+== 0.1.0 / 2008-01-28 - Initial Release
+RosettaQueue was realased in the wild! RQ's initial development was primarily sponsored by Alliance Health Networks (thanks!!).  The original authors were Chris Wyckoff and Ben Mabey. The initial release included adapters for stomp and amqp, in addition to a null and fake adapters for testing.

data/MIT-LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2008-2009 Chris Wyckoff, Ben Mabey
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,11 @@
+= Rosetta Queue
+
+Rosetta Queue is a messaging gateway API with adapters for many messaging systems available in Ruby. Messaging systems can be easily switched out with a small configuration change. Code for testing on the object and application level is also provided.
+
+Documentation can be found on the wiki.[http://wiki.github.com/bmabey/rosetta_queue]
+
+== Authors
+
+Ben Mabey [http://github.com/bmabey]
+
+Chris Wyckoff [http://github.com/cwyckoff]

data/Rakefile

@@ -0,0 +1,39 @@
+require 'rubygems'
+require 'spec/rake/spectask'
+require 'cucumber/rake/task'
+
+Cucumber::Rake::Task.new do |t|
+  t.cucumber_opts = "--format pretty"
+end
+
+desc "Run the specs under spec"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = ['--options', "spec/spec.opts"]
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "rosetta_queue"
+    s.rubyforge_project = "rosetta-queue"
+    s.summary = %Q{Messaging gateway API with adapters for many messaging systems available in Ruby.}
+    s.email = "cbwyckoff@gmail.com"
+    s.homepage = "http://github.com/cwyckoff/rosetta_queue"
+    s.description = %Q{Messaging gateway API with adapters for many messaging systems available in Ruby. Messaging systems can be easily switched out with a small configuration change. Code for testing on the object and application level is also provided.}
+    s.extra_rdoc_files = ["README.rdoc", "MIT-LICENSE.txt"]
+    s.files = FileList["[A-Z]*.*", "{bin,generators,lib,features,spec}/**/*", "Rakefile", "cucumber.yml"]
+    s.authors = ["Ben Mabey", "Chris Wyckoff"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+desc "Default task runs specs"
+task :default => [:spec]
+
+desc 'Removes trailing whitespace'
+task :whitespace do
+  sh %{find . -name '*.rb' -exec sed -i '' 's/ *$//g' {} \\;}
+end
+

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:minor: 4
+:patch: 0
+:major: 0

data/cucumber.yml

@@ -0,0 +1 @@
+default: features --format pretty --require features --tags ~@unreliable

data/examples/sample_amqp_consumer.rb

@@ -0,0 +1,45 @@
+require 'rubygems'
+require File.dirname(__FILE__) + '/../init.rb'
+require File.expand_path(File.dirname(__FILE__) + '/../lib/rosetta_queue/consumer_managers/threaded')
+RosettaQueue.logger = Logger.new(File.expand_path(File.dirname(__FILE__) + '/../../log/rosetta_queue.log'))
+
+module RosettaQueue
+
+  Adapter.define do |a|
+    a.user      = "rosetta"
+    a.password  = "password"
+    a.host      = "localhost"
+    a.type      = 'amqp_synch'
+  end
+
+  Destinations.define do |dest|
+    dest.map :foo, "queue.foo"
+  end
+
+  class MessageHandlerFoo
+    include RosettaQueue::MessageHandler
+    subscribes_to :foo
+    options :ack => true
+    attr_reader :msg
+
+    def on_message(msg)
+      puts "FOO received message: #{msg}"
+    end
+
+  end
+
+#   consumer = RosettaQueue::Consumer.new(MessageHandlerFoo.new)
+# #  Thread.new(consumer) do |cons|
+#     consumer.receive
+# #  end
+#   puts "sleeping for 10"
+#   sleep 10
+#   puts "shutting consumer down"
+#  consumer.disconnect
+
+  ThreadedManager.create do |m|
+    m.add MessageHandlerFoo.new
+    m.start
+  end
+
+end

data/examples/sample_amqp_fanout_consumer.rb

@@ -0,0 +1,52 @@
+require 'rubygems'
+require File.dirname(__FILE__) + '/../init.rb'
+require File.expand_path(File.dirname(__FILE__) + '/../lib/rosetta_queue/consumer_managers/threaded.rb')
+RosettaQueue.logger = Logger.new(File.expand_path(File.dirname(__FILE__) + '/../../log/rosetta_queue.log'))
+
+module RosettaQueue
+
+  Adapter.define do |a|
+    a.user      = "rosetta"
+    a.password  = "password"
+    a.host      = "localhost"
+    a.type      = 'amqp_synch'
+  end
+
+  Destinations.define do |dest|
+    dest.map :foo, "fanout.foo"
+  end
+
+  class MessageHandlerFoo
+    include RosettaQueue::MessageHandler
+    subscribes_to :foo
+    options :ack => true
+    attr_reader :msg
+
+    def on_message(msg)
+      puts "FOO received message:  #{msg}"
+      ack
+    end
+
+  end
+
+  class MessageHandlerBar
+    include RosettaQueue::MessageHandler
+    subscribes_to :foo
+    options :ack => true
+    attr_reader :msg
+
+    def on_message(msg)
+      puts "BAR received message:  #{msg}"
+      ack
+    end
+  end
+
+
+  # threaded version
+  ThreadedManager.create do |m|
+    m.add MessageHandlerFoo.new
+    m.add MessageHandlerBar.new
+    m.start
+  end
+
+end

data/examples/sample_amqp_fanout_producer.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require File.dirname(__FILE__) + '/../init.rb'
+RosettaQueue.logger = Logger.new(File.expand_path(File.dirname(__FILE__) + '/../../log/rosetta_queue.log'))
+
+RosettaQueue::Adapter.define do |a|
+  a.user      = "rosetta"
+  a.password  = "password"
+  a.host      = "localhost"
+  a.type      = "amqp_synch"
+end
+
+RosettaQueue::Destinations.define do |dest|
+  dest.map :foo, "fanout.foo"
+end
+
+
+RosettaQueue::Producer.publish(:foo, "hello there")
+

data/examples/sample_amqp_producer.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require File.dirname(__FILE__) + '/../init.rb'
+RosettaQueue.logger = Logger.new(File.expand_path(File.dirname(__FILE__) + '/../../log/rosetta_queue.log'))
+
+RosettaQueue::Adapter.define do |a|
+  a.user      = "rosetta"
+  a.password  = "password"
+  a.host      = "localhost"
+  a.type      = "amqp_synch"
+end
+
+RosettaQueue::Destinations.define do |dest|
+  dest.map :foo, "queue.foo"
+end
+
+RosettaQueue::Producer.publish(:foo, "hello there")

data/features/filtering.feature

@@ -0,0 +1,31 @@
+Feature: Message Filtering
+  In order to save time and prevent lots of typing
+  As a RosettaQueue user
+  I want to be able to define filters for processing all of my messages
+
+
+  Scenario Outline: receiving filter
+    Given RosettaQueue is configured for '<Adapter>'
+    And a destination is set with queue '<Queue>' and queue address '<QueueAddress>'
+    And a receiving filter is defined to prepend 'Foo' to all messages
+    And the message 'Hello World' is published to queue '<Queue>'
+    When the message on '<Queue>' is consumed
+    Then the consumed message should equal "Foo Hello World"
+
+    Examples:
+    | Adapter     | Queue    |  QueueAddress  |
+    | amqp_synch  | foo      |  queue.foo     |
+    | stomp       | foo      |  /queue/foo    |
+
+  Scenario Outline: sending filter
+    Given RosettaQueue is configured for '<Adapter>'
+    And a destination is set with queue '<Queue>' and queue address '<QueueAddress>'
+    And a sending filter is defined to prepend 'Foo' to all messages
+    And the message 'Hello World' is published to queue '<Queue>'
+    When the message on '<Queue>' is consumed
+    Then the consumed message should equal "Foo Hello World"
+
+    Examples:
+    | Adapter     | Queue    |  QueueAddress  |
+    | amqp_synch  | foo      |  queue.foo     |
+    | stomp       | foo      |  /queue/foo    |

data/features/messaging.feature

@@ -0,0 +1,48 @@
+Story: Producing and Consuming
+
+  As a RosettaQueue user
+  I want to publish and consume point-to-point using various messaging protocols
+  So that I can reliably integrate my systems with a message broker
+
+  Background:
+    Given consumer logs have been cleared
+
+  Scenario Outline: Point-to-Point
+    Given RosettaQueue is configured for '<Adapter>'
+    And a destination is set with queue '<Queue>' and queue address '<QueueAddress>'
+    And a consumer is listening to queue '<Queue>'
+    When a message is published to '<Queue>'
+    Then the message should be consumed from '<Queue>'
+
+    Examples:
+    | Adapter       | Queue    |  QueueAddress  |
+    | amqp_synch    | foo      |  queue.foo     |
+    | amqp_evented  | bar      |  queue.bar     |
+    | stomp         | baz      |  /queue/baz    |
+#| beanstalk     | baz      |  baz           |
+
+  Scenario Outline: Delete queue
+    Given RosettaQueue is configured for '<Adapter>'
+    And a destination is set with queue '<Queue>' and queue address '<QueueAddress>'
+    When a message is published to '<Queue>'
+    And the queue '<Queue>' is deleted
+    Then the queue '<Queue>' should no longer exist
+
+    Examples:
+    | Adapter   | Queue    |  QueueAddress  |
+    | amqp_synch  | foo      |  queue.foo   |
+
+
+  @unreliable
+  Scenario Outline: Publish-Subscribe
+    Given RosettaQueue is configured for '<Adapter>'
+    And a destination is set with queue '<Queue>' and queue address '<QueueAddress>'
+    And multiple consumers are listening to queue '<Queue>'
+    When a message is published to '<Queue>'
+    Then multiple messages should be consumed from '<Queue>'
+
+    Examples:
+   | Adapter    | QueueAddress  | Queue |
+   | amqp_synch   | fanout.baz    | baz   |
+   | amqp_evented | queue.foo     | foo   |
+   | stomp        | /topic/foo     | bar   |

data/features/step_definitions/common_messaging_steps.rb

@@ -0,0 +1,82 @@
+def eval_consumer_class(queue, log_file="point-to-point.log", klass_name=nil)
+  klass_name = "#{queue.to_s.capitalize}Consumer" if klass_name.nil?
+  return if Object.const_defined?(klass_name)
+  options = {}
+  unless @adapter_type == "stomp"
+    options = ":ack => true"
+  else
+    options = ":ack => 'client'"
+  end
+
+  str = <<-EOC
+    class #{klass_name}
+      include RosettaQueue::MessageHandler
+      subscribes_to :#{queue}
+      options #{options}
+
+      def on_message(msg)
+        begin
+          file_path = "#{CONSUMER_LOG_DIR}/#{log_file}"
+          File.open(file_path, "w+") do |f|
+            f << msg + " from #{klass_name}"
+          end
+        rescue Exception => e
+          puts e.message
+        end
+      end
+    end
+  EOC
+
+  eval(str)
+  Object.const_get(klass_name)
+end
+
+Given /^consumer logs have been cleared$/ do
+    %w[point-to-point pub-sub fooconsumer barconsumer].each do |file_name|
+      file_path = "#{CONSUMER_LOG_DIR}/#{file_name}.log"
+      File.delete(file_path) if File.exists?(file_path)
+      File.open(file_path, "a+")
+    end
+end
+
+Given /^RosettaQueue is configured for '(\w+)'$/ do |adapter_type|
+  @adapter_type = adapter_type
+  RosettaQueue::Adapter.define do |a|
+    a.user      = "rosetta"
+    a.password  = "password"
+    a.host      = "localhost"
+    a.type      = @adapter_type
+    a.port      = case @adapter_type
+                    when /stomp/
+                    "61613"
+                    when /beanstalk/
+                    "11300"
+                    else
+                    nil
+                    end
+  end
+end
+
+Given /^a destination is set with queue '(.*)' and queue address '(.*)'$/ do |key, queue|
+  RosettaQueue::Destinations.define do |dest|
+    dest.map key.to_sym, queue
+  end
+end
+
+Given /^the message '(.+)' is published to queue '(.+)'$/ do |message, queue_name|
+  publish_message(message, {:to => queue_name})
+end
+
+When /^a message is published to '(\w+)'$/ do |q|
+  RosettaQueue::Producer.publish(q.to_sym, "Hello World!")
+#  publish_message("Hello World!", {:options => {:to => q}})
+end
+
+When /^the queue '(.*)' is deleted$/ do |queue|
+  system("rabbitmqctl list_queues | grep #{queue}").should be_true
+  RosettaQueue::Consumer.delete(queue.to_sym)
+end
+
+Then /^the queue '(.*)' should no longer exist$/ do |queue|
+  system("rabbitmqctl list_queues | grep #{queue}").should be_false
+end

data/features/step_definitions/filtering_steps.rb

@@ -0,0 +1,17 @@
+Then /^a (receiving|sending) filter is defined to prepend 'Foo' to all messages$/ do |filter_type|
+  RosettaQueue::Filters.reset
+  RosettaQueue::Filters.define do |f|
+    f.send(filter_type) { |message| "Foo #{message}" }
+  end
+end
+
+When /^the message on '(.+)' is consumed$/ do |queue_name|
+  # TODO
+  # @consumed_message = queue(:foo_queue).pop
+  @consumed_message = consume_once(queue_name.to_sym)
+end
+
+Then /^the consumed message should equal "(.+)"$/ do |consumed_message|
+  @consumed_message.should == consumed_message
+end
+