protobuf-nats 0.11.0.pre1 → 0.13.0.pre0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 983e924ae43d3fca4ccdfc73d8715c5c01b3f2bb
-  data.tar.gz: 9b88a322f6a04be4f2a0392b32555ecc9f29f284
+SHA256:
+  metadata.gz: 34ffc46779be7a7549af169386c7212ed7210997dba1c1af19326a10aa92f98f
+  data.tar.gz: 9ca966e67099fc4332bcd4dc9270032f0238cf8afa7f18cb57a6c81e4307ed6e
 SHA512:
-  metadata.gz: 211f48f2481d731e09593fb926f87cf2d93b92e32ceab6e27952735c6da9ee30ea9f2d2bdb5edd9c3986e8efeb0180782f03451d318f3df086887fe49fe133a2
-  data.tar.gz: 0e70e256836e424a011cef424b9f589b36c4f3bd1d203c29db9e24e58e885043f6d409af531cfb9b29ec57087c179c5cfb83a29c9045380db3dd9920c95b32ec
+  metadata.gz: 4d11137ae46ebfe8a1f003fda41aeba78d4a23893efafb38ad803969ba44df594dd3b0d0b5289e6bface579458baea1327749919f92ecbbbf6e3acbd2235c020
+  data.tar.gz: 5f6b0a643ea4d85063232800dff9fefba05ac70b8787666253244afa474f8314ae6de67b2f10efb970884c47150ce404a78dbf9d18b8ac425727f2172196f836

data/.circleci/config.yml

@@ -0,0 +1,84 @@
+version: 2.1
+
+jobs:
+  build_and_test:
+    parameters:
+      docker_image:
+        type: string
+        description: "The Ruby or JRuby Docker image to test against"
+
+    docker:
+      # 1. The Primary Container (where your code actually runs)
+      - image: << parameters.docker_image >>
+        environment:
+          JRUBY_OPTS: "-J-Xmx1024m"
+          RAILS_ENV: test
+
+      # 2. The Service Container (runs in the background)
+      - image: nats:2.14-linux
+
+    working_directory: ~/project
+
+    steps:
+      - run:
+          name: Install System Dependencies
+          command: |
+            if [ "$(id -u)" = "0" ]; then
+              apt-get update && apt-get install -y build-essential git
+            else
+              sudo apt-get update && sudo apt-get install -y build-essential git
+            fi
+      - checkout
+      # Note: We added the docker_image parameter to the cache key
+      # so MRI and JRuby gems don't conflict.
+      - restore_cache:
+          keys:
+            - v1-gems-<< parameters.docker_image >>-{{ checksum "Gemfile.lock" }}
+            - v1-gems-<< parameters.docker_image >>-
+
+      - run:
+          name: Install Ruby Dependencies
+          command: |
+            gem install bundler
+            bundle config set --local path 'vendor/bundle'
+            bundle install --jobs=4 --retry=3
+
+      - save_cache:
+          paths:
+            - ./vendor/bundle
+          key: v1-gems-<< parameters.docker_image >>-{{ checksum "Gemfile.lock" }}
+
+      # Wait for NATS to be ready before running tests.
+      # Service containers can sometimes take a few seconds to boot up.
+      - run:
+          name: Wait for NATS
+          command: |
+            if [ "$(id -u)" = "0" ]; then
+              apt-get install -y netcat-openbsd
+            else
+              sudo apt-get install -y netcat-openbsd
+            fi
+
+            echo "Waiting for NATS to start..."
+            while ! nc -z localhost 4222; do
+              sleep 1
+            done
+            echo "NATS is ready!"
+
+      - run:
+          name: Run Tests
+          command: bundle exec rspec
+
+workflows:
+  version: 2
+  ruby_compatibility_matrix:
+    jobs:
+      - build_and_test:
+          name: test-<< matrix.docker_image >>
+          matrix:
+            parameters:
+              docker_image:
+                - "cimg/ruby:3.1"
+                - "cimg/ruby:3.4"
+                - "jruby:9.4"
+                - "jruby:10.0"

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/CHANGELOG.md

