omq-cli 0.6.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e7461f1ed5fa59b4d82797959a2cfb80f91c74102a0915a7363eed6234ac98e
-  data.tar.gz: 1c1af50a6c3cf4f110d85767418072337fe2dd95e2564d9fdfc8f46e55436a09
+  metadata.gz: a03141c60a8af670aa4de42bc5b5d286fbf3a975c5a455e9276bc2d4b87a0fb8
+  data.tar.gz: 2755cb1054df95a64b5faebe481e93ac2e3f391e878f54b5a30a17514dde399a
 SHA512:
-  metadata.gz: fcc54fa2294ac6fbdcd046582d2f7ed74855e79e66af8f10af6e48e68599aa2f8a29a5b9bd29136cc02fe5ff3d44c1b07943643a7f6a003576bd1ecd3283fc7d
-  data.tar.gz: 0f45f44be69ba3440974efd2e682d1e38cb58c2e7db0c23eff7dffa69c25b967ae9a10230bcafd3051e909e384540c524d7fddd2f47f96faffb3b15590ff5a6c
+  metadata.gz: f245e7f524d745382074347852f1d34e5e1f46e633fe024b7888c05942a399639e69e876ae92c5ace5172800b0dc6a3bd8cd088d3b52f389ea0fb212e0f8da58
+  data.tar.gz: 34992fe5962fd2639b0c3e92597e3d2d6a134f3ac4fecadfa3d64b1d566994cf9f8ef36ce08fc929ab97bfcf7a7b4dd7f9c1de241b8c87e2a207ce17a838c7d2

data/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## 0.7.1 — 2026-04-07
+
+### Fixed
+
+- **Pipe `-P` preresolves TCP hostnames** — DNS resolution happens on the
+  main thread before spawning Ractors, avoiding `Ractor::IsolationError`
+  on `Resolv::DefaultResolver`. All resolved addresses (IPv4 + IPv6) are
+  passed to workers.
+
+## 0.7.0 — 2026-04-07
+
+### Changed
+
+- **`-P` restricted to pipe only** — parallel Ractor workers are no longer
+  available on recv-only socket types (pull, sub, gather, dish). Pipe workers
+  now use bare Ractors with their own Async reactors and OMQ sockets, removing
+  the `omq-ractor` dependency entirely.
+- **`-P` range capped to 1..16** — default is still `nproc`, clamped to 16.
+  `-P 1` is valid (single Ractor worker, no sockets on main thread).
+- **Removed `omq-ractor` dependency** — no longer needed.
+- **Removed `ParallelRecvRunner`** — the Ractor bridge infrastructure for
+  non-pipe socket types has been deleted.
+
+### Fixed
+
+- **Pipe `-P` END blocks execute after timeout** — worker recv loops now
+  catch `IO::TimeoutError` so BEGIN/END expressions run to completion.
+
 ## 0.6.0 — 2026-04-07
 
 ### Added

data/lib/omq/cli/base_runner.rb

@@ -51,7 +51,7 @@ module OMQ
 
       def setup_socket
         @sock = create_socket
-        attach_endpoints unless config.parallel
+        attach_endpoints
         setup_curve
         setup_subscriptions
         compile_expr
@@ -265,17 +265,6 @@ module OMQ
       end
 
 
-      # Parallel recv-eval: delegates to ParallelRecvRunner.
-      #
-      def run_parallel_recv(task)
-        # @sock was created by call() before run_loop; close it now so it doesn't
-        # steal messages from the N worker sockets ParallelRecvRunner creates.
-        @sock&.close
-        @sock = nil
-        ParallelRecvRunner.new(@klass, config, @fmt, method(:output)).run(task)
-      end
-
-
       def wait_for_loops(receiver, sender)
         if config.data || config.file || config.send_expr || config.recv_expr || config.target
           sender.wait

data/lib/omq/cli/cli_parser.rb

@@ -367,9 +367,9 @@ module OMQ
             require "omq" unless defined?(OMQ::VERSION)
             opts[:scripts] << (v == "-" ? :stdin : (v.start_with?("./", "../") ? File.expand_path(v) : v))
           }
