nats-pure 2.0.0.pre.alpha → 2.0.0.pre.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15a5820d95fec0e8c400dab340af35458c52b5bab82e4decdf2b717067dcc940
-  data.tar.gz: 6b98522090c63c3b6338b21e2c42c8bf0172c666c79d5f39237b67a7fff63409
+  metadata.gz: 210e29c9b6fcc68e5c89e841a068c1a389ac78a67cadcb639161d0d5c02c4bf0
+  data.tar.gz: 2b181886b3a96277ae494cdda48b8bf16e9721666294ea69440976b85888b40c
 SHA512:
-  metadata.gz: b31773f6a58cfaa0728bbb544089a4181016bb32b95ca74c1effd06458428b544163bd4bba5194792d7e18c2c20386b49605d701391203aa8c8053a1e597fc57
-  data.tar.gz: 856e51e5c54dc25fba10f126d9072458ef1d7e145fbb9303ef643542c08cfcc155ddbd8c5bacc4d94ecf1c690a08877c6c8a9657fe91a7167d21b4bbedd513ce
+  metadata.gz: 910ffb697d692a3040fd6b40e835d1a2486f16525a5e814ea33dfdb2e732dd6ba3f1876b5e6dbc7dee07e9491154a6c181b41b2db08988434d9e48900ae3dcf0
+  data.tar.gz: a4e4d9cc9be95d1c67331576c814841b7b7784986a6ac9503ec44846e5dfbf2af978990fe482c8a9ea1064112ab54b4c65cfc619a931a20904f712d2896547a1

data/lib/nats/io/client.rb

@@ -75,6 +75,10 @@ module NATS
 
     # When the client is attempting to connect to a NATS Server for the first time.
     CONNECTING = 4
+
+    # When the client is draining a connection before closing.
+    DRAINING_SUBS = 5
+    DRAINING_PUBS = 6
   end
 
   # Client creates a connection to the NATS Server.
@@ -182,6 +186,14 @@ module NATS
       @user_nkey_cb = nil
       @user_jwt_cb = nil
       @signature_cb = nil
+
+      # Tokens
+      @auth_token = nil
+
+      @inbox_prefix = "_INBOX"
+
+      # Draining
+      @drain_t = nil
     end
 
     # Establishes a connection to NATS.
@@ -229,6 +241,7 @@ module NATS
       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?
       opts[:connect_timeout] ||= NATS::IO::DEFAULT_CONNECT_TIMEOUT
+      opts[:drain_timeout] ||= NATS::IO::DEFAULT_DRAIN_TIMEOUT
       @options = opts
 
       # Process servers in the NATS cluster and pick one to connect
@@ -254,13 +267,24 @@ module NATS
       end
 
       # NKEYS
+      @signature_cb ||= opts[:user_signature_cb]
+      @user_jwt_cb ||= opts[:user_jwt_cb]
+      @user_nkey_cb ||= opts[:user_nkey_cb]
       @user_credentials ||= opts[:user_credentials]
       @nkeys_seed ||= opts[:nkeys_seed]
+
       setup_nkeys_connect if @user_credentials or @nkeys_seed
 
+      # Tokens, if set will take preference over the user@server uri token
+      @auth_token ||= opts[:auth_token]
+
       # Check for TLS usage
       @tls = @options[:tls]
 
+      @inbox_prefix = opts.fetch(:custom_inbox_prefix, @inbox_prefix)
+
+      validate_settings!
+
       srv = nil
       begin
         srv = select_next_server
@@ -387,6 +411,8 @@ module NATS
     # Create subscription which is dispatched asynchronously
     # messages to a callback.
     def subscribe(subject, opts={}, &callback)
+      raise NATS::IO::ConnectionDrainingError.new("nats: connection draining") if draining?
+
       sid = nil
       sub = nil
       synchronize do
@@ -640,7 +666,7 @@ module NATS
     end
 
     # Send a ping and wait for a pong back within a timeout.
