autoproj 2.0.0.rc4 → 2.0.0.rc5

data/lib/autoproj.rb

@@ -8,6 +8,7 @@
 require 'autoproj/reporter'
 require 'autoproj/environment'
 require 'autoproj/variable_expansion'
+require 'autoproj/find_workspace'
 require 'autoproj/vcs_definition'
 require 'autoproj/package_set'
 require 'autoproj/package_definition'

data/lib/autoproj/cli.rb

@@ -1,7 +1,6 @@
-require 'autobuild'
 module Autoproj
     module CLI
-        class InvalidArguments < Autobuild::Exception
+        class InvalidArguments < Exception
         end
 
         def self.load_plugins

data/lib/autoproj/cli/commit.rb

@@ -1,7 +1,6 @@
-require 'autoproj'
+require 'autoproj/cli/inspection_tool'
 require 'autoproj/cli/versions'
 require 'autoproj/ops/snapshot'
-require 'autoproj/cli/base'
 
 module Autoproj
     module CLI

data/lib/autoproj/cli/locate.rb

@@ -1,4 +1,3 @@
-require 'autoproj'
 require 'autoproj/cli/base'
 
 module Autoproj
@@ -13,10 +12,12 @@ def initialize(ws = nil)
                 super
                 self.ws.load_config
 
-                @installation_manifest = Autoproj::InstallationManifest.new(self.ws.root_dir)
-                if !File.file?(installation_manifest.default_manifest_path)
+                path = InstallationManifest.path_for_root(self.ws.root_dir)
+                if !File.file?(path)
                     raise ConfigError, "the installation manifest is not present, please run autoproj envsh to generate it"
                 end
+
+                @installation_manifest = Autoproj::InstallationManifest.new(path)
                 installation_manifest.load
             end
 

data/lib/autoproj/cli/log.rb

@@ -1,4 +1,3 @@
-require 'autoproj'
 require 'autoproj/cli/base'
 
 module Autoproj

data/lib/autoproj/cli/main.rb

@@ -1,5 +1,4 @@
 require 'thor'
-require 'autoproj'
 require 'autoproj/cli/main_test'
 
 module Autoproj
@@ -7,9 +6,6 @@ module CLI
         def self.basic_setup
             Encoding.default_internal = Encoding::UTF_8
             Encoding.default_external = Encoding::UTF_8
-
-            Autobuild::Reporting << Autoproj::Reporter.new
-            Autobuild::Package.clear
         end
 
         class Main < Thor
@@ -67,6 +63,8 @@ def envsh
                 desc: "compare to the given baseline. if 'true', the comparison will ignore any override, otherwise it will take into account overrides only up to the given package set"
             option :snapshot, type: :boolean, default: false,
                 desc: "use the VCS information as 'versions --no-local' would detect it instead of the one in the configuration"
+            option :parallel, aliases: :p, type: :numeric,
+                desc: 'maximum number of parallel jobs'
             def status(*packages)
                 run_autoproj_cli(:status, :Status, Hash[], *packages)
             end
@@ -312,9 +310,29 @@ def query(query_string = nil)
                 run_autoproj_cli(:query, :Query, Hash[], *Array(query_string))
             end
 
-            desc "upgrade autoproj itself"
+            desc 'upgrade', "upgrade autoproj itself, and the workspace layout"
+            option :local, type: :boolean, default: false,
+                desc: 'do not access the network (will fail if some gems are missing)'
+            option :gemfile, type: :string,
+                desc: 'path to a gemfile that should be used to install autoproj'
+            option :private_bundler, type: :boolean,
+                desc: 'install bundler inside the workspace instead of using the default Gem location'
+            option :private_gems, type: :boolean,
+                desc: 'install gems inside the workspace instead of using the default Gem location'
+            option :private_autoproj, type: :boolean,
+                desc: 'install bundler inside the workspace instead of using the default Gem location'
+            option :private, type: :boolean,
+                desc: 'equivalent to --private-bundler --private-autoproj --private-gems'
             def upgrade
