nats-pure 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f0d4251703ba9fd6a91f501686025e2f71e93dc7869f65984da7cd312361266
-  data.tar.gz: 411fdfd23878cf89b26c76e04b68c760e10aaef14f2a68fae19c69a8d1392990
+  metadata.gz: f1d8302826b885f0c3a173530bd3d504b5e7a4eb7ec684ac3b43b1ee8f9cf4e3
+  data.tar.gz: 04aa8801b7ddf434155d1ebf40b03fdd6b89bfc6f95d968ff4a501684081ca02
 SHA512:
-  metadata.gz: a3b88a713e2c1b6a515ac4f505cb6724c0059e72693d8d5c2ee61f3579d1b4b846408282e131864735dccc8b224e4a22933be91409d404fedadf0ec6c72051cf
-  data.tar.gz: 9ef88d1a391c2cfec91731aca2742382634c923384b801fce4ee9155418de39bd538f7aaafceb6ba2a1b40b57c6b7db4363ad4cf673d8ff3b5e87b5f74104789
+  metadata.gz: a98b75d47e4b8256c05d284324399807e0bbaf210f2970856b106b46a1264cc12bd96cb00516cb007fd9c68cab001bf08516aee1db46718552bd7397cf8ccb2f
+  data.tar.gz: b752276fa498c423ecdd0002e530639514ef39a1f5c93e73606c6a6f0351cf275817e13c0339d880fadef9e956fdf7b1f63cc816ff0cd2a2e254db73e071344c

data/lib/nats/io/client.rb

@@ -1936,6 +1936,8 @@ module NATS
     end
   end
 
+  NANOSECONDS = 1_000_000_000
+
   class MonotonicTime
     # Implementation of MonotonicTime adapted from
     # https://github.com/ruby-concurrency/concurrent-ruby/

data/lib/nats/io/js.rb

@@ -19,7 +19,6 @@ require 'time'
 require 'base64'
 
 module NATS
-
   # JetStream returns a context with a similar API as the NATS::Client
   # but with enhanced functions to persist and consume messages from
   # the NATS JetStream engine.
@@ -118,6 +117,7 @@ module NATS
       manual_ack = params[:manual_ack]
       idle_heartbeat = params[:idle_heartbeat]
       flow_control = params[:flow_control]
+      config = params[:config]
 
       if queue
         if durable and durable != queue
@@ -184,7 +184,7 @@ module NATS
         config.flow_control = flow_control
         if idle_heartbeat or config.idle_heartbeat
           idle_heartbeat = config.idle_heartbeat if config.idle_heartbeat
-          idle_heartbeat = idle_heartbeat * 1_000_000_000
+          idle_heartbeat = idle_heartbeat * ::NATS::NANOSECONDS
           config.idle_heartbeat = idle_heartbeat
         end
 
@@ -222,7 +222,9 @@ module NATS
     # @option params [Hash] :config Configuration for the consumer.
     # @return [NATS::JetStream::PullSubscription]
     def pull_subscribe(subject, durable, params={})
-      raise JetStream::Error::InvalidDurableName.new("nats: invalid durable name") if durable.empty?
+      if durable.empty? && !params[:consumer]
+        raise JetStream::Error::InvalidDurableName.new("nats: invalid durable name")
+      end
       params[:consumer] ||= durable
       stream = params[:stream].nil? ? find_stream_name_by_subject(subject) : params[:stream]
 
@@ -329,7 +331,16 @@ module NATS
                  else
                    config
                  end
-        req_subject = if config[:durable_name]
+
+        req_subject = case
+                      when config[:name]
+                        # NOTE: Only supported after nats-server v2.9.0
+                        if config[:filter_subject] && config[:filter_subject] != ">"
+                          "#{@prefix}.CONSUMER.CREATE.#{stream}.#{config[:name]}.#{config[:filter_subject]}"
+                        else
+                          "#{@prefix}.CONSUMER.CREATE.#{stream}.#{config[:name]}"
+                        end
+                      when config[:durable_name]
                         "#{@prefix}.CONSUMER.DURABLE.CREATE.#{stream}.#{config[:durable_name]}"
                       else
                         "#{@prefix}.CONSUMER.CREATE.#{stream}"
@@ -339,7 +350,11 @@ module NATS
         # Check if have to normalize ack wait so that it is in nanoseconds for Go compat.
         if config[:ack_wait]
           raise ArgumentError.new("nats: invalid ack wait") unless config[:ack_wait].is_a?(Integer)
