protobuf-nats 0.11.0.pre1 → 0.12.0.pre0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 983e924ae43d3fca4ccdfc73d8715c5c01b3f2bb
-  data.tar.gz: 9b88a322f6a04be4f2a0392b32555ecc9f29f284
+SHA256:
+  metadata.gz: c2df179aaf5b89613d47a629da54127097597956a5154f6628a27155359796f0
+  data.tar.gz: 23f4c10524cd40ec892fdfea7e8c5545590fe667111d0683cc24a9be47e32b60
 SHA512:
-  metadata.gz: 211f48f2481d731e09593fb926f87cf2d93b92e32ceab6e27952735c6da9ee30ea9f2d2bdb5edd9c3986e8efeb0180782f03451d318f3df086887fe49fe133a2
-  data.tar.gz: 0e70e256836e424a011cef424b9f589b36c4f3bd1d203c29db9e24e58e885043f6d409af531cfb9b29ec57087c179c5cfb83a29c9045380db3dd9920c95b32ec
+  metadata.gz: b4ff63c7224a17541320cbc34e196efead0bf0555f0de5aabf110b2e49bb8c0a45ffc8579c295077ace52b40ade6ee991f332df74dba2e4def0d5a4f69917376
+  data.tar.gz: 1772c0bbafddc6364734dbe25d3618e32c93f6d5194241f1bd54e46e3239902916c9195c184ff95953a6db4d28c9e1dd85d756adc4717fda52e5b0bcef76da26

data/.travis.yml

@@ -1,12 +1,16 @@
 sudo: false
 language: ruby
-jdk: openjdk8
+jdk:
+ - openjdk8
 rvm:
   - 2.3.0
+  - 2.7.0
   - jruby-9.1.7.0
+  - jruby-9.2.13.0
 before_install:
+  # Install and start gnatsd
+  - ./scripts/install_gnatsd.sh
+  - $HOME/nats-server/nats-server &
+  # Install deps for project
   - gem install bundler
   - gem update --system
-  - wget https://github.com/nats-io/gnatsd/releases/download/v1.3.0/gnatsd-v1.3.0-linux-amd64.zip
-  - unzip gnatsd-v1.3.0-linux-amd64.zip
-  - ./gnatsd-v1.3.0-linux-amd64/gnatsd &

data/README.md

@@ -49,6 +49,8 @@ used to allow JVM based servers to warm-up slowly to prevent jolts in runtime pe
 
 `PB_NATS_CLIENT_SUBSCRIPTION_POOL_SIZE` - If subscription pooling is desired for the request/response cycle then the pool size maximum should be set; the pool is lazy and therefore will only start new subscriptions as necessary (default: 0)
 
+`PB_NATS_DISABLE_JNATS` - Disable the default jruby jnats client on the jruby platform, use the nats-pure.rb client instead (default: false).
+
 `PROTOBUF_NATS_CONFIG_PATH` - Custom path to the config yaml (default: "config/protobuf_nats.yml").
 
 ### YAML Config
@@ -154,9 +156,11 @@ After checking out the repo, run `bin/setup` to install dependencies. Then, run
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
+The java-nats client is temporarily forked to support jruby > 9.2.10.0. The living branch for that is here: https://github.com/film42/java-nats/tree/jruby-compat. This will be removed when we upgrade to the new nats.java client.
+
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/abrandoned/protobuf-nats.
+Bug reports and pull requests are welcome on GitHub at https://github.com/mxenabled/protobuf-nats.
 
 
 ## License

data/lib/protobuf/nats/client.rb

@@ -1,11 +1,133 @@
 require "connection_pool"
 require "protobuf/nats"
+require "protobuf/nats/platform"
 require "protobuf/rpc/connectors/base"
 require "monitor"
 
 module Protobuf
   module Nats
