puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/provider/package/opkg.rb

@@ -0,0 +1,76 @@
+require 'puppet/provider/package'
+
+Puppet::Type.type(:package).provide :opkg, :source => :opkg, :parent => Puppet::Provider::Package do
+  desc "Opkg packaging support. Common on OpenWrt and OpenEmbedded platforms"
+
+  commands :opkg => "opkg"
+
+  confine     :operatingsystem => :openwrt
+  defaultfor  :operatingsystem => :openwrt
+
+  def self.instances
+    packages = []
+    execpipe("#{command(:opkg)} list-installed") do |process|
+      regex = %r{^(\S+) - (\S+)}
+      fields = [:name, :ensure]
+      hash = {}
+
+      process.each_line { |line|
+        if match = regex.match(line)
+          fields.zip(match.captures) { |field,value| hash[field] = value }
+          hash[:provider] = self.name
+          packages << new(hash)
+          hash = {}
+        else
+          warning("Failed to match line %s" % line)
+        end
+      }
+    end
+    packages
+  rescue Puppet::ExecutionFailure
+    return nil
+  end
+
+  def latest
+    output = opkg( "list", @resource[:name])
+    matches = /^(\S+) - (\S+)/.match(output).captures
+    matches[1]
+  end
+
+  def install
+    # OpenWrt package lists are ephemeral, make sure we have at least
+    # some entries in the list directory for opkg to use
+    opkg('update') if Dir.entries('/var/opkg-lists/').size <= 2
+
+    if @resource[:source]
+      opkg( '--force-overwrite', 'install', @resource[:source] )
+    else
+      opkg( '--force-overwrite', 'install', @resource[:name] )
+    end
+  end
+
+  def uninstall
+    opkg( 'remove', @resource[:name] )
+  end
+
+  def update
+    self.install
+  end
+
+  def query
+    # list out our specific package
+    output = opkg( 'list-installed', @resource[:name] )
+    if output =~ /^(\S+) - (\S+)/
+      return { :ensure => $2 }
+    end
+    nil
+  rescue Puppet::ExecutionFailure
+    return {
+      :ensure => :purged,
+      :status => 'missing',
+      :name => @resource[:name],
+      :error => 'ok',
+    }
+  end
+
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/provider/package/pacman.rb

