nats-pure 2.2.0 → 2.3.0

data/lib/nats/io/kv/errors.rb

@@ -0,0 +1,60 @@
+# Copyright 2021 The NATS Authors
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require_relative '../errors'
+
+module NATS
+  class KeyValue
+    class Error < NATS::Error; end
+
+    # When a key is not found.
+    class KeyNotFoundError < Error
+      attr_reader :entry, :op
+      def initialize(params={})
+        @entry = params[:entry]
+        @op = params[:op]
+        @message = params[:message]
+      end
+
+      def to_s
+        msg = "nats: key not found"
+        msg = "#{msg}: #{@message}" if @message
+        msg
+      end
+    end
+
+    # When a key is not found because it was deleted.
+    class KeyDeletedError < KeyNotFoundError
+      def to_s
+        "nats: key was deleted"
+      end
+    end
+
+    # When there was no bucket present.
+    class BucketNotFoundError < Error; end
+
+    # When it is an invalid bucket.
+    class BadBucketError < Error; end
+
+    # When the result is an unexpected sequence.
+    class KeyWrongLastSequenceError < Error
+      def initialize(msg)
+        @msg = msg
+      end
+      def to_s
+        "nats: #{@msg}"
+      end
+    end
+  end
+end

data/lib/nats/io/kv/manager.rb

@@ -0,0 +1,89 @@
+# Copyright 2021 The NATS Authors
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+module NATS
+  class KeyValue
+    module Manager
+      def key_value(bucket)
+        stream = "KV_#{bucket}"
+        begin
+          si = stream_info(stream)
+        rescue NATS::JetStream::Error::NotFound
+          raise BucketNotFoundError.new("nats: bucket not found")
+        end
+        if si.config.max_msgs_per_subject < 1
+          raise BadBucketError.new("nats: bad bucket")
+        end
+
+        KeyValue.new(
+          name: bucket,
+          stream: stream,
+          pre: "$KV.#{bucket}.",
+          js: self,
+          direct: si.config.allow_direct
+        )
+      end
+
+      def create_key_value(config)
+        config = if not config.is_a?(KeyValue::API::KeyValueConfig)
+                   KeyValue::API::KeyValueConfig.new(config)
+                 else
+                   config
+                 end
+        config.history ||= 1
+        config.replicas ||= 1
+        duplicate_window = 2 * 60 # 2 minutes
+        if config.ttl
+          if config.ttl < duplicate_window
+            duplicate_window = config.ttl
+          end
+          config.ttl = config.ttl * ::NATS::NANOSECONDS
+        end
+
+        stream = JetStream::API::StreamConfig.new(
+          name: "KV_#{config.bucket}",
+          description: config.description,
+          subjects: ["$KV.#{config.bucket}.>"],
+          allow_direct: config.direct,
+          allow_rollup_hdrs: true,
+          deny_delete: true,
+          discard: "new",
+          duplicate_window: duplicate_window * ::NATS::NANOSECONDS,
+          max_age: config.ttl,
+          max_bytes: config.max_bytes,
+          max_consumers: -1,
+          max_msg_size: config.max_value_size,
+          max_msgs: -1,
+          max_msgs_per_subject: config.history,
+          num_replicas: config.replicas,
+          storage: config.storage,
+          republish: config.republish,
+          )
+
+        si = add_stream(stream)
+        KeyValue.new(
+          name: config.bucket,
+          stream: stream.name,
+          pre: "$KV.#{config.bucket}.",
+          js: self,
+          direct: si.config.allow_direct
+        )
+      end
+
+      def delete_key_value(bucket)
+        delete_stream("KV_#{bucket}")
+      end
+    end
+  end
+end

data/lib/nats/io/kv.rb

@@ -11,7 +11,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-require_relative 'errors'
+
+require_relative 'kv/api'
+require_relative 'kv/bucket_status'
+require_relative 'kv/errors'
+require_relative 'kv/manager'
 
 module NATS
   class KeyValue
@@ -30,47 +34,6 @@ module NATS
       @direct = opts[:direct]
     end
 
