nats-pure 2.0.0.pre.rc1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 210e29c9b6fcc68e5c89e841a068c1a389ac78a67cadcb639161d0d5c02c4bf0
-  data.tar.gz: 2b181886b3a96277ae494cdda48b8bf16e9721666294ea69440976b85888b40c
+  metadata.gz: 6f0d4251703ba9fd6a91f501686025e2f71e93dc7869f65984da7cd312361266
+  data.tar.gz: 411fdfd23878cf89b26c76e04b68c760e10aaef14f2a68fae19c69a8d1392990
 SHA512:
-  metadata.gz: 910ffb697d692a3040fd6b40e835d1a2486f16525a5e814ea33dfdb2e732dd6ba3f1876b5e6dbc7dee07e9491154a6c181b41b2db08988434d9e48900ae3dcf0
-  data.tar.gz: a4e4d9cc9be95d1c67331576c814841b7b7784986a6ac9503ec44846e5dfbf2af978990fe482c8a9ea1064112ab54b4c65cfc619a931a20904f712d2896547a1
+  metadata.gz: a3b88a713e2c1b6a515ac4f505cb6724c0059e72693d8d5c2ee61f3579d1b4b846408282e131864735dccc8b224e4a22933be91409d404fedadf0ec6c72051cf
+  data.tar.gz: 9ef88d1a391c2cfec91731aca2742382634c923384b801fce4ee9155418de39bd538f7aaafceb6ba2a1b40b57c6b7db4363ad4cf673d8ff3b5e87b5f74104789

data/lib/nats/io/client.rb

@@ -227,6 +227,7 @@ module NATS
       opts[:pedantic] = false if opts[:pedantic].nil?
       opts[:reconnect] = true if opts[:reconnect].nil?
       opts[:old_style_request] = false if opts[:old_style_request].nil?
+      opts[:ignore_discovered_urls] = false if opts[:ignore_discovered_urls].nil?
       opts[:reconnect_time_wait] = NATS::IO::RECONNECT_TIME_WAIT if opts[:reconnect_time_wait].nil?
       opts[:max_reconnect_attempts] = NATS::IO::MAX_RECONNECT_ATTEMPTS if opts[:max_reconnect_attempts].nil?
       opts[:ping_interval] = NATS::IO::DEFAULT_PING_INTERVAL if opts[:ping_interval].nil?
@@ -237,6 +238,7 @@ module NATS
       opts[:pedantic] = ENV['NATS_PEDANTIC'].downcase == 'true' unless ENV['NATS_PEDANTIC'].nil?
       opts[:reconnect] = ENV['NATS_RECONNECT'].downcase == 'true' unless ENV['NATS_RECONNECT'].nil?
       opts[:reconnect_time_wait] = ENV['NATS_RECONNECT_TIME_WAIT'].to_i unless ENV['NATS_RECONNECT_TIME_WAIT'].nil?
+      opts[:ignore_discovered_urls] = ENV['NATS_IGNORE_DISCOVERED_URLS'].downcase == 'true' unless ENV['NATS_IGNORE_DISCOVERED_URLS'].nil?
       opts[:max_reconnect_attempts] = ENV['NATS_MAX_RECONNECT_ATTEMPTS'].to_i unless ENV['NATS_MAX_RECONNECT_ATTEMPTS'].nil?
       opts[:ping_interval] = ENV['NATS_PING_INTERVAL'].to_i unless ENV['NATS_PING_INTERVAL'].nil?
       opts[:max_outstanding_pings] = ENV['NATS_MAX_OUTSTANDING_PINGS'].to_i unless ENV['NATS_MAX_OUTSTANDING_PINGS'].nil?
@@ -256,7 +258,7 @@ module NATS
                    end
         @server_pool << {
           :uri => nats_uri,
-          :hostname => nats_uri.host
+          :hostname => nats_uri.hostname
         }
       end
 
@@ -807,17 +809,17 @@ module NATS
 
         # Detect any announced server that we might not be aware of...
         connect_urls = @server_info[:connect_urls]
