kimera 0.1.0

data/lib/kimera/execution/overlay_guard_modules.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative "callback"
+
+module Kimera
+  module Execution
+    module OverlayGuardModules
+      module_function
+
+      ENUMGUARD =
+        Module.new do
+        def enum(*args, **kwargs, &)
+          name = args.find { |a| a.is_a?(Symbol) || a.is_a?(String) } || kwargs.keys.first
+          return if name && respond_to?(:defined_enums) && defined_enums.key?(name.to_s)
+          super
+        end
+      end
+
+      CALLBACKGUARD =
+        Module.new do
+        def set_callback(name, *filter_list, &block)
+          return super unless Kimera::Execution::OverlayGuards.overlaying?
+          type, filters, options = normalize_callback_params(filter_list.dup, block)
+          fresh = Kimera::Execution::OverlayGuardModules.fresh(__send__(:get_callbacks, name), type, filters)
+          return if fresh.empty?
+          super(name, type, *fresh, options)
+        end
+      end
+
+      def enum = ENUMGUARD
+
+      def callback = CALLBACKGUARD
+
+      def fresh(chain, type, filters)
+        running = chain.select { |callback| callback.kind == type }
+        filters.reject { |filter| duplicate?(running, filter) }
+      end
+
+      def duplicate?(callbacks, filter)
+        match = Kimera::Execution::Callback.new(filter)
+        callbacks.any? { |callback| match.duplicate?(callback.filter) }
+      end
+
+      SERIALIZEGUARD =
+        Module.new do
+        def serialize(attribute, *args, **options, &)
+          return if OverlayGuards.overlaying? && OverlayGuardModules.serialized?(type_for_attribute(attribute))
+          super
+        end
+      end
+
+      CONCERNGUARD =
+        Module.new do
+        %i[included prepended].each do |hook|
+          stored = :"@_#{hook}_block"
+          define_method(hook) do |base = nil, &block|
+            next super(base, &block) unless block && OverlayGuardModules.replacing?(self, stored, base)
+            instance_variable_set(stored, block)
+          end
+        end
+      end
+
+      def serialization = SERIALIZEGUARD
+
+      def concern = CONCERNGUARD
+
+      def replacing?(target, stored, base)
+        Kimera::Execution::OverlayGuards.overlaying? && !base && target.instance_variable_defined?(stored)
+      end
+
+      def serialized?(type, depth = 10)
+        return false unless depth.positive?
+        return true if leaf?(type)
+        serialized?(unwrap(type), depth - 1)
+      end
+
+      def leaf?(type)
+        defined?(ActiveRecord::Type::Serialized) &&
+          type.is_a?(ActiveRecord::Type::Serialized)
+      end
+
+      def unwrap(type)
+        type.cast_type
+      rescue NoMethodError
+        subtype(type)
+      end
+
+      def subtype(type)
+        type.subtype
+      rescue NoMethodError
+        nil
+      end
+    end
+  end
+end

data/lib/kimera/execution/overlay_guards.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "overlay_guard_modules"
+
+module Kimera
+  module Execution
+    module OverlayGuards
+      class << self
+        attr_accessor :overlaying
+
+        alias overlaying? overlaying
+      end
+
+      module_function
+
+      def overlay
+        install!
+        self.overlaying = true
+        yield
+      ensure
+        self.overlaying = false
+      end
+
+      def install!
+        enum!
+        callbacks!
+        concern!
+        serialize!
+      end
+
+      def enum!
+        return unless defined?(ActiveRecord::Base)
+        ActiveRecord::Base.singleton_class.prepend(OverlayGuardModules.enum)
+      end
+
+      def callbacks!
+        return unless defined?(ActiveSupport::Callbacks::ClassMethods)
+        ActiveSupport::Callbacks::ClassMethods.prepend(OverlayGuardModules.callback)
+      end
+
+      def serialize!
+        return unless defined?(ActiveRecord::Base)
+        ActiveRecord::Base.singleton_class.prepend(OverlayGuardModules.serialization)
+      end
+
+      def concern!
+        return unless defined?(ActiveSupport::Concern)
+        ActiveSupport::Concern.prepend(OverlayGuardModules.concern)
+      end
+
+      def serialized?(type)
+        OverlayGuardModules.serialized?(type)
+      end
+    end
+  end
+end

