puppet 3.1.1 → 3.2.0.rc1

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

@@ -21,6 +21,13 @@ class Puppet::Parser::AST
           scope.setvar(name,value, :file => file, :line => line, :append => @append)
         end
       end
+      if @append
+        # Produce resulting value from append operation
+        scope[name]
+      else
+        # Produce assigned value
+        value
+      end
     end
 
     def each

data/lib/puppet/parser/compiler.rb

@@ -90,18 +90,19 @@ class Puppet::Parser::Compiler
   # This is the main entry into our catalog.
   def compile
     # Set the client's parameters into the top scope.
-    set_node_parameters
-    create_settings_scope
+    Puppet::Util::Profiler.profile("Compile: Set node parameters") { set_node_parameters }
 
-    evaluate_main
+    Puppet::Util::Profiler.profile("Compile: Created settings scope") { create_settings_scope }
 
-    evaluate_ast_node
+    Puppet::Util::Profiler.profile("Compile: Evaluated main") { evaluate_main }
 
-    evaluate_node_classes
+    Puppet::Util::Profiler.profile("Compile: Evaluated AST node") { evaluate_ast_node }
 
-    evaluate_generators
+    Puppet::Util::Profiler.profile("Compile: Evaluated node classes") { evaluate_node_classes }
 
-    finish
+    Puppet::Util::Profiler.profile("Compile: Evaluated generators") { evaluate_generators }
+
+    Puppet::Util::Profiler.profile("Compile: Finished catalog") { finish }
 
     fail_on_unevaluated
 
@@ -226,17 +227,18 @@ class Puppet::Parser::Compiler
   def evaluate_collections
     return false if @collections.empty?
 
-    found_something = false
     exceptwrap do
       # We have to iterate over a dup of the array because
       # collections can delete themselves from the list, which
       # changes its length and causes some collections to get missed.
-      @collections.dup.each do |collection|
-        found_something = true if collection.evaluate
+      Puppet::Util::Profiler.profile("Evaluated collections") do
+        found_something = false
+        @collections.dup.each do |collection|
+          found_something = true if collection.evaluate
+        end
+        found_something
       end
     end
-
-    found_something
   end
 
   # Make sure all of our resources have been evaluated into native resources.
@@ -244,7 +246,13 @@ class Puppet::Parser::Compiler
   # evaluate_generators loop.
   def evaluate_definitions
     exceptwrap do
-      !unevaluated_resources.each { |resource| resource.evaluate }.empty?
+      Puppet::Util::Profiler.profile("Evaluated definitions") do
+        !unevaluated_resources.each do |resource|
+          Puppet::Util::Profiler.profile("Evaluated resource #{resource}") do
+            resource.evaluate
+          end
+        end.empty?
+      end
     end
   end
 
@@ -257,9 +265,12 @@ class Puppet::Parser::Compiler
     loop do
       done = true
 
-      # Call collections first, then definitions.
-      done = false if evaluate_collections
-      done = false if evaluate_definitions
+      Puppet::Util::Profiler.profile("Iterated (#{count + 1}) on generators") do
+        # Call collections first, then definitions.
+        done = false if evaluate_collections
+        done = false if evaluate_definitions
+      end
+
       break if done
 
       count += 1

data/lib/puppet/parser/e_parser_adapter.rb

