jrpc 1.1.7 → 2.0.0

data/lib/jrpc/transport/tcp.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+require 'socket'
+
+module JRPC
+  module Transport
+    class Tcp < Base
+      # Pull error classes into this scope so `raise ConnectionError` resolves correctly.
+      # Without this, Ruby's constant lookup would find JRPC::ConnectionError (v1) instead.
+      ConnectionError = Base::ConnectionError
+      Timeout = Base::Timeout
+      MalformedFrame = Base::MalformedFrame
+
+      def initialize(server, **options)
+        super
+        @socket = nil
+        @read_buffer = ''.b
+      end
+
+      def connect
+        deadline = @connect_timeout ? monotonic_now + @connect_timeout : nil
+        attempts_remaining = @connect_retry_count + 1
+        begin
+          connect_once(deadline)
+        rescue ConnectionError, Timeout
+          attempts_remaining -= 1
+          raise if attempts_remaining <= 0
+          raise if deadline && remaining_time(deadline) <= 0 # total budget spent
+
+          sleep @connect_retry_interval
+          retry
+        end
+      end
+
+      def write_frame(bytes, timeout:)
+        raise ConnectionError, 'transport closed' if @socket.nil?
+
+        frame = "#{bytes.bytesize}:#{bytes},"
+        written = 0
+        deadline = timeout ? monotonic_now + timeout : nil
+
+        while written < frame.bytesize
+          remaining = remaining_time(deadline)
+          close_and_raise_timeout!('write') if remaining && remaining <= 0
+
+          writable = @socket.wait_writable(remaining)
+          close_and_raise_timeout!('write') unless writable
+
+          begin
+            n = @socket.write_nonblock(frame.byteslice(written..))
+            written += n
+          rescue IO::WaitWritable
+            # socket not ready yet; loop back to IO.select. Rescue the module (not the
+            # concrete IO::EAGAINWaitWritable) so IO::EWOULDBLOCKWaitWritable is also
+            # caught on platforms where EAGAIN != EWOULDBLOCK (macOS/BSD).
+          rescue Errno::EPIPE, Errno::ECONNRESET, IOError => e
+            close
+            raise ConnectionError, "write failed: #{e.class}: #{e.message}"
+          end
+        end
+      end
+
+      def read_frame(timeout:)
+        raise ConnectionError, 'transport closed' if @socket.nil?
+
+        deadline = timeout ? monotonic_now + timeout : nil
+
+        loop do
+          result = try_parse_frame
+          return result unless result == :wait
+
+          remaining = remaining_time(deadline)
+          close_and_raise_timeout!('read') if remaining && remaining <= 0
+
+          readable = @socket.wait_readable(remaining)
+          close_and_raise_timeout!('read') unless readable
+
+          fill_buffer
+        end
+      end
+
+      def try_read_frame
+        raise ConnectionError, 'transport closed' if @socket.nil?
+
+        # Parse first so already-buffered frames survive an EOF on the next read.
+        result = try_parse_frame
+        return result unless result == :wait
+
+        # fill_buffer swallows EAGAIN (no data yet); the re-parse then returns :wait.
+        fill_buffer
+        try_parse_frame
+      end
+
+      def close
+        begin
+          @socket&.close
+        rescue StandardError
+          nil
+        end
+        @socket = nil
+        @read_buffer = ''.b
+      end
+
+      def closed?
+        @socket.nil? || @socket.closed?
+      end
+
+      attr_reader :socket
+
+      private
+
+      # Attempt a single TCP connect.  All errors are normalised to ConnectionError or Timeout.
+      def connect_once(deadline)
+        # Close any existing socket first so connecting on an already-connected
+        # transport replaces it cleanly instead of orphaning the old file descriptor.
+        begin
+          @socket&.close
+        rescue StandardError
+          nil
+        end
+        @socket = nil
+
+        sock, sockaddr = build_socket
+
+        loop do
+          break if try_connect_nonblock(sock, sockaddr, deadline)
+        end
+
+        @socket = sock
+        @read_buffer = ''.b
+      end
+
+      def fill_buffer
+        chunk = @socket.read_nonblock(65_536)
+        @read_buffer << chunk.b
+      rescue IO::WaitReadable
+        # no data right now; caller already confirmed readable via IO.select
+      rescue Errno::ECONNRESET, Errno::EPIPE, IOError => e
+        close
+        raise ConnectionError, "read failed: #{e.class}: #{e.message}"
+      end
+
+      def build_socket
+        host, port_str = @server.split(':', 2)
+        addr_info = ::Socket.getaddrinfo(host, nil, nil, ::Socket::SOCK_STREAM)
+        family = ::Socket.const_get(addr_info[0][0])
+        sockaddr = ::Socket.pack_sockaddr_in(port_str.to_i, addr_info[0][3])
+        sock = ::Socket.new(family, ::Socket::SOCK_STREAM, 0)
+        [sock, sockaddr]
+      rescue StandardError => e
+        raise ConnectionError, "#{e.class}: #{e.message}"
+      end
+
+      def try_connect_nonblock(sock, sockaddr, deadline)
+        sock.connect_nonblock(sockaddr)
+        true # connected
+      rescue Errno::EISCONN
+        true # already connected
+      rescue IO::WaitWritable
+        writable = sock.wait_writable(connect_wait_timeout(deadline))
+        unless writable
+          begin
+            sock.close
+          rescue StandardError
+            nil
+          end
+          raise Timeout, "connect timed out to #{@server}"
+        end
+        false
+        # loop again → next connect_nonblock call will return EISCONN or error
+      rescue StandardError => e
+        begin
+          sock.close
+        rescue StandardError
+          nil
+        end
+        raise ConnectionError, "#{e.class}: #{e.message}"
+      end
+
+      # Wait passed to a single IO.select while connecting: the smaller of the per-attempt
+      # cap and the time left in the overall connect deadline. nil (block forever) only when
+      # neither bound is set.
+      def connect_wait_timeout(deadline)
+        bounds = [@connect_attempt_timeout, remaining_time(deadline)].compact
+        return nil if bounds.empty?
+
+        wait = bounds.min
+        wait.negative? ? 0 : wait
+      end
+
+      def try_parse_frame
+        return :wait if @read_buffer.empty?
+
+        colon_idx = @read_buffer.index(':'.b)
+
+        if colon_idx.nil?
+          unless @read_buffer.match?(/\A\d+\z/)
+            raise MalformedFrame, "non-digit in length prefix: #{@read_buffer.byteslice(0, 32).inspect}"
+          end
+
+          return :wait
+        end
+
+        raise MalformedFrame, 'empty length prefix' if colon_idx.zero?
+
+        length_str = @read_buffer.byteslice(0, colon_idx)
+        raise MalformedFrame, "non-digit in length prefix: #{length_str.inspect}" unless length_str.match?(/\A\d+\z/)
+        if length_str.bytesize > 1 && length_str.getbyte(0) == 48 # ord('0'): leading zero
+          raise MalformedFrame, "leading zero in length prefix: #{length_str.inspect}"
+        end
+
+        length = Integer(length_str, 10)
+        frame_end = colon_idx + 1 + length # index of the expected comma
+
+        return :wait if @read_buffer.bytesize <= frame_end
+
+        unless @read_buffer.getbyte(frame_end) == 44 # ord(',')
+          raise MalformedFrame, "missing comma terminator at position #{frame_end}"
+        end
+
+        data = @read_buffer.byteslice(colon_idx + 1, length).force_encoding(Encoding::UTF_8)
+        # The line-194 guard guarantees bytesize > frame_end, so this byteslice is never nil.
+        @read_buffer = @read_buffer.byteslice((frame_end + 1)..)
+        data
+      end
+
+      def monotonic_now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      def remaining_time(deadline)
+        return nil unless deadline
+
+        deadline - monotonic_now
+      end
+
+      def close_and_raise_timeout!(operation)
+        close
+        raise Timeout, "#{operation} timed out on #{@server}"
+      end
+    end
+  end
+end

