automate-it 0.9.0

data/lib/automateit/package_manager/gem.rb

@@ -0,0 +1,201 @@
+# == PackageManager::Gem
+#
+# The Gem driver for the PackageManager provides a way to manage software
+# packages for RubyGems using the +gem+ command.
+#
+# === Specifying version of gem to use
+#
+# You can specify the command to use with each call using the gem option, e.g., the "gem1.8" below:
+#
+#   package_manager.install 'rails', :with => :gem, :gem => "gem1.8"
+#
+# Or set a default and all subsequent calls will use it:
+#
+#   package_manager[:gem].setup(:gem => "gem1.8")
+#   package_manager.install 'rails', :with => :gem
+class AutomateIt::PackageManager::Gem < AutomateIt::PackageManager::BaseDriver
+  attr_accessor :gem
+
+  # FIXME Can't tell which gem program is used until we can use #which, need a new paradigm for #available?
+  depends_on \
+    :libraries => %w(expect pty)
+    ### :programs => %w(gem),
+
+  def setup(*args)
+    super(*args)
+
+    args, opts = args_and_opts(*args)
+    if opts[:gem]
+      @gem = opts[:gem]
+    else
+      @gem ||= %w(gem gem1.8 gem1.9).inject(nil){|s,v| s ? s : interpreter.which(v)}
+    end
+  end
+
+  def suitability(method, *args) # :nodoc:
+    # Never select GEM as the default driver
+    return 0
+  end
+
+  # See PackageManager#installed?
+  def installed?(*packages)
+    return _installed_helper?(*packages) do |list, opts|
+      gem = opts[:gem] || self.gem
+      cmd = "#{gem} list --local 2>&1"
+
+      log.debug(PEXEC+cmd)
+      data = `#{cmd}`
+
+      # Gem lists packages out of order, which screws up the
+      # install/uninstall sequence, so we need to put them back in the
+      # order that the user specified.
+      present = data.scan(/^([^\s\(]+)\s+\([^\)]+\)\s*$/).flatten
+      available = []
+      for package in list
+        available << package if present.include?(package)
+      end
+      available
+    end
+  end
+
+  # See PackageManager#not_installed?
+  def not_installed?(*packages)
+    _not_installed_helper?(*packages)
+  end
+
+  # Special options:
+  # * :docs -- If set to false, won't install rdoc or ri.
+  # * :source -- URL source to retrieve Gems from.
+  #
+  # See PackageManager#install
+  def install(*packages)
+    return _install_helper(*packages) do |list, opts|
+      gem = opts[:gem] || self.gem
+
+      # Why is the "gem" utility such a steaming pile of offal? Lameness include:
+      # - Requires interactive input to install a package, with no way to prevent this
+      # - Repeatedly updates indexes even when there's no reason to, and can't be told to stop
+      # - Doesn't cache packages, insists on downloading them again
+      # - Installs broken packages, often without giving any indication of failure
+      # - Installs broken packages and leaves you to deal with the jagged pieces
+      # - Sometimes fails through exit status, sometimes through output, but not both and not consistently
+      # - Lacks a proper "is this package installed?" feature
+      # - A nightmare to deal with if you want to install your own GEMHOME/GEMPATH
+
+      # Example of an invalid gem that'll cause the failure I'm trying to avoid below:
+      #   package_manager.install("sys-cpu", :with => :gem)
+
+      # gem options:
+      # -y : Include dependencies,
+      # -E : use /usr/bin/env for installed executables; but only with >= 0.9.4
+      cmd = "#{gem} install -y"
+      cmd << " --no-ri" if opts[:ri] == false or opts[:docs] == false
+      cmd << " --no-rdoc" if opts[:rdoc] == false or opts[:docs] == false
+      cmd << " --source #{opts[:source]}" if opts[:source]
+      cmd << " "+list.join(" ")
+      cmd << " " << opts[:args] if opts[:args]
+      cmd << " 2>&1"
+
+      # XXX Try to warn the user that they won't see any output for a while
+      log.info(PNOTE+"Installing Gems, this will take a while...") if writing? and not opts[:quiet]
+      log.info(PEXEC+cmd)
+      return true if preview?
+
+      uninstall_needed = false
+      begin
+        require 'expect'
+        require 'open4'
+        exitstruct = Open4::popen4(cmd) do |pid, sin, sout, serr|
+          $expect_verbose = opts[:quiet] ? false : true
+
+          re_missing=/Could not find.+in any repository/m
+          re_select=/Select which gem to install.+>/m
+          re_failed=/Gem files will remain.+for inspection/m
+          re_refused=/Errno::ECONNREFUSED reading .+?\.gem/m
+          re_all=/#{re_missing}|#{re_select}|#{re_failed}|#{re_refused}/m
+
+          while true
+            begin
+              captureded = sout.expect(re_all)
+            rescue NoMethodError
+              log.debug(PNOTE+"Gem seems to be done")
+              break
+            end
+            ### puts "Captureded %s" % captureded.inspect
+            captured = captureded.first
+            if captured.match(re_failed)
+              log.warn(PERROR+"Gem install failed mid-process")
+              uninstall_needed = true
+              break
+            elsif captured.match(re_refused)
+              log.warn(PERROR+"Gem install refused by server!\n#{captured}")
+              break
+            elsif captured.match(re_select)
+              choice = captured.match(/^ (\d+)\. .+?\(ruby\)\s*$/)[1]
+              log.info(PNOTE+"Guessing: #{choice}")
+              sin.puts(choice)
+            end
+          end
+        end
+      rescue Errno::ENOENT => e
+        raise NotImplementedError.new("can't find gem command: #{e}")
+      end
+
+      if uninstall_needed or not exitstruct.exitstatus.zero?
+        log.error(PERROR+"Gem install failed, trying to uninstall broken pieces: #{list.inspect}")
+        uninstall(list, opts)
+
+        raise ArgumentError.new("Gem install failed because it's invalid, missing a dependency, or can't talk with Gem server: #{list.inspect}")
+      end
+    end
+  end
+
+  # See PackageManager#uninstall
+  def uninstall(*packages)
+    return _uninstall_helper(*packages) do |list, opts|
+      gem = opts[:gem] || self.gem
+
+      # TODO PackageManager::gem#uninstall -- add logic to handle prompts during removal
+=begin
+# idiotic program MAY prompt you like this on uninstall:
+
+Gem 0.9.4 generates prompts like this:
+** gem uninstall -x mongrel < /dev/null 2>&1
+
+You have requested to uninstall the gem:
+    mongrel-1.0.1
+mongrel_cluster-1.0.2 depends on [mongrel (>= 1.0.1)]
+If you remove this gems, one or more dependencies will not be met.
+Continue with Uninstall? [Yn]  Successfully uninstalled mongrel version 1.0.1
+Removing mongrel_rails
+
+#-----------------------------------------------------------------------
+Gem 0.9.0 generates prompts like this:
+** gem uninstall -x mongrel < /dev/null 2>&1
+
+Select RubyGem to uninstall:
+1. mongrel-1.0.1
+2. mongrel_cluster-1.0.2
+3. All versions
+> 3
+
+You have requested to uninstall the gem:
+    mongrel-1.0.1
+mongrel_cluster-1.0.2 depends on [mongrel (>= 1.0.1)]
+If you remove this gems, one or more dependencies will not be met.
+Continue with Uninstall? [Yn]  y
+Successfully uninstalled mongrel version 1.0.1
+Successfully uninstalled mongrel_cluster version 1.0.2
+root@ubuntu:/mnt/satori/svnwork/automateit/src/examples/myapp_rails#
+=end
+      for package in list
+        # gem options:
+        # -x : remove installed executables
+        cmd = "#{gem} uninstall -x #{package} < /dev/null"
+        cmd << " > /dev/null" if opts[:quiet]
+        cmd << " 2>&1"
+        interpreter.sh(cmd)
+      end
+    end
+  end
+end

