autoproj 2.14.0 → 2.15.0

data/lib/autoproj/ops/snapshot.rb

@@ -1,301 +1,304 @@
 module Autoproj
     module Ops
-    class Snapshot
-        # Update version control information with new choices
-        #
-        # The two parameters are formatted as expected in the version_control
-        # and overrides fields in source.yml / overrides.yml, that is (in YAML)
-        #
-        #   - package_name:
-        #     version: '10'
-        #     control: '20'
-        #     info: '30'
-        #
-        # The two parameters are expected to only use full package names, and
-        # not regular expressions
-        #
-        # @param [Array<String=>Hash>] overrides the information that should augment
-        #   the current state
-        # @param [Array<String=>Hash>] state the current state
-        # @param [Hash] the updated information
-        def self.merge_packets( overrides, state )
-            overriden = overrides.map { |entry| entry.keys.first }.to_set
-            filtered_state = state.find_all do |pkg|
-                name, _ = pkg.first
-                !overriden.include?(name)
+        class Snapshot
+            # Update version control information with new choices
+            #
+            # The two parameters are formatted as expected in the version_control
+            # and overrides fields in source.yml / overrides.yml, that is (in YAML)
+            #
+            #   - package_name:
+            #     version: '10'
+            #     control: '20'
+            #     info: '30'
+            #
+            # The two parameters are expected to only use full package names, and
+            # not regular expressions
+            #
+            # @param [Array<String=>Hash>] overrides the information that should augment
+            #   the current state
+            # @param [Array<String=>Hash>] state the current state
+            # @param [Hash] the updated information
+            def self.merge_packets(overrides, state)
+                overriden = overrides.map { |entry| entry.keys.first }.to_set
+                filtered_state = state.find_all do |pkg|
+                    name, = pkg.first
+                    !overriden.include?(name)
+                end
+                filtered_state + overrides
             end
-            filtered_state + overrides
-        end
 
-        def self.update_log_available?(manifest)
-            new(manifest).import_state_log_package
-            true
-        rescue ArgumentError
-            false
-        end
-
-        def sort_versions(versions)
-            pkg_sets, pkgs = versions.partition { |vcs| vcs.keys.first =~ /^pkg_set:/ }
-            pkg_sets.sort_by { |vcs| vcs.keys.first } +
-                pkgs.sort_by { |vcs| vcs.keys.first }
-        end
+            def self.update_log_available?(manifest)
+                new(manifest).import_state_log_package
+                true
+            rescue ArgumentError
+                false
+            end
 
-        def save_versions( versions, versions_file, replace: false)
-            existing_versions = Array.new
-            if !replace && File.exist?(versions_file)
-                existing_versions = YAML.load( File.read( versions_file ) ) ||
-                    Array.new
+            def sort_versions(versions)
+                pkg_sets, pkgs = versions.partition { |vcs| vcs.keys.first =~ /^pkg_set:/ }
+                pkg_sets.sort_by { |vcs| vcs.keys.first } +
+                    pkgs.sort_by { |vcs| vcs.keys.first }
             end
 
-            # create direcotry for versions file first
-            FileUtils.mkdir_p(File.dirname( versions_file ))
+            def save_versions(versions, versions_file, replace: false)
+                existing_versions = Array.new
+                if !replace && File.exist?(versions_file)
+                    existing_versions = YAML.load(File.read(versions_file)) ||
+                                        Array.new
+                end
 
-            # augment the versions file with the updated versions
-            versions = Snapshot.merge_packets( versions, existing_versions )
+                # create direcotry for versions file first
+                FileUtils.mkdir_p(File.dirname(versions_file))
 
-            versions = sort_versions(versions)
+                # augment the versions file with the updated versions
+                versions = Snapshot.merge_packets(versions, existing_versions)
 
-            # write the yaml file
-            File.open(versions_file, 'w') do |io|
-                io.write YAML.dump(versions)
-            end
-        end
-
-        def self.snapshot( packages, target_dir )
-            # todo
-        end
+                versions = sort_versions(versions)
 