+    class ResponseMuxerRequest
+      def initialize(muxer, token)
+        @muxer = muxer
+        @token = token
+      end
+
+      def publish(subject, data)
+        @muxer.publish(subject, data, @token)
+      end
+
+      def next_message(timeout)
+        @muxer.next_message(@token, timeout)
+      end
+
+      def cleanup
+        @muxer.cleanup(@token)
+      end
+    end
+
+    class ResponseMuxer
+      LOCK = ::Mutex.new
+
+      def initialize
+        @resp_map = Hash.new { |h,k| h[k] = { } }
+      end
+
+      def cleanup(token)
+        @resp_sub.synchronize { @resp_map.delete(token) }
+      end
+
+      def next_message(token, timeout)
+        ::NATS::MonotonicTime::with_nats_timeout(timeout) do
+          @resp_sub.synchronize do
+            break if @resp_map[token].key?(:response) &&
+              !@resp_map[token][:response].empty?
+
+            @resp_map[token][:signal].wait(timeout)
+          end
+        end
+
+        @resp_sub.synchronize { @resp_map[token][:response].shift }
+      end
+
+      def new_request
+        nats = Protobuf::Nats.client_nats_connection
+        token = nats.new_inbox.split('.').last
+        @resp_sub.synchronize do
+          @resp_map[token][:signal] = @resp_sub.new_cond
+        end
+
+        ResponseMuxerRequest.new(self, token)
+      end
+
+      def publish(subject, data, token)
+        nats = Protobuf::Nats.client_nats_connection
+        reply_to = "#{@resp_inbox_prefix}.#{token}"
+        nats.publish(subject, data, reply_to)
+      end
+
+      def restart
+        start unless started?
+
+        LOCK.synchronize do
+          @resp_handler&.kill
+          @started = false
+        end
+
+        start
+      end
+
+      def start
+        return if started?
+        LOCK.synchronize do
+          # We check this twice in case another thread was waiting for the lock to
+          # start this party.
+          return if started?
+
+          nats = ::Protobuf::Nats.client_nats_connection
+          return if nats.nil?
+
+          @resp_inbox_prefix = nats.new_inbox
+          @resp_sub = nats.subscribe("#{@resp_inbox_prefix}.*")
+          @started = true
+        end
+
+        @resp_handler = Thread.new do
+          begin
+            loop do
+              msg = @resp_sub.pending_queue.pop
+              next if msg.nil?
+              @resp_sub.synchronize do
+                # Decrease pending size since consumed already
+                @resp_sub.pending_size -= msg.data.size
+              end
+              token = msg.subject.split('.').last
+
+              @resp_sub.synchronize do
+                # Reject if the token is missing from the request map
+                break unless @resp_map.key?(token)
+
+                signal = @resp_map[token][:signal]
+                @resp_map[token][:response] ||= []
+                @resp_map[token][:response] << msg
+                signal.signal
+              end
+            rescue => error
+              ::Protobuf::Nats.notify_error_callbacks(error)
+              LOCK.synchronize { @started = false }
+            end
+          end
+        end
+      end
+
+      def started?
+        !!@started
+      end
+    end
+
     class Client < ::Protobuf::Rpc::Connectors::Base
+
+      RESPONSE_MUXER = ResponseMuxer.new
+
       # Structure to hold subscription and inbox to use within pool
       SubscriptionInbox = ::Struct.new(:subscription, :inbox) do
         def swap(sub_inbox)
@@ -36,6 +158,9 @@ module Protobuf
 
         # This will ensure the client is started.
         ::Protobuf::Nats.start_client_nats_connection
+
+        # Ensure the response muxer is started
+        RESPONSE_MUXER.start
       end
 
       def new_subscription_inbox
@@ -151,12 +276,12 @@ module Protobuf
           when :ack_timeout
             ::ActiveSupport::Notifications.instrument "client.request_timeout.protobuf-nats"
             next if (retries -= 1) > 0
-            raise ::Protobuf::Nats::Errors::RequestTimeout
+            raise ::Protobuf::Nats::Errors::RequestTimeout, formatted_service_and_method_name
           when :nack
             ::ActiveSupport::Notifications.instrument "client.request_nack.protobuf-nats"
             interval = nack_backoff_intervals[nack_retry]
             nack_retry += 1
-            raise ::Protobuf::Nats::Errors::RequestTimeout if interval.nil?
+            raise ::Protobuf::Nats::Errors::RequestTimeout, formatted_service_and_method_name if interval.nil?
             sleep((interval + nack_backoff_splay)/1000.0)
             next
           end
@@ -165,11 +290,11 @@ module Protobuf
         end
 
         parse_response
-      rescue ::Protobuf::Nats::Errors::IOException, ::Protobuf::Nats::Errors::IllegalStateException => error
+      rescue ::Protobuf::Nats::Errors::IOException => error
         ::Protobuf::Nats.log_error(error)
 
         delay = reconnect_delay
