ccrpc 0.3.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 93b1358631d8f55fb408daa3644ff3966d518fdcc0bac693468e679d8ea6a144
+  data.tar.gz: 18c6b183a8904c7ad65ea588ec557be7f063107e3d8c191bf54f1c52fdf16915
+SHA512:
+  metadata.gz: 328200b7e1cfbd503abb5c6503d9efc8851f76c7f964bbeb9ee61986d2a7aa0f89ed318df434bcc14cff28702d1919267bf11516900a26022a2dc9744a95ac88
+  data.tar.gz: 22b0d11ce99abedc64c8e46216025ecd753966f7114ef5351484c0b3c0a2273517a82cc524b1923dcf3dd082b3b81572c388759813d476cde13c1fd24371d95e

data/.github/workflows/ci.yml

@@ -0,0 +1,36 @@
+name: CI
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: "0 6 * * 3" # At 05:00 on Wednesday # https://crontab.guru/#0_5_*_*_3
+  push:
+    branches:
+      - master
+    tags:
+      - "*.*.*"
+  pull_request:
+    types: [opened, synchronize]
+    branches:
+      - "*"
+permissions:
+  contents: read
+
+jobs:
+  specs:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ ubuntu-latest, macos-latest, windows-latest ]
+        ruby: [ 2.7, 3.0, 3.1, 3.2, 3.3, ruby-head, truffleruby-head, jruby-head ]
+        exclude:
+        - os: windows-latest
+          ruby: truffleruby-head
+    runs-on: ${{ matrix.os }}
+    steps:
+    - uses: actions/checkout@v4
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+
+    - run: bundle install
+    - run: bundle exec rake test TESTOPTS=-v

data/.gitignore

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

data/.gitlab-ci.yml

@@ -0,0 +1,15 @@
+.job_template: &job_definition
+  before_script:
+    - ruby -v
+    - bundle install -j$(nproc)
+
+  script:
+    - bundle exec rake test
+
+test-2.7:
+  <<: *job_definition
+  image: comcard/ruby:2.7
+
+test-latest:
+  <<: *job_definition
+  image: comcard/ruby:latest

data/.travis.yml

@@ -0,0 +1,6 @@
+---
+language: ruby
+cache: bundler
+rvm:
+  - 2.7.1
+before_install: gem install bundler -v 2.1.4

