puppet 5.5.22 → 6.0.0

data/lib/puppet/provider/cisco.rb

@@ -1,9 +0,0 @@
-require 'puppet/util/network_device/cisco/device'
-require 'puppet/provider/network_device'
-
-# This is the base class of all prefetched cisco device providers
-class Puppet::Provider::Cisco < Puppet::Provider::NetworkDevice
-  def self.device(url)
-    Puppet::Util::NetworkDevice::Cisco::Device.new(url)
-  end
-end

data/lib/puppet/provider/computer/computer.rb

@@ -1,20 +0,0 @@
-require 'puppet/provider/nameservice/directoryservice'
-
-Puppet::Type.type(:computer).provide :directoryservice, :parent => Puppet::Provider::NameService::DirectoryService do
-  desc "Computer object management using DirectoryService on OS X.
-  Note that these are distinctly different kinds of objects to 'hosts',
-  as they require a MAC address and can have all sorts of policy attached to
-  them.
-
-  This provider only manages Computer objects in the local directory service
-  domain, not in remote directories.
-
-  If you wish to manage /etc/hosts on Mac OS X, then simply use the host
-  type as per other platforms."
-
-  confine :operatingsystem => :darwin
-  defaultfor :operatingsystem => :darwin
-
-  # hurray for abstraction. The nameservice directoryservice provider can
-  # handle everything we need. super.
-end

data/lib/puppet/provider/cron/crontab.rb

