onstomp 1.0.3 → 1.0.4

data/.rspec

@@ -1,2 +1,2 @@
 --colour
---format d
+--format p

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changes
 
+## 1.0.4
+* fixed major oversight when using ruby 1.8.7 / jruby with an SSL connection.
+  it will use blocking read/write methods if nonblocking methods are unavailable
+* added write and read block timeouts. if there is no write activity for a period
+  of time (default of 120 seconds), the connection is assumed to be dead. read
+  activity is handled similarly, but only when performing the CONNECT/CONNECTED
+  exchange, after that we have no way of knowing if the broker just doesn't
+  have any data for us (unless using a STOMP 1.1 connection with heartbeating)
+* refactored common failover buffer code into lib/onstomp/failover/buffers/base
+
 ## 1.0.3
 * change how failover spawns new connections when failing over.
 

data/Gemfile

@@ -3,7 +3,11 @@ source "http://rubygems.org"
 # Specify your gem's dependencies in onstomp.gemspec
 gemspec
 
-group :development do
+group :docs do
   gem 'rdiscount'
   gem 'erubis'
 end
+
+platform :jruby do
+  gem 'jruby-openssl'
+end

data/lib/onstomp/client.rb

@@ -47,6 +47,17 @@ class OnStomp::Client
   # @return [Class]
   attr_configurable_processor :processor
   
+  # The number of seconds to wait before a write-blocked connection is
+  # considered dead. Defaults to 120 seconds.
+  # @return [Fixnum]
+  attr_configurable_int :write_timeout, :default => 120
+  
+  # The number of seconds to wait before a connection that is read-blocked
+  # during the {OnStomp::Connections::Base#connect connect} phase is
+  # considered dead. Defaults to 120 seconds.
+  # @return [Fixnum]
+  attr_configurable_int :read_timeout, :default => 120
+  
   # @api gem:1 STOMP:1.0,1.1
   # Creates a new client for the specified uri and optional hash of options.
   # @param [String,URI] uri
@@ -71,7 +82,8 @@ class OnStomp::Client
     @connection = OnStomp::Connections.connect self, headers,
       { :'accept-version' => @versions.join(','), :host => @host,
         :'heart-beat' => @heartbeats.join(','), :login => @login,
-        :passcode => @passcode }, pending_connection_events
+        :passcode => @passcode }, pending_connection_events,
+      read_timeout, write_timeout
     processor_inst.start
     self
   end

data/lib/onstomp/connections.rb

@@ -44,8 +44,8 @@ module OnStomp::Connections
   #   negotiated protocol version
   # @raise [OnStomp::OnStompError] if negotiating the connection raises an
   #   such an error.
-  def self.connect client, u_head, c_head, con_cbs
-    init_con = create_connection('1.0', nil, client)
+  def self.connect client, u_head, c_head, con_cbs, r_time, w_time
+    init_con = create_connection('1.0', nil, client, r_time, w_time)
     ver, connected = init_con.connect client, u_head, c_head
     begin
       negotiate_connection(ver, init_con, client).tap do |final_con|
@@ -61,21 +61,25 @@ module OnStomp::Connections
   private
   def self.negotiate_connection vers, con, client
     supports_protocol?(vers,con) ? con :
-      create_connection(vers, con.socket, client)
+      create_connection(vers, con.socket, client, con.read_timeout,
+        con.write_timeout)
   end
   
   def self.supports_protocol? ver, con
     con.is_a? PROTOCOL_VERSIONS[ver]
   end
   
-  def self.create_connection ver, sock, client
+  def self.create_connection ver, sock, client, rt, wt
     unless sock
       meth = client.ssl ? :ssl :
         client.uri.respond_to?(:onstomp_socket_type) ?
           client.uri.onstomp_socket_type : :tcp
       sock = __send__(:"create_socket_#{meth}", client)
     end
-    PROTOCOL_VERSIONS[ver].new sock, client
+    PROTOCOL_VERSIONS[ver].new(sock, client).tap do |con|
+      con.read_timeout = rt
+      con.write_timeout = wt
+    end
   end
   
   def self.create_socket_tcp client

data/lib/onstomp/connections/base.rb

@@ -5,6 +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
   
   # The approximate maximum number of bytes to write per call to
   # {#io_process_write}.
@@ -26,6 +27,9 @@ class OnStomp::Connections::Base
     @read_buffer = []
     @client = client
     @connection_up = false
+    @write_timeout = nil
+    @read_timeout  = nil
+    setup_non_blocking_methods
   end
   
   # Performs any necessary configuration of the connection from the CONNECTED
