honeybadger 5.2.0 → 5.3.0

data/vendor/bundle/ruby/3.2.0/gems/shellany-0.0.1/spec/lib/shellany/sheller_spec.rb

@@ -0,0 +1,141 @@
+require "shellany/sheller"
+
+RSpec.describe Shellany::Sheller, :sheller_specs do
+  before do
+    allow(Kernel).to receive(:system) do |args|
+      fail "Stub called with: #{args.inspect}"
+    end
+  end
+
+  subject { described_class }
+
+  context "without a command" do
+    [:new, :run, :stdout, :stderr].each do |meth|
+      describe ".#{meth}" do
+        specify do
+          expect { subject.send(meth) }.
+            to raise_error ArgumentError, "no command given"
+        end
+      end
+    end
+  end
+
+  context "with shell (string) cmd returning success" do
+    let(:cmd) { "ls -l" }
+    let(:output) { "foo.rb\n" }
+    let(:errors) { "" }
+    let(:result) do
+      [instance_double(Process::Status, success?: true), output, errors]
+    end
+
+    context "when constructed with a cmd" do
+      subject { described_class.new(cmd) }
+
+      describe "#run" do
+        it "runs the command given to constructor" do
+          expect(described_class).to receive(:_system_with_capture).
+            with(cmd).and_return(result)
+          subject.run
+        end
+      end
+    end
+  end
+
+  context "with array cmd returning success" do
+    let(:cmd) { %w(ls -l) }
+    let(:output) { "foo.rb\n" }
+    let(:errors) { "" }
+    let(:result) do
+      [instance_double(Process::Status, success?: true), output, errors]
+    end
+
+    describe "when used as class" do
+      describe ".run" do
+        it "runs the given command" do
+          expect(described_class).to receive(:_system_with_capture).
+            with(*cmd) { result }
+          subject.run(*cmd)
+        end
+      end
+
+      describe ".new" do
+        it "does not run anything" do
+          expect(described_class).to_not receive(:_system_with_capture)
+          subject
+        end
+      end
+
+      describe ".stdout" do
+        before do
+          allow(described_class).to receive(:_system_with_capture).
+            with(*cmd) { result }
+        end
+
+        it "runs command and returns output" do
+          expect(subject.stdout(*cmd)).to eq "foo.rb\n"
+        end
+      end
+
+      describe ".stderr" do
+        before do
+          allow(described_class).to receive(:_system_with_capture).
+            with(*cmd) { result }
+        end
+
+        it "runs command and returns errors" do
+          expect(subject.stderr(*cmd)).to eq ""
+        end
+      end
+    end
+
+    context "when constructed with a cmd" do
+      subject { described_class.new(*cmd) }
+
+      it "does not run anything" do
+        expect(described_class).to_not receive(:_system_with_capture)
+        subject
+      end
+
+      describe "#run" do
+        it "runs the command given to constructor" do
+          expect(described_class).to receive(:_system_with_capture).
+            with(*cmd) { result }
+          subject.run
+        end
+      end
+
+      describe "#stdout" do
+        before do
+          allow(described_class).to receive(:_system_with_capture).
+            with(*cmd) { result }
+        end
+
+        it "runs command and returns output" do
+          expect(subject.stdout).to eq "foo.rb\n"
+        end
+      end
+
+      describe "#stderr" do
+        before do
+          allow(described_class).to receive(:_system_with_capture).
+            with(*cmd) { result }
+        end
+
+        it "runs command and returns output" do
+          expect(subject.stderr).to eq ""
+        end
+      end
+
+      describe "#ok?" do
+        before do
+          allow(described_class).to receive(:_system_with_capture).
+            with(*cmd) { result }
+        end
+
+        it "runs command and returns output" do
+          expect(subject).to be_ok
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/shellany-0.0.1/spec/shellany_spec.rb

@@ -0,0 +1,5 @@
+RSpec.describe Shellany do
+  it 'has a version number' do
+    expect(Shellany::VERSION).not_to be nil
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/shellany-0.0.1/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  config.disable_monkey_patching!
+
+  config.warnings = true
+
+  config.default_formatter = 'doc' if config.files_to_run.one?
+
+  # config.profile_examples = 10
+
+  config.order = :random
+
+  Kernel.srand config.seed
+end

