jrpc 1.1.7 → 2.0.0

data/lib/jrpc/error/server_error.rb

@@ -1,11 +0,0 @@
-module JRPC
-  class ServerError < Error
-    attr_reader :code
-
-    def initialize(message, code)
-      @code = code
-      super(message)
-    end
-
-  end
-end

data/lib/jrpc/error/unknown_error.rb

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

data/lib/jrpc/tcp_client.rb

@@ -1,112 +0,0 @@
-require 'netstring'
-require 'logger'
-require 'benchmark'
-module JRPC
-  class TcpClient < BaseClient
-    attr_reader :namespace, :transport
-    attr_accessor :logger
-    def_delegators :@transport, :close, :closed?, :connect
-
-    MAX_LOGGED_MESSAGE_LENGTH = 255
-
-    def initialize(uri, options = {})
-      super
-      @logger = @options.delete(:logger) || Logger.new($null)
-      @namespace = @options.delete(:namespace).to_s
-
-      timeout = @options.fetch(:timeout, 5)
-      connect_timeout = @options.fetch(:connect_timeout, timeout)
-      read_timeout = @options.fetch(:read_timeout, timeout)
-      write_timeout = @options.fetch(:write_timeout, 60) # default 60
-      connect_retry_count = @options.fetch(:connect_retry_count, 10) # default 10
-      @close_after_sent = @options.fetch(:close_after_sent, false)
-
-      @transport = JRPC::Transport::SocketTcp.new server: @uri,
-                                                  connect_retry_count: connect_retry_count,
-                                                  connect_timeout: connect_timeout,
-                                                  read_timeout: read_timeout,
-                                                  write_timeout: write_timeout
-      begin
-        @transport.connect
-      rescue JRPC::Transport::SocketTcp::Error
-        raise ConnectionError, "Can't connect to #{@uri}"
-      end
-    end
-
-    private
-
-    def ensure_connected
-      if @transport.closed?
-        logger.debug { 'Connecting transport...' }
-        @transport.connect
-        logger.debug { 'Connected.' }
-      end
-    end
-
-    def send_command(request, options = {})
-      ensure_connected
-      read_timeout = options.fetch(:read_timeout)
-      write_timeout = options.fetch(:write_timeout)
-      response = nil
-      t = Benchmark.realtime do
-        logger.debug { "Request address: #{uri}" }
-        logger.debug { "Request message: #{Utils.truncate(request, MAX_LOGGED_MESSAGE_LENGTH)}" }
-        logger.debug { "Request read_timeout: #{read_timeout}" }
-        logger.debug { "Request write_timeout: #{write_timeout}" }
-        send_request(request, write_timeout)
-        response = receive_response(read_timeout)
-      end
-      logger.debug do
-        "(#{'%.2f' % (t * 1000)}ms) Response message: #{Utils.truncate(response, MAX_LOGGED_MESSAGE_LENGTH)}"
-      end
-      response
-    ensure
-      @transport.close if @close_after_sent
-    end
-
-    def send_notification(request, options = {})
-      ensure_connected
-      write_timeout = options.fetch(:write_timeout)
-      logger.debug { "Request address: #{uri}" }
-      logger.debug { "Request message: #{Utils.truncate(request, MAX_LOGGED_MESSAGE_LENGTH)}" }
-      logger.debug { "Request write_timeout: #{write_timeout}" }
-      send_request(request, write_timeout)
-      logger.debug { 'No response required' }
-    ensure
-      @transport.close if @close_after_sent
-    end
-
-    def create_message(method, params)
-      super("#{namespace}#{method}", params)
-    end
-
-    def send_request(request, timeout)
-      timeout ||= @transport.write_timeout
-      @transport.write Netstring.dump(request.to_s), timeout
-    rescue ::SocketError
-      raise ConnectionError, "Can't send request to #{uri}"
-    end
-
-    def receive_response(timeout)
-      timeout ||= @transport.read_timeout
-      length = get_msg_length(timeout)
-      response = @transport.read(length + 1, timeout)
-      raise ClientError.new('invalid response. missed comma as terminator') if response[-1] != ','
-      response.chomp(',')
-    rescue ::SocketError
-      raise ConnectionError, "Can't receive response from #{uri}"
-    end
-
-    def get_msg_length(timeout)
-      length = ''
-      while true do
-        character = @transport.read(1, timeout)
-        break if character == ':'
-        length += character
-      end
-
-      Integer(length)
-    end
-
-  end
-end

data/lib/jrpc/transport/socket_base.rb