@@ -1,297 +0,0 @@
-require 'puppet/provider/parsedfile'
-
-Puppet::Type.type(:cron).provide(:crontab, :parent => Puppet::Provider::ParsedFile, :default_target => ENV["USER"] || "root", :raise_prefetch_errors => true) do
-  commands :crontab => "crontab"
-
-  text_line :comment, :match => %r{^\s*#}, :post_parse => proc { |record|
-    record[:name] = $1 if record[:line] =~ /Puppet Name: (.+)\s*$/
-  }
-
-  text_line :blank, :match => %r{^\s*$}
-
-  text_line :environment, :match => %r{^\s*\w+\s*=}
-
-  def self.filetype
-  tabname = case Facter.value(:osfamily)
-            when "Solaris"
-              :suntab
-            when "AIX"
-              :aixtab
-            else
-              :crontab
-            end
-
-    Puppet::Util::FileType.filetype(tabname)
-  end
-
-  self::TIME_FIELDS = [:minute, :hour, :monthday, :month, :weekday]
-
-  record_line :crontab,
-    :fields     => %w{time command},
-    :match      => %r{^\s*(@\w+|\S+\s+\S+\s+\S+\s+\S+\s+\S+)\s+(.+)$},
-    :absent     => '*',
-    :block_eval => :instance do
-
-    def post_parse(record)
-      time = record.delete(:time)
-      if match = /@(\S+)/.match(time)
-        # is there another way to access the constant?
-        Puppet::Type::Cron::ProviderCrontab::TIME_FIELDS.each { |f| record[f] = :absent }
-        record[:special] = match.captures[0]
-      elsif match = /(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)/.match(time)
-        record[:special] = :absent
-        Puppet::Type::Cron::ProviderCrontab::TIME_FIELDS.zip(match.captures).each do |field,value|
-          if value == self.absent
-            record[field] = :absent
-          else
-            record[field] = value.split(",")
-          end
-        end
-      else
-        raise Puppet::Error, _("Line got parsed as a crontab entry but cannot be handled. Please file a bug with the contents of your crontab")
-      end
-      record
-    end
-
-    def pre_gen(record)
-      if record[:special] and record[:special] != :absent
-        record[:special] = "@#{record[:special]}"
-      end
-
-      Puppet::Type::Cron::ProviderCrontab::TIME_FIELDS.each do |field|
-        if vals = record[field] and vals.is_a?(Array)
-          record[field] = vals.join(",")
-        end
-      end
-      record
-    end
-
-    def to_line(record)
-      str = ""
-      record[:name] = nil if record[:unmanaged]
-      str = "# Puppet Name: #{record[:name]}\n" if record[:name]
-      if record[:environment] and record[:environment] != :absent
-        str += record[:environment].map {|line| "#{line}\n"}.join('')
-      end
-      if record[:special] and record[:special] != :absent
-        fields = [:special, :command]
-      else
-        fields = Puppet::Type::Cron::ProviderCrontab::TIME_FIELDS + [:command]
-      end
-      str += record.values_at(*fields).map do |field|
-        if field.nil? or field == :absent
-          self.absent
-        else
-          field
-        end
-      end.join(self.joiner)
-      str
-    end
-  end
-
-  def create
-    if resource.should(:command) then
-      super
-    else
-      resource.err _("no command specified, cannot create")
-    end
-  end
-
-  # Look up a resource with a given name whose user matches a record target
-  #
-  # @api private
-  #
-  # @note This overrides the ParsedFile method for finding resources by name,
-  #   so that only records for a given user are matched to resources of the
-  #   same user so that orphaned records in other crontabs don't get falsely
-  #   matched (#2251)
-  #
-  # @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)
-    resource = super
-
-    if resource
-      target = resource[:target] || resource[:user]
-      if record[:target] == target
-        resource
-      end
-    end
-  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} by puppet.
-# HEADER: While it can still be managed manually, it is definitely not recommended.
-# HEADER: Note particularly that the comments starting with 'Puppet Name' should
-# HEADER: not be deleted, as doing so could cause duplicate cron jobs.\n}
-  end
-
-  # Regex for finding one vixie cron header.
-  def self.native_header_regex
-    /# DO NOT EDIT THIS FILE.*?Cron version.*?vixie.*?\n/m
-  end
-
-  # If a vixie cron header is found, it should be dropped, cron will insert
-  # a new one in any case, so we need to avoid duplicates.
-  def self.drop_native_header
-    true
-  end
-
-  # See if we can match the record against an existing cron job.
-  def self.match(record, resources)
-    # if the record is named, do not even bother (#19876)
-    # except the resource name was implicitly generated (#3220)
-    return false if record[:name] and !record[:unmanaged]
-    resources.each do |name, resource|
-      # Match the command first, since it's the most important one.
-      next unless record[:target] == resource[:target]
-      next unless record[:command] == resource.value(:command)
-
-      # Now check the time fields
-      compare_fields = self::TIME_FIELDS + [:special]
-
-      matched = true
-      compare_fields.each do |field|
-        # If the resource does not manage a property (say monthday) it should
-        # always match. If it is the other way around (e.g. resource defines
-        # a should value for :special but the record does not have it, we do
-        # not match
-        next unless resource[field]
-        unless record.include?(field)
-          matched = false
-          break
-        end
-
-        if record_value = record[field] and resource_value = resource.value(field)
-          # The record translates '*' into absent in the post_parse hook and
-          # the resource type does exactly the opposite (alias :absent to *)
-          next if resource_value == '*' and record_value == :absent
-          next if resource_value == record_value
-        end
-        matched =false
-        break
-      end
-      return resource if matched
-    end
-    false
-  end
-
-  @name_index = 0
-
-  # Collapse name and env records.
-  def self.prefetch_hook(records)
-    name = nil
-    envs = nil
-    result = records.each { |record|
-      case record[:record_type]
-      when :comment
-        if record[:name]
-          name = record[:name]
-          record[:skip] = true
-
-          # Start collecting env values
-          envs = []
-        end
-      when :environment
-        # If we're collecting env values (meaning we're in a named cronjob),
-        # store the line and skip the record.
-        if envs
-          envs << record[:line]
-          record[:skip] = true
-        end
-      when :blank
-        # nothing
-      else
-        if name
-          record[:name] = name
-          name = nil
-        else
-          cmd_string = record[:command].gsub(/\s+/, "_")
-          index = ( @name_index += 1 )
-          record[:name] = "unmanaged:#{cmd_string}-#{ index }"
-          record[:unmanaged] = true
-        end
-        if envs.nil? or envs.empty?
-          record[:environment] = :absent
-        else
-          # Collect all of the environment lines, and mark the records to be skipped,
-          # since their data is included in our crontab record.
-          record[:environment] = envs
-
-          # And turn off env collection again
-          envs = nil
-        end
-      end
-    }.reject { |record| record[:skip] }
-    result
-  end
-
-  def self.to_file(records)
-    text = super
-    # Apparently Freebsd will "helpfully" add a new TZ line to every
-    # single cron line, but not in all cases (e.g., it doesn't do it
-    # on my machine).  This is my attempt to fix it so the TZ lines don't
-    # multiply.
-    if text =~ /(^TZ=.+\n)/
-      tz = $1
-      text.sub!(tz, '')
-      text = tz + text
-    end
-    text
-  end
-
-  def user=(user)
-    # we have to mark the target as modified first, to make sure that if
-    # we move a cronjob from userA to userB, userA's crontab will also
-    # be rewritten
-    mark_target_modified
-    @property_hash[:user] = user
-    @property_hash[:target] = user
-  end
-
-  def user
-    @property_hash[:user] || @property_hash[:target]
-  end
-
-  CRONTAB_DIR = case Facter.value("osfamily")
-  when "Debian", "HP-UX", "Solaris"
-    "/var/spool/cron/crontabs"
-  when /BSD/
-    "/var/cron/tabs"
-  when "Darwin"
-    "/usr/lib/cron/tabs/"
-  else
-    "/var/spool/cron"
-  end
-
-  # Yield the names of all crontab files stored on the local system.
-  #
-  # @note Ignores files that are not writable for the puppet process.
-  #
-  # @api private
-  def self.enumerate_crontabs
-    Puppet.debug "looking for crontabs in #{CRONTAB_DIR}"
-    return unless File.readable?(CRONTAB_DIR)
-    Dir.foreach(CRONTAB_DIR) do |file|
-      path = "#{CRONTAB_DIR}/#{file}"
-      yield(file) if File.file?(path) and File.writable?(path)
-    end
-  end
-
-
-  # Include all plausible crontab files on the system
-  # in the list of targets (#11383 / PUP-1381)
-  def self.targets(resources = nil)
-    targets = super(resources)
-    enumerate_crontabs do |target|
-      targets << target
-    end
-    targets.uniq
-  end
-
-end
-

