xchan.rb 0.20.0 → 0.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3faafc7100339e243744b476b137e7ee96591179027c862509006c60df6c7fe1
-  data.tar.gz: b7abc06e3a789f1f80a171e520c2cd3a64126c11e8bc01795bf90c4fcb5601bc
+  metadata.gz: 2d385aa7803c7861610c50348dec4108760bf2e0a21d36bd6a9402788ec56f62
+  data.tar.gz: 5292469bfb8a3cc8fb581d12ecde445cef46551000604b6e8d1c3b9ca96b2d93
 SHA512:
-  metadata.gz: 1a14ea31ccd8ae96a56d4dfc667fe0141906a8d0123f3ba184e524ad07b4586b205501c870aec02f0af33d47d6ac8b788f023174afcddf8d6d1b90e853a3b40b
-  data.tar.gz: 98c9e23a2abd39852fdd315011c44385b6c57a1a9a000e0d9430580a36a3970091857482d7866c58c765015fce7cbb6523a9b3e411daa2c5520b79f911efaf05
+  metadata.gz: 10b83c2ad3e4861715b4348f0e4aa54e9f84377fa08acf3fb59caaccbb164909326ae1d527afaac5bed6a7401a4981942f75b767a370cb276553784ab0bce2b0
+  data.tar.gz: 990ed1ae55dba125d7f95a4e2d2477353b7bddeaa275149713fc2769fd36cea564ebe179567fe93924b1a37bc18f9e4c51ea7da1310587c34c94190975154fb8

data/README.md

