onstomp 1.0.6 → 1.0.7

data/.gitignore

@@ -3,7 +3,6 @@ pkg/*
 *.gem
 .bundle
 .yardoc
-nbproject
 doc
 coverage
 turbulence
@@ -11,4 +10,5 @@ Gemfile.lock
 *~
 *.swp
 tags
+other
 

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changes
 
+## 1.0.7
+* rescue any exceptions in event callbacks, uses Kernel#warn to notify the
+  user of the exception
+* force OnStomp::Failover::Client to wait until the re-connect thread is up
+  and running before initialize returns
+* force OnStomp::Connections::Base to raise exceptions that occur while trying
+  to read the initial CONNECTED frame from the broker. prior to this, the
+  call to Base#connect would hang indefinitely if the connection to the broker
+  was lost before the CONNECTED frame was received (or if the broker simply did
+  not respond with any frame at all.)
+
+## 1.0.6
+* fix a typo on the `connection` attribute in the ReceiptScope
+
 ## 1.0.5
 * fixed a race condition that would occur if a user (or the failover extension)
   tried to re-connect an OnStomp::Client instance within an `on_connection_closed`

data/lib/onstomp/connections/base.rb

@@ -5,7 +5,7 @@ class OnStomp::Connections::Base
   include OnStomp::Interfaces::ConnectionEvents
   attr_reader :version, :socket, :client
   attr_reader :last_transmitted_at, :last_received_at
-  attr_accessor :write_timeout, :read_timeout
+  attr_reader :write_timeout, :read_timeout
   
   # The approximate maximum number of bytes to write per call to
   # {#io_process_write}.
@@ -27,10 +27,36 @@ class OnStomp::Connections::Base
     @read_buffer = []
     @client = client
     @connection_up = false
-    @write_timeout = nil
-    @read_timeout  = nil
+    self.read_timeout = 120
+    self.write_timeout = nil
     setup_non_blocking_methods
   end
+
+  # Sets the read timeout when connecting to the specified number of seconds.
+  # If set to nil, no read timeout checking will be performed.
+  # @param [Number] secs
+  def read_timeout= secs
+    if secs
+      @read_timeout = secs
+      @read_timeout_ms = secs * 1000
+    else
+      @read_timeout = @read_timeout_ms = nil
+    end
+  end
+
+  # Sets the maximum number of seconds to wait between IO writes before
+  # declaring the connection blocked. This timeout is ignored if there is no
+  # data waiting to be written. If set to `nil`, connection write timeout
+  # checking will be performed.
+  # @param [Number, nil] secs
+  def write_timeout= secs
+    if secs
+      @write_timeout = secs
+      @write_timeout_ms = secs * 1000
+    else
+      @write_timeout = @write_timeout_ms = nil
+    end
+  end
   
   # Performs any necessary configuration of the connection from the CONNECTED
   # frame sent by the broker and a `Hash` of pending callbacks. This method
@@ -70,12 +96,14 @@ class OnStomp::Connections::Base
   # @param [OnStomp::Client] client
   # @param [Array<Hash>] headers
   def connect client, *headers
+    # I really don't care for this. A core part of the CONNECT/CONNECTED
+    # exchange can only be accomplished through subclasses.
     write_frame_nonblock connect_frame(*headers)
     client_con = nil
     until client_con
       io_process_write { |f| client_con ||= f }
     end
-    @last_received_at = Time.now
+    update_last_received
     broker_con = nil
     until broker_con
       io_process_read(true) { |f| broker_con ||= f }
@@ -102,14 +130,14 @@ class OnStomp::Connections::Base
   # `nil` if no data has been transmitted when the method is called.
   # @return [Fixnum, nil]
   def duration_since_transmitted
-    last_transmitted_at && ((Time.now - last_transmitted_at)*1000).to_i
+    last_transmitted_at && ((Time.now.to_f - last_transmitted_at) * 1000)
   end
   
   # Number of milliseconds since data was last received from the broker or
   # `nil` if no data has been received when the method is called.
   # @return [Fixnum, nil]
   def duration_since_received
-    last_received_at && ((Time.now - last_received_at)*1000).to_i
+    last_received_at && ((Time.now.to_f - last_received_at) * 1000)
   end
   
   # Flushes the write buffer by invoking {#io_process_write} until the
@@ -141,7 +169,7 @@ class OnStomp::Connections::Base
   # @param [OnStomp::Components::Frame]
   def push_write_buffer data, frame
     @write_mutex.synchronize {
-      @last_write_activity = Time.now if @write_buffer.empty?
+      update_last_write_activity if @write_buffer.empty?
       @write_buffer << [data, frame] unless @closing
     }
   end
@@ -184,7 +212,8 @@ class OnStomp::Connections::Base
           raise
         end
         written += w
-        @last_write_activity = @last_transmitted_at = Time.now
+        update_last_write_activity
+        update_last_transmitted
         if w < data.length
           unshift_write_buffer data[w..-1], frame
         else
@@ -204,12 +233,12 @@ class OnStomp::Connections::Base
   # and the socket is ready for reading.  The received data will be pushed
   # to the end of a read buffer, which is then sent to the connection's
   # {OnStomp::Connections::Serializers serializer} for processing.
-  def io_process_read(check_timeout=false)
+  def io_process_read(connecting=false)
     if ready_for_read?
       begin
         if data = read_nonblock
           @read_buffer << data
-          @last_received_at = Time.now
+          update_last_received
           serializer.bytes_to_frame(@read_buffer) do |frame|
             yield frame if block_given?
             client.dispatch_received frame
@@ -219,6 +248,7 @@ class OnStomp::Connections::Base
         # do not
       rescue EOFError
         triggered_close $!.message
+        raise if connecting
       rescue Exception
         # TODO: Fix this potential race condition the right way.
         # This is the problematic area!  If the user (or failover library)
@@ -230,14 +260,28 @@ class OnStomp::Connections::Base
         triggered_close $!.message, :terminated
         raise
       end
-    elsif check_timeout && read_timeout_exceeded?
+    end
+    if connecting && read_timeout_exceeded?
       triggered_close 'read blocked', :blocked
+      raise OnStomp::ConnectionTimeoutError
     end
   end
   
   private
+  def update_last_received
+    @last_received_at = Time.now.to_f
+  end
+
+  def update_last_write_activity
+    @last_write_activity = Time.now.to_f
+  end
+
+  def update_last_transmitted
+    @last_transmitted_at = Time.now.to_f
+  end
+
   def duration_since_write_activity
-    Time.now - @last_write_activity
+    (Time.now.to_f - @last_write_activity) * 1000
   end
   
   # Returns true if the connection has buffered data to write and the
@@ -270,8 +314,8 @@ class OnStomp::Connections::Base
   # data to write, and `duration_since_transmitted` is greater than
   # `write_timeout`
   def write_timeout_exceeded?
-    @write_timeout && @write_buffer.length > 0 &&
-      duration_since_write_activity > @write_timeout
+    @write_timeout_ms && @write_buffer.length > 0 &&
+      duration_since_write_activity > @write_timeout_ms
   end
   
   # Returns true if a `read_timeout` has been set and
@@ -279,16 +323,12 @@ class OnStomp::Connections::Base
   # This is only used when establishing the connection through the CONNECT/
   # CONNECTED handshake.  After that, it is up to heart-beating.
   def read_timeout_exceeded?
-    @read_timeout && duration_since_received > (@read_timeout*1000)
+    @read_timeout_ms && duration_since_received > @read_timeout_ms
   end
   
   def triggered_close msg, *evs
     @connection_up = false
     @closing = false
-    # unless socket.closed?
-    #   socket.to_io.shutdown(2) rescue nil
-    #   
-    # end
     socket.close rescue nil
     evs.each { |ev| trigger_connection_event ev, msg }
     trigger_connection_event :closed, msg

data/lib/onstomp/failover/client.rb

@@ -50,14 +50,17 @@ class OnStomp::Failover::Client
     @connection = nil
     @frame_buffer = buffer.new self
     @disconnecting = false
+    retry_ready = false
     @retry_thread = Thread.new do
       until @disconnecting
+        retry_ready = true
         Thread.stop
         @client_mutex.synchronize {
           reconnect unless @disconnecting
         }
       end
     end
+    Thread.pass until retry_ready && @retry_thread.stop?
   end
   
   # Returns true if there is an {#active_client} and it is

data/lib/onstomp/interfaces/event_manager.rb

@@ -27,7 +27,13 @@ module OnStomp::Interfaces::EventManager
   # @param [Symbol] event_name event to trigger
   # @param [Object, Object, ...] args
   def trigger_event(event_name, *args)
-    event_callbacks[event_name].each { |cb| cb.call(*args) }
+    event_callbacks[event_name].each do |cb|
+      begin
+        cb.call(*args)
+      rescue Exception => ex
+        warn "[OnStomp/Event] triggering #{event_name} raised an error: #{ex}"
+      end
+    end
   end
   
   # Mixin to allow includers to define custom event methods

data/lib/onstomp/version.rb

@@ -7,7 +7,7 @@ module OnStomp
   # Minor / feature version
   MINOR = 0
   # Patch version
-  PATCH = 6
+  PATCH = 7
   # Complete version
   VERSION = "#{MAJOR}.#{MINOR}.#{PATCH}"
 end

data/lib/onstomp.rb

@@ -74,6 +74,9 @@ module OnStomp
   # Raised when an attempt to connect to the broker results in an unexpected
   # exchange.
   class ConnectFailedError < FatalConnectionError; end
+
+  # Raised when the connection between client and broker times out.
+  class ConnectionTimeoutError < FatalConnectionError; end
   
   # Raised if the command issued is not supported by the protocol version
   # negotiated between the client and broker.

data/spec/onstomp/connections/base_spec.rb

@@ -19,6 +19,16 @@ module OnStomp::Connections
     let(:frame) {
       mock('frame')
     }
+
+    describe "timeouts" do
+      it "defaults write timeout to nil" do
+        connection.write_timeout.should be_nil
+      end
+
+      it "defaults read timeout to 120 seconds" do
+        connection.read_timeout.should == 120
+      end
+    end
     
     describe ".method_missing" do
       it "should raise an unsupported command error if the method ends in _frame" do
@@ -47,7 +57,8 @@ module OnStomp::Connections
       it "should be the difference between now and the last_transmitted_at in milliseconds" do
         Time.stub(:now => 10)
         connection.stub(:last_transmitted_at => 8.5)
-        connection.duration_since_transmitted.should == 1500
+        # Be careful, floating point will give you problems
+        connection.duration_since_transmitted.should == 1500.0
       end
     end
     
@@ -59,7 +70,7 @@ module OnStomp::Connections
       it "should be the difference between now and the last_received_at in milliseconds" do
         Time.stub(:now => 10)
         connection.stub(:last_received_at => 6)
-        connection.duration_since_received.should == 4000
+        connection.duration_since_received.should == 4000.0
       end
     end
     
@@ -280,7 +291,14 @@ module OnStomp::Connections
         io.should_receive(:read_nonblock).with(Base::MAX_BYTES_PER_READ).and_raise(Errno::EWOULDBLOCK)
         lambda { connection.io_process_read }.should_not raise_error
       end
-      it "should close the connection and not raise error if an EOFError is raised?" do
+      it "closes the connection and re-raises EOFError when connecting" do
+        connection.stub(:connected? => true)
+        IO.stub(:select => true)
+        io.should_receive(:read_nonblock).with(Base::MAX_BYTES_PER_READ).and_raise(EOFError)
+        io.should_receive(:close)
+        lambda { connection.io_process_read(true) }.should raise_error(EOFError)
+      end
+      it "closes the connection without re-raising EOFError when not connecting" do
         connection.stub(:connected? => true)
         IO.stub(:select => true)
         io.should_receive(:read_nonblock).with(Base::MAX_BYTES_PER_READ).and_raise(EOFError)
@@ -311,13 +329,17 @@ module OnStomp::Connections
         lambda { connection.io_process_read }.should raise_error(Exception)
         triggered.should be_true
       end
-      it "should trigger a blocked close if checking timeout and it is exceeded" do
+      it "triggers a blocked close and raises ConnectionTimeoutError when connecting" do
         triggered = false
         connection.on_blocked { triggered = true }
+        connection.read_timeout = 0.5
         IO.stub(:select => false)
-        connection.stub(:read_timeout_exceeded? => true, :connected? => true)
+        connection.stub(:connected? => true)
         io.should_receive(:close)
-        connection.io_process_read(true)
+        connection.__send__(:update_last_received)
+        lambda do
+          connection.io_process_read(true) while true
+        end.should raise_error(OnStomp::ConnectionTimeoutError)
         triggered.should be_true
       end
     end
@@ -354,17 +376,17 @@ module OnStomp::Connections
       end
       it "should not exceed the timeout if duration is less than timeout" do
         connection.read_timeout = 10
-        connection.stub(:duration_since_received => 9000)
+        connection.stub(:duration_since_received => 9000.0)
         connection.__send__(:read_timeout_exceeded?).should be_false
       end
       it "should not exceed the timeout if duration is equal to timeout" do
         connection.read_timeout = 10
-        connection.stub(:duration_since_received => 10000)
+        connection.stub(:duration_since_received => 10000.0)
         connection.__send__(:read_timeout_exceeded?).should be_false
       end
       it "should exceed the timeout if duration is greater than timeout" do
         connection.read_timeout = 10
-        connection.stub(:duration_since_received => 10001)
+        connection.stub(:duration_since_received => 10000.1)
         connection.__send__(:read_timeout_exceeded?).should be_true
       end
     end
@@ -413,9 +435,9 @@ module OnStomp::Connections
         Time.stub(:now => 69)
         connection.__send__(:write_timeout_exceeded?).should be_false
       end
-      it "should not exceed the timeout if the duratio is greater but there's no buffered data" do
+      it "should not exceed the timeout if the duration is greater but there's no buffered data" do
         connection.write_timeout = 1
-        connection.stub(:duration_since_transmitted => 5000)
+        connection.stub(:duration_since_transmitted => 5000.0)
         connection.__send__(:write_timeout_exceeded?).should be_false
       end
       it "should exceed the timeout if buffered and duration is greater than timeout" do
@@ -488,6 +510,30 @@ module OnStomp::Connections
         connection.io_process
         triggered.should == 1
       end
+
+      it "re-raises an error raised while writing during connect" do
+        io.stub(:closed? => false)
+        connection.stub(:connect_frame => connect_frame)
+        connection.stub(:serializer => OnStomp::Connections::Serializers::Stomp_1_0.new)
+        connection.stub(:ready_for_write? => true)
+        connection.stub(:write_nonblock) { raise EOFError }
+        connection.stub(:io_process_read).with(true).and_yield(connected_frame)
+        lambda do
+          connection.connect(client)
+        end.should raise_error(EOFError)
+      end
+
+      it "re-raises an EOFError raised while reading during connect" do
+        io.stub(:closed? => false)
+        connection.stub(:connect_frame => connect_frame)
+        connection.stub(:serializer => OnStomp::Connections::Serializers::Stomp_1_0.new)
+        connection.stub(:ready_for_read? => true)
+        connection.stub(:read_nonblock) { raise EOFError }
+        connection.stub(:io_process_write).and_yield(connect_frame)
+        lambda do
+          connection.connect(client)
+        end.should raise_error(EOFError)
+      end
     end
     
     describe ".configure" do

data/spec/onstomp/full_stacks/onstomp_spec.rb

@@ -10,6 +10,59 @@ describe OnStomp::Client, "full stack test (stomp+ssl:)", :fullstack => true do
       body
     end
   end
+
+  describe "Failing on connect" do
+    let(:broker) {
+      TestBroker.new 10101
+    }
+    before :each do
+      broker.start
+    end
+    after :each do
+      broker.stop
+    end
+
+    it "raises an error when the TCP/IP connection is refused" do
+      broker.stop
+      client = OnStomp::Client.new('stomp://localhost:10101')
+      lambda do
+        client.connect
+      end.should raise_error
+    end
+
+    it "raises an error if the connection is closed while writing the CONNECT frame" do
+      broker.session_class = TestBroker::SessionCloseBeforeConnect
+      client = OnStomp::Client.new('stomp://localhost:10101')
+      lambda do
+        client.connect
+      end.should raise_error
+    end
+
+    it "raises an error if the connection is closed while waiting for the CONNECTED frame" do
+      broker.session_class = TestBroker::SessionCloseAfterConnect
+      client = OnStomp::Client.new('stomp://localhost:10101')
+      lambda do
+        client.connect
+      end.should raise_error
+    end
+
+    it "raises an error if the connection times out before receiving a CONNECTED frame" do
+      broker.session_class = TestBroker::SessionTimeoutAfterConnect
+      client = OnStomp::Client.new('stomp://localhost:10101')
+      client.read_timeout = 1
+      lambda do
+        client.connect
+      end.should raise_error(OnStomp::ConnectionTimeoutError)
+    end
+
+    it "raises an error if the broker does not respond with CONNECTED" do
+      broker.session_class = TestBroker::SessionBadFrameAfterConnect
+      client = OnStomp::Client.new('stomp://localhost:10101')
+      lambda do
+        client.connect
+      end.should raise_error(OnStomp::ConnectFailedError)
+    end
+  end
   
   describe "STOMP 1.0" do
     let(:broker) {

data/spec/onstomp/full_stacks/{onstomp_ssh_spec.rb → onstomp_ssl_spec.rb}

@@ -44,7 +44,7 @@ describe OnStomp::Client, "full stack test (stomp+ssl:)", :fullstack => true do
         })
         lambda {
           client.connect
-        }.should raise_error('hostname was not match with the server certificate')
+        }.should raise_error #('hostname was not match with the server certificate')
       end
     end
   end
@@ -83,7 +83,7 @@ describe OnStomp::Client, "full stack test (stomp+ssl:)", :fullstack => true do
         })
         lambda {
           client.connect
-        }.should raise_error('hostname was not match with the server certificate')
+        }.should raise_error #('hostname was not match with the server certificate')
       end
     end
   end

data/spec/onstomp/full_stacks/test_broker.rb

@@ -243,6 +243,62 @@ class TestBroker
     end
   end
   
+  class SessionCloseBeforeConnect
+    def initialize server, sock
+      sock.close rescue nil
+    end
+  end
+
+  class SessionCloseAfterConnect < Session10
+    def initialize server, sock
+      @server = server
+      @socket = sock
+      init_events
+      init_connection
+      connect_frame = nil
+      @connection.io_process_read do |f|
+        connect_frame ||= f
+      end until connect_frame
+      @socket.close
+    end
+  end
+
+  class SessionTimeoutAfterConnect < Session10
+    def initialize server, sock
+      @server = server
+      @socket = sock
+      init_events
+      init_connection
+      connect_frame = nil
+      @connection.io_process_read do |f|
+        connect_frame ||= f
+      end until connect_frame
+      # Do not send a frame, do not close the connection, let it timeout
+    end
+  end
+
+  class SessionBadFrameAfterConnect < Session10
+    def initialize server, sock
+      @server = server
+      @socket = sock
+      init_events
+      init_connection
+      connect_frame = nil
+      @connection.io_process_read do |f|
+        connect_frame ||= f
+      end until connect_frame
+      reply_to_connect_with_crap
+    end
+
+    def reply_to_connect_with_crap
+      connected_frame = nil
+      transmit OnStomp::Components::Frame.new('CRAPPY_FRAME')
+      @connection.io_process_write do |f|
+        connected_frame ||= f
+      end until connected_frame
+    end
+  end
+
   class StompErrorOnConnectSession < Session10
   end
 end

data/spec/onstomp/interfaces/event_manager_spec.rb

@@ -17,6 +17,17 @@ module OnStomp::Interfaces
         triggered.should == [3, 'test']
       end
     end
+
+    describe "callbacks with exceptions" do
+      it "does not allow exceptions to break the callback chain" do
+        triggered = [false, false]
+        eventable.bind_event(:an_event, lambda { |*_| raise "failed" })
+        eventable.bind_event(:an_event, lambda { |x,y| triggered[0] = y; raise "failed again" })
+        eventable.bind_event(:an_event, lambda { |x,y| triggered[1] = x })
+        eventable.trigger_event :an_event, 4, 10
+        triggered.should == [10, 4]
+      end
+    end
     
     describe ".event_callbacks" do
       it "should provide an empty array for an unbound event" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: onstomp
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 1.0.7
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-21 00:00:00.000000000Z
+date: 2012-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2153282120 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,15 @@ dependencies:
         version: 2.4.0
   type: :development
   prerelease: false
-  version_requirements: *2153282120
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.4.0
 - !ruby/object:Gem::Dependency
   name: simplecov
-  requirement: &2153281520 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +37,15 @@ dependencies:
         version: 0.3.0
   type: :development
   prerelease: false
-  version_requirements: *2153281520
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.0
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &2153280580 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +53,15 @@ dependencies:
         version: 0.6.0
   type: :development
   prerelease: false
-  version_requirements: *2153280580
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.6.0
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &2153280180 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,7 +69,12 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2153280180
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Client library for message passing with brokers that support the Stomp
   protocol.
 email:
@@ -157,7 +177,7 @@ files:
 - spec/onstomp/failover/uri_spec.rb
 - spec/onstomp/full_stacks/failover_spec.rb
 - spec/onstomp/full_stacks/onstomp_spec.rb
-- spec/onstomp/full_stacks/onstomp_ssh_spec.rb
+- spec/onstomp/full_stacks/onstomp_ssl_spec.rb
 - spec/onstomp/full_stacks/open-uri_spec.rb
 - spec/onstomp/full_stacks/ssl/README
 - spec/onstomp/full_stacks/ssl/broker_cert.csr
@@ -212,7 +232,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: onstomp-core
-rubygems_version: 1.8.12
+rubygems_version: 1.8.21
 signing_key: 
 specification_version: 3
 summary: Client for message queues implementing the Stomp protocol interface.
@@ -246,7 +266,7 @@ test_files:
 - spec/onstomp/failover/uri_spec.rb
 - spec/onstomp/full_stacks/failover_spec.rb
 - spec/onstomp/full_stacks/onstomp_spec.rb
-- spec/onstomp/full_stacks/onstomp_ssh_spec.rb
+- spec/onstomp/full_stacks/onstomp_ssl_spec.rb
 - spec/onstomp/full_stacks/open-uri_spec.rb
 - spec/onstomp/full_stacks/ssl/README
 - spec/onstomp/full_stacks/ssl/broker_cert.csr