class Bundler::Fetcher

# File bundler/fetcher.rb, line 97
def initialize(remote)
  @cis = nil
  @remote = remote

  Socket.do_not_reverse_lookup = true
  connection # create persistent connection
end

# File bundler/fetcher.rb, line 204
def api_fetcher?
  fetchers.first.api_fetcher?
end

# File bundler/fetcher.rb, line 110
def fetch_spec(spec)
  spec -= [nil, "ruby", ""]
  spec_file_name = "#{spec.join "-"}.gemspec"

  uri = Gem::URI.parse("#{remote_uri}#{Gem::MARSHAL_SPEC_DIR}#{spec_file_name}.rz")
  spec = if uri.scheme == "file"
    path = Gem::Util.correct_for_windows_path(uri.path)
    Bundler.safe_load_marshal Bundler.rubygems.inflate(Gem.read_binary(path))
  elsif cached_spec_path = gemspec_cached_path(spec_file_name)
    Bundler.load_gemspec(cached_spec_path)
  else
    Bundler.safe_load_marshal Bundler.rubygems.inflate(downloader.fetch(uri).body)
  end
  raise MarshalError, "is #{spec.inspect}" unless spec.is_a?(Gem::Specification)
  spec
rescue MarshalError
  raise HTTPError, "Gemspec #{spec} contained invalid data.\n" \
    "Your network or your gem server is probably having issues right now."
end

# File bundler/fetcher.rb, line 208
def gem_remote_fetcher
  @gem_remote_fetcher ||= begin
    require_relative "fetcher/gem_remote_fetcher"
    fetcher = GemRemoteFetcher.new Gem.configuration[:http_proxy]
    fetcher.headers["User-Agent"] = user_agent
    fetcher.headers["X-Gemfile-Source"] = @remote.original_uri.to_s if @remote.original_uri
    fetcher
  end
end

# File bundler/fetcher.rb, line 195
def http_proxy
  return unless uri = connection.proxy_uri
  uri.to_s
end

# File bundler/fetcher.rb, line 200
def inspect
  "#<#{self.class}:0x#{object_id} uri=#{uri}>"
end

# File bundler/fetcher.rb, line 138
def specs(gem_names, source)
  index = Bundler::Index.new

  fetch_specs(gem_names).each do |name, version, platform, dependencies, metadata|
    spec = if dependencies
      EndpointSpecification.new(name, version, platform, self, dependencies, metadata).tap do |es|
        source.checksum_store.replace(es, es.checksum)
      end
    else
      RemoteSpecification.new(name, version, platform, self)
    end
    spec.source = source
    spec.remote = @remote
    index << spec
  end

  index
rescue CertificateFailureError
  Bundler.ui.info "" if gem_names && api_fetcher? # newline after dots
  raise
end

# File bundler/fetcher.rb, line 131
def specs_with_retry(gem_names, source)
  Bundler::Retry.new("fetcher", FAIL_ERRORS).attempts do
    specs(gem_names, source)
  end
end

# File bundler/fetcher.rb, line 105
def uri
  @remote.anonymized_uri
end

# File bundler/fetcher.rb, line 160
def user_agent
  @user_agent ||= begin
    ruby = Bundler::RubyVersion.system

    agent = String.new("bundler/#{Bundler::VERSION}")
    agent << " rubygems/#{Gem::VERSION}"
    agent << " ruby/#{ruby.versions_string(ruby.versions)}"
    agent << " (#{ruby.host})"
    agent << " command/#{ARGV.first}"

    if ruby.engine != "ruby"
      # engine_version raises on unknown engines
      engine_version = begin
                         ruby.engine_versions
                       rescue RuntimeError
                         "???"
                       end
      agent << " #{ruby.engine}/#{ruby.versions_string(engine_version)}"
    end

    agent << " options/#{Bundler.settings.all.join(",")}"

    agent << " ci/#{cis.join(",")}" if cis.any?

    # add a random ID so we can consolidate runs server-side
    agent << " " << Gem::SecureRandom.hex(8)

    # add any user agent strings set in the config
    extra_ua = Bundler.settings[:user_agent]
    agent << " " << extra_ua if extra_ua

    agent
  end