@@ -0,0 +1,234 @@
+require 'puppet/provider/package'
+require 'set'
+require 'uri'
+
+Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Package do
+  desc "Support for the Package Manager Utility (pacman) used in Archlinux.
+
+  This provider supports the `install_options` attribute, which allows command-line flags to be passed to pacman.
+  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."
+
+  commands :pacman => "/usr/bin/pacman"
+  # Yaourt is a common AUR helper which, if installed, we can use to query the AUR
+  commands :yaourt => "/usr/bin/yaourt" if Puppet::FileSystem.exist? '/usr/bin/yaourt'
+
+  confine     :operatingsystem => :archlinux
+  defaultfor  :operatingsystem => :archlinux
+  has_feature :install_options
+  has_feature :uninstall_options
+  has_feature :upgradeable
+
+  # If yaourt is installed, we can make use of it
+  def yaourt?
+    return Puppet::FileSystem.exist?('/usr/bin/yaourt')
+  end
+
+  # Install a package using 'pacman', or 'yaourt' if available.
+  # Installs quietly, without confirmation or progressbar, updates package
+  # list from servers defined in pacman.conf.
+  def install
+    if @resource[:source]
+      install_from_file
+    else
+      install_from_repo
+    end
+
+    unless self.query
+      raise Puppet::ExecutionFailure.new("Could not find package %s" % self.name)
+    end
+  end
+
+  def install_from_repo
+    if yaourt?
+      cmd = %w{--noconfirm}
+      cmd += install_options if @resource[:install_options]
+      cmd << "-S" << @resource[:name]
+      yaourt *cmd
+    else
+      cmd = %w{--noconfirm --noprogressbar}
+      cmd += install_options if @resource[:install_options]
+      cmd << "-Sy" << @resource[:name]
+      pacman *cmd
+    end
+  end
+  private :install_from_repo
+
+  def install_from_file
+    source = @resource[:source]
+    begin
+      source_uri = URI.parse source
+    rescue => detail
+      self.fail Puppet::Error, "Invalid source '#{source}': #{detail}", detail
+    end
+
+    source = case source_uri.scheme
+    when nil then source
+    when /https?/i then source
+    when /ftp/i then source
+    when /file/i then source_uri.path
+    when /puppet/i
+      fail "puppet:// URL is not supported by pacman"
+    else
+      fail "Source #{source} is not supported by pacman"
+    end
+    pacman "--noconfirm", "--noprogressbar", "-Sy"
+    pacman "--noconfirm", "--noprogressbar", "-U", source
+  end
+  private :install_from_file
+
+  def self.listcmd
+    [command(:pacman), "-Q"]
+  end
+
+  # Pacman has a concept of package groups as well.
+  # Package groups have no versions.
+  def self.listgroupcmd
+    [command(:pacman), "-Qg"]
+  end
+
+  # Get installed packages (pacman -Q)
+  def self.installedpkgs
+    packages = []
+    begin
+      execpipe(listcmd()) do |process|
+        # pacman -Q output is 'packagename version-rel'
+        regex = %r{^(\S+)\s(\S+)}
+        fields = [:name, :ensure]
+        hash = {}
+
+        process.each_line { |line|
+          if match = regex.match(line)
+            fields.zip(match.captures) { |field,value|
+              hash[field] = value
+            }
+
+            hash[:provider] = self.name
+
+            packages << new(hash)
+
+            hash = {}
+          else
+            warning("Failed to match line %s" % line)
+          end
+        }
+      end
+    rescue Puppet::ExecutionFailure
+      return nil
+    end
+    packages
+  end
+
+  # Get installed groups (pacman -Qg)
+  def self.installedgroups
+    packages = []
+    begin
+      execpipe(listgroupcmd()) do |process|
+        # pacman -Qg output is 'groupname packagename'
+        # Groups need to be deduplicated
+        groups = Set[]
+
+        process.each_line { |line|
+          groups.add(line.split[0])
+        }
+
+        groups.each { |line|
+          hash = {
+            :name   => line,
+            :ensure => "1", # Groups don't have versions, so ensure => latest
+                            # will still cause a reinstall.
+            :provider => self.name
+          }
+          packages << new(hash)
+        }
+      end
+    rescue Puppet::ExecutionFailure
+      return nil
+    end
+    packages
+  end
+
+  # Fetch the list of packages currently installed on the system.
+  def self.instances
+    packages = self.installedpkgs
+    groups   = self.installedgroups
+    result   = nil
+
+    if (!packages && !groups)
+      nil
+    elsif (packages && groups)
+      packages.concat(groups)
+    else
+      packages
+    end
+  end
+
+
+  # Because Archlinux is a rolling release based distro, installing a package
+  # should always result in the newest release.
+  def update
+    # Install in pacman can be used for update, too
+    self.install
+  end
+
+  # We rescue the main check from Pacman with a check on the AUR using yaourt, if installed
+  def latest
+    pacman "-Sy"
+    pacman_check = true   # Query the main repos first
+    begin
+      if pacman_check
+        output = pacman "-Sp", "--print-format", "%v", @resource[:name]
+        return output.chomp
+      else
+        output = yaourt "-Qma", @resource[:name]
+        output.split("\n").each do |line|
+          return line.split[1].chomp if line =~ /^aur/
+        end
+      end
+    rescue Puppet::ExecutionFailure
+      if pacman_check and self.yaourt?
+        pacman_check = false # now try the AUR
+        retry
+      else
+        raise
+      end
+    end
+  end
+
+  # Querys the pacman master list for information about the package.
+  def query
+    begin
+      output = pacman("-Qi", @resource[:name])
+
+      if output =~ /Version.*:\s(.+)/
+        return { :ensure => $1 }
+      end
+    rescue Puppet::ExecutionFailure
+      return {
+        :ensure => :purged,
+        :status => 'missing',
+        :name => @resource[:name],
+        :error => 'ok',
+      }
+    end
+    nil
+  end
+
+  # Removes a package from the system.
+  def uninstall
+    cmd = %w{--noconfirm --noprogressbar}
+    cmd += uninstall_options if @resource[:uninstall_options]
+    cmd << "-R" << @resource[:name]
+    pacman *cmd
+  end
+
+  private
+
+  def install_options
+    join_options(@resource[:install_options])
+  end
+
+  def uninstall_options
+    join_options(@resource[:uninstall_options])
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/provider/package/pip.rb