-        logger.warn "An #{error.class} was raised. We are going to sleep for #{delay} seconds."
+        logger.warn "An IOException was raised. We are going to sleep for #{delay} seconds."
         sleep delay
 
         retry if (retries -= 1) > 0
@@ -186,10 +311,16 @@ module Protobuf
         end
       end
 
+      def formatted_service_and_method_name
+        klass = @options[:service]
+        method_name = @options[:method]
+        "#{klass}##{method_name}"
+      end
+
       # The Java nats client offers better message queueing so we're going to use
       # that over locking ourselves. This split in code isn't great, but we can
       # refactor this later.
-      if defined? JRUBY_VERSION
+      if ::Protobuf::Nats.jruby?
 
         # This is a request that expects two responses.
         # 1. An ACK from the server. We use a shorter timeout.
@@ -207,7 +338,7 @@ module Protobuf
             begin
               completed_request = false
 
-              if !sub_inbox.subscription.is_active # replace the subscription if is has been pooled but is no longer valid (maybe a reconnect)
+              if !sub_inbox.subscription.is_valid # replace the subscription if is has been pooled but is no longer valid (maybe a reconnect)
                 nats.unsubscribe(sub_inbox.subscription)
                 sub_inbox.swap(new_subscription_inbox) # this line replaces the sub_inbox in the connection pool if necessary
               end
@@ -231,7 +362,7 @@ module Protobuf
                          else return :ack_timeout
                          end
 
-              fail(::Protobuf::Nats::Errors::ResponseTimeout, subject) unless response
+              fail(::Protobuf::Nats::Errors::ResponseTimeout, formatted_service_and_method_name) unless response
 
               completed_request = true
               response
@@ -247,52 +378,49 @@ module Protobuf
       else
 
         def nats_request_with_two_responses(subject, data, opts)
+          # Wait for the ACK from the server
+          ack_timeout = opts[:ack_timeout] || 5
+          # Wait for the protobuf response
+          timeout = opts[:timeout] || 60
+
           nats = Protobuf::Nats.client_nats_connection
-          inbox = nats.new_inbox
-          lock = ::Monitor.new
-          received = lock.new_cond
-          messages = []
-          first_message = nil
-          second_message = nil
-          response = nil
-
-          sid = nats.subscribe(inbox, :max => 2) do |message, _, _|
-            lock.synchronize do
-              messages << message
-              received.signal
-            end
-          end
 
-          lock.synchronize do
-            # Publish to server
-            nats.publish(subject, data, inbox)
+          # Publish message with the reply topic pointed at the response muxer.
+          req = RESPONSE_MUXER.new_request
+          req.publish(subject, data)
 
-            # Wait for the ACK from the server
-            ack_timeout = opts[:ack_timeout] || 5
-            received.wait(ack_timeout) if messages.empty?
-            first_message = messages.shift
+          # Receive the first message
+          begin
+            first_message = req.next_message(ack_timeout)
+          rescue ::NATS::Timeout => e
+            return :ack_timeout
+          end
 
-            return :ack_timeout if first_message.nil?
-            return :nack if first_message == ::Protobuf::Nats::Messages::NACK
+          # Check for a NACK
+          return :nack if first_message.data == ::Protobuf::Nats::Messages::NACK
 
-            # Wait for the protobuf response
-            timeout = opts[:timeout] || 60
-            received.wait(timeout) if messages.empty?
-            second_message = messages.shift
+          # Receive the second message
+          begin
+            second_message = req.next_message(timeout)
+          rescue ::NATS::Timeout
+            # ignore to raise a repsonse timeout below
           end
 
+          # NOTE: This might be nil, so be careful checking the data value
+          second_message_data = second_message&.data
+
+          # Check messages
           response = case ::Protobuf::Nats::Messages::ACK
-                     when first_message then second_message
-                     when second_message then first_message
+                     when first_message.data then second_message_data
+                     when second_message_data then first_message.data
                      else return :ack_timeout
                      end
 
-          fail(::Protobuf::Nats::Errors::ResponseTimeout, subject) unless response
+          fail(::Protobuf::Nats::Errors::ResponseTimeout, formatted_service_and_method_name) unless response
 
           response
         ensure
-          # Ensure we don't leave a subscription sitting around.
-          nats.unsubscribe(sid) if response.nil?
+          req.cleanup if req
         end
 
       end

data/lib/protobuf/nats/config.rb

