protobuf-nats 0.10.7 → 0.11.0.pre0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b24dc4e6dfe807ddff392c7fdf8187dab743915511c996fb8484dd5d7c61361
-  data.tar.gz: d6fa80dcf05264db2520cb0cffb3f60edef7364d491ffaf66c6c1f2d213eb73d
+  metadata.gz: 0fa8475a4054e8c99c04c30193f773ccca511efbf8412a8d26fa162dbb024f4c
+  data.tar.gz: 66a92c3b49be6df8f0014a219d9691b847b7432e00d685722739190c30ba9ac5
 SHA512:
-  metadata.gz: a0b1a723daac8e84fa1e1d5727334790498b267fc8396352e6a68914f1aace2cadf693674a1a253409e21d2d1057fdd9dea69eec416b61bb7318ab4501389aab
-  data.tar.gz: 169806eefdc18c2bad9e64a880857c9820d3132178df6b7e4a8744bdd119c7ad649082080e272222c167b15c6f75de855ca7340eda4f36cbf34355da50a6b877
+  metadata.gz: 0cce76f4edd08e182c665ac53fc5d69e39ccb764855f1335220a197a98b18fa2012c73862071b77b1f0e32a2c8b7d7e60b5c652fe458151733dc3f7f79970c71
+  data.tar.gz: a024fd949c96297de7d853bb182503716ed449b1500f217660e8e1bcf4fb2639ca0b12840c002732ef415e9889cea39880b638d2fb3f1859405f750185b4d2d1

data/.travis.yml

@@ -1,16 +1,12 @@
 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

@@ -154,11 +154,9 @@ 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/mxenabled/protobuf-nats.
+Bug reports and pull requests are welcome on GitHub at https://github.com/abrandoned/protobuf-nats.
 
 
 ## License

data/lib/protobuf/nats/client.rb

@@ -151,12 +151,12 @@ module Protobuf
           when :ack_timeout
             ::ActiveSupport::Notifications.instrument "client.request_timeout.protobuf-nats"
             next if (retries -= 1) > 0
-            raise ::Protobuf::Nats::Errors::RequestTimeout, formatted_service_and_method_name
+            raise ::Protobuf::Nats::Errors::RequestTimeout
           when :nack
             ::ActiveSupport::Notifications.instrument "client.request_nack.protobuf-nats"
             interval = nack_backoff_intervals[nack_retry]
             nack_retry += 1
-            raise ::Protobuf::Nats::Errors::RequestTimeout, formatted_service_and_method_name if interval.nil?
+            raise ::Protobuf::Nats::Errors::RequestTimeout if interval.nil?
             sleep((interval + nack_backoff_splay)/1000.0)
             next
           end
@@ -186,12 +186,6 @@ 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.
@@ -213,7 +207,7 @@ module Protobuf
             begin
               completed_request = false
 
-              if !sub_inbox.subscription.is_valid # replace the subscription if is has been pooled but is no longer valid (maybe a reconnect)
+              if !sub_inbox.subscription.is_active # 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
@@ -237,7 +231,7 @@ module Protobuf
                          else return :ack_timeout
                          end
 
-              fail(::Protobuf::Nats::Errors::ResponseTimeout, formatted_service_and_method_name) unless response
+              fail(::Protobuf::Nats::Errors::ResponseTimeout, subject) unless response
 
               completed_request = true
               response
@@ -293,7 +287,7 @@ module Protobuf
                      else return :ack_timeout
                      end
 
-          fail(::Protobuf::Nats::Errors::ResponseTimeout, formatted_service_and_method_name) unless response
+          fail(::Protobuf::Nats::Errors::ResponseTimeout, subject) unless response
 
           response
         ensure

data/lib/protobuf/nats/config.rb

@@ -39,13 +39,8 @@ module Protobuf
             yaml_config = {}
             config_path = ENV["PROTOBUF_NATS_CONFIG_PATH"] || ::File.join("config", "protobuf_nats.yml")
             absolute_config_path = ::File.expand_path(config_path)
