nats 0.3.12 → 0.4.2

data/COPYING

@@ -1,4 +1,4 @@
-Copyright (c) 2010 Derek Collison <derek.collison@gmail.com>. All rights reserved.
+Copyright (c) 2010, 2011 Derek Collison <derek.collison@gmail.com>. All rights reserved.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to

data/ChangeLog

@@ -0,0 +1,11 @@
+2011-02-21, version 0.4.2
+  * queue group support
+  * auto-unsubscribe support
+  * time expiration on subscriptions
+  * jruby initial support (1.5.6, 1.6.0-RC1)
+  * performance enhancements
+  * complete config file support
+
+2010-11-20, version 0.3.12
+  * original upload to RubyGems
+

data/README.md

@@ -1,6 +1,6 @@
 # NATS
 
-EventMachine based Publish-Subscribe Messaging that just works.
+A lightweight EventMachine based publish-subscribe messaging system.
 
 ## Supported Platforms
 
@@ -8,15 +8,12 @@ This gem currently works on the following Ruby platforms:
 
 - MRI 1.8 and 1.9 (Performance is best on 1.9.2)
 - Rubinius
-- JRuby (not quite yet)
+- JRuby
 
 ## Getting Started
 
     [sudo] gem install nats
-
-     or
-
-    git clone
+     == or ==
     [sudo] rake geminstall
 
     nats-sub foo &
@@ -34,46 +31,72 @@ This gem currently works on the following Ruby platforms:
       # Simple Publisher
       NATS.publish('foo.bar.baz', 'Hello World!')
 
-      # Publish with closure, callback fires when server has processed the message
-      NATS.publish('foo', 'You done?') { puts 'msg processed!' }
-
       # Unsubscribing
-      s = NATS.subscribe('bar') { |msg| puts "Msg received : '#{msg}'" }
-      NATS.unsubscribe(s)
+      sid = NATS.subscribe('bar') { |msg| puts "Msg received : '#{msg}'" }
+      NATS.unsubscribe(sid)
 
-      # Request/Response
+      # Requests
+      NATS.request('help') { |response| puts "Got a response: '#{response}'" }
 
-      # The helper
-      NATS.subscribe('help') do |msg, reply|
-        NATS.publish(reply, "I'll help!")
-      end
+      # Replies
+      NATS.subscribe('help') { |msg, reply| NATS.publish(reply, "I'll help!") }
 
-      # Help request
-      NATS.request('help') { |response|
-        puts "Got a response: '#{response}'"
-      }
+      # Stop using NATS.stop, exits EM loop if NATS.start started the loop
+      NATS.stop
 
-      # Wildcard Subscriptions
+    end
 
-      # '*" matches any token
-      NATS.subscribe('foo.*.baz') { |msg, _, sub| puts "Msg received on [#{sub}] : '#{msg}'" }
+## Wildcard Subscriptions
 
-      # '>" can only be last token, and matches to any depth
-      NATS.subscribe('foo.>') { |msg, _, sub| puts "Msg received on [#{sub}] : '#{msg}'" }
+      # '*" matches any token, at any level of the subject.
+      NATS.subscribe('foo.*.baz') { |msg, reply, sub| puts "Msg received on [#{sub}] : '#{msg}'" }
+      NATS.subscribe('foo.bar.*') { |msg, reply, sub| puts "Msg received on [#{sub}] : '#{msg}'" }
+      NATS.subscribe('*.bar.*') { |msg, reply, sub| puts "Msg received on [#{sub}] : '#{msg}'" }
 
+      # '>" matches any length of the tail of a subject and can only be last token
+      # E.g. 'foo.>' will match 'foo.bar', 'foo.bar.baz', 'foo.foo.bar.bax.22'
+      NATS.subscribe('foo.>') { |msg, reply, sub| puts "Msg received on [#{sub}] : '#{msg}'" }
 