-    def flush(timeout=60)
+    def flush(timeout=10)
       # Schedule sending a PING, and block until we receive PONG back,
       # or raise a timeout in case the response is past the deadline.
       pong = @pongs.new_cond
@@ -674,7 +700,7 @@ module NATS
     # new_inbox returns a unique inbox used for subscriptions.
     # @return [String]
     def new_inbox
-      "_INBOX.#{@nuid.next}"
+      "#{@inbox_prefix}.#{@nuid.next}"
     end
 
     def connected_server
@@ -697,6 +723,19 @@ module NATS
       @status == CLOSED
     end
 
+    def draining?
+      if @status == DRAINING_PUBS or @status == DRAINING_SUBS
+        return true
+      end
+
+      is_draining = false
+      synchronize do
+        is_draining = true if @drain_t
+      end
+
+      is_draining
+    end
+
     def on_error(&callback)
       @err_cb = callback
     end
@@ -719,6 +758,19 @@ module NATS
       end
     end
 
+    # drain will put a connection into a drain state. All subscriptions will
+    # immediately be put into a drain state. Upon completion, the publishers
+    # will be drained and can not publish any additional messages. Upon draining
+    # of the publishers, the connection will be closed. Use the `on_close`
+    # callback option to know when the connection has moved from draining to closed.
+    def drain
+      return if draining?
+
+      synchronize do
+        @drain_t ||= Thread.new { do_drain }
+      end
+    end
+
     # Create a JetStream context.
     # @param opts [Hash] Options to customize the JetStream context.
     # @option params [String] :prefix JetStream API prefix to use for the requests.
@@ -733,6 +785,13 @@ module NATS
 
     private
 
+    def validate_settings!
+      raise(NATS::IO::ClientError, "custom inbox may not include '>'") if @inbox_prefix.include?(">")
+      raise(NATS::IO::ClientError, "custom inbox may not include '*'") if @inbox_prefix.include?("*")
+      raise(NATS::IO::ClientError, "custom inbox may not end in '.'") if @inbox_prefix.end_with?(".")
+      raise(NATS::IO::ClientError, "custom inbox may not begin with '.'") if @inbox_prefix.start_with?(".")
+    end
+
     def process_info(line)
       parsed_info = JSON.parse(line)
 
@@ -995,6 +1054,83 @@ module NATS
       end
     end
 
+    def drain_sub(sub)
+      sid = nil
+      closed = nil
+      sub.synchronize do
+        sid = sub.sid
+        closed = sub.closed
+      end
+      return if closed
+
+      send_command("UNSUB #{sid}#{CR_LF}")
+      @flush_queue << :drain
+
+      synchronize { sub = @subs[sid] }
+      return unless sub
+    end
+
+    def do_drain
+      synchronize { @status = DRAINING_SUBS }
+
+      # Do unsubscribe protocol for all the susbcriptions, then have a single thread
+      # waiting until all subs are done or drain timeout error reported to async error cb.
+      subs = []
+      @subs.each do |_, sub|
+        next if sub == @resp_sub
+        drain_sub(sub)
+        subs << sub
+      end
+      force_flush!
+
+      # Wait until all subs have no pending messages.
+      drain_timeout = MonotonicTime::now + @options[:drain_timeout]
+      to_delete = []
+
+      loop do
+        break if MonotonicTime::now > drain_timeout
+        sleep 0.1
+
+        # Wait until all subs are done.
+        @subs.each do |_, sub|
+          if sub != @resp_sub and sub.pending_queue.size == 0
+            to_delete << sub
+          end
+        end
+        next if to_delete.empty?
+
+        to_delete.each do |sub|
+          @subs.delete(sub.sid)
+          # Stop messages delivery thread for async subscribers
+          if sub.wait_for_msgs_t && sub.wait_for_msgs_t.alive?
+            sub.wait_for_msgs_t.exit
+            sub.pending_queue.clear
+          end
+        end
+        to_delete.clear
+
+        # Wait until only the resp mux is remaining or there are no subscriptions.
+        if @subs.count == 1
+          sid, sub = @subs.first
+          if sub == @resp_sub
+            break
+          end
+        elsif @subs.count == 0
+          break
+        end
+      end
+
+      if MonotonicTime::now > drain_timeout
+        e = NATS::IO::DrainTimeoutError.new("nats: draining connection timed out")
+        err_cb_call(self, e, nil) if @err_cb
+      end
+      synchronize { @status = DRAINING_PUBS }
+
+      # Remove resp mux handler in case there is one.
+      unsubscribe(@resp_sub) if @resp_sub
+      close
+    end
+
     def send_flush_queue(s)
       @flush_queue << s
     end