@@ -71,9 +75,10 @@ class OnStomp::Connections::Base
     until client_con
       io_process_write { |f| client_con ||= f }
     end
+    @last_received_at = Time.now
     broker_con = nil
     until broker_con
-      io_process_read { |f| broker_con ||= f }
+      io_process_read(true) { |f| broker_con ||= f }
     end
     raise OnStomp::ConnectFailedError if broker_con.command != 'CONNECTED'
     vers = broker_con.header?(:version) ? broker_con[:version] : '1.0'
@@ -93,6 +98,20 @@ class OnStomp::Connections::Base
     end
   end
   
+  # Number of milliseconds since data was last transmitted to the broker or
+  # `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
+  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
+  end
+  
   # Flushes the write buffer by invoking {#io_process_write} until the
   # buffer is empty.
   def flush_write_buffer
@@ -122,6 +141,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?
       @write_buffer << [data, frame] unless @closing
     }
   end
@@ -146,34 +166,34 @@ class OnStomp::Connections::Base
   # sent to the head of the write buffer to be processed first the next time
   # this method is invoked.
   def io_process_write
-    begin
-      if @write_buffer.length > 0 && IO.select(nil, [socket], nil, 0.1)
-        to_shift = @write_buffer.length / 3
-        written = 0
-        while written < MAX_BYTES_PER_WRITE
-          data, frame = shift_write_buffer
-          break unless data && connected?
-          begin
-            w = socket.write_nonblock(data)
-          rescue Errno::EINTR, Errno::EAGAIN, Errno::EWOULDBLOCK
-            # writing will either block, or cannot otherwise be completed,
-            # put data back and try again some other day
-            unshift_write_buffer data, frame
-            break
-          end
-          written += w
-          @last_transmitted_at = Time.now
-          if w < data.length
-            unshift_write_buffer data[w..-1], frame
-          else
-            yield frame if block_given?
-            client.dispatch_transmitted frame
-          end
+    if ready_for_write?
+      to_shift = @write_buffer.length / 3
+      written = 0
+      while written < MAX_BYTES_PER_WRITE
+        data, frame = shift_write_buffer
+        break unless data && connected?
+        begin
+          w = write_nonblock data
+        rescue Errno::EINTR, Errno::EAGAIN, Errno::EWOULDBLOCK
+          # writing will either block, or cannot otherwise be completed,
+          # put data back and try again some other day
+          unshift_write_buffer data, frame
+          break
+        rescue Exception
+          triggered_close $!.message, :terminated
+          raise
+        end
+        written += w
+        @last_write_activity = @last_transmitted_at = Time.now
+        if w < data.length
+          unshift_write_buffer data[w..-1], frame
+        else
+          yield frame if block_given?
+          client.dispatch_transmitted frame
         end
       end
-    rescue Exception
-      triggered_close $!.message, :terminated
-      raise
+    elsif write_timeout_exceeded?
+      triggered_close 'write blocked', :blocked
     end
     if @write_buffer.empty? && @closing
       triggered_close 'client disconnected'
@@ -184,37 +204,123 @@ 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
-    begin
-      if connected? && IO.select([socket], nil, nil, 0.1)
-        if data = socket.read_nonblock(MAX_BYTES_PER_READ)
+  def io_process_read(check_timeout=false)
+    if ready_for_read?
+      begin
+        if data = read_nonblock
           @read_buffer << data
           @last_received_at = Time.now
           serializer.bytes_to_frame(@read_buffer) do |frame|
             yield frame if block_given?
             client.dispatch_received frame
           end
-        else
-          triggered_close $!.message, :terminated
         end
+      rescue Errno::EINTR, Errno::EAGAIN, Errno::EWOULDBLOCK
+        # do not
+      rescue EOFError
+        triggered_close $!.message
+      rescue Exception
+        triggered_close $!.message, :terminated
+        raise
       end
-    rescue Errno::EINTR, Errno::EAGAIN, Errno::EWOULDBLOCK
-      # do not
-    rescue EOFError
-      triggered_close $!.message
+    elsif check_timeout && read_timeout_exceeded?
+      triggered_close 'read blocked', :blocked
+    end
+  end
+  
+  private
+  def duration_since_write_activity
+    Time.now - @last_write_activity
+  end
+  
+  # Returns true if the connection has buffered data to write and the
+  # socket is ready to be written to. If checking the socket's state raises
+  # an exception, the connection will be closed (triggering an
+  # `on_terminated` event) and the error will be re-raised.
+  def ready_for_write?
+    begin
+      @write_buffer.length > 0 && IO.select(nil, [socket], nil, 0.1)
     rescue Exception
       triggered_close $!.message, :terminated
       raise
     end
   end
   
