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

data/lib/puppet/functions/slice.rb

@@ -0,0 +1,126 @@
+# Applies a parameterized block to each _slice_ of elements in a sequence of selected entries from the first
+# argument and returns the first argument, or if no block is given returns a new array with a concatenation of
+# the slices.
+#
+# This function takes two mandatory arguments: the first, `$a`, should be an Array, Hash, or something of
+# enumerable type (integer, Integer range, or String), and the second, `$n`, the number of elements to include
+# in each slice. The optional third argument should be a a parameterized block as produced by the puppet syntax:
+#
+#     $a.slice($n) |$x| { ... }
+#     slice($a) |$x| { ... }
+#
+# The parameterized block should have either one parameter (receiving an array with the slice), or the same number
+# of parameters as specified by the slice size (each parameter receiving its part of the slice).
+# In case there are fewer remaining elements than the slice size for the last slice it will contain the remaining
+# elements. When the block has multiple parameters, excess parameters are set to undef for an array or
+# enumerable type, and to empty arrays for a Hash.
+#
+#     $a.slice(2) |$first, $second| { ... }
+#
+# When the first argument is a Hash, each `key,value` entry is counted as one, e.g, a slice size of 2 will produce
+# an array of two arrays with key, and value.
+#
+# @example Using slice with Hash
+#
+#     $a.slice(2) |$entry|          { notice "first ${$entry[0]}, second ${$entry[1]}" }
+#     $a.slice(2) |$first, $second| { notice "first ${first}, second ${second}" }
+#
+# When called without a block, the function produces a concatenated result of the slices.
+#
+# @example Using slice without a block
+#
+#     slice([1,2,3,4,5,6], 2) # produces [[1,2], [3,4], [5,6]]
+#     slice(Integer[1,6], 2)  # produces [[1,2], [3,4], [5,6]]
+#     slice(4,2)              # produces [[0,1], [2,3]]
+#     slice('hello',2)        # produces [[h, e], [l, l], [o]]
+#
+# @since 3.2 for Array and Hash
+# @since 3.5 for additional enumerable types
+# @note requires `parser = future`.
+#
+Puppet::Functions.create_function(:slice) do
+  dispatch :slice_Hash do
+    param 'Hash[Any, Any]', :hash
+    param 'Integer[1, default]', :slize_size
+    optional_block_param
+  end
+
+  dispatch :slice_Enumerable do
+    param 'Any', :enumerable
+    param 'Integer[1, default]', :slize_size
+    optional_block_param
+  end
+
+  def slice_Hash(hash, slice_size, pblock = nil)
+    result = slice_Common(hash, slice_size, [], pblock)
+    pblock ? hash : result
+  end
+
+  def slice_Enumerable(enumerable, slice_size, pblock = nil)
+    enum = asserted_enumerable(enumerable)
+    result = slice_Common(enum, slice_size, nil, pblock)
+    pblock ? enumerable : result
+  end
+
+  def slice_Common(o, slice_size, filler, pblock)
+    serving_size = asserted_slice_serving_size(pblock, slice_size)
+
+    enumerator = o.each_slice(slice_size)
+    result = []
+    if serving_size == 1
+      begin
+        if pblock
+          loop do
+            pblock.call(nil, enumerator.next)
+          end
+        else
+          loop do
+            result << enumerator.next
+          end
+        end
+      rescue StopIteration
+      end
+    else
+      begin
+        loop do
+          a = enumerator.next
+          if a.size < serving_size
+            a = a.dup.fill(filler, a.length...serving_size)
+          end
+          pblock.call(nil, *a)
+        end
+      rescue StopIteration
+      end
+    end
+    if pblock
+      o
+    else
+      result
+    end
+  end
+
+  def asserted_slice_serving_size(pblock, slice_size)
+    if pblock
+      serving_size = pblock.last_captures_rest? ? slice_size : pblock.parameter_count
+    else
+      serving_size = 1
+    end
+    if serving_size == 0
+      raise ArgumentError, "slice(): block must define at least one parameter. Block has 0."
+    end
+    unless serving_size == 1 || serving_size == slice_size
+      raise ArgumentError, "slice(): block must define one parameter, or " +
+        "the same number of parameters as the given size of the slice (#{slice_size}). Block has #{serving_size}; "+
+      pblock.parameter_names.join(', ')
+    end
+    serving_size
+  end
+
+  def asserted_enumerable(obj)
+    unless enum = Puppet::Pops::Types::Enumeration.enumerator(obj)
+      raise ArgumentError, ("#{self.class.name}(): wrong argument type (#{obj.class}; must be something enumerable.")
+    end
+    enum
+  end
+
+end