@@ -40,7 +40,12 @@ module Protobuf
             config_path = ENV["PROTOBUF_NATS_CONFIG_PATH"] || ::File.join("config", "protobuf_nats.yml")
             absolute_config_path = ::File.expand_path(config_path)
             if ::File.exists?(absolute_config_path)
-              yaml_config = ::YAML.load_file(absolute_config_path)[env]
+              # Psych 4 and newer requires unsafe_load_file in order for aliases to be used
+              yaml_config = if ::YAML.respond_to?(:unsafe_load_file)
+                ::YAML.unsafe_load_file(absolute_config_path)[env]
+              else
+                ::YAML.load_file(absolute_config_path)[env]
+              end
             end
 
             DEFAULTS.each_pair do |key, value|

data/lib/protobuf/nats/errors.rb

@@ -1,27 +1,18 @@
 module Protobuf
   module Nats
     module Errors
-      class Base < ::StandardError
+      class ClientError < ::StandardError
       end
 
-      class RequestTimeout < Base
+      class RequestTimeout < ClientError
       end
 
-      class ResponseTimeout < Base
+      class ResponseTimeout < ClientError
       end
 
       class MriIOException < ::StandardError
       end
 
-      class MriIllegalStateException < ::StandardError
-      end
-
-      IllegalStateException = if defined? JRUBY_VERSION
-                                java.lang.IllegalStateException
-                              else
-                                MriIllegalStateException
-                              end
-
       IOException = if defined? JRUBY_VERSION
                       java.io.IOException
                     else

data/lib/protobuf/nats/jnats.rb

@@ -3,82 +3,12 @@ ext_base = ::File.join(::File.dirname(__FILE__), '..', '..', '..', 'ext')
 require ::File.join(ext_base, "jars/slf4j-api-1.7.25.jar")
 require ::File.join(ext_base, "jars/slf4j-simple-1.7.25.jar")
 require ::File.join(ext_base, "jars/gson-2.6.2.jar")
-require ::File.join(ext_base, "jars/jnats-2.6.0.jar")
+require ::File.join(ext_base, "jars/jnats-1.1-SNAPSHOT.jar")
 
 module Protobuf
   module Nats
     class JNats
-      attr_reader :connection, :dispatcher, :options
-
-      class MessageHandlerProxy
-        include ::Java::IoNatsClient::MessageHandler
-
-        def self.empty
-          new {}
-        end
-
-        def initialize(&block)
-          @cb = block
-        end
-
-        def onMessage(message)
-          @cb.call(message.getData.to_s, message.getReplyTo, message.getSubject)
-        end
-      end
-
-      class ConnectionListener
-        include ::Java::IoNatsClient::ConnectionListener
-
-        def initialize
-          @on_reconnect_cb = lambda {}
-          @on_disconnect_cb = lambda {}
-          @on_close_cb = lambda {}
-        end
-
-        def on_close(&block); @on_close_cb = block; end
-        def on_disconnect(&block); @on_disconnect_cb = block; end
-        def on_reconnect(&block); @on_reconnect_cb = block; end
-
-        def connectionEvent(conn, event_type)
-          case event_type
-          when ::Java::IoNatsClient::ConnectionListener::Events::RECONNECTED
-            @on_reconnect_cb.call
-          when ::Java::IoNatsClient::ConnectionListener::Events::DISCONNECTED
-            @on_disconnect_cb.call
-          when ::Java::IoNatsClient::ConnectionListener::Events::CLOSED
-            @on_close_cb.call
-          end
-        end
-      end
-
-      class ErrorListener
-        include ::Java::IoNatsClient::ErrorListener
-
-        def initialize
-          @on_error_cb = lambda { |_error| }
-          @on_exception_cb = lambda { |_exception| }
-          @on_slow_consumer_cb = lambda { |_consumer| }
-        end
-
-        def on_error(&block)
-          return if block.nil? || block.arity != 1
-          @on_error_cb = block
-        end
-
-        def on_exception(&block)
-          return if block.nil? || block.arity != 1
-          @on_exception_cb = block
-        end
-
-        def on_slow_consumer(&block)
-          return if block.nil? || block.arity != 1
-          @on_slow_consumer_cb = block
-        end
-
-        def errorOccurred(_conn, error); @on_error_cb.call(error); end
-        def exceptionOccurred(_conn, exception); @on_exception_cb.call(exception); end
-        def slowConsumerDetected(_conn, consumer); @on_slow_consumer_cb.call(consumer); end
-      end
+      attr_reader :connection, :options
 
       class Message
         attr_reader :data, :subject, :reply