@@ -0,0 +1,7 @@
+## Changelog
+
+### 0.13.0 - WIP
+- Removed JNats (`nats-pure` is fast enough for JRuby and CRuby parallel work)
+- Added ResponseMuxer (similar to Golang)
+- Added instrumentation when encountering unexpected messages.
+

data/README.md

@@ -148,15 +148,24 @@ And we can see the message was sent to the server and the server replied with a
 If we were to add another service endpoint called `search` to the `UserService` but fail to define an instance method
 `search`, then `protobuf-nats` will not subscribe to that route.
 
+## Future Improvements (locked behind ruby version)
+- Migrate to native `Random.new.uuid_v7`
+```ruby
+@prng_lock.synchronize { @prng.uuid_v7(extra_timestamp_bits: 12) }
+```
+- Change ResponseMuxer to use `.pop()` with a timeout.
+
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 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).
 
+
 ## 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/bench/bench.md

@@ -0,0 +1,16 @@
+
+Notes:
+`-Xjit.threshold=0` - Setting the threshold to 0 forces JRuby to compile every method into Java bytecode immediately before its very first execution. This is particularly useful for debugging or bypassing warm-up times during profiling
+
+
+`-Xjit.threshold=10 -J-XX:CompileThreshold=10` - If you are running benchmarks and want both JRuby and the JVM to aggressively optimize early, you can lower both thresholds simultaneously
+
+`bundle;  bx ruby -I lib bench/real_client.rb`
+
+Start local nats server so details can be monitored.
+`/opt/homebrew/opt/nats-server/bin/nats-server -DV -m 8222 -p 4222`
+
+
+```
+export JRUBY_OPTS="--disable:did_you_mean -J-Djava.security.egd=file:/dev/./urandom -J-Xmx2g -J-Xms1024m -J-Xmn512m -Xjit.threshold=10 -J-XX:CompileThreshold=10"
+```

data/bench/console.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "protobuf/nats"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+# ENV["PB_CLIENT_TYPE"] = "protobuf/nats/client"
+# ENV["PB_SERVER_TYPE"] = "protobuf/nats/runner"
+
+require "irb"
+IRB.start(__FILE__)

data/bench/real_client.rb

@@ -7,8 +7,8 @@ require "./examples/warehouse/app"
 Protobuf::Logging.logger = ::Logger.new(nil)
 
 Benchmark.ips do |config|
-  config.warmup = 10
-  config.time = 10
+  config.warmup = 30
+  config.time = 30
 
   config.report("single threaded performance") do
     req = Warehouse::Shipment.new(:guid => SecureRandom.uuid)

data/bench/real_client.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+
+export JRUBY_OPTS="-J-server --disable:did_you_mean -Xcompile.invokedynamic=true -Xjit.threshold=10 -J-Djava.security.egd=file:/dev/./urandom -J-Xms2g -J-Xmx2g -J-XX:+UseG1GC -J-XX:MaxGCPauseMillis=100"
+
+# export JRUBY_OPTS="-J-server --disable:did_you_mean -Xcompile.invokedynamic=true -Xjit.threshold=0 -J-Djruby.jit.max=0 -J-Djruby.jit.background=false -J-Djava.security.egd=file:/dev/./urandom -J-Xms2g -J-Xmx2g -J-XX:+UseG1GC -J-XX:MaxGCPauseMillis=100"
+
+
+export PB_SERVER_TYPE="protobuf/nats/runner"
+export PB_CLIENT_TYPE="protobuf/nats/client"
+
+echo "$PWD"
+
+bundle exec ruby -I lib bench/real_client.rb

data/bench/real_client_threaded.rb

