123456789_123456789_123456789_123456789_123456789_

Class: Bundler::ParallelInstaller

Relationships & Source Files
Namespace Children
Classes:
Inherits: Object
Defined in: lib/bundler/installer/parallel_installer.rb

Class Method Summary

Instance Attribute Summary

Instance Method Summary

Constructor Details

.new(installer, all_specs, size, standalone, force) ⇒ ParallelInstaller

[ GitHub ]

  
# File 'lib/bundler/installer/parallel_installer.rb', line 83

def initialize(installer, all_specs, size, standalone, force)
  @installer = installer
  @size = size
  @standalone = standalone
  @force = force
  @specs = all_specs.map {|s| SpecInstallation.new(s) }
  @spec_set = all_specs
  @rake = @specs.find {|s| s.name == "rake" }
end

Class Method Details

.call(*args)

[ GitHub ]

  
# File 'lib/bundler/installer/parallel_installer.rb', line 77

def self.call(*args)
  new(*args).call
end

Instance Attribute Details

#finished_installing?Boolean (readonly, private)

[ GitHub ]

  
# File 'lib/bundler/installer/parallel_installer.rb', line 189

def finished_installing?
  @specs.all? do |spec|
    return true if spec.failed?
    spec.installed?
  end
end

#size (readonly)

[ GitHub ]

  
# File 'lib/bundler/installer/parallel_installer.rb', line 81

attr_reader :size

Instance Method Details

#call

[ GitHub ]

  
# File 'lib/bundler/installer/parallel_installer.rb', line 93

def call
  # Since `autoload` has the potential for threading issues on 1.8.7
  # TODO:  remove in bundler 2.0
  require "bundler/gem_remote_fetcher" if RUBY_VERSION < "1.9"

  check_for_corrupt_lockfile

  if @size > 1
    install_with_worker
  else
    install_serially
  end

  handle_error if @specs.any?(&:failed?)
  @specs
ensure
  worker_pool && worker_pool.stop
end

#check_for_corrupt_lockfile

[ GitHub ]

  
# File 'lib/bundler/installer/parallel_installer.rb', line 112

def check_for_corrupt_lockfile
  missing_dependencies = @specs.map do |s|
    [
      s,
      s.missing_lockfile_dependencies(@specs.map(&:name)),
    ]
  end.reject { |a| a.last.empty? }
  return if missing_dependencies.empty?

  warning = []
  warning << "Your lockfile was created by an old Bundler that left some things out."
  if @size != 1
    warning << "Because of the missing DEPENDENCIES, we can only install gems one at a time, instead of installing #{@size} at a time."
    @size = 1
  end
  warning << "You can fix this by adding the missing gems to your Gemfile, running bundle install, and then removing the gems from your Gemfile."
  warning << "The missing gems are:"

  missing_dependencies.each do |spec, missing|
    warning << "* #{missing.map(&:name).join(", ")} depended upon by #{spec.name}"
  end

  Bundler.ui.warn(warning.join("\n"))
end

#do_install(spec_install, worker_num) (private)

[ GitHub ]

  
# File 'lib/bundler/installer/parallel_installer.rb', line 158

def do_install(spec_install, worker_num)
  Plugin.hook(Plugin::Events::GEM_BEFORE_INSTALL, spec_install)
  gem_installer = Bundler::GemInstaller.new(
    spec_install.spec, @installer, @standalone, worker_num, @force
  )
  success, message = begin
    gem_installer.install_from_spec
  rescue RuntimeError => e
    raise e, "#{e}\n\n#{require_tree_for_spec(spec_install.spec)}"
  end
  if success
    spec_install.state = :installed
    spec_install.post_install_message = message unless message.nil?
  else
    spec_install.state = :failed
    spec_install.error = "#{message}\n\n#{require_tree_for_spec(spec_install.spec)}"
  end
  Plugin.hook(Plugin::Events::GEM_AFTER_INSTALL, spec_install)
  spec_install
end

#enqueue_specs (private)

Keys in the remains hash represent uninstalled gems specs. We enqueue all gem specs that do not have any dependencies. Later we call this lambda again to install specs that depended on previously installed specifications. We continue until all specs are installed.

[ GitHub ]

  
# File 'lib/bundler/installer/parallel_installer.rb', line 222

def enqueue_specs
  @specs.select(&:ready_to_enqueue?).each do |spec|
    next if @rake && !@rake.installed? && spec.name != @rake.name

    if spec.dependencies_installed? @specs
      spec.state = :enqueued
      worker_pool.enq spec
    end
  end
end

#handle_error (private)

[ GitHub ]

  
# File 'lib/bundler/installer/parallel_installer.rb', line 196

def handle_error
  errors = @specs.select(&:failed?).map(&:error)
  if exception = errors.find {|e| e.is_a?(Bundler::BundlerError) }
    raise exception
  end
  raise Bundler::InstallError, errors.map(&:to_s).join("\n\n")
end

#install_serially (private)

[ GitHub ]

  
# File 'lib/bundler/installer/parallel_installer.rb', line 144

def install_serially
  until finished_installing?
    raise "failed to find a spec to enqueue while installing serially" unless spec_install = @specs.find(&:ready_to_enqueue?)
    spec_install.state = :enqueued
    do_install(spec_install, 0)
  end
end

#install_with_worker (private)

[ GitHub ]

  
# File 'lib/bundler/installer/parallel_installer.rb', line 139

def install_with_worker
  enqueue_specs
  process_specs until finished_installing?
end

#process_specs (private)

Dequeue a spec and save its post-install message and then enqueue the remaining specs. Some specs might’ve had to wait til this spec was installed to be processed so the call to #enqueue_specs is important after every dequeue.

[ GitHub ]

  
# File 'lib/bundler/installer/parallel_installer.rb', line 184

def process_specs
  worker_pool.deq
  enqueue_specs
end

#require_tree_for_spec(spec) (private)

[ GitHub ]

  
# File 'lib/bundler/installer/parallel_installer.rb', line 204

def require_tree_for_spec(spec)
  tree = @spec_set.what_required(spec)
  t = String.new("In #{File.basename(SharedHelpers.default_gemfile)}:\n")
  tree.each_with_index do |s, depth|
    t << "  " * depth.succ << s.name
    unless tree.last == s
      t << %( was resolved to #{s.version}, which depends on)
    end
    t << %(\n)
  end
  t
end

#worker_pool (private)

[ GitHub ]

  
# File 'lib/bundler/installer/parallel_installer.rb', line 152

def worker_pool
  @worker_pool ||= Bundler::Worker.new @size, "Parallel Installer", lambda { |spec_install, worker_num|
    do_install(spec_install, worker_num)
  }
end