puppet 5.5.22 → 6.0.0

data/lib/puppet/provider/selboolean/getsetsebool.rb

@@ -1,47 +0,0 @@
-Puppet::Type.type(:selboolean).provide(:getsetsebool) do
-  desc "Manage SELinux booleans using the getsebool and setsebool binaries."
-
-  commands :getsebool => "/usr/sbin/getsebool"
-  commands :setsebool => "/usr/sbin/setsebool"
-
-  def value
-    self.debug "Retrieving value of selboolean #{@resource[:name]}"
-
-    status = getsebool(@resource[:name])
-
-    if status =~ / off$/
-      return :off
-    elsif status =~ / on$/ then
-      return :on
-    else
-      status.chomp!
-      raise Puppet::Error, "Invalid response '#{status}' returned from getsebool"
-    end
-  end
-
-  def value=(new)
-    persist = ""
-    if @resource[:persistent] == :true
-      self.debug "Enabling persistence"
-      persist = "-P"
-    end
-    execoutput("#{command(:setsebool)} #{persist} #{@resource[:name]} #{new}")
-    :file_changed
-  end
-
-  # Required workaround, since SELinux policy prevents setsebool
-  # from writing to any files, even tmp, preventing the standard
-  # 'setsebool("...")' construct from working.
-
-  def execoutput (cmd)
-    output = ''
-    begin
-      execpipe(cmd) do |out|
-        output = out.readlines.join('').chomp!
-      end
-    rescue Puppet::ExecutionFailure
-      raise Puppet::ExecutionFailure, output.split("\n")[0], $!.backtrace
-    end
-    output
-  end
-end

data/lib/puppet/provider/selmodule/semodule.rb

@@ -1,157 +0,0 @@
-Puppet::Type.type(:selmodule).provide(:semodule) do
-  desc "Manage SELinux policy modules using the semodule binary."
-
-  commands :semodule => "/usr/sbin/semodule"
-
-  def create
-    begin
-      execoutput("#{command(:semodule)} --install #{selmod_name_to_filename}")
-    rescue Puppet::ExecutionFailure => detail
-      raise Puppet::Error, "Could not load policy module: #{detail}", detail.backtrace
-    end
-    :true
-  end
-
-  def destroy
-      execoutput("#{command(:semodule)} --remove #{@resource[:name]}")
-  rescue Puppet::ExecutionFailure => detail
-      raise Puppet::Error, "Could not remove policy module: #{detail}", detail.backtrace
-  end
-
-  def exists?
-    self.debug "Checking for module #{@resource[:name]}"
-    return selmodules_loaded.has_key?(@resource[:name])
-  end
-
-  def syncversion
-    self.debug "Checking syncversion on #{@resource[:name]}"
-
-    loadver = selmodversion_loaded
-
-    if (loadver) then
-      filever = selmodversion_file
-      if (filever == loadver)
-        return :true
-      end
-    end
-    :false
-  end
-
-  def syncversion=(dosync)
-      execoutput("#{command(:semodule)} --upgrade #{selmod_name_to_filename}")
-  rescue Puppet::ExecutionFailure => detail
-      raise Puppet::Error, "Could not upgrade policy module: #{detail}", detail.backtrace
-  end
-
-  # Helper functions
-
-  def execoutput(cmd)
-    output = ''
-    begin
-      execpipe(cmd) do |out|
-        output = out.readlines.join('').chomp!
-      end
-    rescue Puppet::ExecutionFailure
-      raise Puppet::ExecutionFailure, output.split("\n")[0], $!.backtrace
-    end
-    output
-  end
-
-  def selmod_name_to_filename
-    if @resource[:selmodulepath]
-      return @resource[:selmodulepath]
-    else
-      return "#{@resource[:selmoduledir]}/#{@resource[:name]}.pp"
-    end
-  end
-
-  def selmod_readnext(handle)
-    len = handle.read(4).unpack('V')[0]
-    handle.read(len)
-  end
-
-  def selmodversion_file
-    magic = 0xF97CFF8F
-    v = nil
-
-    filename = selmod_name_to_filename
-    # Open a file handle and parse the bytes until version is found
-    Puppet::FileSystem.open(filename, nil, 'rb') do |mod|
-
-      (hdr, ver, numsec) = mod.read(12).unpack('VVV')
-
-      raise Puppet::Error, "Found #{hdr} instead of magic #{magic} in #{filename}" if hdr != magic
-
-      raise Puppet::Error, "Unknown policy file version #{ver} in #{filename}" if ver != 1
-
-      # Read through (and throw away) the file section offsets, and also
-      # the magic header for the first section.
-
-      mod.read((numsec + 1) * 4)
-
-      ## Section 1 should be "SE Linux Module"
-
-      selmod_readnext(mod)
-      selmod_readnext(mod)
-
-      # Skip past the section headers
-      mod.read(14)
-
-      # Module name
-      selmod_readnext(mod)
-
-      # At last!  the version
-
-      v = selmod_readnext(mod)
-
-    end
-
-    self.debug "file version #{v}"
-    v
-  end
-
-  def selmodversion_loaded
-    selmodules_loaded[@resource[:name]]
-  end
-
-  def selmodules_loaded
-    self.class.selmodules_loaded
-  end
-
-  # Extend Class
-
-  class << self
-    attr_accessor :loaded_modules
-  end
-
-  # Prefetch loaded selinux modules.
-  def self.prefetch(resources)
-    selmodules_loaded
-  end
-
-  def self.selmodules_loaded
-    if self.loaded_modules.nil?
-      self.debug "Fetching loaded selinux modules"
-      modules = {}
-      selmodule_cmd = "#{command(:semodule)} --list"
-      output = []
-      begin
-        execpipe(selmodule_cmd) do |pipe|
-          pipe.each_line do |line|
-            line.chomp!
-            output << line
-            name, version = line.split
-            modules[name] = version
-          end
-        end
-        self.loaded_modules = modules
-      rescue Puppet::ExecutionFailure
-        raise Puppet::Error,
-              _('Could not list policy modules: "%{selmodule_command}" failed with "%{selmod_output}"') %
-                { selmodule_command: selmodule_cmd, selmod_output: output.join(' ') },
-              $ERROR_INFO.backtrace
-      end
-    end
-    self.loaded_modules
-  end
-end

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