@@ -91,9 +21,10 @@ module Protobuf
       end
 
       def initialize
-        @connection_listener = ConnectionListener.new
-        @error_listener = ErrorListener.new
-
+        @on_error_cb = lambda {|error|}
+        @on_reconnect_cb = lambda {}
+        @on_disconnect_cb = lambda {}
+        @on_close_cb = lambda {}
         @options = nil
         @subz_cbs = {}
         @subz_mutex = ::Mutex.new
@@ -103,26 +34,35 @@ module Protobuf
         @options ||= options
 
         servers = options[:servers] || ["nats://localhost:4222"]
-        servers = [servers].flatten
-
-        builder = ::Java::IoNatsClient::Options::Builder.new
-        builder.servers(servers)
-        builder.maxReconnects(options[:max_reconnect_attempts])
-        builder.errorListener(@error_listener)
+        servers = [servers].flatten.map { |uri_string| java.net.URI.new(uri_string) }
+        connection_factory = ::Java::IoNatsClient::ConnectionFactory.new
+        connection_factory.setServers(servers)
+        connection_factory.setMaxReconnect(options[:max_reconnect_attempts])
 
         # Shrink the pending buffer to always raise an error and let the caller retry.
         if options[:disable_reconnect_buffer]
-          builder.reconnectBufferSize(1)
+          connection_factory.setReconnectBufSize(1)
         end
 
+        # Setup callbacks
+        connection_factory.setDisconnectedCallback { |event| @on_disconnect_cb.call }
+        connection_factory.setReconnectedCallback { |_event| @on_reconnect_cb.call }
+        connection_factory.setClosedCallback { |_event| @on_close_cb.call }
+        connection_factory.setExceptionHandler { |error| @on_error_cb.call(error) }
+
         # Setup ssl context if we're using tls
         if options[:uses_tls]
           ssl_context = create_ssl_context(options)
-          builder.sslContext(ssl_context)
+          connection_factory.setSecure(true)
+          connection_factory.setSSLContext(ssl_context)
         end
 
-        @connection = ::Java::IoNatsClient::Nats.connect(builder.build)
-        @dispatcher = @connection.createDispatcher(MessageHandlerProxy.empty)
+        @connection = connection_factory.createConnection
+
+        # We're going to spawn a consumer and supervisor
+        @work_queue = @connection.createMsgChannel
+        spwan_supervisor_and_consumer
+
         @connection
       end
 
@@ -135,56 +75,64 @@ module Protobuf
 
       # Do not depend on #close for a graceful disconnect.
       def close
-        if @connection
-          @connection.closeDispatcher(@dispatcher) rescue nil
-          @connection.close rescue nil
-        end
-        @dispatcher = nil
+        @connection.close rescue nil
         @connection = nil
+        @supervisor.kill rescue nil
+        @supervisor = nil
+        @consumer.kill rescue nil
+        @supervisor = nil
       end
 
       def flush(timeout_sec = 0.5)
-        duration = duration_in_ms(timeout_sec * 1000)
-        connection.flush(duration)
+        connection.flush(timeout_sec * 1000)
       end
 
       def next_message(sub, timeout_sec)
-        duration = duration_in_ms(timeout_sec * 1000)
-        nats_message = sub.nextMessage(duration)
+        nats_message = sub.nextMessage(timeout_sec * 1000)
         return nil unless nats_message
         Message.new(nats_message)
       end
 
       def publish(subject, data, mailbox = nil)
         # The "true" here is to force flush. May not need this.
-        connection.publish(subject, mailbox, data.to_java_bytes)
-        connection.flush(nil)
+        connection.publish(subject, mailbox, data.to_java_bytes, true)
       end
 
       def subscribe(subject, options = {}, &block)
         queue = options[:queue]
         max = options[:max]
-
+        work_queue = nil
+        # We pass our work queue for processing async work because java nats
+        # uses a cahced thread pool: 1 thread per async subscription.
+        # Sync subs need their own queue so work is not processed async.
+        work_queue = block.nil? ? connection.createMsgChannel : @work_queue
+        sub = connection.subscribe(subject, queue, nil, work_queue)
+
+        # Register the block callback. We only lock to save the callback.
         if block
