ruby_nsq 0.0.1 → 0.0.2

data/History.md

@@ -1,5 +1,13 @@
 Changelog
-=====================
+=========
+
+0.0.2
+-----
+
+ - Fix timestamp
+ - More documentation
+ - Deprecate NSQ.create_reader in favor of NSQ::Reader.new
+ - Preliminary Publisher
 
 0.0.1
 -----

data/README.md

@@ -2,15 +2,15 @@
 
 https://github.com/ClarityServices/ruby_nsq
 
-## Description:
+## Description
 
 Ruby client for the [NSQ](https://github.com/bitly/nsq) realtime message processing system.
 
-## Install:
+## Install
 
   gem install ruby_nsq
 
-## Usage:
+## Usage
 
 See [examples](https://github.com/ClarityServices/ruby_nsq/tree/master/examples)
 
@@ -18,7 +18,7 @@ Simple example for synchronous message handling:
 ```
 require 'nsq'
 
-reader = NSQ.create_reader(:nsqd_tcp_addresses => '127.0.0.1:4150')
+reader = NSQ::Reader.new(:nsqd_tcp_addresses => '127.0.0.1:4150')
 # Subscribe to topic=test channel=simple
 reader.subscribe('test', 'simple') do |message|
   # If this block raises an exception, then the message will be requeued.
@@ -36,7 +36,7 @@ foo_worker_count = 50
 bar_worker_count = 30
 baz_worker_count = 20
 
-reader = NSQ.create_reader(: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)
@@ -62,10 +62,23 @@ bar_threads.each(&:join)
 baz_threads.each(&:join)
 ```
 
-## TODO:
-
-* Fix timestamp
+## TODO
 
 * Implement lookupd
 
 * Tests!
+
+* Documentation
+
+## Meta
+
+* Code: `git clone git://github.com/ClarityServices/ruby_nsq.git`
+* Home: <https://github.com/ClarityServices/ruby_nsq>
+* Bugs: <http://github.com/reidmorrison/ruby_nsq/issues>
+* Gems: <http://rubygems.org/gems/ruby_nsq>
+
+This project uses [Semantic Versioning](http://semver.org/).
+
+## Authors
+
+Brad Pardee :: bradpardee@gmail.com

data/examples/async/README

@@ -0,0 +1,6 @@
+# Start up reader
+bundle exec ./reader.rb
+Hit <RETURN> to initialize the Reader and <RETURN> again when you want to stop the reader
+
+# Run publisher with no arguments to get usage info:
+bundle exec ./publisher.rb

data/examples/async/publisher.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+require 'nsq'
+
+if ARGV.length != 3
+  $stderr.puts "bundle exec ./publisher.rb <topic> <count> <eval-string>"
+  $stderr.puts "  where <topic> is either test_xy or test_z"
+  $stderr.puts "  and <eval-string> could be something like 'sleep rand(100)/10.0'"
+  $stderr.puts "  Example: bundle exec ./publisher.rb test_xy 500 'sleep rand(100)/10.0'"
+  $stderr.puts "       or: bundle exec ./publisher.rb test_z 5000 nil"
+  exit 1
+end
+topic       = ARGV[0]
+count       = ARGV[1].to_i
+eval_string = ARGV[2]
+
+NSQ::Publisher.new('localhost', 4150) do |publisher|
+  count.times do
+    publisher.publish(topic, eval_string)
+  end
+end

data/examples/async/reader.rb

@@ -11,9 +11,9 @@ z_worker_count = 20
 puts 'Press enter to start and enter to finish'
 $stdin.gets
 
-reader = NSQ.create_reader(
+reader = NSQ::Reader.new(
     :nsqd_tcp_addresses => '127.0.0.1:4150',
-    :logger_level       => Logger::DEBUG
+    #:logger_level       => Logger::DEBUG
 )
 
 x_subscriber   = reader.subscribe('test_xy', 'x', :max_in_flight => x_worker_count)
@@ -46,13 +46,15 @@ end
 main_thread = Thread.new do
   reader.run
 end
+at_exit {
+  puts 'Exiting...'
+  reader.stop
+  main_thread.join
+  threads.each_value { |arr| arr.each(&:join) }
+  puts
+  puts "Summary of worker message counts"
+  threads.each do |char, arr|
+    puts "#{char} -  #{arr.map(&:message_count).join(' ')} total=#{arr.map(&:message_count).inject(:+)}"
+  end
+}
 $stdin.gets
-puts 'Exiting...'
-reader.stop
-main_thread.join
-threads.each_value { |arr| arr.each(&:join) }
-puts
-puts "Summary of worker message counts"
-threads.each do |char, arr|
-  puts "#{char} -  #{arr.map(&:message_count).join(' ')}"
-end

data/examples/simple/README

@@ -0,0 +1,5 @@
+# Start up reader
+bundle exec ./reader.rb
+
+# From another terminal, send a message:
+bundle exec ./publisher.rb hello world

data/examples/simple/publisher.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require 'nsq'
+
+if ARGV.length == 0
+  $stderr.puts "bundle exec ./publisher.rb <message>*"
+  $stderr.puts "  Example: bundle exec ./publisher.rb hello world"
+  exit 1
+end
+
+NSQ::Publisher.new('localhost', 4150) do |publisher|
+  publisher.publish('test', ARGV.join(' '))
+end

data/examples/simple/reader.rb

@@ -3,16 +3,17 @@
 require 'nsq'
 require 'logger'
 
+# Cntl-c doesn't run at_exit under jruby
 puts 'Press enter to start and enter to finish'
 gets
-reader = NSQ.create_reader(
+reader = NSQ::Reader.new(
     :nsqd_tcp_addresses => '127.0.0.1:4150',
     #:logger_level       => Logger::DEBUG
 )
 thread = Thread.new do
   begin
     reader.subscribe('test', 'simple') do |message|
-      puts "Read #{message.body}"
+      puts "Read: #{message.body.inspect}"
     end
     reader.run
   rescue Exception => e
@@ -20,6 +21,8 @@ thread = Thread.new do
   end
   puts 'Reader exiting'
 end
+at_exit {
+  reader.stop
+  thread.join
+}
 gets
-reader.stop
-thread.join

data/lib/nsq/backoff_timer.rb

@@ -34,7 +34,8 @@ module NSQ
       @short_interval  = [@short_interval, @max_short_timer].min
       @long_interval   = [@long_interval, @max_long_timer].min
     end
-    
+
+    # Return the interval to wait based on the successes and failures
     def interval
       @min_interval + @short_interval + @long_interval
     end

data/lib/nsq/connection.rb

@@ -2,6 +2,7 @@ require 'monitor'
 require 'thread'  #Mutex
 
 module NSQ
+  # Represents a single subscribed connection to an nsqd server.
   class Connection
     attr_reader :name
 
@@ -27,19 +28,19 @@ module NSQ
       connect
     end
 
-    def send_init(topic, channel, short_id, long_id)
+    def send_init(topic, channel, short_id, long_id) #:nodoc:
       write NSQ::MAGIC_V2
       write "SUB #{topic} #{channel} #{short_id} #{long_id}\n"
       self.send_ready
     end
 
-    def send_ready
+    def send_ready #:nodoc:
       @ready_count = @subscriber.ready_count
       write "RDY #{@ready_count}\n" unless @subscriber.stopped?
       @sending_ready = false
     end
 
-    def send_finish(id, success)
+    def send_finish(id, success) #:nodoc:
       write "FIN #{id}\n"
       @ready_mutex.synchronize do
         @ready_count -= 1
@@ -52,7 +53,7 @@ module NSQ
       end
     end
 
-    def send_requeue(id, time_ms)
+    def send_requeue(id, time_ms) #:nodoc:
       write "REQ #{id} #{time_ms}\n"
       @ready_mutex.synchronize do
         @ready_count -= 1
@@ -61,7 +62,7 @@ module NSQ
       end
     end
 
-    def reset
+    def reset #:nodoc:
       return unless verify_connect_state?(:connecting, :connected)
       # Close with the hopes of re-establishing
       close(false)
@@ -82,7 +83,7 @@ module NSQ
       end
     end
 
-    def close(permanent=true)
+    def close(permanent=true) #:nodoc:
       NSQ.logger.debug {"#{@name}: Closing..."}
       @write_monitor.synchronize do
         begin
@@ -98,13 +99,11 @@ module NSQ
       end
     end
 
-    def connect
+    def connect #:nodoc:
       return unless verify_connect_state?(:init, :interval)
       NSQ.logger.debug {"#{self}: Beginning connect"}
       @connect_state = :connecting
       @buffer        = ''
-      @connecting    = false
-      @connected     = false
       @ready_count   = 0
       @socket        = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
       @sockaddr      = Socket.pack_sockaddr_in(@port, @host)
@@ -113,6 +112,10 @@ module NSQ
       do_connect
     end
 
+    def to_s #:nodoc:
+      @name
+    end
+
     private
 
     def do_connect
@@ -200,12 +203,6 @@ module NSQ
       end
     end
 
-    def to_s
-      @name
-    end
-
-    private
-
     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]}")

data/lib/nsq/message.rb

@@ -12,7 +12,9 @@ module NSQ
     end
 
     def timestamp
-      Time.at((@timestamp_high * 2**32 + @timestamp_low) / 1000000000.0)
+      # TODO: Not really a nanosecond timestamp
+      #Time.at((@timestamp_high * 2**32 + @timestamp_low) / 1000000000.0)
+      Time.at(@timestamp_low)
     end
 
     def to_s

data/lib/nsq/publisher.rb

@@ -0,0 +1,40 @@
+require 'socket'
+
+module NSQ
+  class Publisher
+    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?
+    ensure
+      close if block_given?
+    end
+
+    def publish(topic, message)
+      buf = ['PUB ', topic, "\n", message.length, message].pack('a*a*a*Na*')
+      @socket.write(buf)
+      response = ''
+      loop do
+        response += @socket.recv(4096)
+        size, frame, msg = response.unpack('NNa*')
+        if response.length == size+4
+          case msg
+            when 'OK' then return
+            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}"
+        end
+      end
+    end
+
+    def close
+      @socket.close
+    end
+  end
+end

data/lib/nsq/queue_subscriber.rb

@@ -1,28 +1,33 @@
 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)
+    def initialize(reader, topic, channel, options) #:nodoc:
       super
       @queue     = Queue.new
       @run_mutex = Mutex.new
       @run_count = 0
     end
 
-    def ready_count
+    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)
+    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
@@ -33,6 +38,7 @@ module NSQ
       @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