-          config[:ack_wait] = config[:ack_wait] * 1_000_000_000
+          config[:ack_wait] = config[:ack_wait] * ::NATS::NANOSECONDS
+        end
+        if config[:inactive_threshold]
+          raise ArgumentError.new("nats: invalid inactive threshold") unless config[:inactive_threshold].is_a?(Integer)
+          config[:inactive_threshold] = config[:inactive_threshold] * ::NATS::NANOSECONDS
         end
 
         req = {
@@ -396,28 +411,96 @@ module NATS
         result[:streams].first
       end
 
-      def get_last_msg(stream_name, subject)
-        req_subject = "#{@prefix}.STREAM.MSG.GET.#{stream_name}"
-        req = {'last_by_subj': subject}
+      # get_msg retrieves a message from the stream.
+      # @param next [Boolean] Fetch the next message for a subject.
+      # @param seq [Integer] Sequence number of a message.
+      # @param subject [String] Subject of the message.
+      # @param direct [Boolean] Use direct mode to for faster access (requires NATS v2.9.0)
+      def get_msg(stream_name, params={})
+        req = {}
+        case
+        when params[:next]
+          req[:seq] = params[:seq]
+          req[:next_by_subj] = params[:subject]
+        when params[:seq]
+          req[:seq] = params[:seq]
+        when params[:subject]
+          req[:last_by_subj] = params[:subject]
+        end
+
         data = req.to_json
-        resp = api_request(req_subject, data)
-        JetStream::API::RawStreamMsg.new(resp[:message])
+        if params[:direct]
+          if params[:subject] and not params[:seq]
+            # last_by_subject type request requires no payload.
+            data = ''
+            req_subject = "#{@prefix}.DIRECT.GET.#{stream_name}.#{params[:subject]}"
+          else
+            req_subject = "#{@prefix}.DIRECT.GET.#{stream_name}"
+          end
+        else
+          req_subject = "#{@prefix}.STREAM.MSG.GET.#{stream_name}"
+        end
+        resp = api_request(req_subject, data, direct: params[:direct])
+        msg = if params[:direct]
+                _lift_msg_to_raw_msg(resp)
+              else
+                JetStream::API::RawStreamMsg.new(resp[:message])
+              end
+
+        msg
+      end
+
+      def get_last_msg(stream_name, subject, params={})
+        params[:subject] = subject
+        get_msg(stream_name, params)
+      end
+
+      def account_info
+        api_request("#{@prefix}.INFO")
       end
 
       private
 
       def api_request(req_subject, req="", params={})
         params[:timeout] ||= @opts[:timeout]
-        result = begin
-                   msg = @nc.request(req_subject, req, **params)
+        msg = begin
+                @nc.request(req_subject, req, **params)
+              rescue NATS::IO::NoRespondersError
+                raise JetStream::Error::ServiceUnavailable
+              end
+
+        result = if params[:direct]
+                   msg
+                 else
                    JSON.parse(msg.data, symbolize_names: true)
-                 rescue NATS::IO::NoRespondersError
-                   raise JetStream::Error::ServiceUnavailable
                  end
-        raise JS.from_error(result[:error]) if result[:error]
+        if result.is_a?(Hash) and result[:error]
+          raise JS.from_error(result[:error])
+        end
 
         result
       end
+
+      def _lift_msg_to_raw_msg(msg)
+        if msg.header and msg.header['Status']
+          status = msg.header['Status']
+          if status == '404'
+            raise ::NATS::JetStream::Error::NotFound.new
+          else
+            raise JS.from_msg(msg)
+          end
+        end
+        subject = msg.header['Nats-Subject']
+        seq = msg.header['Nats-Sequence']
+        raw_msg = JetStream::API::RawStreamMsg.new(
+           subject: subject,
+           seq: seq,
+           headers: msg.header,
+        )
+        raw_msg.data = msg.data
+
+        raw_msg
+      end
     end
 
     # PushSubscription is included into NATS::Subscription so that it
@@ -1106,7 +1189,7 @@ module NATS
           opts[:created] = Time.parse(opts[:created])
           opts[:ack_floor] = SequenceInfo.new(opts[:ack_floor])
           opts[:delivered] = SequenceInfo.new(opts[:delivered])
-          opts[:config][:ack_wait] = opts[:config][:ack_wait] / 1_000_000_000
+          opts[:config][:ack_wait] = opts[:config][:ack_wait] / ::NATS::NANOSECONDS
           opts[:config] = ConsumerConfig.new(opts[:config])
           opts.delete(:cluster)
           # Filter unrecognized fields just in case.
@@ -1135,12 +1218,24 @@ module NATS
       #   @return [Integer]
       # @!attribute max_ack_pending
       #   @return [Integer]
-      ConsumerConfig = Struct.new(:durable_name, :description, :deliver_subject,
-                                  :deliver_group, :deliver_policy, :opt_start_seq,
-                                  :opt_start_time, :ack_policy, :ack_wait, :max_deliver,
+      ConsumerConfig = Struct.new(:name, :durable_name, :description,
+                                  :deliver_policy, :opt_start_seq, :opt_start_time,
+                                  :ack_policy, :ack_wait, :max_deliver, :backoff,
                                   :filter_subject, :replay_policy, :rate_limit_bps,
                                   :sample_freq, :max_waiting, :max_ack_pending,
                                   :flow_control, :idle_heartbeat, :headers_only,
+
+                                  # Pull based options
+                                  :max_batch, :max_expires,
+                                  # Push based consumers
+                                  :deliver_subject, :deliver_group,
+                                  # Ephemeral inactivity threshold
+                                  :inactive_threshold,
+                                  # Generally inherited by parent stream and other markers,
+                                  # now can be configured directly.
+                                  :num_replicas,
+                                  # Force memory storage
+                                  :mem_storage,
                                   keyword_init: true) do
         def initialize(opts={})
           # Filter unrecognized fields just in case.
@@ -1194,10 +1289,32 @@ module NATS
       #   @return [Integer]
       # @!attribute duplicate_window
       #   @return [Integer]
-      StreamConfig = Struct.new(:name, :subjects, :retention, :max_consumers,
-                                :max_msgs, :max_bytes, :max_age,
-                                :max_msgs_per_subject, :max_msg_size,
-                                :discard, :storage, :num_replicas, :duplicate_window,
+      StreamConfig = Struct.new(
+                                :name,
+                                :description,
+                                :subjects,
+                                :retention,
+                                :max_consumers,
+                                :max_msgs,
+                                :max_bytes,
+                                :discard,
+                                :max_age,
+                                :max_msgs_per_subject,
+                                :max_msg_size,
+                                :storage,
+                                :num_replicas,
+                                :no_ack,
+                                :duplicate_window,
+                                :placement,
+                                :mirror,
+                                :sources,
+                                :sealed,
+                                :deny_delete,
+                                :deny_purge,
+                                :allow_rollup_hdrs,
+                                :republish,
+                                :allow_direct,
+                                :mirror_direct,
                                 keyword_init: true) do
         def initialize(opts={})
           # Filter unrecognized fields just in case.
@@ -1230,7 +1347,7 @@ module NATS
         def initialize(opts={})
           opts[:config] = StreamConfig.new(opts[:config])
           opts[:state] = StreamState.new(opts[:state])
-          opts[:created] = Time.parse(opts[:created])
+          opts[:created] = ::Time.parse(opts[:created])
 
           # Filter fields and freeze.
           rem = opts.keys - members

data/lib/nats/io/kv.rb

@@ -20,46 +20,181 @@ module NATS
     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
+
+    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 < NATS::Error; end
+    class KeyDeletedError < KeyNotFoundError
+      def to_s
+        "nats: key was deleted"
+      end
+    end
 
     # When there was no bucket present.
-    class BucketNotFoundError < NATS::Error; end
+    class BucketNotFoundError < Error; end
 
     # When it is an invalid bucket.
-    class BadBucketError < NATS::Error; end
+    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)
-      msg = @js.get_last_msg(@stream, "#{@pre}#{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]
-        raise KeyDeletedError.new("nats: key was deleted") if op == KV_DEL or op == KV_PURGE
+        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)
-      @js.publish("#{@pre}#{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)
+    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
 
@@ -69,7 +204,7 @@ module NATS
       BucketStatus.new(info, @name)
     end
 
-    Entry = Struct.new(:bucket, :key, :value, :revision, keyword_init: true) do
+    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) }
@@ -94,14 +229,24 @@ module NATS
       end
 
       def ttl
-        @nfo.config.max_age / 1_000_000_000
+        @nfo.config.max_age / ::NATS::NANOSECONDS
       end
     end
-    
-    module API      
-      KeyValueConfig = Struct.new(:bucket, :description, :max_value_size,
-                                  :history, :ttl, :max_bytes, :storage, :replicas,
-                                  keyword_init: true) do
+
+    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) }
@@ -127,40 +272,53 @@ module NATS
           stream: stream,
           pre: "$KV.#{bucket}.",
           js: self,
