kettle-dev 3.1.11 → 3.1.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c6532c0b875c1c1581f43bf3035bc3f9b4ff7ba8d04f7a90f6bf78be7fb167ac
-  data.tar.gz: 9894c1dd7477202261502e23f1e6d37b6f0f174350ac456b834dc8df19b143ba
+  metadata.gz: a53813cd27173724428ba3d36dfc9c49c2cd2602235cc6e67ee4c334ac459f19
+  data.tar.gz: 259280a12837d7baa9521d1846977d400ed626779f05d45448dd751711d1b11e
 SHA512:
-  metadata.gz: 5bf4bd022743bdac03fc5806ff9598781abf17814c14ec9cddd5a917d33af628055dea5adbdbf11ee3d4284aa9f5dc2926c8456dab0710fc59ea7093aa23d457
-  data.tar.gz: a9aa5312d72d80c8868becdb10cbf8e11f57ae4df5e37edc78f781656873b4dea9bc1fd48aca064a4ec63e76ee2156dfe05626e8efa90743a7ffda4b24a397bd
+  metadata.gz: 57d215d343dfbfe520e7d17802afe6ee84cf54ea9a5558924c42c301a43ea768989045e63714fbd4c3b225a57f4b08fe61d3e2aad9f51248d47c8b9d4457d0b8
+  data.tar.gz: 656b8a321db50a699c0a883c17156c46553cacfc47830de36d2926dfc8bafffab4e83948771692f640325a7474b8a7abec613227e23f321b27ad750aa2d62a6f

data/CHANGELOG.md

@@ -30,6 +30,21 @@ Please file a bug if you notice a violation of semantic versioning.
 
 ### Security
 
+## [3.1.12] - 2026-10-12
+
+- TAG: [v3.1.12][3.1.12t]
+- COVERAGE: 91.38% -- 6378/6980 lines in 49 files
+- BRANCH COVERAGE: 75.57% -- 2437/3225 branches in 49 files
+- 52.49% documented
+
+### Fixed
+
+- CI monitor no longer stalls silently at 0/N when GitHub API requests fail: request budget throttling (K_RELEASE_CI_REQUESTS_PER_MINUTE, default 90/min) keeps polling inside the quota; exhausted-quota 403s raise CIRateLimitError so the monitor parks until the reset (emitting a github_rate_limited event) instead of treating the wall as 'no data yet'; 401s raise CIAuthError and abort with token guidance; job-level failure polling is gated to K_RELEASE_CI_JOBS_POLL_INTERVAL (default 60s) — the jobs polling added for early failure detection had multiplied request volume past the quota on large matrices
+
+- kettle-release no longer aborts at release:guard_clean when resuming at step 14/15: the process boot can silently rewrite the canonical Gemfile.lock with sibling PATH remotes (gemspec self-version bump forces re-resolution under the family local-path toggle), so canonical lockfiles are now normalized and re-validated immediately before the build and rake release children
+
+- kettle-release lockfile normalization no longer crashes with Errno::ENOENT when a generated appraisal lockfile (Appraisal.root.gemfile.lock) vanishes between the lockfile scan and the reset in CI
+
 ## [3.1.11] - 2026-10-11
 
 - TAG: [v3.1.11][3.1.11t]
@@ -4049,7 +4064,9 @@ Please file a bug if you notice a violation of semantic versioning.
   - Selecting will run the selected workflow via `act`
   - This may move to its own gem in the future.
 
-[Unreleased]: https://github.com/kettle-dev/kettle-dev/compare/v3.1.11...HEAD
+[Unreleased]: https://github.com/kettle-dev/kettle-dev/compare/v3.1.12...HEAD
+[3.1.12]: https://github.com/kettle-dev/kettle-dev/compare/v3.1.11...v3.1.12
+[3.1.12t]: https://github.com/kettle-dev/kettle-dev/releases/tag/v3.1.12
 [3.1.11]: https://github.com/kettle-dev/kettle-dev/compare/v3.1.10...v3.1.11
 [3.1.11t]: https://github.com/kettle-dev/kettle-dev/releases/tag/v3.1.11
 [3.1.10]: https://github.com/kettle-dev/kettle-dev/compare/v3.1.9...v3.1.10

