io_request 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d6ba3ef4cb967a230cfb350a7413cee8868a2817f5451134105c7ba075470427
+  data.tar.gz: 1438ae77d9f2db624bbf8596d2b4acbf793aa1826bcc9a6e0f83dfe8fde3e541
+SHA512:
+  metadata.gz: e1cc15e03f5489653ec07ce7d7424992ee259b508124972f84fe8c2f10bf08465a59ebebd25dc30cba5be8012c583c2028b4c22332882e13e575903c0898e7af
+  data.tar.gz: a648b296f3b12c90205253bd40ce906b12a5638b892113bfdcf54deedaed8a41d5262c5f4937edc28509de862ce52c91429f450c40a8b97c60acdcf8afdec651

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.5.5
+before_install: gem install bundler -v 2.0.2

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in io_request.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,28 @@
+PATH
+  remote: .
+  specs:
+    io_request (1.0.0)
+      json (~> 2.0)
+      logger (~> 1.4)
+      timeout-extensions (~> 0.1.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    json (2.2.0)
+    logger (1.4.1)
+    minitest (5.13.0)
+    rake (10.5.0)
+    timeout-extensions (0.1.1)
+
+PLATFORMS
+  x64-mingw32
+
+DEPENDENCIES
+  bundler (~> 2.0)
+  io_request!
+  minitest (~> 5.0)
+  rake (~> 10.0)
+
+BUNDLED WITH
+   2.0.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Fizvlad
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,37 @@
+# IORequest
+
+Small gem to create JSON request/response type of connection over IO object
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'io_request'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install io_request
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/fizvlad/io-request-rb.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+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__)

data/io_request.gemspec

@@ -0,0 +1,37 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "io_request/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "io_request"
+  spec.version       = IORequest::VERSION
+  spec.authors       = ["Fizvlad"]
+  spec.email         = ["fizvlad@mail.ru"]
+
+  spec.summary       = "Small gem to create JSON request/response type of connection over IO object"
+  spec.homepage      = "https://github.com/fizvlad/io-request-rb"
+  spec.license       = "MIT"
+
+  spec.required_ruby_version = ">=2.3.1"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/fizvlad/io-request-rb"
+  spec.metadata["changelog_uri"] = "https://github.com/fizvlad/io-request-rb/releases"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+
+  spec.add_runtime_dependency "logger", "~>1.4"
+  spec.add_runtime_dependency "timeout-extensions", "~>0.1.1"
+  spec.add_runtime_dependency "json", "~>2.0"
+end

data/lib/io_request/client.rb

