Class: Bundler::Fetcher

Inherits:
Object
  • Object
show all
Defined in:
lib/bundler/fetcher.rb

Overview

Handles all the fetching with the rubygems server

Defined Under Namespace

Classes: AuthenticationRequiredError, BadAuthenticationError, CertificateFailureError, FallbackError, SSLError

Constant Summary

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.

[AuthenticationRequiredError, BadAuthenticationError]

Class Attribute Summary (collapse)

Class Method Summary (collapse)

Instance Method Summary (collapse)

Constructor Details

- (Fetcher) initialize(remote_uri)



93
94
95
96
97
98
99
100
101
102
103
104
# File 'lib/bundler/fetcher.rb', line 93

def initialize(remote_uri)
  @redirect_limit = 5  # How many redirects to allow in one request
  @api_timeout    = 10 # How long to wait for each API call
  @max_retries    = 3  # How many retries for the API call

  @remote_uri = Bundler::Source.mirror_for(remote_uri)
  @public_uri = @remote_uri.dup
  @public_uri.user, @public_uri.password = nil, nil # don't print these

  Socket.do_not_reverse_lookup = true
  connection # create persistent connection
end

Class Attribute Details

+ (Object) api_timeout

Returns the value of attribute api_timeout



52
53
54
# File 'lib/bundler/fetcher.rb', line 52

def api_timeout
  @api_timeout
end

+ (Object) disable_endpoint

Returns the value of attribute disable_endpoint



52
53
54
# File 'lib/bundler/fetcher.rb', line 52

def disable_endpoint
  @disable_endpoint
end

+ (Object) max_retries

Returns the value of attribute max_retries



52
53
54
# File 'lib/bundler/fetcher.rb', line 52

def max_retries
  @max_retries
end

+ (Object) redirect_limit

Returns the value of attribute redirect_limit



52
53
54
# File 'lib/bundler/fetcher.rb', line 52

def redirect_limit
  @redirect_limit
end

Class Method Details

+ (Object) download_gem_from_uri(spec, uri)



54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
# File 'lib/bundler/fetcher.rb', line 54

def download_gem_from_uri(spec, uri)
  spec.fetch_platform

  download_path = Bundler.requires_sudo? ? Bundler.tmp(spec.full_name) : Bundler.rubygems.gem_dir
  gem_path = "#{Bundler.rubygems.gem_dir}/cache/#{spec.full_name}.gem"

  FileUtils.mkdir_p("#{download_path}/cache")
  Bundler.rubygems.download_gem(spec, uri, download_path)

  if Bundler.requires_sudo?
    Bundler.mkdir_p "#{Bundler.rubygems.gem_dir}/cache"
    Bundler.sudo "mv #{Bundler.tmp(spec.full_name)}/cache/#{spec.full_name}.gem #{gem_path}"
  end

  gem_path
end

+ (Object) user_agent



71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
# File 'lib/bundler/fetcher.rb', line 71

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
    # add a random ID so we can consolidate runs server-side
    agent << " " << SecureRandom.hex(8)
  end
end

Instance Method Details

- (Object) connection



106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
# File 'lib/bundler/fetcher.rb', line 106

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 = @api_timeout
    con.override_headers["User-Agent"] = self.class.user_agent
    con
  end
end

- (Object) fetch_remote_specs(gem_names, full_dependency_list = [], last_spec_list = [])

fetch index



202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
# File 'lib/bundler/fetcher.rb', line 202

def fetch_remote_specs(gem_names, full_dependency_list = [], last_spec_list = [])
  query_list = gem_names - full_dependency_list

  # only display the message on the first run
  if Bundler.ui.debug?
    Bundler.ui.debug "Query List: #{query_list.inspect}"
  else
    Bundler.ui.info ".", false
  end

  return {@remote_uri => last_spec_list} if query_list.empty?

  remote_specs = Bundler::Retry.new("dependency api", AUTH_ERRORS).attempts do
    fetch_dependency_remote_specs(query_list)
  end

  spec_list, deps_list = remote_specs
  returned_gems = spec_list.map {|spec| spec.first }.uniq
  fetch_remote_specs(deps_list, full_dependency_list + returned_gems, spec_list + last_spec_list)
rescue HTTPError, MarshalError, GemspecError
  Bundler.ui.info "" unless Bundler.ui.debug? # new line now that the dots are over
  Bundler.ui.debug "could not fetch from the dependency API, trying the full index"
  @use_api = false
  return nil
end

- (Object) fetch_spec(spec)

fetch a gem specification



138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
# File 'lib/bundler/fetcher.rb', line 138

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

- (Object) gemspec_cached_path(spec_file_name)

cached gem specification path, if one exists



156
157
158
159
160
# File 'lib/bundler/fetcher.rb', line 156

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

- (Object) inspect



240
241
242
# File 'lib/bundler/fetcher.rb', line 240

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

- (Object) specs(gem_names, source)

return the specs in the bundler format as an index



163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
# File 'lib/bundler/fetcher.rb', line 163

def specs(gem_names, source)
  old = Bundler.rubygems.sources
  index = Index.new

  if gem_names && use_api
    specs = fetch_remote_specs(gem_names)
  end

  if specs.nil?
    # API errors mean we should treat this as a non-API source
    @use_api = false

    specs = Bundler::Retry.new("source fetch", AUTH_ERRORS).attempts do
      fetch_all_remote_specs
    end
  end

  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.source_uri = @remote_uri
    index << spec
  end

  index
rescue CertificateFailureError => e
  Bundler.ui.info "" if gem_names && use_api # newline after dots
  raise e
ensure
  Bundler.rubygems.sources = old
end

- (Object) uri



133
134
135
# File 'lib/bundler/fetcher.rb', line 133

def uri
  @public_uri
end

- (Object) use_api



228
229
230
231
232
233
234
235
236
237
238
# File 'lib/bundler/fetcher.rb', line 228

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

  if @remote_uri.scheme == "file" || Bundler::Fetcher.disable_endpoint
    @use_api = false
  elsif fetch(dependency_api_uri)
    @use_api = true
  end
rescue HTTPError
  @use_api = false
end