@@ -1037,16 +1173,18 @@ module NATS
         else
           cs[:auth_token] = @uri.user
         end
-      when @user_credentials
+      when @user_jwt_cb && @signature_cb
         nonce = @server_info[:nonce]
         cs[:jwt] = @user_jwt_cb.call
         cs[:sig] = @signature_cb.call(nonce)
-      when @nkeys_seed
+      when @user_nkey_cb && @signature_cb
         nonce = @server_info[:nonce]
         cs[:nkey] = @user_nkey_cb.call
         cs[:sig] = @signature_cb.call(nonce)
       end
 
+      cs[:auth_token] = @auth_token if @auth_token
+
       if @server_info[:headers]
         cs[:headers] = @server_info[:headers]
         cs[:no_responders] = if @options[:no_responders] == false
@@ -1150,22 +1288,7 @@ module NATS
         # Skip in case nothing remains pending already.
         next if @pending_queue.empty?
 
-        # FIXME: should limit how many commands to take at once
-        # since producers could be adding as many as possible
-        # until reaching the max pending queue size.
-        cmds = []
-        cmds << @pending_queue.pop until @pending_queue.empty?
-        begin
-          @io.write(cmds.join) unless cmds.empty?
-        rescue => e
-          synchronize do
-            @last_err = e
-            err_cb_call(self, e, nil) if @err_cb
-          end
-
-          process_op_error(e)
-          return
-        end if @io
+        force_flush!
 
         synchronize do
           @pending_size = 0
@@ -1173,6 +1296,25 @@ module NATS
       end
     end
 
+    def force_flush!
+      # FIXME: should limit how many commands to take at once
+      # since producers could be adding as many as possible
+      # until reaching the max pending queue size.
+      cmds = []
+      cmds << @pending_queue.pop until @pending_queue.empty?
+      begin
+        @io.write(cmds.join) unless cmds.empty?
+      rescue => e
+        synchronize do
+          @last_err = e
+          err_cb_call(self, e, nil) if @err_cb
+        end
+
+        process_op_error(e)
+        return
+      end if @io
+    end
+
     def ping_interval_loop
       loop do
         sleep @options[:ping_interval]
@@ -1446,7 +1588,7 @@ module NATS
     # 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_sub_prefix = new_inbox
       @resp_map = Hash.new { |h,k| h[k] = { }}
 
       @resp_sub = Subscription.new
@@ -1529,72 +1671,90 @@ module NATS
 
       case
       when @nkeys_seed