-                run_autoproj_cli(:upgrade, :Upgrade, Hash[])
+                require 'autoproj/cli/upgrade'
+                Autoproj::CLI::Upgrade.new.run(options)
+            end
+
+            desc 'install_stage2 ROOT_DIR', 'used by autoproj_install to finalize the installation',
+                hide: true
+            def install_stage2(root_dir)
+                require 'autoproj/ops/install'
+                Autoproj::Ops::Install.new(root_dir).run(stage2: true)
             end
         end
     end

data/lib/autoproj/cli/reset.rb

@@ -1,4 +1,5 @@
 require 'autoproj/cli'
+require 'autoproj/cli/inspection_tool'
 require 'autoproj/cli/update'
 require 'autoproj/cli/versions'
 

data/lib/autoproj/cli/status.rb

@@ -31,7 +31,7 @@ def run(user_selection, options = Hash.new)
                     pkg_sets = ws.manifest.each_package_set.to_a
                     if !pkg_sets.empty?
                         Autoproj.message("autoproj: displaying status of configuration", :bold)
-                        display_status(pkg_sets, snapshot: options[:snapshot], only_local: options[:only_local])
+                        display_status(pkg_sets, parallel: options[:parallel], snapshot: options[:snapshot], only_local: options[:only_local])
                         STDERR.puts
                     end
                 end
@@ -133,7 +133,8 @@ def status_of_package(package_description, options = Hash.new)
             def display_status(packages, options = Hash.new)
                 result = StatusResult.new
 
-                executor = Concurrent::FixedThreadPool.new(ws.config.parallel_import_level, max_length: 0)
+                parallel = options[:parallel] || ws.config.parallel_import_level
+                executor = Concurrent::FixedThreadPool.new(parallel, max_length: 0)
                 interactive, noninteractive = packages.partition do |pkg|
                     pkg.autobuild.importer && pkg.autobuild.importer.interactive?
                 end

data/lib/autoproj/cli/tag.rb

@@ -6,8 +6,12 @@
 module Autoproj
     module CLI
         class Tag < Base
-            def run(tag_name, *user_selection, options = Hash.new)
-                pkg = manifest.main_package_set.create_autobuild_package
+            def run(arguments, options = Hash.new)
+                tag_name, *user_selection = *arguments
+                ws.load_config
+                main_package_set = LocalPackageSet.new(ws.manifest, ws.config_dir)
+
+                pkg = main_package_set.create_autobuild_package
                 importer = pkg.importer
                 if !importer || !importer.kind_of?(Autobuild::Git)
                     raise ConfigError, "cannot use autoproj tag if the main configuration is not managed by git"
@@ -21,6 +25,7 @@ def run(tag_name, *user_selection, options = Hash.new)
                     importer = pkg.importer
                     all_tags = importer.run_git_bare(pkg, 'tag')
                     all_tags.sort.each do |tag|
+                        next if tag =~ /\^/
                         begin importer.show(pkg, "refs/tags/#{tag}", versions_file)
                             puts tag
                         rescue Autobuild::PackageException
@@ -43,7 +48,7 @@ def run(tag_name, *user_selection, options = Hash.new)
                     Autoproj.message "creating versions file, this may take a while"
                     versions.run(user_selection,
                                  package_sets: options[:package_sets],
-                                 output_file: io.path,
+                                 save: io.path,
                                  replace: true,
                                  keep_going: options[:keep_going])
                 end

data/lib/autoproj/cli/upgrade.rb

@@ -1,47 +1,31 @@
+require 'autoproj/ops/install'
+require 'autoproj/find_workspace'
 module Autoproj
     module CLI
         class Upgrade
-            def initialize(root_dir)
-                @root_dir = root_dir
-            end
-
-            def upgrade_from_v2
-                require 'autoproj/ops/install'
-                installer = Autoproj::Ops::Install.new(root_dir)
+            def upgrade_from_v2(installer, options = Hash.new)
                 installer.install
             end
 