data/lib/nsq/reader.rb

@@ -2,16 +2,39 @@ require 'socket'
 require 'thread'
 require 'monitor'
 require 'nio'
-#require 'thread_safe'
 
 module NSQ
+  # Maintains a collection of subscribers to topics and channels.
   class Reader
     attr_reader :name, :long_id, :short_id, :selector, :options
 
+    # Create a new NSQ Reader
+    #
+    # Options (Refer to NSQ::Subscriber::new for additional options which will be passed on to each subscriber):
+    #   :nsqd_tcp_addresses [String or Array of Strings]
+    #     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
+    #
+    #   :short_id [String]
+    #     The identifier used as a short-form descriptor
+    #     Default: short hostname
+    #
     def initialize(options={})
       @options                = options
       @nsqd_tcp_addresses     = s_to_a(options[:nsqd_tcp_addresses])
-      @lookupd_http_addresses = s_to_a(options[:lookupd_http_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]
@@ -27,25 +50,30 @@ module NSQ
 
       raise 'Must pass either option :nsqd_tcp_addresses or :lookupd_http_addresses' if @nsqd_tcp_addresses.empty? && @lookupd_http_addresses.empty?
 
-      # TODO: If the messages are failing, the backoff timer will exponentially increase a timeout before sending a RDY
-      #self.backoff_timer = dict((k, BackoffTimer.BackoffTimer(0, 120)) for k in self.task_lookup.keys())
-        
       @conns = {}
       @last_lookup = nil
 
       @logger.info("starting reader for topic '%s'..." % self.topic) if @logger
     end
 
-    def subscribe(topic, channel, subscribe_options={}, &block)
-      NSQ.assert_topic_and_channel_valid(topic, channel)
-      @topic     = topic
-      @channel   = channel
+    # Subscribes to a given topic and channel.
+    #
+    # If a block is passed, then within NSQ::Reader#run that block will be run synchronously whenever a message
+    # is received for this channel.
+    #
+    # If a block is not passed, then the QueueSubscriber that is returned from this method should have it's
+    # QueueSubscriber#run method executed within one or more separate threads for processing the messages.
+    #
+    # 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)
       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, subscribe_options, &block)