data/README.md

@@ -289,6 +289,8 @@ GitHub API and CI helpers
 
 - `GITHUB_TOKEN` or `GH_TOKEN`: Token used by `ci:act` and release workflow checks to query GitHub Actions status at higher rate limits
 - `GITLAB_TOKEN` or `GL_TOKEN`: Token used by `ci:act` and CI monitor to query GitLab pipeline status
+- `K_RELEASE_CI_REQUESTS_PER_MINUTE`: GitHub API request budget for the release CI monitor (default 90/min). Requests above the budget are spaced out; an exhausted quota parks the monitor until the reset instead of failing
+- `K_RELEASE_CI_JOBS_POLL_INTERVAL`: Minimum seconds between job-level polls of an in-flight workflow run during release CI monitoring (default 60). Job-level detection catches a failed job in a large matrix before the run concludes, without multiplying API request volume
 
 Releasing and signing
 
@@ -1068,7 +1070,7 @@ Thanks for RTFM. ☺️
 [📌gitmoji]: https://gitmoji.dev
 [📌gitmoji-img]: https://img.shields.io/badge/gitmoji_commits-%20%F0%9F%98%9C%20%F0%9F%98%8D-34495e.svg?style=flat-square
 [🧮kloc]: https://www.youtube.com/watch?v=dQw4w9WgXcQ
-[🧮kloc-img]: https://img.shields.io/badge/KLOC-6.926-FFDD67.svg?style=for-the-badge&logo=YouTube&logoColor=blue
+[🧮kloc-img]: https://img.shields.io/badge/KLOC-6.980-FFDD67.svg?style=for-the-badge&logo=YouTube&logoColor=blue
 [🔐security]: https://github.com/kettle-dev/kettle-dev/blob/main/SECURITY.md
 [🔐security-img]: https://img.shields.io/badge/security-policy-259D6C.svg?style=flat
 [📄copyright-notice-explainer]: https://opensource.stackexchange.com/questions/5778/why-do-licenses-such-as-the-mit-license-specify-a-single-year

data/lib/kettle/dev/ci_helpers.rb

@@ -8,6 +8,19 @@ require "uri"
 
 module Kettle
   module Dev
+    # GitHub API rejected the request because the token is invalid/revoked.
+    class CIAuthError < StandardError; end
+
+    # GitHub API quota exhausted. Recoverable: retry after the reset time.
+    class CIRateLimitError < StandardError
+      attr_reader :reset_at
+
+      def initialize(message, reset_at: nil)
+        @reset_at = reset_at
+        super(message)
+      end
+    end
+
     # CI-related helper functions used by Rake tasks and release tooling.
     #
     # This module only exposes module-functions (no instance state) and is
@@ -130,6 +143,13 @@ module Kettle
           "id" => run["id"],
           "head_sha" => run["head_sha"]
         }
+      rescue Kettle::Dev::CIAuthError, Kettle::Dev::CIRateLimitError
+        # Auth failures are fatal; rate limits are recoverable but must reach
+        # the monitor (which parks until the reset) — swallowing either turns
+        # the poll into an infinite 0/N tick.
+        # fail the same way, so swallowing this turns the monitor into an
+        # infinite 0/N tick. Re-raise for the caller to abort with guidance.
+        raise
       rescue => e
         Kettle::Dev.debug_error(e, __method__)
         nil
@@ -163,15 +183,69 @@ module Kettle
         end
       end
 