-        if connect_urls
+        if !@options[:ignore_discovered_urls] && connect_urls
           srvs = []
           connect_urls.each do |url|
             scheme = client_using_secure_connection? ? "tls" : "nats"
             u = URI.parse("#{scheme}://#{url}")
 
             # Skip in case it is the current server which we already know
-            next if @uri.host == u.host && @uri.port == u.port
+            next if @uri.hostname == u.hostname && @uri.port == u.port
 
             present = server_pool.detect do |srv|
-              srv[:uri].host == u.host && srv[:uri].port == u.port
+              srv[:uri].hostname == u.hostname && srv[:uri].port == u.port
             end
 
             if not present
@@ -832,7 +834,7 @@ module NATS
               end
 
               # NOTE: Auto discovery won't work here when TLS host verification is enabled.
-              srv = { :uri => u, :reconnect_attempts => 0, :discovered => true, :hostname => u.host }
+              srv = { :uri => u, :reconnect_attempts => 0, :discovered => true, :hostname => u.hostname }
               srvs << srv
             end
           end
@@ -1758,34 +1760,20 @@ module NATS
     end
 
     def process_uri(uris)
-      connect_uris = []
-      uris.split(',').each do |uri|
+      uris.split(',').map do |uri|
         opts = {}
 
         # Scheme
-        if uri.include?("://")
-          scheme, uri = uri.split("://")
-          opts[:scheme] = scheme
-        else
-          opts[:scheme] = 'nats'
-        end
+        uri = "nats://#{uri}" if !uri.include?("://")
 
-        # UserInfo
-        if uri.include?("@")
-          userinfo, endpoint = uri.split("@")
-          host, port = endpoint.split(":")
-          opts[:userinfo] = userinfo
-        else
-          host, port = uri.split(":")
-        end
+        uri_object = URI(uri)
 
         # Host and Port
-        opts[:host] = host || "localhost"
-        opts[:port] = port || DEFAULT_PORT
+        uri_object.hostname ||= "localhost"
+        uri_object.port ||= DEFAULT_PORT
 
-        connect_uris << URI::Generic.build(opts)
+        uri_object
       end
-      connect_uris
     end
   end
 
@@ -1834,7 +1822,7 @@ module NATS
       end
 
       def connect
-        addrinfo = ::Socket.getaddrinfo(@uri.host, nil, ::Socket::AF_UNSPEC, ::Socket::SOCK_STREAM)
+        addrinfo = ::Socket.getaddrinfo(@uri.hostname, nil, ::Socket::AF_UNSPEC, ::Socket::SOCK_STREAM)
         addrinfo.each_with_index do |ai, i|
           begin
             @socket = connect_addrinfo(ai, @uri.port, @connect_timeout)

data/lib/nats/io/js.rb

@@ -284,6 +284,7 @@ module NATS
                  end
         stream = config[:name]
         raise ArgumentError.new(":name is required to create streams") unless stream
+        raise ArgumentError.new("Spaces, tabs, period (.), greater than (>) or asterisk (*) are prohibited in stream names") if stream =~ /(\s|\.|\>|\*)/
         req_subject = "#{@prefix}.STREAM.CREATE.#{stream}"
         result = api_request(req_subject, config.to_json, params)
         JetStream::API::StreamCreateResponse.new(result)
@@ -345,6 +346,7 @@ module NATS
           stream_name: stream,
           config: config
         }
+
         result = api_request(req_subject, req.to_json, params)
         JetStream::API::ConsumerInfo.new(result).freeze
       end
@@ -502,11 +504,14 @@ module NATS
           synchronize do
             unless @pending_queue.empty?
               msg = @pending_queue.pop
+              @pending_size -= msg.data.size
               # Check for a no msgs response status.
               if JS.is_status_msg(msg)
                 case msg.header["Status"]
                 when JS::Status::NoMsgs
                   msg = nil
+                when JS::Status::RequestTimeout
+                  # Skip
                 else
                   raise JS.from_msg(msg)
                 end