-          o.on("-P", "--parallel [N]", Integer, "Parallel Ractor workers (default: nproc); for non-pipe requires --recv-eval") { |v|
+          o.on("-P", "--parallel [N]", Integer, "Parallel Ractor workers for pipe (default: nproc, max 16)") { |v|
             require "etc"
-            opts[:parallel] = v || Etc.nprocessors
+            opts[:parallel] = [v || Etc.nprocessors, 16].min
           }
 
           o.separator "\nCURVE encryption (requires system libsodium):"
@@ -486,16 +486,10 @@ module OMQ
         abort "--send-eval and --target are mutually exclusive"  if opts[:send_expr] && opts[:target]
 
         if opts[:parallel]
-          abort "-P/--parallel must be >= 2" if opts[:parallel] < 2
-          if type_name == "pipe"
-            all_pipe_eps = opts[:in_endpoints] + opts[:out_endpoints] + opts[:endpoints]
-            abort "-P/--parallel requires all endpoints to use --connect (not --bind)" if all_pipe_eps.any?(&:bind?)
-          elsif RECV_ONLY.include?(type_name)
-            abort "-P/--parallel on #{type_name} requires --recv-eval (-e)" unless opts[:recv_expr]
-            abort "-P/--parallel requires all endpoints to use --connect (not --bind)" if opts[:binds].any?
-          else
-            abort "-P/--parallel is only valid for pipe or recv-only socket types (#{RECV_ONLY.join(', ')})"
-          end
+          abort "-P/--parallel is only valid for pipe" unless type_name == "pipe"
+          abort "-P/--parallel must be 1..16" unless (1..16).include?(opts[:parallel])
+          all_pipe_eps = opts[:in_endpoints] + opts[:out_endpoints] + opts[:endpoints]
+          abort "-P/--parallel requires all endpoints to use --connect (not --bind)" if all_pipe_eps.any?(&:bind?)
         end
 
         (opts[:connects] + opts[:binds]).each do |url|

data/lib/omq/cli/pipe.rb

@@ -130,145 +130,138 @@ module OMQ
 
 
       def run_parallel(task)
+        OMQ.freeze_for_ractors!
         in_eps, out_eps = resolve_endpoints
-        pairs = build_socket_pairs(config.parallel, in_eps, out_eps)
-        wait_for_pairs(pairs)
-        setup_parallel_transient(task, pairs)
-        workers = spawn_workers(pairs, build_worker_data)
-        join_workers(workers)
-      ensure
-        pairs&.each do |pull, push|
-          pull&.close
-          push&.close
+        in_eps  = preresolve_tcp(in_eps)
+        out_eps = preresolve_tcp(out_eps)
+        workers = spawn_workers(config, in_eps, out_eps)
+        workers.each do |w|
+          w.join
+        rescue ::Ractor::RemoteError => e
+          $stderr.write("omq: Ractor error: #{e.cause&.message || e.message}\n")
         end
       end
 
 
-      def build_socket_pairs(n_workers, in_eps, out_eps)
-        pull_opts = { linger: config.linger }
-        push_opts = { linger: config.linger }
-        pull_opts[:recv_timeout] = config.timeout if config.timeout
-        push_opts[:send_timeout] = config.timeout if config.timeout
-        n_workers.times.map { build_pull_push(pull_opts, push_opts, in_eps, out_eps) }
-      end
+      def spawn_workers(config, in_eps, out_eps)
+        config.parallel.times.map do
+          ::Ractor.new(config, in_eps, out_eps) do |cfg, ins, outs|
+            Async do
+              pull = OMQ::PULL.new(linger: cfg.linger)
+              push = OMQ::PUSH.new(linger: cfg.linger)
+              pull.recv_timeout      = cfg.timeout if cfg.timeout
+              push.send_timeout      = cfg.timeout if cfg.timeout
+              pull.reconnect_interval = cfg.reconnect_ivl if cfg.reconnect_ivl
+              push.reconnect_interval = cfg.reconnect_ivl if cfg.reconnect_ivl
+              pull.heartbeat_interval = cfg.heartbeat_ivl if cfg.heartbeat_ivl
+              push.heartbeat_interval = cfg.heartbeat_ivl if cfg.heartbeat_ivl
+              pull.send_hwm          = cfg.send_hwm if cfg.send_hwm
+              pull.recv_hwm          = cfg.recv_hwm if cfg.recv_hwm
+              push.send_hwm          = cfg.send_hwm if cfg.send_hwm
+              push.recv_hwm          = cfg.recv_hwm if cfg.recv_hwm
+              pull.sndbuf            = cfg.sndbuf if cfg.sndbuf
+              pull.rcvbuf            = cfg.rcvbuf if cfg.rcvbuf
+              push.sndbuf            = cfg.sndbuf if cfg.sndbuf
+              push.rcvbuf            = cfg.rcvbuf if cfg.rcvbuf
+
+              OMQ::CLI::SocketSetup.attach_endpoints(pull, ins, verbose: cfg.verbose >= 1)
+              OMQ::CLI::SocketSetup.attach_endpoints(push, outs, verbose: cfg.verbose >= 1)
+
+              Barrier do |barrier|
+                barrier.async { pull.peer_connected.wait }
+                barrier.async { push.peer_connected.wait }
+              end
 
+              begin_proc, end_proc, eval_proc =
+                OMQ::CLI::ExpressionEvaluator.compile_inside_ractor(cfg.recv_expr)
+
+              fmt_in  = OMQ::CLI::Formatter.new(cfg.format, compress: cfg.compress_in || cfg.compress)
+              fmt_out = OMQ::CLI::Formatter.new(cfg.format, compress: cfg.compress_out || cfg.compress)
+
+              _ctx = Object.new
+              _ctx.instance_exec(&begin_proc) if begin_proc
+
+              n_count = cfg.count
+              begin
+                if eval_proc
+                  if n_count && n_count > 0
+                    n_count.times do
+                      parts = pull.receive
+                      break if parts.nil?
+                      parts = OMQ::CLI::ExpressionEvaluator.normalize_result(
+                        _ctx.instance_exec(fmt_in.decompress(parts), &eval_proc)
+                      )
+                      next if parts.nil?
+                      push << fmt_out.compress(parts) unless parts.empty?
+                    end
+                  else
+                    loop do
+                      parts = pull.receive
+                      break if parts.nil?
+                      parts = OMQ::CLI::ExpressionEvaluator.normalize_result(
+                        _ctx.instance_exec(fmt_in.decompress(parts), &eval_proc)
+                      )
+                      next if parts.nil?
+                      push << fmt_out.compress(parts) unless parts.empty?
+                    end
+                  end
+                else
+                  if n_count && n_count > 0
+                    n_count.times do
+                      parts = pull.receive
+                      break if parts.nil?
+                      push << fmt_out.compress(fmt_in.decompress(parts))
+                    end
+                  else
+                    loop do
+                      parts = pull.receive
+                      break if parts.nil?
+                      push << fmt_out.compress(fmt_in.decompress(parts))
+                    end
+                  end
+                end
+              rescue IO::TimeoutError, Async::TimeoutError
+                # recv timed out — fall through to END block
+              end
 
-      def wait_for_pairs(pairs)
-        with_timeout(config.timeout) do
-          Barrier do |barrier|
-            pairs.each do |pull, push|
-              barrier.async(annotation: "wait push peer") { push.peer_connected.wait }
-              barrier.async(annotation: "wait pull peer") { pull.peer_connected.wait }
+              if end_proc
+                out = OMQ::CLI::ExpressionEvaluator.normalize_result(
+                  _ctx.instance_exec(&end_proc)
+                )
+                push << fmt_out.compress(out) if out && !out.empty?
+              end
+            ensure
+              pull&.close
+              push&.close
             end
           end
         end
       end
 
 
-      def setup_parallel_transient(task, pairs)
-        return unless config.transient
-        task.async do
-          pairs[0][0].all_peers_gone.wait
-          pairs.each do |pull, _|
-            pull.reconnect_enabled = false
-            pull.close_read
-          end
-        end
-      end
-
-
-      def build_worker_data
-        # Pack worker config into a shareable Hash passed via omq.data —
-        # Ruby 4.0 forbids Ractor blocks from closing over outer locals.
-        ::Ractor.make_shareable({
-          recv_src:    config.recv_expr,
-          fmt_format:  config.format,
-          compr_in:    config.compress_in || config.compress,
-          compr_out:   config.compress_out || config.compress,
-          n_count:     config.count,
-        })
-      end
-
+      # ── Shared helpers ────────────────────────────────────────────────
 
-      def spawn_workers(pairs, worker_data)
-        pairs.map do |pull, push|
-          OMQ::Ractor.new(pull, push, serialize: false, data: worker_data) do |omq|
-            pull_p, push_p = omq.sockets
-            d = omq.data
-
-            # Re-compile expression inside Ractor (Procs are not shareable)
-            begin_proc, end_proc, eval_proc =
-              OMQ::CLI::ExpressionEvaluator.compile_inside_ractor(d[:recv_src])
-
-            fmt_in  = OMQ::CLI::Formatter.new(d[:fmt_format], compress: d[:compr_in])
-            fmt_out = OMQ::CLI::Formatter.new(d[:fmt_format], compress: d[:compr_out])
-            # Use a dedicated context object so @ivar expressions in BEGIN/END/eval
-            # work inside Ractors (self in a Ractor is shareable; Object.new is not).
-            _ctx = Object.new
-            _ctx.instance_exec(&begin_proc) if begin_proc
-
-            n_count = d[:n_count]
-            if eval_proc
-              if n_count && n_count > 0
-                n_count.times do
-                  parts = pull_p.receive
-                  break if parts.nil?
-                  parts = OMQ::CLI::ExpressionEvaluator.normalize_result(
-                    _ctx.instance_exec(fmt_in.decompress(parts), &eval_proc)
-                  )
-                  next if parts.nil?
-                  push_p << fmt_out.compress(parts) unless parts.empty?
-                end
-              else
-                loop do
-                  parts = pull_p.receive
-                  break if parts.nil?
-                  parts = OMQ::CLI::ExpressionEvaluator.normalize_result(
-                    _ctx.instance_exec(fmt_in.decompress(parts), &eval_proc)
-                  )
-                  next if parts.nil?
-                  push_p << fmt_out.compress(parts) unless parts.empty?
-                end
-              end
-            else
-              if n_count && n_count > 0
-                n_count.times do
-                  parts = pull_p.receive
-                  break if parts.nil?
-                  push_p << fmt_out.compress(fmt_in.decompress(parts))
-                end
-              else
-                loop do
-                  parts = pull_p.receive
-                  break if parts.nil?
-                  push_p << fmt_out.compress(fmt_in.decompress(parts))
-                end
-              end
-            end
 
-            if end_proc
-              out = OMQ::CLI::ExpressionEvaluator.normalize_result(
-                _ctx.instance_exec(&end_proc)
-              )
-              push_p << fmt_out.compress(out) if out && !out.empty?
+      # Resolves TCP hostnames to IP addresses so Ractors don't touch
+      # Resolv::DefaultResolver (which is not shareable).
+      #
+      def preresolve_tcp(endpoints)
+        endpoints.flat_map do |ep|
+          url = ep.url
+          if url.start_with?("tcp://")
+            host, port = OMQ::Transport::TCP.parse_endpoint(url)
+            Addrinfo.getaddrinfo(host, port, nil, :STREAM).map do |addr|
+              ip = addr.ip_address
+              ip = "[#{ip}]" if ip.include?(":")
+              Endpoint.new("tcp://#{ip}:#{addr.ip_port}", ep.bind?)
             end
+          else
+            ep
           end
         end
       end
 
 
-      def join_workers(workers)
-        workers.each do |w|
-          w.value
-        rescue Ractor::RemoteError => e
-          $stderr.write("omq: Ractor error: #{e.cause&.message || e.message}\n")
-        end
-      end
-
-
-      # ── Shared helpers ────────────────────────────────────────────────
-
-
       def with_timeout(seconds)
         if seconds
           Async::Task.current.with_timeout(seconds) { yield }

data/lib/omq/cli/pub_sub.rb

@@ -10,9 +10,7 @@ module OMQ
 
     # Runner for SUB sockets (subscribe and receive published messages).
     class SubRunner < BaseRunner
-      def run_loop(task)
-        config.parallel ? run_parallel_recv(task) : run_recv_logic
-      end
+      def run_loop(task) = run_recv_logic
     end
   end
 end

data/lib/omq/cli/push_pull.rb

@@ -10,9 +10,7 @@ module OMQ
 
     # Runner for PULL sockets (receive-only pipeline consumer).
     class PullRunner < BaseRunner
-      def run_loop(task)
-        config.parallel ? run_parallel_recv(task) : run_recv_logic
-      end
+      def run_loop(task) = run_recv_logic
     end
   end
 end

data/lib/omq/cli/radio_dish.rb

@@ -23,9 +23,7 @@ module OMQ
 
     # Runner for DISH sockets (draft; group-based subscribe).
     class DishRunner < BaseRunner
-      def run_loop(task)
-        config.parallel ? run_parallel_recv(task) : run_recv_logic
-      end
+      def run_loop(task) = run_recv_logic
     end
   end
 end

data/lib/omq/cli/scatter_gather.rb

@@ -10,9 +10,7 @@ module OMQ
 
     # Runner for GATHER sockets (draft; fan-in receive).
     class GatherRunner < BaseRunner
-      def run_loop(task)
-        config.parallel ? run_parallel_recv(task) : run_recv_logic
-      end
+      def run_loop(task) = run_recv_logic
     end
   end
 end

data/lib/omq/cli/version.rb

@@ -2,6 +2,6 @@
 
 module OMQ
   module CLI
-    VERSION = "0.6.0"
+    VERSION = "0.7.1"
   end
 end

data/lib/omq/cli.rb

@@ -9,7 +9,6 @@ require_relative "cli/expression_evaluator"
 require_relative "cli/socket_setup"
 require_relative "cli/routing_helper"
 require_relative "cli/transient_monitor"
-require_relative "cli/parallel_recv_runner"
 require_relative "cli/base_runner"
 require_relative "cli/push_pull"
 require_relative "cli/pub_sub"
@@ -199,8 +198,6 @@ module OMQ
       require "console"
 
       CliParser.validate_gems!(config)
-      require "omq/ractor" if config.parallel
-
       trap("INT")  { Process.exit!(0) }
       trap("TERM") { Process.exit!(0) }
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omq-cli
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Patrik Wenger
@@ -16,6 +16,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.15'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.15.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -23,20 +26,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.15'
-- !ruby/object:Gem::Dependency
-  name: omq-ractor
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.1'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: 0.15.2
 - !ruby/object:Gem::Dependency
   name: omq-rfc-clientserver
   requirement: !ruby/object:Gem::Requirement
@@ -173,7 +165,6 @@ files:
 - lib/omq/cli/expression_evaluator.rb
 - lib/omq/cli/formatter.rb
 - lib/omq/cli/pair.rb
-- lib/omq/cli/parallel_recv_runner.rb
 - lib/omq/cli/pipe.rb
 - lib/omq/cli/pub_sub.rb
 - lib/omq/cli/push_pull.rb

data/lib/omq/cli/parallel_recv_runner.rb

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-
-module OMQ
-  module CLI
-    # Manages N OMQ::Ractor workers for parallel recv-eval.
-    #
-    # Each worker gets its own input socket connecting to the external
-    # endpoints; ZMQ distributes work naturally. Results are collected via
-    # an inproc PULL back to the main task for output.
-    #
-    class ParallelRecvRunner
-      # @param klass [Class] OMQ socket class for worker input sockets
-      # @param config [Config] frozen CLI configuration
-      # @param fmt [Formatter] message formatter
-      # @param output_fn [Method] callable for writing output
-      def initialize(klass, config, fmt, output_fn)
-        @klass     = klass
-        @config    = config
-        @fmt       = fmt
-        @output_fn = output_fn
-      end
-
-
-      # Spawns N Ractor workers, distributes incoming messages, and collects results.
-      #
-      # @param task [Async::Task] parent async task
-      # @return [void]
-      def run(task)
-        cfg       = @config
-        n_workers = cfg.parallel
-        inproc    = "inproc://omq-out-#{object_id}"
-
-        # Pack worker config into a shareable Hash passed via omq.data —
-        # Ruby 4.0 forbids Ractor blocks from closing over outer locals.
-        worker_data = ::Ractor.make_shareable({
-          recv_src:  cfg.recv_expr,
-          fmt_sym:   cfg.format,
-          fmt_compr: cfg.compress,
-        })
-
-        # Create N input sockets in the main Async context
-        input_socks = n_workers.times.map do
-          sock = SocketSetup.build(@klass, cfg)
-          SocketSetup.setup_subscriptions(sock, cfg)
-          cfg.connects.each { |url| sock.connect(url) }
-          sock
-        end
-
-        with_timeout(cfg.timeout) { input_socks.each { |s| s.peer_connected.wait } }
-
-        # Inproc collector: one bound PULL to receive all worker output
-        collector = OMQ::PULL.new(linger: cfg.linger)
-        collector.recv_timeout = cfg.timeout if cfg.timeout
-        collector.bind(inproc)
-
-        # N output sockets connecting to the collector
-        output_socks = n_workers.times.map do
-          s = OMQ::PUSH.new(linger: cfg.linger)
-          s.connect(inproc)
-          s
-        end
-
-        workers = n_workers.times.map do |i|
-          OMQ::Ractor.new(input_socks[i], output_socks[i], serialize: false, data: worker_data) do |omq|
-            pull_p, push_p = omq.sockets
-            d = omq.data
-
-            # Re-compile expression inside Ractor (Procs are not shareable)
-            begin_proc, end_proc, eval_proc =
-              OMQ::CLI::ExpressionEvaluator.compile_inside_ractor(d[:recv_src])
-
-            formatter = OMQ::CLI::Formatter.new(d[:fmt_sym], compress: d[:fmt_compr])
-            # Use a dedicated context object so @ivar expressions in BEGIN/END/eval
-            # work inside Ractors (self in a Ractor is shareable; Object.new is not).
-            _ctx = Object.new
-            _ctx.instance_exec(&begin_proc) if begin_proc
-
-            if eval_proc
-              loop do
-                parts = pull_p.receive
-                break if parts.nil?
-                parts = OMQ::CLI::ExpressionEvaluator.normalize_result(
-                  _ctx.instance_exec(formatter.decompress(parts), &eval_proc)
-                )
-                next if parts.nil?
-                push_p << parts unless parts.empty?
-              end
-            else
-              loop do
-                parts = pull_p.receive
-                break if parts.nil?
-                push_p << formatter.decompress(parts)
-              end
-            end
-
-            if end_proc
-              out = OMQ::CLI::ExpressionEvaluator.normalize_result(
-                _ctx.instance_exec(&end_proc)
-              )
-              push_p << out if out && !out.empty?
-            end
-          end
-        end
-
-
-        # Collect loop: drain inproc PULL → output
-        n_count = cfg.count
-        if n_count && n_count > 0
-          n_count.times do
-            parts = collector.receive
-            break if parts.nil?
-            @output_fn.call(parts)
-          end
-        else
-          loop do
-            parts = collector.receive
-            break if parts.nil?
-            @output_fn.call(parts)
-          end
-        end
-
-
-        # Inject nil into each worker's input port so it exits its loop
-        # without waiting for recv_timeout (workers don't self-terminate
-        # when the collect loop exits on count).
-        workers.each do |w|
-          w.close
-        rescue Ractor::RemoteError => e
-          $stderr.puts "omq: Ractor error: #{e.cause&.message || e.message}"
-        end
-      ensure
-        input_socks&.each(&:close)
-        output_socks&.each(&:close)
-        collector&.close
-      end
-
-
-      private
-
-
-      def with_timeout(seconds)
-        if seconds
-          Async::Task.current.with_timeout(seconds) { yield }
-        else
-          yield
-        end
-      end
-    end
-  end
-end