class AutomateIt::PackageManager::BaseDriver

PackageManager::BaseDriver

Base class for all PackageManager drivers.

Protected Instance Methods

_install_helper(*packages) { |filtered_packages, opts| ... } click to toggle source

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
# File lib/automateit/package_manager.rb, line 124
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
_installed_helper?(*packages) { |filtered_packages, opts| ... } click to toggle source

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
# File lib/automateit/package_manager.rb, line 82
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
_list_normalizer(*packages) click to toggle source

Returns a normalized array of packages. Transforms manifest string into packages. Turns symbols into string, strips blank lines and comments.

# File lib/automateit/package_manager.rb, line 205
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
_not_installed_helper?(*packages) click to toggle source

Are these packages not installed?

# File lib/automateit/package_manager.rb, line 97
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
_string_to_packages(string) click to toggle source
# File lib/automateit/package_manager.rb, line 243
def _string_to_packages(string)
  string.scan(/^\s*([^#]+)\s*/).flatten.map{|t| t.split}.flatten.uniq
end
_uninstall_helper(*packages) { |filtered_packages, opts| ... } click to toggle source

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
# File lib/automateit/package_manager.rb, line 169
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