vagrant-unbundled 2.2.18.0 → 2.2.19.0

data/vendor/bundle/ruby/3.0.0/gems/excon-0.89.0/lib/excon/constants.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+module Excon
+
+  CR_NL = "\r\n"
+
+  DEFAULT_CA_FILE = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "data", "cacert.pem"))
+
+  DEFAULT_CHUNK_SIZE = 1048576 # 1 megabyte
+
+  # avoid overwrite if somebody has redefined
+  unless const_defined?(:CHUNK_SIZE)
+    CHUNK_SIZE = DEFAULT_CHUNK_SIZE
+  end
+
+  DEFAULT_REDIRECT_LIMIT = 10
+
+  DEFAULT_RETRY_LIMIT = 4
+
+  DEFAULT_RETRY_ERRORS = [
+    Excon::Error::Timeout,
+    Excon::Error::Socket,
+    Excon::Error::HTTPStatus
+  ]
+
+  FORCE_ENC = CR_NL.respond_to?(:force_encoding)
+
+  HTTP_1_1 = " HTTP/1.1\r\n"
+
+  HTTP_VERBS = %w{connect delete get head options patch post put trace}
+
+  HTTPS = 'https'
+
+  NO_ENTITY = [204, 205, 304].freeze
+
+  REDACTED = 'REDACTED'
+
+  UNIX = 'unix'
+
+  USER_AGENT = "excon/#{VERSION}"
+
+  VERSIONS = "#{USER_AGENT} (#{RUBY_PLATFORM}) ruby/#{RUBY_VERSION}"
+
+  VALID_REQUEST_KEYS = [
+    :allow_unstubbed_requests,
+    :body,
+    :chunk_size,
+    :debug_request,
+    :debug_response,
+    :headers,
+    :instrumentor, # Used for setting logging within Connection
+    :logger,
+    :method,
+    :middlewares,
+    :password,
+    :path,
+    :persistent,
+    :pipeline,
+    :query,
+    :read_timeout,
+    :request_block,
+    :response_block,
+    :stubs,
+    :user,
+    :versions,
+    :write_timeout
+  ]
+
+  VALID_CONNECTION_KEYS = VALID_REQUEST_KEYS + [
+    :ciphers,
+    :client_key,
+    :client_key_data,
+    :client_key_pass,
+    :client_cert,
+    :client_cert_data,
+    :certificate,
+    :certificate_path,
+    :disable_proxy,
+    :private_key,
+    :private_key_path,
+    :connect_timeout,
+    :family,
+    :keepalive,
+    :host,
+    :hostname,
+    :omit_default_port,
+    :nonblock,
+    :reuseaddr,
+    :port,
+    :proxy,
+    :scheme,
+    :socket,
+    :ssl_ca_file,
+    :ssl_ca_path,
+    :ssl_cert_store,
+    :ssl_verify_callback,
+    :ssl_verify_peer,
+    :ssl_verify_peer_host,
+    :ssl_verify_hostname,
+    :ssl_version,
+    :ssl_min_version,
+    :ssl_max_version,
+    :ssl_security_level,
+    :ssl_proxy_headers,
+    :ssl_uri_schemes,
+    :tcp_nodelay,
+    :thread_safe_sockets,
+    :uri_parser,
+  ]
+
+  DEPRECATED_VALID_REQUEST_KEYS = {
+    :captures => 'Mock',
+    :expects => 'Expects',
+    :idempotent => 'Idempotent',
+    :instrumentor_name => 'Instrumentor',
+    :mock => 'Mock',
+    :retries_remaining => 'Idempotent', # referenced in Instrumentor, but only relevant with Idempotent
+    :retry_errors => 'Idempotent',
+    :retry_interval => 'Idempotent',
+    :retry_limit => 'Idempotent' # referenced in Instrumentor, but only relevant with Idempotent
+  }
+
+  unless ::IO.const_defined?(:WaitReadable)
+    class ::IO
+      module WaitReadable; end
+    end
+  end
+
+  unless ::IO.const_defined?(:WaitWritable)
+    class ::IO
+      module WaitWritable; end
+    end
+  end
+  # these come last as they rely on the above
+  DEFAULTS = {
+    :chunk_size           => CHUNK_SIZE || DEFAULT_CHUNK_SIZE,
+    # see https://wiki.mozilla.org/Security/Server_Side_TLS#Intermediate_compatibility_.28default.29
+    # list provided then had DES related things sorted to the end
+    :ciphers              => 'ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA:ECDHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA256:DHE-RSA-AES256-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA:ECDHE-ECDSA-DES-CBC3-SHA:ECDHE-RSA-DES-CBC3-SHA:EDH-RSA-DES-CBC3-SHA:DES-CBC3-SHA:!DSS',
+    :connect_timeout      => 60,
+    :debug_request        => false,
+    :debug_response       => false,
+    :headers              => {
+      'User-Agent' => USER_AGENT,
+      'Accept'     =>  '*/*'
+    },
+    :idempotent           => false,
+    :instrumentor_name    => 'excon',
+    :middlewares          => [
+      Excon::Middleware::ResponseParser,
+      Excon::Middleware::Expects,
+      Excon::Middleware::Idempotent,
+      Excon::Middleware::Instrumentor,
+      Excon::Middleware::Mock
+    ],
+    :mock                 => false,
+    :nonblock             => true,
+    :omit_default_port    => false,
+    :persistent           => false,
+    :read_timeout         => 60,
+    :retry_errors         => DEFAULT_RETRY_ERRORS,
+    :retry_limit          => DEFAULT_RETRY_LIMIT,
+    :ssl_verify_peer      => true,
+    :ssl_uri_schemes      => [HTTPS],
+    :stubs                => :global,
+    :tcp_nodelay          => false,
+    :thread_safe_sockets  => true,
+    :uri_parser           => URI,
+    :versions             => VERSIONS,
+    :write_timeout        => 60
+  }
+
+end