@@ -0,0 +1,120 @@
+require 'puppet/pops'
+
+module Puppet; module Parser; end; end;
+# Adapts an egrammar/eparser to respond to the public API of the classic parser
+#
+class Puppet::Parser::EParserAdapter
+
+  def initialize(classic_parser)
+    @classic_parser = classic_parser
+    @file = ''
+    @string = ''
+    @use = :undefined
+  end
+
+  def file=(file)
+    @classic_parser.file = file
+    @file = file
+    @use = :file
+  end
+
+  def parse(string = nil)
+    if @file =~ /\.rb$/
+      return parse_ruby_file
+    else
+      self.string= string if string
+      parser = Puppet::Pops::Parser::Parser.new()
+      parse_result = if @use == :string
+        parser.parse_string(@string)
+      else
+        parser.parse_file(@file)
+      end
+      # Compute the source_file to set in created AST objects (it was either given, or it may be unknown
+      # if caller did not set a file and the present a string.
+      #
+      source_file = @file || "unknown-source-location"
+
+      # Validate
+      validate(parse_result)
+
+      # Transform the result, but only if not nil
+      parse_result = Puppet::Pops::Model::AstTransformer.new(source_file, @classic_parser).transform(parse_result) if parse_result
+      if parse_result && !parse_result.is_a?(Puppet::Parser::AST::BlockExpression)
+        # Need to transform again, if result is not wrapped in something iterable when handed off to
+        # a new Hostclass as its code.
+        parse_result = Puppet::Parser::AST::BlockExpression.new(:children => [parse_result]) if parse_result
+      end
+    end
+
+    Puppet::Parser::AST::Hostclass.new('', :code => parse_result)
+  end
+
+  def validate(parse_result)
+    # TODO: This is too many hoops to jump through... ugly API
+    # could reference a ValidatorFactory.validator_3_1(acceptor) instead.
+    # and let the factory abstract the rest.
+    #
+    return unless parse_result
+
+    acceptor  = Puppet::Pops::Validation::Acceptor.new
+    validator = Puppet::Pops::Validation::ValidatorFactory_3_1.new().validator(acceptor)
+    validator.validate(parse_result)
+
+    max_errors = Puppet[:max_errors]
+    max_warnings = Puppet[:max_warnings] + 1
+    max_deprecations = Puppet[:max_deprecations] + 1
+
+    # If there are warnings output them
+    warnings = acceptor.warnings
+    if warnings.size > 0
+      formatter = Puppet::Pops::Validation::DiagnosticFormatterPuppetStyle.new
+      emitted_w = 0
+      emitted_dw = 0
+      acceptor.warnings.each {|w|
+        if w.severity == :deprecation
+          # Do *not* call Puppet.deprecation_warning it is for internal deprecation, not
+          # deprecation of constructs in manifests! (It is not designed for that purpose even if
+          # used throughout the code base).
+          #
+          Puppet.warning(formatter.format(w)) if emitted_dw < max_deprecations
+          emitted_dw += 1
+        else
+          Puppet.warning(formatter.format(w)) if emitted_w < max_warnings
+          emitted_w += 1
+        end
+        break if emitted_w > max_warnings && emitted_dw > max_deprecations # but only then
+      }
+    end
+
+    # If there were errors, report the first found. Use a puppet style formatter.
+    errors = acceptor.errors
+    if errors.size > 0
+      formatter = Puppet::Pops::Validation::DiagnosticFormatterPuppetStyle.new
+      if errors.size == 1 || max_errors <= 1
+        # raise immediately
+        raise Puppet::ParseError.new(formatter.format(errors[0]))
+      end
+      emitted = 0
+      errors.each do |e|
+        Puppet.err(formatter.format(e))
+        emitted += 1
+        break if emitted >= max_errors
+      end
+      warnings_message = warnings.size > 0 ? ", and #{warnings.size} warnings" : ""
+      giving_up_message = "Found #{errors.size} errors#{warnings_message}. Giving up"
+      exception = Puppet::ParseError.new(giving_up_message)
+      exception.file = errors[0].file
+      raise exception
+    end
+  end
+
+  def string=(string)
+    @classic_parser.string = string
+    @string = string
+    @use = :string
+  end
+
+  def parse_ruby_file
+    @classic_parser.parse
+  end
+end

data/lib/puppet/parser/files.rb

@@ -1,11 +1,12 @@
 require 'puppet/module'
-require 'puppet/parser/parser'
+#require 'puppet/parser/parser'
 
 # This is a silly central module for finding
 # different kinds of files while parsing.  This code
 # doesn't really belong in the Puppet::Module class,
 # but it doesn't really belong anywhere else, either.
-module Puppet::Parser::Files
+module Puppet; module Parser; module Files
+  
   module_function
 
   # Return a list of manifests (as absolute filenames) that match +pat+
@@ -28,9 +29,9 @@ module Puppet::Parser::Files
   end
 
   # Find the concrete file denoted by +file+. If +file+ is absolute,
-  # return it directly. Otherwise try to find it as a template in a
-  # module. If that fails, return it relative to the +templatedir+ config
-  # param.
+  # return it directly. Otherwise try to find relative to the +templatedir+
+  # config param.  If that fails try to find it as a template in a
+  # module.
   # In all cases, an absolute path is returned, which does not
   # necessarily refer to an existing file
   def find_template(template, environment = nil)
