honeybadger 4.5.3 → 4.5.4

data/vendor/bundle/ruby/2.6.0/gems/sshkit-1.18.2/lib/sshkit/backends/connection_pool/cache.rb

@@ -1,76 +0,0 @@
-# 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, _connection = connections.first
-    return if first_expires_at.nil? || fresh?(first_expires_at)
-
-    connections.synchronize do
-      fresh, stale = connections.partition do |expires_at, _|
-        fresh?(expires_at)
-      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)
-    conn.respond_to?(:closed?) && conn.closed?
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/sshkit-1.18.2/lib/sshkit/backends/connection_pool/nil_cache.rb

@@ -1,15 +0,0 @@
-# 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/2.6.0/gems/sshkit-1.18.2/lib/sshkit/backends/local.rb

@@ -1,66 +0,0 @@
-require 'open3'
-require 'fileutils'
-module SSHKit
-
-  module Backend
-
-    class Local < Abstract
-
-      def initialize(_ = nil, &block)
-        super(Host.new(:local), &block)
-      end
-
-      def upload!(local, remote, options = {})
-        remote = File.join(pwd_path, remote) unless remote.to_s.start_with?("/") || pwd_path.nil?
-        if local.is_a?(String)
-          if options[:recursive]
-            FileUtils.cp_r(local, remote)
-          else
-            FileUtils.cp(local, remote)
-          end
-        else
-          File.open(remote, "wb") do |f|
-            IO.copy_stream(local, f)
-          end
-        end
-      end
-
-      def download!(remote, local=nil, _options = {})
-        remote = File.join(pwd_path, remote) unless remote.to_s.start_with?("/") || pwd_path.nil?
-        if local.nil?
-          FileUtils.cp(remote, File.basename(remote))
-        else
-          File.open(remote, "rb") do |f|
-            IO.copy_stream(f, local)
-          end
-        end
-      end
-
-      private
-
-      def execute_command(cmd)
-        output.log_command_start(cmd.with_redaction)
-        cmd.started = Time.now
-        Open3.popen3(cmd.to_command) do |stdin, stdout, stderr, wait_thr|
-          stdout_thread = Thread.new do
-            while (line = stdout.gets) do
-              cmd.on_stdout(stdin, line)
-              output.log_command_data(cmd, :stdout, line)
-            end
-          end
-          stderr_thread = Thread.new do
-            while (line = stderr.gets) do
-              cmd.on_stderr(stdin, line)
-              output.log_command_data(cmd, :stderr, line)
-            end
-          end
-          stdout_thread.join
-          stderr_thread.join
-          cmd.exit_status = wait_thr.value.to_i
-          output.log_command_exit(cmd)
-        end
-      end
-
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/sshkit-1.18.2/lib/sshkit/backends/netssh.rb

