puppet 3.3.2 → 3.4.0.rc1

data/lib/puppet/node/environment.rb

@@ -10,20 +10,18 @@ end
 # Puppet::Node::Environment acts as a container for all configuration
 # that is expected to vary between environments.
 #
-# ## Thread local variables
+# ## Global variables
 #
-# The Puppet::Node::Environment uses a number of `Thread.current` variables.
-# Since all web servers that Puppet runs on are single threaded these
-# variables are effectively global.
+# The Puppet::Node::Environment uses a number of global variables.
 #
-# ### `Thread.current[:environment]`
+# ### `$environment`
 #
-# The 'environment' thread variable represents the current environment that's
+# The 'environment' global variable represents the current environment that's
 # being used in the compiler.
 #
-# ### `Thread.current[:known_resource_types]`
+# ### `$known_resource_types`
 #
-# The 'known_resource_types' thread variable represents a singleton instance
+# The 'known_resource_types' global variable represents a singleton instance
 # of the Puppet::Resource::TypeCollection class. The variable is discarded
 # and regenerated if it is accessed by an environment that doesn't match the
 # environment of the 'known_resource_types'
@@ -129,7 +127,7 @@ class Puppet::Node::Environment
   # @return [Puppet::Node::Environment] the currently set environment if one
   #   has been explicitly set, else it will return the '*root*' environment
   def self.current
-    Thread.current[:environment] || root
+    $environment || root
   end
 
   # Set the environment for the current thread
@@ -145,7 +143,7 @@ class Puppet::Node::Environment
   #
   # @param env [Puppet::Node::Environment]
   def self.current=(env)
-    Thread.current[:environment] = new(env)
+    $environment = new(env)
   end
 
 
@@ -164,7 +162,7 @@ class Puppet::Node::Environment
   # @api private
   def self.clear
     @seen.clear
-    Thread.current[:environment] = nil
+    $environment = nil
   end
 
   # @!attribute [r] name
@@ -192,17 +190,16 @@ class Puppet::Node::Environment
   # @param name [Symbol] The environment name
   def initialize(name)
     @name = name
-    extend MonitorMixin
   end
 
   # The current global TypeCollection
   #
   # @note The environment is loosely coupled with the {Puppet::Resource::TypeCollection}
   #   class. While there is a 1:1 relationship between an environment and a
-  #   TypeCollection instance, there is only one TypeCollection instance available
-  #   at any given time. It is stored in the Thread.current collection as
-  #   'known_resource_types'. 'known_resource_types' is accessed as an instance
-  #   method, but is global to all environment variables.
+  #   TypeCollection instance, there is only one TypeCollection instance
+  #   available at any given time. It is stored in `$known_resource_types`.
+  #   `$known_resource_types` is accessed as an instance method, but is global
+  #   to all environment variables.
   #
   # @api public
   # @return [Puppet::Resource::TypeCollection] The current global TypeCollection
@@ -212,14 +209,15 @@ class Puppet::Node::Environment
     # always just return our thread's known-resource types.  Only at the start
     # of a compilation (after our thread var has been set to nil) or when the
     # environment has changed do we delve deeper.
-    Thread.current[:known_resource_types] = nil if (krt = Thread.current[:known_resource_types]) && krt.environment != self
-    Thread.current[:known_resource_types] ||= synchronize {
+    $known_resource_types = nil if $known_resource_types && $known_resource_types.environment != self
+    $known_resource_types ||=
       if @known_resource_types.nil? or @known_resource_types.require_reparse?
         @known_resource_types = Puppet::Resource::TypeCollection.new(self)
         @known_resource_types.import_ast(perform_initial_import, '')
+        @known_resource_types
+      else
+        @known_resource_types
       end
-      @known_resource_types
-    }
   end
 
   # Yields each modules' plugin directory if the plugin directory (modulename/lib)

data/lib/puppet/node/facts.rb

@@ -84,16 +84,33 @@ class Puppet::Node::Facts
     new_facts
   end
 
-  def to_pson(*args)
+  def to_data_hash
     result = {
       'name' => name,
       'values' => strip_internal,
     }
 
