nats-pure 2.2.1 → 2.4.0

data/lib/nats/io/jetstream/msg/ack_methods.rb

@@ -41,11 +41,15 @@ module NATS
 
         def nak(**params)
           ensure_is_acked_once!
-
+          payload = if params[:delay]
+                      payload = "#{Ack::Nak} #{{ delay: params[:delay] }.to_json}"
+                    else
+                      Ack::Nak
+                    end
           resp = if params[:timeout]
-                   @nc.request(@reply, Ack::Nak, **params)
+                   @nc.request(@reply, payload, **params)
                  else
-                   @nc.publish(@reply, Ack::Nak)
+                   @nc.publish(@reply, payload)
                  end
           @sub.synchronize { @ackd = true }
 
@@ -104,4 +108,4 @@ module NATS
       end
     end
   end
-end
+end

data/lib/nats/io/jetstream.rb

@@ -105,16 +105,50 @@ module NATS
 
     # subscribe binds or creates a push subscription to a JetStream pull consumer.
     #
-    # @param subject [String] Subject from which the messages will be fetched.
+    # @param subject [String, Array] Subject(s) from which the messages will be fetched.
     # @param params [Hash] Options to customize the PushSubscription.
     # @option params [String] :stream Name of the Stream to which the consumer belongs.
     # @option params [String] :consumer Name of the Consumer to which the PushSubscription will be bound.
+    # @option params [String] :name Name of the Consumer to which the PushSubscription will be bound.
     # @option params [String] :durable Consumer durable name from where the messages will be fetched.
     # @option params [Hash] :config Configuration for the consumer.
     # @return [NATS::JetStream::PushSubscription]
     def subscribe(subject, params={}, &cb)
       params[:consumer] ||= params[:durable]
-      stream = params[:stream].nil? ? find_stream_name_by_subject(subject) : params[:stream]
+      params[:consumer] ||= params[:name]
+      multi_filter = case 
+                     when (subject.is_a?(Array) and subject.size == 1)
+                       subject = subject.first
+                       false
+                     when (subject.is_a?(Array) and subject.size > 1)
+                       true
+                     end
+
+      # 
+      stream = if params[:stream].nil?
+                 if multi_filter
+                   # Use the first subject to try to find the stream.
+                   streams = subject.map do |s|
+                    begin
+                      find_stream_name_by_subject(s)
+                    rescue NATS::JetStream::Error::NotFound
+                      raise NATS::JetStream::Error.new("nats: could not find stream matching filter subject '#{s}'")
+                    end
+                   end
+
+                   # Ensure that the filter subjects are not ambiguous.
+                   streams.uniq!
+                   if streams.count > 1
+                     raise NATS::JetStream::Error.new("nats: multiple streams matched filter subjects: #{streams}")
+                   end
+
+                   streams.first
+                 else
+                   find_stream_name_by_subject(subject)
+                 end
+               else
+                 params[:stream]
+               end
 
       queue = params[:queue]
       durable = params[:durable]
@@ -183,7 +217,11 @@ module NATS
         config.deliver_subject = deliver
 
         # Auto created consumers use the filter subject.
-        config.filter_subject = subject
+        if multi_filter
+          config[:filter_subjects] ||= subject
+        else
+          config[:filter_subject] ||= subject
+        end
 
         # Heartbeats / FlowControl
         config.flow_control = flow_control
@@ -219,25 +257,57 @@ module NATS
 
     # pull_subscribe binds or creates a subscription to a JetStream pull consumer.
     #
-    # @param subject [String] Subject from which the messages will be fetched.
+    # @param subject [String, Array] Subject or subjects from which the messages will be fetched.
     # @param durable [String] Consumer durable name from where the messages will be fetched.
     # @param params [Hash] Options to customize the PullSubscription.
     # @option params [String] :stream Name of the Stream to which the consumer belongs.
     # @option params [String] :consumer Name of the Consumer to which the PullSubscription will be bound.