data/lib/puppet/provider/host/parsed.rb

@@ -1,46 +0,0 @@
-require 'puppet/provider/parsedfile'
-
-hosts = nil
-case Facter.value(:osfamily)
-when "Solaris"; hosts = "/etc/inet/hosts"
-when "windows"
-  require 'win32/resolv'
-  hosts = Win32::Resolv.get_hosts_path
-else
-  hosts = "/etc/hosts"
-end
-
-
-Puppet::Type.type(:host).provide(:parsed,:parent => Puppet::Provider::ParsedFile,
-  :default_target => hosts,:filetype => :flat) do
-  confine :exists => hosts
-
-  text_line :comment, :match => /^#/
-  text_line :blank, :match => /^\s*$/
-  hosts_pattern = '^([0-9a-f:]\S+)\s+([^#\s+]\S+)\s*(.*?)?(?:\s*#\s*(.*))?$'
-  record_line :parsed, :fields => %w{ip name host_aliases comment},
-    :optional => %w{host_aliases comment},
-    :match    => /#{hosts_pattern}/,
-    :post_parse => proc { |hash|
-      # An absent comment should match "comment => ''"
-      hash[:comment] = '' if hash[:comment].nil? or hash[:comment] == :absent
-      unless hash[:host_aliases].nil? or hash[:host_aliases] == :absent
-        hash[:host_aliases].gsub!(/\s+/,' ') # Change delimiter
-      end
-    },
-    :to_line  => proc { |hash|
-      [:ip, :name].each do |n|
-        raise ArgumentError, _("%{attr} is a required attribute for hosts") % { attr: n } unless hash[n] and hash[n] != :absent
-      end
-      str = "#{hash[:ip]}\t#{hash[:name]}"
-      if hash.include? :host_aliases and !hash[:host_aliases].nil? and hash[:host_aliases] != :absent
-        str += "\t#{hash[:host_aliases]}"
-      end
-      if hash.include? :comment and !hash[:comment].empty?
-        str += "\t# #{hash[:comment]}"
-      end
-      str
-    }
-
-  text_line :incomplete, :match => /(?! (#{hosts_pattern}))/
-end

data/lib/puppet/provider/interface/cisco.rb

@@ -1,27 +0,0 @@
-require 'puppet/provider/cisco'
-
-Puppet::Type.type(:interface).provide :cisco, :parent => Puppet::Provider::Cisco do
-
-  desc "Cisco switch/router provider for interface."
-
-  mk_resource_methods
-
-  def self.lookup(device, name)
-    interface = nil
-    device.command do |dev|
-      interface = dev.interface(name)
-    end
-    interface
-  end
-
-  def initialize(device, *args)
-    super
-  end
-
-  def flush
-    device.command do |dev|
-      dev.new_interface(name).update(former_properties, properties)
-    end
-    super
-  end
-end

data/lib/puppet/provider/macauthorization/macauthorization.rb

@@ -1,298 +0,0 @@
-require 'facter'
-require 'puppet/util/plist' if Puppet.features.cfpropertylist?
-require 'puppet'
-require 'tempfile'
-
-Puppet::Type.type(:macauthorization).provide :macauthorization, :parent => Puppet::Provider do
-
-  desc "Manage Mac OS X authorization database rules and rights.
-
-  "
-
-  commands :security => "/usr/bin/security"
-
-  confine :operatingsystem => :darwin
-  confine :feature         => :cfpropertylist
-
-  defaultfor :operatingsystem => :darwin
-
-  AuthDB = "/etc/authorization"
-
-  @rights = {}
-  @rules = {}
-  @parsed_auth_db = {}
-  @comment = ""  # Not implemented yet. Is there any real need to?
-
-  # This map exists due to the use of hyphens and reserved words in
-  # the authorization schema.
-  PuppetToNativeAttributeMap = {  :allow_root => "allow-root",
-    :authenticate_user => "authenticate-user",
-    :auth_class => "class",
-    :k_of_n => "k-of-n",
-    :session_owner => "session-owner", }
-
-  class << self
-    attr_accessor :parsed_auth_db
-    attr_accessor :rights
-    attr_accessor :rules
-    attr_accessor :comments  # Not implemented yet.
-
-    def prefetch(resources)
-      self.populate_rules_rights
-    end
-
-    def instances
-      if self.parsed_auth_db == {}
-        self.prefetch(nil)
-      end
-      self.parsed_auth_db.collect do |k,v|
-        new(:name => k)
-      end
-    end
-
-    def populate_rules_rights
-      auth_plist = Puppet::Util::Plist.parse_plist(AuthDB)
-      raise Puppet::Error.new(_("Cannot parse: %{auth}") % { auth: AuthDB }) if not auth_plist
-      self.rights = auth_plist["rights"].dup
-      self.rules = auth_plist["rules"].dup
-      self.parsed_auth_db = self.rights.dup
-      self.parsed_auth_db.merge!(self.rules.dup)
-    end
-
-  end
-
-  # standard required provider instance methods
-
-  def initialize(resource)
-    if self.class.parsed_auth_db == {}
-      self.class.prefetch(resource)
-    end
-    super
-  end
-
-
-  def create
-    # we just fill the @property_hash in here and let the flush method
-    # deal with it rather than repeating code.
-    new_values = {}
-    validprops = Puppet::Type.type(resource.class.name).validproperties
-    validprops.each do |prop|
-      next if prop == :ensure
-      if value = resource.should(prop) and value != ""
-        new_values[prop] = value
-      end
-    end
-    @property_hash = new_values.dup
-  end
-
-  def destroy
-    # We explicitly delete here rather than in the flush method.
-    case resource[:auth_type]
-    when :right
-      destroy_right
-    when :rule
-      destroy_rule
-    else
-      raise Puppet::Error.new(_("Must specify auth_type when destroying."))
-    end
-  end
-
-  def exists?
-    !!self.class.parsed_auth_db.has_key?(resource[:name])
-  end
-
-
-  def flush
-    # deletion happens in the destroy methods
-    if resource[:ensure] != :absent
-      case resource[:auth_type]
-      when :right
-        flush_right
-      when :rule
-        flush_rule
-      else
-        raise Puppet::Error.new(_("flush requested for unknown type."))
-      end
-      @property_hash.clear
-    end
-  end
-
-
-  # utility methods below
-
-  def destroy_right
-    security "authorizationdb", :remove, resource[:name]
-  end
-
-  def destroy_rule
-    authdb = Puppet::Util::Plist.parse_plist(AuthDB)
-    authdb_rules = authdb["rules"].dup
-    if authdb_rules[resource[:name]]
-      begin
-        authdb["rules"].delete(resource[:name])
-        Puppet::Util::Plist.write_plist_file(authdb, AuthDB)
-      rescue Errno::EACCES => e
-        raise Puppet::Error.new(_("Error saving %{auth}: %{error}") % { auth: AuthDB, error: e }, e)
-      end
-    end
-  end
-
-  def flush_right
-    # first we re-read the right just to make sure we're in sync for
-    # values that weren't specified in the manifest. As we're supplying
-    # the whole plist when specifying the right it seems safest to be
-    # paranoid given the low cost of querying the db once more.
-    cmds = []
-    cmds << :security << "authorizationdb" << "read" << resource[:name]
-    output = execute(cmds, :failonfail => false, :combine => false)
-    current_values = Puppet::Util::Plist.parse_plist(output)
-    current_values ||= {}
-    specified_values = convert_plist_to_native_attributes(@property_hash)
-
-    # take the current values, merge the specified values to obtain a
-    # complete description of the new values.
-    new_values = current_values.merge(specified_values)
-    set_right(resource[:name], new_values)
-  end
-
-  def flush_rule
-    authdb = Puppet::Util::Plist.parse_plist(AuthDB)
-    authdb_rules = authdb["rules"].dup
-    current_values = {}
-    current_values = authdb_rules[resource[:name]] if authdb_rules[resource[:name]]
-    specified_values = convert_plist_to_native_attributes(@property_hash)
-    new_values = current_values.merge(specified_values)
-    set_rule(resource[:name], new_values)
-  end
-
-  def set_right(name, values)
-    # Both creates and modifies rights as it simply overwrites them.
-    # The security binary only allows for writes using stdin, so we
-    # dump the values to a tempfile.
-    values = convert_plist_to_native_attributes(values)
-    tmp = Tempfile.new('puppet_macauthorization')
-    begin
-      Puppet::Util::Plist.write_plist_file(values, tmp.path)
-      cmds = []
-      cmds << :security << "authorizationdb" << "write" << name
-      execute(cmds, :failonfail => false, :combine => false, :stdinfile => tmp.path.to_s)
-    rescue Errno::EACCES => e
-      raise Puppet::Error.new(_("Cannot save right to %{path}: %{error}") % { path: tmp.path, error: e }, e)
-    ensure
-      tmp.close
-      tmp.unlink
-    end
-  end
-
-  def set_rule(name, values)
-    # Both creates and modifies rules as it overwrites the entry in the
-    # rules dictionary.  Unfortunately the security binary doesn't
-    # support modifying rules at all so we have to twiddle the whole
-    # plist... :( See Apple Bug #6386000
-    values = convert_plist_to_native_attributes(values)
-    authdb = Puppet::Util::Plist.parse_plist(AuthDB)
-    authdb["rules"][name] = values
-
-    begin
-      Puppet::Util::Plist.write_plist_file(authdb, AuthDB)
-    rescue
-      raise Puppet::Error.new(_("Error writing to: %{auth_db}") % { auth_db: AuthDB })
-    end
-  end
-
-  def convert_plist_to_native_attributes(propertylist)
-    # This mainly converts the keys from the puppet attributes to the
-    # 'native' ones, but also enforces that the keys are all Strings
-    # rather than Symbols so that any merges of the resultant Hash are
-    # sane. The exception is booleans, where we coerce to a proper bool
-    # if they come in as a symbol.
-    newplist = {}
-    propertylist.each_pair do |key, value|
-      next if key == :ensure     # not part of the auth db schema.
-      next if key == :auth_type  # not part of the auth db schema.
-      case value
-      when true, :true
-        value = true
-      when false, :false
-        value = false
-      end
-      new_key = key
-      if PuppetToNativeAttributeMap.has_key?(key)
-        new_key = PuppetToNativeAttributeMap[key].to_s
-      elsif not key.is_a?(String)
-        new_key = key.to_s
-      end
-      newplist[new_key] = value
-    end
-    newplist
-  end
-
-  def retrieve_value(resource_name, attribute)
-    # We set boolean values to symbols when retrieving values
-    raise Puppet::Error.new(_("Cannot find %{resource_name} in auth db") % { resource_name: resource_name }) if not self.class.parsed_auth_db.has_key?(resource_name)
-
-    if PuppetToNativeAttributeMap.has_key?(attribute)
-      native_attribute = PuppetToNativeAttributeMap[attribute]
-    else
-      native_attribute = attribute.to_s
-    end
-
-    if self.class.parsed_auth_db[resource_name].has_key?(native_attribute)
-      value = self.class.parsed_auth_db[resource_name][native_attribute]
-      case value
-      when true, :true
-        value = :true
-      when false, :false
-        value = :false
-      end
-
-      @property_hash[attribute] = value
-      return value
-    else
-      @property_hash.delete(attribute)
-      return ""  # so ralsh doesn't display it.
-    end
-  end
-
-
-  # property methods below
-  #
-  # We define them all dynamically apart from auth_type which is a special
-  # case due to not being in the actual authorization db schema.
-
-  properties = [  :allow_root, :authenticate_user, :auth_class, :comment,
-    :group, :k_of_n, :mechanisms, :rule, :session_owner,
-    :shared, :timeout, :tries ]
-
-  properties.each do |field|
-    define_method(field.to_s) do
-      retrieve_value(resource[:name], field)
-    end
-
-    define_method(field.to_s + "=") do |value|
-      @property_hash[field] = value
-    end
-  end
-
-  def auth_type
-    if resource.should(:auth_type) != nil
-      return resource.should(:auth_type)
-    elsif self.exists?
-      # this is here just for ralsh, so it can work out what type it is.
-      if self.class.rights.has_key?(resource[:name])
-        return :right
-      elsif self.class.rules.has_key?(resource[:name])
-        return :rule
-      else
-        raise Puppet::Error.new(_("%{resource} is unknown type.") % { resource: resource[:name] })
-      end
-    else
-      raise Puppet::Error.new(_("auth_type required for new resources."))
-    end
-  end
-
-  def auth_type=(value)
-    @property_hash[:auth_type] = value
-  end
-
-end