nats 0.4.28 → 0.5.0.beta.12

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NTZjYWZjNDUxYmZmMzU2NTIxZjY0ODgwNTBlZWI4MGIwNTA1Y2U2NQ==
+  data.tar.gz: !binary |-
+    MjVkYjliNDVkMzNkNDA4ZjIxYjBhNjgxMzcxNDQ3MDQ5NzRiYjFjOA==
+SHA512:
+  metadata.gz: !binary |-
+    ODFlNmMxMjkzMzgwYmIwM2I5NWMxNzE3YWY2ZjUxYzEwNDZiMzQyYWQ5M2Q5
+    MzQ2ZGUzYTZiYmU1NTBhZDczMmZjZjBhMzlhM2Q4ZDkzYzNhYjMzYmRlNzFk
+    Yzc2ZjUxNjEyNWUwZDQ3NzcxMDY0NGVmMzdlMDZlN2FlYzExMWQ=
+  data.tar.gz: !binary |-
+    M2U4MTVjMmYyMzIxODI4NjZjZjhmNDkwOGE1MDM2ZWRmN2I4ZjJjMTYwMTQx
+    MWY0MTA2NmJhNzQ3ZWI3NGI1YmY4ODFmMzk2YzRmMzMwOWJjYjJlMGE3MDAy
+    N2EzNjM4MGZjOTQzOTgwMTYzNzk1YjY3ZTYzMTdjZTcyYmI0MDA=

data/HISTORY.md

@@ -1,5 +1,21 @@
 # HISTORY
 
+## v0.5.0.beta.12 (October 1, 2013)
+  - Fixed issue #58, reconnects not stopped on auth failures
+  - Fixed leaking ping timers on auth failures
+  - Created AuthError
+  - See full list @ https://github.com/derekcollison/nats/compare/v0.5.0.beta.11...v0.5.0.beta.12
+
+## v0.5.0.beta.11 (July 26, 2013)
+  - Bi-directional Route designation
+  - Upgrade to EM 1.x
+  - See full list @ https://github.com/derekcollison/nats/compare/v0.5.0.beta.1...v0.5.0.beta.11
+
+## v0.5.0.beta.1 (Sept 10, 2012)
+  - Clustering support for nats-servers
+  - Reconnect client logic cluster aware (explicit servers only for now)
+  - See full list @ https://github.com/derekcollison/nats/compare/v0.4.26...v0.5.0.beta.1
+
 ## v0.4.28 (September 22, 2012)
   - Binary payload bug fix
   - Lock EM to version 0.12.10, 1.0 does not pass tests currently.

data/README.md

@@ -2,7 +2,7 @@
 
 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)
