nats 0.4.10 → 0.4.22

data/HISTORY.md

@@ -0,0 +1,42 @@
+# HISTORY
+
+## v0.4.22 (Mar 5, 2012)
+
+  - HTTP based server monitoring (/varz, /connz, /healthz)
+  - Perfomance and Stability improvements
+  - Client monitoring
+  - Server to Client pings
+  - Multiple Auth users
+  - SSL/TSL support
+  - nats-top utility
+  - Connection state dump on SIGUSR2
+  - Client Server information support
+  - Client Fast Producer support
+  - Client reconenct callbacks
+  - Server Max Connections support
+  - See full list @ https://github.com/derekcollison/nats/compare/v0.4.10...v0.4.22
+
+## v0.4.10 (Apr 21, 2011)
+
+  - Minor bug fixes
+  - See full list @ https://github.com/derekcollison/nats/compare/v0.4.8...v0.4.10
+
+## v0.4.8 (Apr 2, 2011)
+
+  - Minor bug fixes
+  - See full list @ https://github.com/derekcollison/nats/compare/v0.4.2...v0.4.8
+
+## v0.4.2 (Feb 21, 2011)
+
+  - Queue group support
+  - Auto-unsubscribe support
+  - Time expiration on subscriptions
+  - Jruby initial support
+  - Performance enhancements
+  - Complete config file support
+  - See full list @ https://github.com/derekcollison/nats/compare/v0.3.12...v0.4.2
+
+## v0.3.12 (Nov 21, 2010)
+
+  - Initial Release
+

data/README.md

@@ -1,102 +1,114 @@
 # NATS
 