@@ -0,0 +1,183 @@
+require "base64"
+require "timeout"
+require "json"
+
+module IORequest
+  # Connection client.
+  class Client
+    include Utility::WithProgName
+    include Utility::MultiThread
+
+    # IO-like object provided at initialization.
+    attr_reader :io
+
+    # Initialize new client over IO.
+    #
+    # @option options [:gets] read IO to read from.
+    # @option options [:puts] write IO to write to.
+    def initialize(read: nil, write: nil)
+      @io_r = read
+      @io_w = write
+
+      @mutex = Mutex.new
+      @responders = [] # Array of pairs [Subhash, Block]
+      @out_requests = {} # Request => Proc
+
+      @receive_thread = Thread.new { receive_loop }
+      IORequest.debug("New IORequest client initialized", prog_name)
+    end
+
+    # Send request.
+    #
+    # Optional block can be provided. It will be called when response received.
+    #
+    # @param data [Hash] data to send with request.
+    #
+    # @option options [Boolean] sync whether to join request after sending.
+    # @option options [Integer, Float] timeout timeout for {Request#join}.
+    #
+    # @yieldparam request [Response] response for request.
+    # 
+    # @return [Request]
+    def request(data: {}, sync: false, timeout: nil, &block)
+      req = Request.new(data)
+      @out_requests[req] = block
+      send(req.to_hash)
+      req.join(timeout) if sync
+      req
+    end
+
+    # Setup block for answering incoming requests.
+    #
+    # @param subdata [Hash] provided block will be called only if received data
+    #   includes this hash.
+    #
+    # @yieldparam request [Request] incoming request.
+    # @yieldreturn [Hash] data to be sent in response.
+    #
+    # @return [nil]
+    def respond(subdata = {}, &block)
+      @responders << [subdata, block]
+      nil
+    end
+
+    private
+
+    # Starts receiving loop and freezes thread.
+    def receive_loop
+      loop do
+        h = receive(nil)
+        break if h.nil?
+        case h[:type]
+          when "request"
+            handle_in_request(Request.from_hash h)
+          when "response"
+            handle_in_response(Response.from_hash h)
+          else
+            IORequest.warn("Unknown message type: #{h[:type].inspect}", prog_name)
+        end
+      end
+      IORequest.debug("Receive loop exited", prog_name)
+    end
+    # Handle incoming request.
+    def handle_in_request(req)
+      IORequest.debug("Handling request ##{req.id}", prog_name)
+      in_thread do
+        responder = find_responder(req)
+        data = nil
+        begin
+          data = responder.call(req) if responder
+        rescue Exception => e
+          IORequest.warn("Provided block raised exception:\n#{e.full_message}", prog_name)
+        end
+        data = {} unless data.is_a?(Hash)
+        res = Response.new(data, req)
+        send(res.to_hash)
+      end
+      nil
+    end
+    # Handle incoming response.
+    def handle_in_response(res)
+      req_id = res.request.to_i
+      req = @out_requests.keys.find { |r| r.id == req_id }
+      unless req
+        IORequest.warn("Request ##{req_id} not found", prog_name)
+        return
+      end
+      IORequest.debug("Request ##{req_id} response received", prog_name)
+      req.response = res
+      # If block is not provided it's totally ok
+      block = @out_requests.delete(req)
+      if block
+        in_thread do
+          begin
+            block.call(res)
+          rescue Exception => e
+            IORequest.warn("Provided block raised exception:\n#{e.full_message}", prog_name)
+          end
+        end
+      end
+    end
+
+    # find responder for provided request.
+    def find_responder(req)
+      @responders.each do |subdata, block|
+        break block if req.data.contains? subdata
+      end
+    end
+
+    # Send data.
+    # 
+    # @param [Hash]
+    def send(data)
+      send_raw(encode(data_to_string data))
+    end
+
+    # Receive data.
+    #
+    # @param timeout [Integer, Float, nil] timeout size or +nil+ if no timeout required.
+    #
+    # @return [Hash, nil] hash or +nil+ if timed out or IO was closed.
+    def receive(timeout)
+      str = Timeout::timeout(timeout) do
+        receive_raw
+      end
+      return nil if str.nil?
+      string_to_data(decode(str))
+    rescue Timeout::Error
+      nil
+    rescue IOError
+      nil
+    rescue Exception => e
+      IORequest.warn "Exception of #{e.class} encountered while trying to receive message. Suggesting IO was closed. Full trace: #{e.full_message}", prog_name
+      nil
+    end
+
+    # Send string.
+    def send_raw(str)
+      @io_w.puts str
+    end
+    # Receive string.
+    def receive_raw
+      @io_r.gets&.chomp
+    end
+
+    # Encode string
+    def encode(str)
+      Base64::strict_encode64 str
+    end
+    # Decode string
+    def decode(str)
+      Base64::strict_decode64 str
+    end
+
+    # Turn data into string
+    def data_to_string(data)
+      JSON.generate(data)
+    end
+    # Turn string into data
+    def string_to_data(str)
+      JSON.parse(str).symbolize_keys!
+    end
+  end
+end

data/lib/io_request/logging.rb

@@ -0,0 +1,49 @@
+require "logger"
+
+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
+
+  # Access current logger.
+  #
+  # @return [Logger, nil]
+  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)
+  end
+
+  # Log info message.
+  def self.info(message = nil, progname = nil)
+    @@logger.log(Logger::INFO, message, progname)
+  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

@@ -0,0 +1,112 @@
+module IORequest
+  # Message to other side of IO.
+  class Message
+    # @return [Integer] ID of message.
+    attr_reader :id
+    alias_method :to_i, :id
+
+    # @return [Hash] stored data.
+    attr_reader :data
+
+    # Initialize 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
+      @data = data
+    end
+
+    # @return [String] human-readable form.
+    def to_s
+      "#{self.class.name}##{@id}: #{@data.inspect}"
+    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
+    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
+
+    # 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 [String] human readable form.
+    def to_s
+      "#{super.to_s}; #{@response ? "Response ID: #{@response.to_i}" : "Not responded"}"
+    end
+
+    # 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
+
+    # Save into hash.
+    def to_hash
+      { type: "request", data: @data, id: @id, response: @response.to_i }
+    end
+
+    # Initialize new request from hash obtained with {Request#to_hash}.
+    def self.from_hash(hash)
+      Request.new(hash[:data], hash[:response], hash[:id])
+    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)
+    end
+
+    # @return [String] human readable form.
+    def to_s
+      "#{super.to_s}; Initial request ID: #{@request.to_i}"
+    end
+
+    # Save into hash.
+    def to_hash
+      { type: "response", data: @data, id: @id, request: @request.to_i }
+    end
+
+    # Initialize new request from hash obtained with {Response#to_hash}.
+    def self.from_hash(hash)
+      Response.new(hash[:data], hash[:request], hash[:id])
+    end
+  end
+end

