automate-it 0.9.0

data/lib/automateit/package_manager.rb

@@ -0,0 +1,257 @@
+# == PackageManager
+#
+# The PackageManager provides a way to manage packages, e.g., install,
+# uninstall and query if the Apache package is installed with APT.
+#
+# Examples:
+#
+#   package_manager.installed?("apache2") # => false
+#   package_manager.install("apache2") # => true
+#   package_manager.installed?("apache2") # => true
+#   package_manager.uninstall("apache2") # => true
+#   package_manager.not_installed("apache2") # => true
+#
+# Commands can accept arrays:
+#
+#   package_manager.install("apache2", "bash")
+#   package_manager.installed? %w(apache2 bash)
+#
+# Commands can also accept a single, annotated string as a manifest -- useful
+# for installing large numbers of packages at once:
+#
+#   package_manager.install <<HERE, :with => :apt
+#     # One per line
+#     apache
+#     bash
+#
+#     # Or many on the same line
+#     sysvconfig sysv-rc-conf
+#   HERE
+#
+# Commands can also accept a hash of names to paths -- necessary for installing
+# packages stored on the filesystem:
+#
+#   # Is the package called "TracTags" installed? If not, run the installer
+#   # with the "/tmp/tractags_latest" path as an argument:
+#   package.manager.install({"TracTags" => "/tmp/tractags_latest"}, :with => :egg)
+class AutomateIt::PackageManager < AutomateIt::Plugin::Manager
+  # Alias for #install
+  def add(*packages) dispatch_to(:install, *packages) end
+
+  # Alias for #uninstall
+  def remove(*packages) dispatch_to(:uninstall, *packages) end
+
+  # Are these +packages+ installed?
+  #
+  # Options:
+  # * :details -- Returns an array containing the boolean result value and an
+  #   array with a subset of installed +packages+. Boolean, defaults to false.
+  def installed?(*packages) dispatch(*packages) end
+
+  # Are these +packages+ not installed? 
+  #
+  # Options:
+  # * :details -- Returns an array containing the boolean result value and an
+  #   array with a subset of +packages+ not installed. Boolean, defaults to false.
+  def not_installed?(*packages) dispatch(*packages) end
+
+  # Install these +packages+. Returns +true+ if any packages are installed
+  # successfully; or +false+ if all packages were already installed.
+  def install(*packages) dispatch(*packages) end
+
+  # Uninstall these +packages+. Returns +true+ if any packages are uninstalled
+  # successfully; or +false+ if none of the packages are installed.
+  def uninstall(*packages) dispatch(*packages) end
+end
+
+# == PackageManager::BaseDriver
+#
+# Base class for all PackageManager drivers.
+class AutomateIt::PackageManager::BaseDriver < AutomateIt::Plugin::Driver
+  protected
+
+  # Are these +packages+ installed? Works like PackageManager#installed?
+  # but calls a block that actually checks whether the packages are
+  # installed and returns an array of packages installed.
+  #
+  # For example:
+  #   _installed_helper?("package1", "package2", :details => true) do |packages, opts|
+  #     # Dummy code which reports that these packages are installed:
+  #     ["package1]
+  #   end
+  def _installed_helper?(*packages, &block) # :yields: filtered_packages, opts
+    _raise_unless_available
+
+    packages, opts = args_and_opts(*packages)
+    packages = _list_normalizer(packages)
+    packages = packages.keys if Hash === packages
+
+    available = block.call(packages, opts)
+    truth = (packages - available).empty?
+    result = opts[:details] ? [truth, available] : truth
+    log.debug(PNOTE+"installed?(#{packages.inspect}) => #{truth}: #{available.inspect}")
+    return result
+  end
+
+  # Are these +packages+ not installed?
+  def _not_installed_helper?(*packages)
+    _raise_unless_available
+
+    # Requires that your PackageManager#installed? method is implemented.
+    packages, opts = args_and_opts(*packages)
+    packages = _list_normalizer(packages)
+    packages = packages.keys if Hash === packages
+
+    available = [installed?(packages, :details => true)].flatten
+    missing = packages - available
+    truth = (packages - missing).empty?
+    result = opts[:details] ? [truth, missing] : truth
+    log.debug(PNOTE+"not_installed?(#{packages.inspect}) => #{truth}: #{missing.inspect}")
+    return result
+  end
+
+  # Install these +packages+. Works like PackageManager#install but calls a
+  # block that's responsible for actually installing the packages and
+  # returning true if the installation succeeded. This block is only called
+  # if packages need to be installed and receives a filtered list of
+  # packages that are guaranteed not to be installed on the system already.
+  #
+  # For example:
+  #   _install_helper("package1", "package2", :quiet => true) do |packages, opts|
+  #     # Dummy code that installs packages here, e.g:
+  #     system("apt-get", "install", "-y", packages)
+  #   end
+  def _install_helper(*packages, &block) # :yields: filtered_packages, opts
+    _raise_unless_available
+
+    packages, opts = args_and_opts(*packages)
+    packages = _list_normalizer(packages)
+
+    check_packages = \
+      case packages
+      when Hash
+        packages.keys
+      else 
+        packages
+      end
+
+    missing = not_installed?(check_packages, :details => true)[1]
+    return false if missing.blank?
+
+    install_packages = \
+      case packages
+      when Hash
+        missing.map{|t| packages[t]}
+      else 
+        missing
+      end
+    block.call(install_packages, opts)
+
+    return true if preview?
+    unless (failed = not_installed?(check_packages, :details => true)[1]).empty?
+      raise ArgumentError.new("Couldn't install: #{failed.join(' ')}")
+    else
+      return true
+    end
+  end
+
+  # Uninstall these +packages+. Works like PackageManager#uninstall but calls a
+  # block that's responsible for actually uninstalling the packages and
+  # returning true if the uninstall succeeded. This block is only called
+  # if packages need to be uninstalled and receives a filtered list of
+  # packages that are guaranteed to be installed on the system.
+  #
+  # For example:
+  #   _uninstall_helper("package1", "package2", :quiet => true) do |packages, opts|
+  #     # Dummy code that removes packages here, e.g:
+  #     system("apt-get", "remove", "-y", packages)
+  #   end
+  def _uninstall_helper(*packages, &block) # :yields: filtered_packages, opts
+    _raise_unless_available
+
+    packages, opts = args_and_opts(*packages)
+    packages = _list_normalizer(packages)
+
+    check_packages = \
+      case packages
+      when Hash
+        packages.keys
+      else 
+        packages
+      end
+
+    present = installed?(check_packages, :details => true)[1]
+    return false if present.blank?
+
+    uninstall_packages = \
+      case packages
+      when Hash
+        present.map{|t| packages[t]}
+      else 
+        present
+      end
+    block.call(uninstall_packages, opts)
+
+    return true if preview?
+    unless (failed = installed?(check_packages, :details => true)[1]).empty?
+      raise ArgumentError.new("Couldn't uninstall: #{failed.join(' ')}")
+    else
+      return true
+    end
+  end
+
+  # Returns a normalized array of packages. Transforms manifest string into
+  # packages. Turns symbols into string, strips blank lines and comments.
+  def _list_normalizer(*packages)
+    packages = [packages].flatten
+    if packages.size == 1
+      packages = packages.first
+      nitpick "LN SI %s" % packages.inspect
+      nitpick "LN Sc %s" % packages.class
+      case packages
+      when Symbol
+        nitpick "LN Sy"
+        packages = [packages.to_s]
+      when String
+        nitpick "LN Ss"
+        packages = _string_to_packages(packages)
+      when Hash
+        # Don't do anything
+        nitpick "LN Sh"
+      else
+        nitpick "LN S?"
+        raise TypeError.new("Unknown input type: #{packages.class}")
+      end
+      nitpick "LN SO %s" % packages.inspect
+    end
+
+    case packages
+    when Array
+      result = packages.map(&:to_s).map{|t| _string_to_packages(t)}.flatten.uniq
+    when Hash
+      result = packages.stringify_keys
+    when Symbol, String
+      result = packages.to_s
+    else
+      raise TypeError.new("Unknown input type: #{packages.class}")
+    end
+
+    nitpick "LN RR %s" % result.inspect
+    return result
+  end
+
+  def _string_to_packages(string)
+    string.scan(/^\s*([^#]+)\s*/).flatten.map{|t| t.split}.flatten.uniq
+  end
+end
+
+# Drivers
+require 'automateit/package_manager/dpkg'
+require 'automateit/package_manager/apt'
+require 'automateit/package_manager/yum'
+require 'automateit/package_manager/gem'
+require 'automateit/package_manager/egg'
+require 'automateit/package_manager/portage'
+require 'automateit/package_manager/pear'
+require 'automateit/package_manager/pecl'
+require 'automateit/package_manager/cpan'

data/lib/automateit/package_manager/apt.rb

@@ -0,0 +1,27 @@
+# == PackageManager::APT
+#
+# The APT driver for the PackageManager provides a way to manage software
+# packages on Debian-style systems using <tt>apt-get</tt> and <tt>dpkg</tt>.
+class AutomateIt::PackageManager::APT < AutomateIt::PackageManager::DPKG
+  depends_on :programs => %w(apt-get dpkg)
+
+  def suitability(method, *args) # :nodoc:
+    return available? ? 1 : 0
+  end
+
+  # See AutomateIt::PackageManager#install
+  def install(*packages)
+    return _install_helper(*packages) do |list, opts|
+      # apt-get options:
+      # -y : yes to all queries
+      # -q : no interactive progress bars
+      cmd = "export DEBIAN_FRONTEND=noninteractive; apt-get"
+      cmd << " -t #{opts[:backports]}" if opts[:backports]
+      cmd << " install -y -q "+list.join(" ")+" < /dev/null"
+      cmd << " > /dev/null" if opts[:quiet]
+      cmd << " 2>&1"
+
+      interpreter.sh(cmd)
+    end
+  end
+end

data/lib/automateit/package_manager/cpan.rb

@@ -0,0 +1,101 @@
+# == PackageManager::CPAN
+#
+# A PackageManager driver for Perl CPAN (Comprehensive Perl Archive Network)
+# software packages.
+#
+# === No automatic dependency installation
+#
+# Unlike other AutomateIt PackageManager drivers, the CPAN driver will not install a package's dependencies automatically. This protects you because many CPAN packages require a specific version of Perl, often one which you don't have installed, and installing that dependency will destroy your Perl interpreter and everything that depends on it. Therefore, you must specify all package dependencies manually. If a package dependency isn't found, the install will fail.
+#
+# === Specifying Perl interpreter
+#
+# Use #setup to specify the Perl interpreter to use for all subsequent calls.
+#
+# Example:
+#
+#   package_manager[:cpan].setup(:perl => "/usr/local/bin/perl")
+#   package_manager.install %w(File::Next App::Ack), :with => :cpan
+class ::AutomateIt::PackageManager::CPAN < ::AutomateIt::PackageManager::BaseDriver
+  CPAN_WRAPPER = File.join(::AutomateIt::Constants::HELPERS_DIR, "cpan_wrapper.pl")
+
+  # Path to Perl interpreter
+  attr_accessor :perl
+
+  # FIXME How to get #depends_on to use same Perl interpreter as #perl? The trouble is that Plugin::Driver#available? checks a class variable populated by #depends_on, so it can't see the instance's #perl variable that's been set by the user. A general solution would address this problem for all drivers that use commands with different names, e.g. "gem1.8", "python2.5.1", etc.
+  depends_on :programs => %w(perl)
+
+  # Setup the PackageManager::CPAN driver.
+  #
+  # Options:
+  # * :perl -- The absolute, relative or unqualified path for the Perl interpreter to use. E.g., "perl" or "/usr/local/bin/perl".
+  def setup(*args)
+    super(*args)
+
+    args, opts = args_and_opts(*args)
+    if opts[:perl]
+      self.perl = opts[:perl]
+    else
+      self.perl ||= "perl"
+    end
+  end
+
+  def suitability(method, *args) # :nodoc:
+    # Never select as default driver
+    return 0
+  end
+
+  # Options:
+  # * :perl -- Command to use as the Perl interpreter, otherwise defaults to the one specified during #setup or to "perl"
+  #
+  # See AutomateIt::PackageManager#installed?
+  def installed?(*packages)
+    return _installed_helper?(*packages) do |list, opts|
+      perl = opts[:perl] || self.perl
+      cmd = "#{perl} #{CPAN_WRAPPER} --query #{list.join(' ')}"
+
+      # FIXME if CPAN isn't configured, this will hang because Perl will demand input
+      log.debug(PEXEC+cmd)
+      output = `#{cmd}`
+      output.sub!(/.*---(\s[^\n]+)?\n/m, '')
+      struct = ::YAML.load(output)
+
+      struct["available"] || []
+    end
+  end
+
+  # See AutomateIt::PackageManager#not_installed?
+  def not_installed?(*packages)
+    # TODO Move #not_installed? up to BaseDriver
+    return _not_installed_helper?(*packages)
+  end
+
+  # Options:
+  # * :perl -- Command to use as the Perl interpreter, otherwise defaults to the one specified during #setup or to "perl"
+  #
+  # See AutomateIt::PackageManager#install
+  def install(*packages)
+    return _install_helper(*packages) do |list, opts|
+      perl = opts[:perl] || self.perl
+      cmd = "#{perl} #{CPAN_WRAPPER} --install #{list.join(' ')}"
+      cmd << " > /dev/null" if opts[:quiet]
+      cmd << " 2>&1"
+
+      interpreter.sh(cmd)
+    end
+  end
+
+  # Options:
+  # * :perl -- Command to use as the Perl interpreter, otherwise defaults to the one specified during #setup or to "perl"
+  #
+  # See AutomateIt::PackageManager#uninstall
+  def uninstall(*packages)
+    return _uninstall_helper(*packages) do |list, opts|
+      perl = opts[:perl] || self.perl
+      cmd = "#{perl} #{CPAN_WRAPPER} --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/dpkg.rb

@@ -0,0 +1,54 @@
+# == PackageManager::DPKG
+#
+# The DPKG driver for the PackageManager provides a way to manage software
+# packages on Debian-style systems using <tt>dpkg</tt>.
+class AutomateIt::PackageManager::DPKG < AutomateIt::PackageManager::BaseDriver
+  depends_on :programs => %w(dpkg)
+
+  # See AutomateIt::PackageManager#installed?
+  def installed?(*packages)
+    return _installed_helper?(*packages) do |list, opts|
+      ### data = `dpkg --status nomarch apache2 not_a_real_package 2>&1`
+      cmd = "dpkg --status "+list.join(" ")+" 2>&1"
+
+      log.debug(PEXEC+cmd)
+      data = `#{cmd}`
+      matches = data.scan(/^Package: (.+)$\s*^Status: (.+)$/)
+      available = matches.inject([]) do |sum, match|
+        package, status = match
+        sum << package if status.match(/(?:^|\s)installed\b/)
+        sum
+      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 = "export DEBIAN_FRONTEND=noninteractive; dpkg --install --skip-same-version "+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 = "export DEBIAN_FRONTEND=noninteractive; dpkg --remove "+list.join(" ")+" < /dev/null"
+      cmd << " > /dev/null" if opts[:quiet]
+      cmd << " 2>&1"
+
+      interpreter.sh(cmd)
+    end
+  end
+end
+

data/lib/automateit/package_manager/egg.rb

@@ -0,0 +1,64 @@
+# == PackageManager::Egg
+#
+# The Egg driver for the PackageManager provides a way to manage
+# Python software packages with the PEAK +easy_install+ tool.
+class AutomateIt::PackageManager::Egg < AutomateIt::PackageManager::BaseDriver
+  depends_on :programs => %w(python easy_install)
+
+  def suitability(method, *args) # :nodoc:
+    # Never select as default driver
+    return 0
+  end
+
+  # See AutomateIt::PackageManager#installed?
+  def installed?(*packages)
+    return _installed_helper?(*packages) do |list, opts|
+      cmd = "python -c 'import sys; print(sys.path)' 2>&1"
+
+      log.debug(PEXEC+cmd)
+      data = `#{cmd}`
+      # Extract array elements, turn them into basenames, and then split on
+      # '-' because that's the separator for the name and version.
+      found = data.scan(/'([^']+\.egg)'/).flatten.map{|t| File.basename(t).split('-', 2)[0]}
+      available = found & list
+    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|
+      # easy_install options:
+      # -Z : install into a direcory rather than a file
+      cmd = "easy_install -Z "+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|
+      # easy_install options:
+      # -m : removes package from the easy-install.pth
+      cmd = "easy_install -m "+list.join(" ")+" < /dev/null"
+      cmd << " > /dev/null" if opts[:quiet]
+      cmd << " 2>&1"
+
+      # Parse output for paths and remove the orphaned entries
+      log.info(PEXEC+cmd)
+      return packages if preview?
+      data = `#{cmd}`
+      paths = data.scan(/^Using ([^\n]+\.egg)$/m).flatten
+      for path in paths
+        interpreter.rm_rf(path)
+      end
+    end
+  end
+end