nats-pure 2.4.0 → 2.6.0

data/lib/nats/io/subscription.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright 2016-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.
@@ -13,45 +15,46 @@
 #
 
 module NATS
-
   # A Subscription represents interest in a given subject.
-  # 
+  #
   # @example Create NATS subscription with callback.
   #   require 'nats/client'
-  # 
+  #
   #   nc = NATS.connect("demo.nats.io")
   #   sub = nc.subscribe("foo") do |msg|
   #     puts "Received [#{msg.subject}]: #{}"
   #   end
-  # 
+  #
   class Subscription
     include MonitorMixin
 
     attr_accessor :subject, :queue, :future, :callback, :response, :received, :max, :pending, :sid
-    attr_accessor :pending_queue, :pending_size, :wait_for_msgs_cond, :concurrency_semaphore
+    attr_accessor :pending_queue, :pending_size, :wait_for_msgs_cond
     attr_accessor :pending_msgs_limit, :pending_bytes_limit
     attr_accessor :nc
     attr_accessor :jsi
-    attr_accessor :closed
+    attr_accessor :closed, :drained
+    alias_method :delivered, :received
 
     def initialize(**opts)
       super() # required to initialize monitor
-      @subject  = ''
-      @queue    = nil
-      @future   = nil
+      @subject = ""
+      @queue = nil
+      @future = nil
       @callback = nil
       @response = nil
       @received = 0
-      @max      = nil
-      @pending  = nil
-      @sid      = nil
-      @nc       = nil
-      @closed   = nil
+      @max = nil
+      @pending = nil
+      @sid = nil
+      @nc = nil
+      @closed = nil
+      @drained = false
 
       # State from async subscriber messages delivery
-      @pending_queue       = nil
-      @pending_size        = 0
-      @pending_msgs_limit  = nil
+      @pending_queue = nil
+      @pending_size = 0
+      @pending_msgs_limit = nil
       @pending_bytes_limit = nil
 
       # Sync subscriber
@@ -78,22 +81,22 @@ module NATS
 
     # Auto unsubscribes the server by sending UNSUB command and throws away
     # subscription in case already present and has received enough messages.
-    def unsubscribe(opt_max=nil)
+    def unsubscribe(opt_max = nil)
       @nc.send(:unsubscribe, self, opt_max)
     end
 
     # next_msg blocks and waiting for the next message to be received.
-    def next_msg(opts={})
+    def next_msg(opts = {})
       timeout = opts[:timeout] ||= 0.5
       synchronize do
-        return @pending_queue.pop if not @pending_queue.empty?
+        return @pending_queue.pop if !@pending_queue.empty?
 
         # Wait for a bit until getting a signal.
-        MonotonicTime::with_nats_timeout(timeout) do
+        MonotonicTime.with_nats_timeout(timeout) do
           wait_for_msgs_cond.wait(timeout)
         end
 
-        if not @pending_queue.empty?
+        if !@pending_queue.empty?
           return @pending_queue.pop
         else
           raise NATS::Timeout
@@ -145,13 +148,20 @@ module NATS
         msg = pending_queue.pop(true)
         process(msg)
       rescue ThreadError # queue is empty
-        concurrency_semaphore.release
+        # No release here: the ensure below releases the permit; a second
+        # release would grow the semaphore beyond processing_concurrency.
       ensure
         concurrency_semaphore.release
         [concurrency_semaphore.available_permits, pending_queue.size].min.times do
           enqueue_processing(executor)
         end
       end
+    rescue Concurrent::RejectedExecutionError
+      # The executor is being shut down (the connection is closing,
+      # draining or reconnecting). Release the permit so the
+      # subscription can process messages again after a reconnect;
+      # the message stays in pending_queue.
+      concurrency_semaphore.release
     end
   end
 end

data/lib/nats/io/version.rb

@@ -1,4 +1,6 @@
-# Copyright 2016-2022 The NATS Authors
+# frozen_string_literal: true
+
+# Copyright 2016-2026 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
@@ -15,7 +17,7 @@
 module NATS
   module IO
     # VERSION is the version of the client announced on CONNECT to the server.
-    VERSION = "2.4.0".freeze
+    VERSION = "2.6.0"
 
     # 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

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 begin
-  require 'websocket'
+  require "websocket"
 rescue LoadError
   raise LoadError, "Please add `websocket` gem to your Gemfile to connect to NATS via WebSocket."
 end