-            def find_v1_root_dir(base_dir = ENV['AUTOPROJ_CURRENT_ROOT'] || Dir.pwd)
-                path = Pathname.new(base_dir)
-                while !path.root?
-                    if (path + "autoproj").exist?
-                        break
-                    end
-                    path = path.parent
-                end
+            def upgrade_from_v1(installer, options = Hash.new)
+                root_dir = installer.root_dir
 
-                if path.root?
-                    return
+                # Save a backup of the existing env.sh (if the backup does not
+                # already exist) to make it easier for a user to downgrade
+                env_backup = File.join(root_dir, 'env.sh-autoproj-v1')
+                if !File.file?(env_backup)
+                    FileUtils.cp File.join(root_dir, 'env.sh'), env_backup
                 end
 
-                # I don't know if this is still useful or not ... but it does not hurt
-                #
-                # Preventing backslashed in path, that might be confusing on some path compares
-                if Autobuild.windows?
-                    result = result.gsub(/\\/,'/')
-                end
-                result
-            end
-
-            def upgrade_from_v1
                 # Do an install
-                require 'autoproj/ops/install'
-                installer = Autoproj::Ops::Install.new(root_dir)
                 installer.run
-                # Copy the current configuration
+
+                # Copy the current configuration, merging it with the autoproj
+                # 2.x attributes
                 current_config = File.open(File.join(root_dir, 'autoproj', 'config.yml')) do |io|
                     YAML.load(io)
                 end
+                config_file_path = File.join(root_dir, '.autoproj', 'config.yml')
                 new_config = File.open(config_file_path) do |io|
                     YAML.load(io)
                 end
@@ -49,20 +33,40 @@ def upgrade_from_v1
                     io.write YAML.dump(current_config.merge(new_config))
                 end
 
-                Autoproj.message "now, open a new console, source env.sh and run"
-                Autoproj.message "  autoproj osdeps"
-                Autoproj.message "  autoproj envsh"
+                # Copy the remotes symlinks
+                FileUtils.cp_r File.join(root_dir, '.remotes'), File.join(root_dir, '.autoproj', 'remotes')
+                # Copy the installation manifest
+                FileUtils.cp File.join(root_dir, '.autoproj-installation-manifest'),
+                    File.join(root_dir, '.autoproj', 'installation-manifest')
+
+                puts "now, open a new console, source env.sh and run"
+                puts "  autoproj osdeps"
+                puts "  autoproj envsh"
+            end
+
+            def create_installer(root_dir, options = Hash.new)
+                installer = Autoproj::Ops::Install.new(root_dir)
+                installer.local = options[:local]
+                installer.private_bundler  = options[:private_bundler] || options[:private]
+                installer.private_autoproj = options[:private_autoproj] || options[:private]
+                installer.private_gems     = options[:private_gems] || options[:private]
+                if gemfile_path = options[:gemfile]
+                    installer.gemfile = File.read(gemfile_path)
+                end
+                installer
             end
 
-            def run(*args)
-                root_dir = Workspace.find_root_dir
+            def run(options = Hash.new)
+                root_dir = Autoproj.find_v2_workspace_dir
                 if root_dir && File.directory?(File.join(root_dir, '.autoproj'))
-                    return upgrade_from_v2
+                    installer = create_installer(root_dir, options)
+                    return upgrade_from_v2(installer, options)
                 end
 
-                root_dir = find_v1_root_dir
-                if root_dir && File.directory?(root_dir, '.gems')
-                    return upgrade_from_v1
+                root_dir = Autoproj.find_v1_workspace_dir
+                if root_dir && File.directory?(File.join(root_dir, '.gems'))
+                    installer = create_installer(root_dir, options)
+                    return upgrade_from_v1(installer, options)
                 end
             end
         end

data/lib/autoproj/environment.rb

@@ -8,8 +8,16 @@ class Environment < Autobuild::Environment
         attr_reader :root_dir
 
         def prepare(root_dir)
