io_request 2.0.0 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a78b709d9b064cd44737d76a24c27f0df37e9f0d5897829043e9d884287219d
-  data.tar.gz: a2350c480d0f9cc883526c47021505bfd511ffa12622436ac5bafbe4d050c6df
+  metadata.gz: a560819ec6ad8dc50801411fcea4ca4263b29e88067187cc2035e3cbad133394
+  data.tar.gz: 1d82e187a4044f25e3ee061a7f382423e1013644dff7663467e694e4139fc8f2
 SHA512:
-  metadata.gz: b1cc3c89258eaa0d4511fdcd1dc17cae4b82061ebdb747732a8cc60467a9a39c3414a337f6f85acc4dd6768f16bc45f9fe037405e5e7aeb19f0723deeb01759a
-  data.tar.gz: eb6918fb66bbaec142dd88abf4c00b69d5204fb88b03f00532e52d12d8a03822275efb3cac4584177a8f9ab40bc549bc5dff09977410f3cf6f99435f594e41ad
+  metadata.gz: ff19727550d073a8cccc146a2c1de65a6f67458a276b003e122e471ef73d584a52741bdaf07da51e0ed2513f33d0cf8a139eb4e5f0c342e2f6a77cc929f2982a
+  data.tar.gz: 0eaf1f54fcac605a4dc62a8ff7b7bcc41a7d68ee3e75c2020971e9bfb432cc08f22799506ae6e80409f4892b2e5e12cee2e5da28f4657f13a059dfad900402e2

data/Gemfile

@@ -11,3 +11,7 @@ gem 'json', '~> 2.3'
 gem 'timeout', '~> 0.1.0'
 
 gem 'logger', '~> 1.4'
+
+gem 'openssl', '~> 2.2'
+
+gem 'pry', '~> 0.13.1'

data/bin/console

@@ -4,12 +4,5 @@
 require 'bundler/setup'
 require 'io_request'
 
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require 'irb'
-IRB.start(__FILE__)
+require 'pry'
+Pry.start(__FILE__)

data/lib/io_request.rb

@@ -1,6 +1,16 @@
 # frozen_string_literal: true
 
+# Main module.
+module IORequest
+  # Client received message of zero size.
+  class ZeroSizeMessageError < RuntimeError; end
+
+  # Authorization failed.
+  class AuthorizationFailureError < RuntimeError; end
+end
+
 require_relative 'io_request/version'
+require_relative 'io_request/logging'
 require_relative 'io_request/utility/multi_thread'
 require_relative 'io_request/utility/with_id'
 require_relative 'io_request/utility/with_prog_name'
@@ -8,23 +18,3 @@ require_relative 'io_request/utility/with_prog_name'
 require_relative 'io_request/authorizer'
 require_relative 'io_request/message'
 require_relative 'io_request/client'
-
-require 'logger'
-
-# Main module.
-module IORequest
-  # @return [Logger]
-  def self.logger
-    @@logger ||= Logger.new( # rubocop:disable Style/ClassVars
-      STDOUT,
-      formatter: proc do |severity, datetime, progname, msg|
-        "[#{datetime}] #{severity} - #{progname}:\t #{msg}\n"
-      end
-    )
-  end
-
-  # @param new_logger [Logger]
-  def self.logger=(new_logger)
-    @@logger = new_logger # rubocop:disable Style/ClassVars
-  end
-end

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,15 +65,21 @@ 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
+
+    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.
@@ -96,50 +104,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 +166,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
@@ -180,6 +191,8 @@ 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)

