bolt 0.19.1 → 0.20.0

data/vendored/puppet/lib/puppet/provider/package/apt.rb

@@ -1,116 +0,0 @@
-Puppet::Type.type(:package).provide :apt, :parent => :dpkg, :source => :dpkg do
-  # Provide sorting functionality
-  include Puppet::Util::Package
-
-  desc "Package management via `apt-get`.
-
-    This provider supports the `install_options` attribute, which allows command-line flags to be passed to apt-get.
-    These options should be specified as a string (e.g. '--flag'), a hash (e.g. {'--flag' => 'value'}),
-    or an array where each element is either a string or a hash."
-
-  has_feature :versionable, :install_options
-
-  commands :aptget => "/usr/bin/apt-get"
-  commands :aptcache => "/usr/bin/apt-cache"
-  commands :preseed => "/usr/bin/debconf-set-selections"
-
-  defaultfor :osfamily => :debian
-
-  ENV['DEBIAN_FRONTEND'] = "noninteractive"
-
-  # disable common apt helpers to allow non-interactive package installs
-  ENV['APT_LISTBUGS_FRONTEND'] = "none"
-  ENV['APT_LISTCHANGES_FRONTEND'] = "none"
-
-  # A derivative of DPKG; this is how most people actually manage
-  # Debian boxes, and the only thing that differs is that it can
-  # install packages from remote sites.
-
-  def checkforcdrom
-    have_cdrom = begin
-                   !!(File.read("/etc/apt/sources.list") =~ /^[^#]*cdrom:/)
-                 rescue
-                   # This is basically pathological...
-                   false
-                 end
-
-    if have_cdrom and @resource[:allowcdrom] != :true
-      raise Puppet::Error,
-        _("/etc/apt/sources.list contains a cdrom source; not installing.  Use 'allowcdrom' to override this failure.")
-    end
-  end
-
-  # Install a package using 'apt-get'.  This function needs to support
-  # installing a specific version.
-  def install
-    self.run_preseed if @resource[:responsefile]
-    should = @resource[:ensure]
-
-    checkforcdrom
-    cmd = %w{-q -y}
-
-    if config = @resource[:configfiles]
-      if config == :keep
-        cmd << "-o" << 'DPkg::Options::=--force-confold'
-      else
-        cmd << "-o" << 'DPkg::Options::=--force-confnew'
-      end
-    end
-
-    str = @resource[:name]
-    case should
-    when true, false, Symbol
-      # pass
-    else
-      # Add the package version and --force-yes option
-      str += "=#{should}"
-      cmd << "--force-yes"
-    end
-
-    cmd += install_options if @resource[:install_options]
-    cmd << :install << str
-
-    aptget(*cmd)
-  end
-
-  # What's the latest package version available?
-  def latest
-    output = aptcache :policy,  @resource[:name]
-
-    if output =~ /Candidate:\s+(\S+)\s/
-      return $1
-    else
-      self.err _("Could not find latest version")
-      return nil
-    end
-  end
-
-  #
-  # preseeds answers to dpkg-set-selection from the "responsefile"
-  #
-  def run_preseed
-    if response = @resource[:responsefile] and Puppet::FileSystem.exist?(response)
-      self.info(_("Preseeding %{response} to debconf-set-selections") % { response: response })
-
-      preseed response
-    else
-      self.info _("No responsefile specified or non existent, not preseeding anything")
-    end
-  end
-
-  def uninstall
-    self.run_preseed if @resource[:responsefile]
-    aptget "-y", "-q", :remove, @resource[:name]
-  end
-
-  def purge
-    self.run_preseed if @resource[:responsefile]
-    aptget '-y', '-q', :remove, '--purge', @resource[:name]
-    # workaround a "bug" in apt, that already removed packages are not purged
-    super
-  end
-
-  def install_options
-    join_options(@resource[:install_options])
-  end
-end

data/vendored/puppet/lib/puppet/provider/package/aptitude.rb

@@ -1,29 +0,0 @@
-Puppet::Type.type(:package).provide :aptitude, :parent => :apt, :source => :dpkg do
-  desc "Package management via `aptitude`."
-
-  has_feature :versionable
-
-  commands :aptitude => "/usr/bin/aptitude"
-  commands :aptcache => "/usr/bin/apt-cache"
-
-  ENV['DEBIAN_FRONTEND'] = "noninteractive"
-
-  def aptget(*args)
-    args.flatten!
-    # Apparently aptitude hasn't always supported a -q flag.
-    args.delete("-q") if args.include?("-q")
-    args.delete("--force-yes") if args.include?("--force-yes")
-    output = aptitude(*args)
-
-    # Yay, stupid aptitude doesn't throw an error when the package is missing.
-    if args.include?(:install) and output =~ /Couldn't find any package/
-      raise Puppet::Error.new(
-        _("Could not find package %{name}") % { name: self.name }
-      )
-    end
-  end
-
-  def purge
-    aptitude '-y', 'purge', @resource[:name]
-  end
-end

data/vendored/puppet/lib/puppet/provider/package/aptrpm.rb

@@ -1,83 +0,0 @@
-Puppet::Type.type(:package).provide :aptrpm, :parent => :rpm, :source => :rpm do
-  # Provide sorting functionality
-  include Puppet::Util::Package
-
-  desc "Package management via `apt-get` ported to `rpm`."
-
-  has_feature :versionable
-
-  commands :aptget => "apt-get"
-  commands :aptcache => "apt-cache"
-  commands :rpm => "rpm"
-
-  if command('rpm')
-    confine :true => begin
-      rpm('-ql', 'rpm')
-      rescue Puppet::ExecutionFailure
-        false
-      else
-        true
-      end
-  end
-
-  # Install a package using 'apt-get'.  This function needs to support
-  # installing a specific version.
-  def install
-    should = @resource.should(:ensure)
-
-    str = @resource[:name]
-    case should
-    when true, false, Symbol
-      # pass
-    else
-      # Add the package version
-      str += "=#{should}"
-    end
-    cmd = %w{-q -y}
-
-    cmd << 'install' << str
-
-    aptget(*cmd)
-  end
-
-  # What's the latest package version available?
-  def latest
-    output = aptcache :showpkg,  @resource[:name]
-
-    if output =~ /Versions:\s*\n((\n|.)+)^$/
-      versions = $1
-      available_versions = versions.split(/\n/).collect { |version|
-        if version =~ /^([^\(]+)\(/
-          $1
-        else
-          self.warning _("Could not match version '%{version}'") % { version: version }
-          nil
-        end
-      }.reject { |vers| vers.nil? }.sort { |a,b|
-        versioncmp(a,b)
-      }
-
-      if available_versions.length == 0
-        self.debug "No latest version"
-        print output if Puppet[:debug]
-      end
-
-      # Get the latest and greatest version number
-      return available_versions.pop
-    else
-      self.err _("Could not match string")
-    end
-  end
-
-  def update
-    self.install
-  end
-
-  def uninstall
-    aptget "-y", "-q", 'remove', @resource[:name]
-  end
-
-  def purge
-    aptget '-y', '-q', 'remove', '--purge', @resource[:name]
-  end
-end

data/vendored/puppet/lib/puppet/provider/package/blastwave.rb

@@ -1,111 +0,0 @@
-# Packaging using Blastwave's pkg-get program.
-Puppet::Type.type(:package).provide :blastwave, :parent => :sun, :source => :sun do
-  desc "Package management using Blastwave.org's `pkg-get` command on Solaris."
-  pkgget = "pkg-get"
-  pkgget = "/opt/csw/bin/pkg-get" if FileTest.executable?("/opt/csw/bin/pkg-get")
-
-  confine :osfamily => :solaris
-
-  commands :pkgget => pkgget
-
-  def pkgget_with_cat(*args)
-    Puppet::Util.withenv(:PAGER => "/usr/bin/cat") { pkgget(*args) }
-  end
-
-  def self.extended(mod)
-    unless command(:pkgget) != "pkg-get"
-      raise Puppet::Error,
-        _("The pkg-get command is missing; blastwave packaging unavailable")
-    end
-
-    unless Puppet::FileSystem.exist?("/var/pkg-get/admin")
-      Puppet.notice _("It is highly recommended you create '/var/pkg-get/admin'.")
-      Puppet.notice _("See /var/pkg-get/admin-fullauto")
-    end
-  end
-
-  def self.instances(hash = {})
-    blastlist(hash).collect do |bhash|
-      bhash.delete(:avail)
-      new(bhash)
-    end
-  end
-
-  # Turn our blastwave listing into a bunch of hashes.
-  def self.blastlist(hash)
-    command = ["-c"]
-
-    command << hash[:justme] if hash[:justme]
-
-    output = Puppet::Util.withenv(:PAGER => "/usr/bin/cat") { pkgget command }
-
-    list = output.split("\n").collect do |line|
-      next if line =~ /^#/
-      next if line =~ /^WARNING/
-      next if line =~ /localrev\s+remoterev/
-
-      blastsplit(line)
-    end.reject { |h| h.nil? }
-
-    if hash[:justme]
-      return list[0]
-    else
-      list.reject! { |h|
-        h[:ensure] == :absent
-      }
-      return list
-    end
-
-  end
-
-  # Split the different lines into hashes.
-  def self.blastsplit(line)
-    if line =~ /\s*(\S+)\s+((\[Not installed\])|(\S+))\s+(\S+)/
-      hash = {}
-      hash[:name] = $1
-      hash[:ensure] = if $2 == "[Not installed]"
-        :absent
-      else
-        $2
-      end
-      hash[:avail] = $5
-
-      hash[:avail] = hash[:ensure] if hash[:avail] == "SAME"
-
-      # Use the name method, so it works with subclasses.
-      hash[:provider] = self.name
-
-      return hash
-    else
-      Puppet.warning _("Cannot match %{line}") % { line: line }
-      return nil
-    end
-  end
-
-  def install
-    pkgget_with_cat "-f", :install, @resource[:name]
-  end
-
-  # Retrieve the version from the current package file.
-  def latest
-    hash = self.class.blastlist(:justme => @resource[:name])
-    hash[:avail]
-  end
-
-  def query
-    if hash = self.class.blastlist(:justme => @resource[:name])
-      hash
-    else
-      {:ensure => :absent}
-    end
-  end
-
-  # Remove the old package, and install the new one
-  def update
-    pkgget_with_cat "-f", :upgrade, @resource[:name]
-  end
-
-  def uninstall
-    pkgget_with_cat "-f", :remove, @resource[:name]
-  end
-end

data/vendored/puppet/lib/puppet/provider/package/dnf.rb

@@ -1,46 +0,0 @@
-Puppet::Type.type(:package).provide :dnf, :parent => :yum do
-  desc "Support via `dnf`.
-
-  Using this provider's `uninstallable` feature will not remove dependent packages. To
-  remove dependent packages with this provider use the `purgeable` feature, but note this
-  feature is destructive and should be used with the utmost care.
-
-  This provider supports the `install_options` attribute, which allows command-line flags to be passed to dnf.
-  These options should be specified as a string (e.g. '--flag'), a hash (e.g. {'--flag' => 'value'}),
-  or an array where each element is either a string or a hash."
-
-  has_feature :install_options, :versionable, :virtual_packages
-
-  commands :cmd => "dnf", :rpm => "rpm"
-
-  # Note: this confine was borrowed from the Yum provider. The
-  # original purpose (from way back in 2007) was to make sure we
-  # never try to use RPM on a machine without it. We think this
-  # has probably become obsolete with the way `commands` work, so
-  # we should investigate removing it at some point.
-  if command('rpm')
-    confine :true => begin
-      rpm('--version')
-      rescue Puppet::ExecutionFailure
-        false
-      else
-        true
-      end
-  end
-
-  defaultfor :operatingsystem => :fedora, :operatingsystemmajrelease => (22..30).to_a
-
-  def self.update_command
-    # In DNF, update is deprecated for upgrade
-    'upgrade'
-  end
-
-  # The value to pass to DNF as its error output level.
-  # DNF differs from Yum slightly with regards to error outputting.
-  #
-  # @param None
-  # @return [String]
-  def self.error_level
-    '1'
-  end
-end

data/vendored/puppet/lib/puppet/provider/package/dpkg.rb

@@ -1,165 +0,0 @@
-require 'puppet/provider/package'
-
-Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package do
-  desc "Package management via `dpkg`.  Because this only uses `dpkg`
-    and not `apt`, you must specify the source of any packages you want
-    to manage."
-
-  has_feature :holdable
-
-  commands :dpkg => "/usr/bin/dpkg"
-  commands :dpkg_deb => "/usr/bin/dpkg-deb"
-  commands :dpkgquery => "/usr/bin/dpkg-query"
-
-  # Performs a dpkgquery call with a pipe so that output can be processed
-  # inline in a passed block.
-  # @param args [Array<String>] any command line arguments to be appended to the command
-  # @param block expected to be passed on to execpipe
-  # @return whatever the block returns
-  # @see Puppet::Util::Execution.execpipe
-  # @api private
-  def self.dpkgquery_piped(*args, &block)
-    cmd = args.unshift(command(:dpkgquery))
-    Puppet::Util::Execution.execpipe(cmd, &block)
-  end
-
-  def self.instances
-    packages = []
-
-    # list out all of the packages
-    dpkgquery_piped('-W', '--showformat', self::DPKG_QUERY_FORMAT_STRING) do |pipe|
-      # now turn each returned line into a package object
-      pipe.each_line do |line|
-        if hash = parse_line(line)
-          packages << new(hash)
-        end
-      end
-    end
-
-    packages
-  end
-
-  private
-
-  # Note: self:: is required here to keep these constants in the context of what will
-  # eventually become this Puppet::Type::Package::ProviderDpkg class.
-  self::DPKG_QUERY_FORMAT_STRING = %Q{'${Status} ${Package} ${Version}\\n'}
-  self::FIELDS_REGEX = %r{^(\S+) +(\S+) +(\S+) (\S+) (\S*)$}
-  self::FIELDS= [:desired, :error, :status, :name, :ensure]
-
-  # @param line [String] one line of dpkg-query output
-  # @return [Hash,nil] a hash of FIELDS or nil if we failed to match
-  # @api private
-  def self.parse_line(line)
-    hash = nil
-
-    if match = self::FIELDS_REGEX.match(line)
-      hash = {}
-
-      self::FIELDS.zip(match.captures) do |field,value|
-        hash[field] = value
-      end
-
-      hash[:provider] = self.name
-
-      if hash[:status] == 'not-installed'
-        hash[:ensure] = :purged
-      elsif ['config-files', 'half-installed', 'unpacked', 'half-configured'].include?(hash[:status])
-        hash[:ensure] = :absent
-      end
-      hash[:ensure] = :held if hash[:desired] == 'hold'
-    else
-      Puppet.debug("Failed to match dpkg-query line #{line.inspect}")
-    end
-
-    return hash
-  end
-
-  public
-
-  def install
-    unless file = @resource[:source]
-      raise ArgumentError, _("You cannot install dpkg packages without a source")
-    end
-
-    args = []
-
-    # We always unhold when installing to remove any prior hold.
-    self.unhold
-
-    if @resource[:configfiles] == :keep
-      args << '--force-confold'
-    else
-      args << '--force-confnew'
-    end
-    args << '-i' << file
-
-    dpkg(*args)
-  end
-
-  def update
-    self.install
-  end
-
-  # Return the version from the package.
-  def latest
-    output = dpkg_deb "--show", @resource[:source]
-    matches = /^(\S+)\t(\S+)$/.match(output).captures
-    warning _("source doesn't contain named package, but %{name}") % { name: matches[0] } unless matches[0].match( Regexp.escape(@resource[:name]) )
-    matches[1]
-  end
-
-  def query
-    hash = nil
-
-    # list out our specific package
-    begin
-      output = dpkgquery(
-        "-W",
-        "--showformat",
-        self.class::DPKG_QUERY_FORMAT_STRING,
-        @resource[:name]
-      )
-      hash = self.class.parse_line(output)
-    rescue Puppet::ExecutionFailure
-      # dpkg-query exits 1 if the package is not found.
-      return {:ensure => :purged, :status => 'missing', :name => @resource[:name], :error => 'ok'}
-    end
-
-    hash ||= {:ensure => :absent, :status => 'missing', :name => @resource[:name], :error => 'ok'}
-
-    if hash[:error] != "ok"
-      raise Puppet::Error.new(
-        "Package #{hash[:name]}, version #{hash[:ensure]} is in error state: #{hash[:error]}"
-      )
-    end
-
-    hash
-  end
-
-  def uninstall
-    dpkg "-r", @resource[:name]
-  end
-
-  def purge
-    dpkg "--purge", @resource[:name]
-  end
-
-  def hold
-    self.install
-    Tempfile.open('puppet_dpkg_set_selection') do |tmpfile|
-      tmpfile.write("#{@resource[:name]} hold\n")
-      tmpfile.flush
-      execute([:dpkg, "--set-selections"], :failonfail => false, :combine => false, :stdinfile => tmpfile.path.to_s)
-    end
-  end
-
-  def unhold
-    Tempfile.open('puppet_dpkg_set_selection') do |tmpfile|
-      tmpfile.write("#{@resource[:name]} install\n")
-      tmpfile.flush
-      execute([:dpkg, "--set-selections"], :failonfail => false, :combine => false, :stdinfile => tmpfile.path.to_s)
-    end
-  end
-
-end