class Autoproj::Ops::Install

This class contains the functionality necessary to install autoproj in a clean root

It can be required standalone (i.e. does not depend on anything else than ruby and the ruby standard library)

Constants

ENV_BUNDLE_GEMFILE_RX
EXCLUDED_FROM_SHIMS
RUBYLIB_REINIT
WITHOUT_BUNDLER

Attributes

autoproj_options[R]

A set of options that should be passed to autoproj when calling it in a subprocess

config[R]

The configuration hash

env[R]

The environment that is passed to the bundler installs

gem_source[RW]

The URL of the source to be used to get gems

gemfile[RW]

Content of the Gemfile generated to install autoproj itself

gems_install_path[RW]

The path into which the workspace’s gems should be installed

They are installed in a versioned subdirectory of this path, e.g. {#gem_path_suffix}.

@return [String]

local[W]

(see local?)

root_dir[R]

The created workspace’s root directory

ruby_executable[R]

The Ruby interpreter we use for this install

skip_stage2[W]

(see skip_stage2?)

Public Class Methods

dot_gem_dir() click to toggle source

The user-wide place where RubyGems installs gems

# File lib/autoproj/ops/install.rb, line 165
def self.dot_gem_dir
    if Gem.respond_to?(:data_home) # Debian 11+
        File.join(Gem.data_home, "gem")
    else
        File.join(Gem.user_home, ".gem")
    end
end
gems_path_suffix() click to toggle source

The version and platform-specific suffix under {#dot_gem_dir}

This is also the suffix used by bundler to install gems

# File lib/autoproj/ops/install.rb, line 176
def self.gems_path_suffix
    @gems_path_suffix ||=
        Pathname
        .new(Gem.user_dir)
        .relative_path_from(Pathname.new(dot_gem_dir))
        .to_s
end
guess_gem_program() click to toggle source
# File lib/autoproj/ops/install.rb, line 241
def self.guess_gem_program
    ruby_bin = RbConfig::CONFIG["RUBY_INSTALL_NAME"]
    ruby_bindir = RbConfig::CONFIG["bindir"]

    candidates = ["gem"]
    candidates.unshift "gem#{$1}" if ruby_bin =~ /^ruby(.+)$/

    candidates.each do |gem_name|
        if File.file?(gem_full_path = File.join(ruby_bindir, gem_name))
            return gem_full_path
        end
    end
    raise ArgumentError, "cannot find a gem program "\
                         "(tried #{candidates.sort.join(', ')} in #{ruby_bindir})"
end
has_autoproj_preamble?(script_lines) click to toggle source
# File lib/autoproj/ops/install.rb, line 524
def self.has_autoproj_preamble?(script_lines)
    script_lines.any? { |l| l =~ /Autoproj generated preamble/ }
end
in_workspace?(base_dir) click to toggle source
# File lib/autoproj/ops/install.rb, line 117
def self.in_workspace?(base_dir)
    path = Pathname.new(base_dir)
    until path.root?
        if path.join(".autoproj").exist? || path.join("autoproj").exist?
            return true
        end

        path = path.parent
    end
    false
end
new(root_dir) click to toggle source
# File lib/autoproj/ops/install.rb, line 65
def initialize(root_dir)
    @root_dir = root_dir
    @gem_source = "https://rubygems.org"
    @gemfile = nil
    @skip_stage2 = false

    @autoproj_options = Array.new

    @env = Hash.new
    env["RUBYOPT"] = []
    env["RUBYLIB"] = []
    env["PATH"] = self.class.sanitize_env(ENV["PATH"] || "")
    env["BUNDLE_GEMFILE"] = []

    load_config

    if config["ruby_executable"] != Gem.ruby
        raise "this autoproj installation was already bootstrapped using "\
              "#{config['ruby_executable']}, but you are currently running "\
              "under #{Gem.ruby}. Changing the ruby interpreter in a given "\
              "workspace is not supported, you need to do a clean bootstrap"
    end
    @ruby_executable = config["ruby_executable"]
    @local = false

    install_gems_in_gem_user_dir unless @gems_install_path
    env["GEM_HOME"] = [gems_gem_home]
    env["GEM_PATH"] = [gems_gem_home]
end
new_style_bundler_binstub?(script_lines) click to toggle source
# File lib/autoproj/ops/install.rb, line 520
def self.new_style_bundler_binstub?(script_lines)
    script_lines.any? { |l| l =~ /This file was generated by Bundler/ }
end
rewrite_shims(shim_path, ruby_executable, root_dir, autoproj_gemfile_path, gems_gem_home) click to toggle source
# File lib/autoproj/ops/install.rb, line 479
def self.rewrite_shims(shim_path, ruby_executable,
    root_dir, autoproj_gemfile_path, gems_gem_home)
    FileUtils.mkdir_p shim_path
    File.open(File.join(shim_path, "ruby"), "w") do |io|
        io.puts "#! /bin/sh"
        io.puts "exec #{ruby_executable} \"$@\""
    end
    FileUtils.chmod 0755, File.join(shim_path, "ruby")

    Dir.glob(File.join(shim_path, "*")) do |bin_script|
        next unless File.file?(bin_script)

        bin_name = File.basename(bin_script)
        if EXCLUDED_FROM_SHIMS.include?(bin_name)
            FileUtils.rm_f bin_script
            next
        end
        next if bin_name == "ruby"

        bin_shim = File.join(shim_path, bin_name)
        bin_script_lines = File.readlines(bin_script)
        next if has_autoproj_preamble?(bin_script_lines)
        next unless ruby_script?(bin_script_lines)

        File.open(bin_shim, "w") do |io|
            if bin_name == "bundler" || bin_name == "bundle"
                io.puts shim_bundler(bin_script_lines, ruby_executable,
                                     autoproj_gemfile_path, gems_gem_home)
            else
                io.puts shim_script(bin_script_lines, ruby_executable, root_dir,
                                    autoproj_gemfile_path, gems_gem_home)
            end
        end
        FileUtils.chmod 0755, bin_shim
    end
end
ruby_script?(script_lines) click to toggle source
# File lib/autoproj/ops/install.rb, line 516
def self.ruby_script?(script_lines)
    script_lines.first =~ /\#\s*!(.*ruby.*)/
end
sanitize_env(value) click to toggle source
# File lib/autoproj/ops/install.rb, line 112
def self.sanitize_env(value)
    value.split(File::PATH_SEPARATOR)
         .find_all { |p| !in_workspace?(p) }
end
shim_bundler(script_lines, ruby_executable, autoproj_gemfile_path, gems_gem_home) click to toggle source
# File lib/autoproj/ops/install.rb, line 528
            def self.shim_bundler(script_lines, ruby_executable, autoproj_gemfile_path, gems_gem_home)
                return shim_bundler_old(ruby_executable, autoproj_gemfile_path, gems_gem_home) \
                    unless new_style_bundler_binstub?(script_lines)

                script_lines.insert(1, <<-RESTART_BUNDLER)
#
# This file was generated by Bundler.
#

# Autoproj generated preamble
#{WITHOUT_BUNDLER}
ENV['BUNDLE_GEMFILE'] ||= '#{autoproj_gemfile_path}'
ENV['GEM_HOME'] = '#{gems_gem_home}'
ENV.delete('GEM_PATH')
Gem.paths = Hash['GEM_HOME' => '#{gems_gem_home}', 'GEM_PATH' => '']
                RESTART_BUNDLER
                script_lines.join
            end
shim_bundler_old(ruby_executable, autoproj_gemfile_path, gems_gem_home) click to toggle source
# File lib/autoproj/ops/install.rb, line 547
            def self.shim_bundler_old(ruby_executable, autoproj_gemfile_path, gems_gem_home)
                "#! #{ruby_executable}

#{WITHOUT_BUNDLER}
ENV['BUNDLE_GEMFILE'] ||= '#{autoproj_gemfile_path}'
ENV['GEM_HOME'] = '#{gems_gem_home}'
ENV.delete('GEM_PATH')
Gem.paths = Hash['GEM_HOME' => '#{gems_gem_home}', 'GEM_PATH' => '']

load Gem.bin_path('bundler', 'bundler')"
            end
shim_script(script_lines, ruby_executable, root_dir, autoproj_gemfile_path, gems_gem_home) click to toggle source
# File lib/autoproj/ops/install.rb, line 559
            def self.shim_script(script_lines, ruby_executable, root_dir,
                autoproj_gemfile_path, gems_gem_home)
                new_style = !script_lines.empty? && script_lines.any? do |l|
                    l =~ /This file was generated by Bundler/
                end
                load_line = script_lines.grep(/load Gem.bin_path/).first
                return shim_script_old(ruby_executable, root_dir,
                                       autoproj_gemfile_path, gems_gem_home, load_line) \
                    unless new_style

                script_lines.insert(1, <<-AUTOPROJ_PREAMBLE)
#
# This file was generated by Bundler.
#

# Autoproj generated preamble, v1
#{RUBYLIB_REINIT}
ENV['BUNDLE_GEMFILE'] = '#{autoproj_gemfile_path}'
ENV['AUTOPROJ_CURRENT_ROOT'] = '#{root_dir}'
Gem.paths = Hash['GEM_HOME' => '#{gems_gem_home}', 'GEM_PATH' => '']
                AUTOPROJ_PREAMBLE
                script_lines.join
            end
shim_script_old(ruby_executable, root_dir, autoproj_gemfile_path, gems_gem_home, load_line) click to toggle source
# File lib/autoproj/ops/install.rb, line 583
            def self.shim_script_old(ruby_executable, root_dir, autoproj_gemfile_path,
                gems_gem_home, load_line)
                "#! #{ruby_executable}

#{RUBYLIB_REINIT}
ENV['BUNDLE_GEMFILE'] = '#{autoproj_gemfile_path}'
ENV['AUTOPROJ_CURRENT_ROOT'] = '#{root_dir}'
require 'rubygems'
Gem.paths = Hash['GEM_HOME' => '#{gems_gem_home}', 'GEM_PATH' => '']
require 'bundler/setup'
#{load_line}"
            end

Public Instance Methods

add_seed_config(path) click to toggle source
# File lib/autoproj/ops/install.rb, line 269
def add_seed_config(path)
    @config.merge!(YAML.safe_load(File.read(path), [Symbol]))
end
apply_env(env) click to toggle source
# File lib/autoproj/ops/install.rb, line 102
def apply_env(env)
    env.each do |k, v|
        if v
            ENV[k] = v
        else
            ENV.delete(k)
        end
    end
end
autoproj_config_path() click to toggle source

The path to the autoproj configuration file

@return [String]

# File lib/autoproj/ops/install.rb, line 146
def autoproj_config_path
    File.join(dot_autoproj, "config.yml")
end
autoproj_gemfile_path() click to toggle source

The path to the gemfile used to install autoproj

@return [String]

# File lib/autoproj/ops/install.rb, line 139
def autoproj_gemfile_path
    File.join(dot_autoproj, "Gemfile")
end
autoproj_path() click to toggle source
# File lib/autoproj/ops/install.rb, line 760
def autoproj_path
    File.join(dot_autoproj, "bin", "autoproj")
end
bundler_version() click to toggle source
# File lib/autoproj/ops/install.rb, line 352
def bundler_version
    @config["bundler_version"]
end
call_stage2() click to toggle source
# File lib/autoproj/ops/install.rb, line 786
def call_stage2
    clean_env = env_for_child
    stage2_vars = clean_env.map { |k, v| "#{k}=#{v}" }
    puts "starting the newly installed autoproj for stage2 install"
    unless run_autoproj("install-stage2", root_dir, *stage2_vars, *@autoproj_options)
        raise "failed to execute autoproj install-stage2"
    end
end
default_gemfile_contents(autoproj_version = ">= 2.0.0") click to toggle source

The content of the default {#gemfile}

@param [String] autoproj_version a constraint on the autoproj version

that should be used

@return [String]

# File lib/autoproj/ops/install.rb, line 262
def default_gemfile_contents(autoproj_version = ">= 2.0.0")
    ["source \"#{gem_source}\"",
     "ruby \"#{RUBY_VERSION}\" if respond_to?(:ruby)",
     "gem \"autoproj\", \"#{autoproj_version}\"",
     "gem \"utilrb\", \">= 3.0.1\""].join("\n")
end
dot_autoproj() click to toggle source

The path to the .autoproj configuration directory

@return [String]

# File lib/autoproj/ops/install.rb, line 132
def dot_autoproj
    File.join(root_dir, ".autoproj")
end
env_for_child(env = self.env) click to toggle source
# File lib/autoproj/ops/install.rb, line 95
def env_for_child(env = self.env)
    env.inject(Hash.new) do |h, (k, v)|
        h[k] = (v.join(File::PATH_SEPARATOR) if v && !v.empty?)
        h
    end
end
find_bundler(gem_program, version: nil) click to toggle source
# File lib/autoproj/ops/install.rb, line 356
def find_bundler(gem_program, version: nil)
    bundler_path = File.join(gems_gem_home, "bin", "bundle")
    return unless File.exist?(bundler_path)

    setup_paths =
        if version
            find_versioned_bundler_setup(gem_program, version)
        else
            find_unversioned_bundler_setup(gem_program)
        end

    setup_paths.each do |setup_path|
        return bundler_path if setup_path.start_with?(gems_gem_home)
    end
    nil
end
find_in_clean_path(command, *additional_paths) click to toggle source
# File lib/autoproj/ops/install.rb, line 654
def find_in_clean_path(command, *additional_paths)
    clean_path = env_for_child["PATH"].split(File::PATH_SEPARATOR) +
                 additional_paths
    clean_path.each do |p|
        full_path = File.join(p, command)
        return full_path if File.file?(full_path)
    end
    nil
end
find_unversioned_bundler_setup(gem_program) click to toggle source
# File lib/autoproj/ops/install.rb, line 384
def find_unversioned_bundler_setup(gem_program)
    setup_paths = IO.popen(
        [env_for_child, Gem.ruby, gem_program,
         "which", "-a", "bundler/setup"],
        &:readlines
    )
    return [] unless $CHILD_STATUS.success?

    setup_paths
end
find_versioned_bundler_setup(gem_program, version) click to toggle source
# File lib/autoproj/ops/install.rb, line 373
def find_versioned_bundler_setup(gem_program, version)
    contents = IO.popen(
        [env_for_child, Gem.ruby, gem_program,
         "contents", "-v", version, "bundler"],
        &:readlines
    )
    return [] unless $CHILD_STATUS.success?

    contents.grep(%r{bundler/setup.rb$})
end
gem_bindir() click to toggle source

The path of the bin/ folder for installed gems

# File lib/autoproj/ops/install.rb, line 665
def gem_bindir
    return @gem_bindir if @gem_bindir

    # Here, we're getting into the esotheric
    #
    # The problem is that e.g. Ubuntu and Debian install an
    # operating_system.rb file that sets proper OS defaults. Some
    # autoproj installs have it in their RUBYLIB but should not
    # because of limitations of autoproj 1.x. This leads to
    # Gem.bindir being *not* valid for subprocesses
    #
    # So, we're calling 'gem' as a subcommand to discovery the
    # actual bindir
    bindir = IO.popen(
        env_for_child,
        [Gem.ruby, "-e", 'puts "#{Gem.user_dir}/bin"'], # rubocop:disable Lint/InterpolationCheck
        &:read
    )
    if bindir
        @gem_bindir = bindir.chomp
    else
        raise "FATAL: cannot run #{Gem.ruby} -e 'puts Gem.bindir'"
    end
end
gems_gem_home() click to toggle source

The GEM_HOME under which the workspace’s gems should be installed

@return [String]

# File lib/autoproj/ops/install.rb, line 195
def gems_gem_home
    File.join(gems_install_path, self.class.gems_path_suffix)
end
install(bundler_version: self.bundler_version) click to toggle source
# File lib/autoproj/ops/install.rb, line 690
def install(bundler_version: self.bundler_version)
    if ENV["BUNDLER_GEMFILE"]
        raise "cannot run autoproj_install or autoproj_bootstrap while "\
              "under a 'bundler exec' subcommand or having loaded an "\
              "env.sh. Open a new console and try again"
    end

    gem_program = self.class.guess_gem_program
    puts "Detected 'gem' to be #{gem_program}"
    env["GEM_HOME"] = [gems_gem_home]
    env["GEM_PATH"] = [gems_gem_home]

    if (bundler = find_bundler(gem_program, version: bundler_version))
        puts "Detected bundler at #{bundler}"
    else
        puts "Installing bundler in #{gems_gem_home}"
        bundler = install_bundler(gem_program, version: bundler_version)
        exit(1) unless bundler
    end
    self.class.rewrite_shims(
        File.join(dot_autoproj, "bin"),
        ruby_executable,
        root_dir,
        autoproj_gemfile_path,
        gems_gem_home
    )
    env["PATH"].unshift File.join(dot_autoproj, "bin")
    save_gemfile

    puts "Installing autoproj in #{gems_gem_home}"
    install_autoproj(bundler, bundler_version: bundler_version)
end
install_autoproj(bundler, bundler_version: self.bundler_version) click to toggle source
# File lib/autoproj/ops/install.rb, line 433
def install_autoproj(bundler, bundler_version: self.bundler_version)
    # Force bundler to update. If the user does not want this, let
    # him specify a Gemfile with tighter version constraints
    lockfile = File.join(dot_autoproj, "Gemfile.lock")
    FileUtils.rm lockfile if File.exist?(lockfile)

    run_bundler(bundler, "config", "set", "--local", "path", gems_install_path,
                bundler_version: bundler_version)
    run_bundler(bundler, "config", "set", "--local", "shebang", Gem.ruby,
                bundler_version: bundler_version)

    install_args = ["--gemfile=#{autoproj_gemfile_path}"]
    install_args << "--local" if local?
    run_bundler(bundler, "install", *install_args,
                bundler_version: bundler_version)

    shims_path = File.join(dot_autoproj, "bin")
    run_bundler(bundler, "binstubs", "--all", "--force", "--path", shims_path,
                bundler_version: bundler_version)
    self.class.rewrite_shims(
        shims_path, ruby_executable, root_dir,
        autoproj_gemfile_path, gems_gem_home
    )
end
install_bundler(gem_program, version: nil, silent: false) click to toggle source
# File lib/autoproj/ops/install.rb, line 395
def install_bundler(gem_program, version: nil, silent: false)
    local = ["--local"] if local?

    redirection = Hash.new
    redirection = Hash[out: :close] if silent

    version_args = []
    version_args << "-v" << version if version

    # Shut up the bundler warning about 'bin' not being in PATH
    env = self.env
    env = env.merge(
        { "PATH" => env["PATH"] + [File.join(gems_gem_home, "bin")] }
    )
    result = system(
        env_for_child(env),
        Gem.ruby, gem_program, "install",
        "--env-shebang", "--no-document", "--no-format-executable",
        "--clear-sources", "--source", gem_source,
        "--no-user-install", "--install-dir", gems_gem_home,
        *local, "--bindir=#{File.join(gems_gem_home, 'bin')}",
        "bundler", *version_args, **redirection
    )

    unless result
        STDERR.puts "FATAL: failed to install bundler in #{gems_gem_home}"
        nil
    end

    if (bundler_path = find_bundler(gem_program, version: version))
        bundler_path
    else
        STDERR.puts "gem install bundler returned successfully, but still "\
                    "cannot find bundler in #{gems_gem_home}"
        nil
    end
end
install_gems_in_gem_user_dir() click to toggle source

Install autoproj in Gem’s default user dir

# File lib/autoproj/ops/install.rb, line 213
def install_gems_in_gem_user_dir
    xdg_default_gem_path = xdg_var("XDG_DATA_HOME",
                                   File.join(Dir.home, ".local", "share", "autoproj", "gems"))
    default_gem_path = File.join(
        Dir.home, ".autoproj", "gems"
    )
    @gems_install_path =
        if File.directory?(xdg_default_gem_path)
            xdg_default_gem_path
        elsif File.directory?(default_gem_path)
            default_gem_path
        else
            xdg_default_gem_path
        end
end
load_config() click to toggle source
# File lib/autoproj/ops/install.rb, line 723
def load_config
    v1_config_path = File.join(root_dir, "autoproj", "config.yml")

    config = Hash.new
    if File.file?(v1_config_path)
        config.merge!(YAML.load(File.read(v1_config_path)) || Hash.new)
    end
    if File.file?(autoproj_config_path)
        config.merge!(YAML.load(File.read(autoproj_config_path)) || Hash.new)
    end

    ruby = RbConfig::CONFIG["RUBY_INSTALL_NAME"]
    ruby_bindir = RbConfig::CONFIG["bindir"]
    ruby_executable = File.join(ruby_bindir, ruby)
    if (current = config["ruby_executable"]) # When upgrading or reinstalling
        if current != ruby_executable
            raise "this workspace has already been initialized using "\
                  "#{current}, you cannot run autoproj install with "\
                  "#{ruby_executable}. If you know what you're doing, "\
                  "delete the ruby_executable line in config.yml and try again"
        end
    else
        config["ruby_executable"] = ruby_executable
    end

    @config = config
    %w[gems_install_path prefer_indep_over_os_packages].each do |flag|
        instance_variable_set "@#{flag}", config.fetch(flag, false)
    end
end
local?() click to toggle source

Whether we can access the network while installing

# File lib/autoproj/ops/install.rb, line 158
def local?
    !!@local
end
parse_options(args = ARGV) click to toggle source

Parse the provided command line options and returns the non-options

# File lib/autoproj/ops/install.rb, line 274
def parse_options(args = ARGV)
    options = OptionParser.new do |opt|
        opt.on "--local", "do not access the network (may fail)" do
            @local = true
        end
        opt.on "--skip-stage2", "do not run the stage2 install" do
            @skip_stage2 = true
        end
        opt.on "--debug", "Run in debug mode" do
            @autoproj_options << "--debug"
        end
        opt.on "--gem-source=URL", String, "use this source for RubyGems "\
                                           "instead of rubygems.org" do |url|
            @gem_source = url
        end
        opt.on "--gems-path=PATH", "install gems under this path instead "\
                                   "of ~/.autoproj/gems" do |path|
            self.gems_install_path = path
        end
        opt.on "--public-gems", "install gems in the default gem location" do
            install_gems_in_gem_user_dir
        end
        opt.on "--bundler-version=VERSION_CONSTRAINT", String, "use the provided "\
                                                               "string as a version constraint for bundler" do |version|
            @config["bundler_version"] = version
        end
        opt.on "--version=VERSION_CONSTRAINT", String, "use the provided "\
                                                       "string as a version constraint for autoproj" do |version|
            raise "cannot give both --version and --gemfile" if @gemfile

            @gemfile = default_gemfile_contents(version)
        end
        opt.on "--gemfile=PATH", String, "use the given Gemfile to install "\
                                         "autoproj instead of the default" do |path|
            raise "cannot give both --version and --gemfile" if @gemfile

            @gemfile = File.read(path)
        end
        opt.on "--no-seed-config",
               "when reinstalling an existing autoproj workspace, do not "\
               "use the config in .autoproj/ as seed" do
            @config.clear
        end
        opt.on "--seed-config=PATH", String, "path to a seed file that "\
                                             "should be used to initialize the configuration" do |path|
            add_seed_config(path)
        end
        opt.on "--prefer-os-independent-packages", "prefer OS-independent "\
                                                   "packages (such as a RubyGem) over their OS-packaged equivalent "\
                                                   "(e.g. the thor gem vs. the ruby-thor debian package)" do
            @prefer_indep_over_os_packages = true
        end
        opt.on "--[no-]color", "do not use colored output (enabled by "\
                               "default if the terminal supports it)" do |color|
            if color then @autoproj_options << "--color"
            else
                @autoproj_options << "--no-color"
            end
        end
        opt.on "--[no-]progress", "do not use progress output (enabled by "\
                                  "default if the terminal supports it)" do |progress|
            if progress then @autoproj_options << "--progress"
            else
                @autoproj_options << "--no-progress"
            end
        end
        opt.on "--[no-]interactive", "if non-interactive, use default "\
                                     "answer for questions" do |flag|
            if flag then @autoproj_options << "--interactive"
            else
                @autoproj_options << "--no-interactive"
            end
        end
    end
    args = options.parse(ARGV)
    @autoproj_options + args
end
prefer_indep_over_os_packages=(flag) click to toggle source

(see prefer_index_over_os_packages?)

# File lib/autoproj/ops/install.rb, line 237
def prefer_indep_over_os_packages=(flag)
    @prefer_indep_over_os_packages = !!flag
end
prefer_indep_over_os_packages?() click to toggle source

Whether autoproj should prefer OS-independent packages over their OS-packaged equivalents (e.g. the thor gem vs. the ruby-thor Debian package)

# File lib/autoproj/ops/install.rb, line 232
def prefer_indep_over_os_packages?
    @prefer_indep_over_os_packages
end
run_autoproj(*args) click to toggle source
# File lib/autoproj/ops/install.rb, line 764
def run_autoproj(*args)
    system env_for_child.merge("BUNDLE_GEMFILE" => autoproj_gemfile_path),
           Gem.ruby, autoproj_path, *args, *@autoproj_options
end
run_bundler(bundler, *args, bundler_version: self.bundler_version) click to toggle source
# File lib/autoproj/ops/install.rb, line 460
def run_bundler(bundler, *args, bundler_version: self.bundler_version)
    clean_env = env_for_child.dup

    version_arg = []
    version_arg << "_#{bundler_version}_" if bundler_version

    result = system(
        clean_env, Gem.ruby, bundler, *version_arg,
        *args, chdir: dot_autoproj
    )

    unless result
        raise BundlerFailed,
              "FAILED: bundler #{args.join(', ')} in #{dot_autoproj}"
    end
end
save_config() click to toggle source
# File lib/autoproj/ops/install.rb, line 754
def save_config
    config["gems_install_path"] = gems_install_path
    config["prefer_indep_over_os_packages"] = prefer_indep_over_os_packages?
    File.open(autoproj_config_path, "w") { |io| YAML.dump(config, io) }
end
save_env_sh(*vars) click to toggle source
# File lib/autoproj/ops/install.rb, line 596
def save_env_sh(*vars)
    env = Autobuild::Environment.new
    env.prepare
    vars.each do |kv|
        k, *v = kv.split("=")
        v = v.join("=")

        if v.empty?
            env.unset k
        else
            env.set k, *v.split(File::PATH_SEPARATOR)
        end
    end
    # Generate environment files right now, we can at least use bundler
    File.open(File.join(dot_autoproj, "env.sh"), "w") do |io|
        env.export_env_sh(io)
    end

    # And now the root envsh
    env = Autobuild::Environment.new
    env.source_before File.join(dot_autoproj, "env.sh")
    env.set("AUTOPROJ_CURRENT_ROOT", root_dir)
    File.open(File.join(root_dir, "env.sh"), "w") do |io|
        env.export_env_sh(io)
    end
end
save_gemfile() click to toggle source
# File lib/autoproj/ops/install.rb, line 623
def save_gemfile
    gemfile =
        if @gemfile
            @gemfile
        elsif File.file?(autoproj_gemfile_path)
            File.read(autoproj_gemfile_path)
        else
            default_gemfile_contents
        end

    gemfile += [
        "",
        "config_path = File.join(__dir__, 'config.yml')",
        "if File.file?(config_path)",
        "    require 'yaml'",
        "    config = YAML.load(File.read(config_path)) || Hash.new",
        "    (config['plugins'] || Hash.new).",
        "        each do |plugin_name, (version, options)|",
        "            gem plugin_name, version, **options",
        "        end",
        "end"
    ].join("\n")

    FileUtils.mkdir_p File.dirname(autoproj_gemfile_path)
    File.open(autoproj_gemfile_path, "w") do |io|
        io.write gemfile
    end
end
skip_stage2?() click to toggle source

Whether the stage2 install should be called or not

# File lib/autoproj/ops/install.rb, line 151
def skip_stage2?
    !!@skip_stage2
end
stage1() click to toggle source
# File lib/autoproj/ops/install.rb, line 774
def stage1
    if v1_workspace? && File.file?(v1_envsh = File.join(root_dir, "env.sh"))
        FileUtils.cp v1_envsh, "env.sh-autoproj-v1"
    end
    FileUtils.mkdir_p dot_autoproj
    save_config
    install
rescue Exception
    FileUtils.rm_rf dot_autoproj
    raise
end
stage2(*vars) click to toggle source
# File lib/autoproj/ops/install.rb, line 795
def stage2(*vars)
    require "autobuild"
    puts "saving temporary env.sh and .autoproj/env.sh"
    save_env_sh(*vars)
    puts "running 'autoproj envsh' to generate a proper env.sh"
    unless system(Gem.ruby, autoproj_path, "envsh", *@autoproj_options)
        STDERR.puts "failed to run autoproj envsh on the newly installed "\
                    "autoproj (#{autoproj_path})"
        exit 1
    end
    # This is really needed on an existing install to install the
    # gems that were present in the v1 layout
    puts "running 'autoproj osdeps' to re-install missing gems"
    unless system(Gem.ruby, autoproj_path, "osdeps", *@autoproj_options)
        STDERR.puts "failed to run autoproj osdeps on the newly installed "\
                    "autoproj (#{autoproj_path})"
        exit 1
    end
end
v1_workspace?() click to toggle source
# File lib/autoproj/ops/install.rb, line 769
def v1_workspace?
    File.file?(File.join(root_dir, "autoproj", "config.yml")) &&
        !File.directory?(File.join(root_dir, ".autoproj"))
end

Private Instance Methods

xdg_var(varname, default) click to toggle source

Sets where the workspace’s gems should be installed

@param [String] path the absolute path that should be given to

bundler. The gems themselves will be installed in the
{.gems_path_suffix} subdirectory under this
# File lib/autoproj/ops/install.rb, line 204
        def xdg_var(varname, default)
    if (env = ENV[varname]) && !env.empty?
        env
    else
        default
    end
end