@@ -15,7 +17,7 @@ module NATS
 
       attr_accessor :socket
 
-      def initialize(options={})
+      def initialize(options = {})
         super
       end
 
@@ -44,31 +46,51 @@ module NATS
         super
       end
 
-      def read(max_bytes=MAX_SOCKET_READ_BYTES, deadline=nil)
-        data = super
-        @frame << data
-        result = []
-        while msg = @frame.next
-          result << msg
+      def read(max_bytes = MAX_SOCKET_READ_BYTES, deadline = nil)
+        # Hand over what read_line decoded beyond its last line first,
+        # otherwise those bytes are lost once the read loop takes over.
+        if @line_buf && !@line_buf.empty?
+          return @line_buf.slice!(0, @line_buf.bytesize)
         end
-        result.join
+
+        read_frames(max_bytes, deadline)
       end
 
-      def read_line(deadline=nil)
-        data = super
-        @frame << data
-        result = []
-        while msg = @frame.next
-          result << msg
+      def read_line(deadline = nil)
+        @line_buf ||= +""
+        loop do
+          if (idx = @line_buf =~ /\r?\n/)
+            return @line_buf.slice!(0, idx + Regexp.last_match(0).length)
+          end
+
+          # Pull more data from the wire; never from @line_buf itself,
+          # or a partial line would be fed back forever.
+          data = read_frames(MAX_SOCKET_READ_BYTES, deadline)
+          return nil unless data
+          @line_buf << data
         end
-        result.join
       end
 
-      def write(data, deadline=nil)
+      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
+        super(frame.to_s)
+      end
+
+      private
+
+      # Reads from the socket and returns the payloads of all complete
+      # frames decoded so far.
+      def read_frames(max_bytes, deadline)
+        data = Socket.instance_method(:read).bind_call(self, max_bytes, deadline)
+        @frame << data
+        [].tap do |parts|
+          while (msg = @frame.next)
+            payload = msg.respond_to?(:data) ? msg.data : msg
+            parts << payload if payload
+          end
+        end.join
       end
     end
   end

data/lib/nats/nuid.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright 2016-2018 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.
@@ -11,27 +13,27 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-require 'securerandom'
+require "securerandom"
 
 module NATS
   class NUID
-    DIGITS        = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.split('')
-    BASE          = 62
+    DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".chars
+    BASE = 62
     PREFIX_LENGTH = 12
-    SEQ_LENGTH    = 10
-    TOTAL_LENGTH  = PREFIX_LENGTH + SEQ_LENGTH
-    MAX_SEQ       = BASE**10
-    MIN_INC       = 33
-    MAX_INC       = 333
+    SEQ_LENGTH = 10
+    TOTAL_LENGTH = PREFIX_LENGTH + SEQ_LENGTH
+    MAX_SEQ = BASE**10
+    MIN_INC = 33
+    MAX_INC = 333
     INC = MAX_INC - MIN_INC
 
     Ractor.make_shareable(DIGITS) if defined?(Ractor)
 
     def initialize
-      @prand    = Random.new
-      @seq      = @prand.rand(MAX_SEQ)
-      @inc      = MIN_INC + @prand.rand(INC)
-      @prefix   = ''
+      @prand = Random.new
+      @seq = @prand.rand(MAX_SEQ)
+      @inc = MIN_INC + @prand.rand(INC)
+      @prefix = ""
       randomize_prefix!
     end
 
@@ -46,22 +48,31 @@ module NATS
       # Do this inline 10 times to avoid even more extra allocs,
       # then use string interpolation of everything which works
       # faster for doing concat.
-      s_10 = DIGITS[l % BASE];
+      s_10 = DIGITS[l % BASE]
 
       # Ugly, but parallel assignment is slightly faster here...
-      s_09, s_08, s_07, s_06, s_05, s_04, s_03, s_02, s_01 = \
-      (l /= BASE; DIGITS[l % BASE]), (l /= BASE; DIGITS[l % BASE]), (l /= BASE; DIGITS[l % BASE]),\
-      (l /= BASE; DIGITS[l % BASE]), (l /= BASE; DIGITS[l % BASE]), (l /= BASE; DIGITS[l % BASE]),\
-      (l /= BASE; DIGITS[l % BASE]), (l /= BASE; DIGITS[l % BASE]), (l /= BASE; DIGITS[l % BASE])
+      s_09, s_08, s_07, s_06, s_05, s_04, s_03, s_02, s_01 =
+        (l /= BASE
+         DIGITS[l % BASE]), (l /= BASE
+                             DIGITS[l % BASE]), (l /= BASE
+                                                 DIGITS[l % BASE]),
+        (l /= BASE
+         DIGITS[l % BASE]), (l /= BASE
+                             DIGITS[l % BASE]), (l /= BASE
+                                                 DIGITS[l % BASE]),
+        (l /= BASE
+         DIGITS[l % BASE]), (l /= BASE
+                             DIGITS[l % BASE]), (l /= BASE
+                                                 DIGITS[l % BASE])
       "#{@prefix}#{s_01}#{s_02}#{s_03}#{s_04}#{s_05}#{s_06}#{s_07}#{s_08}#{s_09}#{s_10}"
     end
 
     def randomize_prefix!