@@ -0,0 +1,119 @@
+# Puppet package provider for Python's `pip` package management frontend.
+# <http://pip.openplans.org/>
+
+require 'puppet/provider/package'
+require 'xmlrpc/client'
+
+Puppet::Type.type(:package).provide :pip,
+  :parent => ::Puppet::Provider::Package do
+
+  desc "Python packages via `pip`."
+
+  has_feature :installable, :uninstallable, :upgradeable, :versionable
+
+  # Parse lines of output from `pip freeze`, which are structured as
+  # _package_==_version_.
+  def self.parse(line)
+    if line.chomp =~ /^([^=]+)==([^=]+)$/
+      {:ensure => $2, :name => $1, :provider => name}
+    else
+      nil
+    end
+  end
+
+  # Return an array of structured information about every installed package
+  # that's managed by `pip` or an empty array if `pip` is not available.
+  def self.instances
+    packages = []
+    pip_cmd = which(cmd) or return []
+    execpipe "#{pip_cmd} freeze" do |process|
+      process.collect do |line|
+        next unless options = parse(line)
+        packages << new(options)
+      end
+    end
+    packages
+  end
+
+  def self.cmd
+    case Facter.value(:osfamily)
+      when "RedHat"
+        "pip-python"
+      else
+        "pip"
+    end
+  end
+
+  # Return structured information about a particular package or `nil` if
+  # it is not installed or `pip` itself is not available.
+  def query
+    self.class.instances.each do |provider_pip|
+      return provider_pip.properties if @resource[:name].downcase == provider_pip.name.downcase
+    end
+    return nil
+  end
+
+  # Ask the PyPI API for the latest version number.  There is no local
+  # cache of PyPI's package list so this operation will always have to
+  # ask the web service.
+  def latest
+    client = XMLRPC::Client.new2("http://pypi.python.org/pypi")
+    client.http_header_extra = {"Content-Type" => "text/xml"}
+    client.timeout = 10
+    result = client.call("package_releases", @resource[:name])
+    result.first
+  rescue Timeout::Error => detail
+    raise Puppet::Error, "Timeout while contacting pypi.python.org: #{detail}", detail.backtrace
+  end
+
+  # Install a package.  The ensure parameter may specify installed,
+  # latest, a version number, or, in conjunction with the source
+  # parameter, an SCM revision.  In that case, the source parameter
+  # gives the fully-qualified URL to the repository.
+  def install
+    args = %w{install -q}
+    if @resource[:source]
+      if String === @resource[:ensure]
+        args << "#{@resource[:source]}@#{@resource[:ensure]}#egg=#{
+          @resource[:name]}"
+      else
+        args << "#{@resource[:source]}#egg=#{@resource[:name]}"
+      end
+    else
+      case @resource[:ensure]
+      when String
+        args << "#{@resource[:name]}==#{@resource[:ensure]}"
+      when :latest
+        args << "--upgrade" << @resource[:name]
+      else
+        args << @resource[:name]
+      end
+    end
+    lazy_pip *args
+  end
+
+  # Uninstall a package.  Uninstall won't work reliably on Debian/Ubuntu
+  # unless this issue gets fixed.
+  # <http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=562544>
+  def uninstall
+    lazy_pip "uninstall", "-y", "-q", @resource[:name]
+  end
+
+  def update
+    install
+  end
+
+  # Execute a `pip` command.  If Puppet doesn't yet know how to do so,
+  # try to teach it and if even that fails, raise the error.
+  private
+  def lazy_pip(*args)
+    pip *args
+  rescue NoMethodError => e
+    if pathname = which(self.class.cmd)
+      self.class.commands :pip => pathname
+      pip *args
+    else
+      raise e, 'Could not locate the pip command.', e.backtrace
+    end
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/provider/package/pkg.rb

