autoproj 2.0.0.b7 → 2.0.0.rc1

data/lib/autoproj/package_managers/pacman_manager.rb

@@ -0,0 +1,14 @@
+module Autoproj
+    module PackageManagers
+        # Package manager interface for systems that use pacman (i.e. arch) as
+        # their package manager
+        class PacmanManager < ShellScriptManager
+            def initialize
+                super(['pacman'], true,
+                        "pacman -Sy --needed '%s'",
+                        "pacman -Sy --needed --noconfirm '%s'")
+            end
+        end
+    end
+end
+

data/lib/autoproj/package_managers/pip_manager.rb

@@ -0,0 +1,86 @@
+module Autoproj
+    module PackageManagers
+        # Using pip to install python packages
+        class PipManager < Manager
+            attr_reader :installed_pips
+
+            def self.initialize_environment(env = Autobuild.env, _manifest = nil, root_dir = Autoproj.root_dir)
+                env.set 'PYTHONUSERBASE', pip_home(env, root_dir)
+            end
+
+            # Return the directory where python packages are installed to.
+            # The actual path is pip_home/lib/pythonx.y/site-packages.
+            def self.pip_home(env = Autobuild.env, root_dir = Autoproj.root_dir)
+                env['AUTOPROJ_PYTHONUSERBASE'] || File.join(root_dir,".pip")
+            end
+
+            def initialize
+                super(['pip'])
+                @installed_pips = Set.new
+            end
+
+            def guess_pip_program
+                if Autobuild.programs['pip']
+                    return Autobuild.programs['pip']
+                end
+
+                Autobuild.programs['pip'] = "pip"
+            end
+
+            def install(pips)
+                guess_pip_program
+                if pips.is_a?(String)
+                    pips = [pips]
+                end
+
+                base_cmdline = [Autobuild.tool('pip'), 'install','--user']
+
+                cmdlines = [base_cmdline + pips]
+
+                if pips_interaction(pips, cmdlines)
+                    Autoproj.message "  installing/updating Python dependencies: "+
+                        "#{pips.sort.join(", ")}"
+
+                    cmdlines.each do |c|
+                        Autobuild::Subprocess.run 'autoproj', 'osdeps', *c
+                    end
+
+                    pips.each do |p|
+                        @installed_pips << p
+                    end
+                end
+            end
+            
+            def pips_interaction(pips, cmdlines)
+                if OSDependencies.force_osdeps
+                    return true
+                elsif enabled?
+                    return true
+                elsif silent?
+                    return false
+                end
+
+                # We're not supposed to install rubygem packages but silent is not
+                # set, so display information about them anyway
+                puts <<-EOMSG
+      #{Autoproj.color("The build process and/or the packages require some Python packages to be installed", :bold)}
+      #{Autoproj.color("and you required autoproj to not do it itself", :bold)}
+        The following command line can be used to install them manually
+        
+          #{cmdlines.map { |c| c.join(" ") }.join("\n      ")}
+        
+        Autoproj expects these Python packages to be installed in #{PipManager.pip_home} This can
+        be overridden by setting the AUTOPROJ_PYTHONUSERBASE environment variable manually
+
+                EOMSG
+                print "    #{Autoproj.color("Press ENTER to continue ", :bold)}"
+
+                STDOUT.flush
+                STDIN.readline
+                puts
+                false
+            end
+        end
+    end
+end
+

data/lib/autoproj/package_managers/pkg_manager.rb

@@ -0,0 +1,14 @@
+module Autoproj
+    module PackageManagers
+	# Package manager interface for systems that use pkg (i.e. FreeBSD) as
+        # their package manager
+        class PkgManager < ShellScriptManager
+            def initialize
+                super(['pkg'], true,
+                        "pkg install -y '%s'",
+                        "pkg install -y '%s'")
+            end
+        end
+    end
+end
+

data/lib/autoproj/package_managers/port_manager.rb

@@ -0,0 +1,14 @@
+module Autoproj
+    module PackageManagers
+        # Package manager interface for systems that use port (i.e. MacPorts/Darwin) as
+        # their package manager
+        class PortManager < ShellScriptManager
+            def initialize
+                super(['macports'], true,
+                        "port install '%s'",
+                        "port install '%s'")
+            end
+        end
+    end
+end
+