@@ -1,12 +1,8 @@
-> **Designed for minimalism** <br>
-> One direct runtime dependency ([lockf.rb](https://github.com/0x1eef/lockf.rb#readme)) <br>
-> Zero indirect dependencies outside Ruby's standard library
-
 ## About
 
-xchan.rb is an easy to use, minimalist library for
-InterProcess Communication (IPC). The library provides a channel
-that can help facilitate communication between Ruby
+xchan.rb is an easy to use library for InterProcess Communication (IPC).
+
+The library provides a channel that can help facilitate communication between Ruby
 processes who have a parent &lt;=&gt; child relationship.
 A channel lock is provided by
 [lockf(3)](https://man.freebsd.org/cgi/man.cgi?query=lockf&sektion=3) and a temporary, unlinked file to protect against race conditions

data/lib/xchan/unix_socket.rb

@@ -45,6 +45,9 @@ class Chan::UNIXSocket
     @bytes = Chan::Bytes.new(tmpdir)
     @counter = Chan::Counter.new(tmpdir)
     @lock = Chan.locks[lock]&.call(tmpdir) || lock
+    @mutex = Mutex.new
+    @partial = nil
+    @partial_len = 0
   end
 
   ##
@@ -81,7 +84,11 @@ class Chan::UNIXSocket
   #  Returns the number of bytes written to the channel
   def send(object)
     send_nonblock(object)
-  rescue Chan::WaitWritable, Chan::WaitLockable
+  rescue Chan::WaitWritable
+    wait_writable
+    retry
+  rescue Chan::WaitLockable
+    wait_lockable
     retry
   end
   alias_method :write, :send
@@ -99,17 +106,21 @@ class Chan::UNIXSocket
   # @return [Integer, nil]
   #  Returns the number of bytes written to the channel
   def send_nonblock(object)
-    @lock.lock_nonblock
-    raise IOError, "channel closed" if closed?
-    len = @w.write_nonblock(serialize(object))
-    @bytes.push(len)
-    @counter.increment!(bytes_written: len)
-    len.tap { @lock.release }
-  rescue IOError, IO::WaitWritable, Errno::ENOBUFS => ex
-    @lock.release
-    raise Chan::WaitWritable, ex.message
-  rescue Errno::EWOULDBLOCK => ex
-    raise Chan::WaitLockable, ex.message
+    @mutex.synchronize do
+      @lock.lock_nonblock
+      raise IOError, "channel closed" if closed?
+      data = serialize(object)
+      head = [data.bytesize].pack("Q>")
+      n = @w.write_nonblock(head << data)
+      @bytes.push(data.bytesize)
+      @counter.increment!(bytes_written: data.bytesize)
+      data.bytesize.tap { @lock.release }
+    rescue IOError, IO::WaitWritable, Errno::ENOBUFS => ex
+      @lock.release
+      raise Chan::WaitWritable, ex.message
+    rescue Errno::EWOULDBLOCK => ex
+      raise Chan::WaitLockable, ex.message
+    end
   end
   alias_method :write_nonblock, :send_nonblock
 
@@ -131,6 +142,7 @@ class Chan::UNIXSocket
     wait_readable
     retry
   rescue Chan::WaitLockable
+    wait_lockable
     retry
   end
   alias_method :read, :recv
@@ -146,21 +158,43 @@ class Chan::UNIXSocket
   # @return [Object]
   #  Returns an object from the channel
   def recv_nonblock
-    @lock.lock_nonblock
-    raise IOError, "closed channel" if closed?
-    len = @bytes.shift
-    obj = deserialize(@r.read_nonblock(len.zero? ? 1 : len))
-    @counter.increment!(bytes_read: len)
-    obj.tap { @lock.release }
-  rescue IOError => ex
-    @lock.release
-    raise(ex)
-  rescue IO::WaitReadable => ex
-    @bytes.unshift(len)
-    @lock.release
-    raise Chan::WaitReadable, ex.message
-  rescue Errno::EAGAIN => ex
-    raise Chan::WaitLockable, ex.message
+    @mutex.synchronize do
+      @lock.lock_nonblock
+      raise IOError, "closed channel" if closed?
+      stream = @r.local_address.socktype == Socket::SOCK_STREAM
+      unless @partial
+        if stream
+          head = String.new
+          while head.bytesize < 8
+            head << @r.read_nonblock(8 - head.bytesize)
+          end
+          @partial_len = head.unpack1("Q>")
+          @partial = String.new(capacity: @partial_len)
+        else
+          buf = @r.read_nonblock(65536)
+          @partial_len = buf[0, 8].unpack1("Q>")
+          @partial = buf[8, @partial_len]
+        end
+        @bytes.shift
+      end
+      if stream
+        while @partial.bytesize < @partial_len
+          @partial << @r.read_nonblock(@partial_len - @partial.bytesize)
+        end
+      end
+      obj = deserialize(@partial)
+      @counter.increment!(bytes_read: @partial.bytesize)
+      @partial = nil
+      obj.tap { @lock.release }
+    rescue IOError => ex
+      @lock.release
+      raise(ex)
+    rescue IO::WaitReadable => ex
+      @lock.release
+      raise Chan::WaitReadable, ex.message
+    rescue Errno::EAGAIN => ex
+      raise Chan::WaitLockable, ex.message
+    end
   end
   alias_method :read_nonblock, :recv_nonblock
 
@@ -188,6 +222,13 @@ class Chan::UNIXSocket
     lock { size.zero? }
   end
 
+  ##
+  # @return [Integer]
+  #  Returns the number of elements waiting to be read
+  def size
+    @bytes.size
+  end
+
   ##
   # @group Stat methods
 
@@ -208,14 +249,16 @@ class Chan::UNIXSocket
   alias_method :bytes_read, :bytes_received
 
   ##
-  # @return [Integer]
-  #  Returns the number of objects waiting to be read
-  def size
-    lock { @bytes.size }
-  end
+  # @endgroup
 
   ##
-  # @endgroup
+  # @return [void]
+  def flush
+    @lock.lock
+    to_a
+  ensure
+    @lock.release
+  end
 
   ##
   # @group Wait methods
@@ -223,7 +266,8 @@ class Chan::UNIXSocket
   ##
   # Waits for the channel to become readable
   # @param [Float, Integer, nil] timeout
-  #  The number of seconds to wait. Waits indefinitely with no arguments.
+  #  The number of seconds to wait before timeout.
+  #  Waits indefinitely with no arguments
   # @return [Chan::UNIXSocket, nil]
   #  Returns self when the channel is readable, otherwise returns nil
   def wait_readable(timeout = nil)
@@ -233,7 +277,8 @@ class Chan::UNIXSocket
   ##
   # Waits for the channel to become writable
   # @param [Float, Integer, nil] timeout
-  #  The number of seconds to wait. Waits indefinitely with no arguments.
+  #  The number of seconds to wait before timeout.
+  #  Waits indefinitely with no arguments
   # @return [Chan::UNIXSocket, nil]
   #  Returns self when the channel is writable, otherwise returns nil
   def wait_writable(timeout = nil)
@@ -243,8 +288,10 @@ class Chan::UNIXSocket
   ##
   # Waits for the channel to become lockable
   # @param [Float, Integer, nil] timeout
-  #  The number of seconds to wait before timeout
+  #  The number of seconds to wait before timeout.
+  #  Waits indefinitely with no arguments
   # @return [Chan::UNIXSocket, nil]
+  #  Returns self when the channel is lockable, otherwise returns nil
   def wait_lockable(timeout = nil)
     start = (timeout ? gettime : nil)
     loop do

data/lib/xchan/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Chan
-  VERSION = "0.20.0"
+  VERSION = "0.22.0"
 end

data/test/thread_safety_test.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "xchan"
+require "test/unit"
+
+class ThreadSafetyTest < Test::Unit::TestCase
+  ##
+  # Without a Mutex wrapping the critical sections in send_nonblock and
+  # recv_nonblock, lockf(3) record locks do not provide thread safety
+  # because they are per-process (PID-based). Two threads sharing the
+  # same channel can both acquire the lock simultaneously, causing the
+  # @bytes and @counter tempfiles to be read and written concurrently.
+  #
+  # This test reproduces the race by having one thread write many
+  # messages while another reads them. A mismatch between the byte
+  # length recorded by @bytes.push and the actual data read from the
+  # socket triggers Marshal.load errors.
+  def test_concurrent_send_and_recv
+    ch = xchan(:marshal)
+    n = 1000
+    writer = Thread.new do
+      n.times { ch.send("hello") }
+    end
+    reader = Thread.new do
+      count = 0
+      n.times do
+        ch.recv
+        count += 1
+      end
+      count
+    end
+    count = [writer, reader].map(&:value).last
+    assert_equal n, count
+  ensure
+    ch.close unless ch.closed?
+  end
+
+  def test_concurrent_send_nonblock_and_recv_nonblock
+    ch = xchan(:marshal)
+    n = 1000
+    writer = Thread.new do
+      n.times { ch.send("world") }
+    end
+    reader = Thread.new do
+      count = 0
+      n.times do
+        ch.recv
+        count += 1
+      end
+      count
+    end
+    count = [writer, reader].map(&:value).last
+    assert_equal n, count
+  ensure
+    ch.close unless ch.closed?
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: xchan.rb
 version: !ruby/object:Gem::Version
-  version: 0.20.0
+  version: 0.22.0
 platform: ruby
 authors:
 - '0x1eef'
@@ -146,6 +146,7 @@ files:
 - share/xchan.rb/examples/write_operations/2_nonblocking_write.rb
 - test/readme_test.rb
 - test/setup.rb
+- test/thread_safety_test.rb
 - test/xchan_test.rb
 - xchan.rb.gemspec
 homepage: https://github.com/0x1eef/xchan.rb#readme
@@ -166,7 +167,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.6
 specification_version: 4
 summary: An easy to use InterProcess Communication (IPC) library
 test_files: []