nats-pure 0.5.0 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 741d87f63f2851dc25639453f9cd5ed68b3e2bfb66f45f1b5fe6caa9b3e352dd
-  data.tar.gz: 1af44d28a31788e37fbb50d14f966ff30805ee42614ae37a7ab3599edd0de4f0
+  metadata.gz: 1283c1d3b53b281eec2c1fb01643b3efd51c7b2468a54006f4afc9b0aa6cfffd
+  data.tar.gz: d6777d4b80d57b44da776e75be073f67fd76c3a7d23cf66fa7a2dc96f74afe64
 SHA512:
-  metadata.gz: 432d3b3cf28752ec19c6278763ec5e1ef5992ee9d57796aeadb41b978028b3700c699795134f46297c982d9fc98fc3979d0760842f74fb528977e62b66431c9c
-  data.tar.gz: 758a3b3deb4c2b14198bca42b647d2b11726c08d7150a914a8835a64fa6720d57d28c2207ddcd6ad40995427902ab1afd6705f2ab4c4ea1adbe9e131ccc1ea32
+  metadata.gz: bb44bb3872296a3cce5416777b2e85c5c2046fb64a545157fd3661754a31311b9bf2d032494d5eb1e34a08c1e0d2f3982538a098f0066f30c2a5c16823ee8ec8
+  data.tar.gz: f5a2e1f1a836392030c1abc0d8ee65a3b19e2bb371d7c3cae0c8107ae5444a13609275f85c6ec12c06070218e1220ec36bb57eba4d8a7c86b4ac314eba6ddc4e

data/lib/nats/io/client.rb

@@ -1,4 +1,4 @@
-# Copyright 2016-2018 The NATS Authors
+# 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
@@ -28,6 +28,15 @@ rescue LoadError
 end
 
 module NATS
+  class << self
+    def connect(uri=nil, opts={})
+      nc = NATS::IO::Client.new
+      nc.connect(uri, opts)
+
+      nc
+    end
+  end
+
   module IO
 
     DEFAULT_PORT = 4222
@@ -64,6 +73,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)
 
@@ -91,6 +106,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
 
@@ -174,16 +192,52 @@ module NATS
         # Hostname of current server; used for when TLS host
         # verification is enabled.
         @hostname = nil
+        @single_url_connect_used = false
+
+        # Track whether connect has been already been called.
+        @connect_called = 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={})
+      def connect(uri=nil, opts={})
+        synchronize do
+          # In case it has been connected already, then do not need to call this again.
+          return if @connect_called
+          @connect_called = true
+        end
+
+        # Convert URI to string if needed.
+        uri = uri.to_s if uri.is_a?(URI)
+
+        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?
@@ -226,6 +280,11 @@ module NATS
           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]
 
@@ -245,7 +304,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
@@ -312,6 +376,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)
@@ -359,7 +453,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
@@ -377,11 +472,12 @@ module NATS
       # 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)
-        return unless subject
+      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
@@ -403,16 +499,81 @@ module NATS
 
         # Publish request and wait for reply.
         publish(subject, payload, inbox)
-        with_nats_timeout(timeout) do
-          @resp_sub.synchronize do
-            future.wait(timeout)
+        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
+        # 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
@@ -430,11 +591,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)
@@ -473,6 +636,11 @@ module NATS
         end
         response = sub.response
 
+        if response and response.header
+          status = response.header[STATUS_HDR]
+          raise NoRespondersError if status == "503"
+        end
+
         response
       end
 
@@ -560,8 +728,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
 
@@ -570,7 +737,7 @@ module NATS
         synchronize { sub = @subs[sid] }
         return unless sub
 
-        sc = nil
+        err = nil
         sub.synchronize do
           sub.received += 1
 
@@ -591,7 +758,8 @@ 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
@@ -600,20 +768,54 @@ module NATS
             # 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)
@@ -634,7 +836,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
@@ -753,6 +956,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
@@ -774,13 +981,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}"
@@ -933,8 +1158,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?)
@@ -1021,7 +1251,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
@@ -1241,6 +1476,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
@@ -1370,7 +1714,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

@@ -16,6 +16,7 @@ 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
@@ -49,6 +50,7 @@ module NATS
         @sid = nil
         @reply = nil
         @needed = nil
+        @header_needed = nil
       end
 
       def parse(data)
@@ -61,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
@@ -89,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,4 +1,4 @@
-# Copyright 2016-2018 The NATS Authors
+# 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
@@ -15,8 +15,8 @@
 module NATS
   module IO
     # NOTE: These are all announced to the server on CONNECT
-    VERSION  = "0.5.0"
-    LANG     = "#{RUBY_ENGINE}2".freeze
+    VERSION  = "0.7.2"
+    LANG     = "#{RUBY_ENGINE}#{RUBY_VERSION}".freeze
     PROTOCOL = 1
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nats-pure
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.2
 platform: ruby
 authors:
 - Waldemar Quevedo
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-04-04 00:00:00.000000000 Z
+date: 2021-08-25 00:00:00.000000000 Z
 dependencies: []
 description: NATS is an open-source, high-performance, lightweight cloud messaging
   system.
@@ -26,7 +26,7 @@ homepage: https://nats.io
 licenses:
 - Apache-2.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -41,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: []