data/lib/autoproj/package_managers/shell_script_manager.rb

@@ -0,0 +1,207 @@
+module Autoproj
+    module PackageManagers
+        # Base class for all package managers that simply require the call of a
+        # shell script to install packages (e.g. yum, apt, ...)
+        class ShellScriptManager < Manager
+            def self.execute(script, with_locking, with_root)
+                if with_locking
+                    File.open('/tmp/autoproj_osdeps_lock', 'w') do |lock_io|
+                        begin
+                            while !lock_io.flock(File::LOCK_EX | File::LOCK_NB)
+                                Autoproj.message "  waiting for other autoproj instances to finish their osdeps installation"
+                                sleep 5
+                            end
+                            return execute(script, false,with_root)
+                        ensure
+                            lock_io.flock(File::LOCK_UN)
+                        end
+                    end
+                end
+                
+                sudo = Autobuild.tool_in_path('sudo')
+                Tempfile.open('osdeps_sh') do |io|
+                    io.puts "#! /bin/bash"
+                    io.puts GAIN_ROOT_ACCESS % [sudo] if with_root
+                    io.write script
+                    io.flush
+                    Autobuild::Subprocess.run 'autoproj', 'osdeps', '/bin/bash', io.path
+                end
+            end
+
+            GAIN_ROOT_ACCESS = <<-EOSCRIPT
+# Gain root access using sudo
+if test `id -u` != "0"; then
+    exec %s /bin/bash $0 "$@"
+
+fi
+            EOSCRIPT
+
+            # Overrides the {#needs_locking?} flag
+            attr_writer :needs_locking
+            # Whether two autoproj instances can run this package manager at the
+            # same time
+            #
+            # This declares if this package manager cannot be used concurrently.
+            # If it is the case, autoproj will ensure that there is no two
+            # autoproj instances running this package manager at the same time
+            # 
+            # @return [Boolean]
+            # @see needs_locking=
+            def needs_locking?; !!@needs_locking end
+
+            # Overrides the {#needs_root?} flag
+            attr_writer :needs_root
+            # Whether this package manager needs root access.
+            #
+            # This declares if the command line(s) for this package manager
+            # should be started as root. Root access is provided using sudo
+            # 
+            # @return [Boolean]
+            # @see needs_root=
+            def needs_root?; !!@needs_root end
+
+            # Command line used by autoproj to install packages
+            #
+            # Since it is to be used for automated install by autoproj, it
+            # should not require any interaction with the user. When generating
+            # the command line, the %s slot is replaced by the quoted package
+            # name(s).
+            #
+            # @return [String] a command line pattern that allows to install
+            #   packages without user interaction. It is used when a package
+            #   should be installed by autoproj automatically
+            attr_reader :auto_install_cmd
+            # Command line displayed to the user to install packages
+            #
+            # When generating the command line, the %s slot is replaced by the
+            # quoted package name(s).
+            #
+            # @return [String] a command line pattern that allows to install
+            #   packages with user interaction. It is displayed to the
+            #   user when it chose to not let autoproj install packages for this
+            #   package manager automatically
+            attr_reader :user_install_cmd
+
+            # @param [Array<String>] names the package managers names, see
+            #   {#names}
+            # @param [Boolean] needs_locking whether this package manager can be
+            #   started by two separate autoproj instances at the same time. See
+            #   {#needs_locking?}
+            # @param [String] user_install_cmd the user-visible command line. See
+            #   {#user_install_cmd}
+            # @param [String] auto_install_cmd the command line used by autoproj
+            #   itself, see {#auto_install_cmd}.
+            # @param [Boolean] needs_root if the command lines should be started
+            #   as root or not. See {#needs_root?}
+            def initialize(names, needs_locking, user_install_cmd, auto_install_cmd,needs_root=true)
+                super(names)
+                @needs_locking, @user_install_cmd, @auto_install_cmd,@needs_root =
+                    needs_locking, user_install_cmd, auto_install_cmd, needs_root
+            end
+
+            # Generate the shell script that would allow the user to install
+            # the given packages
+            #
+            # @param [Array<String>] os_packages the name of the packages to be
+            #   installed
+            # @option options [String] :user_install_cmd (#user_install_cmd) the
+            #   command-line pattern that should be used to generate the script.
+            #   If given, it overrides the default value stored in
+            #   {#user_install_cmd]
+            def generate_user_os_script(os_packages, options = Hash.new)
+                user_install_cmd = options[:user_install_cmd] || self.user_install_cmd
+                if user_install_cmd
+                    (user_install_cmd % [os_packages.join("' '")])
+                else generate_auto_os_script(os_packages)
+                end
+            end
+
+            # Generate the shell script that should be executed by autoproj to
+            # install the given packages
+            #
+            # @param [Array<String>] os_packages the name of the packages to be
+            #   installed
+            # @option options [String] :auto_install_cmd (#auto_install_cmd) the
+            #   command-line pattern that should be used to generate the script.
+            #   If given, it overrides the default value stored in
+            #   {#auto_install_cmd]
+            def generate_auto_os_script(os_packages, options = Hash.new)
+                auto_install_cmd = options[:auto_install_cmd] || self.auto_install_cmd
+                (auto_install_cmd % [os_packages.join("' '")])
+            end
+
+            # Handles interaction with the user
+            #
+            # This method will verify whether the user required autoproj to
+            # install packages from this package manager automatically. It
+            # displays a relevant message if it is not the case.
+            #
+            # @return [Boolean] true if the packages should be installed
+            #   automatically, false otherwise
+            def osdeps_interaction(os_packages, shell_script)
+                if OSDependencies.force_osdeps
+                    return true
+                elsif enabled?
+                    return true
+                elsif silent?
+                    return false
+                end
+
+                # We're asked to not install the OS packages but to display them
+                # anyway, do so now
+                puts <<-EOMSG
+
+                #{Autoproj.color("The build process and/or the packages require some other software to be installed", :bold)}
+                #{Autoproj.color("and you required autoproj to not install them itself", :bold)}
+                #{Autoproj.color("\nIf these packages are already installed, simply ignore this message\n", :red) if !respond_to?(:filter_uptodate_packages)}
+    The following packages are available as OS dependencies, i.e. as prebuilt
+    packages provided by your distribution / operating system. You will have to
+    install them manually if they are not already installed
+
+                #{os_packages.sort.join("\n      ")}
+
+    the following command line(s) can be run as root to install them:
+
+                #{shell_script.split("\n").join("\n|   ")}
+
+            EOMSG
+                print "    #{Autoproj.color("Press ENTER to continue ", :bold)}"
+                STDOUT.flush
+                STDIN.readline
+                puts
+                false
+            end
+
+            # Install packages using this package manager
+            #
+            # @param [Array<String>] packages the name of the packages that
+            #   should be installed
+            # @option options [String] :user_install_cmd (#user_install_cmd) the
+            #   command line that should be displayed to the user to install said
+            #   packages. See the option in {#generate_user_os_script}
+            # @option options [String] :auto_install_cmd (#auto_install_cmd) the
+            #   command line that should be used by autoproj to install said
+            #   packages. See the option in {#generate_auto_os_script}
+            # @return [Boolean] true if packages got installed, false otherwise
+            def install(packages, options = Hash.new)
+                handled_os = OSDependencies.supported_operating_system?
+                if handled_os
+                    shell_script = generate_auto_os_script(packages, options)
+                    user_shell_script = generate_user_os_script(packages, options)
+                end
+                if osdeps_interaction(packages, user_shell_script)
+                    Autoproj.message "  installing OS packages: #{packages.sort.join(", ")}"
+
+                    if Autoproj.verbose
+                        Autoproj.message "Generating installation script for non-ruby OS dependencies"
+                        Autoproj.message shell_script
+                    end
+                    ShellScriptManager.execute(shell_script, needs_locking?,needs_root?)
+                    return true
+                end
+                false
+            end
+        end
+    end
+end
+