-        attr_reader :manifest
+                # write the yaml file
+                File.open(versions_file, "w") do |io|
+                    io.write YAML.dump(versions)
+                end
+            end
 
-        # Control what happens if a package fails to be snapshotted
-        #
-        # If true, the failure to snapshot a package should lead to a warning.
-        # Otherwise (the default), it leads to an error.
-        #
-        # @return [Boolean]
-        # @see initialize error_or_warn
-        def keep_going?; !!@keep_going end
+            def self.snapshot(packages, target_dir)
+                # todo
+            end
 
-        def initialize(manifest, keep_going: false)
-            @manifest = manifest
-            @keep_going = keep_going
-        end
+            attr_reader :manifest
+
+            # Control what happens if a package fails to be snapshotted
+            #
+            # If true, the failure to snapshot a package should lead to a warning.
+            # Otherwise (the default), it leads to an error.
+            #
+            # @return [Boolean]
+            # @see initialize error_or_warn
+            def keep_going?
+                !!@keep_going
+            end
 
-        def snapshot_package_sets(target_dir = nil, only_local: true)
-            result = Array.new
-            manifest.each_package_set do |pkg_set|
-                next if pkg_set.local?
+            def initialize(manifest, keep_going: false)
+                @manifest = manifest
+                @keep_going = keep_going
+            end
 
-                vcs_info =
-                    begin pkg_set.snapshot(target_dir, only_local: only_local)
-                    rescue Exception => e
-                        error_or_warn(pkg_set, e)
-                        next
+            def snapshot_package_sets(target_dir = nil, only_local: true)
+                result = Array.new
+                manifest.each_package_set do |pkg_set|
+                    next if pkg_set.local?
+
+                    vcs_info =
+                        begin pkg_set.snapshot(target_dir, only_local: only_local)
+                        rescue Exception => e
+                            error_or_warn(pkg_set, e)
+                            next
+                        end
+
+                    if vcs_info
+                        result << Hash["pkg_set:#{pkg_set.repository_id}", vcs_info]
+                    else
+                        error_or_warn(pkg_set, "cannot snapshot package set #{pkg_set.name}: importer snapshot failed")
                     end
-
-                if vcs_info
-                    result << Hash["pkg_set:#{pkg_set.repository_id}", vcs_info]
-                else
-                    error_or_warn(pkg_set, "cannot snapshot package set #{pkg_set.name}: importer snapshot failed")
                 end
+                result
             end
-            result
-        end
 
-        def error_or_warn(package, error)
-            if error.kind_of?(Interrupt)
-                raise
-            elsif keep_going?
-                if !error.respond_to?(:to_str)
-                    error = error.message
+            def error_or_warn(package, error)
+                if error.kind_of?(Interrupt)
+                    raise
+                elsif keep_going?
+                    error = error.message unless error.respond_to?(:to_str)
+                    Autoproj.warn error
+                elsif error.respond_to?(:to_str)
+                    raise Autobuild::PackageException.new(package, "snapshot"), error
+                else
+                    raise
                 end
-                Autoproj.warn error
-            elsif error.respond_to?(:to_str)
-                raise Autobuild::PackageException.new(package, 'snapshot'), error
-            else
-                raise
             end
-        end
 
-        def snapshot_packages(packages, target_dir = nil, only_local: true, fingerprint: false)
-            result = Array.new
-            fingerprint_memo = Hash.new
-            packages.each do |package_name|
-                package  = manifest.find_package_definition(package_name)
-                if !package
-                    raise ArgumentError, "#{package_name} is not a known package"
-                end
-                importer = package.autobuild.importer
-                if !importer
-                    error_or_warn(package, "cannot snapshot #{package_name} as it has no importer")
-                    next
-                elsif !importer.respond_to?(:snapshot)
-                    error_or_warn(package, "cannot snapshot #{package_name} as the #{importer.class} importer does not support it")
-                    next
-                end
+            def snapshot_packages(packages, target_dir = nil, only_local: true, fingerprint: false)
+                result = Array.new
+                fingerprint_memo = Hash.new
+                packages.each do |package_name|
+                    package = manifest.find_package_definition(package_name)
+                    unless package
+                        raise ArgumentError, "#{package_name} is not a known package"
+                    end
 