@@ -85,4 +86,4 @@ module Puppet::Parser::Files
     path.split(File::SEPARATOR, 2) unless path == "" or Puppet::Util.absolute_path?(path)
   end
 
-end
+end; end; end

data/lib/puppet/parser/functions.rb

@@ -137,15 +137,17 @@ module Puppet::Parser::Functions
 
     fname = "function_#{name}"
     environment_module.send(:define_method, fname) do |*args|
-      if args[0].is_a? Array
-        if arity >= 0 and args[0].size != arity
-          raise ArgumentError, "#{name}(): Wrong number of arguments given (#{args[0].size} for #{arity})"
-        elsif arity < 0 and args[0].size < (arity+1).abs
-          raise ArgumentError, "#{name}(): Wrong number of arguments given (#{args[0].size} for minimum #{(arity+1).abs})"
+      Puppet::Util::Profiler.profile("Called #{name}") do
+        if args[0].is_a? Array
+          if arity >= 0 and args[0].size != arity
+            raise ArgumentError, "#{name}(): Wrong number of arguments given (#{args[0].size} for #{arity})"
+          elsif arity < 0 and args[0].size < (arity+1).abs
+            raise ArgumentError, "#{name}(): Wrong number of arguments given (#{args[0].size} for minimum #{(arity+1).abs})"
+          end
+          self.send(real_fname, args[0])
+        else
+          raise ArgumentError, "custom functions must be called with a single array that contains the arguments. For example, function_example([1]) instead of function_example(1)"
         end
-        self.send(real_fname, args[0])
-      else
-        raise ArgumentError, "custom functions must be called with a single array that contains the arguments. For example, function_example([1]) instead of function_example(1)"
       end
     end
 

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

@@ -0,0 +1,43 @@
+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 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.collect |$x|{ $x[1] }
+
+    # Turns hash into array of keys
+    $a.collect |$x| { $x[0] }
+
+  Since 3.2
+  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

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

@@ -0,0 +1,96 @@
+Puppet::Parser::Functions::newfunction(
+:each,
+:type => :rvalue,
+:arity => 2,
+:doc => <<-'ENDHEREDOC') do |args|
+  Applies a parameterized block to each element in a sequence of selected entries from the first
+  argument and returns the first argument.
+
+  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.each {|$x| ... }
+
+  When the first argument is an Array, the parameterized block should define one or two block parameters.
+  For each application of the block, the next element from the array is selected, and it is passed to
+  the block if the block has one parameter. If the block has two parameters, the first is the elements
+  index, and the second the value. The index starts from 0.
+
+    $a.each {|$index, $value| ... }
+
+  When the first argument is a Hash, the parameterized block should define one or two parameters.
+  When one parameter is defined, the iteration is performed with each entry as an array of `[key, value]`,
+  and when two parameters are defined the iteration is performed with key and value.
+
+    $a.each {|$entry|       ..."key ${$entry[0]}, value ${$entry[1]}" }
+    $a.each {|$key, $value| ..."key ${key}, value ${value}" }
+
+  Since 3.2
+  ENDHEREDOC
+  require 'puppet/parser/ast/lambda'
+
+  def foreach_Array(o, scope, pblock)
+    return nil unless pblock
+
+    serving_size = pblock.parameter_count
+    if serving_size == 0
+      raise ArgumentError, "Block must define at least one parameter; value."
+    end
+    if serving_size > 2
+      raise ArgumentError, "Block must define at most two parameters; index, value"
+    end
+    enumerator = o.each
+    index = 0
+    result = nil
+    if serving_size == 1
+      (o.size).times do
+        pblock.call(scope, enumerator.next)
+      end
+    else
+      (o.size).times do
+        pblock.call(scope, index, enumerator.next)
+        index = index +1
+      end
+    end
+    o
+  end
+
+  def foreach_Hash(o, scope, pblock)
+    return nil unless pblock
+    serving_size = pblock.parameter_count
+    case serving_size
+    when 0
+      raise ArgumentError, "Block must define at least one parameter (for hash entry key)."
+    when 1
+    when 2
+    else
+      raise ArgumentError, "Block must define at most two parameters (for hash entry key and value)."
+    end
+    enumerator = o.each_pair
+    result = nil
+    if serving_size == 1
+      (o.size).times do
+        pblock.call(scope, enumerator.next)
+      end
+    else
+      (o.size).times do
+        pblock.call(scope, *enumerator.next)
+      end
+    end
+    o
+  end
+
+  raise ArgumentError, ("each(): wrong number of arguments (#{args.length}; must be 2)") if args.length != 2
+  receiver = args[0]
+  pblock = args[1]
+  raise ArgumentError, ("each(): wrong argument type (#{args[1].class}; must be a parameterized block.") unless pblock.is_a? Puppet::Parser::AST::Lambda
+
+  case receiver
+  when Array
+    foreach_Array(receiver, self, pblock)
+  when Hash
+    foreach_Hash(receiver, self, pblock)
+  else
+    raise ArgumentError, ("each(): wrong argument type (#{args[0].class}; must be an Array or a Hash.")
+  end
+end

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

