puppet 3.4.3 → 3.5.0.rc1

data/lib/puppet/settings/base_setting.rb

@@ -72,14 +72,15 @@ class Puppet::Settings::BaseSetting
     end
   end
 
-  def has_hook?
-    respond_to? :handle
-  end
-
   def hook=(block)
+    @has_hook = true
     meta_def :handle, &block
   end
 
+  def has_hook?
+    @has_hook
+  end
+
   # Create the new element.  Pretty much just sets the name.
   def initialize(args = {})
     unless @settings = args.delete(:settings)
@@ -92,6 +93,7 @@ class Puppet::Settings::BaseSetting
 
     #set the default value for call_hook
     @call_hook = :on_write_only if args[:hook] and not args[:call_hook]
+    @has_hook = false
 
     raise ArgumentError, "Cannot reference :call_hook for :#{@name} if no :hook is defined" if args[:call_hook] and not args[:hook]
 
@@ -159,4 +161,8 @@ class Puppet::Settings::BaseSetting
   def munge(value)
     value
   end
+
+  def set_meta(meta)
+    Puppet.notice("#{name} does not support meta data. Ignoring.")
+  end
 end

data/lib/puppet/settings/config_file.rb

@@ -1,3 +1,5 @@
+require 'puppet/settings/ini_file'
+
 ##
 # @api private
 #
@@ -13,65 +15,100 @@ class Puppet::Settings::ConfigFile
   end
 
   def parse_file(file, text)
-    result = {}
-    count = 0
-
-    # Default to 'main' for the section.
-    section_name = :main
-    result[section_name] = empty_section
-    text.split(/\n/).each do |line|
-      count += 1
-      case line
-      when /^\s*\[(\w+)\]\s*$/
-        section_name = $1.intern
-        fail_when_illegal_section_name(section_name, file, line)
-        if result[section_name].nil?
-          result[section_name] = empty_section
-        end
-      when /^\s*#/; next # Skip comments
-      when /^\s*$/; next # Skip blanks
-      when /^\s*(\w+)\s*=\s*(.*?)\s*$/ # settings
-        var = $1.intern
-
-        # We don't want to munge modes, because they're specified in octal, so we'll
-        # just leave them as a String, since Puppet handles that case correctly.
-        if var == :mode
-          value = $2
-        else
-          value = @value_converter[$2]
-        end
+    result = Conf.new
 
-        # Check to see if this is a file argument and it has extra options
-        begin
-          if value.is_a?(String) and options = extract_fileinfo(value)
-            value = options[:value]
-            options.delete(:value)
-            result[section_name][:_meta][var] = options
-          end
-          result[section_name][var] = value
-        rescue Puppet::Error => detail
-          raise Puppet::Settings::ParseError.new(detail.message, file, line, detail)
+    ini = Puppet::Settings::IniFile.parse(StringIO.new(text))
+    unique_sections_in(ini, file).each do |section_name|
+      section = Section.new(section_name.to_sym)
+      result.with_section(section)
+
+      ini.lines_in(section_name).each do |line|
+        if line.is_a?(Puppet::Settings::IniFile::SettingLine)
+          parse_setting(line, section)
+        elsif line.text !~ /^\s*#|^\s*$/
+          raise Puppet::Settings::ParseError.new("Could not match line #{line.text}", file, line.line_number)
         end
-      else
-        raise Puppet::Settings::ParseError.new("Could not match line #{line}", file, line)
       end
     end
 
     result
   end
 
+  Conf = Struct.new(:sections) do
+    def initialize
+      super({})
+    end
+
+    def with_section(section)
+      sections[section.name] = section
+      self
+    end
+  end
+
+  Section = Struct.new(:name, :settings) do
+    def initialize(name)
+      super(name, [])
+    end
+
+    def with_setting(name, value, meta)
+      settings << Setting.new(name, value, meta)
+      self
+    end
+
+    def setting(name)
+      settings.find { |setting| setting.name == name }
+    end
+  end
+
+  Setting = Struct.new(:name, :value, :meta) do
+    def has_metadata?
+      meta != NO_META
+    end
+  end
+
+  Meta = Struct.new(:owner, :group, :mode)
+  NO_META = Meta.new(nil, nil, nil)
+
 private
 