-                vcs_info =
-                    begin importer.snapshot(package.autobuild, target_dir, only_local: only_local)
-                    rescue Exception => e
-                        error_or_warn(package, e)
+                    importer = package.autobuild.importer
+                    if !importer
+                        error_or_warn(package, "cannot snapshot #{package_name} as it has no importer")
+                        next
+                    elsif !importer.respond_to?(:snapshot)
+                        error_or_warn(package, "cannot snapshot #{package_name} as the #{importer.class} importer does not support it")
                         next
                     end
 
-                if fingerprint
-                    vcs_info['fingerprint'] = package.autobuild.fingerprint(memo: fingerprint_memo)
-                end
+                    vcs_info =
+                        begin importer.snapshot(package.autobuild, target_dir, only_local: only_local)
+                        rescue Exception => e
+                            error_or_warn(package, e)
+                            next
+                        end
 
-                if vcs_info
-                    result << Hash[package_name, vcs_info]
-                else
-                    error_or_warn(package, "cannot snapshot #{package_name}: importer snapshot failed")
+                    if fingerprint
+                        vcs_info["fingerprint"] = package.autobuild.fingerprint(memo: fingerprint_memo)
+                    end
+
+                    if vcs_info
+                        result << Hash[package_name, vcs_info]
+                    else
+                        error_or_warn(package, "cannot snapshot #{package_name}: importer snapshot failed")
+                    end
                 end
+                result
             end
-            result
-        end
 
-        # Returns the list of existing version tags
-        def tags(package)
-            importer = package.importer
-            all_tags = importer.run_git_bare(package, 'tag')
-            all_tags.find_all do |tag_name|
+            # Returns the list of existing version tags
+            def tags(package)
+                importer = package.importer
+                all_tags = importer.run_git_bare(package, "tag")
+                all_tags.find_all do |tag_name|
+                end
             end
-        end
 
-        # Returns a package that is used to store this installs import history
-        #
-        # Its importer is guaranteed to be a git importer
-        #
-        # @return [Autobuild::Package] a package whose importer is
-        #   {Autobuild::Git}
-        def import_state_log_package
-            pkg = manifest.main_package_set.create_autobuild_package
-            if !pkg.importer
-                if Autobuild::Git.can_handle?(pkg.srcdir)
-                    pkg.importer = Autobuild.git(pkg.srcdir)
+            # Returns a package that is used to store this installs import history
+            #
+            # Its importer is guaranteed to be a git importer
+            #
+            # @return [Autobuild::Package] a package whose importer is
+            #   {Autobuild::Git}
+            def import_state_log_package
+                pkg = manifest.main_package_set.create_autobuild_package
+                unless pkg.importer
+                    if Autobuild::Git.can_handle?(pkg.srcdir)
+                        pkg.importer = Autobuild.git(pkg.srcdir)
+                    end
                 end
-            end
 
-            if !pkg.importer.kind_of?(Autobuild::Git)
-                raise ArgumentError, "cannot use autoproj auto-import feature if the main configuration is not managed under git"
-            end
-            pkg
-        end
+                unless pkg.importer.kind_of?(Autobuild::Git)
+                    raise ArgumentError, "cannot use autoproj auto-import feature if the main configuration is not managed under git"
+                end
 
-        def self.import_state_log_ref
-            "refs/autoproj"
-        end
+                pkg
+            end
 
-        DEFAULT_VERSIONS_FILE_BASENAME = "50-versions.yml"
+            def self.import_state_log_ref
+                "refs/autoproj"
+            end
 
-        def import_state_log_file
-            File.join(Workspace::OVERRIDES_DIR, DEFAULT_VERSIONS_FILE_BASENAME)
-        end
+            DEFAULT_VERSIONS_FILE_BASENAME = "50-versions.yml"
 
