io_request 1.2.0 → 2.3.1

data/lib/io_request/connection/ssl_sockets.rb

@@ -0,0 +1,163 @@
+# 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>]
+      attr_reader :clients
+
+      # Start server.
+      def start
+        @clients = []
+
+        @server = TCPServer.new(@port)
+
+        @accept_thread = in_thread(name: 'accept_thr') { accept_loop }
+      end
+
+      # Fully stop server.
+      def stop
+        @clients.each(&:close)
+        @clients = []
+
+        @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
+        stop
+      end
+
+      def handle_socket(socket)
+        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.on_request { |data| @requests_handler.call(data, client) }
+          @clients << client
+          client.on_close do
+            @clients.select!(&:open?)
+          end
+        rescue StandardError => e
+          IORequest.logger.debug "Failed to open client: #{e}"
+          ssl_socket.close
+        end
+      rescue StandardError => e
+        IORequest.logger.warn "Unknown error while handling sockets: #{e}"
+      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

@@ -1,49 +1,20 @@
-require "logger"
+# frozen_string_literal: true
 
-module IORequest
-  # @!group Logger
-
-  # Default logger.
-  @@logger = Logger.new($LOG_FILE || STDOUT,
-    formatter: Proc.new do |severity, datetime, progname, msg|
-      "[#{datetime}] #{severity} - #{progname}:\t #{msg}\n"
-    end
-  )
-  @@logger.level = $DEBUG ? Logger::DEBUG : Logger::INFO
-
-  # Setup new logger.
-  #
-  # @param logger [Logger, nil]
-  def self.logger=(logger)
-    @@logger = logger
-  end
+require 'logger'
 
-  # Access current logger.
-  #
-  # @return [Logger, nil]
+module IORequest
+  # @return [Logger]
   def self.logger
-    @@logger
-  end
-
-  # Log message.
-  def self.log(severity, message = nil, progname = nil)
-    @@logger.log(severity, message, progname) if @@logger
-  end
-
-  # Log warning message.
-  def self.warn(message = nil, progname = nil)
-    @@logger.log(Logger::WARN, message, progname)
+    @@logger ||= Logger.new( # rubocop:disable Style/ClassVars
+      STDOUT,
+      formatter: proc do |severity, datetime, progname, msg|
+        "[#{datetime}] #{severity} - #{progname}:\t #{msg}\n"
+      end
+    )
   end
 
-  # Log info message.
-  def self.info(message = nil, progname = nil)
-    @@logger.log(Logger::INFO, message, progname)
+  # @param new_logger [Logger]
+  def self.logger=(new_logger)
+    @@logger = new_logger # rubocop:disable Style/ClassVars
   end
-
-  # Log debug message.
-  def self.debug(message = nil, progname = nil)
-    @@logger.log(Logger::DEBUG, message, progname)
-  end
-
-  # @!endgroup
 end

data/lib/io_request/message.rb

@@ -1,112 +1,95 @@
+# frozen_string_literal: true
+
 module IORequest
-  # Message to other side of IO.
+  # Single message. Either request or response.
   class Message
-    # @return [Integer] ID of message.
-    attr_reader :id
-    alias_method :to_i, :id
-
-    # @return [Hash] stored data.
-    attr_reader :data
+    include Utility::WithID
+    # Types of messages.
+    TYPES = %i[request response].freeze
 
-    # Initialize new message.
-    #
+    # Create new message.
     # @param data [Hash]
-    # @param id [Integer, nil] if +nil+ provided {Message.generate_id} will be
-    #   used to generate random id.
-    def initialize(data, id = nil)
-      @id = id || Message.generate_id
+    # @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.
+    def initialize(data, type: :request, id: nil, to: nil)
       @data = data
-    end
+      @type = type
+      @id = id.nil? ? extended_id : Utility::ExtendedID.from(id)
+      @to = to.nil? ? nil : Utility::ExtendedID.from(to)
 
-    # @return [String] human-readable form.
-    def to_s
-      "#{self.class.name}##{@id}: #{@data.inspect}"
+      check_data
     end
 
-    # @return [Integer] random numerical ID based on current time and random salt.
-    def self.generate_id
-      ((rand(999) + 1) * Time.now.to_f * 1000).to_i % 2**32
+    # Check data correctness.
+    def check_data
+      raise '@data is not a hash' unless @data.is_a? Hash
+      raise 'incorrect @type' unless TYPES.include? @type
+      raise 'incorrect @id' unless @id.is_a? Utility::ExtendedID
+      raise '@to not specified for response' if response? && @to.nil?
     end
-  end
-
-  # Request for server or client.
-  class Request < Message
-    # Amount of time to sleep before checking whether responded.
-    JOIN_SLEEP_TIME = 0.5
-
-    # @return [Integer, Response, nil] ID of response or response itself for this message.
-    attr_reader :response
 
-    # @!visibility private
-    attr_writer :response
+    # @return [Hash]
+    attr_reader :data
 