data/lib/io_request/utility.rb

@@ -0,0 +1,99 @@
+module IORequest
+  # Utility methods.
+  module Utility
+    # Adds special method to identify object in log files.
+    module WithProgName
+      ##
+      # Identifies object and thread it runs in.
+      def prog_name
+        self_class = self.class
+        "#{self_class.name}##{object_id} in Thread##{Thread.current.object_id}"
+      end
+    end
+
+    # Adds some methods to spawn new threads and join them.
+    #
+    # @note This module creates instance variables with prefix +@_MultiThread_+.
+    module MultiThread
+      private
+
+      # @return [Array<Thread>] array of running threads
+      def running_threads
+        @_MultiThread_threads ||= []
+      end
+
+      # Runs block with provided arguments forwarded as arguments in separate thread.
+      #
+      # @return [Thread]
+      def in_thread(*args, &block)
+        @_MultiThread_threads ||= []
+        @_MultiThread_mutex ||= Mutex.new
+        # Synchronizing addition/deletion of new threads. That's important
+        @_MultiThread_mutex.synchronize do
+          new_thread = Thread.new(*args) do |*in_args|
+            begin
+              block.call(*in_args)
+            ensure
+              @_MultiThread_mutex.synchronize do
+                @_MultiThread_threads.delete(Thread.current)
+              end
+            end
+          end
+          @_MultiThread_threads << new_thread
+          new_thread
+        end        
+      end
+
+      # For each running thread.
+      def each_thread(&block)
+        @_MultiThread_threads ||= []
+        
+        @_MultiThread_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
+
+# Extending Hash class.
+class Hash
+  # Use this on JSON objects to turn all the +String+ keys of hash to symbols.
+  #
+  # @param depth [Integer] maximum amount of hashes to handle. This is just a
+  #   simple way to protect from infinite loop.
+  #
+  # @return [self]
+  def symbolize_keys!(depth = 1000)
+    queue = [self]
+    count = 0
+    while h = queue.shift
+      h.transform_keys! { |key| key.is_a?(String) ? key.to_sym : key }
+      h.each_value { |v| queue.push(v) if v.is_a?(Hash) }
+      count += 1
+      break if count >= depth
+    end
+    self
+  end
+
+  # Whether provided hash is included into this one.
+  #
+  # @param other [Hash]
+  #
+  # @return [Boolean]
+  def contains?(other)
+    other.keys.all? do |key|
+      other[key] == self[key]
+    end
+  end
+end
+

data/lib/io_request/version.rb

@@ -0,0 +1,4 @@
+module IORequest
+  # Gem version.
+  VERSION = "1.0.0"
+end

data/lib/io_request.rb

@@ -0,0 +1,8 @@
+require_relative "io_request/version"
+require_relative "io_request/utility"
+require_relative "io_request/logging"
+require_relative "io_request/message"
+require_relative "io_request/client"
+
+# Main module.
+module IORequest; end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: io_request
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Fizvlad
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-11-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !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: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: timeout-extensions
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: 
+email:
+- fizvlad@mail.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- io_request.gemspec
+- lib/io_request.rb
+- lib/io_request/client.rb
+- lib/io_request/logging.rb
+- lib/io_request/message.rb
+- lib/io_request/utility.rb
+- lib/io_request/version.rb
+homepage: https://github.com/fizvlad/io-request-rb
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/fizvlad/io-request-rb
+  source_code_uri: https://github.com/fizvlad/io-request-rb
+  changelog_uri: https://github.com/fizvlad/io-request-rb/releases
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.4
+signing_key: 
+specification_version: 4
+summary: Small gem to create JSON request/response type of connection over IO object
+test_files: []