nats-pure 0.7.2 → 2.4.0

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

@@ -0,0 +1,38 @@
+# 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
+    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
+  end
+end

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

@@ -0,0 +1,178 @@
+# 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 'kv/api'
+require_relative 'kv/bucket_status'
+require_relative 'kv/errors'
+require_relative 'kv/manager'
+
+module NATS
+  class KeyValue
+    KV_OP = "KV-Operation"
+    KV_DEL = "DEL"
+    KV_PURGE = "PURGE"
+    MSG_ROLLUP_SUBJECT = "sub"
+    MSG_ROLLUP_ALL = "all"
+    ROLLUP = "Nats-Rollup"
+
+    def initialize(opts={})
+      @name = opts[:name]
+      @stream = opts[:stream]
+      @pre = opts[:pre]
+      @js = opts[:js]
+      @direct = opts[:direct]
+    end
+
+    # get returns the latest value for the key.
+    def get(key, params={})
+      entry = nil
+      begin
+        entry = _get(key, params)
+      rescue KeyDeletedError
+        raise KeyNotFoundError
+      end
+
+      entry
+    end
+
+    def _get(key, params={})
+      msg = nil
+      subject = "#{@pre}#{key}"
+
+      if params[:revision]
+        msg = @js.get_msg(@stream,
+                          seq: params[:revision],
+                          direct: @direct)
+      else
+        msg = @js.get_msg(@stream,
+                          subject: subject,
+                          seq: params[:revision],
+                          direct: @direct)
+      end
+
+      entry = Entry.new(bucket: @name, key: key, value: msg.data, revision: msg.seq)
+
+      if subject != msg.subject
+        raise KeyNotFoundError.new(
+          entry: entry,
+          message: "expected '#{subject}', but got '#{msg.subject}'"
+        )
+      end
+
+      if not msg.headers.nil?
+        op = msg.headers[KV_OP]
+        if op == KV_DEL or op == KV_PURGE
+          raise KeyDeletedError.new(entry: entry, op: op)
+        end
+      end
+
+      entry
+    rescue NATS::JetStream::Error::NotFound
+      raise KeyNotFoundError
+    end
+    private :_get
+
+    # put will place the new value for the key into the store
+    # and return the revision number.
+    def put(key, value)
+      ack = @js.publish("#{@pre}#{key}", value)
+      ack.seq
+    end
+
+    # create will add the key/value pair iff it does not exist.
+    def create(key, value)
+      pa = nil
+      begin
+        pa = update(key, value, last: 0)
+      rescue KeyWrongLastSequenceError => err
+        # In case of attempting to recreate an already deleted key,
+        # the client would get a KeyWrongLastSequenceError.  When this happens,
+        # it is needed to fetch latest revision number and attempt to update.
+        begin
+          # NOTE: This reimplements the following behavior from Go client.
+          #
+          #   Since we have tombstones for DEL ops for watchers, this could be from that
+          #   so we need to double check.
+          #
+          _get(key)
+
+          # No exception so not a deleted key, so reraise the original KeyWrongLastSequenceError.
+          # If it was deleted then the error exception will contain metadata
+          # to recreate using the last revision.
+          raise err
+        rescue KeyDeletedError => err
+          pa = update(key, value, last: err.entry.revision)
+        end
+      end
+
+      pa
+    end
+
+    EXPECTED_LAST_SUBJECT_SEQUENCE = "Nats-Expected-Last-Subject-Sequence"
+
+    # update will update the value iff the latest revision matches.
+    def update(key, value, params={})
+      hdrs = {}
+      last = (params[:last] ||= 0)
+      hdrs[EXPECTED_LAST_SUBJECT_SEQUENCE] = last.to_s
+      ack = nil
+      begin
+        ack = @js.publish("#{@pre}#{key}", value, header: hdrs)
+      rescue NATS::JetStream::Error::APIError => err
+        if err.err_code == 10071
+          raise KeyWrongLastSequenceError.new(err.description)
+        else
+          raise err
+        end
+      end
+
+      ack.seq
+    end
+
+    # delete will place a delete marker and remove all previous revisions.
+    def delete(key, params={})
+      hdrs = {}
+      hdrs[KV_OP] = KV_DEL
+      last = (params[:last] ||= 0)
+      if last > 0
+        hdrs[EXPECTED_LAST_SUBJECT_SEQUENCE] = last.to_s
+      end
+      ack = @js.publish("#{@pre}#{key}", header: hdrs)
+
+      ack.seq
+    end
+
+    # purge will remove the key and all revisions.
+    def purge(key)
+      hdrs = {}
+      hdrs[KV_OP] = KV_PURGE
+      hdrs[ROLLUP] = MSG_ROLLUP_SUBJECT
+      @js.publish("#{@pre}#{key}", header: hdrs)
+    end
+
+    # status retrieves the status and configuration of a bucket.
+    def status
+      info = @js.stream_info(@stream)
+      BucketStatus.new(info, @name)
+    end
+
+    Entry = Struct.new(:bucket, :key, :value, :revision, :delta, :created, :operation, keyword_init: true) do
+      def initialize(opts={})
+        rem = opts.keys - members
+        opts.delete_if { |k| rem.include?(k) }
+        super(opts)
+      end
+    end
+  end
+end