-            if ::File.exist?(absolute_config_path)
-              # 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
+            if ::File.exists?(absolute_config_path)
+              yaml_config = ::YAML.load_file(absolute_config_path)[env]
             end
 
             DEFAULTS.each_pair do |key, value|

data/lib/protobuf/nats/errors.rb

@@ -1,13 +1,13 @@
 module Protobuf
   module Nats
     module Errors
-      class ClientError < ::StandardError
+      class Base < ::StandardError
       end
 
-      class RequestTimeout < ClientError
+      class RequestTimeout < Base
       end
 
-      class ResponseTimeout < ClientError
+      class ResponseTimeout < Base
       end
 
       class MriIOException < ::StandardError

data/lib/protobuf/nats/jnats.rb

@@ -3,12 +3,82 @@ 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-1.1-SNAPSHOT.jar")
+require ::File.join(ext_base, "jars/jnats-2.6.0.jar")
 
 module Protobuf
   module Nats
     class JNats
-      attr_reader :connection, :options
+      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
 
       class Message
         attr_reader :data, :subject, :reply
@@ -21,10 +91,9 @@ module Protobuf
       end
 
       def initialize
-        @on_error_cb = lambda {|error|}
-        @on_reconnect_cb = lambda {}
-        @on_disconnect_cb = lambda {}
-        @on_close_cb = lambda {}
+        @connection_listener = ConnectionListener.new
+        @error_listener = ErrorListener.new
+
         @options = nil
         @subz_cbs = {}
         @subz_mutex = ::Mutex.new
@@ -34,35 +103,26 @@ module Protobuf
         @options ||= options
 
         servers = options[:servers] || ["nats://localhost:4222"]
-        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])
+        servers = [servers].flatten
+
+        builder = ::Java::IoNatsClient::Options::Builder.new
+        builder.servers(servers)
+        builder.maxReconnects(options[:max_reconnect_attempts])
+        builder.errorListener(@error_listener)
 
         # Shrink the pending buffer to always raise an error and let the caller retry.
         if options[:disable_reconnect_buffer]
-          connection_factory.setReconnectBufSize(1)
+          builder.reconnectBufferSize(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)
-          connection_factory.setSecure(true)
-          connection_factory.setSSLContext(ssl_context)
+          builder.sslContext(ssl_context)
         end
 
-        @connection = connection_factory.createConnection
-
-        # We're going to spawn a consumer and supervisor
-        @work_queue = @connection.createMsgChannel
-        spwan_supervisor_and_consumer
-
+        @connection = ::Java::IoNatsClient::Nats.connect(builder.build)
+        @dispatcher = @connection.createDispatcher(MessageHandlerProxy.empty)
         @connection
       end
 
@@ -75,64 +135,56 @@ module Protobuf
 
       # Do not depend on #close for a graceful disconnect.
       def close
-        @connection.close rescue nil
+        if @connection
+          @connection.closeDispatcher(@dispatcher) rescue nil
+          @connection.close rescue nil
+        end
+        @dispatcher = nil
         @connection = nil
-        @supervisor.kill rescue nil
-        @supervisor = nil
-        @consumer.kill rescue nil
-        @supervisor = nil
       end
 
       def flush(timeout_sec = 0.5)
-        connection.flush(timeout_sec * 1000)
+        duration = duration_in_ms(timeout_sec * 1000)
+        connection.flush(duration)
       end
 
       def next_message(sub, timeout_sec)
-        nats_message = sub.nextMessage(timeout_sec * 1000)
+        duration = duration_in_ms(timeout_sec * 1000)
+        nats_message = sub.nextMessage(duration)
         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, true)
+        connection.publish(subject, mailbox, data.to_java_bytes)
+        connection.flush(nil)
       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
-          @subz_mutex.synchronize do
-            @subz_cbs[sub.getSid] = block
-          end
+          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
         end
-
-        # Auto unsub if max message option was provided.
-        sub.autoUnsubscribe(max) if max
-
-        sub
       end
 
       def unsubscribe(sub)
         return if sub.nil?
