puppet 3.2.4 → 3.3.0.rc2

data/lib/puppet/file_bucket/dipper.rb

@@ -77,7 +77,6 @@ class Puppet::FileBucket::Dipper
 
     if restore
       if newcontents = getfile(sum)
-        tmp = ""
         newsum = Digest::MD5.hexdigest(newcontents)
         changed = nil
         if FileTest.exists?(file) and ! FileTest.writable?(file)

data/lib/puppet/file_serving/base.rb

@@ -15,7 +15,7 @@ class Puppet::FileServing::Base
   def exist?
       stat
       return true
-  rescue => detail
+  rescue
       return false
   end
 

data/lib/puppet/file_serving/configuration/parser.rb

@@ -1,19 +1,19 @@
 require 'puppet/file_serving/configuration'
-require 'puppet/util/loadedfile'
+require 'puppet/util/watched_file'
 
-class Puppet::FileServing::Configuration::Parser < Puppet::Util::LoadedFile
+class Puppet::FileServing::Configuration::Parser
   Mount = Puppet::FileServing::Mount
   MODULES = 'modules'
 
   # Parse our configuration file.
   def parse
-    raise("File server configuration #{self.file} does not exist") unless FileTest.exists?(self.file)
-    raise("Cannot read file server configuration #{self.file}") unless FileTest.readable?(self.file)
+    raise("File server configuration #{@file} does not exist") unless FileTest.exists?(@file)
+    raise("Cannot read file server configuration #{@file}") unless FileTest.readable?(@file)
 
     @mounts = {}
     @count = 0
 