data/lib/nats/io/msg.rb

@@ -0,0 +1,58 @@
+# 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.
+# 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 'jetstream'
+
+module NATS
+  class Msg
+    attr_accessor :subject, :reply, :data, :header
+
+    # Enhance it with ack related methods from JetStream to ack msgs.
+    include JetStream::Msg::AckMethods
+
+    def initialize(opts={})
+      @subject = opts[:subject]
+      @reply   = opts[:reply]
+      @data    = opts[:data]
+      @header  = opts[:header]
+      @nc      = opts[:nc]
+      @sub     = opts[:sub]
+      @ackd    = false
+      @meta    = nil
+    end
+
+    def respond(data='')
+      return unless @nc
+      if self.header
+        dmsg = self.dup
+        dmsg.subject = self.reply
+        dmsg.data = data
+        @nc.publish_msg(dmsg)
+      else
+        @nc.publish(self.reply, data)
+      end
+    end
+
+    def respond_msg(msg)
+      return unless @nc
+      @nc.publish_msg(msg)
+    end
+
+    def inspect
+      hdr = ", header=#{@header}" if @header
+      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/parser.rb

@@ -71,22 +71,22 @@ module NATS
               @buf = $'
             when ERR
               @buf = $'
-              @nc.process_err($1)
+              @nc.send(:process_err, $1)
             when PING
               @buf = $'
-              @nc.process_ping
+              @nc.send(:process_ping)
             when PONG
               @buf = $'
-              @nc.process_pong
+              @nc.send(:process_pong)
             when INFO
               @buf = $'
               # First INFO message is processed synchronously on connect,
               # and onwards we would be receiving asynchronously INFO commands
               # signaling possible changes in the topology of the NATS cluster.
-              @nc.process_info($1)
+              @nc.send(:process_info, $1)
             when UNKNOWN
               @buf = $'
-              @nc.process_err("Unknown protocol: #{$1}")
+              @nc.send(:process_err, "Unknown protocol: #{$1}")
             else
               # If we are here we do not have a complete line yet that we understand.
               return
@@ -98,10 +98,10 @@ module NATS
             if @header_needed
               hbuf = @buf.slice(0, @header_needed)
               payload = @buf.slice(@header_needed, (@needed-@header_needed))
-              @nc.process_msg(@sub, @sid, @reply, payload, hbuf)
+              @nc.send(:process_msg, @sub, @sid, @reply, payload, hbuf)
               @buf = @buf.slice((@needed + CR_LF_SIZE), @buf.bytesize)
             else
-              @nc.process_msg(@sub, @sid, @reply, @buf.slice(0, @needed), nil)
+              @nc.send(:process_msg, @sub, @sid, @reply, @buf.slice(0, @needed), nil)
               @buf = @buf.slice((@needed + CR_LF_SIZE), @buf.bytesize)
             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

@@ -0,0 +1,157 @@
+# 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.
+# 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
+
+  # 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_msgs_limit, :pending_bytes_limit
+    attr_accessor :nc
+    attr_accessor :jsi
+    attr_accessor :closed
+
+    def initialize(**opts)
+      super() # required to initialize monitor
+      @subject  = ''
+      @queue    = nil
+      @future   = nil
+      @callback = nil
+      @response = nil
+      @received = 0
+      @max      = nil
+      @pending  = nil
+      @sid      = nil
+      @nc       = nil
+      @closed   = nil
+
+      # State from async subscriber messages delivery
+      @pending_queue       = nil
+      @pending_size        = 0
+      @pending_msgs_limit  = nil
+      @pending_bytes_limit = nil
+
+      # 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
+    # subscription in case already present and has received enough messages.
+    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={})
+      timeout = opts[:timeout] ||= 0.5
+      synchronize do
+        return @pending_queue.pop if not @pending_queue.empty?
+
+        # Wait for a bit until getting a signal.
+        MonotonicTime::with_nats_timeout(timeout) do
+          wait_for_msgs_cond.wait(timeout)
+        end
+
+        if not @pending_queue.empty?
+          return @pending_queue.pop
+        else
+          raise NATS::Timeout
+        end
+      end
+    end
+
+    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

@@ -1,4 +1,4 @@
-# Copyright 2016-2021 The NATS Authors
+# Copyright 2016-2022 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
@@ -14,9 +14,13 @@
 
 module NATS
   module IO
-    # NOTE: These are all announced to the server on CONNECT
-    VERSION  = "0.7.2"
-    LANG     = "#{RUBY_ENGINE}#{RUBY_VERSION}".freeze
+    # VERSION is the version of the client announced on CONNECT to the server.
+    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
+
+    # PROTOCOL is the supported version of the protocol in the client.
     PROTOCOL = 1
   end
 end