ci_runner 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 25a11b4505aff5153e388723711643c4aae5f3a7b64b53b3265e0bd7198ec381
-  data.tar.gz: 858492f60b87472cf41da22c5808a2371659d56712ef77dad98590cb98063ecf
+  metadata.gz: f7834106a8db1f0770e5184dcf31fbfc892a92890b52f4709ab900ccd560f1b2
+  data.tar.gz: 69c9c0533ff5a52a1f97cb1f4374e012f56004a06a584b2b60ab80e4c9897517
 SHA512:
-  metadata.gz: 51158e9a4b9cd2188f5161320dc140e076009f7c4550206b957ffac03e9b5859533dc99defc644f05aa126713f8d52cf1d2260a4691ba74cba746f779ec3c945
-  data.tar.gz: 5db9352b2360cec4f5f8b23ce4cf378fcef79c3cc1e8b2f1cb4543fb307a2fc8db1116fea023b766d262d768582dd9f44bb1c48434c2c6171e697962398f0543
+  metadata.gz: 67d81327e046862ccb85ead5688aac13d9818d8ffc1487ef92001fba07ff6c6795dee7a537566e410c3c864ed0ee8e3712668310412cae9bbab3eddaeff52114
+  data.tar.gz: ac943446f8cf3ebd2a65c5d35e021aebcfee0cca6c5e693bafe7f4ea41b673bc669a3eabe1914eed70a98c646dc12d51dba12d14a066e6b51538a9bfc37318d8

data/ci_runner.gemspec

@@ -24,6 +24,7 @@ Gem::Specification.new do |spec|
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = "https://github.com/Edouard-chin/ci_runner"
+  spec.metadata["changelog_uri"] = "https://github.com/Edouard-chin/ci_runner/blob/main/CHANGELOG.md"
   spec.metadata["allowed_push_host"] = "https://rubygems.org"
   spec.metadata["rubygems_mfa_required"] = "true"
 

data/lib/ci_runner/check/base.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module CIRunner
+  module Check
+    # Base class for a CI check.
+    #
+    # @see https://docs.github.com/en/rest/checks/runs#get-a-check-run
+    # @see https://docs.github.com/en/rest/commits/statuses#list-commit-statuses-for-a-reference
+    class Base
+      # @return [String] The full repository name, including the owner (i.e. rails/rails)
+      attr_reader :repository
+
+      # @return [String] The Git commit that has been pushed to GitHub and for which we'll retrieve the CI checks.
+      attr_reader :commit
+
+      # @return [String] The name of that check. Should be whatever you had set in your CI configuration cile
+      attr_reader :name
+
+      # @return [String] The status from the GitHub API for this check. Can be a lot of different values.
+      #   See the GitHub API.
+      attr_reader :status
+
+      # @param repository (See #repository)
+      # @param commit (See #commit)
+      # @param name (See #name)
+      # @param status (See #status)
+      def initialize(repository, commit, name, status)
+        @repository = repository
+        @commit = commit
+        @name = name
+        @status = status
+      end
+
+      # Subclass have to implement this to download the log(s) output for the build.
+      #
+      # @raise [NotImplementedError]
+      #
+      # @return [IO]
+      def download_log
+        raise(NotImplementedError, "Subclass responsability")
+      end
+
+      # Used to tell the user which CI provider we are downloading the log output from.
+      #
+      # @return [String]
+      def provider
+        raise(NotImplementedError, "Subclass responsability")
+      end
+
+      # @return [Boolean]
+      def success?
+        @status == "success"
+      end
+
+      # @return [Boolean]
+      #
+      # @see https://docs.github.com/en/rest/commits/statuses#get-the-combined-status-for-a-specific-reference
+      def failed?
+        ["error", "failure"].include?(status)
+      end
+    end
+  end
+end