@@ -0,0 +1,96 @@
+Puppet::Parser::Functions::newfunction(
+:foreach,
+:type => :rvalue,
+:arity => 2,
+:doc => <<-'ENDHEREDOC') do |args|
+  Applies a parameterized block to each element in a sequence of selected entries from the first
+  argument and returns the first argument.
+
+  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.foreach {|$x| ... }
+
+  When the first argument is an Array, the parameterized block should define one or two block parameters.
+  For each application of the block, the next element from the array is selected, and it is passed to
+  the block if the block has one parameter. If the block has two parameters, the first is the elements
+  index, and the second the value. The index starts from 0.
+
+    $a.foreach {|$index, $value| ... }
+
+  When the first argument is a Hash, the parameterized block should define one or two parameters.
+  When one parameter is defined, the iteration is performed with each entry as an array of `[key, value]`,
+  and when two parameters are defined the iteration is performed with key and value.
+
+    $a.foreach {|$entry|       ..."key ${$entry[0]}, value ${$entry[1]}" }
+    $a.foreach {|$key, $value| ..."key ${key}, value ${value}" }
+
+  Since 3.2
+  ENDHEREDOC
+  require 'puppet/parser/ast/lambda'
+
+  def foreach_Array(o, scope, pblock)
+    return nil unless pblock
+
+    serving_size = pblock.parameter_count
+    if serving_size == 0
+      raise ArgumentError, "Block must define at least one parameter; value."
+    end
+    if serving_size > 2
+      raise ArgumentError, "Block must define at most two parameters; index, value"
+    end
+    enumerator = o.each
+    index = 0
+    result = nil
+    if serving_size == 1
+      (o.size).times do
+        pblock.call(scope, enumerator.next)
+      end
+    else
+      (o.size).times do
+        pblock.call(scope, index, enumerator.next)
+        index = index +1
+      end
+    end
+    o
+  end
+
+  def foreach_Hash(o, scope, pblock)
+    return nil unless pblock
+    serving_size = pblock.parameter_count
+    case serving_size
+    when 0
+      raise ArgumentError, "Block must define at least one parameter (for hash entry key)."
+    when 1
+    when 2
+    else
+      raise ArgumentError, "Block must define at most two parameters (for hash entry key and value)."
+    end
+    enumerator = o.each_pair
+    result = nil
+    if serving_size == 1
+      (o.size).times do
+        pblock.call(scope, enumerator.next)
+      end
+    else
+      (o.size).times do
+        pblock.call(scope, *enumerator.next)
+      end
+    end
+    o
+  end
+
+  raise ArgumentError, ("foreach(): wrong number of arguments (#{args.length}; must be 2)") if args.length != 2
+  receiver = args[0]
+  pblock = args[1]
+  raise ArgumentError, ("foreach(): wrong argument type (#{args[1].class}; must be a parameterized block.") unless pblock.is_a? Puppet::Parser::AST::Lambda
+
+  case receiver
+  when Array
+    foreach_Array(receiver, self, pblock)
+  when Hash
+    foreach_Hash(receiver, self, pblock)
+  else
+    raise ArgumentError, ("foreach(): wrong argument type (#{args[0].class}; must be an Array or a Hash.")
+  end
+end