-      # Stop using NATS.stop, exits EM loop if NATS.start started it
-      NATS.stop
+## Queues Groups
+
+      # All subscriptions with the same queue name will form a queue group
+      # Each message will be delivered to only one subscriber per queue group, queuing semantics
+      # You can have as many queue groups as you wish
+      # Normal subscribers will continue to work as expected.
+      NATS.subscribe(subject, :queue => 'job.workers') { |msg| puts "Received '#{msg}'" }
+
+## Advanced Usage
+
+      # Publish with closure, callback fires when server has processed the message
+      NATS.publish('foo', 'You done?') { puts 'msg processed!' }
+
+      # Timeouts for subscriptions
+      sid = NATS.subscribe('foo') { received += 1 }
+      NATS.timeout(sid, TIMEOUT_IN_SECS) { timeout_recvd = true }
+
+      # Timeout unless a certain number of messages have been received
+      NATS.timeout(sid, TIMEOUT_IN_SECS, :expected => 2) { timeout_recvd = true }
+
+      # Auto-unsubscribe after MAX_WANTED messages received
+      NATS.unsubscribe(sid, MAX_WANTED)
+
+      # Multiple connections
+      NATS.subscribe('test') do |msg|
+        puts "received msg"
+        NATS.stop
+      end
+
+      # Form second connection to send message on
+      NATS.connect { NATS.publish('test', 'Hello World!') }
 
-    end
 
-See examples and benchmark for more..
+See examples and benchmark for more information..
 
 ## License
 
 (The MIT License)
 
-Copyright (c) 2010 Derek Collison
+Copyright (c) 2010, 2011 Derek Collison
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to

data/Rakefile

@@ -1,8 +1,8 @@
 
-desc "Run rspec" 
+desc "Run rspec"
 task :spec do
+  sh('bundle install')
   require "rspec/core/rake_task"
-
   RSpec::Core::RakeTask.new do |t|
     t.rspec_opts = %w(-fs -c)
   end

data/bin/nats-queue

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'nats/client'
+
+trap("TERM") { NATS.stop }
+trap("INT")  { NATS.stop }
+
+def usage
+  puts "Usage: nats-queue <subject> <queue name>"; exit
+end
+
+subject, queue_group = ARGV
+usage unless subject and queue_group
+
+NATS.on_error { |err| puts "Server Error: #{err}"; exit! }
+
+NATS.start do
+  puts "Listening on [#{subject}], queue group [#{queue_group}]"
+  NATS.subscribe(subject, queue_group) { |msg| puts "Received '#{msg}'" }
+end

data/lib/nats/client.rb

@@ -1,84 +1,33 @@
-
 require 'uri'
 
-require File.dirname(__FILE__) + '/ext/em'
-require File.dirname(__FILE__) + '/ext/bytesize'
-require File.dirname(__FILE__) + '/ext/json'
-
-# NATS is a simple publish-subscribe messaging system.
-#
-# == Usage
-# <tt>
-#    require "nats/client"
-#
-#    NATS.start do
-#
-#      # Simple Subscriber
-#      NATS.subscribe('foo') { |msg| puts "Msg received : '#{msg}'" }
-#
-#      # Simple Publisher
-#      NATS.publish('foo.bar.baz', 'Hello World!')
-#
-#      # Publish with closure, callback fires when server has processed the message
-#      NATS.publish('foo', 'You done?') { puts 'msg processed!' }
-#
-#      # Unsubscribing
-#      s = NATS.subscribe('bar') { |msg| puts "Msg received : '#{msg}'" }
-#      NATS.unsubscribe(s)
-#
-#      # Request/Response
-#
-#      # The helper
-#      NATS.subscribe('help') do |msg, reply|
-#        NATS.publish(reply, "I'll help!")
-#      end
-#
-#      # Help request
-#      NATS.request('help') { |response|
-#        puts "Got a response: '#{response}'"
-#      }
-#
-#      # Wildcard Subscriptions
-#
-#      # '*" matches any token
-#      NATS.subscribe('foo.*.baz') { |msg, _, sub| puts "Msg received on [#{sub}] : '#{msg}'" }
-#
-#      # '>" can only be last token, and matches to any depth
-#      NATS.subscribe('foo.>') { |msg, _, sub| puts "Msg received on [#{sub}] : '#{msg}'" }
-#
-#
-#      # Stop using NATS.stop, exits EM loop if NATS.start started it
-#      NATS.stop
-#
-#    end
-#
-# </tt>
+ep = File.expand_path(File.dirname(__FILE__))
 
