fun_ci 1.1.0 → 1.2.0

data/lib/fun_ci/stage_runner.rb

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-require "open3"
-require "timeout"
-
-module FunCi
-  class StageRunner
-    def initialize(commit_hash:, stdout:, command_runner: nil, time_budgets: {}, recorder: NullRecorder.new)
-      @commit_hash = commit_hash
-      @stdout = stdout
-      @command_runner = command_runner
-      @time_budgets = time_budgets
-      @recorder = recorder
-    end
-
-    def run_stage(config, stage)
-      script = config.script_path(stage)
-      budget = @time_budgets[stage]
-
-      job_id = @recorder.start_stage(stage)
-      output, status, timed_out = run_with_timeout(script, budget)
-
-      if timed_out
-        @recorder.end_stage(job_id, "timed_out")
-        @stdout.puts "#{stage_label(stage)} killed -- exceeded #{budget}s time budget."
-        @stdout.puts budget_advice(stage)
-        return false
-      end
-
-      unless status.success?
-        @recorder.end_stage(job_id, "failed")
-        @stdout.puts output unless output.empty?
-        @stdout.puts "#{stage_label(stage)} failed."
-        return false
-      end
-
-      @recorder.end_stage(job_id, "completed")
-      true
-    end
-
-    private
-
-    def run_with_timeout(script, budget)
-      cmd = "#{script} #{@commit_hash}"
-
-      if @command_runner
-        begin
-          Timeout.timeout(budget) do
-            output, status = @command_runner.call(cmd)
-            [output, status, false]
-          end
-        rescue Timeout::Error
-          ["", nil, true]
-        end
-      else
-        run_process_with_timeout(cmd, budget)
-      end
-    end
-
-    def run_process_with_timeout(cmd, budget)
-      pid = nil
-      output = ""
-      r, w = IO.pipe
-      pid = Process.spawn(cmd, out: w, err: w)
-      w.close
-
-      begin
-        Timeout.timeout(budget) do
-          output = r.read
-          _, status = Process.waitpid2(pid)
-          pid = nil
-          [output, status, false]
-        end
-      rescue Timeout::Error
-        Process.kill("TERM", pid) rescue nil
-        Process.kill("KILL", pid) rescue nil
-        Process.waitpid(pid) rescue nil
-        r.close rescue nil
-        ["", nil, true]
-      ensure
-        r.close rescue nil
-      end
-    end
-
-    def stage_label(stage)
-      case stage
-      when "lint" then "Lint"
-      when "build" then "Build"
-      when "fast" then "Fast suite"
-      when "slow" then "Slow suite"
-      else stage
-      end
-    end
-
-    def budget_advice(stage)
-      case stage
-      when "lint"
-        "Trim your linter config or split into stages."
-      when "build"
-        "Keep your build efficient and not let it become a bottleneck."
-      when "fast"
-        "Your fast tests have gotten too slow. Split or speed them up."
-      when "slow"
-        "Pare down integration tests, parallelise, or raise the budget."
-      end
-    end
-  end
-end

data/lib/fun_ci/stale_pipeline_canceller.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "pipeline_run"
-
-module FunCi
-  class StalePipelineCanceller
-    def initialize(db:, branch:, stdout:, process_killer: nil)
-      @db = db
-      @branch = branch
-      @stdout = stdout
-      @process_killer = process_killer || method(:default_process_killer)
-    end
-
-    def cancel(new_commit_hash:)
-      run = PipelineRun.find_running_with_pid(@db, @branch)
-      return unless run
-
-      kill_process(run[:pid])
-      PipelineRun.update_status(@db, run[:id], "cancelled")
-      @stdout.puts "Cancelled stale pipeline for #{run[:commit_hash]}. Starting fresh for #{new_commit_hash}."
-    end
-
-    def store_pid(run_id, pid)
-      PipelineRun.store_pid(@db, run_id, pid)
-    end
-
-    private
-
-    def kill_process(pid)
-      @process_killer.call(0, pid)
-      safe_signal("TERM", pid)
-      safe_signal("KILL", pid)
-      begin
-        Process.waitpid(pid)
-      rescue Errno::ECHILD, Errno::ESRCH # rubocop:disable Lint/SuppressedException
-      end
-    rescue Errno::ESRCH
-      # Process already dead
-    end
-
-    def safe_signal(signal, pid)
-      @process_killer.call(signal, pid)
-    rescue Errno::ESRCH
-      # Already dead
-    end
-
-    def default_process_killer(signal, pid)
-      Process.kill(signal, pid)
-    end
-  end
-end