data/vendor/bundle/ruby/3.2.0/gems/sshkit-1.21.5/examples/simple_connection.rb

@@ -0,0 +1,9 @@
+# tiny example so you can play with the sshkit or make a failing example for an issue
+require 'bundler/setup'
+require 'sshkit'
+require 'sshkit/dsl'
+include SSHKit::DSL
+
+on [ENV.fetch("HOST")] do
+  execute "echo hello"
+end

data/vendor/bundle/ruby/3.2.0/gems/sshkit-1.21.5/lib/core_ext/array.rb

@@ -0,0 +1,5 @@
+class Array
+  def extract_options!
+    last.is_a?(::Hash) ? pop : {}
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/sshkit-1.21.5/lib/core_ext/hash.rb

@@ -0,0 +1,11 @@
+class Hash
+  def symbolize_keys
+    inject({}) do |options, (key, value)|
+      options[(key.to_sym rescue key) || key] = value
+      options
+    end
+  end
+  def symbolize_keys!
+    self.replace(self.symbolize_keys)
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/sshkit-1.21.5/lib/sshkit/all.rb

@@ -0,0 +1,40 @@
+require_relative '../core_ext/array'
+require_relative '../core_ext/hash'
+
+require_relative 'host'
+
+require_relative 'color'
+require_relative 'command'
+require_relative 'command_map'
+require_relative 'configuration'
+require_relative 'coordinator'
+
+require_relative 'deprecation_logger'
+require_relative 'dsl'
+
+require_relative 'exception'
+
+require_relative 'logger'
+require_relative 'log_message'
+
+require_relative 'mapping_interaction_handler'
+
+require_relative 'formatters/abstract'
+require_relative 'formatters/black_hole'
+require_relative 'formatters/pretty'
+require_relative 'formatters/simple_text'
+require_relative 'formatters/dot'
+
+require_relative 'runners/abstract'
+require_relative 'runners/sequential'
+require_relative 'runners/parallel'
+require_relative 'runners/group'
+require_relative 'runners/null'
+
+require_relative 'backends/abstract'
+require_relative 'backends/connection_pool'
+require_relative 'backends/printer'
+require_relative 'backends/netssh'
+require_relative 'backends/netssh/known_hosts'
+require_relative 'backends/local'
+require_relative 'backends/skipper'

data/vendor/bundle/ruby/3.2.0/gems/sshkit-1.21.5/lib/sshkit/backends/abstract.rb

