Class: Autoproj::Ops::Install

Inherits:
Object
  • Object
show all
Defined in:
lib/autoproj/ops/install.rb

Overview

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)

Defined Under Namespace

Classes: BundlerFailed, UnexpectedBinstub

Constant Summary collapse

RUBYLIB_REINIT = 
<<~RUBY
    if defined?(Bundler)
        if Bundler.respond_to?(:with_unbundled_env)
            Bundler.with_unbundled_env do
                exec(Hash['RUBYLIB' => nil], $0, *ARGV)
            end
        else
            Bundler.with_clean_env do
                exec(Hash['RUBYLIB' => nil], $0, *ARGV)
            end
        end
    elsif ENV['RUBYLIB']
        exec(Hash['RUBYLIB' => nil], $0, *ARGV)
    end
RUBY
WITHOUT_BUNDLER = 
<<~RUBY
    if defined?(Bundler)
        if Bundler.respond_to?(:with_unbundled_env)
            Bundler.with_unbundled_env do
                exec($0, *ARGV)
            end
        else
            Bundler.with_clean_env do
                exec($0, *ARGV)
            end
        end
    end
RUBY
EXCLUDED_FROM_SHIMS = 
%w[rake thor].freeze
ENV_BUNDLE_GEMFILE_RX = 
/^(\s*ENV\[['"]BUNDLE_GEMFILE['"]\]\s*)(?:\|\|)?=/

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(root_dir) ⇒ Install

Returns a new instance of Install.



65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
 
# 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

Instance Attribute Details

#autoproj_options ⇒ Object (readonly)

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



59
60
61
 
# File 'lib/autoproj/ops/install.rb', line 59

def autoproj_options
  @autoproj_options
end

#config ⇒ Object (readonly)

The configuration hash



56
57
58
 
# File 'lib/autoproj/ops/install.rb', line 56

def config
  @config
end

#env ⇒ Object (readonly)

The environment that is passed to the bundler installs



54
55
56
 
# File 'lib/autoproj/ops/install.rb', line 54

def env
  @env
end

#gem_source ⇒ Object

The URL of the source to be used to get gems



63
64
65
 
# File 'lib/autoproj/ops/install.rb', line 63

def gem_source
  @gem_source
end

#gemfile ⇒ Object

Content of the Gemfile generated to install autoproj itself



52
53
54
 
# File 'lib/autoproj/ops/install.rb', line 52

def gemfile
  @gemfile
end

#gems_install_path ⇒ String

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.

Returns:

  • (String) 


190
191
192
 
# File 'lib/autoproj/ops/install.rb', line 190

def gems_install_path
  @gems_install_path
end

#local=(value) ⇒ Object (writeonly)

Whether we can access the network while installing



162
163
164
 
# File 'lib/autoproj/ops/install.rb', line 162

def local=(value)
  @local = value
end

#root_dir ⇒ Object (readonly)

The created workspace’s root directory



50
51
52
 
# File 'lib/autoproj/ops/install.rb', line 50

def root_dir
  @root_dir
end

#ruby_executable ⇒ Object (readonly)

The Ruby interpreter we use for this install



61
62
63
 
# File 'lib/autoproj/ops/install.rb', line 61

def ruby_executable
  @ruby_executable
end

#skip_stage2=(value) ⇒ Object (writeonly)

Whether the stage2 install should be called or not



155
156
157
 
# File 'lib/autoproj/ops/install.rb', line 155

def skip_stage2=(value)
  @skip_stage2 = value
end

Class Method Details

.dot_gem_dir ⇒ Object

The user-wide place where RubyGems installs gems



165
166
167
168
169
170
171
 
# 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 ⇒ Object

The version and platform-specific suffix under #dot_gem_dir

This is also the suffix used by bundler to install gems



176
177
178
179
180
181
182
 
# 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 ⇒ Object

Raises:

  • (ArgumentError) 


241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
 
# 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) ⇒ Boolean

Returns:

  • (Boolean) 


524
525
526
 
# 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) ⇒ Boolean

Returns:

  • (Boolean) 


117
118
119
120
121
122
123
124
125
126
127
 
# 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_style_bundler_binstub?(script_lines) ⇒ Boolean

Returns:

  • (Boolean) 


520
521
522
 
# 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) ⇒ Object 



479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
 
# 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) ⇒ Boolean

Returns:

  • (Boolean) 


516
517
518
 
# File 'lib/autoproj/ops/install.rb', line 516

def self.ruby_script?(script_lines)
    script_lines.first =~ /\#\s*!(.*ruby.*)/
end

.sanitize_env(value) ⇒ Object 



112
113
114
115
 
# 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) ⇒ Object 



528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
 
# 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) ⇒ Object 



547
548
549
550
551
552
553
554
555
556
557
 
# 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) ⇒ Object 



559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
 
# 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) ⇒ Object 



583
584
585
586
587
588
589
590
591
592
593
594
 
# 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

Instance Method Details

#add_seed_config(path) ⇒ Object 



269
270
271
 
# 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) ⇒ Object 



102
103
104
105
106
107
108
109
110
 
# 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 ⇒ String

The path to the autoproj configuration file

Returns:

  • (String) 


146
147
148
 
# File 'lib/autoproj/ops/install.rb', line 146

def autoproj_config_path
    File.join(dot_autoproj, "config.yml")
end

#autoproj_gemfile_path ⇒ String

The path to the gemfile used to install autoproj

Returns:

  • (String) 


139
140
141
 
# File 'lib/autoproj/ops/install.rb', line 139

def autoproj_gemfile_path
    File.join(dot_autoproj, "Gemfile")
end

#autoproj_path ⇒ Object 



760
761
762
 
# File 'lib/autoproj/ops/install.rb', line 760

def autoproj_path
    File.join(dot_autoproj, "bin", "autoproj")
end

#bundler_version ⇒ Object 



352
353
354
 
# File 'lib/autoproj/ops/install.rb', line 352

def bundler_version
    @config["bundler_version"]
end

#call_stage2 ⇒ Object 



786
787
788
789
790
791
792
793
 
# 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") ⇒ String

The content of the default #gemfile

Parameters:

  • autoproj_version (String) (defaults to: ">= 2.0.0") —

    a constraint on the autoproj version that should be used

Returns:

  • (String) 


262
263
264
265
266
267
 
# 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 ⇒ String

The path to the .autoproj configuration directory

Returns:

  • (String) 


132
133
134
 
# File 'lib/autoproj/ops/install.rb', line 132

def dot_autoproj
    File.join(root_dir, ".autoproj")
end

#env_for_child(env = self.env) ⇒ Object 



95
96
97
98
99
100
 
# 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) ⇒ Object 



356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
 
# 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) ⇒ Object 



654
655
656
657
658
659
660
661
662
 
# 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) ⇒ Object 



384
385
386
387
388
389
390
391
392
393
 
# 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) ⇒ Object 



373
374
375
376
377
378
379
380
381
382
 
# 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 ⇒ Object

The path of the bin/ folder for installed gems



665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
 
# 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 ⇒ String

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

Returns:

  • (String) 


195
196
197
 
# 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) ⇒ Object 



690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
 
# 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) ⇒ Object 



433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
 
# 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) ⇒ Object 



395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
 
# 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 ⇒ Object

Install autoproj in Gem’s default user dir



213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
 
# 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 ⇒ Object 



723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
 
# 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? ⇒ Boolean

Whether we can access the network while installing

Returns:

  • (Boolean) 


158
159
160
 
# File 'lib/autoproj/ops/install.rb', line 158

def local?
    !!@local
end

#parse_options(args = ARGV) ⇒ Object

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



274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
 
# 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) ⇒ Object 



237
238
239
 
# 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? ⇒ Boolean

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

Returns:

  • (Boolean) 


232
233
234
 
# File 'lib/autoproj/ops/install.rb', line 232

def prefer_indep_over_os_packages?
    @prefer_indep_over_os_packages
end

#run_autoproj(*args) ⇒ Object 



764
765
766
767
 
# 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) ⇒ Object 



460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
 
# 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 ⇒ Object 



754
755
756
757
758
 
# 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) ⇒ Object 



596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
 
# 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 ⇒ Object 



623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
 
# 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? ⇒ Boolean

Whether the stage2 install should be called or not

Returns:

  • (Boolean) 


151
152
153
 
# File 'lib/autoproj/ops/install.rb', line 151

def skip_stage2?
    !!@skip_stage2
end

#stage1 ⇒ Object 



774
775
776
777
778
779
780
781
782
783
784
 
# 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) ⇒ Object 



795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
 
# 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? ⇒ Boolean

Returns:

  • (Boolean) 


769
770
771
772
 
# 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