class Bundler::ParallelInstaller - bundler-1.15.4 Documentation

# class Bundler::ParallelInstaller

### Attributes

size[R]

### Public Class Methods

call(*args) click to toggle source

    # File lib/bundler/installer/parallel_installer.rb, line 75
    def self.call(*args)
      new(*args).call
    end

max_threads() click to toggle source

Returns max number of threads machine can handle with a min of 1

    # File lib/bundler/installer/parallel_installer.rb, line 80
    def self.max_threads
      [Bundler.settings[:jobs].to_i - 1, 1].max
    end

new(installer, all_specs, size, standalone, force) click to toggle source

    # File lib/bundler/installer/parallel_installer.rb, line 86
    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
    end

### Public Instance Methods

call() click to toggle source

    # File lib/bundler/installer/parallel_installer.rb, line 95
    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
      enqueue_specs
      process_specs until @specs.all?(&:installed?) || @specs.any?(&:failed?)
      handle_error if @specs.any?(&:failed?)
      @specs
    ensure
      worker_pool && worker_pool.stop
    end

check_for_corrupt_lockfile() click to toggle source

    # File lib/bundler/installer/parallel_installer.rb, line 144
    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

enqueue_specs() click to toggle source

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.

    # File lib/bundler/installer/parallel_installer.rb, line 187
    def enqueue_specs
      @specs.select(&:ready_to_enqueue?).each do |spec|
        if spec.dependencies_installed? @specs
          spec.state = :enqueued
          worker_pool.enq spec
        end
      end
    end

handle_error() click to toggle source

    # File lib/bundler/installer/parallel_installer.rb, line 136
    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

process_specs() click to toggle source

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.

    # File lib/bundler/installer/parallel_installer.rb, line 130
    def process_specs
      spec = worker_pool.deq
      spec.state = :installed unless spec.failed?
      enqueue_specs
    end

require_tree_for_spec(spec) click to toggle source

    # File lib/bundler/installer/parallel_installer.rb, line 169
    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 << %Q( was resolved to #{s.version}, which depends on)
        end
        t << %Q(\n)
      end
      t
    end

worker_pool() click to toggle source

    # File lib/bundler/installer/parallel_installer.rb, line 109
    def worker_pool
      @worker_pool ||= Bundler::Worker.new @size, "Parallel Installer", lambda { |spec_install, worker_num|
        gem_installer = Bundler::GemInstaller.new(
          spec_install.spec, @installer, @standalone, worker_num, @force
        )
        success, message = gem_installer.install_from_spec
        if success && !message.nil?
          spec_install.post_install_message = message
        elsif !success
          spec_install.state = :failed
          spec_install.error = "#{message}\n\n#{require_tree_for_spec(spec_install.spec)}"
        end
        spec_install
      }
    end