+    # @option params [String] :name Name of the Consumer to which the PullSubscription will be bound.
     # @option params [Hash] :config Configuration for the consumer.
     # @return [NATS::JetStream::PullSubscription]
     def pull_subscribe(subject, durable, params={})
-      if durable.empty? && !params[:consumer]
+      if (!durable or durable.empty?) && !(params[:consumer] or params[:name])
         raise JetStream::Error::InvalidDurableName.new("nats: invalid durable name")
       end
+      multi_filter = case 
+                     when (subject.is_a?(Array) and subject.size == 1)
+                       subject = subject.first
+                       false
+                     when (subject.is_a?(Array) and subject.size > 1)
+                       true
+                     end
+
       params[:consumer] ||= durable
-      stream = params[:stream].nil? ? find_stream_name_by_subject(subject) : params[:stream]
+      params[:consumer] ||= params[:name]
+      stream = if params[:stream].nil?
+                 if multi_filter
+                   # Use the first subject to try to find the stream.
+                   streams = subject.map do |s|
+                    begin
+                      find_stream_name_by_subject(s)
+                    rescue NATS::JetStream::Error::NotFound
+                      raise NATS::JetStream::Error.new("nats: could not find stream matching filter subject '#{s}'")
+                    end
+                   end
+
+                   # Ensure that the filter subjects are not ambiguous.
+                   streams.uniq!
+                   if streams.count > 1
+                     raise NATS::JetStream::Error.new("nats: multiple streams matched filter subjects: #{streams}")
+                   end
 
+                   streams.first
+                 else
+                   find_stream_name_by_subject(subject)
+                 end
+               else
+                 params[:stream]
+               end
       begin
         consumer_info(stream, params[:consumer])
       rescue NATS::JetStream::Error::NotFound => e
         # If attempting to bind, then this is a hard error.
-        raise e if params[:stream]
+        raise e if params[:stream] and !multi_filter
 
         config = if not params[:config]
                    JetStream::API::ConsumerConfig.new
@@ -248,6 +318,11 @@ module NATS
                  end
         config[:durable_name] = durable
         config[:ack_policy] ||= JS::Config::AckExplicit
+        if multi_filter
+          config[:filter_subjects] ||= subject
+        else
+          config[:filter_subject] ||= subject
+        end
         add_consumer(stream, config)
       end
 

data/lib/nats/io/msg.rb

@@ -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.1".freeze
+    VERSION = "2.4.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

data/sig/nats/io/client.rbs

