io_request 2.2.0 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f13666edea5cbb28ef091256048953a91693bb015d089b497dfa2657b75e2ca5
-  data.tar.gz: d05a984fe433d148c049f2156637fe7bf7ff6e19aa89f85d90f776e4337b8110
+  metadata.gz: 53fdb5fa823faf9d379e6c2180f0d47f79959caa144dd1c34295c81226a4566d
+  data.tar.gz: 8614bb17e707782adc8d13ea01d0328bac2432658d0dc91977ee728107dcfcb7
 SHA512:
-  metadata.gz: a4abe0a1f30f5760ab110f9b8ad097d4eda24548418398d0b24102d4b2fd8bb652082414c993672aa81915a939e8f07130a87eb1f137543ca87a54a1e0879ead
-  data.tar.gz: 5a541175e7b27d967c22333f700a2a08b4de10b4fa0804230a5ef90406d6be28eeaa62025e9dca32d8986dd553b846cbfd16c2cc5b66848eb81b0a0ec2a08099
+  metadata.gz: 234a5e6d21fe3b1214a719af4b52617d4f58a3cf205e17cd8fa2d045098ada47bae1a272b8ec1daadfe5909831408e754d6a84085cad3705b5e09c8d3f940ccf
+  data.tar.gz: ef33270ed7cbf3b2082f7845d1ca1bbab2b3e77a145cff65ec4de361fb9b728535b3bd7b6d63bfef28713a216daea9434a6b908459fc3d7be1002142e90e3386

data/lib/io_request.rb

@@ -1,7 +1,16 @@
 # frozen_string_literal: true
 
 # Main module.
-module IORequest; end
+module IORequest
+  # Client received message of zero size.
+  class ZeroSizeMessageError < RuntimeError; end
+
+  # Authorization failed.
+  class AuthorizationFailureError < RuntimeError; end
+
+  # Request timed out.
+  class RequestTimeoutError < RuntimeError; end
+end
 
 require_relative 'io_request/version'
 require_relative 'io_request/logging'

data/lib/io_request/client.rb

@@ -45,15 +45,17 @@ module IORequest
     # @param r [IO] object to read from.
     # @param w [IO] object to write to.
     # @param rw [IO] read-write object (replaces `r` and `w` arguments).
+    # @return [Object] data from {Authorizer}
     def open(read: nil, write: nil, read_write: nil)
       @io_r = read_write || read
       @io_w = read_write || write
 
       IORequest.logger.debug(prog_name) { 'Starting connection' }
 
-      authorization
+      auth_data = authorization
       @open = true
       @data_transition_thread = in_thread(name: 'connection') { data_transition_loop }
+      auth_data
     end
 
     def open?
@@ -63,30 +65,38 @@ module IORequest
     # Close connection.
     def close
       close_internal
+
       join_threads
-      @open = false
     end
 
     # @yieldparam [Hash]
     # @yieldreturn [Hash]
-    def respond(&block)
-      IORequest.logger.debug(prog_name) { 'Saved responder block' }
-      @responder = block
+    def on_request(&block)
+      IORequest.logger.debug(prog_name) { 'Saved on_request block' }
+      @on_request = block
+    end
+    alias respond on_request
+
+    # Code to execute after connection is closed.
+    def on_close(&block)
+      IORequest.logger.debug(prog_name) { 'Saved on_close block' }
+      @on_close = block
     end
 
     # If callback block is provided, request will be sent asynchroniously.
     # @param data [Hash]
-    def request(data = {}, &callback)
+    # @param timeout [Integer] timeout in seconds.
+    def request(data, timeout: nil, &callback)
       message = Message.new(data, type: :request)
 
       if block_given?
         # Async execution of request
         in_thread(callback, name: 'requesting') do |cb|
-          cb.call(send_request_and_wait_for_response(message).data)
+          cb.call(send_request_and_wait_for_response(message, timeout).data)
         end
         nil
       else
-        send_request_and_wait_for_response(message).data
+        send_request_and_wait_for_response(message, timeout).data
       end
     end
 
@@ -96,50 +106,52 @@ module IORequest
 
     def close_internal
       IORequest.logger.debug(prog_name) { 'Closing connection' }