-      @prefix = \
-      SecureRandom.random_bytes(PREFIX_LENGTH).each_byte
-        .reduce('') do |prefix, n|
-        prefix << DIGITS[n % BASE]
-      end
+      @prefix =
+        SecureRandom.random_bytes(PREFIX_LENGTH).each_byte
+          .reduce("".dup) do |prefix, n|
+          prefix << DIGITS[n % BASE]
+        end
     end
 
     private

data/lib/nats/service/callbacks.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module NATS
+  class Service
+    class Callbacks
+      attr_reader :service, :callbacks
+
+      def initialize(service)
+        @service = service
+        @callbacks = {}
+      end
+
+      def register(name, &block)
+        callbacks[name] = block
+      end
+
+      def call(name, *args)
+        callbacks[name]&.call(*args)
+      end
+    end
+  end
+end

data/lib/nats/service/endpoint.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+# Copyright 2025 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 Service
+    class Request < ::NATS::Msg
+      attr_reader :error, :endpoint
+
+      def initialize(opts = {})
+        super
+        @endpoint = opts[:endpoint]
+        @error = nil
+      end
+
+      def respond_with_error(error)
+        @error = NATS::Service::ErrorWrapper.new(error)
+
+        message = dup
+        message.subject = reply
+        message.reply = ""
+        message.data = @error.data
+
+        message.header = {
+          "Nats-Service-Error" => @error.message,
+          "Nats-Service-Error-Code" => @error.code
+        }
+
+        respond_msg(message)
+      end
+
+      def inspect
+        dot = "..." if @data.length > 10
+        dat = "#{data.slice(0, 10)}#{dot}"
+        "#<Service::Request(subject: \"#{@subject}\", reply: \"#{@reply}\", data: #{dat.inspect})>"
+      end
+
+      class << self
+        def from_msg(svc, msg)
+          request = Request.new(endpoint: svc)
+          request.subject = msg.subject
+          request.reply = msg.reply
+          request.data = msg.data
+          request.header = msg.header
+          request.nc = msg.nc
+          request.sub = msg.sub
+
+          request
+        end
+      end
+    end
+
+    class Endpoint
+      attr_reader :name, :service, :subject, :metadata, :queue, :stats
+
+      def initialize(name:, options:, parent:, &block)
+        validate(name, options)
+
+        @name = name
+
+        @service = parent.service
+        @subject = build_subject(parent, options)
+        @queue = options[:queue] || parent.queue
+        @metadata = options[:metadata]
+
+        @stats = NATS::Service::Stats.new
+        @handler = create_handler(block)
+
+        @stopped = false
+      end
+
+      def stop
+        service.client.send(:drain_sub, @handler)
+      rescue
+        # nothing we can do here
+      ensure
+        @stopped = true
+      end
+
+      def reset
+        stats.reset
+      end
+
+      def stopped?
+        @stopped
+      end
+
+      private
+
+      def validate(name, options)
+        Validator.validate(
+          name: name,
+          subject: options[:subject],
+          queue: options[:queue]
+        )
+      end
+
+      def build_subject(parent, options)
+        subject = options[:subject] || name
+
+        parent.subject ? "#{parent.subject}.#{subject}" : subject
+      end
+
+      def create_handler(block)
+        service.client.subscribe(subject, queue: queue) do |msg|
+          started_at = Time.now
+
+          req = Request.from_msg(self, msg)
+          block.call(req)
+          stats.error(req.error) if req.error
+        rescue NATS::Error => error
+          stats.error(error)
+          service.stop(error)
+
+          raise error
+        rescue => error
+          stats.error(error)
+          Request.from_msg(self, msg).respond_with_error(error)
+        ensure
+          stats.record(started_at)
+        end
+      rescue => error
+        service.stop(error)
+        raise error
+      end
+    end
+
+    class Endpoints < NATS::Utils::List
+      def add(name, options = {}, &block)
+        endpoint = Endpoint.new(
+          name: name,
+          options: options,
+          parent: parent,
+          &block
+        )
+
+        insert(endpoint)
+        parent.service.endpoints.insert(endpoint)
+
+        endpoint
+      end
+    end
+  end
+end

