puppet 3.2.4 → 3.3.0.rc2

data/lib/puppet/graph/sequential_prioritizer.rb

@@ -0,0 +1,31 @@
+# This implements a priority in which keys are given values that will keep them
+# in the same priority in which they priorities are requested. Nested
+# structures (those in which a key is contained within another key) are
+# preserved in such a way that child keys are after the parent and before the
+# key after the parent.
+#
+# @api private
+class Puppet::Graph::SequentialPrioritizer < Puppet::Graph::Prioritizer
+  def initialize
+    super
+    @container = {}
+    @count = Puppet::Graph::Key.new
+  end
+
+  def generate_priority_for(key)
+    if priority_of(key).nil?
+      @count = @count.next
+      record_priority_for(key, @count)
+    else
+      priority_of(key)
+    end
+  end
+
+  def generate_priority_contained_in(container, key)
+    @container[container] ||= priority_of(container).down
+    priority = @container[container].next
+    record_priority_for(key, priority)
+    @container[container] = priority
+    priority
+  end
+end

data/lib/puppet/{simple_graph.rb → graph/simple_graph.rb}

@@ -3,7 +3,7 @@ require 'puppet/relationship'
 require 'set'
 
 # A hopefully-faster graph class to replace the use of GRATR.
-class Puppet::SimpleGraph
+class Puppet::Graph::SimpleGraph
   #
   # All public methods of this class must maintain (assume ^ ensure) the following invariants, where "=~=" means
   # equiv. up to order:
@@ -178,7 +178,11 @@ class Puppet::SimpleGraph
     # Given we are in a failure state here, any extra cost is more or less
     # irrelevant compared to the cost of a fix - which is on a human
     # time-scale.
-    state[:scc].select { |c| c.length > 1 }.map {|x| x.sort }.sort
+    state[:scc].select do |component|
+      multi_vertex_component?(component) || single_vertex_referring_to_self?(component)
+    end.map do |component|
+      component.sort
+    end.sort
   end
 
   # Perform a BFS on the sub graph representing the cycle, with a view to
@@ -516,7 +520,7 @@ class Puppet::SimpleGraph
               (adjacencies[direction][other_vertex] ||= Set.new).add(edge)
             end
           end
-          result[vertex] = Puppet::SimpleGraph::VertexWrapper.new(vertex, adjacencies)
+          result[vertex] = Puppet::Graph::SimpleGraph::VertexWrapper.new(vertex, adjacencies)
         end
         result
       end
@@ -544,4 +548,19 @@ class Puppet::SimpleGraph
       instance_variable_set("@#{varname}", value)
     end
   end
+
+  def multi_vertex_component?(component)
+    component.length > 1
+  end
+  private :multi_vertex_component?
+
+  def single_vertex_referring_to_self?(component)
+    if component.length == 1
+      vertex = component[0]
+      adjacent(vertex).include?(vertex)
+    else
+      false
+    end
+  end
+  private :single_vertex_referring_to_self?
 end

data/lib/puppet/graph/title_hash_prioritizer.rb

@@ -0,0 +1,16 @@
+# Prioritize keys, which must be Puppet::Resources, based on a static hash of
+# the key's ref. This prioritizer does not take containment into account.
+#
+# @api private
+require 'digest/sha1'
+
+class Puppet::Graph::TitleHashPrioritizer < Puppet::Graph::Prioritizer
+  def generate_priority_for(resource)
+    record_priority_for(resource,
+                        Digest::SHA1.hexdigest("NaCl, MgSO4 (salts) and then #{resource.ref}"))
+  end
+
+  def generate_priority_contained_in(container, resource)
+    generate_priority_for(resource)
+  end
+end

data/lib/puppet/indirector.rb

@@ -10,7 +10,7 @@ module Puppet::Indirector
   require 'puppet/indirector/indirection'
   require 'puppet/indirector/terminus'
   require 'puppet/indirector/envelope'
-  require 'puppet/network/format_handler'
+  require 'puppet/network/format_support'
 
   def self.configure_routes(application_routes)
     application_routes.each do |indirection_name, termini|
@@ -38,7 +38,7 @@ module Puppet::Indirector
     # populate this class with the various new methods
     extend ClassMethods
     include Puppet::Indirector::Envelope
-    extend Puppet::Network::FormatHandler
+    include Puppet::Network::FormatSupport
 
     # record the indirected class name for documentation purposes
     options[:indirected_class] = name

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

@@ -23,7 +23,8 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
       if text_facts.is_a?(Puppet::Node::Facts)
         facts = text_facts
       else