-    class Error < NATS::Error; end
-
-    # When a key is not found.
-    class KeyNotFoundError < Error
-      attr_reader :entry, :op
-      def initialize(params={})
-        @entry = params[:entry]
-        @op = params[:op]
-        @message = params[:message]
-      end
-
-      def to_s
-        msg = "nats: key not found"
-        msg = "#{msg}: #{@message}" if @message
-        msg
-      end
-    end
-
-    # When a key is not found because it was deleted.
-    class KeyDeletedError < KeyNotFoundError
-      def to_s
-        "nats: key was deleted"
-      end
-    end
-
-    # When there was no bucket present.
-    class BucketNotFoundError < Error; end
-
-    # When it is an invalid bucket.
-    class BadBucketError < Error; end
-
-    # When the result is an unexpected sequence.
-    class KeyWrongLastSequenceError < Error
-      def initialize(msg)
-        @msg = msg
-      end
-      def to_s
-        "nats: #{@msg}"
-      end
-    end
-
     # get returns the latest value for the key.
     def get(key, params={})
       entry = nil
@@ -211,120 +174,5 @@ module NATS
         super(opts)
       end
     end
-
-    class BucketStatus
-      attr_reader :bucket
-
-      def initialize(info, bucket)
-        @nfo = info
-        @bucket = bucket
-      end
-
-      def values
-        @nfo.state.messages
-      end
-
-      def history
-        @nfo.config.max_msgs_per_subject
-      end
-
-      def ttl
-        @nfo.config.max_age / ::NATS::NANOSECONDS
-      end
-    end
-
-    module API
-      KeyValueConfig = Struct.new(
-          :bucket,
-          :description,
-          :max_value_size,
-          :history,
-          :ttl,
-          :max_bytes,
-          :storage,
-          :replicas,
-          :placement,
-          :republish,
-          :direct,
-          keyword_init: true) do
-        def initialize(opts={})
-          rem = opts.keys - members
-          opts.delete_if { |k| rem.include?(k) }
-          super(opts)
-        end
-      end
-    end
-
-    module Manager
-      def key_value(bucket)
-        stream = "KV_#{bucket}"
-        begin
-          si = stream_info(stream)
-        rescue NATS::JetStream::Error::NotFound
-          raise BucketNotFoundError.new("nats: bucket not found")
-        end
-        if si.config.max_msgs_per_subject < 1
-          raise BadBucketError.new("nats: bad bucket")
-        end
-
-        KeyValue.new(
-          name: bucket,
-          stream: stream,
-          pre: "$KV.#{bucket}.",
-          js: self,
-          direct: si.config.allow_direct
-        )
-      end
-
-      def create_key_value(config)
-        config = if not config.is_a?(KeyValue::API::KeyValueConfig)
-                   KeyValue::API::KeyValueConfig.new(config)
-                 else
-                   config
-                 end
-        config.history ||= 1
-        config.replicas ||= 1
-        duplicate_window = 2 * 60 # 2 minutes
-        if config.ttl
-          if config.ttl < duplicate_window
-            duplicate_window = config.ttl
-          end
-          config.ttl = config.ttl * ::NATS::NANOSECONDS
-        end
-
-        stream = JetStream::API::StreamConfig.new(
-          name: "KV_#{config.bucket}",
-          description: config.description,
-          subjects: ["$KV.#{config.bucket}.>"],
-          allow_direct: config.direct,
-          allow_rollup_hdrs: true,
-          deny_delete: true,
-          discard: "new",
-          duplicate_window: duplicate_window * ::NATS::NANOSECONDS,
-          max_age: config.ttl,
-          max_bytes: config.max_bytes,
-          max_consumers: -1,
-          max_msg_size: config.max_value_size,
-          max_msgs: -1,
-          max_msgs_per_subject: config.history,
-          num_replicas: config.replicas,
-          storage: config.storage,
-          republish: config.republish,
-        )
-
-        si = add_stream(stream)
-        KeyValue.new(
-          name: config.bucket,
-          stream: stream.name,
-          pre: "$KV.#{config.bucket}.",
-          js: self,
-          direct: si.config.allow_direct
-        )
-      end
-
-      def delete_key_value(bucket)
-        delete_stream("KV_#{bucket}")
-      end
-    end
   end
 end