data/lib/kimera/execution/parallel_test_databases.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+class Kimera::Execution::ParallelTestDatabases
+  def initialize(adapter:, jobs:, errors: nil)
+    @adapter = adapter
+    @jobs = jobs
+    @errors = errors
+  end
+
+  def active?
+    return false unless eligible?
+    register!
+    ActiveSupport::Testing::Parallelization.after_fork_hooks.any?
+  end
+
+  def before_fork
+    return unless active?
+    ActiveSupport::Testing::Parallelization.before_fork_hooks.each(&:call)
+  end
+
+  def after_fork(index)
+    return unless index && active?
+    ActiveSupport::Testing::Parallelization.after_fork_hooks.each { |hook| hook.call(index) }
+    @adapter.start
+  end
+
+  def before_exit(index)
+    Array(index).each { cleanup }
+  rescue StandardError => error
+    errors.puts("kimera: parallelize_teardown failed (#{error.class}: #{error.message})")
+  end
+
+  private
+
+  def cleanup
+    return unless active?
+    ActiveSupport::Testing::Parallelization.run_cleanup_hooks.each(&:call)
+  end
+
+  def errors = @errors || $stderr
+
+  def eligible?
+    return false unless @jobs > 1
+    return false unless defined?(ActiveSupport::Testing::Parallelization)
+    configured?
+  end
+
+  def configured?
+    ActiveSupport.parallelize_test_databases
+  rescue NoMethodError
+    false
+  end
+
+  def register!
+    return unless defined?(ActiveRecord::Base)
+    require("active_record/test_databases")
+  rescue LoadError, StandardError => error
+    errors.puts(notice(error))
+  end
+
+  def notice(error)
+    "kimera: per-worker test databases unavailable (#{error.class}: #{error.message}); workers share one database"
+  end
+end

data/lib/kimera/execution/pool_driver.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require_relative "child_process"
+require_relative "shift"
+require_relative "worker_pool"
+
+class Kimera::Execution::Pool
+  include Kimera::Execution::ChildProcess
+
+  Channels =
+    Struct.new(:req_r, :req_w, :res_r, :res_w) do
+      def parent!
+        req_r.close
+        res_w.close
+        [req_w, res_r]
+      end
+
+      def child!
+        req_w.close
+        res_r.close
+      end
+    end
+
+  Duty =
+    Struct.new(:entry, :index, :pipes) do
+      def run(shift)
+        shift.public_send(entry, pipes.req_r, pipes.res_w)
+      end
+
+      def finish(database)
+        database.before_exit(index)
+        pipes.res_w.close
+      end
+    end
+
+  def initialize(adapter:, registry:, isolation:, **options)
+    @adapter = adapter
+    @registry = registry
+    @isolation = isolation
+    @options = options
+  end
+
+  def coverage = @options[:coverage]
+
+  def coverage=(measured)
+    @options[:coverage] = measured
+  end
+
+  def drive(queue, spawner, resolve:, lost:)
+    Kimera::Execution::WorkerPool.new(
+      queue: queue, spawner: spawner, jobs: @options.fetch(:jobs),
+      hard_timeout: @options.fetch(:hard), resolve: resolve, lost: lost
+    ).run
+  end
+
+  def worker(index = nil)
+    launch(:serve, index)
+  end
+
+  def channel(index = nil)
+    launch(:coverage, index)
+  end
+
+  private
+
+  def database = @options.fetch(:paralleldb)
+
+  def launch(entry, index)
+    database.before_fork
+    duty = Duty.new(entry, index, channels)
+    [spawn(duty), *duty.pipes.parent!]
+  end
+
+  def channels
+    request, response = Array.new(2) { IO.pipe }
+    Channels.new(*request, *response)
+  end
+
+  def spawn(duty) = fork { boot(duty) }
+
+  def boot(duty)
+    duty.pipes.child!
+    silence!
+    database.after_fork(duty.index)
+    serve(duty)
+    exit!(0)
+  end
+
+  def serve(duty)
+    duty.run(build)
+  ensure
+    duty.finish(database)
+  end
+
+  def build
+    Kimera::Execution::Shift.new(
+      adapter: @adapter, registry: @registry, coverage: coverage,
+      isolation: @isolation, soft_timeout: @options.fetch(:soft), leak_every: @options.fetch(:leak)
+    )
+  end
+end