+          direct: si.config.allow_direct
         )
       end
 
       def create_key_value(config)
-        config = if not config.is_a?(JetStream::API::StreamConfig)
+        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
-          config.ttl = config.ttl * 1_000_000_000
+          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}.>"],
-          max_msgs_per_subject: config.history,
-          max_bytes: config.max_bytes,
+          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,
-          storage: config.storage,
+          max_msgs: -1,
+          max_msgs_per_subject: config.history,
           num_replicas: config.replicas,
-          allow_rollup_hdrs: true,
-          deny_delete: true,
+          storage: config.storage,
+          republish: config.republish,
         )
-        resp = add_stream(stream)
 
+        si = add_stream(stream)
         KeyValue.new(
           name: config.bucket,
           stream: stream.name,
           pre: "$KV.#{config.bucket}.",
           js: self,
+          direct: si.config.allow_direct
         )
       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.1.0".freeze
+    VERSION = "2.2.0".freeze
 
     # LANG is the lang runtime of the client announced on CONNECT to the server.
     LANG = "#{RUBY_ENGINE}#{RUBY_VERSION}".freeze

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nats-pure
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Waldemar Quevedo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-06-09 00:00:00.000000000 Z
+date: 2022-10-01 00:00:00.000000000 Z
 dependencies: []
 description: NATS is an open-source, high-performance, lightweight cloud messaging
   system.