nats-pure 0.2.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a1804a68dcb41e7e76ca9f53fc6b13fc44605090
-  data.tar.gz: c2b611901423068cdcd6e6add32b18b9079e47fd
+  metadata.gz: d7cfcdf1243c5e666ab143dfc2455382b6e005d4
+  data.tar.gz: 5b14efd741a22149d8b2d2f32cc2b9f1ae3d26d2
 SHA512:
-  metadata.gz: 7dbaaa96f906080b70992031edbe1d257fe5248f9ff72be6df19050b4554cacce53382946196395d24cae27a3db15de4d4acf07c67097c45d76883423f092419
-  data.tar.gz: e4dcd3d62141d47273518fc0252755495162cd0a4d49432647838a06d65203ee4bbbbabe026217567a253ba4da531d293a5e29f6c321e97548419433d1529602
+  metadata.gz: 30bf47ea7e3bb6baf8e52adc60ca7d8d2ef5ee532dd3effe9ae0994d017ee43bce26ff4035901b329fd2865cf9d6f35fb6e5c92515e7afb536f5d471eb91640f
+  data.tar.gz: 19a9a15800568b21b583a690c0a3d56dd40841c15369971afd83d38e54b5f1e2752727eb6027b4a9ef42c84317af455c95530216cddd1221dc1c9e38fa226e1c

data/lib/nats/io/client.rb

@@ -72,6 +72,9 @@ module NATS
     # When we cannot connect since there are no servers available.
     class NoServersError < ConnectError; end
 
+    # When the connection exhausts max number of pending pings replies.
+    class StaleConnectionError < Error; end
+
     # When we do not get a result within a specified time.
     class Timeout < Error; end
 
@@ -137,8 +140,8 @@ module NATS
         # Sticky error
         @last_err = nil
 
-        # Async callbacks
-        @err_cb = proc { |e| raise e }
+        # Async callbacks, no ops by default.
+        @err_cb = proc { }
         @close_cb = proc { }
         @disconnect_cb = proc { }
         @reconnect_cb = proc { }
@@ -178,8 +181,9 @@ module NATS
         # Check for TLS usage
         @tls = @options[:tls]
 
+        srv = nil
         begin
-          current = select_next_server
+          srv = select_next_server
 
           # Create TCP socket connection to NATS
           @io = create_socket
@@ -187,7 +191,7 @@ module NATS
 
           # Capture state that we have had a TCP connection established against
           # this server and could potentially be used for reconnecting.
-          current[:was_connected] = true
+          srv[:was_connected] = true
 
           # Connection established and now in process of sending CONNECT to NATS
           @status = CONNECTING
@@ -196,13 +200,21 @@ module NATS
           process_connect_init
 
           # Reset reconnection attempts if connection is valid
-          current[:reconnect_attempts] = 0
+          srv[:reconnect_attempts] = 0
+          srv[:auth_required] ||= true if @server_info[:auth_required]
+
+          # Add back to rotation since successfully connected
+          server_pool << srv
         rescue NoServersError => e
           @disconnect_cb.call(e) if @disconnect_cb
           raise @last_err || e
         rescue => e
           # Capture sticky error
-          synchronize { @last_err = e }
+          synchronize do
+            @last_err = e
+            srv[:auth_required] ||= true if @server_info[:auth_required]
+            server_pool << srv if can_reuse_server?(srv)
+          end
 
           @err_cb.call(e) if @err_cb
 
@@ -385,26 +397,23 @@ module NATS
 
       # Handles protocol errors being sent by the server.
       def process_err(err)
-        # FIXME: In case of a stale connection, then handle as process_op_error
-
         # In case of permissions violation then dispatch the error callback
         # while holding the lock.