-  private
+  # Returns true if the connection has buffered data to write and the
+  # socket is ready to be written to. If checking the socket's state raises
+  # an exception, the connection will be closed (triggering an
+  # `on_terminated` event) and the error will be re-raised.
+  def ready_for_read?
+    begin
+      connected? && IO.select([socket], nil, nil, 0.1)
+    rescue Exception
+      triggered_close $!.message, :terminated
+      raise
+    end
+  end
+  
+  # Returns true if a `write_timeout` has been set, the connection has buffered
+  # 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
+  end
+  
+  # Returns true if a `read_timeout` has been set and
+  # `duration_since_received` is greater than `read_timeout`
+  # 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)
+  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
     @write_buffer.clear
   end
+  
+  # OpenSSL sockets in Ruby 1.8.7 and JRuby (as of jruby-openssl 0.7.3)
+  # do NOT support non-blocking IO natively. Such a hack, and such a huge
+  # oversight on my part. We define some methods on this instance to use
+  # the right read/write operations. Fortunately, this gets done at
+  # initialization and only has to happen once.
+  def setup_non_blocking_methods
+    read_mod = @socket.respond_to?(:read_nonblock) ? NonblockingRead :
+      BlockingRead
+    write_mod = @socket.respond_to?(:write_nonblock) ? NonblockingWrite :
+      BlockingWrite
+    self.extend read_mod
+    self.extend write_mod
+  end
+
+  module NonblockingRead
+    def read_nonblock
+      socket.read_nonblock MAX_BYTES_PER_READ
+    end
+  end
+  module NonblockingWrite
+    def write_nonblock data
+      socket.write_nonblock data
+    end
+  end
+  
+  module BlockingRead
+    def read_nonblock
+      socket.readpartial MAX_BYTES_PER_READ
+    end
+  end
+  module BlockingWrite
+    def write_nonblock data
+      socket.write data
+    end
+  end
 end

data/lib/onstomp/connections/heartbeating.rb

@@ -51,20 +51,6 @@ module OnStomp::Connections::Heartbeating
     end
     @heartbeat_broker_limit
   end
-  
-  # Number of milliseconds since data was last transmitted to the broker or
-  # `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
-  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
-  end
 
   # Returns true if client-side heartbeating is disabled, or 
   # {#duration_since_transmitted} has not exceeded {#heartbeat_client_limit}

data/lib/onstomp/failover/buffers.rb

@@ -5,5 +5,6 @@
 module OnStomp::Failover::Buffers
 end
 
+require 'onstomp/failover/buffers/base'
 require 'onstomp/failover/buffers/written'
 require 'onstomp/failover/buffers/receipts'

data/lib/onstomp/failover/buffers/base.rb

@@ -0,0 +1,59 @@
+# -*- encoding: utf-8 -*-
+
+# The base class for all buffers. This class exists mostly as a factoring
+# out of the code shared between the {OnStomp::Failover::Buffers::Written}
+# and {OnStomp::Failover::Buffers::Receipts} buffers.
+class OnStomp::Failover::Buffers::Base
+  def initialize failover
+    @failover = failover
+    @buffer_mutex = Mutex.new
+    @buffer = []
+    @txs = {}
+  end
+  
+  # Returns the number of frames currently sitting in the buffer.
+  # @return [Fixnum]
+  def buffered
+    @buffer.length
+  end
+  
+  private
+  def add_to_buffer f, heads={}
+    @buffer_mutex.synchronize do
+      unless f.header? :'x-onstomp-failover-replay'
+        f.headers.reverse_merge! heads        
+        @buffer << f 
+      end
+    end
+  end
+  
+  def add_to_transactions f, heads={}
+    @txs[f[:transaction]] = true
+    add_to_buffer f, heads
+  end
+  
+  def remove_from_transactions f
+    tx = f[:transaction]
+    if @txs.delete tx
+      @buffer_mutex.synchronize do
+        @buffer.reject! { |bf| bf[:transaction] == tx }
+      end
+    end
+  end
+  
+  def remove_subscribe_from_buffer f
+    @buffer_mutex.synchronize do
+      @buffer.reject! { |bf| bf.command == 'SUBSCRIBE' && bf[:id] == f[:id] }
+    end
+  end
+  
+  def replay_buffer client
+    replay_frames = @buffer_mutex.synchronize do
+      @buffer.select { |f| f[:'x-onstomp-failover-replay'] = '1'; true }
+    end
+    
+    replay_frames.each do |f|
+      client.transmit f
+    end
+  end
+end

data/lib/onstomp/failover/buffers/receipts.rb

