openvox 8.19.0

data/lib/puppet/graph/rb_tree_map.rb

@@ -0,0 +1,407 @@
+# frozen_string_literal: true
+
+# Algorithms and Containers project is Copyright (c) 2009 Kanwei Li
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the 'Software'), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+# A RbTreeMap is a map that is stored in sorted order based on the order of its keys. This ordering is
+# determined by applying the function <=> to compare the keys. No duplicate values for keys are allowed,
+# so duplicate values are overwritten.
+#
+# A major advantage of RBTreeMap over a Hash is the fact that keys are stored in order and can thus be
+# iterated over in order. This is useful for many datasets.
+#
+# The implementation is adapted from Robert Sedgewick's Left Leaning Red-Black Tree implementation,
+# which can be found at https://www.cs.princeton.edu/~rs/talks/LLRB/Java/RedBlackBST.java
+#
+# Most methods have O(log n) complexity.
+
+class Puppet::Graph::RbTreeMap
+  include Enumerable
+
+  attr_reader :size
+
+  alias_method :length, :size
+
+  # Create and initialize a new empty TreeMap.
+  def initialize
+    @root = nil
+    @size = 0
+  end
+
+  # Insert an item with an associated key into the TreeMap, and returns the item inserted
+  #
+  # Complexity: O(log n)
+  #
+  # map = Containers::TreeMap.new
+  # map.push("MA", "Massachusetts") #=> "Massachusetts"
+  # map.get("MA") #=> "Massachusetts"
+  def push(key, value)
+    @root = insert(@root, key, value)
+    @root.color = :black
+    value
+  end
+  alias_method :[]=, :push
+
+  # Return true if key is found in the TreeMap, false otherwise
+  #
+  # Complexity: O(log n)
+  #
+  #   map = Containers::TreeMap.new
+  #   map.push("MA", "Massachusetts")
+  #   map.push("GA", "Georgia")
+  #   map.has_key?("GA") #=> true
+  #   map.has_key?("DE") #=> false
+  def has_key?(key)
+    !get_recursive(@root, key).nil?
+  end
+
+  # Return the item associated with the key, or nil if none found.
+  #
+  # Complexity: O(log n)
+  #
+  #   map = Containers::TreeMap.new
+  #   map.push("MA", "Massachusetts")
+  #   map.push("GA", "Georgia")
+  #   map.get("GA") #=> "Georgia"
+  def get(key)
+    node = get_recursive(@root, key)
+    node ? node.value : nil
+    node.value if node
+  end
+  alias_method :[], :get
+
+  # Return the smallest key in the map.
+  #
+  # Complexity: O(log n)
+  #
+  #   map = Containers::TreeMap.new
+  #   map.push("MA", "Massachusetts")
+  #   map.push("GA", "Georgia")
+  #   map.min_key #=> "GA"
+  def min_key
+    @root.nil? ? nil : min_recursive(@root).key
+  end
+
+  # Return the largest key in the map.
+  #
+  # Complexity: O(log n)
+  #
+  #   map = Containers::TreeMap.new
+  #   map.push("MA", "Massachusetts")
+  #   map.push("GA", "Georgia")
+  #   map.max_key #=> "MA"
+  def max_key
+    @root.nil? ? nil : max_recursive(@root).key
+  end
+
+  # Deletes the item and key if it's found, and returns the item. Returns nil
+  # if key is not present.
+  #
+  # Complexity: O(log n)
+  #
+  #   map = Containers::TreeMap.new
+  #   map.push("MA", "Massachusetts")
+  #   map.push("GA", "Georgia")
+  #   map.delete("MA") #=> "Massachusetts"
+  def delete(key)
+    result = nil
+    if @root
+      return unless has_key? key
+
+      @root, result = delete_recursive(@root, key)
+      @root.color = :black if @root
+      @size -= 1
+    end
+    result
+  end
+
+  # Returns true if the tree is empty, false otherwise
+  def empty?
+    @root.nil?
+  end
+
+  # Deletes the item with the smallest key and returns the item. Returns nil
+  # if key is not present.
+  #
+  # Complexity: O(log n)
+  #
+  #   map = Containers::TreeMap.new
+  #   map.push("MA", "Massachusetts")
+  #   map.push("GA", "Georgia")
+  #   map.delete_min #=> "Massachusetts"
+  #   map.size #=> 1
+  def delete_min
+    result = nil
+    if @root
+      @root, result = delete_min_recursive(@root)
+      @root.color = :black if @root
+      @size -= 1
+    end
+    result
+  end
+
+  # Deletes the item with the largest key and returns the item. Returns nil
+  # if key is not present.
+  #
+  # Complexity: O(log n)
+  #
+  #   map = Containers::TreeMap.new
+  #   map.push("MA", "Massachusetts")
+  #   map.push("GA", "Georgia")
+  #   map.delete_max #=> "Georgia"
+  #   map.size #=> 1
+  def delete_max
+    result = nil
+    if @root
+      @root, result = delete_max_recursive(@root)
+      @root.color = :black if @root
+      @size -= 1
+    end
+    result
+  end
+
+  # Yields [key, value] pairs in order by key.
+  def each(&blk)
+    recursive_yield(@root, &blk)
+  end
+
+  def first
+    return nil unless @root
+
+    node = min_recursive(@root)
+    [node.key, node.value]
+  end
+
+  def last
+    return nil unless @root
+
+    node = max_recursive(@root)
+    [node.key, node.value]
+  end
+
+  def to_hash
+    @root ? @root.to_hash : {}
+  end
+
+  class Node # :nodoc: all
+    attr_accessor :color, :key, :value, :left, :right
+
+    def initialize(key, value)
+      @key = key
+      @value = value
+      @color = :red
+      @left = nil
+      @right = nil
+    end
+
+    def to_hash
+      h = {
+        :node => {
+          :key => @key,
+          :value => @value,
+          :color => @color,
+        }
+      }
+      h[:left] = left.to_hash if @left
+      h[:right] = right.to_hash if @right
+      h
+    end
+
+    def red?
+      @color == :red
+    end
+
+    def colorflip
+      @color       = @color == :red       ? :black : :red
+      @left.color  = @left.color == :red  ? :black : :red
+      @right.color = @right.color == :red ? :black : :red
+    end
+
+    def rotate_left
+      r = @right
+      r_key = r.key
+      r_value = r.value
+      b = r.left
+      r.left = @left
+      @left = r
+      @right = r.right
+      r.right = b
+      r.color = :red
+      r.key = @key
+      r.value = @value
+      @key = r_key
+      @value = r_value
+      self
+    end
+
+    def rotate_right
+      l = @left
+      l_key = l.key
+      l_value = l.value
+      b = l.right
+      l.right = @right
+      @right = l
+      @left = l.left
+      l.left = b
+      l.color = :red
+      l.key = @key
+      l.value = @value
+      @key = l_key
+      @value = l_value
+      self
+    end
+
+    def move_red_left
+      colorflip
+      if @right.left && @right.left.red?
+        @right.rotate_right
+        rotate_left
+        colorflip
+      end
+      self
+    end
+
+    def move_red_right
+      colorflip
+      if @left.left && @left.left.red?
+        rotate_right
+        colorflip
+      end
+      self
+    end
+
+    def fixup
+      rotate_left if @right && @right.red?
+      rotate_right if (@left && @left.red?) && (@left.left && @left.left.red?)
+      colorflip if (@left && @left.red?) && (@right && @right.red?)
+
+      self
+    end
+  end
+
+  private
+
+  def recursive_yield(node, &blk)
+    return unless node
+
+    recursive_yield(node.left, &blk)
+    yield node.key, node.value
+    recursive_yield(node.right, &blk)
+  end
+
+  def delete_recursive(node, key)
+    if (key <=> node.key) == -1
+      node.move_red_left if !isred(node.left) && !isred(node.left.left)
+      node.left, result = delete_recursive(node.left, key)
+    else
+      node.rotate_right if isred(node.left)
+      if ((key <=> node.key) == 0) && node.right.nil?
+        return nil, node.value
+      end
+
+      if !isred(node.right) && !isred(node.right.left)
+        node.move_red_right
+      end
+      if (key <=> node.key) == 0
+        result = node.value
+        min_child = min_recursive(node.right)
+        node.value = min_child.value
+        node.key = min_child.key
+        node.right = delete_min_recursive(node.right).first
+      else
+        node.right, result = delete_recursive(node.right, key)
+      end
+    end
+    [node.fixup, result]
+  end
+
+  def delete_min_recursive(node)
+    if node.left.nil?
+      return nil, node.value
+    end
+
+    if !isred(node.left) && !isred(node.left.left)
+      node.move_red_left
+    end
+    node.left, result = delete_min_recursive(node.left)
+
+    [node.fixup, result]
+  end
+
+  def delete_max_recursive(node)
+    if isred(node.left)
+      node = node.rotate_right
+    end
+    return nil, node.value if node.right.nil?
+
+    if !isred(node.right) && !isred(node.right.left)
+      node.move_red_right
+    end
+    node.right, result = delete_max_recursive(node.right)
+
+    [node.fixup, result]
+  end
+
+  def get_recursive(node, key)
+    return nil if node.nil?
+
+    case key <=> node.key
+    when 0 then node
+    when -1 then get_recursive(node.left, key)
+    when  1 then get_recursive(node.right, key)
+    end
+  end
+
+  def min_recursive(node)
+    return node if node.left.nil?
+
+    min_recursive(node.left)
+  end
+
+  def max_recursive(node)
+    return node if node.right.nil?
+
+    max_recursive(node.right)
+  end
+
+  def insert(node, key, value)
+    unless node
+      @size += 1
+      return Node.new(key, value)
+    end
+
+    case key <=> node.key
+    when 0 then node.value = value
+    when -1 then node.left = insert(node.left, key, value)
+    when  1 then node.right = insert(node.right, key, value)
+    end
+
+    node.rotate_left if node.right && node.right.red?
+    node.rotate_right if node.left && node.left.red? && node.left.left && node.left.left.red?
+    node.colorflip if node.left && node.left.red? && node.right && node.right.red?
+    node
+  end
+
+  def isred(node)
+    return false if node.nil?
+
+    node.color == :red
+  end
+end