-        def current_import_state
-            main = import_state_log_package
-            # Try to resolve the log ref, and extract the version file from it
-            begin
-                yaml = main.importer.show(main, self.class.import_state_log_ref, import_state_log_file)
-                YAML.load(yaml) || Array.new
-            rescue Autobuild::PackageException
-                Array.new
+            def import_state_log_file
+                File.join(Workspace::OVERRIDES_DIR, DEFAULT_VERSIONS_FILE_BASENAME)
             end
-        end
 
-        def update_package_import_state(name, packages)
-            current_versions = current_import_state
-            if current_versions.empty?
-                # Do a full snapshot this time only
-                Autoproj.message "  building initial autoproj import log, this may take a while"
-                packages = manifest.all_selected_source_packages.
-                    find_all { |pkg| File.directory?(pkg.autobuild.srcdir) }.
-                    map(&:name)
+            def current_import_state
+                main = import_state_log_package
+                # Try to resolve the log ref, and extract the version file from it
+                begin
+                    yaml = main.importer.show(main, self.class.import_state_log_ref, import_state_log_file)
+                    YAML.load(yaml) || Array.new
+                rescue Autobuild::PackageException
+                    Array.new
+                end
             end
-            versions  = snapshot_package_sets
-            versions += snapshot_packages(packages)
-            versions = Snapshot.merge_packets(versions, current_versions)
-            save_import_state(name, versions)
-        end
 
-        def save_import_state(name, versions)
-            versions = sort_versions(versions)
-            
-            main = import_state_log_package
-            git_dir = main.importer.git_dir(main, false)
-            # Ensure that our ref is being logged
-            FileUtils.touch File.join(git_dir, 'logs', *self.class.import_state_log_ref.split("/"))
-            # Create the commit with the versions info
-            commit_id = Snapshot.create_commit(main, import_state_log_file, name, real_author: false) do |io|
-                YAML.dump(versions, io)
+            def update_package_import_state(name, packages)
+                current_versions = current_import_state
+                if current_versions.empty?
+                    # Do a full snapshot this time only
+                    Autoproj.message "  building initial autoproj import log, this may take a while"
+                    packages = manifest.all_selected_source_packages
+                                       .find_all { |pkg| File.directory?(pkg.autobuild.srcdir) }
+                                       .map(&:name)
+                end
+                versions  = snapshot_package_sets
+                versions += snapshot_packages(packages)
+                versions = Snapshot.merge_packets(versions, current_versions)
+                save_import_state(name, versions)
             end
-            # And save it in our reflog
-            main.importer.run_git_bare(main, "update-ref", '-m', name, self.class.import_state_log_ref, commit_id)
-        end
 
-        # Create a git commit in which a file contains provided content
-        #
-        # The target git repository's current index and history is left
-        # unmodified. The only modification is the creation of a new dangling
-        # commit.
-        #
-        # It creates a temporary file and gives it to the block so that the file
-        # gets filled with the new content
-        #
-        # @yieldparam [Tempfile] io a temporary file 
-        # @param [Autobuild::Package] a package object whose importer is a git
-        #   importer. The git commit is created in this repository
-        # @param [String] path the file to be created or updated, relative to
-        #   the root of the git repository
-        # @param [String] the commit message
-        # @return [String] the commit ID
-        def self.create_commit(pkg, path, message, parent_id = nil, real_author: true)
-            importer = pkg.importer
-            object_id = Tempfile.open 'autoproj-versions' do |io|
-                yield(io)
-                io.flush
-                importer.run_git_bare(
-                    pkg, 'hash-object', '-w',
-                    '--path', path, io.path).first
-            end
+            def save_import_state(name, versions)
+                versions = sort_versions(versions)
 
-            cacheinfo = ["100644", object_id, path]
-            if Autobuild::Git.at_least_version(2, 1)
-                cacheinfo = cacheinfo.join(",")
+                main = import_state_log_package
+                git_dir = main.importer.git_dir(main, false)
+                # Ensure that our ref is being logged
+                FileUtils.touch File.join(git_dir, "logs", *self.class.import_state_log_ref.split("/"))
+                # Create the commit with the versions info
+                commit_id = Snapshot.create_commit(main, import_state_log_file, name, real_author: false) do |io|
+                    YAML.dump(versions, io)
+                end
+                # And save it in our reflog
+                main.importer.run_git_bare(main, "update-ref", "-m", name, self.class.import_state_log_ref, commit_id)
             end
 
