ccrpc 0.3.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 93b1358631d8f55fb408daa3644ff3966d518fdcc0bac693468e679d8ea6a144
-  data.tar.gz: 18c6b183a8904c7ad65ea588ec557be7f063107e3d8c191bf54f1c52fdf16915
+  metadata.gz: a3f1a9ac22e449534ede2f1d3f94efcc11becf3d65d7e868ce1f6334f580ba54
+  data.tar.gz: 70a5849b9f6594090a5069b13d566b39cf53baf69bf5ee743ead1fa56d7bd1a3
 SHA512:
-  metadata.gz: 328200b7e1cfbd503abb5c6503d9efc8851f76c7f964bbeb9ee61986d2a7aa0f89ed318df434bcc14cff28702d1919267bf11516900a26022a2dc9744a95ac88
-  data.tar.gz: 22b0d11ce99abedc64c8e46216025ecd753966f7114ef5351484c0b3c0a2273517a82cc524b1923dcf3dd082b3b81572c388759813d476cde13c1fd24371d95e
+  metadata.gz: 31e497800794295aafed95c1f75b8d2cc866aff6255d94914f0377eb04d7ad3a0009da355bc6f240466a25cd5131de46a56d8845c345f4a67b8896303e79a5e2
+  data.tar.gz: c457015d25201324c856a7fea9b0bc3ccdc0b5a1f9819f7c0758e45f27f3cf4c732b4028fa3e8f9af955a2e14319bde9c6ff6da9e3a3cae09b3cc560e8109520

data/README.md

@@ -1,15 +1,16 @@
-# Ccrpc - A minimalistic RPC library for Ruby
+# Ccrpc - A minimalist 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
+
+* Simple human readable wire protocol and optionally a faster binary protocol
+* Works on arbitrary IO like objects (Pipes, Sockets, STDIN, STDOUT, OpenSSL) 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
+* 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
+* Each `call_back` arrives in the thread of the caller
 * Only dedicated functions can be called (not arbitrary as in DRb)
 * No dependencies
 
@@ -72,7 +73,7 @@ The following example invokes the call in the opposite direction, from the subpr
     require 'ccrpc'
     # Create the receiver side of the connection
     # Use a copy of STDOUT because...
-    rpc = Ccrpc::RpcConnection.new(STDIN, STDOUT.dup)
+    rpc = Ccrpc::RpcConnection.new(STDIN.binmode, STDOUT.dup.binmode)
     # .. STDOUT is now redirected to STDERR, so that pp prints to STDERR
     STDOUT.reopen(STDERR)
     # Call function "hello" with param {"who" => "world"}
@@ -84,10 +85,10 @@ The following example invokes the call in the opposite direction, from the subpr
   tf.write(code)
   tf.flush
   # Execute the temp file in a subprocess
-  io = IO.popen(['ruby', tf.path], "w+")
+  io = IO.popen(['ruby', tf.path], "wb+")
 
   # Create the caller side of the connection
-  rpc = Ccrpc::RpcConnection.new(io, io)
+  rpc = Ccrpc::RpcConnection.new(io, io, protocol: :binary)
   # Wait for calls
   rpc.call do |call|
     # Print the received call data to STDERR