-  def empty_section
-    { :_meta => {} }
+  def unique_sections_in(ini, file)
+    ini.section_lines.collect do |section|
+      if section.name == "application_defaults" || section.name == "global_defaults"
+        raise Puppet::Error, "Illegal section '#{section.name}' in config file #{file} at line #{section.line_number}"
+      end
+      section.name
+    end.uniq
   end
 
-  def fail_when_illegal_section_name(section, file, line)
-    if section == :application_defaults or section == :global_defaults
-      raise Puppet::Error, "Illegal section '#{section}' in config file #{file} at line #{line}"
+  def parse_setting(setting, section)
+    var = setting.name.intern
+
+    # We don't want to munge modes, because they're specified in octal, so we'll
+    # just leave them as a String, since Puppet handles that case correctly.
+    if var == :mode
+      value = setting.value
+    else
+      value = @value_converter[setting.value]
+    end
+
+    # Check to see if this is a file argument and it has extra options
+    begin
+      if value.is_a?(String) and options = extract_fileinfo(value)
+        section.with_setting(var, options[:value], Meta.new(options[:owner],
+                                                            options[:group],
+                                                            options[:mode]))
+      else
+        section.with_setting(var, value, NO_META)
+      end
+    rescue Puppet::Error => detail
+      raise Puppet::Settings::ParseError.new(detail.message, file, setting.line_number, detail)
     end
   end
 
+  def empty_section
+    { :_meta => {} }
+  end
+
   def extract_fileinfo(string)
     result = {}
     value = string.sub(/\{\s*([^}]+)\s*\}/) do

data/lib/puppet/settings/directory_setting.rb

@@ -5,9 +5,8 @@ class Puppet::Settings::DirectorySetting < Puppet::Settings::FileSetting
 
   # @api private
   def open_file(filename, option = 'r', &block)
-    file = Puppet::FileSystem::File.new(filename)
     controlled_access do |mode|
-      file.open(mode, option, &block)
+      Puppet::FileSystem.open(filename, mode, option, &block)
     end
   end
 end

data/lib/puppet/settings/file_setting.rb

@@ -106,6 +106,12 @@ class Puppet::Settings::FileSetting < Puppet::Settings::StringSetting
     @owner.value
   end
 
+  def set_meta(meta)
+    self.owner = meta.owner if meta.owner
+    self.group = meta.group if meta.group
+    self.mode = meta.mode if meta.mode
+  end
+
   def munge(value)
     if value.is_a?(String) and value != ':memory:' # for sqlite3 in-memory tests
       value = File.expand_path(value)
@@ -128,7 +134,7 @@ class Puppet::Settings::FileSetting < Puppet::Settings::StringSetting
     # Make sure the paths are fully qualified.
     path = File.expand_path(path)
 
-    return nil unless type == :directory or create_files? or Puppet::FileSystem::File.exist?(path)
+    return nil unless type == :directory or create_files? or Puppet::FileSystem.exist?(path)
     return nil if path =~ /^\/dev/ or path =~ /^[A-Z]:\/dev/i
 
     resource = Puppet::Resource.new(:file, path)
@@ -181,20 +187,21 @@ class Puppet::Settings::FileSetting < Puppet::Settings::StringSetting
   # @api private
   def exclusive_open(option = 'r', &block)
     controlled_access do |mode|
-      file.exclusive_open(mode, option, &block)
+      Puppet::FileSystem.exclusive_open(file(), mode, option, &block)
     end
   end
 
   # @api private
   def open(option = 'r', &block)
     controlled_access do |mode|
-      file.open(mode, option, &block)
+      Puppet::FileSystem.open(file, mode, option, &block)
     end
   end
 
-private
+  private
+
   def file