+require "#{ep}/ext/em"
+require "#{ep}/ext/bytesize"
+require "#{ep}/ext/json"
 
 module NATS
 
-  # Version <b>0.3.12</b>
-  VERSION = "0.3.12".freeze
+  VERSION = "0.4.2".freeze
 
-  # Default port: <b>4222</b>
   DEFAULT_PORT = 4222
-
-  # Default URI to connect to the server, <b>nats://localhost:4222</b>
   DEFAULT_URI = "nats://localhost:#{DEFAULT_PORT}".freeze
 
-  # Max attempts at a reconnect: <b>10</b>
   MAX_RECONNECT_ATTEMPTS = 10
-
-  # Maximum time to wait for a reconnect: <b>2 seconds</b>
   RECONNECT_TIME_WAIT = 2
 
+  AUTOSTART_PID_FILE = '/tmp/nats-server.pid'
+  AUTOSTART_LOG_FILE = '/tmp/nats-server.log'
+
   # Protocol
-  MSG  = /^MSG\s+(\S+)\s+(\S+)\s+((\S+)\s+)?(\d+)$/i #:nodoc:
-  OK   = /^\+OK/i #:nodoc:
-  ERR  = /^-ERR\s+('.+')?/i #:nodoc:
-  PING = /^PING/i #:nodoc:
-  PONG = /^PONG/i #:nodoc:
-  INFO = /^INFO\s+(.+)/i #:nodoc:
+  # @private
+  MSG      = /\AMSG\s+([^\s\r\n]+)\s+([^\s\r\n]+)\s+(([^\s\r\n]+)[^\S\r\n]+)?(\d+)\r\n/i #:nodoc:
+  OK       = /\A\+OK\s*\r\n/i #:nodoc:
+  ERR      = /\A-ERR\s+('.+')?\r\n/i #:nodoc:
+  PING     = /\APING\r\n/i #:nodoc:
+  PONG     = /\APONG\r\n/i #:nodoc:
+  INFO     = /\AINFO\s+([^\r\n]+)\r\n/i  #:nodoc:
+  UNKNOWN  = /\A(.*)\r\n/  #:nodoc:
 
   # Responses
   CR_LF = ("\r\n".freeze) #:nodoc:
@@ -93,6 +42,10 @@ module NATS
   SUB = /^([^\.\*>\s]+|>$|\*)(\.([^\.\*>\s]+|>$|\*))*$/ #:nodoc:
   SUB_NO_WC = /^([^\.\*>\s]+)(\.([^\.\*>\s]+))*$/ #:nodoc:
 
+  # Parser
+  AWAITING_CONTROL_LINE = 1 #:nodoc:
+  AWAITING_MSG_PAYLOAD  = 2 #:nodoc:
+
   # Duplicate autostart protection
   @@tried_autostart = {}
 
@@ -100,72 +53,142 @@ module NATS
   end
 
   class << self
-    attr_reader :client, :reactor_was_running, :err_cb, :err_cb_overridden #:nodoc:
+    attr_reader   :client, :reactor_was_running, :err_cb, :err_cb_overridden #:nodoc:
+    attr_accessor :timeout_cb #:nodoc
+
     alias :reactor_was_running? :reactor_was_running
 