-        @user_nkey_cb = proc {
-          seed = File.read(@nkeys_seed).chomp
-          kp = NKEYS::from_seed(seed)
+        @user_nkey_cb = nkey_cb_for_nkey_file(@nkeys_seed)
+        @signature_cb = signature_cb_for_nkey_file(@nkeys_seed)
+      when @user_credentials
+        # When the credentials are within a single decorated file.
+        @user_jwt_cb = jwt_cb_for_creds_file(@user_credentials)
+        @signature_cb = signature_cb_for_creds_file(@user_credentials)
+      end
+    end
 
-          # Take a copy since original will be gone with the wipe.
-          pub_key = kp.public_key.dup
-          kp.wipe!
+    def signature_cb_for_nkey_file(nkey)
+      proc { |nonce|
+        seed = File.read(nkey).chomp
+        kp = NKEYS::from_seed(seed)
+        raw_signed = kp.sign(nonce)
+        kp.wipe!
+        encoded = Base64.urlsafe_encode64(raw_signed)
+        encoded.gsub('=', '')
+      }
+    end
 
-          pub_key
-        }
+    def nkey_cb_for_nkey_file(nkey)
+      proc {
+        seed = File.read(nkey).chomp
+        kp = NKEYS::from_seed(seed)
 
-        @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
+        # Take a copy since original will be gone with the wipe.
+        pub_key = kp.public_key.dup
+        kp.wipe!
+
+        pub_key
+      }
+    end
+
+    def jwt_cb_for_creds_file(creds)
+      proc {
+        jwt_start = "BEGIN NATS USER JWT".freeze
+        found = false
+        jwt = nil
+
+        File.readlines(creds).each do |line|
+          case
+          when found
+            jwt = line.chomp
+            break
+          when line.include?(jwt_start)
+            found = true
           end
-          raise(Error, "No JWT found in #{@user_credentials}") if not found
+        end
 
-          jwt
-        }
+        raise(Error, "No JWT found in #{creds}") if not found
 
-        @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
+        jwt
+      }
+    end
+
+    def signature_cb_for_creds_file(creds)
+      proc { |nonce|
+        seed_start = "BEGIN USER NKEY SEED".freeze
+        found = false
+        seed = nil
+
+        File.readlines(creds).each do |line|
+          case
+          when found
+            seed = line.chomp
+            break
+          when line.include?(seed_start)
+            found = true
           end
-          raise(Error, "No nkey user seed found in #{@user_credentials}") if not found
+        end
 
-          kp = NKEYS::from_seed(seed)
-          raw_signed = kp.sign(nonce)
+        raise(Error, "No nkey user seed found in #{creds}") if not found
 
-          # 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)
+        kp = NKEYS::from_seed(seed)
+        raw_signed = kp.sign(nonce)
 
-          # Remove padding
-          encoded.gsub('=', '')
-        }
-      end
+        # 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
 
     def process_uri(uris)
@@ -1655,6 +1815,7 @@ module NATS
     # Default IO timeouts
     DEFAULT_CONNECT_TIMEOUT = 2
     DEFAULT_READ_WRITE_TIMEOUT = 2
+    DEFAULT_DRAIN_TIMEOUT = 30
 
     # Default Pending Limits
     DEFAULT_SUB_PENDING_MSGS_LIMIT  = 65536

data/lib/nats/io/errors.rb

@@ -52,6 +52,12 @@ module NATS
 
     # When a subscription hits the pending messages limit.
     class SlowConsumer < Error; end
+
+    # When an action cannot be done because client is draining.
+    class ConnectionDrainingError < Error; end
+
+    # When drain takes too long to complete.
+    class DrainTimeoutError < Error; end
   end
 
   # Timeout is raised when the client gives up waiting for a response from a service.

data/lib/nats/io/js.rb

@@ -14,7 +14,9 @@
 require_relative 'msg'
 require_relative 'client'
 require_relative 'errors'
+require_relative 'kv'
 require 'time'
+require 'base64'
 
 module NATS
 
@@ -49,6 +51,7 @@ module NATS
 
       # Include JetStream::Manager
       extend Manager
+      extend KeyValue::Manager
     end
 
     # PubAck is the API response from a successfully published message.
@@ -96,6 +99,119 @@ module NATS
       PubAck.new(result)
     end
 