-        current = server_pool.first
-        current[:error_received] = true
-        if current[:auth_required]
-          @err_cb.call(NATS::IO::AuthError.new(err))
-        else
-          @err_cb.call(NATS::IO::ServerError.new(err))
-        end
-
-        # Otherwise, capture the error under a lock and close
-        # the connection gracefully.
-        synchronize do
-          @last_err = NATS::IO::ServerError.new(err)
+        e = synchronize do
+          current = server_pool.first
+          case
+          when err =~ /'Stale Connection'/
+            @last_err = NATS::IO::StaleConnectionError.new(err)
+          when current && current[:auth_required]
+            # We cannot recover from auth errors so mark it to avoid
+            # retrying to unecessarily next time.
+            current[:error_received] = true
+            @last_err = NATS::IO::AuthError.new(err)
+          else
+            @last_err = NATS::IO::ServerError.new(err)
+          end
         end
-
-        # Process disconnect under a different thread as reading loop
-        Thread.new { close }
+        process_op_error(e)
       end
 
       def process_msg(subject, sid, reply, data)
@@ -456,6 +465,58 @@ module NATS
         end
       end
 
+      def process_info(line)
+        parsed_info = JSON.parse(line)
+
+        # INFO can be received asynchronously too,
+        # so has to be done under the lock.
+        synchronize do
+          # Symbolize keys from parsed info line
+          @server_info = parsed_info.reduce({}) do |info, (k,v)|
+            info[k.to_sym] = v
+
+            info
+          end
+
+          # Detect any announced server that we might not be aware of...
+          connect_urls = @server_info[:connect_urls]
+          if connect_urls
+            srvs = []
+            connect_urls.each do |url|
+              u = URI.parse("nats://#{url}")
+
+              # Skip in case it is the current server which we already know
+              next if @uri.host == u.host && @uri.port == u.port
+
+              present = server_pool.detect do |srv|
+                srv[:uri].host == u.host && srv[:uri].port == u.port
+              end
+
+              if not present
+                # Let explicit user and pass options set the credentials.
+                u.user = options[:user] if options[:user]
+                u.password = options[:pass] if options[:pass]
+
+                # Use creds from the current server if not set explicitly.
+                if @uri
+                  u.user ||= @uri.user if @uri.user
+                  u.password ||= @uri.password if @uri.password
+                end
+
+                srv = { :uri => u, :reconnect_attempts => 0, :discovered => true }
+                srvs << srv
+              end
+            end
+            srvs.shuffle! unless @options[:dont_randomize_servers]
+
+            # Include in server pool but keep current one as the first one.
+            server_pool.push(*srvs)
+          end
+        end
+
+        @server_info
+      end
+
       # Close connection to NATS, flushing in case connection is alive
       # and there are any pending messages, should not be used while
       # holding the lock.
@@ -521,13 +582,6 @@ module NATS
         srv[:reconnect_attempts] ||= 0
         srv[:reconnect_attempts] += 1
 
-        # In case there was an error from the server we will
-        # take it out from rotation unless we specify infinite
-        # reconnects via setting :max_reconnect_attempts to -1
-        if options[:max_reconnect_attempts] < 0 || can_reuse_server?(srv)
-          server_pool << srv
-        end
-
         # Back off in case we are reconnecting to it and have been connected
         sleep @options[:reconnect_time_wait] if should_delay_connect?(srv)
 
@@ -539,53 +593,6 @@ module NATS
         srv
       end
 
-      def process_info(line)
-        parsed_info = JSON.parse(line)
-
-        # INFO can be received asynchronously too,
-        # so has to be done under the lock.
-        synchronize do
-          # Symbolize keys from parsed info line
-          @server_info = parsed_info.reduce({}) do |info, (k,v)|
-            info[k.to_sym] = v
-
-            info
-          end
-
-          # Detect any announced server that we might not be aware of...
-          connect_urls = @server_info[:connect_urls]
-          if connect_urls
-            srvs = []
-            connect_urls.each do |url|
-              u = URI.parse("nats://#{url}")
-              present = server_pool.detect do |srv|
-                srv[:uri].host == u.host && srv[:uri].port == u.port
-              end
-
-              if not present
-                # Let explicit user and pass options set the credentials.
-                u.user = options[:user] if options[:user]
-                u.password = options[:pass] if options[:pass]
-
-                # Use creds from the current server if not set explicitly.
-                if @uri
-                  u.user ||= @uri.user if @uri.user
-                  u.password ||= @uri.password if @uri.password
-                end
-
-                srvs << { :uri => u, :reconnect_attempts => 0, :discovered => true }
-              end
-            end
-            srvs.shuffle! unless @options[:dont_randomize_servers]
-
-            # Include in server pool but keep current one as the first one.
-            server_pool.push(*srvs)
-          end
-        end
-
-        @server_info
-      end
-
       def server_using_secure_connection?
         @server_info[:ssl_required] || @server_info[:tls_required]
       end