data/lib/io_request/connection/ssl_sockets.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require_relative '../../io_request'
+
+require 'socket'
+require 'openssl'
+
+module IORequest
+  # Connection via SSL sockets
+  module SSLSockets
+    # SSL socket server.
+    class Server
+      include Utility::MultiThread
+
+      # Initalize new server.
+      # @param port [Integer] port of server.
+      # @param authorizer [Authorizer]
+      # @param certificate [String]
+      # @param key [String]
+      def initialize(
+        port: 8000,
+        authorizer: Authorizer.empty,
+        certificate: nil,
+        key: nil,
+        &requests_handler
+      )
+        @port = port
+        @authorizer = authorizer
+        @requests_handler = requests_handler
+
+        initialize_ssl_context(certificate, key)
+      end
+
+      # @return [Array<IORequest::Client>]
+      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_data = {}
+
+        @server = TCPServer.new(@port)
+
+        @accept_thread = in_thread(name: 'accept_thr') { accept_loop }
+      end
+
+      # Fully stop server.
+      def stop
+        clients.each(&:close)
+        @clients_data.clear
+
+        @server.close
+        @server = nil
+
+        @accept_thread&.kill
+        @accept_thread = nil
+      end
+
+      private
+
+      def initialize_ssl_context(certificate, key)
+        @ctx = OpenSSL::SSL::SSLContext.new
+        @ctx.cert = OpenSSL::X509::Certificate.new certificate
+        @ctx.key = OpenSSL::PKey::RSA.new key
+        @ctx.ssl_version = :TLSv1_2
+      end
+
+      def accept_loop
+        while (socket = @server.accept)
+          handle_socket(socket)
+        end
+      rescue StandardError
+        stop
+      end
+
+      def handle_socket(socket)
+        ssl_socket = OpenSSL::SSL::SSLSocket.new(socket, @ctx)
+        ssl_socket.accept
+
+        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.logger.debug "Failed to open client: #{e}"
+        ssl_socket.close
+      end
+    end
+
+    # SSL socket client.
+    class Client
+      # Initialize new client.
+      # @param authorizer [Authorizer]
+      # @param certificate [String]
+      # @param key [String]
+      def initialize(
+        authorizer: Authorizer.empty,
+        certificate: nil,
+        key: nil,
+        &requests_handler
+      )
+        @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.
+      def connect(host = 'localhost', port = 8000)
+        socket = TCPSocket.new(host, port)
+
+        ssl_socket = OpenSSL::SSL::SSLSocket.new(socket, @ctx)
+        ssl_socket.sync_close = true
+        ssl_socket.connect
+
+        @client = IORequest::Client.new authorizer: @authorizer
+        begin
+          @client.open read_write: ssl_socket
+          @client.on_request(&@requests_handler)
+        rescue StandardError
+          ssl_socket.close
+          @client = nil
+        end
+      end
+
+      # Closes connection to server.
+      def disconnect
+        return unless defined?(@client) && !@client.nil?
+
+        @client.close
+        @client = nil
+      end
+
+      # Wrapper over {IORequest::Client#request}
+      def request(*args, **options, &block)
+        @client.request(*args, **options, &block)
+      end
+
+      private
+
+      def initialize_ssl_context(certificate, key)
+        @ctx = OpenSSL::SSL::SSLContext.new
+        @ctx.cert = OpenSSL::X509::Certificate.new certificate
+        @ctx.key = OpenSSL::PKey::RSA.new key
+        @ctx.ssl_version = :TLSv1_2
+      end
+    end
+  end
+end

data/lib/io_request/logging.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module IORequest
+  # @return [Logger]
+  def self.logger
+    @@logger ||= Logger.new( # rubocop:disable Style/ClassVars
+      STDOUT,
+      formatter: proc do |severity, datetime, progname, msg|
+        "[#{datetime}] #{severity} - #{progname}:\t #{msg}\n"
+      end
+    )
+  end
+
+  # @param new_logger [Logger]
+  def self.logger=(new_logger)
+    @@logger = new_logger # rubocop:disable Style/ClassVars
+  end
+end

data/lib/io_request/message.rb

@@ -10,9 +10,10 @@ module IORequest
     # Create new message.
     # @param data [Hash]
     # @param type [Symbol] one of {TYPES} member.
-    # @param id [Utility::ExtendedID, String, nil] only should be filled if message is received from outside.
-    # @param to [Utility::ExtendedID, String, nil] if message is response, it should include integer
-    #   of original request.
+    # @param id [Utility::ExtendedID, String, nil] only should be filled if
+    #   message is received from outside.
+    # @param to [Utility::ExtendedID, String, nil] if message is response, it
+    #   should include integer of original request.
     def initialize(data, type: :request, id: nil, to: nil)
       @data = data
       @type = type
@@ -80,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.0.0'
+  VERSION = '2.4.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: io_request
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.4.0
 platform: ruby
 authors:
 - Fizvlad
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-07-18 00:00:00.000000000 Z
+date: 2020-07-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -110,11 +110,12 @@ files:
 - README.md
 - Rakefile
 - bin/console
-- examples/simple_example.rb
 - io_request.gemspec
 - lib/io_request.rb
 - lib/io_request/authorizer.rb
 - lib/io_request/client.rb
+- lib/io_request/connection/ssl_sockets.rb
+- lib/io_request/logging.rb
 - lib/io_request/message.rb
 - lib/io_request/utility/multi_thread.rb
 - lib/io_request/utility/with_id.rb

data/examples/simple_example.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require 'io_request'
-
-r1, w1 = IO.pipe
-r2, w2 = IO.pipe
-
-client_1 = IORequest::Client.new read: r1, write: w2
-client_2 = IORequest::Client.new read: r2, write: w1
-
-# Use
-# Set up responders
-# Authorization
-client_2.respond type: 'auth' do |request|
-  puts "Client 2: Authorization attempt as #{request.data[:username].inspect}"
-  sleep 2 # Some processing
-  { type: 'auth_success' }
-end
-
-# Default
-client_2.respond do |request|
-  puts "Client 2: #{request.data.inspect}"
-  { type: 'success' }
-end
-
-# Send requests
-auth = false
-auth_request = client_1.request(
-  data: { type: 'auth', username: 'mymail@example.com', password: "let's pretend password hash is here" },
-  sync: true
-) do |response|
-  unless response.data[:type] == 'auth_success'
-    puts "Client 1: Authorization failed. Response: #{response.data.inspect}"
-    next
-  end
-
-  auth = true
-  # Do something
-end
-exit unless auth
-puts 'Client 1: Authorized!'
-
-message = client_1.request(
-  data: { type: 'message', message: 'Hello!' },
-  sync: true
-) do |_response|
-  puts 'Client 1: Message responded'
-end
-
-# Close
-r1.close
-w1.close
-r2.close
-w2.close