data/lib/jrpc/transport.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'jrpc/transport/base'
+require 'jrpc/transport/tcp'
+
+module JRPC
+  module Transport
+    def self.build(server, **)
+      JRPC::Transport::Tcp.new(server, **)
+    end
+  end
+end

data/lib/jrpc/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JRPC
-  VERSION = '1.1.7'
+  VERSION = '2.0.0'
 end

data/lib/jrpc.rb

@@ -1,20 +1,19 @@
+# frozen_string_literal: true
+
+require 'socket'
+require 'json'
+require 'concurrent'
 require 'jrpc/version'
-require 'jrpc/error/error'
-require 'jrpc/utils'
-require 'jrpc/base_client'
-require 'jrpc/transport/socket_base'
-require 'jrpc/transport/socket_tcp'
-require 'jrpc/tcp_client'
-require 'jrpc/error/connection_error'
-require 'jrpc/error/client_error'
-require 'jrpc/error/server_error'
-require 'jrpc/error/internal_error'
-require 'jrpc/error/internal_server_error'
-require 'jrpc/error/invalid_params'
-require 'jrpc/error/invalid_request'
-require 'jrpc/error/method_not_found'
-require 'jrpc/error/parse_error'
-require 'jrpc/error/unknown_error'
+require 'jrpc/errors'
+require 'jrpc/id_generator'
+require 'jrpc/message'
+require 'jrpc/transport'
+require 'jrpc/simple_client'
+require 'jrpc/shared_client/ticket'
+require 'jrpc/shared_client/registry'
+require 'jrpc/shared_client/outbound_queue'
+require 'jrpc/shared_client/transport_loop'
+require 'jrpc/shared_client'
 
 module JRPC
   JSON_RPC_VERSION = '2.0'

