123456789_123456789_123456789_123456789_123456789_

Class: Bundler::ParallelInstaller

Relationships & Source Files
Namespace Children
Classes:
SpecInstallation
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, local: false, skip: nil) ⇒ ParallelInstaller

[ GitHub ] 

  


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



def initialize(installer, all_specs, size, standalone, force, local: false, skip: nil)
  @installer = installer
  @size = size
  @standalone = standalone
  @force = force
  @local = local
  @specs = all_specs.map {|s| SpecInstallation.new(s) }
  specs_by_name = @specs.to_h {|s| [s.name, s] }
  @specs.each do |spec_install|
    spec_install.dependencies = spec_install.spec.dependencies.filter_map do |dep|
      specs_by_name[dep.name] unless dep.type == :development || dep.name == spec_install.name
    end
  end
  @specs.each do |spec_install|
    spec_install.state = :installed if skip.include?(spec_install.name)
  end if skip
  @spec_set = all_specs
  @rake = @specs.find {|s| s.name == "rake" unless s.installed? }
end


  







Class Method Details



  

    .call(*args, **kwargs)  
  

  [ GitHub ]


  

  


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



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


  







Instance Attribute Details



  

    #finished_installing?  ⇒ Boolean  (readonly, private)
  

  [ GitHub ]


  

  


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



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 65



attr_reader :size


  







Instance Method Details



  

    #call  
  

  [ GitHub ]


  

  


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



def call
  if @rake
    do_download(@rake, 0)
    do_install(@rake, 0)
    Gem::Specification.reset
  end

  if @size > 1
    install_with_worker
  else
    install_serially
  end

  handle_error if failed_specs.any?
  @specs
ensure
  worker_pool&.stop
end


  








  

    #do_download(spec_install, worker_num)   (private)
  

  [ GitHub ]


  

  


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



def do_download(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, @local
  )

  success, message = gem_installer.download

  if success
    spec_install.state = :downloaded
  else
    spec_install.error = "#{message}\n\n#{require_tree_for_spec(spec_install.spec)}"
    spec_install.state = :failed
  end

  spec_install
end


  








  

    #do_install(spec_install, worker_num)   (private)
  

  [ GitHub ]


  

  


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



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


  








  

    #enqueue_specs(installed_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 229



def enqueue_specs(installed_specs)
  @specs.each do |spec|
    if spec.installed?
      installed_specs[spec.name] = true
      next
    end

    spec.state = :enqueued
    worker_pool.enq spec
  end
end


  








  

    #failed_specs   (private)
  

  [ GitHub ]


  

  


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



def failed_specs
  @specs.select(&:failed?)
end


  








  

    #handle_error   (private)
  



  

    
  





  
Raises:





  [ GitHub ]


  

  


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



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


  








  

    #install_serially   (private)
  

  [ GitHub ]


  

  


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



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_download(spec_install, 0)
    do_install(spec_install, 0)
  end
end


  








  

    #install_with_worker   (private)
  

  [ GitHub ]


  

  


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



def install_with_worker
  installed_specs = {}
  enqueue_specs(installed_specs)

  process_specs(installed_specs) until finished_installing?
end


  








  

    #process_specs(installed_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 181



def process_specs(installed_specs)
  spec = worker_pool.deq

  if spec.installed?
    installed_specs[spec.name] = true
    return
  elsif spec.failed?
    return
  elsif spec.ready_to_install?(installed_specs)
    spec.state = :installable
  end

  worker_pool.enq(spec, priority: spec.enqueue_with_priority?)
end


  








  

    #require_tree_for_spec(spec)   (private)
  

  [ GitHub ]


  

  


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



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 128



def worker_pool
  @worker_pool ||= Bundler::Worker.new @size, "Parallel Installer", lambda {|spec_install, worker_num|
    case spec_install.state
    when :enqueued
      do_download(spec_install, worker_num)
    when :installable
      do_install(spec_install, worker_num)
    else
      spec_install
    end
  }
end