-    # Create and return a connection to the server with the given options. The server will be autostarted if needed if
-    # the <b>uri</b> is determined to be local. The optional block will be called when the connection has been completed.
+    # Create and return a connection to the server with the given options.
+    # The server will be autostarted if needed if the <b>uri</b> is determined to be local.
+    # The optional block will be called when the connection has been completed.
     #
-    def connect(options = {}, &blk)
-      options[:uri] ||= ENV['NATS_URI'] || DEFAULT_URI
-      options[:debug] ||= ENV['NATS_DEBUG']
-      options[:autostart] = (ENV['NATS_AUTO'] || true) unless options[:autostart] != nil
-      uri = options[:uri] = URI.parse(options[:uri])
-      @err_cb = proc { raise Error, "Could not connect to server on #{uri}."} unless err_cb
-      check_autostart(uri) if options[:autostart]
-      client = EM.connect(uri.host, uri.port, self, options)
+    # @param [Hash] opts
+    # @option opts [String] :uri The URI to connect to, example nats://localhost:4222
+    # @option opts [Boolean] :autostart Boolean that can be used to suppress autostart functionality.
+    # @option opts [Boolean] :reconnect Boolean that can be used to suppress reconnect functionality.
+    # @option opts [Boolean] :debug Boolean that can be used to output additional debug information.
+    # @option opts [Boolean] :verbose Boolean that is sent to server for setting verbose protocol mode.
+    # @option opts [Boolean] :pedantic Boolean that is sent to server for setting pedantic mode.
+    # @param [Block] &blk called when the connection is completed. Connection will be passed to the block.
+    # @return [NATS] connection to the server.
+    def connect(opts={}, &blk)
+      # Defaults
+      opts[:verbose] = false if opts[:verbose].nil?
+      opts[:pedantic] = false if opts[:pedantic].nil?
+      opts[:reconnect] = true if opts[:reconnect].nil?
+
+      # Override with ENV
+      opts[:uri] ||= ENV['NATS_URI'] || DEFAULT_URI
+      opts[:verbose] = ENV['NATS_VERBOSE'] unless ENV['NATS_VERBOSE'].nil?
+      opts[:pedantic] = ENV['NATS_PEDANTIC'] unless ENV['NATS_PEDANTIC'].nil?
+      opts[:debug] = ENV['NATS_DEBUG'] if !ENV['NATS_DEBUG'].nil?
+      opts[:autostart] = (ENV['NATS_AUTO'] || true) if opts[:autostart].nil?
+
+      @uri = opts[:uri] = URI.parse(opts[:uri])
+      @err_cb = proc { raise Error, "Could not connect to server on #{@uri}."} unless err_cb
+      check_autostart(@uri) if opts[:autostart]
+      client = EM.connect(@uri.host, @uri.port, self, opts)
       client.on_connect(&blk) if blk
       return client
     end
 
-    # Create a default client connection to the server. See connect for more information.
+    # Create a default client connection to the server.
+    # @see NATS::connect
     def start(*args, &blk)
       @reactor_was_running = EM.reactor_running?
       unless (@reactor_was_running || blk)
         raise(Error, "EM needs to be running when NATS.start called without a run block")
       end
+      # Setup optimized select versions
+      EM.epoll; EM.kqueue
       EM.run { @client = connect(*args, &blk) }
     end
 
     # Close the default client connection and optionally call the associated block.
+    # @param [Block] &blk called when the connection is closed.
     def stop(&blk)
       client.close if (client and client.connected?)
       blk.call if blk
+      @@tried_autostart = {}
+      @err_cb = nil
+    end
+
+    # @return [Boolean] Connected state
+    def connected?
+      return false unless client
+      client.connected?
+    end
+
+    # @return [Hash] Options
+    def options
+      return {} unless client
+      client.options
     end
 
     # Set the default on_error callback.
+    # @param [Block] &callback called when an error has been detected.
     def on_error(&callback)
       @err_cb, @err_cb_overridden = callback, true
     end
 