metadata

@@ -1,123 +1,83 @@
 --- !ruby/object:Gem::Specification
 name: jrpc
 version: !ruby/object:Gem::Version
-  version: 1.1.7
+  version: 2.0.0
 platform: ruby
 authors:
 - Denis Talakevich
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-04 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: netstring
+  name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.2'
 - !ruby/object:Gem::Dependency
-  name: oj
+  name: logger
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.10'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.10'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '0'
 description: JSON RPC client over TCP
 email:
 - senid231@gmail.com
-executables: []
+executables:
+- jrpc
+- jrpc-shell
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rspec"
-- ".travis.yml"
+- ".rubocop.yml"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/console
+- bin/jrpc
+- bin/jrpc-shell
+- bin/setup
 - jrpc.gemspec
 - lib/jrpc.rb
-- lib/jrpc/base_client.rb
-- lib/jrpc/error/client_error.rb
-- lib/jrpc/error/connection_error.rb
-- lib/jrpc/error/error.rb
-- lib/jrpc/error/internal_error.rb
-- lib/jrpc/error/internal_server_error.rb
-- lib/jrpc/error/invalid_params.rb
-- lib/jrpc/error/invalid_request.rb
-- lib/jrpc/error/method_not_found.rb
-- lib/jrpc/error/parse_error.rb
-- lib/jrpc/error/server_error.rb
-- lib/jrpc/error/unknown_error.rb
-- lib/jrpc/tcp_client.rb
-- lib/jrpc/transport/socket_base.rb
-- lib/jrpc/transport/socket_tcp.rb
-- lib/jrpc/utils.rb
+- lib/jrpc/errors.rb
+- lib/jrpc/id_generator.rb
+- lib/jrpc/message.rb
+- lib/jrpc/shared_client.rb
+- lib/jrpc/shared_client/outbound_queue.rb
+- lib/jrpc/shared_client/registry.rb
+- lib/jrpc/shared_client/ticket.rb
+- lib/jrpc/shared_client/transport_loop.rb
+- lib/jrpc/simple_client.rb
+- lib/jrpc/transport.rb
+- lib/jrpc/transport/base.rb
+- lib/jrpc/transport/tcp.rb
 - lib/jrpc/version.rb
-homepage: https://github.com/senid231/jrpc
+homepage: https://github.com/didww/jrpc
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -125,15 +85,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.6.9
 specification_version: 4
 summary: JSON RPC client
 test_files: []

data/.travis.yml

@@ -1,4 +0,0 @@
-language: ruby
-rvm:
-  - 2.2.2
-before_install: gem install bundler -v 1.10.6

data/lib/jrpc/base_client.rb