data/lib/fun_ci/streak_counter.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module FunCi
-  module StreakCounter
-    PASS_STATUS = "completed"
-    ACTIVE_STATUSES = %w[running scheduled].freeze
-
-    # Counts consecutive passed runs from the most recent terminal run.
-    # Skips running/scheduled pipelines.
-    # Returns nil if no terminal runs exist, 0 if streak is broken.
-    def self.count(runs)
-      terminal_runs = runs.reject { |r| ACTIVE_STATUSES.include?(r[:status]) }
-      return nil if terminal_runs.empty?
-
-      streak = 0
-      terminal_runs.each do |run|
-        break unless run[:status] == PASS_STATUS
-        streak += 1
-      end
-      streak
-    end
-
-    def self.format_text(streak)
-      return nil if streak.nil?
-      return "Streak broken" if streak == 0
-
-      "#{streak} in a row!"
-    end
-  end
-end

data/lib/fun_ci/template_writer.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module FunCi
-  class TemplateWriter
-    TEMPLATES = {
-      ruby_bundler: {
-        "lint.sh" => "#!/bin/sh\nbundle exec rubocop\n",
-        "build.sh" => "#!/bin/sh\nbundle install --quiet\n",
-        "fast.sh" => "#!/bin/sh\nbundle exec rake test\n",
-        "slow.sh" => "#!/bin/sh\nbundle exec rake test:slow\n"
-      },
-      jvm_gradle_kotlin: {
-        "lint.sh" => "#!/bin/sh\n./gradlew check -x test\n",
-        "build.sh" => "#!/bin/sh\n./gradlew assemble\n",
-        "fast.sh" => "#!/bin/sh\n./gradlew test\n",
-        "slow.sh" => "#!/bin/sh\n./gradlew integrationTest\n"
-      },
-      jvm_gradle_groovy: {
-        "lint.sh" => "#!/bin/sh\n./gradlew check -x test\n",
-        "build.sh" => "#!/bin/sh\n./gradlew assemble\n",
-        "fast.sh" => "#!/bin/sh\n./gradlew test\n",
-        "slow.sh" => "#!/bin/sh\n./gradlew integrationTest\n"
-      },
-      jvm_maven: {
-        "lint.sh" => "#!/bin/sh\nmvn verify -DskipTests\n",
-        "build.sh" => "#!/bin/sh\nmvn compile\n",
-        "fast.sh" => "#!/bin/sh\nmvn test\n",
-        "slow.sh" => "#!/bin/sh\nmvn verify\n"
-      }
-    }.freeze
-
-    def initialize(template_id, target_dir, lint_override: nil)
-      @template_id = template_id
-      @target_dir = target_dir
-      @lint_override = lint_override
-    end
-
-    def write
-      scripts = TEMPLATES.fetch(@template_id)
-      fun_ci_dir = File.join(@target_dir, ".fun-ci")
-      Dir.mkdir(fun_ci_dir)
-
-      scripts.each do |name, content|
-        content = "#!/bin/sh\n#{@lint_override}\n" if name == "lint.sh" && @lint_override
-        path = File.join(fun_ci_dir, name)
-        File.write(path, content)
-        File.chmod(0o755, path)
-      end
-    end
-  end
-end