-          handler = MessageHandlerProxy.new(&block)
-          sub = subscribe_using_subscription_dispatcher(subject, queue, handler)
-          # Auto unsub if max message option was provided.
-          dispatcher.unsubscribe(sub, max) if max
-          sub
-        else
-          sub = subscribe_using_connection(subject, queue)
-          sub.unsubscribe(max) if max
-          sub
+          @subz_mutex.synchronize do
+            @subz_cbs[sub.getSid] = block
+          end
         end
+
+        # Auto unsub if max message option was provided.
+        sub.autoUnsubscribe(max) if max
+
+        sub
       end
 
       def unsubscribe(sub)
         return if sub.nil?
-        if sub.getDispatcher
-          dispatcher.unsubscribe(sub)
-        else
-          sub.unsubscribe()
+
+        # Cleanup our async callback
+        if @subz_cbs[sub.getSid]
+          @subz_mutex.synchronize do
+            @subz_cbs.delete(sub.getSid)
+          end
         end
+
+        # The "true" here is to ignore and invalid conn.
+        sub.unsubscribe(true)
       end
 
       def new_inbox
@@ -192,23 +140,69 @@ module Protobuf
       end
 
       def on_reconnect(&cb)
-        @connection_listener.on_reconnect(&cb)
+        @on_reconnect_cb = cb
       end
 
       def on_disconnect(&cb)
-        @connection_listener.on_disconnect(&cb)
+        @on_disconnect_cb = cb
       end
 
       def on_error(&cb)
-        @error_listener.on_exception(&cb)
+        @on_error_cb = cb
       end
 
       def on_close(&cb)
-        @connection_listener.on_close(&cb)
+        @on_close_cb = cb
       end
 
     private
 
+      def spwan_supervisor_and_consumer
+        spawn_consumer
+        @supervisor = ::Thread.new do
+          loop do
+            begin
+              sleep 1
+              next if @consumer && @consumer.alive?
+              # We need to recreate the consumer thread
+              @consumer.kill if @consumer
+              spawn_consumer
+            rescue => error
+              @on_error_cb.call(error)
+            end
+          end
+        end
+      end
+
+      def spawn_consumer
+        @consumer = ::Thread.new do
+          loop do
+            begin
+              message = @work_queue.take
+              next unless message
+              sub = message.getSubscription
+
+              # We have to update the subscription stats so we're not considered a slow consumer.
+              begin
+                sub.lock
+                sub.incrPMsgs(-1)
+                sub.incrPBytes(-message.getData.length) if message.getData
+                sub.incrDelivered(1) unless sub.isClosed
+              ensure
+                sub.unlock
+              end
+
+              # We don't need t
+              callback = @subz_cbs[sub.getSid]
+              next unless callback
+              callback.call(message.getData.to_s, message.getReplyTo, message.getSubject)
+            rescue => error
+              @on_error_cb.call(error)
+            end
+          end
+        end
+      end
+
       # Jruby-openssl depends on bouncycastle so our lives don't suck super bad
       def read_pem_object_from_file(path)
         fail ::ArgumentError, "Tried to read a PEM key or cert with path nil" if path.nil?
@@ -252,30 +246,6 @@ module Protobuf
         context.init(key_manager.getKeyManagers, trust_manager.getTrustManagers, nil)
         context
       end
-
-      def duration_in_ms(ms)
-        ::Java::JavaTime::Duration.ofMillis(ms)
-      end
-
-      def subscribe_using_connection(subject, queue)
-        if queue
-          connection.subscribe(subject, queue)
-        else
-          connection.subscribe(subject)
-        end
-      end
-
-      def subscribe_using_subscription_dispatcher(subject, queue, handler)
-        if queue
-          dispatcher.java_send(:subscribe,
-                               [::Java::JavaLang::String, ::Java::JavaLang::String, ::Java::IoNatsClient::MessageHandler],
-                               subject, queue, handler)
-        else
-          dispatcher.java_send(:subscribe,
-                               [::Java::JavaLang::String, ::Java::IoNatsClient::MessageHandler],
-                               subject, handler)
-        end
-      end
     end
   end
 end

data/lib/protobuf/nats/platform.rb

@@ -0,0 +1,14 @@
+module Protobuf
+  module Nats
+    def self.jruby?
+      return false if jnats_disabled?
+
+      defined? JRUBY_VERSION
+    end
+
+    def self.jnats_disabled?
+      !!ENV["PB_NATS_DISABLE_JNATS"]
+    end
+  end
+end
+