-        facts = Puppet::Node::Facts.convert_from(format, text_facts)
+        # We unescape here because the corrosponding code in Puppet::Configurer::FactHandler escapes
+        facts = Puppet::Node::Facts.convert_from(format, CGI.unescape(text_facts))
       end
 
       unless facts.name == request.key
@@ -81,12 +82,14 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
     str += " in environment #{node.environment}" if node.environment
     config = nil
 
-    Puppet::Util::Profiler.profile(str) do
-      begin
-        config = Puppet::Parser::Compiler.compile(node)
-      rescue Puppet::Error => detail
-        Puppet.err(detail.to_s) if networked?
-        raise
+    benchmark(:notice, str) do
+      Puppet::Util::Profiler.profile(str) do
+        begin
+          config = Puppet::Parser::Compiler.compile(node)
+        rescue Puppet::Error => detail
+          Puppet.err(detail.to_s) if networked?
+          raise
+        end
       end
     end
 

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

@@ -49,6 +49,7 @@ class Puppet::Resource::Catalog::StaticCompiler < Puppet::Indirector::Code
       next unless source =~ /^puppet:/
 
       file = resource.to_ral
+
       if file.recurse?
         add_children(request.key, catalog, resource, file)
       else
@@ -59,6 +60,18 @@ class Puppet::Resource::Catalog::StaticCompiler < Puppet::Indirector::Code
     catalog
   end
 
+  # Take a resource with a fileserver based file source remove the source
+  # parameter, and insert the file metadata into the resource.
+  #
+  # This method acts to do the fileserver metadata retrieval in advance, while
+  # the file source is local and doesn't require an HTTP request. It retrieves
+  # the file metadata for a given file resource, removes the source parameter
+  # from the resource, inserts the metadata into the file resource, and uploads
+  # the file contents of the source to the file bucket.
+  #
+  # @param host [String] The host name of the node requesting this catalog
+  # @param resource [Puppet::Resource] The resource to replace the metadata in
+  # @param file [Puppet::Type::File] The file RAL associated with the resource
   def find_and_replace_metadata(host, resource, file)
     # We remove URL info from it, so it forces a local copy
     # rather than routing through the network.
@@ -71,6 +84,14 @@ class Puppet::Resource::Catalog::StaticCompiler < Puppet::Indirector::Code
     replace_metadata(host, resource, metadata)
   end
 
+  # Rewrite a given file resource with the metadata from a fileserver based file
+  #
+  # This performs the actual metadata rewrite for the given file resource and
+  # uploads the content of the source file to the filebucket.
+  #
+  # @param host [String] The host name of the node requesting this catalog
+  # @param resource [Puppet::Resource] The resource to add the metadata to
+  # @param metadata [Puppet::FileServing::Metadata] The metadata of the given fileserver based file
   def replace_metadata(host, resource, metadata)
     [:mode, :owner, :group].each do |param|
       resource[param] ||= metadata.send(param)
@@ -89,6 +110,12 @@ class Puppet::Resource::Catalog::StaticCompiler < Puppet::Indirector::Code
     Puppet.info "Metadata for #{resource} in catalog for '#{host}' added from '#{old_source}'"
   end
 
+  # Generate children resources for a recursive file and add them to the catalog.
+  #
+  # @param host [String] The host name of the node requesting this catalog
+  # @param catalog [Puppet::Resource::Catalog]
+  # @param resource [Puppet::Resource]
+  # @param file [Puppet::Type::File] The file RAL associated with the resource
   def add_children(host, catalog, resource, file)
     file = resource.to_ral
 
@@ -102,6 +129,14 @@ class Puppet::Resource::Catalog::StaticCompiler < Puppet::Indirector::Code
     end
   end
 
+  # Given a recursive file resource, recursively generate its children resources
+  #
+  # @param host [String] The host name of the node requesting this catalog
+  # @param catalog [Puppet::Resource::Catalog]
+  # @param resource [Puppet::Resource]
+  # @param file [Puppet::Type::File] The file RAL associated with the resource
+  #
+  # @return [Array<Puppet::Resource>] The recursively generated File resources for the given resource
   def get_child_resources(host, catalog, resource, file)
     sourceselect = file[:sourceselect]
     children = {}
@@ -137,18 +172,33 @@ class Puppet::Resource::Catalog::StaticCompiler < Puppet::Indirector::Code
 
       # I think this is safe since it's a URL, not an actual file
       children[meta.relative_path][:source] = source + "/" + meta.relative_path
+      resource.each do |param, value|
+        # These should never be passed to our children.
+        unless [:parent, :ensure, :recurse, :recurselimit, :target, :alias, :source].include? param
+          children[meta.relative_path][param] = value
+        end
+      end
       replace_metadata(host, children[meta.relative_path], meta)
     end
 
     children
   end
 
