stomp 1.1.4 → 1.1.5

data/.gitignore

@@ -0,0 +1,3 @@
+pkg/*
+doc/*
+coverage/*

data/{CHANGELOG → CHANGELOG.rdoc}

@@ -1,3 +1,10 @@
+== 1.1.5 2010-17-03
+
+* Added publish method (send is now deprecated)
+* Changes on Rake File
+* Added original_destination header to unreceive
+* suppress content length header is send on the message for future handling (like unreceive)
+
 == 1.1.4 2010-21-01
 
 * Added unreceive message method that sends the message back to its queue or to the 

data/README.rdoc

@@ -73,3 +73,19 @@ Project Home :
 
 Stomp Protocol Info :
   http://stomp.codehaus.org/Protocol
+
+= Contributors
+
+The following people have contributed to Stomp (ordered by commits):
+
+* Brian McCaliister
+* Glenn Rempe <glenn@rempe.us>
+* jstrachan 
+* Marius Mathiesen <marius.mathiesen@gmail.com>
+* Johan S√∏rensen <johan@johansorensen.com>
+* Thiago Morello <morellon@gmail.com>
+* Guy M. Allard
+* kookster
+* Tony Garnock-Jones <tonyg@lshift.net>
+* chirino
+* Stefan Saasen

data/Rakefile

@@ -11,37 +11,40 @@
 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
-
+$:.unshift(File.dirname(__FILE__) + "/lib")
 require 'rubygems'
-require 'rake/gempackagetask'
+require 'rake'
 require 'rake/testtask'
-require 'rake/rdoctask'
 require 'spec/rake/spectask'
+require "stomp/version"
 
-# read the contents of the gemspec, eval it, and assign it to 'spec'
-# this lets us maintain all gemspec info in one place.  Nice and DRY.
-spec = eval(IO.read("stomp.gemspec"))
-
-Rake::GemPackageTask.new(spec) do |pkg|
-  pkg.gem_spec = spec
-  pkg.need_tar = true
+begin
+  require "hanna/rdoctask"
+rescue LoadError => e
+  require "rake/rdoctask"
 end
 
-task :install => [:package] do
-  sh %{sudo gem install pkg/#{GEM}-#{VERSION}}
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "stomp"
+    gem.version = Stomp::Version::STRING
+    gem.summary = %Q{Ruby client for the Stomp messaging protocol}
+    gem.description = %Q{Ruby client for the Stomp messaging protocol}
+    gem.email = ["brianm@apache.org", 'marius@stones.com', 'morellon@gmail.com']
+    gem.homepage = "http://stomp.codehaus.org/"
+    gem.authors = ["Brian McCallister", 'Marius Mathiesen', 'Thiago Morello']
+    gem.add_development_dependency "rspec"
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
 end
 
-Rake::TestTask.new do |t|
-  t.libs << "test"
-  t.test_files = FileList['test/test*.rb']
-  t.verbose = true
-end
-
-Rake::RDocTask.new do |rd|
-  rd.main = "README.rdoc"
-  rd.rdoc_files.include("README.rdoc", "lib/**/*.rb")
-  rd.rdoc_dir = 'doc'
-  rd.options = spec.rdoc_options
+desc 'Run the specs'
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts = ['--colour --format specdoc --loadby mtime --reverse']
+  t.spec_files = FileList['spec/**/*_spec.rb']
 end
 
 desc "Rspec : run all with RCov"
@@ -51,9 +54,22 @@ Spec::Rake::SpecTask.new('spec:rcov') do |t|
   t.rcov_opts = ['--exclude', 'gems', '--exclude', 'spec']
 end
 
-desc "RSpec : run all"
-Spec::Rake::SpecTask.new('spec') do |t|
-  t.spec_files = FileList['spec/**/*.rb']
-  t.spec_opts = ["--color", "--format", "specdoc"]
+Rake::RDocTask.new do |rdoc|
+  rdoc.main = "README.rdoc"
+  rdoc.rdoc_dir = "doc"
+  rdoc.title = "Stomp"
+  rdoc.options += %w[ --line-numbers --inline-source --charset utf-8 ]
+  rdoc.rdoc_files.include("README.rdoc", "CHANGELOG.rdoc")
+  rdoc.rdoc_files.include("lib/**/*.rb")
 end
 
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/test*.rb']
+  t.verbose = true
+end
+
+task :default => :spec
+
+
+

