nats-pure 0.4.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 59129f0c5e0180f95490a2ca5e2acb8cf0c1d630c32e4d4ab6f0cf859242500b
-  data.tar.gz: c23db05317523a59762b9b2e73917165baf8ee3a898aaa74e84a74b0977c1942
+  metadata.gz: d21f9a3f83d1aaa172f0835a2d74b5109a8e937429550981427b84325f97f1d3
+  data.tar.gz: 48ea0ef20a7c2611023573f883384d15ebf6bf9c342f37336b25157d79963098
 SHA512:
-  metadata.gz: b82fdc592bea6ddc5ca1e0792b76071dd09db70a86fcaef517207d33c339d1b105076efd2b3d3cc83960a6b470739d01ec9d2f41574f57111935e0245eb02e5d
-  data.tar.gz: 4439c2f2f0c3c6118b5a4b93587a60ecb069f8b85e0907539bec6a497a8394a1f78a9a961aa2565436e7c7ab4ee3bc1bd459310935499da67c1d7e7c11a0d5c7
+  metadata.gz: b72826e0d687cee2e303f3fae2abbc34ad6fe10ce35967d2201ecd3838c27f186e70c99c880288bfd2fbdc840edebfa80f4f31e282caafb15f899b41301a5a94
+  data.tar.gz: b5328d07ffa92de70d32cb37b28bf1c08db2866b58902dee2f761b6c0cf758c18037262fca4f42a3ab5bf6c4f0663abb733d8322cdfe8a2e30d8bd9de9a4139f

data/lib/nats/io/client.rb

@@ -1,5 +1,20 @@
+# 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 'nats/io/parser'
 require 'nats/io/version'
+require 'nats/nuid'
 require 'thread'
 require 'socket'
 require 'json'
@@ -49,6 +64,12 @@ module NATS
     PING_REQUEST  = ("PING#{CR_LF}".freeze)
     PONG_RESPONSE = ("PONG#{CR_LF}".freeze)
 
+    NATS_HDR_LINE  = ("NATS/1.0#{CR_LF}".freeze)
+    STATUS_MSG_LEN = 3
+    STATUS_HDR     = ("Status".freeze)
+    DESC_HDR       = ("Description".freeze)
+    NATS_HDR_LINE_SIZE = (NATS_HDR_LINE.bytesize)
+
     SUB_OP = ('SUB'.freeze)
     EMPTY_MSG = (''.freeze)
 
@@ -76,6 +97,9 @@ module NATS
     # When we cannot connect since there are no servers available.
     class NoServersError < ConnectError; end
 
+    # When there are no subscribers available to respond.
+    class NoRespondersError < ConnectError; end
+
     # When the connection exhausts max number of pending pings replies.
     class StaleConnectionError < Error; end
 
@@ -159,13 +183,44 @@ module NATS
         # Hostname of current server; used for when TLS host
         # verification is enabled.
         @hostname = nil
+        @single_url_connect_used = false
+
+        # New style request/response implementation.
+        @resp_sub = nil
+        @resp_map = nil
+        @resp_sub_prefix = nil
+        @nuid = NATS::NUID.new
+
+        # NKEYS
+        @user_credentials = nil
+        @nkeys_seed = nil
+        @user_nkey_cb = nil
+        @user_jwt_cb = nil
+        @signature_cb = nil
       end
 
-      # Establishes connection to NATS
-      def connect(opts={})
+      # Establishes connection to NATS.
+      def connect(uri=nil, opts={})
+        case uri
+        when String
+          # Initialize TLS defaults in case any url is using it.
+          srvs = opts[:servers] = process_uri(uri)
+          if srvs.any? {|u| u.scheme == 'tls'} and !opts[:tls]
+            tls_context = OpenSSL::SSL::SSLContext.new
+            tls_context.set_params
+            opts[:tls] = {
+              context: tls_context
+            }
+          end
+          @single_url_connect_used = true if srvs.size == 1
+        when Hash
+          opts = uri
+        end
+
         opts[:verbose] = false if opts[:verbose].nil?
         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[:reconnect_time_wait] = RECONNECT_TIME_WAIT if opts[:reconnect_time_wait].nil?
         opts[:max_reconnect_attempts] = MAX_RECONNECT_ATTEMPTS if opts[:max_reconnect_attempts].nil?
         opts[:ping_interval] = DEFAULT_PING_INTERVAL if opts[:ping_interval].nil?