@@ -0,0 +1,167 @@
+require 'shellwords'
+
+module SSHKit
+
+  module Backend
+
+    MethodUnavailableError = Class.new(SSHKit::StandardError)
+
+    # The Backend instance that is running in the current thread. If no Backend
+    # is running, returns `nil` instead.
+    #
+    # Example:
+    #
+    #   on(:local) do
+    #     self == SSHKit::Backend.current # => true
+    #   end
+    #
+    def self.current
+      Thread.current["sshkit_backend"]
+    end
+
+    class Abstract
+
+      extend Forwardable
+      def_delegators :output, :log, :fatal, :error, :warn, :info, :debug
+
+      attr_reader :host
+
+      def run
+        Thread.current["sshkit_backend"] = self
+        instance_exec(@host, &@block)
+      ensure
+        Thread.current["sshkit_backend"] = nil
+      end
+
+      def initialize(host, &block)
+        raise "Must pass a Host object" unless host.is_a? Host
+        @host  = host
+        @block = block
+
+        @pwd   = nil
+        @env   = nil
+        @user  = nil
+        @group = nil
+      end
+
+      def redact(arg) # Used in execute_command to hide redact() args a user passes in
+        arg.to_s.extend(Redaction) # to_s due to our inability to extend Integer, etc
+      end
+
+      def make(commands=[])
+        execute :make, commands
+      end
+
+      def rake(commands=[])
+        execute :rake, commands
+      end
+
+      def test(*args)
+        options = { verbosity: Logger::DEBUG, raise_on_non_zero_exit: false }.merge(args.extract_options!)
+        create_command_and_execute(args, options).success?
+      end
+
+      def capture(*args)
+        options = { verbosity: Logger::DEBUG, strip: true }.merge(args.extract_options!)
+        result = create_command_and_execute(args, options).full_stdout
+        options[:strip] ? result.strip : result
+      end
+
+      def background(*args)
+        SSHKit.config.deprecation_logger.log(
+          'The background method is deprecated. Blame badly behaved pseudo-daemons!'
+        )
+        options = args.extract_options!.merge(run_in_background: true)
+        create_command_and_execute(args, options).success?
+      end
+
+      def execute(*args)
+        options = args.extract_options!
+        create_command_and_execute(args, options).success?
+      end
+
+      def within(directory, &_block)
+        (@pwd ||= []).push directory.to_s
+        escaped = Command.shellescape_except_tilde(pwd_path)
+        execute <<-EOTEST, verbosity: Logger::DEBUG
+          if test ! -d #{escaped}
+            then echo "Directory does not exist '#{escaped}'" 1>&2
+            false
+          fi
+        EOTEST
+        yield
+      ensure
+        @pwd.pop
+      end
+
+      def with(environment, &_block)
+        env_old = (@env ||= {})
+        @env = env_old.merge environment
+        yield
+      ensure
+        @env = env_old
+      end
+
+      def as(who, &_block)
+        if who.is_a? Hash
+          @user  = who[:user]  || who["user"]
+          @group = who[:group] || who["group"]
+        else
+          @user  = who
+          @group = nil
+        end
+        execute <<-EOTEST, verbosity: Logger::DEBUG
+          if ! sudo -u #{@user.to_s.shellescape} whoami > /dev/null
+            then echo "You cannot switch to user '#{@user.to_s.shellescape}' using sudo, please check the sudoers file" 1>&2
+            false
+          fi
+        EOTEST
+        yield
+      ensure
+        remove_instance_variable(:@user)
+        remove_instance_variable(:@group)
+      end
+
+      class << self
+        def config
+          @config ||= OpenStruct.new
+        end
+
+        def configure
+          yield config
+        end
+      end
+
+      # Backends which extend the Abstract backend should implement the following methods:
+      def upload!(_local, _remote, _options = {}) raise MethodUnavailableError end
+      def download!(_remote, _local=nil, _options = {}) raise MethodUnavailableError end
+      def execute_command(_cmd) raise MethodUnavailableError end
+      private :execute_command # Can inline after Ruby 2.1
+
+      private
+
+      def output
+        SSHKit.config.output
+      end
+
+      def create_command_and_execute(args, options)
+        command(args, options).tap { |cmd| execute_command(cmd) }
+      end
+
+      def pwd_path
+        if @pwd.nil? || @pwd.empty?
+          nil
+        else
+          File.join(@pwd)
+        end
+      end
+
+      def command(args, options)
+        SSHKit::Command.new(*args, options.merge({in: pwd_path, env: @env, host: @host, user: @user, group: @group}))
+      end
+
+    end
+
+  end
+
+end

data/vendor/bundle/ruby/3.2.0/gems/sshkit-1.21.5/lib/sshkit/backends/connection_pool/cache.rb