data/vendor/bundle/ruby/3.0.0/gems/excon-0.89.0/lib/excon/error.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+module Excon
+  # Excon exception classes
+  class Error < StandardError
+    @default_status_error = :HTTPStatus
+
+    class StubNotFound < Error; end
+    class InvalidStub < Error; end
+    class Warning < Error; end
+
+    # Socket related errors
+    class Socket < Error
+      attr_reader :socket_error
+
+      def initialize(socket_error = Excon::Error.new)
+        if is_a?(Certificate) || is_a?(Excon::Errors::CertificateError)
+          super
+        else
+          super("#{socket_error.message} (#{socket_error.class})")
+          set_backtrace(socket_error.backtrace)
+          @socket_error = socket_error
+        end
+      end
+    end
+
+    # Certificate related errors
+    class Certificate < Socket
+      def initialize(socket_error = Excon::Error.new)
+        msg = <<-EOL
+Unable to verify certificate. This may be an issue with the remote host or with Excon. Excon has certificates bundled, but these can be customized:
+
+            `Excon.defaults[:ssl_ca_path] = path_to_certs`
+            `ENV['SSL_CERT_DIR'] = path_to_certs`
+            `Excon.defaults[:ssl_ca_file] = path_to_file`
+            `ENV['SSL_CERT_FILE'] = path_to_file`
+            `Excon.defaults[:ssl_verify_callback] = callback`
+                (see OpenSSL::SSL::SSLContext#verify_callback)
+or:
+            `Excon.defaults[:ssl_verify_peer] = false` (less secure).
+        EOL
+        full_message = "#{socket_error.message} (#{socket_error.class})" +
+                       ' ' + msg
+        super(full_message)
+        set_backtrace(socket_error.backtrace)
+        @socket_error = socket_error
+      end
+    end
+
+    class InvalidHeaderKey < Error; end
+    class InvalidHeaderValue < Error; end
+    class Timeout < Error; end
+    class ResponseParse < Error; end
+
+    class ProxyConnectionError < Error
+      attr_reader :request, :response
+
+      def initialize(msg, request = nil, response = nil)
+        super(msg)
+        @request = request
+        @response = response
+      end
+    end
+
+    class ProxyParse < Error; end
+    class TooManyRedirects < Error; end
+
+    # Base class for HTTP Error classes
+    class HTTPStatus < Error
+      attr_reader :request, :response
+
+      def initialize(msg, request = nil, response = nil)
+        super(msg)
+        @request = request
+        @response = response
+      end
+    end
+
+    # HTTP Error classes
+    class Informational < HTTPStatus; end
+    class Success < HTTPStatus; end
+    class Redirection < HTTPStatus; end
+    class Client < HTTPStatus; end
+    class Server < HTTPStatus; end
+
+    class Continue < Informational; end                  # 100
+    class SwitchingProtocols < Informational; end        # 101
+    class OK < Success; end                              # 200
+    class Created < Success; end                         # 201
+    class Accepted < Success; end                        # 202
+    class NonAuthoritativeInformation < Success; end     # 203
+    class NoContent < Success; end                       # 204
+    class ResetContent < Success; end                    # 205
+    class PartialContent < Success; end                  # 206
+    class MultipleChoices < Redirection; end             # 300
+    class MovedPermanently < Redirection; end            # 301
+    class Found < Redirection; end                       # 302
+    class SeeOther < Redirection; end                    # 303
+    class NotModified < Redirection; end                 # 304
+    class UseProxy < Redirection; end                    # 305
+    class TemporaryRedirect < Redirection; end           # 307
+    class BadRequest < Client; end                       # 400
+    class Unauthorized < Client; end                     # 401
+    class PaymentRequired < Client; end                  # 402
+    class Forbidden < Client; end                        # 403
+    class NotFound < Client; end                         # 404
+    class MethodNotAllowed < Client; end                 # 405
+    class NotAcceptable < Client; end                    # 406
+    class ProxyAuthenticationRequired < Client; end      # 407
+    class RequestTimeout < Client; end                   # 408
+    class Conflict < Client; end                         # 409
+    class Gone < Client; end                             # 410
+    class LengthRequired < Client; end                   # 411
+    class PreconditionFailed < Client; end               # 412
+    class RequestEntityTooLarge < Client; end            # 413
+    class RequestURITooLong < Client; end                # 414
+    class UnsupportedMediaType < Client; end             # 415
+    class RequestedRangeNotSatisfiable < Client; end     # 416
+    class ExpectationFailed < Client; end                # 417
+    class UnprocessableEntity < Client; end              # 422
+    class TooManyRequests < Client; end                  # 429
+    class InternalServerError < Server; end              # 500
+    class NotImplemented < Server; end                   # 501
+    class BadGateway < Server; end                       # 502
+    class ServiceUnavailable < Server; end               # 503
+    class GatewayTimeout < Server; end                   # 504
+
+    def self.status_errors
+      @status_errors ||= {
+        100 => [Excon::Error::Continue, 'Continue'],
+        101 => [Excon::Error::SwitchingProtocols, 'Switching Protocols'],
+        200 => [Excon::Error::OK, 'OK'],
+        201 => [Excon::Error::Created, 'Created'],
+        202 => [Excon::Error::Accepted, 'Accepted'],
+        203 => [Excon::Error::NonAuthoritativeInformation, 'Non-Authoritative Information'],
+        204 => [Excon::Error::NoContent, 'No Content'],
+        205 => [Excon::Error::ResetContent, 'Reset Content'],
+        206 => [Excon::Error::PartialContent, 'Partial Content'],
+        300 => [Excon::Error::MultipleChoices, 'Multiple Choices'],
+        301 => [Excon::Error::MovedPermanently, 'Moved Permanently'],
+        302 => [Excon::Error::Found, 'Found'],
+        303 => [Excon::Error::SeeOther, 'See Other'],
+        304 => [Excon::Error::NotModified, 'Not Modified'],
+        305 => [Excon::Error::UseProxy, 'Use Proxy'],
+        307 => [Excon::Error::TemporaryRedirect, 'Temporary Redirect'],
+        400 => [Excon::Error::BadRequest, 'Bad Request'],
+        401 => [Excon::Error::Unauthorized, 'Unauthorized'],
+        402 => [Excon::Error::PaymentRequired, 'Payment Required'],
+        403 => [Excon::Error::Forbidden, 'Forbidden'],
+        404 => [Excon::Error::NotFound, 'Not Found'],
+        405 => [Excon::Error::MethodNotAllowed, 'Method Not Allowed'],
+        406 => [Excon::Error::NotAcceptable, 'Not Acceptable'],
+        407 => [Excon::Error::ProxyAuthenticationRequired, 'Proxy Authentication Required'],
+        408 => [Excon::Error::RequestTimeout, 'Request Timeout'],
+        409 => [Excon::Error::Conflict, 'Conflict'],
+        410 => [Excon::Error::Gone, 'Gone'],
+        411 => [Excon::Error::LengthRequired, 'Length Required'],
+        412 => [Excon::Error::PreconditionFailed, 'Precondition Failed'],
+        413 => [Excon::Error::RequestEntityTooLarge, 'Request Entity Too Large'],
+        414 => [Excon::Error::RequestURITooLong, 'Request-URI Too Long'],
+        415 => [Excon::Error::UnsupportedMediaType, 'Unsupported Media Type'],
+        416 => [Excon::Error::RequestedRangeNotSatisfiable, 'Request Range Not Satisfiable'],
+        417 => [Excon::Error::ExpectationFailed, 'Expectation Failed'],
+        422 => [Excon::Error::UnprocessableEntity, 'Unprocessable Entity'],
+        429 => [Excon::Error::TooManyRequests, 'Too Many Requests'],
+        500 => [Excon::Error::InternalServerError, 'InternalServerError'],
+        501 => [Excon::Error::NotImplemented, 'Not Implemented'],
+        502 => [Excon::Error::BadGateway, 'Bad Gateway'],
+        503 => [Excon::Error::ServiceUnavailable, 'Service Unavailable'],
+        504 => [Excon::Error::GatewayTimeout, 'Gateway Timeout']
+      }
+    end
+
+    # Messages for nicer exceptions, from rfc2616
+    def self.status_error(request, response)
+      error_class, error_message = status_errors[response[:status]]
+      if error_class.nil?
+        default_class = Excon::Error.const_get(@default_status_error)
+        error_class, error_message = [default_class, 'Unknown']
+      end
+      message = StringIO.new
+      str = "Expected(#{request[:expects].inspect}) <=>" +
+            " Actual(#{response[:status]} #{error_message})"
+      message.puts(str)
+      if request[:debug_request]
+        message.puts('excon.error.request')
+        Excon::PrettyPrinter.pp(message, request)
+      end
+
+      if request[:debug_response]
+        message.puts('excon.error.response')
+        Excon::PrettyPrinter.pp(message, response.data)
+      end
+      message.rewind
+      error_class.new(message.read, request, response)
+    end
+  end
+
+  # Legacy
+  module Errors
+    Excon::Errors::Error = Excon::Error
+
+    legacy_re = /
+      \A
+      Client
+      |Server
+      |Socket
+      |Certificate
+      |HTTPStatus
+      |InternalServer
+      \Z
+    /x
+
+    klasses = Excon::Error.constants.select do |c|
+      Excon::Error.const_get(c).is_a? Class
+    end
+
+    klasses.each do |klass|
+      class_name = klass.to_s
+      unless class_name =~ /Error\Z/
+        class_name = klass.to_s + 'Error' if class_name =~ legacy_re
+      end
+      Excon::Errors.const_set(class_name, Excon::Error.const_get(klass))
+    end
+
+    def self.status_error(request, response)
+      Excon::Error.status_error(request, response)
+    end
+  end
+end

data/vendor/bundle/ruby/3.0.0/gems/excon-0.89.0/lib/excon/extensions/uri.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+# TODO: Remove this monkey patch once ruby 1.9.3+ is the minimum supported version.
+#
+# This patch backports URI#hostname to ruby 1.9.2 and older.
+# URI#hostname is used for IPv6 support in Excon.
+#
+# URI#hostname was added in stdlib in v1_9_3_0 in this commit:
+#   https://github.com/ruby/ruby/commit/5fd45a4b79dd26f9e7b6dc41142912df911e4d7d
+#
+# Addressable::URI is also an URI parser accepted in some parts of Excon.
+# Addressable::URI#hostname was added in addressable-2.3.5+ in this commit:
+#   https://github.com/sporkmonger/addressable/commit/1b94abbec1f914d5f707c92a10efbb9e69aab65e
+#
+# Users who want to use Addressable::URI to parse URIs must upgrade to 2.3.5 or newer.
+require 'uri'
+unless URI("http://foo/bar").respond_to?(:hostname)
+  module URI
+    class Generic
+      # extract the host part of the URI and unwrap brackets for IPv6 addresses.
+      #
+      # This method is same as URI::Generic#host except
+      # brackets for IPv6 (and future IP) addresses are removed.
+      #
+      # u = URI("http://[::1]/bar")
+      # p u.hostname      #=> "::1"
+      # p u.host          #=> "[::1]"
+      #
+      def hostname
+        v = self.host
+        /\A\[(.*)\]\z/ =~ v ? $1 : v
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.0.0/gems/excon-0.89.0/lib/excon/headers.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+module Excon
+  class Headers < Hash
+
+    SENTINEL = {}
+
+    alias_method :raw_writer, :[]=
+    alias_method :raw_reader, :[]
+    if SENTINEL.respond_to?(:assoc)
+      alias_method :raw_assoc, :assoc
+    end
+    alias_method :raw_delete, :delete
+    alias_method :raw_fetch, :fetch
+    alias_method :raw_has_key?, :has_key?
+    alias_method :raw_include?, :include?
+    alias_method :raw_key?, :key?
+    alias_method :raw_member?, :member?
+    alias_method :raw_merge, :merge
+    alias_method :raw_merge!, :merge!
+    alias_method :raw_rehash, :rehash
+    alias_method :raw_store, :store
+    alias_method :raw_values_at, :values_at
+
+    def initialize
+      super
+      @downcased = {}
+    end
+
+    def [](key)
+      @downcased[key.to_s.downcase]
+    end
+
+    def []=(key, value)
+      raw_writer(key, value)
+      @downcased[key.to_s.downcase] = value
+    end
+    alias_method :store, :[]=
+
+    if SENTINEL.respond_to? :assoc
+      def assoc(obj)
+        @downcased.assoc(obj.downcase)
+      end
+    end
+
+    def delete(key, &proc)
+      raw_delete(key, &proc)
+      @downcased.delete(key.to_s.downcase, &proc)
+    end
+
+    def fetch(key, default = nil, &proc)
+      if proc
+        @downcased.fetch(key.to_s.downcase, &proc)
+      else
+        @downcased.fetch(key.to_s.downcase, default)
+      end
+    end
+
+    def has_key?(key)
+      raw_key?(key) || @downcased.has_key?(key.to_s.downcase)
+    end
+    alias_method :key?, :has_key?
+    alias_method :member?, :has_key?
+
+    def merge(other_hash)
+      self.dup.merge!(other_hash)
+    end
+
+    def merge!(other_hash)
+      other_hash.each do |key, value|
+        self[key] = value
+      end
+      raw_merge!(other_hash)
+    end
+
+    def rehash
+      @downcased.rehash
+      raw_rehash
+    end
+
+    def values_at(*keys)
+      @downcased.values_at(*keys.map {|key| key.to_s.downcase})
+    end
+
+  end
+end

data/vendor/bundle/ruby/3.0.0/gems/excon-0.89.0/lib/excon/instrumentors/logging_instrumentor.rb

@@ -0,0 +1,48 @@
+require 'logger'
+
+module Excon
+  class LoggingInstrumentor
+
+    def self.instrument(name, params = {})
+      params = params.dup
+
+      logger = params[:logger] || Logger.new($stderr)
+
+      # reduce duplication/noise of output
+      params.delete(:connection)
+      params.delete(:stack)
+
+      if params.has_key?(:headers) && params[:headers].has_key?('Authorization')
+        params[:headers] = params[:headers].dup
+        params[:headers]['Authorization'] = "REDACTED"
+      end
+
+      if params.has_key?(:password)
+        params[:password] = "REDACTED"
+      end
+
+      if name.include?('request')
+        info = "request: " + params[:scheme] + "://" + File.join(params[:host], params[:path])
+
+        if params[:query]
+          info << "?"
+
+          if params[:query].is_a?(Hash)
+            info << params[:query].to_a.map { |key,value| "#{key}=#{value}" }.join('&')
+          else
+            info << params[:query]
+          end
+        end
+      else
+        response_type = name.split('.').last
+        if params[:body]
+          info = "#{response_type}: " + params[:body]
+        end
+      end
+
+      logger.info(info) if info
+
+      yield if block_given?
+    end
+  end
+end

data/vendor/bundle/ruby/3.0.0/gems/excon-0.89.0/lib/excon/instrumentors/standard_instrumentor.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+module Excon
+  class StandardInstrumentor
+    def self.instrument(name, params = {})
+      params = params.dup
+
+      # reduce duplication/noise of output
+      params.delete(:connection)
+      params.delete(:stack)
+
+      params = Utils.redact(params)
+
+      $stderr.puts(name)
+      Excon::PrettyPrinter.pp($stderr, params)
+
+      if block_given?
+        yield
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.0.0/gems/excon-0.89.0/lib/excon/middlewares/base.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module Excon
+  module Middleware
+    class Base
+      # Returns the list of parameters that this middleware uses that are valid
+      # as arguments to `Connection#request` or `Connection#new`.
+      def self.valid_parameter_keys
+        []
+      end
+
+      def initialize(stack)
+        @stack = stack
+      end
+
+      def error_call(datum)
+        # do stuff
+        @stack.error_call(datum)
+      end
+
+      def request_call(datum)
+        # do stuff
+        @stack.request_call(datum)
+      end
+
+      def response_call(datum)
+        @stack.response_call(datum)
+        # do stuff
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.0.0/gems/excon-0.89.0/lib/excon/middlewares/capture_cookies.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module Excon
+  module Middleware
+    class CaptureCookies < Excon::Middleware::Base
+
+      def extract_cookies_from_set_cookie(set_cookie)
+        set_cookie.split(',').map { |full| full.split(';').first.strip }.join('; ')
+      end
+
+      def get_header(datum, header)
+        _, header_value = datum[:response][:headers].detect do |key, _|
+          key.casecmp(header) == 0
+        end
+        header_value
+      end
+
+      def response_call(datum)
+        cookie = get_header(datum, 'Set-Cookie')
+        if cookie
+          cookie = extract_cookies_from_set_cookie(cookie)
+          unless datum[:headers].key?("Cookie")
+            datum[:headers]["Cookie"] = cookie
+          else
+            original_cookies = datum[:headers]["Cookie"]
+            datum[:headers]["Cookie"] = original_cookies.empty? ? cookie : [original_cookies,cookie].join('; ')
+          end
+        end
+        super(datum)
+      end
+    end
+  end
+end