-    # Publish a message using the default client connection. See NATS#publish for more information.
+    # Publish a message using the default client connection.
+    # @see NATS#publish
     def publish(*args, &blk)
       (@client ||= connect).publish(*args, &blk)
     end
 
-    # Subscribe using the default client connection. See NATS#subscribe for more information.
+    # Subscribe using the default client connection.
+    # @see NATS#subscribe
     def subscribe(*args, &blk)
       (@client ||= connect).subscribe(*args, &blk)
     end
 
     # Cancel a subscription on the default client connection.
+    # @see NATS#unsubscribe
     def unsubscribe(*args)
       (@client ||= connect).unsubscribe(*args)
     end
 
-    # Publish a message and wait for a response on the default client connection. See NATS#request for more information.
+    # Set a timeout for receiving messages for the subscription.
+    # @see NATS#timeout
+    def timeout(*args, &blk)
+      (@client ||= connect).timeout(*args, &blk)
+    end
+
+    # Publish a message and wait for a response on the default client connection.
+    # @see NATS#request
     def request(*args, &blk)
       (@client ||= connect).request(*args, &blk)
     end
 
-    # Returns a subject that can be used for "directed" communications, utilized in #request.
+    # Returns a subject that can be used for "directed" communications.
+    # @return [String]
     def create_inbox
       v = [rand(0x0010000),rand(0x0010000),rand(0x0010000),
            rand(0x0010000),rand(0x0010000),rand(0x1000000)]
       "_INBOX.%04x%04x%04x%04x%04x%06x" % v
     end
 
-    def check_autostart(uri) #:nodoc:
+    def wait_for_server(uri, max_wait = 5) # :nodoc:
+      start = Time.now
+      while (Time.now - start < max_wait) # Wait max_wait seconds max
+        break if server_running?(uri)
+        sleep(0.1)
+      end
+    end
+
+    def server_running?(uri) # :nodoc:
+      require 'socket'
+      s = TCPSocket.new(uri.host, uri.port)
+      s.close
+      return true
+    rescue
+      return false
+    end
+
+    private
+
+    def check_autostart(uri)
       return if uri_is_remote?(uri) || @@tried_autostart[uri]
       @@tried_autostart[uri] = true
       return if server_running?(uri)
@@ -173,41 +196,25 @@ module NATS
       wait_for_server(uri)
     end
 
-    def uri_is_remote?(uri) #:nodoc:
+    def uri_is_remote?(uri)
       uri.host != 'localhost' && uri.host != '127.0.0.1'
     end
 
-    def try_autostart_succeeded?(uri) #:nodoc:
+    def try_autostart_succeeded?(uri)
       port_arg = "-p #{uri.port}"
       user_arg = "--user #{uri.user}" if uri.user
       pass_arg = "--pass #{uri.password}" if uri.password
-      log_arg  = '-l /tmp/nats-server.log'
-      pid_arg  = '-P /tmp/nats-server.pid'
+      log_arg  = "-l #{AUTOSTART_LOG_FILE}"
+      pid_arg  = "-P #{AUTOSTART_PID_FILE}"
       # daemon mode to release client
       system("nats-server #{port_arg} #{user_arg} #{pass_arg} #{log_arg} #{pid_arg} -d 2> /dev/null")
       $? == 0
     end
 
-    def wait_for_server(uri) #:nodoc:
-      start = Time.now
-      while (Time.now - start < 5) # Wait 5 seconds max
-        break if server_running?(uri)
-        sleep(0.1)
-      end
-    end
-
-    def server_running?(uri) #:nodoc:
-      require 'socket'
-      s = TCPSocket.new(uri.host, uri.port)
-      s.close
-      return true
-    rescue
-      return false
-    end
-
   end
 
-  attr_reader :connect_cb, :err_cb, :err_cb_overridden, :connected, :closing, :reconnecting #:nodoc:
+  attr_reader :connected, :connect_cb, :err_cb, :err_cb_overridden #:nodoc:
+  attr_reader :closing, :reconnecting, :options #:nodoc
 
   alias :connected? :connected
   alias :closing? :closing