@@ -525,7 +530,12 @@ module NATS
             # Wait for result of fetch or timeout.
             synchronize { wait_for_msgs_cond.wait(timeout) }
 
-            msgs << @pending_queue.pop unless @pending_queue.empty?
+            unless @pending_queue.empty?
+              msg = @pending_queue.pop
+              @pending_size -= msg.data.size
+
+              msgs << msg
+            end
 
             duration = MonotonicTime.since(t)
             if duration > timeout
@@ -535,7 +545,13 @@ module NATS
             # Should have received at least a message at this point,
             # if that is not the case then error already.
             if JS.is_status_msg(msgs.first)
-              raise JS.from_msg(msgs.first)
+              msg = msgs.first
+              case msg.header[JS::Header::Status]
+              when JS::Status::RequestTimeout
+                raise NATS::Timeout.new("nats: fetch request timeout")
+              else
+                raise JS.from_msg(msgs.first)
+              end
             end
           end
         when batch > 1
@@ -546,7 +562,23 @@ module NATS
           # Check if there already enough in the pending buffer.
           synchronize do
             if batch <= @pending_queue.size
-              batch.times { msgs << @pending_queue.pop }
+              batch.times do
+                msg = @pending_queue.pop
+                @pending_size -= msg.data.size
+
+                # Check for a no msgs response status.
+                if JS.is_status_msg(msg)
+                  case msg.header[JS::Header::Status]
+                  when JS::Status::NoMsgs, JS::Status::RequestTimeout
+                    # Skip these
+                    next
+                  else
+                    raise JS.from_msg(msg)
+                  end
+                else
+                  msgs << msg
+                end
+              end
 
               return msgs
             end
@@ -559,10 +591,15 @@ module NATS
           # Not receiving even one is a timeout.
           start_time = MonotonicTime.now
           msg = nil
-          synchronize {
+
+          synchronize do
             wait_for_msgs_cond.wait(timeout)
-            msg = @pending_queue.pop unless @pending_queue.empty?
-          }
+
+            unless @pending_queue.empty?
+              msg = @pending_queue.pop
+              @pending_size -= msg.data.size
+            end
+          end
 
           # Check if the first message was a response saying that
           # there are no messages.
@@ -574,11 +611,13 @@ module NATS
               next_req.delete(:no_wait)
 
               @nc.publish(@jsi.nms, JS.next_req_to_json(next_req), @subject)
+            when JS::Status::RequestTimeout
+              raise NATS::Timeout.new("nats: fetch request timeout")
             else
               raise JS.from_msg(msg)
             end
           else
-            msgs << msg
+            msgs << msg unless msg.nil?
           end
 
           # Check if have not received yet a single message.
@@ -605,23 +644,27 @@ module NATS
                 end
               else
                 msg = @pending_queue.pop
+                @pending_size -= msg.data.size
 
                 if JS.is_status_msg(msg)
-                  case msg.header["Status"]
+                  case msg.header[JS::Header::Status]
                   when JS::Status::NoMsgs, JS::Status::RequestTimeout
                     duration = MonotonicTime.since(start_time)
 
-                    # Do not time out if we received at least some messages.
-                    if msgs.empty? && @pending_queue.empty? and duration > timeout
-                      raise NATS::Timeout.new("nats: fetch timeout")
+                    if duration > timeout
+                      # Only received a subset of the messages.
+                      if !msgs.empty?
+                        return msgs
+                      else
+                        raise NATS::Timeout.new("nats: fetch timeout")
+                      end
                     end
-
-                    # Likely only received a subset of the messages.
-                    return msgs
                   else
                     raise JS.from_msg(msg)
                   end
+
                 else
+                  # Add to the set of messages that will be returned.
                   msgs << msg
                   needed -= 1
                 end

data/lib/nats/io/kv.rb

