protobuf-nats 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1a5657826a433d857f0b08fa99f314df065af9be
-  data.tar.gz: 0f4a0ec4a8c239e595251c2894f6e7d7bca8419a
+  metadata.gz: df808ca99a789024cfe3ab03071d1acafeef32a5
+  data.tar.gz: 6ba58e9150dd5b575a3b2b44e1f6ff06ff151681
 SHA512:
-  metadata.gz: 541b8c84ffe66f575447b69c84198ed3eedebd996879fa9dc75b3ac210ed899dc526626d7a31f0a526ec68a8407f6a19d69248e6fb7dd4845ef2fc5d41e706a9
-  data.tar.gz: 34e7f770187a6d14d3d88aa4637688c8a5c4fd48e6fcf9dbf7f1a635a3fe0c9e739ecabcb6ccee6c8f0db34a188f58632cff4cf56b06a5fa6459bcbe84393214
+  metadata.gz: 648a3e8de0b1ca89864eaef8b5076d25eb74508920c31d04883b1766bf09d6237aac15b3b55ba3b5e126d51ebc063468ebbdb92278a33ac8dd953e9c85e7b1ba
+  data.tar.gz: f4dba8e3b094b0e2f19a89d436ed209f792cd3696d07d6c6c931352202aceec5961980be83e45708d2a39c3d091e99754b3179f3776d0934464de44933c64627

data/README.md

@@ -38,6 +38,11 @@ used to allow JVM based servers to warm-up slowly to prevent jolts in runtime pe
 
 `PB_NATS_CLIENT_ACK_TIMEOUT` - Seconds to wait for an ACK from the rpc server (default: 5 seconds).
 
+`PB_NATS_CLIENT_NACK_BACKOFF_INTERVALS` - Array of milliseconds to wait between NACK retries (default: "0,1,3,5,10").
+
+`PB_NATS_CLIENT_NACK_BACKOFF_SPLAY_LIMIT` - Milliseconds to add to the NACK backoff timeout to avoid bursting retries
+(default: 10 milliseconds).
+
 `PB_NATS_CLIENT_RESPONSE_TIMEOUT` - Seconds to wait for a non-ACK response from the rpc server (default: 60 seconds).
 
 `PB_NATS_CLIENT_RECONNECT_DELAY` - If we detect a reconnect delay, we will wait this many seconds (default: the ACK timeout).

data/lib/protobuf/nats.rb

@@ -19,7 +19,8 @@ module Protobuf
     end
 
     module Messages
-      ACK = "\1".freeze
+      ACK  = "\1".freeze
+      NACK = "\2".freeze
     end
 
     NatsClient = if defined? JRUBY_VERSION

data/lib/protobuf/nats/client.rb

@@ -29,6 +29,30 @@ module Protobuf
         end
       end
 
+      def nack_backoff_intervals
+        @nack_backoff_intervals ||= if ::ENV.key?("PB_NATS_CLIENT_NACK_BACKOFF_INTERVALS")
+          ::ENV["PB_NATS_CLIENT_NACK_BACKOFF_INTERVALS"].split(",").map(&:to_i)
+        else
+          [0, 1, 3, 5, 10]
+        end
+      end
+
+      def nack_backoff_splay
+        @nack_backoff_splay ||= if nack_backoff_splay_limit > 0
+          rand(nack_backoff_splay_limit)
+        else
+          0
+        end
+      end
+
+      def nack_backoff_splay_limit
+        @nack_backoff_splay_limit ||= if ::ENV.key?("PB_NATS_CLIENT_NACK_BACKOFF_SPLAY_LIMIT")
+          ::ENV["PB_NATS_CLIENT_NACK_BACKOFF_SPLAY_LIMIT"].to_i
+        else
+          10
+        end
+      end
+
       def reconnect_delay
         @reconnect_delay ||= if ::ENV.key?("PB_NATS_CLIENT_RECONNECT_DELAY")
           ::ENV["PB_NATS_CLIENT_RECONNECT_DELAY"].to_i
@@ -47,11 +71,28 @@ module Protobuf
 
       def send_request
         retries ||= 3
+        nack_retry ||= 0
+
+        loop do
+          setup_connection
+          request_options = {:timeout => response_timeout, :ack_timeout => ack_timeout}
+          @response_data = nats_request_with_two_responses(cached_subscription_key, @request_data, request_options)
+          case @response_data
+          when :ack_timeout
+            next if (retries -= 1) > 0
+            raise ::NATS::IO::Timeout
+          when :nack
+            interval = nack_backoff_intervals[nack_retry]
+            nack_retry += 1
+            raise ::NATS::IO::Timeout if interval.nil?
+            sleep((interval + nack_backoff_splay)/1000.0)
+            next
+          end
+          break
+        end
 
-        setup_connection
-        request_options = {:timeout => response_timeout, :ack_timeout => ack_timeout}
-        @response_data = nats_request_with_two_responses(cached_subscription_key, @request_data, request_options)
         parse_response