@@ -0,0 +1,83 @@
+# A Cache holds connections for a given key. Each connection is stored along
+# with an expiration time so that its idle duration can be measured.
+class SSHKit::Backend::ConnectionPool::Cache
+  attr_accessor :key
+
+  def initialize(key, idle_timeout, closer)
+    @key = key
+    @connections = []
+    @connections.extend(MonitorMixin)
+    @idle_timeout = idle_timeout
+    @closer = closer
+  end
+
+  # Remove and return a fresh connection from this Cache. Returns `nil` if
+  # the Cache is empty or if all existing connections have gone stale.
+  def pop
+    connections.synchronize do
+      evict
+      _, connection = connections.pop
+      connection
+    end
+  end
+
+  # Return a connection to this Cache.
+  def push(conn)
+    # No need to cache if the connection has already been closed.
+    return if closed?(conn)
+
+    connections.synchronize do
+      connections.push([Time.now + idle_timeout, conn])
+    end
+  end
+
+  # Close and remove any connections in this Cache that have been idle for
+  # too long.
+  def evict
+    # Peek at the first connection to see if it is still fresh. If so, we can
+    # return right away without needing to use `synchronize`.
+    first_expires_at, first_conn = connections.first
+    return if (first_expires_at.nil? || fresh?(first_expires_at)) && !closed?(first_conn)
+
+    connections.synchronize do
+      fresh, stale = connections.partition do |expires_at, conn|
+        fresh?(expires_at) && !closed?(conn)
+      end
+      connections.replace(fresh)
+      stale.each { |_, conn| closer.call(conn) }
+    end
+  end
+
+  # Close all connections and completely clear the cache.
+  def clear
+    connections.synchronize do
+      connections.map(&:last).each(&closer)
+      connections.clear
+    end
+  end
+
+  def same_key?(other_key)
+    key == other_key
+  end
+
+  protected
+
+  attr_reader :connections, :idle_timeout, :closer
+
+  private
+
+  def fresh?(expires_at)
+    expires_at > Time.now
+  end
+
+  def closed?(conn)
+    return true if conn.respond_to?(:closed?) && conn.closed?
+    # test if connection is alive
+    conn.process(0) if conn.respond_to?(:process)
+    return false
+  rescue IOError => e
+    # connection is closed by server
+    return true if e.message == 'closed stream'
+    raise
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/sshkit-1.21.5/lib/sshkit/backends/connection_pool/nil_cache.rb

@@ -0,0 +1,15 @@
+# A cache that holds no connections. Any connection provided to this cache
+# is simply closed.
+SSHKit::Backend::ConnectionPool::NilCache = Struct.new(:closer) do
+  def pop
+    nil
+  end
+
+  def push(conn)
+    closer.call(conn)
+  end
+
+  def same_key?(_key)
+    true
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/sshkit-1.21.5/lib/sshkit/backends/connection_pool.rb