data/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in ccrpc.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+gem "minitest", "~> 5.0"
+gem "yard"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Lars Kanis
+
+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,115 @@
+# Ccrpc - A minimalistic RPC library for Ruby
+
+Features:
+* Simple human readable wire protocol
+* Works on arbitrary ruby IO objects (Pipes, Sockets, STDIN, STDOUT) even Windows CR/LF converting IOs
+* No object definitions - only plain string transfers (so no issues with undefined classes or garbage collection like in DRb)
+* Each call transfers a function name and a list of parameters in form of a Hash<String=>String>
+* Each response equally transfers a list of parameters
+* Similar to closures, it's possible to respond to a particular call as a call_back
+* Fully asynchronous, either by use of multiple threads or by using lazy_answers, so that arbitrary calls in both directions can be mixed simultaneously without blocking each other
+* Fully thread safe, but doesn't use additional internal threads
+* Each call_back arrives in the thread of the caller
+* Only dedicated functions can be called (not arbitrary as in DRb)
+* No dependencies
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ccrpc'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install ccrpc
+
+## Usage
+
+Fork a subprocess and communicate with it through pipes
+```ruby
+  require 'ccrpc'
+
+  ar, aw = IO.pipe # pipe to send data to the forking process
+  br, bw = IO.pipe # pipe to send data to the forked process
+  fork do
+    ar.close; bw.close
+    # Create the receiver side of the connection
+    rpc = Ccrpc::RpcConnection.new(br, aw)
+    # Wait for calls
+    rpc.call do |call|
+      # Print the received call data
+      pp func: call.func, params: call.params  # =>  {:func=>:hello, :params=>{"who"=>"world"}}
+      # The answer of the subprocess
+      {my_answer: 'hello back'}
+    end
+  end
+  br.close; aw.close
+
+  # Create the caller side of the connection
+  rpc = Ccrpc::RpcConnection.new(ar, bw)
+  # Call function "hello" with param {"who" => "world"}
+  pp rpc.call(:hello, who: 'world')  # => {"my_answer"=>"hello back"}
+```
+
+Communicate with a subprocess through STDIN and STDOUT.
+Since STDIN and STDOUT are used for the RPC connection, it's best zu redirect STDOUT to STDERR after the RPC object is created.
+This avoids clashes between "p" calls and the RPC protocol.
+
+The following example invokes the call in the opposite direction, from the subprocess to the main process.
+
+```ruby
+  require 'ccrpc'
+
+  # The code of the subprocess:
+  code = <<-EOT
+    require 'ccrpc'
+    # Create the receiver side of the connection
+    # Use a copy of STDOUT because...
+    rpc = Ccrpc::RpcConnection.new(STDIN, STDOUT.dup)
+    # .. STDOUT is now redirected to STDERR, so that pp prints to STDERR
+    STDOUT.reopen(STDERR)
+    # Call function "hello" with param {"who" => "world"}
+    pp rpc.call(:hello, who: 'world')  # => {"my_answer"=>"hello back"}
+  EOT
+
+  # Write the code to a temp file
+  tf = Tempfile.new('rpc')
+  tf.write(code)
+  tf.flush
+  # Execute the temp file in a subprocess
+  io = IO.popen(['ruby', tf.path], "w+")
+
+  # Create the caller side of the connection
+  rpc = Ccrpc::RpcConnection.new(io, io)
+  # Wait for calls
+  rpc.call do |call|
+    # Print the received call data to STDERR
+    pp func: call.func, params: call.params  # =>  {:func=>:hello, :params=>{"who"=>"world"}}
+    # The answer of the subprocess
+    {my_answer: 'hello back'}
+  end
+  # call returns when the IO is closed by the subprocess
+```
+
+
+## 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/larskanis/ccrpc.
+
+
+## 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 "ccrpc"
+
+# 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/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ccrpc.gemspec

@@ -0,0 +1,25 @@
+require_relative 'lib/ccrpc/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ccrpc"
+  spec.version       = Ccrpc::VERSION
+  spec.authors       = ["Lars Kanis"]
+  spec.email         = ["lars@greiz-reinsdorf.de"]
+
+  spec.summary       = %q{Simple bidirectional RPC protocol}
+  spec.description   = %q{Simple bidirectional and thread safe RPC protocol. Works on arbitrary Ruby IO objects.}
+  spec.homepage      = "https://github.com/larskanis/ccrpc"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.7.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+
+  # 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"]
+end

data/lib/ccrpc/escape.rb

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+# -*- frozen_string_literal: true -*-
+
+module Ccrpc
+  module Escape
+    def self.escape(data)
+      data = data.b if data.frozen? || data.encoding != Encoding::BINARY
+      data.gsub(/([\a\r\n\t\\])/n){ "\\x" + $1.unpack("H2")[0] }
+    end
+
+    def self.unescape(data)
+      data.b.gsub(/\\x([0-9a-fA-F]{2,2})/n){ [$1].pack("H*") }.force_encoding(Encoding::UTF_8)
+    end
+  end
+end

data/lib/ccrpc/lazy.rb