@@ -616,8 +623,12 @@ module NATS
         cs[:name] = @options[:name] if @options[:name]
 
         if auth_connection?
-          cs[:user] = @uri.user
-          cs[:pass] = @uri.password
+          if @uri.password
+            cs[:user] = @uri.user
+            cs[:pass] = @uri.password
+          else
+            cs[:auth_token] = @uri.user
+          end
         end
 
         "CONNECT #{cs.to_json}#{CR_LF}"
@@ -641,6 +652,7 @@ module NATS
 
         synchronize do
           @last_err = e
+          @err_cb.call(e) if @err_cb
 
           # If we were connected and configured to reconnect,
           # then trigger disconnect and start reconnection logic
@@ -651,8 +663,8 @@ module NATS
 
             # TODO: Reconnecting pending buffer?
 
-            # Reconnect under a different thread than the one
-            # which got the error.
+            # Do reconnect under a different thread than the one
+            # in which we got the error.
             Thread.new do
               begin
                 # Abort currently running reads in case they're around
@@ -734,7 +746,6 @@ module NATS
               @err_cb.call(e) if @err_cb
             end
 
-            # TODO: Thread.exit?
             process_op_error(e)
             return
           end if @io
@@ -748,12 +759,16 @@ module NATS
       def ping_interval_loop
         loop do
           sleep @options[:ping_interval]
-          if @pings_outstanding > @options[:max_outstanding_pings]
-            # FIXME: Check if we have to dispatch callbacks.
-            close
+
+          # Skip ping interval until connected
+          next if !connected?
+
+          if @pings_outstanding >= @options[:max_outstanding_pings]
+            process_op_error(StaleConnectionError.new("nats: stale connection"))
+            return
           end
-          @pings_outstanding += 1
 
+          @pings_outstanding += 1
           send_command(PING_REQUEST)
           @flush_queue << :ping
         end
@@ -763,6 +778,9 @@ module NATS
 
       def process_connect_init
         line = @io.read_line(options[:connect_timeout])
+        if !line or line.empty?
+          raise ConnectError.new("nats: protocol exception, INFO not received")
+        end
         _, info_json = line.split(' ')
         process_info(info_json)
 
@@ -791,11 +809,6 @@ module NATS
           # Otherwise, use a regular connection.
         end
 
-        if @server_info[:auth_required]
-          current = server_pool.first
-          current[:auth_required] = true
-        end
-
         # Send connect and process synchronously. If using TLS,
         # it should have handled upgrading at this point.
         @io.write(connect_command)
@@ -831,8 +844,9 @@ module NATS
         @last_err = nil
 
         # Do reconnect
+        srv = nil
         begin
-          current = select_next_server
+          srv = select_next_server
 
           # Establish TCP connection with new server
           @io = create_socket
@@ -843,10 +857,19 @@ module NATS
           process_connect_init
 
           # Reset reconnection attempts if connection is valid
-          current[:reconnect_attempts] = 0
+          srv[:reconnect_attempts] = 0
+          srv[:auth_required] ||= true if @server_info[:auth_required]
+
+          # Add back to rotation since successfully connected
+          server_pool << srv
         rescue NoServersError => e
           raise e
         rescue => e