@@ -0,0 +1,172 @@
+# 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
+    KV_OP = "KV-Operation"
+    KV_DEL = "DEL"
+    KV_PURGE = "PURGE"
+    MSG_ROLLUP_SUBJECT = "sub"
+    MSG_ROLLUP_ALL = "all"
+
+    def initialize(opts={})
+      @name = opts[:name]
+      @stream = opts[:stream]
+      @pre = opts[:pre]
+      @js = opts[:js]
+    end
+
+    # When a key is not found because it was deleted.
+    class KeyDeletedError < NATS::Error; end
+
+    # When there was no bucket present.
+    class BucketNotFoundError < NATS::Error; end
+
+    # When it is an invalid bucket.
+    class BadBucketError < NATS::Error; end
+
+    # get returns the latest value for the key.
+    def get(key)
+      msg = @js.get_last_msg(@stream, "#{@pre}#{key}")
+      entry = Entry.new(bucket: @name, key: key, value: msg.data, revision: msg.seq)
+
+      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
+      end
+
+      entry
+    end
+
+    # 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)
+    end
+
+    # delete will place a delete marker and remove all previous revisions.
+    def delete(key)
+      hdrs = {}
+      hdrs[KV_OP] = KV_DEL
+      @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, keyword_init: true) do
+      def initialize(opts={})
+        rem = opts.keys - members
+        opts.delete_if { |k| rem.include?(k) }
+        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 / 1_000_000_000
+      end
+    end
+    
+    module API      
+      KeyValueConfig = Struct.new(:bucket, :description, :max_value_size,
+                                  :history, :ttl, :max_bytes, :storage, :replicas,
+                                  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,
+        )
+      end
+
+      def create_key_value(config)
+        config = if not config.is_a?(JetStream::API::StreamConfig)
+                   KeyValue::API::KeyValueConfig.new(config)
+                 else
+                   config
+                 end
+        config.history ||= 1
+        config.replicas ||= 1
+        if config.ttl
+          config.ttl = config.ttl * 1_000_000_000
+        end
+
+        stream = JetStream::API::StreamConfig.new(
+          name: "KV_#{config.bucket}",
+          subjects: ["$KV.#{config.bucket}.>"],
+          max_msgs_per_subject: config.history,
+          max_bytes: config.max_bytes,
+          max_age: config.ttl,
+          max_msg_size: config.max_value_size,
+          storage: config.storage,
+          num_replicas: config.replicas,
+          allow_rollup_hdrs: true,
+          deny_delete: true,
+        )
+        resp = add_stream(stream)
+
+        KeyValue.new(
+          name: config.bucket,
+          stream: stream.name,
+          pre: "$KV.#{config.bucket}.",
+          js: self,
+        )
+      end
+
+      def delete_key_value(bucket)
+        delete_stream("KV_#{bucket}")
+      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
@@ -15,7 +15,7 @@
 module NATS
   module IO
     # VERSION is the version of the client announced on CONNECT to the server.
-    VERSION = "2.0.0-rc1".freeze
+    VERSION = "2.1.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/nuid.rb

@@ -15,7 +15,7 @@ require 'securerandom'
 
 module NATS
   class NUID
-    DIGITS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.split('')
+    DIGITS        = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.split('')
     BASE          = 62
     PREFIX_LENGTH = 12
     SEQ_LENGTH    = 10
@@ -25,6 +25,8 @@ module NATS
     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)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nats-pure
 version: !ruby/object:Gem::Version
-  version: 2.0.0.pre.rc1
+  version: 2.1.0
 platform: ruby
 authors:
 - Waldemar Quevedo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-29 00:00:00.000000000 Z
+date: 2022-06-09 00:00:00.000000000 Z
 dependencies: []
 description: NATS is an open-source, high-performance, lightweight cloud messaging
   system.
@@ -23,6 +23,7 @@ files:
 - lib/nats/io/client.rb
 - lib/nats/io/errors.rb
 - lib/nats/io/js.rb
+- lib/nats/io/kv.rb
 - lib/nats/io/msg.rb
 - lib/nats/io/parser.rb
 - lib/nats/io/subscription.rb
@@ -43,11 +44,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.3.3
 signing_key:
 specification_version: 4
 summary: NATS is an open-source, high-performance, lightweight cloud messaging system.