data/lib/kimera/execution/priority.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Kimera
+  module Execution
+  end
+end
+
+class Kimera::Execution::Priority
+  def initialize(coverage)
+    @coverage = coverage
+  end
+
+  def order(ids)
+    return ids unless @coverage
+    ids.sort_by { |id| -count(id) }
+  end
+
+  private
+
+  def count(id)
+    @coverage.fetch(id) { @coverage.fetch(id.to_s, []) }.size
+  end
+end

data/lib/kimera/execution/reload.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../runtime"
+require_relative "../synthesis/overlay"
+require_relative "child_process"
+require_relative "overlay_guards"
+require_relative "verdicts"
+
+class Kimera::Execution::Reload
+  Failure =
+    Data.define(:exception) do
+      def message = "#{exception.class}: #{exception.message}"
+    end
+  include Kimera::Execution::ChildProcess
+
+  Errand =
+    Struct.new(:id, :reader, :writer) do
+      def parent!
+        writer.close
+      end
+
+      def child!
+        reader.close
+      end
+
+      def emit(payload)
+        writer.puts(payload)
+        writer.close
+      end
+
+      def await(deadline, &)
+        return reader.gets if reader.wait_readable(deadline)
+        yield
+        nil
+      ensure
+        reader.close
+      end
+    end
+
+  def initialize(registry:, adapter:, isolation:, root:)
+    @registry = registry
+    @adapter = adapter
+    @isolation = isolation
+    @root = root
+  end
+
+  def run(id, deadline:)
+    errand = Errand.new(id, *IO.pipe)
+    collect(errand, child(errand), deadline)
+  end
+
+  private
+
+  def child(errand)
+    fork { work(errand) }.tap { errand.parent! }
+  end
+
+  def work(errand)
+    errand.child!
+    silence!
+    errand.emit(report(errand.id))
+    exit!(0)
+  end
+
+  def report(id)
+    status, fails = evaluate(id)
+    JSON.generate(id: id, status: status.to_s, fails: fails)
+  end
+
+  def collect(errand, pid, deadline)
+    line = errand.await(deadline) { kill(pid) }
+    reap(pid)
+    verdict(errand.id, line)
+  end
+
+  def evaluate(id)
+    mutate(id).verdict
+  rescue StandardError, ScriptError => error
+    [:error, [Failure.new(error).message]]
+  end
+
+  def mutate(id)
+    file = verdicts.point(id).file
+    overlay(file, File.join(File.expand_path(@root), file), id)
+    Kimera::Runtime.active = nil
+    @isolation.around { @adapter.run(@adapter.test_ids) }
+  end
+
+  def overlay(file, path, id)
+    baked = Kimera::Overlay.new(@registry).bake(file, File.read(path, encoding: Encoding::UTF_8), id)
+    Kimera::Execution::OverlayGuards.overlay { Kimera::Overlay.evaluate(baked, path) }
+  end
+
+  def verdict(id, line)
+    return verdicts.unjudged(id, "reload worker produced no result") unless line
+    message = parse(line)
+    message ? verdicts.parse(message) : verdicts.unjudged(id, "reload worker output unparseable")
+  end
+
+  def verdicts
+    Kimera::Execution::Verdicts.new(@registry)
+  end
+end