+          # In case there was an error from the server check
+          # to see whether need to take it out from rotation
+          srv[:auth_required] ||= true if @server_info[:auth_required]
+          server_pool << srv if can_reuse_server?(srv)
+          
           @last_err = e
 
           # Trigger async error handler
@@ -874,6 +897,10 @@ module NATS
         @status = CONNECTED
         @pending_size = 0
 
+        # Reset parser state here to avoid unknown protocol errors
+        # on reconnect...
+        @parser.reset!
+
         # Now connected to NATS, and we can restart parser loop, flusher
         # and ping interval
         start_threads!
@@ -964,9 +991,17 @@ module NATS
       end
 
       def can_reuse_server?(server)
-        # We will retry a number of times to reconnect to a server
-        # unless we got a hard error from it already.
-        server[:reconnect_attempts] <= @options[:max_reconnect_attempts] && !server[:error_received]
+        return false if server.nil?
+
+        # We can always reuse servers with infinite reconnects settings
+        return true if @options[:max_reconnect_attempts] < 0
+
+        # In case of hard errors like authorization errors, drop the server
+        # already since won't be able to connect.
+        return false if server[:error_received]
+
+        # We will retry a number of times to reconnect to a server.
+        return server[:reconnect_attempts] <= @options[:max_reconnect_attempts]
       end
 
       def should_delay_connect?(server)
@@ -993,10 +1028,6 @@ module NATS
     class Socket
       attr_accessor :socket
 
-      # Exceptions raised during non-blocking I/O ops that require retrying the op
-      NBIO_READ_EXCEPTIONS  = [Errno::EWOULDBLOCK, Errno::EAGAIN, ::IO::WaitReadable]
-      NBIO_WRITE_EXCEPTIONS = [Errno::EWOULDBLOCK, Errno::EAGAIN, ::IO::WaitWritable]
-
       def initialize(options={})
         @uri = options[:uri]
         @connect_timeout = options[:connect_timeout]
@@ -1033,13 +1064,13 @@ module NATS
 
         begin
           return @socket.read_nonblock(max_bytes)
-        rescue *NBIO_READ_EXCEPTIONS
+        rescue ::IO::WaitReadable
           if ::IO.select([@socket], nil, nil, deadline)
             retry
           else
             raise SocketTimeoutError
           end
-        rescue *NBIO_WRITE_EXCEPTIONS
+        rescue ::IO::WaitWritable
           if ::IO.select(nil, [@socket], nil, deadline)
             retry
           else
@@ -1067,13 +1098,13 @@ module NATS
             total_written += written
             break total_written if total_written >= length
             data = data.byteslice(written..-1)
-          rescue *NBIO_WRITE_EXCEPTIONS
+          rescue ::IO::WaitWritable
             if ::IO.select(nil, [@socket], nil, deadline)
               retry
             else
               raise SocketTimeoutError
             end
-          rescue *NBIO_READ_EXCEPTIONS => e
+          rescue ::IO::WaitReadable
             if ::IO.select([@socket], nil, nil, deadline)
               retry
             else

data/lib/nats/io/parser.rb

@@ -24,8 +24,11 @@ module NATS
     class Parser
       def initialize(nc)
         @nc = nc
+        reset!
+      end
+
+      def reset!
         @buf = nil
-        @needed = nil
         @parse_state = AWAITING_CONTROL_LINE
 
         @sub = nil

data/lib/nats/io/version.rb

@@ -1,7 +1,7 @@
 module NATS
   module IO
     # NOTE: These are all announced to the server on CONNECT
-    VERSION  = "0.2.0"
+    VERSION  = "0.2.2"
     LANG     = "#{RUBY_ENGINE}2".freeze
     PROTOCOL = 1
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nats-pure
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.2
 platform: ruby
 authors:
 - Waldemar Quevedo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-30 00:00:00.000000000 Z
+date: 2017-03-14 00:00:00.000000000 Z
 dependencies: []
 description: NATS is an open-source, high-performance, lightweight cloud messaging
   system.