io_request 1.2.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5bc70dc523aa523749a9ff7ced4fb1e59243a70ab963026b76c0feada184adad
-  data.tar.gz: fd2d048ddf79f0102bbc39ab72ad98529b090d40a2f681b72bb14d2149bea241
+  metadata.gz: 9a78b709d9b064cd44737d76a24c27f0df37e9f0d5897829043e9d884287219d
+  data.tar.gz: a2350c480d0f9cc883526c47021505bfd511ffa12622436ac5bafbe4d050c6df
 SHA512:
-  metadata.gz: 4e348c7d960286264707730c07f46ed6de58edd8b27653271aa4b76f87718c1ca623364299a409d4179c71083158c076d9658dcfe7a7f1ef6b62610eae797da3
-  data.tar.gz: 5d01d75cfdd3eea6b39b1e1a74556bd260ded06d699f72cbe22f1812d5680a3d4621170116d2bfc7700d0c6a8793c1e34959dd039fd2bb94566abae439816950
+  metadata.gz: b1cc3c89258eaa0d4511fdcd1dc17cae4b82061ebdb747732a8cc60467a9a39c3414a337f6f85acc4dd6768f16bc45f9fe037405e5e7aeb19f0723deeb01759a
+  data.tar.gz: eb6918fb66bbaec142dd88abf4c00b69d5204fb88b03f00532e52d12d8a03822275efb3cac4584177a8f9ab40bc549bc5dff09977410f3cf6f99435f594e41ad

data/.gitignore

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

data/.rubocop.yml

@@ -0,0 +1,37 @@
+inherit_from: .rubocop_todo.yml
+
+require:
+  - rubocop-performance
+
+AllCops:
+  DisplayCopNames: true
+  DisplayStyleGuide: true
+  ExtraDetails: false
+  TargetRubyVersion: 2.6
+  Exclude:
+    - config/**/*
+    - tmp/**/*
+    - Capfile
+    - Gemfile
+    - Rakefile
+
+# EOL is handled by git settings
+Layout/EndOfLine:
+  Enabled: false
+
+# Just enough
+Layout/LineLength:
+  Max: 100
+
+# Disable some common cops for tests
+Style/Documentation:
+  Exclude:
+    - test/**/*
+Metrics/AbcSize:
+  Exclude:
+    - test/**/*
+Metrics/MethodLength:
+  Max: 15 # Extended limit of lines in method
+  Exclude:
+    - test/**/*
+

data/.rubocop_todo.yml

@@ -0,0 +1,7 @@
+# This configuration was generated by
+# `rubocop --auto-gen-config`
+# on 2020-07-15 18:13:41 UTC using RuboCop version 0.88.0.
+# The point is for the user to remove these configuration records
+# one by one as the offenses are removed from the code base.
+# Note that changes in the inspected code, or installation of new
+# versions of RuboCop, may require this file to be generated again.

data/Gemfile

@@ -1,4 +1,13 @@
-source "https://rubygems.org"
-
-# Specify your gem's dependencies in io_request.gemspec
-gemspec
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in io_request.gemspec
+gemspec
+
+gem 'rubocop', '~> 0.88.0', group: :development
+gem 'rubocop-performance', '~> 1.6', group: :development, require: false
+
+gem 'json', '~> 2.3'
+
+gem 'timeout', '~> 0.1.0'
+
+gem 'logger', '~> 1.4'

data/README.md

