ruby_nsq 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9579c1a3a9b590d345635b1ad0118dc33e5fbd97
-  data.tar.gz: c2a3fe655159c07d68e8e9a05212f71050ec7457
+  metadata.gz: 52265e899f8f90847c965d85f1ebad0ecc76994c
+  data.tar.gz: e12d1e4f0ac44dd1faf07905ff505c22cb0facd4
 SHA512:
-  metadata.gz: d28cb948f57d9606e1301f460ee3dd6f7ac948e6c3c7f537fa63568097f6009ec7cb8101e33286f1c6ab4336321e1112f7fe9a498c8e03e94e0d7e143503ede3
-  data.tar.gz: 9f2ea7faedaecd1d4ea0f4568dfe38173c0e6f53b008874605cb3269362bda7a4ca33e0d225cff17302a16ae372c6dd2f86f933fb164dc866a35b9d481735d40
+  metadata.gz: f0890442271e47716b204b4412fa06b7294b9f70a9273ba22058f7844bd9dd1948d9e06fc94ce65be0658ca6f8bc0dbe9ea2ef19e3cdcf146bc86ae68fab82f9
+  data.tar.gz: ff7f950a74306eece1c5c77e34a8ab78869bbf1a651aef66cc568870c6600b1c11a0f5a6452f478843b56a034f18639dfc459e562c4297f85c98d2300eec3f50

data/History.md

@@ -1,6 +1,12 @@
 Changelog
 =========
 
+0.0.4
+-----
+
+ - Refactoring
+ - Bug fixes
+
 0.0.3
 -----
 

data/README.md