data/lib/ci_runner/check/buildkite.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require "uri"
+
+module CIRunner
+  module Check
+    # Check class used when a project is configured to run its CI using Buildkite.
+    class Buildkite < Base
+      include ConcurrentDownload
+
+      attr_reader :url # :private:
+
+      # @param args (See Base#initialize)
+      # @param url [String] The html URL pointing to the Buildkite build.
+      def initialize(*args, url)
+        super(*args)
+
+        @url = url
+      end
+
+      # Used to tell the user which CI provider we are downloading the log output from.
+      #
+      # @return [String]
+      def provider
+        "Buildkite"
+      end
+
+      # Download the CI logs for this Buildkite build.
+      #
+      # The Buildkite API scopes tokens per organizations (token generated for org A can't access
+      # resource on org B, even for public resources). This means that for opensource projects using
+      # Buildkite, users that are not members of the buildkite org normally can't use CI Runner.
+      #
+      # To bypass this problem, for builds that are public, CI Runner uses a different API.
+      # For private build, CI runner will check if the user had stored a Buildkite token in its config.
+      #
+      # @return [Tempfile]
+      def download_log
+        uri = URI(url)
+        _, org, pipeline, _, build = uri.path.split("/")
+        @client = Client::Buildkite.new
+
+        unless @client.public_build?(org, pipeline, build)
+          token = retrieve_token_from_config(org, url)
+          @client = Client::AuthenticatedBuildkite.new(token)
+        end
+
+        @client.job_logs(org, pipeline, build).each do |log_url|
+          @queue << log_url
+        end
+
+        process_queue
+      end
+
+      private
+
+      # @param url [String]
+      #
+      # @return [void]
+      def process(url)
+        @client.reset!
+        response = @client.download_log(url)
+
+        @tempfile.write(response.read)
+      end
+
+      # Retrieve a Buildkite token from the user confg.
+      #
+      # @param organization [String] The organization that owns this buildkite build.
+      # @param url [String] The FQDN pointing to the buildkite build.
+      #
+      # @return [String] The token
+      #
+      # @raise [Error] If no token for that organization exists in the config.
+      def retrieve_token_from_config(organization, url)
+        token = Configuration::User.instance.buildkite_token(organization.downcase)
+
+        token || raise(Error, <<~EOM)
+          Can't get the log output from the Buildkite build #{url} because it requires authentication.
+
+          Please store a Buildkite token scoped to the organization #{organization} and retry.
+          See {{command:ci_runner help buildkite_token}}
+        EOM
+      end
+    end
+  end
+end

