autoproj 1.10.2 → 1.11.0.b1

data/lib/autoproj/ops/loader.rb

@@ -0,0 +1,97 @@
+module Autoproj
+    module Ops
+    class Loader
+        # @return [Array<String>] information about what is being loaded
+        attr_reader :file_stack
+
+        def initialize
+            @file_stack = Array.new
+        end
+
+        def in_package_set(pkg_set, path)
+            @file_stack.push([pkg_set, File.expand_path(path).gsub(/^#{Regexp.quote(Autoproj.root_dir)}\//, '')])
+            yield
+        ensure
+            @file_stack.pop
+        end
+
+        def filter_load_exception(error, package_set, path)
+            raise error if Autoproj.verbose
+            rx_path = Regexp.quote(path)
+            if error_line = error.backtrace.find { |l| l =~ /#{rx_path}/ }
+                if line_number = Integer(/#{rx_path}:(\d+)/.match(error_line)[1])
+                    line_number = "#{line_number}:"
+                end
+
+                if package_set.local?
+                    raise ConfigError.new(path), "#{path}:#{line_number} #{error.message}", error.backtrace
+                else
+                    raise ConfigError.new(path), "#{File.basename(path)}(package_set=#{package_set.name}):#{line_number} #{error.message}", error.backtrace
+                end
+            else
+                raise error
+            end
+        end
+
+        # Returns the information about the file that is currently being loaded
+        #
+        # The return value is [package_set, path], where +package_set+ is the
+        # PackageSet instance and +path+ is the path of the file w.r.t. the autoproj
+        # root directory
+        def current_file
+            if file = @file_stack.last
+                file
+            else raise ArgumentError, "not in a #in_package_set context"
+            end
+        end
+
+        # The PackageSet object representing the package set that is currently being
+        # loaded
+        def current_package_set
+            current_file.first
+        end
+
+        # Load a definition file from a package set
+        #
+        # If any error is detected, the backtrace will be filtered so that it is
+        # easier to understand by the user. Moreover, if +source+ is non-nil, the
+        # package set name will be mentionned.
+        #
+        # @param [PackageSet] pkg_set
+        # @param [Array<String>] path
+        def load(pkg_set, *path)
+            path = File.join(*path)
+            in_package_set(pkg_set, File.expand_path(path).gsub(/^#{Regexp.quote(Autoproj.root_dir)}\//, '')) do
+                begin
+                    Kernel.load path
+                rescue Interrupt
+                    raise
+                rescue ConfigError => e
+                    raise
+                rescue Exception => e
+                    filter_load_exception(e, pkg_set, path)
+                end
+            end
+        end
+
+        # Load a definition file from a package set if the file is present
+        #
+        # (see load)
+        def load_if_present(pkg_set, *path)
+            path = File.join(*path)
+            if File.file?(path)
+                load(pkg_set, *path)
+            end
+        end
+    end
+
+    # Singleton object that maintains the loading state
+    #
+    # Note that it is here hopefully temporarily. All the Ops classes should
+    # have their loader object given at construction time
+    def self.loader
+        @loader ||= Loader.new
+    end
+    end
+end
+

data/lib/autoproj/ops/main_config_switcher.rb

@@ -0,0 +1,271 @@
+module Autoproj
+    module Ops
+        # Operations that modify the source of the main configuration (bootstrap
+        # and switch-config)
+        class MainConfigSwitcher
+            attr_reader :root_dir
+
+            def initialize(root_dir)
+                @root_dir = root_dir
+            end
+
+            # Set of directory entries that are expected to be present in the
+            # directory in which the user bootstraps
+            #
+            # @see check_root_dir_empty
+            EXPECTED_ROOT_ENTRIES = [".", "..", "autoproj_bootstrap",
+                                     ".gems", "bootstrap.sh", ENV_FILENAME].to_set
+
+            # Verifies that {#root_dir} contains only expected entries, to make
+            # sure that the user bootstraps into a new directory
+            #
+            # If the environment variable AUTOPROJ_BOOTSTRAP_IGNORE_NONEMPTY_DIR
+            # is set to 1, the check is skipped
+            def check_root_dir_empty
+                return if ENV['AUTOPROJ_BOOTSTRAP_IGNORE_NONEMPTY_DIR'] == '1'
+
+                require 'set'
+                curdir_entries = Dir.entries('.').to_set - EXPECTED_ROOT_ENTRIES
+                return if curdir_entries.empty?
+
+                while true
+                    print "The current directory is not empty, continue bootstrapping anyway ? [yes] "
+                    STDOUT.flush
+                    answer = STDIN.readline.chomp
+                    if answer == "no"
+                        raise Interrupt, "Interrupted by user"
+                    end
+
+                    if answer == "" || answer == "yes"
+                        # Set this environment variable since we might restart
+                        # autoproj later on.
+                        ENV['AUTOPROJ_BOOTSTRAP_IGNORE_NONEMPTY_DIR'] = '1'
+                        return
+                    else
+                        STDOUT.puts "invalid answer. Please answer 'yes' or 'no'"
+                        STDOUT.flush
+                    end
+                end
+            end
+
+            # Validates the environment variable AUTOPROJ_CURRENT_ROOT during a
+            # bootstrap
+            #
+            # AUTOPROJ_CURRENT_ROOT must be set to either the new root
+            # ({root_dir}) or a root that we are reusing
+            #
+            # @param [Array<String>] reuse set of autoproj roots that are being reused
+            # @raise ConfigError
+            def validate_autoproj_current_root(reuse)
+                if current_root = ENV['AUTOPROJ_CURRENT_ROOT']
+                    # Allow having a current root only if it is being reused
+                    if (current_root != root_dir) && !reuse.include?(current_root)
+                        Autoproj.error "the env.sh from #{ENV['AUTOPROJ_CURRENT_ROOT']} seem to already be sourced"
+                        Autoproj.error "start a new shell and try to bootstrap again"
+                        Autoproj.error
+                        Autoproj.error "you are allowed to boostrap from another autoproj installation"
+                        Autoproj.error "only if you reuse it with the --reuse flag"
+                        raise ConfigError
+                    end
+                end
+            end
+
+            def handle_bootstrap_options(args)
+                reuse = []
+                parser = OptionParser.new do |opt|
+                    opt.on '--reuse [DIR]', "reuse the given autoproj installation (can be given multiple times). If given without arguments, reuse the currently active install (#{ENV['AUTOPROJ_CURRENT_ROOT']})" do |path|
+                        path ||= ENV['AUTOPROJ_CURRENT_ROOT']
+
+                        path = File.expand_path(path)
+                        if !File.directory?(path) || !File.directory?(File.join(path, 'autoproj'))
+                            raise ConfigError.new, "#{path} does not look like an autoproj installation"
+                        end
+                        reuse << path
+                    end
+                end
+                args = parser.parse(args)
+                return args, reuse
+            end
+
+            def bootstrap(*args)
+                if File.exists?(File.join(root_dir, 'autoproj', "manifest"))
+                    raise ConfigError.new, "this installation is already bootstrapped. Remove the autoproj directory if it is not the case"
+                end
+
+                check_root_dir_empty
+                args, reuse = handle_bootstrap_options(args)
+                validate_autoproj_current_root(reuse)
+
+                Autoproj.root_dir = root_dir
+                Autobuild.prefix  = Autoproj.build_dir
+                Autobuild.srcdir  = Autoproj.root_dir
+                Autobuild.logdir = File.join(Autobuild.prefix, 'log')
+
+                Autoproj.manifest = Manifest.new
+                load_autoprojrc
+                Autoproj.prepare_environment
+
+                Autoproj::OSDependencies.define_osdeps_mode_option
+                osdeps = Autoproj::OSDependencies.load_default
+                if osdeps_forced_mode
+                    osdeps.osdeps_mode = osdeps_forced_mode
+                end
+                osdeps.osdeps_mode
+
+                CmdLine.update_myself :force => true, :restart_on_update => false
+                Autoproj.change_option 'reused_autoproj_installations', reuse, true
+                Autoproj.export_env_sh
+
+                # If we are not getting the installation setup from a VCS, copy the template
+                # files
+                if args.empty? || args.size == 1
+                    sample_dir = File.expand_path(File.join("..", "..", "samples"), File.dirname(__FILE__))
+                    FileUtils.cp_r File.join(sample_dir, "autoproj"), "autoproj"
+                end
+
+                if args.size == 1 # the user asks us to download a manifest
+                    manifest_url = args.first
+                    Autoproj.message("autoproj: downloading manifest file #{manifest_url}", :bold)
+                    manifest_data =
+                        begin open(manifest_url) { |file| file.read }
+                        rescue
+                            # Delete the autoproj directory
+                            FileUtils.rm_rf 'autoproj'
+                            raise ConfigError.new, "cannot read file / URL #{manifest_url}, did you mean 'autoproj bootstrap VCSTYPE #{manifest_url}' ?"
+                        end
+
+                    File.open(File.join(Autoproj.config_dir, "manifest"), "w") do |io|
+                        io.write(manifest_data)
+                    end
+
+                elsif args.size >= 2 # is a VCS definition for the manifest itself ...
+                    type, url, *options = *args
+                    url = VCSDefinition.to_absolute_url(url, Dir.pwd)
+                    do_switch_config(false, type, url, *options)
+                end
+                Autoproj.save_config
+            end
+
+            def switch_config(*args)
+                Autoproj.load_config
+                if Autoproj.has_config_key?('manifest_source')
+                    vcs = VCSDefinition.from_raw(Autoproj.user_config('manifest_source'))
+                end
+
+                if args.first =~ /^(\w+)=/
+                    # First argument is an option string, we are simply setting the
+                    # options without changing the type/url
+                    type, url = vcs.type, vcs.url
+                else
+                    type, url = args.shift, args.shift
+                end
+                options = args
+
+                url = VCSDefinition.to_absolute_url(url)
+
+                if vcs && (vcs.type == type && vcs.url == url)
+                    # Don't need to do much: simply change the options and save the config
+                    # file, the VCS handler will take care of the actual switching
+                    vcs_def = Autoproj.user_config('manifest_source')
+                    options.each do |opt|
+                        opt_name, opt_value = opt.split('=')
+                        vcs_def[opt_name] = opt_value
+                    end
+                    # Validate the VCS definition, but save the hash as-is
+                    VCSDefinition.from_raw(vcs_def)
+                    Autoproj.change_option "manifest_source", vcs_def.dup, true
+                    Autoproj.save_config
+                    true
+
+                else
+                    # We will have to delete the current autoproj directory. Ask the user.
+                    opt = Autoproj::BuildOption.new("delete current config", "boolean",
+                                Hash[:default => "false",
+                                    :doc => "delete the current configuration ? (required to switch)"], nil)
+
+                    return if !opt.ask(nil)
+
+                    Dir.chdir(Autoproj.root_dir) do
+                        do_switch_config(true, type, url, *options)
+                    end
+                    false
+                end
+            end
+
+            def do_switch_config(delete_current, type, url, *options)
+                vcs_def = Hash.new
+                vcs_def[:type] = type
+                vcs_def[:url]  = VCSDefinition.to_absolute_url(url)
+                options.each do |opt|
+                    name, value = opt.split("=")
+                    if value =~ /^\d+$/
+                        value = Integer(value)
+                    end
+
+                    vcs_def[name] = value
+                end
+
+                vcs = VCSDefinition.from_raw(vcs_def)
+
+                # Install the OS dependencies required for this VCS
+                Autoproj::OSDependencies.define_osdeps_mode_option
+                osdeps = Autoproj::OSDependencies.load_default
+                osdeps.osdeps_mode
+                osdeps.install([vcs.type])
+
+                # Now check out the actual configuration
+                config_dir = File.join(Dir.pwd, "autoproj")
+                if delete_current
+                    # Find a backup name for it
+                    backup_base_name = backup_name = "#{config_dir}.bak"
+                    index = 0
+                    while File.directory?(backup_name)
+                        backup_name = "#{backup_base_name}-#{index}.bak"
+                        index += 1
+                    end
+                        
+                    FileUtils.mv config_dir, backup_name
+                end
+                Ops::Configuration.update_configuration_repository(
+                    vcs,
+                    "autoproj main configuration",
+                    config_dir)
+
+                # If the new tree has a configuration file, load it and set
+                # manifest_source
+                Autoproj.load_config
+
+                # And now save the options: note that we keep the current option set even
+                # though we switched configuration. This is not a problem as undefined
+                # options will not be reused
+                #
+                # TODO: cleanup the options to only keep the relevant ones
+                vcs_def = Hash['type' => type, 'url' => url]
+                options.each do |opt|
+                    opt_name, opt_val = opt.split '='
+                    vcs_def[opt_name] = opt_val
+                end
+                # Validate the option hash, just in case
+                VCSDefinition.from_raw(vcs_def)
+                # Save the new options
+                Autoproj.change_option "manifest_source", vcs_def.dup, true
+                Autoproj.save_config
+
+            rescue Exception => e
+                Autoproj.error "switching configuration failed: #{e.message}"
+                if backup_name
+                    Autoproj.error "restoring old configuration"
+                    FileUtils.rm_rf config_dir if config_dir
+                    FileUtils.mv backup_name, config_dir
+                end
+                raise
+            ensure
+                if backup_name
+                    FileUtils.rm_rf backup_name
+                end
+            end
+        end
+    end
+end
+
+

data/lib/autoproj/ops/tools.rb

@@ -0,0 +1,54 @@
+module Autoproj
+    module Ops
+    module Tools
+        # Data structure used to use autobuild importers without a package, to
+        # import configuration data.
+        #
+        # It has to match the interface of Autobuild::Package that is relevant
+        # for importers
+        class FakePackage < Autobuild::Package
+            attr_reader :srcdir
+            attr_reader :importer
+
+            # Used by the autobuild importers
+            attr_accessor :updated
+
+            def autoproj_name
+                name
+            end
+
+            def initialize(text_name, srcdir, importer = nil)
+                super(text_name)
+                @srcdir = srcdir
+                @importer = importer
+                @@packages.delete(text_name)
+            end
+
+            def import(only_local = false)
+                importer.import(self, only_local)
+            end
+
+            def add_stat(*args)
+            end
+        end
+
+        # Creates an autobuild package whose job is to allow the import of a
+        # specific repository into a given directory.
+        #
+        # +vcs+ is the VCSDefinition file describing the repository, +text_name+
+        # the name used when displaying the import progress, +pkg_name+ the
+        # internal name used to represent the package and +into+ the directory
+        # in which the package should be checked out.
+        def create_autobuild_package(vcs, text_name, into)
+            importer     = vcs.create_autobuild_importer
+            FakePackage.new(text_name, into, importer)
+
+        rescue Autobuild::ConfigException => e
+            raise ConfigError.new, "cannot import #{text_name}: #{e.message}", e.backtrace
+        end
+
+        extend Tools
+    end
+    end
+end
+

data/lib/autoproj/options.rb

@@ -1,203 +1,51 @@
 module Autoproj
-    class InputError < RuntimeError; end
-
-    class << self
-        # Programatically overriden autoproj options
-        #
-        # @see override_option
-        attr_reader :option_overrides
-    end
-    @option_overrides = Hash.new
-
-    # Programatically override a user-selected option without changing the
-    # configuration file
+    # @deprecated use config.override instead
     def self.override_option(option_name, value)
-        @option_overrides[option_name] = value
+        config.override(option_name, value)
     end
-
-    class BuildOption
-        attr_reader :name
-        attr_reader :type
-        attr_reader :options
-
-        attr_reader :validator
-
-        TRUE_STRINGS = %w{on yes y true}
-        FALSE_STRINGS = %w{off no n false}
-        def initialize(name, type, options, validator)
-            @name, @type, @options = name.to_str, type.to_str, options.to_hash
-            @validator = validator.to_proc if validator
-            if !BuildOption.respond_to?("validate_#{type}")
-                raise ConfigError.new, "invalid option type #{type}"
-            end
-        end
-
-        def short_doc
-            if short_doc = options[:short_doc]
-                short_doc
-            elsif doc = options[:doc]
-                if doc.respond_to?(:to_ary) then doc.first
-                else doc
-                end
-            else "#{name} (no documentation for this option)"
-            end
-        end
-
-        def doc
-            doc = (options[:doc] || "#{name} (no documentation for this option)")
-            if doc.respond_to?(:to_ary) # multi-line
-                first_line = doc[0]
-                remaining = doc[1..-1]
-                if remaining.empty?
-                    first_line
-                else
-                    remaining = remaining.join("\n").split("\n").join("\n    ")
-                    Autoproj.color(first_line, :bold) + "\n    " + remaining
-                end
-            else
-                doc
-            end
-        end
-
-        def ask(current_value, doc = nil)
-            default_value =
-		if !current_value.nil? then current_value.to_s
-		elsif options[:default] then options[:default].to_str
-		else ''
-		end
-
-            STDOUT.print "  #{doc || self.doc} [#{default_value}] "
-            STDOUT.flush
-            answer = STDIN.readline.chomp
-            if answer == ''
-                answer = default_value
-            end
-            validate(answer)
-
-        rescue InputError => e
-            Autoproj.message("invalid value: #{e.message}", :red)
-            retry
-        end
-
-        def validate(value)
-            value = BuildOption.send("validate_#{type}", value, options)
-            if validator
-                value = validator[value]
-            end
-            value
-        end
-
-        def self.validate_boolean(value, options)
-            if TRUE_STRINGS.include?(value.downcase)
-                true
-            elsif FALSE_STRINGS.include?(value.downcase)
-                false
-            else
-                raise InputError, "invalid boolean value '#{value}', accepted values are '#{TRUE_STRINGS.join(", ")}' for true, and '#{FALSE_STRINGS.join(", ")} for false"
-            end
-        end
-
-        def self.validate_string(value, options)
-            if possible_values = options[:possible_values]
-                if options[:lowercase]
-                    value = value.downcase
-                elsif options[:uppercase]
-                    value = value.upcase
-                end
-
-                if !possible_values.include?(value)
-                    raise InputError, "invalid value '#{value}', accepted values are '#{possible_values.join("', '")}' (without the quotes)"
-                end
-            end
-            value
-        end
-    end
-
-    @user_config = Hash.new
-
-    def self.option_set
-        @user_config.inject(Hash.new) do |h, (k, v)|
-            h[k] = v.first
-            h
-        end
-    end
-
+    # @deprecated use config.reset instead
     def self.reset_option(key)
-        @user_config.delete(key)
+        config.reset(key)
     end
-
+    # @deprecated use config.set(key, value, user_validated) instead
     def self.change_option(key, value, user_validated = false)
-        @user_config[key] = [value, user_validated]
+        config.set(key, value, user_validated)
     end
-
+    # @deprecated use config.validated_values instead
+    def self.option_set
+        config.validated_values
+    end
+    # @deprecated use config.get(key) instead
     def self.user_config(key)
-        value, seen = @user_config[key]
-        # All non-user options are always considered as "seen"
-        seen ||= !@declared_options.has_key?(key)
-
-        if value.nil? || (!seen && Autoproj.reconfigure?)
-            value = configure(key)
-        else
-            if !seen
-                doc = @declared_options[key].short_doc
-                if doc[-1, 1] != "?"
-                    doc = "#{doc}:"
-                end
-                Autoproj.message "  #{doc} #{value}"
-                @user_config[key] = [value, true]
-            end
-            value
-        end
+        config.get(key)
     end
-
-    @declared_options = Hash.new
+    # @deprecated use config.declare(name, type, options, &validator) instead
     def self.configuration_option(name, type, options, &validator)
-        @declared_options[name] = BuildOption.new(name, type, options, validator)
+        config.declare(name, type, options, &validator)
     end
-
+    # @deprecated use config.declared?(name, type, options, &validator) instead
     def self.declared_option?(name)
-	@declared_options.has_key?(name)
+        config.declared?(name)
     end
-
+    # @deprecated use config.configure(option_name) instead
     def self.configure(option_name)
-        if opt = @declared_options[option_name]
-            if current_value = @user_config[option_name]
-                current_value = current_value.first
-            end
-            value = opt.ask(current_value)
-            @user_config[option_name] = [value, true]
-            value
-        else
-            raise ConfigError.new, "undeclared option '#{option_name}'"
-        end
+        config.configure(option_name)
     end
-
-    def self.save_config
-        File.open(File.join(Autoproj.config_dir, "config.yml"), "w") do |io|
-            config = Hash.new
-            @user_config.each_key do |key|
-                config[key] = @user_config[key].first
-            end
-
-            io.write YAML.dump(config)
-        end
+    # @deprecated use config.has_value_for?(name)
+    def self.has_config_key?(name)
+        config.has_value_for?(name)
     end
 
-    def self.has_config_key?(name)
-        @user_config.has_key?(name)
+    def self.save_config
+        config.save(File.join(Autoproj.config_dir, "config.yml"))
     end
 
     def self.load_config
+        @config ||= Configuration.new
+
         config_file = File.join(Autoproj.config_dir, "config.yml")
         if File.exists?(config_file)
-            config = YAML.load(File.read(config_file))
-            if !config
-                return
-            end
-
-            config.each do |key, value|
-                @user_config[key] = [value, false]
-            end
+            config.load(config_file, reconfigure?)
         end
     end