stomper 2.0.1 → 2.0.2

data/CHANGELOG.md

@@ -0,0 +1,28 @@
+# Changes
+
+## 2.0.2 - 2011-03-01
+
+* updated to-do's and version number in README.md
+
+* added CHANGELOG.md
+
+* connection's @close@ method now clears remaining subscriptions and receipt
+  handlers after all events are fired. should ease the work
+  the failover extension has to do to re-subscribe appropriately.
+  
+* corrected spec tests to handle features introduced in 2.0.1 - should not
+  have pushed a new version until those specs were run.
+
+## 2.0.1 - 2011-02-27
+
+* connection now raises exception in threaded receiver to stop, prevents
+  blocking on @receive@
+  
+* connection terminated event now fires properly, fixes #1
+
+* subscription manager clears remaining subscriptions when the connection
+  is closed, fixes #2
+
+## 2.0.0 - 2011-02-22
+
+* Rewrite of stomper

data/README.md

@@ -1,4 +1,4 @@
-#Stomper 2.0.0
+#Stomper 2.0
 
 Stomper is a library for connecting to and interacting with a message broker
 service that supports the Stomp [1.0](http://stomp.github.com/stomp-specification-1-0.html)
@@ -15,22 +15,6 @@ rather unpleasant to deal with for common use cases.
 This gem is in no way related to the [Python stomper](http://code.google.com/p/stomper/)
 library.
 
-##Still in the Works
-
-There are a few features that have not yet been implemented, hence why we're
-still on a prerelease version number. The following is a list of the major
-deficiencies of the gem, but this list is not necessarily exhaustive.
-
-* Write some features to test other connections:
-  * Authenticated logins
-  * SSL Client verification (just to ensure that SSL params are being
-    delivered appropriately)
-* A bit of refactoring is in order
-  * Refactor specs a bit, clean up separation between 1.9 and 1.8 specific tests
-
-As these issues are resolved, I'll drop them from the list (and potentially
-add other issues)
-
 ##Example Usage
 
     # Establish a connection to the broker

data/features/protocol_version_negotiation.feature

@@ -5,17 +5,17 @@ Feature: Protocol version negotiation
   
   Scenario: By default, allow 1.1 from broker
     Given a Stomp 1.1 broker
-    When a connection is established
+    When the connection is told to connect
     Then the connection should be using the 1.1 protocol
     
   Scenario: By default, allow 1.0 from broker
     Given a Stomp 1.0 broker
-    When a connection is established
+    When the connection is told to connect
     Then the connection should be using the 1.0 protocol
     
   Scenario: By default, assume 1.0 from version-less broker
     Given an unversioned Stomp broker
-    When a connection is established
+    When the connection is told to connect
     Then the connection should be using the 1.0 protocol
   
   Scenario: By default, raise error if the broker's version isn't supported
@@ -26,13 +26,13 @@ Feature: Protocol version negotiation
   Scenario: A 1.0 client should accept a 1.0 broker
     Given a Stomp 1.0 broker
     When the client protocol version is "1.0"
-    And a connection is established
+    And the connection is told to connect
     Then the connection should be using the 1.0 protocol
   
   Scenario: A 1.0 client should accept a version-less broker
     Given an unversioned Stomp broker
     When the client protocol version is "1.0"
-    And a connection is established
+    And the connection is told to connect
     Then the connection should be using the 1.0 protocol
     
   Scenario: A 1.0 client should not accept a 1.1 broker
@@ -44,7 +44,7 @@ Feature: Protocol version negotiation
   Scenario: A 1.1 client should accept a 1.1 broker
     Given a Stomp 1.1 broker
     When the client protocol version is "1.1"
-    And a connection is established
+    And the connection is told to connect
     Then the connection should be using the 1.1 protocol
   
   Scenario: A 1.1 client should not accept a 1.0 broker

data/features/steps/{acking_messages_steps.rb → ack_and_nack_steps.rb}

@@ -38,4 +38,12 @@ end
 
 Then /^the client nacking the last MESSAGE should raise an argument error$/ do
   lambda { @connection.nack @received_frames.select { |f| f.command == "MESSAGE" }.last }.should raise_error(ArgumentError)
-end
+end
+
+When /^the client acks a message by ID "([^"]*)" and subscription "([^"]*)" within the scope$/ do |message_id, subscription|
+  @scope.ack message_id, subscription
+end
+
+When /^the client nacks a message by ID "([^"]*)" and subscription "([^"]*)" within the scope$/ do |message_id, subscription|
+  @scope.nack message_id, subscription
+end

data/features/steps/broker_steps.rb

@@ -0,0 +1,52 @@
+Given /^a Stomp (\d+\.\d+)?\s*broker$/ do |version|
+  version ||= '1.0'
+  @broker_uri_string = "stomp:///"
+  @broker_uri = URI.parse(@broker_uri_string)
+  @broker = TestStompServer.new(version)
+  @broker.start
+  @connection = Stomper::Connection.new(@broker_uri)
+end
+
+Given /^an erroring Stomp broker$/ do
+  @broker_uri_string = "stomp:///"
+  @broker_uri = URI.parse(@broker_uri_string)
+  @broker = TestStompServer.new('1.0')
+  @broker.session_class = TestStompServer::StompErrorOnConnectSession
+  @broker.start
+  @connection = Stomper::Connection.new(@broker_uri)
+end
+
+Then /^the broker should have received an? "([^"]*)" frame$/ do |command|
+  Then "the broker should have received a \"#{command}\" frame with headers", table(%{
+    | header-name | header-value |
+  })
+end
+
+Then /^the broker should have received an? "([^"]*)" frame with headers$/ do |command, table|
+  headers = table_to_headers table
+  @broker.session.received_frames.any? do |f|
+    f.command == command && headers.all? { |(k,v)| headers[k] == f[k] }
+  end.should be_true
+end
+
+When /^the broker sends a "([^"]*)" frame with headers$/ do |command, table|
+  headers = table_to_headers table
+  @broker.session.send_frame command, headers
+end
+
+When /^the broker closes the connection unexpectedly$/ do
+  @broker.force_stop
+end
+
+Given /^a Stomp (\d+\.\d+)?\s*SSL broker$/ do |version|
+  @broker = TestSSLStompServer.new(version)
+  @broker.start
+end
+
+Given /^an unversioned Stomp broker$/ do
+  @broker_uri_string = "stomp:///"
+  @broker_uri = URI.parse(@broker_uri_string)
+  @broker = TestStompServer.new(nil)
+  @broker.start
+  @connection = Stomper::Connection.new(@broker_uri)
+end