+
       rescue ::Protobuf::Nats::Errors::IOException => error
         ::Protobuf::Nats.log_error(error)
 
@@ -59,10 +100,6 @@ module Protobuf
         logger.warn "An IOException was raised. We are going to sleep for #{delay} seconds."
         sleep delay
 
-        retry if (retries -= 1) > 0
-        raise
-      rescue ::NATS::IO::Timeout
-        # Nats response timeout.
         retry if (retries -= 1) > 0
         raise
       end
@@ -100,24 +137,19 @@ module Protobuf
 
           # Wait for reply
           first_message = nats.next_message(sub, ack_timeout)
-          fail ::NATS::IO::Timeout if first_message.nil?
+          return :ack_timeout if first_message.nil?
+          return :nack if first_message.data == ::Protobuf::Nats::Messages::NACK
+
           second_message = nats.next_message(sub, timeout)
-          fail ::NATS::IO::Timeout if second_message.nil?
+          fail(::NATS::IO::Timeout, subject) if second_message.nil?
 
           # Check messages
-          response = nil
-          has_ack = false
-          case first_message.data
-          when ::Protobuf::Nats::Messages::ACK then has_ack = true
-          else response = first_message.data
-          end
-          case second_message.data
-          when ::Protobuf::Nats::Messages::ACK then has_ack = true
-          else response = second_message.data
-          end
+          response = case ::Protobuf::Nats::Messages::ACK
+                     when first_message.data then second_message.data
+                     when second_message.data then first_message.data
+                     end
 
-          success = has_ack && response
-          fail(::NATS::IO::Timeout, subject) unless success
+          fail(::NATS::IO::Timeout, subject) unless response
 
           response
         ensure
@@ -131,19 +163,16 @@ module Protobuf
           nats = Protobuf::Nats.client_nats_connection
           inbox = nats.new_inbox
           lock = ::Monitor.new
-          ack_condition = lock.new_cond
-          pb_response_condition = lock.new_cond
+          received = lock.new_cond
+          messages = []
+          first_message = nil
+          second_message = nil
           response = nil
+
           sid = nats.subscribe(inbox, :max => 2) do |message, _, _|
             lock.synchronize do
-              case message
-              when ::Protobuf::Nats::Messages::ACK
-                ack_condition.signal
-                next
-              else
-                response = message
-                pb_response_condition.signal
-              end
+              messages << message
+              received.signal
             end
           end
 
@@ -153,28 +182,31 @@ module Protobuf
 
             # Wait for the ACK from the server
             ack_timeout = opts[:ack_timeout] || 5
-            with_timeout(ack_timeout) { ack_condition.wait(ack_timeout) }
+            received.wait(ack_timeout) if messages.empty?
+            first_message = messages.shift
+
+            return :ack_timeout if first_message.nil?
+            return :nack if first_message == ::Protobuf::Nats::Messages::NACK
 
             # Wait for the protobuf response
             timeout = opts[:timeout] || 60
-            with_timeout(timeout) { pb_response_condition.wait(timeout) } unless response
+            received.wait(timeout) if messages.empty?
+            second_message = messages.shift
           end
 
+          response = case ::Protobuf::Nats::Messages::ACK
+                     when first_message then second_message
+                     when second_message then first_message
+                     end
+
+          fail(::NATS::IO::Timeout, subject) unless response
+
           response
         ensure
           # Ensure we don't leave a subscription sitting around.
           nats.unsubscribe(sid) if response.nil?
         end
 
-        # This is a copy of #with_nats_timeout
-        def with_timeout(timeout)
-          start_time = ::NATS::MonotonicTime.now
-          yield
-          end_time = ::NATS::MonotonicTime.now
-          duration = end_time - start_time
-          raise ::NATS::IO::Timeout.new("nats: timeout") if duration > timeout
-        end
-
       end
 
     end

data/lib/protobuf/nats/server.rb

@@ -55,7 +55,12 @@ module Protobuf
         end
 
         # Publish an ACK to signal the server has picked up the work.
-        nats.publish(reply_id, ::Protobuf::Nats::Messages::ACK) if was_enqueued
+        if was_enqueued
+          nats.publish(reply_id, ::Protobuf::Nats::Messages::ACK)
+        else
+          # TODO: Uncomment once we can roll out NACK messages without a 60 second timeout
+          # nats.publish(reply_id, ::Protobuf::Nats::Messages::NACK)
+        end
 
         was_enqueued
       end

data/lib/protobuf/nats/version.rb

@@ -1,5 +1,5 @@
 module Protobuf
   module Nats
-    VERSION = "0.5.0"
+    VERSION = "0.5.1"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: protobuf-nats
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Brandon Dewitt
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-05-26 00:00:00.000000000 Z
+date: 2017-06-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: protobuf