@@ -198,6 +253,17 @@ module NATS
           }
         end
 
+        if @options[:old_style_request]
+          # Replace for this instance the implementation
+          # of request to use the old_request style.
+          class << self; alias_method :request, :old_request; end
+        end
+
+        # NKEYS
+        @user_credentials ||= opts[:user_credentials]
+        @nkeys_seed ||= opts[:nkeys_seed]
+        setup_nkeys_connect if @user_credentials or @nkeys_seed
+
         # Check for TLS usage
         @tls = @options[:tls]
 
@@ -217,7 +283,12 @@ module NATS
           @status = CONNECTING
 
           # Use the hostname from the server for TLS hostname verification.
-          @hostname = srv[:hostname]
+          if client_using_secure_connection? and single_url_connect_used?
+            # Always reuse the original hostname used to connect.
+            @hostname ||= srv[:hostname]
+          else
+            @hostname = srv[:hostname]
+          end
 
           # Established TCP connection successfully so can start connect
           process_connect_init
@@ -284,6 +355,36 @@ module NATS
         @flush_queue << :pub if @flush_queue.empty?
       end
 
+      # Publishes a NATS::Msg that may include headers.
+      def publish_msg(msg)
+        raise TypeError, "nats: expected NATS::Msg, got #{msg.class.name}" unless msg.is_a?(Msg)
+        raise BadSubject if !msg.subject or msg.subject.empty?
+
+        msg.reply ||= ''
+        msg.data ||= ''
+        msg_size = msg.data.bytesize
+
+        # Accounting
+        @stats[:out_msgs] += 1
+        @stats[:out_bytes] += msg_size
+
+        if msg.header
+          hdr = ''
+          hdr << NATS_HDR_LINE
+          msg.header.each do |k, v|
+            hdr << "#{k}: #{v}#{CR_LF}"
+          end
+          hdr << CR_LF
+          hdr_len = hdr.bytesize
+          total_size = msg_size + hdr_len
+          send_command("HPUB #{msg.subject} #{msg.reply} #{hdr_len} #{total_size}\r\n#{hdr}#{msg.data}\r\n")
+        else
+          send_command("PUB #{msg.subject} #{msg.reply} #{msg_size}\r\n#{msg.data}\r\n")
+        end
+
+        @flush_queue << :pub if @flush_queue.empty?
+      end
+
       # Create subscription which is dispatched asynchronously
       # messages to a callback.
       def subscribe(subject, opts={}, &callback)
@@ -331,7 +432,8 @@ module NATS
               when 0 then cb.call
               when 1 then cb.call(msg.data)
               when 2 then cb.call(msg.data, msg.reply)
-              else cb.call(msg.data, msg.reply, msg.subject)
+              when 3 then cb.call(msg.data, msg.reply, msg.subject)
+              else cb.call(msg.data, msg.reply, msg.subject, msg.header)
               end
             rescue => e
               synchronize do
@@ -344,10 +446,123 @@ module NATS
         sid
       end
 
-      # Sends a request expecting a single response or raises a timeout
-      # in case the request is not retrieved within the specified deadline.
+      # Sends a request using expecting a single response using a
+      # single subscription per connection for receiving the responses.
+      # It times out in case the request is not retrieved within the
+      # specified deadline.
       # If given a callback, then the request happens asynchronously.