+      # Process-wide rate-limit state shared by every CIHelpers caller in this
+      # process (the release runner polls many member/monitor children in one
+      # process tree, and each child gets its own copy — this throttles within
+      # a process; the budget is sized so even a fully parallel family run
+      # stays inside GitHub's per-token allowance).
+      CI_RATE_BUDGET_PER_MINUTE = (ENV["K_RELEASE_CI_REQUESTS_PER_MINUTE"] || 90).to_f
+      CI_RATE_MIN_INTERVAL = CI_RATE_BUDGET_PER_MINUTE.positive? ? 60.0 / CI_RATE_BUDGET_PER_MINUTE : 0.0
+      @ci_rate_last_request = 0.0
+      @ci_rate_lock = Mutex.new
+
+      def github_rate_limit_wait!
+        return if CI_RATE_MIN_INTERVAL.zero?
+
+        @ci_rate_lock.synchronize do
+          now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          delta = now - @ci_rate_last_request
+          if delta < CI_RATE_MIN_INTERVAL
+            sleep(CI_RATE_MIN_INTERVAL - delta)
+            now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          end
+          @ci_rate_last_request = now
+        end
+      end
+
       def github_get_json(url, token:)
+        github_rate_limit_wait!
         uri = URI(url)
         req = Net::HTTP::Get.new(uri)
         req["User-Agent"] = "kettle-dev/ci-helpers"
         req["Authorization"] = "token #{token}" if token && !token.empty?
         res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
-        return unless res.is_a?(Net::HTTPSuccess)
+        # Dispatch on is_a? rather than `case`/===: verifying doubles
+        # (instance_double(Net::HTTPOK)) used in specs do not reliably match
+        # `Net::HTTPSuccess === res`, which silently degraded every stubbed
+        # response to "no data".
+        if res.is_a?(Net::HTTPSuccess)
+          JSON.parse(res.body)
+        elsif res.is_a?(Net::HTTPUnauthorized)
+          # 401 is not retryable: an invalid or revoked token fails EVERY
+          # request, so a monitor treating it as "no data yet" would tick
+          # forever at 0/N. Abort with an actionable message.
+          raise(
+            Kettle::Dev::CIAuthError,
+            "GitHub API rejected the request (401: invalid or revoked token) for #{url}. " \
+              "Check GITHUB_TOKEN / GH_TOKEN."
+          )
+        elsif res.is_a?(Net::HTTPForbidden)
+          if res["X-RateLimit-Remaining"].to_i.zero?
+            # Rate limited: recoverable. Honor the reset time, then let the
+            # caller retry the poll cycle.
+            reset_at = Time.at(res["X-RateLimit-Reset"].to_i).utc
+            raise(
+              Kettle::Dev::CIRateLimitError,
+              "GitHub API rate limit exceeded; resets at #{reset_at.strftime("%H:%M:%SZ")}"
+            )
+          end
 
-        JSON.parse(res.body)
+          # Non-quota 403 (e.g. resource permissions): treat as no data, like
+          # other transient responses.
+          nil
+        else
+          nil
+        end
       end
 
       # Whether a run has completed successfully.
@@ -215,6 +289,11 @@ module Kettle
             "html_url" => job["html_url"]
           }
         end
+      rescue Kettle::Dev::CIAuthError, Kettle::Dev::CIRateLimitError
+        # See latest_run: auth/rate-limit failures must abort or park the
+        # monitor, not degrade
+        # to "no jobs yet".
+        raise
       rescue => e
         Kettle::Dev.debug_error(e, __method__)
         []

data/lib/kettle/dev/ci_monitor.rb

@@ -50,10 +50,17 @@ module Kettle
       # @param restart_hint [String] guidance command shown on failure
       # @return [Boolean] whether all configured CI providers passed
       def monitor_all!(restart_hint: "bundle exec kettle-release --start-step 10", workflows: nil, keepalive: nil, event_recorder: nil, **options)
-        results = [
-          monitor_github_internal!(restart_hint: restart_hint, workflows: workflows, keepalive: keepalive, event_recorder: event_recorder),
-          monitor_gitlab_internal!(restart_hint: restart_hint, keepalive: keepalive, event_recorder: event_recorder)
-        ]
+        # Rate limiting is recoverable: when the GitHub monitor parks for the
+        # quota reset it returns :rate_limited and we re-enter it. GitLab has
+        # no equivalent, so only the GitHub result drives the retry.
+        results = nil
+        loop do
+          results = [
+            monitor_github_internal!(restart_hint: restart_hint, workflows: workflows, keepalive: keepalive, event_recorder: event_recorder),
+            monitor_gitlab_internal!(restart_hint: restart_hint, keepalive: keepalive, event_recorder: event_recorder)
+          ]
+          break unless results.first == :rate_limited
+        end
         abort("CI configuration not detected (GitHub or GitLab). Ensure CI is configured and remotes point to the correct hosts.") if results.all?(&:nil?)
 
         results.all? { |result| result != false }