+  # Remove any file resources in the catalog that will be duplicated by the
+  # given file resources.
+  #
+  # @param children [Array<Puppet::Resource>]
+  # @param catalog [Puppet::Resource::Catalog]
   def remove_existing_resources(children, catalog)
     existing_names = catalog.resources.collect { |r| r.to_s }
     both = (existing_names & children.keys).inject({}) { |hash, name| hash[name] = true; hash }
     both.each { |name| children.delete(name) }
   end
 
+  # Retrieve the source of a file resource using a fileserver based source and
+  # upload it to the filebucket.
+  #
+  # @param resource [Puppet::Resource]
   def store_content(resource)
     @summer ||= Object.new
     @summer.extend(Puppet::Util::Checksums)

data/lib/puppet/indirector/certificate/rest.rb

@@ -2,7 +2,7 @@ require 'puppet/ssl/certificate'
 require 'puppet/indirector/rest'
 
 class Puppet::SSL::Certificate::Rest < Puppet::Indirector::REST
-  desc "Find and save certificates over HTTP via REST."
+  desc "Find certificates over HTTP via REST."
 
   use_server_setting(:ca_server)
   use_port_setting(:ca_port)

data/lib/puppet/indirector/exec.rb

@@ -7,7 +7,7 @@ class Puppet::Indirector::Exec < Puppet::Indirector::Terminus
     name = request.key
     external_command = command
 
-    # Make sure it's an arry
+    # Make sure it's an array
     raise Puppet::DevError, "Exec commands must be an array" unless external_command.is_a?(Array)
 
     # Make sure it's fully qualified.

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

@@ -19,7 +19,7 @@ class Puppet::Node::Facts::Facter < Puppet::Indirector::Code
       end
     end.flatten
     dirs = module_fact_dirs + Puppet[:factpath].split(File::PATH_SEPARATOR)
-    x = dirs.uniq.each do |dir|
+    dirs.uniq.each do |dir|
       load_facts_in_dir(dir)
     end
   end
@@ -55,7 +55,7 @@ class Puppet::Node::Facts::Facter < Puppet::Indirector::Code
     result = Puppet::Node::Facts.new(request.key, Facter.to_hash)
 
     result.add_local_facts
-    result.stringify
+    Puppet[:stringify_facts] ? result.stringify : result.sanitize
 
     result
   end

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

@@ -46,7 +46,6 @@ class Puppet::Node::Facts::InventoryActiveRecord < Puppet::Indirector::ActiveRec
   def search(request)
     return [] unless request.options
     matching_nodes = []
-    fact_names = []
     fact_filters = Hash.new {|h,k| h[k] = []}
     meta_filters = Hash.new {|h,k| h[k] = []}
     request.options.each do |key,value|

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

@@ -9,7 +9,7 @@ class Puppet::Node::Facts::NetworkDevice < Puppet::Indirector::Code
     result = Puppet::Node::Facts.new(request.key, Puppet::Util::NetworkDevice.current.facts)
 
     result.add_local_facts
-    result.stringify
+    Puppet[:stringify_facts] ? result.stringify : result.sanitize
 
     result
   end

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

@@ -22,7 +22,6 @@ module Puppet::FileBucketFile
       return nil unless path_match(dir_path, files_original_path)
 
       if request.options[:diff_with]
-        hash_protocol = sumtype(checksum)
         file2_path = path_for(request.options[:bucket_path], request.options[:diff_with], 'contents')
         raise "could not find diff_with #{request.options[:diff_with]}" unless ::File.exists?(file2_path)
         return `diff #{file_path.inspect} #{file2_path.inspect}`

data/lib/puppet/indirector/indirection.rb

@@ -88,7 +88,7 @@ class Puppet::Indirector::Indirection
     text += scrub(@doc) + "\n\n" if @doc
 
     text << "* **Indirected Class**: `#{@indirected_class}`\n";
-    if s = terminus_setting
+    if terminus_setting
       text << "* **Terminus Setting**: #{terminus_setting}\n"
     end
 
@@ -247,7 +247,7 @@ class Puppet::Indirector::Indirection
 
     result = terminus.destroy(request)
 
-    if cache? and cached = cache.find(request(:find, key, nil, options))
+    if cache? and cache.find(request(:find, key, nil, options))
       # Reuse the existing request, since it's equivalent.
       cache.destroy(request)
     end

data/lib/puppet/indirector/memory.rb