-    Puppet::FileSystem::File.new(value)
+    Puppet::FileSystem.pathname(value)
   end
 
   def unknown_value(parameter, value)

data/lib/puppet/settings/ini_file.rb

@@ -0,0 +1,171 @@
+# @api private
+class Puppet::Settings::IniFile
+  DEFAULT_SECTION_NAME = "main"
+
+  def self.update(config_fh, &block)
+    config = parse(config_fh)
+    manipulator = Manipulator.new(config)
+    yield manipulator
+    config.write(config_fh)
+  end
+
+  def self.parse(config_fh)
+    config = new([DefaultSection.new])
+    config_fh.each_line do |line|
+      case line
+      when /^(\s*)\[(\w+)\](\s*)$/
+        config.append(SectionLine.new($1, $2, $3))
+      when /^(\s*)(\w+)(\s*=\s*)(.*?)(\s*)$/
+        config.append(SettingLine.new($1, $2, $3, $4, $5))
+      else
+        config.append(Line.new(line))
+      end
+    end
+
+    config
+  end
+
+  def initialize(lines = [])
+    @lines = lines
+  end
+
+  def append(line)
+    line.previous = @lines.last
+    @lines << line
+  end
+
+  def insert_after(line, new_line)
+    new_line.previous = line
+
+    insertion_point = @lines.index(line)
+    @lines.insert(insertion_point + 1, new_line)
+    if @lines.length > insertion_point + 2
+      @lines[insertion_point + 2].previous = new_line
+    end
+  end
+
+  def section_lines
+    @lines.select { |line| line.is_a?(SectionLine) }
+  end
+
+  def section_line(name)
+    section_lines.find { |section| section.name == name }
+  end
+
+  def setting(section, name)
+    settings_in(lines_in(section)).find do |line|
+      line.name == name
+    end
+  end
+
+  def lines_in(section_name)
+    section_lines = []
+    current_section_name = DEFAULT_SECTION_NAME
+    @lines.each do |line|
+      if line.is_a?(SectionLine)
+        current_section_name = line.name
+      elsif current_section_name == section_name
+        section_lines << line
+      end
+    end
+
+    section_lines
+  end
+
+  def settings_in(lines)
+    lines.select { |line| line.is_a?(SettingLine) }
+  end
+
+  def write(fh)
+    fh.truncate(0)
+    fh.rewind
+    @lines.each do |line|
+      line.write(fh)
+    end
+    fh.flush
+  end
+
+  class Manipulator
+    def initialize(config)
+      @config = config
+    end
+
+    def set(section, name, value)
+      setting = @config.setting(section, name)
+      if setting
+        setting.value = value
+      else
+        add_setting(section, name, value)
+      end
+    end
+
+    private
+
+    def add_setting(section_name, name, value)
+      section = @config.section_line(section_name)
+      if section.nil?
+        previous_line = SectionLine.new("", section_name, "")
+        @config.append(previous_line)
+      else
+        previous_line = @config.settings_in(@config.lines_in(section_name)).last || section
+      end
+
+      @config.insert_after(previous_line, SettingLine.new("", name, " = ", value, ""))
+    end
+  end
+
+  module LineNumber
+    attr_accessor :previous
+
+    def line_number
+      line = 0
+      previous_line = previous
+      while previous_line
+        line += 1
+        previous_line = previous_line.previous
+      end
+      line
+    end
+  end
+
+  Line = Struct.new(:text) do
+    include LineNumber
+
+    def write(fh)
+      fh.puts(text)
+    end
+  end
+
+  SettingLine = Struct.new(:prefix, :name, :infix, :value, :suffix) do
+    include LineNumber
+
+    def write(fh)
+      fh.write(prefix)
+      fh.write(name)
+      fh.write(infix)
+      fh.write(value)
+      fh.puts(suffix)
+    end
+  end
+
+  SectionLine = Struct.new(:prefix, :name, :suffix) do
+    include LineNumber
+
+    def write(fh)
+      fh.write(prefix)
+      fh.write("[")
+      fh.write(name)
+      fh.write("]")
+      fh.puts(suffix)
+    end
+  end
+
+  class DefaultSection < SectionLine
+    def initialize
+      super("", DEFAULT_SECTION_NAME, "")
+    end
+
+    def write(fh)
+    end
+  end
+end