data/features/steps/client_steps.rb

@@ -0,0 +1,137 @@
+After do |s|
+  begin
+    @connection && @connection.stop
+    @broker && @broker.force_stop
+  rescue Exception => ex
+  end
+end
+
+Given /^a (\d+\.\d+)?\s*connection between client and broker$/ do |version|
+  version ||= '1.0'
+  @broker_uri_string = "stomp:///"
+  @broker_uri = URI.parse(@broker_uri_string)
+  @broker = TestStompServer.new(version)
+  @broker.start
+  @connection = Stomper::Connection.new(@broker_uri)
+  @received_frames = []
+  @sent_frames = []
+  @connection.before_transmitting do |f, c|
+    @sent_frames << f
+  end
+  @connection.after_receiving do |f, c|
+    @received_frames << f
+  end
+  @connection.start
+end
+
+When /^the frame exchange is completed$/ do
+  @connection.disconnect(:receipt => 'TERMINATE_POLITELY_12345')
+  @connection.stop
+  @broker.stop
+end
+
+When /^the frame exchange is completed without client disconnect$/ do
+  @connection.stop
+  @broker.stop
+end
+
+When /^a connection is created from the broker's URI$/ do
+  #@connection = Stomper::Connection.new(@broker_uri)
+end
+
+When /^a connection is created from the broker's URI string$/ do
+  @connection = Stomper::Connection.new(@broker_uri_string)
+end
+
+When /^the connection is told to connect$/ do
+  @connection.connect
+end
+
+When /^the client protocol version is "([^"]*)"$/ do |arg1|
+  @connection.versions = arg1.split(",")
+end
+
+Then /^the connection should be connected$/ do
+  @connection.connected?.should be_true
+end
+
+Then /^the connection should be using the (\d+\.\d+) protocol$/ do |version|
+  @connection.version.should == version
+end
+
+Then /^connecting should raise an unsupported protocol version error$/ do
+  lambda { @connection.connect }.should raise_error(Stomper::Errors::UnsupportedProtocolVersionError)
+end
+
+Then /^the (connection|client) should not be connected$/ do |arbitrary_name|
+  @connection.connected?.should be_false
+end
+
+Then /^connecting should raise an connect failed error$/ do
+  lambda { @connection.connect }.should raise_error(Stomper::Errors::ConnectFailedError)
+end
+
+Then /^the client should have received an? "([^"]*)" frame with headers$/ do |command, table|
+  headers = table_to_headers table
+  @received_frames.any? do |f|
+    f.command == command && headers.all? { |(k,v)| headers[k] == f[k] }
+  end.should be_true
+end
+
+When /^the client waits for (\d+) "([^"]*)" frames?$/ do |count, command|
+  count = count.to_i
+  Thread.pass while @received_frames.select { |f| f.command == command }.size < count
+end
+
+Given /^an established connection$/ do
+  @connection.connect
+end
+
+When /^the client disconnects$/ do
+  @connection.disconnect
+  @broker.stop
+end
+
+Then /^after (\d+\.\d+) seconds, the receiver should no longer be running$/ do |sleep_for|
+  sleep sleep_for.to_f
+  @connection.running?.should be_false
+end
+
+When /^a connection is created for the SSL broker$/ do
+  @connection = Stomper::Connection.new("stomp+ssl:///")
+end
+
+When /^the broker's host is "([^"]*)"$/ do |hostname|
+  @connection.host = hostname
+end
+
+When /^no SSL verification is performed$/ do
+  @connection.ssl[:verify_mode] = OpenSSL::SSL::VERIFY_NONE
+end
+
+When /^SSL verification is performed$/ do
+  @connection.ssl[:verify_mode] = ::OpenSSL::SSL::VERIFY_PEER | ::OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT
+end
+
+When /^an SSL post connection check is performed on "([^"]*)"$/ do |host|
+  @connection.ssl[:post_connection_check] = host
+end
+
+Then /^connecting should raise an openssl error$/ do
+  lambda { @connection.connect }.should raise_error(OpenSSL::SSL::SSLError)
+  # It is problematic that this is needed...
+  @broker.stop
+end
+
+When /^an SSL post connection check is not performed$/ do
+  @connection.ssl[:post_connection_check] = false
+end
+
+When /^the broker's certificate is verified by CA$/ do  
+  @connection.ssl[:ca_file] = File.expand_path('../../support/ssl/demoCA/cacert.pem', __FILE__)
+end
+
+When /^the client's certificate and key are specified$/ do
+  @connection.ssl[:cert] = OpenSSL::X509::Certificate.new(File.read(File.expand_path('../../support/ssl/client_cert.pem', __FILE__)))
+  @connection.ssl[:key] = OpenSSL::PKey::RSA.new(File.read(File.expand_path('../../support/ssl/client_key.pem', __FILE__)))
+end