@@ -0,0 +1,183 @@
+require "monitor"
+require "thread"
+
+# Since we call to_s on new connection arguments and use that as a cache key, we
+# need to make sure the memory address of the object is not used as part of the
+# key. Otherwise identical objects with different memory address won't reuse the
+# cache.
+#
+# In the case of proxy commands, this can lead to proxy processes leaking, and
+# in severe cases can cause deploys to fail due to default file descriptor
+# limits. An alternate solution would be to use a different means of generating
+# hash keys.
+#
+require "net/ssh/proxy/command"
+class Net::SSH::Proxy::Command
+  # Ensure a stable string value is used, rather than memory address.
+  def inspect
+    @command_line_template
+  end
+end
+
+# The ConnectionPool caches connections and allows them to be reused, so long as
+# the reuse happens within the `idle_timeout` period. Timed out connections are
+# eventually closed, forcing a new connection to be used in that case.
+#
+# Additionally, a background thread is started to check for abandoned
+# connections that have timed out without any attempt at being reused. These
+# are eventually closed as well and removed from the cache.
+#
+# If `idle_timeout` set to `false`, `0`, or `nil`, no caching is performed, and
+# a new connection is created and then immediately closed each time. The default
+# timeout is 30 (seconds).
+#
+# There is a single public method: `with`. Example usage:
+#
+#   pool = SSHKit::Backend::ConnectionPool.new
+#   pool.with(Net::SSH.method(:start), "host", "username") do |connection|
+#     # do stuff with connection
+#   end
+#
+class SSHKit::Backend::ConnectionPool
+  attr_accessor :idle_timeout
+
+  def initialize(idle_timeout=30)
+    @idle_timeout = idle_timeout
+    @caches = {}
+    @caches.extend(MonitorMixin)
+    @timed_out_connections = Queue.new
+
+    # Spin up eviction loop only if caching is enabled
+    if cache_enabled?
+      Thread.new { run_eviction_loop }
+    end
+  end
+
+  # Creates a new connection or reuses a cached connection (if possible) and
+  # yields the connection to the given block. Connections are created by
+  # invoking the `connection_factory` proc with the given `args`. The arguments
+  # are used to construct a key used for caching.
+  def with(connection_factory, *args)
+    cache = find_cache(args)
+    conn = cache.pop || begin
+      connection_factory.call(*args)
+    end
+    yield(conn)
+  ensure
+    cache.push(conn) unless conn.nil?
+    # Sometimes the args mutate as a result of opening a connection. In this
+    # case we need to update the cache key to match the new args.
+    update_key_if_args_changed(cache, args)
+  end
+
+  # Immediately remove all cached connections, without closing them. This only
+  # exists for unit test purposes.
+  def flush_connections
+    caches.synchronize { caches.clear }
+  end
+
+  # Immediately close all cached connections and empty the pool.
+  def close_connections
+    caches.synchronize do
+      caches.values.each(&:clear)
+      caches.clear
+      process_deferred_close
+    end
+  end
+
+  protected
+
+  attr_reader :caches, :timed_out_connections
+
+  private
+
+  def cache_key_for_connection_args(args)
+    args.hash
+  end
+
+  def cache_enabled?
+    idle_timeout && idle_timeout > 0
+  end
+
+  # Look up a Cache that matches the given connection arguments.
+  def find_cache(args)
+    if cache_enabled?
+      key = cache_key_for_connection_args(args)
+      caches[key] || thread_safe_find_or_create_cache(key)
+    else
+      NilCache.new(method(:silently_close_connection))
+    end
+  end
+
+  # Cache creation needs to happen in a mutex, because otherwise a race
+  # condition might cause two identical caches to be created for the same key.
+  def thread_safe_find_or_create_cache(key)
+    caches.synchronize do
+      caches[key] ||= begin
+        Cache.new(key, idle_timeout, method(:silently_close_connection_later))
+      end
+    end
+  end
+
+  # Update cache key with changed args to prevent cache miss
+  def update_key_if_args_changed(cache, args)
+    new_key = cache_key_for_connection_args(args)
+
+    caches.synchronize do
+      return if cache.same_key?(new_key)
+      caches[new_key] = caches.delete(cache.key)
+      cache.key = new_key
+    end
+  end
+
+  # Loops indefinitely to close connections and to find abandoned connections
+  # that need to be closed.
+  def run_eviction_loop
+    loop do
+      process_deferred_close
+
+      # Periodically sweep all Caches to evict stale connections
+      sleep(5)
+      caches.values.each(&:evict)
+    end
+  end
+
+  # Immediately close any connections that are pending closure.
+  # rubocop:disable Lint/HandleExceptions
+  def process_deferred_close
+    until timed_out_connections.empty?
+      connection = timed_out_connections.pop(true)
+      silently_close_connection(connection)
+    end
+  rescue ThreadError
+    # Queue#pop(true) raises ThreadError if the queue is empty.
+    # This could only happen if `close_connections` is called at the same time
+    # the background eviction thread has woken up to close connections. In any
+    # case, it is not something we need to care about, since an empty queue is
+    # perfectly OK.
+  end
+  # rubocop:enable Lint/HandleExceptions
+
+  # Adds the connection to a queue that is processed asynchronously by a
+  # background thread. The connection will eventually be closed.
+  def silently_close_connection_later(connection)
+    timed_out_connections << connection
+  end
+
+  # Close the given `connection` immediately, assuming it responds to a `close`
+  # method. If it doesn't, or if `nil` is provided, it is silently ignored. Any
+  # `StandardError` is also silently ignored. Returns `true` if the connection
+  # was closed; `false` if it was already closed or could not be closed due to
+  # an error.
+  def silently_close_connection(connection)
+    return false unless connection.respond_to?(:close)
+    return false if connection.respond_to?(:closed?) && connection.closed?
+    connection.close
+    true
+  rescue StandardError
+    false
+  end
+end
+
+require "sshkit/backends/connection_pool/cache"
+require "sshkit/backends/connection_pool/nil_cache"