openvox 8.19.0

data/lib/puppet/error.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Puppet
+  # The base class for all Puppet errors. It can wrap another exception
+  class Error < RuntimeError
+    attr_accessor :original
+
+    def initialize(message, original = nil)
+      super(message.scrub)
+      @original = original
+    end
+  end
+
+  module ExternalFileError
+    # This module implements logging with a filename and line number. Use this
+    # for errors that need to report a location in a non-ruby file that we
+    # parse.
+    attr_accessor :line, :file, :pos, :puppetstack
+
+    # May be called with 3 arguments for message, file, line, and exception, or
+    # 4 args including the position on the line.
+    #
+    def initialize(message, file = nil, line = nil, pos = nil, original = nil)
+      if pos.is_a? Exception
+        original = pos
+        pos = nil
+      end
+
+      super(message, original)
+
+      @file = file unless file.is_a?(String) && file.empty?
+      @line = line
+      @pos = pos
+
+      if original && original.respond_to?(:puppetstack)
+        @puppetstack = original.puppetstack
+      else
+        @puppetstack = Puppet::Pops::PuppetStack.stacktrace()
+      end
+    end
+
+    def to_s
+      msg = super
+      @file = nil if @file.is_a?(String) && @file.empty?
+      msg += Puppet::Util::Errors.error_location_with_space(@file, @line, @pos)
+      msg
+    end
+  end
+
+  class ParseError < Puppet::Error
+    include ExternalFileError
+  end
+
+  class ResourceError < Puppet::Error
+    include ExternalFileError
+  end
+
+  # Contains an issue code and can be annotated with an environment and a node
+  class ParseErrorWithIssue < Puppet::ParseError
+    attr_reader :issue_code, :basic_message, :arguments
+    attr_accessor :environment, :node
+
+    # @param message [String] The error message
+    # @param file [String] The path to the file where the error was found
+    # @param line [Integer] The line in the file
+    # @param pos [Integer] The position on the line
+    # @param original [Exception] Original exception
+    # @param issue_code [Symbol] The issue code
+    # @param arguments [Hash{Symbol=>Object}] Issue arguments
+    #
+    def initialize(message, file = nil, line = nil, pos = nil, original = nil, issue_code = nil, arguments = nil)
+      super(message, file, line, pos, original)
+      @issue_code = issue_code
+      @basic_message = message
+      @arguments = arguments
+    end
+
+    def to_s
+      msg = super
+      msg = _("Could not parse for environment %{environment}: %{message}") % { environment: environment, message: msg } if environment
+      msg = _("%{message} on node %{node}") % { message: msg, node: node } if node
+      msg
+    end
+
+    def to_h
+      {
+        :issue_code => issue_code,
+        :message => basic_message,
+        :full_message => to_s,
+        :file => file,
+        :line => line,
+        :pos => pos,
+        :environment => environment.to_s,
+        :node => node.to_s,
+      }
+    end
+
+    def self.from_issue_and_stack(issue, args = {})
+      filename, line = Puppet::Pops::PuppetStack.top_of_stack
+
+      new(
+        issue.format(args),
+        filename,
+        line,
+        nil,
+        nil,
+        issue.issue_code,
+        args
+      )
+    end
+  end
+
+  # An error that already contains location information in the message text
+  class PreformattedError < Puppet::ParseErrorWithIssue
+  end
+
+  # An error class for when I don't know what happened.  Automatically
+  # prints a stack trace when in debug mode.
+  class DevError < Puppet::Error
+    include ExternalFileError
+  end
+
+  class MissingCommand < Puppet::Error
+  end
+
+  # Raised when we failed to acquire a lock
+  class LockError < Puppet::Error
+  end
+
+  # An Error suitable for raising an error with details in a Puppet::Datatypes::Error
+  # that can be used as a value in the Puppet Language
+  #
+  class ErrorWithData < Puppet::Error
+    include ExternalFileError
+    attr_reader :error_data
+
+    def initialize(error_data, message, file: nil, line: nil, pos: nil, original: nil)
+      super(message, file, line, pos, original)
+      @error_data = error_data
+    end
+  end
+end