@@ -6,79 +6,38 @@
 # {OnStomp::Failover::Client failover} client reconnects.
 # @todo Quite a lot of this code is shared between Written and Receipts,
 #   we'll want to factor the common stuff out.
-class OnStomp::Failover::Buffers::Receipts
+class OnStomp::Failover::Buffers::Receipts < OnStomp::Failover::Buffers::Base
   def initialize failover
-    @failover = failover
-    @buffer_mutex = Mutex.new
-    @buffer = []
-    @txs = {}
-    
-    failover.before_send &method(:buffer_frame)
-    failover.before_commit &method(:buffer_frame)
-    failover.before_abort &method(:buffer_frame)
-    failover.before_subscribe &method(:buffer_frame)
-    failover.before_begin &method(:buffer_transaction)
+    super
+    [:send, :commit, :abort, :subscribe].each do |ev|
+      failover.__send__(:"before_#{ev}") do |f, *_|
+        add_to_buffer f, {:receipt => OnStomp.next_serial}
+      end
+    end
+    failover.before_begin do |f, *_|
+      add_to_transactions f, {:receipt => OnStomp.next_serial}
+    end
     # We can scrub the subscription before UNSUBSCRIBE is fully written
     # because if we replay before UNSUBSCRIBE was sent, we still don't
     # want to be subscribed when we reconnect.
-    failover.before_unsubscribe &method(:debuffer_subscription)
-    failover.on_receipt &method(:debuffer_frame)
-    
-    failover.on_failover_connected &method(:replay)
-  end
-  
-  # Adds a frame to a buffer so that it may be replayed if the
-  # {OnStomp::Failover::Client failover} client re-connects
-  def buffer_frame f, *_
-    @buffer_mutex.synchronize do
-      # Don't re-buffer frames that are being replayed.
-      unless f.header? :'x-onstomp-failover-replay'
-        # Create a receipt header, unless the frame already has one.
-        f[:receipt] = OnStomp.next_serial unless f.header?(:receipt)
-        @buffer << f 
-      end
-    end
-  end
-  
-  # Records the start of a transaction so that it may be replayed if the
-  # {OnStomp::Failover::Client failover} client re-connects
-  def buffer_transaction f, *_
-    @txs[f[:transaction]] = true
-    buffer_frame f
-  end
-  
-  # Removes the recorded transaction from the buffer after it has been
-  # written the broker socket so that it will not be replayed when the
-  # {OnStomp::Failover::Client failover} client re-connects
-  def debuffer_transaction f
-    tx = f[:transaction]
-    if @txs.delete tx
-      @buffer_mutex.synchronize do
-        @buffer.reject! { |bf| bf[:transaction] == tx }
-      end
+    failover.before_unsubscribe do |f, *_|
+      remove_subscribe_from_buffer f
     end
+    failover.on_receipt { |r, *_| debuffer_frame r }
+    failover.on_failover_connected { |f,c,*_| replay_buffer c }
   end
   
-  # Removes the matching SUBSCRIBE frame from the buffer after the
-  # UNSUBSCRIBE has been added to the connection's write buffer
-  # so that it will not be replayed when the
-  # {OnStomp::Failover::Client failover} client re-connects
-  def debuffer_subscription f, *_
-    @buffer_mutex.synchronize do
-      @buffer.reject! { |bf| bf.command == 'SUBSCRIBE' && bf[:id] == f[:id] }
-    end
-  end
   
   # Removes frames that neither transactional nor SUBSCRIBEs from the buffer
   # by looking the buffered frames up by their `receipt` header.
-  def debuffer_frame r, *_
+  def debuffer_frame r
     orig = @buffer_mutex.synchronize do
       @buffer.detect { |f| f[:receipt] == r[:'receipt-id'] }
     end
     if orig
       # COMMIT and ABORT debuffer the whole transaction sequence
       if ['COMMIT', 'ABORT'].include? orig.command
-        debuffer_transaction orig
+        remove_from_transactions orig
       # Otherwise, if this isn't part of a transaction, debuffer the
       # particular frame (if it's not a SUBSCRIBE)
       elsif orig.command != 'SUBSCRIBE' && !orig.header?(:transaction)
@@ -86,16 +45,4 @@ class OnStomp::Failover::Buffers::Receipts
       end
     end
   end
-  
-  # Called when the {OnStomp::Failover::Client failover} client triggers
-  # `on_failover_connected` to start replaying any frames in the buffer.
-  def replay fail, client, *_
-    replay_frames = @buffer_mutex.synchronize do
-      @buffer.select { |f| f[:'x-onstomp-failover-replay'] = '1'; true }
-    end
-    
-    replay_frames.each do |f|
-      client.transmit f
-    end
-  end
 end