-      begin
-        send_zero_size_request
-      rescue StandardError
-        IORequest.logger.debug(prog_name) { 'Failed to send zero-sized message. Closing anyway' }
-      end
-      stop_data_transition
+      send_zero_size_request
       close_io
-    end
-
-    def stop_data_transition
-      return unless defined?(@data_transition_thread) && !@data_transition_thread.nil?
-
-      IORequest.logger.debug(prog_name) { 'Killing data transition thread' }
-      @data_transition_thread.kill
       @data_transition_thread = nil
+      @open = false
+      @on_close&.call if defined?(@on_close)
     end
 
     def close_io
-      IORequest.logger.debug(prog_name) { 'Closing IO' }
-      @mutex_r.synchronize { @io_r&.close }
-      @mutex_w.synchronize { @io_w&.close }
+      begin
+        @io_r&.close
+      rescue StandardError => e
+        IORequest.logger.debug "Failed to close read IO: #{e}"
+      end
+      begin
+        @io_w&.close
+      rescue StandardError => e
+        IORequest.logger.debug "Failed to close write IO: #{e}"
+      end
+      IORequest.logger.debug(prog_name) { 'Closed IO streams' }
     end
 
     def authorization
-      auth_successful = @mutex_r.synchronize do
+      auth_successful = false
+      data = nil
+      @mutex_r.synchronize do
         @mutex_w.synchronize do
           IORequest.logger.debug(prog_name) { 'Authorizing new client' }
-          @authorizer.authorize(@io_r, @io_w)
+          auth_successful = @authorizer.authorize(@io_r, @io_w)
+          data = @authorizer.data
         end
       end
-      unless auth_successful
-        IORequest.logger.debug(prog_name) { 'Authorization failed' }
-        raise 'Authorization failed'
-      end
+      raise AuthorizationFailureError unless auth_successful
 
-      IORequest.logger.debug(prog_name) { "New client authorized with data #{@authorizer.data}" }
+      IORequest.logger.debug(prog_name) { "New client authorized with data #{data}" }
+      data
     end
 
     def data_transition_loop
       IORequest.logger.debug(prog_name) { 'Starting data transition loop' }
       loop do
         data_transition_iteration
+      rescue ZeroSizeMessageError
+        IORequest.logger.debug(prog_name) { 'Connection was closed from the other side' }
+        break
       rescue StandardError => e
-        IORequest.logger.debug(prog_name) { "Data transition iteration failed: #{e}" }
+        IORequest.logger.debug(prog_name) { "Data transition unknown error: #{e}" }
         break
       end
       close_internal
@@ -156,7 +168,8 @@ module IORequest
     end
 
     def handle_request(message)
-      data = @responder&.call(message.data) || {}
+      data = {}
+      data = @on_request&.call(message.data) if defined?(@on_request)
       response = Message.new(data, type: :response, to: message.id)
       send_response(response)
     end
@@ -171,7 +184,11 @@ module IORequest
     def send_response(response)
       @mutex_w.synchronize do
         IORequest.logger.debug(prog_name) { "Sending response: #{response}" }
-        response.write_to(@io_w)
+        begin
+          response.write_to(@io_w)
+        rescue IOError => e
+          IORequest.logger.debug(prog_name) { "Failed to write response message: #{e}" }
+        end
       end
     end
 
@@ -180,23 +197,30 @@ module IORequest
         IORequest.logger.debug(prog_name) { 'Sending zero size message' }
         @io_w.write([0].pack('S'))
       end
+    rescue StandardError => e
+      IORequest.logger.debug(prog_name) { "Failed to send zero-sized message(#{e})" }
     end
 
-    def send_request_and_wait_for_response(request)
+    def send_request_and_wait_for_response(request, timeout)
       @mutex_w.synchronize do
         IORequest.logger.debug(prog_name) { "Sending message: #{request}" }
         request.write_to(@io_w)
       end
-      wait_for_response(request)
+      wait_for_response(request, timeout)
     end
 
-    def wait_for_response(request)
+    def wait_for_response(request, timeout)
       IORequest.logger.debug(prog_name) { "Waiting for response for #{request}" }
+      waiting_start_time = Time.now
       @responses_access_mutex.synchronize do
         response = nil
         until response
