nats-pure 0.7.2 → 2.4.0

data/lib/nats/io/websocket.rb

@@ -0,0 +1,75 @@
+begin
+  require 'websocket'
+rescue LoadError
+  raise LoadError, "Please add `websocket` gem to your Gemfile to connect to NATS via WebSocket."
+end
+
+module NATS
+  module IO
+    # WebSocket to connect to NATS via WebSocket and automatically decode and encode frames.
+
+    # @see https://docs.nats.io/running-a-nats-service/configuration/websocket
+
+    class WebSocket < Socket
+      class HandshakeError < RuntimeError; end
+
+      attr_accessor :socket
+
+      def initialize(options={})
+        super
+      end
+
+      def connect
+        super
+
+        setup_tls! if @uri.scheme == "wss" # WebSocket connection must be made over TLS from the beginning
+
+        @handshake = ::WebSocket::Handshake::Client.new url: @uri.to_s
+        @frame = ::WebSocket::Frame::Incoming::Client.new
+        @handshaked = false
+
+        @socket.write @handshake.to_s
+
+        until @handshaked
+          @handshake << method(:read).super_method.call(MAX_SOCKET_READ_BYTES)
+          if @handshake.finished?
+            @handshaked = true
+          end
+        end
+      end
+
+      def setup_tls!
+        return if @socket.is_a? OpenSSL::SSL::SSLSocket
+
+        super
+      end
+
+      def read(max_bytes=MAX_SOCKET_READ_BYTES, deadline=nil)
+        data = super
+        @frame << data
+        result = []
+        while msg = @frame.next
+          result << msg
+        end
+        result.join
+      end
+
+      def read_line(deadline=nil)
+        data = super
+        @frame << data
+        result = []
+        while msg = @frame.next
+          result << msg
+        end
+        result.join
+      end
+
+      def write(data, deadline=nil)
+        raise HandshakeError, "Attempted to write to socket while WebSocket handshake is in progress" unless @handshaked
+
+        frame = ::WebSocket::Frame::Outgoing::Client.new(data: data, type: :binary, version: @handshake.version)
+        super frame.to_s
+      end
+    end
+  end
+end

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)

data/lib/nats.rb

@@ -0,0 +1,39 @@
+# 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 'nats/io/client'
+require 'nats/nuid'
+
+# A thread safe Ruby client for the NATS messaging system (https://nats.io).
+#
+# @example Service example
+#   nc = NATS.connect("demo.nats.io")
+#   nc.subscribe("foo") do |msg|
+#     msg.respond("Hello World")
+#   end
+#
+#   resp = nc.request("foo")
+#   puts "Received: #{msg.data}"
+# 
+# 
+# @example Stream example
+#   nc = NATS.connect("demo.nats.io")
+#   sub = nc.subscribe("foo")
+# 
+#   nc.publish("foo")
+#   msg = sub.next_msg
+#   puts "Received: #{msg.data}"
+# 
+module NATS
+end

data/sig/nats/io/client.rbs

@@ -0,0 +1,304 @@
+module NATS
+  # class << self
+  def self.connect: (String?, Hash[Symbol, untyped]) -> NATS::Client
+  # end class << self
+
+  module Status
+    DISCONNECTED: Integer
+    CONNECTED: Integer
+    CLOSED: Integer
+    RECONNECTING: Integer
+    CONNECTING: Integer
+    DRAINING_SUBS: Integer
+    DRAINING_PUBS: Integer
+  end
+
+  class Client
+    include MonitorMixin
+    include Status
+
+    attr_reader status: Integer
+    attr_reader server_info: Hash[Symbol, untyped]
+    attr_reader server_pool: Array[untyped]
+    attr_reader options: Hash[Symbol, untyped]?
+    attr_reader connected_server: String?
+    attr_reader stats: Hash[Symbol, Integer]
+    attr_reader uri: String?
+    attr_reader subscription_executor: Concurrent::ThreadPoolExecutor?
+    attr_reader reloader: Proc
+
+    DEFAULT_PORT: Hash[Symbol, Integer]
+    DEFAULT_URI: String
+
+    CR_LF: '\r\n'
+    CR_LF_SIZE: Integer
+
+    PING_REQUEST: String
+    PONG_RESPONSE: String
+
+    NATS_HDR_LINE: String
+    STATUS_MSG_LEN: 3
+    STATUS_HDR: 'Status'
+    DESC_HDR: 'Description'
+    NATS_HDR_LINE_SIZE: Integer
+
+    SUB_OP: 'SUB'
+    EMPTY_MSG: ''
+
+    INSTANCES: ObjectSpace::WeakMap
+
+    @options: Hash[Symbol, untyped]
+
+    @io: NATS::IO::Socket?
+
+    @flush_queue: Thread::SizedQueue?
+    @pending_queue: Thread::SizedQueue?
+
+    @parser: NATS::Protocol::Parser
+
+    @flusher_thread: Thread?
+    @read_loop_thread: Thread?
+    @ping_interval_thread: Thread?
+    @subscription_executor: Concurrent::ThreadPoolExecutor?
+
+    @subs: Hash[Symbol, untyped]
+    @ssid: Integer
+
+    @pings_outstanding: Integer
+    @pongs_received: Integer
+    @pongs: Array[MonitorMixin::ConditionVariable]
+
+    @pending_size: Integer
+
+    @last_err: untyped
+
+    @err_cb: Proc
+    @close_cp: Proc
+    @disconnect_cb: Proc
+    @reconnect_cb: Proc
+
+    @tls: bool?
+
+    @hostname: String?
+    @single_url_connect_used: bool
+
+    @connect_called: bool
+
+    @resp_sub: NATS::Subscription?
+    @resp_map: Hash[String | Symbol, untyped]?
+    @resp_sub_prefix: String?
+    @nuid: NATS::NUID
+
+    @user_credentials: String?
+    @nkeys_seed: String?
+    @user_nkey_cb: Proc?
+    @user_jwt_cb: Proc?
+    @signature_cb: Proc?
+
+    @auth_token: String?
+
+    @inbox_prefix: String
+
+    @drain_t: Thread?
+
+    @reloader: Proc
+
+    def self.default_reloader: -> Proc
+
+    def connect: ((String | Hash[Symbol, untyped])?, Hash[Symbol, untyped]) -> self
+
+    def publish: (String, String, String?, **Hash[Symbol, untyped]) -> void
+
+    def publish_msg: (NATS::Msg) -> void
+
+    def subscribe: (String, Hash[Symbol, untyped]) ?{ (?(NATS::Msg | String), ?String, ?String, ?Hash[Symbol, untyped]) -> void } -> NATS::Subscription
+
+    def request: (String, ?String, **Hash[Symbol, untyped]) ?{ (?(NATS::Msg | String), ?String, ?String, ?Hash[Symbol, untyped]) -> void } -> NATS::Msg
+
+    def request_msg: (NATS::Msg, **Hash[Symbol, untyped]) -> NATS::Msg
+
+    def old_request: (String, ?String, **Hash[Symbol, untyped]) ?{ (?(NATS::Msg | String), ?String, ?String, ?Hash[Symbol, untyped]) -> void } -> NATS::Msg
+
+    def flush: (?Integer) -> void
+
+    alias servers server_pool
+
+    def discovered_servers: () -> Array[String]
+
+    def close: () -> void
+
+    def new_inbox: () -> String
+
+    def connected?: () -> bool
+
+    def connecting?: () -> bool
+
+    def reconnecting?: () -> bool
+
+    def closed?: () -> bool
+
+    def draining?: () -> bool
+
+    def on_error: () { (?self, ?untyped, ?NATS::Subscription) -> void } -> void
+
+    def on_disconnect: () { (?untyped) -> void } -> void
+
+    def on_reconnect: () { () -> void } -> void
+
+    def on_close: () { () -> void } -> void
+
+    def last_error: () -> untyped
+
+    def drain: () -> void
+
+    def jetstream: (**Hash[Symbol, untyped]) -> NATS::JetStream
+    alias JetStream jetstream
+    alias jsm jetstream
+
+    private
+
+    def validate_settings!: () -> void
+
+    def process_info: (String) -> Hash[Symbol, untyped]
+
+    def process_hdr: (String) -> Hash[String, untyped]?
+
+    def process_pong: () -> void
+
+    def process_ping: () -> void
+
+    def process_err: (String) -> void
+
+    def process_msg: (String, String, String, String, String) -> void
+
+    def select_next_error: () -> untyped
+
+    def server_using_secure_connection?: () -> bool
+
+    def client_using_secure_connection?: () -> bool
+
+    def single_url_connect_used?: () -> bool
+
+    def send_command: (String) -> void
+
+    def unsubscribe: (NATS::Subscription, Integer?) -> void
+
+    def drain_sub: (NATS::Subscription) -> void
+
+    def do_drain: () -> void
+
+    def send_flush_queue: (Symbol) -> void
+
+    def delete_sid: (Symbol) -> void
+
+    def err_cb_call: (self, untyped, NATS::Subscription) -> void
+
+    def auth_connection?: () -> bool
+
+    def connect_command: () -> String
+
+    def process_op_error: (untyped) -> void
+
+    def read_loop: () -> void
+
+    def flusher_loop: () -> void
+
+    def force_flush!: () -> void
+
+    def ping_interval_loop: () -> void
+
+    def process_connect_init: () -> void
+
+    def attempt_reconnect: () -> void
+
+    def close_connection: (Integer, bool) -> void
+
+    def start_threads!: () -> void
+
+    def start_resp_mux_sub!: () -> void
+
+    def can_reuse_server?: (Hash[Symbol, untyped]) -> bool
+
+    def should_delay_connect?: () -> bool
+
+    def should_not_reconnect?: () -> bool
+
+    def should_reconnect?: () -> bool
+
+    def create_socket: () -> NATS::IO::Socket
+
+    def setup_nkeys_connect: () -> void
+
+    def signature_cb_for_nkey_file: (String) -> Proc
+
+    def nkey_cb_for_nkey_file: (String) -> Proc
+
+    def jwt_cb_for_creds_file: (String) -> Proc
+
+    def signature_cb_for_creds_file: (String) -> Proc
+
+    def process_uri: (String) -> Array[URI::Generic]
+  end
+
+  module IO
+    include Status
+
+    Client: NATS::Client
+
+    MAX_RECONNECT_ATTEMPTS: 10
+    RECONNECT_TIME_WAIT: 2
+
+    MAX_PENDING_SIZE: 32768
+
+    MAX_FLUSH_KICK_SIZE: 1024
+
+    MAX_SOCKET_READ_BYTES: 32768
+
+    DEFAULT_PING_INTERVAL: 120
+    DEFAULT_PING_MAX: 2
+
+    DEFAULT_CONNECT_TIMEOUT: 2
+    DEFAULT_READ_WRITE_TIMEOUT: 2
+    DEFAULT_DRAIN_TIMEOUT: 30
+
+    DEFAULT_SUB_PENDING_MSGS_LIMIT: 65536
+    DEFAULT_SUB_PENDING_BYTES_LIMIT: Integer
+
+    class Socket
+      attr_accessor socket: ::Socket?
+
+      @uri: URI::Generic
+      @connect_timeout: Numeric
+      @write_timeout: Numeric
+      @read_timeout: Numeric
+
+      def connect: () -> void
+
+      def read_line: (Numeric?) -> untyped
+
+      def read: (Integer, Numeric?) -> untyped
+
+      def write: (String, Numeric?) -> void
+
+      def close: () -> void
+
+      def closed?: () -> bool
+
+      private
+
+      def connect_addrinfo: (String | Integer, Integer, Numeric) -> ::Socket
+    end
+  end
+
+  NANOSECONDS: 1_000_000_000
+
+  class MonotonicTime
+    # class << self
+    def self.now: () -> Float
+
+    def self.with_nats_timeout: (Float) -> Float
+
+    def self.since: (Float) -> Float
+    # end class << self
+  end
+end

data/sig/nats/io/errors.rbs

@@ -0,0 +1,54 @@
+module NATS
+  module IO
+    class Error < StandardError
+    end
+
+    class ServerError < NATS::IO::Error
+    end
+    
+    class ClientError < NATS::IO::Error
+    end
+
+    class ConnectError < NATS::IO::Error
+    end
+
+    class AuthError < NATS::IO::ConnectError
+    end
+
+    class NoServersError < NATS::IO::ConnectError
+    end
+
+    class NoRespondersError < NATS::IO::ConnectError
+    end
+
+    class StaleConnectionError < NATS::IO::Error
+    end
+
+    class Timeout < NATS::IO::Error
+    end
+
+    class SocketTimeoutError < NATS::IO::Timeout
+    end
+
+    class BadSubject < NATS::IO::Error
+    end
+
+    class BadSubscription < NATS::IO::Error
+    end
+
+    class SlowConsumer < NATS::IO::Error
+    end
+
+    class ConnectionDrainingError < NATS::IO::Error
+    end
+
+    class DrainTimeoutError < NATS::IO::Error
+    end
+  end
+
+  class Timeout < NATS::IO::Timeout
+  end
+
+  class Error < NATS::IO::Error
+  end
+end

data/sig/nats/io/jetstream/api.rbs