+            super()
+
             @root_dir = root_dir
             set 'AUTOPROJ_CURRENT_ROOT', root_dir
+
+            @original_env = original_env.map_value do |name, value|
+                filtered = value.split(File::PATH_SEPARATOR).
+                    find_all { |p| !Workspace.in_autoproj_project?(p) }
+                filtered.join(File::PATH_SEPARATOR)
+            end
         end
 
         def expand(value)

data/lib/autoproj/exceptions.rb

@@ -49,6 +49,10 @@ class WorkspaceAlreadyCreated < RuntimeError; end
     # Exception raised when looking for a workspace and it cannot be found
     class NotWorkspace < RuntimeError; end
 
+    # Exception raised when the autoproj workspace changes and the current
+    # workspace is outdated
+    class OutdatedWorkspace < RuntimeError; end
+
     # Exception raised when initializing on a workspace that is not the current
     # one
     class MismatchingWorkspace < RuntimeError; end

data/lib/autoproj/find_workspace.rb

@@ -0,0 +1,83 @@
+require 'pathname'
+require 'yaml'
+
+module Autoproj
+    # The base path from which we search for workspaces
+    def self.defaulT_find_base_dir
+        ENV['AUTOPROJ_CURRENT_ROOT'] || Dir.pwd
+    end
+
+    # Looks for the autoproj workspace that is related to a given directory
+    #
+    # @return [String,nil]
+    def self.find_workspace_dir(base_dir = defaulT_find_base_dir)
+        find_v2_workspace_dir(base_dir)
+    end
+
+    # Looks for the autoproj prefix that contains a given directory
+    #
+    # @return [String,nil]
+    def self.find_prefix_dir(base_dir = defaulT_find_base_dir)
+        find_v2_prefix_dir(base_dir)
+    end
+
+    # @private
+    #
+    # Finds an autoproj "root directory" that contains a given directory. It
+    # can either be the root of a workspace or the root of an install
+    # directory
+    #
+    # @param [String] base_dir the start of the search
+    # @param [String] config_field_name the name of a field in the root's
+    #   configuration file, that should be returned instead of the root
+    #   itself
+    # @return [String,nil] the root of the workspace directory, or nil if
+    #   there's none
+    def self.find_v2_root_dir(base_dir, config_field_name)
+        path = Pathname.new(base_dir)
+        while !path.root?
+            if (path + ".autoproj").exist?
+                break
+            end
+            path = path.parent
+        end
+
+        if path.root?
+            return
+        end
+
+        config_path = path + ".autoproj" + "config.yml"
+        if config_path.exist?
+            config = YAML.load(config_path.read) || Hash.new
+            result = config[config_field_name] || path.to_s
+            File.expand_path(result, path.to_s)
+        else
+            path.to_s 
+        end
+    end
+
+    # {#find_workspace_dir} for v2 workspaces
+    def self.find_v2_workspace_dir(base_dir = defaulT_find_base_dir)
+        find_v2_root_dir(base_dir, 'workspace')
+    end
+
+    # {#find_prefix_dir} for v2 workspaces
+    def self.find_v2_prefix_dir(base_dir = defaulT_find_base_dir)
+        find_v2_root_dir(base_dir, 'prefix')
+    end
+
+    # {#find_workspace_dir} for v1 workspaces
+    #
+    # Note that for v1 workspaces {#find_prefix_dir} cannot be implemented
+    def self.find_v1_workspace_dir(base_dir = defaulT_find_base_dir)
+        path = Pathname.new(base_dir)
+        while !path.root?
+            if (path + "autoproj").exist?
+                return path.to_s
+            end
+            path = path.parent
+        end
+        nil
+    end
+end
+

data/lib/autoproj/ops/install.rb

@@ -1,3 +1,4 @@
+require 'pathname'
 require 'optparse'
 require 'fileutils'
 require 'yaml'