data/lib/puppet/functions/with.rb

@@ -0,0 +1,23 @@
+# Call a lambda with the given arguments. Since the parameters of the lambda
+# are local to the lambda's scope, this can be used to create private sections
+# of logic in a class so that the variables are not visible outside of the
+# class.
+#
+# @example Using with
+#
+#     # notices the array [1, 2, 'foo']
+#     with(1, 2, 'foo') |$x, $y, $z| { notice [$x, $y, $z] }
+#
+# @since 3.7.0
+#
+Puppet::Functions.create_function(:with) do
+  dispatch :with do
+    param 'Any', 'arg'
+    arg_count(0, :default)
+    required_block_param
+  end
+
+  def with(*args)
+    args[-1].call({}, *args[0..-2])
+  end
+end

data/lib/puppet/indirector/catalog/compiler.rb

@@ -17,7 +17,7 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
       raise ArgumentError, "Facts but no fact format provided for #{request.key}"
     end
 
-    Puppet::Util::Profiler.profile("Found facts") do
+    Puppet::Util::Profiler.profile("Found facts", [:compiler, :find_facts]) do
       # If the facts were encoded as yaml, then the param reconstitution system
       # in Network::HTTP::Handler will automagically deserialize the value.
       if text_facts.is_a?(Puppet::Node::Facts)
@@ -65,7 +65,7 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
   end
 
   def initialize
-    Puppet::Util::Profiler.profile("Setup server facts for compiling") do
+    Puppet::Util::Profiler.profile("Setup server facts for compiling", [:compiler, :init_server_facts]) do
       set_server_facts
     end
   end
@@ -90,7 +90,7 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
     config = nil
 
     benchmark(:notice, str) do
-      Puppet::Util::Profiler.profile(str) do
+      Puppet::Util::Profiler.profile(str, [:compiler, :compile, node.environment, node.name]) do
         begin
           config = Puppet::Parser::Compiler.compile(node)
         rescue Puppet::Error => detail
@@ -105,7 +105,7 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
 
   # Turn our host name into a node object.
   def find_node(name, environment, transaction_uuid)