data/lib/autoproj/package_managers/unknown_os_manager.rb

@@ -0,0 +1,42 @@
+module Autoproj
+    module PackageManagers
+        # Dummy package manager used for unknown OSes. It simply displays a
+        # message to the user when packages are needed
+        class UnknownOSManager < Manager
+            def initialize
+                super(['unknown'])
+                @installed_osdeps = Set.new
+            end
+
+            def osdeps_interaction_unknown_os(osdeps)
+                puts <<-EOMSG
+  #{Autoproj.color("The build process requires some other software packages to be installed on our operating system", :bold)}
+  #{Autoproj.color("If they are already installed, simply ignore this message", :red)}
+
+    #{osdeps.to_a.sort.join("\n    ")}
+
+                EOMSG
+                print Autoproj.color("Press ENTER to continue", :bold)
+                STDOUT.flush
+                STDIN.readline
+                puts
+                nil
+            end
+
+            def install(osdeps)
+                if silent?
+                    return false
+                else
+                    osdeps = osdeps.to_set
+                    osdeps -= @installed_osdeps
+                    if !osdeps.empty?
+                        result = osdeps_interaction_unknown_os(osdeps)
+                    end
+                    @installed_osdeps |= osdeps
+                    return result
+                end
+            end
+        end
+    end
+end
+

