openvox 7.37.1

data/lib/puppet/util/filetype.rb

@@ -0,0 +1,358 @@
+# Basic classes for reading, writing, and emptying files.  Not much
+# to see here.
+
+require_relative '../../puppet/util/selinux'
+require 'tempfile'
+require 'fileutils'
+
+class Puppet::Util::FileType
+  attr_accessor :loaded, :path, :synced
+
+  class FileReadError < Puppet::Error; end
+
+  include Puppet::Util::SELinux
+
+  class << self
+    attr_accessor :name
+    include Puppet::Util::ClassGen
+  end
+
+  # Create a new filetype.
+  def self.newfiletype(name, &block)
+    @filetypes ||= {}
+
+    klass = genclass(
+      name,
+      :block => block,
+      :prefix => "FileType",
+      :hash => @filetypes
+    )
+
+    # Rename the read and write methods, so that we're sure they
+    # maintain the stats.
+    klass.class_eval do
+      # Rename the read method
+      define_method(:real_read, instance_method(:read))
+      define_method(:read) do
+        begin
+          val = real_read
+          @loaded = Time.now
+          if val
+            return val.gsub(/# HEADER.*\n/,'')
+          else
+            return ""
+          end
+        rescue Puppet::Error
+          raise
+        rescue => detail
+          message = _("%{klass} could not read %{path}: %{detail}") % { klass: self.class, path: @path, detail: detail }
+          Puppet.log_exception(detail, message)
+          raise Puppet::Error, message, detail.backtrace
+        end
+      end
+
+      # And then the write method
+      define_method(:real_write, instance_method(:write))
+      define_method(:write) do |text|
+        begin
+          val = real_write(text)
+          @synced = Time.now
+          return val
+        rescue Puppet::Error
+          raise
+        rescue => detail
+          message = _("%{klass} could not write %{path}: %{detail}") % { klass: self.class, path: @path, detail: detail }
+          Puppet.log_exception(detail, message)
+          raise Puppet::Error, message, detail.backtrace
+        end
+      end
+    end
+  end
+
+  def self.filetype(type)
+    @filetypes[type]
+  end
+
+  # Pick or create a filebucket to use.
+  def bucket
+    @bucket ||= Puppet::Type.type(:filebucket).mkdefaultbucket.bucket
+  end
+
+  def initialize(path, default_mode = nil)
+    raise ArgumentError.new(_("Path is nil")) if path.nil?
+    @path = path
+    @default_mode = default_mode
+  end
+
+  # Arguments that will be passed to the execute method. Will set the uid
+  # to the target user if the target user and the current user are not
+  # the same
+  def cronargs
+    uid = Puppet::Util.uid(@path)
+    if uid && uid == Puppet::Util::SUIDManager.uid
+      {:failonfail => true, :combine => true}
+    else
+      {:failonfail => true, :combine => true, :uid => @path}
+    end
+  end
+
+  # Operate on plain files.
+  newfiletype(:flat) do
+    # Back the file up before replacing it.
+    def backup
+      bucket.backup(@path) if Puppet::FileSystem.exist?(@path)
+    end
+
+    # Read the file.
+    def read
+      if Puppet::FileSystem.exist?(@path)
+        # this code path is used by many callers so the original default is
+        # being explicitly preserved
+        Puppet::FileSystem.read(@path, :encoding => Encoding.default_external)
+      else
+        return nil
+      end
+    end
+
+    # Remove the file.
+    def remove
+      Puppet::FileSystem.unlink(@path) if Puppet::FileSystem.exist?(@path)
+    end
+
+    # Overwrite the file.
+    def write(text)
+      # this file is managed by the OS and should be using system encoding
+      tf = Tempfile.new("puppet", :encoding => Encoding.default_external)
+      tf.print text; tf.flush
+      File.chmod(@default_mode, tf.path) if @default_mode
+      FileUtils.cp(tf.path, @path)
+      tf.close
+      # If SELinux is present, we need to ensure the file has its expected context
+      set_selinux_default_context(@path)
+    end
+  end
+
+  # Operate on plain files.
+  newfiletype(:ram) do
+    @@tabs = {}
+
+    def self.clear
+      @@tabs.clear
+    end
+
+    def initialize(path, default_mode = nil)
+      # default_mode is meaningless for this filetype,
+      # supported only for compatibility with :flat
+      super
+      @@tabs[@path] ||= ""
+    end
+
+    # Read the file.
+    def read
+      Puppet.info _("Reading %{path} from RAM") % { path: @path }
+      @@tabs[@path]
+    end
+
+    # Remove the file.
+    def remove
+      Puppet.info _("Removing %{path} from RAM") % { path: @path }
+      @@tabs[@path] = ""
+    end
+
+    # Overwrite the file.
+    def write(text)
+      Puppet.info _("Writing %{path} to RAM") % { path: @path }
+      @@tabs[@path] = text
+    end
+  end
+
+  # Handle Linux-style cron tabs.
+  #
+  # TODO: We can possibly eliminate the "-u <username>" option in cmdbase
+  # by just running crontab under <username>'s uid (like we do for suntab
+  # and aixtab). It may be worth investigating this alternative
+  # implementation in the future. This way, we can refactor all three of
+  # our cron file types into a common crontab file type.
+  newfiletype(:crontab) do
+    def initialize(user)
+      self.path = user
+    end
+
+    def path=(user)
+      begin
+        @uid = Puppet::Util.uid(user)
+      rescue Puppet::Error => detail
+        raise FileReadError, _("Could not retrieve user %{user}: %{detail}") % { user: user, detail: detail }, detail.backtrace
+      end
+
+      # XXX We have to have the user name, not the uid, because some
+      # systems *cough*linux*cough* require it that way
+      @path = user
+    end
+
+    # Read a specific @path's cron tab.
+    def read
+      unless Puppet::Util.uid(@path)
+        Puppet.debug _("The %{path} user does not exist. Treating their crontab file as empty in case Puppet creates them in the middle of the run.") % { path: @path }
+
+        return ""
+      end
+
+      Puppet::Util::Execution.execute("#{cmdbase} -l", failonfail: true, combine: true)
+    rescue => detail
+      case detail.to_s
+      when /no crontab for/
+        return ""
+      when /are not allowed to/
+        Puppet.debug _("The %{path} user is not authorized to use cron. Their crontab file is treated as empty in case Puppet authorizes them in the middle of the run (by, for example, modifying the cron.deny or cron.allow files).") % { path: @path }
+
+        return ""
+      else
+        raise FileReadError, _("Could not read crontab for %{path}: %{detail}") % { path: @path, detail: detail }, detail.backtrace
+      end
+    end
+
+    # Remove a specific @path's cron tab.
+    def remove
+      cmd = "#{cmdbase} -r"
+      if %w{Darwin FreeBSD DragonFly}.include?(Puppet.runtime[:facter].value("operatingsystem"))
+        cmd = "/bin/echo yes | #{cmd}"
+      end
+
+      Puppet::Util::Execution.execute(cmd, failonfail: true, combine: true)
+    end
+
+    # Overwrite a specific @path's cron tab; must be passed the @path name
+    # and the text with which to create the cron tab.
+    #
+    # TODO: We should refactor this at some point to make it identical to the
+    # :aixtab and :suntab's write methods so that, at the very least, the pipe
+    # is not created and the crontab command's errors are not swallowed.
+    def write(text)
+      unless Puppet::Util.uid(@path)
+        raise Puppet::Error, _("Cannot write the %{path} user's crontab: The user does not exist") % { path: @path }
+      end
+
+      # this file is managed by the OS and should be using system encoding
+      IO.popen("#{cmdbase()} -", "w", :encoding => Encoding.default_external) { |p|
+        p.print text
+      }
+    end
+
+    private
+
+    # Only add the -u flag when the @path is different.  Fedora apparently
+    # does not think I should be allowed to set the @path to my own user name
+    def cmdbase
+      if @uid == Puppet::Util::SUIDManager.uid || Puppet.runtime[:facter].value(:operatingsystem) == "HP-UX"
+        return "crontab"
+      else
+        return "crontab -u #{@path}"
+      end
+    end
+  end
+
+  # SunOS has completely different cron commands; this class implements
+  # its versions.
+  newfiletype(:suntab) do
+    # Read a specific @path's cron tab.
+    def read
+      unless Puppet::Util.uid(@path)
+        Puppet.debug _("The %{path} user does not exist. Treating their crontab file as empty in case Puppet creates them in the middle of the run.") % { path: @path }
+
+        return ""
+      end
+
+      Puppet::Util::Execution.execute(%w{crontab -l}, cronargs)
+    rescue => detail
+      case detail.to_s
+      when /can't open your crontab/
+        return ""
+      when /you are not authorized to use cron/
+        Puppet.debug _("The %{path} user is not authorized to use cron. Their crontab file is treated as empty in case Puppet authorizes them in the middle of the run (by, for example, modifying the cron.deny or cron.allow files).") % { path: @path }
+
+        return ""
+      else
+        raise FileReadError, _("Could not read crontab for %{path}: %{detail}") % { path: @path, detail: detail }, detail.backtrace
+      end
+    end
+
+    # Remove a specific @path's cron tab.
+    def remove
+      Puppet::Util::Execution.execute(%w{crontab -r}, cronargs)
+    rescue => detail
+      raise FileReadError, _("Could not remove crontab for %{path}: %{detail}") % { path: @path, detail: detail }, detail.backtrace
+    end
+
+    # Overwrite a specific @path's cron tab; must be passed the @path name
+    # and the text with which to create the cron tab.
+    def write(text)
+      # this file is managed by the OS and should be using system encoding
+      output_file = Tempfile.new("puppet_suntab", :encoding => Encoding.default_external)
+      begin
+        output_file.print text
+        output_file.close
+        # We have to chown the stupid file to the user.
+        File.chown(Puppet::Util.uid(@path), nil, output_file.path)
+        Puppet::Util::Execution.execute(["crontab", output_file.path], cronargs)
+      rescue => detail
+        raise FileReadError, _("Could not write crontab for %{path}: %{detail}") % { path: @path, detail: detail }, detail.backtrace
+      ensure
+        output_file.close
+        output_file.unlink
+      end
+    end
+  end
+
+  #  Support for AIX crontab with output different than suntab's crontab command.
+  newfiletype(:aixtab) do
+    # Read a specific @path's cron tab.
+    def read
+      unless Puppet::Util.uid(@path)
+        Puppet.debug _("The %{path} user does not exist. Treating their crontab file as empty in case Puppet creates them in the middle of the run.") % { path: @path }
+
+        return ""
+      end
+
+      Puppet::Util::Execution.execute(%w{crontab -l}, cronargs)
+    rescue => detail
+      case detail.to_s
+      when /open.*in.*directory/
+        return ""
+      when /not.*authorized.*cron/
+        Puppet.debug _("The %{path} user is not authorized to use cron. Their crontab file is treated as empty in case Puppet authorizes them in the middle of the run (by, for example, modifying the cron.deny or cron.allow files).") % { path: @path }
+
+        return ""
+      else
+        raise FileReadError, _("Could not read crontab for %{path}: %{detail}") % { path: @path, detail: detail }, detail.backtrace
+      end
+    end
+
+    # Remove a specific @path's cron tab.
+    def remove
+      Puppet::Util::Execution.execute(%w{crontab -r}, cronargs)
+    rescue => detail
+      raise FileReadError, _("Could not remove crontab for %{path}: %{detail}") % { path: @path, detail: detail }, detail.backtrace
+    end
+
+    # Overwrite a specific @path's cron tab; must be passed the @path name
+    # and the text with which to create the cron tab.
+    def write(text)
+      # this file is managed by the OS and should be using system encoding
+      output_file = Tempfile.new("puppet_aixtab", :encoding => Encoding.default_external)
+
+      begin
+        output_file.print text
+        output_file.close
+        # We have to chown the stupid file to the user.
+        File.chown(Puppet::Util.uid(@path), nil, output_file.path)
+        Puppet::Util::Execution.execute(["crontab", output_file.path], cronargs)
+      rescue => detail
+        raise FileReadError, _("Could not write crontab for %{path}: %{detail}") % { path: @path, detail: detail }, detail.backtrace
+      ensure
+        output_file.close
+        output_file.unlink
+      end
+    end
+  end
+end

data/lib/puppet/util/http_proxy.rb

@@ -0,0 +1,4 @@
+require_relative '../../puppet/http'
+
+# for backwards compatibility
+Puppet::Util::HttpProxy = Puppet::HTTP::Proxy

data/lib/puppet/util/inifile.rb

@@ -0,0 +1,340 @@
+# Module Puppet::IniConfig
+# A generic way to parse .ini style files and manipulate them in memory
+# One 'file' can be made up of several physical files. Changes to sections
+# on the file are tracked so that only the physical files in which
+# something has changed are written back to disk
+# Great care is taken to preserve comments and blank lines from the original
+# files
+#
+# The parsing tries to stay close to python's ConfigParser
+
+require_relative '../../puppet/util/filetype'
+require_relative '../../puppet/error'
+
+module Puppet::Util::IniConfig
+  # A section in a .ini file
+  class Section
+    attr_reader :name, :file, :entries
+    attr_writer :destroy
+
+    def initialize(name, file)
+      @name = name
+      @file = file
+      @dirty = false
+      @entries = []
+      @destroy = false
+    end
+
+    # Does this section need to be updated in/removed from the associated file?
+    #
+    # @note This section is dirty if a key has been modified _or_ if the
+    #   section has been modified so the associated file can be rewritten
+    #   without this section.
+    def dirty?
+      @dirty or @destroy
+    end
+
+    def mark_dirty
+      @dirty = true
+    end
+
+    # Should only be used internally
+    def mark_clean
+      @dirty = false
+    end
+
+    # Should the file be destroyed?
+    def destroy?
+      @destroy
+    end
+
+    # Add a line of text (e.g., a comment) Such lines
+    # will be written back out in exactly the same
+    # place they were read in
+    def add_line(line)
+      @entries << line
+    end
+
+    # Set the entry 'key=value'. If no entry with the
+    # given key exists, one is appended to the end of the section
+    def []=(key, value)
+      entry = find_entry(key)
+      @dirty = true
+      if entry.nil?
+        @entries << [key, value]
+      else
+        entry[1] = value
+      end
+    end
+
+    # Return the value associated with KEY. If no such entry
+    # exists, return nil
+    def [](key)
+      entry = find_entry(key)
+      return(entry.nil? ? nil : entry[1])
+    end
+
+    # Format the section as text in the way it should be
+    # written to file
+    def format
+      if @destroy
+        text = ""
+      else
+        text = "[#{name}]\n"
+        @entries.each do |entry|
+          if entry.is_a?(Array)
+            key, value = entry
+            text << "#{key}=#{value}\n" unless value.nil?
+          else
+            text << entry
+          end
+        end
+      end
+      text
+    end
+
+    private
+    def find_entry(key)
+      @entries.each do |entry|
+        return entry if entry.is_a?(Array) && entry[0] == key
+      end
+      nil
+    end
+
+  end
+
+  class PhysicalFile
+
+    # @!attribute [r] filetype
+    #   @api private
+    #   @return [Puppet::Util::FileType::FileTypeFlat]
+    attr_reader :filetype
+
+    # @!attribute [r] contents
+    #   @api private
+    #   @return [Array<String, Puppet::Util::IniConfig::Section>]
+    attr_reader :contents
+
+    # @!attribute [rw] destroy_empty
+    #   Whether empty files should be removed if no sections are defined.
+    #   Defaults to false
+    attr_accessor :destroy_empty
+
+    # @!attribute [rw] file_collection
+    #   @return [Puppet::Util::IniConfig::FileCollection]
+    attr_accessor :file_collection
+
+    def initialize(file, options = {})
+      @file = file
+      @contents = []
+      @filetype = Puppet::Util::FileType.filetype(:flat).new(file)
+
+      @destroy_empty = options.fetch(:destroy_empty, false)
+    end
+
+    # Read and parse the on-disk file associated with this object
+    def read
+      text = @filetype.read
+      if text.nil?
+        raise IniParseError, _("Cannot read nonexistent file %{file}") % { file: @file.inspect }
+      end
+      parse(text)
+    end
+
+    INI_COMMENT = Regexp.union(
+      /^\s*$/,
+      /^[#;]/,
+      /^\s*rem\s/i
+    )
+    INI_CONTINUATION = /^[ \t\r\n\f]/
+    INI_SECTION_NAME = /^\[([^\]]+)\]/
+    INI_PROPERTY     = /^\s*([^\s=]+)\s*\=\s*(.*)$/
+
+    # @api private
+    def parse(text)
+      section = nil   # The name of the current section
+      optname = nil   # The name of the last option in section
+      line_num = 0
+
+      text.each_line do |l|
+        line_num += 1
+        if l.match(INI_COMMENT)
+          # Whitespace or comment
+          if section.nil?
+            @contents << l
+          else
+            section.add_line(l)
+          end
+        elsif l.match(INI_CONTINUATION) && section && optname
+          # continuation line
+          section[optname] += "\n#{l.chomp}"
+        elsif (match = l.match(INI_SECTION_NAME))
+          # section heading
+          section.mark_clean if section
+
+          section_name = match[1]
+
+          section = add_section(section_name)
+          optname = nil
+        elsif (match = l.match(INI_PROPERTY))
+          # the regex strips leading white space from the value, and here we strip the trailing white space as well
+          key = match[1]
+          val = match[2].rstrip
+
+          if section.nil?
+            raise IniParseError.new(_("Property with key %{key} outside of a section") % { key: key.inspect })
+          end
+
+          section[key] = val
+          optname = key
+        else
+          raise IniParseError.new(_("Can't parse line '%{line}'") % { line: l.chomp }, @file, line_num)
+        end
+      end
+      section.mark_clean unless section.nil?
+    end
+
+    # @return [Array<Puppet::Util::IniConfig::Section>] All sections defined in
+    #   this file.
+    def sections
+      @contents.select { |entry| entry.is_a? Section }
+    end
+
+    # @return [Puppet::Util::IniConfig::Section, nil] The section with the
+    #   given name if it exists, else nil.
+    def get_section(name)
+      @contents.find { |entry| entry.is_a? Section and entry.name == name }
+    end
+
+    def format
+      text = ""
+
+      @contents.each do |content|
+        if content.is_a? Section
+          text << content.format
+        else
+          text << content
+        end
+      end
+
+      text
+    end
+
+    def store
+      if @destroy_empty and (sections.empty? or sections.all?(&:destroy?))
+        ::File.unlink(@file)
+      elsif sections.any?(&:dirty?)
+        text = self.format
+        @filetype.write(text)
+      end
+      sections.each(&:mark_clean)
+    end
+
+    # Create a new section and store it in the file contents
+    #
+    # @api private
+    # @param name [String] The name of the section to create
+    # @return [Puppet::Util::IniConfig::Section]
+    def add_section(name)
+      if section_exists?(name)
+        raise IniParseError.new(_("Section %{name} is already defined, cannot redefine") % { name: name.inspect }, @file)
+      end
+
+      section = Section.new(name, @file)
+      @contents << section
+
+      section
+    end
+
+    private
+
+    def section_exists?(name)
+      if self.get_section(name)
+        true
+      elsif @file_collection and @file_collection.get_section(name)
+        true
+      else
+        false
+      end
+    end
+  end
+
+  class FileCollection
+
+    attr_reader :files
+
+    def initialize
+      @files = {}
+    end
+
+    # Read and parse a file and store it in the collection. If the file has
+    # already been read it will be destroyed and re-read.
+    def read(file)
+      new_physical_file(file).read
+    end
+
+    def store
+      @files.values.each do |file|
+        file.store
+      end
+    end
+
+    def each_section(&block)
+      @files.values.each do |file|
+        file.sections.each do |section|
+          yield section
+        end
+      end
+    end
+
+    def each_file(&block)
+      @files.keys.each do |path|
+        yield path
+      end
+    end
+
+    def get_section(name)
+      sect = nil
+      @files.values.each do |file|
+        if (current = file.get_section(name))
+          sect = current
+        end
+      end
+      sect
+    end
+    alias [] get_section
+
+    def include?(name)
+      !! get_section(name)
+    end
+
+    def add_section(name, file)
+      get_physical_file(file).add_section(name)
+    end
+
+    private
+
+    # Return a file if it's already been defined, create a new file if it hasn't
+    # been defined.
+    def get_physical_file(file)
+      if @files[file]
+        @files[file]
+      else
+        new_physical_file(file)
+      end
+    end
+
+    # Create a new physical file and set required attributes on that file.
+    def new_physical_file(file)
+      @files[file] = PhysicalFile.new(file)
+      @files[file].file_collection = self
+      @files[file]
+    end
+  end
+
+  File = FileCollection
+
+  class IniParseError < Puppet::Error
+    include Puppet::ExternalFileError
+  end
+end