data/lib/puppet/etc.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require_relative '../puppet/util/character_encoding'
+# Wrapper around Ruby Etc module allowing us to manage encoding in a single
+# place.
+# This represents a subset of Ruby's Etc module, only the methods required by Puppet.
+
+# On Ruby 2.1.0 and later, Etc returns strings in variable encoding depending on
+# environment. The string returned will be labeled with the environment's
+# encoding (Encoding.default_external), with one exception: If the environment
+# encoding is 7-bit ASCII, and any individual character bit representation is
+# equal to or greater than 128 - \x80 - 0b10000000 - signifying the smallest
+# 8-bit big-endian value, the returned string will be in BINARY encoding instead
+# of environment encoding.
+#
+# Barring that exception, the returned string will be labeled as encoding
+# Encoding.default_external, regardless of validity or byte-width. For example,
+# ruby will label a string containing a four-byte characters such as "\u{2070E}"
+# as EUC_KR even though EUC_KR is a two-byte width encoding.
+#
+# On Ruby 2.0.x and earlier, Etc will always return string values in BINARY,
+# ignoring encoding altogether.
+#
+# For Puppet we specifically want UTF-8 as our input from the Etc module - which
+# is our input for many resource instance 'is' values. The associated 'should'
+# value will basically always be coming from Puppet in UTF-8 - and written to
+# disk as UTF-8. Etc is defined for Windows but the majority calls to it return
+# nil and Puppet does not use it.
+#
+# That being said, we have cause to retain the original, pre-override string
+# values. `puppet resource user`
+# (Puppet::Resource::User.indirection.search('User', {})) uses self.instances to
+# query for user(s) and then iterates over the results of that query again to
+# obtain state for each user. If we've overridden the original user name and not
+# retained the original, we've lost the ability to query the system for it
+# later. Hence the Puppet::Etc::Passwd and Puppet::Etc::Group structs.
+#
+# We only use Etc for retrieving existing property values from the system. For
+# setting property values, providers leverage system tools (i.e., `useradd`)
+#
+# @api private
+module Puppet::Etc
+  class << self
+    # Etc::getgrent returns an Etc::Group struct object
+    # On first call opens /etc/group and returns parse of first entry. Each subsquent call
+    # returns new struct the next entry or nil if EOF. Call ::endgrent to close file.
+    def getgrent
+      override_field_values_to_utf8(::Etc.getgrent)
+    end
+
+    # closes handle to /etc/group file
+    def endgrent
+      ::Etc.endgrent
+    end
+
+    # effectively equivalent to IO#rewind of /etc/group
+    def setgrent
+      ::Etc.setgrent
+    end
+
+    # Etc::getpwent returns an Etc::Passwd struct object
+    # On first call opens /etc/passwd and returns parse of first entry. Each subsquent call
+    # returns new struct for the next entry or nil if EOF. Call ::endgrent to close file.
+    def getpwent
+      override_field_values_to_utf8(::Etc.getpwent)
+    end
+
+    # closes handle to /etc/passwd file
+    def endpwent
+      ::Etc.endpwent
+    end
+
+    # effectively equivalent to IO#rewind of /etc/passwd
+    def setpwent
+      ::Etc.setpwent
+    end
+
+    # Etc::getpwnam searches /etc/passwd file for an entry corresponding to
+    # username.
+    # returns an Etc::Passwd struct corresponding to the entry or raises
+    # ArgumentError if none
+    def getpwnam(username)
+      override_field_values_to_utf8(::Etc.getpwnam(username))
+    end
+
+    # Etc::getgrnam searches /etc/group file for an entry corresponding to groupname.
+    # returns an Etc::Group struct corresponding to the entry or raises
+    # ArgumentError if none
+    def getgrnam(groupname)
+      override_field_values_to_utf8(::Etc.getgrnam(groupname))
+    end
+
+    # Etc::getgrid searches /etc/group file for an entry corresponding to id.
+    # returns an Etc::Group struct corresponding to the entry or raises
+    # ArgumentError if none
+    def getgrgid(id)
+      override_field_values_to_utf8(::Etc.getgrgid(id))
+    end
+
+    # Etc::getpwuid searches /etc/passwd file for an entry corresponding to id.
+    # returns an Etc::Passwd struct corresponding to the entry or raises
+    # ArgumentError if none
+    def getpwuid(id)
+      override_field_values_to_utf8(::Etc.getpwuid(id))
+    end
+
+    # Etc::group returns a Ruby iterator that executes a block for
+    # each entry in the /etc/group file. The code-block is passed
+    # a Group struct. See getgrent above for more details.
+    def group
+      # The implementation here duplicates the logic in https://github.com/ruby/etc/blob/master/ext/etc/etc.c#L523-L537
+      # Note that we do not call ::Etc.group directly, because we
+      # want to use our wrappers for methods like getgrent, setgrent,
+      # endgrent, etc.
+      return getgrent unless block_given?
+
+      setgrent
+      begin
+        while cur_group = getgrent # rubocop:disable Lint/AssignmentInCondition
+          yield cur_group
+        end
+      ensure
+        endgrent
+      end
+    end
+
+    private
+
+    # @api private
+    # Defines Puppet::Etc::Passwd struct class. Contains all of the original
+    # member fields of Etc::Passwd, and additional "canonical_" versions of
+    # these fields as well. API compatible with Etc::Passwd. Because Struct.new
+    # defines a new Class object, we memoize to avoid superfluous extra Class
+    # instantiations.
+    # rubocop:disable Naming/MemoizedInstanceVariableName
+    def puppet_etc_passwd_class
+      @password_class ||= Struct.new(*Etc::Passwd.members, *Etc::Passwd.members.map { |member| "canonical_#{member}".to_sym })
+    end
+
+    # @api private
+    # Defines Puppet::Etc::Group struct class. Contains all of the original
+    # member fields of Etc::Group, and additional "canonical_" versions of these
+    # fields as well. API compatible with Etc::Group. Because Struct.new
+    # defines a new Class object, we memoize to avoid superfluous extra Class
+    # instantiations.
+    def puppet_etc_group_class
+      @group_class ||= Struct.new(*Etc::Group.members, *Etc::Group.members.map { |member| "canonical_#{member}".to_sym })
+    end
+    # rubocop:enable Naming/MemoizedInstanceVariableName
+
+    # Utility method for overriding the String values of a struct returned by
+    # the Etc module to UTF-8. Structs returned by the ruby Etc module contain
+    # members with fields of type String, Integer, or Array of Strings, so we
+    # handle these types. Otherwise ignore fields.
+    #
+    # @api private
+    # @param [Etc::Passwd or Etc::Group struct]
+    # @return [Puppet::Etc::Passwd or Puppet::Etc::Group struct] a new struct
+    #   object with the original struct values overridden to UTF-8, if valid. For
+    #   invalid values originating in UTF-8, invalid characters are replaced with
+    #   '?'. For each member the struct also contains a corresponding
+    #   :canonical_<member name> struct member.
+    def override_field_values_to_utf8(struct)
+      return nil if struct.nil?
+
+      new_struct = struct.is_a?(Etc::Passwd) ? puppet_etc_passwd_class.new : puppet_etc_group_class.new
+      struct.each_pair do |member, value|
+        case value
+        when String
+          new_struct["canonical_#{member}".to_sym] = value.dup
+          new_struct[member] = Puppet::Util::CharacterEncoding.override_encoding_to_utf_8(value).scrub
+        when Array
+          new_struct["canonical_#{member}".to_sym] = value.inject([]) { |acc, elem| acc << elem.dup }
+          new_struct[member] = value.inject([]) do |acc, elem|
+            acc << Puppet::Util::CharacterEncoding.override_encoding_to_utf_8(elem).scrub
+          end
+        else
+          new_struct["canonical_#{member}".to_sym] = value
+          new_struct[member] = value
+        end
+      end
+      new_struct
+    end
+  end
+end