-      def request(subject, payload, opts={}, &blk)
+      def request(subject, payload="", opts={}, &blk)
+        raise BadSubject if !subject or subject.empty?
+
+        # If a block was given then fallback to method using auto unsubscribe.
+        return old_request(subject, payload, opts, &blk) if blk
+        return old_request(subject, payload, opts) if opts[:old_style]
+
+        token = nil
+        inbox = nil
+        future = nil
+        response = nil
+        timeout = opts[:timeout] ||= 0.5
+        synchronize do
+          start_resp_mux_sub! unless @resp_sub_prefix
+
+          # Create token for this request.
+          token = @nuid.next
+          inbox = "#{@resp_sub_prefix}.#{token}"
+
+          # Create the a future for the request that will
+          # get signaled when it receives the request.
+          future = @resp_sub.new_cond
+          @resp_map[token][:future] = future
+        end
+
+        # Publish request and wait for reply.
+        publish(subject, payload, inbox)
+        begin
+          with_nats_timeout(timeout) do
+            @resp_sub.synchronize do
+              future.wait(timeout)
+            end
+          end
+        rescue NATS::IO::Timeout => e
+          synchronize { @resp_map.delete(token) }
+          raise e
+        end
+
+        # Check if there is a response already.
+        synchronize do
+          result = @resp_map[token]
+          response = result[:response]
+          @resp_map.delete(token)
+        end
+
+        if response and response.header
+          status = response.header[STATUS_HDR]
+          raise NoRespondersError if status == "503"
+        end
+
+        response
+      end
+
+      # Makes a NATS request using a NATS::Msg that may include headers.
+      def request_msg(msg, opts={})
+        raise TypeError, "nats: expected NATS::Msg, got #{msg.class.name}" unless msg.is_a?(Msg)
+        raise BadSubject if !msg.subject or msg.subject.empty?
+
+        token = nil
+        inbox = nil
+        future = nil
+        response = nil
+        timeout = opts[:timeout] ||= 0.5
+        synchronize do
+          start_resp_mux_sub! unless @resp_sub_prefix
+
+          # Create token for this request.
+          token = @nuid.next
+          inbox = "#{@resp_sub_prefix}.#{token}"
+
+          # Create the a future for the request that will
+          # get signaled when it receives the request.
+          future = @resp_sub.new_cond
+          @resp_map[token][:future] = future
+        end
+        msg.reply = inbox
+        msg.data ||= ''
+        msg_size = msg.data.bytesize
+
+        # Publish request and wait for reply.
+        publish_msg(msg)
+        begin
+          with_nats_timeout(timeout) do
+            @resp_sub.synchronize do
+              future.wait(timeout)
+            end
+          end
+        rescue NATS::IO::Timeout => e
+          synchronize { @resp_map.delete(token) }
+          raise e
+        end
+
+        # Check if there is a response already.
+        synchronize do
+          result = @resp_map[token]
+          response = result[:response]
+          @resp_map.delete(token)
+        end
+
+        if response and response.header
+          status = response.header[STATUS_HDR]
+          raise NoRespondersError if status == "503"
+        end
+
+        response
+      end
+
+      # Sends a request creating an ephemeral subscription for the request,
+      # expecting a single response or raising a timeout in case the request
+      # is not retrieved within the specified deadline.
+      # If given a callback, then the request happens asynchronously.
+      def old_request(subject, payload, opts={}, &blk)
         return unless subject
         inbox = new_inbox
 
@@ -355,11 +570,13 @@ module NATS
         # the messages asynchronously and return the sid.
         if blk
           opts[:max] ||= 1
-          s = subscribe(inbox, opts) do |msg, reply|
+          s = subscribe(inbox, opts) do |msg, reply, subject, header|
             case blk.arity
             when 0 then blk.call
             when 1 then blk.call(msg)
-            else blk.call(msg, reply)
+            when 2 then blk.call(msg, reply)
+            when 3 then blk.call(msg, reply, subject)
+            else blk.call(msg, reply, subject, header)
             end
           end
           publish(subject, payload, inbox)