data/lib/automateit/package_manager/pear.rb

@@ -0,0 +1,95 @@
+# == PackageManager::PEAR
+#
+# A PackageManager driver for PEAR (PHP Extension and Application Repository),
+# manages software packages using the <tt>pear</tt> command.
+#
+# === Using specific channels
+#
+# To install a package from the default PEAR channel, just specify it's name,
+# e.g. <tt>HTML_QuickForm</tt>.
+#
+# To install a package from another channel, you must specify the name prefixed
+# with the channel's URL, e.g. <tt>pear.symfony-project.com/symfony</tt>, so
+# that the channel can be automatically added as needed.
+#
+# *IMPORTANT*: DO NOT specify a remote channel's alias, e.g.
+# <tt>symfony/symfony</tt>, because this provides no way to discover the
+# channel.
+class ::AutomateIt::PackageManager::PEAR < ::AutomateIt::PackageManager::BaseDriver
+  depends_on :programs => %w(pear)
+
+  def suitability(method, *args) # :nodoc:
+    # Never select as default driver
+    return 0
+  end
+
+  # Retrieve a hash containing all installed packages, indexed by package
+  # name.  Each value is a hash containing values for :version and :state.
+  def get_installed_packages()
+    cmd = "pear list --allchannels 2>&1"
+    data = `#{cmd}`
+    installed_packages = {}
+    data.scan(/^([^(\s]+)\s+([^\s]+)\s+([^\s]+)$/) do |package, version, state|
+      next if version.upcase == 'VERSION'
+      installed_packages[package] = {:version => version, :state => state}
+    end
+    return installed_packages
+  end
+  protected :get_installed_packages
+
+  # See AutomateIt::PackageManager#installed?
+  def installed?(*packages)
+    return _installed_helper?(*packages) do |list, opts|
+      all_installed = get_installed_packages().keys.collect {|pkg| pkg.downcase}
+
+      result = []
+      list.each do |pkg|
+        pkg_without_channel = pkg.gsub(%r{^[^/]+/}, '').downcase
+        result.push pkg if all_installed.include?(pkg_without_channel)
+      end
+
+      result
+    end
+  end
+
+  # See AutomateIt::PackageManager#not_installed?
+  def not_installed?(*packages)
+    return _not_installed_helper?(*packages)
+  end
+
+  # *IMPORTANT*: See documentation at the top of this file for how to correctly
+  # install packages from a specific channel.
+  #
+  # Options:
+  # * :force -- Force installation, needed when installing unstable packages
+  #
+  # See AutomateIt::PackageManager#install
+  def install(*packages)
+    return _install_helper(*packages) do |list, opts|
+      # pear options:
+      # -a install all required dependencies
+      # -f force installation
+
+      cmd = "(pear config-set auto_discover 1; "
+      cmd << "pear install -a"
+      cmd << " -f" if opts[:force]
+      cmd << " "+list.join(" ")+" < /dev/null)"
+      cmd << " > /dev/null" if opts[:quiet]
+      cmd << " 2>&1"
+
+      interpreter.sh(cmd)
+    end
+  end
+
+  # See AutomateIt::PackageManager#uninstall
+  def uninstall(*packages)
+    return _uninstall_helper(*packages) do |list, opts|
+
+      cmd = "pear uninstall "+list.join(" ")+" < /dev/null"
+      cmd << " > /dev/null" if opts[:quiet]
+      cmd << " 2>&1"
+
+      interpreter.sh(cmd)
+    end
+  end
+end

data/lib/automateit/package_manager/pecl.rb

@@ -0,0 +1,80 @@
+# == PackageManager::PECL
+#
+# A PackageManager driver for PECL (PHP Extension Community Library), manages
+# software packages using the <tt>pecl</tt> command.
+class ::AutomateIt::PackageManager::PECL < ::AutomateIt::PackageManager::BaseDriver
+  depends_on :programs => %w(pecl)
+
+  def suitability(method, *args) # :nodoc:
+    # Never select as default driver
+    return 0
+  end
+
+  # Retrieve a hash containing all installed packages, indexed by package
+  # name.  Each value is a hash containing values for :channel, :version,
+  # and :state.
+  def get_installed_packages()
+    cmd = "pecl list -a 2>&1"
+    data = `#{cmd}`
+    installed_packages = {}
+    data.scan(/^([^(\s]+)\s+([^\s]+)\s+([^\s]+)$/) do |package, version, state|
+      next if version.upcase == 'VERSION'
+      installed_packages[package] = {:version => version, :state => state}
+    end
+    return installed_packages
+  end
+  protected :get_installed_packages
+
+  # See AutomateIt::PackageManager#installed?
+  def installed?(*packages)
+    return _installed_helper?(*packages) do |list, opts|
+      all_installed = get_installed_packages().keys.collect {|pkg| pkg.downcase}
+
+      result = []
+      list.each do |pkg|
+        pkg_without_channel = pkg.gsub(%r{^[^/]+/}, '').downcase
+        result.push pkg if all_installed.include?(pkg_without_channel)
+      end
+
+      result
+    end
+  end
+
+
+  # See AutomateIt::PackageManager#not_installed?
+  def not_installed?(*packages)
+    return _not_installed_helper?(*packages)
+  end
+
+  # Options:
+  # * :force -- Force installation, needed when installing unstable packages
+  #
+  # See AutomateIt::PackageManager#install
+  def install(*packages)
+    return _install_helper(*packages) do |list, opts|
+      # pecl options:
+      # -a install all required dependencies
+      # -f force installation
+
+      cmd = "pecl install -a"
+      cmd << " -f" if opts[:force]
+      cmd << " "+list.join(" ")+" < /dev/null"
+      cmd << " > /dev/null" if opts[:quiet]
+      cmd << " 2>&1"
+
+      interpreter.sh(cmd)
+    end
+  end
+
+  # See AutomateIt::PackageManager#uninstall
+  def uninstall(*packages)
+    return _uninstall_helper(*packages) do |list, opts|
+
+      cmd = "pecl uninstall "+list.join(" ")+" < /dev/null"
+      cmd << " > /dev/null" if opts[:quiet]
+      cmd << " 2>&1"
+
+      interpreter.sh(cmd)
+    end
+  end
+end

data/lib/automateit/package_manager/portage.rb

@@ -0,0 +1,69 @@
+# == PackageManager::Portage
+#
+# The Portage driver for the PackageManager provides a way to manage software
+# packages on Gentoo systems using.
+class AutomateIt::PackageManager::Portage < AutomateIt::PackageManager::BaseDriver
+  depends_on :programs => %w(emerge)
+
+  def suitability(method, *args) # :nodoc:
+    return available? ? 1 : 0
+  end
+
+  # See AutomateIt::PackageManager#installed?
+  def installed?(*packages)
+    return _installed_helper?(*packages) do |list, opts|
+      # Emerge throws an error when called with invalid packages, so it's
+      # necessary to find the invalid packages and re-run the command without
+      # them to find out what is actually installed.
+      missing = []
+      available = []
+      while true
+        cmd = "emerge --color n --nospinner --tree --usepkg --quiet --pretend " + \
+          (list-missing).join(' ') + " < /dev/null 2>&1"
+        log.debug(PEXEC+cmd)
+        output = `#{cmd}`
+
+        if output.match(/no ebuilds to satisfy "(.+)"/)
+          invalid = $1
+          log.debug(PNOTE+"PackageManager::Portage.installed? skipping invalid package '#{invalid}'")
+          missing << invalid
+          break if (list-missing).size.zero?
+        else
+          matches = output.scan(%r{^\[\w+\s+R\s*\] .+/(\w+?)-.+$}).flatten
+          available = list & matches
+          break
+        end
+      end
+
+      available
+    end
+  end
+
+  # See AutomateIt::PackageManager#not_installed?
+  def not_installed?(*packages)
+    return _not_installed_helper?(*packages)
+  end
+
+  # See AutomateIt::PackageManager#install
+  def install(*packages)
+    return _install_helper(*packages) do |list, opts|
+      cmd = "emerge --color n --nospinner --tree --usepkg --quiet #{list.join(' ')} < /dev/null"
+      cmd << " > /dev/null" if opts[:quiet]
+      cmd << " 2>&1"
+
+      interpreter.sh(cmd)
+    end
+  end
+
+  # See AutomateIt::PackageManager#uninstall
+  def uninstall(*packages)
+    return _uninstall_helper(*packages) do |list, opts|
+      cmd = "emerge --color n --nospinner --tree --unmerge --quiet #{list.join(' ')} < /dev/null"
+      cmd << " > /dev/null" if opts[:quiet]
+      cmd << " 2>&1"
+
+      interpreter.sh(cmd)
+    end
+  end
+end
+