data/lib/nats/io/msg.rb

@@ -11,7 +11,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-require_relative 'js'
+require_relative 'jetstream'
 
 module NATS
   class Msg
@@ -50,7 +50,9 @@ module NATS
 
     def inspect
       hdr = ", header=#{@header}" if @header
-      "#<NATS::Msg(subject: \"#{@subject}\", reply: \"#{@reply}\", data: #{@data.slice(0, 10).inspect}#{hdr})>"
+      dot = '...' if @data.length > 10
+      dat = "#{data.slice(0, 10)}#{dot}"
+      "#<NATS::Msg(subject: \"#{@subject}\", reply: \"#{@reply}\", data: #{dat.inspect}#{hdr})>"
     end
   end
 end

data/lib/nats/io/rails.rb

@@ -0,0 +1,29 @@
+require "rails"
+
+module NATS
+  class Rails < ::Rails::Engine
+    # This class is used to free resources managed by Rails (e.g. database connections)
+    # that were implicitly acquired in subscription callbacks
+    # Implementation is based on https://github.com/sidekiq/sidekiq/blob/5e1a77a6d03193dd977fbfe8961ab78df91bb392/lib/sidekiq/rails.rb
+    class Reloader
+      def initialize(app = ::Rails.application)
+        @app = app
+      end
+
+      def call
+        params = (::Rails::VERSION::STRING >= "7.1") ? {source: "gem.nats"} : {}
+        @app.reloader.wrap(**params) do
+          yield
+        end
+      end
+
+      def inspect
+        "#<NATS::Rails::Reloader @app=#{@app.class.name}>"
+      end
+    end
+
+    config.after_initialize do
+      NATS::Client.default_reloader = NATS::Rails::Reloader.new
+    end
+  end
+end

data/lib/nats/io/subscription.rb

@@ -28,14 +28,14 @@ module NATS
     include MonitorMixin
 
     attr_accessor :subject, :queue, :future, :callback, :response, :received, :max, :pending, :sid
-    attr_accessor :pending_queue, :pending_size, :wait_for_msgs_t, :wait_for_msgs_cond, :is_slow_consumer
+    attr_accessor :pending_queue, :pending_size, :wait_for_msgs_cond, :concurrency_semaphore
     attr_accessor :pending_msgs_limit, :pending_bytes_limit
     attr_accessor :nc
     attr_accessor :jsi
     attr_accessor :closed
 
-    def initialize
-      super # required to initialize monitor
+    def initialize(**opts)
+      super() # required to initialize monitor
       @subject  = ''
       @queue    = nil
       @future   = nil
@@ -53,11 +53,27 @@ module NATS
       @pending_size        = 0
       @pending_msgs_limit  = nil
       @pending_bytes_limit = nil
-      @wait_for_msgs_t     = nil
-      @is_slow_consumer    = false
 
       # Sync subscriber
       @wait_for_msgs_cond = nil
+
+      # To limit number of concurrent messages being processed (1 to only allow sequential processing)
+      @processing_concurrency = opts.fetch(:processing_concurrency, NATS::IO::DEFAULT_SINGLE_SUB_CONCURRENCY)
+    end
+
+    # Concurrency of message processing for a single subscription.
+    # 1 means sequential processing
+    # 2+ allow processed concurrently and possibly out of order.
+    def processing_concurrency=(value)
+      raise ArgumentError, "nats: subscription processing concurrency must be positive integer" unless value.positive?
+      return if @processing_concurrency == value
+
+      @processing_concurrency = value
+      @concurrency_semaphore = Concurrent::Semaphore.new(value)
+    end
+
+    def concurrency_semaphore
+      @concurrency_semaphore ||= Concurrent::Semaphore.new(@processing_concurrency)
     end
 
     # Auto unsubscribes the server by sending UNSUB command and throws away
@@ -88,5 +104,54 @@ module NATS
     def inspect
       "#<NATS::Subscription(subject: \"#{@subject}\", queue: \"#{@queue}\", sid: #{@sid})>"
     end