data/lib/protobuf/nats/server.rb

@@ -6,11 +6,58 @@ require "protobuf/nats/thread_pool"
 
 module Protobuf
   module Nats
+    class SuperSubscriptionManager
+      def initialize(nats, &cb)
+        # Central queue used by all subscriptions
+        @pending_queue = ::SizedQueue.new(::NATS::IO::DEFAULT_SUB_PENDING_MSGS_LIMIT)
+        @subscriptions = []
+        @nats = nats
+        @callback = cb
+
+        # For MRI, reroute the pending queue to the callback
+        @pending_queue_handler = Thread.new do
+          loop do
+            msg = @pending_queue.pop
+            @callback.call(msg.data, msg.reply)
+          end
+        end
+      end
+
+      def queue_subscribe(name)
+        if ::Protobuf::Nats.jruby?
+          @subscriptions << @nats.subscribe(name, :queue => name) do |request_data, reply_id|
+            @callback.call(request_data, reply_id)
+          end
+        else
+          sub = @nats.subscribe(name, :queue => name)
+
+          # Create a subscription but reset the pending queue to use a central pending queue.
+          # NOTE: This is a potential race condition. Chances of the round-trip message to an
+          # existing queue before this queue swap happens seems extremely low, but possible.
+          sub.pending_queue = @pending_queue
+
+          @subscriptions << sub
+
+          sub
+        end
+      end
+
+      def unsubscribe_all
+        if ::Protobuf::Nats.jruby?
+          @subscriptions.each do |subscription_id|
+            @nats.unsubscribe(subscription_id)
+          end
+        else
+          @subscriptions.each { |sub| sub.unsubscribe }
+        end
+      end
+    end
+
     class Server
       include ::Protobuf::Rpc::Server
       include ::Protobuf::Logging
 
-      attr_reader :nats, :thread_pool, :subscriptions
+      attr_reader :nats, :thread_pool, :subscription_manager
 
       MILLISECOND = 1000
 
@@ -25,7 +72,11 @@ module Protobuf
 
         @thread_pool = ::Protobuf::Nats::ThreadPool.new(@options[:threads], :max_queue => max_queue_size)
 
-        @subscriptions = []
+        @subscription_manager = SuperSubscriptionManager.new(@nats) do |request_data, reply_id|
+          unless enqueue_request(request_data, reply_id)
+            logger.error { "Thread pool is full! Dropping message for: #{subscription_key_and_queue}" }
+          end
+        end
         @server = options.fetch(:server, ::Socket.gethostname)
       end
 
@@ -114,11 +165,7 @@ module Protobuf
 
       def subscribe_to_services_once
         with_each_subscription_key do |subscription_key_and_queue|
-          subscriptions << nats.subscribe(subscription_key_and_queue, :queue => subscription_key_and_queue) do |request_data, reply_id, _subject|
-            unless enqueue_request(request_data, reply_id)
-              logger.error { "Thread pool is full! Dropping message for: #{subscription_key_and_queue}" }
-            end
-          end
+          subscription_manager.queue_subscribe(subscription_key_and_queue)
         end
       end
 
@@ -233,9 +280,7 @@ module Protobuf
 
       def unsubscribe
         logger.info "Unsubscribing from rpc routes..."
-        subscriptions.each do |subscription_id|
-          nats.unsubscribe(subscription_id)
-        end
+        subscription_manager.unsubscribe_all
       end
     end
   end

data/lib/protobuf/nats/version.rb

@@ -1,5 +1,5 @@
 module Protobuf
   module Nats
-    VERSION = "0.11.0.pre1"
+    VERSION = "0.12.0.pre0"
   end
 end

data/lib/protobuf/nats.rb

@@ -6,6 +6,7 @@ require "protobuf/rpc/service_directory"
 
 require "nats/io/client"
 
+require "protobuf/nats/platform"
 require "protobuf/nats/errors"
 require "protobuf/nats/client"
 require "protobuf/nats/server"
@@ -23,7 +24,7 @@ module Protobuf
       NACK = "\2".freeze
     end
 
-    NatsClient = if defined? JRUBY_VERSION
+    NatsClient = if jruby?
                    require "protobuf/nats/jnats"
                    ::Protobuf::Nats::JNats
                  else