@@ -485,8 +702,7 @@ module NATS
         process_op_error(e)
       end
 
-      def process_msg(subject, sid, reply, data)
-        # Accounting
+      def process_msg(subject, sid, reply, data, header)
         @stats[:in_msgs] += 1
         @stats[:in_bytes] += data.size
 
@@ -495,7 +711,7 @@ module NATS
         synchronize { sub = @subs[sid] }
         return unless sub
 
-        sc = nil
+        err = nil
         sub.synchronize do
           sub.received += 1
 
@@ -516,29 +732,64 @@ module NATS
           # do so here already while holding the lock and return
           if sub.future
             future = sub.future
-            sub.response = Msg.new(subject, reply, data)
+            hdr = process_hdr(header)
+            sub.response = Msg.new(subject: subject, reply: reply, data: data, header: hdr)
             future.signal
 
             return
-          elsif sub.callback
+          elsif sub.pending_queue
             # Async subscribers use a sized queue for processing
             # and should be able to consume messages in parallel.
             if sub.pending_queue.size >= sub.pending_msgs_limit \
               or sub.pending_size >= sub.pending_bytes_limit then
-              sc = SlowConsumer.new("nats: slow consumer, messages dropped")
+              err = SlowConsumer.new("nats: slow consumer, messages dropped")
             else
+              hdr = process_hdr(header)
+
               # Only dispatch message when sure that it would not block
               # the main read loop from the parser.
-              sub.pending_queue << Msg.new(subject, reply, data)
+              msg = Msg.new(subject: subject, reply: reply, data: data, header: hdr)
+              sub.pending_queue << msg
               sub.pending_size += data.size
             end
           end
         end
 
         synchronize do
-          @last_err = sc
-          @err_cb.call(sc) if @err_cb
-        end if sc
+          @last_err = err
+          @err_cb.call(err) if @err_cb
+        end if err
+      end
+
+      def process_hdr(header)
+        hdr = nil
+        if header
+          hdr = {}
+          lines = header.lines
+
+          # Check if it is an inline status and description.
+          if lines.count <= 2
+            status_hdr = lines.first.rstrip
+            hdr[STATUS_HDR] = status_hdr.slice(NATS_HDR_LINE_SIZE-1, STATUS_MSG_LEN)
+
+            if NATS_HDR_LINE_SIZE+2 < status_hdr.bytesize
+              desc = status_hdr.slice(NATS_HDR_LINE_SIZE+STATUS_MSG_LEN, status_hdr.bytesize)
+              hdr[DESC_HDR] = desc unless desc.empty?
+            end
+          end
+          begin
+            lines.slice(1, header.size).each do |line|
+              line.rstrip!
+              next if line.empty?
+              key, value = line.strip.split(/\s*:\s*/, 2)
+              hdr[key] = value
+            end
+          rescue => e
+            err = e
+          end
+        end
+
+        hdr
       end
 
       def process_info(line)
@@ -559,7 +810,8 @@ module NATS
           if connect_urls
             srvs = []
             connect_urls.each do |url|
-              u = URI.parse("nats://#{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
@@ -678,6 +930,10 @@ module NATS
         @uri.scheme == "tls" || @tls
       end
 
+      def single_url_connect_used?
+        @single_url_connect_used
+      end
+
       def send_command(command)
         @pending_size += command.bytesize
         @pending_queue << command
@@ -699,13 +955,31 @@ module NATS
         }
         cs[:name] = @options[:name] if @options[:name]
 
-        if auth_connection?
+        case
+        when auth_connection?
           if @uri.password
             cs[:user] = @uri.user
             cs[:pass] = @uri.password
           else
             cs[:auth_token] = @uri.user
           end