@@ -1,88 +0,0 @@
-module JRPC
-  module Transport
-    class SocketBase
-
-      class Error < ::JRPC::Error
-      end
-
-      class TimeoutError < Error
-        def initialize
-          super(self.class.to_s.split('::').last)
-        end
-      end
-
-      class ReadTimeoutError < TimeoutError
-      end
-
-      class WriteTimeoutError < TimeoutError
-      end
-
-      class ConnectionTimeoutError < TimeoutError
-      end
-
-      class ConnectionFailedError < Error
-      end
-
-      class WriteFailedError < Error
-      end
-
-      class ReadFailedError < Error
-      end
-
-      attr_reader :options, :read_timeout, :write_timeout
-
-      def self.connect(options)
-        connection = new(options)
-        yield(connection)
-      ensure
-        connection.close if connection
-      end
-
-      def initialize(options)
-        @server = options.fetch(:server)
-        @read_timeout = options.fetch(:read_timeout, nil)
-        @write_timeout = options.fetch(:write_timeout, nil)
-        @connect_timeout = options.fetch(:connect_timeout, nil)
-        @connect_retry_count = options.fetch(:connect_retry_count, 0)
-        @options = options
-      end
-
-      def connect
-        retries = @connect_retry_count
-
-        while retries >= 0
-          begin
-            connect_socket
-            break
-          rescue Error => e
-            retries -= 1
-            raise e if retries < 0
-          end
-        end
-      end
-
-      def read(_length, _timeout = @read_timeout)
-        raise NotImplementedError
-      end
-
-      def write(_data, _timeout = @write_timeout)
-        raise NotImplementedError
-      end
-
-      def close
-        raise NotImplementedError
-      end
-
-      def closed?
-        raise NotImplementedError
-      end
-
-      private
-
-      def connect_socket
-        raise NotImplementedError
-      end
-
-    end
-  end
-end

data/lib/jrpc/transport/socket_tcp.rb

@@ -1,98 +0,0 @@
-module JRPC
-  module Transport
-    class SocketTcp < SocketBase
-
-      def read(length, timeout = @read_timeout)
-        received = ''
-        length_to_read = length
-        while length_to_read > 0
-          io_read, = IO.select([socket], [], [], timeout)
-          raise ReadTimeoutError unless io_read
-          chunk = io_read[0].read_nonblock(length_to_read)
-          received += chunk
-          length_to_read -= chunk.bytesize
-        end
-        received
-      rescue Errno::EPIPE, EOFError => e
-        # EPIPE, in this case, means that the data connection was unexpectedly terminated.
-        clear_socket!
-        raise ReadFailedError, "#{e.class} #{e.message}"
-      end
-
-      def write(data, timeout = @write_timeout)
-        length_written = 0
-        data_to_write = data
-        while data_to_write.bytesize > 0
-          _, io_write, = IO.select([], [socket], [], timeout)
-          raise WriteTimeoutError unless io_write
-          chunk_length = io_write[0].write_nonblock(data_to_write)
-          length_written += chunk_length
-          data_to_write = data.byteslice(length_written, data.length)
-        end
-        length_written
-      rescue Errno::EPIPE => e
-        # EPIPE, in this case, means that the data connection was unexpectedly terminated.
-        clear_socket!
-        raise WriteFailedError, "#{e.class} #{e.message}"
-      end
-
-      def close
-        return if @socket.nil?
-        socket.close
-      end
-
-      def closed?
-        @socket.nil? || socket.closed?
-      end
-
-      def socket
-        @socket ||= build_socket
-      end
-
-      private
-
-      def clear_socket!
-        return if @socket.nil?
-        @socket.close unless @socket.closed?
-        @socket = nil
-      end
-
-      def set_timeout_to(socket, type, value)
-        secs = Integer(value)
-        u_secs = Integer((value - secs) * 1_000_000)
-        opt_val = [secs, u_secs].pack('l_2')
-        socket.setsockopt Socket::SOL_SOCKET, type, opt_val
-      end
-
-      def build_socket
-        host = @server.split(':').first
-        addr = Socket.getaddrinfo(host, nil)
-        Socket.new(Socket.const_get(addr[0][0]), Socket::SOCK_STREAM, 0)
-      end
-
-      def connect_socket
-        host, port = @server.split(':')
-        addr = Socket.getaddrinfo(host, nil)
-        full_addr = Socket.pack_sockaddr_in(port, addr[0][3])
-
-        begin
-          socket.connect_nonblock(full_addr)
-        rescue IO::WaitWritable => _
-          if IO.select(nil, [socket], nil, @connect_timeout)
-            socket.connect_nonblock(full_addr)
-          else
-            clear_socket!
-            raise ConnectionFailedError, "Can't connect during #{@connect_timeout}"
-          end
-        end
-
-      rescue Errno::EISCONN => _
-        # already connected
-      rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ETIMEDOUT, Errno::EPIPE => e
-        clear_socket!
-        raise ConnectionFailedError, "#{e.class} #{e.message}"
-      end
-
-    end
-  end
-end

data/lib/jrpc/utils.rb

@@ -1,9 +0,0 @@
-module JRPC
-  class Utils
-
-    def self.truncate(string, length, ommiter = '...')
-      "#{string[0..length]}#{ommiter if string.length > length}"
-    end
-
-  end
-end