protobuf-nats 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6da90fadf74510112e08d690f747aa2f1dbebb1e
-  data.tar.gz: dde2e57a8cdc900f029e8931cd6153b6e3bf6904
+  metadata.gz: eeff2a5c3d939012fe3cd2cb7cce12ba89392a81
+  data.tar.gz: 406a4b1f779d1a3d91ea136bbb3616560e8152a7
 SHA512:
-  metadata.gz: 4339ab9bac17df4f2e7b5f33ef5ba93fc4c6e4896c7d84fbd319df503e3790cd6927fbc2c241779fc66c1f7c77438d9b298b923038edf9bfe017ae52274f923c
-  data.tar.gz: 71ff1d34845258b508960d7b5ca8a6ca218d02659ecf4a8513a14d9420a09d44a190a4149822679fbd37b810e6fedde89d3b4cfec56f3880832a5713cb805e70
+  metadata.gz: 8a517022291c46d42a4c6b243cc50625ca37770e64c3fb387c990b43d06b70078ab697a2b153b1e731f04d622758c4a7a33915267014f0f47440e238f3d1455e
+  data.tar.gz: 2368ebed1aead198a600eebac3cdea821c4004737a9983e549b217025fb7d1d10c4a3bed46523b189b1920bb872af2e462acf61d00b07f07c1f264292bd433cb

data/bench/real_client.rb

@@ -4,10 +4,6 @@ ENV["PB_SERVER_TYPE"] = "protobuf/nats/runner"
 require "benchmark/ips"
 require "./examples/warehouse/app"
 
-payload = ::Warehouse::Shipment.new(:guid => ::SecureRandom.uuid, :address => "123 yolo st")
-nats = ::NATS::IO::Client.new
-nats.connect({:servers => ["nats://127.0.0.1:4222"]})
-
 Protobuf::Logging.logger = ::Logger.new(nil)
 
 Benchmark.ips do |config|

data/lib/protobuf/nats.rb

@@ -4,7 +4,6 @@ require "protobuf"
 # We don't need this, but the CLI attempts to terminate.
 require "protobuf/rpc/service_directory"
 
-require "concurrent"
 require "nats/io/client"
 
 require "protobuf/nats/client"
@@ -22,6 +21,13 @@ module Protobuf
       ACK = "\1".freeze
     end
 
+    NatsClient = if defined? JRUBY_VERSION
+                   require "protobuf/nats/jnats"
+                   ::Protobuf::Nats::JNats
+                 else
+                   ::NATS::IO::Client
+                 end
+
     GET_CONNECTED_MUTEX = ::Mutex.new
 
     def self.config
@@ -46,16 +52,39 @@ module Protobuf
         GET_CONNECTED_MUTEX.synchronize do
           return if @start_client_nats_connection
 
-          @client_nats_connection = ::NATS::IO::Client.new
+          @client_nats_connection = NatsClient.new
           @client_nats_connection.connect(config.connection_options)
 
           # Ensure we have a valid connection to the NATS server.
           @client_nats_connection.flush(5)
 
+          @client_nats_connection.on_error do |error|
+            log_error(error)
+          end
+
           true
         end
       end
     end
 
+    # This will work with both ruby and java errors
+    def self.log_error(error)
+      logger.error error.to_s
+      logger.error error.class.to_s
+      if error.respond_to?(:backtrace) && error.backtrace.is_a?(::Array)
+        logger.error error.backtrace.join("\n")
+      end
+    end
+
+    def self.logger
+      ::Protobuf::Logging.logger
+    end
+
+    logger.info "Using #{NatsClient} to connect"
+
+    at_exit do
+      ::Protobuf::Nats.client_nats_connection.close rescue nil
+    end
+
   end
 end

data/lib/protobuf/nats/client.rb

@@ -44,55 +44,106 @@ module Protobuf
         end
       end
 
-      # This is a request that expects two responses.
-      # 1. An ACK from the server. We use a shorter timeout.
-      # 2. A PB message from the server. We use a longer timoeut.
-      def nats_request_with_two_responses(subject, data, opts)
-        nats = Protobuf::Nats.client_nats_connection
-        inbox = nats.new_inbox
-        lock = ::Monitor.new
-        ack_condition = lock.new_cond
-        pb_response_condition = lock.new_cond
-        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
-          end
-        end
-
-        lock.synchronize do
-          # Publish to server
-          nats.publish(subject, data, inbox)
+      # 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
 
+        # This is a request that expects two responses.
+        # 1. An ACK from the server. We use a shorter timeout.
+        # 2. A PB message from the server. We use a longer timoeut.
+        def nats_request_with_two_responses(subject, data, opts)
           # Wait for the ACK from the server
           ack_timeout = opts[:ack_timeout] || 5