-
-        # Cleanup our async callback
-        if @subz_cbs[sub.getSid]
-          @subz_mutex.synchronize do
-            @subz_cbs.delete(sub.getSid)
-          end
+        if sub.getDispatcher
+          dispatcher.unsubscribe(sub)
+        else
+          sub.unsubscribe()
         end
-
-        # The "true" here is to ignore and invalid conn.
-        sub.unsubscribe(true)
       end
 
       def new_inbox
@@ -140,69 +192,23 @@ module Protobuf
       end
 
       def on_reconnect(&cb)
-        @on_reconnect_cb = cb
+        @connection_listener.on_reconnect(&cb)
       end
 
       def on_disconnect(&cb)
-        @on_disconnect_cb = cb
+        @connection_listener.on_disconnect(&cb)
       end
 
       def on_error(&cb)
-        @on_error_cb = cb
+        @error_listener.on_exception(&cb)
       end
 
       def on_close(&cb)
-        @on_close_cb = cb
+        @connection_listener.on_close(&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?
@@ -246,6 +252,30 @@ 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/server.rb

@@ -29,12 +29,6 @@ module Protobuf
         @server = options.fetch(:server, ::Socket.gethostname)
       end
 
-      def instrument_thread_pool_sizes
-        ::ActiveSupport::Notifications.instrument("server.thread_pool_enqueued_size.protobuf-nats", thread_pool.enqueued_size)
-        ::ActiveSupport::Notifications.instrument("server.thread_pool_max_size.protobuf-nats", thread_pool.max_size)
-        ::ActiveSupport::Notifications.instrument("server.thread_pool_running_size.protobuf-nats", thread_pool.size)
-      end
-
       def max_queue_size
         ::ENV.fetch("PB_NATS_SERVER_MAX_QUEUE_SIZE", @options[:threads]).to_i
       end
@@ -211,7 +205,6 @@ module Protobuf
         loop do
           break unless @running
           detect_and_handle_a_pause
-          instrument_thread_pool_sizes
           sleep 1
         end
 

data/lib/protobuf/nats/thread_pool.rb

@@ -22,18 +22,10 @@ module Protobuf
         supervise_workers
       end
 
-      def enqueued_size
-        @queue.size
-      end
-
       def full?
         @active_work >= @max_size
       end
 
-      def max_size
-        @max_size
-      end
-
       # This method is not thread safe by design since our IO model is a single producer thread
       # with multiple consumer threads.
       def push(&work_cb)

data/lib/protobuf/nats/version.rb

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

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      = "https://github.com/mxenabled/protobuf-nats"
+  #spec.homepage      = "TODO: Put your gem's website or public repo URL here."
   spec.license       = "MIT"
 
   # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: protobuf-nats
 version: !ruby/object:Gem::Version
-  version: 0.10.7
+  version: 0.11.0.pre0
 platform: ruby
 authors:
 - Brandon Dewitt
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-08-26 00:00:00.000000000 Z
+date: 2019-08-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -171,7 +171,7 @@ files:
 - examples/warehouse/start_client.sh
 - examples/warehouse/start_server.sh
 - ext/jars/gson-2.6.2.jar
-- ext/jars/jnats-1.1-SNAPSHOT.jar
+- ext/jars/jnats-2.6.0.jar
 - ext/jars/slf4j-api-1.7.25.jar
 - ext/jars/slf4j-simple-1.7.25.jar
 - lib/protobuf/nats.rb
@@ -184,13 +184,12 @@ files:
 - lib/protobuf/nats/thread_pool.rb
 - lib/protobuf/nats/version.rb
 - protobuf-nats.gemspec
-- scripts/install_gnatsd.sh
-homepage: https://github.com/mxenabled/protobuf-nats
+homepage: 
 licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -201,12 +200,13 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.5.17
-signing_key:
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
 specification_version: 4
 summary: ruby-protobuf client/server for nats
 test_files: []

data/scripts/install_gnatsd.sh

@@ -1,20 +0,0 @@
-#!/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