@@ -0,0 +1,201 @@
+require 'puppet/provider/package'
+
+Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package do
+  desc "OpenSolaris image packaging system. See pkg(5) for more information"
+  # http://docs.oracle.com/cd/E19963-01/html/820-6572/managepkgs.html
+  # A few notes before we start :
+  # Opensolaris pkg has two slightly different formats (as of now.)
+  # The first one is what is distributed with the Solaris 11 Express 11/10 dvd
+  # The latest one is what you get when you update package.
+  # To make things more interesting, pkg version just returns a sha sum.
+  # dvd:     pkg version => 052adf36c3f4
+  # updated: pkg version => 630e1ffc7a19
+  # Thankfully, solaris has not changed the commands to be used.
+  # TODO: We still have to allow packages to specify a preferred publisher.
+
+  has_feature :versionable
+
+  has_feature :upgradable
+
+  has_feature :holdable
+
+  commands :pkg => "/usr/bin/pkg"
+
+  confine :osfamily => :solaris
+
+  defaultfor :osfamily => :solaris, :kernelrelease => '5.11'
+
+  def self.instances
+    pkg(:list, '-H').split("\n").map{|l| new(parse_line(l))}
+  end
+
+  # The IFO flag field is just what it names, the first field can have ether
+  # i_nstalled or -, and second field f_rozen or -, and last
+  # o_bsolate or r_rename or -
+  # so this checks if the installed field is present, and also verifies that
+  # if not the field is -, else we dont know what we are doing and exit with
+  # out doing more damage.
+  def self.ifo_flag(flags)
+    (
+      case flags[0..0]
+      when 'i'
+        {:status => 'installed'}
+      when '-'
+        {:status => 'known'}
+      else
+        raise ArgumentError, 'Unknown format %s: %s[%s]' % [self.name, flags, flags[0..0]]
+      end
+    ).merge(
+      case flags[1..1]
+      when 'f'
+        {:ensure => 'held'}
+      when '-'
+        {}
+      else
+        raise ArgumentError, 'Unknown format %s: %s[%s]' % [self.name, flags, flags[1..1]]
+      end
+    )
+  end
+
+  # The UFOXI field is the field present in the older pkg
+  # (solaris 2009.06 - snv151a)
+  # similar to IFO, UFOXI is also an either letter or -
+  # u_pdate indicates that an update for the package is available.
+  # f_rozen(n/i) o_bsolete x_cluded(n/i) i_constrained(n/i)
+  # note that u_pdate flag may not be trustable due to constraints.
+  # so we dont rely on it
+  # Frozen was never implemented in UFOXI so skipping frozen here.
+  def self.ufoxi_flag(flags)
+    {}
+  end
+
+  # pkg state was present in the older version of pkg (with UFOXI) but is
+  # no longer available with the IFO field version. When it was present,
+  # it was used to indicate that a particular version was present (installed)
+  # and later versions were known. Note that according to the pkg man page,
+  # known never lists older versions of the package. So we can rely on this
+  # field to make sure that if a known is present, then the pkg is upgradable.
+  def self.pkg_state(state)
+    case state
+    when /installed/
+      {:status => 'installed'}
+    when /known/
+      {:status => 'known'}
+    else
+      raise ArgumentError, 'Unknown format %s: %s' % [self.name, state]
+    end
+  end
+
+  # Here is (hopefully) the only place we will have to deal with multiple
+  # formats of output for different pkg versions.
+  def self.parse_line(line)
+    (case line.chomp
+    # NAME (PUBLISHER)            VERSION           IFO  (new:630e1ffc7a19)
+    # system/core-os              0.5.11-0.169      i--
+    when /^(\S+) +(\S+) +(...)$/
+      {:name => $1, :ensure => $2}.merge ifo_flag($3)
+
+    # x11/wm/fvwm (fvwm.org)      2.6.1-3           i--
+    when /^(\S+) \((.+)\) +(\S+) +(...)$/
+      {:name => $1, :publisher => $2, :ensure => $3}.merge ifo_flag($4)
+
+    # NAME (PUBLISHER)                  VERSION          STATE      UFOXI (dvd:052adf36c3f4)
+    # SUNWcs                            0.5.11-0.126     installed  -----
+    when /^(\S+) +(\S+) +(\S+) +(.....)$/
+      {:name => $1, :ensure => $2}.merge pkg_state($3).merge(ufoxi_flag($4))
+
+    # web/firefox/plugin/flash (extra)  10.0.32.18-0.111 installed  -----
+    when /^(\S+) \((.+)\) +(\S+) +(\S+) +(.....)$/
+      {:name => $1, :publisher => $2, :ensure => $3}.merge pkg_state($4).merge(ufoxi_flag($5))
+
+    else
+      raise ArgumentError, 'Unknown line format %s: %s' % [self.name, line]
+    end).merge({:provider => self.name})
+  end
+
+  def hold
+    pkg(:freeze, @resource[:name])
+  end
+
+  def unhold
+    r = exec_cmd(command(:pkg), 'unfreeze', @resource[:name])
+    raise Puppet::Error, "Unable to unfreeze #{r[:out]}" unless [0,4].include? r[:exit]
+  end
+
+  # Return the version of the package. Note that the bug
+  # http://defect.opensolaris.org/bz/show_bug.cgi?id=19159%
+  # notes that we can't use -Ha for the same even though the manual page reads that way.
+  def latest
+    lines = pkg(:list, "-Hn", @resource[:name]).split("\n")
+
+    # remove certificate expiration warnings from the output, but report them
+    # Note: we'd like to use select! here to modify the lines array and avoid
+    #       the second select further down. But Solaris 11 comes with ruby 1.8.7
+    #       which doesn't support select!, so do this as two selects.
+    cert_warnings = lines.select { |line| line =~ /^Certificate/ }
+    if cert_warnings
+      Puppet.warning("pkg warning: #{cert_warnings}")
+    end
+
+    lst = lines.select { |line| line !~ /^Certificate/ }.map { |line| self.class.parse_line(line) }
+
+    # Now we know there is a newer version. But is that installable? (i.e are there any constraints?)
+    # return the first known we find. The only way that is currently available is to do a dry run of
+    # pkg update and see if could get installed (`pkg update -n res`).
+    known = lst.find {|p| p[:status] == 'known' }
+    return known[:ensure] if known and exec_cmd(command(:pkg), 'update', '-n', @resource[:name])[:exit].zero?
+
+    # If not, then return the installed, else nil
+    (lst.find {|p| p[:status] == 'installed' } || {})[:ensure]
+  end
+
+  # install the package and accept all licenses.
+  def install(nofail = false)
+    name = @resource[:name]
+    should = @resource[:ensure]
+    # always unhold if explicitly told to install/update
+    self.unhold
+    unless should.is_a? Symbol
+      name += "@#{should}"
+      is = self.query
+      unless is[:ensure].to_sym == :absent
+        self.uninstall if Puppet::Util::Package.versioncmp(should, is[:ensure]) < 0
+      end
+    end
+    r = exec_cmd(command(:pkg), 'install', '--accept', name)
+    return r if nofail
+    raise Puppet::Error, "Unable to update #{r[:out]}" if r[:exit] != 0
+  end
+
+  # uninstall the package. The complication comes from the -r_ecursive flag which is no longer
+  # present in newer package version.
+  def uninstall
+    cmd = [:uninstall]
+    case (pkg :version).chomp
+    when /052adf36c3f4/
+      cmd << '-r'
+    end
+    cmd << @resource[:name]
+    pkg cmd
+  end
+
+  # update the package to the latest version available
+  def update
+    r = install(true)
+    # 4 == /No updates available for this image./
+    return if [0,4].include? r[:exit]
+    raise Puppet::Error, "Unable to update #{r[:out]}"
+  end
+
+  # list a specific package
+  def query
+    r = exec_cmd(command(:pkg), 'list', '-H', @resource[:name])
+    return {:ensure => :absent, :name => @resource[:name]} if r[:exit] != 0
+    self.class.parse_line(r[:out])
+  end
+
+  def exec_cmd(*cmd)
+    output = Puppet::Util::Execution.execute(cmd, :failonfail => false, :combine => true)
+    {:out => output, :exit => $CHILD_STATUS.exitstatus}
+  end
+end