+[![Build Status](https://secure.travis-ci.org/derekcollison/nats.png?branch=cluster)](http://travis-ci.org/derekcollison/nats)
 
 ## Supported Platforms
 
@@ -12,11 +12,14 @@ This gem currently works on the following Ruby platforms:
 - Rubinius
 - JRuby
 
+## Additional Clients
+
 There are several other client language bindings as well.
 
-[Node.js](https://github.com/derekcollison/node_nats)  
-[Go - Apcera](https://github.com/apcera/nats)  
-[Go - CloudFoundry](https://github.com/cloudfoundry/gonats)  
+- [Node.js](https://github.com/derekcollison/node_nats)
+- [Go](https://github.com/apcera/nats)
+- [Java](https://github.com/tyagihas/java_nats)
+- [Java - Spring](https://github.com/mheath/jnats)
 
 ## Getting Started
 
@@ -112,7 +115,7 @@ See examples and benchmarks for more information..
 
 (The MIT License)
 
-Copyright (c) 2010-2012 Derek Collison
+Copyright (c) 2010-2013 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/bin/nats-queue

@@ -7,14 +7,14 @@ require 'nats/client'
 ['TERM', 'INT'].each { |s| trap(s) {  puts; exit! } }
 
 def usage
-  puts "Usage: nats-queue <subject> <queue name> [-s server] [-t]"; exit
+  puts "Usage: nats-queue <subject> <queue name> [-s server] [-t] [-r]"; 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('-t','--time') { $show_time = true }
+  opts.on('-r','--raw') { $show_raw = true }
 end
 args = opts_parser.parse!(args)
 
@@ -30,11 +30,20 @@ def header
   "#{time_prefix}[\##{$i+=1}]"
 end
 
+def decorate sub, msg
+  if $show_raw
+    msg
+  else
+    "#{header} Received on [#{sub}] : '#{msg}'"
+  end
+end
+
+
 NATS.on_error { |err| puts "Server Error: #{err}"; exit! }
 
 NATS.start(:uri => $nats_server,  :autostart => true) do
-  puts "Listening on [#{subject}], queue group [#{queue_group}]"
+  puts "Listening on [#{subject}], queue group [#{queue_group}]" unless $show_raw
   NATS.subscribe(subject, :queue => queue_group) { |msg, _, sub|
-    puts "#{header} Received on [#{sub}] : '#{msg}'"
+    puts decorate(sub, msg)
   }
 end

data/bin/nats-request

@@ -7,13 +7,14 @@ 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
+  puts "Usage: nats-request <subject> <msg> [-s server] [-t] [-r] [-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('-t','--time') { $show_time = true }
+  opts.on('-r','--raw') { $show_raw = true }
   opts.on('-n RESPONSES') { |responses| $responses = Integer(responses) if Integer(responses) > 0 }
 end
 args = opts_parser.parse!(args)
@@ -31,11 +32,19 @@ def header
   "#{time_prefix}[\##{$i+=1}]"
 end
 
+def decorate msg
+  if $show_raw
+    msg
+  else
+    "#{header} Replied with : '#{msg}'"
+  end
+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}'"
+    puts decorate(msg)
     exit! if $responses && ($responses-=1) < 1
   }
 end

data/bin/nats-sub

@@ -7,14 +7,14 @@ require 'nats/client'
 ['TERM', 'INT'].each { |s| trap(s) {  puts; exit! } }
 
 def usage
-  puts "Usage: nats-sub <subject> [-s server] [-t]"; exit
+  puts "Usage: nats-sub <subject> [-s server] [-t] [-r]"; 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('-t','--time') { $show_time = true }
+  opts.on('-r','--raw') { $show_raw = true }
 end
 args = opts_parser.parse!(args)
 
@@ -30,9 +30,17 @@ def header
   "#{time_prefix}[\##{$i+=1}]"
 end
 
+def decorate sub, msg
+  if $show_raw
+    msg
+  else
+    "#{header} Received on [#{sub}] : '#{msg}'"
+  end
+end
+
 NATS.on_error { |err| puts "Server Error: #{err}"; exit! }
 
 NATS.start(:uri => $nats_server, :autostart => true) do
-  puts "Listening on [#{subject}]"
-  NATS.subscribe(subject) { |msg, _, sub| puts "#{header} Received on [#{sub}] : '#{msg}'" }
+  puts "Listening on [#{subject}]" unless $show_raw
+  NATS.subscribe(subject) { |msg, _, sub| puts decorate(sub, msg) }
 end

data/lib/nats/client.rb

@@ -1,4 +1,5 @@
 require 'uri'
+require 'securerandom'
 
 ep = File.expand_path(File.dirname(__FILE__))
 
@@ -8,7 +9,7 @@ require "#{ep}/ext/json"
 
 module NATS
 
-  VERSION = '0.4.28'.freeze
+  VERSION = "0.5.0.beta.12".freeze
 
   DEFAULT_PORT = 4222
   DEFAULT_URI = "nats://localhost:#{DEFAULT_PORT}".freeze
@@ -21,6 +22,10 @@ module NATS
   # Maximum outbound size per client to trigger FP, 20MB
   FAST_PRODUCER_THRESHOLD = (10*1024*1024)
 
+  # Ping intervals
+  DEFAULT_PING_INTERVAL = 120
+  DEFAULT_PING_MAX = 2
+
   # Protocol
   # @private
   MSG      = /\AMSG\s+([^\s]+)\s+([^\s]+)\s+(([^\s]+)[^\S\r\n]+)?(\d+)\r\n/i #:nodoc:
@@ -66,6 +71,9 @@ module NATS
   # When we cannot connect to the server (either initially or after a reconnect), this is raised/passed
   class ConnectError < Error; end #:nodoc:
 
+  # When we cannot connect to the server because authorization failed.
+  class AuthError < ConnectError; end #:nodoc:
+
   class << self
     attr_reader   :client, :reactor_was_running, :err_cb, :err_cb_overridden #:nodoc:
     attr_reader   :reconnect_cb  #:nodoc
@@ -87,6 +95,8 @@ module NATS
     # @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
+    # @option opts [Integer] :ping_interval Integer that can be used to set the ping interval in seconds.
+    # @option opts [Integer] :max_outstanding_pings Integer that can be used to set the max number of outstanding pings before declaring a connection closed.
     # @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)
@@ -97,6 +107,8 @@ module NATS
       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?
+      opts[:ping_interval] = DEFAULT_PING_INTERVAL if opts[:ping_interval].nil?
+      opts[:max_outstanding_pings] = DEFAULT_PING_MAX if opts[:max_outstanding_pings].nil?
 
       # Override with ENV
       opts[:uri] ||= ENV['NATS_URI'] || DEFAULT_URI
@@ -108,7 +120,19 @@ module NATS
       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])
+
+      opts[:ping_interval] = ENV['NATS_PING_INTERVAL'].to_i unless ENV['NATS_PING_INTERVAL'].nil?
+      opts[:max_outstanding_pings] = ENV['NATS_MAX_OUTSTANDING_PINGS'].to_i unless ENV['NATS_MAX_OUTSTANDING_PINGS'].nil?
+
+      uri = opts[:uris] || opts[:servers] || opts[:uri]
+
+      # If they pass an array here just pass along to the real connection, and use first as the first attempt..
+      # Real connection will do proper walk throughs etc..
+      unless uri.nil?
+        u = uri.kind_of?(Array) ? uri.first : uri
+        @uri = u.is_a?(URI) ? u.dup : URI.parse(u)
+      end
+
       @err_cb = proc { |e| raise e } unless err_cb
       check_autostart(@uri) if opts[:autostart] == true
 
@@ -122,7 +146,7 @@ module NATS
     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")
+        raise(Error, "EM needs to be running when NATS.start is called without a run block")
       end
       # Setup optimized select versions
       EM.epoll; EM.kqueue
@@ -172,6 +196,7 @@ module NATS
     # @param [Block] &callback called when a reconnect attempt is made.
     def on_reconnect(&callback)
       @reconnect_cb = callback
+      @client.on_reconnect(&callback) unless @client.nil?
     end
 
     # Publish a message using the default client connection.
@@ -207,9 +232,7 @@ module NATS
     # 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
+      "_INBOX.#{SecureRandom.hex(13)}"
     end
 
     # Flushes all messages and subscriptions in the default connection
@@ -272,8 +295,8 @@ module NATS
 
   end
 
-  attr_reader :connected, :connect_cb, :err_cb, :err_cb_overridden #:nodoc:
-  attr_reader :closing, :reconnecting, :options, :server_info #:nodoc
+  attr_reader :connected, :connect_cb, :err_cb, :err_cb_overridden, :pongs_received #:nodoc:
+  attr_reader :closing, :reconnecting, :server_pool, :options, :server_info #:nodoc
   attr_reader :msgs_received, :msgs_sent, :bytes_received, :bytes_sent, :pings
 
   alias :connected? :connected
@@ -281,16 +304,14 @@ module NATS
   alias :reconnecting? :reconnecting
 
   def initialize(options)
-    @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
+    process_uri_options
+    @ssl = options[:ssl] if options[:ssl]
     @ssid, @subs = 1, {}
     @err_cb = NATS.err_cb
     @reconnect_timer, @needed = nil, nil
     @reconnect_cb = NATS.reconnect_cb
-    @connected, @closing, @reconnecting = false, false, false
+    @connected, @closing, @reconnecting, @conn_cb_called = false, false, false, false
     @msgs_received = @msgs_sent = @bytes_received = @bytes_sent = @pings = 0
     @pending_size = 0
     send_connect_command
@@ -418,7 +439,8 @@ module NATS
   # Close the connection to the server.
   def close
     @closing = true
-    EM.cancel_timer(@reconnect_timer) if @reconnect_timer
+    cancel_ping_timer
+    cancel_reconnect_timer
     close_connection_after_writing if connected?
     process_disconnect if reconnecting?
   end
@@ -432,14 +454,22 @@ module NATS
     err_cb_overridden || NATS.err_cb_overridden
   end
 
-  def send_connect_command #:nodoc:
+  def auth_connection?
+    !@uri.user.nil?
+  end
+
+  def connect_command #:nodoc:
     cs = { :verbose => @options[:verbose], :pedantic => @options[:pedantic] }
-    if @uri.user
+    if auth_connection?
       cs[:user] = @uri.user
       cs[:pass] = @uri.password
     end
     cs[:ssl_required] = @ssl if @ssl
-    send_command("CONNECT #{cs.to_json}#{CR_LF}", true)
+    "CONNECT #{cs.to_json}#{CR_LF}"
+  end
+
+  def send_connect_command #:nodoc:
+    send_command(connect_command, true)
   end
 
   def queue_server_rt(&cb) #:nodoc:
@@ -465,8 +495,6 @@ module NATS
       @subs.delete(sid) if (sub[:received] == sub[:max])
     end
 
-    return unsubscribe(sid) if (sub[:max] && (sub[:received] > sub[:max]))
-
     if cb = sub[:callback]
       case cb.arity
         when 0 then cb.call
@@ -503,7 +531,13 @@ module NATS
           @buf = $'
         when ERR
           @buf = $'
-          err_cb.call(NATS::ServerError.new($1))
+          current = server_pool.first
+          current[:error_received] = true
+          if current[:auth_required] && !current[:auth_ok]
+            err_cb.call(NATS::AuthError.new($1))
+          else
+            err_cb.call(NATS::ServerError.new($1))
+          end
         when PING
           @pings += 1
           @buf = $'
@@ -547,6 +581,12 @@ module NATS
         err_cb.call(NATS::ClientError.new('TLS/SSL not supported by server'))
       end
     end
+    if @server_info[:auth_required]
+      current = server_pool.first
+      current[:auth_required] = true
+      queue_server_rt { current[:auth_ok] = true }
+      flush_pending
+    end
     @server_info
   end
 
@@ -555,38 +595,103 @@ module NATS
     flush_pending
   end
 
+  def cancel_ping_timer
+    if @ping_timer
+      EM.cancel_timer(@ping_timer)
+      @ping_timer = nil
+    end
+  end
+
   def connection_completed #:nodoc:
     @connected = true unless @ssl
+
+    current = server_pool.first
+    current[:was_connected] = true
+    current[:reconnect_attempts] = 0
+
     if reconnecting?
-      EM.cancel_timer(@reconnect_timer)
-      send_connect_command
+      cancel_reconnect_timer
       @subs.each_pair { |k, v| send_command("SUB #{v[:subject]} #{v[:queue]} #{k}#{CR_LF}") }
     end
-    flush_pending unless @ssl
+
     unless user_err_cb? or reconnecting?
       @err_cb = proc { |e| raise e }
     end
-    if (connect_cb and not reconnecting?)
+
+    flush_pending unless @ssl
+
+    if (connect_cb and not @conn_cb_called)
       # 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) }
+      queue_server_rt do
+        connect_cb.call(self)
+        @conn_cb_called = true
+      end
     end
     @reconnecting = false
     @parse_state = AWAITING_CONTROL_LINE
+
+    # Initialize ping timer and processing
+    @pings_outstanding = 0
+    @pongs_received = 0
+    @ping_timer = EM.add_periodic_timer(@options[:ping_interval]) { send_ping }
+  end
+
+  def send_ping #:nodoc:
+    return if @closing
+    if @pings_outstanding > @options[:max_outstanding_pings]
+      close_connection
+      #close
+      return
+    end
+    @pings_outstanding += 1
+    queue_server_rt { process_pong }
+    flush_pending
+  end
+
+  def process_pong
+    @pongs_received += 1
+    @pings_outstanding -= 1
+  end
+
+  def should_delay_connect?(server)
+    server[:was_connected] && server[:reconnect_attempts] >= 1
   end
 
-  def schedule_reconnect(wait=RECONNECT_TIME_WAIT) #:nodoc:
+  def schedule_reconnect #:nodoc:
     @reconnecting = true
-    @reconnect_attempts = 0
     @connected = false
-    @reconnect_timer = EM.add_periodic_timer(wait) { attempt_reconnect }
+    @reconnect_timer = EM.add_timer(@options[:reconnect_time_wait]) { attempt_reconnect }
   end
 
   def unbind #:nodoc:
-    if connected? and not closing? and not reconnecting? and @options[:reconnect]
-      schedule_reconnect(@options[:reconnect_time_wait])
-    else
-      process_disconnect unless reconnecting?
+    # If we are closing or shouldn't reconnect, go ahead and disconnect.
+    process_disconnect and return if (closing? or should_not_reconnect?)
+
+    @reconnecting = true if connected?
+    @connected = false
+    @pending = @pongs = nil
+    cancel_ping_timer
+
+    schedule_primary_and_connect
+  end
+
+  def multiple_servers_available?
+    server_pool && server_pool.size > 1
+  end
+
+  def had_error?
+    server_pool.first && server_pool.first[:error_received]
+  end
+
+  def should_not_reconnect?
+    !@options[:reconnect]
+  end
+
+  def cancel_reconnect_timer
+    if @reconnect_timer
+      EM.cancel_timer(@reconnect_timer)
+      @reconnect_timer = nil
     end
   end
 
@@ -597,18 +702,26 @@ module NATS
 
   def process_disconnect #:nodoc:
     err_cb.call(NATS::ConnectError.new(disconnect_error_string)) if not closing? and @err_cb
+    true # Chaining
   ensure
-    EM.cancel_timer(@reconnect_timer) if @reconnect_timer
+    cancel_ping_timer
+    cancel_reconnect_timer
     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 can_reuse_server?(server) #:nodoc:
+    reconnecting? && server[:was_connected] && server[:reconnect_attempts] <= @options[:max_reconnect_attempts]
   end
 
   def attempt_reconnect #:nodoc:
-    process_disconnect and return if (@reconnect_attempts += 1) > @options[:max_reconnect_attempts]
+    @reconnect_timer = nil
+    current = server_pool.first
+    current[:reconnect_attempts] += 1 if current[:reconnect_attempts]
+    send_connect_command
     EM.reconnect(@uri.host, @uri.port, self)
     @reconnect_cb.call unless @reconnect_cb.nil?
   end
@@ -626,6 +739,47 @@ module NATS
     true
   end
 
+  # Parse out URIs which can now be an array of server choices
+  # The server pool will contain both explicit and implicit members.
+  def process_uri_options #:nodoc
+    @server_pool = []
+    uri = options[:uris] || options[:servers] || options[:uri]
+    uri = uri.kind_of?(Array) ? uri : [uri]
+    uri.each { |u| server_pool << { :uri => u.is_a?(URI) ? u.dup : URI.parse(u) } }
+    server_pool.shuffle! unless options[:dont_randomize_servers]
+    bind_primary
+  end
+
+  def connected_server
+    connected? ? @uri : nil
+  end
+
+  def bind_primary #:nodoc:
+    first = server_pool.first
+    @uri = first[:uri]
+    @uri.user = options[:user] if options[:user]
+    @uri.password = options[:pass] if options[:pass]
+    first
+  end
+
+  # We have failed on an attempt at the primary (first) server, rotate and try again
+  def schedule_primary_and_connect #:nodoc:
+    # Dump the one we were trying if it wasn't connected
+    current = server_pool.shift
+    server_pool << current if (current && can_reuse_server?(current) && !current[:error_received])
+    # If we are out of options, go ahead and disconnect.
+    process_disconnect and return if server_pool.empty?
+    # bind new one
+    next_server = bind_primary
+    # If the next one was connected and we are trying to reconnect
+    # set up timer if we tried once already.
+    if should_delay_connect?(next_server)
+      schedule_reconnect
+    else
+      attempt_reconnect
+    end
+  end
+
   def inspect #:nodoc:
     "<nats client v#{NATS::VERSION}>"
   end