+        subscriber = @subscribers[name] = subscriber_class.new(self, topic, channel, options, &block)
       end
 
       @nsqd_tcp_addresses.each do |addr|
@@ -55,6 +83,7 @@ module NSQ
       subscriber
     end
 
+    # Unsubscribe  a given topic and channel.
     def unsubscribe(topic, channel)
       name = "#{topic}:#{channel}"
       @subscriber_mutex.synchronize do
@@ -65,6 +94,8 @@ module NSQ
       end
     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
@@ -75,6 +106,7 @@ module NSQ
       end
     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
@@ -84,14 +116,17 @@ module NSQ
       end
     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
+    def to_s #:nodoc:
       @name
     end
 
+    private
+
     def s_to_a(val)
       val.kind_of?(String) ? [val] : val
     end

data/lib/nsq/subscriber.rb

@@ -3,6 +3,53 @@ module NSQ
     attr_reader :selector, :name
     attr_accessor :max_in_flight
 
+    # Creates a new subscriber which maintain connections to all the nsqd instances which publish
+    # the given topic.  This is never called directly but instead called when Reader#subscribe is called.
+    #
+    # Options:
+    #   :max_tries [Integer]
+    #     The max number of attempts to process a given message at which point it will no longer be requeued.
+    #     Defaults to nil which means it will be requeued forever if it continues to fail.
+    #
+    #   :max_in_flight [Integer]
+    #     The number used to determine the RDY count sent for each connection.
+    #     Defaults to 1
+    #
+    #   :requeue_delay (msec) [Integer]
+    #     The delay that is sent along with the requeue when a message fails.
+    #     Defaults to 90,000 msec
+    #
+    #   :ready_backoff_timer [Hash of BackoffTimer options]
+    #     Options passed to a BackoffTimer for increasing the interval between ready counts when
+    #     messages are failing.
+    #       Options:
+    #         :min_interval (seconds) [Float]
+    #           The minimum interval that the BackoffTimer will return.
+    #           Defaults to 0
+    #
+    #         :max_interval (seconds) [Float]
+    #           The maximum interval that the BackoffTimer will return.
+    #           Defaults to 120
+    #
+    #         :ratio [Float]
+    #           Defaults to 0.25
+    #
+    #         :short_length [Float]
+    #           Defaults to 10
+    #
+    #         :long_length [Float]
+    #           Defaults to 250
+    #
+    #   :connection_backoff_timer [Hash of BackoffTimer options]
+    #     Options passed to a BackoffTimer for increasing the interval between connection attempts
+    #     when a connection to nsqd is failing.
+    #       Options (Refer to :ready_backoff_timer above for the meaning of these options):
+    #         :min_interval (seconds) [Float]
+    #           Defaults to 0
+    #
+    #         :max_interval (seconds) [Float]
+    #           Defaults to 30
+    #
     def initialize(reader, topic, channel, options, &block)
       options          = reader.options.merge(options)
       @name            = "#{reader.name}:#{topic}:#{channel}"
