class Bundler::Fetcher

Handles all the fetching with the rubygems server

Constants

FAIL_ERRORS
FETCHERS
HTTP_ERRORS
NET_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.

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 81
def initialize(remote)
  @remote = remote

  Socket.do_not_reverse_lookup = true
  connection # create persistent connection
end

Public Instance Methods

bundler_cert_store() click to toggle source
# File lib/bundler/fetcher.rb, line 283
def bundler_cert_store
  store = OpenSSL::X509::Store.new
  ssl_ca_cert = Bundler.settings[:ssl_ca_cert] ||
    (Bundler.rubygems.configuration.ssl_ca_cert if
      Bundler.rubygems.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
    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 219
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, _| ENV[env] }.map {|_, ci| ci }
end
connection() click to toggle source
# File lib/bundler/fetcher.rb, line 234
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 = PersistentHTTP.new "bundler", :ENV
    if gem_proxy = Bundler.rubygems.configuration[:http_proxy]
      con.proxy = 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] ||
      (Bundler.rubygems.configuration.ssl_client_cert if
        Bundler.rubygems.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
downloader() click to toggle source
# File lib/bundler/fetcher.rb, line 308
def downloader
  @downloader ||= Downloader.new(connection, self.class.redirect_limit)
end
fetch_spec(spec) click to toggle source

fetch a gem specification

# File lib/bundler/fetcher.rb, line 93
def fetch_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 Bundler.rubygems.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 Bundler.rubygems.inflate(downloader.fetch(uri).body)
  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 202
def fetchers
  @fetchers ||= FETCHERS.map {|f| f.new(downloader, @remote, uri) }
end
gemspec_cached_path(spec_file_name) click to toggle source

cached gem specification path, if one exists

# File lib/bundler/fetcher.rb, line 270
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
http_proxy() click to toggle source
# File lib/bundler/fetcher.rb, line 206
  def http_proxy
    return unless uri = connection.proxy_uri
    uri.to_s
  end

  def inspect
    "#<#{self.class}:0x#{object_id} uri=#{uri}>"
  end

private

  FETCHERS = [CompactIndex, Dependency, Index].freeze

  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, _| ENV[env] }.map {|_, ci| ci }
  end

  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 = PersistentHTTP.new "bundler", :ENV
      if gem_proxy = Bundler.rubygems.configuration[:http_proxy]
        con.proxy = 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] ||
        (Bundler.rubygems.configuration.ssl_client_cert if
          Bundler.rubygems.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

  # cached gem specification path, if one exists
  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

  HTTP_ERRORS = [
    Timeout::Error, EOFError, SocketError, Errno::ENETDOWN, Errno::ENETUNREACH,
    Errno::EINVAL, Errno::ECONNRESET, Errno::ETIMEDOUT, Errno::EAGAIN,
    Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError,
    PersistentHTTP::Error, Zlib::BufError, Errno::EHOSTUNREACH
  ].freeze

  def bundler_cert_store
    store = OpenSSL::X509::Store.new
    ssl_ca_cert = Bundler.settings[:ssl_ca_cert] ||
      (Bundler.rubygems.configuration.ssl_ca_cert if
        Bundler.rubygems.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
      certs = File.expand_path("../ssl_certs/*/*.pem", __FILE__)
      Dir.glob(certs).each {|c| store.add_file c }
    end
    store
  end

private

  def remote_uri
    @remote.uri
  end

  def downloader
    @downloader ||= Downloader.new(connection, self.class.redirect_limit)
  end
end
inspect() click to toggle source
# File lib/bundler/fetcher.rb, line 211
def inspect
  "#<#{self.class}:0x#{object_id} uri=#{uri}>"
end
remote_uri() click to toggle source
# File lib/bundler/fetcher.rb, line 304
def remote_uri
  @remote.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 118
    def specs(gem_names, source)
      old = Bundler.rubygems.sources
      index = Bundler::Index.new

      if Bundler::Fetcher.disable_endpoint
        @use_api = false
        specs = fetchers.last.specs(gem_names)
      else
        specs = []
        fetchers.shift until fetchers.first.available? || fetchers.empty?
        fetchers.dup.each do |f|
          break unless f.api_fetcher? && !gem_names || !specs = f.specs(gem_names)
          fetchers.delete(f)
        end
        @use_api = false if fetchers.none?(&:api_fetcher?)
      end

      specs.each do |name, version, platform, dependencies, metadata|
        next if name == "bundler"
        spec = if dependencies
          EndpointSpecification.new(name, version, platform, dependencies, metadata)
        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 && use_api # newline after dots
      raise
    ensure
      Bundler.rubygems.sources = old
    end

    def use_api
      return @use_api if defined?(@use_api)

      fetchers.shift until fetchers.first.available?

      @use_api = if remote_uri.scheme == "file" || Bundler::Fetcher.disable_endpoint
        false
      else
        fetchers.first.api_fetcher?
      end
    end

    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 << " " << 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

    def fetchers
      @fetchers ||= FETCHERS.map {|f| f.new(downloader, @remote, uri) }
    end

    def http_proxy
      return unless uri = connection.proxy_uri
      uri.to_s
    end

    def inspect
      "#<#{self.class}:0x#{object_id} uri=#{uri}>"
    end

  private

    FETCHERS = [CompactIndex, Dependency, Index].freeze

    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, _| ENV[env] }.map {|_, ci| ci }
    end

    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 = PersistentHTTP.new "bundler", :ENV
        if gem_proxy = Bundler.rubygems.configuration[:http_proxy]
          con.proxy = 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] ||
          (Bundler.rubygems.configuration.ssl_client_cert if
            Bundler.rubygems.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

    # cached gem specification path, if one exists
    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

    HTTP_ERRORS = [
      Timeout::Error, EOFError, SocketError, Errno::ENETDOWN, Errno::ENETUNREACH,
      Errno::EINVAL, Errno::ECONNRESET, Errno::ETIMEDOUT, Errno::EAGAIN,
      Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError,
      PersistentHTTP::Error, Zlib::BufError, Errno::EHOSTUNREACH
    ].freeze

    def bundler_cert_store
      store = OpenSSL::X509::Store.new
      ssl_ca_cert = Bundler.settings[:ssl_ca_cert] ||
        (Bundler.rubygems.configuration.ssl_ca_cert if
          Bundler.rubygems.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
        certs = File.expand_path("../ssl_certs/*/*.pem", __FILE__)
        Dir.glob(certs).each {|c| store.add_file c }
      end
      store
    end

  private

    def remote_uri
      @remote.uri
    end

    def downloader
      @downloader ||= Downloader.new(connection, self.class.redirect_limit)
    end
  end
end
specs_with_retry(gem_names, source) click to toggle source

return the specs in the bundler format as an index with retries

# File lib/bundler/fetcher.rb, line 111
def specs_with_retry(gem_names, source)
  Bundler::Retry.new("fetcher", FAIL_ERRORS).attempts do
    specs(gem_names, source)
  end
end
uri() click to toggle source
# File lib/bundler/fetcher.rb, line 88
def uri
  @remote.anonymized_uri
end
use_api() click to toggle source
# File lib/bundler/fetcher.rb, line 155
def use_api
  return @use_api if defined?(@use_api)

  fetchers.shift until fetchers.first.available?

  @use_api = if remote_uri.scheme == "file" || Bundler::Fetcher.disable_endpoint
    false
  else
    fetchers.first.api_fetcher?
  end
end
user_agent() click to toggle source
# File lib/bundler/fetcher.rb, line 167
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 << " " << 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