Class: Bundler::ParallelInstaller

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

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

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

def nmake?
  make = ENV["MAKE"] || ENV["make"]
  make ||= "nmake" if RUBY_PLATFORM.include?("mswin")
  /\bnmake/i.match?(make.to_s)
end

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

attr_reader :size

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

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

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

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

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

def download_worker_pool
  @download_worker_pool ||= Bundler::Worker.new(@size, "Gem Downloader",
    ->(spec_install, worker_num) { do_download(spec_install, worker_num) }, response_queue: response_queue)
end

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

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

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

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

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

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

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

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

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

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

def install_with_worker
  with_jobserver do
    installed_specs = {}
    enqueue_specs(installed_specs)

    process_specs(installed_specs) until finished_installing?
  end
end

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

def process_specs(installed_specs)
  spec = worker_pool.deq

  if spec.installed?
    installed_specs[spec.name] = true
  elsif spec.failed?
    return
  end

  @specs.each do |candidate|
    next unless candidate.ready_to_install?(installed_specs)

    candidate.state = :installable
    worker_pool.enq(candidate, priority: candidate.enqueue_with_priority?)
  end
end

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

def require_tree_for_spec(spec)
  tree = @spec_set.what_required(spec)
  gemfile_name = begin
    File.basename(SharedHelpers.default_gemfile)
  rescue GemfileNotFound
    # This runs while reporting an install error. When no Gemfile can be
    # located (e.g. Bundler used as a library), raising here would mask
    # the original error, so fall back to a generic header instead.
    "Gemfile"
  end
  t = String.new("In #{gemfile_name}:\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

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

def response_queue
  @response_queue ||= Thread::Queue.new
end

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

def with_jobserver
  # The jobserver hands tokens to child `make` processes through MAKEFLAGS
  # using the GNU make `--jobserver-auth` protocol. nmake, the default make
  # on mswin, instead reads MAKEFLAGS as bare option letters and aborts
  # every native extension build with `fatal error U1065: invalid option
  # '-'`. Skip the jobserver when nmake is in use. Other Windows toolchains
  # such as mingw use GNU make and keep working through the inherited pipe.
  return yield if nmake? || bsd_make?

  begin
    r, w = IO.pipe
    r.close_on_exec = false
    w.close_on_exec = false
    w.write("*" * @size)

    old_makeflags = ENV["MAKEFLAGS"]
    ENV["MAKEFLAGS"] = [old_makeflags, "--jobserver-auth=#{r.fileno},#{w.fileno}"].compact.join(" ")

    yield
  ensure
    # Restore MAKEFLAGS before closing the pipe so a close failure can't
    # leave the process with descriptors that point at a closed pipe.
    old_makeflags ? ENV["MAKEFLAGS"] = old_makeflags : ENV.delete("MAKEFLAGS")

    r&.close
    w&.close
  end
end

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

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