@@ -0,0 +1,35 @@
+module NATS
+  class JetStream
+    module API
+      class Error < NATS::JetStream::Error::APIError
+      end
+
+      class SequenceInfo < Struct[Integer]
+      end
+
+      class ConsumerInfo < Struct[String | NATS::JetStream::API::ConsumerConfig | NATS::JetStream::API::SequenceInfo | Integer | Hash[Symbol, untyped]]
+      end
+
+      class ConsumerConfig < Struct[String | Integer]
+        def to_json: (*Hash[untyped, untyped]) -> String
+      end
+
+      class StreamConfig < Struct[String | Hash[Symbol, untyped] | NATS::JetStream::API::StreamState | bool | Integer]
+        def to_json: (*Hash[untyped, untyped]) -> String
+      end
+
+      class StreamInfo < Struct[String | Hash[Symbol, untyped]]
+      end
+
+      class StreamState < Struct[Integer]
+      end
+
+      class StreamCreateResponse < Struct[String | NATS::JetStream::API::StreamConfig | NATS::JetStream::API::StreamState | bool]
+      end
+
+      class RawStreamMsg < Struct[String | Integer | Hash[Symbol, untyped]]
+        def sequence: () -> Integer
+      end
+    end
+  end
+end

data/sig/nats/io/jetstream/errors.rbs

@@ -0,0 +1,54 @@
+module NATS
+  class JetStream
+    class Error < NATS::IO::Error
+      class NoStreamResponse < NATS::JetStream::Error
+      end
+
+      class InvalidDurableName < NATS::JetStream::Error
+      end
+
+      class InvalidJSAck < NATS::JetStream::Error
+      end
+
+      class MsgAlreadyAckd < NATS::JetStream::Error
+      end
+
+      class NotJSMessage < NATS::JetStream::Error
+      end
+
+      class InvalidStreamName < NATS::JetStream::Error
+      end
+
+      class InvalidConsumerName < NATS::JetStream::Error
+      end
+
+      class APIError < NATS::JetStream::Error
+        attr_reader code: Integer
+        attr_reader err_code: Integer
+        attr_reader description: String
+        attr_reader stream: String
+        attr_reader seq: Integer
+
+        def initialize: (Hash[Symbol, untyped]) -> void
+      end
+
+      class ServiceUnavailable < NATS::JetStream::Error::APIError
+      end
+
+      class ServerError < NATS::JetStream::Error::APIError
+      end
+
+      class NotFound < NATS::JetStream::Error::APIError
+      end
+
+      class StreamNotFound < NATS::JetStream::Error::NotFound
+      end
+
+      class ConsumerNotFound < NATS::JetStream::Error::NotFound
+      end
+
+      class BadRequest < NATS::JetStream::Error::APIError
+      end
+    end
+  end
+end

data/sig/nats/io/jetstream/js/config.rbs

@@ -0,0 +1,11 @@
+module NATS
+  class JetStream
+    module JS
+      module Config
+        AckExplicit: 'explicit'
+        AckAll: 'all'
+        AckNone: 'none'
+      end
+    end
+  end
+end

data/sig/nats/io/jetstream/js/header.rbs