-          with_timeout(ack_timeout) { ack_condition.wait(ack_timeout) }
-
           # Wait for the protobuf response
           timeout = opts[:timeout] || 60
-          with_timeout(timeout) { pb_response_condition.wait(timeout) } unless response
+
+          nats = ::Protobuf::Nats.client_nats_connection
+          inbox = nats.new_inbox
+
+          # Publish to server
+          sub = nats.subscribe(inbox, :max => 2)
+          nats.publish(subject, data, inbox)
+
+          # Wait for reply
+          first_message = nats.next_message(sub, ack_timeout)
+          fail ::NATS::IO::Timeout if first_message.nil?
+          second_message = nats.next_message(sub, timeout)
+          fail ::NATS::IO::Timeout 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
+
+          success = has_ack && response
+          fail ::NATS::IO::Timeout unless success
+
+          response
+        ensure
+          # Ensure we don't leave a subscriptiosn sitting around.
+          # This also cleans up memory. It's a no-op if the subscription
+          # is already cleaned up.
+          nats.unsubscribe(sub)
         end
 
-        response
-      ensure
-        # Ensure we don't leave a subscription sitting around.
-        nats.unsubscribe(sid) if response.nil?
-      end
+      else
+
+        def nats_request_with_two_responses(subject, data, opts)
+          nats = Protobuf::Nats.client_nats_connection
+          inbox = nats.new_inbox
+          lock = ::Monitor.new
+          ack_condition = lock.new_cond
+          pb_response_condition = lock.new_cond
+          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
+            end
+          end
+
+          lock.synchronize do
+            # Publish to server
+            nats.publish(subject, data, inbox)
+
+            # Wait for the ACK from the server
+            ack_timeout = opts[:ack_timeout] || 5
+            with_timeout(ack_timeout) { ack_condition.wait(ack_timeout) }
+
+            # Wait for the protobuf response
+            timeout = opts[:timeout] || 60
+            with_timeout(timeout) { pb_response_condition.wait(timeout) } unless response
+          end
+
+          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
 
-      # 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

data/lib/protobuf/nats/config.rb

@@ -4,7 +4,7 @@ require "yaml"
 module Protobuf
   module Nats
     class Config
-      attr_accessor :uses_tls, :servers, :connect_timeout, :tls_client_cert, :tls_client_key
+      attr_accessor :uses_tls, :servers, :connect_timeout, :tls_client_cert, :tls_client_key, :tls_ca_cert
 
       CONFIG_MUTEX = ::Mutex.new
 
@@ -13,6 +13,7 @@ module Protobuf
         :servers => nil,
         :tls_client_cert => nil,
         :tls_client_key => nil,
+        :tls_ca_cert => nil,
         :uses_tls => false,
       }.freeze
 
@@ -53,6 +54,10 @@ module Protobuf
         @connection_options ||= begin
           options = {
             servers: servers,
+            uses_tls: uses_tls,
+            tls_client_cert: tls_client_cert,
+            tls_client_key: tls_client_key,
+            tls_ca_cert: tls_ca_cert,
             connect_timeout: connect_timeout
           }
           options[:tls] = {:context => new_tls_context} if uses_tls

data/lib/protobuf/nats/jnats.rb