data/lib/kimera/execution/rig.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "parallel_test_databases"
+require_relative "pool_driver"
+require_relative "schedule"
+
+class Kimera::Execution::Rig
+  def initialize(**options)
+    @options = options
+  end
+
+  def driver = @_driver ||= pool
+
+  def spawner = @_spawner ||= @options[:spawner] || driver.method(:worker)
+
+  def schedule = @_schedule ||= plan
+
+  private
+
+  def parallel
+    @_parallel ||= Kimera::Execution::ParallelTestDatabases.new(
+      adapter: @options.fetch(:adapter), jobs: @options.fetch(:jobs)
+    )
+  end
+
+  def pool
+    Kimera::Execution::Pool.new(
+      adapter: @options.fetch(:adapter), registry: @options.fetch(:registry),
+      isolation: @options.fetch(:isolation), jobs: @options.fetch(:jobs), hard: @options.fetch(:hard),
+      soft: @options.fetch(:soft), leak: @options.fetch(:leak), paralleldb: parallel, coverage: @options[:coverage]
+    )
+  end
+
+  def plan
+    Kimera::Execution::Schedule.new(
+      registry: @options.fetch(:registry), driver: driver, spawner: spawner,
+      adapter: @options.fetch(:adapter), isolation: @options.fetch(:isolation),
+      root: @options.fetch(:root), progress: @options.fetch(:progress), hard: @options.fetch(:hard)
+    )
+  end
+end

data/lib/kimera/execution/schedule.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative "priority"
+require_relative "reload"
+require_relative "verdicts"
+
+class Kimera::Execution::Schedule
+  Ledger = Struct.new(:results, :leaks)
+  Batch = Struct.new(:safe, :reloadable, :deferred, :ledger)
+
+  LOSSES = { timeout: :expired }.freeze
+
+  def initialize(registry:, driver:, spawner:, **options)
+    @registry = registry
+    @driver = driver
+    @spawner = spawner
+    @options = options
+  end
+
+  def run(ids, coverage:, label: "mutants")
+    batch = plan(ids, coverage, label)
+    process(batch)
+    finish(batch.ledger)
+  ensure
+    progress.finish
+  end
+
+  private
+
+  def progress = @options.fetch(:progress)
+
+  def hard = @options[:hard]
+
+  def verdicts = @_verdicts ||= Kimera::Execution::Verdicts.new(@registry)
+
+  def plan(ids, coverage, label)
+    safe, unsafe = ids.partition { |id| verdicts.safe?(id) }
+    reloadable, deferred = unsafe.partition { |id| verdicts.reloadable?(id) }
+    progress.start(safe.size + unsafe.size, label)
+    Batch.new(Kimera::Execution::Priority.new(coverage).order(safe), reloadable, deferred, Ledger.new({}, []))
+  end
+
+  def process(batch)
+    safe, reloadable, deferred, ledger = batch.to_a
+    pool(safe, ledger)
+    reload(reloadable, ledger)
+    defer(deferred, ledger)
+  end
+
+  def finish(ledger)
+    results = ledger.results
+    verdicts.reclassify!(results)
+    Kimera::RunReport.new(results: results.values, leaks: ledger.leaks, registry: @registry)
+  end
+
+  def record(ledger, id, result)
+    ledger.results[id] = result
+    progress.tick(result.status)
+  end
+
+  def reload(ids, ledger)
+    ids.each { |id| record(ledger, id, reloader.run(id, deadline: hard)) }
+  end
+
+  def defer(ids, ledger)
+    ids.each { |id| record(ledger, id, verdicts.quarantine(id)) }
+  end
+
+  def pool(queue, ledger)
+    @driver.drive(queue, @spawner, resolve: resolver(ledger), lost: loser(ledger))
+  end
+
+  def resolver(ledger)
+    ->(message) { resolve(message, ledger) }
+  end
+
+  def loser(ledger)
+    ->(id, reason) { record(ledger, id, lost(id, reason)) }
+  end
+
+  def resolve(message, ledger)
+    case message["t"]
+    when "result" then parse(message, ledger)
+    when "leak" then ledger.leaks << Kimera::LeakReport.new(mutant_id: message["id"], detail: message["detail"])
+    end
+  end
+
+  def parse(message, ledger)
+    result = verdicts.parse(message)
+    record(ledger, result.mutant_id, result)
+  end
+
+  def lost(id, reason) = __send__(LOSSES.fetch(reason, :crashed), id)
+
+  def expired(id) = verdicts.timeout(id, hard)
+
+  def crashed(id) = verdicts.unjudged(id, "worker crashed before result")
+
+  def reloader
+    Kimera::Execution::Reload.new(
+      registry: @registry, adapter: @options.fetch(:adapter),
+      isolation: @options.fetch(:isolation), root: @options.fetch(:root)
+    )
+  end
+end