@@ -1,123 +0,0 @@
-require 'oj'
-require 'forwardable'
-module JRPC
-  class BaseClient
-    extend Forwardable
-
-    attr_reader :uri, :options
-
-    ID_CHARACTERS = (('a'..'z').to_a + ('0'..'9').to_a + ('A'..'Z').to_a).freeze
-    REQUEST_TYPES = [:request, :notification].freeze
-
-    def self.connect(uri, options)
-      client = new(uri, options)
-      yield(client)
-    ensure
-      client.close if client
-    end
-
-    def initialize(uri, options)
-      @uri = uri
-      @options = options
-    end
-
-    def method_missing(method, *params)
-      invoke_request(method, *params)
-    end
-
-    def perform_request(method, params: nil, type: :request, read_timeout: nil, write_timeout: nil)
-      validate_request(params, type)
-      request = create_message(method.to_s, params)
-      if type == :request
-        id = generate_id
-        request['id'] = id
-        response = send_command serialize_request(request), read_timeout: read_timeout, write_timeout: write_timeout
-        response = deserialize_response(response)
-
-        validate_response(response, id)
-        parse_error(response['error']) if response.has_key?('error')
-
-        response['result']
-      else
-        send_notification serialize_request(request), write_timeout: write_timeout
-        nil
-      end
-    end
-
-    def invoke_request(method, *params)
-      warn '[DEPRECATION] `invoke_request` is deprecated. Please use `perform_request` instead.'
-      params = nil if params.empty?
-      perform_request(method, params: params)
-    end
-
-    def invoke_notification(method, *params)
-      warn '[DEPRECATION] `invoke_request` is deprecated. Please use `perform_request` instead.'
-      params = nil if params.empty?
-      perform_request(method, params: params, type: :notification)
-    end
-
-    private
-
-    def serialize_request(request)
-      Oj.dump(request, mode: :compat)
-    end
-
-    def deserialize_response(response)
-      Oj.load(response)
-    end
-
-    def validate_response(response, id)
-      raise ClientError, 'Wrong response structure' unless response.is_a?(Hash)
-      raise ClientError, 'Wrong version' if response['jsonrpc'] != JRPC::JSON_RPC_VERSION
-      if id != response['id']
-        raise ClientError, "ID response mismatch. expected #{id.inspect} got #{response['id'].inspect}"
-      end
-    end
-
-    def validate_request(params, type)
-      raise ClientError, 'invalid type' unless REQUEST_TYPES.include?(type)
-      raise ClientError, 'invalid params' if !params.nil? && !params.is_a?(Array) && !params.is_a?(Hash)
-    end
-
-    def parse_error(error)
-      case error['code']
-        when -32700
-          raise ParseError.new(error['message'])
-        when -32600
-          raise InvalidRequest.new(error['message'])
-        when -32601
-          raise MethodNotFound.new(error['message'])
-        when -32602
-          raise InvalidParams.new(error['message'])
-        when -32603
-          raise InternalError.new(error['message'])
-        when -32099..-32000
-          raise InternalServerError.new(error['message'], error['code'])
-        else
-          raise UnknownError.new(error['message'], error['code'])
-      end
-    end
-
-    def send_command(json, options={})
-      raise NotImplementedError
-    end
-
-    def send_notification(json, options={})
-      raise NotImplementedError
-    end
-
-    def generate_id
-      size = ID_CHARACTERS.size
-      (0...32).map { ID_CHARACTERS.to_a[rand(size)] }.join
-    end
-
-    def create_message(method, params)
-      message = {
-          'jsonrpc' => JSON_RPC_VERSION,
-          'method' => method
-      }
-      message['params'] = params unless params.nil?
-      message
-    end
-  end
-end

data/lib/jrpc/error/client_error.rb

@@ -1,5 +0,0 @@
-module JRPC
-  class ClientError < Error
-
-  end
-end

data/lib/jrpc/error/connection_error.rb

@@ -1,11 +0,0 @@
-module JRPC
-  class ConnectionError < Error
-    attr_reader :original
-
-    def initialize(msg, original=$!)
-      super(msg)
-      @original = original
-    end
-
-  end
-end

data/lib/jrpc/error/error.rb

@@ -1,5 +0,0 @@
-module JRPC
-  class Error < RuntimeError
-
-  end
-end

data/lib/jrpc/error/internal_error.rb

@@ -1,9 +0,0 @@
-module JRPC
-  class InternalError < ServerError
-
-    def initialize(message)
-      super(message, -32603)
-    end
-
-  end
-end

data/lib/jrpc/error/internal_server_error.rb

@@ -1,5 +0,0 @@
-module JRPC
-  class InternalServerError < ServerError
-
-  end
-end

data/lib/jrpc/error/invalid_params.rb

@@ -1,9 +0,0 @@
-module JRPC
-  class InvalidParams < ServerError
-
-    def initialize(message)
-      super(message, -32602)
-    end
-
-  end
-end

data/lib/jrpc/error/invalid_request.rb

@@ -1,9 +0,0 @@
-module JRPC
-  class InvalidRequest < ServerError
-
-    def initialize(message)
-      super(message, -32600)
-    end
-
-  end
-end

data/lib/jrpc/error/method_not_found.rb

@@ -1,9 +0,0 @@
-module JRPC
-  class MethodNotFound < ServerError
-
-    def initialize(message)
-      super(message, -32601)
-    end
-
-  end
-end

data/lib/jrpc/error/parse_error.rb

@@ -1,9 +0,0 @@
-module JRPC
-  class ParseError < ServerError
-
-    def initialize(message)
-      super(message, -32700)
-    end
-
-  end
-end