@@ -10,19 +11,65 @@ module Ops
         # It can be required standalone (i.e. does not depend on anything else than
         # ruby and the ruby standard library)
         class Install
+            class UnexpectedBinstub < RuntimeError; end
+
             # The directory in which to install autoproj
             attr_reader :root_dir
             # Content of the Gemfile generated to install autoproj itself
             attr_accessor :gemfile
+            # The environment that is passed to the bundler installs
+            attr_reader :env
 
             def initialize(root_dir)
                 @root_dir = root_dir
-                @gemfile  = default_gemfile_contents
+                if File.file?(autoproj_gemfile_path)
+                    @gemfile = File.read(autoproj_gemfile_path)
+                else
+                    @gemfile = default_gemfile_contents
+                end
+
                 @private_bundler  = false
                 @private_autoproj = false
                 @private_gems     = false
+                @local = false
+                @env = self.class.clean_env
+            end
+
+            def self.clean_env
+                env = Hash.new
+                env['RUBYLIB'] = []
+                env['GEM_PATH'] = []
+                %w{PATH GEM_HOME}.each do |name|
+                    env[name] = sanitize_env(ENV[name] || "")
+                end
+                env['BUNDLE_GEMFILE'] = nil
+                env
             end
 
+            def env_for_child
+                env.inject(Hash.new) do |h, (k, v)|
+                    h[k] = (v.join(File::PATH_SEPARATOR) if v && !v.empty?)
+                    h
+                end
+            end
+
+            def self.sanitize_env(value)
+                value.split(File::PATH_SEPARATOR).
+                    find_all { |p| !in_workspace?(p) }
+            end
+
+            def self.in_workspace?(base_dir)
+                path = Pathname.new(base_dir)
+                while !path.root?
+                    if (path + ".autoproj").exist? || (path + "autoproj").exist?
+                        return true
+                    end
+                    path = path.parent
+                end
+                return false
+            end
+
+
             def dot_autoproj; File.join(root_dir, '.autoproj') end
             def bin_dir; File.join(dot_autoproj, 'bin') end
             def bundler_install_dir; File.join(dot_autoproj, 'bundler') end
@@ -31,13 +78,24 @@ def autoproj_install_dir; File.join(dot_autoproj, 'autoproj') end
             def autoproj_gemfile_path; File.join(autoproj_install_dir, 'Gemfile') end
             def autoproj_config_path; File.join(dot_autoproj, 'config.yml') end
 
+            # Whether we can access the network while installing
+            def local?; !!@local end
+            # (see #local?)
+            def local=(flag); @local = flag end
+
             # Whether bundler should be installed locally in {#dot_autoproj}
             def private_bundler?; @private_bundler end
+            # (see #private_bundler?)
+            def private_bundler=(flag); @private_bundler = flag end
             # Whether autoproj should be installed locally in {#dot_autoproj}
             def private_autoproj?; @private_autoproj end
+            # (see #private_autoproj?)
+            def private_autoproj=(flag); @private_autoproj = flag end
             # Whether bundler should be installed locally in the workspace
             # prefix directory
             def private_gems?; @private_gems end
+            # (see #private_gems?)
+            def private_gems=(flag); @private_gems = flag end
 
             def guess_gem_program
                 ruby_bin = RbConfig::CONFIG['RUBY_INSTALL_NAME']
@@ -61,14 +119,18 @@ def guess_gem_program
             # @param [String] autoproj_version a constraint on the autoproj version
             #   that should be used
             # @return [String]
-            def default_gemfile_contents(autoproj_version = ">= 0")
+            def default_gemfile_contents(autoproj_version = ">= 2.0.0.a")
                 ["source \"https://rubygems.org\"",
-                 "gem \"autoproj\", \"#{autoproj_version}\""].join("\n")
+                 "gem \"autoproj\", \"#{autoproj_version}\"",
+                 "gem \"utilrb\", \">= 3.0.0.a\""].join("\n")
             end
 
             # Parse the provided command line options and returns the non-options
             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 '--private-bundler', 'install bundler locally in the workspace' do
                         @private_bundler = true
                     end