+        when @user_credentials
+          nonce = @server_info[:nonce]
+          cs[:jwt] = @user_jwt_cb.call
+          cs[:sig] = @signature_cb.call(nonce)
+        when @nkeys_seed
+          nonce = @server_info[:nonce]
+          cs[:nkey] = @user_nkey_cb.call
+          cs[:sig] = @signature_cb.call(nonce)
+        end
+
+        if @server_info[:headers]
+          cs[:headers] = @server_info[:headers]
+          cs[:no_responders] = if @options[:no_responders] == false
+                                 @options[:no_responders]
+                               else
+                                 @server_info[:headers]
+                               end
         end
 
         "CONNECT #{cs.to_json}#{CR_LF}"
@@ -858,8 +1132,13 @@ module NATS
         if !line or line.empty?
           raise ConnectError.new("nats: protocol exception, INFO not received")
         end
-        _, info_json = line.split(' ')
-        process_info(info_json)
+
+        if match = line.match(NATS::Protocol::INFO)
+          info_json = match.captures.first
+          process_info(info_json)
+        else
+          raise ConnectError.new("nats: protocol exception, INFO not valid")
+        end
 
         case
         when (server_using_secure_connection? and client_using_secure_connection?)
@@ -946,7 +1225,12 @@ module NATS
           @stats[:reconnects] += 1
 
           # Set hostname to use for TLS hostname verification
-          @hostname = srv[:hostname]
+          if client_using_secure_connection? and single_url_connect_used?
+            # Reuse original hostname name in case of using TLS.
+            @hostname ||= srv[:hostname]
+          else
+            @hostname = srv[:hostname]
+          end
 
           # Established TCP connection successfully so can start connect
           process_connect_init
@@ -1093,6 +1377,47 @@ module NATS
         @ping_interval_thread.abort_on_exception = true
       end
 
+      # Prepares requests subscription that handles the responses
+      # for the new style request response.
+      def start_resp_mux_sub!
+        @resp_sub_prefix = "_INBOX.#{@nuid.next}"
+        @resp_map = Hash.new { |h,k| h[k] = { }}
+
+        @resp_sub = Subscription.new
+        @resp_sub.subject = "#{@resp_sub_prefix}.*"
+        @resp_sub.received = 0
+
+        # FIXME: Allow setting pending limits for responses mux subscription.
+        @resp_sub.pending_msgs_limit = DEFAULT_SUB_PENDING_MSGS_LIMIT
+        @resp_sub.pending_bytes_limit = DEFAULT_SUB_PENDING_BYTES_LIMIT
+        @resp_sub.pending_queue = SizedQueue.new(@resp_sub.pending_msgs_limit)
+        @resp_sub.wait_for_msgs_t = Thread.new do
+          loop do
+            msg = @resp_sub.pending_queue.pop
+            @resp_sub.pending_size -= msg.data.size
+
+            # Pick the token and signal the request under the mutex
+            # from the subscription itself.
+            token = msg.subject.split('.').last
+            future = nil
+            synchronize do
+              future = @resp_map[token][:future]
+              @resp_map[token][:response] = msg
+            end
+
+            # Signal back that the response has arrived.
+            @resp_sub.synchronize do
+              future.signal
+            end
+          end
+        end
+
+        sid = (@ssid += 1)
+        @subs[sid] = @resp_sub
+        send_command("SUB #{@resp_sub.subject} #{sid}#{CR_LF}")
+        @flush_queue << :sub
+      end
+
       def can_reuse_server?(server)
         return false if server.nil?
 
@@ -1125,6 +1450,115 @@ module NATS
           connect_timeout: DEFAULT_CONNECT_TIMEOUT
         })
       end