data/features/steps/{scopes_steps.rb → scope_steps.rb}

@@ -3,19 +3,6 @@ Given /^a header scope with headers$/ do |table|
   @scope = @connection.with_headers(headers)
 end
 
-When /^the client acks a message by ID "([^"]*)" and subscription "([^"]*)" within the scope$/ do |message_id, subscription|
-  @scope.ack message_id, subscription
-end
-
-When /^the client subscribes to "([^"]*)" with headers within the scope$/ do |dest, table|
-  @subscribe_frames ||= []
-  headers = table_to_headers table
-  @default_subscription_triggered = 0
-  @subscribe_frames << @scope.subscribe(dest, headers) do |m|
-    @default_subscription_triggered += 1
-  end
-end
-
 Given /^a transaction scope named "([^"]*)"$/ do |tx|
   @scope = @connection.with_transaction(:transaction => tx)
 end
@@ -24,9 +11,6 @@ When /^the client begins the transaction scope$/ do
   @scope.begin
 end
 
-When /^the client nacks a message by ID "([^"]*)" and subscription "([^"]*)" within the scope$/ do |message_id, subscription|
-  @scope.nack message_id, subscription
-end
 
 When /^the client aborts the transaction scope$/ do
   @scope.abort

data/features/steps/subscription_steps.rb

@@ -0,0 +1,80 @@
+When /^the client subscribes to "([^"]*)" with headers$/ do |dest, table|
+  @subscribe_frames ||= []
+  headers = table_to_headers table
+  @default_subscription_triggered = 0
+  @subscribe_frames << @connection.subscribe(dest, headers) do |m|
+    @default_subscription_triggered += 1
+  end
+end
+
+Then /^the default subscription callback should have been triggered( (\d+) times?)?$/ do |full, times|
+  if times.nil? || times.empty?
+    @default_subscription_triggered.should >= 1
+  else
+    @default_subscription_triggered.should == times.to_i
+  end
+end
+
+Then /^the default subscription callback should not have been triggered$/ do
+  @default_subscription_triggered.should == 0
+end
+
+When /^the client unsubscribes by ID$/ do
+  @connection.unsubscribe(@subscribe_frames.last[:id])
+end
+
+When /^the client unsubscribes by destination$/ do
+  @connection.unsubscribe(@subscribe_frames.last[:destination])
+end
+
+When /^the client unsubscribes by frame$/ do
+  @connection.unsubscribe(@subscribe_frames.last)
+end
+
+When /^the client unsubscribes from destination "([^"]*)"$/ do |destination|
+  @connection.unsubscribe(destination)
+end
+
+Given /^the client subscribes to (\/.*)$/ do |dest|
+  @messages_for_subscription ||= []
+  @connection.subscribe(dest) do |m|
+    sub = m[:subscription]
+    @messages_for_subscription << m
+  end
+end
+
+When /^the client sends a "([^"]*)" "([^"]*)" to (\/.*)$/ do |ct, body, dest|
+  @connection.send(dest, body, :'content-type' => ct)
+end
+
+Then /^the client should have received a "([^"]*)" message of "([^"]*)"$/ do |ct, body|
+  @messages_for_subscription.any? do |m|
+    m.content_type == ct && m.body == body
+  end.should be_true
+end
+
+When /^the client sends a "([^"]*)" encoded as "([^"]*)" to (\/.*)$/ do |body, enc, dest|
+  body.force_encoding(enc) if body.respond_to?(:force_encoding)
+  @connection.send(dest, body)
+end
+
+Then /^the client should have received a "([^"]*)" message of "([^"]*)" encoded as "([^"]*)"$/ do |ct, body, enc|
+  @messages_for_subscription.any? do |m|
+    ct_check = (m.content_type == ct || m.content_type.nil? && ct.empty?)
+    b_check = body == m.body
+    if body.respond_to?(:encoding)
+      ct_check && b_check && m.body.encoding.name == enc
+    else
+      ct_check && b_check
+    end
+  end.should be_true
+end
+
+When /^the client subscribes to "([^"]*)" with headers within the scope$/ do |dest, table|
+  @subscribe_frames ||= []
+  headers = table_to_headers table
+  @default_subscription_triggered = 0
+  @subscribe_frames << @scope.subscribe(dest, headers) do |m|
+    @default_subscription_triggered += 1
+  end
+end