data/lib/autoproj/package_managers/yum_manager.rb

@@ -0,0 +1,56 @@
+module Autoproj
+    module PackageManagers
+        # Package manager interface for systems that use yum
+        class YumManager < ShellScriptManager
+            def initialize
+                super(['yum'], true,
+                      "yum install '%s'",
+                      "yum install -y '%s'")
+            end
+
+            def filter_uptodate_packages(packages, options = Hash.new)
+                result = `LANG=C rpm -q --queryformat "%{NAME}\n" '#{packages.join("' '")}'`
+
+                installed_packages = []
+                new_packages = []
+                result.split("\n").each_with_index do |line, index|
+                    line = line.strip
+                    if line =~ /package (.*) is not installed/
+                        package_name = $1
+                        if !packages.include?(package_name) # something is wrong, fallback to installing everything
+                            return packages
+                        end
+                        new_packages << package_name
+                    else 
+                        package_name = line.strip
+                        if !packages.include?(package_name) # something is wrong, fallback to installing everything
+                            return packages
+                        end
+                        installed_packages << package_name
+                    end
+                end
+                new_packages
+            end
+
+            def install(packages)
+                patterns, packages = packages.partition { |pkg| pkg =~ /^@/ }
+                patterns = patterns.map { |str| str[1..-1] }
+                result = false
+                if !patterns.empty?
+                    result |= super(patterns,
+                                    :auto_install_cmd => "yum groupinstall -y '%s'",
+                                    :user_install_cmd => "yum groupinstall '%s'")
+                end
+                if !packages.empty?
+                    result |= super(packages)
+                end
+                if result
+                    # Invalidate caching of installed packages, as we just
+                    # installed new packages !
+                    @installed_packages = nil
+                end
+            end
+        end
+    end
+end
+

data/lib/autoproj/package_managers/zypper_manager.rb

@@ -0,0 +1,43 @@
+module Autoproj
+    module PackageManagers
+        #Package manger for OpenSuse and Suse (untested)
+        class ZypperManager < ShellScriptManager
+            def initialize
+                super(['zypper'], true,
+                        "zypper install '%s'",
+                        "zypper -n install '%s'")
+            end
+
+            def filter_uptodate_packages(packages, options = Hash.new)
+                result = `LANG=C rpm -q --whatprovides '#{packages.join("' '")}'`
+                has_all_pkgs = $?.success?
+
+                if !has_all_pkgs
+                    return packages # let zypper filter, we need root now anyways
+                else 
+                    return []
+                end
+            end
+
+            def install(packages)
+                patterns, packages = packages.partition { |pkg| pkg =~ /^@/ }
+                patterns = patterns.map { |str| str[1..-1] }
+                result = false
+                if !patterns.empty?
+                    result |= super(patterns,
+                                    :auto_install_cmd => "zypper --non-interactive install --type pattern '%s'",
+                                    :user_install_cmd => "zypper install --type pattern '%s'")
+                end
+                if !packages.empty?
+                    result |= super(packages)
+                end
+                if result
+                    # Invalidate caching of installed packages, as we just
+                    # installed new packages !
+                    @installed_packages = nil
+                end
+            end
+        end
+    end
+end
+