data/lib/puppet/external/dot.rb

@@ -0,0 +1,315 @@
+# frozen_string_literal: true
+
+# rdot.rb
+#
+#
+# This is a modified version of dot.rb from Dave Thomas's rdoc project.  I [Horst Duchene]
+# renamed it to rdot.rb to avoid collision with an installed rdoc/dot.
+#
+# It also supports undirected edges.
+
+module DOT
+  # These global vars are used to make nice graph source.
+
+  $tab  = '    '
+  $tab2 = $tab * 2
+
+  # if we don't like 4 spaces, we can change it any time
+
+  def change_tab(t)
+    $tab  = t
+    $tab2 = t * 2
+  end
+
+  # options for node declaration
+
+  NODE_OPTS = [
+    # attributes due to
+    # http://www.graphviz.org/Documentation/dotguide.pdf
+    # March, 26, 2005
+    'bottomlabel', # auxiliary label for nodes of shape M*
+    'color',       # default: black; node shape color
+    'comment',     # any string (format-dependent)
+    'distortion',  # default: 0.0; node distortion for shape=polygon
+    'fillcolor',   # default: lightgrey/black; node fill color
+    'fixedsize',   # default: false; label text has no affect on node size
+    'fontcolor',   # default: black; type face color
+    'fontname',    # default: Times-Roman; font family
+    'fontsize',    # default: 14; point size of label
+    'group',       # name of node's group
+    'height',      # default: .5; height in inches
+    'label',       # default: node name; any string
+    'layer',       # default: overlay range; all, id or id:id
+    'orientation', # default: 0.0; node rotation angle
+    'peripheries', # shape-dependent number of node boundaries
+    'regular',     # default: false; force polygon to be regular
+    'shape',       # default: ellipse; node shape; see Section 2.1 and Appendix E
+    'shapefile',   # external EPSF or SVG custom shape file
+    'sides',       # default: 4; number of sides for shape=polygon
+    'skew',        # default: 0.0; skewing of node for shape=polygon
+    'style',       # graphics options, e.g. bold, dotted, filled; cf. Section 2.3
+    'toplabel',    # auxiliary label for nodes of shape M*
+    'URL',         # URL associated with node (format-dependent)
+    'width',       # default: .75; width in inches
+    'z',           # default: 0.0; z coordinate for VRML output
+
+    # maintained for backward compatibility or rdot internal
+    'bgcolor',
+    'rank'
+  ]
+
+  # options for edge declaration
+
+  EDGE_OPTS = [
+    'arrowhead',      # default: normal; style of arrowhead at head end
+    'arrowsize',      # default: 1.0; scaling factor for arrowheads
+    'arrowtail',      # default: normal; style of arrowhead at tail end
+    'color',          # default: black; edge stroke color
+    'comment',        # any string (format-dependent)
+    'constraint',     # default: true use edge to affect node ranking
+    'decorate',       # if set, draws a line connecting labels with their edges
+    'dir',            # default: forward; forward, back, both, or none
+    'fontcolor',      # default: black type face color
+    'fontname',       # default: Times-Roman; font family
+    'fontsize',       # default: 14; point size of label
+    'headlabel',      # label placed near head of edge
+    'headport',       # n,ne,e,se,s,sw,w,nw
+    'headURL',        # URL attached to head label if output format is ismap
+    'label',          # edge label
+    'labelangle',     # default: -25.0; angle in degrees which head or tail label is rotated off edge
+    'labeldistance',  # default: 1.0; scaling factor for distance of head or tail label from node
+    'labelfloat',     # default: false; lessen constraints on edge label placement
+    'labelfontcolor', # default: black; type face color for head and tail labels
+    'labelfontname',  # default: Times-Roman; font family for head and tail labels
+    'labelfontsize',  # default: 14 point size for head and tail labels
+    'layer',          # default: overlay range; all, id or id:id
+    'lhead',          # name of cluster to use as head of edge
+    'ltail',          # name of cluster to use as tail of edge
+    'minlen',         # default: 1 minimum rank distance between head and tail
+    'samehead',       # tag for head node; edge heads with the same tag are merged onto the same port
+    'sametail',       # tag for tail node; edge tails with the same tag are merged onto the same port
+    'style',          # graphics options, e.g. bold, dotted, filled; cf. Section 2.3
+    'taillabel',      # label placed near tail of edge
+    'tailport',       # n,ne,e,se,s,sw,w,nw
+    'tailURL',        # URL attached to tail label if output format is ismap
+    'weight',         # default: 1; integer cost of stretching an edge
+
+    # maintained for backward compatibility or rdot internal
+    'id'
+  ]
+
+  # options for graph declaration
+
+  GRAPH_OPTS = %w[
+    bgcolor
+    center clusterrank color concentrate
+    fontcolor fontname fontsize
+    label layerseq
+    margin mclimit
+    nodesep nslimit
+    ordering orientation
+    page
+    rank rankdir ranksep ratio
+    size
+  ]
+
+  # a root class for any element in dot notation
+
+  class DOTSimpleElement
+    attr_accessor :name
+
+    def initialize(params = {})
+      @label = params['name'] || ''
+    end
+
+    def to_s
+      @name
+    end
+  end
+
+  # an element that has options ( node, edge, or graph )
+
+  class DOTElement < DOTSimpleElement
+    # attr_reader :parent
+    attr_accessor :name, :options
+
+    def initialize(params = {}, option_list = [])
+      super(params)
+      @name   = params['name']   || nil
+      @parent = params['parent'] || nil
+      @options = {}
+      option_list.each { |i|
+        @options[i] = params[i] if params[i]
+      }
+      @options['label'] ||= @name if @name != 'node'
+    end
+
+    def each_option
+      @options.each { |i| yield i }
+    end
+
+    def each_option_pair
+      @options.each_pair { |key, val| yield key, val }
+    end
+  end
+
+  # This is used when we build nodes that have shape=record
+  # ports don't have options :)
+
+  class DOTPort < DOTSimpleElement
+    attr_accessor :label
+
+    def initialize(params = {})
+      super(params)
+      @name = params['label'] || ''
+    end
+
+    def to_s
+      (@name && @name != "" ? "<#{@name}>" : "") + @label.to_s
+    end
+  end
+
+  # node element
+
+  class DOTNode < DOTElement
+    def initialize(params = {}, option_list = NODE_OPTS)
+      super(params, option_list)
+      @ports = params['ports'] || []
+    end
+
+    def each_port
+      @ports.each { |i| yield i }
+    end
+
+    def <<(thing)
+      @ports << thing
+    end
+
+    def push(thing)
+      @ports.push(thing)
+    end
+
+    def pop
+      @ports.pop
+    end
+
+    def to_s(t = '')
+      # This code is totally incomprehensible; it needs to be replaced!
+
+      label = if @options['shape'] != 'record' && @ports.length == 0
+                if @options['label']
+                  t + $tab + "label = #{stringify(@options['label'])}\n"
+                else
+                  ''
+                end
+              else
+                t + $tab + 'label = "' + " \\\n" +
+                  t + $tab2 + "#{stringify(@options['label'])}| \\\n" +
+                  @ports.collect { |i|
+                    t + $tab2 + i.to_s
+                  }.join("| \\\n") + " \\\n" +
+                  t + $tab + '"' + "\n"
+              end
+
+      t + "#{@name} [\n" +
+        @options.to_a.filter_map { |i|
+          i[1] && i[0] != 'label' ?
+            t + $tab + "#{i[0]} = #{i[1]}" : nil
+        }.join(",\n") + (label != '' ? ",\n" : "\n") +
+        label +
+        t + "]\n"
+    end
+
+    private
+
+    def stringify(s)
+      %("#{s.gsub('"', '\\"')}")
+    end
+  end
+
+  # A subgraph element is the same to graph, but has another header in dot
+  # notation.
+
+  class DOTSubgraph < DOTElement
+    def initialize(params = {}, option_list = GRAPH_OPTS)
+      super(params, option_list)
+      @nodes      = params['nodes'] || []
+      @dot_string = 'graph'
+    end
+
+    def each_node
+      @nodes.each { |i| yield i }
+    end
+
+    def <<(thing)
+      @nodes << thing
+    end
+
+    def push(thing)
+      @nodes.push(thing)
+    end
+
+    def pop
+      @nodes.pop
+    end
+
+    def to_s(t = '')
+      hdr = t + "#{@dot_string} #{@name} {\n"
+
+      options = @options.to_a.filter_map { |name, val|
+        if val && name != 'label'
+          t + $tab + "#{name} = #{val}"
+        else
+          name ? t + $tab + "#{name} = \"#{val}\"" : nil
+        end
+      }.join("\n") + "\n"
+
+      nodes = @nodes.collect { |i|
+        i.to_s(t + $tab)
+      }.join("\n") + "\n"
+      hdr + options + nodes + t + "}\n"
+    end
+  end
+
+  # This is a graph.
+
+  class DOTDigraph < DOTSubgraph
+    def initialize(params = {}, option_list = GRAPH_OPTS)
+      super(params, option_list)
+      @dot_string = 'digraph'
+    end
+  end
+
+  # This is an edge.
+
+  class DOTEdge < DOTElement
+    attr_accessor :from, :to
+
+    def initialize(params = {}, option_list = EDGE_OPTS)
+      super(params, option_list)
+      @from = params['from'] || nil
+      @to   = params['to'] || nil
+    end
+
+    def edge_link
+      '--'
+    end
+
+    def to_s(t = '')
+      t + "#{@from} #{edge_link} #{to} [\n" +
+        @options.to_a.filter_map { |i|
+          if i[1] && i[0] != 'label'
+            t + $tab + "#{i[0]} = #{i[1]}"
+          else
+            i[1] ? t + $tab + "#{i[0]} = \"#{i[1]}\"" : nil
+          end
+        }.join("\n") + "\n#{t}]\n"
+    end
+  end
+
+  class DOTDirectedEdge < DOTEdge
+    def edge_link
+      '->'
+    end
+  end
+end