data/examples/consumer.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'stomp'
+
+
+client = Stomp::Client.new("failover://(stomp://:@localhost:61613,stomp://:@remotehost:61613)?initialReconnectDelay=5000&randomize=false&useExponentialBackOff=false")
+puts "Subscribing ronaldo"
+client.subscribe("/queue/ronaldo", {:ack => "client", "activemq.prefetchSize" => 1, "activemq.exclusive" => true }) do |msg|
+  File.open("file", "a") do |f|
+    f.write(msg.body)
+    f.write("\n----------------\n")
+  end
+  
+  client.acknowledge(msg)
+end
+
+loop do
+  sleep(1)
+  puts "."
+end

data/examples/publisher.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'stomp'
+
+#client = Stomp::Client.new("", "", "localhost", 61613)
+
+client = Stomp::Client.new("failover://(stomp://:@localhost:61613,stomp://:@remotehost:61613)?initialReconnectDelay=5000&randomize=false&useExponentialBackOff=false")
+message = "ronaldo #{ARGV[0]}"
+
+for i in (1..300)
+  puts "Sending message"
+  client.send("/queue/ronaldo", "#{i}: #{message}", {:persistent => true})
+  puts "(#{Time.now})Message sent: #{i}"
+  sleep 1
+end
+
+
+

data/lib/stomp.rb

@@ -13,11 +13,11 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
-require File.join(File.dirname(__FILE__), 'stomp', 'ext', 'hash')
-require File.join(File.dirname(__FILE__), 'stomp', 'connection')
-require File.join(File.dirname(__FILE__), 'stomp', 'client')
-require File.join(File.dirname(__FILE__), 'stomp', 'message')
-require File.join(File.dirname(__FILE__), 'stomp', 'errors')
+require 'stomp/ext/hash'
+require 'stomp/connection'
+require 'stomp/client'
+require 'stomp/message'
+require 'stomp/errors'
 
 module Stomp
 end

data/lib/stomp/client.rb

@@ -10,7 +10,8 @@ module Stomp
   class Client
 
     attr_reader :login, :passcode, :host, :port, :reliable, :parameters
-    alias :obj_send :send
+    
+    #alias :obj_send :send
 
     # A new Client object can be initialized using two forms:
     #
@@ -172,22 +173,31 @@ module Stomp
     end
     
     # Unreceive a message, sending it back to its queue or to the DLQ
-    # client acknowledgement ( connection.subscribe "/queue/a", :ack => 'client'g
     #
-    def unreceive(message)
-      @connection.unreceive message
+    def unreceive(message, options = {})
+      @connection.unreceive(message, options)
     end
-    # Send message to destination
+    
+    # Publishes message to destination
     #
     # If a block is given a receipt will be requested and passed to the
     # block on receipt
     #
     # Accepts a transaction header ( :transaction => 'some_transaction_id' )
-    def send(destination, message, headers = {})
+    def publish(destination, message, headers = {})
       if block_given?
         headers['receipt'] = register_receipt_listener lambda {|r| yield r}
       end
-      @connection.send(destination, message, headers)
+      @connection.publish(destination, message, headers)
+    end
+    
+    def obj_send(*args)
+      __send__(*args)
+    end
+    
+    def send(*args)
+      warn("This method is deprecated and will be removed on the next release. Use 'publish' instead")
+      publish(*args)
     end
     
     def connection_frame

data/lib/stomp/connection.rb

@@ -9,7 +9,7 @@ module Stomp
   class Connection
     attr_reader :connection_frame
     attr_reader :disconnect_receipt
-    alias :obj_send :send
+    #alias :obj_send :send
 
     def self.default_port(ssl)
       ssl ? 61612 : 61613
@@ -239,19 +239,29 @@ module Stomp
       end
     end
 
-    # Send message to destination
+    # Publish message to destination
     #
     # To disable content length header ( :suppress_content_length => true )
     # Accepts a transaction header ( :transaction => 'some_transaction_id' )
-    def send(destination, message, headers = {})
+    def publish(destination, message, headers = {})
       headers[:destination] = destination
       transmit("SEND", headers, message)
     end
     
+    def obj_send(*args)
+      __send__(*args)
+    end
+    
+    def send(*args)
+      warn("This method is deprecated and will be removed on the next release. Use 'publish' instead")
+      publish(*args)
+    end
+    
     # Send a message back to the source or to the dead letter queue
     #
     # Accepts a dead letter queue option ( :dead_letter_queue => "/queue/DLQ" )
     # Accepts a limit number of redeliveries option ( :max_redeliveries => 6 )