@@ -0,0 +1,239 @@
+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")
+
+# Set field accessors so we can access the member variables directly.
+class Java::IoNatsClient::SubscriptionImpl
+  field_accessor :pMsgs, :pBytes, :delivered
+end
+
+module Protobuf
+  module Nats
+    class JNats
+      attr_reader :connection
+
+      class Message
+        attr_reader :data, :subject, :reply
+
+        def initialize(nats_message)
+          @data = nats_message.getData.to_s
+          @reply = nats_message.getReplyTo.to_s
+          @subject = nats_message.getSubject
+        end
+      end
+
+      def initialize
+        @on_error_cb = lambda {|error|}
+        @on_reconnect_cb = lambda {}
+        @on_disconnect_cb = lambda {}
+        @on_close_cb = lambda {}
+        @subz_cbs = {}
+        @subz_mutex = ::Mutex.new
+      end
+
+      def connect(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)
+        # Basically never stop trying to connect
+        connection_factory.setMaxReconnect(60_000)
+
+        # 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)
+        end
+
+        @connection = connection_factory.createConnection
+
+        # We're going to spawn a consumer and supervisor
+        @work_queue = @connection.createMsgChannel
+        spwan_supervisor_and_consumer
+
+        @connection
+      end
+
+      # Do not depend on #close for a greaceful disconnect.
+      def close
+        @connection.close
+        @supervisor.kill rescue nil
+        @consumer.kill rescue nil
+      end
+
+      def flush(timeout_sec = 0.5)
+        @connection.flush(timeout_sec * 1000)
+      end
+
+      def next_message(sub, timeout_sec)
+        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, 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
+          @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?
+
+        # 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
+        "_INBOX.#{::SecureRandom.hex(13)}"
+      end
+
+      def on_reconnect(&cb)
+        @on_reconnect_cb = cb
+      end
+
+      def on_disconnect(&cb)
+        @on_disconnect_cb = cb
+      end
+
+      def on_error(&cb)
+        @on_error_cb = cb
+      end
+
+      def 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.pMsgs -= 1
+                sub.pBytes -= message.getData.length if message.getData
+                sub.delivered += 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?
+
+        file_reader = java.io.FileReader.new(path)
+        pem_parser = org.bouncycastle.openssl.PEMParser.new(file_reader)
+        object = pem_parser.readObject
+        pem_parser.close
+        object
+      end
+
+      def create_ssl_context(options)
+        # Create our certs and key converters to go from bouncycastle to java.
+        cert_converter = org.bouncycastle.cert.jcajce.JcaX509CertificateConverter.new
+        key_converter = org.bouncycastle.openssl.jcajce.JcaPEMKeyConverter.new
+
+        # Load the certs and keys.
+        tls_ca_cert = cert_converter.getCertificate(read_pem_object_from_file(options[:tls_ca_cert]))
+        tls_client_cert = cert_converter.getCertificate(read_pem_object_from_file(options[:tls_client_cert]))
+        tls_client_key = key_converter.getKeyPair(read_pem_object_from_file(options[:tls_client_key]))
+
+        # Setup the CA cert.
+        ca_key_store = java.security.KeyStore.getInstance(java.security.KeyStore.getDefaultType)
+        ca_key_store.load(nil, nil)
+        ca_key_store.setCertificateEntry("ca-certificate", tls_ca_cert)
+        trust_manager = javax.net.ssl.TrustManagerFactory.getInstance(javax.net.ssl.TrustManagerFactory.getDefaultAlgorithm)
+        trust_manager.init(ca_key_store)
+
+        # Setup the cert / key pair.
+        client_key_store = java.security.KeyStore.getInstance(java.security.KeyStore.getDefaultType)
+        client_key_store.load(nil, nil)
+        client_key_store.setCertificateEntry("certificate", tls_client_cert)
+        certificate_java_array = [tls_client_cert].to_java(java.security.cert.Certificate)
+        empty_password = [].to_java(:char)
+        client_key_store.setKeyEntry("private-key", tls_client_key.getPrivate, empty_password, certificate_java_array)
+        key_manager = javax.net.ssl.KeyManagerFactory.getInstance(javax.net.ssl.KeyManagerFactory.getDefaultAlgorithm)
+        key_manager.init(client_key_store, empty_password)
+
+        # Create ssl context.
+        context = javax.net.ssl.SSLContext.getInstance("TLSv1.2")
+        context.init(key_manager.getKeyManagers, trust_manager.getTrustManagers, nil)
+        context
+      end
+    end
+  end
+end

data/lib/protobuf/nats/server.rb

@@ -1,6 +1,7 @@
 require "active_support/core_ext/class/subclasses"
 require "protobuf/rpc/server"
 require "protobuf/rpc/service"
+require "protobuf/nats/thread_pool"
 
 module Protobuf
   module Nats
@@ -15,10 +16,10 @@ module Protobuf
         @running = true
         @stopped = false
 
-        @nats = options[:client] || ::NATS::IO::Client.new
+        @nats = options[:client] || ::Protobuf::Nats::NatsClient.new
         @nats.connect(::Protobuf::Nats.config.connection_options)
 
-        @thread_pool = ::Concurrent::FixedThreadPool.new(options[:threads], :max_queue => options[:threads])
+        @thread_pool = ::Protobuf::Nats::ThreadPool.new(options[:threads], :max_queue => options[:threads])
 
         @subscriptions = []
       end
@@ -27,29 +28,22 @@ module Protobuf
         ::Protobuf::Rpc::Service.implemented_services.map(&:safe_constantize)
       end
 
-      def execute_request_promise(request_data, reply_id)
-        promise = ::Concurrent::Promise.new(:executor => thread_pool).then do
-          # Process request.
-          response_data = handle_request(request_data)
-          # Publish response.
-          nats.publish(reply_id, response_data)
-        end.on_error do |error|
-          log_error(error)
-        end.execute
+      def enqueue_request(request_data, reply_id)
+        was_enqueued = thread_pool.push do
+          begin
+            # Process request.
+            response_data = handle_request(request_data)
+            # Publish response.
+            nats.publish(reply_id, response_data)
+          rescue => error
+            ::Protobuf::Nats.log_error(error)
+          end
+        end
 
         # Publish an ACK to signal the server has picked up the work.
