puppet 3.6.2-x86-mingw32 → 3.7.0-x86-mingw32

data/lib/puppet/provider/zone/solaris.rb

@@ -30,7 +30,7 @@ Puppet::Type.type(:zone).provide(:solaris) do
 
   def multi_conf(name, should, &action)
     has = properties[name]
-    has = [] if has == :absent
+    has = [] if !has || has == :absent
     rms = has - should
     adds = should - has
     (rms.map{|o| action.call(:rm,o)} + adds.map{|o| action.call(:add,o)}).join("\n")

data/lib/puppet/reference/metaparameter.rb

@@ -10,12 +10,14 @@ Puppet::Util::Reference.newreference :metaparameter, :doc => "All Puppet metapar
 
   str = %{
 
-# Metaparameters
-
-Metaparameters are parameters that work with any resource type; they are part of the
-Puppet framework itself rather than being part of the implementation of any
-given instance.  Thus, any defined metaparameter can be used with any instance
-in your manifest, including defined components.
+Metaparameters are attributes that work with any resource type, including custom
+types and defined types.
+
+In general, they affect _Puppet's_ behavior rather than the desired state of the
+resource. Metaparameters do things like add metadata to a resource (`alias`,
+`tag`), set limits on when the resource should be synced (`require`, `schedule`,
+etc.), prevent Puppet from making changes (`noop`), and change logging verbosity
+(`loglevel`).
 
 ## Available Metaparameters
 

data/lib/puppet/reports/store.rb

@@ -1,6 +1,6 @@
 require 'puppet'
 require 'fileutils'
-require 'tempfile'
+require 'puppet/util'
 
 SEPARATOR = [Regexp.escape(File::SEPARATOR.to_s), Regexp.escape(File::ALT_SEPARATOR.to_s)].join
 
@@ -31,17 +31,12 @@ Puppet::Reports.register_report(:store) do
 
     file = File.join(dir, name)
 
-    f = Tempfile.new(name, dir)
     begin
-      begin
-        f.chmod(0640)
-        f.print to_yaml
-      ensure
-        f.close
+      Puppet::Util.replace_file(file, 0640) do |fh|
+        fh.print to_yaml
       end
-      FileUtils.mv(f.path, file)
     rescue => detail
-      Puppet.log_exception(detail, "Could not write report for #{host} at #{file}: #{detail}")
+       Puppet.log_exception(detail, "Could not write report for #{host} at #{file}: #{detail}")
     end
 
     # Only testing cares about the return value

data/lib/puppet/resource.rb

@@ -186,9 +186,42 @@ class Puppet::Resource
     @is_stage ||= @type.to_s.downcase == "stage"
   end
 
-  # Create our resource.
+  # Cache to reduce respond_to? lookups
+  @@nondeprecating_type = {}
+
+  # Construct a resource from data.
+  #
+  # Constructs a resource instance with the given `type` and `title`. Multiple
+  # type signatures are possible for these arguments and most will result in an
+  # expensive call to {Puppet::Node::Environment#known_resource_types} in order
+  # to resolve `String` and `Symbol` Types to actual Ruby classes.
+  #
+  # @param type [Symbol, String] The name of the Puppet Type, as a string or
+  #   symbol. The actual Type will be looked up using
+  #   {Puppet::Node::Environment#known_resource_types}. This lookup is expensive.
+  # @param type [String] The full resource name in the form of
+  #   `"Type[Title]"`. This method of calling should only be used when
+  #   `title` is `nil`.
+  # @param type [nil] If a `nil` is passed, the title argument must be a string
+  #   of the form `"Type[Title]"`.
+  # @param type [Class] A class that inherits from `Puppet::Type`. This method
+  #   of construction is much more efficient as it skips calls to
+  #   {Puppet::Node::Environment#known_resource_types}.
+  #
+  # @param title [String, :main, nil] The title of the resource. If type is `nil`, may also
+  #   be the full resource name in the form of `"Type[Title]"`.
+  #
+  # @api public
   def initialize(type, title = nil, attributes = {})
     @parameters = {}
+    if type.is_a?(Class) && type < Puppet::Type
+      # Set the resource type to avoid an expensive `known_resource_types`
+      # lookup.
+      self.resource_type = type
+      # From this point on, the constructor behaves the same as if `type` had
+      # been passed as a symbol.
+      type = type.name
+    end
 
     # Set things like strictness first.
     attributes.each do |attr, value|
@@ -209,6 +242,14 @@ class Puppet::Resource
       extract_parameters(params)
     end
 
+    if resource_type and ! @@nondeprecating_type[resource_type]
+      if resource_type.respond_to?(:deprecate_params)
+        resource_type.deprecate_params(title, attributes[:parameters])
+      else
+        @@nondeprecating_type[resource_type] = true
+      end
+    end
+
     tag(self.type)
     tag(self.title) if valid_tag?(self.title)
 
@@ -254,7 +295,7 @@ class Puppet::Resource
     @environment ||= if catalog
                        catalog.environment_instance
                      else
-                       Puppet::Node::Environment::NONE
+                       Puppet.lookup(:current_environment) { Puppet::Node::Environment::NONE }
                      end
   end
 
@@ -407,15 +448,23 @@ class Puppet::Resource
         end
       end
 
-      # If the value is an array with only one value, then
-      # convert it to a single value.  This is largely so that
-      # the database interaction doesn't have to worry about
-      # whether it returns an array or a string.
-      result[p] = if v.is_a?(Array) and v.length == 1
-                    v[0]
-                  else
-                    v
-                  end
+      if Puppet[:parser] == 'current'
+        # If the value is an array with only one value, then
+        # convert it to a single value.  This is largely so that
+        # the database interaction doesn't have to worry about
+        # whether it returns an array or a string.
+        #
+        # This behavior is not done in the future parser, but we can't issue a
+        # deprecation warning either since there isn't anything that a user can
+        # do about it.
+        result[p] = if v.is_a?(Array) and v.length == 1
+                      v[0]
+                    else
+                      v
+                    end
+      else
+        result[p] = v
+      end
     end
 
     result
@@ -436,6 +485,21 @@ class Puppet::Resource
       param = param.to_sym
       fail Puppet::ParseError, "Must pass #{param} to #{self}" unless parameters.include?(param)
     end
+
+    # Perform optional type checking
+    if Puppet[:parser] == 'future'
+      # Perform type checking
+      arg_types = resource_type.argument_types
+      # Parameters is a map from name, to parameter, and the parameter again has name and value
+      parameters.each do |name, value|
+        next unless t = arg_types[name.to_s]  # untyped, and parameters are symbols here (aargh, strings in the type)
+        unless Puppet::Pops::Types::TypeCalculator.instance?(t, value.value)
+          inferred_type = Puppet::Pops::Types::TypeCalculator.infer(value.value)
+          actual = Puppet::Pops::Types::TypeCalculator.generalize!(inferred_type)
+          fail Puppet::ParseError, "Expected parameter '#{name}' of '#{self}' to have type #{t.to_s}, got #{actual.to_s}"
+        end
+      end
+    end
   end
 
   def validate_parameter(name)

data/lib/puppet/resource/catalog.rb

@@ -81,9 +81,12 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   end
 
   def add_one_resource(resource)
-    fail_on_duplicate_type_and_title(resource)
+    title_key = title_key_for_ref(resource.ref)
+    if @resource_table[title_key]
+      fail_on_duplicate_type_and_title(resource, title_key)
+    end
 
-    add_resource_to_table(resource)
+    add_resource_to_table(resource, title_key)
     create_resource_aliases(resource)
 
     resource.catalog = self if resource.respond_to?(:catalog=)
@@ -91,8 +94,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   end
   private :add_one_resource
 
-  def add_resource_to_table(resource)
-    title_key = title_key_for_ref(resource.ref)
+  def add_resource_to_table(resource, title_key)
     @resource_table[title_key] = resource
     @resources << title_key
   end
@@ -476,9 +478,9 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   end
 
   # Verify that the given resource isn't declared elsewhere.
-  def fail_on_duplicate_type_and_title(resource)
+  def fail_on_duplicate_type_and_title(resource, title_key)
     # Short-circuit the common case,
-    return unless existing_resource = @resource_table[title_key_for_ref(resource.ref)]
+    return unless existing_resource = @resource_table[title_key]
 
     # If we've gotten this far, it's a real conflict
     msg = "Duplicate declaration: #{resource.ref} is already declared"
@@ -547,6 +549,6 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   end
 
   def virtual_not_exported?(resource)
-    resource.respond_to?(:virtual?) and resource.virtual? and (resource.respond_to?(:exported?) and not resource.exported?)
+    resource.virtual && !resource.exported
   end
 end

data/lib/puppet/resource/type.rb

@@ -33,6 +33,11 @@ class Puppet::Resource::Type
   attr_accessor :file, :line, :doc, :code, :ruby_code, :parent, :resource_type_collection
   attr_reader :namespace, :arguments, :behaves_like, :module_name
 
+  # Map from argument (aka parameter) names to Puppet Type
+  # @return [Hash<Symbol, Puppet::Pops::Types::PAnyType] map from name to type
+  #
+  attr_reader :argument_types
+
   # This should probably be renamed to 'kind' eventually, in accordance with the changes
   #  made for serialization and API usability (#14137).  At the moment that seems like
   #  it would touch a whole lot of places in the code, though.  --cprice 2012-04-23
@@ -140,6 +145,7 @@ class Puppet::Resource::Type
     end
 
     set_arguments(options[:arguments])
+    set_argument_types(options[:argument_types])
 
     @match = nil
 
@@ -327,6 +333,27 @@ class Puppet::Resource::Type
     end
   end
 
+  # Sets the argument name to Puppet Type hash used for type checking.
+  # Names must correspond to available arguments (they must be defined first).
+  # Arguments not mentioned will not be type-checked. Only supported when parser == "future"
+  #
+  def set_argument_types(name_to_type_hash)
+    @argument_types = {}
+    # Stop here if not running under future parser, the rest requires pops to be initialized
+    # and that the type system is available
+    return unless Puppet[:parser] == 'future' && name_to_type_hash
+    name_to_type_hash.each do |name, t|
+      # catch internal errors
+      unless @arguments.include?(name)
+        raise Puppet::DevError, "Parameter '#{name}' is given a type, but is not a valid parameter."
+      end
+      unless t.is_a? Puppet::Pops::Types::PAnyType
+        raise Puppet::DevError, "Parameter '#{name}' is given a type that is not a Puppet Type, got #{t.class}"
+      end
+      @argument_types[name] = t
+    end
+  end
+
   private
 
   def convert_from_ast(name)

data/lib/puppet/settings.rb

@@ -2,9 +2,11 @@ require 'puppet'
 require 'getoptlong'
 require 'puppet/util/watched_file'
 require 'puppet/util/command_line/puppet_option_parser'
+require 'forwardable'
 
 # The class for handling configuration files.
 class Puppet::Settings
+  extend Forwardable
   include Enumerable
 
   require 'puppet/settings/errors'
@@ -89,6 +91,7 @@ class Puppet::Settings
 
     # And keep a per-environment cache
     @cache = Hash.new { |hash, key| hash[key] = {} }
+    @values = Hash.new { |hash, key| hash[key] = {} }
 
     # The list of sections we've used.
     @used = []
@@ -196,6 +199,8 @@ class Puppet::Settings
     @value_sets[:memory] = Values.new(:memory, @config)
     @value_sets[:overridden_defaults] = Values.new(:overridden_defaults, @config)
 
+    @deprecated_settings_that_have_been_configured.clear
+    @values.clear
     @cache.clear
   end
   private :unsafe_clear
@@ -349,11 +354,7 @@ class Puppet::Settings
     end
   end
 
-  def each
-    @config.each { |name, object|
-      yield name, object
-    }
-  end
+  def_delegator :@config, :each
 
   # Iterate over each section name.
   def eachsection
@@ -541,12 +542,12 @@ class Puppet::Settings
     # If we get here and don't have any data, we just return and don't muck with the current state of the world.
     return if data.nil?
 
-    record_deprecations_from_puppet_conf(data)
-
-    # If we get here then we have some data, so we need to clear out any previous settings that may have come from
-    #  config files.
+    # If we get here then we have some data, so we need to clear out any
+    # previous settings that may have come from config files.
     unsafe_clear(false, false)
 
+    record_deprecations_from_puppet_conf(data)
+
     # And now we can repopulate with the values from our last parsing of the config files.
     @configuration_file = data
 
@@ -825,9 +826,9 @@ class Puppet::Settings
   # @param [Hash[Hash]] defs the settings to be defined.  This argument is a hash of hashes; each key should be a symbol,
   #   which is basically the name of the setting that you are defining.  The value should be another hash that specifies
   #   the parameters for the particular setting.  Legal values include:
-  #    [:default] => required; this is a string value that will be used as a default value for a setting if no other
-  #       value is specified (via cli, config file, etc.)  This string may include "variables", demarcated with $ or ${},
-  #       which will be interpolated with values of other settings.
+  #    [:default] => not required; this is the value for the setting if no other value is specified (via cli, config file, etc.)
+  #       For string settings this may include "variables", demarcated with $ or ${} which will be interpolated with values of other settings.
+  #       The default value may also be a Proc that will be called only once to evaluate the default when the setting's value is retrieved.
   #    [:desc] => required; a description of the setting, used in documentation / help generation
   #    [:type] => not required, but highly encouraged!  This specifies the data type that the setting represents.  If
   #       you do not specify it, it will default to "string".  Legal values include:
@@ -899,6 +900,7 @@ class Puppet::Settings
     end
 
     add_user_resources(catalog, sections)
+    add_environment_resources(catalog, sections)
 
     catalog
   end
@@ -993,7 +995,7 @@ Generated on #{Time.now}.
   # @return [Puppet::Settings::ChainedValues] An object to perform lookups
   # @api public
   def values(environment, section)
-    ChainedValues.new(
+    @values[environment][section] ||= ChainedValues.new(
       section,
       environment,
       value_sets_for(environment, section),
@@ -1122,6 +1124,20 @@ Generated on #{Time.now}.
     obj
   end
 
+  def add_environment_resources(catalog, sections)
+    path = self[:environmentpath]
+    envdir = path.split(File::PATH_SEPARATOR).first if path
+    configured_environment = self[:environment]
+    if configured_environment == "production" && envdir && Puppet::FileSystem.exist?(envdir)
+      configured_environment_path = File.join(envdir, configured_environment)
+      catalog.add_resource(
+        Puppet::Resource.new(:file,
+                             configured_environment_path,
+                             :parameters => { :ensure => 'directory' })
+      )
+    end
+  end
+
   def add_user_resources(catalog, sections)
     return unless Puppet.features.root?
     return if Puppet.features.microsoft_windows?
@@ -1181,6 +1197,7 @@ Generated on #{Time.now}.
   # @return nil
   def clear_everything_for_tests()
     unsafe_clear(true, true)
+    @configuration_file = nil
     @global_defaults_initialized = false
     @app_defaults_initialized = false
   end
@@ -1214,6 +1231,8 @@ Generated on #{Time.now}.
   #
   # @api public
   class ChainedValues
+    ENVIRONMENT_SETTING = "environment".freeze
+
     # @see Puppet::Settings.values
     # @api private
     def initialize(mode, environment, value_sets, defaults)
@@ -1278,50 +1297,54 @@ Generated on #{Time.now}.
     private
 
     def convert(value)
-      return nil if value.nil?
-      return value unless value.is_a? String
-      value.gsub(/\$(\w+)|\$\{(\w+)\}/) do |value|
-        varname = $2 || $1
-        if varname == "environment" && @environment
-          @environment
-        elsif varname == "run_mode"
-          @mode
-        elsif !(pval = interpolate(varname.to_sym)).nil?
-          pval
-        else
-          raise InterpolationError, "Could not find value for #{value}"
+      case value
+      when nil
+        nil
+      when String
+        value.gsub(/\$(\w+)|\$\{(\w+)\}/) do |value|
+          varname = $2 || $1
+          if varname == ENVIRONMENT_SETTING && @environment
+            @environment
+          elsif varname == "run_mode"
+            @mode
+          elsif !(pval = interpolate(varname.to_sym)).nil?
+            pval
+          else
+            raise InterpolationError, "Could not find value for #{value}"
+          end
         end
+      else
+        value
       end
     end
   end
 
   class Values
+    extend Forwardable
+
     def initialize(name, defaults)
       @name = name
       @values = {}
       @defaults = defaults
     end
 
-    def include?(name)
-      @values.include?(name)
-    end
+    def_delegator :@values, :include?
+    def_delegator :@values, :[], :lookup
 
     def set(name, value)
-      if !@defaults[name]
+      default = @defaults[name]
+
+      if !default
         raise ArgumentError,
           "Attempt to assign a value to unknown setting #{name.inspect}"
       end
 
-      if @defaults[name].has_hook?
-        @defaults[name].handle(value)
+      if default.has_hook?
+        default.handle(value)
       end
 
       @values[name] = value
     end
-
-    def lookup(name)
-      @values[name]
-    end
   end
 
   class ValuesFromSection
@@ -1361,12 +1384,9 @@ Generated on #{Time.now}.
     end
 
     def conf
-      unless @conf
-        if environments = Puppet.lookup(:environments)
-          @conf = environments.get_conf(@environment_name)
-        end
-      end
-      return @conf
+      @conf ||= if environments = Puppet.lookup(:environments)
+                  environments.get_conf(@environment_name)
+                end
     end
   end
 end