@@ -0,0 +1,135 @@
+# -*- frozen_string_literal: true -*-
+# = lazy.rb -- Lazy evaluation in Ruby
+#
+# Author:: MenTaLguY
+#
+# Copyright 2005-2006  MenTaLguY <mental@rydia.net>
+#
+# You may redistribute it and/or modify it under the same terms as Ruby.
+#
+
+require 'thread'
+
+module Ccrpc
+  # Raised when a forced computation diverges (e.g. if it tries to directly
+  # use its own result)
+  #
+  class DivergenceError < RuntimeError
+    def initialize( message="Computation diverges" )
+      super( message )
+    end
+  end
+
+  # Wraps an exception raised by a lazy computation.
+  #
+  # The reason we wrap such exceptions in LazyException is that they need to
+  # be distinguishable from similar exceptions which might normally be raised
+  # by whatever strict code we happen to be in at the time.
+  #
+  class LazyException < DivergenceError
+    # the original exception
+    attr_reader :reason
+
+    def initialize( reason )
+      @reason = reason
+      super( "#{ reason } (#{ reason.class })" )
+      set_backtrace( reason.backtrace.dup ) if reason
+    end
+  end
+
+  # A promise is just a magic object that springs to life when it is actually
+  # used for the first time, running the provided block and assuming the
+  # identity of the resulting object.
+  #
+  # This impersonation isn't perfect -- a promise wrapping nil or false will
+  # still be considered true by Ruby -- but it's good enough for most purposes.
+  # If you do need to unwrap the result object for some reason (e.g. for truth
+  # testing or for simple efficiency), you may do so via Kernel.demand.
+  #
+  # Formally, a promise is a placeholder for the result of a deferred computation.
+  #
+  class Promise
+    alias __class__ class #:nodoc:
+    instance_methods.each { |m| undef_method m unless m =~ /^__|^object_id$|^instance_variable|^frozen\?$/ }
+
+    def initialize( &computation ) #:nodoc:
+      @mutex = Mutex.new
+      @computation = computation
+      @exception = nil
+    end
+
+    # create this once here, rather than creating a proc object for
+    # every evaluation
+    DIVERGES = lambda {|promise| raise DivergenceError.new } #:nodoc:
+    def DIVERGES.inspect #:nodoc:
+      "DIVERGES"
+    end
+
+    def __result__ #:nodoc:
+      @mutex.synchronize do
+        if @computation
+          raise @exception if @exception
+
+          computation = @computation
+          @computation = DIVERGES # trap divergence due to over-eager recursion
+
+          begin
+            @result = Promise.demand( computation.call( self ) )
+            @computation = nil
+          rescue DivergenceError => exception
+            @exception = exception
+            raise
+          rescue Exception => exception
+            # handle exceptions
+            @exception = LazyException.new( exception )
+            raise @exception
+          end
+        end
+
+        @result
+      end
+    end
+
+    def inspect #:nodoc:
+      @mutex.synchronize do
+        if @computation
+          "#<#{ __class__ } computation=#{ @computation.inspect }>"
+        else
+          @result.inspect
+        end
+      end
+    end
+
+    def marshal_dump
+      __result__
+      Marshal.dump( [ @exception, @result ] )
+    end
+
+    def marshal_load( str )
+      @mutex = Mutex.new
+      ( @exception, @result ) = Marshal.load( str )
+      @computation = DIVERGES if @exception
+    end
+
+    def respond_to?( message, include_all=false ) #:nodoc:
+      message = message.to_sym
+      message == :__result__ or
+      message == :inspect or
+      message == :marshal_dump or
+      message == :marshal_load or
+      __result__.respond_to?(message, include_all)
+    end
+
+    ruby2_keywords def method_missing( *args, &block ) #:nodoc:
+      __result__.__send__( *args, &block )
+    end
+
+    def self.demand( promise )
+      if promise.respond_to? :__result__
+        promise.__result__
+      else # not really a promise
+        promise
+      end
+    end
+  end
+end

data/lib/ccrpc/rpc_connection.rb