data/lib/ci_runner/check/circle_ci.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require "uri"
+require "open-uri"
+require "json"
+
+module CIRunner
+  module Check
+    # A Step object represents a CircleCI step.
+    # This Struct has +eql?+ and +hash+ implemented in order to check if two steps are the same and remove
+    # the duplicates.
+    #
+    # Two steps are considered the same if their names are equal and both are successful.
+    # The reason this is implemented like this is to avoid downloading too many of the same logfiles.
+    #
+    # Project on CircleCI can be configured to run in parallel, the number of steps and therefore log output
+    # we have to download increases exponentially.
+    #
+    # As an example, imagine this CircleCI configuration:
+    #
+    # 'Minitest':
+    #   executor: ruby/default
+    #   parallelism: 16
+    #   steps:
+    #     - setup-ruby
+    #     - bundle install
+    #     - bin/rails test
+    #
+    # CircleCI will create 48 steps (and 48 log download link). Downloading those 48 log, don't make sense
+    # since they will be all similar. Unless they failed, in which case we download the log for that step.
+    #
+    # @see https://circleci.com/docs/configuration-reference#steps
+    Step = Struct.new(:name, :output_url, :failed) do
+      # Used in conjuction with +hash+ for unique comparison.
+      #
+      # @param other [Object]
+      #
+      # @return [Boolean]
+      def eql?(other)
+        return false if failed || other.failed
+
+        name == other.name
+      end
+
+      # Used for unique comparison.
+      #
+      # @return [String]
+      def hash
+        [self.class, name, failed].hash
+      end
+    end
+
+    # Check class used when a project is configured to run its CI using CircleCI.
+    class CircleCI < Base
+      include ConcurrentDownload
+
+      attr_reader :url # :private:
+
+      # @param args (See Base#initialize)
+      # @param url [String] The html URL pointing to the CircleCI build.
+      def initialize(*args, url)
+        super(*args)
+
+        @url = url
+      end
+
+      # Used to tell the user which CI provider we are downloading the log output from.
+      #
+      # @return [String]
+      def provider
+        "CircleCI"
+      end
+
+      # Download the CI logs for this CI build.
+      #
+      # CircleCI doesn't have an API to download a single log file for the whole build. Instead, we have
+      # to download a log output for each steps. Depending on the number of steps configured on a project, and
+      # whether it uses parallelism, the number of log files to download might be quite important.
+      #
+      # The log for each steps are small in size, so downloading them in parallel to make things much faster.
+      #
+      # @return [Tempfile]
+      def download_log
+        client = Client::CircleCI.new(Configuration::User.instance.circle_ci_token)
+        job = client.job(repository, build_number)
+        steps = []
+
+        job["steps"].each do |step|
+          step["actions"].each do |parallel|
+            next unless parallel["has_output"]
+
+            steps << Step.new(*parallel.values_at("name", "output_url", "failed"))
+          end
+        end
+
+        steps.uniq!
+
+        steps.each do |step|
+          @queue << step
+        end
+
+        process_queue
+      end
+
+      private
+
+      # @param step [Step]
+      #
+      # @return [void]
+      def process(step)
+        response = URI.open(step.output_url)
+        parsed_response = JSON.parse(response.read)
+        log_output = parsed_response.map! { |res| res["message"] }.join
+
+        @tempfile.write(log_output)
+      end
+
+      # The URL on the commit status will look something like: https://circleci.com/gh/owner/repo/1234?query_string.
+      # We want the `1234` which is the builder number.
+      #
+      # @return [Integer]
+      def build_number
+        URI(@url.to_s).path.split("/").last
+      end
+    end
+  end
+end

data/lib/ci_runner/check/concurrent_download.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "tempfile"
+
+module CIRunner
+  module Check
+    # Module used to dowload multiple logfiles in parallel.
+    #
+    # Some CI providers doesn't have an API to download a single log file for the whole
+    # build, and instead one log file is produced per step. CI Runner needs to download
+    # the logfile of all steps in the build in order to rerun all test that failed.
+    module ConcurrentDownload
+      def initialize(...)
+        @queue = Queue.new
+        @tempfile = Tempfile.new
+
+        super(...)
+      end
+
+      private
+
+      # Implement a queuing system in order to download log files in parallel.
+      #
+      # @return [void]
+      def process_queue
+        max_threads = 6
+        threads = []
+
+        max_threads.times do
+          threads << Thread.new do
+            while (element = dequeue)
+              process(element)
+            end
+          end
+        end
+
+        threads.each(&:join)
+
+        @tempfile.tap(&:flush)
+      end
+
+      # Process item in the queue.
+      def process
+        raise(NotImplementedError)
+      end
+
+      # Dequeue a CircleCI Step from the queue.
+      #
+      # @return [Step, nil]
+      def dequeue
+        @queue.pop(true)
+      rescue ThreadError
+        nil
+      end
+    end
+  end
+end