@@ -0,0 +1,17 @@
+module NATS
+  class JetStream
+    module JS
+      module Header
+        Status: 'Status'
+        Desc: 'Description'
+        MsgID: 'Nats-Msg-Id'
+        ExpectedStream: 'Nats-Expected-Stream'
+        ExpectedLastSeq: 'Nats-Expected-Last-Sequence'
+        ExpectedLastSubjSeq: 'Nats-Expected-Last-Subject-Sequence'
+        ExpectedLastMsgID: 'Nats-Expected-Last-Msg-Id'
+        LastConsumerSeq: 'Nats-Last-Consumer'
+        LastStreamSeq: 'Nats-Last-Stream'
+      end
+    end
+  end
+end

data/sig/nats/io/jetstream/js/status.rbs

@@ -0,0 +1,13 @@
+module NATS
+  class JetStream
+    module JS
+      module Status
+        CtrlMsg: '100'
+        NoMsgs: '404'
+        NotFound: '404'
+        RequestTimeout: '408'
+        ServiceUnavailable: '503'
+      end
+    end
+  end
+end

data/sig/nats/io/jetstream/js/sub.rbs

@@ -0,0 +1,14 @@
+module NATS
+  class JetStream
+    module JS
+      module Sub
+        attr_reader js: NATS::JetStream
+        attr_reader stream: String
+        attr_reader consumer: String
+        attr_reader nms: String
+
+        def initialize: (Hash[Symbol, untyped]) -> void
+      end
+    end
+  end
+end

data/sig/nats/io/jetstream/js.rbs

@@ -0,0 +1,27 @@
+module NATS
+  class JetStream
+    module JS
+      DefaultAPIPrefix: '$JS.API'
+
+      # class << self
+      def self.next_req_to_json: (Hash[Symbol, untyped]) -> String
+
+      def self.is_status_msg: (NATS::Msg) -> bool
+
+      def self.check_503_error: (NATS::Msg) -> void
+
+      def self.from_msg: (NATS::Msg) -> NATS::JetStream::API::Error
+
+      def self.from_error: (Hash[Symbol, untyped]) -> (
+          NATS::JetStream::Error::ServiceUnavailable |
+          NATS::JetStream::Error::ServerError |
+          NATS::JetStream::Error::StreamNotFound |
+          NATS::JetStream::Error::ConsumerNotFound |
+          NATS::JetStream::Error::NotFound |
+          NATS::JetStream::Error::BadRequest |
+          NATS::JetStream::API::Error
+        )
+      # end class << self
+    end
+  end
+end

data/sig/nats/io/jetstream/manager.rbs

@@ -0,0 +1,33 @@
+module NATS
+  class JetStream
+    module Manager
+      def add_stream: (JetStream::API::StreamConfig, ?Hash[Symbol, untyped]) -> JetStream::API::StreamCreateResponse
+
+      def stream_info: (String, ?Hash[Symbol, untyped]) -> JetStream::API::StreamInfo
+
+      def update_stream: (JetStream::API::StreamConfig, ?Hash[Symbol, untyped]) -> JetStream::API::StreamCreateResponse
+
+      def delete_stream: (String, ?Hash[Symbol, untyped]) -> bool
+
+      def add_consumer: (String, JetStream::API::ConsumerConfig, ?Hash[Symbol, untyped]) -> JetStream::API::ConsumerInfo
+
+      def consumer_info: (String, String, ?Hash[Symbol, untyped]) -> JetStream::API::ConsumerInfo
+
+      def delete_consumer: (String, String, ?Hash[Symbol, untyped]) -> bool
+
+      def find_stream_name_by_subject: (String, ?Hash[Symbol, untyped]) -> String
+
+      def get_msg: (String, ?Hash[Symbol, untyped]) -> JetStream::API::RawStreamMsg
+
+      def get_last_msg: (String, String, ?Hash[Symbol, untyped]) -> JetStream::API::RawStreamMsg
+
+      def account_info: () -> Hash[Symbol, untyped]
+
+      private
+
+      def api_request: (String, String, ?Hash[Symbol, untyped]) -> Hash[Symbol, untyped]
+
+      def _lift_msg_to_raw_msg: (NATS::Msg) -> JetStream::API::RawStreamMsg
+    end
+  end
+end