@@ -0,0 +1,327 @@
+# -*- coding: utf-8 -*-
+# -*- frozen_string_literal: true -*-
+###########################################################################
+#    Copyright (C) 2015 to 2024 by Lars Kanis
+#    <lars@greiz-reinsdorf.de>
+#
+# Copyright: See COPYING file that comes with this distribution
+###########################################################################
+#
+# RPC Connection
+#
+
+require 'thread'
+require_relative 'escape'
+
+module Ccrpc
+class RpcConnection
+  class InvalidResponse < RuntimeError
+  end
+  class NoCallbackDefined < RuntimeError
+  end
+  class CallAlreadyReturned < NoCallbackDefined
+  end
+  class DoubleResultError < RuntimeError
+  end
+  class ConnectionDetached < RuntimeError
+  end
+  class ReceiverAlreadyDefined < RuntimeError
+  end
+
+  # The context of a received call.
+  class Call
+    # @return [RpcConnection]  The used connection.
+    attr_reader :conn
+    # @return [String]  Called function
+    attr_reader :func
+    # @return [Hash{String => String}] List of parameters passed with the call.
+    attr_reader :params
+    attr_reader :id
+    # @return [Hash{String => String}] List of parameters send back to the called.
+    attr_reader :answer
+
+    # @private
+    def initialize(conn, func, params={}, id)
+      @conn = conn
+      @func = func
+      @params = params
+      @id = id
+      @answer = nil
+    end
+
+    # Send the answer back to the caller.
+    #
+    # @param [Hash{String, Symbol => String, Symbol}] value  The answer parameters to be sent to the caller.
+    def answer=(value)
+      raise DoubleAnswerError, "More than one answer to #{self.inspect}" if @answer
+      @answer = value
+      conn.send(:send_answer, value, id)
+    end
+
+    # Send a dedicated callback to the caller's block.
+    #
+    # If {RpcConnection#call} is called with both function name and block, then it's possible to call back to this dedicated block through {#call_back} .
+    # The library ensures, that the callback ends up in the corresponding call block and in the same thread as the caller, even if there are multiple simultaneous calls are running at the same time in different threads or by using +lazy_answers+ .
+    #
+    # @param func [String, Symbol]  The RPC function to be called on the other side.
+    #   The other side must wait for calls through {#call} with function name and with a block.
+    # @param params [Hash{Symbol, String => Symbol, String}]  Optional parameters passed with the RPC call.
+    #   They can be retrieved through {Call#params} on the receiving side.
+    #
+    # Yielded parameters and returned objects are described in {RpcConnection#call}.
+    def call_back(func, params={}, &block)
+      raise CallAlreadyReturned, "Callback is no longer possible since the call already returned #{self.inspect}" if @answer
+      conn.send(:call_intern, func, params, @id, &block)
+    end
+  end
+
+  CallbackReceiver = Struct.new :meth, :callbacks
+
+  attr_accessor :read_io
+  attr_accessor :write_io
+
+  # Create a RPC connection
+  #
+  # @param [IO] read_io   readable IO object for reception of data
+  # @param [IO] write_io   writable IO object for transmission of data
+  # @param [Boolean] lazy_answers   Enable or disable lazy results. See {#call} for more description.
+  def initialize(read_io, write_io, lazy_answers: false)
+    super()
+
+    @read_io = read_io
+    @write_io = write_io
+    if lazy_answers
+      require 'ccrpc/lazy'
+      alias maybe_lazy do_lazy
+    else
+      alias maybe_lazy dont_lazy
+    end
+
+    if @write_io.respond_to?(:setsockopt)
+      @write_io.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, true)
+    end
+
+    # A random number as start call ID is not technically required, but makes transferred data more readable.
+    @id = rand(1000)
+    @id_mutex = Mutex.new
+    @read_mutex = Mutex.new
+    @write_mutex = Mutex.new
+    @answers = {}
+    @receivers = {}
+    @answers_mutex = Mutex.new
+    @new_answer = ConditionVariable.new
+
+    @read_enum = Enumerator.new do |y|
+      begin
+        while @read_enum
+          l = @read_io.gets&.force_encoding(Encoding::BINARY)
+          break if l.nil?
+          y << l
+        end
+      rescue => err
+        y << err
+      end
+    end
+  end
+
+  private def do_lazy(&block)
+    Promise.new(&block)
+  end
+  private def dont_lazy
+    yield
+  end
+
+  # Disable reception of data from the read_io object.
+  #
+  # This function doesn't close the IO objects.
+  # A waiting reception is not aborted by this call.
+  # It can be aborted by calling IO#close on the underlying read_io and write_io objects.
+  def detach
+    @read_enum = nil
+  end
+
+  # Do a RPC call and/or wait for a RPC call from the other side.
+  #
+  # {#call} must be called with either a function name (and optional parameters) or with a block or with both.
+  # If {#call} is called with a function name, the block on the other side of the RPC connection is called with that function name.
+  # If {#call} is called with a block only, than it receives these kind of calls, which are called anonymous callbacks.
+  # If {#call} is called with a function name and a block, then the RPC function on the other side is called and it is possible to call back to this dedicated block by invoking {Call#call_back} .
+  #
+  # @param func [String, Symbol]  The RPC function to be called on the other side.
+  #   The other side must wait for calls through {#call} without arguments but with a block.
+  # @param params [Hash{Symbol, String => Symbol, String}]  Optional parameters passed with the RPC call.
+  #   They can be retrieved through {Call#params} on the receiving side.
+  #
+  # @yieldparam [Ccrpc::Call] block  The context of the received call.
+  # @yieldreturn [Hash{String, Symbol => String, Symbol}] The answer parameters to be sent back to the caller.
+  # @yieldreturn [Array<Hash>] Two element array with the answer parameters as the first element and +true+ as the second.
+  #   By this answer type the answer is sent to other side but the reception of further calls or callbacks is stopped subsequently and the local corresponding {#call} method returns with +nil+.
+  #
+  # @return [Hash]  Received answer parameters.
+  # @return [Promise] Received answer parameters enveloped by a Promise.
+  #   This type of answers can be enabled by +RpcConnection#new(lazy_answers: true)+
+  #   The Promise object is returned as soon as the RPC call is sent, but before waiting for the corresponding answer.
+  #   This way several calls can be send in parallel without using threads.
+  #   As soon as a method is called on the Promise object, this method is blocked until the RPC answer was received.
+  #   The Promise object then behaves like a Hash object.
+  # @return [NilClass] Waiting for further answers was stopped gracefully by either returning +[hash, true]+ from the block or because the connection was closed.
+  def call(func=nil, params={}, &block)
+    call_intern(func, params, &block)
+  end
+
+  protected
+
+  def call_intern(func, params={}, recv_id=nil, &block)
+    id = next_id if func
+
+    @answers_mutex.synchronize do
+      @receivers[id] = CallbackReceiver.new(block_given? ? nil : caller[3], [])
+    end
+
+    send_call(func, params, id, recv_id) if func
+
+    pr = proc do
+      @answers_mutex.synchronize do
+        res = loop do
+          # Is a callback pending for this thread?
+          if cb=@receivers[id].callbacks.shift
+            @answers_mutex.unlock
+            begin
+              rets, exit = yield(cb)
+              if rets
+                cb.answer = rets
+              end
+              break if exit
+            ensure
+              @answers_mutex.lock
+            end
+
+          # Is a call return pending for this thread?
+          elsif a=@answers.delete(id)
+            break a
+
+          # Unless some other thread is already reading from the read_io, do it now
+          elsif @read_mutex.try_lock
+            @answers_mutex.unlock
+            begin
+              break if receive_answers
+            ensure
+              @read_mutex.unlock
+              @answers_mutex.lock
+              # Send signal possibly again to prevent deadlock if another thread started waiting before we re-locked the @answers_mutex
+              @new_answer.signal
+            end
+
+          # Wait for signal from other thread about a new call return or callback was received
+          else
+            @new_answer.wait(@answers_mutex)
+          end
+        end
+
+        @receivers.delete(id)
+
+        res
+      end
+    end
+    func ? maybe_lazy(&pr) : pr.call
+  end
+
+  def next_id
+    @id_mutex.synchronize do
+      @id = (@id + 1) & 0xffffffff
+    end
+  end
+
+  def send_call(func, params, id, recv_id=nil)
+    to_send = String.new
+    @write_mutex.synchronize do
+      params.reject{|k,v| v.nil? }.each do |key, value|
+        to_send << Escape.escape(key.to_s) << "\t" <<
+            Escape.escape(value.to_s) << "\n"
+        if to_send.bytesize > 9999
+          @write_io.write to_send
+          to_send = String.new
+        end
+      end
+      to_send << Escape.escape(func.to_s) << "\a#{id}"
+      to_send << "\a#{recv_id}" if recv_id
+      @write_io.write(to_send << "\n")
+    end
+    @write_io.flush
+    after_write
+  end
+
+  def send_answer(answer, id)
+    to_send = String.new
+    @write_mutex.synchronize do
+      answer.reject{|k,v| v.nil? }.each do |key, value|
+        to_send << Escape.escape(key.to_s) << "\t" <<
+            Escape.escape(value.to_s) << "\n"
+        if to_send.bytesize > 9999
+          @write_io.write to_send
+          to_send = String.new
+        end
+      end
+      to_send << "\a#{id}" if id
+      @write_io.write(to_send << "\n")
+    end
+    @write_io.flush
+    after_write
+  end
+
+  def receive_answers
+    rets = {}
+    (@read_enum || raise(ConnectionDetached, "connection already detached")).each do |l|
+      case l
+        when Exception
+          raise l
+        when /\A([^\t\a\n]+)\t(.*?)\r?\n\z/mn
+          # received key/value pair used for either callback parameters or return values
+          rets[Escape.unescape($1).force_encoding(Encoding::UTF_8)] ||= Escape.unescape($2.force_encoding(Encoding::UTF_8))
+
+        when /\A([^\t\a\n]+)(?:\a(\d+))?(?:\a(\d+))?\r?\n\z/mn
+          # received callback
+          cbfunc, id, recv_id = $1, $2&.to_i, $3&.to_i
+
+          callback = Call.new(self, Escape.unescape(cbfunc.force_encoding(Encoding::UTF_8)).to_sym, rets, id)
+
+          @answers_mutex.synchronize do
+            receiver = @receivers[recv_id]
+
+            if !receiver
+              if recv_id
+                raise NoCallbackDefined, "call_back to #{cbfunc.inspect} was received, but corresponding call returned already"
+              else
+                raise NoCallbackDefined, "call to #{cbfunc.inspect} was received, but there is no #{self.class}#call running"
+              end
+            elsif meth=receiver.meth
+              raise NoCallbackDefined, "call_back to #{cbfunc.inspect} was received, but corresponding call was called without a block in #{meth}"
+            end
+
+            receiver.callbacks << callback
+            @new_answer.broadcast
+          end
+          return
+
+        when /\A\a(\d+)\r?\n\z/mn
+          # received return event
+          id = $1.to_i
+          @answers_mutex.synchronize do
+            @answers[id] = rets
+            @new_answer.broadcast
+          end
+          return
+
+        else
+          raise InvalidResponse, "invalid response #{l.inspect}"
+      end
+    end
+    detach
+    return true
+  end
+
+  # Can be overwritten by subclasses to make use of idle time while waiting for answers.
+  def after_write
+  end
+end
+end

