padded_cell 0.2.0-x86_64-linux-gnu → 0.3.0-x86_64-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d938c3e531357727a22bf6a2759c2f381960729f309ce98c54474087cc5e7599
-  data.tar.gz: 6f91994847f2b887ddd3523c71e1c197028d529a55a9b2726f8146afcd847cb3
+  metadata.gz: 18ddd483c349cd093dafa125ee74d7a340926d64494d71103725320d79e4f491
+  data.tar.gz: 25b575be7e64071b58a4fdb0bcd5891973e8423dae49884b8f8e696dfa20b0e2
 SHA512:
-  metadata.gz: 703c85c4e53f4c03c6b068e688b459d0b279e3ad80117075e3ded0e342b73383975f4632bbb4694d48d6c8e5e2fe8233b7839efc7df53ee2f2e5ffb904157ab0
-  data.tar.gz: f9d6f0dbd6e472529eabe4c82bccb669295957fcaad2c7319b2a2d8136267a52986b8e4c1dabf2ed9c71e70d1da1d79839ba9c3abbfdf5bd5c0e561a0b3e02ec
+  metadata.gz: b05b36a943bcc0af55de4f9102f8bcf5049151a3140f6a6b0beb91de9fbad0ed32c2296fa99f1be2ce66672b6cf01aa37a8dcd32c9904f9c672f104b9893fda4
+  data.tar.gz: bd71550a929918248364af56965200fb895f6fb0e32729cc1838645acfe5b434e0d8a5a8907e158b5692a1659ee28f40a06624e3cae498a28e2b6135f24641e0

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.3.0 (2026-11-08)
+
+- `--budget SECONDS`: a deadline for the whole run, loading included. Once
+  it's spent, nothing more is dispatched and running tests are killed. Tests
+  it left out fail the run (exit 1). `--timeout` never outlives it.
+- Workers that keep dying (more than 4 per worker, at least 16, in 10s) are
+  no longer replaced forever. padded_cell gives up, reports how many tests
+  never ran, and exits 1. Uses `supervisor-machines`.
+- A replacement worker that died before its first test crashed the run with
+  `Errno::EPIPE` (exit 2). A worker reset mid-frame is now reported as dead.
+- `--asylum` retry seeds keep all 64 bits: they were folded modulo 0xffff,
+  so large `--seed`s shared the same few retry seeds.
+
 ## 0.2.0 (2026-10-11)
 
 - Built-in coverage: `--coverage[=lines,branches,methods,eval]` (or

data/README.md

@@ -69,11 +69,13 @@ $ padded_cell user_test.rb:12-30:41        # tests overlapping 12..30, or spanni
 $ padded_cell -n /refund/ -e test_slow     # Minitest's --include / --exclude
 $ padded_cell -j 8 --seed 1234             # 8 workers, reproducible order
 $ padded_cell --timeout 30                 # kill and fail anything running 30s
+$ padded_cell --budget 600                 # the whole run gets 10 minutes; what's left out fails it
 $ padded_cell --fail-fast
 $ padded_cell --asylum                     # retry failures; report the flaky ones (see below)
 $ padded_cell --list                       # what would run, without loading anything
 $ padded_cell --shard 2/4                  # CI: the second quarter of the classes
 $ padded_cell --junit tmp/junit.xml --json tmp/results.jsonl
+$ PADDED_CELL_JSON=tmp/results.jsonl padded_cell   # same, from a CI runner's env
 $ padded_cell --coverage                   # line and branch coverage (see Coverage)
 ```
 
@@ -110,6 +112,23 @@ cheap, and order-dependent tests stop depending on order.
 Rails' `parallelize`. A worker that crashes or times out is still reported
 and replaced.
 
+Replaced up to a point. If workers keep dying, say a boot that segfaults or an
+`after_fork` hook that calls `exit`, every remaining test would come back as a
+crash report, one fork at a time. So past 4 deaths per worker in 10 seconds
+(16 at least), padded_cell gives up: it lists how many tests never ran and
+exits 1. The decision comes from
+[supervisor_machines](https://github.com/seuros/supervisor_machines), the same
+one-for-one restart intensity OTP uses.
+
+### Budget
+
+`--budget SECONDS` caps the whole run, loading included. Once it's spent,
+nothing more is dispatched, and a test still running is killed and fails
+("run budget of 600.0s spent"). A test's `--timeout` never outlives the
+budget. If the budget left tests out, the run fails and says how many. The
+deadline math comes from
+[deadline_machines](https://github.com/seuros/deadline_machines).
+
 The default is `test`, except when Active Record fixtures are loaded: a fork
 discards Active Record's connection pool, and every test would reload its
 fixtures, so those suites default to `worker`. The `Run options:` line shows
@@ -305,7 +324,9 @@ PaddedCell::Scheduler.batches(class_names, durations: seconds, seed: 42, shard:
 ## Rust
 
 The extension lives in `ext/padded_cell_native`: `core` does discovery and
-scheduling in plain Rust (no Ruby types), `ffi` binds it to Ruby. Neither is
+scheduling in plain Rust (no Ruby types), `ffi` binds it to Ruby. Worker
+supervision and deadlines come from the published `supervisor-machines` and
+`deadline-machines` crates. Neither is
 published as a crate.
 
 ## Development

data/lib/padded_cell/asylum.rb

@@ -13,18 +13,20 @@ module PaddedCell
   class Asylum
     ALONE = 'timing, contention or state left by other tests'
     RESEEDED = 'randomness or test order'
+    SEEDS = 2**64
 
     # The seed of retry attempt, derived from the run's seed so a report can
-    # be replayed. Attempt 1 keeps the run's seed.
+    # be replayed. Attempt 1 keeps the run's seed. Wraps within the planner's
+    # 64-bit seeds, as --seed accepts them.
     def self.retry_seed(seed, attempt)
-      attempt == 1 ? seed : (seed + (attempt * 0x9e37)) % 0xffff
+      attempt == 1 ? seed : (seed + (attempt * 0x9e37)) % SEEDS
     end
 
-    def initialize(tests, attempts:, seed:, timeout: nil)
+    def initialize(tests, attempts:, seed:, limits: Limits.new)
       @tests = tests
       @attempts = attempts
       @seed = seed
-      @timeout = timeout
+      @limits = limits
       @success = true
     end
 
@@ -58,7 +60,7 @@ module PaddedCell
     def retry_round(pending, history, attempt)
       seed = self.class.retry_seed(@seed, attempt)
       passed = []
-      pool = Pool.new(@tests, jobs: 1, isolation: :test, seed:, timeout: @timeout)
+      pool = Pool.new(@tests, jobs: 1, isolation: :test, seed:, limits: @limits)
       pool.run([pending.dup]) do |index, result|
         recovered = result.passed? && !result.skipped?
         history[index] << attempt_entry(seed, true, recovered ? nil : result)

data/lib/padded_cell/cell.rb

@@ -9,19 +9,21 @@ module PaddedCell
     module_function
 
     # Runs klass#name in a fork and returns its Minitest::Result, or an error
-    # result when the cell died or ran past timeout seconds.
+    # result when the cell died or ran past its deadline.
     #
-    #   close: descriptors the cell must not keep open (the worker's socket)
-    #   probe: the worker's Chart::Probe, which gets the cell's coverage
-    def run(klass, name, seed:, timeout: nil, close: [], probe: nil)
+    #   limits: the run's Limits (--timeout, --budget); nil: no deadline
+    #   close:  descriptors the cell must not keep open (the worker's socket)
+    #   probe:  the worker's Chart::Probe, which gets the cell's coverage
+    def run(klass, name, seed:, limits: nil, close: [], probe: nil)
       # Binary: the result is Marshal data, and with Encoding.default_internal
       # set (Rails sets it) a text-mode pipe transcodes what is written to it.
       reader, writer = IO.pipe
       [reader, writer].each(&:binmode)
       started = Minitest.clock_time
+      deadline = limits&.for_test
       pid = fork_cell(klass, name, seed, reader, writer, close, probe)
       writer.close
-      delta, result = collect(pid, reader, klass, name, started, timeout)
+      delta, result = collect(pid, reader, klass, name, started, deadline) { limits.message(deadline) }
       delta ? probe.absorb(delta) : probe&.lost
       result
     ensure
@@ -59,14 +61,15 @@ module PaddedCell
       end
     end
 
-    # [coverage delta or nil, result]
-    def collect(pid, reader, klass, name, started, timeout)
-      data = read(reader, timeout && (started + timeout))
+    # [coverage delta or nil, result]. Yields for the message of a cell
+    # killed at its deadline.
+    def collect(pid, reader, klass, name, started, deadline)
+      data = read(reader, deadline)
       elapsed = Minitest.clock_time - started
       if data.nil?
         Process.kill(:KILL, pid)
         Process.wait(pid)
-        return [nil, Results.crashed(klass, name, "timed out after #{timeout}s", time: elapsed)]
+        return [nil, Results.crashed(klass, name, yield, time: elapsed)]
       end
 
       _, status = Process.wait2(pid)
@@ -75,11 +78,11 @@ module PaddedCell
       [nil, Results.crashed(klass, name, Results.describe(status, 'cell'), time: elapsed)]
     end
 
-    # Everything until EOF, or nil when the deadline passes first.
+    # Everything until EOF, or nil when the deadline (if any) passes first.
     def read(io, deadline)
       data = String.new(encoding: Encoding::BINARY)
       loop do
-        remaining = deadline && (deadline - Minitest.clock_time)
+        remaining = deadline && Limits.remaining(deadline)
         return if remaining&.<= 0
         next unless io.wait_readable(remaining)
 

data/lib/padded_cell/cli.rb

@@ -22,7 +22,7 @@ module PaddedCell
     # Exit status: 0 passed, 1 failed, 2 usage or load error, 3 coverage below
     # a minimum, 130 interrupted.
     def start(argv, io: $stdout)
-      options = { io:, coverage: coverage_criteria(ENV.fetch('PADDED_CELL_COVERAGE', nil)) }
+      options = { io:, coverage: coverage_criteria(ENV.fetch('PADDED_CELL_COVERAGE', nil)), **report_paths }
       parser(options).parse!(argv)
       return merge(options) if options[:coverage_merge]
 
@@ -33,6 +33,13 @@ module PaddedCell
       2
     end
 
+    # Report paths a CI runner can set without touching the command line;
+    # --json and --junit still win.
+    def report_paths
+      { json: ENV.fetch('PADDED_CELL_JSON', nil), junit: ENV.fetch('PADDED_CELL_JUNIT', nil) }
+        .reject { |_, path| path.nil? || path.empty? }
+    end
+
     def parser(options)
       OptionParser.new do |opts|
         opts.banner = BANNER
@@ -70,6 +77,10 @@ module PaddedCell
       opts.on('--timeout SECONDS', Float, 'Kill and fail a test running longer') do
         options[:timeout] = positive(it)
       end
+      opts.on('--budget SECONDS', Float, 'Stop dispatching once the run has taken SECONDS (and kill and ' \
+                                         'fail what runs past it); tests left out fail the run') do
+        options[:budget] = positive(it)
+      end
       opts.on('--fail-fast', 'Stop dispatching after the first failure') { options[:fail_fast] = true }
       opts.on('--asylum[=N]', Integer, 'Retry failed tests up to N times (default 2) after the run, alone, ' \
                                        'each in a fresh cell; report the flaky ones') do

data/lib/padded_cell/limits.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module PaddedCell
+  # What cuts a test short: its --timeout, and what is left of the run's
+  # --budget. A test's deadline never outlives the run's. Deadlines are
+  # PaddedCellNative::Deadline values in monotonic nanoseconds: one clock for
+  # the runner, its workers and their cells.
+  class Limits
+    NS = 1_000_000_000
+
+    def self.now = Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
+
+    # Seconds left before deadline (0.0 once passed), nil when never.
+    def self.remaining(deadline, now = self.now) = deadline.remaining_ns(now)&./(NS.to_f)
+
+    attr_reader :timeout, :budget
+
+    #   timeout: seconds per test, or nil
+    #   budget:  seconds for the whole run from started, or nil
+    def initialize(timeout: nil, budget: nil, started: Limits.now)
+      @timeout = timeout
+      @budget = budget
+      @run = budget ? PaddedCellNative::Deadline.after(started, nanoseconds(budget)) : PaddedCellNative::Deadline.never
+    end
+
+    # The deadline of a test starting now.
+    def for_test(now = Limits.now) = @run.derive(now, @timeout && nanoseconds(@timeout))
+
+    # True once the run's budget is gone: nothing more gets dispatched.
+    def spent?(now = Limits.now) = @run.expired?(now)
+
+    # Why a test that reached deadline was cut short.
+    def message(deadline)
+      if @budget && deadline.expires_at == @run.expires_at
+        "run budget of #{@budget}s spent"
+      else
+        "timed out after #{@timeout}s"
+      end
+    end
+
+    private
+
+    def nanoseconds(seconds) = (seconds * NS).round
+  end
+end

data/lib/padded_cell/pool.rb

@@ -13,20 +13,34 @@ module PaddedCell
   #
   # With isolation :test a worker forks a Cell per test; with :worker it runs
   # tests itself, faster but sharing process state. A worker that dies
-  # mid-test, or runs past the timeout, gets its test reported as an error and
-  # is replaced; its replacement continues the class.
+  # mid-test, or runs past its deadline (--timeout, --budget), gets its test
+  # reported as an error and is replaced; its replacement continues the class.
+  #
+  # Replaced, up to a point: workers that keep dying (a boot that segfaults,
+  # an after_fork hook that exits) would turn every remaining test into a
+  # crash report. Past PaddedCellNative::Restarts' limit the pool gives up.
+  # Once the run's budget is spent, it dispatches nothing more.
   class Pool
-    Slot = Struct.new(:worker, :pid, :socket, :test, :started, :batch)
+    Slot = Struct.new(:worker, :pid, :socket, :test, :started, :batch, :deadline)
+
+    # Tests left undispatched by stop! (--fail-fast, the budget, giving up).
+    attr_reader :undispatched
+
+    # Why the pool gave up on its workers, or nil.
+    attr_reader :gave_up
 
     # tests: [[klass, method_name], ...], dispatched by index.
+    # limits: the run's Limits
     # coverage: a Chart::Accumulator when measuring coverage
-    def initialize(tests, jobs:, isolation:, seed:, timeout: nil, coverage: nil)
+    def initialize(tests, jobs:, isolation:, seed:, limits: Limits.new, coverage: nil)
       @tests = tests
       @jobs = jobs
       @isolation = isolation
       @seed = seed
-      @timeout = timeout
+      @limits = limits
       @coverage = coverage
+      @restarts = PaddedCellNative::Restarts.new(jobs)
+      @undispatched = 0
     end
 
     # Runs batches of test indices in order (consuming them), yielding
@@ -36,7 +50,7 @@ module PaddedCell
       @on_result = on_result
       @sockets = []
       Hooks.run_before_fork
-      @slots = Array.new([@jobs, batches.sum(&:size)].min) { spawn(Slot.new(it, nil, nil, nil, nil, [])) }
+      @slots = Array.new([@jobs, batches.sum(&:size)].min) { spawn(Slot.new(it, nil, nil, nil, nil, [], nil)) }
       @slots.each { feed(it) }
       loop do
         busy = @slots.select(&:test)
@@ -53,6 +67,7 @@ module PaddedCell
 
     # Dispatch nothing more; tests already running still report.
     def stop!
+      @undispatched += @queue.sum(&:size) + @slots.sum { it.batch.size }
       @queue.clear
       @slots.each { it.batch.clear }
     end
@@ -67,7 +82,7 @@ module PaddedCell
         # A worker holding another worker's socket would keep it from ever
         # seeing EOF: keep only its own end.
         [parent, *@sockets].each(&:close)
-        Worker.new(@tests, isolation: @isolation, seed: @seed, timeout: @timeout, probe: @coverage&.probe)
+        Worker.new(@tests, isolation: @isolation, seed: @seed, limits: @limits, probe: @coverage&.probe)
               .run(slot.worker, child)
       end
       child.close
@@ -77,18 +92,25 @@ module PaddedCell
     end
 
     def feed(slot)
+      return stop! if @limits.spent?
+
       slot.batch = @queue.shift || steal if slot.batch.empty?
       slot.test = slot.batch.shift
       return unless slot.test
 
       slot.started = Minitest.clock_time
+      slot.deadline = @limits.for_test
       begin
         slot.socket.puts(slot.test)
       rescue Errno::EPIPE, Errno::ECONNRESET
-        # The worker died between tests: its replacement gets this one.
+        # The worker died between tests: its replacement gets this one, unless
+        # it dies too. Restarts bounds the retries.
         reap(slot)
         @coverage&.lost_worker
-        spawn(slot).socket.puts(slot.test)
+        return abandon(slot) unless @restarts.died(Limits.now)
+
+        spawn(slot)
+        retry
       end
     end
 
@@ -99,17 +121,24 @@ module PaddedCell
     end
 
     def receive(slot)
-      header = slot.socket.read(4)
+      header = read_frame(slot, 4)
       return died(slot) unless header&.bytesize == 4
 
       size = header.unpack1('N')
-      payload = slot.socket.read(size)
+      payload = read_frame(slot, size)
       return died(slot) unless payload&.bytesize == size
 
       report(slot, Results.load(payload, *@tests.fetch(slot.test)))
       feed(slot)
     end
 
+    # nil when the worker died: EOF, or a reset when it left data unread.
+    def read_frame(slot, size)
+      slot.socket.read(size)
+    rescue Errno::ECONNRESET
+      nil
+    end
+
     def report(slot, result)
       index = slot.test
       slot.test = nil
@@ -118,25 +147,42 @@ module PaddedCell
 
     def died(slot)
       status = reap(slot)
+      give_up unless @restarts.died(Limits.now)
       replace(slot, Results.describe(status, 'worker'), Minitest.clock_time - slot.started)
     end
 
-    # Cells time out inside their worker; with :worker isolation the runner
-    # kills the worker itself.
+    # Stops replacing workers: whatever was not dispatched is not run.
+    def give_up
+      window = PaddedCellNative::Restarts.window_ns / Limits::NS
+      @gave_up = "workers died more than #{@restarts.limit} times in #{window}s"
+      stop!
+    end
+
+    # A test taken for a worker that died before receiving it, and is not
+    # replaced.
+    def abandon(slot)
+      slot.test = nil
+      @undispatched += 1
+      give_up
+    end
+
+    # Cells meet their deadline inside their worker; with :worker isolation
+    # the runner kills the worker itself.
     def wait_time(busy)
-      return unless @timeout && @isolation == :worker
+      return unless @isolation == :worker
 
-      deadline = busy.map { it.started + @timeout }.min
-      [deadline - Minitest.clock_time, 0].max
+      now = Limits.now
+      busy.filter_map { Limits.remaining(it.deadline, now) }.min
     end
 
     def expire(busy)
+      now = Limits.now
       busy.each do |slot|
-        next if Minitest.clock_time - slot.started < @timeout
+        next unless slot.deadline.expired?(now)
 
         Process.kill(:KILL, slot.pid)
         reap(slot)
-        replace(slot, "timed out after #{@timeout}s", @timeout)
+        replace(slot, @limits.message(slot.deadline), Minitest.clock_time - slot.started)
       end
     end
 
@@ -145,6 +191,7 @@ module PaddedCell
       @coverage&.lost_worker
       klass, name = @tests.fetch(slot.test)
       report(slot, Results.crashed(klass, name, message, time:))
+      stop! if @limits.spent?
       return if @queue.empty? && @slots.all? { it.batch.empty? }
 
       spawn(slot)

data/lib/padded_cell/runner.rb

@@ -4,6 +4,7 @@ require 'etc'
 require 'minitest'
 require_relative '../padded_cell'
 require_relative 'results'
+require_relative 'limits'
 require_relative 'cell'
 require_relative 'worker'
 require_relative 'pool'
@@ -20,7 +21,7 @@ module PaddedCell
   class Runner
     DEFAULTS = {
       paths: [], jobs: Etc.nprocessors, seed: nil, include: nil, exclude: nil, shard: [0, 1],
-      isolation: nil, timeout: nil, asylum: nil, fail_fast: false, verbose: false, show_skips: false,
+      isolation: nil, timeout: nil, budget: nil, asylum: nil, fail_fast: false, verbose: false, show_skips: false,
       list: false, junit: nil, json: nil, timings: 'tmp/padded_cell/timings.tsv', coverage: nil,
       coverage_dir: nil, io: $stdout
     }.freeze
@@ -35,6 +36,8 @@ module PaddedCell
     # Exit status: 0 when everything passed, 1 otherwise, 3 when only
     # coverage is below a minimum, 130 on Ctrl-C.
     def run
+      # The budget covers the whole run, loading included.
+      @limits = Limits.new(timeout: options[:timeout], budget: options[:budget])
       selection = Selection.parse(options[:paths])
       refs = Discovery.call(selection.files)
       filter = Filter.new(selection, refs, include: options[:include], exclude: options[:exclude])
@@ -121,7 +124,8 @@ module PaddedCell
 
     # Yields each result as it arrives. With --asylum a failure is held back:
     # only its final result, after the retries, is reported. Returns 1 when a
-    # worker failed (its cleanup hook), 130 when interrupted, 0 otherwise.
+    # worker failed (its cleanup hook) or tests were left out (the budget ran
+    # out, workers kept dying), 130 when interrupted, 0 otherwise.
     def dispatch(tests, batches, reporter, retried)
       held = {}
       record = lambda do |index, result|
@@ -130,15 +134,16 @@ module PaddedCell
         retried << result if result.metadata? && (result.metadata[:flaky] || result.metadata[:asylum])
       end
       pool = Pool.new(tests, jobs: options[:jobs], isolation: options[:isolation], seed: options[:seed],
-                             timeout: options[:timeout], coverage: @coverage)
+                             limits: @limits, coverage: @coverage)
       pool.run(batches) do |index, result|
         yield index, result
         failed = failed?(result)
         options[:asylum] && failed ? held[index] = result : record.call(index, result)
         pool.stop! if options[:fail_fast] && failed
       end
+      complete = report_left_out(pool)
       retries_ok = retry_held(tests, held, record)
-      pool.success? && retries_ok ? 0 : 1
+      pool.success? && retries_ok && complete ? 0 : 1
     rescue Interrupt
       warn 'Interrupted. Exiting...'
       # Failures still waiting for a retry are failures.
@@ -146,11 +151,31 @@ module PaddedCell
       130
     end
 
+    # False when tests never ran because the budget ran out or workers kept
+    # dying. --fail-fast leaving them out is what it asked for.
+    def report_left_out(pool)
+      left_out = pool.undispatched
+      if pool.gave_up
+        warn "padded_cell: #{pool.gave_up}; gave up, #{left_out} tests not run"
+      elsif @limits.spent? && left_out.positive?
+        warn "padded_cell: run budget of #{@limits.budget}s spent, #{left_out} tests not run"
+      else
+        return true
+      end
+      false
+    end
+
     # False when a retry's worker failed.
     def retry_held(tests, held, record)
       return true if held.empty?
 
-      asylum = Asylum.new(tests, attempts: options[:asylum], seed: options[:seed], timeout: options[:timeout])
+      # No budget left to retry in: failures stay failures.
+      if @limits.spent?
+        held.each { |index, result| record.call(index, result) }
+        return true
+      end
+
+      asylum = Asylum.new(tests, attempts: options[:asylum], seed: options[:seed], limits: @limits)
       asylum.call(held) do |index, result|
         held.delete(index)
         record.call(index, result)

data/lib/padded_cell/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PaddedCell
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

data/lib/padded_cell/worker.rb

@@ -6,12 +6,12 @@ module PaddedCell
   # Minitest::Result as a length-prefixed Marshal frame. Exits once the
   # socket closes.
   class Worker
-    # probe: a Chart::Probe when measuring coverage
-    def initialize(tests, isolation:, seed:, timeout:, probe:)
+    # limits: the run's Limits; probe: a Chart::Probe when measuring coverage
+    def initialize(tests, isolation:, seed:, limits:, probe:)
       @tests = tests
       @isolation = isolation
       @seed = seed
-      @timeout = timeout
+      @limits = limits
       @probe = probe
     end
 
@@ -54,7 +54,7 @@ module PaddedCell
       if setup_error
         Results.crashed(klass, name, "after_fork hook failed: #{setup_error.class}: #{setup_error.message}")
       elsif @isolation == :test
-        Cell.run(klass, name, seed: @seed, timeout: @timeout, close: [socket], probe: @probe)
+        Cell.run(klass, name, seed: @seed, limits: @limits, close: [socket], probe: @probe)
       else
         Cell.execute(klass, name)
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: padded_cell
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: x86_64-linux-gnu
 authors:
 - Abdelkader Boudih
@@ -56,6 +56,7 @@ files:
 - lib/padded_cell/cli.rb
 - lib/padded_cell/discovery.rb
 - lib/padded_cell/hooks.rb
+- lib/padded_cell/limits.rb
 - lib/padded_cell/loader.rb
 - lib/padded_cell/native.rb
 - lib/padded_cell/pool.rb