-    # Initialize new request.
-    #
-    # @param data [Hash]
-    # @param response [Integer, Response, nil]
-    # @param id [Integer, nil]
-    def initialize(data, response = nil, id = nil)
-      @response = response
-      super(data, id)
-    end
+    # @return [Symbol]
+    attr_reader :type
 
-    # @return [String] human readable form.
-    def to_s
-      "#{super.to_s}; #{@response ? "Response ID: #{@response.to_i}" : "Not responded"}"
-    end
+    # @return [Utility::ExtendedID]
+    attr_reader :id
 
-    # Freezes thread until request is responded or until timeout expends.
-    #
-    # @param timeout [Integer, Float, nil] timeout size or +nil+ if no timeout.
-    #
-    # @return [Integer] amount of time passed
-    def join(timeout = nil)
-      time_passed = 0
-      while @response.nil? && (timeout.nil? || time_passed < timeout)
-        time_passed += (sleep JOIN_SLEEP_TIME)
-      end
-      time_passed
-    end
+    # @return [Utility::ExtendedID]
+    attr_reader :to
 
-    # Save into hash.
-    def to_hash
-      { type: "request", data: @data, id: @id, response: @response.to_i }
+    # @return [Boolean]
+    def request?
+      @type == :request
     end
 
-    # Initialize new request from hash obtained with {Request#to_hash}.
-    def self.from_hash(hash)
-      Request.new(hash[:data], hash[:response], hash[:id])
+    # @return [Boolean]
+    def response?
+      @type == :response
     end
-  end
 
-  # Response to some request.
-  class Response < Message
-    # @return [Integer, Request] ID of initial request or request itself.
-    attr_reader :request
-
-    # Initialize new response.
-    #
-    # @param data [Hash]
-    # @param request [Integer, Request]
-    # @param id [Integer, nil]
-    def initialize(data, request, id = nil)
-      @request = request
-      super(data, id)
+    # @return [String]
+    def to_s
+      if request?
+        "Request##{@id}: #{data}"
+      else
+        "Response##{@id}: #{data} to ##{@to}"
+      end
     end
 
-    # @return [String] human readable form.
-    def to_s
-      "#{super.to_s}; Initial request ID: #{@request.to_i}"
+    # @return [String] binary data to be passed over IO.
+    def to_binary
+      json_string = JSON.generate({
+                                    id: @id.to_s,
+                                    type: @type.to_s,
+                                    to: @to.to_s,
+                                    data: @data
+                                  })
+      [json_string.size, json_string].pack("Sa#{json_string.size}")
     end
 
-    # Save into hash.
-    def to_hash
-      { type: "response", data: @data, id: @id, request: @request.to_i }
+    # @param io_w [:write]
+    def write_to(io_w)
+      io_w.write(to_binary)
     end
 
-    # Initialize new request from hash obtained with {Response#to_hash}.
-    def self.from_hash(hash)
-      Response.new(hash[:data], hash[:request], hash[:id])
+    # @param io_r [:read]
+    # @return [Message]
+    def self.read_from(io_r)
+      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)
+      Message.new(msg[:data],
+                  id: msg[:id],
+                  type: msg[:type].to_sym,
+                  to: msg[:to])
     end
   end
 end

data/lib/io_request/utility/multi_thread.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module IORequest
+  # Utility methods.
+  module Utility
+    # Adds some methods to spawn new threads and join them.
+    # @note This module creates instance variables with prefix +@__multi_thread__+.
+    module MultiThread
+      private
+
+      # @return [Array<Thread>] array of running threads.
+      def __multi_thread__threads
+        @__multi_thread__threads ||= []
+      end
+      alias running_threads __multi_thread__threads
+
+      # @return [Mutex] threads manipulations mutex.
+      def __multi_thread__mutex
+        @__multi_thread__mutex ||= Mutex.new
+      end
+
+      # Runs block with provided arguments forwarded as arguments in separate thread.
+      # All the inline args will be passed to block.
+      # @param thread_name [String] thread name.
+      # @return [Thread]
+      def in_thread(*args, name: nil)
+        # Synchronizing addition/deletion of new threads. That's important
+        __multi_thread__mutex.synchronize do
+          new_thread = Thread.new(*args) do |*in_args|
+            yield(*in_args)
+          ensure
+            __multi_thread__remove_current_thread
+          end
+          __multi_thread__threads << new_thread
+          new_thread.name = name if name
+          new_thread
+        end
+      end
+
+      # Removes current thread from thread list.
+      def __multi_thread__remove_current_thread
+        __multi_thread__mutex.synchronize do
+          __multi_thread__threads.delete(Thread.current)
+        end
+      end
+
+      # For each running thread.
+      def each_thread(&block)
+        __multi_thread__threads.each(&block)
+      end
+
+      # Kills each thread.
+      def kill_threads
+        each_thread(&:kill)
+        each_thread(&:join)
+      end
+
+      # Joins each thread.
+      def join_threads
+        each_thread(&:join)
+      end
+    end
+  end
+end