kettle-dev 2.5.11 → 2.5.13

data/lib/kettle/dev/release_secrets_doctor.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+require "shellwords"
+require "time"
+
+module Kettle
+  module Dev
+    class ReleaseSecretsDoctor
+      DEFAULT_SLEEP_SECONDS = 30.0
+      DEFAULT_KEEPALIVE_SECONDS = 0.0
+      DEFAULT_PROVIDER = "op"
+      DEFAULT_SHAPE = "same-process"
+      CHILD_SHAPE = "same-process"
+      SHAPES = %w[same-process child-process parent-child thread bundler-child env-reset-child].freeze
+      BUNDLER_ENV_UNSETS = %w[
+        BUNDLE_BIN_PATH
+        BUNDLE_FROZEN
+        BUNDLE_GEMFILE
+        BUNDLE_LOCKFILE
+        BUNDLER_SETUP
+        BUNDLER_VERSION
+        RUBYLIB
+        RUBYOPT
+      ].freeze
+
+      def self.options_from_env(env = ENV)
+        {
+          provider: env.fetch("KETTLE_RELEASE_SECRETS_PROVIDER", DEFAULT_PROVIDER),
+          sleep_seconds: Float(env.fetch("KETTLE_RELEASE_SECRETS_DOCTOR_SLEEP", DEFAULT_SLEEP_SECONDS.to_s)),
+          keepalive_seconds: Float(env.fetch("KETTLE_RELEASE_SECRETS_DOCTOR_KEEPALIVE", DEFAULT_KEEPALIVE_SECONDS.to_s)),
+          shape: env.fetch("KETTLE_RELEASE_SECRETS_DOCTOR_SHAPE", DEFAULT_SHAPE),
+          otp: false
+        }
+      end
+
+      def initialize(options:, program_name:, output: $stdout, system_runner: Kernel)
+        @options = normalize_options(options)
+        @program_name = program_name
+        @output = output
+        @system_runner = system_runner
+      end
+
+      def run
+        case options.fetch(:shape)
+        when "same-process"
+          run_same_process(options)
+        when "child-process"
+          run_child_process(options)
+        when "parent-child"
+          run_parent_child(options)
+        when "thread"
+          run_thread(options)
+        when "bundler-child"
+          run_bundler_child(options)
+        when "env-reset-child"
+          run_env_reset_child(options)
+        else
+          raise Kettle::Dev::Error, "unknown shape #{options.fetch(:shape).inspect}; expected #{SHAPES.join(", ")}"
+        end
+      end
+
+      def child_env(shape:, options: self.options)
+        env = {
+          "KETTLE_RELEASE_SECRETS_PROVIDER" => options.fetch(:provider),
+          "KETTLE_RELEASE_SECRETS_DOCTOR_SHAPE" => shape,
+          "KETTLE_RELEASE_SECRETS_DOCTOR_SLEEP" => options.fetch(:sleep_seconds).to_s,
+          "KETTLE_RELEASE_SECRETS_DOCTOR_KEEPALIVE" => options.fetch(:keepalive_seconds).to_s
+        }
+        env["KETTLE_RELEASE_SECRETS_DOCTOR_CHILD"] = "true"
+        env
+      end
+
+      def child_args(otp: options.fetch(:otp))
+        args = [RbConfig.ruby, program_name]
+        args << "--otp" if otp
+        args
+      end
+
+      def bundler_child_args(otp: options.fetch(:otp))
+        args = ["bundle", "exec", RbConfig.ruby, program_name]
+        args << "--otp" if otp
+        args
+      end
+
+      private
+
+      attr_reader :options, :program_name, :output, :system_runner
+
+      def normalize_options(raw_options)
+        {
+          provider: raw_options.fetch(:provider, DEFAULT_PROVIDER).to_s,
+          sleep_seconds: Float(raw_options.fetch(:sleep_seconds, DEFAULT_SLEEP_SECONDS)),
+          keepalive_seconds: Float(raw_options.fetch(:keepalive_seconds, DEFAULT_KEEPALIVE_SECONDS)),
+          shape: raw_options.fetch(:shape, DEFAULT_SHAPE).to_s,
+          otp: !!raw_options.fetch(:otp, false)
+        }
+      end
+
+      def provider_for(current_options)
+        Kettle::Dev::ReleaseSecrets::Factory.build(provider_name: current_options.fetch(:provider))
+      end
+
+      def run_same_process(current_options)
+        provider = provider_for(current_options)
+        output.puts("[#{timestamp}] initial keepalive")
+        provider.keepalive!
+        wait_with_keepalive(provider, current_options)
+        output.puts("[#{timestamp}] final keepalive")
+        provider.keepalive!
+        run_otp_lookup(provider) if current_options.fetch(:otp)
+        true
+      end
+
+      def run_parent_child(current_options)
+        provider = provider_for(current_options)
+        output.puts("[#{timestamp}] parent initial keepalive")
+        provider.keepalive!
+        wait_with_keepalive(provider, current_options)
+        output.puts("[#{timestamp}] parent spawning child after keepalive")
+        run_child_process(current_options)
+      end
+
+      def run_child_process(current_options)
+        env = child_env(shape: CHILD_SHAPE, options: current_options)
+        args = child_args(otp: current_options.fetch(:otp))
+        output.puts("[#{timestamp}] spawning child: #{args.shelljoin}")
+        run_system(env, args)
+      end
+
+      def run_bundler_child(current_options)
+        env = child_env(shape: CHILD_SHAPE, options: current_options)
+        args = bundler_child_args(otp: current_options.fetch(:otp))
+        output.puts("[#{timestamp}] spawning bundler child: #{args.shelljoin}")
+        run_system(env, args)
+      end
+
+      def run_env_reset_child(current_options)
+        env = child_env(shape: CHILD_SHAPE, options: current_options)
+        BUNDLER_ENV_UNSETS.each { |key| env[key] = nil }
+        args = child_args(otp: current_options.fetch(:otp))
+        output.puts("[#{timestamp}] spawning env-reset child: #{args.shelljoin}")
+        run_system(env, args)
+      end
+
+      def run_thread(current_options)
+        error = nil
+        # rubocop:disable ThreadSafety/NewThread -- this doctor intentionally probes threaded secret-provider behavior.
+        thread = Thread.new do
+          begin
+            run_same_process(current_options)
+          rescue => e
+            error = e
+          end
+        end
+        # rubocop:enable ThreadSafety/NewThread
+        thread.join
+        raise error if error
+
+        true
+      end
+
+      def run_system(env, args)
+        success = system_runner.system(env, *args)
+        raise Kettle::Dev::Error, "child shape failed: #{args.shelljoin}" unless success
+
+        true
+      end
+
+      def wait_with_keepalive(provider, current_options)
+        sleep_seconds = current_options.fetch(:sleep_seconds)
+        keepalive_seconds = current_options.fetch(:keepalive_seconds)
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + sleep_seconds
+        if keepalive_seconds <= 0
+          output.puts("[#{timestamp}] sleeping #{sleep_seconds}s without keepalive")
+          sleep(sleep_seconds)
+          return
+        end
+
+        output.puts("[#{timestamp}] sleeping #{sleep_seconds}s with #{keepalive_seconds}s keepalive")
+        loop do
+          remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          break if remaining <= 0
+
+          sleep([remaining, keepalive_seconds].min)
+          break if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+
+          output.puts("[#{timestamp}] keepalive")
+          provider.keepalive!
+        end
+      end
+
+      def run_otp_lookup(provider)
+        output.puts("[#{timestamp}] OTP lookup")
+        otp = provider.rubygems_otp
+        output.puts("[#{timestamp}] OTP lookup returned #{otp.to_s.empty? ? "empty" : "#{otp.length} chars"}")
+      end
+
+      def timestamp
+        Time.now.iso8601
+      end
+    end
+  end
+end

data/lib/kettle/dev/version.rb

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

data/lib/kettle/dev.rb

@@ -46,8 +46,10 @@ module Kettle
     autoload :LockfileReset, "kettle/dev/lockfile_reset"
     autoload :ReadmeBackers, "kettle/dev/readme_backers"
     autoload :OpenCollectiveConfig, "kettle/dev/open_collective_config"
+    autoload :ReleaseNotifier, "kettle/dev/release_notifier"
     autoload :ReleaseCLI, "kettle/dev/release_cli"
     autoload :ReleaseSecrets, "kettle/dev/release_secrets"
+    autoload :ReleaseSecretsDoctor, "kettle/dev/release_secrets_doctor"
     autoload :ResetCLI, "kettle/dev/reset_cli"
     autoload :PreReleaseCLI, "kettle/dev/pre_release_cli"
     autoload :Version, "kettle/dev/version"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kettle-dev
 version: !ruby/object:Gem::Version
-  version: 2.5.11
+  version: 2.5.13
 platform: ruby
 authors:
 - Peter H. Boling
@@ -80,7 +80,7 @@ dependencies:
         version: '0.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.3
+        version: 0.1.9
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -90,7 +90,7 @@ dependencies:
         version: '0.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.3
+        version: 0.1.9
 - !ruby/object:Gem::Dependency
   name: kettle-rb
   requirement: !ruby/object:Gem::Requirement
@@ -327,6 +327,7 @@ executables:
 - kettle-pre-release
 - kettle-readme-backers
 - kettle-release
+- kettle-release-secrets-doctor
 - kettle-reset
 extensions: []
 extra_rdoc_files: []
@@ -346,6 +347,7 @@ files:
 - exe/kettle-pre-release
 - exe/kettle-readme-backers
 - exe/kettle-release
+- exe/kettle-release-secrets-doctor
 - exe/kettle-reset
 - lib/kettle-dev.rb
 - lib/kettle/dev.rb
@@ -381,7 +383,9 @@ files:
 - lib/kettle/dev/rakelib/yard.rake
 - lib/kettle/dev/readme_backers.rb
 - lib/kettle/dev/release_cli.rb
+- lib/kettle/dev/release_notifier.rb
 - lib/kettle/dev/release_secrets.rb
+- lib/kettle/dev/release_secrets_doctor.rb
 - lib/kettle/dev/reset_cli.rb
 - lib/kettle/dev/ruby_gems_versions.rb
 - lib/kettle/dev/tasks.rb
@@ -397,10 +401,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/v2.5.11
-  changelog_uri: https://github.com/kettle-dev/kettle-dev/blob/v2.5.11/CHANGELOG.md
+  source_code_uri: https://github.com/kettle-dev/kettle-dev/tree/v2.5.13
+  changelog_uri: https://github.com/kettle-dev/kettle-dev/blob/v2.5.13/CHANGELOG.md
   bug_tracker_uri: https://github.com/kettle-dev/kettle-dev/issues
-  documentation_uri: https://www.rubydoc.info/gems/kettle-dev/2.5.11
+  documentation_uri: https://www.rubydoc.info/gems/kettle-dev/2.5.13
   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