end

# File bundler/fetcher.rb, line 220
def available_fetchers
  if Bundler::Fetcher.disable_endpoint
    [Index]
  elsif remote_uri.scheme == "file"
    Bundler.ui.debug("Using a local server, bundler won't use the CompactIndex API")
    [Index]
  else
    [CompactIndex, Dependency, Index]
  end
end

# File bundler/fetcher.rb, line 297
def bundler_cert_store
  store = OpenSSL::X509::Store.new
  ssl_ca_cert = Bundler.settings[:ssl_ca_cert] ||
                (Gem.configuration.ssl_ca_cert if
                  Gem.configuration.respond_to?(:ssl_ca_cert))
  if ssl_ca_cert
    if File.directory? ssl_ca_cert
      store.add_path ssl_ca_cert
    else
      store.add_file ssl_ca_cert
    end
  else
    store.set_default_paths
    require "rubygems/request"
    Gem::Request.get_cert_files.each {|c| store.add_file c }
  end
  store
end

# File bundler/fetcher.rb, line 245
def cis
  @cis ||= Bundler::CIDetector.ci_strings
end

# File bundler/fetcher.rb, line 249
def connection
  @connection ||= begin
    needs_ssl = remote_uri.scheme == "https" ||
                Bundler.settings[:ssl_verify_mode] ||
                Bundler.settings[:ssl_client_cert]
    raise SSLError if needs_ssl && !defined?(OpenSSL::SSL)

    con = Gem::Net::HTTP::Persistent.new name: "bundler", proxy: :ENV
    if gem_proxy = Gem.configuration[:http_proxy]
      con.proxy = Gem::URI.parse(gem_proxy) if gem_proxy != :no_proxy
    end

    if remote_uri.scheme == "https"
      con.verify_mode = (Bundler.settings[:ssl_verify_mode] ||
        OpenSSL::SSL::VERIFY_PEER)
      con.cert_store = bundler_cert_store
    end

    ssl_client_cert = Bundler.settings[:ssl_client_cert] ||
                      (Gem.configuration.ssl_client_cert if
                        Gem.configuration.respond_to?(:ssl_client_cert))
    if ssl_client_cert
      pem = File.read(ssl_client_cert)
      con.cert = OpenSSL::X509::Certificate.new(pem)
      con.key  = OpenSSL::PKey::RSA.new(pem)
    end

    con.read_timeout = Fetcher.api_timeout
    con.open_timeout = Fetcher.api_timeout
    con.override_headers["User-Agent"] = user_agent
    con.override_headers["X-Gemfile-Source"] = @remote.original_uri.to_s if @remote.original_uri
    con
  end
end

# File bundler/fetcher.rb, line 320
def downloader
  @downloader ||= Downloader.new(connection, self.class.redirect_limit)
end

# File bundler/fetcher.rb, line 235
def fetch_specs(gem_names)
  fetchers.reject!(&:api_fetcher?) unless gem_names
  fetchers.reject! do |f|
    specs = f.specs(gem_names)
    return specs if specs
    true
  end
  []
end

# File bundler/fetcher.rb, line 231
def fetchers
  @fetchers ||= available_fetchers.map {|f| f.new(downloader, @remote, uri, gem_remote_fetcher) }.drop_while {|f| !f.available? }
end

# File bundler/fetcher.rb, line 285
def gemspec_cached_path(spec_file_name)
  paths = Bundler.rubygems.spec_cache_dirs.map {|dir| File.join(dir, spec_file_name) }
  paths.find {|path| File.file? path }
end

# File bundler/fetcher.rb, line 316
def remote_uri
  @remote.uri
end