data/lib/fun_ci/trigger.rb

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-
-require "open3"
-require "timeout"
-require_relative "project_config"
-require_relative "pipeline_recorder"
-require_relative "background_wrapper"
-require_relative "stage_runner"
-require_relative "stale_pipeline_canceller"
-require_relative "progress_reporter"
-require_relative "pipeline_forker"
-
-module FunCi
-  class Trigger
-    DEFAULT_BUDGETS = {
-      "lint" => 30,
-      "build" => 30,
-      "fast" => 10,
-      "slow" => 300
-    }.freeze
-
-    def self.run_from_args(args, stdout: $stdout, stderr: $stderr, recorder: NullRecorder.new, pipeline_forker: nil)
-      positional = args.reject { |a| a.start_with?("--") }
-      if positional.length < 2
-        stderr.puts "fun-ci: commit hash and branch name are required."
-        stderr.puts "Usage: fun-ci trigger <commit-hash> <branch>"
-        return 1
-      end
-      commit_hash, branch = positional
-      if args.include?("--no-validate")
-        db_path = recorder.db_path
-        recorder.close
-        (pipeline_forker || PipelineForker.method(:fork_pipeline)).call(
-          commit_hash: commit_hash, branch: branch, db_path: db_path
-        )
-        return 0
-      end
-      new(project_root: Dir.pwd, commit_hash: commit_hash, branch: branch,
-          stdout: stdout, stderr: stderr, recorder: recorder).run
-    end
-
-    attr_writer :command_runner
-
-    def initialize(project_root:, commit_hash:, branch:, stdout: $stdout, stderr: $stderr, command_runner: nil, time_budgets: {}, commit_validator: nil, recorder: NullRecorder.new, background_launcher: nil)
-      @project_root = project_root
-      @commit_hash = commit_hash
-      @branch = branch
-      @stdout = stdout
-      @stderr = stderr
-      @command_runner = command_runner
-      @time_budgets = DEFAULT_BUDGETS.merge(time_budgets)
-      @commit_validator = commit_validator || method(:default_commit_validator)
-      @recorder = recorder
-      @background_launcher = background_launcher || method(:default_background_launcher)
-    end
-
-    def run
-      config = ProjectConfig.new(@project_root)
-      return handle_config_errors(config) if config.validate.any?
-      unless @commit_validator.call(@commit_hash)
-        @stderr.puts "fun-ci: commit #{@commit_hash} not found in this repository."
-        return 1
-      end
-      cancel_stale_pipelines
-      @recorder.create_run(commit_hash: @commit_hash, branch: @branch, project_path: @project_root)
-      stage_runner = make_stage_runner
-      progress = ProgressReporter.new(stdout: @stdout)
-      results = run_phase_one(stage_runner, config)
-      progress.phase_one_result(results)
-      unless results.values.all?
-        @recorder.fail_run
-        return 1
-      end
-      spawn_slow_suite(config)
-      progress.slow_launched
-      fast_runner = make_stage_runner
-      fast_passed = fast_runner.run_stage(config, "fast")
-      progress.fast_result(fast_passed)
-      unless fast_passed
-        @recorder.fail_run
-        return 1
-      end
-      0
-    end
-
-    private
-
-    def handle_config_errors(config)
-      config.validate.each { |e| @stdout.puts "fun-ci: #{e}" }
-      unless config.folder_exists?
-        @stdout.puts "Create .fun-ci/lint.sh, build.sh, fast.sh, and slow.sh to set up this project."
-        @stdout.puts "Commit will proceed without CI."
-      end
-      0
-    end
-
-    def run_phase_one(stage_runner, config)
-      results = {}
-      threads = %w[lint build].map do |stage|
-        Thread.new { results[stage] = stage_runner.run_stage(config, stage) }
-      end
-      threads.each(&:join)
-      results
-    end
-
-    def spawn_slow_suite(config)
-      cmd = "#{config.script_path("slow")} #{@commit_hash}"
-      job_id = @recorder.start_stage("slow")
-      runner = @command_runner || ->(c) { Open3.capture2e(c) }
-      budget = @time_budgets["slow"]
-      executor = -> { Timeout.timeout(budget) { runner.call(cmd) } }
-      @background_launcher.call(
-        db_path: @recorder.db_path, pipeline_run_id: @recorder.pipeline_run_id,
-        job_id: job_id, executor: executor
-      )
-    end
-
-    def make_stage_runner
-      StageRunner.new(
-        commit_hash: @commit_hash, stdout: @stdout,
-        command_runner: @command_runner,
-        time_budgets: @time_budgets, recorder: @recorder
-      )
-    end
-
-    def cancel_stale_pipelines
-      return unless @recorder.db
-      StalePipelineCanceller.new(
-        db: @recorder.db, branch: @branch, stdout: @stdout
-      ).cancel(new_commit_hash: @commit_hash)
-    end
-
-    def default_background_launcher(db_path:, pipeline_run_id:, job_id:, executor:)
-      @recorder.close
-      pid = fork do
-        recorder = DbRecorder.for_background(db_path, pipeline_run_id)
-        BackgroundWrapper.new(recorder: recorder, job_id: job_id, executor: executor).run
-        recorder.close
-      end
-      @recorder = DbRecorder.for_background(db_path, pipeline_run_id)
-      Process.detach(pid)
-      PipelineRun.store_pid(@recorder.db, pipeline_run_id, pid)
-    end
-
-    def default_commit_validator(commit_hash)
-      _, status = Open3.capture2e("git", "cat-file", "-t", commit_hash)
-      status.success?
-    end
-  end
-end