@@ -34,40 +81,41 @@ module NSQ
       raise "Invalid value for max_in_flight, must be between 0 and 2500: #{@max_in_flight}" unless @max_in_flight.between?(1,2499)
     end
 
-    def create_ready_backoff_timer
+    def create_ready_backoff_timer #:nodoc:
       BackoffTimer.new(@ready_min_interval, @ready_max_interval, @ready_ratio, @ready_short_length, @ready_long_length)
     end
 
-    def create_connection_backoff_timer
+    def create_connection_backoff_timer #:nodoc:
       BackoffTimer.new(@connection_min_interval, @connection_max_interval, @connection_ratio, @connection_short_length, @connection_long_length)
     end
 
     # Threshold for a connection where it's time to send a new READY message
-    def ready_threshold
+    def ready_threshold #:nodoc:
       @max_in_flight / @connection_hash.size / 4
     end
 
     # The actual value for the READY message
-    def ready_count
+    def ready_count #:nodoc:
       # TODO: Should we take into account the last_ready_count minus the number of messages sent since then?
       # Rounding up!
       (@max_in_flight + @connection_hash.size - 1) / @connection_hash.size
     end
 
-    def connection_count
+    def connection_count #:nodoc:
       @connection_hash.size
     end
 
-    def add_connection(host, port)
+    def add_connection(host, port) #:nodoc:
       @connection_hash[[host, port]] = Connection.new(@reader, self, host, port)
     end
 
-    def remove_connection(host, port)
+    def remove_connection(host, port) #:nodoc:
       connection = @connection_hash.delete([host, port])
       return unless connection
       connection.close
     end
 
+    # Stop this subscriber
     def stop
       @stopped = true
       @connection_hash.each_value do |connection|