@@ -1,105 +0,0 @@
-require 'puppet/provider/parsedfile'
-
-Puppet::Type.type(:ssh_authorized_key).provide(
-  :parsed,
-  :parent         => Puppet::Provider::ParsedFile,
-  :filetype       => :flat,
-  :default_target => ''
-) do
-  desc "Parse and generate authorized_keys files for SSH."
-
-  text_line :comment, :match => /^\s*#/
-  text_line :blank, :match => /^\s*$/
-
-  record_line :parsed,
-    :fields   => %w{options type key name},
-    :optional => %w{options},
-    :rts => /^\s+/,
-    :match    => Puppet::Type.type(:ssh_authorized_key).keyline_regex,
-    :post_parse => proc { |h|
-      h[:name] = "" if h[:name] == :absent
-      h[:options] ||= [:absent]
-      h[:options] = Puppet::Type::Ssh_authorized_key::ProviderParsed.parse_options(h[:options]) if h[:options].is_a? String
-    },
-    :pre_gen => proc { |h|
-      # if this name was generated, don't write it back to disk
-      h[:name] = "" if h[:unnamed]
-      h[:options] = [] if h[:options].include?(:absent)
-      h[:options] = h[:options].join(',')
-    }
-
-  record_line :key_v1,
-    :fields   => %w{options bits exponent modulus name},
-    :optional => %w{options},
-    :rts      => /^\s+/,
-    :match    => /^(?:(.+) )?(\d+) (\d+) (\d+)(?: (.+))?$/
-
-  def dir_perm
-    0700
-  end
-
-  def file_perm
-    0600
-  end
-
-  def user
-    uid = Puppet::FileSystem.stat(target).uid
-    Etc.getpwuid(uid).name
-  end
-
-  def flush
-    raise Puppet::Error, "Cannot write SSH authorized keys without user"    unless @resource.should(:user)
-    raise Puppet::Error, "User '#{@resource.should(:user)}' does not exist" unless Puppet::Util.uid(@resource.should(:user))
-    # ParsedFile usually calls backup_target much later in the flush process,
-    # but our SUID makes that fail to open filebucket files for writing.
-    # Fortunately, there's already logic to make sure it only ever happens once,
-    # so calling it here suppresses the later attempt by our superclass's flush method.
-    self.class.backup_target(target)
-
-    Puppet::Util::SUIDManager.asuser(@resource.should(:user)) do
-        unless Puppet::FileSystem.exist?(dir = File.dirname(target))
-          Puppet.debug "Creating #{dir} as #{@resource.should(:user)}"
-          Dir.mkdir(dir, dir_perm)
-        end
-
-        super
-
-        File.chmod(file_perm, target)
-    end
-  end
-
-  # Parse sshv2 option strings, which is a comma-separated list of
-  # either key="values" elements or bare-word elements
-  def self.parse_options(options)
-    result = []
-    scanner = StringScanner.new(options)
-    while !scanner.eos?
-      scanner.skip(/[ \t]*/)
-      # scan a long option
-      if out = scanner.scan(/[-a-z0-9A-Z_]+=\".*?[^\\]\"/) or out = scanner.scan(/[-a-z0-9A-Z_]+/)
-        result << out
-      else
-        # found an unscannable token, let's abort
-        break
-      end
-      # eat a comma
-      scanner.skip(/[ \t]*,[ \t]*/)
-    end
-    result
-  end
-
-  def self.prefetch_hook(records)
-    name_index = 0
-    records.each do |record|
-      if record[:record_type] == :parsed && record[:name].empty?
-        record[:unnamed] = true
-        # Generate a unique ID for unnamed keys, in case they need purging.
-        # If you change this, you have to keep
-        # Puppet::Type::User#unknown_keys_in_file in sync! (PUP-3357)
-        record[:name] = "#{record[:target]}:unnamed-#{ name_index += 1 }"
-        Puppet.debug("generating name for on-disk ssh_authorized_key #{record[:key]}: #{record[:name]}")
-      end
-    end
-  end
-end
-

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

@@ -1,50 +0,0 @@
-require 'puppet/provider/parsedfile'
-
-Puppet::Type.type(:sshkey).provide(
-  :parsed,
-  :parent => Puppet::Provider::ParsedFile,
-  :filetype => :flat
-) do
-  desc "Parse and generate host-wide known hosts files for SSH."
-
-  text_line :comment, :match => /^#/
-  text_line :blank, :match => /^\s*$/
-
-  record_line :parsed, :fields => %w{name type key},
-    :post_parse => proc { |hash|
-      names = hash[:name].split(",", -1)
-      hash[:name]  = names.shift
-      hash[:host_aliases] = names
-    },
-    :pre_gen => proc { |hash|
-      if hash[:host_aliases]
-        hash[:name] = [hash[:name], hash[:host_aliases]].flatten.join(",")
-        hash.delete(:host_aliases)
-      end
-    }
-
-  # Make sure to use mode 644 if ssh_known_hosts is newly created
-  def self.default_mode
-    0644
-  end
-
-  def self.default_target
-    case Facter.value(:operatingsystem)
-    when "Darwin"
-      # Versions 10.11 and up use /etc/ssh/ssh_known_hosts
-      version = Facter.value(:macosx_productversion_major)
-      if version
-        if Puppet::Util::Package.versioncmp(version, '10.11') >= 0
-          "/etc/ssh/ssh_known_hosts"
-        else
-          "/etc/ssh_known_hosts"
-        end
-      else
-        "/etc/ssh_known_hosts"
-      end
-    else
-      "/etc/ssh/ssh_known_hosts"
-    end
-  end
-end
-

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

@@ -1,28 +0,0 @@
-require 'puppet/provider/cisco'
-
-Puppet::Type.type(:vlan).provide :cisco, :parent => Puppet::Provider::Cisco do
-
-  desc "Cisco switch/router provider for vlans."
-
-  mk_resource_methods
-
-  def self.lookup(device, id)
-    vlans = {}
-    device.command do |dev|
-      vlans = dev.parse_vlans || {}
-    end
-    vlans[id]
-  end
-
-  def initialize(device, *args)
-    super
-  end
-
-  # Clear out the cached values.
-  def flush
-    device.command do |dev|
-      dev.update_vlan(resource[:name], former_properties, properties)
-    end
-    super
-  end
-end

data/lib/puppet/provider/yumrepo/inifile.rb

@@ -1,315 +0,0 @@
-require 'puppet/util/inifile'
-
-Puppet::Type.type(:yumrepo).provide(:inifile) do
-  desc <<-EOD
-    Manage yum repo configurations by parsing yum INI configuration files.
-
-    ### Fetching instances
-
-    When fetching repo instances, directory entries in '/etc/yum/repos.d',
-    '/etc/yum.repos.d', and the directory optionally specified by the reposdir
-    key in '/etc/yum.conf' will be checked. If a given directory does not exist it
-    will be ignored. In addition, all sections in '/etc/yum.conf' aside from
-    'main' will be created as sections.
-
-    ### Storing instances
-
-    When creating a new repository, a new section will be added in the first
-    yum repo directory that exists. The custom directory specified by the
-    '/etc/yum.conf' reposdir property is checked first, followed by
-    '/etc/yum/repos.d', and then '/etc/yum.repos.d'. If none of these exist, the
-    section will be created in '/etc/yum.conf'.
-  EOD
-
-  PROPERTIES = Puppet::Type.type(:yumrepo).validproperties
-
-  # Retrieve all providers based on existing yum repositories
-  #
-  # @api public
-  # @return [Array<Puppet::Provider>] providers generated from existing yum
-  #   repository definitions.
-  def self.instances
-    instances = []
-
-    virtual_inifile.each_section do |section|
-      # Ignore the 'main' section in yum.conf since it's not a repository.
-      next if section.name == "main"
-
-      attributes_hash = {:name => section.name, :ensure => :present, :provider => :yumrepo}
-
-      section.entries.each do |key, value|
-        key = key.to_sym
-        if valid_property?(key)
-          attributes_hash[key] = value
-        elsif key == :name
-          attributes_hash[:descr] = value
-        end
-      end
-      instances << new(attributes_hash)
-    end
-
-    instances
-  end
-
-  # Match catalog type instances to provider instances.
-  #
-  # @api public
-  # @param resources [Array<Puppet::Type::Yumrepo>] Resources to prefetch.
-  # @return [void]
-  def self.prefetch(resources)
-    repos = instances
-    resources.each_key do |name|
-      if provider = repos.find { |repo| repo.name == name }
-        resources[name].provider = provider
-      end
-    end
-  end
-
-  # Return a list of existing directories that could contain repo files.
-  #
-  # @api private
-  # @param conf [String] Configuration file to look for directories in.
-  # @param dirs [Array<String>] Default locations for yum repos.
-  # @return [Array<String>] All present directories that may contain yum repo configs.
-  def self.reposdir(conf='/etc/yum.conf', dirs=['/etc/yum.repos.d', '/etc/yum/repos.d'])
-    reposdir = find_conf_value('reposdir', conf)
-    # Use directories in reposdir if they are set instead of default
-    if reposdir
-      # Follow the code from the yum/config.py
-      reposdir.tr!("\n", ' ')
-      reposdir.tr!(',', ' ')
-      dirs = reposdir.split
-    end
-    dirs.select! { |dir| Puppet::FileSystem.exist?(dir) }
-    if dirs.empty?
-      Puppet.debug('No yum directories were found on the local filesystem')
-    end
-
-    dirs
-  end
-
-  # Used for testing only
-  # @api private
-  def self.clear
-    @virtual = nil
-  end
-
-  # Helper method to look up specific values in ini style files.
-  #
-  # @api private
-  # @param value [String] Value to look for in the configuration file.
-  # @param conf [String] Configuration file to check for value.
-  # @return [String] The value of a looked up key from the configuration file.
-  def self.find_conf_value(value, conf='/etc/yum.conf')
-    if Puppet::FileSystem.exist?(conf)
-      file = Puppet::Util::IniConfig::PhysicalFile.new(conf)
-      file.read
-      if (main = file.get_section('main'))
-        main[value]
-      end
-    end
-  end
-
-  # Enumerate all files that may contain yum repository configs.
-  # '/etc/yum.conf' is always included.
-  #
-  # @api private
-  # @return [Array<String>
-  def self.repofiles
-    files = ["/etc/yum.conf"]
-    reposdir.each do |dir|
-      Dir.glob("#{dir}/*.repo").each do |file|
-        files << file
-      end
-    end
-
-    files
-  end
-
-  # Build a virtual inifile by reading in numerous .repo files into a single
-  # virtual file to ease manipulation.
-  # @api private
-  # @return [Puppet::Util::IniConfig::File] The virtual inifile representing
-  #   multiple real files.
-  def self.virtual_inifile
-    unless @virtual
-      @virtual = Puppet::Util::IniConfig::File.new
-      self.repofiles.each do |file|
-        @virtual.read(file) if Puppet::FileSystem.file?(file)
-      end
-    end
-    return @virtual
-  end
-
-  # Is the given key a valid type property?
-  #
-  # @api private
-  # @param key [String] The property to look up.
-  # @return [Boolean] Returns true if the property is defined in the type.
-  def self.valid_property?(key)
-    PROPERTIES.include?(key)
-  end
-
-  # Return an existing INI section or create a new section in the default location
-  #
-  # The default location is determined based on what yum repo directories
-  # and files are present. If /etc/yum.conf has a value for 'reposdir' then that
-  # is preferred. If no such INI property is found then the first default yum
-  # repo directory that is present is used. If no default directories exist then
-  # /etc/yum.conf is used.
-  #
-  # @param name [String] Section name to lookup in the virtual inifile.
-  # @return [Puppet::Util::IniConfig] The IniConfig section
-  def self.section(name)
-    result = self.virtual_inifile[name]
-    # Create a new section if not found.
-    unless result
-      path = getRepoPath(name)
-      result = self.virtual_inifile.add_section(name, path)
-    end
-    result
-  end
-
-  # Save all yum repository files and force the mode to 0644
-  # @api private
-  # @return [void]
-  def self.store(resource)
-    inifile = self.virtual_inifile
-    inifile.store
-
-    target_mode = 0644
-    inifile.each_file do |file|
-      next unless Puppet::FileSystem.exist?(file)
-      current_mode = Puppet::FileSystem.stat(file).mode & 0777
-      unless current_mode == target_mode
-        resource.info _("changing mode of %{file} from %{current_mode} to %{target_mode}") %
-                          { file: file, current_mode: "%03o" % current_mode, target_mode: "%03o" % target_mode }
-        Puppet::FileSystem.chmod(target_mode, file)
-      end
-    end
-  end
-
-  def self.getRepoPath(name)
-    dirs = reposdir()
-    if dirs.empty?
-      # If no repo directories are present, default to using yum.conf.
-      path = '/etc/yum.conf'
-    else
-      # The ordering of reposdir is [defaults, custom], and we want to use
-      # the custom directory if present.
-      path = File.join(dirs.last, "#{name}.repo")
-    end
-    path
-  end
-
-  # Create a new section for the given repository and set all the specified
-  # properties in the section.
-  #
-  # @api public
-  # @return [void]
-  def create
-    @property_hash[:ensure] = :present
-
-    # Check to see if the file that would be created in the
-    # default location for the yumrepo already exists on disk.
-    # If it does, read it in to the virtual inifile
-    path = self.class.getRepoPath(name)
-    self.class.virtual_inifile.read(path) if Puppet::FileSystem.file?(path)
-
-    # We fetch a list of properties from the type, then iterate
-    # over them, avoiding ensure.  We're relying on .should to
-    # check if the property has been set and should be modified,
-    # and if so we set it in the virtual inifile.
-    PROPERTIES.each do |property|
-      next if property == :ensure
-
-      if value = @resource.should(property)
-        self.send("#{property}=", value)
-      end
-    end
-  end
-
-  # Does the given repository already exist?
-  #
-  # @api public
-  # @return [Boolean]
-  def exists?
-    @property_hash[:ensure] == :present
-  end
-
-  # Mark the given repository section for destruction.
-  #
-  # The actual removal of the section will be handled by {#flush} after the
-  # resource has been fully evaluated.
-  #
-  # @api public
-  # @return [void]
-  def destroy
-    # Flag file for deletion on flush.
-    current_section.destroy=(true)
-
-    @property_hash.clear
-  end
-
-  # Finalize the application of the given resource.
-  #
-  # @api public
-  # @return [void]
-  def flush
-    self.class.store(self)
-  end
-
-  # Generate setters and getters for our INI properties.
-  PROPERTIES.each do |property|
-    # The ensure property uses #create, #exists, and #destroy we can't generate
-    # meaningful setters and getters for this
-    next if property == :ensure
-
-    define_method(property) do
-      get_property(property)
-    end
-
-    define_method("#{property}=") do |value|
-      set_property(property, value)
-    end
-  end
-
-  # Map the yumrepo 'descr' type property to the 'name' INI property.
-  def descr
-    if ! @property_hash.has_key?(:descr)
-      @property_hash[:descr] = current_section['name']
-    end
-    value = @property_hash[:descr]
-    value.nil? ? :absent : value
-  end
-
-  def descr=(value)
-    value = (value == :absent ? nil : value)
-    current_section['name'] = value
-    @property_hash[:descr] = value
-  end
-
-  private
-
-  def get_property(property)
-    if ! @property_hash.has_key?(property)
-      @property_hash[property] = current_section[property.to_s]
-    end
-    value = @property_hash[property]
-    value.nil? ? :absent : value
-  end
-
-  def set_property(property, value)
-    value = (value == :absent ? nil : value)
-    current_section[property.to_s] = value
-    @property_hash[property] = value
-  end
-
-  def section(name)
-    self.class.section(name)
-  end
-
-  def current_section
-    self.class.section(self.name)
-  end
-end