+
+      def setup_nkeys_connect
+        begin
+          require 'nkeys'
+          require 'base64'
+        rescue LoadError
+          raise(Error, "nkeys is not installed")
+        end
+
+        case
+        when @nkeys_seed
+          @user_nkey_cb = proc {
+            seed = File.read(@nkeys_seed).chomp
+            kp = NKEYS::from_seed(seed)
+
+            # Take a copy since original will be gone with the wipe.
+            pub_key = kp.public_key.dup
+            kp.wipe!
+
+            pub_key
+          }
+
+          @signature_cb = proc { |nonce|
+            seed = File.read(@nkeys_seed).chomp
+            kp = NKEYS::from_seed(seed)
+            raw_signed = kp.sign(nonce)
+            kp.wipe!
+            encoded = Base64.urlsafe_encode64(raw_signed)
+            encoded.gsub('=', '')
+          }
+        when @user_credentials
+          # When the credentials are within a single decorated file.
+          @user_jwt_cb = proc {
+            jwt_start = "BEGIN NATS USER JWT".freeze
+            found = false
+            jwt = nil
+            File.readlines(@user_credentials).each do |line|
+              case
+              when found
+                jwt = line.chomp
+                break
+              when line.include?(jwt_start)
+                found = true
+              end
+            end
+            raise(Error, "No JWT found in #{@user_credentials}") if not found
+
+            jwt
+          }
+
+          @signature_cb = proc { |nonce|
+            seed_start = "BEGIN USER NKEY SEED".freeze
+            found = false
+            seed = nil
+            File.readlines(@user_credentials).each do |line|
+              case
+              when found
+                seed = line.chomp
+                break
+              when line.include?(seed_start)
+                found = true
+              end
+            end
+            raise(Error, "No nkey user seed found in #{@user_credentials}") if not found
+
+            kp = NKEYS::from_seed(seed)
+            raw_signed = kp.sign(nonce)
+
+            # seed is a reference so also cleared when doing wipe,
+            # which can be done since Ruby strings are mutable.
+            kp.wipe
+            encoded = Base64.urlsafe_encode64(raw_signed)
+
+            # Remove padding
+            encoded.gsub('=', '')
+          }
+        end
+      end
+
+      def process_uri(uris)
+        connect_uris = []
+        uris.split(',').each do |uri|
+          opts = {}
+
+          # Scheme
+          if uri.include?("://")
+            scheme, uri = uri.split("://")
+            opts[:scheme] = scheme
+          else
+            opts[:scheme] = 'nats'
+          end
+
+          # UserInfo
+          if uri.include?("@")
+            userinfo, endpoint = uri.split("@")
+            host, port = endpoint.split(":")
+            opts[:userinfo] = userinfo
+          else
+            host, port = uri.split(":")
+          end
+
+          # Host and Port
+          opts[:host] = host || "localhost"
+          opts[:port] = port || DEFAULT_PORT
+
+          connect_uris << URI::Generic.build(opts)
+        end
+        connect_uris
+      end
     end
 
     # Implementation adapted from https://github.com/redis/redis-rb
@@ -1254,7 +1688,7 @@ module NATS
     end
   end
 
-  Msg = Struct.new(:subject, :reply, :data)
+  Msg = Struct.new(:subject, :reply, :data, :header, keyword_init: true)
 
   class Subscription
     include MonitorMixin

data/lib/nats/io/parser.rb

@@ -1,7 +1,22 @@
+# 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.
+# 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
   module Protocol
 
     MSG      = /\AMSG\s+([^\s]+)\s+([^\s]+)\s+(([^\s]+)[^\S\r\n]+)?(\d+)\r\n/i
+    HMSG     = /\AHMSG\s+([^\s]+)\s+([^\s]+)\s+(([^\s]+)[^\S\r\n]+)?([\d]+)\s+(\d+)\r\n/i
     OK       = /\A\+OK\s*\r\n/i
     ERR      = /\A-ERR\s+('.+')?\r\n/i
     PING     = /\APING\s*\r\n/i
@@ -35,6 +50,7 @@ module NATS
         @sid = nil
         @reply = nil
         @needed = nil
+        @header_needed = nil
       end
 
       def parse(data)
@@ -47,6 +63,10 @@ module NATS
               @buf = $'
               @sub, @sid, @reply, @needed = $1, $2.to_i, $4, $5.to_i
               @parse_state = AWAITING_MSG_PAYLOAD
