puppet-retrospec 0.7.0 → 0.7.2

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

@@ -0,0 +1,79 @@
+Puppet::Type.type(:package).provide :fink, :parent => :dpkg, :source => :dpkg do
+  # Provide sorting functionality
+  include Puppet::Util::Package
+
+  desc "Package management via `fink`."
+
+  commands :fink => "/sw/bin/fink"
+  commands :aptget => "/sw/bin/apt-get"
+  commands :aptcache => "/sw/bin/apt-cache"
+  commands :dpkgquery => "/sw/bin/dpkg-query"
+
+  has_feature :versionable
+
+  # 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 finkcmd(*args)
+    fink(*args)
+  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.should(:ensure)
+
+    str = @resource[:name]
+    case should
+    when true, false, Symbol
+      # pass
+    else
+      # Add the package version
+      str += "=#{should}"
+    end
+    cmd = %w{-b -q -y}
+
+    cmd << :install << str
+
+    finkcmd(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")
+
+      preseed response
+    else
+      self.info "No responsefile specified or non existant, not preseeding anything"
+    end
+  end
+
+  def update
+    self.install
+  end
+
+  def uninstall
+    finkcmd "-y", "-q", :remove, @model[:name]
+  end
+
+  def purge
+    aptget '-y', '-q', 'remove', '--purge', @resource[:name]
+  end
+end

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

@@ -0,0 +1,47 @@
+Puppet::Type.type(:package).provide :freebsd, :parent => :openbsd do
+  desc "The specific form of package management on FreeBSD.  This is an
+    extremely quirky packaging system, in that it freely mixes between
+    ports and packages.  Apparently all of the tools are written in Ruby,
+    so there are plans to rewrite this support to directly use those
+    libraries."
+
+  commands :pkginfo => "/usr/sbin/pkg_info",
+    :pkgadd => "/usr/sbin/pkg_add",
+    :pkgdelete => "/usr/sbin/pkg_delete"
+
+  confine :operatingsystem => :freebsd
+
+  def self.listcmd
+    command(:pkginfo)
+  end
+
+  def install
+    if @resource[:source] =~ /\/$/
+      if @resource[:source] =~ /^(ftp|https?):/
+        Puppet::Util.withenv :PACKAGESITE => @resource[:source] do
+          pkgadd "-r", @resource[:name]
+        end
+      else
+        Puppet::Util.withenv :PKG_PATH => @resource[:source] do
+          pkgadd @resource[:name]
+        end
+      end
+    else
+      Puppet.warning "source is defined but does not have trailing slash, ignoring #{@resource[:source]}" if @resource[:source]
+      pkgadd "-r", @resource[:name]
+    end
+  end
+
+  def query
+    self.class.instances.each do |provider|
+      if provider.name == @resource.name
+        return provider.properties
+      end
+    end
+    nil
+  end
+
+  def uninstall
+    pkgdelete "#{@resource[:name]}-#{@resource.should(:ensure)}"
+  end
+end

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

@@ -0,0 +1,135 @@
+require 'puppet/provider/package'
+require 'uri'
+
+# Ruby gems support.
+Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package do
+  desc "Ruby Gem support.  If a URL is passed via `source`, then that URL is used as the
+    remote gem repository; if a source is present but is not a valid URL, it will be
+    interpreted as the path to a local gem file.  If source is not present at all,
+    the gem will be installed from the default gem repositories.
+
+    This provider supports the `install_options` attribute, which allows command-line flags to be passed to the gem command.
+    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 :gemcmd => "gem"
+
+  def self.gemlist(options)
+    gem_list_command = [command(:gemcmd), "list"]
+
+    if options[:local]
+      gem_list_command << "--local"
+    else
+      gem_list_command << "--remote"
+    end
+    if options[:source]
+      gem_list_command << "--source" << options[:source]
+    end
+    if name = options[:justme]
+      gem_list_command << "^" + name + "$"
+    end
+
+    begin
+      list = execute(gem_list_command).lines.
+        map {|set| gemsplit(set) }.
+        reject {|x| x.nil? }
+    rescue Puppet::ExecutionFailure => detail
+      raise Puppet::Error, "Could not list gems: #{detail}", detail.backtrace
+    end
+
+    if options[:justme]
+      return list.shift
+    else
+      return list
+    end
+  end
+
+  def self.gemsplit(desc)
+    # `gem list` when output console has a line like:
+    # *** LOCAL GEMS ***
+    # but when it's not to the console that line
+    # and all blank lines are stripped
+    # so we don't need to check for them
+
+    if desc =~ /^(\S+)\s+\((.+)\)/
+      name = $1
+      versions = $2.split(/,\s*/)
+      {
+        :name     => name,
+        :ensure   => versions.map{|v| v.split[0]},
+        :provider => :gem
+      }
+    else
+      Puppet.warning "Could not match #{desc}" unless desc.chomp.empty?
+      nil
+    end
+  end
+
+  def self.instances(justme = false)
+    gemlist(:local => true).collect do |hash|
+      new(hash)
+    end
+  end
+
+  def install(useversion = true)
+    command = [command(:gemcmd), "install"]
+    command << "-v" << resource[:ensure] if (! resource[:ensure].is_a? Symbol) and useversion
+
+    if source = resource[:source]
+      begin
+        uri = URI.parse(source)
+      rescue => detail
+        self.fail Puppet::Error, "Invalid source '#{uri}': #{detail}", detail
+      end
+
+      case uri.scheme
+      when nil
+        # no URI scheme => interpret the source as a local file
+        command << source
+      when /file/i
+        command << uri.path
+      when 'puppet'
+        # we don't support puppet:// URLs (yet)
+        raise Puppet::Error.new("puppet:// URLs are not supported as gem sources")
+      else
+        # interpret it as a gem repository
+        command << "--source" << "#{source}" << resource[:name]
+      end
+    else
+      command << "--no-rdoc" << "--no-ri" << resource[:name]
+    end
+
+    command += install_options if resource[:install_options]
+
+    output = execute(command)
+    # Apparently some stupid gem versions don't exit non-0 on failure
+    self.fail "Could not install: #{output.chomp}" if output.include?("ERROR")
+  end
+
+  def latest
+    # This always gets the latest version available.
+    gemlist_options = {:justme => resource[:name]}
+    gemlist_options.merge!({:source => resource[:source]}) unless resource[:source].nil?
+    hash = self.class.gemlist(gemlist_options)
+
+    hash[:ensure][0]
+  end
+
+  def query
+    self.class.gemlist(:justme => resource[:name], :local => true)
+  end
+
+  def uninstall
+    gemcmd "uninstall", "-x", "-a", resource[:name]
+  end
+
+  def update
+    self.install(false)
+  end
+
+  def install_options
+    join_options(resource[:install_options])
+  end
+end

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

@@ -0,0 +1,44 @@
+# HP-UX packaging.
+
+require 'puppet/provider/package'
+
+Puppet::Type.type(:package).provide :hpux, :parent => Puppet::Provider::Package do
+
+  desc "HP-UX's packaging system."
+
+  commands :swinstall => "/usr/sbin/swinstall",
+    :swlist => "/usr/sbin/swlist",
+    :swremove => "/usr/sbin/swremove"
+
+  confine :operatingsystem => "hp-ux"
+
+  defaultfor :operatingsystem => "hp-ux"
+
+  def self.instances
+    # TODO:  This is very hard on HP-UX!
+    []
+  end
+
+  # source and name are required
+  def install
+    raise ArgumentError, "source must be provided to install HP-UX packages" unless resource[:source]
+    args = standard_args + ["-s", resource[:source], resource[:name]]
+    swinstall(*args)
+  end
+
+  def query
+    swlist resource[:name]
+    {:ensure => :present}
+  rescue
+    {:ensure => :absent}
+  end
+
+  def uninstall
+    args = standard_args + [resource[:name]]
+    swremove(*args)
+  end
+
+  def standard_args
+    ["-x", "mount_all_filesystems=false"]
+  end
+end

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

@@ -0,0 +1,107 @@
+require 'puppet/provider/package'
+require 'puppet/provider/command'
+
+Puppet::Type.type(:package).provide :macports, :parent => Puppet::Provider::Package do
+  desc "Package management using MacPorts on OS X.
+
+    Supports MacPorts versions and revisions, but not variants.
+    Variant preferences may be specified using
+    [the MacPorts variants.conf file](http://guide.macports.org/chunked/internals.configuration-files.html#internals.configuration-files.variants-conf).
+
+    When specifying a version in the Puppet DSL, only specify the version, not the revision.
+    Revisions are only used internally for ensuring the latest version/revision of a port.
+  "
+
+  confine :operatingsystem => :darwin
+
+  has_command(:port, "/opt/local/bin/port") do
+    environment :HOME => "/opt/local"
+  end
+
+  has_feature :installable
+  has_feature :uninstallable
+  has_feature :upgradeable
+  has_feature :versionable
+
+
+  def self.parse_installed_query_line(line)
+    regex = /(\S+)\s+@(\S+)_(\d+).*\(active\)/
+    fields = [:name, :ensure, :revision]
+    hash_from_line(line, regex, fields)
+  end
+
+  def self.parse_info_query_line(line)
+    regex = /(\S+)\s+(\S+)/
+    fields = [:version, :revision]
+    hash_from_line(line, regex, fields)
+  end
+
+  def self.hash_from_line(line, regex, fields)
+    hash = {}
+    if match = regex.match(line)
+      fields.zip(match.captures) { |field, value|
+        hash[field] = value
+      }
+      hash[:provider] = self.name
+      return hash
+    end
+    nil
+  end
+
+  def self.instances
+    packages = []
+    port("-q", :installed).each_line do |line|
+      if hash = parse_installed_query_line(line)
+        packages << new(hash)
+      end
+    end
+    packages
+  end
+
+  def install
+    should = @resource.should(:ensure)
+    if [:latest, :installed, :present].include?(should)
+      output = port("-q", :install, @resource[:name])
+    else
+      output = port("-q", :install, @resource[:name], "@#{should}")
+    end
+    # MacPorts now correctly exits non-zero with appropriate errors in
+    # situations where a port cannot be found or installed.
+  end
+
+  def query
+    result = self.class.parse_installed_query_line(execute([command(:port), "-q", :installed, @resource[:name]], :failonfail => false, :combine => false))
+    return {} if result.nil?
+    return result
+  end
+
+  def latest
+    # We need both the version and the revision to be confident
+    # we've got the latest revision of a specific version
+    # Note we're still not doing anything with variants here.
+    info_line = execute([command(:port), "-q", :info, "--line", "--version", "--revision", @resource[:name]], :failonfail => false, :combine => false)
+    return nil if info_line == ""
+
+    if newest = self.class.parse_info_query_line(info_line)
+      current = query
+      # We're doing some fiddling behind the scenes here to cope with updated revisions.
+      # If we're already at the latest version/revision, then just return the version
+      # so the current and desired values match. Otherwise return version and revision
+      # to trigger an upgrade to the latest revision.
+      if newest[:version] == current[:ensure] and newest[:revision] == current[:revision]
+        return current[:ensure]
+      else
+        return "#{newest[:version]}_#{newest[:revision]}"
+      end
+    end
+    nil
+  end
+
+  def uninstall
+    port("-q", :uninstall, @resource[:name])
+  end
+
+  def update
+    install
+  end
+end

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

@@ -0,0 +1,125 @@
+require 'puppet/provider/package'
+require 'puppet/util/windows'
+
+Puppet::Type.type(:package).provide(:msi, :parent => Puppet::Provider::Package) do
+  desc "Windows package management by installing and removing MSIs.
+
+    The `msi` provider is deprecated. Use the `windows` provider instead."
+
+  confine    :operatingsystem => :windows
+
+  has_feature :installable
+  has_feature :uninstallable
+  has_feature :install_options
+  has_feature :uninstall_options
+
+  class MsiPackage
+    extend Enumerable
+    include Puppet::Util::Windows::Registry
+    extend Puppet::Util::Windows::Registry
+
+    def self.installer
+      WIN32OLE.new("WindowsInstaller.Installer")
+    end
+
+    def self.each(&block)
+      inst = installer
+      inst.UILevel = 2
+
+      inst.Products.each do |guid|
+        # products may be advertised, installed in a different user
+        # context, etc, we only want to know about products currently
+        # installed in our context.
+        next unless inst.ProductState(guid) == 5
+
+        package = {
+          :name        => inst.ProductInfo(guid, 'ProductName'),
+          # although packages have a version, the provider isn't versionable,
+          # so we can't return a version
+          # :ensure      => inst.ProductInfo(guid, 'VersionString'),
+          :ensure      => :installed,
+          :provider    => :msi,
+          :productcode => guid,
+          :packagecode => inst.ProductInfo(guid, 'PackageCode')
+        }
+
+        yield package
+      end
+    end
+  end
+
+  def self.instances
+    []
+  end
+
+  def initialize(resource = nil)
+    Puppet.deprecation_warning "The `:msi` package provider is deprecated, use the `:windows` provider instead."
+    super(resource)
+  end
+
+  # Find first package whose PackageCode, e.g. {B2BE95D2-CD2C-46D6-8D27-35D150E58EC9},
+  # matches the resource name (case-insensitively due to hex) or the ProductName matches
+  # the resource name. The ProductName is not guaranteed to be unique, but the PackageCode
+  # should be if the package is authored correctly.
+  def query
+    MsiPackage.enum_for.find do |package|
+      resource[:name].casecmp(package[:packagecode]) == 0 || resource[:name] == package[:name]
+    end
+  end
+
+  def install
+    fail("The source parameter is required when using the MSI provider.") unless resource[:source]
+
+    # Unfortunately, we can't use the msiexec method defined earlier,
+    # because of the special quoting we need to do around the MSI
+    # properties to use.
+    command = ['msiexec.exe', '/qn', '/norestart', '/i', shell_quote(resource[:source]), install_options].flatten.compact.join(' ')
+    output = execute(command, :failonfail => false, :combine => true)
+
+    check_result(output.exitstatus)
+  end
+
+  def uninstall
+    fail("The productcode property is missing.") unless properties[:productcode]
+
+    command = ['msiexec.exe', '/qn', '/norestart', '/x', properties[:productcode], uninstall_options].flatten.compact.join(' ')
+    output = execute(command, :failonfail => false, :combine => true)
+
+    check_result(output.exitstatus)
+  end
+
+  # (Un)install may "fail" because the package requested a reboot, the system requested a
+  # reboot, or something else entirely. Reboot requests mean the package was installed
+  # successfully, but we warn since we don't have a good reboot strategy.
+  def check_result(hr)
+    operation = resource[:ensure] == :absent ? 'uninstall' : 'install'
+
+    # http://msdn.microsoft.com/en-us/library/windows/desktop/aa368542(v=vs.85).aspx
+    case hr
+    when 0
+      # yeah
+    when 1641
+      warning("The package #{operation}ed successfully and the system is rebooting now.")
+    when 3010
+      warning("The package #{operation}ed successfully, but the system must be rebooted.")
+    else
+      raise Puppet::Util::Windows::Error.new("Failed to #{operation}", hr)
+    end
+  end
+
+  def validate_source(value)
+    fail("The source parameter cannot be empty when using the MSI provider.") if value.empty?
+  end
+
+  def install_options
+    join_options(resource[:install_options])
+  end
+
+  def uninstall_options
+    join_options(resource[:uninstall_options])
+  end
+
+  def shell_quote(value)
+    value.include?(' ') ? %Q["#{value.gsub(/"/, '\"')}"] : value
+  end
+end