class Bundler::Fetcher - bundler: Ruby Standard Library Documentation

# class Bundler::Fetcher

Handles all the fetching with the rubygems server

### Constants

FAIL_ERRORS
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 bundler/fetcher.rb, line 98
    def initialize(remote)
      @cis = nil
      @remote = remote

      Socket.do_not_reverse_lookup = true
      connection # create persistent connection
    end

### Public Instance Methods

api_fetcher?() click to toggle source

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

fetch_spec(spec) click to toggle source

fetch a gem specification

    # File bundler/fetcher.rb, line 111
    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

gem_remote_fetcher() click to toggle source

    # File bundler/fetcher.rb, line 209
    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

http_proxy() click to toggle source

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

inspect() click to toggle source

    # File bundler/fetcher.rb, line 201
    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 bundler/fetcher.rb, line 139
    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

specs_with_retry(gem_names, source) click to toggle source

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

    # File bundler/fetcher.rb, line 132
    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 bundler/fetcher.rb, line 106
    def uri
      @remote.anonymized_uri
    end

user_agent() click to toggle source

    # File bundler/fetcher.rb, line 161
    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

### Private Instance Methods

available_fetchers() click to toggle source

    # File bundler/fetcher.rb, line 221
    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

bundler_cert_store() click to toggle source

    # File bundler/fetcher.rb, line 304
    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

cis() click to toggle source

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

connection() click to toggle source

    # File bundler/fetcher.rb, line 250
    def connection
      @connection ||= begin
        needs_ssl = remote_uri.scheme == "https" ||
                    Bundler.settings[:ssl_verify_mode] ||
                    Bundler.settings[:ssl_client_cert]
        if needs_ssl
          begin
            require "openssl"
          rescue StandardError, LoadError => e
            raise SSLError.new(e.message)
          end
        end

        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

downloader() click to toggle source

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

fetch_specs(gem_names) click to toggle source

    # File bundler/fetcher.rb, line 236
    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

fetchers() click to toggle source

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

gemspec_cached_path(spec_file_name) click to toggle source

cached gem specification path, if one exists

    # File bundler/fetcher.rb, line 292
    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

remote_uri() click to toggle source

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