+    # Accepts a force client acknowledgement option (:force_client_ack => true)
     def unreceive(message, options = {})
       options = { :dead_letter_queue => "/queue/DLQ", :max_redeliveries => 6 }.merge options
       # Lets make sure all keys are symbols
@@ -260,19 +270,20 @@ module Stomp
       retry_count = message.headers[:retry_count].to_i || 0
       message.headers[:retry_count] = retry_count + 1
       transaction_id = "transaction-#{message.headers[:'message-id']}-#{retry_count}"
+      message_id = message.headers.delete(:'message-id')
       
       begin
         self.begin transaction_id
         
-        if client_ack?(message)
-          self.ack(message.headers[:'message-id'], :transaction => transaction_id)
+        if client_ack?(message) || options[:force_client_ack]
+          self.ack(message_id, :transaction => transaction_id)
         end
         
         if retry_count <= options[:max_redeliveries]
-          self.send(message.headers[:destination], message.body, message.headers.merge(:transaction => transaction_id))
+          self.publish(message.headers[:destination], message.body, message.headers.merge(:transaction => transaction_id))
         else
           # Poison ack, sending the message to the DLQ
-          self.send(options[:dead_letter_queue], message.body, message.headers.merge(:transaction => transaction_id, :persistent => true))
+          self.publish(options[:dead_letter_queue], message.body, message.headers.merge(:transaction => transaction_id, :original_destination => message.headers[:destination], :persistent => true))
         end
         self.commit transaction_id
       rescue Exception => exception
@@ -397,8 +408,8 @@ module Stomp
           # Using :suppress_content_length => true will suppress this behaviour
           # and ActiveMQ will interpret the message as a TextMessage.
           # For more information refer to http://juretta.com/log/2009/05/24/activemq-jms-stomp/
-          suppress_content_length = headers.delete :suppress_content_length
-          headers['content-length'] = "#{body.length}" unless suppress_content_length
+          # Lets send this header in the message, so it can maintain state when using unreceive
+          headers['content-length'] = "#{body.length}" unless headers[:suppress_content_length]
           
           used_socket.puts command  
           headers.each {|k,v| used_socket.puts "#{k}:#{v}" }

data/lib/stomp/version.rb

@@ -0,0 +1,8 @@
+module Stomp
+  module Version  #:nodoc: all
+    MAJOR = 1
+    MINOR = 1
+    PATCH = 5
+    STRING = "#{MAJOR}.#{MINOR}.#{PATCH}"
+  end
+end

data/spec/client_shared_examples.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+shared_examples_for "standard Client" do
+
+  before(:each) do
+    @destination = "/queue/test/ruby/client"
+    @message_text = "test_client-#{Time.now.to_i}"
+  end
+
+  describe "the closed? method" do
+    it "should be false when the connection is open" do
+      @mock_connection.stub!(:closed?).and_return(false)
+      @client.closed?.should == false
+    end
+
+    it "should be true when the connection is closed" do
+      @mock_connection.stub!(:closed?).and_return(true)
+      @client.closed?.should == true
+    end
+  end
+
+  describe "the open? method" do
+    it "should be true when the connection is open" do
+      @mock_connection.stub!(:open?).and_return(true)
+      @client.open?.should == true
+    end
+
+    it "should be false when the connection is closed" do
+      @mock_connection.stub!(:open?).and_return(false)
+      @client.open?.should == false
+    end
+  end
+
+  describe "the subscribe method" do
+
+    before(:each) do
+      @mock_connection.stub!(:subscribe).and_return(true)
+    end
+
+    it "should raise RuntimeError if not passed a block" do
+      lambda {
+        @client.subscribe(@destination)
+      }.should raise_error
+    end
+
+    it "should not raise an error when passed a block" do
+      lambda {
+        @client.subscribe(@destination) {|msg| received = msg}
+      }.should_not raise_error
+    end
+
+  end
+
+end
+

data/spec/client_spec.rb