data/lib/puppet/ssl/base.rb

@@ -90,6 +90,10 @@ class Puppet::SSL::Base
     content.to_pem
   end
 
+  def to_data_hash
+    to_s
+  end
+
   # Provide the full text of the thing we're dealing with.
   def to_text
     return "" unless content

data/lib/puppet/ssl/certificate_authority.rb

@@ -85,10 +85,10 @@ class Puppet::SSL::CertificateAuthority
       when 'true', true
         AutosignAlways.new
       else
-        file = Puppet::FileSystem::File.new(auto)
-        if file.executable?
+        file = Puppet::FileSystem.pathname(auto)
+        if Puppet::FileSystem.executable?(file)
           Puppet::SSL::CertificateAuthority::AutosignCommand.new(auto)
-        elsif file.exist?
+        elsif Puppet::FileSystem.exist?(file)
           AutosignConfig.new(file)
         else
           AutosignNever.new
@@ -174,7 +174,7 @@ class Puppet::SSL::CertificateAuthority
     begin
       Puppet.settings.setting(:capass).open('w') { |f| f.print pass }
     rescue Errno::EACCES => detail
-      raise Puppet::Error, "Could not write CA password: #{detail}"
+      raise Puppet::Error, "Could not write CA password: #{detail}", detail.backtrace
     end
 
     @password = pass
@@ -184,9 +184,11 @@ class Puppet::SSL::CertificateAuthority
 
   # Lists the names of all signed certificates.
   #
+  # @param name [Array<string>] filter to cerificate names
+  #
   # @return [Array<String>]
-  def list
-    list_certificates.collect { |c| c.name }
+  def list(name='*')
+    list_certificates(name).collect { |c| c.name }
   end
 
   # Return all the certificate objects as found by the indirector
@@ -195,13 +197,16 @@ class Puppet::SSL::CertificateAuthority
   # Created to prevent the case of reading all certs from disk, getting
   # just their names and verifying the cert for each name, which then
   # causes the cert to again be read from disk.
+  # @param name [Array<string>] filter to cerificate names
   #
   # @author Jeff Weiss <jeff.weiss@puppetlabs.com>
   # @api Puppet Enterprise Licensing
   #
+  # @param name [Array<string>] filter to cerificate names
+  #
   # @return [Array<Puppet::SSL::Certificate>]
-  def list_certificates
-    Puppet::SSL::Certificate.indirection.search("*")
+  def list_certificates(name='*')
+    Puppet::SSL::Certificate.indirection.search(name)
   end
 
   # Read the next serial from the serial file, and increment the
@@ -227,7 +232,7 @@ class Puppet::SSL::CertificateAuthority
 
   # Does the password file exist?
   def password?
-    Puppet::FileSystem::File.exist? Puppet[:capass]
+    Puppet::FileSystem.exist?(Puppet[:capass])
   end
 
   # Print a given host's certificate as text.
@@ -408,7 +413,7 @@ class Puppet::SSL::CertificateAuthority
   private :create_x509_store
 
   # Utility method which is API for PE license checking.
-  # This is used rather than `verify` because 
+  # This is used rather than `verify` because
   #  1) We have already read the certificate from disk into memory.
   #     To read the certificate from disk again is just wasteful.
   #  2) Because we're checking a large number of certificates against
@@ -492,7 +497,7 @@ class Puppet::SSL::CertificateAuthority
 
     def autosign_store
       auth = Puppet::Network::AuthStore.new
-      @config.each_line do |line|
+      Puppet::FileSystem.each_line(@config) do |line|
         next if line =~ /^\s*#/
         next if line =~ /^\s*$/
         auth.allow(line.chomp)