data/protobuf-nats.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
 
   spec.summary       = %q{ ruby-protobuf client/server for nats }
   spec.description   = %q{ ruby-protobuf client/server for nats }
-  #spec.homepage      = "TODO: Put your gem's website or public repo URL here."
+  spec.homepage      = "https://github.com/mxenabled/protobuf-nats"
   spec.license       = "MIT"
 
   # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
@@ -33,7 +33,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "activesupport", ">= 3.2"
   spec.add_runtime_dependency "connection_pool"
   spec.add_runtime_dependency "protobuf", "~> 3.7", ">= 3.7.2"
-  spec.add_runtime_dependency "nats-pure", "~> 0.3", "< 0.4"
+  spec.add_runtime_dependency "nats-pure", "~> 2"
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake", "~> 10.0"

data/scripts/install_gnatsd.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+
+set -e
+
+export DEFAULT_NATS_SERVER_VERSION=v2.0.0
+
+export NATS_SERVER_VERSION="${NATS_SERVER_VERSION:=$DEFAULT_NATS_SERVER_VERSION}"
+
+# check to see if nats-server folder is empty
+if [ ! "$(ls -A $HOME/nats-server)" ]; then
+    (
+	mkdir -p $HOME/nats-server
+	cd $HOME/nats-server
+	wget https://github.com/nats-io/nats-server/releases/download/$NATS_SERVER_VERSION/nats-server-$NATS_SERVER_VERSION-linux-amd64.zip -O nats-server.zip
+	unzip nats-server.zip
+	cp nats-server-$NATS_SERVER_VERSION-linux-amd64/nats-server $HOME/nats-server/nats-server
+    )
+else
+  echo 'Using cached directory.';
+fi

metadata

@@ -1,44 +1,45 @@
 --- !ruby/object:Gem::Specification
 name: protobuf-nats
 version: !ruby/object:Gem::Version
-  version: 0.11.0.pre1
+  version: 0.12.0.pre0
 platform: ruby
 authors:
 - Brandon Dewitt
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-21 00:00:00.000000000 Z
+date: 2023-01-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.2'
-  name: activesupport
-  prerelease: false
   type: :runtime
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.2'
 - !ruby/object:Gem::Dependency
+  name: connection_pool
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  name: connection_pool
-  prerelease: false
   type: :runtime
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
+  name: protobuf
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -47,9 +48,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 3.7.2
-  name: protobuf
-  prerelease: false
   type: :runtime
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -59,90 +59,84 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 3.7.2
 - !ruby/object:Gem::Dependency
+  name: nats-pure
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '0.4'
-  name: nats-pure
-  prerelease: false
+        version: '2'
   type: :runtime
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '2'
 - !ruby/object:Gem::Dependency
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  name: bundler
-  prerelease: false
   type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
-  name: rake
-  prerelease: false
   type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
 - !ruby/object:Gem::Dependency
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  name: rspec
-  prerelease: false
   type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
+  name: benchmark-ips
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  name: benchmark-ips
-  prerelease: false
   type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  name: pry
-  prerelease: false
   type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -171,7 +165,7 @@ files:
 - examples/warehouse/start_client.sh
 - examples/warehouse/start_server.sh
 - ext/jars/gson-2.6.2.jar
-- ext/jars/jnats-2.6.0.jar
+- ext/jars/jnats-1.1-SNAPSHOT.jar
 - ext/jars/slf4j-api-1.7.25.jar
 - ext/jars/slf4j-simple-1.7.25.jar
 - lib/protobuf/nats.rb
@@ -179,17 +173,19 @@ files:
 - lib/protobuf/nats/config.rb
 - lib/protobuf/nats/errors.rb
 - lib/protobuf/nats/jnats.rb
+- lib/protobuf/nats/platform.rb
 - lib/protobuf/nats/runner.rb
 - lib/protobuf/nats/server.rb
 - lib/protobuf/nats/thread_pool.rb
 - lib/protobuf/nats/version.rb
 - protobuf-nats.gemspec
-homepage:
+- scripts/install_gnatsd.sh
+homepage: https://github.com/mxenabled/protobuf-nats
 licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -204,9 +200,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubyforge_project:
-rubygems_version: 2.6.14.1
-signing_key:
+rubygems_version: 3.1.6
+signing_key: 
 specification_version: 4
 summary: ruby-protobuf client/server for nats
 test_files: []