puppet 3.0.2 → 3.1.0.rc1

data/lib/puppet/settings.rb

@@ -11,6 +11,8 @@ require 'puppet/settings/path_setting'
 require 'puppet/settings/boolean_setting'
 require 'puppet/settings/terminus_setting'
 require 'puppet/settings/duration_setting'
+require 'puppet/settings/config_file'
+require 'puppet/settings/value_translator'
 
 # The class for handling configuration files.
 class Puppet::Settings
@@ -61,6 +63,35 @@ class Puppet::Settings
     "puppet.conf"
   end
 
+  # Create a new collection of config settings.
+  def initialize
+    @config = {}
+    @shortnames = {}
+
+    @created = []
+    @searchpath = nil
+
+    # Mutex-like thing to protect @values
+    @sync = Sync.new
+
+    # Keep track of set values.
+    @values = Hash.new { |hash, key| hash[key] = {} }
+
+    # Hold parsed metadata until run_mode is known
+    @metas = {}
+
+    # And keep a per-environment cache
+    @cache = Hash.new { |hash, key| hash[key] = {} }
+
+    # The list of sections we've used.
+    @used = []
+
+    @hooks_to_call_on_application_initialization = []
+
+    @translate = Puppet::Settings::ValueTranslator.new
+    @config_file_parser = Puppet::Settings::ConfigFile.new(@translate)
+  end
+
   # Retrieve a config value
   def [](param)
     value(param)
@@ -208,7 +239,6 @@ class Puppet::Settings
   end
 
   def initialize_app_defaults(app_defaults)
-    raise Puppet::DevError, "Attempting to initialize application default settings more than once!" if app_defaults_initialized?
     REQUIRED_APP_SETTINGS.each do |key|
       raise SettingsError, "missing required app default setting '#{key}'" unless app_defaults.has_key?(key)
     end
@@ -220,6 +250,7 @@ class Puppet::Settings
         set_value(key, value, :application_defaults)
       end
     end
+    apply_metadata
     call_hooks_deferred_to_application_initialization
 
     @app_defaults_initialized = true
@@ -301,7 +332,7 @@ class Puppet::Settings
       value = "true"
     end
 
-    value &&= munge_value(value)
+    value &&= @translate[value]
     str = opt.sub(/^--/,'')
 
     bool = true
@@ -332,29 +363,6 @@ class Puppet::Settings
     @shortnames.include?(short)
   end
 
-  # Create a new collection of config settings.
-  def initialize
-    @config = {}
-    @shortnames = {}
-
-    @created = []
-    @searchpath = nil
-
-    # Mutex-like thing to protect @values
-    @sync = Sync.new
-
-    # Keep track of set values.
-    @values = Hash.new { |hash, key| hash[key] = {} }
-
-    # And keep a per-environment cache
-    @cache = Hash.new { |hash, key| hash[key] = {} }
-
-    # The list of sections we've used.
-    @used = []
-
-    @hooks_to_call_on_application_initialization = []
-  end
-
   # Prints the contents of a config file with the available config settings, or it
   # prints a single value of a config setting.
   def print_config_options
@@ -465,19 +473,8 @@ class Puppet::Settings
 
   # Parse the configuration file.  Just provides thread safety.
   def parse_config_files
-    # we are able to support multiple config files; the "main" config file will
-    # be the one located in /etc/puppet (or overridden $confdir)... but we can
-    # also look for a config file in the user's home directory.  We only load
-    # one configuration file in order to present a simple and consistent
-    # configuration model to the end user.  It should also be noted we decided
-    # to merge in the user puppet.conf with the system puppet.conf for a time
-    # (e.g. load two configuration files) as a small part of #7749 but then
-    # decided to reverse this decision in #15337 to return to a disjoint
-    # configuration file model.
-    config_files = [which_configuration_file]
-
     @sync.synchronize do
-      unsafe_parse(config_files)
+      unsafe_parse(which_configuration_file)
     end
 
     call_hooks_deferred_to_application_initialization :ignore_interpolation_dependency_errors => true
@@ -518,13 +515,10 @@ class Puppet::Settings
   private :config_file_name
 
   # Unsafely parse the file -- this isn't thread-safe and causes plenty of problems if used directly.
-  def unsafe_parse(files)
-    raise Puppet::DevError unless files.length > 0
-
+  def unsafe_parse(file)
     # build up a single data structure that contains the values from all of the parsed files.
     data = {}
-    files.each do |file|
-      next unless FileTest.exist?(file)
+    if FileTest.exist?(file)
       begin
         file_data = parse_file(file)
 
@@ -537,7 +531,6 @@ class Puppet::Settings
             data[key] = file_data[key]
           end
         end
-
       rescue => detail
         Puppet.log_exception(detail, "Could not parse #{file}: #{detail}")
         return
@@ -552,9 +545,8 @@ class Puppet::Settings
     unsafe_clear(false, false)
 
     # And now we can repopulate with the values from our last parsing of the config files.
-    metas = {}
     data.each do |area, values|
-      metas[area] = values.delete(:_meta)
+      @metas[area] = values.delete(:_meta)
       values.each do |key,value|
         set_value(key, value, area, :dont_trigger_handles => true, :ignore_bad_settings => true )
       end
@@ -582,19 +574,24 @@ class Puppet::Settings
       end
     end
 
+    # Take a best guess at metadata based on uninitialized run_mode
+    apply_metadata
+  end
+  private :unsafe_parse
+
+  def apply_metadata
     # We have to do it in the reverse of the search path,
     # because multiple sections could set the same value
     # and I'm too lazy to only set the metadata once.
     searchpath.reverse.each do |source|
       source = preferred_run_mode if source == :run_mode
       source = @name if (@name && source == :name)
-      if meta = metas[source]
+      if meta = @metas[source]
         set_metadata(meta)
       end
     end
   end
-  private :unsafe_parse
-
+  private :apply_metadata
 
   # Create a new setting.  The value is passed in because it's used to determine
   # what kind of setting we're creating, but the value itself might be either
@@ -710,11 +707,25 @@ class Puppet::Settings
   def service_user_available?
     return @service_user_available if defined?(@service_user_available)
 
-    return @service_user_available = false unless user_name = self[:user]
+    if self[:user]
+      user = Puppet::Type.type(:user).new :name => self[:user], :audit => :ensure
+
+      @service_user_available = user.exists?
+    else
+      @service_user_available = false
+    end
+  end
 
-    user = Puppet::Type.type(:user).new :name => self[:user], :audit => :ensure
+  def service_group_available?
+    return @service_group_available if defined?(@service_group_available)
 
-    @service_user_available = user.exists?
+    if self[:group]
+      group = Puppet::Type.type(:group).new :name => self[:group], :audit => :ensure
+
+      @service_group_available = group.exists?
+    else
+      @service_group_available = false
+    end
   end
 
   # Allow later inspection to determine if the setting was set on the
@@ -1098,98 +1109,9 @@ Generated on #{Time.now}.
     @config.values.find_all { |setting| setting.has_hook? }
   end
 
-  # Extract extra setting information for files.
-  def extract_fileinfo(string)
-    result = {}
-    value = string.sub(/\{\s*([^}]+)\s*\}/) do
-      params = $1
-      params.split(/\s*,\s*/).each do |str|
-        if str =~ /^\s*(\w+)\s*=\s*([\w\d]+)\s*$/
-          param, value = $1.intern, $2
-          result[param] = value
-          raise ArgumentError, "Invalid file option '#{param}'" unless [:owner, :mode, :group].include?(param)
-
-          if param == :mode and value !~ /^\d+$/
-            raise ArgumentError, "File modes must be numbers"
-          end
-        else
-          raise ArgumentError, "Could not parse '#{string}'"
-        end
-      end
-      ''
-    end
-    result[:value] = value.sub(/\s*$/, '')
-    result
-  end
-
-  # Convert arguments into booleans, integers, or whatever.
-  def munge_value(value)
-    # Handle different data types correctly
-    return case value
-      when /^false$/i; false
-      when /^true$/i; true
-      when /^\d+$/i; Integer(value)
-      when true; true
-      when false; false
-      else
-        value.gsub(/^["']|["']$/,'').sub(/\s+$/, '')
-    end
-  end
-
   # This method just turns a file in to a hash of hashes.
   def parse_file(file)
-    text = read_file(file)
-
-    result = Hash.new { |names, name|
-      names[name] = {}
-    }
-
-    count = 0
-
-    # Default to 'main' for the section.
-    section = :main
-    result[section][:_meta] = {}
-    text.split(/\n/).each do |line|
-      count += 1
-      case line
-      when /^\s*\[(\w+)\]\s*$/
-        section = $1.intern # Section names
-        #disallow application_defaults in config file
-        if section == :application_defaults
-          raise Puppet::Error, "Illegal section 'application_defaults' in config file #{file} at line #{line}"
-        end
-        # Add a meta section
-        result[section][:_meta] ||= {}
-      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 = munge_value($2)
-        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)
-            value = options[:value]
-            options.delete(:value)
-            result[section][:_meta][var] = options
-          end
-          result[section][var] = value
-        rescue Puppet::Error => detail
-          raise ParseError.new(detail.message, file, line, detail)
-        end
-      else
-        raise ParseError.new("Could not match line #{line}", file, line)
-      end
-    end
-
-    result
+    @config_file_parser.parse_file(file, read_file(file))
   end
 
   # Read the file in.
@@ -1207,7 +1129,9 @@ Generated on #{Time.now}.
   def set_metadata(meta)
     meta.each do |var, values|
       values.each do |param, value|
-        @config[var].send(param.to_s + "=", value)
+        @sync.synchronize do # yay, thread-safe
+          @config[var].send(param.to_s + "=", value)
+        end
       end
     end
   end

data/lib/puppet/settings/config_file.rb

@@ -0,0 +1,99 @@
+require 'puppet/settings/errors'
+
+##
+# @api private
+#
+# Parses puppet configuration files
+#
+class Puppet::Settings::ConfigFile
+
+  ##
+  # @param value_converter [Proc] a function that will convert strings into ruby types
+  #
+  def initialize(value_converter)
+    @value_converter = value_converter
+  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
+
+        # 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)
+        end
+      else
+        raise Puppet::Settings::ParseError.new("Could not match line #{line}", file, line)
+      end
+    end
+
+    result
+  end
+
+private
+
+  def empty_section
+    { :_meta => {} }
+  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}"
+    end
+  end
+
+  def extract_fileinfo(string)
+    result = {}
+    value = string.sub(/\{\s*([^}]+)\s*\}/) do
+      params = $1
+      params.split(/\s*,\s*/).each do |str|
+        if str =~ /^\s*(\w+)\s*=\s*([\w\d]+)\s*$/
+          param, value = $1.intern, $2
+          result[param] = value
+          raise ArgumentError, "Invalid file option '#{param}'" unless [:owner, :mode, :group].include?(param)
+
+          if param == :mode and value !~ /^\d+$/
+            raise ArgumentError, "File modes must be numbers"
+          end
+        else
+          raise ArgumentError, "Could not parse '#{string}'"
+        end
+      end
+      ''
+    end
+    result[:value] = value.sub(/\s*$/, '')
+    result
+  end
+end

data/lib/puppet/settings/file_setting.rb

@@ -2,47 +2,110 @@ require 'puppet/settings/string_setting'
 
 # A file.
 class Puppet::Settings::FileSetting < Puppet::Settings::StringSetting
-  AllowedOwners = %w{root service}
-  AllowedGroups = %w{root service}
-
   class SettingError < StandardError; end
 
+  # An unspecified user or group
+  #
+  # @api private
+  class Unspecified
+    def value
+      nil
+    end
+  end
+
+  # A "root" user or group
+  #
+  # @api private
+  class Root
+    def value
+      "root"
+    end
+  end
+
+  # A "service" user or group that picks up values from settings when the
+  # referenced user or group is safe to use (it exists or will be created), and
+  # uses the given fallback value when not safe.
+  #
+  # @api private
+  class Service
+    # @param name [Symbol] the name of the setting to use as the service value
+    # @param fallback [String, nil] the value to use when the service value cannot be used
+    # @param settings [Puppet::Settings] the puppet settings object
+    # @param available_method [Symbol] the name of the method to call on
+    #   settings to determine if the value in settings is available on the system
+    #
+    def initialize(name, fallback, settings, available_method)
+      @settings = settings
+      @available_method = available_method
+      @name = name
+      @fallback = fallback
+    end
+
+    def value
+      if safe_to_use_settings_value?
+        @settings[@name]
+      else
+        @fallback
+      end
+    end
+
+  private
+    def safe_to_use_settings_value?
+      @settings[:mkusers] or @settings.send(@available_method)
+    end
+  end
+
   attr_accessor :mode, :create
 
+  def initialize(args)
+    @group = Unspecified.new
+    @owner = Unspecified.new
+    super(args)
+  end
+
   # Should we create files, rather than just directories?
   def create_files?
     create
   end
 
+  # @param value [String] the group to use on the created file (can only be "root" or "service")
+  # @api public
   def group=(value)
-    unless AllowedGroups.include?(value)
-      identifying_fields = [desc,name,default].compact.join(': ')
-      raise SettingError, "Internal error: The :group setting for #{identifying_fields} must be 'service', not '#{value}'"
-    end
-    @group = value
-  end
-
-  def group
-    return unless @group
-    @settings[:group]
+    @group = case value
+             when "root"
+               Root.new
+             when "service"
+               # Group falls back to `nil` because we cannot assume that a "root" group exists.
+               # Some systems have root group, others have wheel, others have something else.
+               Service.new(:group, nil, @settings, :service_group_available?)
+             else
+               unknown_value(':group', value)
+             end
   end
 
+  # @param value [String] the owner to use on the created file (can only be "root" or "service")
+  # @api public
   def owner=(value)
-    unless AllowedOwners.include?(value)
-      identifying_fields = [desc,name,default].compact.join(': ')
-      raise SettingError, "Internal error: The :owner setting for #{identifying_fields} must be either 'root' or 'service', not '#{value}'"
-    end
-    @owner = value
+    @owner = case value
+             when "root"
+               Root.new
+             when "service"
+               Service.new(:user, "root", @settings, :service_user_available?)
+             else
+               unknown_value(':owner', value)
+             end
   end
 
-  def owner
-    return unless @owner
-    return "root" if @owner == "root" or ! use_service_user?
-    @settings[:user]
+  # @return [String, nil] the name of the group to use for the file or nil if the group should not be managed
+  # @api public
+  def group
+    @group.value
   end
 
-  def use_service_user?
-    @settings[:mkusers] or @settings.service_user_available?
+  # @return [String, nil] the name of the user to use for the file or nil if the user should not be managed
+  # @api public
+  def owner
+    @owner.value
   end
 
   def munge(value)
@@ -116,4 +179,9 @@ class Puppet::Settings::FileSetting < Puppet::Settings::StringSetting
       end
     }
   end
+
+private
+  def unknown_value(parameter, value)
+    raise SettingError, "The #{parameter} parameter for the setting '#{name}' must be either 'root' or 'service', not '#{value}'"
+  end
 end