@@ -0,0 +1,19 @@
+ENV["PB_CLIENT_TYPE"] = "protobuf/nats/client"
+ENV["PB_SERVER_TYPE"] = "protobuf/nats/runner"
+
+require "./examples/warehouse/app"
+
+THREAD_COUNT = ENV.fetch("CLIENT_THREADS",4).to_i
+
+puts "THREAD_COUNT = #{THREAD_COUNT}"
+
+::Protobuf::Logging.logger = ::Logger.new(nil)
+
+while true
+  THREAD_COUNT.times.map do |i|
+    Thread.new do
+      req = Warehouse::Shipment.new(:guid => SecureRandom.uuid, :sleep_time_ms => 5)
+      Warehouse::ShipmentService.client.create(req)
+    end
+  end.each(&:join)
+end

data/bench/real_client_threaded.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+export JRUBY_OPTS="-J-server --disable:did_you_mean -Xcompile.invokedynamic=true -Xjit.threshold=10 -J-Djava.security.egd=file:/dev/./urandom -J-Xms2g -J-Xmx2g -J-XX:+UseG1GC -J-XX:MaxGCPauseMillis=100"
+
+export PB_SERVER_TYPE="protobuf/nats/runner"
+export PB_CLIENT_TYPE="protobuf/nats/client"
+
+export THREAD_COUNT=4
+
+bundle exec ruby -I lib bench/real_client_threaded.rb

data/bench/real_server.sh

@@ -1 +1,16 @@
-PB_SERVER_TYPE="protobuf/nats/runner" PB_CLIENT_TYPE="protobuf/nats/client" bundle exec rpc_server start --threads=20 ./examples/warehouse/app.rb > /dev/null
+#!/bin/bash
+
+# export JRUBY_OPTS="-J-server --disable:did_you_mean -Xcompile.invokedynamic=true -Xjit.threshold=0 -J-Djruby.jit.max=0 -J-Djruby.jit.background=false -J-Djava.security.egd=file:/dev/./urandom -J-Xms2g -J-Xmx2g -J-XX:+UseG1GC -J-XX:MaxGCPauseMillis=100"
+
+export JRUBY_OPTS="-J-server -J-Xms4g -J-Xmx4g -J-XX:+AlwaysPreTouch -J-XX:+UseParallelGC -J-XX:ReservedCodeCacheSize=768m -J-XX:MaxInlineLevel=18 -J-XX:MaxInlineSize=100 -J-XX:FreqInlineSize=500 -J-XX:LoopUnrollLimit=250 -J-XX:+UseSuperWord -J-Djruby.jit.threshold=0 -J-Djruby.jit.max=0 -J-Djruby.jit.background=false  -Xcompile.invokedynamic=true"
+
+
+export PB_SERVER_TYPE="protobuf/nats/runner"
+export PB_CLIENT_TYPE="protobuf/nats/client"
+
+export PB_NATS_SERVER_SLOW_START_DELAY=1
+
+export PB_NATS_SERVER_MAX_QUEUE_SIZE=6
+
+bundle exec rpc_server start --threads=10 ./examples/warehouse/app.rb
+

data/examples/warehouse/app.rb

@@ -12,7 +12,6 @@ module Warehouse
   class ShipmentRequest < ::Protobuf::Message; end
   class Shipments < ::Protobuf::Message; end
 
-
   ##
   # Message Fields
   #
@@ -21,6 +20,8 @@ module Warehouse
     optional :string, :address, 2
     optional :double, :price, 3
     optional :string, :package_guid, 4
+
+    optional :int64, :sleep_time_ms, 100
   end
 
   class ShipmentRequest
@@ -33,7 +34,6 @@ module Warehouse
     repeated ::Warehouse::Shipment, :records, 1
   end
 
-
   ##
   # Service Classes
   #
@@ -43,6 +43,12 @@ module Warehouse
     rpc :search, ::Warehouse::ShipmentRequest, ::Warehouse::Shipments
 
     def create
