selective-ruby-core 0.1.0-aarch64-linux

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0a0e4dc18c3cb6d8d0b4821b8ff26bcb0082a3a501593493207d99dd9814305c
+  data.tar.gz: 2791a6864d2be9e577d0e5a00600df3f5da2d28f9a3207e64ed1bfddfa7129a1
+SHA512:
+  metadata.gz: d8ae66cad83d5e643f5ae882b30424bd06a8c711dfd22b76d805f7f3c610c734901ae7d3adf68c696f07c9a0451b14fbdee3f760945a9775a160a1e5ad199be3
+  data.tar.gz: 1d2e7be21539b9fcdccfa23e093892723aa7fedccc8c6d89128fc9d9eff5a34522cd2f1c3e3d4c94ab569fe675f85a6c670488dac11660b4c8a72fd4b088f2f1

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Selective
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/Rakefile

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+
+# Override the guard_clean task to be a no-op
+Rake::Task["release:guard_clean"].clear
+
+task "release:guard_clean" do
+  # Intentionally blank to skip the check
+end
+
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "standard/rake"
+
+task default: %i[spec standard]

data/exe/selective

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+
+# We test selective-ruby using selective-ruby. This means that
+# SimpleCov.start must be called before our code is loaded.
+if ENV["SELECTIVE_SIMPLECOV"]
+  require "simplecov"
+  SimpleCov.start do
+    add_filter "/spec/"
+  end
+end
+
+require "selective-ruby-core"
+
+Selective::Ruby::Core::Init.run(ARGV.dup)

data/lib/bin/build_env.sh

@@ -0,0 +1,34 @@
+#!/bin/bash
+
+# Detect the platform (only GitHub Actions in this case)
+if [ -n "$GITHUB_ACTIONS" ]; then
+  # Get environment variables
+  platform="github_actions"
+  branch="${GITHUB_HEAD_REF:-$GITHUB_REF_NAME}"
+  pr_title="$PR_TITLE"
+  target_branch="${GITHUB_BASE_REF}"
+  actor="$GITHUB_ACTOR"
+  sha="$GITHUB_SHA"
+  commit_message=$(git log --format=%s -n 1 $sha)
+else
+  platform="$SELECTIVE_PLATFORM"
+  branch="$SELECTIVE_BRANCH"
+  pr_title="$SELECTIVE_PR_TITLE"
+  target_branch="$SELECTIVE_TARGET_BRANCH"
+  actor="$SELECTIVE_ACTOR"
+  sha="$SELECTIVE_SHA"
+  commit_message=$(git log --format=%s -n 1 $sha)
+fi
+
+# Output the JSON
+cat <<EOF
+  {
+    "platform": "$platform",
+    "branch": "$branch",
+    "pr_title": "$pr_title",
+    "target_branch": "$target_branch",
+    "actor": "$actor",
+    "sha": "$sha",
+    "commit_message": "$commit_message"
+  }
+EOF

data/lib/selective/ruby/core/controller.rb