-            parent_id ||= importer.rev_parse(pkg, 'HEAD')
+            # Create a git commit in which a file contains provided content
+            #
+            # The target git repository's current index and history is left
+            # unmodified. The only modification is the creation of a new dangling
+            # commit.
+            #
+            # It creates a temporary file and gives it to the block so that the file
+            # gets filled with the new content
+            #
+            # @yieldparam [Tempfile] io a temporary file
+            # @param [Autobuild::Package] a package object whose importer is a git
+            #   importer. The git commit is created in this repository
+            # @param [String] path the file to be created or updated, relative to
+            #   the root of the git repository
+            # @param [String] the commit message
+            # @return [String] the commit ID
+            def self.create_commit(pkg, path, message, parent_id = nil, real_author: true)
+                importer = pkg.importer
+                object_id = Tempfile.open "autoproj-versions" do |io|
+                    yield(io)
+                    io.flush
+                    importer.run_git_bare(
+                        pkg, "hash-object", "-w",
+                        "--path", path, io.path
+                    ).first
+                end
 
-            env = Hash.new
-            if !real_author
-                env['GIT_AUTHOR_NAME'] = 'autoproj'
-                env['GIT_AUTHOR_EMAIL'] = 'autoproj'
-                env['GIT_COMMITTER_NAME'] = 'autoproj'
-                env['GIT_COMMITTER_EMAIL'] = 'autoproj'
-            end
+                cacheinfo = ["100644", object_id, path]
+                cacheinfo = cacheinfo.join(",") if Autobuild::Git.at_least_version(2, 1)
 
-            # Create the tree using a temporary index in order to not mess with
-            # the user's index state. read-tree initializes the new index and
-            # then we add the overrides file with update-index / write-tree
-            our_index = File.join(importer.git_dir(pkg, false), 'index.autoproj')
-            FileUtils.rm_f our_index
-            begin
-                ENV['GIT_INDEX_FILE'] = our_index
-                importer.run_git_bare(pkg, 'read-tree', parent_id)
-                # And add the new file
-                importer.run_git_bare(
-                    pkg, 'update-index',
-                    '--add', '--cacheinfo', *cacheinfo)
-                tree_id = importer.run_git_bare(pkg, 'write-tree').first
-            ensure
-                ENV.delete('GIT_INDEX_FILE')
+                parent_id ||= importer.rev_parse(pkg, "HEAD")
+
+                env = Hash.new
+                unless real_author
+                    env["GIT_AUTHOR_NAME"] = "autoproj"
+                    env["GIT_AUTHOR_EMAIL"] = "autoproj"
+                    env["GIT_COMMITTER_NAME"] = "autoproj"
+                    env["GIT_COMMITTER_EMAIL"] = "autoproj"
+                end
+
+                # Create the tree using a temporary index in order to not mess with
+                # the user's index state. read-tree initializes the new index and
+                # then we add the overrides file with update-index / write-tree
+                our_index = File.join(importer.git_dir(pkg, false), "index.autoproj")
                 FileUtils.rm_f our_index
-            end
+                begin
+                    ENV["GIT_INDEX_FILE"] = our_index
+                    importer.run_git_bare(pkg, "read-tree", parent_id)
+                    # And add the new file
+                    importer.run_git_bare(
+                        pkg, "update-index",
+                        "--add", "--cacheinfo", *cacheinfo
+                    )
+                    tree_id = importer.run_git_bare(pkg, "write-tree").first
+                ensure
+                    ENV.delete("GIT_INDEX_FILE")
+                    FileUtils.rm_f our_index
+                end
 
-            importer.run_git_bare(
-                pkg, 'commit-tree',
-                tree_id, '-p', parent_id, env: env, input_streams: [message]).first
+                importer.run_git_bare(
+                    pkg, "commit-tree",
+                    tree_id, "-p", parent_id, env: env, input_streams: [message]
+                ).first
+            end
         end
     end
-    end
 end