data/lib/nats/service/errors.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module NATS
+  class Service
+    class Error < StandardError; end
+
+    class InvalidNameError < Error; end
+
+    class InvalidVersionError < Error; end
+
+    class InvalidQueueError < Error; end
+
+    class InvalidSubjectError < Error; end
+
+    class ErrorWrapper
+      attr_reader :code, :message, :data
+
+      def initialize(error)
+        case error
+        when Exception
+          @code = 500
+          @message = error.message
+          @data = ""
+        when Hash
+          @code = error[:code]
+          @message = error[:description]
+          @data = error[:data]
+        when ErrorWrapper
+          @code = error.code
+          @message = error.message
+          @data = error.data
+        else
+          @code = 500
+          @message = error.to_s
+          @data = ""
+        end
+      end
+
+      def description
+        "#{code}:#{message}"
+      end
+    end
+  end
+end

data/lib/nats/service/group.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module NATS
+  class Service
+    class Group
+      attr_reader :service, :name, :subject, :queue, :groups, :endpoints
+
+      def initialize(name:, parent:, queue:)
+        Validator.validate(name: name, queue: queue)
+
+        @name = name
+
+        @service = parent.service
+        @subject = parent.subject ? "#{parent.subject}.#{name}" : name
+        @queue = queue || parent.queue
+
+        @groups = Groups.new(self)
+        @endpoints = Endpoints.new(self)
+      end
+    end
+
+    class Groups < NATS::Utils::List
+      def add(name, queue: nil)
+        group = Group.new(
+          name: name,
+          queue: queue,
+          parent: parent
+        )
+
+        insert(group)
+        parent.service.groups.insert(group)
+
+        group
+      end
+    end
+  end
+end

data/lib/nats/service/monitoring.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "json"
+
+module NATS
+  class Service
+    class Monitoring
+      DEFAULT_PREFIX = "$SRV"
+
+      VERBS = {
+        ping: "PING",
+        info: "INFO",
+        stats: "STATS"
+      }.freeze
+
+      TYPES = {
+        ping: "io.nats.micro.v1.ping_response",
+        info: "io.nats.micro.v1.info_response",
+        stats: "io.nats.micro.v1.stats_response"
+      }.freeze
+
+      attr_reader :service, :prefix, :stopped
+
+      def initialize(service, prefix = nil)
+        @service = service
+        @prefix = prefix || DEFAULT_PREFIX
+
+        setup_monitors
+      end
+
+      def stop
+        return if @monitors.nil?
+
+        @monitors.each do |monitor|
+          service.client.send(:drain_sub, monitor)
+        end
+      rescue
+        # nothing we can do here
+      ensure
+        @monitors = nil
+      end
+
+      def stopped?
+        @monitors.nil?
+      end
+
+      private
+
+      def setup_monitors
+        @monitors = []
+
+        ping
+        info
+        stats
+      end
+
+      def ping
+        monitor(:ping) do
+          {
+            type: TYPES[:ping],
+            **service.status.basic
+          }
+        end
+      end
+
+      def info
+        monitor(:info) do
+          {
+            type: TYPES[:info],
+            **service.status.info
+          }
+        end
+      end
+
+      def stats
+        monitor(:stats) do
+          {
+            type: TYPES[:stats],
+            **service.status.stats
+          }
+        end
+      end
+
+      def monitor(verb, &block)
+        subjects(verb).map do |subject|
+          @monitors << subscribe_monitor(subject, block)
+        end
+      end
+
+      def subscribe_monitor(subject, block)
+        service.client.subscribe(subject) do |message|
+          message.respond(block.call.to_json)
+        end
+      rescue => error
+        service.stop(error)
+        raise error
+      end
+
+      def subjects(verb)
+        [
+          "#{prefix}.#{VERBS[verb]}",
+          "#{prefix}.#{VERBS[verb]}.#{service.name}",
+          "#{prefix}.#{VERBS[verb]}.#{service.name}.#{service.id}"
+        ]
+      end
+    end
+  end
+end