-          @responses_access_cv.wait(@responses_access_mutex)
-          response = @responses[request.id.to_s]
+          @responses_access_cv.wait(@responses_access_mutex, 1)
+          if @responses_access_mutex.owned?
+            # NOTE: Only accessing responses hash if thread owns access mutex
+            response = @responses.delete(request.id.to_s)
+          end
+          raise RequestTimeoutError if timeout && (Time.now - waiting_start_time < timeout)
         end
         IORequest.logger.debug(prog_name) { "Found response: #{response}" }
         response

data/lib/io_request/connection/ssl_sockets.rb

@@ -32,11 +32,20 @@ module IORequest
       end
 
       # @return [Array<IORequest::Client>]
-      attr_reader :clients
+      def clients
+        @clients_data.keys
+      end
+
+      # @param client [IORequest::Client]
+      # @return [Hash, nil] you are free to store anything you want in hash.
+      #   Only field you will find in it is `auth` with authenticator data.
+      def data(client)
+        @clients_data[client]
+      end
 
       # Start server.
       def start
-        @clients = []
+        @clients_data = {}
 
         @server = TCPServer.new(@port)
 
@@ -45,8 +54,8 @@ module IORequest
 
       # Fully stop server.
       def stop
-        @clients.each(&:close)
-        @clients = []
+        clients.each(&:close)
+        @clients_data.clear
 
         @server.close
         @server = nil
@@ -68,7 +77,7 @@ module IORequest
         while (socket = @server.accept)
           handle_socket(socket)
         end
-      rescue
+      rescue StandardError
         stop
       end
 
@@ -76,17 +85,21 @@ module IORequest
         ssl_socket = OpenSSL::SSL::SSLSocket.new(socket, @ctx)
         ssl_socket.accept
 
-        client = IORequest::Client.new authorizer: @authorizer
-        begin
-          client.open read_write: ssl_socket
-          client.respond { |data| @requests_handler.call(data, client) }
-          @clients << client
-        rescue StandardError
-          IORequest.debug "Failed to open client: #{e}"
-          ssl_socket.close
+        handle_client(ssl_socket, IORequest::Client.new(authorizer: @authorizer))
+      rescue StandardError => e
+        IORequest.logger.warn "Unknown error while handling sockets: #{e}"
+      end
+
+      def handle_client(ssl_socket, client)
+        auth_data = client.open read_write: ssl_socket
+        client.on_request { |data| @requests_handler.call(data, client) }
+        @clients_data[client] = { auth: auth_data }
+        client.on_close do
+          @clients_data.select! { |c, _d| c.open? }
         end
       rescue StandardError => e
-        IORequest.warn "Unknown error while handling sockets: #{e}"
+        IORequest.logger.debug "Failed to open client: #{e}"
+        ssl_socket.close
       end
     end
 
@@ -105,9 +118,15 @@ module IORequest
         @authorizer = authorizer
         @requests_handler = requests_handler
 
+        @client = nil
+
         initialize_ssl_context(certificate, key)
       end
 
+      def connected?
+        !@client.nil?
+      end
+
       # Connect to server.
       # @param host [String] host of server.
       # @param port [Integer] port of server.
@@ -121,9 +140,11 @@ module IORequest
         @client = IORequest::Client.new authorizer: @authorizer
         begin
           @client.open read_write: ssl_socket
-          @client.respond(&@requests_handler)
+          @client.on_request(&@requests_handler)
+          @client.on_close do
+            @client = nil
+          end
         rescue StandardError
-          IORequest.debug "Failed to open client: #{e}"
           ssl_socket.close
           @client = nil
         end

data/lib/io_request/message.rb

@@ -81,8 +81,8 @@ module IORequest
     # @param io_r [:read]
     # @return [Message]
     def self.read_from(io_r)
-      size = io_r.read(2).unpack1('S')
-      raise '0 size received' if size.zero?
+      size = io_r.read(2)&.unpack1('S') || 0
+      raise ZeroSizeMessageError if size.zero?
 
       json_string = io_r.read(size).unpack1("a#{size}")
       msg = JSON.parse(json_string, symbolize_names: true)

data/lib/io_request/version.rb

@@ -2,5 +2,5 @@
 
 module IORequest
   # Gem version.
-  VERSION = '2.2.0'
+  VERSION = '2.5.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: io_request
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.5.0
 platform: ruby
 authors:
 - Fizvlad
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-07-19 00:00:00.000000000 Z
+date: 2020-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler