kimera 0.1.0

data/lib/kimera/execution/shift/coverage_channel.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+class Kimera::Execution::Shift::CoverageChannel
+  def initialize(adapter)
+    @adapter = adapter
+  end
+
+  def serve(request, response)
+    ledger = Kimera::Runtime.start!
+    drain(request, response, ledger)
+    emit(response, t: "done")
+  ensure
+    stop(ledger)
+  end
+
+  private
+
+  def drain(request, response, ledger)
+    while (line = request.gets)
+      step(response, JSON.parse(line)["id"], ledger)
+      emit(response, t: "ready")
+    end
+  end
+
+  def step(response, testid, ledger)
+    Kimera::Runtime.active = nil
+    emit(response, **message(testid, ledger, @adapter.run([testid])))
+  end
+
+  def message(testid, ledger, outcome)
+    { t: "result", id: testid, passed: outcome.passed? }
+      .merge(touched: Kimera::Runtime.drain!(ledger), failure: outcome.failures[testid])
+  end
+
+  def stop(ledger)
+    Kimera::Runtime.stop!(ledger)
+    Kimera::Runtime.active = nil
+  end
+
+  def emit(io, **msg)
+    io.puts(JSON.generate(msg))
+  end
+end

data/lib/kimera/execution/shift/killer_memory.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class Kimera::Execution::Shift::KillerMemory
+  LIMIT = 16
+
+  def initialize
+    @recent = []
+  end
+
+  def order(tests)
+    likely = @recent & tests
+    likely + (tests - likely)
+  end
+
+  def remember(testid)
+    @recent.delete(testid)
+    @recent.unshift(testid)
+    @recent.pop while @recent.size > LIMIT
+  end
+end

data/lib/kimera/execution/shift/leak_guard.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class Kimera::Execution::Shift::LeakGuard
+  def initialize(every, &evaluator)
+    @every = every
+    @evaluator = evaluator
+  end
+
+  def check(io, history, index)
+    return unless due?(index)
+    return if history.empty?
+    recheck(io, history.last)
+  end
+
+  private
+
+  def due?(index)
+    return false unless @every&.positive?
+    ((index + 1) % @every).zero?
+  end
+
+  def recheck(io, id)
+    return if @evaluator.call(id).killed?
+    emit(io, t: "leak", id: id, detail: detail(id))
+  end
+
+  def detail(id)
+    "mutant #{id} killed earlier but survived re-run (state leakage suspected)"
+  end
+
+  def emit(io, **msg)
+    io.puts(JSON.generate(msg))
+  end
+end

data/lib/kimera/execution/shift.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "json"
+require "timeout"
+require_relative "../results/result"
+require_relative "../runtime"
+require_relative "isolation"
+
+class Kimera::Execution::Shift
+  Subject = Struct.new(:id, :file)
+  Channel =
+    Data.define(:requests, :responses) do
+      def each_request
+        while (line = requests.gets)
+          yield(line, responses)
+        end
+      end
+    end
+
+  def initialize(adapter:, registry:, coverage: nil, **options)
+    @adapter = adapter
+    @registry = registry
+    @coverage = coverage
+    @options = options
+  end
+
+  def serve(requests, responses)
+    listen(Channel.new(requests, responses))
+    emit(responses, t: "done")
+  ensure
+    Kimera::Runtime.active = nil
+  end
+
+  def coverage(requests, responses) = channel.serve(requests, responses)
+
+  def run(ids, io)
+    history = []
+    ids.each_with_index { |id, index| process(id, io, history, index) }
+    emit(io, t: "done")
+  ensure
+    Kimera::Runtime.active = nil
+  end
+
+  def evaluate(id)
+    safely(Subject.new(id, @registry.index[id]&.file))
+  ensure
+    Kimera::Runtime.active = nil
+    isolation.reset!
+  end
+
+  private
+
+  def isolation = @_isolation ||= @options.fetch(:isolation) { Kimera::Execution::Isolation.new }
+
+  def timeout = @options.fetch(:soft_timeout, 5.0)
+
+  def attempt
+    kind = self.class
+    @_attempt ||= kind::Attempt.new(
+      adapter: @adapter, isolation: isolation, killers: kind::KillerMemory.new, timeout: timeout
+    )
+  end
+
+  def leaks = @_leaks ||= self.class::LeakGuard.new(@options.fetch(:leak_every, 10)) { |id| evaluate(id) }
+
+  def channel = @_channel ||= self.class::CoverageChannel.new(@adapter)
+
+  def listen(connection)
+    history = []
+    index = 0
+    connection.each_request { |line, responses| index = step(line, responses, history, index) }
+  end
+
+  def step(line, responses, history, index)
+    process(JSON.parse(line)["id"], responses, history, index)
+    emit(responses, t: "ready")
+    index + 1
+  end
+
+  def safely(subject)
+    tests = available(subject.id)
+    return result(subject, :no_coverage) if tests.empty?
+    outcome(subject, tests)
+  rescue StandardError, ScriptError => error
+    error(subject, error)
+  end
+
+  def error(subject, error)
+    return result(subject, :timeout, timeout) if error.is_a?(Timeout::Error)
+    result(subject, :error, detail: "#{error.class}: #{error.message}")
+  end
+
+  def outcome(subject, tests)
+    started = monotonic
+    outcome = attempt.run(subject.id, tests)
+    result(subject, classify(outcome), monotonic - started, failing(outcome), tests)
+  end
+
+  def process(id, io, history, index)
+    result = evaluate(id)
+    emit(io, **result.message)
+    history << id if result.killed?
+    leaks.check(io, history, index)
+  end
+
+  def classify(outcome)
+    !outcome || outcome.passed? ? :survived : :killed
+  end
+
+  def failing(outcome) = outcome&.failed_ids
+
+  def available(id)
+    return @adapter.test_ids unless @coverage
+    @coverage.fetch(id) { @coverage.fetch(id.to_s, []) }
+  end
+
+  def result(subject, status, duration = nil, fails = nil, cover = nil, detail: nil)
+    Kimera::MutantResult.new(
+      mutant_id: subject.id, status: status, file: subject.file,
+      duration: duration, failing_tests: fails,
+      covering_tests: cover, detail: detail
+    )
+  end
+
+  def emit(io, **message)
+    io.puts(JSON.generate(message))
+  end
+
+  def monotonic
+    Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+end
+
+require_relative "shift/attempt"
+require_relative "shift/coverage_channel"
+require_relative "shift/killer_memory"
+require_relative "shift/leak_guard"

data/lib/kimera/execution/sweep.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Kimera
+  module Execution
+  end
+end
+
+class Kimera::Execution::Sweep
+  def initialize(ids, lock)
+    @ids = ids
+    @lock = lock
+  end
+
+  def total = @ids.size
+
+  def results = @_results ||= []
+
+  def pop = queue.pop(timeout: 0)
+
+  def each(&) = @ids.each(&)
+
+  def record(result)
+    @lock.synchronize { results << result }
+    results.size
+  end
+
+  private
+
+  def queue = @_queue ||= Queue.new.tap { |pending| @ids.each { |id| pending << id } }
+end

data/lib/kimera/execution/transaction_isolation.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "isolation"
+
+class Kimera::Execution::TransactionIsolation < Kimera::Execution::Isolation; end
+class Kimera::Execution::TransactionIsolation::Rollback < StandardError; end
+
+class Kimera::Execution::TransactionIsolation
+  def initialize(owner)
+    super()
+    @owner = owner
+  end
+
+  def around
+    result = nil
+    rollback { result = yield }
+    result
+  end
+
+  private
+
+  def rollback(&)
+    @owner.transaction(requires_new: true) { unwind(&) }
+  rescue Rollback
+    nil
+  end
+
+  def unwind
+    yield
+    raise(Rollback)
+  end
+end

data/lib/kimera/execution/trial.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Kimera
+  module Execution
+  end
+end
+
+Kimera::Execution::Trial =
+  Struct.new(:id, :mirror, :synth, :file) do
+    def stage(root)
+      source = File.read(File.join(root, file), encoding: Encoding::UTF_8)
+      target = File.join(mirror, file)
+      File.write(target, synth.bake(file, source, id))
+      [source, target]
+    end
+  end

data/lib/kimera/execution/verdicts.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "../results/result"
+require_relative "../self_protection"
+
+module Kimera
+  module Execution
+  end
+end
+
+class Kimera::Execution::Verdicts
+  def initialize(registry)
+    @registry = registry
+  end
+
+  def safe?(id)
+    point(id).safe?
+  end
+
+  def reloadable?(id)
+    !point(id).body?
+  end
+
+  def reclassify!(results)
+    results.each { |id, result| reclassify(results, id, result) }
+  end
+
+  def parse(message)
+    id = message["id"]
+    Kimera::MutantResult.new(
+      mutant_id: id, status: message["status"].to_sym, file: path(id),
+      duration: message["ms"], failing_tests: message["fails"], covering_tests: message["cover"]
+    )
+  end
+
+  def timeout(id, duration)
+    Kimera::MutantResult.new(
+      mutant_id: id, status: :timeout, file: path(id),
+      duration: duration, detail: "hard watchdog timeout"
+    )
+  end
+
+  def unjudged(id, detail)
+    Kimera::MutantResult.new(mutant_id: id, status: :harness_error, file: path(id), detail: detail)
+  end
+
+  def quarantine(id)
+    Kimera::MutantResult.new(mutant_id: id, status: :isolated_only, file: path(id), detail: point(id).unsafe_reason)
+  end
+
+  def point(id)
+    @registry.index[id] || Kimera::MutationPoint::NONE
+  end
+
+  def path(id)
+    point(id).file
+  end
+
+  private
+
+  def reclassify(results, id, result)
+    return unless suspect?(result)
+    results[id] = result.isolated(detail(result.status))
+  end
+
+  def suspect?(result)
+    Kimera::Status::SELF_SUSPECT.include?(result.status) && harness?(result)
+  end
+
+  def harness?(result)
+    Kimera::SelfProtection.critical?(result.file)
+  end
+
+  def detail(status)
+    "#{status == :survived ? "unfalsifiable warm survivor" : "self-crash"} in the in-process runner " \
+      "(warm #{status}); evaluate with --isolated"
+  end
+end

data/lib/kimera/execution/worker_pool/fleet.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative "stillborn_guard"
+
+class Kimera::Execution::WorkerPool::Fleet
+  include Kimera::Execution::ChildProcess
+
+  def initialize(queue:, spawner:, jobs:, pool:)
+    @source = queue
+    @spawner = spawner
+    @jobs = jobs
+    @pool = pool
+  end
+
+  def bootstrap
+    [@jobs, queue.size].min.times { spawn }
+  end
+
+  def each(&)
+    workers.each_value(&)
+  end
+
+  def pairs(&)
+    workers.to_a.each(&)
+  end
+
+  def fetch(pipe)
+    workers.fetch(pipe)
+  end
+
+  def keys
+    workers.keys
+  end
+
+  def any?
+    workers.any?
+  end
+
+  def take
+    until queue.empty?
+      id = queue.shift
+      return id unless done[id]
+    end
+  end
+
+  def done!(id)
+    done[id] = true
+  end
+
+  def progress!
+    guard.progress!
+  end
+
+  def remove(pipe, reason: :crash)
+    worker = workers.delete(pipe)
+    slots.push(worker.slot)
+    close(worker)
+    charge(worker.inflight, reason, reap(worker.pid))
+    refill
+  end
+
+  private
+
+  def queue = @_queue ||= @source.dup
+
+  def done = @_done ||= {}
+
+  def workers = @_workers ||= {}
+
+  def slots = @_slots ||= (0...@jobs).to_a
+
+  def guard = @_guard ||= Kimera::Execution::WorkerPool::StillbornGuard.new(@jobs)
+
+  def spawn
+    slot = slots.shift
+    pid, request, pipe = @spawner.call(slot)
+    workers[pipe] = Kimera::Execution::WorkerPool::Worker.new(pid, request, pipe, nil, nil, slot)
+  end
+
+  def close(worker)
+    shut(worker.response)
+    shut(worker.request)
+  end
+
+  def charge(id, reason, status)
+    return unless id
+    guard.track(status) if reason == :crash
+    done!(id)
+    @pool.lost(id, reason)
+  end
+
+  def refill
+    missing = @jobs - workers.size
+    missing.times do
+      break unless queue.any? { |id| !done[id] }
+      replace
+    end
+  end
+
+  def replace
+    spawn
+    @pool.assign(workers.values.last)
+  end
+end