data/lib/puppet/graph/relationship_graph.rb

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+# 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_autorelation_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] || -> { true }
+    pre_process = options[:pre_process] || ->(resource) {}
+    overly_deferred_resource_handler = options[:overly_deferred_resource_handler] || ->(resource) {}
+    canceled_resource_handler = options[:canceled_resource_handler] || ->(resource) {}
+    teardown = options[:teardown] || -> {}
+    graph_cycle_handler = options[:graph_cycle_handler] || -> { [] }
+
+    cycles = report_cycles_in_graph
+    if cycles
+      graph_cycle_handler.call(cycles)
+    end
+
+    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
+
+      next unless @ready.empty? and deferred_resources.any?
+
+      if made_progress
+        enqueue(*deferred_resources)
+      else
+        deferred_resources.each do |res|
+          overly_deferred_resource_handler.call(res)
+          finish(res)
+        end
+      end
+
+      made_progress = false
+      deferred_resources = []
+    end
+
+    unless 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_autorelation_dependencies(catalog)
+    vertices.each do |vertex|
+      [:require, :subscribe].each do |rel_type|
+        vertex.send("auto#{rel_type}".to_sym, 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 "Adding auto#{rel_type} relationship with #{edge.source}"
+            if rel_type == :require
+              edge.event = :NONE
+            else
+              edge.callback = :refresh
+              edge.event = :ALL_EVENTS
+            end
+            add_edge(edge)
+          end
+        end
+      end
+
+      [:before, :notify].each do |rel_type|
+        vertex.send("auto#{rel_type}".to_sym, catalog).each do |edge|
+          # don't let automatic relationships conflict with manual ones.
+          next if edge?(edge.target, edge.source)
+
+          if edge?(edge.source, edge.target)
+            vertex.debug "Skipping automatic relationship with #{edge.target}"
+          else
+            vertex.debug "Adding auto#{rel_type} relationship with #{edge.target}"
+            if rel_type == :before
+              edge.event = :NONE
+            else
+              edge.callback = :refresh
+              edge.event = :ALL_EVENTS
+            end
+            add_edge(edge)
+          end
+        end
+      end
+    end
+  end
+
+  # Impose our container information on another graph by using it
+  # to replace any container vertices X with a pair of vertices
+  # { admissible_X and completed_X } such 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 depends 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 vertices regardless of how containers are related;
+  # alternatives such as replacing container-edges with content-edges
+  # scale as the product of the number of external dependencies, 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 vertices through.  Thus we
+    #   can "do the right thing" for references to other vertices 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)
+
+      # This copies the original container's tags over to the two anchor whits.
+      # Without this, tags are not propagated to the container's resources.
+      admissible[x].set_tags(x)
+      completed[x].set_tags(x)
+
+      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

data/lib/puppet/graph/sequential_prioritizer.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# 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