@@ -97,28 +159,37 @@ def install_bundler
                 gem_program  = guess_gem_program
                 puts "Detected 'gem' to be #{gem_program}"
 
+                local = ['--local'] if local?
+
                 result = system(
-                    Hash['GEM_PATH' => nil,
-                         'GEM_HOME' => bundler_install_dir],
+                    env_for_child.merge('GEM_PATH' => nil, 'GEM_HOME' => bundler_install_dir),
                     gem_program, 'install', '--no-document', '--no-user-install', '--no-format-executable',
+                        *local,
                         "--bindir=#{File.join(bundler_install_dir, 'bin')}", 'bundler')
 
                 if !result
                     STDERR.puts "FATAL: failed to install bundler in #{dot_autoproj}"
                     exit 1
                 end
+                env['GEM_PATH'] << bundler_install_dir
+                env['PATH'] << File.join(bundler_install_dir, 'bin')
                 File.join(bin_dir, 'bundler')
             end
 
             def save_env_sh
                 env = Autobuild::Environment.new
-                path = []
-                if private_bundler?
-                    env.push_path 'PATH', File.join(bundler_install_dir, 'bin')
-                    env.push_path 'GEM_PATH', bundler_install_dir
+                env.prepare
+
+                %w{GEM_HOME GEM_PATH}.each do |name|
+                    value = self.env[name]
+                    if value.empty?
+                        env.unset name
+                    else
+                        env.set name, *value
+                    end
                 end
                 env.push_path 'PATH', File.join(autoproj_install_dir, 'bin')
-                env.inherit 'PATH'
+
                 if private_autoproj?
                     env.push_path 'GEM_PATH', autoproj_install_dir
                 end
@@ -142,7 +213,9 @@ def save_gemfile
                     io.write gemfile
                 end
             end