@@ -343,6 +350,18 @@ module Kettle
         start_deadline = monotonic_time + start_timeout
         keepalive_timer = keepalive_timer(keepalive)
         all_started_emitted = false
+        # Job-level failure detection polls one jobs endpoint per in-flight
+        # workflow per cycle; on big matrices that multiplies request volume.
+        # Gate it to once per K_RELEASE_CI_JOBS_POLL_INTERVAL seconds
+        # (default 60) so run-level polling carries the fast loop and jobs
+        # checks stay a bounded add-on.
+        jobs_poll_interval = begin
+          Float(ENV["K_RELEASE_CI_JOBS_POLL_INTERVAL"])
+        rescue
+          nil
+        end
+        jobs_poll_interval = (jobs_poll_interval && jobs_poll_interval >= 0) ? jobs_poll_interval : 60.0
+        last_jobs_poll = 0.0
         loop do
           keepalive_timer.call
 
@@ -414,7 +433,9 @@ module Kettle
                 # a re-run will have to spend anyway.
                 run_failed = Kettle::Dev::CIHelpers.failed?(run)
                 failed_job = nil
-                if !passed[wf] && !run_failed && run["status"] != "completed"
+                jobs_poll_due = monotonic_time - last_jobs_poll >= jobs_poll_interval
+                if !passed[wf] && !run_failed && run["status"] != "completed" && jobs_poll_due
+                  last_jobs_poll = monotonic_time
                   # Run still in flight: poll its jobs so a single red job in
                   # a large matrix aborts immediately instead of waiting for
                   # the whole workflow to conclude.
@@ -504,6 +525,25 @@ module Kettle
           puts "\nGitHub workflows completed with failures (#{passed.size}/#{total} passed); continuing because K_RELEASE_CI_CONTINUE=true."
         end
         failed.empty?
+      rescue Kettle::Dev::CIRateLimitError => error
+        # Rate limiting is recoverable: park until the quota resets, emit an
+        # event, then re-enter the same monitor (the caller wraps this method
+        # in a retry loop keyed on the :rate_limited return value).
+        pbar&.finish unless pbar&.finished?
+        reset_at = (error.respond_to?(:reset_at) && error.reset_at) ? error.reset_at : (Time.now.utc + 60)
+        wait = [(reset_at - Time.now.utc).ceil, 1].max
+        puts "\n#{error.message}; waiting #{wait}s before retrying."
+        emit_ci_monitor_event(
+          event_recorder,
+          action: "github_rate_limited",
+          status: "started",
+          provider: "github",
+          reset_at: reset_at.utc.strftime("%H:%M:%SZ"),
+          wait_seconds: wait,
+          head_sha: head_sha
+        )
+        sleep(wait)
+        :rate_limited
       end
       module_function :monitor_github_internal!
 

data/lib/kettle/dev/lockfile_reset.rb

@@ -161,6 +161,12 @@ module Kettle
         platforms = release_platforms_for(paths) if force_full_update
         uninstall_unreleased_local_gems(paths) if force_full_update
         paths.each do |path|