@@ -1,8 +1,4 @@
-# ruby_nsq
-
-https://github.com/ClarityServices/ruby_nsq
-
-## Description
+# Ruby NSQ
 
 Ruby client for the [NSQ](https://github.com/bitly/nsq) realtime message processing system.
 
@@ -15,7 +11,7 @@ Ruby client for the [NSQ](https://github.com/bitly/nsq) realtime message process
 See [examples](https://github.com/ClarityServices/ruby_nsq/tree/master/examples)
 
 Simple example for synchronous message handling:
-```
+```rb
 require 'nsq'
 
 reader = NSQ::Reader.new(:nsqd_tcp_addresses => '127.0.0.1:4150')
@@ -29,14 +25,14 @@ puts 'Reader stopped'
 ```
 
 Advanced example demonstrating asynchronous handling of messages on multiple threads:
-```
+```rb
 require 'nsq'
 
 foo_worker_count = 50
 bar_worker_count = 30
 baz_worker_count = 20
 
-reader = NSQ::Reader.new(:nsqd_tcp_addresses => '127.0.0.1:4150')
+reader = NSQ::Reader.new(nsqd_tcp_addresses: '127.0.0.1:4150')
 
 foo_subscriber  = reader.subscribe('test',  'foo', :max_in_flight => foo_worker_count)
 bar_subscriber  = reader.subscribe('test2', 'bar', :max_in_flight => bar_worker_count)
@@ -72,9 +68,9 @@ baz_threads.each(&:join)
 
 ## Meta
 
-* Code: `git clone git://github.com/ClarityServices/ruby_nsq.git`
-* Home: <https://github.com/ClarityServices/ruby_nsq>
-* Bugs: <http://github.com/ClarityServices/ruby_nsq/issues>
+* Code: `git clone git://github.com/daddye/ruby_nsq.git`
+* Home: <https://github.com/daddye/ruby_nsq>
+* Bugs: <http://github.com/daddye/ruby_nsq/issues>
 * Gems: <http://rubygems.org/gems/ruby_nsq>
 
 This project uses [Semantic Versioning](http://semver.org/).
@@ -82,3 +78,4 @@ This project uses [Semantic Versioning](http://semver.org/).
 ## Authors
 
 Brad Pardee :: bradpardee@gmail.com
+Davide D'Agostino (@DAddYE) :: info@daddye.it

data/lib/nsq.rb

@@ -1,25 +1,16 @@
-require 'nsq/loggable'
+require 'nsq/util'
+require 'nsq/logger'
 require 'nsq/message'
 require 'nsq/reader'
 require 'nsq/subscriber'
 require 'nsq/publisher'
-require 'nsq/queue_subscriber'
 require 'nsq/connection'
 require 'nsq/backoff_timer'
 require 'nsq/timer'
-require 'nsq/util'
 
 module NSQ
-  extend NSQ::Loggable
-
-  MAGIC_V2 = "  V2"
-
+  MAGIC_V2            = "  V2"
   FRAME_TYPE_RESPONSE = 0
   FRAME_TYPE_ERROR    = 1
   FRAME_TYPE_MESSAGE  = 2
-
-  def self.create_reader(options, &block) #:nodoc:
-    NSQ.logger.info('NSQ#create_reader has been deprecated, please use NSQ::Reader#new instead')
-    Reader.new(options, &block)
-  end
 end

data/lib/nsq/connection.rb

@@ -4,7 +4,7 @@ require 'thread'  #Mutex
 module NSQ
   # Represents a single subscribed connection to an nsqd server.
   class Connection
-    attr_reader :name
+    include NSQ::Logger
 
     def initialize(reader, subscriber, host, port)
       @reader        = reader
@@ -12,7 +12,6 @@ module NSQ
       @selector      = reader.selector
       @host          = host
       @port          = port
-      @name          = "#{subscriber.name}:#{host}:#{port}"
       @write_monitor = Monitor.new
       @ready_mutex   = Mutex.new
       @sending_ready = false
@@ -20,18 +19,16 @@ module NSQ
       # Connect states :init, :interval, :connecting, :connected, :closed
       @connect_state = :init
 
-      @next_connection_time     = nil
-      @next_ready_time          = nil
       @connection_backoff_timer = nil
       @ready_backoff_timer      = @subscriber.create_ready_backoff_timer
 
       connect
     end
 
-    def send_init(topic, channel, short_id, long_id) #:nodoc:
+    def send_init(topic, channel) #:nodoc:
       write NSQ::MAGIC_V2
-      write "SUB #{topic} #{channel} #{short_id} #{long_id}\n"
-      self.send_ready
+      write "SUB #{topic} #{channel}\n"
+      send_ready
     end
 
     def send_ready #:nodoc:
@@ -73,10 +70,8 @@ module NSQ
         interval = @connection_backoff_timer.interval
         if interval > 0
           @connect_state = :interval
-          NSQ.logger.debug {"#{self}: Reattempting connection in #{interval} seconds"}
-          @reader.add_timeout(interval) do
-            connect
-          end
+          logger.debug("Reattempting connection in #{interval} seconds")
+          @reader.add_timeout(interval, &method(:connect))
         else
           connect
         end
@@ -84,14 +79,14 @@ module NSQ
     end
 
     def close(permanent=true) #:nodoc:
-      NSQ.logger.debug {"#{@name}: Closing..."}
+      logger.debug "Closing..."
       @write_monitor.synchronize do
         begin
           @selector.deregister(@socket)
           # Use straight socket to write otherwise we need to use Monitor instead of Mutex
           @socket.write "CLS\n"
           @socket.close
-        rescue Exception => e
+        rescue Exception
         ensure
           @connect_state = permanent ? :closed : :init
           @socket        = nil
@@ -101,21 +96,18 @@ module NSQ
 
     def connect #:nodoc:
       return unless verify_connect_state?(:init, :interval)
-      NSQ.logger.debug {"#{self}: Beginning connect"}
+      logger.debug {"#{self}: Beginning connect"}
       @connect_state = :connecting
       @buffer        = ''
       @ready_count   = 0
       @socket        = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
       @sockaddr      = Socket.pack_sockaddr_in(@port, @host)
+      @socket.set_encoding 'UTF-8'
       @monitor       = @selector.register(@socket, :w)
-      @monitor.value = proc { do_connect }
+      @monitor.value = method(:do_connect)
       do_connect
     end
 
-    def to_s #:nodoc:
-      @name
-    end
-
     private
 
     def do_connect
@@ -124,14 +116,14 @@ module NSQ
         begin
           @socket.connect_nonblock(@sockaddr)
           # Apparently we always throw an exception here
-          NSQ.logger.debug {"#{self}: do_connect fell thru without throwing an exception"}
+          logger.debug {"#{self}: do_connect fell thru without throwing an exception"}
         rescue Errno::EINPROGRESS
-          NSQ.logger.debug {"#{self}: do_connect - connect in progress"}
+          logger.debug {"#{self}: do_connect - connect in progress"}
         rescue Errno::EISCONN
-          NSQ.logger.debug {"#{self}: do_connect - connection complete"}
+          logger.debug {"#{self}: do_connect - connection complete"}
           @selector.deregister(@socket)
           monitor = @selector.register(@socket, :r)
-          monitor.value = proc { read_messages }
+          monitor.value = method(:read_messages)
           @connect_state = :connected
           # The assumption for connections is that a good connection means the server is good, no ramping back up like ready counts
           @connection_backoff_timer = nil
@@ -148,11 +140,9 @@ module NSQ
         if interval == 0.0
           send_ready
         else
-          NSQ.logger.debug {"#{self}: Delaying READY for #{interval} seconds"}
+          logger.debug {"#{self}: Delaying READY for #{interval} seconds"}
           @sending_ready = true
-          @reader.add_timeout(interval) do
-            send_ready
-          end
+          @reader.add_timeout(interval, method(:send_ready))
         end
       end
     end
@@ -162,29 +152,29 @@ module NSQ
       while @buffer.length >= 8
         size, frame = @buffer.unpack('NN')
         break if @buffer.length < 4+size
+ 
         case frame
-          when NSQ::FRAME_TYPE_RESPONSE
-            if @buffer[8,11] == "_heartbeat_"
-              send_nop
-              @subscriber.handle_heartbeat(self)
-              @buffer = @buffer[(4+size)..-1]
-            else
-              NSQ.logger.error("I don't know what to do with the rest of this buffer: #{@buffer[8,size-4].inspect}") if @buffer.length > 8
-              @buffer = @buffer[(4+size)..-1]
-            end
-          when NSQ::FRAME_TYPE_ERROR
-            @subscriber.handle_frame_error(self, @buffer[8, size-4])
-            @buffer = @buffer[(4+size)..-1]
-          when NSQ::FRAME_TYPE_MESSAGE
-            raise "Bad message: #{@buffer.inspect}" if size < 30
-            ts_hi, ts_lo, attempts, id = @buffer.unpack('@8NNna16')
-            body = @buffer[34, size-30]
-            message = Message.new(self, id, ts_hi, ts_lo, attempts, body)
-            @buffer = @buffer[(4+size)..-1]
-            NSQ.logger.debug {"#{self}: Read message=#{message}"}
-            @subscriber.handle_message(self, message)
-          else
-            raise "Unrecognized message frame: #{frame} buffer=#{@buffer.inspect}"
+        when NSQ::FRAME_TYPE_RESPONSE
+          if @buffer[8,11] == "_heartbeat_"
+            send_nop
+            @subscriber.handle_heartbeat(self)
+          elsif @buffer[8, 2] != "OK"
+            logger.error("I don't know what to do with the rest of this buffer: #{@buffer[8,size-4].inspect}") if @buffer.length > 8
+          end
+          @buffer = @buffer[(4+size)..-1]
+        when NSQ::FRAME_TYPE_ERROR
+          @subscriber.handle_frame_error(self, @buffer[8, size-4])
+          @buffer = @buffer[(4+size)..-1]
+        when NSQ::FRAME_TYPE_MESSAGE
+          raise "Bad message: #{@buffer.inspect}" if size < 30
+          ts_hi, ts_lo, attempts, id = @buffer.unpack('@8NNna16')
+          body = @buffer[34, size-30].force_encoding('UTF-8')
+          message = Message.new(self, id, ts_hi, ts_lo, attempts, body)
+          @buffer = @buffer[(4+size)..-1]
+          logger.debug("Read message=#{message}")
+          @subscriber.handle_message(self, message)
+        else
+          raise "Unrecognized message frame: #{frame} buffer=#{@buffer.inspect}"
         end
       end
     rescue Exception => e
@@ -196,7 +186,7 @@ module NSQ
     end
 
     def write(msg)
-      NSQ.logger.debug {"#{@name}: Sending #{msg.inspect}"}
+      logger.debug("Sending #{msg.inspect}")
       # We should only ever have one reader but we can have multiple writers
       @write_monitor.synchronize do
         @socket.write(msg) if verify_connect_state?(:connected)
@@ -204,16 +194,7 @@ module NSQ
     end
 
     def verify_connect_state?(*states)
-      return true if states.include?(@connect_state)
-      NSQ.logger.error("Unexpected connect state of #{@connect_state}, expected to be in #{states.inspect}\n\t#{caller[0]}")
-      if @connect_state != :closed
-        # Likely in a bug state.
-        # I don't want to get in an endless loop of exceptions.  Is this a good idea or bad?  Maybe close to deregister first
-        # Attempt recovery
-        @connect_state = :init
-        connect
-      end
-      return false
+      states.include?(@connect_state)
     end
   end
 end

data/lib/nsq/error.rb

@@ -0,0 +1,8 @@
+module NSQ
+	class Error < StandardError
+		Invalid    = Class.new(self)
+		BadTopic   = Class.new(self)
+		BadMessage = Class.new(self)
+		PutFailed  = Class.new(self)
+	end
+end

data/lib/nsq/logger.rb

@@ -0,0 +1,18 @@
+require 'logger'
+
+module NSQ
+  module Logger
+    def logger
+      @_logger ||= 
+        begin
+          l = ::Logger.new(STDOUT)
+          l.level = ::Logger::INFO
+          l
+        end
+    end
+
+    def logger=(logger)
+      @_logger = logger
+    end
+  end
+end

data/lib/nsq/message.rb

@@ -5,7 +5,6 @@ module NSQ
     def initialize(connection, id, timestamp_high, timestamp_low, attempts, body)
       @connection     = connection
       @id             = id
-      @timestamp_high = timestamp_high
       @timestamp_low  = timestamp_low
       @attempts       = attempts
       @body           = body

data/lib/nsq/publisher.rb

@@ -1,41 +1,69 @@
 require 'socket'
+require 'nsq/error'
 
 module NSQ
   class Publisher
+
+    SIZE_BYTES = 4
+
     def initialize(host, port, options={}, &block)
       @socket = TCPSocket.open(host, port)
       @socket.write(MAGIC_V2)
-      @response_timeout = options[:response_timeout] || 5
-      yield self if block_given?
+      block[self] if block_given?
     ensure
       close if block_given?
     end
 
     def publish(topic, message)
-      buf = ['PUB ', topic, "\n", message.length, message].pack('a*a*a*Na*')
+      buf = ['PUB ', topic, "\n", message.bytesize, message].pack('a*a*a*Na*')
       @socket.write(buf)
+
       response = ''
+      have_received_ok = false
       loop do
-        response += @socket.recv(4096)
-        size, frame, msg = response.unpack('NNa*')
-        if response.length == size+4
-          case msg
-            when 'OK'            then return
-            when '_heartbeat_'   then response = ""
-            when 'E_INVALID'     then raise 'Invalid message'
-            when 'E_BAD_TOPIC'   then raise 'Bad topic'
-            when 'E_BAD_MESSAGE' then raise 'Bad message'
-            when 'E_PUT_FAILED'  then raise 'Put failed'
-            else raise "Unknown PUB response: #{msg}"
-          end
-        elsif response.length > size+4
-          raise "Unexpected PUB response - Expected size = #{size} actual size = #{response.length-4}: message=#{msg}"
+        until response.size >= expected_size(response)
+          response += @socket.recv(4096)
         end
+
+        size = expected_size(response)
+
+        # Extract the first message from `response`.
+        first_message = response.slice!(0, size)
+        _, _, data = first_message.unpack("NNa#{size}")
+        have_received_ok ||= handle(data)
+
+        # If the message was "OK", we can return successfully when the buffer
+        # is empty.
+        return if response.empty? && have_received_ok
+
+        # We are now in a situation where we have processed a message, but we
+        # must process more. Either it was an OK but we have partially read
+        # another message that we must finish, or it was a heartbeat and we
+        # must read again until we get an OK or an error code.
       end
     end
 
     def close
-      @socket.close
+      @socket.close if @socket
     end
+
+    private
+    def expected_size(response)
+      return 8 if response.size < 8
+      SIZE_BYTES + response.unpack('N')[0]
+    end
+
+    def handle(msg)
+      case msg
+      when 'OK'            ; return true
+      when '_heartbeat_'   ; return false
+      when 'E_INVALID'     ; raise NSQ::Error::Invalid
+      when 'E_BAD_TOPIC'   ; raise NSQ::Error::BadTopic
+      when 'E_BAD_MESSAGE' ; raise NSQ::Error::BadMessage
+      when 'E_PUT_FAILED'  ; raise NSQ::Error::PutFailed
+      else raise NSQ::Error, "Unknown PUB response: #{msg}"
+      end
+    end
+
   end
 end

data/lib/nsq/reader.rb

@@ -1,12 +1,14 @@
-require 'socket'
-require 'thread'
-require 'monitor'
 require 'nio'
+require 'thread_safe'
+require 'atomic'
 
 module NSQ
   # Maintains a collection of subscribers to topics and channels.
   class Reader
-    attr_reader :name, :long_id, :short_id, :selector, :options
+    include NSQ::Util
+    include NSQ::Logger
+
+    attr_reader :selector, :options
 
     # Create a new NSQ Reader
     #
@@ -15,45 +17,26 @@ module NSQ
     #     Array of nsqd servers to connect to with port numbers
     #     ['server1:4150', 'server2:4150']
     #
-    #   :lookupd_tcp_addresses [String or Array of Strings] (Not implemented)
-    #     Array of nsq_lookupd servers to connect to with port numbers
-    #     ['server1:4160', 'server2:4160']
-    #
-    #   :lookupd_poll_interval [Float] (Not implemented)
-    #     How often to poll the lookupd_tcp_addresses for new nsqd servers
-    #     Default: 120
-    #
-    #   :long_id [String]
-    #     The identifier used as a long-form descriptor
-    #     Default: fully-qualified hostname
+    #   :logger [Logger]
+    #     The Logger class
     #
-    #   :short_id [String]
-    #     The identifier used as a short-form descriptor
-    #     Default: short hostname
+    #   :logger_level [Symbol]
+    #     The Logger Level [:info, :debug, :warn, :error]
     #
     def initialize(options={})
-      @options                = options
-      @nsqd_tcp_addresses     = s_to_a(options[:nsqd_tcp_addresses])
-      @lookupd_tcp_addresses  = s_to_a(options[:lookupd_tcp_addresses])
-      @lookupd_poll_interval  = options[:lookupd_poll_interval]        || 120
-      @long_id                = options[:long_id]                      || Socket.gethostname
-      @short_id               = options[:short_id]                     || @long_id.split('.')[0]
-      NSQ.logger              = options[:logger] if options[:logger]
-      NSQ.logger.level        = options[:logger_level] if options[:logger_level]
-
-      @selector               = ::NIO::Selector.new
-      @timer                  = Timer.new(@selector)
-      @topic_count            = Hash.new(0)
-      @subscribers            = {}
-      @subscriber_mutex       = Monitor.new
-      @name                   = "#{@long_id}:#{@short_id}"
-
-      raise 'Must pass either option :nsqd_tcp_addresses or :lookupd_http_addresses' if @nsqd_tcp_addresses.empty? && @lookupd_http_addresses.empty?
-
-      @conns = {}
-      @last_lookup = nil
-
-      @logger.info("starting reader for topic '%s'..." % self.topic) if @logger
+      @options            = options
+      @nsqd_tcp_addresses = Array(options[:nsqd_tcp_addresses])
+
+      logger          = options[:logger]       if options[:logger]
+      logger.level    = options[:logger_level] if options[:logger_level]
+
+      @selector    = ::NIO::Selector.new
+      @timer       = Timer.new(@selector)
+      @subscribers = ThreadSafe::Cache.new
+      @stop        = Atomic.new(false)
+      @running     = Atomic.new(false)
+
+      raise 'Must pass either option :nsqd_tcp_addresses' if @nsqd_tcp_addresses.empty?
     end
 
     # Subscribes to a given topic and channel.
@@ -67,68 +50,63 @@ module NSQ
     # Refer to Subscriber::new for the options that can be passed to this method.
     #
     def subscribe(topic, channel, options={}, &block)
-      Util.assert_topic_and_channel_valid(topic, channel)
+      assert_topic_and_channel_valid(topic, channel)
       subscriber = nil
-      name       = "#{topic}:#{channel}"
-      @subscriber_mutex.synchronize do
-        raise "Already subscribed to #{name}" if @subscribers[name]
-        subscriber_class = block_given? ? Subscriber : QueueSubscriber
-        subscriber = @subscribers[name] = subscriber_class.new(self, topic, channel, options, &block)
-      end
+      name = "#{topic}:#{channel}"
+
+      raise "Already subscribed to #{name}" if @subscribers[name]
+      subscriber = @subscribers[name] = Subscriber.new(self, topic, channel, options, &block)
 
       @nsqd_tcp_addresses.each do |addr|
         address, port = addr.split(':')
         subscriber.add_connection(address, port.to_i)
       end
+
       subscriber
     end
 
     # Unsubscribe  a given topic and channel.
     def unsubscribe(topic, channel)
       name = "#{topic}:#{channel}"
-      @subscriber_mutex.synchronize do
-        subscriber = @subscribers[name]
-        return unless subscriber
-        subscriber.stop
-        @subscribers.delete(name)
-      end
+      subscriber = @subscribers[name]
+      return unless subscriber
+      subscriber.stop
+      @subscribers.delete(name)
+    end
+
+    def stopped?
+      @stop.value
+    end
+
+    def running?
+      @running.value
     end
 
     # Processes all the messages from the subscribed connections.  This will not return until #stop
     # has been called in a separate thread.
     def run
-      @stopped = false
-      until @stopped do
-        if (Time.now.to_i - @last_lookup.to_i) > @lookupd_poll_interval
-          # Do lookupd
-        end
+      @running.value = true # we can't run from multiple threads so this is fine
+      until stopped?
         @selector.select(@timer.next_interval) { |m| m.value.call }
       end
+    ensure
+      @running.value = false
     end
 
     # Stop this reader which will gracefully exit the run method after all current messages are processed.
     def stop
-      NSQ.logger.info("#{self}: Reader stopping...")
-      @stopped = true
+      logger.debug("#{self}: Reader stopping...")
+      @stop.try_update { |m| m = true }
+      @running.try_update { |m| m = false }
       @selector.wakeup
-      @subscriber_mutex.synchronize do
-        @subscribers.each_value {|subscriber| subscriber.stop}
-      end
+      @subscribers.each_value(&:stop)
+    rescue Atomic::ConcurrentUpdateError
+      retry
     end
 
     # Call the given block from within the #run thread when the given interval has passed.
     def add_timeout(interval, &block)
       @timer.add(interval, &block)
     end
-
-    def to_s #:nodoc:
-      @name
-    end
-
-    private
-
-    def s_to_a(val)
-      val.kind_of?(String) ? [val] : val
-    end
   end
 end

data/lib/nsq/subscriber.rb

@@ -1,6 +1,8 @@
 module NSQ
   class Subscriber
-    attr_reader :selector, :name
+    include NSQ::Logger
+
+    attr_reader :selector
     attr_accessor :max_in_flight
 
     # Creates a new subscriber which maintain connections to all the nsqd instances which publish
@@ -52,7 +54,6 @@ module NSQ
     #
     def initialize(reader, topic, channel, options, &block)
       options          = reader.options.merge(options)
-      @name            = "#{reader.name}:#{topic}:#{channel}"
       @reader          = reader
       @selector        = reader.selector
       @topic           = topic
@@ -118,9 +119,7 @@ module NSQ
     # Stop this subscriber
     def stop
       @stopped = true
-      @connection_hash.each_value do |connection|
-        connection.close
-      end
+      @connection_hash.each_value(&:close)
       @connection_hash.clear
     end
 
@@ -130,7 +129,7 @@ module NSQ
     end
 
     def handle_connection(connection) #:nodoc:
-      connection.send_init(@topic, @channel, @reader.short_id, @reader.long_id)
+      connection.send_init(@topic, @channel)
     end
 
     def handle_heartbeat(connection) #:nodoc:
@@ -141,30 +140,26 @@ module NSQ
     end
 
     def process_message(connection, message, &block) #:nodoc:
-      yield message
+      block[message]
       connection.send_finish(message.id, true)
     rescue Exception => e
-      NSQ.logger.error("#{connection.name}: Exception during handle_message: #{e.message}\n\t#{e.backtrace.join("\n\t")}")
-      if @max_tries && attempts >= @max_tries
-        NSQ.logger.warning("#{connection.name}: Giving up on message after #{@max_tries} tries: #{body.inspect}")
+      logger.error("Exception during handle_message: #{e.message}\n\t#{e.backtrace.join("\n\t")}")
+      if @max_tries && message.attempts >= @max_tries
+        logger.warning("Giving up on message after #{@max_tries} tries: #{message.body.inspect}")
         connection.send_finish(message.id, false)
       else
-        connection.send_requeue(message.id, attempts * @requeue_delay)
+        connection.send_requeue(message.id, message.attempts * @requeue_delay)
       end
     end
 
     def handle_frame_error(connection, error_message) #:nodoc:
-      NSQ.logger.error("Received error from nsqd: #{error_message.inspect}")
+      logger.error("Received error from nsqd: #{error_message.inspect}")
       connection.reset
     end
 
     def handle_io_error(connection, exception) #:nodoc:
-      NSQ.logger.error("Socket error: #{exception.message}\n\t#{exception.backtrace[0,2].join("\n\t")}")
+      logger.error("Socket error: #{exception.message}\n\t#{exception.backtrace[0,2].join("\n\t")}")
       connection.reset
     end
-
-    def to_s #:nodoc:
-      @name
-    end
   end
 end

data/lib/nsq/util.rb

@@ -1,16 +1,16 @@
 module NSQ
   module Util
 
-    def self.assert_topic_and_channel_valid(topic, channel) #:nodoc:
+    def assert_topic_and_channel_valid(topic, channel) #:nodoc:
       raise "Invalid topic #{topic}" unless valid_topic_name?(topic)
       raise "Invalid channel #{channel}" unless valid_channel_name?(channel)
     end
 
-    def self.valid_topic_name?(topic) #:nodoc:
+    def valid_topic_name?(topic) #:nodoc:
       !!topic.match(/^[\.a-zA-Z0-9_-]+$/)
     end
 
-    def self.valid_channel_name?(channel) #:nodoc:
+    def valid_channel_name?(channel) #:nodoc:
       !!channel.match(/^[\.a-zA-Z0-9_-]+(#ephemeral)?$/)
     end
   end

metadata

@@ -1,145 +1,174 @@
 --- !ruby/object:Gem::Specification
 name: ruby_nsq
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Brad Pardee
+- DAddYE (Davide D'Agostino)
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-02 00:00:00.000000000 Z
+date: 2014-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nio4r
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: thread_safe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: atomic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: turn
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: wirble
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: hirb
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Ruby client for the NSQ realtime message processing system
 email:
 - bradpardee@gmail.com
+- info@daddye.it
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- History.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/async/README
+- examples/async/publisher.rb
+- examples/async/reader.rb
+- examples/simple/README
+- examples/simple/publisher.rb
+- examples/simple/reader.rb
+- lib/nsq.rb
 - lib/nsq/backoff_timer.rb
 - lib/nsq/connection.rb
-- lib/nsq/loggable.rb
+- lib/nsq/error.rb
+- lib/nsq/logger.rb
 - lib/nsq/message.rb
 - lib/nsq/publisher.rb
-- lib/nsq/queue_subscriber.rb
 - lib/nsq/reader.rb
 - lib/nsq/subscriber.rb
 - lib/nsq/timer.rb
 - lib/nsq/util.rb
-- lib/nsq.rb
 - lib/ruby_nsq.rb
-- examples/async/publisher.rb
-- examples/async/reader.rb
-- examples/async/README
-- examples/simple/publisher.rb
-- examples/simple/reader.rb
-- examples/simple/README
-- LICENSE.txt
-- Rakefile
-- History.md
-- README.md
 - test/backoff_timer_test.rb
-- test/sync_connection_test.rb.tbd
-homepage: http://github.com/ClarityServices/ruby_nsq
+homepage: https://github.com/bpardee/ruby_nsq.git
 licenses: []
 metadata: {}
 post_install_message: 
@@ -148,20 +177,19 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.2
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Ruby client for NSQ
 test_files:
 - test/backoff_timer_test.rb
-- test/sync_connection_test.rb.tbd

data/lib/nsq/loggable.rb

@@ -1,23 +0,0 @@
-module NSQ
-  module Loggable
-    def logger
-      @logger ||= (rails_logger || default_logger)
-    end
-
-    def rails_logger
-      (defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger) ||
-      (defined?(RAILS_DEFAULT_LOGGER) && RAILS_DEFAULT_LOGGER.respond_to?(:debug) && RAILS_DEFAULT_LOGGER)
-    end
-
-    def default_logger
-      require 'logger'
-      l = Logger.new($stdout)
-      l.level = Logger::INFO
-      l
-    end
-
-    def logger=(logger)
-      @logger = logger
-    end
-  end
-end

data/lib/nsq/queue_subscriber.rb

@@ -1,51 +0,0 @@
-require 'thread' #Mutex
-
-module NSQ
-  # An asynchronous subscriber that can be run on multiple threads for reading messages from a subscribed channel.
-  class QueueSubscriber < Subscriber
-    def initialize(reader, topic, channel, options) #:nodoc:
-      super
-      @queue     = Queue.new
-      @run_mutex = Mutex.new
-      @run_count = 0
-    end
-
-    def ready_count #:nodoc:
-      # Return the minimum of Subscriber#ready_count and the amount of space left in the queue
-      [super, self.max_in_flight - @queue.size].min
-    end
-
-    def handle_message(connection, message) #:nodoc:
-      @queue << [connection, message]
-    end
-
-    # Processes messages from the subscribed connections.  This will not return until #stop
-    # has been called in a separate thread.  This can be called from multiple threads if you
-    # want multiple workers handling the incoming messages.
-    def run(&block)
-      @run_mutex.synchronize { @run_count += 1}
-      until @stopped
-        pair = @queue.pop
-        if pair == :stop
-          # Give the next thread something to pop
-          @queue << :stop
-          return
-        end
-        connection, message = pair
-        process_message(connection, message, &block)
-      end
-    ensure
-      @run_mutex.synchronize { @run_count -= 1}
-    end
-
-    # Stop this subscriber once all the queued messages have been handled.
-    def stop
-      @stopped = true
-      # Give the threads something to pop
-      @queue << :stop
-      # TODO: Put a max time on this so we don't potentially hang
-      sleep 1 while @run_count > 0
-      super
-    end
-  end
-end

data/test/sync_connection_test.rb.tbd

@@ -1,12 +0,0 @@
-
-c = SyncConn()
-c.connect("127.0.0.1", 4150)
-c.send(nsq.subscribe('test', 'ch', 'a', 'b'))
-10.times do
-  c.send(nsq.ready(1))
-  resp = c.read_response()
-  unpacked = nsq.unpack_response(resp)
-  msg = nsq.decode_message(unpacked[1])
-  print msg.id, msg.body
-  c.send(nsq.finish(msg.id))
-end