@@ -215,7 +222,9 @@ module NATS
 
   def initialize(options)
     @uri = options[:uri]
-    @debug = options[:debug]
+    @uri.user = options[:user] if options[:user]
+    @uri.password = options[:pass] if options[:pass]
+    @options = options
     @ssid, @subs = 1, {}
     @err_cb = NATS.err_cb
     @reconnect_timer, @needed = nil, nil
@@ -224,36 +233,78 @@ module NATS
   end
 
   # Publish a message to a given subject, with optional reply subject and completion block
-  def publish(subject, data=EMPTY_MSG, opt_reply=nil, &blk)
+  # @param [String] subject
+  # @param [Object, #to_s] msg
+  # @param [String] opt_reply
+  # @param [Block] blk, closure called when publish has been processed by the server.
+  def publish(subject, msg=EMPTY_MSG, opt_reply=nil, &blk)
     return unless subject
-    data = data.to_s
-    send_command("PUB #{subject} #{opt_reply} #{data.bytesize}#{CR_LF}#{data}#{CR_LF}")
+    msg = msg.to_s
+    send_command("PUB #{subject} #{opt_reply} #{msg.bytesize}#{CR_LF}#{msg}#{CR_LF}")
     queue_server_rt(&blk) if blk
   end
 
-  # Subscribe to a subject with optional wildcards. Messages will be delivered to the supplied callback.
+  # Subscribe to a subject with optional wildcards.
+  # Messages will be delivered to the supplied callback.
   # Callback can take any number of the supplied arguments as defined by the list: msg, reply, sub.
-  # Returns subscription id which can be passed to NATS#unsubscribe.
-  def subscribe(subject, &callback)
+  # Returns subscription id which can be passed to #unsubscribe.
+  # @param [String] subject, optionally with wilcards.
+  # @param [Hash] opts, optional options hash, e.g. :queue, :max.
+  # @param [Block] callback, called when a message is delivered.
+  # @return [Object] sid, Subject Identifier
+  def subscribe(subject, opts={}, &callback)
     return unless subject
-    @ssid += 1
-    @subs[@ssid] = { :subject => subject, :callback => callback }
-    send_command("SUB #{subject} #{@ssid}#{CR_LF}")
-    @ssid
+    sid = (@ssid += 1)
+    sub = @subs[sid] = { :subject => subject, :callback => callback, :received => 0 }
+    sub[:queue] = opts[:queue] if opts[:queue]
+    sub[:max] = opts[:max] if opts[:max]
+    send_command("SUB #{subject} #{opts[:queue]} #{sid}#{CR_LF}")
+    # Setup server support for auto-unsubscribe
+    unsubscribe(sid, opts[:max]) if opts[:max]
+    sid
   end
 
   # Cancel a subscription.
-  def unsubscribe(sid)
-    @subs.delete(sid)
-    send_command("UNSUB #{sid}#{CR_LF}")
+  # @param [Object] sid
+  # @param [Number] opt_max, optional number of responses to receive before auto-unsubscribing
+  def unsubscribe(sid, opt_max=nil)
+    opt_max_str = " #{opt_max}" unless opt_max.nil?
+    send_command("UNSUB #{sid}#{opt_max_str}#{CR_LF}")
+    return unless sub = @subs[sid]
+    sub[:max] = opt_max
+    @subs.delete(sid) unless (sub[:max] && (sub[:received] < sub[:max]))
+  end
+
+  # Setup a timeout for receiving messages for the subscription.
+  # @param [Object] sid
+  # @param [Number] timeout, float in seconds
+  # @param [Hash] opts, options, :auto_unsubscribe(true), :expected(1)
+  def timeout(sid, timeout, opts={}, &callback)
+    # Setup a timeout if requested
+    return unless sub = @subs[sid]
+
+    auto_unsubscribe, expected = true, 1
+    auto_unsubscribe = opts[:auto_unsubscribe] if opts.key?(:auto_unsubscribe)
+    expected = opts[:expected] if opts.key?(:expected)
+
+    EM.cancel_timer(sub[:timeout]) if sub[:timeout]
+
+    sub[:timeout] = EM.add_timer(timeout) do
+      unsubscribe(sid) if auto_unsubscribe
+      callback.call(sid) if callback
+    end
+    sub[:expected] = expected
   end
 
   # Send a request and have the response delivered to the supplied callback.