-    Puppet::Util::Profiler.profile("Found node information") do
+    Puppet::Util::Profiler.profile("Found node information", [:compiler, :find_node]) do
       node = nil
       begin
         node = Puppet::Node.indirection.find(name, :environment => environment,

data/lib/puppet/indirector/data_binding/hiera.rb

@@ -1,50 +1,7 @@
-require 'puppet/indirector/code'
+require 'puppet/indirector/hiera'
 require 'hiera/scope'
 
-class Puppet::DataBinding::Hiera < Puppet::Indirector::Code
+class Puppet::DataBinding::Hiera < Puppet::Indirector::Hiera
   desc "Retrieve data using Hiera."
-
-  def initialize(*args)
-    if ! Puppet.features.hiera?
-      raise "Hiera terminus not supported without hiera library"
-    end
-    super
-  end
-
-  if defined?(::Psych::SyntaxError)
-    DataBindingExceptions = [::StandardError, ::Psych::SyntaxError]
-  else
-    DataBindingExceptions = [::StandardError]
-  end
-
-  def find(request)
-    hiera.lookup(request.key, nil, Hiera::Scope.new(request.options[:variables]), nil, nil)
-  rescue *DataBindingExceptions => detail
-    raise Puppet::DataBinding::LookupError.new(detail.message, detail)
-  end
-
-  private
-
-  def self.hiera_config
-    hiera_config = Puppet.settings[:hiera_config]
-    config = {}
-
-    if Puppet::FileSystem.exist?(hiera_config)
-      config = Hiera::Config.load(hiera_config)
-    else
-      Puppet.warning "Config file #{hiera_config} not found, using Hiera defaults"
-    end
-
-    config[:logger] = 'puppet'
-    config
-  end
-
-  def self.hiera
-    @hiera ||= Hiera.new(:config => hiera_config)
-  end
-
-  def hiera
-    self.class.hiera
-  end
 end
 

data/lib/puppet/indirector/facts/couch.rb

@@ -2,7 +2,9 @@ require 'puppet/node/facts'
 require 'puppet/indirector/couch'
 class Puppet::Node::Facts::Couch < Puppet::Indirector::Couch
 
-  desc "Store facts in CouchDB. This should not be used with the inventory service;
+  desc "DEPRECATED. This terminus will be removed in Puppet 4.0.
+
+    Store facts in CouchDB. This should not be used with the inventory service;
     it is for more obscure custom integrations. If you are wondering whether you
     should use it, you shouldn't; use PuppetDB instead."
   # Return the facts object or nil if there is no document

data/lib/puppet/indirector/facts/facter.rb

@@ -6,86 +6,73 @@ class Puppet::Node::Facts::Facter < Puppet::Indirector::Code
     between Puppet and Facter.  It's only `somewhat` abstract because it always
     returns the local host's facts, regardless of what you attempt to find."
 
-  private
-
-  def self.reload_facter
-    Facter.clear
-    Facter.loadfacts
+  def destroy(facts)
+    raise Puppet::DevError, 'You cannot destroy facts in the code store; it is only used for getting facts from Facter'
   end
 
-  def self.load_fact_plugins
-    # Add any per-module fact directories to the factpath
-    module_fact_dirs = Puppet.lookup(:current_environment).modulepath.collect do |d|
-      ["lib", "plugins"].map do |subdirectory|
-        Dir.glob("#{d}/*/#{subdirectory}/facter")
-      end
-    end.flatten
-    dirs = module_fact_dirs + Puppet[:factpath].split(File::PATH_SEPARATOR)
-    dirs.uniq.each do |dir|
-      load_facts_in_dir(dir)
-    end
+  def save(facts)
+    raise Puppet::DevError, 'You cannot save facts to the code store; it is only used for getting facts from Facter'
   end
 
-  def self.setup_external_facts(request)
-    # Add any per-module fact directories to the factpath
-    external_facts_dirs = []
-    request.environment.modules.each do |m|
-         if m.has_external_facts?
-            Puppet.info "Loading external facts from #{m.plugin_fact_directory}"
-            external_facts_dirs << m.plugin_fact_directory
-         end
-    end
-
-    # Add system external fact directory if it exists
-    if File.directory?(Puppet[:pluginfactdest])
-      external_facts_dirs << Puppet[:pluginfactdest]
-    end
-
-    # Add to facter config
-    Facter.search_external external_facts_dirs
+  # Lookup a host's facts up in Facter.
+  def find(request)
+    Facter.reset
+    self.class.setup_external_search_paths(request) if Puppet.features.external_facts?
+    self.class.setup_search_paths(request)
 
+    result = Puppet::Node::Facts.new(request.key, Facter.to_hash)
+    result.add_local_facts
+    Puppet[:stringify_facts] ? result.stringify : result.sanitize
+    result
   end
 
-  def self.load_facts_in_dir(dir)
-    return unless FileTest.directory?(dir)
+  private
 
-    Dir.chdir(dir) do
-      Dir.glob("*.rb").each do |file|
-        fqfile = ::File.join(dir, file)
-        begin
-          Puppet.info "Loading facts in #{fqfile}"
-          ::Timeout::timeout(Puppet[:configtimeout]) do
-            load File.join('.', file)
-          end
-        rescue SystemExit,NoMemoryError
-          raise
-        rescue Exception => detail
-          Puppet.warning "Could not load fact file #{fqfile}: #{detail}"
+  def self.setup_search_paths(request)
+    # Add any per-module fact directories to facter's search path
+    dirs = request.environment.modulepath.collect do |dir|
+      ['lib', 'plugins'].map do |subdirectory|
+        Dir.glob("#{dir}/*/#{subdirectory}/facter")
+      end
+    end.flatten + Puppet[:factpath].split(File::PATH_SEPARATOR)
+
+    dirs = dirs.select do |dir|
+      next false unless FileTest.directory?(dir)
+
+      # Even through we no longer directly load facts in the terminus,
+      # print out each .rb in the facts directory as module
+      # developers may find that information useful for debugging purposes
+      if Puppet::Util::Log.sendlevel?(:info)
+        Puppet.info "Loading facts"
+        Dir.glob("#{dir}/*.rb").each do |file|
+          Puppet.debug "Loading facts from #{file}"
         end
       end
-    end
-  end
 
-  public
+      true
+    end
 
-  def destroy(facts)
-    raise Puppet::DevError, "You cannot destroy facts in the code store; it is only used for getting facts from Facter"
+    Facter.search *dirs
   end
 
-  # Look a host's facts up in Facter.
-  def find(request)
-    self.class.setup_external_facts(request) if Puppet.features.external_facts?
-    self.class.reload_facter
-    self.class.load_fact_plugins
-    result = Puppet::Node::Facts.new(request.key, Facter.to_hash)
-
-    result.add_local_facts
-    Puppet[:stringify_facts] ? result.stringify : result.sanitize
+  def self.setup_external_search_paths(request)
+    # Add any per-module external fact directories to facter's external search path
+    dirs = []
+    request.environment.modules.each do |m|
+      if m.has_external_facts?
+        dir = m.plugin_fact_directory
+        Puppet.debug "Loading external facts from #{dir}"
+        dirs << dir
+      end
+    end
 
-    result
-  end
+    # Add system external fact directory if it exists
+    if FileTest.directory?(Puppet[:pluginfactdest])
+      dir = Puppet[:pluginfactdest]
+      Puppet.debug "Loading external facts from #{dir}"
+      dirs << dir
+    end
 
-  def save(facts)
-    raise Puppet::DevError, "You cannot save facts to the code store; it is only used for getting facts from Facter"
+    Facter.search_external dirs
   end
 end

data/lib/puppet/indirector/file_bucket_file/file.rb

@@ -87,7 +87,10 @@ module Puppet::FileBucketFile
             Puppet::FileSystem.touch(contents_file)
           else
             Puppet::FileSystem.open(contents_file, 0440, 'wb') do |of|
-              of.write(bucket_file.contents)
+              # PUP-1044 writes all of the contents
+              bucket_file.stream() do |src|
+                FileUtils.copy_stream(src, of)
+              end
             end
           end
 
@@ -124,8 +127,8 @@ module Puppet::FileBucketFile
     # @param contents_file [Object] Opaque file path
     # @param bucket_file [IO]
     def verify_identical_file!(contents_file, bucket_file)
-      if bucket_file.contents.size == Puppet::FileSystem.size(contents_file)
-        if Puppet::FileSystem.compare_stream(contents_file, bucket_file.stream)
+      if bucket_file.size == Puppet::FileSystem.size(contents_file)
+        if bucket_file.stream() {|s| Puppet::FileSystem.compare_stream(contents_file, s) }
           Puppet.info "FileBucket got a duplicate file #{bucket_file.checksum}"
           return
         end

data/lib/puppet/indirector/hiera.rb

@@ -0,0 +1,48 @@
+require 'puppet/indirector/terminus'
+require 'hiera/scope'
+
+class Puppet::Indirector::Hiera < Puppet::Indirector::Terminus
+  def initialize(*args)
+    if ! Puppet.features.hiera?
+      raise "Hiera terminus not supported without hiera library"
+    end
+    super
+  end
+
+  if defined?(::Psych::SyntaxError)
+    DataBindingExceptions = [::StandardError, ::Psych::SyntaxError]
+  else
+    DataBindingExceptions = [::StandardError]
+  end
+
+  def find(request)
+    hiera.lookup(request.key, nil, Hiera::Scope.new(request.options[:variables]), nil, nil)
+  rescue *DataBindingExceptions => detail
+    raise Puppet::DataBinding::LookupError.new(detail.message, detail)
+  end
+
+  private
+
+  def self.hiera_config
+    hiera_config = Puppet.settings[:hiera_config]
+    config = {}
+
+    if Puppet::FileSystem.exist?(hiera_config)
+      config = Hiera::Config.load(hiera_config)
+    else
+      Puppet.warning "Config file #{hiera_config} not found, using Hiera defaults"
+    end
+
+    config[:logger] = 'puppet'
+    config
+  end
+
+  def self.hiera
+    @hiera ||= Hiera.new(:config => hiera_config)
+  end
+
+  def hiera
+    self.class.hiera
+  end
+end
+