@@ -0,0 +1,275 @@
+require 'spec_helper'
+require 'client_shared_examples'
+
+describe Stomp::Client do
+
+  before(:each) do
+    @mock_connection = mock('connection')
+    Stomp::Connection.stub!(:new).and_return(@mock_connection)
+  end
+
+  describe "(created with no params)" do
+
+    before(:each) do
+      @client = Stomp::Client.new
+    end
+
+    it "should not return any errors" do
+      lambda {
+        @client = Stomp::Client.new
+      }.should_not raise_error
+    end
+
+    it "should not return any errors when created with the open constructor" do
+      lambda {
+        @client = Stomp::Client.open
+      }.should_not raise_error
+    end
+
+    it_should_behave_like "standard Client"
+
+  end
+
+  describe "(created with invalid params)" do
+
+    it "should return ArgumentError if host is nil" do
+      lambda {
+        @client = Stomp::Client.new('login', 'passcode', nil)
+      }.should raise_error
+    end
+
+    it "should return ArgumentError if host is empty" do
+      lambda {
+        @client = Stomp::Client.new('login', 'passcode', '')
+      }.should raise_error
+    end
+
+    it "should return ArgumentError if port is nil" do
+      lambda {
+        @client = Stomp::Client.new('login', 'passcode', 'localhost', nil)
+      }.should raise_error
+    end
+
+    it "should return ArgumentError if port is < 1" do
+      lambda {
+        @client = Stomp::Client.new('login', 'passcode', 'localhost', 0)
+      }.should raise_error
+    end
+
+    it "should return ArgumentError if port is > 65535" do
+      lambda {
+        @client = Stomp::Client.new('login', 'passcode', 'localhost', 65536)
+      }.should raise_error
+    end
+
+    it "should return ArgumentError if port is empty" do
+      lambda {
+        @client = Stomp::Client.new('login', 'passcode', 'localhost', '')
+      }.should raise_error
+    end
+
+    it "should return ArgumentError if reliable is something other than true or false" do
+      lambda {
+        @client = Stomp::Client.new('login', 'passcode', 'localhost', '12345', 'foo')
+      }.should raise_error
+    end
+
+  end
+
+
+  describe "(created with positional params)" do
+
+    before(:each) do
+      @client = Stomp::Client.new('testlogin', 'testpassword', 'localhost', '12345', false)
+    end
+
+    it "should properly parse the URL provided" do
+      @client.login.should eql('testlogin')
+      @client.passcode.should eql('testpassword')
+      @client.host.should eql('localhost')
+      @client.port.should eql(12345)
+      @client.reliable.should be_false
+    end
+
+    it_should_behave_like "standard Client"
+
+  end
+
+  describe "(created with non-authenticating stomp:// URL and non-TLD host)" do
+
+    before(:each) do
+      @client = Stomp::Client.new('stomp://foobar:12345')
+    end
+
+    it "should properly parse the URL provided" do
+      @client.login.should eql('')
+      @client.passcode.should eql('')
+      @client.host.should eql('foobar')
+      @client.port.should eql(12345)
+      @client.reliable.should be_false
+    end
+
+    it_should_behave_like "standard Client"
+
+  end
+
+  describe "(created with authenticating stomp:// URL and non-TLD host)" do
+
+    before(:each) do
+      @client = Stomp::Client.new('stomp://testlogin:testpasscode@foobar:12345')
+    end
+
+    it "should properly parse the URL provided" do
+      @client.login.should eql('testlogin')
+      @client.passcode.should eql('testpasscode')
+      @client.host.should eql('foobar')
+      @client.port.should eql(12345)
+      @client.reliable.should be_false
+    end
+
+    it_should_behave_like "standard Client"
+
+  end
+
+  describe "(created with non-authenticating stomp:// URL and TLD host)" do
+
+    before(:each) do
+      @client = Stomp::Client.new('stomp://host.foobar.com:12345')
+    end
+
+    after(:each) do
+    end
+
+    it "should properly parse the URL provided" do
+      @client.login.should eql('')
+      @client.passcode.should eql('')
+      @client.host.should eql('host.foobar.com')
+      @client.port.should eql(12345)
+      @client.reliable.should be_false
+    end
+
+    it_should_behave_like "standard Client"
+
+  end
+
+  describe "(created with authenticating stomp:// URL and non-TLD host)" do
+
+    before(:each) do
+      @client = Stomp::Client.new('stomp://testlogin:testpasscode@host.foobar.com:12345')
+    end
+
+    it "should properly parse the URL provided" do
+      @client.login.should eql('testlogin')
+      @client.passcode.should eql('testpasscode')
+      @client.host.should eql('host.foobar.com')
+      @client.port.should eql(12345)
+      @client.reliable.should be_false
+    end
+
+    it_should_behave_like "standard Client"
+
+  end
+  
+  describe "(created with failover URL)" do
+    before(:each) do
+      #default options
+      @parameters = {
+        :initial_reconnect_delay => 0.01,
+        :max_reconnect_delay => 30.0,
+        :use_exponential_back_off => true,
+        :back_off_multiplier => 2,
+        :max_reconnect_attempts => 0,
+        :randomize => false,
+        :backup => false,
+        :timeout => -1
+      }
+    end
+    it "should properly parse a URL with failover://" do
+      url = "failover://(stomp://login1:passcode1@localhost:61616,stomp://login2:passcode2@remotehost:61617)"
+
+      @parameters[:hosts] = [
+        {:login => "login1", :passcode => "passcode1", :host => "localhost", :port => 61616, :ssl => false},
+        {:login => "login2", :passcode => "passcode2", :host => "remotehost", :port => 61617, :ssl => false}
+      ]
+      
+      Stomp::Connection.should_receive(:new).with(@parameters)
+      
+      client = Stomp::Client.new(url)
+      client.parameters.should == @parameters
+    end
+    
+    it "should properly parse a URL with failover:" do
+      url = "failover:(stomp://login1:passcode1@localhost:61616,stomp://login2:passcode2@remotehost1:61617),stomp://login3:passcode3@remotehost2:61618)"
+      
+      @parameters[:hosts] = [
+        {:login => "login1", :passcode => "passcode1", :host => "localhost", :port => 61616, :ssl => false},
+        {:login => "login2", :passcode => "passcode2", :host => "remotehost1", :port => 61617, :ssl => false},
+        {:login => "login3", :passcode => "passcode3", :host => "remotehost2", :port => 61618, :ssl => false}
+      ]
+      
+      Stomp::Connection.should_receive(:new).with(@parameters)
+      
+      client = Stomp::Client.new(url)
+      client.parameters.should == @parameters
+    end
+    
+    it "should properly parse a URL without user and password" do
+      url = "failover:(stomp://localhost:61616,stomp://remotehost:61617)"
+
+      @parameters[:hosts] = [
+        {:login => "", :passcode => "", :host => "localhost", :port => 61616, :ssl => false},
+        {:login => "", :passcode => "", :host => "remotehost", :port => 61617, :ssl => false}
+      ]
+      
+      Stomp::Connection.should_receive(:new).with(@parameters)
+      
+      client = Stomp::Client.new(url)
+      client.parameters.should == @parameters
+    end
+    
+    it "should properly parse a URL with user and/or password blank" do
+      url = "failover:(stomp://:@localhost:61616,stomp://:@remotehost:61617)"
+      
+      @parameters[:hosts] = [
+        {:login => "", :passcode => "", :host => "localhost", :port => 61616, :ssl => false},
+        {:login => "", :passcode => "", :host => "remotehost", :port => 61617, :ssl => false}
+      ]
+      
+      Stomp::Connection.should_receive(:new).with(@parameters)
+      
+      client = Stomp::Client.new(url)
+      client.parameters.should == @parameters
+    end
+    
+    it "should properly parse a URL with the options query" do
+      query = "initialReconnectDelay=5000&maxReconnectDelay=60000&useExponentialBackOff=false&backOffMultiplier=3"
+      query += "&maxReconnectAttempts=4&randomize=true&backup=true&timeout=10000"
+      
+      url = "failover:(stomp://login1:passcode1@localhost:61616,stomp://login2:passcode2@remotehost:61617)?#{query}"
+      
+      #backup and timeout are not implemented yet
+      @parameters = {  
+        :initial_reconnect_delay => 5.0,
+        :max_reconnect_delay => 60.0,
+        :use_exponential_back_off => false,
+        :back_off_multiplier => 3,
+        :max_reconnect_attempts => 4,
+        :randomize => true,
+        :backup => false,
+        :timeout => -1
+      }
+      
+      @parameters[:hosts] = [
+        {:login => "login1", :passcode => "passcode1", :host => "localhost", :port => 61616, :ssl => false},
+        {:login => "login2", :passcode => "passcode2", :host => "remotehost", :port => 61617, :ssl => false}
+      ]
+      
+      Stomp::Connection.should_receive(:new).with(@parameters)
+      
+      client = Stomp::Client.new(url)
+      client.parameters.should == @parameters
+    end
+    
+  end
+
+end