@@ -98,6 +99,8 @@ The following example invokes the call in the opposite direction, from the subpr
   # call returns when the IO is closed by the subprocess
 ```
 
+Full API documentation is here: https://rubydoc.info/gems/ccrpc
+
 
 ## Development
 

data/ccrpc.gemspec

@@ -13,6 +13,7 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = Gem::Requirement.new(">= 2.7.0")
 
   spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["documentation_uri"] = "https://rubydoc.info/gems/ccrpc"
 
   # 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.

data/lib/ccrpc/escape.rb

@@ -5,7 +5,7 @@ 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] }
+      data.gsub(/([\a\r\n\t\\])/n){ "\\x" + $1.unpack1("H2") }
     end
 
     def self.unescape(data)

data/lib/ccrpc/rpc_connection.rb

@@ -76,20 +76,43 @@ class RpcConnection
   end
 
   CallbackReceiver = Struct.new :meth, :callbacks
+  ReceivedCallData = Struct.new :cbfunc, :id, :recv_id
 
+  # The kind of +IO+ object used to receive calls and answers. Set by {initialize}.
   attr_accessor :read_io
+  # The kind of +IO+ object used to send calls and answers. Set by {initialize}.
   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)
+  # @param [Boolean] lazy_answers   Enable or disable lazy results.
+  #    If enabled the return value of #call is always a Ccrpc::Promise object.
+  #    It behaves like an ordinary +nil+ or Hash object, but the actual IO blocking operation is delayed to the first method call on the Promise object.
+  #    See {#call} for more description.
+  # @param [Symbol] protocol   Select the protocol which is used to send calls.
+  #    * The +:text+ protocol is the classic default.
+  #    * The +:binary+ protocol is faster, but not so readable for human.
+  #    * The +:prefer_binary+ is the same as :binary, but with an initial round-trip to check that the other end is binary-capable (means ccrpc >= 0.5).
+  #    The protocol used to receive calls is selected by the *protocol* option on the other end.
+  #    A connection could use different protocols for both directions, although this has no advantage.
+  def initialize(read_io, write_io, lazy_answers: false, protocol: :text)
     super()
 
     @read_io = read_io
     @write_io = write_io
+    @read_binary = false
+    @write_binary = case protocol
+      when :binary
+        true
+      when :text, :only_text # only_text is to simulate ccrpc-0.4.0 peer
+        false
+      when :prefer_binary
+        nil
+      else
+        raise ArgumentError, "invalid protocol: #{protocol.inspect}"
+    end
     if lazy_answers
       require 'ccrpc/lazy'
       alias maybe_lazy do_lazy
@@ -101,27 +124,100 @@ class RpcConnection
       @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
+    @proto_ack_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
+          if @read_binary
+            t = @read_io.read(1)&.getbyte(0)
+            # p @read_io=>t
+            case t
+              when 1
+                keysize, valsize = @read_io.read(8).unpack("NN")
+                key = @read_io.read(keysize).force_encoding(Encoding::UTF_8)
+                value = @read_io.read(valsize).force_encoding(Encoding::UTF_8)
+                y << [key, value]
+              when 2
+                id, funcsize = @read_io.read(8).unpack("NN")
+                func = @read_io.read(funcsize)
+                y << ReceivedCallData.new(func.force_encoding(Encoding::UTF_8), id)
+              when 3
+                id, recv_id, funcsize = @read_io.read(12).unpack("NNN")
+                func = @read_io.read(funcsize)
+                y << ReceivedCallData.new(func.force_encoding(Encoding::UTF_8), id, recv_id)
+              when 4
+                id = @read_io.read(4).unpack1("N")
+                y << id
+              when 79 # "O"
+                l = @read_io.read(6)
+                unless l == "\tK\n\a1\n"
+                  raise InvalidResponse, "invalid binary response #{l.inspect}"
+                end
+                y << ["O", "K"]
+                y << 1
+
+              when NilClass
+                # connection closed
+                break
+
+              else
+                raise InvalidResponse, "invalid binary response #{t.inspect}"
+            end
+
+          else
+
+            l = @read_io.gets&.force_encoding(Encoding::BINARY)
+            # p @read_io=>l
+            case
+              when l=="\r\0\a1\n" && protocol != :only_text
+                @read_binary = true
+              when l=="\r\1\a1\n" && protocol != :only_text
+                @read_binary = true
+                send_answer({O: :K}, 1)
+
+              when l=~/\A([^\t\a\n]+)\t(.*?)\r?\n\z/mn
+                # received key/value pair used for either callback parameters or return values
+                y << [Escape.unescape($1).force_encoding(Encoding::UTF_8), Escape.unescape($2.force_encoding(Encoding::UTF_8))]
+
+              when l=~/\A([^\t\a\n]+)(?:\a(\d+))?(?:\a(\d+))?\r?\n\z/mn
+                # received callback
+                y << ReceivedCallData.new(Escape.unescape($1.force_encoding(Encoding::UTF_8)), $2&.to_i, $3&.to_i)
+
+              when l=~/\A\a(\d+)\r?\n\z/mn
+                # received return event
+                y << $1.to_i
+
+              when l.nil?
+                # connection closed
+                break
+
+              else
+                raise InvalidResponse, "invalid text response #{l.inspect}"
+            end
+          end
         end
       rescue => err
         y << err
       end
     end
+
+    if @write_binary == true # immediate binary mode
+      # Use ID 1 for proto change request to have a fixed string over the wire
+      register_call("\r", 1)
+      @write_io.write "\r\0\a1\n"
+      @write_io.flush
+    end
+
+    # A random number as start call ID is not technically required, but makes transferred data more readable.
+    @id = rand(1000) + 1
   end
 
   private def do_lazy(&block)
@@ -131,11 +227,11 @@ class RpcConnection
     yield
   end
 
-  # Disable reception of data from the read_io object.
+  # Disable reception of data from the {read_io} object.
   #
-  # This function doesn't close the IO objects.
+  # 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.
+  # It can be aborted by calling +IO#close+ on the underlying {read_io} and {write_io} objects.
   def detach
     @read_enum = nil
   end
@@ -143,9 +239,9 @@ class RpcConnection
   # 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} .
+  # * If called with a function name, the block on the other end of the RPC connection is called with that function name.
+  # * If called with a block only, than it receives these kind of calls, which are called anonymous callbacks.
+  # * If 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.
@@ -160,10 +256,11 @@ class RpcConnection
   # @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.
+  #   The Promise object is returned as soon as the RPC call is sent and a callback receiver is registered, 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.
+  #   As soon as any method is called on the Promise object, this method is blocked until the RPC answer was received.
+  #   When the RPC answer has been received, the Promise object then behaves like an ordinary Hash object or +nil+ in case of connection end.
+  #   It is recommended to use +Promise#itself+ to trigger explicit waiting for call answers or callbacks (although any other method triggers waiting as well).
   # @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)
@@ -171,22 +268,24 @@ class RpcConnection
 
   protected
 
-  def call_intern(func, params={}, recv_id=nil, &block)
-    id = next_id if func
+  def register_call(func, id, &block)
+    id ||= next_id if func
 
     @answers_mutex.synchronize do
-      @receivers[id] = CallbackReceiver.new(block_given? ? nil : caller[3], [])
+      @receivers[id] = CallbackReceiver.new(block_given? ? nil : caller[4], [])
     end
+    id
+  end
 
-    send_call(func, params, id, recv_id) if func
-
-    pr = proc do
+  def wait_for_return(id, &block)
+    maybe_lazy 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
+              # invoke the user block
               rets, exit = yield(cb)
               if rets
                 cb.answer = rets
@@ -223,7 +322,12 @@ class RpcConnection
         res
       end
     end
-    func ? maybe_lazy(&pr) : pr.call
+  end
+
+  def call_intern(func, params={}, recv_id=nil, &block)
+    id = register_call(func, nil, &block)
+    send_call(func, params, id, recv_id) if func
+    wait_for_return(id, &block)
   end
 
   def next_id
@@ -232,70 +336,103 @@ class RpcConnection
     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
+  def wait_for_proto_ack
+    @proto_ack_mutex.synchronize do
+      if @write_binary.nil? # acknowledge text/binary mode
+        register_call("\r", 1)
+        @write_mutex.synchronize do
+          @write_io.write "\r\1\a1\n"
+          @write_io.flush
+        end
+        # wait until protocol is acknowledged
+        res = wait_for_return(1)
+        if res == {"O" => "K"}
+          @write_binary = true
+        else
+          @write_binary = false
         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)
+  def send_call_or_answer(params)
     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"
+      params.compact.each do |key, value|
+        if @write_binary
+          k = key.to_s
+          v = value.to_s
+          to_send << [1, k.bytesize, v.bytesize, k, v].pack("CNNa*a*")
+        else
+          to_send << Escape.escape(key.to_s) << "\t" <<
+              Escape.escape(value.to_s) << "\n"
+        end
         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")
+      yield(to_send)
+      @write_io.write(to_send)
+      @write_io.flush
     end
-    @write_io.flush
     after_write
   end
 
+  def send_call(func, params, id, recv_id)
+    wait_for_proto_ack unless recv_id
+    send_call_or_answer(params) do |to_send|
+      if @write_binary
+        f = func.to_s
+        if recv_id
+          to_send << [3, id, recv_id, f.bytesize, f].pack("CNNNa*")
+        else
+          to_send << [2, id, f.bytesize, f].pack("CNNa*")
+        end
+      else
+        to_send << Escape.escape(func.to_s) << "\a#{id}"
+        to_send << "\a#{recv_id}" if recv_id
+        to_send << "\n"
+      end
+    end
+  end
+
+  def send_answer(answer, id)
+    send_call_or_answer(answer) do |to_send|
+      if @write_binary
+        to_send << [4, id].pack("CN")
+      else
+        to_send << "\a#{id}" if id
+        to_send << "\n"
+      end
+    end
+  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
+        when Array
+          rets[l[0]] ||= l[1]
 
-          callback = Call.new(self, Escape.unescape(cbfunc.force_encoding(Encoding::UTF_8)).to_sym, rets, id)
+        when ReceivedCallData
+          # received callback
+          callback = Call.new(self, l.cbfunc.to_sym, rets, l.id)
 
           @answers_mutex.synchronize do
-            receiver = @receivers[recv_id]
+            receiver = @receivers[l.recv_id]
 
             if !receiver
-              if recv_id
-                raise NoCallbackDefined, "call_back to #{cbfunc.inspect} was received, but corresponding call returned already"
+              if l.recv_id
+                raise NoCallbackDefined, "call_back to #{l.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"
+                raise NoCallbackDefined, "call to #{l.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}"
+              raise NoCallbackDefined, "call_back to #{l.cbfunc.inspect} was received, but corresponding call was called without a block in #{meth}"
             end
 
             receiver.callbacks << callback
@@ -303,9 +440,10 @@ class RpcConnection
           end
           return
 
-        when /\A\a(\d+)\r?\n\z/mn
+        when Integer
           # received return event
-          id = $1.to_i
+          id = l
+
           @answers_mutex.synchronize do
             @answers[id] = rets
             @new_answer.broadcast

data/lib/ccrpc/version.rb

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

metadata

@@ -1,35 +1,38 @@
 --- !ruby/object:Gem::Specification
 name: ccrpc
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.5.0
 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=
+  MIIEBDCCAmygAwIBAgIBAzANBgkqhkiG9w0BAQsFADAoMSYwJAYDVQQDDB1sYXJz
+  L0RDPWdyZWl6LXJlaW5zZG9yZi9EQz1kZTAeFw0yNDEyMjkxOTU2NTZaFw0yNTEy
+  MjkxOTU2NTZaMCgxJjAkBgNVBAMMHWxhcnMvREM9Z3JlaXotcmVpbnNkb3JmL0RD
+  PWRlMIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEAwum6Y1KznfpzXOT/
+  mZgJTBbxZuuZF49Fq3K0WA67YBzNlDv95qzSp7V/7Ek3NCcnT7G+2kSuhNo1FhdN
+  eSDO/moYebZNAcu3iqLsuzuULXPLuoU0GsMnVMqV9DZPh7cQHE5EBZ7hlzDBK7k/
+  8nBMvR0mHo77kIkapHc26UzVq/G0nKLfDsIHXVylto3PjzOumjG6GhmFN4r3cP6e
+  SDfl1FSeRYVpt4kmQULz/zdSaOH3AjAq7PM2Z91iGwQvoUXMANH2v89OWjQO/NHe
+  JMNDFsmHK/6Ji4Kk48Z3TyscHQnipAID5GhS1oD21/WePdj7GhmbF5gBzkV5uepd
+  eJQPgWGwrQW/Z2oPjRuJrRofzWfrMWqbOahj9uth6WSxhNexUtbjk6P8emmXOJi5
+  chQPnWX+N3Gj+jjYxqTFdwT7Mj3pv1VHa+aNUbqSPpvJeDyxRIuo9hvzDaBHb/Cg
+  9qRVcm8a96n4t7y2lrX1oookY6bkBaxWOMtWlqIprq8JZXM9AgMBAAGjOTA3MAkG
+  A1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQWBBQ4h1tIyvdUWtMI739xMzTR
+  7EfMFzANBgkqhkiG9w0BAQsFAAOCAYEAoZZWzNV2XXaoSmvyamSSN+Wt/Ia+DNrU
+  2pc3kMEqykH6l1WiVPszr6HavQ//2I2UcSRSS5AGDdiSXcfyFmHtMBdtJHhTPcn7
+  4DLliB0szpvwG+ltGD8PI8eWkLaTQeFzs+0QCTavgKV+Zw56Q0J5zZvHHUMrLkUD
+  qhwKjdTdkrRTn9Sqi0BrIRRZGTUDdrt8qoWm35aES5arKZzytgrRD/kXfFW2LCg0
+  FzgTKibR4/3g8ph94kQLg/D2SMlVPkQ3ECi036mZxDC2n8V6u3rDkG5923wmrRZB
+  J6cqz475Q8HYORQCB68OPzkWMfC7mBo3vpSsIqRoNs1FE4FJu4FGwZG8fBSrDC4H
+  bZe+GtyS3e2SMjgT65zp35gLO9I7MquzYN9P6V2u1iBpTycchk5z9R1ghxzZSBT8
+  DrkJ9tVlPQtJB0LqT0tvBap4upnwT1xYq721b5dwH6AF4Pi6iz/dc5vnq1/MH8bV
+  8VbbBzzeE7MsvgkP3sHlLmY8PtuyViJ8
   -----END CERTIFICATE-----
-date: 2024-07-11 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: Simple bidirectional and thread safe RPC protocol. Works on arbitrary
   Ruby IO objects.
@@ -60,7 +63,7 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/larskanis/ccrpc
-post_install_message:
+  documentation_uri: https://rubydoc.info/gems/ccrpc
 rdoc_options: []
 require_paths:
 - lib
@@ -75,8 +78,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Simple bidirectional RPC protocol
 test_files: []