+          # Re-check existence: in CI the checkout can contain a stale
+          # appraisal lock that later steps (or a parallel worker) delete
+          # between the lockfile_paths scan and this loop; ENOENT here would
+          # abort the whole release pipeline for a file that no longer needs
+          # resetting.
+          next unless File.file?(path)
           if force_full_update || normalization_needed?(path, strict: release_lockfiles)
             reset_lockfile!(
               path,
@@ -191,6 +197,10 @@ module Kettle
       end
 
       def reset_lockfile!(path, full_update: false, platforms: nil, skip_changelog_dependency: false, update_bundler: false, strict: false)
+        # Mirrors the reset loop guard: a lockfile that vanished after the
+        # scan (CI cleanup of generated appraisal locks) has nothing to
+        # normalize; aborting the whole release for it would be wrong.
+        return unless File.file?(path)
         gemfile = gemfile_for_lockfile(path)
         unless gemfile && File.file?(gemfile)
           warn("Cannot reset #{display_path(path)} because its Gemfile was not found.")
@@ -701,6 +711,11 @@ module Kettle
 
       def lockfile_source_content(path)
         in_checksums = false
+        # A lockfile can vanish between the lockfile_paths scan and this read
+        # (CI workers clean up generated appraisal locks mid-process). Treat a
+        # missing lockfile as an empty graph: bootstrap version lookups return
+        # nil and the reset skips what no longer exists.
+        return [].freeze unless File.file?(path)
         File.readlines(path).filter_map do |line|
           stripped = line.strip
           if stripped == "CHECKSUMS"

data/lib/kettle/dev/release_cli.rb

@@ -492,6 +492,21 @@ module Kettle
         # 14. build
         with_release_resume_step(14) do
           if run_step?(14)
+            # When resuming at step 14/15 the step 0-5 lockfile preflight is
+            # skipped, but this process's own boot (`bundle exec
+            # kettle-release` with the family launcher's local-path toggle
+            # active) can silently rewrite the canonical Gemfile.lock with
+            # sibling PATH remotes — the gemspec self-version bump makes every
+            # boot re-resolve. `rake release` aborts on the dirty worktree at
+            # release:guard_clean. Normalize at the publish boundary too.
+            # Projects without any tracked release lockfile (bare scratch
+            # specs) have nothing to normalize; LockfileReset would abort.
+            unless lockfile_reset.lockfile_paths.empty?
+              reset_release_lockfiles!(stage: "before publish tasks")
+              validate_release_lockfiles!(stage: "before publish tasks")
+              prepare_release_lockfiles_for_release_tasks!
+              materialize_release_lockfiles_for_release_tasks!
+            end
             ensure_release_secrets_ready_for_signing! if signing_enabled? && release_secrets_configured?
             if signing_enabled? && release_secrets_configured?
               puts "Running build with gem signing passphrase from configured secrets provider (#{release_secrets_provider_label})..."

data/lib/kettle/dev/version.rb

@@ -5,7 +5,7 @@ module Kettle
     # Version namespace for this gem.
     module Version
       # Current gem version.
-      VERSION = "3.1.11"
+      VERSION = "3.1.12"
     end
     # Current gem version exposed at the traditional constant location.
     VERSION = Version::VERSION # Traditional Constant Location

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kettle-dev
 version: !ruby/object:Gem::Version
-  version: 3.1.11
+  version: 3.1.12
 platform: ruby
 authors:
 - Peter H. Boling
@@ -422,10 +422,10 @@ licenses:
 - AGPL-3.0-only
 metadata:
   homepage_uri: https://kettle-dev.galtzo.com
-  source_code_uri: https://github.com/kettle-dev/kettle-dev/tree/v3.1.11
-  changelog_uri: https://github.com/kettle-dev/kettle-dev/blob/v3.1.11/CHANGELOG.md
+  source_code_uri: https://github.com/kettle-dev/kettle-dev/tree/v3.1.12
+  changelog_uri: https://github.com/kettle-dev/kettle-dev/blob/v3.1.12/CHANGELOG.md
   bug_tracker_uri: https://github.com/kettle-dev/kettle-dev/issues
-  documentation_uri: https://www.rubydoc.info/gems/kettle-dev/3.1.11
+  documentation_uri: https://www.rubydoc.info/gems/kettle-dev/3.1.12
   funding_uri: https://github.com/sponsors/pboling
   wiki_uri: https://github.com/kettle-dev/kettle-dev/wiki
   news_uri: https://www.railsbling.com/tags/kettle-dev