@@ -0,0 +1,304 @@
+module NATS
+  # class << self
+  def self.connect: (String?, Hash[Symbol, untyped]) -> NATS::Client
+  # end class << self
+
+  module Status
+    DISCONNECTED: Integer
+    CONNECTED: Integer
+    CLOSED: Integer
+    RECONNECTING: Integer
+    CONNECTING: Integer
+    DRAINING_SUBS: Integer
+    DRAINING_PUBS: Integer
+  end
+
+  class Client
+    include MonitorMixin
+    include Status
+
+    attr_reader status: Integer
+    attr_reader server_info: Hash[Symbol, untyped]
+    attr_reader server_pool: Array[untyped]
+    attr_reader options: Hash[Symbol, untyped]?
+    attr_reader connected_server: String?
+    attr_reader stats: Hash[Symbol, Integer]
+    attr_reader uri: String?
+    attr_reader subscription_executor: Concurrent::ThreadPoolExecutor?
+    attr_reader reloader: Proc
+
+    DEFAULT_PORT: Hash[Symbol, Integer]
+    DEFAULT_URI: String
+
+    CR_LF: '\r\n'
+    CR_LF_SIZE: Integer
+
+    PING_REQUEST: String
+    PONG_RESPONSE: String
+
+    NATS_HDR_LINE: String
+    STATUS_MSG_LEN: 3
+    STATUS_HDR: 'Status'
+    DESC_HDR: 'Description'
+    NATS_HDR_LINE_SIZE: Integer
+
+    SUB_OP: 'SUB'
+    EMPTY_MSG: ''
+
+    INSTANCES: ObjectSpace::WeakMap
+
+    @options: Hash[Symbol, untyped]
+
+    @io: NATS::IO::Socket?
+
+    @flush_queue: Thread::SizedQueue?
+    @pending_queue: Thread::SizedQueue?
+
+    @parser: NATS::Protocol::Parser
+
+    @flusher_thread: Thread?
+    @read_loop_thread: Thread?
+    @ping_interval_thread: Thread?
+    @subscription_executor: Concurrent::ThreadPoolExecutor?
+
+    @subs: Hash[Symbol, untyped]
+    @ssid: Integer
+
+    @pings_outstanding: Integer
+    @pongs_received: Integer
+    @pongs: Array[MonitorMixin::ConditionVariable]
+
+    @pending_size: Integer
+
+    @last_err: untyped
+
+    @err_cb: Proc
+    @close_cp: Proc
+    @disconnect_cb: Proc
+    @reconnect_cb: Proc
+
+    @tls: bool?
+
+    @hostname: String?
+    @single_url_connect_used: bool
+
+    @connect_called: bool
+
+    @resp_sub: NATS::Subscription?
+    @resp_map: Hash[String | Symbol, untyped]?
+    @resp_sub_prefix: String?
+    @nuid: NATS::NUID
+
+    @user_credentials: String?
+    @nkeys_seed: String?
+    @user_nkey_cb: Proc?
+    @user_jwt_cb: Proc?
+    @signature_cb: Proc?
+
+    @auth_token: String?
+
+    @inbox_prefix: String
+
+    @drain_t: Thread?
+
+    @reloader: Proc
+
+    def self.default_reloader: -> Proc
+
+    def connect: ((String | Hash[Symbol, untyped])?, Hash[Symbol, untyped]) -> self
+
+    def publish: (String, String, String?, **Hash[Symbol, untyped]) -> void
+
+    def publish_msg: (NATS::Msg) -> void
+
+    def subscribe: (String, Hash[Symbol, untyped]) ?{ (?(NATS::Msg | String), ?String, ?String, ?Hash[Symbol, untyped]) -> void } -> NATS::Subscription
+
+    def request: (String, ?String, **Hash[Symbol, untyped]) ?{ (?(NATS::Msg | String), ?String, ?String, ?Hash[Symbol, untyped]) -> void } -> NATS::Msg
+
+    def request_msg: (NATS::Msg, **Hash[Symbol, untyped]) -> NATS::Msg
+
+    def old_request: (String, ?String, **Hash[Symbol, untyped]) ?{ (?(NATS::Msg | String), ?String, ?String, ?Hash[Symbol, untyped]) -> void } -> NATS::Msg
+
+    def flush: (?Integer) -> void
+
+    alias servers server_pool
+
+    def discovered_servers: () -> Array[String]
+
+    def close: () -> void
+
+    def new_inbox: () -> String
+
+    def connected?: () -> bool
+
+    def connecting?: () -> bool
+
+    def reconnecting?: () -> bool
+
+    def closed?: () -> bool
+
+    def draining?: () -> bool
+
+    def on_error: () { (?self, ?untyped, ?NATS::Subscription) -> void } -> void
+
+    def on_disconnect: () { (?untyped) -> void } -> void
+
+    def on_reconnect: () { () -> void } -> void
+
+    def on_close: () { () -> void } -> void
+
+    def last_error: () -> untyped
+
+    def drain: () -> void
+
+    def jetstream: (**Hash[Symbol, untyped]) -> NATS::JetStream
+    alias JetStream jetstream
+    alias jsm jetstream
+
+    private
+
+    def validate_settings!: () -> void
+
+    def process_info: (String) -> Hash[Symbol, untyped]
+
+    def process_hdr: (String) -> Hash[String, untyped]?
+
+    def process_pong: () -> void
+
+    def process_ping: () -> void
+
+    def process_err: (String) -> void
+
+    def process_msg: (String, String, String, String, String) -> void
+
+    def select_next_error: () -> untyped
+
+    def server_using_secure_connection?: () -> bool
+
+    def client_using_secure_connection?: () -> bool
+
+    def single_url_connect_used?: () -> bool
+
+    def send_command: (String) -> void
+
+    def unsubscribe: (NATS::Subscription, Integer?) -> void
+
+    def drain_sub: (NATS::Subscription) -> void
+
+    def do_drain: () -> void
+
+    def send_flush_queue: (Symbol) -> void
+
+    def delete_sid: (Symbol) -> void
+
+    def err_cb_call: (self, untyped, NATS::Subscription) -> void
+
+    def auth_connection?: () -> bool
+
+    def connect_command: () -> String
+
+    def process_op_error: (untyped) -> void
+
+    def read_loop: () -> void
+
+    def flusher_loop: () -> void
+
+    def force_flush!: () -> void
+
+    def ping_interval_loop: () -> void
+
+    def process_connect_init: () -> void
+
+    def attempt_reconnect: () -> void
+
+    def close_connection: (Integer, bool) -> void
+
+    def start_threads!: () -> void
+
+    def start_resp_mux_sub!: () -> void
+
+    def can_reuse_server?: (Hash[Symbol, untyped]) -> bool
+
+    def should_delay_connect?: () -> bool
+
+    def should_not_reconnect?: () -> bool
+
+    def should_reconnect?: () -> bool
+
+    def create_socket: () -> NATS::IO::Socket
+
+    def setup_nkeys_connect: () -> void
+
+    def signature_cb_for_nkey_file: (String) -> Proc
+
+    def nkey_cb_for_nkey_file: (String) -> Proc
+
+    def jwt_cb_for_creds_file: (String) -> Proc
+
+    def signature_cb_for_creds_file: (String) -> Proc
+
+    def process_uri: (String) -> Array[URI::Generic]
+  end
+
+  module IO
+    include Status
+
+    Client: NATS::Client
+
+    MAX_RECONNECT_ATTEMPTS: 10
+    RECONNECT_TIME_WAIT: 2
+
+    MAX_PENDING_SIZE: 32768
+
+    MAX_FLUSH_KICK_SIZE: 1024
+
+    MAX_SOCKET_READ_BYTES: 32768
+
+    DEFAULT_PING_INTERVAL: 120
+    DEFAULT_PING_MAX: 2
+
+    DEFAULT_CONNECT_TIMEOUT: 2
+    DEFAULT_READ_WRITE_TIMEOUT: 2
+    DEFAULT_DRAIN_TIMEOUT: 30
+
+    DEFAULT_SUB_PENDING_MSGS_LIMIT: 65536
+    DEFAULT_SUB_PENDING_BYTES_LIMIT: Integer
+
+    class Socket
+      attr_accessor socket: ::Socket?
+
+      @uri: URI::Generic
+      @connect_timeout: Numeric
+      @write_timeout: Numeric
+      @read_timeout: Numeric
+
+      def connect: () -> void
+
+      def read_line: (Numeric?) -> untyped
+
+      def read: (Integer, Numeric?) -> untyped
+
+      def write: (String, Numeric?) -> void
+
+      def close: () -> void
+
+      def closed?: () -> bool
+
+      private
+
+      def connect_addrinfo: (String | Integer, Integer, Numeric) -> ::Socket
+    end
+  end
+
+  NANOSECONDS: 1_000_000_000
+
+  class MonotonicTime
+    # class << self
+    def self.now: () -> Float
+
+    def self.with_nats_timeout: (Float) -> Float
+
+    def self.since: (Float) -> Float
+    # end class << self
+  end
+end