automateit 0.70923

data/lib/automateit/package_manager.rb

@@ -0,0 +1,242 @@
+# == 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 = packages.grep(LIST_NORMALIZER_RE).join(" ").split
+      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).grep(LIST_NORMALIZER_RE)
+    when Hash
+      result = packages.stringify_keys
+    else
+      raise TypeError.new("Unknown input type: #{packages.class}")
+    end
+
+    nitpick "LN RR %s" % result.inspect
+    return result
+  end
+
+  # Expression for matching packages in arguments
+  LIST_NORMALIZER_RE = /^\s*([^\s#]+)/
+end
+
+# Drivers
+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'

data/lib/automateit/package_manager/apt.rb

@@ -0,0 +1,63 @@
+# == 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::BaseDriver
+  depends_on :programs => %w(apt-get dpkg)
+
+  def suitability(method, *args) # :nodoc:
+    return available? ? 1 : 0
+  end
+
+  # 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|
+      # apt-get options:
+      # -y : yes to all queries
+      # -q : no interactive progress bars
+      cmd = "export DEBIAN_FRONTEND=noninteractive; apt-get install -y -q "+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|
+      # apt-get options:
+      # -y : yes to all queries
+      # -q : no interactive progress bars
+      cmd = "export DEBIAN_FRONTEND=noninteractive; apt-get remove -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/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

data/lib/automateit/package_manager/gem.rb

@@ -0,0 +1,179 @@
+# == PackageManager::Gem
+#
+# The Gem driver for the PackageManager provides a way to manage software
+# packages for RubyGems using the +gem+ command.
+class AutomateIt::PackageManager::Gem < AutomateIt::PackageManager::BaseDriver
+  depends_on \
+    :programs => %w(gem), 
+    :callbacks => [lambda{
+      # TODO PackageManager::Gem -- Misleading #depends_on makes entire driver unavailable, although only #install requires PTY.
+      begin
+        require 'expect'
+        require 'pty'
+        return true
+      rescue LoadError
+        return false
+      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|
+      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|
+      # 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'
+        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|
+      # 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