data/lib/stomper/connection.rb

@@ -171,7 +171,7 @@ class Stomper::Connection
     @connecting = false
     @disconnecting = false
     @disconnected = false
-    @socket_mutex = ::Mutex.new
+    @close_mutex = ::Mutex.new
     
     on_connected do |cf, con|
       unless connected?
@@ -272,34 +272,32 @@ class Stomper::Connection
   # connection has been established and you're ready to go, otherwise the
   # socket will be closed and an error will be raised.
   def connect(headers={})
-    #@socket_mutex.synchronize do
-      unless @connected
-        @socket = @uri.create_socket(@ssl)
-        @serializer = ::Stomper::FrameSerializer.new(@socket)
-        m_headers = {
-          :'accept-version' => @versions.join(','),
-          :host => @host,
-          :'heart-beat' => @heartbeats.join(','),
-          :login => @login,
-          :passcode => @passcode
-        }
-        @disconnecting = false
-        @disconnected = false
-        @connecting = true
-        transmit create_frame('CONNECT', headers, m_headers)
-        receive.tap do |f|
-          if f.command == 'CONNECTED'
-            @connected_frame = f
-            @connected = true
-            @connecting = false
-            trigger_event(:on_connection_established, self)
-          else
-            close
-            raise ::Stomper::Errors::ConnectFailedError, 'broker did not send CONNECTED frame'
-          end
+    unless @connected
+      @socket = @uri.create_socket(@ssl)
+      @serializer = ::Stomper::FrameSerializer.new(@socket)
+      m_headers = {
+        :'accept-version' => @versions.join(','),
+        :host => @host,
+        :'heart-beat' => @heartbeats.join(','),
+        :login => @login,
+        :passcode => @passcode
+      }
+      @disconnecting = false
+      @disconnected = false
+      @connecting = true
+      transmit create_frame('CONNECT', headers, m_headers)
+      receive.tap do |f|
+        if f.command == 'CONNECTED'
+          @connected_frame = f
+          @connected = true
+          @connecting = false
+          trigger_event(:on_connection_established, self)
+        else
+          close
+          raise ::Stomper::Errors::ConnectFailedError, 'broker did not send CONNECTED frame'
         end
       end