@@ -1,188 +0,0 @@
-require 'English'
-require 'strscan'
-require 'mutex_m'
-require 'net/ssh'
-require 'net/scp'
-
-module Net
-  module SSH
-    class Config
-      class << self
-        remove_method :default_files
-
-        def default_files
-          @@default_files + [File.join(Dir.pwd, '.ssh/config')]
-        end
-      end
-    end
-  end
-end
-
-module SSHKit
-
-  module Backend
-
-    class Netssh < Abstract
-      class Configuration
-        attr_accessor :connection_timeout, :pty
-        attr_writer :ssh_options
-
-        def ssh_options
-          default_options.merge(@ssh_options ||= {})
-        end
-
-        private
-
-        if Net::SSH::VALID_OPTIONS.include?(:known_hosts)
-          def default_options
-            @default_options ||= {known_hosts: SSHKit::Backend::Netssh::KnownHosts.new}
-            assign_defaults
-          end
-        else
-          def default_options
-            @default_options ||= {}
-            assign_defaults
-          end
-        end
-
-        # Set default options early for ConnectionPool cache key
-        def assign_defaults
-          if Net::SSH.respond_to?(:assign_defaults)
-            Net::SSH.assign_defaults(@default_options)
-          else
-            # net-ssh < 4.0.0 doesn't have assign_defaults
-            unless @default_options.key?(:logger)
-              require 'logger'
-              @default_options[:logger] = ::Logger.new(STDERR)
-              @default_options[:logger].level = ::Logger::FATAL
-            end
-          end
-          @default_options
-        end
-      end
-
-      def upload!(local, remote, options = {})
-        summarizer = transfer_summarizer('Uploading', options)
-        remote = File.join(pwd_path, remote) unless remote.to_s.start_with?("/") || pwd_path.nil?
-        with_ssh do |ssh|
-          ssh.scp.upload!(local, remote, options, &summarizer)
-        end
-      end
-
-      def download!(remote, local=nil, options = {})
-        summarizer = transfer_summarizer('Downloading', options)
-        remote = File.join(pwd_path, remote) unless remote.to_s.start_with?("/") || pwd_path.nil?
-        with_ssh do |ssh|
-          ssh.scp.download!(remote, local, options, &summarizer)
-        end
-      end
-
-      # Note that this pool must be explicitly closed before Ruby exits to
-      # ensure the underlying IO objects are properly cleaned up. We register an
-      # at_exit handler to do this automatically, as long as Ruby is exiting
-      # cleanly (i.e. without an exception).
-      @pool = SSHKit::Backend::ConnectionPool.new
-      at_exit { @pool.close_connections if @pool && !$ERROR_INFO }
-
-      class << self
-        attr_accessor :pool
-
-        def configure
-          yield config
-        end
-
-        def config
-          @config ||= Configuration.new
-        end
-      end
-
-      private
-
-      def transfer_summarizer(action, options = {})
-        log_percent = options[:log_percent] || 10
-        log_percent = 100 if log_percent <= 0
-        last_name = nil
-        last_percentage = nil
-        proc do |_ch, name, transferred, total|
-          percentage = (transferred.to_f * 100 / total.to_f)
-          unless percentage.nan?
-            message = "#{action} #{name} #{percentage.round(2)}%"
-            percentage_r = (percentage / log_percent).truncate * log_percent
-            if percentage_r > 0 && (last_name != name || last_percentage != percentage_r)
-              info message
-              last_name = name
-              last_percentage = percentage_r
-            else
-              debug message
-            end
-          else
-            warn "Error calculating percentage #{transferred}/#{total}, " <<
-              "is #{name} empty?"
-          end
-        end
-      end
-
-      def execute_command(cmd)
-        output.log_command_start(cmd.with_redaction)
-        cmd.started = true
-        exit_status = nil
-        with_ssh do |ssh|
-          ssh.open_channel do |chan|
-            chan.request_pty if Netssh.config.pty
-            chan.exec cmd.to_command do |_ch, _success|
-              chan.on_data do |ch, data|
-                cmd.on_stdout(ch, data)
-                output.log_command_data(cmd, :stdout, data)
-              end
-              chan.on_extended_data do |ch, _type, data|
-                cmd.on_stderr(ch, data)
-                output.log_command_data(cmd, :stderr, data)
-              end
-              chan.on_request("exit-status") do |_ch, data|
-                exit_status = data.read_long
-              end
-              #chan.on_request("exit-signal") do |ch, data|
-              #  # TODO: This gets called if the program is killed by a signal
-              #  # might also be a worthwhile thing to report
-              #  exit_signal = data.read_string.to_i
-              #  warn ">>> " + exit_signal.inspect
-              #  output.log_command_killed(cmd, exit_signal)
-              #end
-              chan.on_open_failed do |_ch|
-                # TODO: What do do here?
-                # I think we should raise something
-              end
-              chan.on_process do |_ch|
-                # TODO: I don't know if this is useful
-              end
-              chan.on_eof do |_ch|
-                # TODO: chan sends EOF before the exit status has been
-                # writtend
-              end
-            end
-            chan.wait
-          end
-          ssh.loop
-        end
-        # Set exit_status and log the result upon completion
-        if exit_status
-          cmd.exit_status = exit_status
-          output.log_command_exit(cmd)
-        end
-      end
-
-      def with_ssh(&block)
-        host.ssh_options = self.class.config.ssh_options.merge(host.ssh_options || {})
-        self.class.pool.with(
-          Net::SSH.method(:start),
-          String(host.hostname),
-          host.username,
-          host.netssh_options,
-          &block
-        )
-      end
-
-    end
-  end
-
-end