data/lib/ci_runner/check/github.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module CIRunner
+  module Check
+    # Check class used when a project is configured to run its CI using GitHub actions.
+    #
+    # @see https://docs.github.com/en/rest/actions/workflow-jobs
+    class Github < Base
+      attr_reader :id # :private:
+
+      # @param args (See Base#initialize)
+      # @param id [Integer] The ID of this check.
+      def initialize(*args, id)
+        super(*args)
+
+        @id = id
+      end
+
+      # Used to tell the user which CI provider we are downloading the log output from.
+      #
+      # @return [String]
+      def provider
+        "GitHub"
+      end
+
+      # Download the log output for thig GitHub build.
+      #
+      # @return (See Client::Github#download_log)
+      #
+      # @see https://docs.github.com/en/rest/actions/workflow-jobs#download-job-logs-for-a-workflow-run
+      def download_log
+        github_client = Client::Github.new(Configuration::User.instance.github_token)
+
+        github_client.download_log(@repository, @id)
+      end
+    end
+  end
+end

data/lib/ci_runner/check/unsupported.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module CIRunner
+  module Check
+    # Check class used for any CI provider not (yet) supported by CIRunner.
+    #
+    # When running the `ci_runner` CLI, those will be selectable but CI runner will bail out
+    # if they get selected. Not sure if its a good idea :shrug:.
+    class Unsupported < Base
+      # @return [String]
+      def name
+        "#{@name} (Unsupported by CI Runner)"
+      end
+
+      # @return [String]
+      def provider
+        ""
+      end
+
+      # @raise [Error]
+      def download_log
+        raise(Error, <<~EOM)
+          Aw, snap! This CI is not supported by CI Runner.
+          Please open an Issue on GitHub to let me know you are interested:
+
+          {{info:https://github.com/Edouard-chin/ci_runner/issues/new}}
+        EOM
+      end
+    end
+  end
+end

data/lib/ci_runner/cli.rb

@@ -35,6 +35,7 @@ module CIRunner
     def rerun
       ::CLI::UI::StdoutRouter.enable
 
+      check_for_new_version
       runner = nil
 
       ::CLI::UI.frame("Preparing CI Runner") do
@@ -47,14 +48,12 @@ module CIRunner
         run_name = options[:run_name] || ask_for_name(ci_checks)
         check_run = TestRunFinder.find(ci_checks, run_name)
 
-        ci_log = fetch_ci_log(repository, commit, check_run)
-        runner = TestRunFinder.detect_runner(ci_log)
+        ci_log = fetch_ci_log(check_run)
+        runner = TestRunFinder.detect_runner(ci_log.read)
         runner.parse!
 
-        if runner.failures.count == 0
-          # Error
-        end
-      rescue GithubClient::Error, Error => e
+        no_failure_error(ci_log, runner) if runner.failures.count.zero?
+      rescue Client::Error, Error => e
         ::CLI::UI.puts("\n{{red:#{e.message}}}", frame_color: :red)
 
         exit(false)
@@ -71,13 +70,13 @@ module CIRunner
       Save a personal access GitHub token in the ~/.ci_runner/config.yml file.
       The GitHub token is required to fetch CI checks and download logs from repositories.
 
-      You can get a token from GitHub by following this link: https://github.com/settings/tokens/new?description=CI+Runner&scopes=repo # rubocop:disable Layout/LineLength
+      You can get a token from GitHub by following this link: https://github.com/settings/tokens/new?description=CI+Runner&scopes=repo
     EOM
     def github_token(token)
       ::CLI::UI::StdoutRouter.enable
 
       ::CLI::UI.frame("Saving GitHub Token") do
-        user = GithubClient.new(token).me
+        user = Client::Github.new(token).me
         Configuration::User.instance.save_github_token(token)
 
         ::CLI::UI.puts(<<~EOM)
@@ -85,22 +84,97 @@ module CIRunner
 
           {{info:The token has been saved in this file: #{Configuration::User.instance.config_file}}}
         EOM
-      rescue GithubClient::Error => e
+      rescue Client::Error => e
         ::CLI::UI.puts("{{red:\nYour token doesn't seem to be valid. The response from GitHub was: #{e.message}}}")
 
         exit(false)
       end
     end
 
+    desc "circle_ci_token TOKEN", "Save a Circle CI token in your config."
+    long_desc <<~EOM
+      Save a personal access Circle CI token in the ~/.ci_runner/config.yml file.
+      If one of your project uses Circle CI as its CI provider and the project is set to private,
+      CI Runner won't be able to fetch the logs unless you provide a token.
+
+      You can get a token from Circle CI by following this link: https://app.circleci.com/settings/user/tokens
+    EOM
+    def circle_ci_token(token)
+      ::CLI::UI::StdoutRouter.enable
+
+      ::CLI::UI.frame("Saving CircleCI Token") do
+        user = Client::CircleCI.new(token).me
+        Configuration::User.instance.save_circle_ci_token(token)
+
+        ::CLI::UI.puts(<<~EOM)
+          Hello {{warning:#{user["login"]}}}! {{success:Your token is valid!}}
+
+          {{info:The token has been saved in this file: #{Configuration::User.instance.config_file}}}
+        EOM
+      rescue Client::Error => e
+        ::CLI::UI.puts("{{red:\nYour token doesn't seem to be valid. The response from Circle CI was: #{e.message}}}")
+
+        exit(false)
+      end
+    end
+
+    desc "buildkite_token TOKEN ORGANIZATION", "Save a Buildkite token in your config."
+    long_desc <<~EOM
+      Save a personal access Buildkite token in the ~/.ci_runner/config.yml file.
+      Storing a Buildkite token is required to retrieve log from private Buildkite builds.
+
+      The ORGANIZATION, should be the name of the organization the token has access to.
+
+      You can get a token from Buildkite by following this link: https://buildkite.com/user/api-access-tokens/new?description=CI%20Runner&scopes[]=read_builds&scopes[]=read_build_logs
+    EOM
+    def buildkite_token(token, organization)
+      ::CLI::UI::StdoutRouter.enable
+
+      required_scopes = ["read_builds", "read_build_logs"]
+      token_scopes = Client::AuthenticatedBuildkite.new(token).access_token["scopes"]
+      missing_scopes = required_scopes - token_scopes
+
+      if missing_scopes.empty?
+        Configuration::User.instance.save_buildkite_token(token, organization)
+
+        ::CLI::UI.puts(<<~EOM)
+          {{success:Your token is valid!}}
+
+          {{info:The token has been saved in this file: #{Configuration::User.instance.config_file}}}
+        EOM
+      else
+        ::CLI::UI.puts("{{red:\nYour token is missing required scope(s): #{missing_scopes.join(",")}")
+      end
+    rescue Client::Error => e
+      ::CLI::UI.puts("{{red:\nYour token doesn't seem to be valid. The response from Buildkite was: #{e.message}}}")
+
+      exit(false)
+    end
+
     private
 
+    # Inform the user of a possible new CI Runner version.
+    #
+    # @return [void]
+    def check_for_new_version
+      version_verifier = VersionVerifier.new
+      return unless version_verifier.new_ci_runner_version?
+
+      ::CLI::UI.puts(<<~EOM)
+        {{info:A newer version of CI Runner is available (#{version_verifier.upstream_version}).}}
+        {{info:You can update CI Runner by running}} {{command:gem update ci_runner}}
+      EOM
+    rescue StandardError
+      nil
+    end
+
     # Retrieve all the GitHub CI checks for a given commit. Will be used to interactively prompt
     # the user which one to rerun.
     #
     # @param repository [String] The full repository name including the owner (rails/rails).
     # @param commit [String] A Git commit that has been pushed to GitHub and for which CI failed.
     #
-    # @return [Hash] See the GitHub documentation.
+    # @return [Array<Check::Base>] Array filled with Check::Base subclasses.
     #
     # @raise [SystemExit] Early exit the process if the CI checks can't be retrieved.
     #
@@ -120,19 +194,17 @@ module CIRunner
     # Download and cache the log for the GitHub check. Downloading the log allows CI Runner to parse it and detect
     # which test failed in order to run uniquely those on the user machine.
     #
-    # @param repository [String] The full repository name including the owner (rails/rails).
-    # @param commit [String]     A Git commit that has been pushed to GitHub and for which CI failed.
-    # @param check_run [Hash]    The GitHub Check that failed. See #fetch_ci_checks.
+    # @param check_run [Check::Base] The GitHub Check that failed. See #fetch_ci_checks.
     #
     # @return [String] The content of the CI log.
     #
     # @raise [SystemExit] Early exit the process if the CI checks can't be retrieved.
     #
     # @see https://docs.github.com/en/rest/actions/workflow-jobs#download-job-logs-for-a-workflow-run
-    def fetch_ci_log(repository, commit, check_run)
-      log = LogDownloader.new(commit, repository, check_run).fetch do |error|
-        puts(<<~EOM)
-          Couldn't fetch the CI log. The response from GitHub was:
+    def fetch_ci_log(check_run)
+      log = LogDownloader.new(check_run).fetch do |error|
+        ::CLI::UI.puts(<<~EOM)
+          Couldn't fetch the CI log. The error was:
 
           #{error.message}
         EOM
@@ -140,27 +212,26 @@ module CIRunner
         exit(false)
       end
 
-      log.read
+      log
     end
 
     # Interatively ask the user which CI check to rerun in the case a commit has multiple failing checks.
     # This method only runs if the user has not passed the '--run-name' flag to ci_runner.
     # Will automatically select a check in the case where there is only one failing check.
     #
-    # @param ci_checks [Hash] (See #fetch_ci_checks)
+    # @param ci_checks [Array<Check::Base>] (See #fetch_ci_checks)
     #
-    # @return [Hash] A single Check Run, the one that the user selected.
+    # @return [Check::Base] A single Check, the one that the user selected.
     #
     # @raise [CIRunner::Error] In case all the CI checks on this commit were successfull. In such case
     #   there is no need to proceed as there should be no failing tests to rerun.
     def ask_for_name(ci_checks)
-      check_runs = ci_checks["check_runs"]
-      failed_runs = check_runs.reject { |check_run| check_run["conclusion"] == "success" }
+      failed_runs = ci_checks.select(&:failed?)
 
       if failed_runs.count == 0
         raise(Error, "No CI checks failed on this commit.")
       elsif failed_runs.count == 1
-        check_run = failed_runs.first["name"]
+        check_run = failed_runs.first.name
 
         ::CLI::UI.puts(<<~EOM)
           {{warning:Automatically selected the CI check #{check_run} because it's the only one failing.}}
@@ -170,9 +241,30 @@ module CIRunner
       else
         ::CLI::UI.ask(
           "Multiple CI checks failed for this commit. Please choose the one you wish to re-run.",
-          options: failed_runs.map { |check_run| check_run["name"] },
+          options: failed_runs.map(&:name),
         )
       end
     end
+
+    # Raise an error in the case where CI Runner can't detect test failures from the logs.
+    # Can happen for a couple of reasons, outlined in the error message below.
+    #
+    # @param ci_log [Pathname]
+    # @param runner [Runners::Minitest, Runners::RSpec]
+    #
+    # @raise [Error]
+    def no_failure_error(ci_log, runner)
+      raise(Error, <<~EOM)
+        Couldn't detect any {{warning:#{runner.name}}} test failures from the log output. This can be either because:
+
+        {{warning:- The selected CI is not running #{runner.name} tests.}}
+        {{warning:- CIRunner default set of regexes failed to match the failures.}}
+
+          If your application is using custom reporters, you'll need to configure CI Runner.
+          {{info:Have a look at the wiki to know how: https://github.com/Edouard-chin/ci_runner/wiki}}
+
+        The CI log output has been downloaded to {{underline:#{ci_log}}} if you need to inspect it.
+      EOM
+    end
   end
 end