@@ -76,22 +124,23 @@ module NSQ
       @connection_hash.clear
     end
 
+    # Return true if this subscriber has been stopped
     def stopped?
       @stopped
     end
 
-    def handle_connection(connection)
+    def handle_connection(connection) #:nodoc:
       connection.send_init(@topic, @channel, @reader.short_id, @reader.long_id)
     end
 
-    def handle_heartbeat(connection)
+    def handle_heartbeat(connection) #:nodoc:
     end
 
-    def handle_message(connection, message)
+    def handle_message(connection, message) #:nodoc:
       process_message(connection, message, &@block)
     end
 
-    def process_message(connection, message, &block)
+    def process_message(connection, message, &block) #:nodoc:
       yield message
       connection.send_finish(message.id, true)
     rescue Exception => e
@@ -104,17 +153,17 @@ module NSQ
       end
     end
 
-    def handle_frame_error(connection, error_message)
+    def handle_frame_error(connection, error_message) #:nodoc:
       NSQ.logger.error("Received error from nsqd: #{error_message.inspect}")
       connection.reset
     end
 
-    def handle_io_error(connection, exception)
+    def handle_io_error(connection, exception) #:nodoc:
       NSQ.logger.error("Socket error: #{exception.message}\n\t#{exception.backtrace[0,2].join("\n\t")}")
       connection.reset
     end
 
-    def to_s
+    def to_s #:nodoc:
       @name
     end
   end

data/lib/nsq/timer.rb

@@ -1,6 +1,7 @@
 require 'thread'
 
 module NSQ
+  #:nodoc:
   class Timer
     def initialize(selector)
       @selector   = selector

data/lib/nsq/util.rb

@@ -0,0 +1,17 @@
+module NSQ
+  module Util
+
+    def self.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:
+      !!topic.match(/^[\.a-zA-Z0-9_-]+$/)
+    end
+
+    def self.valid_channel_name?(channel) #:nodoc:
+      !!channel.match(/^[\.a-zA-Z0-9_-]+(#ephemeral)?$/)
+    end
+  end
+end

data/lib/nsq.rb

@@ -2,10 +2,12 @@ require 'nsq/loggable'
 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
@@ -16,20 +18,8 @@ module NSQ
   FRAME_TYPE_ERROR    = 1
   FRAME_TYPE_MESSAGE  = 2
 
-  def self.create_reader(options, &block)
+  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
-
-  def self.assert_topic_and_channel_valid(topic, channel)
-    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)
-    !!topic.match(/^[\.a-zA-Z0-9_-]+$/)
-  end
-
-  def self.valid_channel_name?(channel)
-    !!channel.match(/^[\.a-zA-Z0-9_-]+(#ephemeral)?$/)
-  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_nsq
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-26 00:00:00.000000000 Z
+date: 2012-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nio4r
@@ -107,7 +107,7 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: Ruby client for NSQ modeled after pynsq
+description: Ruby client for the NSQ realtime message processing system
 email:
 - bradpardee@gmail.com
 executables: []
@@ -118,15 +118,20 @@ files:
 - lib/nsq/connection.rb
 - lib/nsq/loggable.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/writer.rb
+- examples/async/README
+- examples/simple/publisher.rb
 - examples/simple/reader.rb
+- examples/simple/README
 - LICENSE.txt
 - Rakefile
 - History.md
@@ -147,7 +152,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1380563601085235267
+      hash: 1267684542890965568
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -156,7 +161,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1380563601085235267
+      hash: 1267684542890965568
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23

data/examples/async/writer.rb

@@ -1,17 +0,0 @@
-#!/usr/bin/env ruby
-
-if ARGV.length != 3
-  $stderr.puts "ruby writer.rb <topic> <count> <eval-string>"
-  $stderr.puts "  where <topic> is either test_xy or test_z"
-  $stderr.puts "  and <eval-string> could be something like 'sleep rand(100)/10.0'"
-  $stderr.puts "  Example: ./writer.rb test_xy 500 'sleep rand(100)/10.0'"
-  $stderr.puts "       or: ./writer.rb test_z 5000 nil"
-  exit 1
-end
-topic       = ARGV[0]
-count       = ARGV[1].to_i
-eval_string = ARGV[2]
-# TODO: Figure out TCP protocol
-count.times do
-  system "curl -d #{eval_string.inspect} 'http://127.0.0.1:4151/put?topic=#{topic}'"
-end