-A lightweight EventMachine based publish-subscribe messaging system.
+A lightweight publish-subscribe and distributed queueing messaging system.
+
+[![Build Status](https://secure.travis-ci.org/derekcollison/nats.png)](http://travis-ci.org/derekcollison/nats)
 
 ## Supported Platforms
 
 This gem currently works on the following Ruby platforms:
 
-- MRI 1.8 and 1.9 (Performance is best on 1.9.2)
+- MRI 1.8 and 1.9 (Performance is best on 1.9.3)
 - Rubinius
 - JRuby
 
+There is a [Node.js](https://github.com/derekcollison/node_nats) client available as well.
+
 ## Getting Started
 
-    [sudo] gem install nats
-     == or ==
-    [sudo] rake geminstall
+```bash
+[sudo] gem install nats
+== or ==
+[sudo] rake geminstall
 
-    nats-sub foo &
-    nats-pub foo "Hello World!'
+nats-sub foo &
+nats-pub foo 'Hello World!'
+```
 
-## Usage
+## Basic Usage
 
-    require "nats/client"
+```ruby
+require "nats/client"
 
-    NATS.start do
+NATS.start do
 
-      # Simple Subscriber
-      NATS.subscribe('foo') { |msg| puts "Msg received : '#{msg}'" }
+  # Simple Subscriber
+  NATS.subscribe('foo') { |msg| puts "Msg received : '#{msg}'" }
 
-      # Simple Publisher
-      NATS.publish('foo.bar.baz', 'Hello World!')
+  # Simple Publisher
+  NATS.publish('foo.bar.baz', 'Hello World!')
 
-      # Unsubscribing
-      sid = NATS.subscribe('bar') { |msg| puts "Msg received : '#{msg}'" }
-      NATS.unsubscribe(sid)
+  # Unsubscribing
+  sid = NATS.subscribe('bar') { |msg| puts "Msg received : '#{msg}'" }
+  NATS.unsubscribe(sid)
 
-      # Requests
-      NATS.request('help') { |response| puts "Got a response: '#{response}'" }
+  # Requests
+  NATS.request('help') { |response| puts "Got a response: '#{response}'" }
 
-      # Replies
-      NATS.subscribe('help') { |msg, reply| NATS.publish(reply, "I'll help!") }
+  # Replies
+  NATS.subscribe('help') { |msg, reply| NATS.publish(reply, "I'll help!") }
 
-      # Stop using NATS.stop, exits EM loop if NATS.start started the loop
-      NATS.stop
+  # Stop using NATS.stop, exits EM loop if NATS.start started the loop
+  NATS.stop
 
-    end
+end
+```
 
 ## Wildcard Subscriptions
 
-      # '*" 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}'" }
+```ruby
+# "*" 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}'" }
+# ">" matches any length of the tail of a subject and can only be the 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}'" }
+```
 
 ## 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}'" }
+```ruby
+# 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
+```ruby
+# Publish with closure, callback fires when server has processed the message
+NATS.publish('foo', 'You done?') { puts 'msg processed!' }
 
-      # 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 }
+# Timeouts for subscriptions
+sid = NATS.subscribe('foo') { received += 1 }
+NATS.timeout(sid, TIMEOUT_IN_SECS) { timeout_recvd = true }
 
-      # Auto-unsubscribe after MAX_WANTED messages received
-      NATS.unsubscribe(sid, MAX_WANTED)
+# Timeout unless a certain number of messages have been received
+NATS.timeout(sid, TIMEOUT_IN_SECS, :expected => 2) { timeout_recvd = true }
 
-      # Multiple connections
-      NATS.subscribe('test') do |msg|
-        puts "received msg"
-        NATS.stop
-      end
+# Auto-unsubscribe after MAX_WANTED messages received
+NATS.unsubscribe(sid, MAX_WANTED)
 
-      # Form second connection to send message on
-      NATS.connect { NATS.publish('test', 'Hello World!') }
+# 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!') }
+```
 
-See examples and benchmark for more information..
+See examples and benchmarks for more information..
 
 ## License
 
 (The MIT License)
 
-Copyright (c) 2010, 2011 Derek Collison
+Copyright (c) 2010-2012 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,4 +1,3 @@
-
 desc "Run rspec"
 task :spec do
   sh('bundle install')
@@ -7,6 +6,7 @@ task :spec do
     t.rspec_opts = %w(-fs -c)
   end
 end
+task :default => :spec
 
 desc "Build the gem"
 task :gem do

data/bin/nats-request

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'rubygems'
+require 'nats/client'
+
+['TERM', 'INT'].each { |s| trap(s) {  puts; exit! } }
+
+def usage
+  puts "Usage: nats-request <subject> <msg> [-s server] [-t] [-n responses]"; exit
+end
+
+args = ARGV.dup
+opts_parser = OptionParser.new do |opts|
+  opts.on('-s SERVER') { |server| $nats_server = server }
+  opts.on('-t') { $show_time = true }
+  opts.on('-n RESPONSES') { |responses| $responses = Integer(responses) if Integer(responses) > 0 }
+end
+args = opts_parser.parse!(args)
+
+subject, msg = args
+usage unless subject
+msg ||= 'Hello World'
+
+def time_prefix
+  "[#{Time.now}] " if $show_time
+end
+
+def header
+  $i=0 unless $i
+  "#{time_prefix}[\##{$i+=1}]"
+end
+
+NATS.on_error { |err| puts "Server Error: #{err}"; exit! }
+
+NATS.start(:uri => $nats_server, :autostart => true) do
+  NATS.request(subject, msg) { |(msg, reply)|
+    puts "#{header} Replied with : '#{msg}'"
+    exit! if $responses && ($responses-=1) < 1
+  }
+end

data/bin/nats-top

@@ -0,0 +1,146 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'net/http'
+require 'uri'
+require 'io/wait'
+
+require 'rubygems'
+require 'json'
+
+def usage
+  puts "Usage: nats-top [-s server_uri] [-m local monitor port] [-n num_connections] [-d delay_secs] [--sort sort_by]"
+  puts "--sort_options for more help"
+  exit
+end
+
+$valid_sort_options = ['pending_size', 'msgs_to', 'msgs_from', 'bytes_to', 'bytes_from', 'subs']
+
+def sort_options_help
+  puts "Available sort_by options: #{$valid_sort_options.join(', ')}."
+  puts "E.g. #{$0} -s bytes_to"
+  exit
+end
+
+args = ARGV.dup
+opts_parser = OptionParser.new do |opts|
+  opts.on('-s server_uri')      { |server|   $nats_server = server }
+  opts.on('-m local_port')      { |port|     $nats_port = port.to_i }
+  opts.on('-n num_connections') { |num|      $num_connections = num.to_i }
+  opts.on('-d delay')           { |delay|    $delay = delay.to_f }
+  opts.on('--sort sort_by')     { |sort_key| $sort_key = sort_key }
+  opts.on('--sort_options')     { sort_options_help }
+  opts.on('-h')     { usage }
+  opts.on('--help') { usage }
+end
+args = opts_parser.parse!(args)
+
+DEFAULT_MONITOR_PORT = 9222
+DEFAULT_NUM_CONNECTIONS = 10
+DEFAULT_DELAY = 1 #sec
+DEFAULT_SORT = 'pending_size'
+
+$nats_port = DEFAULT_MONITOR_PORT if $nats_port.nil?
+$num_connections = DEFAULT_NUM_CONNECTIONS if $num_connections.nil?
+$nats_server = "http://localhost:#{$nats_port}" if $nats_server.nil?
+
+$nats_server = "http://#{$nats_server}" unless $nats_server.start_with?('http')
+
+$delay = DEFAULT_DELAY if $delay.nil?
+$sort_key = DEFAULT_SORT if $sort_key.nil?
+$sort_key.downcase!
+
+unless $valid_sort_options.include?($sort_key)
+  puts "Invalid sort_by argument: #{$sort_key}"
+  sort_options_help
+end
+
+varz_uri = URI.parse("#{$nats_server}/varz")
+connz_uri = URI.parse("#{$nats_server}/connz?n=#{$num_connections}&s=#{$sort_key}")
+
+def psize(size, prec=1)
+  return 'NA' unless size
+  return sprintf("%.#{prec}f", size) if size < 1024
+  return sprintf("%.#{prec}fK", size/1024.0) if size < (1024*1024)
+  return sprintf("%.#{prec}fM", size/(1024.0*1024.0)) if size < (1024*1024*1024)
+  return sprintf("%.#{prec}fG", size/(1024.0*1024.0*1024.0))
+end
+
+def clear_screen
+  print "\e[H\e[2J"
+end
+
+['TERM', 'INT'].each { |s| trap(s) {  clear_screen; exit! } }
+
+in_last_msgs  = in_last_bytes = 0
+out_last_msgs = out_last_bytes = 0
+
+poll = Time.now
+first = true
+
+while true
+  begin
+
+    varz_response = Net::HTTP::get_response(varz_uri)
+    varz = JSON.parse(varz_response.body, :symbolize_keys => true, :symbolize_names => true)
+
+    # Simple rates
+    delta_in_msgs, in_last_msgs     = varz[:in_msgs] - in_last_msgs, varz[:in_msgs]
+    delta_in_bytes, in_last_bytes   = varz[:in_bytes] - in_last_bytes, varz[:in_bytes]
+    delta_out_msgs, out_last_msgs   = varz[:out_msgs] - out_last_msgs, varz[:out_msgs]
+    delta_out_bytes, out_last_bytes = varz[:out_bytes] - out_last_bytes, varz[:out_bytes]
+
+    now = Time.now
+    tdelta, poll = now - poll, now
+
+    unless first
+      rate_in_msgs = delta_in_msgs / tdelta
+      rate_in_bytes = delta_in_bytes / tdelta
+      rate_out_msgs = delta_out_msgs / tdelta
+      rate_out_bytes = delta_out_bytes / tdelta
+    end
+
+    connz_response = Net::HTTP::get_response(connz_uri)
+    connz = JSON.parse(connz_response.body, :symbolize_keys => true, :symbolize_names => true)
+
+    clear_screen
+
+    puts  "\nServer:"
+    puts  "  Load: CPU: #{varz[:cpu]}%  Memory: #{psize(varz[:mem])}"
+    print "  In:   Msgs: #{psize(varz[:in_msgs])}  Bytes: #{psize(varz[:in_bytes])}"
+    puts  "  Msgs/Sec: #{psize(rate_in_msgs)}  Bytes/Sec: #{psize(rate_in_bytes)}"
+
+    print "  Out:  Msgs: #{psize(varz[:out_msgs])}  Bytes: #{psize(varz[:out_bytes])}"
+    puts  "  Msgs/Sec: #{psize(rate_out_msgs)}  Bytes/Sec: #{psize(rate_out_bytes)}"
+
+    puts "\nConnections: #{psize(connz[:num_connections], 0)}"
+
+    conn_t = "  %-20s %-8s %-6s  %-10s  %-10s  %-10s  %-10s  %-10s\n"
+    printf(conn_t, 'HOST', 'CID', 'SUBS', 'PENDING', 'MSGS_TO', 'MSGS_FROM', 'BYTES_TO', 'BYTES_FROM')
+
+    connz[:connections].each do |conn|
+      printf(conn_t, "#{conn[:ip]}:#{conn[:port]}",
+                     conn[:cid],
+                     psize(conn[:subscriptions]),
+                     psize(conn[:pending_size]),
+                     psize(conn[:out_msgs]),
+                     psize(conn[:in_msgs]),
+                     psize(conn[:out_bytes]),
+                     psize(conn[:in_bytes])
+             )
+    end
+    puts
+
+    first = false
+
+    sleep($delay)
+
+  rescue => e
+    puts "Error: #{e}"
+    exit(1)
+  end
+
+end
+
+
+

data/lib/nats/client.rb

@@ -8,7 +8,7 @@ require "#{ep}/ext/json"
 
 module NATS
 
-  VERSION = "0.4.10".freeze
+  VERSION = '0.4.22'.freeze
 
   DEFAULT_PORT = 4222
   DEFAULT_URI = "nats://localhost:#{DEFAULT_PORT}".freeze
@@ -16,6 +16,11 @@ module NATS
   MAX_RECONNECT_ATTEMPTS = 10
   RECONNECT_TIME_WAIT = 2
 
+  MAX_PENDING_SIZE = 32768
+
+  # Maximum outbound size per client to trigger FP, 20MB
+  FAST_PRODUCER_THRESHOLD = (10*1024*1024)
+
   # Protocol
   # @private
   MSG      = /\AMSG\s+([^\s]+)\s+([^\s]+)\s+(([^\s]+)[^\S\r\n]+)?(\d+)\r\n/i #:nodoc:
@@ -50,19 +55,20 @@ module NATS
   # Duplicate autostart protection
   @@tried_autostart = {}
 
-  class Error < StandardError #:nodoc:
-  end
+  class Error < StandardError; end #:nodoc:
 
   # When the NATS server sends us an ERROR message, this is raised/passed by default
-  class ServerError < Error #:nodoc:
-  end
+  class ServerError < Error; end #:nodoc:
+
+  # When we detect error on the client side (e.g. Fast Producer)
+  class ClientError < Error; end #:nodoc:
 
   # When we cannot connect to the server (either initially or after a reconnect), this is raised/passed
-  class ConnectError < Error #:nodoc:
-  end
+  class ConnectError < Error; end #:nodoc:
 
   class << self
     attr_reader   :client, :reactor_was_running, :err_cb, :err_cb_overridden #:nodoc:
+    attr_reader   :reconnect_cb  #:nodoc
     attr_accessor :timeout_cb #:nodoc
 
     alias :reactor_was_running? :reactor_was_running
@@ -72,12 +78,15 @@ module NATS
     # The optional block will be called when the connection has been completed.
     #
     # @param [Hash] opts
-    # @option opts [String] :uri The URI to connect to, example nats://localhost:4222
+    # @option opts [String|URI] :uri The URI to connect to, example nats://localhost:4222
     # @option opts [Boolean] :autostart Boolean that can be used to engage server 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.
+    # @option opts [Boolean] :ssl Boolean that is sent to server for setting TLS/SSL mode.
+    # @option opts [Integer] :max_reconnect_attempts Integer that can be used to set the max number of reconnect tries
+    # @option opts [Integer] :reconnect_time_wait Integer that can be used to set the number of seconds to wait between reconnect tries
     # @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)
@@ -85,14 +94,22 @@ module NATS
       opts[:verbose] = false if opts[:verbose].nil?
       opts[:pedantic] = false if opts[:pedantic].nil?
       opts[:reconnect] = true if opts[:reconnect].nil?
+      opts[:ssl] = false if opts[:ssl].nil?
+      opts[:max_reconnect_attempts] = MAX_RECONNECT_ATTEMPTS if opts[:max_reconnect_attempts].nil?
+      opts[:reconnect_time_wait] = RECONNECT_TIME_WAIT if opts[:reconnect_time_wait].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?
-      @uri = opts[:uri] = URI.parse(opts[:uri])
-      @err_cb = proc {|e| raise e } unless err_cb
+      opts[:verbose] = ENV['NATS_VERBOSE'].downcase == 'true' unless ENV['NATS_VERBOSE'].nil?
+      opts[:pedantic] = ENV['NATS_PEDANTIC'].downcase == 'true' unless ENV['NATS_PEDANTIC'].nil?
+      opts[:debug] = ENV['NATS_DEBUG'].downcase == 'true' unless ENV['NATS_DEBUG'].nil?
+      opts[:reconnect] = ENV['NATS_RECONNECT'].downcase == 'true' unless ENV['NATS_RECONNECT'].nil?
+      opts[:fast_producer_error] = ENV['NATS_FAST_PRODUCER'].downcase == 'true' unless ENV['NATS_FAST_PRODUCER'].nil?
+      opts[:ssl] = ENV['NATS_SSL'].downcase == 'true' unless ENV['NATS_SSL'].nil?
+      opts[:max_reconnect_attempts] = ENV['NATS_MAX_RECONNECT_ATTEMPTS'].to_i unless ENV['NATS_MAX_RECONNECT_ATTEMPTS'].nil?
+      opts[:reconnect_time_wait] = ENV['NATS_RECONNECT_TIME_WAIT'].to_i unless ENV['NATS_RECONNECT_TIME_WAIT'].nil?
+      @uri = opts[:uri] = opts[:uri].is_a?(URI) ? opts[:uri] : URI.parse(opts[:uri])
+      @err_cb = proc { |e| raise e } unless err_cb
       check_autostart(@uri) if opts[:autostart] == true
 
       client = EM.connect(@uri.host, @uri.port, self, opts)
@@ -115,7 +132,7 @@ module NATS
     # 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?)
+      client.close if (client and (client.connected? || client.reconnecting?))
       blk.call if blk
       @@tried_autostart = {}
       @err_cb = nil
@@ -127,18 +144,36 @@ module NATS
       client.connected?
     end
 
+    # @return [Boolean] Reconnecting state
+    def reconnecting?
+      return false unless client
+      client.reconnecting?
+    end
+
     # @return [Hash] Options
     def options
       return {} unless client
       client.options
     end
 
+    # @return [Hash] Server information
+    def server_info
+      return nil unless client
+      client.server_info
+    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
 
+    # Set the default on_reconnect callback.
+    # @param [Block] &callback called when a reconnect attempt is made.
+    def on_reconnect(&callback)
+      @reconnect_cb = callback
+    end
+
     # Publish a message using the default client connection.
     # @see NATS#publish
     def publish(*args, &blk)
@@ -177,6 +212,18 @@ module NATS
       "_INBOX.%04x%04x%04x%04x%04x%06x" % v
     end
 
+    # Flushes all messages and subscriptions in the default connection
+    # @see NATS#flush
+    def flush(*args, &blk)
+      (@client ||= connect).flush(*args, &blk)
+    end
+
+    # Return bytes outstanding for the default client connection.
+    # @see NATS#pending_data_size
+    def pending_data_size(*args)
+      (@client ||= connect).pending_data_size(*args)
+    end
+
     def wait_for_server(uri, max_wait = 5) # :nodoc:
       start = Time.now
       while (Time.now - start < max_wait) # Wait max_wait seconds max
@@ -194,6 +241,10 @@ module NATS
       return false
     end
 
+    def clear_client # :nodoc:
+      @client = nil
+    end
+
     private
 
     def check_autostart(uri)
@@ -222,7 +273,8 @@ module NATS
   end
 
   attr_reader :connected, :connect_cb, :err_cb, :err_cb_overridden #:nodoc:
-  attr_reader :closing, :reconnecting, :options #:nodoc
+  attr_reader :closing, :reconnecting, :options, :server_info #:nodoc
+  attr_reader :msgs_received, :msgs_sent, :bytes_received, :bytes_sent, :pings
 
   alias :connected? :connected
   alias :closing? :closing
@@ -232,11 +284,15 @@ module NATS
     @uri = options[:uri]
     @uri.user = options[:user] if options[:user]
     @uri.password = options[:pass] if options[:pass]
+    @ssl = options[:ssl] if options[:ssl]
     @options = options
     @ssid, @subs = 1, {}
     @err_cb = NATS.err_cb
     @reconnect_timer, @needed = nil, nil
+    @reconnect_cb = NATS.reconnect_cb
     @connected, @closing, @reconnecting = false, false, false
+    @msgs_received = @msgs_sent = @bytes_received = @bytes_sent = @pings = 0
+    @pending_size = 0
     send_connect_command
   end
 
@@ -248,6 +304,11 @@ module NATS
   def publish(subject, msg=EMPTY_MSG, opt_reply=nil, &blk)
     return unless subject
     msg = msg.to_s
+
+    # Accounting
+    @msgs_sent += 1
+    @bytes_sent += msg.bytesize if msg
+
     send_command("PUB #{subject} #{opt_reply} #{msg.bytesize}#{CR_LF}#{msg}#{CR_LF}")
     queue_server_rt(&blk) if blk
   end
@@ -283,6 +344,12 @@ module NATS
     @subs.delete(sid) unless (sub[:max] && (sub[:received] < sub[:max]))
   end
 
+  # Return the active subscription count.
+  # @return [Number]
+  def subscription_count
+    @subs.size
+  end
+
   # Setup a timeout for receiving messages for the subscription.
   # @param [Object] sid
   # @param [Number] timeout, float in seconds
@@ -323,6 +390,13 @@ module NATS
     return s
   end
 
+  # Flushes all messages and subscriptions for the connection.
+  # All messages and subscriptions have been processed by the server
+  # when the optional callback is called.
+  def flush(&blk)
+    queue_server_rt(&blk) if blk
+  end
+
   # Define a callback to be called when the client connection has been established.
   # @param [Block] callback
   def on_connect(&callback)
@@ -335,7 +409,7 @@ module NATS
     @err_cb, @err_cb_overridden = callback, true
   end
 
-  # Define a callback to be called when a reconnect attempt is being made.
+  # Define a callback to be called when a reconnect attempt is made.
   # @param [Block] &blk called when the connection is closed.
   def on_reconnect(&callback)
     @reconnect_cb = callback
@@ -344,7 +418,14 @@ module NATS
   # Close the connection to the server.
   def close
     @closing = true
-    close_connection_after_writing
+    EM.cancel_timer(@reconnect_timer) if @reconnect_timer
+    close_connection_after_writing if connected?
+    process_disconnect if reconnecting?
+  end
+
+  # Return bytes outstanding waiting to be sent to server.
+  def pending_data_size
+    get_outbound_data_size + @pending_size
   end
 
   def user_err_cb? # :nodoc:
@@ -357,6 +438,7 @@ module NATS
       cs[:user] = @uri.user
       cs[:pass] = @uri.password
     end
+    cs[:ssl_required] = @ssl if @ssl
     send_command("CONNECT #{cs.to_json}#{CR_LF}")
   end
 
@@ -367,10 +449,22 @@ module NATS
   end
 
   def on_msg(subject, sid, reply, msg) #:nodoc:
+
+    # Accounting - We should account for inbound even if they are not processed.
+    @msgs_received += 1
+    @bytes_received += msg.bytesize if msg
+
     return unless sub = @subs[sid]
 
     # Check for auto_unsubscribe
     sub[:received] += 1
+    if sub[:max]
+      # Client side support in case server did not receive unsubscribe
+      return unsubscribe(sid) if (sub[:received] > sub[:max])
+      # cleanup here if we have hit the max..
+      @subs.delete(sid) if (sub[:received] == sub[:max])
+    end
+
     return unsubscribe(sid) if (sub[:max] && (sub[:received] > sub[:max]))
 
     if cb = sub[:callback]
@@ -391,70 +485,86 @@ module NATS
 
   def flush_pending #:nodoc:
     return unless @pending
-    @pending.each { |p| send_data(p) }
-    @pending = nil
+    send_data(@pending.join)
+    @pending, @pending_size = nil, 0
   end
 
   def receive_data(data) #:nodoc:
     @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.call(NATS::ServerError.new($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.call(NATS::Error.new("Unknown protocol: $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?)
+      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.call(NATS::ServerError.new($1))
+        when PING
+          @pings += 1
+          @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.call(NATS::ServerError.new("Unknown protocol: $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
+
     end
   end
 
   def process_info(info) #:nodoc:
     @server_info = JSON.parse(info, :symbolize_keys => true, :symbolize_names => true)
+    if @server_info[:ssl_required] && @ssl
+      start_tls
+    else
+      if @server_info[:ssl_required]
+        err_cb.call(NATS::ClientError.new('TLS/SSL required by server'))
+      elsif @ssl
+        err_cb.call(NATS::ClientError.new('TLS/SSL not supported by server'))
+      end
+    end
+    @server_info
   end
 
-  def connection_completed #:nodoc:
+  def ssl_handshake_completed
     @connected = true
+    flush_pending
+  end
+
+  def connection_completed #:nodoc:
+    @connected = true unless @ssl
     if reconnecting?
       EM.cancel_timer(@reconnect_timer)
       send_connect_command
       @subs.each_pair { |k, v| send_command("SUB #{v[:subject]} #{k}#{CR_LF}") }
     end
-    flush_pending if @pending
+    flush_pending unless @ssl
     unless user_err_cb? or reconnecting?
-      @err_cb = proc {|e| raise e }
+      @err_cb = proc { |e| raise e }
     end
     if (connect_cb and not reconnecting?)
       # We will round trip the server here to make sure all state from any pending commands
@@ -468,43 +578,49 @@ module NATS
   def schedule_reconnect(wait=RECONNECT_TIME_WAIT) #:nodoc:
     @reconnecting = true
     @reconnect_attempts = 0
+    @connected = false
     @reconnect_timer = EM.add_periodic_timer(wait) { attempt_reconnect }
   end
 
   def unbind #:nodoc:
     if connected? and not closing? and not reconnecting? and @options[:reconnect]
-      schedule_reconnect
+      schedule_reconnect(@options[:reconnect_time_wait])
     else
       process_disconnect unless reconnecting?
     end
   end
 
+  def disconnect_error_string
+    return "Client disconnected from server on #{@uri}." if @connected
+    return "Could not connect to server on #{@uri}"
+  end
+
   def process_disconnect #:nodoc:
-    if not closing? and @err_cb
-      err_string = @connected ? "Client disconnected from server on #{@uri}." : "Could not connect to server on #{@uri}"
-      err_cb.call(NATS::ConnectError.new(err_string))
-    end
+    err_cb.call(NATS::ConnectError.new(disconnect_error_string)) if not closing? and @err_cb
   ensure
     EM.cancel_timer(@reconnect_timer) if @reconnect_timer
-    if (NATS.client == self and connected? and closing? and not NATS.reactor_was_running?)
-      EM.stop
+    if (NATS.client == self)
+      NATS.clear_client
+      EM.stop if ((connected? || reconnecting?) and closing? and not NATS.reactor_was_running?)
     end
     @connected = @reconnecting = false
     true # Chaining
   end
 
   def attempt_reconnect #:nodoc:
-    process_disconnect and return if (@reconnect_attempts += 1) > MAX_RECONNECT_ATTEMPTS
+    process_disconnect and return if (@reconnect_attempts += 1) > @options[:max_reconnect_attempts]
     EM.reconnect(@uri.host, @uri.port, self)
+    @reconnect_cb.call unless @reconnect_cb.nil?
   end
 
   def send_command(command) #:nodoc:
-    queue_command(command) and return unless connected?
-    send_data(command)
-  end
-
-  def queue_command(command) #:nodoc:
+    EM.next_tick { flush_pending } if (connected? && @pending.nil?)
     (@pending ||= []) << command
+    @pending_size += command.bytesize
+    flush_pending if (connected? && @pending_size > MAX_PENDING_SIZE)
+    if (@options[:fast_producer_error] && pending_data_size > FAST_PRODUCER_THRESHOLD)
+      err_cb.call(NATS::ClientError.new("Fast Producer: #{pending_data_size} bytes outstanding"))
+    end
     true
   end