@@ -1,39 +1,31 @@
-# 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
-
-Documentation is available at https://www.rubydoc.info/gems/io_request
-
-Some examples could be find in *examples* folder.
-
-## 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).
+# IORequest
+
+Small gem to create JSON request/response type of connection over different IO objects.
+
+## Installation
+
+Using [bundler](https://bundler.io/):
+
+```
+$ bundle add io_request
+```
+
+## Usage
+
+Documentation is available at https://www.rubydoc.info/gems/io_request
+
+Some examples could be find in *examples* folder.
+
+## 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

@@ -1,10 +1,31 @@
-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
+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
+
+require 'rubocop/rake_task'
+RuboCop::RakeTask.new(:rubocop) {}
+namespace 'rubocop' do
+  desc 'Generate rubocop TODO file.'
+  task 'todo' do
+    puts `rubocop --auto-gen-config`
+  end
+end
+
+namespace 'yardoc' do
+  desc 'Generate documentation'
+  task 'generate' do
+    puts `yardoc lib/*`
+  end
+
+  desc 'List undocumented elements'
+  task 'undoc' do
+    puts `yardoc stats --list-undoc lib/*`
+  end
+end
+
+task :default => :test

data/bin/console

@@ -1,14 +1,15 @@
-#!/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__)
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+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/examples/simple_example.rb

@@ -1,4 +1,6 @@
-require "io_request"
+# frozen_string_literal: true
+
+require 'io_request'
 
 r1, w1 = IO.pipe
 r2, w2 = IO.pipe
@@ -9,25 +11,25 @@ client_2 = IORequest::Client.new read: r2, write: w1
 # Use
 # Set up responders
 # Authorization
-client_2.respond type: "auth" do |request|
+client_2.respond type: 'auth' do |request|
   puts "Client 2: Authorization attempt as #{request.data[:username].inspect}"
   sleep 2 # Some processing
-  { type: "auth_success" }
+  { type: 'auth_success' }
 end
 
 # Default
 client_2.respond do |request|
   puts "Client 2: #{request.data.inspect}"
-  { type: "success" }
+  { 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" },
+  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"
+  unless response.data[:type] == 'auth_success'
     puts "Client 1: Authorization failed. Response: #{response.data.inspect}"
     next
   end
@@ -36,13 +38,13 @@ auth_request = client_1.request(
   # Do something
 end
 exit unless auth
-puts "Client 1: Authorized!"
+puts 'Client 1: Authorized!'
 
 message = client_1.request(
-  data: { type: "message", message: "Hello!" },
+  data: { type: 'message', message: 'Hello!' },
   sync: true
-) do |response|
-  puts "Client 1: Message responded"
+) do |_response|
+  puts 'Client 1: Message responded'
 end
 
 # Close

data/io_request.gemspec

@@ -1,37 +1,39 @@
-lib = File.expand_path("lib", __dir__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "io_request/version"
+require 'io_request/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "io_request"
+  spec.name          = 'io_request'
   spec.version       = IORequest::VERSION
-  spec.authors       = ["Fizvlad"]
-  spec.email         = ["fizvlad@mail.ru"]
+  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.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.required_ruby_version = '>=2.6.5'
 
-  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"
+  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
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
-  spec.bindir        = "exe"
+  spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler", "~> 2.0"
-  spec.add_development_dependency "rake", "~> 13.0"
-  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'minitest', '~> 5.0'
+  spec.add_development_dependency 'rake', '~> 13.0'
 
-  spec.add_runtime_dependency "logger", "~>1.4"
-  spec.add_runtime_dependency "timeout-extensions", "~>0.1.1"
-  spec.add_runtime_dependency "json", "~>2.0"
+  spec.add_runtime_dependency 'json', '~>2.0'
+  spec.add_runtime_dependency 'logger', '~>1.4'
+  spec.add_runtime_dependency 'timeout-extensions', '~>0.1.1'
 end

data/lib/io_request.rb

@@ -1,8 +1,30 @@
-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
+# frozen_string_literal: true
+
+require_relative 'io_request/version'
+require_relative 'io_request/utility/multi_thread'
+require_relative 'io_request/utility/with_id'
+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/authorizer.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module IORequest
+  # Class to authorize client connection.
+  class Authorizer
+    # @yieldparam io_r [IO] input stream.
+    # @yieldparam io_w [IO] output stream.
+    # @yieldreturn [Object, nil] if `nil` is returned, authorization will be
+    #   considered as failed one. Otherwise data will be saved into `data`.
+    def initialize(&block)
+      @block = block
+      @data = nil
+    end
+
+    # @return [Object] literally any non-nil data from block.
+    attr_reader :data
+
+    # @return [Boolean] authorization status.
+    def authorize(io_r, io_w)
+      @data = nil
+      @data = @block.call(io_r, io_w)
+      !@data.nil?
+    rescue StandardError => e
+      IORequest.logger.error(e.full_message)
+      false
+    end
+  end
+
+  # No authorization.
+  def Authorizer.empty
+    Authorizer.new { |_io_r, _io_w| true }
+  end
+
+  # Secret key authorization.
+  def Authorizer.by_secret_key(key)
+    Authorizer.new do |io_r, io_w|
+      io_w.write(key)
+      other = io_r.read(key.size)
+      key == other ? other : nil
+    end
+  end
+end

data/lib/io_request/client.rb

@@ -1,193 +1,206 @@
-require "base64"
-require "timeout"
-require "json"
+# frozen_string_literal: true
+
+require 'timeout'
+require 'json'
 
 module IORequest
   # Connection client.
+  #
+  # General scheme:
+  #  Client 1                 Client 2
+  #     |                        |
+  #   (        Authorization       )  See `Authorizer` class. Error in authorization should close
+  #     |                        |    connection
+  #     |                        |
+  #   [    Data transition loop    ]  Loop runs until someone sends 0 sized data. Then everyone
+  #     |                        |    should close connection. Any R/W errors should also finish the
+  #     |                        |    loop
+  #     |                        |
+  #     |-> uint(2 bytes)      ->|    Specifies size of following JSON string
+  #     |-> Mesage as JSON     ->|    Message itself. It should contain its `type`, `id` and some
+  #     |                        |    data hash
+  #     |                        |
+  #     |               (Message handling) See `Handler` class
+  #     |                        |
+  #     |<- uint(2 bytes)      <-|
+  #     |<- Mesage as JSON     <-|
   class Client
     include Utility::WithProgName
     include Utility::MultiThread
 
-    # 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.
-    #
-    # @option options [Hash] data data to send.
-    # @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
-      IORequest.debug("Sending request ##{req.id}", prog_name)
-      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
+    # Initialize new client.
+    def initialize(authorizer: Authorizer.empty)
+      @open = false
+      @authorizer = authorizer
+
+      @mutex_r = Mutex.new
+      @mutex_w = Mutex.new
+
+      @responses = {}
+      @responses_access_mutex = Mutex.new
+      @responses_access_cv = ConditionVariable.new
     end
 
-    private
+    # Start new client connection.
+    # @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).
+    def open(read: nil, write: nil, read_write: nil)
+      @io_r = read_write || read
+      @io_w = read_write || write
 
-    # 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(name: "request_handler") do
-        responder = find_responder(req)
-        data = nil
-        data = begin
-          if responder
-            responder.call(req, self)
-          else
-            IORequest.warn "Responder not found!"
-            nil
-          end
-        rescue Exception => e
-          IORequest.warn "Provided block raised exception:\n#{e.full_message}", prog_name
-          nil
+      IORequest.logger.debug(prog_name) { 'Starting connection' }
+
+      authorization
+      @open = true
+      @data_transition_thread = in_thread(name: 'connection') { data_transition_loop }
+    end
+
+    def open?
+      @open
+    end
+
+    # 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
+    end
+
+    # If callback block is provided, request will be sent asynchroniously.
+    # @param data [Hash]
+    def request(data = {}, &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)
         end
-        data ||= {}
-        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
+        nil
+      else
+        send_request_and_wait_for_response(message).data
       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(name: "response_handle") do
-          begin
-            block.call(res)
-          rescue Exception => e
-            IORequest.warn("Provided block raised exception:\n#{e.full_message}", prog_name)
-          end
-        end
+    end
+
+    attr_reader :authorizer
+
+    private
+
+    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
+      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
+    end
+
+    def close_io
+      IORequest.logger.debug(prog_name) { 'Closing IO' }
+      @mutex_r.synchronize { @io_r&.close }
+      @mutex_w.synchronize { @io_w&.close }
     end
 
-    # find responder for provided request.
-    def find_responder(req)
-      result = nil
-      @responders.each do |subdata, block|
-        if req.data.contains? subdata
-          result = block
-          break
+    def authorization
+      auth_successful = @mutex_r.synchronize do
+        @mutex_w.synchronize do
+          IORequest.logger.debug(prog_name) { 'Authorizing new client' }
+          @authorizer.authorize(@io_r, @io_w)
         end
       end
+      unless auth_successful
+        IORequest.logger.debug(prog_name) { 'Authorization failed' }
+        raise 'Authorization failed'
+      end
 
-      result
+      IORequest.logger.debug(prog_name) { "New client authorized with data #{@authorizer.data}" }
     end
 
-    # Send data.
-    #
-    # @param [Hash]
-    def send(data)
-      IORequest.debug("Sending hash: #{data.inspect}", prog_name)
-      send_raw(encode(data_to_string data))
+    def data_transition_loop
+      IORequest.logger.debug(prog_name) { 'Starting data transition loop' }
+      loop do
+        data_transition_iteration
+      rescue StandardError => e
+        IORequest.logger.debug(prog_name) { "Data transition iteration failed: #{e}" }
+        break
+      end
+      close_internal
     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
+    def data_transition_iteration
+      message = @mutex_r.synchronize { Message.read_from(@io_r) }
+      IORequest.logger.debug(prog_name) { "Received message: #{message}" }
+      if message.request?
+        in_thread(name: 'responding') { handle_request(message) }
+      else
+        handle_response(message)
       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
+    def handle_request(message)
+      data = @responder&.call(message.data) || {}
+      response = Message.new(data, type: :response, to: message.id)
+      send_response(response)
     end
-    # Receive string.
-    def receive_raw
-      @io_r.gets&.chomp
+
+    def handle_response(message)
+      @responses_access_mutex.synchronize do
+        @responses[message.to.to_s] = message
+        @responses_access_cv.broadcast
+      end
     end
 
-    # Encode string
-    def encode(str)
-      Base64::strict_encode64 str
+    def send_response(response)
+      @mutex_w.synchronize do
+        IORequest.logger.debug(prog_name) { "Sending response: #{response}" }
+        response.write_to(@io_w)
+      end
     end
-    # Decode string
-    def decode(str)
-      Base64::strict_decode64 str
+
+    def send_zero_size_request
+      @mutex_w.synchronize do
+        IORequest.logger.debug(prog_name) { 'Sending zero size message' }
+        @io_w.write([0].pack('S'))
+      end
     end
 
-    # Turn data into string
-    def data_to_string(data)
-      JSON.generate(data)
+    def send_request_and_wait_for_response(request)
+      @mutex_w.synchronize do
+        IORequest.logger.debug(prog_name) { "Sending message: #{request}" }
+        request.write_to(@io_w)
+      end
+      wait_for_response(request)
     end
-    # Turn string into data
-    def string_to_data(str)
-      JSON.parse(str).symbolize_keys!
+
+    def wait_for_response(request)
+      IORequest.logger.debug(prog_name) { "Waiting for response for #{request}" }
+      @responses_access_mutex.synchronize do
+        response = nil
+        until response
+          @responses_access_cv.wait(@responses_access_mutex)
+          response = @responses[request.id.to_s]
+        end
+        IORequest.logger.debug(prog_name) { "Found response: #{response}" }
+        response
+      end
     end
   end
 end