-            
+
+            ENV_BUNDLE_GEMFILE_RX = /^(\s*ENV\[['"]BUNDLE_GEMFILE['"]\]\s*)(?:\|\|)?=/
+
             def install_autoproj(bundler)
                 # Force bundler to update. If the user does not want this, let him specify a
                 # Gemfile with tighter version constraints
@@ -151,24 +224,57 @@ def install_autoproj(bundler)
                     FileUtils.rm lockfile
                 end
 
-                env = Hash['BUNDLE_GEMFILE' => nil, 'RUBYLIB' => nil]
                 opts = Array.new
+                opts << '--local' if local?
 
+                env = env_for_child
                 if private_autoproj?
-                    env = Hash['GEM_PATH' => bundler_install_dir,
-                               'GEM_HOME' => nil]
+                    env = env.merge(
+                        'GEM_PATH' => bundler_install_dir,
+                        'GEM_HOME' => nil)
                     opts << "--clean" << "--path=#{autoproj_install_dir}"
                 end
 
+                binstubs_path = File.join(autoproj_install_dir, 'bin')
+
                 result = system(env,
-                    bundler, 'install',
+                    Gem.ruby, bundler, 'install',
                         "--gemfile=#{autoproj_gemfile_path}",
-                        "--binstubs=#{File.join(autoproj_install_dir, 'bin')}",
+                        "--binstubs=#{binstubs_path}",
                         *opts)
                 if !result
                     STDERR.puts "FATAL: failed to install autoproj in #{dot_autoproj}"
                     exit 1
                 end
+
+                # Now tune the binstubs to force the usage of the autoproj
+                # gemfile. Otherwise, they get BUNDLE_GEMFILE from the
+                # environment by default
+                Dir.glob(File.join(binstubs_path, '*')) do |path|
+                    next if !File.file?(path)
+                    # Do NOT do that for bundler, otherwise it will fail with an
+                    # "already loaded gemfile" message once we e.g. try to do
+                    # 'bundler install --gemfile=NEW_GEMFILE'
+                    next if File.basename(path) == 'bundler'
+
+                    lines = File.readlines(path)
+                    matched = false
+                    filtered = lines.map do |l|
+                        matched ||= (ENV_BUNDLE_GEMFILE_RX === l)
+                        l.gsub(ENV_BUNDLE_GEMFILE_RX, '\\1=')
+                    end
+                    if !matched
+                        raise UnexpectedBinstub, "expected #{path} to contain a line looking like ENV['BUNDLE_GEMFILE'] ||= but could not find one"
+                    end
+                    File.open(path, 'w') do |io|
+                        io.write filtered.join("")
+                    end
+                end
+
+                env['PATH'] << File.join(autoproj_install_dir, 'bin')
+                if private_autoproj?
+                    env['GEM_PATH'] << autoproj_install_dir
+                end
             end
 
             def update_configuration
@@ -185,25 +291,92 @@ def update_configuration
                 end
             end
 
+            def find_in_clean_path(command)
+                clean_path = env_for_child['PATH'].split(File::PATH_SEPARATOR)
+                clean_path.each do |p|
+                    full_path = File.join(p, command)
+                    if File.file?(full_path)
+                        return full_path
+                    end
+                end
+                nil
+            end
+
+            def find_bundler
+                clean_env = env_for_child
+                Gem.paths = Hash[
+                    'GEM_HOME' => clean_env['GEM_HOME'] || Gem.default_dir,
+                    'GEM_PATH' => clean_env['GEM_PATH'] || nil
+                ]
+                # 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(clean_env, [Gem.ruby, '-e', 'puts Gem.bindir']).read
+                if bindir
+                    env['PATH'].unshift bindir.chomp
+                else
+                    STDERR.puts "FATAL: cannot run #{Gem.ruby} -e 'puts Gem.bindir'"
+                    exit 1
+                end
+
+                bundler = find_in_clean_path('bundler')
+                if !bundler
+                    clean_path = env_for_child['PATH']
+                    STDERR.puts "FATAL: cannot find 'bundler' in PATH=#{clean_path}"
+                    if ENV['PATH'] != clean_path
+                        STDERR.puts "  it appears that you already have some autoproj-generated env.sh loaded"
+                        STDERR.puts "  - if you are running 'autoproj upgrade', please contact the autoproj author at https://github.com/rock-core/autoproj/issues/new"
+                        STDERR.puts "  - if you are running an install, try again in a console where the env.sh is not loaded"
+                        exit 1
+                    else
+                        STDERR.puts "  the recommended action is to install it manually first by running 'gem install bundler'"
+                        STDERR.puts "  or call this command again with --private-bundler to have it installed in the workspace"
+                        exit 1
+                    end
+                end
+                bundler
+            end
+
             def install
                 if private_bundler?
                     puts "Installing bundler in #{bundler_install_dir}"
                     bundler = install_bundler
+                else
+                    bundler = find_bundler
+                    puts "Detected bundler at #{bundler}"
                 end
                 save_gemfile
                 puts "Installing autoproj in #{dot_autoproj}"
-                install_autoproj(bundler || 'bundler')
+                install_autoproj(bundler)
             end
 
             # Actually perform the install
-            def run
-                install
-                ENV['BUNDLE_GEMFILE'] = autoproj_gemfile_path
-                require 'bundler'
-                Bundler.setup
-                require 'autobuild'
-                save_env_sh
-                update_configuration
+            def run(stage2: false)
+                if stage2
+                    require 'autobuild'
+                    save_env_sh
+                else
+                    install
+
+                    env_for_child.each do |k, v|
+                        if v
+                            ENV[k] = v
+                        else
+                            ENV.delete(k)
+                        end
+                    end
+                    ENV['BUNDLE_GEMFILE'] = autoproj_gemfile_path
+                    update_configuration
+                    exec Gem.ruby, File.join(autoproj_install_dir, 'bin', 'autoproj'),
+                        'install-stage2', root_dir
+                end
             end
         end
     end