+    # subscribe binds or creates a push subscription to a JetStream pull consumer.
+    #
+    # @param subject [String] Subject from which the messages will be fetched.
+    # @param params [Hash] Options to customize the PushSubscription.
+    # @option params [String] :stream Name of the Stream to which the consumer belongs.
+    # @option params [String] :consumer Name of the Consumer to which the PushSubscription will be bound.
+    # @option params [String] :durable Consumer durable name from where the messages will be fetched.
+    # @option params [Hash] :config Configuration for the consumer.
+    # @return [NATS::JetStream::PushSubscription]
+    def subscribe(subject, params={}, &cb)
+      params[:consumer] ||= params[:durable]
+      stream = params[:stream].nil? ? find_stream_name_by_subject(subject) : params[:stream]
+
+      queue = params[:queue]
+      durable = params[:durable]
+      flow_control = params[:flow_control]
+      manual_ack = params[:manual_ack]
+      idle_heartbeat = params[:idle_heartbeat]
+      flow_control = params[:flow_control]
+
+      if queue
+        if durable and durable != queue
+          raise NATS::JetStream::Error.new("nats: cannot create queue subscription '#{queue}' to consumer '#{durable}'")
+        else
+          durable = queue
+        end
+      end
+
+      cinfo = nil
+      consumer_found = false
+      should_create = false
+
+      if not durable
+        should_create = true
+      else
+        begin
+          cinfo = consumer_info(stream, durable)
+          config = cinfo.config
+          consumer_found = true
+          consumer = durable
+        rescue NATS::JetStream::Error::NotFound
+          should_create = true
+          consumer_found = false
+        end
+      end
+
+      if consumer_found
+        if not config.deliver_group
+          if queue
+            raise NATS::JetStream::Error.new("nats: cannot create a queue subscription for a consumer without a deliver group")
+          elsif cinfo.push_bound
+            raise NATS::JetStream::Error.new("nats: consumer is already bound to a subscription")
+          end
+        else
+          if not queue
+            raise NATS::JetStream::Error.new("nats: cannot create a subscription for a consumer with a deliver group #{config.deliver_group}")
+          elsif queue != config.deliver_group
+            raise NATS::JetStream::Error.new("nats: cannot create a queue subscription #{queue} for a consumer with a deliver group #{config.deliver_group}")
+          end
+        end
+      elsif should_create
+        # Auto-create consumer if none found.
+        if config.nil?
+          # Defaults
+          config = JetStream::API::ConsumerConfig.new({ack_policy: "explicit"})
+        elsif config.is_a?(Hash)
+          config = JetStream::API::ConsumerConfig.new(config)
+        elsif !config.is_a?(JetStream::API::ConsumerConfig)
+          raise NATS::JetStream::Error.new("nats: invalid ConsumerConfig")
+        end
+
+        config.durable_name = durable if not config.durable_name
+        config.deliver_group = queue if not config.deliver_group
+
+        # Create inbox for push consumer.
+        deliver = @nc.new_inbox
+        config.deliver_subject = deliver
+
+        # Auto created consumers use the filter subject.
+        config.filter_subject = subject
+
+        # Heartbeats / FlowControl
+        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
+          config.idle_heartbeat = idle_heartbeat
+        end
+
+        # Auto create the consumer.
+        cinfo = add_consumer(stream, config)
+        consumer = cinfo.name
+      end
+
+      # Enable auto acking for async callbacks unless disabled.
+      if cb and not manual_ack
+        ocb = cb
+        new_cb = proc do |msg|
+          ocb.call(msg)
+          msg.ack rescue JetStream::Error::MsgAlreadyAckd
+        end
+        cb = new_cb
+      end
+      sub = @nc.subscribe(config.deliver_subject, queue: config.deliver_group, &cb)
+      sub.extend(PushSubscription)
+      sub.jsi = JS::Sub.new(
+        js: self,
+        stream: stream,
+        consumer: consumer,
+      )
+      sub
+    end
+
     # pull_subscribe binds or creates a subscription to a JetStream pull consumer.
     #
     # @param subject [String] Subject from which the messages will be fetched.