@@ -15,6 +15,15 @@ class Puppet::Indirector::Memory < Puppet::Indirector::Terminus
     @instances[request.key]
   end
 
+  def search(request)
+    found_keys = @instances.keys.find_all { |key| key.include?(request.key) }
+    found_keys.collect { |key| @instances[key] }
+  end
+
+  def head(request)
+    not find(request).nil?
+  end
+
   def save(request)
     @instances[request.key] = request.instance
   end

data/lib/puppet/indirector/node/ldap.rb

@@ -9,15 +9,14 @@ class Puppet::Node::Ldap < Puppet::Indirector::Ldap
 
   # The attributes that Puppet class information is stored in.
   def class_attributes
-    # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
-    x = Puppet[:ldapclassattrs].split(/\s*,\s*/)
+    Puppet[:ldapclassattrs].split(/\s*,\s*/)
   end
 
   # Separate this out so it's relatively atomic.  It's tempting to call
   # process instead of name2hash() here, but it ends up being
   # difficult to test because all exceptions get caught by ldapsearch.
   # LAK:NOTE Unfortunately, the ldap support is too stupid to throw anything
-  # but LDAP::ResultError, even on bad connections, so we are rough handed
+  # but LDAP::ResultError, even on bad connections, so we are rough-handed
   # with our error handling.
   def name2hash(name)
     info = nil
@@ -198,7 +197,6 @@ class Puppet::Node::Ldap < Puppet::Indirector::Ldap
   end
 
   def merge_parent(info)
-    parent_info = nil
     parent = info[:parent]
 
     # Preload the parent array with the node name.

data/lib/puppet/indirector/report/processor.rb

@@ -43,8 +43,7 @@ class Puppet::Transaction::Report::Processor < Puppet::Indirector::Code
 
   # Handle the parsing of the reports attribute.
   def reports
-    # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
-    x = Puppet[:reports].gsub(/(^\s+)|(\s+$)/, '').split(/\s*,\s*/)
+    Puppet[:reports].gsub(/(^\s+)|(\s+$)/, '').split(/\s*,\s*/)
   end
 
   def processors(&blk)

data/lib/puppet/indirector/report/rest.rb

@@ -9,7 +9,7 @@ class Puppet::Transaction::Report::Rest < Puppet::Indirector::REST
   private
 
   def deserialize_save(content_type, body)
-    format = Puppet::Network::FormatHandler.protected_format(content_type)
+    format = Puppet::Network::FormatHandler.format_for(content_type)
     format.intern(Array, body)
   end
 end

data/lib/puppet/indirector/request.rb

@@ -5,7 +5,7 @@ require 'puppet/util/pson'
 require 'puppet/network/resolver'
 
 # This class encapsulates all of the information you need to make an
-# Indirection call, and as a a result also handles REST calls.  It's somewhat
+# Indirection call, and as a result also handles REST calls.  It's somewhat
 # analogous to an HTTP Request object, except tuned for our Indirector.
 class Puppet::Indirector::Request
   attr_accessor :key, :method, :options, :instance, :node, :ip, :authenticated, :ignore_cache, :ignore_terminus
@@ -158,20 +158,42 @@ class Puppet::Indirector::Request
 
   # Create the query string, if options are present.
   def query_string
-    return "" unless options and ! options.empty?
-    "?" + options.collect do |key, value|
+    return "" if options.nil? || options.empty?
+    "?" + encode_params(expand_into_parameters(options.to_a))
+  end
+
+  def expand_into_parameters(data)
+    data.inject([]) do |params, key_value|
+      key, value = key_value
+
+      expanded_value = case value
+                       when Array
+                         value.collect { |val| [key, val] }
+                       else
+                         [key_value]
+                       end
+
+      params.concat(expand_primitive_types_into_parameters(expanded_value))
+    end
+  end
+
+  def expand_primitive_types_into_parameters(data)
+    data.inject([]) do |params, key_value|
+      key, value = key_value
       case value
-      when nil; next
-      when true, false; value = value.to_s
-      when Fixnum, Bignum, Float; value = value # nothing
-      when String; value = CGI.escape(value)
-      when Symbol; value = CGI.escape(value.to_s)
-      when Array; value = CGI.escape(YAML.dump(value))
+      when nil
+        params
+      when true, false, String, Symbol, Fixnum, Bignum, Float
+        params << [key, value]
       else
         raise ArgumentError, "HTTP REST queries cannot handle values of type '#{value.class}'"
       end
+    end
+  end
 
-      "#{key}=#{value}"
+  def encode_params(params)
+    params.collect do |key, value|
+      "#{key}=#{CGI.escape(value.to_s)}"
     end.join("&")
   end