+      # Allows for easier testing of multiple threads
+      if request.sleep_time_ms > 0
+        sleep(request.sleep_time_ms / 1000.0)
+        puts "sleep_time:#{request.sleep_time_ms}"
+      end
+
       respond_with request
     end
 

data/lib/protobuf/nats/client.rb

@@ -1,11 +1,21 @@
+require 'securerandom'
 require "connection_pool"
 require "protobuf/nats"
 require "protobuf/rpc/connectors/base"
 require "monitor"
 
+# Load this independently because we store the class singleton in a const.
+require "protobuf/nats/response_muxer"
+
 module Protobuf
   module Nats
     class Client < ::Protobuf::Rpc::Connectors::Base
+
+      RESPONSE_MUXER = ::Protobuf::Nats::ResponseMuxer.new
+
+      @subscription_key_cache = {}
+      @subscription_pool_lock = ::Mutex.new
+
       # Structure to hold subscription and inbox to use within pool
       SubscriptionInbox = ::Struct.new(:subscription, :inbox) do
         def swap(sub_inbox)
@@ -14,11 +24,26 @@ module Protobuf
         end
       end
 
+      def logger
+        ::Protobuf::Logging.logger
+      end
+
+      def response_muxer
+        RESPONSE_MUXER
+      end
+
       def self.subscription_pool
-        @subscription_pool ||= ::ConnectionPool.new(:size => subscription_pool_size, :timeout => 0.1) do
-          inbox = ::Protobuf::Nats.client_nats_connection.new_inbox
+        return @subscription_pool if @subscription_pool
+
+        @subscription_pool_lock.synchronize do
+          # The double-check ensures we don't create a new pool if another
+          # thread created one while we were waiting for the lock.
+          return @subscription_pool if @subscription_pool
 
-          SubscriptionInbox.new(::Protobuf::Nats.client_nats_connection.subscribe(inbox), inbox)
+          @subscription_pool = ::ConnectionPool.new(:size => subscription_pool_size, :timeout => 0.1) do
+            inbox = ::Protobuf::Nats.client_nats_connection.new_inbox
+            SubscriptionInbox.new(::Protobuf::Nats.client_nats_connection.subscribe(inbox), inbox)
+          end
         end
       end
 
@@ -36,6 +61,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
@@ -69,7 +97,7 @@ module Protobuf
       end
 
       def self.subscription_key_cache
-        @subscription_key_cache ||= {}
+        @subscription_key_cache
       end
 
       def ack_timeout
@@ -151,12 +179,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 +193,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,115 +214,65 @@ module Protobuf
         end
       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
-
-        # 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
-          # Wait for the protobuf response
-          timeout = opts[:timeout] || 60
-
-          nats = ::Protobuf::Nats.client_nats_connection
-
-          # Publish to server
-          with_subscription do |sub_inbox|
-            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)
-                nats.unsubscribe(sub_inbox.subscription)
-                sub_inbox.swap(new_subscription_inbox) # this line replaces the sub_inbox in the connection pool if necessary
-              end
-
-              nats.publish(subject, data, sub_inbox.inbox)
-
-              # Wait for reply
-              first_message = nats.next_message(sub_inbox.subscription, ack_timeout)
-              return :ack_timeout if first_message.nil?
-
-              first_message_data = first_message.data
-              return :nack if first_message_data == ::Protobuf::Nats::Messages::NACK
+      def formatted_service_and_method_name
+        klass = @options[:service]
+        method_name = @options[:method]
+        "#{klass}##{method_name}"
+      end
 
-              second_message = nats.next_message(sub_inbox.subscription, timeout)
-              second_message_data = second_message.nil? ? nil : second_message.data
+      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
 
-              # Check messages
-              response = case ::Protobuf::Nats::Messages::ACK
-                         when first_message_data then second_message_data
-                         when second_message_data then first_message_data
-                         else return :ack_timeout
-                         end
+        nats = Protobuf::Nats.client_nats_connection
 