-    File.open(self.file) { |f|
+    File.open(@file) { |f|
       mount = nil
       f.each_line { |line|
         # Have the count increment at the top, in case we throw exceptions.
@@ -37,10 +37,10 @@ class Puppet::FileServing::Configuration::Parser < Puppet::Util::LoadedFile
           when "deny"
             deny(mount, value)
           else
-            raise ArgumentError.new("Invalid argument '#{var}'", @count, file)
+            raise ArgumentError.new("Invalid argument '#{var}'", @count, @file)
           end
         else
-          raise ArgumentError.new("Invalid line '#{line.chomp}'", @count, file)
+          raise ArgumentError.new("Invalid line '#{line.chomp}'", @count, @file)
         end
       }
     }
@@ -50,37 +50,43 @@ class Puppet::FileServing::Configuration::Parser < Puppet::Util::LoadedFile
     @mounts
   end
 
+  def initialize(filename)
+    @file = Puppet::Util::WatchedFile.new(filename)
+  end
+
+  def changed?
+    @file.changed?
+  end
+
   private
 
   # Allow a given pattern access to a mount.
   def allow(mount, value)
-    # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
-    x = value.split(/\s*,\s*/).each { |val|
+    value.split(/\s*,\s*/).each { |val|
       begin
         mount.info "allowing #{val} access"
         mount.allow(val)
       rescue Puppet::AuthStoreError => detail
-        raise ArgumentError.new(detail.to_s, @count, file)
+        raise ArgumentError.new(detail.to_s, @count, @file)
       end
     }
   end
 
   # Deny a given pattern access to a mount.
   def deny(mount, value)
-    # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
-    x = value.split(/\s*,\s*/).each { |val|
+    value.split(/\s*,\s*/).each { |val|
       begin
         mount.info "denying #{val} access"
         mount.deny(val)
       rescue Puppet::AuthStoreError => detail
-        raise ArgumentError.new(detail.to_s, @count, file)
+        raise ArgumentError.new(detail.to_s, @count, @file)
       end
     }
   end
 
   # Create a new mount.
   def newmount(name)
-    raise ArgumentError, "#{@mounts[name]} is already mounted at #{name}", @count, file if @mounts.include?(name)
+    raise ArgumentError, "#{@mounts[name]} is already mounted at #{name}", @count, @file if @mounts.include?(name)
     case name
     when "modules"
       mount = Mount::Modules.new(name)

data/lib/puppet/forge.rb

@@ -89,38 +89,6 @@ class Puppet::Forge
     end
   end
 
-  def get_release_packages_from_repository(install_list)
-    install_list.map do |release|
-      modname, version, file = release
-      cache_path = nil
-      if file
-        begin
-          cache_path = repository.retrieve(file)
-        rescue OpenURI::HTTPError => e
-          raise HttpResponseError.new(:uri => uri.to_s, :input => modname, :message => e.message)
-        end
-      else
-        raise RuntimeError, "Malformed response from module repository."
-      end
-      cache_path
-    end
-  end
-
-  # Locate a module release package on the local filesystem and move it
-  # into the `Puppet.settings[:module_working_dir]`. Do not unpack it, just
-  # return the location of the package on disk.
-  def get_release_package_from_filesystem(filename)
-    if File.exist?(File.expand_path(filename))
-      repository = Repository.new('file:///')
-      uri = URI.parse("file://#{URI.escape(File.expand_path(filename))}")
-      cache_path = repository.retrieve(uri)
-    else
-      raise ArgumentError, "File does not exists: #{filename}"
-    end
-
-    cache_path
-  end
-
   def retrieve(release)
     repository.retrieve(release)
   end

data/lib/puppet/forge/cache.rb

@@ -6,7 +6,7 @@ class Puppet::Forge
   # Provides methods for reading files from local cache, filesystem or network.
   class Cache
 
-    # Instantiate new cahe for the +repositry+ instance.
+    # Instantiate new cache for the +repository+ instance.
     def initialize(repository, options = {})
       @repository = repository
       @options = options

data/lib/puppet/forge/errors.rb

@@ -30,7 +30,7 @@ module Puppet::Forge::Errors
     #
     # @return [String] the multiline version of the error message
     def multiline
-      message = <<-EOS.chomp
+      <<-EOS.chomp
 Could not connect via HTTPS to #{@uri}
   Unable to verify the SSL certificate
     The certificate may not be signed by a valid CA
@@ -57,7 +57,7 @@ Could not connect via HTTPS to #{@uri}
     #
     # @return [String] the multiline version of the error message
     def multiline
-      message = <<-EOS.chomp
+      <<-EOS.chomp
 Could not connect to #{@uri}
   There was a network communications problem
     The error we caught said '#{@detail}'
@@ -78,7 +78,7 @@ Could not connect to #{@uri}
       @input   = options[:input]
       @message = options[:message]
       response = options[:response]
-      @response = "#{response.code} #{response.message}"
+      @response = "#{response.code} #{response.message.strip}"
 
       message = "Could not execute operation for '#{@input}'. Detail: "
       message << @message << " / " if @message

data/lib/puppet/forge/repository.rb

@@ -2,6 +2,7 @@ require 'net/https'
 require 'zlib'
 require 'digest/sha1'
 require 'uri'
+require 'puppet/util/http_proxy'
 require 'puppet/forge/errors'
 
 class Puppet::Forge
@@ -37,45 +38,9 @@ class Puppet::Forge
       @consumer_version = consumer_version
     end
 
-    # Read HTTP proxy configurationm from Puppet's config file, or the
-    # http_proxy environment variable.
-    def http_proxy_env
-      proxy_env = ENV["http_proxy"] || ENV["HTTP_PROXY"] || nil
-      begin
-        return URI.parse(proxy_env) if proxy_env
-      rescue URI::InvalidURIError
-        return nil
-      end
-      return nil
-    end
-
-    def http_proxy_host
-      env = http_proxy_env
-
-      if env and env.host then
-        return env.host
-      end
-
-      if Puppet.settings[:http_proxy_host] == 'none'
-        return nil
-      end
-
-      return Puppet.settings[:http_proxy_host]
-    end
-
-    def http_proxy_port
-      env = http_proxy_env
-
-      if env and env.port then
-        return env.port
-      end
-
-      return Puppet.settings[:http_proxy_port]
-    end
-
     # Return a Net::HTTPResponse read for this +request_path+.
     def make_http_request(request_path)
-      request = Net::HTTP::Get.new(URI.escape(request_path), { "User-Agent" => user_agent })
+      request = Net::HTTP::Get.new(URI.escape(@uri.path + request_path), { "User-Agent" => user_agent })
       if ! @uri.user.nil? && ! @uri.password.nil?
         request.basic_auth(@uri.user, @uri.password)
       end
@@ -115,7 +80,7 @@ class Puppet::Forge
     #
     # @return [Net::HTTP::Proxy] object constructed from repo settings
     def get_http_object
-      proxy_class = Net::HTTP::Proxy(http_proxy_host, http_proxy_port)
+      proxy_class = Net::HTTP::Proxy(Puppet::Util::HttpProxy.http_proxy_host, Puppet::Util::HttpProxy.http_proxy_port)
       proxy = proxy_class.new(@uri.host, @uri.port)
 
       if @uri.scheme == 'https'
@@ -133,7 +98,9 @@ class Puppet::Forge
     # Return the local file name containing the data downloaded from the
     # repository at +release+ (e.g. "myuser-mymodule").
     def retrieve(release)
-      return cache.retrieve(@uri + release)
+      uri = @uri.dup
+      uri.path = uri.path.chomp('/') + release
+      return cache.retrieve(uri)
     end
 
     # Return the URI string for this repository.
@@ -156,9 +123,7 @@ class Puppet::Forge
     private :user_agent
 
     def ruby_version
-      # the patchlevel is not available in ruby 1.8.5
-      patch = defined?(RUBY_PATCHLEVEL) ? "-p#{RUBY_PATCHLEVEL}" : ""
-      "Ruby/#{RUBY_VERSION}#{patch} (#{RUBY_RELEASE_DATE}; #{RUBY_PLATFORM})"
+      "Ruby/#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE}; #{RUBY_PLATFORM})"
     end
     private :ruby_version
   end

data/lib/puppet/graph.rb

@@ -0,0 +1,11 @@
+module Puppet::Graph
+  require 'puppet/graph/prioritizer'
+  require 'puppet/graph/sequential_prioritizer'
+  require 'puppet/graph/title_hash_prioritizer'
+  require 'puppet/graph/random_prioritizer'
+
+  require 'puppet/graph/simple_graph'
+  require 'puppet/graph/rb_tree_map'
+  require 'puppet/graph/key'
+  require 'puppet/graph/relationship_graph'
+end

data/lib/puppet/graph/key.rb

@@ -0,0 +1,26 @@
+# Sequential, nestable keys for tracking order of insertion in "the graph"
+# @api private
+class Puppet::Graph::Key
+  include Comparable
+
+  attr_reader :value
+  protected :value
+
+  def initialize(value = [0])
+    @value = value
+  end
+
+  def next
+    next_values = @value.clone
+    next_values[-1] += 1
+    Puppet::Graph::Key.new(next_values)
+  end
+
+  def down
+    Puppet::Graph::Key.new(@value + [0])
+  end
+
+  def <=>(other)
+    @value <=> other.value
+  end
+end

data/lib/puppet/graph/prioritizer.rb

@@ -0,0 +1,29 @@
+# Base, template method, class for Prioritizers. This provides the basic
+# tracking facilities used.
+#
+# @api private
+class Puppet::Graph::Prioritizer
+  def initialize
+    @priority = {}
+  end
+
+  def forget(key)
+    @priority.delete(key)
+  end
+
+  def record_priority_for(key, priority)
+    @priority[key] = priority
+  end
+
+  def generate_priority_for(key)
+    raise NotImplementedError
+  end
+
+  def generate_priority_contained_in(container, key)
+    raise NotImplementedError
+  end
+
+  def priority_of(key)
+    @priority[key]
+  end
+end

data/lib/puppet/graph/random_prioritizer.rb

@@ -0,0 +1,16 @@
+# Assign a random priority to items.
+#
+# @api private
+class Puppet::Graph::RandomPrioritizer < Puppet::Graph::Prioritizer
+  def generate_priority_for(key)
+    if priority_of(key).nil?
+      record_priority_for(key, SecureRandom.uuid)
+    else
+      priority_of(key)
+    end
+  end
+
+  def generate_priority_contained_in(container, key)
+    generate_priority_for(key)
+  end
+end

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

@@ -30,7 +30,7 @@
 #
 # Most methods have O(log n) complexity.
 
-class Puppet::RbTreeMap
+class Puppet::Graph::RbTreeMap
   include Enumerable
 
   attr_reader :size
@@ -230,7 +230,7 @@ class Puppet::RbTreeMap
 
     def rotate_left
       r = @right
-      r_key, r_value, r_color = r.key, r.value, r.color
+      r_key, r_value = r.key, r.value
       b = r.left
       r.left = @left
       @left = r
@@ -243,7 +243,7 @@ class Puppet::RbTreeMap
 
     def rotate_right
       l = @left
-      l_key, l_value, l_color = l.key, l.value, l.color
+      l_key, l_value = l.key, l.value
       b = l.right
       l.right = @right
       @right = l

data/lib/puppet/graph/relationship_graph.rb

@@ -0,0 +1,246 @@
+# The relationship graph is the final form of a puppet catalog in
+# which all dependency edges are explicitly in the graph. This form of the
+# catalog is used to traverse the graph in the order in which resources are
+# managed.
+#
+# @api private
+class Puppet::Graph::RelationshipGraph < Puppet::Graph::SimpleGraph
+  attr_reader :blockers
+
+  def initialize(prioritizer)
+    super()
+
+    @prioritizer = prioritizer
+
+    @ready = Puppet::Graph::RbTreeMap.new
+    @generated = {}
+    @done = {}
+    @blockers = {}
+    @providerless_types = []
+  end
+
+  def populate_from(catalog)
+    add_all_resources_as_vertices(catalog)
+    build_manual_dependencies
+    build_autorequire_dependencies(catalog)
+
+    write_graph(:relationships) if catalog.host_config?
+
+    replace_containers_with_anchors(catalog)
+
+    write_graph(:expanded_relationships) if catalog.host_config?
+  end
+
+  def add_vertex(vertex, priority = nil)
+    super(vertex)
+
+    if priority
+      @prioritizer.record_priority_for(vertex, priority)
+    else
+      @prioritizer.generate_priority_for(vertex)
+    end
+  end
+
+  def add_relationship(f, t, label=nil)
+    super(f, t, label)
+    @ready.delete(@prioritizer.priority_of(t))
+  end
+
+  def remove_vertex!(vertex)
+    super
+    @prioritizer.forget(vertex)
+  end
+
+  def resource_priority(resource)
+    @prioritizer.priority_of(resource)
+  end
+
+  # Enqueue the initial set of resources, those with no dependencies.
+  def enqueue_roots
+    vertices.each do |v|
+      @blockers[v] = direct_dependencies_of(v).length
+      enqueue(v) if @blockers[v] == 0
+    end
+  end
+
+  # Decrement the blocker count for the resource by 1. If the number of
+  # blockers is unknown, count them and THEN decrement by 1.
+  def unblock(resource)
+    @blockers[resource] ||= direct_dependencies_of(resource).select { |r2| !@done[r2] }.length
+    if @blockers[resource] > 0
+      @blockers[resource] -= 1
+    else
+      resource.warning "appears to have a negative number of dependencies"
+    end
+    @blockers[resource] <= 0
+  end
+
+  def clear_blockers
+    @blockers.clear
+  end
+
+  def enqueue(*resources)
+    resources.each do |resource|
+      @ready[@prioritizer.priority_of(resource)] = resource
+    end
+  end
+
+  def finish(resource)
+    direct_dependents_of(resource).each do |v|
+      enqueue(v) if unblock(v)
+    end
+    @done[resource] = true
+  end
+
+  def next_resource
+    @ready.delete_min
+  end
+
+  def traverse(options = {}, &block)
+    continue_while = options[:while] || lambda { true }
+    pre_process = options[:pre_process] || lambda { |resource| }
+    overly_deferred_resource_handler = options[:overly_deferred_resource_handler] || lambda { |resource| }
+    canceled_resource_handler = options[:canceled_resource_handler] || lambda { |resource| }
+    teardown = options[:teardown] || lambda {}
+
+    report_cycles_in_graph
+
+    enqueue_roots
+
+    deferred_resources = []
+
+    while continue_while.call() && (resource = next_resource)
+      if resource.suitable?
+        made_progress = true
+
+        pre_process.call(resource)
+
+        yield resource
+
+        finish(resource)
+      else
+        deferred_resources << resource
+      end
+
+      if @ready.empty? and deferred_resources.any?
+        if made_progress
+          enqueue(*deferred_resources)
+        else
+          deferred_resources.each do |resource|
+            overly_deferred_resource_handler.call(resource)
+            finish(resource)
+          end
+        end
+
+        made_progress = false
+        deferred_resources = []
+      end
+    end
+
+    if !continue_while.call()
+      while (resource = next_resource)
+        canceled_resource_handler.call(resource)
+        finish(resource)
+      end
+    end
+
+    teardown.call()
+  end
+
+  private
+
+  def add_all_resources_as_vertices(catalog)
+    catalog.resources.each do |vertex|
+      add_vertex(vertex)
+    end
+  end
+
+  def build_manual_dependencies
+    vertices.each do |vertex|
+      vertex.builddepends.each do |edge|
+        add_edge(edge)
+      end
+    end
+  end
+
+  def build_autorequire_dependencies(catalog)
+    vertices.each do |vertex|
+      vertex.autorequire(catalog).each do |edge|
+        # don't let automatic relationships conflict with manual ones.
+        next if edge?(edge.source, edge.target)
+
+        if edge?(edge.target, edge.source)
+          vertex.debug "Skipping automatic relationship with #{edge.source}"
+        else
+          vertex.debug "Autorequiring #{edge.source}"
+          add_edge(edge)
+        end
+      end
+    end
+  end
+
+  # Impose our container information on another graph by using it
+  # to replace any container vertices X with a pair of verticies
+  # { admissible_X and completed_X } such that that
+  #
+  #    0) completed_X depends on admissible_X
+  #    1) contents of X each depend on admissible_X
+  #    2) completed_X depends on each on the contents of X
+  #    3) everything which depended on X depens on completed_X
+  #    4) admissible_X depends on everything X depended on
+  #    5) the containers and their edges must be removed
+  #
+  # Note that this requires attention to the possible case of containers
+  # which contain or depend on other containers, but has the advantage
+  # that the number of new edges created scales linearly with the number
+  # of contained verticies regardless of how containers are related;
+  # alternatives such as replacing container-edges with content-edges
+  # scale as the product of the number of external dependences, which is
+  # to say geometrically in the case of nested / chained containers.
+  #
+  Default_label = { :callback => :refresh, :event => :ALL_EVENTS }
+  def replace_containers_with_anchors(catalog)
+    stage_class      = Puppet::Type.type(:stage)
+    whit_class       = Puppet::Type.type(:whit)
+    component_class  = Puppet::Type.type(:component)
+    containers = catalog.resources.find_all { |v| (v.is_a?(component_class) or v.is_a?(stage_class)) and vertex?(v) }
+    #
+    # These two hashes comprise the aforementioned attention to the possible
+    #   case of containers that contain / depend on other containers; they map
+    #   containers to their sentinels but pass other verticies through.  Thus we
+    #   can "do the right thing" for references to other verticies that may or
+    #   may not be containers.
+    #
+    admissible = Hash.new { |h,k| k }
+    completed  = Hash.new { |h,k| k }
+    containers.each { |x|
+      admissible[x] = whit_class.new(:name => "admissible_#{x.ref}", :catalog => catalog)
+      completed[x]  = whit_class.new(:name => "completed_#{x.ref}",  :catalog => catalog)
+      priority = @prioritizer.priority_of(x)
+      add_vertex(admissible[x], priority)
+      add_vertex(completed[x], priority)
+    }
+    #
+    # Implement the six requirements listed above
+    #
+    containers.each { |x|
+      contents = catalog.adjacent(x, :direction => :out)
+      add_edge(admissible[x],completed[x]) if contents.empty? # (0)
+      contents.each { |v|
+        add_edge(admissible[x],admissible[v],Default_label) # (1)
+        add_edge(completed[v], completed[x], Default_label) # (2)
+      }
+      # (3) & (5)
+      adjacent(x,:direction => :in,:type => :edges).each { |e|
+        add_edge(completed[e.source],admissible[x],e.label)
+        remove_edge! e
+      }
+      # (4) & (5)
+      adjacent(x,:direction => :out,:type => :edges).each { |e|
+        add_edge(completed[x],admissible[e.target],e.label)
+        remove_edge! e
+      }
+    }
+    containers.each { |x| remove_vertex! x } # (5)
+  end
+end