data/lib/puppet/face/catalog/select.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# Select and show a list of resources of a given type.
+Puppet::Face.define(:catalog, '0.0.1') do
+  action :select do
+    summary _("Retrieve a catalog and filter it for resources of a given type.")
+    arguments _("<host> <resource_type>")
+    returns _(<<-'EOT')
+      A list of resource references ("Type[title]"). When used from the API,
+      returns an array of Puppet::Resource objects excised from a catalog.
+    EOT
+    description <<-'EOT'
+      Retrieves a catalog for the specified host, then searches it for all
+      resources of the requested type.
+    EOT
+    notes <<-'NOTES'
+      By default, this action will retrieve a catalog from Puppet's compiler
+      subsystem; you must call the action with `--terminus rest` if you wish
+      to retrieve a catalog from the puppet master.
+
+      FORMATTING ISSUES: This action cannot currently render useful yaml;
+      instead, it returns an entire catalog. Use json instead.
+    NOTES
+    examples <<-'EOT'
+      Ask the puppet master for a list of managed file resources for a node:
+
+      $ puppet catalog select --terminus rest somenode.magpie.lan file
+    EOT
+    when_invoked do |host, type, _options|
+      # REVISIT: Eventually, type should have a default value that triggers
+      # the non-specific behaviour.  For now, though, this will do.
+      # --daniel 2011-05-03
+      catalog = Puppet::Resource::Catalog.indirection.find(host)
+
+      if type == '*'
+        catalog.resources
+      else
+        type = type.downcase
+        catalog.resources.reject { |res| res.type.downcase != type }
+      end
+    end
+
+    when_rendering :console do |value|
+      if value.nil? then
+        _("no matching resources found")
+      else
+        value.map(&:to_s).join("\n")
+      end
+    end
+  end
+end