@@ -103,6 +219,7 @@ module NATS
     # @param params [Hash] Options to customize the PullSubscription.
     # @option params [String] :stream Name of the Stream to which the consumer belongs.
     # @option params [String] :consumer Name of the Consumer to which the PullSubscription will be bound.
+    # @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?
@@ -277,6 +394,14 @@ 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}
+        data = req.to_json
+        resp = api_request(req_subject, data)
+        JetStream::API::RawStreamMsg.new(resp[:message])
+      end
+
       private
 
       def api_request(req_subject, req="", params={})
@@ -293,6 +418,31 @@ module NATS
       end
     end
 
+    # PushSubscription is included into NATS::Subscription so that it
+    #
+    # @example Create a push subscription using JetStream context.
+    #
+    #   require 'nats/client'
+    #
+    #   nc = NATS.connect
+    #   js = nc.jetstream
+    #   sub = js.subscribe("foo", "bar")
+    #   msg = sub.next_msg
+    #   msg.ack
+    #   sub.unsubscribe
+    #
+    # @!visibility public
+    module PushSubscription
+      # consumer_info retrieves the current status of the pull subscription consumer.
+      # @param params [Hash] Options to customize API request.
+      # @option params [Float] :timeout Time to wait for response.
+      # @return [JetStream::API::ConsumerInfo] The latest ConsumerInfo of the consumer.
+      def consumer_info(params={})
+        @jsi.js.consumer_info(@jsi.stream, @jsi.consumer, params)
+      end
+    end
+    private_constant :PushSubscription
+
     # PullSubscription is included into NATS::Subscription so that it
     # can be used to fetch messages from a pull based consumer from
     # JetStream.
@@ -617,7 +767,11 @@ module NATS
         private
 
         def ensure_is_acked_once!
-          @sub.synchronize { raise JetStream::Error::InvalidJSAck.new("nats: invalid ack") if @ackd }
+          @sub.synchronize do
+            if @ackd
+              raise JetStream::Error::MsgAlreadyAckd.new("nats: message was already acknowledged: #{self}")
+            end
+          end
         end
 
         def parse_metadata(reply)
@@ -771,9 +925,12 @@ module NATS
       # When an invalid durable or consumer name was attempted to be used.
       class InvalidDurableName < Error; end
 
-      # When an ack is no longer valid, for example when it has been acked already.
+      # When an ack not longer valid.
       class InvalidJSAck < Error; end
 
+      # When an ack has already been acked.
+      class MsgAlreadyAckd < Error; end
+
       # When the delivered message does not behave as a message delivered by JetStream,
       # for example when the ack reply has unrecognizable fields.
       class NotJSMessage < Error; end
@@ -1085,6 +1242,33 @@ module NATS
           freeze
         end
       end
+
+      RawStreamMsg = Struct.new(:subject, :seq, :data, :headers, keyword_init: true) do
+        def initialize(opts)
+          opts[:data] = Base64.decode64(opts[:data]) if opts[:data]
+          if opts[:hdrs]
+            header = Base64.decode64(opts[:hdrs])
+            hdr = {}
+            lines = header.lines
+            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
+            opts[:headers] = hdr
+          end
+
+          # Filter out members not present.
+          rem = opts.keys - members
+          opts.delete_if { |k| rem.include?(k) }
+          super(opts)
+        end
+
+        def sequence
+          self.seq
+        end
+      end
     end
   end
 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.0.0-alpha".freeze
+    VERSION = "2.0.0-rc1".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.0.0.pre.alpha
+  version: 2.0.0.pre.rc1
 platform: ruby
 authors:
 - Waldemar Quevedo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-10-27 00:00:00.000000000 Z
+date: 2021-12-29 00:00:00.000000000 Z
 dependencies: []
 description: NATS is an open-source, high-performance, lightweight cloud messaging
   system.