puppet-retrospec 1.5.0 → 1.6.0

data/vendor/gems/puppet-4.5.2/lib/puppet/provider/package/yum.rb

@@ -1,241 +0,0 @@
-Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
-  desc "Support via `yum`.
-
-  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 yum.
-  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 => "yum", :rpm => "rpm"
-
-  if command('rpm')
-    confine :true => begin
-      rpm('--version')
-      rescue Puppet::ExecutionFailure
-        false
-      else
-        true
-      end
-  end
-
-  defaultfor :osfamily => :redhat
-
-  def self.prefetch(packages)
-    raise Puppet::Error, "The yum provider can only be used as root" if Process.euid != 0
-    super
-  end
-
-  # Retrieve the latest package version information for a given package name
-  # and combination of repos to enable and disable.
-  #
-  # @note If multiple package versions are defined (such as in the case where a
-  #   package is built for multiple architectures), the first package found
-  #   will be used.
-  #
-  # @api private
-  # @param package [String] The name of the package to query
-  # @param enablerepo [Array<String>] A list of repositories to enable for this query
-  # @param disablerepo [Array<String>] A list of repositories to disable for this query
-  # @param disableexcludes [Array<String>] A list of repository excludes to disable for this query
-  # @return [Hash<Symbol, String>]
-  def self.latest_package_version(package, enablerepo, disablerepo, disableexcludes)
-
-    key = [enablerepo, disablerepo, disableexcludes]
-
-    @latest_versions ||= {}
-    if @latest_versions[key].nil?
-      @latest_versions[key] = check_updates(enablerepo, disablerepo, disableexcludes)
-    end
-
-    if @latest_versions[key][package]
-      @latest_versions[key][package].first
-    end
-  end
-
-  # Search for all installed packages that have newer versions, given a
-  # combination of repositories to enable and disable.
-  #
-  # @api private
-  # @param enablerepo [Array<String>] A list of repositories to enable for this query
-  # @param disablerepo [Array<String>] A list of repositories to disable for this query
-  # @param disableexcludes [Array<String>] A list of repository excludes to disable for this query
-  # @return [Hash<String, Array<Hash<String, String>>>] All packages that were
-  #   found with a list of found versions for each package.
-  def self.check_updates(enablerepo, disablerepo, disableexcludes)
-    args = [command(:cmd), 'check-update']
-    args.concat(enablerepo.map { |repo| ["--enablerepo=#{repo}"] }.flatten)
-    args.concat(disablerepo.map { |repo| ["--disablerepo=#{repo}"] }.flatten)
-    args.concat(disableexcludes.map { |repo| ["--disableexcludes=#{repo}"] }.flatten)
-
-    output = Puppet::Util::Execution.execute(args, :failonfail => false, :combine => false)
-
-    updates = {}
-    if output.exitstatus == 100
-      updates = parse_updates(output)
-    elsif output.exitstatus == 0
-      self.debug "#{command(:cmd)} check-update exited with 0; no package updates available."
-    else
-      self.warning "Could not check for updates, '#{command(:cmd)} check-update' exited with #{output.exitstatus}"
-    end
-    updates
-  end
-
-  def self.parse_updates(str)
-    # Strip off all content before the first blank line
-    body = str.partition(/^\s*\n/m).last
-
-    updates = Hash.new { |h, k| h[k] = [] }
-    body.split.each_slice(3) do |tuple|
-      break if tuple[0] =~ /^(Obsoleting|Security:|Update)/
-      hash = update_to_hash(*tuple[0..1])
-      # Create entries for both the package name without a version and a
-      # version since yum considers those as mostly interchangeable.
-      short_name = hash[:name]
-      long_name  = "#{hash[:name]}.#{hash[:arch]}"
-
-      updates[short_name] << hash
-      updates[long_name] << hash
-    end
-
-    updates
-  end
-
-  def self.update_to_hash(pkgname, pkgversion)
-    name, arch = pkgname.split('.')
-
-    match = pkgversion.match(/^(?:(\d+):)?(\S+)-(\S+)$/)
-    epoch = match[1] || '0'
-    version = match[2]
-    release = match[3]
-
-    {
-      :name => name,
-      :epoch => epoch,
-      :version => version,
-      :release => release,
-      :arch    => arch,
-    }
-  end
-
-  def self.clear
-    @latest_versions = nil
-  end
-
-  def self.error_level
-    '0'
-  end
-
-  def install
-    wanted = @resource[:name]
-    error_level = self.class.error_level
-    # If not allowing virtual packages, do a query to ensure a real package exists
-    unless @resource.allow_virtual?
-      execute([command(:cmd), '-d', '0', '-e', error_level, '-y', install_options, :list, wanted].compact)
-    end
-
-    should = @resource.should(:ensure)
-    self.debug "Ensuring => #{should}"
-    operation = :install
-
-    case should
-    when true, false, Symbol
-      # pass
-      should = nil
-    else
-      # Add the package version
-      wanted += "-#{should}"
-      if wanted.scan(ARCH_REGEX)
-        self.debug "Detected Arch argument in package! - Moving arch to end of version string"
-        wanted.gsub!(/(.+)(#{ARCH_REGEX})(.+)/,'\1\3\2')
-      end
-
-      is = self.query
-      if is && rpm_compareEVR(rpm_parse_evr(should), rpm_parse_evr(is[:ensure])) < 0
-        self.debug "Downgrading package #{@resource[:name]} from version #{is[:ensure]} to #{should}"
-        operation = :downgrade
-      end
-    end
-
-    # Yum on el-4 and el-5 returns exit status 0 when trying to install a package it doesn't recognize;
-    # ensure we capture output to check for errors.
-    no_debug = if Facter.value(:operatingsystemmajrelease).to_i > 5 then ["-d", "0"] else [] end
-    command = [command(:cmd)] + no_debug + ["-e", error_level, "-y", install_options, operation, wanted].compact
-    output = execute(command)
-
-    if output =~ /^No package #{wanted} available\.$/
-      raise Puppet::Error, "Could not find package #{wanted}"
-    end
-
-    # If a version was specified, query again to see if it is a matching version
-    if should
-      is = self.query
-      raise Puppet::Error, "Could not find package #{self.name}" unless is
-
-      # FIXME: Should we raise an exception even if should == :latest
-      # and yum updated us to a version other than @param_hash[:ensure] ?
-      vercmp_result = rpm_compareEVR(rpm_parse_evr(should), rpm_parse_evr(is[:ensure]))
-      raise Puppet::Error, "Failed to update to version #{should}, got version #{is[:ensure]} instead" if vercmp_result != 0
-    end
-  end
-
-  # What's the latest package version available?
-  def latest
-    upd = self.class.latest_package_version(@resource[:name], enablerepo, disablerepo, disableexcludes)
-    unless upd.nil?
-      # FIXME: there could be more than one update for a package
-      # because of multiarch
-      return "#{upd[:epoch]}:#{upd[:version]}-#{upd[:release]}"
-    else
-      # Yum didn't find updates, pretend the current version is the latest
-      version = properties[:ensure]
-      raise Puppet::DevError, "Tried to get latest on a missing package" if version == :absent || version == :purged
-      return version
-    end
-  end
-
-  def update
-    # Install in yum can be used for update, too
-    self.install
-  end
-
-  def purge
-    execute([command(:cmd), "-y", :erase, @resource[:name]])
-  end
-
-  private
-
-  def enablerepo
-    scan_options(resource[:install_options], '--enablerepo')
-  end
-
-  def disablerepo
-    scan_options(resource[:install_options], '--disablerepo')
-  end
-
-  def disableexcludes
-    scan_options(resource[:install_options], '--disableexcludes')
-  end
-
-  # Scan a structure that looks like the package type 'install_options'
-  # structure for all hashes that have a specific key.
-  #
-  # @api private
-  # @param options [Array<String | Hash>, nil] The options structure. If the
-  #   options are nil an empty array will be returned.
-  # @param key [String] The key to look for in all contained hashes
-  # @return [Array<String>] All hash values with the given key.
-  def scan_options(options, key)
-    return [] if options.nil?
-    options.inject([]) do |repos, opt|
-      if opt.is_a? Hash and opt[key]
-        repos << opt[key]
-      end
-      repos
-    end
-  end
-end

data/vendor/gems/puppet-4.5.2/lib/puppet/provider/parsedfile.rb

@@ -1,459 +0,0 @@
-require 'puppet'
-require 'puppet/util/filetype'
-require 'puppet/util/fileparsing'
-
-# This provider can be used as the parent class for a provider that
-# parses and generates files.  Its content must be loaded via the
-# 'prefetch' method, and the file will be written when 'flush' is called
-# on the provider instance.  At this point, the file is written once
-# for every provider instance.
-#
-# Once the provider prefetches the data, it's the resource's job to copy
-# that data over to the @is variables.
-class Puppet::Provider::ParsedFile < Puppet::Provider
-  extend Puppet::Util::FileParsing
-
-  class << self
-    attr_accessor :default_target, :target
-  end
-
-  attr_accessor :property_hash
-
-  def self.clean(hash)
-    newhash = hash.dup
-    [:record_type, :on_disk].each do |p|
-      newhash.delete(p) if newhash.include?(p)
-    end
-
-    newhash
-  end
-
-  def self.clear
-    @target_objects.clear
-    @records.clear
-  end
-
-  def self.filetype
-    @filetype ||= Puppet::Util::FileType.filetype(:flat)
-  end
-
-  def self.filetype=(type)
-    if type.is_a?(Class)
-      @filetype = type
-    elsif klass = Puppet::Util::FileType.filetype(type)
-      @filetype = klass
-    else
-      raise ArgumentError, "Invalid filetype #{type}"
-    end
-  end
-
-  # Flush all of the targets for which there are modified records.  The only
-  # reason we pass a record here is so that we can add it to the stack if
-  # necessary -- it's passed from the instance calling 'flush'.
-  def self.flush(record)
-    # Make sure this record is on the list to be flushed.
-    unless record[:on_disk]
-      record[:on_disk] = true
-      @records << record
-
-      # If we've just added the record, then make sure our
-      # target will get flushed.
-      modified(record[:target] || default_target)
-    end
-
-    return unless defined?(@modified) and ! @modified.empty?
-
-    flushed = []
-    begin
-      @modified.sort { |a,b| a.to_s <=> b.to_s }.uniq.each do |target|
-        Puppet.debug "Flushing #{@resource_type.name} provider target #{target}"
-        flushed << target
-        flush_target(target)
-      end
-    ensure
-      @modified.reject! { |t| flushed.include?(t) }
-    end
-  end
-
-  # Make sure our file is backed up, but only back it up once per transaction.
-  # We cheat and rely on the fact that @records is created on each prefetch.
-  def self.backup_target(target)
-    return nil unless target_object(target).respond_to?(:backup)
-
-    @backup_stats ||= {}
-    return nil if @backup_stats[target] == @records.object_id
-
-    target_object(target).backup
-    @backup_stats[target] = @records.object_id
-  end
-
-  # Flush all of the records relating to a specific target.
-  def self.flush_target(target)
-    backup_target(target)
-
-    records = target_records(target).reject { |r|
-      r[:ensure] == :absent
-    }
-
-    target_object(target).write(to_file(records))
-  end
-
-  # Return the header placed at the top of each generated file, warning
-  # users that modifying this file manually is probably a bad idea.
-  def self.header
-%{# HEADER: This file was autogenerated at #{Time.now}
-# HEADER: by puppet.  While it can still be managed manually, it
-# HEADER: is definitely not recommended.\n}
-  end
-
-  # An optional regular expression matched by third party headers.
-  #
-  # For example, this can be used to filter the vixie cron headers as
-  # erronously exported by older cron versions.
-  #
-  # @api private
-  # @abstract Providers based on ParsedFile may implement this to make it
-  #   possible to identify a header maintained by a third party tool.
-  #   The provider can then allow that header to remain near the top of the
-  #   written file, or remove it after composing the file content.
-  #   If implemented, the function must return a Regexp object.
-  #   The expression must be tailored to match exactly one third party header.
-  # @see drop_native_header
-  # @note When specifying regular expressions in multiline mode, avoid
-  #   greedy repititions such as '.*' (use .*? instead). Otherwise, the
-  #   provider may drop file content between sparse headers.
-  def self.native_header_regex
-    nil
-  end
-
-  # How to handle third party headers.
-  # @api private
-  # @abstract Providers based on ParsedFile that make use of the support for
-  #   third party headers may override this method to return +true+.
-  #   When this is done, headers that are matched by the native_header_regex
-  #   are not written back to disk.
-  # @see native_header_regex
-  def self.drop_native_header
-    false
-  end
-
-  # Add another type var.
-  def self.initvars
-    @records = []
-    @target_objects = {}
-
-    @target = nil
-
-    # Default to flat files
-    @filetype ||= Puppet::Util::FileType.filetype(:flat)
-    super
-  end
-
-  # Return a list of all of the records we can find.
-  def self.instances
-    targets.collect do |target|
-      prefetch_target(target)
-    end.flatten.reject { |r| skip_record?(r) }.collect do |record|
-      new(record)
-    end
-  end
-
-  # Override the default method with a lot more functionality.
-  def self.mk_resource_methods
-    [resource_type.validproperties, resource_type.parameters].flatten.each do |attr|
-      attr = attr.intern
-      define_method(attr) do
-        # If it's not a valid field for this record type (which can happen
-        # when different platforms support different fields), then just
-        # return the should value, so the resource shuts up.
-        if @property_hash[attr] or self.class.valid_attr?(self.class.name, attr)
-          @property_hash[attr] || :absent
-        else
-          if defined?(@resource)
-            @resource.should(attr)
-          else
-            nil
-          end
-        end
-      end
-
-      define_method(attr.to_s + "=") do |val|
-        mark_target_modified
-        @property_hash[attr] = val
-      end
-    end
-  end
-
-  # Always make the resource methods.
-  def self.resource_type=(resource)
-    super
-    mk_resource_methods
-  end
-
-  # Mark a target as modified so we know to flush it.  This only gets
-  # used within the attr= methods.
-  def self.modified(target)
-    @modified ||= []
-    @modified << target unless @modified.include?(target)
-  end
-
-  # Retrieve all of the data from disk.  There are three ways to know
-  # which files to retrieve:  We might have a list of file objects already
-  # set up, there might be instances of our associated resource and they
-  # will have a path parameter set, and we will have a default path
-  # set.  We need to turn those three locations into a list of files,
-  # prefetch each one, and make sure they're associated with each appropriate
-  # resource instance.
-  def self.prefetch(resources = nil)
-    # Reset the record list.
-    @records = prefetch_all_targets(resources)
-
-    match_providers_with_resources(resources)
-  end
-
-  # Match a list of catalog resources with provider instances
-  #
-  # @api private
-  #
-  # @param [Array<Puppet::Resource>] resources A list of resources using this class as a provider
-  def self.match_providers_with_resources(resources)
-    return unless resources
-    matchers = resources.dup
-    @records.each do |record|
-      # Skip things like comments and blank lines
-      next if skip_record?(record)
-
-      if (resource = resource_for_record(record, resources))
-        resource.provider = new(record)
-      elsif respond_to?(:match)
-        if resource = match(record, matchers)
-          matchers.delete(resource.title)
-          record[:name] = resource[:name]
-          resource.provider = new(record)
-        end
-      end
-    end
-  end
-
-  # Look up a resource based on a parsed file record
-  #
-  # @api private
-  #
-  # @param [Hash<Symbol, Object>] record
-  # @param [Array<Puppet::Resource>] resources
-  #
-  # @return [Puppet::Resource, nil] The resource if found, else nil
-  def self.resource_for_record(record, resources)
-    name = record[:name]
-    if name
-      resources[name]
-    end
-  end
-
-  def self.prefetch_all_targets(resources)
-    records = []
-    targets(resources).each do |target|
-      records += prefetch_target(target)
-    end
-    records
-  end
-
-  # Prefetch an individual target.
-  def self.prefetch_target(target)
-
-    begin
-      target_records = retrieve(target)
-    rescue Puppet::Util::FileType::FileReadError => detail
-      puts detail.backtrace if Puppet[:trace]
-      Puppet.err "Could not prefetch #{self.resource_type.name} provider '#{self.name}' target '#{target}': #{detail}. Treating as empty"
-      target_records = []
-    end
-
-    target_records.each do |r|
-      r[:on_disk] = true
-      r[:target] = target
-      r[:ensure] = :present
-    end
-
-    target_records = prefetch_hook(target_records) if respond_to?(:prefetch_hook)
-
-    raise Puppet::DevError, "Prefetching #{target} for provider #{self.name} returned nil" unless target_records
-
-    target_records
-  end
-
-  # Is there an existing record with this name?
-  def self.record?(name)
-    return nil unless @records
-    @records.find { |r| r[:name] == name }
-  end
-
-  # Retrieve the text for the file. Returns nil in the unlikely
-  # event that it doesn't exist.
-  def self.retrieve(path)
-    # XXX We need to be doing something special here in case of failure.
-    text = target_object(path).read
-    if text.nil? or text == ""
-      # there is no file
-      return []
-    else
-      # Set the target, for logging.
-      old = @target
-      begin
-        @target = path
-        return self.parse(text)
-      rescue Puppet::Error => detail
-        detail.file = @target if detail.respond_to?(:file=)
-        raise detail
-      ensure
-        @target = old
-      end
-    end
-  end
-
-  # Should we skip the record?  Basically, we skip text records.
-  # This is only here so subclasses can override it.
-  def self.skip_record?(record)
-    record_type(record[:record_type]).text?
-  end
-
-  # The mode for generated files if they are newly created.
-  # No mode will be set on existing files.
-  #
-  # @abstract Providers inheriting parsedfile can override this method
-  #   to provide a mode. The value should be suitable for File.chmod
-  def self.default_mode
-    nil
-  end
-
-  # Initialize the object if necessary.
-  def self.target_object(target)
-    # only send the default mode if the actual provider defined it,
-    # because certain filetypes (e.g. the crontab variants) do not
-    # expect it in their initialize method
-    if default_mode
-      @target_objects[target] ||= filetype.new(target, default_mode)
-    else
-      @target_objects[target] ||= filetype.new(target)
-    end
-
-    @target_objects[target]
-  end
-
-  # Find all of the records for a given target
-  def self.target_records(target)
-    @records.find_all { |r| r[:target] == target }
-  end
-
-  # Find a list of all of the targets that we should be reading.  This is
-  # used to figure out what targets we need to prefetch.
-  def self.targets(resources = nil)
-    targets = []
-    # First get the default target
-    raise Puppet::DevError, "Parsed Providers must define a default target" unless self.default_target
-    targets << self.default_target
-
-    # Then get each of the file objects
-    targets += @target_objects.keys
-
-    # Lastly, check the file from any resource instances
-    if resources
-      resources.each do |name, resource|
-        if value = resource.should(:target)
-          targets << value
-        end
-      end
-    end
-
-    targets.uniq.compact
-  end
-
-  # Compose file contents from the set of records.
-  #
-  # If self.native_header_regex is not nil, possible vendor headers are
-  # identified by matching the return value against the expression.
-  # If one (or several consecutive) such headers, are found, they are
-  # either moved in front of the self.header if self.drop_native_header
-  # is false (this is the default), or removed from the return value otherwise.
-  #
-  # @api private
-  def self.to_file(records)
-    text = super
-    if native_header_regex and (match = text.match(native_header_regex))
-      if drop_native_header
-        # concatenate the text in front of and after the native header
-        text = match.pre_match + match.post_match
-      else
-        native_header = match[0]
-        return native_header + header + match.pre_match + match.post_match
-      end
-    end
-    header + text
-  end
-
-  def create
-    @resource.class.validproperties.each do |property|
-      if value = @resource.should(property)
-        @property_hash[property] = value
-      end
-    end
-    mark_target_modified
-    (@resource.class.name.to_s + "_created").intern
-  end
-
-  def destroy
-    # We use the method here so it marks the target as modified.
-    self.ensure = :absent
-    (@resource.class.name.to_s + "_deleted").intern
-  end
-
-  def exists?
-    !(@property_hash[:ensure] == :absent or @property_hash[:ensure].nil?)
-  end
-
-  # Write our data to disk.
-  def flush
-    # Make sure we've got a target and name set.
-
-    # If the target isn't set, then this is our first modification, so
-    # mark it for flushing.
-    unless @property_hash[:target]
-      @property_hash[:target] = @resource.should(:target) || self.class.default_target
-      self.class.modified(@property_hash[:target])
-    end
-    @resource.class.key_attributes.each do |attr|
-      @property_hash[attr] ||= @resource[attr]
-    end
-
-    self.class.flush(@property_hash)
-  end
-
-  def initialize(record)
-    super
-
-    # The 'record' could be a resource or a record, depending on how the provider
-    # is initialized.  If we got an empty property hash (probably because the resource
-    # is just being initialized), then we want to set up some defaults.
-    @property_hash = self.class.record?(resource[:name]) || {:record_type => self.class.name, :ensure => :absent} if @property_hash.empty?
-  end
-
-  # Retrieve the current state from disk.
-  def prefetch
-    raise Puppet::DevError, "Somehow got told to prefetch with no resource set" unless @resource
-    self.class.prefetch(@resource[:name] => @resource)
-  end
-
-  def record_type
-    @property_hash[:record_type]
-  end
-
-  private
-
-  # Mark both the resource and provider target as modified.
-  def mark_target_modified
-    if defined?(@resource) and restarget = @resource.should(:target) and restarget != @property_hash[:target]
-      self.class.modified(restarget)
-    end
-    self.class.modified(@property_hash[:target]) if @property_hash[:target] != :absent and @property_hash[:target]
-  end
-end