data/vendor/bundle/ruby/2.6.0/gems/sshkit-1.18.2/lib/sshkit/backends/netssh/known_hosts.rb

@@ -1,143 +0,0 @@
-module SSHKit
-
-  module Backend
-
-    class Netssh < Abstract
-
-      class KnownHostsKeys
-        include Mutex_m
-
-        def initialize(path)
-          super()
-          @path = File.expand_path(path)
-          @hosts_keys = nil
-        end
-
-        def keys_for(hostlist)
-          keys, hashes = hosts_keys, hosts_hashes
-          parse_file unless keys && hashes
-          keys, hashes = hosts_keys, hosts_hashes
-
-          host_names = hostlist.split(',')
-
-          keys_found = host_names.map { |h| keys[h] || [] }.compact.inject(:&)
-          return keys_found unless keys_found.empty?
-
-          host_names.each do |host|
-            hashes.each do |(hmac, salt), hash_keys|
-              if OpenSSL::HMAC.digest(sha1, salt, host) == hmac
-                return hash_keys
-              end
-            end
-          end
-
-          []
-        end
-
-        private
-
-        attr_reader :path
-        attr_accessor :hosts_keys, :hosts_hashes
-
-        def sha1
-          @sha1 ||= OpenSSL::Digest.new('sha1')
-        end
-
-        def parse_file
-          synchronize do
-            return if hosts_keys && hosts_hashes
-
-            unless File.readable?(path)
-              self.hosts_keys = {}
-              self.hosts_hashes = []
-              return
-            end
-
-            new_keys = {}
-            new_hashes = []
-            File.open(path) do |file|
-              scanner = StringScanner.new("")
-              file.each_line do |line|
-                scanner.string = line
-                parse_line(scanner, new_keys, new_hashes)
-              end
-            end
-            self.hosts_keys = new_keys
-            self.hosts_hashes = new_hashes
-          end
-        end
-
-        def parse_line(scanner, hosts_keys, hosts_hashes)
-          return if empty_line?(scanner)
-
-          hostlist = parse_hostlist(scanner)
-          return unless supported_type?(scanner)
-          key = parse_key(scanner)
-
-          if hostlist.size == 1 && hostlist.first =~ /\A\|1(\|.+){2}\z/
-            hosts_hashes << [parse_host_hash(hostlist.first), key]
-          else
-            hostlist.each do |host|
-              (hosts_keys[host] ||= []) << key
-            end
-          end
-        end
-
-        def parse_host_hash(line)
-          _, _, salt, hmac = line.split('|')
-          [Base64.decode64(hmac), Base64.decode64(salt)]
-        end
-
-        def empty_line?(scanner)
-          scanner.skip(/\s*/)
-          scanner.match?(/$|#/)
-        end
-
-        def parse_hostlist(scanner)
-          scanner.skip(/\s*/)
-          scanner.scan(/\S+/).split(',')
-        end
-
-        def supported_type?(scanner)
-          scanner.skip(/\s*/)
-          Net::SSH::KnownHosts::SUPPORTED_TYPE.include?(scanner.scan(/\S+/))
-        end
-
-        def parse_key(scanner)
-          scanner.skip(/\s*/)
-          Net::SSH::Buffer.new(scanner.rest.unpack("m*").first).read_key
-        end
-      end
-
-      class KnownHosts
-        include Mutex_m
-
-        def initialize
-          super()
-          @files = {}
-        end
-
-        def search_for(host, options = {})
-          keys = ::Net::SSH::KnownHosts.hostfiles(options).map do |path|
-            known_hosts_file(path).keys_for(host)
-          end.flatten
-          ::Net::SSH::HostKeys.new(keys, host, self, options)
-        end
-
-        def add(*args)
-          ::Net::SSH::KnownHosts.add(*args)
-          synchronize { @files = {} }
-        end
-
-        private
-
-        def known_hosts_file(path)
-          @files[path] || synchronize { @files[path] ||= KnownHostsKeys.new(path) }
-        end
-      end
-
-    end
-
-  end
-
-end