-    #end
+    end
   end
   alias :open :connect
   
@@ -372,7 +370,7 @@ class Stomper::Connection
   # @param [true,false] fire_terminated (false) If true, trigger
   #   {Stomper::Extensions::Events#on_connection_terminated}
   def close
-    #@socket_mutex.synchronize do
+    @close_mutex.synchronize do
       if @connected
         begin
           trigger_event(:on_connection_terminated, self) unless @disconnected
@@ -384,8 +382,10 @@ class Stomper::Connection
           @connected = false
         end
         trigger_event(:on_connection_closed, self)
+        subscription_manager.clear
+        receipt_manager.clear
       end
-    #end
+    end
   end
   
   # Transmits a frame to the broker. This is a low-level method used internally

data/lib/stomper/receipt_manager.rb

@@ -27,6 +27,11 @@ class Stomper::ReceiptManager
     self
   end
   
+  # Remove all receipt handlers.
+  def clear
+    @mon.synchronize { @callbacks.clear }
+  end
+  
   private
   def dispatch(receipt)
     cb = @mon.synchronize { @callbacks.delete(receipt[:'receipt-id']) }

data/lib/stomper/subscription_manager.rb

@@ -9,7 +9,6 @@ class Stomper::SubscriptionManager
     @subscriptions = {}
     connection.on_message { |m, con| dispatch(m) }
     connection.on_unsubscribe { |u, con| remove(u[:id]) }
-    connection.on_connection_closed { |con| @subscriptions.clear }
   end
   
   # Adds a callback handler for a MESSAGE frame that is sent via the subscription
@@ -46,12 +45,18 @@ class Stomper::SubscriptionManager
     end
   end
   
-  # Returns all current subscriptions in the form of their SUBSCRIBE frames.
-  # @return [Array<Stomper::Frame>]
+  # Returns all current subscriptions.
+  # @return [Array<Stomper::SubscriptionManager::Subscription>]
   def subscriptions
     @mon.synchronize { @subscriptions.values }
   end
   
+  # Remove all subscriptions. This method does not send UNSUBSCRIBE frames
+  # to the broker.
+  def clear
+    @mon.synchronize { @subscriptions.clear }
+  end
+  
   private
   def dispatch(message)
     s_id = message[:subscription]

data/lib/stomper/version.rb

@@ -3,5 +3,5 @@
 # Primary namespace of the stomper gem.
 module Stomper
   # The current version of the stomper gem.
-  VERSION = '2.0.1'
+  VERSION = '2.0.2'
 end

data/spec/stomper/connection_spec.rb

@@ -218,6 +218,22 @@ module Stomper
         @connection.connected?.should be_false
       end
       
+      it "should clear subscriptions on close" do
+        @serializer.should_receive(:read_frame).at_least(:once).and_return(@connected_frame)
+        @serializer.should_receive(:write_frame).with(stomper_frame_with_headers({}, 'CONNECT')).once.and_return { |f| f }
+        @connection.connect
+        @connection.subscription_manager.should_receive(:clear)
+        @connection.close
+      end
+      
+      it "should clear receipt handlers on close" do
+        @serializer.should_receive(:read_frame).at_least(:once).and_return(@connected_frame)
+        @serializer.should_receive(:write_frame).with(stomper_frame_with_headers({}, 'CONNECT')).once.and_return { |f| f }
+        @connection.connect
+        @connection.receipt_manager.should_receive(:clear)
+        @connection.close
+      end
+      
       describe "frame reading" do
         before(:each) do
           @serializer.should_receive(:read_frame).at_least(:once).and_return(@connected_frame)
@@ -394,7 +410,6 @@ module Stomper
           lambda { @connection.receive }.should raise_error(SystemCallError)
           triggered.should be_true
         end
-        
       end
       
       describe "frame events" do