data/lib/kimera/execution/worker_pool/stillborn_guard.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../../error"
+
+class Kimera::Execution::WorkerPool::StillbornGuard
+  def initialize(jobs)
+    @jobs = jobs
+    @stillborn = 0
+    @progressed = false
+  end
+
+  def progress!
+    @progressed = true
+  end
+
+  def track(status)
+    return if @progressed
+    @stillborn += 1
+    abort!(status) if @stillborn > @jobs
+  end
+
+  private
+
+  def abort!(status)
+    raise(Kimera::Error, message(status))
+  end
+
+  def message(status)
+    "#{@stillborn} warm workers died before reporting a result " \
+      "(last exit: #{describe(status)}). The app raises during " \
+      "fork or the suite aborts on load; re-run with --jobs 1 to see " \
+      "the error."
+  end
+
+  def describe(status)
+    [status].compact.map do |current|
+      current.signaled? ? "signal #{current.termsig}" : "status #{current.exitstatus}"
+    end.fetch(0, "unknown")
+  end
+end

data/lib/kimera/execution/worker_pool/worker.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+Kimera::Execution::WorkerPool::Worker =
+  Struct.new(:pid, :request, :response, :inflight, :deadline, :slot) do
+    def idle!
+      self.inflight = nil
+    end
+
+    def busy!(id)
+      self.inflight = id
+    end
+
+    def renew(limit)
+      self.deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + limit
+    end
+
+    def expired?(now)
+      deadline && !(deadline - now).positive?
+    end
+
+    def retire
+      self.inflight = nil
+      self.deadline = nil
+      request
+    end
+
+    def offer(id)
+      request.puts(JSON.generate(id: id))
+    rescue Errno::EPIPE, IOError
+      nil
+    end
+  end

data/lib/kimera/execution/worker_pool.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../error"
+require_relative "child_process"
+
+class Kimera::Execution::WorkerPool
+  include Kimera::Execution::ChildProcess
+
+  Context = Data.define(:queue, :spawner, :resolve, :lost, :options)
+
+  POLL_INTERVAL = 0.2
+
+  class << self
+    def new(queue:, spawner:, resolve:, lost:, **options)
+      super(Context.new(queue, spawner, resolve, lost, options))
+    end
+  end
+
+  def initialize(context)
+    @context = context
+  end
+
+  def run
+    bootstrap
+    poll while fleet.any?
+  end
+
+  def assign(worker)
+    id = fleet.take
+    return close(worker) unless id
+    worker.busy!(id)
+    worker.renew(limit)
+    worker.offer(id)
+  end
+
+  def lost(id, reason) = context.lost.call(id, reason)
+
+  private
+
+  attr_reader :context
+
+  def limit = context.options.fetch(:hard_timeout)
+
+  def fleet
+    @_fleet ||= Kimera::Execution::WorkerPool::Fleet.new(
+      queue: context.queue, spawner: context.spawner, jobs: context.options.fetch(:jobs), pool: self
+    )
+  end
+
+  def bootstrap
+    fleet.bootstrap
+    fleet.each { |worker| assign(worker) }
+  end
+
+  def poll
+    ready, = IO.select(fleet.keys, nil, nil, POLL_INTERVAL)
+    Array(ready).each { |pipe| service(pipe) }
+    watch
+  end
+
+  def service(pipe)
+    worker = fleet.fetch(pipe)
+    line = pipe.gets
+    return fleet.remove(pipe) unless line
+    message = parse(line)
+    dispatch(worker, message) if message
+  end
+
+  def dispatch(worker, message)
+    case message["t"]
+    when "result" then finish(worker, message)
+    when "leak" then context.resolve.call(message)
+    when "ready" then assign(worker)
+    end
+  end
+
+  def finish(worker, message)
+    fleet.done!(message["id"])
+    fleet.progress!
+    context.resolve.call(message)
+    worker.idle!
+    worker.renew(limit)
+  end
+
+  def close(worker) = shut(worker.retire)
+
+  def watch
+    current = now
+    fleet.pairs { |pipe, worker| expire(pipe, worker, current) }
+  end
+
+  def expire(pipe, worker, current)
+    return unless worker.expired?(current)
+    kill(worker.pid)
+    fleet.remove(pipe, reason: :timeout)
+  end
+end
+
+require_relative "worker_pool/fleet"
+require_relative "worker_pool/worker"