-              fail(::Protobuf::Nats::Errors::ResponseTimeout, subject) unless response
+        # Publish message with the reply topic pointed at the response muxer.
+        req = RESPONSE_MUXER.new_request
+        req.publish(subject, data)
 
-              completed_request = true
-              response
-            ensure
-              if !completed_request
-                nats.unsubscribe(sub_inbox.subscription)
-                sub_inbox.swap(new_subscription_inbox) # this line replaces the sub_inbox in the connection pool if necessary
-              end
-            end
-          end
+        # Receive the first message
+        begin
+          first_message = req.next_message(ack_timeout)
+          logger.debug { "received message with subject:#{first_message.subject}" } if logger.debug?
+        rescue ::NATS::Timeout => e
+          return :ack_timeout
         end
 
-      else
-
-        def nats_request_with_two_responses(subject, data, opts)
-          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
+        # Check for a NACK
+        return :nack if first_message.data == ::Protobuf::Nats::Messages::NACK
 
-          lock.synchronize do
-            # Publish to server
-            nats.publish(subject, data, inbox)
-
-            # Wait for the ACK from the server
-            ack_timeout = opts[:ack_timeout] || 5
-            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
+        # Receive the second message
+        begin
+          second_message = req.next_message(timeout)
+        rescue ::NATS::Timeout
+          # ignore to raise a repsonse timeout below
+        end
 
-            # Wait for the protobuf response
-            timeout = opts[:timeout] || 60
-            received.wait(timeout) if messages.empty?
-            second_message = messages.shift
-          end
+        # NOTE: This might be nil, so be careful checking the data value
+        second_message_data = second_message&.data
 
-          response = case ::Protobuf::Nats::Messages::ACK
-                     when first_message then second_message
-                     when second_message then first_message
-                     else return :ack_timeout
-                     end
+        # This should never happen, if it does, then return an :ack_timeout because something went wrong
+        if first_message&.data == ::Protobuf::Nats::Messages::ACK &&
+          second_message&.data == ::Protobuf::Nats::Messages::ACK
+          logger.warn "received ACK/ACK message."
+          return :ack_timeout
+        end
 
-          fail(::Protobuf::Nats::Errors::ResponseTimeout, subject) unless response
+        # Check messages
+        response = case ::Protobuf::Nats::Messages::ACK
+                   when first_message&.data then second_message_data
+                   when second_message&.data then first_message&.data
+                   else return :ack_timeout
+                   end
 
-          response
-        ensure
-          # Ensure we don't leave a subscription sitting around.
-          nats.unsubscribe(sid) if response.nil?
-        end
+        fail(::Protobuf::Nats::Errors::ResponseTimeout, formatted_service_and_method_name) unless response
 
+        response
+      ensure
+        # cleanup the token from the request map
+        req.cleanup if req
       end
 
     end

data/lib/protobuf/nats/config.rb

@@ -1,3 +1,4 @@
+require "erb"
 require "openssl"
 require "yaml"
 
@@ -39,8 +40,14 @@ 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.exists?(absolute_config_path)
-              yaml_config = ::YAML.load_file(absolute_config_path)[env]
+            if ::File.exist?(absolute_config_path)
+              yaml_string = ::ERB.new(::File.read(absolute_config_path)).result
+              # 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(yaml_string)[env]
+              else
+                ::YAML.load(yaml_string)[env]
+              end
             end
 
             DEFAULTS.each_pair do |key, value|

data/lib/protobuf/nats/errors.rb

@@ -1,32 +1,22 @@
 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
+      class ResponseMuxer < ClientError
       end
 
-      class MriIllegalStateException < ::StandardError
+      class MriIOException < ::StandardError
       end
 
-      IllegalStateException = if defined? JRUBY_VERSION
-                                java.lang.IllegalStateException
-                              else
-                                MriIllegalStateException
-                              end
-
-      IOException = if defined? JRUBY_VERSION
-                      java.io.IOException
-                    else
-                      MriIOException
-                    end
+      IOException = MriIOException
     end
   end
 end