+
+    def dispatch(msg)
+      pending_queue << msg
+      synchronize { self.pending_size += msg.data.size }
+
+      # For async subscribers, send message for processing to the thread pool.
+      enqueue_processing(@nc.subscription_executor) if callback
+
+      # For sync subscribers, signal that there is a new message.
+      wait_for_msgs_cond&.signal
+    end
+
+    def process(msg)
+      return unless callback
+
+      # Decrease pending size since consumed already
+      synchronize { self.pending_size -= msg.data.size }
+
+      nc.reloader.call do
+        # Note: Keep some of the alternative arity versions to slightly
+        # improve backwards compatibility.  Eventually fine to deprecate
+        # since recommended version would be arity of 1 to get a NATS::Msg.
+        case callback.arity
+        when 0 then callback.call
+        when 1 then callback.call(msg)
+        when 2 then callback.call(msg.data, msg.reply)
+        when 3 then callback.call(msg.data, msg.reply, msg.subject)
+        else callback.call(msg.data, msg.reply, msg.subject, msg.header)
+        end
+      rescue => e
+        synchronize { nc.send(:err_cb_call, nc, e, self) }
+      end
+    end
+
+    # Send a message for its processing to a separate thread
+    def enqueue_processing(executor)
+      concurrency_semaphore.try_acquire || return # Previous message is being executed, let it finish and enqueue next one.
+      executor.post do
+        msg = pending_queue.pop(true)
+        process(msg)
+      rescue ThreadError # queue is empty
+        concurrency_semaphore.release
+      ensure
+        concurrency_semaphore.release
+        [concurrency_semaphore.available_permits, pending_queue.size].min.times do
+          enqueue_processing(executor)
+        end
+      end
+    end
   end
 end

data/lib/nats/io/version.rb

@@ -15,7 +15,7 @@
 module NATS
   module IO
     # VERSION is the version of the client announced on CONNECT to the server.
-    VERSION = "2.2.0".freeze
+    VERSION = "2.3.0".freeze
 
     # LANG is the lang runtime of the client announced on CONNECT to the server.
     LANG = "#{RUBY_ENGINE}#{RUBY_VERSION}".freeze

data/lib/nats/io/websocket.rb

@@ -0,0 +1,75 @@
+begin
+  require 'websocket'
+rescue LoadError
+  raise LoadError, "Please add `websocket` gem to your Gemfile to connect to NATS via WebSocket."
+end
+
+module NATS
+  module IO
+    # WebSocket to connect to NATS via WebSocket and automatically decode and encode frames.
+
+    # @see https://docs.nats.io/running-a-nats-service/configuration/websocket
+
+    class WebSocket < Socket
+      class HandshakeError < RuntimeError; end
+
+      attr_accessor :socket
+
+      def initialize(options={})
+        super
+      end
+
+      def connect
+        super
+
+        setup_tls! if @uri.scheme == "wss" # WebSocket connection must be made over TLS from the beginning
+
+        @handshake = ::WebSocket::Handshake::Client.new url: @uri.to_s
+        @frame = ::WebSocket::Frame::Incoming::Client.new
+        @handshaked = false
+
+        @socket.write @handshake.to_s
+
+        until @handshaked
+          @handshake << method(:read).super_method.call(MAX_SOCKET_READ_BYTES)
+          if @handshake.finished?
+            @handshaked = true
+          end
+        end
+      end
+
+      def setup_tls!
+        return if @socket.is_a? OpenSSL::SSL::SSLSocket
+
+        super
+      end
+
+      def read(max_bytes=MAX_SOCKET_READ_BYTES, deadline=nil)
+        data = super
+        @frame << data
+        result = []
+        while msg = @frame.next
+          result << msg
+        end
+        result.join
+      end
+
+      def read_line(deadline=nil)
+        data = super
+        @frame << data
+        result = []
+        while msg = @frame.next
+          result << msg
+        end
+        result.join
+      end
+
+      def write(data, deadline=nil)
+        raise HandshakeError, "Attempted to write to socket while WebSocket handshake is in progress" unless @handshaked
+
+        frame = ::WebSocket::Frame::Outgoing::Client.new(data: data, type: :binary, version: @handshake.version)
+        super frame.to_s
+      end
+    end
+  end
+end