-    result['timestamp'] = timestamp if timestamp
-    result['expiration'] = expiration if expiration
+    if timestamp
+      if timestamp.is_a? Time
+        result['timestamp'] = timestamp.iso8601(9)
+      else
+        result['timestamp'] = timestamp
+      end
+    end
+
+    if expiration
+      if expiration.is_a? Time
+        result['expiration'] = expiration.iso8601(9)
+      else
+        result['expiration'] = expiration
+      end
+    end
 
-    result.to_pson(*args)
+    result
+  end
+
+  def to_pson(*args)
+    to_data_hash.to_pson(*args)
   end
 
   # Add internal data to the facts for storage.
@@ -109,8 +126,6 @@ class Puppet::Node::Facts
     self.values['_timestamp']
   end
 
-  private
-
   # Strip out that internal data.
   def strip_internal
     newvals = values.dup
@@ -118,6 +133,8 @@ class Puppet::Node::Facts
     newvals
   end
 
+  private
+
   def sanitize_fact(fact)
     if fact.is_a? Hash then
       ret = {}

data/lib/puppet/parameter.rb

@@ -116,10 +116,13 @@ class Puppet::Parameter
       @doc ||= ""
 
       unless defined?(@addeddocvals)
-        @doc += value_collection.doc
+        @doc = Puppet::Util::Docs.scrub(@doc)
+        if vals = value_collection.doc
+          @doc << "\n\n#{vals}"
+        end
 
         if f = self.required_features
-          @doc += "  Requires features #{f.flatten.collect { |f| f.to_s }.join(" ")}."
+          @doc << "\n\nRequires features #{f.flatten.collect { |f| f.to_s }.join(" ")}."
         end
         @addeddocvals = true
       end
@@ -567,6 +570,16 @@ class Puppet::Parameter
       "'#{value}'"
     end
   end
+
+  # @comment Document post_compile_hook here as it does not exist anywhere (called from type if implemented)
+  # @!method post_compile()
+  # @since 3.4.0
+  # @api public
+  #   @abstract A subclass may implement this - it is not implemented in the Parameter class
+  #   This method may be implemented by a parameter in order to perform actions during compilation
+  #   after all resources have been added to the catalog.
+  #   @see Puppet::Type#finish
+  #   @see Puppet::Parser::Compiler#finish
 end
 
 require 'puppet/parameter/path'

data/lib/puppet/parameter/boolean.rb

@@ -7,4 +7,9 @@ class Puppet::Parameter::Boolean < Puppet::Parameter
   def unsafe_munge(value)
     Puppet::Coercion.boolean(value)
   end
+
+  def self.initvars
+    super
+    @value_collection.newvalues(*Puppet::Coercion.boolean_values)
+  end
 end

data/lib/puppet/parameter/value_collection.rb

@@ -33,17 +33,19 @@ class Puppet::Parameter::ValueCollection
     unless defined?(@doc)
       @doc = ""
       unless values.empty?
-        @doc += "  Valid values are "
-        @doc += @strings.collect do |value|
+        @doc << "Valid values are "
+        @doc << @strings.collect do |value|
           if aliases = value.aliases and ! aliases.empty?
             "`#{value.name}` (also called `#{aliases.join(", ")}`)"
           else
             "`#{value.name}`"
           end
-        end.join(", ") + "."
+        end.join(", ") << ". "
       end
 
-      @doc += "  Values can match `" + regexes.join("`, `") + "`." unless regexes.empty?
+      unless regexes.empty?
+        @doc << "Values can match `#{regexes.join("`, `")}`."
+      end
     end
 
     @doc

data/lib/puppet/parser/ast/resourceparam.rb

@@ -11,9 +11,10 @@ class Puppet::Parser::AST
 
     # Return the parameter and the value.
     def evaluate(scope)
+      value = @value.safeevaluate(scope)
       return Puppet::Parser::Resource::Param.new(
         :name   => @param,
-        :value  => @value.safeevaluate(scope),
+        :value  => value.nil? ? :undef : value,
         :source => scope.source, :line => self.line, :file => self.file,
         :add    => self.add
       )

data/lib/puppet/parser/compiler.rb

@@ -17,13 +17,8 @@ class Puppet::Parser::Compiler
   include Puppet::Resource::TypeCollectionHelper
 
   def self.compile(node)
-    # We get these from the environment and only cache them in a thread
-    # variable for the duration of the compilation.  If nothing else is using
-    # the thread, though, we can leave 'em hanging round with no ill effects,
-    # and this is safer than cleaning them at the end and assuming that will
-    # stick until the next entry to this function.
-    Thread.current[:known_resource_types] = nil
-    Thread.current[:env_module_directories] = nil
+    $known_resource_types = nil
+    $env_module_directories = nil
 
     # ...and we actually do the compile now we have caching ready.
     new(node).compile.to_resource
@@ -143,8 +138,27 @@ class Puppet::Parser::Compiler
   end
 
   # Evaluate all of the classes specified by the node.
+  # Classes with parameters are evaluated as if they were declared.
+  # Classes without parameters or with an empty set of parameters are evaluated
+  # as if they were included. This means classes with an empty set of
+  # parameters won't conflict even if the class has already been included.
   def evaluate_node_classes
-    evaluate_classes(@node.classes, @node_scope || topscope)
+    if @node.classes.is_a? Hash
+      classes_with_params, classes_without_params = @node.classes.partition {|name,params| params and !params.empty?}
+
+      # The results from Hash#partition are arrays of pairs rather than hashes,
+      # so we have to convert to the forms evaluate_classes expects (Hash, and
+      # Array of class names)
+      classes_with_params = Hash[classes_with_params]
+      classes_without_params.map!(&:first)
+    else
+      classes_with_params = {}
+      classes_without_params = @node.classes
+    end
+
+    evaluate_classes(classes_without_params, @node_scope || topscope)
+
+    evaluate_classes(classes_with_params, @node_scope || topscope)
   end
 
   # Evaluate each specified class in turn.  If there are any classes we can't
@@ -487,10 +501,12 @@ class Puppet::Parser::Compiler
     node.parameters.each do |param, value|
       @topscope[param.to_s] = value
     end
-
     # These might be nil.
     catalog.client_version = node.parameters["clientversion"]
     catalog.server_version = node.parameters["serverversion"]
+    if Puppet[:trusted_node_data]
+      @topscope.set_trusted(node.trusted_data)
+    end
   end
 
   def create_settings_scope

data/lib/puppet/parser/files.rb

@@ -41,7 +41,7 @@ module Puppet; module Parser; module Files
       template_paths.collect { |path|
         File::join(path, template)
       }.each do |f|
-        return f if FileTest.exist?(f)
+        return f if Puppet::FileSystem::File.exist?(f)
       end
     end
 

data/lib/puppet/parser/functions.rb

@@ -1,6 +1,5 @@
 require 'puppet/util/autoload'
 require 'puppet/parser/scope'
-require 'monitor'
 
 # A module for managing parser functions.  Each specified function
 # is added to a central module that then gets included into the Scope
@@ -18,8 +17,8 @@ module Puppet::Parser::Functions
   #
   # @api private
   def self.reset
-    @functions = Hash.new { |h,k| h[k] = {} }.extend(MonitorMixin)
-    @modules = Hash.new.extend(MonitorMixin)
+    @functions = Hash.new { |h,k| h[k] = {} }
+    @modules = Hash.new
 
     # Runs a newfunction to create a function for each of the log levels
     Puppet::Util::Log.levels.each do |level|
@@ -46,9 +45,7 @@ module Puppet::Parser::Functions
     if env and ! env.is_a?(Puppet::Node::Environment)
       env = Puppet::Node::Environment.new(env)
     end
-    @modules.synchronize {
-      @modules[ (env || Environment.current || Environment.root).name ] ||= Module.new
-    }
+    @modules[ (env || Environment.current || Environment.root).name ] ||= Module.new
   end
 
   # Create a new Puppet DSL function.
@@ -170,11 +167,9 @@ module Puppet::Parser::Functions
     name = name.intern
 
     func = nil
-    @functions.synchronize do
-      unless func = get_function(name)
-        autoloader.load(name, Environment.current)
-        func = get_function(name)
-      end
+    unless func = get_function(name)
+      autoloader.load(name, Environment.current)
+      func = get_function(name)
     end
 
     if func
@@ -190,14 +185,14 @@ module Puppet::Parser::Functions
     ret = ""
 
     merged_functions.sort { |a,b| a[0].to_s <=> b[0].to_s }.each do |name, hash|
-      ret += "#{name}\n#{"-" * name.to_s.length}\n"
+      ret << "#{name}\n#{"-" * name.to_s.length}\n"
       if hash[:doc]
-        ret += Puppet::Util::Docs.scrub(hash[:doc])
+        ret << Puppet::Util::Docs.scrub(hash[:doc])
       else
-        ret += "Undocumented.\n"
+        ret << "Undocumented.\n"
       end
 
-      ret += "\n\n- *Type*: #{hash[:type]}\n\n"
+      ret << "\n\n- *Type*: #{hash[:type]}\n\n"
     end
 
     ret
@@ -229,9 +224,7 @@ module Puppet::Parser::Functions
     private
 
     def merged_functions
-      @functions.synchronize {
-        @functions[Environment.root].merge(@functions[Environment.current])
-      }
+      @functions[Environment.root].merge(@functions[Environment.current])
     end
 
     def get_function(name)
@@ -241,9 +234,7 @@ module Puppet::Parser::Functions
 
     def add_function(name, func)
       name = name.intern
-      @functions.synchronize {
-        @functions[Environment.current][name] = func
-      }
+      @functions[Environment.current][name] = func
     end
   end
 

data/lib/puppet/parser/functions/collect.rb

@@ -1,44 +1,15 @@
-require 'puppet/parser/ast/lambda'
-
 Puppet::Parser::Functions::newfunction(
 :collect,
 :type => :rvalue,
 :arity => 2,
 :doc => <<-'ENDHEREDOC') do |args|
-  Applies a parameterized block to each element in a sequence of entries from the first
-  argument and returns an array with the result of each invocation of the parameterized block.
-
-  This function takes two mandatory arguments: the first should be an Array or a Hash, and the second
-  a parameterized block as produced by the puppet syntax:
-
-        $a.collect |$x| { ... }
-
-  When the first argument `$a` is an Array, the block is called with each entry in turn. When the first argument
-  is a hash the entry is an array with `[key, value]`.
-
-  *Examples*
+  The 'collect' function has been renamed to 'map'. Please update your manifests.
 
-        # Turns hash into array of values
-        $a.collect |$x|{ $x[1] }
-
-        # Turns hash into array of keys
-        $a.collect |$x| { $x[0] }
-
-  - Since 3.2
+  The collect function is reserved for future use.
+  - Removed as of 3.4
   - requires `parser = future`.
   ENDHEREDOC
 
-  receiver = args[0]
-  pblock = args[1]
-
-  raise ArgumentError, ("collect(): wrong argument type (#{pblock.class}; must be a parameterized block.") unless pblock.is_a? Puppet::Parser::AST::Lambda
-
-  case receiver
-  when Array
-  when Hash
-  else
-    raise ArgumentError, ("collect(): wrong argument type (#{receiver.class}; must be an Array or a Hash.")
-  end
-
-  receiver.to_a.collect {|x| pblock.call(self, x) }
-end
+  raise NotImplementedError,
+    "The 'collect' function has been renamed to 'map'. Please update your manifests."
+end

data/lib/puppet/parser/functions/contain.rb

@@ -0,0 +1,26 @@
+# Called within a class definition, establishes a containment
+# relationship with another class
+
+Puppet::Parser::Functions::newfunction(
+  :contain,
+  :arity => -2,
+  :doc => "Contain one or more classes inside the current class. If any of
+these classes are undeclared, they will be declared as if called with the
+`include` function. Accepts a class name, an array of class names, or a
+comma-separated list of class names.
+
+A contained class will not be applied before the containing class is
+begun, and will be finished before the containing class is finished.
+"
+) do |classes|
+  scope = self
+
+  scope.function_include(classes)
+
+  classes.each do |class_name|
+    class_resource = scope.catalog.resource("Class", class_name)
+    if ! scope.catalog.edge?(scope.resource, class_resource)
+      scope.catalog.add_edge(scope.resource, class_resource)
+    end
+  end
+end