data/lib/kimera/execution/schemata.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "stringio"
+require_relative "../self_protection"
+require_relative "../synthesis/overlay"
+require_relative "overlay_guards"
+
+class Kimera::Execution::Schemata
+  attr_reader :skipped
+
+  def initialize(registry, root: ".", errors: nil)
+    @registry = registry
+    @root = root
+    @errors = errors
+    @skipped = {}
+  end
+
+  class << self
+    def install!
+      Kimera::Execution::OverlayGuards.install!
+    end
+
+    def with_guards(&)
+      Kimera::Execution::OverlayGuards.overlay(&)
+    end
+  end
+
+  def overlay!
+    Kimera::Execution::OverlayGuards.install!
+    @registry.files.flat_map { |path| load(path) }
+  end
+
+  private
+
+  def load(path)
+    file = File.join(root, path)
+    return [] unless File.file?(file)
+    return [] if Kimera::SelfProtection.protected?(file)
+    overlay(path, file)
+  end
+
+  def overlay(path, file)
+    result = synthesize(path, file)
+    return [] if result.mutant_ids.empty?
+    apply(result, file)
+  rescue StandardError, ScriptError, SystemExit => error
+    skip(path, error)
+  end
+
+  def synthesize(path, file)
+    synth.synthesize(path, File.read(file, encoding: Encoding::UTF_8))
+  end
+
+  def apply(result, file)
+    silence { result.install(file) }
+  end
+
+  def skip(path, error)
+    reason = "#{error.class}: #{error.message}"
+    @skipped[path] = reason
+    notice(path, reason)
+    []
+  end
+
+  def notice(path, reason)
+    errors.puts(
+      "kimera: #{path} cannot run in warm workers — schemata setup failed " \
+        "(#{reason}); its mutants are reported no_coverage"
+    )
+  end
+
+  def errors = @errors || $stderr
+
+  def root = @_root ||= File.expand_path(@root)
+
+  def synth = @_synth ||= Kimera::Overlay.new(@registry)
+
+  def silence(&)
+    original, captured = capture
+    Kimera::Execution::OverlayGuards.overlay(&).tap { original.write(captured.string) }
+  ensure
+    $stderr = original
+  end
+
+  def capture
+    [$stderr, $stderr = StringIO.new]
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "timeout"
+
+class Kimera::Execution::Shift::Attempt
+  def initialize(adapter:, isolation:, killers:, timeout:)
+    @adapter = adapter
+    @isolation = isolation
+    @killers = killers
+    @timeout = timeout
+  end
+
+  def run(id, tests)
+    timeout { @isolation.around { attempt(id, tests) } }
+  end
+
+  private
+
+  def attempt(id, tests)
+    @killers.order(tests).lazy.map { |testid| kill(id, testid) }.find { |outcome| outcome }
+  end
+
+  def kill(id, testid)
+    Kimera::Runtime.active = id
+    outcome = @adapter.run([testid])
+    return if outcome.passed?
+    @killers.remember(testid)
+    outcome
+  end
+
+  def timeout(&)
+    Timeout.timeout(@timeout, &)
+  end
+end