+            when HMSG
+              @buf = $'
+              @sub, @sid, @reply, @header_needed, @needed = $1, $2.to_i, $4, $5.to_i, $6.to_i
+              @parse_state = AWAITING_MSG_PAYLOAD
             when OK # No-op right now
               @buf = $'
             when ERR
@@ -75,9 +95,17 @@ module NATS
 
           when AWAITING_MSG_PAYLOAD
             return unless (@needed && @buf.bytesize >= (@needed + CR_LF_SIZE))
-            @nc.process_msg(@sub, @sid, @reply, @buf.slice(0, @needed))
-            @buf = @buf.slice((@needed + CR_LF_SIZE), @buf.bytesize)
-            @sub = @sid = @reply = @needed = nil
+            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)
+              @buf = @buf.slice((@needed + CR_LF_SIZE), @buf.bytesize)
+            else
+              @nc.process_msg(@sub, @sid, @reply, @buf.slice(0, @needed), nil)
+              @buf = @buf.slice((@needed + CR_LF_SIZE), @buf.bytesize)
+            end
+
+            @sub = @sid = @reply = @needed = @header_needed = nil
             @parse_state = AWAITING_CONTROL_LINE
             @buf = nil if (@buf && @buf.empty?)
           end

data/lib/nats/io/version.rb

@@ -1,8 +1,22 @@
+# 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.
+# 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
   module IO
     # NOTE: These are all announced to the server on CONNECT
-    VERSION  = "0.4.0"
-    LANG     = "#{RUBY_ENGINE}2".freeze
+    VERSION  = "0.7.0"
+    LANG     = "#{RUBY_ENGINE}#{RUBY_VERSION}".freeze
     PROTOCOL = 1
   end
 end

data/lib/nats/nuid.rb

@@ -0,0 +1,81 @@
+# 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.
+# 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 'securerandom'
+
+module NATS
+  class NUID
+    DIGITS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.split('')
+    BASE          = 62
+    PREFIX_LENGTH = 12
+    SEQ_LENGTH    = 10
+    TOTAL_LENGTH  = PREFIX_LENGTH + SEQ_LENGTH
+    MAX_SEQ       = BASE**10
+    MIN_INC       = 33
+    MAX_INC       = 333
+    INC = MAX_INC - MIN_INC
+
+    def initialize
+      @prand    = Random.new
+      @seq      = @prand.rand(MAX_SEQ)
+      @inc      = MIN_INC + @prand.rand(INC)
+      @prefix   = ''
+      randomize_prefix!
+    end
+
+    def next
+      @seq += @inc
+      if @seq >= MAX_SEQ
+        randomize_prefix!
+        reset_sequential!
+      end
+      l = @seq
+
+      # 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];
+
+      # 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])
+      "#{@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
+    end
+
+    private
+
+    def reset_sequential!
+      @seq = @prand.rand(MAX_SEQ)
+      @inc = MIN_INC + @prand.rand(INC)
+    end
+
+    class << self
+      @@nuid = NUID.new.extend(MonitorMixin)
+      def next
+        @@nuid.synchronize do
+          @@nuid.next
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,19 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: nats-pure
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Waldemar Quevedo
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-03-15 00:00:00.000000000 Z
+date: 2021-08-17 00:00:00.000000000 Z
 dependencies: []
 description: NATS is an open-source, high-performance, lightweight cloud messaging
   system.
 email:
-- wally@apcera.com
+- wally@synadia.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -21,11 +21,12 @@ files:
 - lib/nats/io/client.rb
 - lib/nats/io/parser.rb
 - lib/nats/io/version.rb
+- lib/nats/nuid.rb
 homepage: https://nats.io
 licenses:
-- MIT
+- Apache-2.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -40,9 +41,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.3
-signing_key: 
+rubygems_version: 3.2.22
+signing_key:
 specification_version: 4
 summary: NATS is an open-source, high-performance, lightweight cloud messaging system.
 test_files: []