Up to [cvs.NetBSD.org] / pkgsrc / devel / ruby-async
Request diff between arbitrary revisions
Keyword substitution: kv
Default branch: MAIN
devel/ruby-async: update to 2.46.0 2.46.0 (2026-09-13) * Fixed Thread#kill raising a TypeError while shutting down a thread with an active Async::Reactor.
devel/ruby-async: update to 2.45.1 2.45.0 (20260-08-26) * Fixed scheduler I/O and process waits returning prematurely after stale or interrupted wake-ups. I/O waits now preserve their original timeout, while blocking process waits retry and non-blocking Process::WNOHANG waits still return nil. 2.45.1 (2026-08-28) * Fixed Scheduler#io_wait returning nil instead of false when an explicit timeout expired. Native callers such as Socket#connect with connect_timeout: distinguish a timeout by checking for false, so the nil caused TypeError: no implicit conversion from nil to integer instead of the intended IO::TimeoutError.
devel/ruby-async: update to 2.44.1 2.44.1 (2026-08-05) * Improve Async and Sync documentation. (#465)
devel/ruby-async: update to 2.44.0 2.44.0 (2026-07-29) * Fixed scheduler cleanup after forking while other fibers are blocked.
devel/ruby-async: update to 2.43.0 2.43.0 (2026-07-22) * Propagate cancellation causes through task trees so child tasks observe the original cancellation cause.
devel/ruby-async: update to 2.42.0 2.42.0 (2026-07-02) * Sync and Async can now be invoked from a non-blocking fiber that has no scheduler (e.g. inside an Enumerator or a bare Fiber.new). Previously this raised RuntimeError: Running scheduler on non-blocking fiber!. The reactor is now run within Fiber.blocking, so the scheduler always runs on a blocking fiber.
devel/ruby-async: update to 2.41.0 2.40.0 (2026-06-24) * Introduce Async::Condition#waiting_count. This allows you to see how many tasks are currently waiting on the condition, which can be useful for debugging and monitoring purposes. 2.41.0 (2026-06-28) * Fixed: Protect initial task from Interrupt exceptions.
devel/ruby-async: update to 2.39.0 2.38.0 (2026-03-08) * Rename Task#stop to Task#cancel for better clarity and consistency with common concurrency terminology. The old stop method is still available as an alias for backward compatibility, but it is recommended to use cancel going forward. * Forward arguments from Task#wait -> Promise#wait, so task.wait(timeout: N) is supported. 2.38.1 (2026-03-17) * Fix Barrier#async when parent.async yields before the child block executes. Previously, Barrier#wait could return early and miss tracking the task entirely, because the task had not yet appended itself to the barrier's task list. 2.39.0 (2026-04-05) * Async::Barrier#wait now returns the number of tasks that were waited for, or nil if there were no tasks to wait for. This provides better feedback about the operation, and allows you to know how many tasks were involved in the wait.
devel/ruby-async: downgrade to 2.37.0 Version 2.38.0 silently increase minimum version of Ruby to 3.3. At this time, downgrading to 2.37.0 which supports Ruby 3.2.
devel/ruby-async: update to 2.38.0 2.37.0 (2026-03-08) * Introduce Async::Loop for robust, time-aligned loops. * Add support for Async::Promise#wait(timeout: N). 2.38.0 (2026-03-08) * Rename Task#stop to Task#cancel for better clarity and consistency with common concurrency terminology. The old stop method is still available as an alias for backward compatibility, but it is recommended to use cancel going forward. * Forward arguments from Task#wait -> Promise#wait, so task.wait(timeout: N) is supported.
devel/ruby-async: update to 2.36.0 2.36.0 (2026-01-22) * Better class Task documentation. * Introduce Task.wait_all. (#441) * Introduce Task#join alias.
devel/ruby-async: update to 2.35.3 2.35.3 (2026-01-15) * Add Clock#as_json and Clock#to_json.
devel/ruby-async: update to 2.35.2 2.35.0 (2025-11-30) * Process.fork is now properly handled by the Async fiber scheduler, ensuring that the scheduler state is correctly reset in the child process after a fork. This prevents issues where the child process inherits the scheduler state from the parent, which could lead to unexpected behavior. 2.35.1 (2026-01-02) * Fix incorrect handling of spurious wakeups in Async::Promise#wait, which could lead to premature (incorrect) resolution of the promise. 2.35.2 (2026-01-11) * Improved handling of Process.fork on Ruby 4+. * Improve @promise state handling in Task#initialize, preventing incomplete instances being visible to the scheduler.
devel/ruby-async: update to 2.34.0
2.33.0 (2025-09-29)
* Introduce Async::Promise.fulfill for optional promise resolution.
2.34.0 (2025-10-08)
Kernel::Barrier Convenience Interface
Starting multiple concurrent tasks and waiting for them to finish is a
common pattern. This change introduces a small ergonomic helper, Barrier,
defined in Kernel, that encapsulates this behavior: it creates an
Async::Barrier, yields it to a block, waits for completion (using Sync to
run a reactor if needed), and ensures remaining tasks are stopped on exit.
require 'async'
Barrier do |barrier|
3.times do |i|
barrier.async do |task|
sleep(rand * 0.1) # Simulate work
puts "Task #{i} completed"
end
end
end
# All tasks are guaranteed to complete or be stopped when the block exits.
If an exception is raised by a task, it will be propagated to the caller,
and any remaining tasks will be stopped. The parent: parameter can be used
to specify a parent task for the barrier, otherwise it will use the current
task if available, or create a new reactor if not.
devel/ruby-async: update to 2.32.0
2.29.0 (2025-09-04)
This release introduces thread-safety as a core concept of Async. Many core
classes now have thread-safe guarantees, allowing them to be used safely
across multiple threads.
* Thread-safe Async::Condition and Async::Notification, implemented using
Thread::Queue.
* Thread-safe Async::Queue and Async::LimitedQueue, implemented using
Thread::Queue and Thread::LimitedQueue respectively.
* Async::Variable is deprecated in favor of Async::Promise.
Introduce Async::Promise
This release introduces the new Async::Promise class and refactors
Async::Task to use promises for state management internally. This
architectural improvement achieves the design goal that "a task should be a
promise with attached computation and cancellation handling."
* Thread-safe promise implementation with immutable state transitions.
* Consistent state management using symbols: :completed, :failed,
:cancelled.
* Promise cancellation with cancel() method and Cancel exception class.
* Comprehensive test coverage with 47 new test cases covering all edge
cases.
require 'async/promise'
# Basic promise usage - works independently of Async framework
promise = Async::Promise.new
# In another thread or fiber, resolve the promise
Thread.new do
sleep(1) # Simulate some work
promise.resolve("Hello, World!")
end
# Wait for the result
result = promise.wait
puts result # => "Hello, World!"
# Check promise state
puts promise.resolved? # => true
puts promise.completed? # => true
Promises bridge Thread and Fiber concurrency models - a promise resolved in
one thread can be awaited in a fiber, and vice versa.
Introduce Async::PriorityQueue
The new Async::PriorityQueue provides a thread-safe, fiber-aware queue where
consumers can specify priority levels. Higher priority consumers are served
first when items become available, with FIFO ordering maintained for equal
priorities. This is useful for implementing priority-based task processing
systems where critical operations need to be handled before lower priority
work.
require 'async'
require 'async/priority_queue'
Async do
queue = Async::PriorityQueue.new
# Start consumers with different priorities
low_priority = async do
puts "Low priority consumer got: #{queue.dequeue(priority: 1)}"
end
medium_priority = async do
puts "Medium priority consumer got: #{queue.dequeue(priority: 5)}"
end
high_priority = async do
puts "High priority consumer got: #{queue.dequeue(priority: 10)}"
end
# Add items to the queue
queue.push("first item")
queue.push("second item")
queue.push("third item")
# Output:
# High priority consumer got: first item
# Medium priority consumer got: second item
# Low priority consumer got: third item
end
2.29.1 (2025-09-05)
* Better handling of waiter invalidation in PriorityQueue. (#419)
2.30.0 (2025-09-08)
* Add timeout support to Async::Queue#dequeue and Async::Queue#pop methods.
* Add timeout support to Async::PriorityQueue#dequeue and
Async::PriorityQueue#pop methods.
* Add closed? method to Async::PriorityQueue for full queue interface
compatibility.
* Support non-blocking operations using timeout: 0 parameter.
2.31.0 (2025-09-08)
* Introduce Async::Deadline for precise timeout management in compound
operations.
2.32.0 (2025-09-11)
* Introduce Queue#waiting_count and PriorityQueue#waiting_count. Generally
for statistics/testing purposes only.
devel/ruby-async: update to 2.28.1 2.28.1 (2025-09-01) * Fix race condition between Async::Barrier#stop and finish signalling.
devel/ruby-async: update to 2.28.0 2.28.0 (2025-08-25) * Use Traces.current_context and Traces.with_context for better integration with OpenTelemetry.
devel/ruby-async: update to 2.27.4 2.27.4 (2025-08-20) * Suppress excessive warning in Async::Scheduler#async.
devel/ruby-async: update to 2.27.3 2.27.3 (2025-08-15) * Ensure trace attributes are strings, fixes integration with OpenTelemetry.
devel/ruby-async: update to 2.27.2 2.27.1 (2025-08-05) * Updated documentation and agent context. 2.27.2 (2025-08-05) * Fix context/index.yaml schema.
devel/ruby-async: update to 2.27.0
2.25.0
* Added support for io_select hook in the fiber scheduler, allowing
non-blocking IO.select operations. This enables better integration with
code that uses IO.select for multiplexing IO operations.
- Use IO::Event::WorkerPool for Blocking Operations
- Better handling of IO#close using fiber_interrupt
2.26.0
* Async::Notification#signal now returns true if a task was signaled, false
otherwise, providing better feedback for notification operations.
* require "async/limited_queue" is required to use Async::LimitedQueue
without a deprecation warning. Async::LimitedQueue is not deprecated, but
it's usage via async/queue is deprecated.
* Async::Task#sleep is deprecated with no replacement.
* Async::Task.yield is deprecated with no replacement.
* Async::Scheduler#async is deprecated, use Async{}, Sync{} or
Async::Task#async instead.
* Agent context is now available, via the agent-context gem.
* Async::Barrier Improvements
Async::Barrier now provides more flexible and predictable behavior for
waiting on task completion:
- Completion-order waiting: barrier.wait now processes tasks in the order
they complete rather than the order they were created. This provides
more predictable behavior when tasks have different execution times.
- Block-based waiting: barrier.wait now accepts an optional block that
yields each task as it completes, allowing for custom handling of
individual tasks.
- Partial completion support: The new block-based interface allows you to
wait for only the first N tasks to complete.
* Introduce Async::Queue#close
Async::Queue and Async::LimitedQueue can now be closed, which provides
better resource management and error handling:
- New close method: Both queue types now have a close method that prevents
further items from being added and signals any waiting tasks.
- Consistent error handling: All queue modification methods (push,
enqueue, <<) now raise Async::Queue::ClosedError when called on a closed
queue.
- Waiting task signaling: When a queue is closed, any tasks waiting on
dequeue (for regular queues) or enqueue (for limited queues) are
properly signaled and can complete.
2.27.0
* Async::Task#stop supports an optional cause: argument (that defaults to
$!), which allows you to specify the cause (exception) for stopping the
task.
* Add thread-safety agent context.
devel/ruby-async: update to 2.24.0
2.24.0 (2025-05-03)
* Ruby v3.1 support is dropped.
* Async::Wrapper which was previously deprecated, is now removed.
Flexible Timeouts
When {ruby Async::Scheduler#with_timeout} is invoked with a block, it can
receive a {ruby Async::Timeout} instance. This allows you to adjust or
cancel the timeout while the block is executing. This is useful for
long-running tasks that may need to adjust their timeout based on external
factors.
Async do
Async::Scheduler.with_timeout(5) do |timeout|
# Do some work that may take a while...
if some_condition
timeout.cancel! # Cancel the timeout
else
# Add 10 seconds to the current timeout:
timeout.adjust(10)
# Reduce the timeout by 10 seconds:
timeout.adjust(-10)
# Set the timeout to 10 seconds from now:
timeout.duration = 10
# Increase the current duration:
timeout.duration += 10
end
end
end
devel/ruby-async: update to 2.23.1 2.23.1 (2025-03-10) * Fixed a tiny typo in the debugging docs (#377) * Remove GitS from readme.
devel/ruby-async: update to 2.23.0
2.23.0 (2025-02-13)
* Rename ASYNC_SCHEDULER_DEFAULT_WORKER_POOL to ASYNC_SCHEDULER_WORKER_POOL.
Fiber Stall Profiler
After several iterations of experimentation, we are officially introducing
the fiber stall profiler, implemented using the optional fiber-profiler gem.
This gem is not included by default, but can be added to your project:
$ bundle add fiber-profiler
After adding the gem, you can enable the fiber stall profiler by setting the
FIBER_PROFILER_CAPTURE=true environment variable:
$ FIBER_PROFILER_CAPTURE=true bundle exec ruby -rasync -e 'Async{Fiber.blocking{sleep 0.1}}'
Fiber stalled for 0.105 seconds
-e:1 in c-call '#<Class:Fiber>#blocking' (0.105s)
-e:1 in c-call 'Kernel#sleep' (0.105s)
Skipped 1 calls that were too short to be meaningful.
The fiber profiler will help you find problems with your code that cause the
event loop to stall, which can be a common source of performance issues in
asynchronous code.
devel/ruby-async: update to 2.22.0 2.22.0 (2025-02-07) * Prefer bare sleep. * Updated scheduler guide. * Add Async::Clock#reset!. * Add async.task.finished metric.
devel/ruby-async: update to 2.21.1
2.19.0 (2024-11-08)
Async::Scheduler Debugging
Occasionally on issues, I encounter people asking for help and I need more
information. Pressing Ctrl-C to exit a hung program is common, but it
usually doesn't provide enough information to diagnose the problem. Setting
the CONSOLE_LEVEL=debug environment variable will now print additional
information about the scheduler when you interrupt it, including a backtrace
of the current tasks.
> CONSOLE_LEVEL=debug bundle exec ruby ./test.rb
^C 0.0s debug: Async::Reactor [oid=0x974] [ec=0x988] [pid=9116] [2024-11-08 14:12:03 +1300]
| Scheduler interrupted: Interrupt
| #<Async::Reactor:0x0000000000000974 1 children (running)>
| #<Async::Task:0x000000000000099c /Users/samuel/Developer/socketry/async/lib/async/scheduler.rb:185:in `transfer' (running)>
| → /Users/samuel/Developer/socketry/async/lib/async/scheduler.rb:185:in `transfer'
| /Users/samuel/Developer/socketry/async/lib/async/scheduler.rb:185:in `block'
| /Users/samuel/Developer/socketry/async/lib/async/scheduler.rb:207:in `kernel_sleep'
| /Users/samuel/Developer/socketry/async/test.rb:7:in `sleep'
| /Users/samuel/Developer/socketry/async/test.rb:7:in `sleepy'
| /Users/samuel/Developer/socketry/async/test.rb:12:in `block in <top (required)>'
| /Users/samuel/Developer/socketry/async/lib/async/task.rb:197:in `block in run'
| /Users/samuel/Developer/socketry/async/lib/async/task.rb:420:in `block in schedule'
/Users/samuel/Developer/socketry/async/lib/async/scheduler.rb:317:in `select': Interrupt
... (backtrace continues) ...
This gives better visibility into what the scheduler is doing, and should
help diagnose issues.
Console Shims
The async gem depends on console gem, because my goal was to have good
logging by default without thinking about it too much. However, some users
prefer to avoid using the console gem for logging, so I've added an
experimental set of shims which should allow you to bypass the console gem
entirely.
require 'async/console'
require 'async'
Async{raise "Boom"}
Will now use Kernel#warn to print the task failure warning:
#<Async::Task:0x00000000000012d4 /home/samuel/Developer/socketry/async/lib/async/task.rb:104:in `backtrace' (running)>
Task may have ended with unhandled exception.
(irb):4:in `block in <top (required)>': Boom (RuntimeError)
from /home/samuel/Developer/socketry/async/lib/async/task.rb:197:in `block in run'
from /home/samuel/Developer/socketry/async/lib/async/task.rb:420:in `block in schedule'
2.20.0 (2024-11-10)
Traces and Metrics Providers
Async now has traces and metrics providers for various core classes. This
allows you to emit traces and metrics to a suitable backend (including
DataDog, New Relic, OpenTelemetry, etc.) for monitoring and debugging
purposes.
To take advantage of this feature, you will need to introduce your own
config/traces.rb and config/metrics.rb. Async's own repository includes
these files for testing purposes, you could copy them into your own project
and modify them as needed.
2.21.0 (2024-11-21)
(No release note, not released?)
2.21.1 (2024-11-27)
Worker Pool
Ruby 3.4 will feature a new fiber scheduler hook, blocking_operation_wait
which allows the scheduler to redirect the work given to rb_nogvl to a
worker pool.
The Async scheduler optionally supports this feature using a worker pool, by using the following environment variable:
ASYNC_SCHEDULER_DEFAULT_WORKER_POOL=true
This will cause the scheduler to use a worker pool for general blocking
operations, rather than blocking the event loop.
It should be noted that this isn't a net win, as the overhead of using a
worker pool can be significant compared to the rb_nogvl work. As such, it
is recommended to benchmark your application with and without the worker
pool to determine if it is beneficial.
devel/ruby-async: update to 2.18.0 2.18.0 (2024-10-29) * Add support for Sync(annotation:), so that you can annotate the block with a description of what it does, even if it doesn't create a new task.
devel/ruby-async: update to 2.17.0
2.15.0 (2024-08-04)
* Allow transient tasks to exit completely. (#336)
2.15.1 (2024-08-07)
* Allow transient tasks to exit gracefully. (#337)
2.15.2 (2024-08-07)
* Transient tasks should only be stopped once. (#338)
2.15.3 (2024-08-08)
* Ensure that defer_stop resets state. (#339)
2.16.0 (2024-08-23)
Better Handling of Async and Sync in Nested Fibers
Interleaving bare fibers within Async and Sync blocks should not cause
problems, but it presents a number of issues in the current implementation.
Tracking the parent-child relationship between tasks, when they are
interleaved with bare fibers, is difficult. The current implementation
assumes that if there is no parent task, then it should create a new
reactor. This is not always the case, as the parent task might not be
visible due to nested Fibers. As a result, Async will create a new reactor,
trying to stop the existing one, causing major internal consistency issues.
I encountered this issue when trying to use Async within a streaming
response in Rails. The protocol-rack uses a normal fiber to wrap streaming
responses, and if you try to use Async within it, it will create a new
reactor, causing the server to lock up.
Ideally, Async and Sync helpers should work when any Fiber.scheduler is
defined. Right now, it's unrealistic to expect Async::Task to work in any
scheduler, but at the very least, the following should work:
reactor = Async::Reactor.new # internally calls Fiber.set_scheduler
# This should run in the above reactor, rather than creating a new one.
Async do
puts "Hello World"
end
In order to do this, bare Async and Sync blocks should use Fiber.scheduler
as a parent if possible.
See #340 for more details.
2.16.1 (2024-08-26)
* Add timeout to timeout error message.
2.17.0 (2024-09-05)
* Introduce Async::Queue#push and Async::Queue#pop for compatibility with
::Queue.
xdevel/ruby-async: update to 2.14.2 2.14.1 (2024-07-15) * Minor updates to compatibility guide. * Add initial debugging guide. * Restore error logging. (#331) * Remove unused gem dependency. * Use direct instance variable for async_task. 2.14.2 (2024-07-17) * Fix failure logs and add explicit tests.
devel/ruby-async: update to 2.14.1 2.14.1 (2024-07-15) * Minor updates to compatibility guide. * Add initial debugging guide. * Restore error logging. (#331) * Use direct instance variable for async_task.
devel/ruby-async: update to 2.14.0 2.14.0 (2024-07-14) * Opt-in to task failures using $DEBUG only. * Update external tests - drop async-io.
devel/ruby-async: update to 2.13.0 2.13.0 (2024-07-12) * Update logo. * Waiter#async: pass options to parent (#327) * Minor documentation updates. * Allow queue to be used for task finished. (#276)
devel/ruby-async: update to 2.12.1 2.12.1 (2024-06-23) * Docs: correct ruby version requirement * Docs: various typo fixes * Fix idle load computation. (#323) * Propagate interrupts when exiting event loop. (#322)
devel/ruby-async: update to 2.12.0 2.12.0 (2024-06-04) * Add dining philosopher's example. * Prefer IO::Event::Timers. (#316) * Add benchmark timers dependencies.
devel/ruby-async: update to 2.11.0 2.10.2 (2024-04-15) What's Changed * Update readme.md - fixing a typo by @peychinov in #313 * Add source_code_uri to published gemspec. New Contributors * @peychinov made their first contribution in #313 Contributors * @peychinov 2.11.0 (2024-05-04) What's Changed * Update dependency on console gem and modernize usage. by @ioquatix in #315 Contributors * @ioquatix
devel/ruby-async: update to 2.10.1 2.10.0 (2024-03-27) * Introduce Async::Task#defer_stop by @ioquatix in #310 2.10.1 (2024-03-27) * Raise stop directly in #defer_stop. by @ioquatix in #311
devel/ruby-async: update to 2.9.0 2.9.0 (2024-03-05) What's Changed * Introduce Scheduler#load and Async::Idler for load shedding and saturation. (#309)
devel/ruby-async: update to 2.8.2 2.8.2 (2024-02-24) What's Changed * Fix compatibility with quoting change. by @ioquatix in #307 * Better handling of interrupts during stop/terminate. by @ioquatix in #308
devel/ruby-async: update to 2.8.1 2.7.0 (2024-01-02) What's Changed * Try testing on Ruby 3.3. by @ioquatix in #294 * Add support for IO#timeout in io_read, io_write and io_wait. by @ioquatix in #296 2.8.0 (2024-01-03) What's Changed * Allow Interrupt to retry the run loop after issuing #stop. by @ioquatix in #297 * Add write timeout test. by @ioquatix in #298 2.8.1 (2024-02-01) What's Changed * Don't enable io_write hook on Ruby < 3.3.1 as it's buggy. by @ioquatix in #303
devel/ruby-async: update to 2.6.5 2.6.5 (2023-10-29) * Guide: ensure url exists in block (#278) * Improved documentation. * Remove duplicate attr :annotation.
devel/ruby-async: update to 2.6.4 2.6.4 (2023-08-25) * If a task returns an exception value, do not raise it in #wait. (#270) * Minor improvement to test performance. * Test multiple process waits. (#273) * Failing timeout while getting from stdin. (#266) * Fix handling of TimeoutError in io_wait. (#274) * Add test for blocking IO#gets in task. (#267)
devel/ruby-async: update to 2.6.3
2.6.3 (2023-07-28)
* Documentation improvements. (#248)
* Modernize gem. (#249)
* Extended documentation. (#250)
- Consistent usage of reactor/event loop terminology.
- Show how to use `ensure` with barrier.
- Expanded documentation / questions / answers.
- Add best practices.
* Improve readme.
* Add code of conduct.
* Replace 3.times do with 1.upto(3) do.
* Fix guide lines, fixes #251.
* Fix Markdown syntax highlighting marker (#252)
* Guide: ensure barrier is in scope (#253)
- This change avoids a NoMethodError on the barrier local variable. And
also a LoadError, with the Async::Barrier constant.
* Follow-up barrier in scope docs fix (#254)
- This makes the same change as #253 but in this file.
* Don't run scheduler when there is a pending exception. (#262)
* Ensure the scheduler is cleaned up on exit.
* Better handling of interrupted flag. (#264)
devel/ruby-async: update to 2.6.2 2.6.2 (2023-06-13) What's Changed * Don't allow event loop to be interrupted at any time. by @ioquatix in #223
devel/ruby-async: update to 2.6.1 2.6.0 (2023-06-07) What's Changed * Fix trasient typo; make general syntax and punctuation edits to readme by @ColinDKelley in #235 * Better error handling when scheduler is closed. by @ioquatix in #240 * Delegate to Fiber#annotate where possible. by @ioquatix in #241 * Fix handling of stop stopping the stopping task. by @ioquatix in #242 * Strip device suffix before resolving hostname. by @ioquatix in #243 New Contributors * @ColinDKelley made their first contribution in #235 2.6.1 (2023-06-09) What's Changed * Ensure transient tasks are correctly terminated. by @ioquatix in #245
devel/ruby-async: update to 2.5.1 2.5.1 (2023-05-15) * LimitedBarrier was renamed to Waiter (#231)
devel/ruby-async: update to 2.5.0 2.5.0 Latest (2023-03-19) What's Changed * Improved state handling by @ioquatix in #222
devel/ruby-async: update to 2.4.2 2.4.1 (2023-03-07) * Allow running the test in isolation. * Avoid race conditions in Scheduler#interrupt and Scheduler#unblock. (#216) 2.4.2 (2023-03-11) * Ensure all tasks are completed before closing scheduler. (#219)
devel/ruby-async: update to 2.4.0 2.4.0 (2023-03-02) What's Changed * Allow assigning to semaphore limit. by @ioquatix in #215
devel/ruby-async: update to 2.3.1 2.3.1 (2022-12-27) No release note. Please refer commit log <https://github.com/socketry/async/compare/v2.3.0...v2.3.1> in detail.
devel/ruby-async: update to 2.3.0 2.3.0 (2022-12-03) What's Changed * Convert tests to sus. by @ioquatix in #188 * Use a linked list for the barrier implementation. by @ioquatix in #192 * Add a concurrency primitive for waiting for a specific number of tasks to complete. by @ioquatix in #189 * Better support for Fiber.set_scheduler. by @ioquatix in #194 * Rename Async::LimitedBarrier to Async::Waiter based on feedback. by @ioquatix in #196 * Relax io-event dependency. by @ioquatix in #200 * Implement semaphore using linked list. by @ioquatix in #203
devel/ruby-async: add package version 2.2.1
Required by ruby-html-proofer package.
Async
Async is a composable asynchronous I/O framework for Ruby based on io-event
and timers.
"Lately I've been looking into async, as one of my projects -
tus-ruby-server - would really benefit from non-blocking I/O.
It's really beautifully designed." - janko
Features
* Scalable event-driven I/O for Ruby. Thousands of clients per process!
* Light weight fiber-based concurrency. No need for callbacks!
* Multi-thread/process containers for parallelism.
* Growing eco-system of event-driven components.