@@ -0,0 +1,313 @@
+require "logger"
+require "uri"
+require "json"
+
+module Selective
+  module Ruby
+    module Core
+      class Controller
+        @@selective_suppress_reporting = false
+
+        def initialize(runner, debug = false)
+          @debug = debug
+          @runner = runner
+          @retries = 0
+          @runner_id = ENV.fetch("SELECTIVE_RUNNER_ID", generate_runner_id)
+          @logger = Logger.new("log/#{runner_id}.log")
+        end
+
+        def start(reconnect: false)
+          @pipe = NamedPipe.new("/tmp/#{runner_id}_2", "/tmp/#{runner_id}_1")
+          @transport_pid = spawn_transport_process(reconnect ? transport_url + "&reconnect=true" : transport_url)
+
+          handle_termination_signals(transport_pid)
+          run_main_loop
+        rescue NamedPipe::PipeClosedError
+          retry!
+        rescue => e
+          with_error_handling { raise e }
+        end
+
+        def exec
+          runner.exec
+        rescue => e
+          with_error_handling(include_header: false) { raise e }
+        end
+
+        def self.suppress_reporting!
+          @@selective_suppress_reporting = true
+        end
+
+        def self.restore_reporting!
+          @@selective_suppress_reporting = false
+        end
+
+        def self.suppress_reporting?
+          @@selective_suppress_reporting
+        end
+
+        private
+
+        attr_reader :runner, :pipe, :transport_pid, :retries, :logger, :runner_id
+
+        BUILD_ENV_SCRIPT_PATH = "../../../bin/build_env.sh".freeze
+
+        def run_main_loop
+          loop do
+            message = pipe.read
+            next sleep(0.1) if message.nil? || message.empty?
+
+            response = JSON.parse(message, symbolize_names: true)
+
+            @logger.info("Received Command: #{response}")
+            next if handle_command(response)
+
+            break
+          end
+        end
+
+        def retry!
+          @retries += 1
+
+          with_error_handling { raise "Too many retries" } if retries > 4
+
+          puts("Retrying in #{retries} seconds...")
+          sleep(retries)
+          kill_transport
+
+          pipe.reset!
+          start(reconnect: true)
+        end
+
+        def write(data)
+          pipe.write JSON.dump(data)
+        end
+
+        def generate_runner_id
+          "selgen-#{SecureRandom.hex(4)}"
+        end
+
+        def transport_url
+          @transport_url ||= begin
+            api_key = ENV.fetch("SELECTIVE_API_KEY")
+            run_id = ENV.fetch("SELECTIVE_RUN_ID")
+            run_attempt = ENV.fetch("SELECTIVE_RUN_ATTEMPT", SecureRandom.uuid)
+            host = ENV.fetch("SELECTIVE_HOST", "wss://app.selective.ci")
+
+            # Validate that host is a valid websocket url(starts with ws:// or wss://)
+            raise "Invalid host: #{host}" unless host.match?(/^wss?:\/\//)
+
+            params = {
+              "run_id" => run_id,
+              "run_attempt" => run_attempt,
+              "api_key" => api_key,
+              "runner_id" => runner_id
+            }.merge(metadata: build_env.to_json)
+
+            query_string = URI.encode_www_form(params)
+
+            "#{host}/transport/websocket?#{query_string}"
+          end
+        end
+
+        def build_env
+          result = `#{Pathname.new(__dir__) + BUILD_ENV_SCRIPT_PATH}`
+          JSON.parse(result)
+        end
+
+        def spawn_transport_process(url)
+          root_path = Gem.loaded_specs["selective-ruby-core"].full_gem_path
+          transport_path = File.join(root_path, "lib", "bin", "transport")
+          get_transport_path = File.join(root_path, "bin", "get_transport")
+
+          # The get_transport script is not released with the gem, so this
+          # code is intended for development/CI purposes.
+          if !File.exist?(transport_path) && File.exist?(get_transport_path)
+            require "open3"
+            output, status = Open3.capture2e(get_transport_path)
+            if !status.success?
+              puts <<~TEXT
+                Failed to download transport binary.
+
+                #{output}
+              TEXT
+            end
+          end
+
+          Process.spawn(transport_path, url, runner_id).tap do |pid|
+            Process.detach(pid)
+          end
+        end
+
+        def handle_termination_signals(pid)
+          ["INT", "TERM"].each do |signal|
+            Signal.trap(signal) do
+              # :nocov:
+              kill_transport(signal: signal)
+              exit
+              # :nocov:
+            end
+          end
+        end
+
+        def kill_transport(signal: "TERM")
+          begin
+            pipe.write "exit"
+
+            # Give up to 5 seconds for graceful exit
+            # before killing it below
+            1..5.times do
+              Process.getpgid(transport_pid)
+
+              sleep(1)
+            end
+          rescue NamedPipe::PipeClosedError
+            # If the pipe is close, move straight to killing
+            # it forcefully.
+          end
+
+          # :nocov:
+          Process.kill(signal, transport_pid)
+          # :nocov:
+        rescue Errno::ESRCH
+          # Process already gone noop
+        end
+
+        def handle_command(response)
+          case response[:command]
+          when "init"
+            print_init(response[:runner_id])
+          when "test_manifest"
+            handle_test_manifest
+          when "run_test_cases"
+            handle_run_test_cases(response[:test_case_ids])
+          when "remove_failed_test_case_result"
+            handle_remove_failed_test_case_result(response[:test_case_id])
+          when "reconnect"
+            handle_reconnect
+          when "print_message"
+            handle_print_message(response[:message])
+          when "close"
+            handle_close(response[:exit_status])
+
+            # This is here for the sake of test where we
+            # cannot exit but we need to break the loop
+            return false
+          end
+
+          true
+        end
+
+        def handle_reconnect
+          kill_transport
+          pipe.reset!
+          start(reconnect: true)
+        end
+
+        def handle_test_manifest
+          self.class.restore_reporting!
+          @logger.info("Sending Response: test_manifest")
+          write({type: "test_manifest", data: {
+            test_cases: runner.manifest["examples"],
+            modified_test_files: modified_test_files
+          }})
+        end
+
+        def handle_run_test_cases(test_cases)
+          runner.run_test_cases(test_cases, method(:test_case_callback))
+        end
+
+        def test_case_callback(test_case)
+          @logger.info("Sending Response: test_case_result: #{test_case[:id]}")
+          write({type: "test_case_result", data: test_case})
+        end
+
+        def handle_remove_failed_test_case_result(test_case_id)
+          runner.remove_failed_test_case_result(test_case_id)
+        end
+
+        def modified_test_files
+          # Todo: This should find files changed in the current branch
+          `git diff --name-only`.split("\n").filter do |f|
+            f.match?(/^#{runner.base_test_path}/)
+          end
+        end
+
+        def handle_print_message(message)
+          print_warning(message)
+        end
+
+        def handle_close(exit_status = nil)
+          self.class.restore_reporting!
+          runner.finish unless exit_status.is_a?(Integer)
+
+          kill_transport
+          pipe.delete_pipes
+          exit(exit_status || runner.exit_status)
+        end
+
+        def debug?
+          @debug
+        end
+
+        def with_error_handling(include_header: true)
+          yield
+        rescue => e
+          raise e if debug?
+          header = <<~TEXT
+            An error occurred. Please rerun with --debug
+            and contact support at https://selective.ci/support
+          TEXT
+
+          unless @banner_displayed
+            header = <<~TEXT
+              #{banner}
+
+              #{header}
+            TEXT
+          end
+
+          puts_indented <<~TEXT
+            \e[31m
+            #{header if include_header}
+            #{e.message}
+            \e[0m
+          TEXT
+
+          exit 1
+        end
+
+        def print_warning(message)
+          puts_indented <<~TEXT
+            \e[33m
+            #{message}
+            \e[0m
+          TEXT
+        end
+
+        def print_init(runner_id)
+          puts_indented <<~TEXT
+            #{banner}
+            Runner ID: #{runner_id.gsub("selgen-", "")}
+          TEXT
+        end
+
+        def puts_indented(text)
+          puts text.gsub(/^/, "  ")
+        end
+
+        def banner
+          @banner_displayed = true
+          <<~BANNER
+             ____       _           _   _
+            / ___|  ___| | ___  ___| |_(_)_   _____
+            \\___ \\ / _ \\ |/ _ \\/ __| __| \\ \\ / / _ \\
+             ___) |  __/ |  __/ (__| |_| |\\ V /  __/
+            |____/ \\___|_|\\___|\\___|\\__|_| \\_/ \\___|
+            ________________________________________
+          BANNER
+        end
+      end
+    end
+  end
+end

data/lib/selective/ruby/core/named_pipe.rb

@@ -0,0 +1,103 @@
+module Selective
+  module Ruby
+    module Core
+      class NamedPipe
+        class PipeClosedError < StandardError; end
+
+        attr_reader :read_pipe_path, :write_pipe_path
+
+        def initialize(read_pipe_path, write_pipe_path, skip_reset: false)
+          @read_pipe_path = read_pipe_path
+          @write_pipe_path = write_pipe_path
+
+          delete_pipes unless skip_reset
+          initialize_pipes
+        end
+
+        def initialize_pipes
+          create_pipes
+
+          # Open the read and write pipes in separate threads
+          Thread.new do
+            @read_pipe = File.open(read_pipe_path, "r")
+          end
+          Thread.new do
+            @write_pipe = File.open(write_pipe_path, "w")
+          end
+        end
+
+        def write(message)
+          return unless write_pipe
+
+          chunk_size = 1024  # 1KB chunks
+          offset = 0
+          begin
+            while offset < message.bytesize
+              chunk = message.byteslice(offset, chunk_size)
+
+              write_pipe.write(chunk)
+              write_pipe.flush
+
+              offset += chunk_size
+            end
+
+            write_pipe.write("\n")
+            write_pipe.flush
+          rescue Errno::EPIPE
+            raise PipeClosedError
+          end
+        end
+
+        def read
+          return unless read_pipe
+          begin
+            message = read_pipe.gets.chomp
+          rescue NoMethodError => e
+            if e.name == :chomp
+              raise PipeClosedError
+            else
+              raise e
+            end
+          end
+          message
+        end
+
+        def reset!
+          delete_pipes
+          initialize_pipes
+        end
+
+        def delete_pipes
+          # Close the pipes before deleting them
+          read_pipe&.close
+          write_pipe&.close
+
+          # Allow threads to close before deleting pipes
+          sleep(0.1)
+
+          delete_pipe(read_pipe_path)
+          delete_pipe(write_pipe_path)
+        rescue Errno::EPIPE
+          # Noop
+        end
+
+        private
+
+        attr_reader :read_pipe, :write_pipe
+
+        def create_pipes
+          create_pipe(read_pipe_path)
+          create_pipe(write_pipe_path)
+        end
+
+        def create_pipe(path)
+          system("mkfifo #{path}") unless File.exist?(path)
+        end
+
+        def delete_pipe(path)
+          File.delete(path) if File.exist?(path)
+        end
+      end
+    end
+  end
+end

data/lib/selective/ruby/core/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Selective
+  module Ruby
+    module Core
+      VERSION = "0.1.0"
+    end
+  end
+end

data/lib/selective-ruby-core.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+
+loader = Zeitwerk::Loader.for_gem(warn_on_extra_files: false)
+loader.ignore("#{__dir__}/selective-ruby-core.rb")
+loader.setup
+
+module Selective
+  module Ruby
+    module Core
+      class Error < StandardError; end
+
+      @@available_runners = {}
+
+      def self.register_runner(name, runner_class)
+        @@available_runners[name] = runner_class
+      end
+
+      def self.runner_for(name)
+        @@available_runners[name] || raise("Unknown runner #{name}")
+      end
+
+      class Init
+        def initialize(args)
+          @debug = !args.delete("--debug").nil?
+          @runner_name, @args, @command = parse_args(args)
+          require_runner
+        end
+
+        def self.run(args)
+          new(args).send(:run)
+        end
+
+        private
+
+        attr_reader :debug, :runner_name, :args, :command
+
+        def run
+          Selective::Ruby::Core::Controller.new(runner, debug).send(command)
+        end
+
+        def parse_args(args)
+          # Returns runner_name, args, command
+          if args[0] == "exec" # e.g. selective exec rspec
+            [args[1], args[2..], :exec]
+          else # e.g. selective rspec
+            [args[0], args[1..], :start]
+          end
+        end
+
+        def runner
+          Selective::Ruby::Core.runner_for(runner_name).new(args)
+        end
+
+        def require_runner
+          require "selective-ruby-#{runner_name}"
+        rescue LoadError
+          nil
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: selective-ruby-core
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: aarch64-linux
+authors:
+- Benjamin Wood
+- Nate Vick
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2023-11-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.6.12
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.6.12
+description: Selective is an intelligent test runner for your current CI provider.
+  Get real-time test results, intelligent ordering based on code changes, shorter
+  run times, automatic flake detection, the ability to re-enqueue failed tests, and
+  more.
+email:
+- ben@hint.io
+- nate@hint.io
+executables:
+- selective
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- Rakefile
+- exe/selective
+- lib/bin/build_env.sh
+- lib/bin/transport
+- lib/selective-ruby-core.rb
+- lib/selective/ruby/core/controller.rb
+- lib/selective/ruby/core/named_pipe.rb
+- lib/selective/ruby/core/version.rb
+homepage: https://www.selective.ci
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://www.selective.ci
+  source_code_uri: http://github.com/selectiveci/selective-ruby-core
+  changelog_uri: https://github.com/selectiveci/selective-ruby-core/blob/main/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key: 
+specification_version: 4
+summary: Selective Ruby Client Core
+test_files: []