-        nats.publish(reply_id, ::Protobuf::Nats::Messages::ACK)
+        nats.publish(reply_id, ::Protobuf::Nats::Messages::ACK) if was_enqueued
 
-        promise
-      rescue ::Concurrent::RejectedExecutionError
-        nil
-      end
-
-      def log_error(error)
-        logger.error error.to_s
-        if error.respond_to?(:backtrace) && error.backtrace.is_a?(::Array)
-          logger.error error.backtrace.join("\n")
-        end
+        was_enqueued
       end
 
       def subscribe_to_services
@@ -64,7 +58,7 @@ module Protobuf
             logger.info "  - #{subscription_key_and_queue}"
 
             subscriptions << nats.subscribe(subscription_key_and_queue, :queue => subscription_key_and_queue) do |request_data, reply_id, _subject|
-              unless execute_request_promise(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
@@ -82,7 +76,7 @@ module Protobuf
         end
 
         nats.on_error do |error|
-          log_error(error)
+          ::Protobuf::Nats.log_error(error)
         end
 
         nats.on_close do

data/lib/protobuf/nats/thread_pool.rb

@@ -0,0 +1,108 @@
+module Protobuf
+  module Nats
+    class ThreadPool
+
+      def initialize(size, opts = {})
+        @queue = ::Queue.new
+        @active_work = 0
+
+        # Callbacks
+        @error_cb = lambda {|_error|}
+
+        # Synchronization
+        @mutex = ::Mutex.new
+        @cb_mutex = ::Mutex.new
+
+        # Let's get this party started
+        queue_size = opts[:max_queue].to_i || 0
+        @max_size = size + queue_size
+        @max_workers = size
+        @shutting_down = false
+        @workers = []
+        supervise_workers
+      end
+
+      def full?
+        @active_work >= @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)
+        return false if full?
+        return false if @shutting_down
+        @queue << [:work, work_cb]
+        @mutex.synchronize { @active_work += 1 }
+        supervise_workers
+        true
+      end
+
+      # This method is not thread safe by design since our IO model is a single producer thread
+      # with multiple consumer threads.
+      def shutdown
+        @shutting_down = true
+        @max_workers.times { @queue << [:stop, nil] }
+      end
+
+      def kill
+        @shutting_down = true
+        @workers.map(&:kill)
+      end
+
+      # This method is not thread safe by design since our IO model is a single producer thread
+      # with multiple consumer threads.
+      def wait_for_termination(seconds = nil)
+        started_at = ::Time.now
+        loop do
+          sleep 0.1
+          break if seconds && (::Time.now - started_at) >= seconds
+          break if @workers.empty?
+          prune_dead_workers
+        end
+      end
+
+      # This callback is executed in a thread safe manner.
+      def on_error(&cb)
+        @error_cb = cb
+      end
+
+      def size
+        @active_work
+      end
+
+    private
+
+      def prune_dead_workers
+        @workers = @workers.select(&:alive?)
+      end
+
+      def supervise_workers
+        prune_dead_workers
+        missing_worker_count = (@max_workers - @workers.size)
+        missing_worker_count.times do
+          @workers << spawn_worker
+        end
+      end
+
+      def spawn_worker
+        ::Thread.new do
+          loop do
+            type, cb = @queue.pop
+            begin
+              # Break if we're shutting down
+              break if type == :stop
+              # Perform work
+              cb.call
+              # Update stats
+            rescue => error
+              @cb_mutex.synchronize { @error_cb.call(error) }
+            ensure
+              @mutex.synchronize { @active_work -= 1 }
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/protobuf/nats/version.rb

@@ -1,5 +1,5 @@
 module Protobuf
   module Nats
-    VERSION = "0.1.3"
+    VERSION = "0.2.0"
   end
 end

data/protobuf-nats.gemspec

@@ -31,7 +31,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_runtime_dependency "protobuf", "~> 3.7"
-  spec.add_runtime_dependency "concurrent-ruby"
   spec.add_runtime_dependency "nats-pure"
 
   spec.add_development_dependency "bundler", "~> 1.14"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: protobuf-nats
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Brandon Dewitt
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-03-30 00:00:00.000000000 Z
+date: 2017-04-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: protobuf
@@ -24,20 +24,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.7'
-- !ruby/object:Gem::Dependency
-  name: concurrent-ruby
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: nats-pure
   requirement: !ruby/object:Gem::Requirement
@@ -144,11 +130,17 @@ files:
 - examples/warehouse/app.rb
 - 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/slf4j-api-1.7.25.jar
+- ext/jars/slf4j-simple-1.7.25.jar
 - lib/protobuf/nats.rb
 - lib/protobuf/nats/client.rb
 - lib/protobuf/nats/config.rb
+- lib/protobuf/nats/jnats.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: