puppet 3.3.2 → 3.4.0.rc1

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

@@ -44,6 +44,11 @@ Puppet::Parser::Functions::newfunction(:create_resources, :arity => -3, :doc =>
 
   ENDHEREDOC
   raise ArgumentError, ("create_resources(): wrong number of arguments (#{args.length}; must be 2 or 3)") if args.length > 3
+  raise ArgumentError, ('create_resources(): second argument must be a hash') unless args[1].is_a?(Hash)
+  if args.length == 3
+    raise ArgumentError, ('create_resources(): third argument, if provided, must be a hash') unless args[2].is_a?(Hash)
+  end
+
 
   type, instances, defaults = args
   defaults ||= {}

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

@@ -100,7 +100,7 @@ This is for back compatibility to interpolate variables with %. % interpolation
 
   # if we got a custom data file, put it first in the array of search files
   if datafile != ""
-    datafiles << extlookup_datadir + "/#{datafile}.csv" if File.exists?(extlookup_datadir + "/#{datafile}.csv")
+    datafiles << extlookup_datadir + "/#{datafile}.csv" if Puppet::FileSystem::File.exist?(extlookup_datadir + "/#{datafile}.csv")
   end
 
   extlookup_precedence.each do |d|
@@ -111,7 +111,7 @@ This is for back compatibility to interpolate variables with %. % interpolation
 
   datafiles.each do |file|
     if desired.nil?
-      if File.exists?(file)
+      if Puppet::FileSystem::File.exist?(file)
         result = CSV.read(file).find_all do |r|
           r[0] == key
         end

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

@@ -10,7 +10,7 @@ Puppet::Parser::Functions::newfunction(
       unless Puppet::Util.absolute_path?(file)
         raise Puppet::ParseError, "Files must be fully qualified"
       end
-      if FileTest.exists?(file)
+      if Puppet::FileSystem::File.exist?(file)
         ret = File.read(file)
         break
       end

data/lib/puppet/parser/functions/{reject.rb → filter.rb}

@@ -1,47 +1,48 @@
 require 'puppet/parser/ast/lambda'
 
 Puppet::Parser::Functions::newfunction(
-:reject,
+:filter,
 :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 entires for which the block did *not* evaluate to true.
+  argument and returns an array or hash (same type as left operand)
+  with the entries for which the block evaluates to true.
 
   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.reject |$x| { ... }
+        $a.filter |$x| { ... }
 
   When the first argument 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]`.
+  is a Hash the entry is an array with `[key, value]`.
 
   The returned filtered object is of the same type as the receiver.
 
   *Examples*
 
-        # selects all that does not end with berry
-        $a = ["rasberry", "blueberry", "orange"]
-        $a.reject |$x| { $x =~ /berry$/ }
+        # selects all that end with berry
+        $a = ["raspberry", "blueberry", "orange"]
+        $a.filter |$x| { $x =~ /berry$/ }
 
-  - Since 3.2
+  - Since 3.4
   - requires `parser = future`.
   ENDHEREDOC
 
   receiver = args[0]
   pblock = args[1]
 
-  raise ArgumentError, ("reject(): wrong argument type (#{pblock.class}; must be a parameterized block.") unless pblock.is_a? Puppet::Parser::AST::Lambda
+  raise ArgumentError, ("filter(): wrong argument type (#{pblock.class}; must be a parameterized block.") unless pblock.is_a? Puppet::Parser::AST::Lambda
 
   case receiver
   when Array
-    receiver.reject {|x| pblock.call(self, x) }
+    receiver.select {|x| pblock.call(self, x) }
   when Hash
-    result = receiver.reject {|x, y| pblock.call(self, [x, y]) }
+    result = receiver.select {|x, y| pblock.call(self, [x, y]) }
     # Ruby 1.8.7 returns Array
     result = Hash[result] unless result.is_a? Hash
     result
   else
-    raise ArgumentError, ("reject(): wrong argument type (#{receiver.class}; must be an Array or a Hash.")
+    raise ArgumentError, ("filter(): wrong argument type (#{receiver.class}; must be an Array or a Hash.")
   end
 end

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

@@ -1,12 +1,20 @@
 require 'digest/md5'
 
 Puppet::Parser::Functions::newfunction(:fqdn_rand, :arity => -2, :type => :rvalue, :doc =>
-  "Generates random numbers based on the node's fqdn. Generated random values
-  will be a range from 0 up to and excluding n, where n is the first parameter.
-  The second argument specifies a number to add to the seed and is optional, for example:
+  "Usage: `fqdn_rand(MAX, [SEED])`. MAX is required and must be a positive
+  integer; SEED is optional and may be any number or string.
 
-      $random_number = fqdn_rand(30)
-      $random_number_seed = fqdn_rand(30,30)") do |args|
+  Generates a random whole number greater than or equal to 0 and less than MAX,
+  combining the `$fqdn` fact and the value of SEED for repeatable randomness.
+  (That is, each node will get a different random number from this function, but
+  a given node's result will be the same every time unless its hostname changes.)
+
+  This function is usually used for spacing out runs of resource-intensive cron
+  tasks that run on many nodes, which could cause a thundering herd or degrade
+  other services if they all fire at once. Adding a SEED can be useful when you
+  have more than one such task and need several unrelated random numbers per
+  node. (For example, `fqdn_rand(30)`, `fqdn_rand(30, 'expensive job 1')`, and
+  `fqdn_rand(30, 'expensive job 2')` will produce totally different numbers.)") do |args|
     max = args.shift.to_i
     seed = Digest::MD5.hexdigest([self['::fqdn'],args].join(':')).hex
     Puppet::Util.deterministic_rand(seed,max)

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

@@ -1,5 +1,22 @@
 # Include the specified classes
-Puppet::Parser::Functions::newfunction(:include, :arity => -2, :doc => "Evaluate one or more classes.") do |vals|
+Puppet::Parser::Functions::newfunction(:include, :arity => -2, :doc => "Declares one or more classes, causing the resources in them to be
+evaluated and added to the catalog. Accepts a class name, an array of class
+names, or a comma-separated list of class names.
+
+The `include` function can be used multiple times on the same class and will
+only declare a given class once. If a class declared with `include` has any
+parameters, Puppet will automatically look up values for them in Hiera, using
+`<class name>::<parameter name>` as the lookup key.
+
+Contrast this behavior with resource-like class declarations
+(`class {'name': parameter => 'value',}`), which must be used in only one place
+per class and can directly set parameters. You should avoid using both `include`
+and resource-like declarations with the same class.
+
+The `include` function does not cause classes to be contained in the class
+where they are declared. For that, see the `contain` function. It also
+does not create a dependency relationship between the declared class and th
+surrounding class; for that, see the `require` function.") do |vals|
     if vals.is_a?(Array)
       # Protect against array inside array
       vals = vals.flatten

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

@@ -0,0 +1,44 @@
+require 'puppet/parser/ast/lambda'
+
+Puppet::Parser::Functions::newfunction(
+:map,
+: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.map |$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*
+
+        # Turns hash into array of values
+        $a.map |$x|{ $x[1] }
+
+        # Turns hash into array of keys
+        $a.map |$x| { $x[0] }
+
+  - Since 3.4
+  - requires `parser = future`.
+  ENDHEREDOC
+
+  receiver = args[0]
+  pblock = args[1]
+
+  raise ArgumentError, ("map(): 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, ("map(): wrong argument type (#{receiver.class}; must be an Array or a Hash.")
+  end
+
+  receiver.to_a.map {|x| pblock.call(self, x) }
+end

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

@@ -1,47 +1,15 @@
-require 'puppet/parser/ast/lambda'
-
 Puppet::Parser::Functions::newfunction(
 :select,
 :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 entires for which the block evaluates to true.
-
-  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.select |$x| { ... }
-
-  When the first argument 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]`.
-
-  The returned filtered object is of the same type as the receiver.
+  The 'select' function has been renamed to 'filter'. Please update your manifests.
 
-  *Examples*
-
-        # selects all that end with berry
-        $a = ["raspberry", "blueberry", "orange"]
-        $a.select |$x| { $x =~ /berry$/ }
-
-  - Since 3.2
+  The select function is reserved for future use.
+  - Removed as of 3.4
   - requires `parser = future`.
   ENDHEREDOC
 
-  receiver = args[0]
-  pblock = args[1]
-
-  raise ArgumentError, ("select(): wrong argument type (#{pblock.class}; must be a parameterized block.") unless pblock.is_a? Puppet::Parser::AST::Lambda
-
-  case receiver
-  when Array
-    receiver.select {|x| pblock.call(self, x) }
-  when Hash
-    result = receiver.select {|x, y| pblock.call(self, [x, y]) }
-    # Ruby 1.8.7 returns Array
-    result = Hash[result] unless result.is_a? Hash
-    result
-  else
-    raise ArgumentError, ("select(): wrong argument type (#{receiver.class}; must be an Array or a Hash.")
-  end
-end
+  raise NotImplementedError,
+    "The 'select' function has been renamed to 'filter'. Please update your manifests."
+end

data/lib/puppet/parser/lexer.rb

@@ -347,7 +347,7 @@ class Puppet::Parser::Lexer
   def file=(file)
     @file = file
     @line = 1
-    contents = File.exists?(file) ? File.read(file) : ""
+    contents = Puppet::FileSystem::File.exist?(file) ? File.read(file) : ""
     @scanner = StringScanner.new(contents)
   end
 

data/lib/puppet/parser/parser_support.rb

@@ -82,7 +82,7 @@ class Puppet::Parser::Parser
   def_delegators :@lexer, :file, :string=
 
   def file=(file)
-    unless FileTest.exist?(file)
+    unless Puppet::FileSystem::File.exist?(file)
       unless file =~ /\.pp$/
         file = file + ".pp"
       end

data/lib/puppet/parser/resource.rb

@@ -1,12 +1,9 @@
-require 'forwardable'
 require 'puppet/resource'
 
 # The primary difference between this class and its
 # parent is that this class has rules on who can set
 # parameters
 class Puppet::Parser::Resource < Puppet::Resource
-  extend Forwardable
-
   require 'puppet/parser/resource/param'
   require 'puppet/util/tagging'
   require 'puppet/parser/yaml_trimmer'
@@ -18,7 +15,6 @@ class Puppet::Parser::Resource < Puppet::Resource
   include Puppet::Util::MethodHelper
   include Puppet::Util::Errors
   include Puppet::Util::Logging
-  include Puppet::Util::Tagging
   include Puppet::Parser::YamlTrimmer
 
   attr_accessor :source, :scope, :collector_id
@@ -56,7 +52,9 @@ class Puppet::Parser::Resource < Puppet::Resource
     end
   end
 
-  def_delegator :scope, :environment
+  def environment
+    scope.environment
+  end
 
   # Process the  stage metaparameter for a class.   A containment edge
   # is drawn from  the class to the stage.   The stage for containment
@@ -188,47 +186,10 @@ class Puppet::Parser::Resource < Puppet::Resource
     end
   end
 
-
-  # Create a Puppet::Resource instance from this parser resource.
-  # We plan, at some point, on not needing to do this conversion, but
-  # it's sufficient for now.
-  def to_resource
-    result = Puppet::Resource.new(type, title)
-
-    to_hash.each do |p, v|
-      if v.is_a?(Puppet::Resource)
-        v = Puppet::Resource.new(v.type, v.title)
-      elsif v.is_a?(Array)
-        # flatten resource references arrays
-        v = v.flatten if v.flatten.find { |av| av.is_a?(Puppet::Resource) }
-        v = v.collect do |av|
-          av = Puppet::Resource.new(av.type, av.title) if av.is_a?(Puppet::Resource)
-          av
-        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
-    end
-
-    result.file = self.file
-    result.line = self.line
-    result.exported = self.exported
-    result.virtual = self.virtual
-    result.tag(*self.tags)
-
-    result
-  end
-
   # Convert this resource to a RAL resource.
-  def_delegator :to_resource, :to_ral
+  def to_ral
+    copy_as_resource.to_ral
+  end
 
   private
 

data/lib/puppet/parser/scope.rb

@@ -116,6 +116,9 @@ class Puppet::Parser::Scope
     compiler.node.name
   end
 
+  # TODO: 19514 - this is smelly; who uses this? functions? templates?
+  # What about trusted facts ? Should untrusted facts be removed from facts?
+  #
   def facts
     compiler.node.facts
   end
@@ -195,8 +198,6 @@ class Puppet::Parser::Scope
 
     extend_with_functions_module
 
-    @tags = []
-
     # The symbol table for this scope.  This is where we store variables.
     @symtable = Ephemeral.new(nil, true)
 
@@ -461,6 +462,8 @@ class Puppet::Parser::Scope
     }
   end
 
+  RESERVED_VARIABLE_NAMES = ['trusted'].freeze
+
   # Set a variable in the current scope.  This will override settings
   # in scopes above, but will not allow variables in the current scope
   # to be reassigned.
@@ -474,6 +477,11 @@ class Puppet::Parser::Scope
       raise Puppet::ParseError, "Scope variable name #{name.inspect} is a #{name.class}, not a string"
     end
 
+    # Check for reserved variable names
+    if Puppet[:trusted_node_data] && !options[:privileged] && RESERVED_VARIABLE_NAMES.include?(name)
+      raise Puppet::ParseError, "Attempt to assign to a reserved variable name: '#{name}'"
+    end
+
     table = effective_symtable options[:ephemeral]
     if table.bound?(name)
       if options[:append]
@@ -494,6 +502,29 @@ class Puppet::Parser::Scope
     table[name]
   end
 
+  def set_trusted(hash)
+    setvar('trusted', deep_freeze(hash), :privileged => true)
+  end
+
+  # Deeply freezes the given object. The object and its content must be of the types:
+  # Array, Hash, Numeric, Boolean, Symbol, Regexp, NilClass, or String. All other types raises an Error.
+  # (i.e. if they are assignable to Puppet::Pops::Types::Data type).
+  #
+  def deep_freeze(object)
+    case object
+    when Hash
+      object.each {|k, v| deep_freeze(k); deep_freeze(v) }
+    when NilClass
+      # do nothing
+    when String
+      object.freeze
+    else
+      raise Puppet::Error, "Unsupported data type: '#{object.class}"
+    end
+    object
+  end
+  private :deep_freeze
+
   # Return the effective "table" for setting variables.
   # This method returns the first ephemeral "table" that acts as a local scope, or this
   # scope's symtable. If the parameter `use_ephemeral` is true, the "top most" ephemeral "table"

data/lib/puppet/parser/type_loader.rb

@@ -7,61 +7,6 @@ class Puppet::Parser::TypeLoader
   extend  Forwardable
   include Puppet::Node::Environment::Helper
 
-  # Helper class that makes sure we don't try to import the same file
-  # more than once from either the same thread or different threads.
-  class Helper
-    include MonitorMixin
-    def initialize
-      super
-      # These hashes are indexed by filename
-      @state = {} # :doing or :done
-      @thread = {} # if :doing, thread that's doing the parsing
-      @cond_var = {} # if :doing, condition var that will be signaled when done.
-    end
-
-    # Execute the supplied block exactly once per file, no matter how
-    # many threads have asked for it to run.  If another thread is
-    # already executing it, wait for it to finish.  If this thread is
-    # already executing it, return immediately without executing the
-    # block.
-    #
-    # Note: the reason for returning immediately if this thread is
-    # already executing the block is to handle the case of a circular
-    # import--when this happens, we attempt to recursively re-parse a
-    # file that we are already in the process of parsing.  To prevent
-    # an infinite regress we need to simply do nothing when the
-    # recursive import is attempted.
-    def do_once(file)
-      need_to_execute = synchronize do
-        case @state[file]
-        when :doing
-          if @thread[file] != Thread.current
-            @cond_var[file].wait
-          end
-          false
-        when :done
-          false
-        else
-          @state[file] = :doing
-          @thread[file] = Thread.current
-          @cond_var[file] = new_cond
-          true
-        end
-      end
-      if need_to_execute
-        begin
-          yield
-        ensure
-          synchronize do
-            @state[file] = :done
-            @thread.delete(file)
-            @cond_var.delete(file).broadcast
-          end
-        end
-      end
-    end
-  end
-
   # Import manifest files that match a given file glob pattern.
   #
   # @param pattern [String] the file glob to apply when determining which files
@@ -103,7 +48,6 @@ class Puppet::Parser::TypeLoader
 
   def initialize(env)
     self.environment = env
-    @loading_helper = Helper.new
   end
 
   # Try to load the object with the given fully qualified name.
@@ -148,11 +92,11 @@ class Puppet::Parser::TypeLoader
   end
 
   def load_files(modname, files)
+    @loaded ||= {}
     loaded_asts = []
-    files.each do |file|
-      @loading_helper.do_once(file) do
-        loaded_asts << parse_file(file)
-      end
+    files.reject { |file| @loaded[file] }.each do |file|
+      loaded_asts << parse_file(file)
+      @loaded[file] = true
     end
 
     loaded_asts.collect do |ast|