-  # Returns subscription id which can be passed to NATS#unsubscribe.
-  def request(subject, data=nil, &cb)
+  # @param [String] subject
+  # @param [Object] msg
+  # @param [Block] callback
+  # @return [Object] sid
+  def request(subject, data=nil, opts={}, &cb)
     return unless subject
     inbox = NATS.create_inbox
-    s = subscribe(inbox) { |msg, reply|
+    s = subscribe(inbox, opts) { |msg, reply|
       case cb.arity
         when 0 then cb.call
         when 1 then cb.call(msg)
@@ -265,16 +316,19 @@ module NATS
   end
 
   # Define a callback to be called when the client connection has been established.
+  # @param [Block] callback
   def on_connect(&callback)
     @connect_cb = callback
   end
 
   # Define a callback to be called when errors occur on the client connection.
+  # @param [Block] &blk called when the connection is closed.
   def on_error(&callback)
     @err_cb, @err_cb_overridden = callback, true
   end
 
   # Define a callback to be called when a reconnect attempt is being made.
+  # @param [Block] &blk called when the connection is closed.
   def on_reconnect(&callback)
     @reconnect_cb = callback
   end
@@ -285,12 +339,12 @@ module NATS
     close_connection_after_writing
   end
 
-  def user_err_cb? #:nodoc:
+  def user_err_cb? # :nodoc:
     err_cb_overridden || NATS.err_cb_overridden
   end
 
   def send_connect_command #:nodoc:
-    cs = { :verbose => false, :pedantic => false }
+    cs = { :verbose => @options[:verbose], :pedantic => @options[:pedantic] }
     if @uri.user
       cs[:user] = @uri.user
       cs[:pass] = @uri.password
@@ -305,8 +359,13 @@ module NATS
   end
 
   def on_msg(subject, sid, reply, msg) #:nodoc:
-    return unless subscriber = @subs[sid]
-    if cb = subscriber[:callback]
+    return unless sub = @subs[sid]
+
+    # Check for auto_unsubscribe
+    sub[:received] += 1
+    return unsubscribe(sid) if (sub[:max] && (sub[:received] > sub[:max]))
+
+    if cb = sub[:callback]
       case cb.arity
         when 0 then cb.call
         when 1 then cb.call(msg)
@@ -314,6 +373,12 @@ module NATS
         else cb.call(msg, reply, subject)
       end
     end
+
+    # Check for a timeout, and cancel if received >= expected
+    if (sub[:timeout] && sub[:received] >= sub[:expected])
+      EM.cancel_timer(sub[:timeout])
+      sub[:timeout] = nil
+    end
   end
 
   def flush_pending #:nodoc:
@@ -323,39 +388,55 @@ module NATS
   end
 
   def receive_data(data) #:nodoc:
-    (@buf ||= '') << data
-    while (@buf && !@buf.empty?)
-      if (@needed && @buf.bytesize >= @needed + CR_LF_SIZE)
-        payload = @buf.slice(0, @needed)
-        on_msg(@sub, @sid, @reply, payload)
-        @buf = @buf.slice((@needed + CR_LF_SIZE), @buf.bytesize)
-        @sub = @sid = @reply = @needed = nil
-      elsif @buf =~ /^(.*)\r\n/ # Process a control line
-        @buf = $'
-        op = $1
-        case op
-          when MSG
-            @sub, @sid, @reply, @needed = $1, $2.to_i, $4, $5.to_i
-          when OK # No-op right now
-          when ERR
-            @err_cb = proc { raise Error, "Error received from server :#{$1}."} unless user_err_cb?
-            err_cb.call($1)
-          when PING
-            send_command(PONG_RESPONSE)
-          when PONG
-            cb = @pongs.shift
-            cb.call if cb
-          when INFO
-            process_info($1)
+    @buf = @buf ? @buf << data : data
+    while (@buf)
+        case @parse_state
+
+          when AWAITING_CONTROL_LINE
+            case @buf
+              when MSG
+                @buf = $'
+                @sub, @sid, @reply, @needed = $1, $2.to_i, $4, $5.to_i
+                @parse_state = AWAITING_MSG_PAYLOAD
+              when OK # No-op right now
+                @buf = $'
+              when ERR
+                @buf = $'
+                @err_cb = proc { raise Error, "Error received from server :#{$1}."} unless user_err_cb?
+                err_cb.call($1)
+              when PING
+                @buf = $'
+                send_command(PONG_RESPONSE)
+              when PONG
+                @buf = $'
+                cb = @pongs.shift
+                cb.call if cb
+              when INFO
+                @buf = $'
+                process_info($1)
+              when UNKNOWN
+                @buf = $'
+                @err_cb = proc { raise Error, "Error: Ukknown Protocol."} unless user_err_cb?
+                err_cb.call($1)
+              else
+                # If we are here we do not have a complete line yet that we understand.
+                return
+            end
+            @buf = nil if (@buf && @buf.empty?)
+
+          when AWAITING_MSG_PAYLOAD
+            return unless (@needed && @buf.bytesize >= (@needed + CR_LF_SIZE))
+            on_msg(@sub, @sid, @reply, @buf.slice(0, @needed))
+            @buf = @buf.slice((@needed + CR_LF_SIZE), @buf.bytesize)
+            @sub = @sid = @reply = @needed = nil
+            @parse_state = AWAITING_CONTROL_LINE
+            @buf = nil if (@buf && @buf.empty?)
         end
-      else # Waiting for additional data
-        return
-      end
     end
   end
 
   def process_info(info) #:nodoc:
-    @server_info = JSON.parse(info, :symbolize_keys => true)
+    @server_info = JSON.parse(info, :symbolize_keys => true, :symbolize_names => true)
   end
 
   def connection_completed #:nodoc:
@@ -366,13 +447,16 @@ module NATS
       @subs.each_pair { |k, v| send_command("SUB #{v[:subject]} #{k}#{CR_LF}") }
     end
     flush_pending if @pending
-    @err_cb = proc { raise Error, "Client disconnected from server on #{@uri}."} unless user_err_cb? or reconnecting?
+    unless user_err_cb? or reconnecting?
+      @err_cb = proc { raise Error, "Client disconnected from server on #{@uri}."}
+    end
     if (connect_cb and not reconnecting?)
       # We will round trip the server here to make sure all state from any pending commands
       # has been processed before calling the connect callback.
       queue_server_rt { connect_cb.call(self) }
     end
     @reconnecting = false
+    @parse_state = AWAITING_CONTROL_LINE
   end
 
   def schedule_reconnect(wait=RECONNECT_TIME_WAIT) #:nodoc:
@@ -382,7 +466,7 @@ module NATS
   end
 
   def unbind #:nodoc:
-    if connected? and not closing? and not reconnecting?
+    if connected? and not closing? and not reconnecting? and @options[:reconnect]
       schedule_reconnect
     else
       process_disconnect unless reconnecting?
@@ -396,7 +480,9 @@ module NATS
     end
   ensure
     EM.cancel_timer(@reconnect_timer) if @reconnect_timer
-    EM.stop if (NATS.client == self and connected? and closing? and not NATS.reactor_was_running?)
+    if (NATS.client == self and connected? and closing? and not NATS.reactor_was_running?)
+      EM.stop
+    end
     @connected = @reconnecting = false
     true # Chaining
   end