xchan.rb 0.23.0 → 0.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4bf62c9fb6b3813e464c25bcd2e99f860a7a106ff85ea3e8e564f8a0d16e160b
-  data.tar.gz: 1e1868a087396c56e176c9fff11d4086e4b30d6d5cc09968c48261212317e8dc
+  metadata.gz: 181f4b9e1add150781f56e06f8d6d011a7474e55a501a6dce1713c975d52280d
+  data.tar.gz: 96b2056582afaa5f67f774c626a21cb9f8feadb09aea346150bcf685660e4dce
 SHA512:
-  metadata.gz: '0095b2e81e0f76c47fb8f3fc402945956b9865b16e119e85f2d1aa3e9ab1ff90e7ed63214871298bea7da759a7a7f9b8c38a57c87c0bf5d541d3ae6491be1956'
-  data.tar.gz: 5b21ab069f5be98a2f14fa596492654a73b90efb5e25a670cbb3aa81f034927ef77e954d589dab1504f627010933f335ba84f84e0749fe236c802b040d29a6eb
+  metadata.gz: ab568cfe894198659cb45e72759dfa7daa95b290d647a1d633225e83093eb86f28b1a2c13e47b38d8626d2a275cbd80364416b15dbff050c6e2ba4ac36aff76c
+  data.tar.gz: 2a45fd7441fb2312d1fcfce43ad6f53fe60ad7c304a833667a22e7024c06a74ad21b6b235b1950835e71ddd49f43b03c958662ed92b746bc52829cead23db9da

data/README.md

@@ -1,4 +1,16 @@
-## About
+<p align="center">
+  <a href="https://r.uby.dev">
+    <img
+      src="rubydev.svg"
+      width="400"
+      height="200"
+      border="0"
+      alt="a r.uby.dev project"
+     >
+  </a>
+</p>
+
+> [r.uby.dev](https://r.uby.dev/llm) project.
 
 xchan.rb is an easy to use library for InterProcess Communication (IPC).
 
@@ -245,22 +257,12 @@ print "The maximum size of a single message is: ", sndbuf.int, " bytes.\n"
 # The maximum size of a single message is: 2048 bytes.
 ```
 
-## Documentation
-
-A complete API reference is available at
-[0x1eef.github.io/x/xchan.rb](https://0x1eef.github.io/x/xchan.rb/)
-
 ## Install
 
 xchan.rb can be installed via rubygems.org:
 
     gem install xchan.rb
 
-## Sources
-
-* [github.com/@0x1eef](https://github.com/0x1eef/xchan.rb#readme)
-* [gitlab.com/@0x1eef](https://gitlab.com/0x1eef/xchan.rb#about)
-
 ## License
 
 [BSD Zero Clause](https://choosealicense.com/licenses/0bsd/)

data/lib/xchan/unix_socket.rb

@@ -285,13 +285,35 @@ class Chan::UNIXSocket
   end
 
   ##
-  # Waits for the channel to become lockable
+  # Waits for the channel to become lockable, and takes the lock.
+  #
+  # Without a timeout the wait is `lockf(F_LOCK)`, which blocks in the
+  # kernel: the releaser wakes the waiter, so there is no interval to poll
+  # on - a lock held for microseconds is released with a wakeup rather than
+  # up to a tick of the loop below.
+  #
+  # **The caller comes back holding the lock**, which is what the retry in
+  # `send` and `recv` expects, and why the release paths are theirs. With a
+  # timeout the channel comes back as it was, because that loop gives up
+  # rather than acquires.
+  #
+  # The acquisition is no longer under `@mutex`, where it used to be - only
+  # the release is. With threads the two ends can therefore belong to
+  # different threads, which is a redundant retry at worst: `lockf` locks
+  # are held per process and give no intra-process exclusion at all, and
+  # every socket operation still happens under a successfully taken
+  # `F_TLOCK`.
+  #
   # @param [Float, Integer, nil] 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)
+    if timeout.nil?
+      @lock.lock
+      return self
+    end
     start = (timeout ? gettime : nil)
     loop do
       break(nil) if start && (gettime - start) >= timeout

data/lib/xchan/version.rb

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

data/test/xchan_test.rb

@@ -227,6 +227,8 @@ end
 ##
 # Chan::UNIXSocket#wait_lockable
 class Chan::WaitLockableTest < Chan::Test
+  include Timeout
+
   def test_wait_lockable_on_lockable_channel
     assert_instance_of Chan::UNIXSocket, ch.wait_lockable
   end
@@ -241,6 +243,27 @@ class Chan::WaitLockableTest < Chan::Test
     aux.close
   end
 
+  ##
+  # Without a timeout the wait is a blocking lock rather than a loop, so
+  # the answer can only arrive because the release woke the child - a lock
+  # that was never contended would answer either way, and a timeout would
+  # answer before the release at all.
+  def test_wait_lockable_without_a_timeout_on_a_locked_channel
+    aux = xchan(:pure)
+    lock! do
+      pid = fork { aux.send ch.wait_lockable.class.to_s }
+      ##
+      # Long enough that the child is inside the lock rather than between
+      # two calls, and then the release.
+      sleep 0.1
+      release!
+      Process.wait(pid)
+    end
+    assert_equal "Chan::UNIXSocket", timeout(5) { aux.recv }
+  ensure
+    aux.close
+  end
+
   def test_wait_lockable_on_null_lock
     ch = xchan(:pure, lock: :null)
     assert_instance_of Chan::UNIXSocket, ch.wait_lockable
@@ -261,4 +284,3 @@ class Chan::WaitLockableTest < Chan::Test
     ch.instance_variable_get(:@lock).release
   end
 end
-

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: xchan.rb
 version: !ruby/object:Gem::Version
-  version: 0.23.0
+  version: 0.24.0
 platform: ruby
 authors:
 - '0x1eef'