automateit 0.70923

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
+

data/lib/automateit/package_manager/yum.rb

@@ -0,0 +1,65 @@
+# == PackageManager::YUM
+#
+# The YUM driver for the PackageManager provides a way to manage software
+# packages on Red Hat-style systems using +yum+ and +rpm+.
+class AutomateIt::PackageManager::YUM < AutomateIt::PackageManager::BaseDriver
+  depends_on :programs => %w(yum rpm)
+
+  def suitability(method, *args) # :nodoc:
+    return available? ? 1 : 0
+  end
+
+  # See AutomateIt::PackageManager#installed?
+  def installed?(*packages)
+    return _installed_helper?(*packages) do |list, opts|
+      ### rpm -q --nosignature --nodigest --qf "%{NAME} # %{VERSION} # %{RELEASE}\n" httpd nomarch foo
+      cmd = 'rpm -q --nosignature --nodigest --qf "%{NAME} # %{VERSION} # %{RELEASE}\n"'
+      list.each{|package| cmd << " "+package}
+      cmd << " 2>&1" # missing packages are listed on STDERR
+
+      log.debug(PEXEC+cmd)
+      data = `#{cmd}`
+      matches = data.scan(/^(.+) # (.+) # .+$/)
+      available = matches.inject([]) do |sum, match|
+        package, status = match
+        sum << package
+        sum
+      end
+      available
+    end
+  end
+
+  # See AutomateIt::PackageManager#not_installed?
+  def not_installed?(*packages)
+    _not_installed_helper?(*packages)
+  end
+
+  # See AutomateIt::PackageManager#install
+  def install(*packages)
+    return _install_helper(*packages) do |list, opts|
+      # yum options:
+      # -y : yes to queries
+      # -d 0 : no debugging info
+      # -e 0 : show only fatal errors
+      # -C : don't download headers
+      cmd = "yum -y -d 0 -e 0"
+      cmd << " -C" if opts[:cache] == true
+      cmd << " install "+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 = "rpm --erase --quiet "+list.join(" ")+" < /dev/null"
+      cmd << " > /dev/null" if opts[:quiet]
+      cmd << " 2>&1"
+
+      interpreter.sh(cmd)
+    end
+  end
+end

data/lib/automateit/platform_manager.rb

@@ -0,0 +1,47 @@
+# == PlatformManager
+#
+# The PlatformManager provides a way to query platform identifiers, such as
+# the operating system distribution's version.
+class AutomateIt::PlatformManager < AutomateIt::Plugin::Manager
+  # Query the +search+ field. The +search+ can either be a key or a set of
+  # keys separated by "#" signs.
+  #
+  # Examples:
+  #   query(:os) # => "linux"
+  #   query("arch") # => "i686"
+  #   query("os#arch") # => "linux_i686"
+  #   query("os#arch#distro#release") # => "linux_i686_ubuntu_6.06"
+  #
+  # Fields that may be provided by drivers:
+  # * :arch -- Hardware architecture, e.g., "i686"
+  # * :os -- Operating system, e.g., "linux"
+  # * :distro -- Operating system distribution, e.g., "ubuntu"
+  # * :release -- Operating system distribution release, e.g., "6.06"
+  def query(search) dispatch(search) end
+
+  # Is this a single-vendor operating system? E.g., Windows is, while Linux
+  # isn't. This method helps the TagManager determine how to name tags. A
+  # single-vendor product uses the "os#release" format (e.g., "windows_xp"),
+  # while a multi-vendor product uses a "distro#release" format
+  # ("ubuntu_6.06").
+  def single_vendor?() dispatch() end
+
+  # Return an array of tags for this platform.
+  def tags() dispatch() end
+end
+
+# == PlatformManager::BaseDriver
+#
+# Base class for all PlatformManager drivers.
+class AutomateIt::PlatformManager::BaseDriver < AutomateIt::Plugin::Driver
+end
+
+# Drivers
+require 'automateit/platform_manager/struct'
+require 'automateit/platform_manager/uname'
+require 'automateit/platform_manager/lsb'
+require 'automateit/platform_manager/debian'
+require 'automateit/platform_manager/gentoo'
+require 'automateit/platform_manager/darwin'
+require 'automateit/platform_manager/windows'
+require 'automateit/platform_manager/freebsd'

data/lib/automateit/platform_manager/darwin.rb

@@ -0,0 +1,30 @@
+# == PlatformManager::Darwin
+#
+# A PlatformManager driver for Apple's Darwin.
+class AutomateIt::PlatformManager::Darwin < AutomateIt::PlatformManager::Struct
+  depends_on :files => ["/usr/sbin/scutil"], :programs => ["which"]
+
+  def suitability(method, *args) # :nodoc:
+    # Must be higher than PlatformManager::Struct
+    return available? ? 3 : 0
+  end
+
+  def _prepare
+    return if @struct[:release]
+    @struct[:os] = "darwin"
+    @struct[:arch] = `uname -p`.strip.downcase
+    @struct[:distro] = "apple"
+    @struct[:release] = `uname -r`.strip.downcase
+    @struct
+  end
+  private :_prepare
+
+  def query(search)
+    _prepare
+    super(search)
+  end
+
+  def single_vendor?
+    return true
+  end
+end

data/lib/automateit/platform_manager/debian.rb

@@ -0,0 +1,26 @@
+# == PlatformManager::Debian
+#
+# A PlatformManager driver for Debian Linux.
+class AutomateIt::PlatformManager::Debian < AutomateIt::PlatformManager::Uname
+  VERSION_FILE = "/etc/debian_version"
+
+  depends_on :files => [VERSION_FILE]
+
+  def suitability(method, *args) # :nodoc:
+    # Must be higher than PlatformManager::Struct
+    return available? ? 3 : 0
+  end
+
+  def _prepare
+    return if @struct[:distro]
+    @struct[:distro] = "debian"
+    @struct[:release] = File.read(VERSION_FILE).strip
+    @struct
+  end
+  private :_prepare
+
+  def query(search)
+    _prepare
+    super(search)
+  end
+end

data/lib/automateit/platform_manager/freebsd.rb

@@ -0,0 +1,25 @@
+# == PlatformManager::FreeBSD
+#
+# A PlatformManager driver for FreeBSD.
+class AutomateIt::PlatformManager::FreeBSD < AutomateIt::PlatformManager::Uname
+  depends_on :files => %w(/etc/portsnap.conf /etc/rc.conf)
+
+  def suitability(method, *args) # :nodoc:
+    # Must be higher than PlatformManager::Struct
+    return available? ? 3 : 0
+  end
+
+  def _prepare
+    return if @struct[:distro]
+    @struct[:distro] = "freebsd"
+    @struct[:release] = `uname -r`.strip.match(/^([\d\.]+)-/)[1]
+    @struct
+  end
+  private :_prepare
+
+  def query(search)
+    _prepare
+    super(search)
+  end
+end
+

data/lib/automateit/platform_manager/gentoo.rb

@@ -0,0 +1,26 @@
+# == PlatformManager::Gentoo
+#
+# A PlatformManager driver for Gentoo Linux.
+class AutomateIt::PlatformManager::Gentoo < AutomateIt::PlatformManager::Uname
+  GENTOO_RELEASE = "/etc/gentoo-release"
+
+  depends_on :files => [GENTOO_RELEASE]
+
+  def suitability(method, *args) # :nodoc:
+    # Must be higher than PlatformManager::Struct
+    return available? ? 3 : 0
+  end
+
+  def _prepare
+    return if @struct[:distro]
+    @struct[:distro] = "gentoo"
+    @struct[:release] = File.read(GENTOO_RELEASE).strip.match(/\s([\d\.]+)$/)[1]
+    @struct
+  end
+  private :_prepare
+
+  def query(search)
+    _prepare
+    super(search)
+  end
+end

data/lib/automateit/platform_manager/lsb.rb

@@ -0,0 +1,40 @@
+# == PlatformManager::LSB
+#
+# A PlatformManager driver for LSB (Linux Standards Base) systems. The
+# platform doesn't actually need to be Linux, but simply has to provide an
+# <tt>lsb_release</tt> command.
+class AutomateIt::PlatformManager::LSB < AutomateIt::PlatformManager::Uname
+  LSB_RELEASE = "lsb_release"
+
+  depends_on :programs => [LSB_RELEASE]
+
+  def suitability(method, *args) # :nodoc:
+    # Level must be greater than Uname and Debian
+    return available? ? 4 : 0
+  end
+
+  def setup(opts={}) # :nodoc:
+    super(opts) # Rely on Uname to set :os and :arch
+    @struct[:distro]  ||= @@struct_cache[:distro]
+    @struct[:release] ||= @@struct_cache[:release]
+    if available?
+      unless @struct[:distro] and @struct[:release]
+        data = _read_lsb_release_output # SLOW 0.2s
+        begin
+          yaml = YAML::load(data)
+          @struct[:distro]  ||= @@struct_cache[:distro]  ||= yaml["Distributor ID"].to_s.downcase
+          @struct[:release] ||= @@struct_cache[:release] ||= yaml["Release"].to_s.downcase
+        rescue NoMethodError, IndexError, ArgumentError => e
+          raise ArgumentError.new("invalid YAML output from '#{LSB_RELEASE}': #{data.inspect}")
+        end
+      end
+    end
+  end
+
+  def _read_lsb_release_output
+    # Do NOT use 'lsb_release -a' because this takes a few seconds. Telling
+    # 'lsb_release' which fields we want makes it much faster.
+    return `"#{LSB_RELEASE}" --release --id`.gsub(/\t/, " ")
+  end
+  private :_read_lsb_release_output
+end

data/lib/automateit/platform_manager/struct.rb

@@ -0,0 +1,78 @@
+# == PlatformManager::Struct
+#
+# A simple PlatformManager driver that queries a hash for results. Although
+# not useful on its own, it's inherited by other drivers that provide
+# platform-specific methods to query the system.
+class AutomateIt::PlatformManager::Struct < AutomateIt::PlatformManager::BaseDriver
+  depends_on :nothing
+
+  # Hash mapping of keys that have many common names, e.g., "release" and "version"
+  attr_accessor :key_aliases
+
+  def suitability(method, *args) # :nodoc:
+    return 1
+  end
+
+  # Options:
+  # * :struct -- The hash to use for queries.
+  def setup(opts={})
+    super(opts)
+
+    @@struct_cache ||= {}
+
+    if opts[:struct]
+      @struct = opts[:struct]
+    else
+      @struct ||= {}
+    end
+
+    # Generate bi-directional map
+    @key_aliases ||= @@key_aliases ||= {
+      :version => :release,
+    }.inject({}){|s,v| s[v[0]] = v[1]; s[v[1]] = v[0]; s}
+  end
+
+  # See PlatformManager#query
+  def query(search)
+    result = ""
+    for key in search.to_s.split(/#/)
+      result << "_" unless result.empty?
+      result << _query_key(key)
+    end
+    result
+  end
+
+  def _query_key(key)
+    key = key.to_sym
+    unless @struct.has_key?(key)
+      key_alias = key_aliases[key]
+      if @struct.has_key?(key_alias)
+        key = key_alias
+      else
+        raise IndexError.new("platform doesn't provide key: #{key}")
+      end
+    end
+    return @struct[key]
+  end
+  private :_query_key
+
+  # See PlatformManager#single_vendor?
+  def single_vendor?
+    return false
+  end
+
+  # See PlatformManager#tags
+  def tags
+    results = @struct.values
+    results << query("os#arch") rescue IndexError
+
+    release_query = \
+      if single_vendor?
+        "os#release"     # E.g. windows_xp
+      else
+        "distro#release" # E.g. ubuntu_6.06
+      end
+    results << query(release_query) rescue IndexError
+    return results
+  end
+end

data/lib/automateit/platform_manager/uname.rb

@@ -0,0 +1,29 @@
+# == PlatformManager::Uname
+#
+# A PlatformManager driver that uses the Unix +uname+ command to provide
+# basic information about the platform.
+class AutomateIt::PlatformManager::Uname < AutomateIt::PlatformManager::Struct
+  depends_on :programs => %w(uname)
+
+  def suitability(method, *args) # :nodoc:
+    # Level must be greater than Struct's
+    return available? ? 2 : 0
+  end
+
+  def setup(opts={}) # :nodoc:
+    super(opts)
+    if available?
+      @struct[:os]   ||= @@struct_cache[:os]   ||= `uname -s`.chomp.downcase
+      @struct[:arch] ||= @@struct_cache[:arch] ||= `uname -m`.chomp.downcase
+=begin
+      # This method is 20% faster, but is it less portable because of the combined calls?
+      @struct[:os] and @struct[:arch] or begin
+        output = `uname -s -m`.chomp.downcase
+        os, arch = output.split(/\s+/)
+        @struct[:os]   = @@struct_cache[:os]   = os
+        @struct[:arch] = @@struct_cache[:arch] = arch
+      end
+=end
+    end
+  end
+end