class Bundler::Fetcher

Handles all the fetching with the rubygems server

Constants

AUTH_ERRORS

Exceptions classes that should bypass retry attempts. If your password didn't work the first time, it's not going to the third time.

FETCHERS
HTTP_ERRORS

Attributes

api_timeout[RW]
disable_endpoint[RW]
max_retries[RW]
redirect_limit[RW]

Public Class Methods

new(remote) click to toggle source
# File lib/bundler/fetcher.rb, line 65
def initialize(remote)
  @remote = remote

  Socket.do_not_reverse_lookup = true
  connection # create persistent connection
end

Public Instance Methods

fetch_spec(spec) click to toggle source

fetch a gem specification

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

  uri = URI.parse("#{remote_uri}#{Gem::MARSHAL_SPEC_DIR}#{spec_file_name}.rz")
  if uri.scheme == 'file'
    Bundler.load_marshal Gem.inflate(Gem.read_binary(uri.path))
  elsif cached_spec_path = gemspec_cached_path(spec_file_name)
    Bundler.load_gemspec(cached_spec_path)
  else
    Bundler.load_marshal Gem.inflate(downloader.fetch uri)
  end
rescue MarshalError
  raise HTTPError, "Gemspec #{spec} contained invalid data.\n"          "Your network or your gem server is probably having issues right now."
end
fetchers() click to toggle source
# File lib/bundler/fetcher.rb, line 171
def fetchers
  @fetchers ||= FETCHERS.map { |f| f.new(downloader, remote_uri, fetch_uri, uri) }
end
inspect() click to toggle source
# File lib/bundler/fetcher.rb, line 175
def inspect
  "#<#{self.class}:0x#{object_id} uri=#{uri}>"
end
specs(gem_names, source) click to toggle source

return the specs in the bundler format as an index

# File lib/bundler/fetcher.rb, line 95
def specs(gem_names, source)
  old = Bundler.rubygems.sources
  index = Bundler::Index.new

  specs = {}
  fetchers.dup.each do |f|
    unless f.api_fetcher? && !gem_names
      break if specs = f.specs(gem_names)
    end
    fetchers.delete(f)
  end
  @use_api = false if fetchers.none?(&:api_fetcher?)

  specs[remote_uri].each do |name, version, platform, dependencies|
    next if name == 'bundler'
    spec = nil
    if dependencies
      spec = EndpointSpecification.new(name, version, platform, dependencies)
    else
      spec = 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 && use_api # newline after dots
  raise
ensure
  Bundler.rubygems.sources = old
end
uri() click to toggle source
# File lib/bundler/fetcher.rb, line 72
def uri
  @remote.anonymized_uri
end
use_api() click to toggle source
# File lib/bundler/fetcher.rb, line 129
def use_api
  return @use_api if defined?(@use_api)

  if remote_uri.scheme == "file" || Bundler::Fetcher.disable_endpoint
    @use_api = false
  else
    fetchers.reject! { |f| f.api_fetcher? && !f.api_available? }
    @use_api = fetchers.any?(&:api_fetcher?)
  end
end
user_agent() click to toggle source
# File lib/bundler/fetcher.rb, line 140
def user_agent
  @user_agent ||= begin
    ruby = Bundler.ruby_version

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

    if ruby.engine != "ruby"
      # engine_version raises on unknown engines
      engine_version = ruby.engine_version rescue "???"
      agent << " #{ruby.engine}/#{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 << " " << 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

Private Instance Methods

bundler_cert_store() click to toggle source
# File lib/bundler/fetcher.rb, line 239
def bundler_cert_store
  store = OpenSSL::X509::Store.new
  if Bundler.settings[:ssl_ca_cert]
    if File.directory? Bundler.settings[:ssl_ca_cert]
      store.add_path Bundler.settings[:ssl_ca_cert]
    else
      store.add_file Bundler.settings[:ssl_ca_cert]
    end
  else
    store.set_default_paths
    certs = File.expand_path("../ssl_certs/*.pem", __FILE__)
    Dir.glob(certs).each { |c| store.add_file c }
  end
  store
end
cis() click to toggle source
# File lib/bundler/fetcher.rb, line 183
def cis
  env_cis = {
    "TRAVIS" => "travis",
    "CIRCLECI" => "circle",
    "SEMAPHORE" => "semaphore",
    "JENKINS_URL" => "jenkins",
    "BUILDBOX" => "buildbox",
    "GO_SERVER_URL" => "go",
    "SNAP_CI" => "snap",
    "CI_NAME" => ENV["CI_NAME"],
    "CI" => "ci"
  }
  env_cis.find_all{ |env, ci| ENV[env]}.map{ |env, ci| ci }
end
connection() click to toggle source
# File lib/bundler/fetcher.rb, line 198
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 = Net::HTTP::Persistent.new 'bundler', :ENV

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

    if Bundler.settings[:ssl_client_cert]
      pem = File.read(Bundler.settings[: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.override_headers["User-Agent"] = user_agent
    con
  end
end
downloader() click to toggle source
# File lib/bundler/fetcher.rb, line 273
def downloader
  @downloader ||= Downloader.new(connection, self.class.redirect_limit)
end
fetch_uri() click to toggle source
# File lib/bundler/fetcher.rb, line 257
def fetch_uri
  @fetch_uri ||= begin
    if remote_uri.host == "rubygems.org"
      uri = remote_uri.dup
      uri.host = "bundler.rubygems.org"
      uri
    else
      remote_uri
    end
  end
end
gemspec_cached_path(spec_file_name) click to toggle source

cached gem specification path, if one exists

# File lib/bundler/fetcher.rb, line 226
def gemspec_cached_path spec_file_name
  paths = Bundler.rubygems.spec_cache_dirs.map { |dir| File.join(dir, spec_file_name) }
  paths = paths.select {|path| File.file? path }
  paths.first
end
remote_uri() click to toggle source
# File lib/bundler/fetcher.rb, line 269
def remote_uri
  @remote.uri
end