data/lib/ccrpc/version.rb

@@ -0,0 +1,3 @@
+module Ccrpc
+  VERSION = "0.3.1"
+end

data/lib/ccrpc.rb

@@ -0,0 +1,5 @@
+module Ccrpc
+  autoload :RpcConnection, "ccrpc/rpc_connection"
+  autoload :Escape, "ccrpc/escape"
+  autoload :VERSION, "ccrpc/version"
+end

data.tar.gz.sig

@@ -0,0 +1 @@
+�=EB!�|7^��S��zB?���,�Men%쓐o���γ���l08B�ur�p���^���|s�B{.X�D��93�����t���Mb���J�/�ɂ�W/jI�<���#G�������M�Czn{�&�Cd��Z�m�E9>I
͉�Hl��h�uV{��䗧����PB��fet54;O��F��k����ڥwF�g�;��~���.U�lna5�u

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: ccrpc
+version: !ruby/object:Gem::Version
+  version: 0.3.1
+platform: ruby
+authors:
+- Lars Kanis
+autorequire:
+bindir: exe
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDLjCCAhagAwIBAgIBDDANBgkqhkiG9w0BAQsFADA9MQ4wDAYDVQQDDAVrYW5p
+  czEXMBUGCgmSJomT8ixkARkWB2NvbWNhcmQxEjAQBgoJkiaJk/IsZAEZFgJkZTAe
+  Fw0yNDA1MDIxMTAwNDVaFw0yNTA1MDIxMTAwNDVaMD0xDjAMBgNVBAMMBWthbmlz
+  MRcwFQYKCZImiZPyLGQBGRYHY29tY2FyZDESMBAGCgmSJomT8ixkARkWAmRlMIIB
+  IjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEApop+rNmg35bzRugZ21VMGqI6
+  HGzPLO4VHYncWn/xmgPU/ZMcZdfj6MzIaZJ/czXyt4eHpBk1r8QOV3gBXnRXEjVW
+  9xi+EdVOkTV2/AVFKThcbTAQGiF/bT1n2M+B1GTybRzMg6hyhOJeGPqIhLfJEpxn
+  lJi4+ENAVT4MpqHEAGB8yFoPC0GqiOHQsdHxQV3P3c2OZqG+yJey74QtwA2tLcLn
+  Q53c63+VLGsOjODl1yPn/2ejyq8qWu6ahfTxiIlSar2UbwtaQGBDFdb2CXgEufXT
+  L7oaPxlmj+Q2oLOfOnInd2Oxop59HoJCQPsg8f921J43NCQGA8VHK6paxIRDLQID
+  AQABozkwNzAJBgNVHRMEAjAAMAsGA1UdDwQEAwIEsDAdBgNVHQ4EFgQUvgTdT7fe
+  x17ugO3IOsjEJwW7KP4wDQYJKoZIhvcNAQELBQADggEBAH+LA+CcA9vbbqtuhK4J
+  lG1lQwA+hCKiueQgVsepNbXyDzx6PMC8ap/bFaKSaoUWABBA/bsh3jDNXT/eVZrN
+  lFP8cVGrznSYIBG8D/QQmJKpvDBJgnC4Zk01HkhYlqJC4qCTn9X+/uZNHLPLbAEL
+  xl3P43zyL3GQb1IP9bp0xV6oxwG9FO9Rk8bYDojky/69ylowFI5aODS39v01Siu2
+  FsEjM9tMSNb7lQRywQ/432KXi+8AAPTm+wdGnlt3wLE9w2TTpGUBsNKk+QiytTZO
+  zwbjAdVlRm0pg/vpDzzFmRf1GYVckMm8hpCRt8BP0akAbNyw1snYvZBwgLqxztru
+  bEo=
+  -----END CERTIFICATE-----
+date: 2024-07-11 00:00:00.000000000 Z
+dependencies: []
+description: Simple bidirectional and thread safe RPC protocol. Works on arbitrary
+  Ruby IO objects.
+email:
+- lars@greiz-reinsdorf.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/ci.yml"
+- ".gitignore"
+- ".gitlab-ci.yml"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- ccrpc.gemspec
+- lib/ccrpc.rb
+- lib/ccrpc/escape.rb
+- lib/ccrpc/lazy.rb
+- lib/ccrpc/rpc_connection.rb
+- lib/ccrpc/version.rb
+homepage: https://github.com/larskanis/ccrpc
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/larskanis/ccrpc
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.11
+signing_key:
+specification_version: 4
+summary: Simple bidirectional RPC protocol
+test_files: []

metadata.gz.sig

@@ -0,0 +1 @@
+I�}
�17��ˎ�F�ȯ~W�����4ٍn��^+0