openvox 7.37.1

data/lib/puppet/face/parser.rb

@@ -0,0 +1,227 @@
+require_relative '../../puppet/face'
+require_relative '../../puppet/parser'
+
+Puppet::Face.define(:parser, '0.0.1') do
+  copyright "Puppet Inc.", 2014
+  license   _("Apache 2 license; see COPYING")
+
+  summary _("Interact directly with the parser.")
+
+  action :validate do
+    summary _("Validate the syntax of one or more Puppet manifests.")
+    arguments _("[<manifest>] [<manifest> ...]")
+    returns _("Nothing, or the first syntax error encountered.")
+
+    description <<-'EOT'
+      This action validates Puppet DSL syntax without compiling a catalog or
+      syncing any resources. If no manifest files are provided, it will
+      validate the default site manifest.
+
+      When validating multiple issues per file are reported up
+      to the settings of max_error, and max_warnings. The processing stops
+      after having reported issues for the first encountered file with errors.
+    EOT
+    examples <<-'EOT'
+      Validate the default site manifest at /etc/puppetlabs/puppet/manifests/site.pp:
+
+      $ puppet parser validate
+
+      Validate two arbitrary manifest files:
+
+      $ puppet parser validate init.pp vhost.pp
+
+      Validate from STDIN:
+
+      $ cat init.pp | puppet parser validate
+    EOT
+    when_invoked do |*args|
+      files = args.slice(0..-2)
+
+      parse_errors = {}
+
+      if files.empty?
+        if not STDIN.tty?
+          Puppet[:code] = STDIN.read
+          error = validate_manifest(nil)
+          parse_errors['STDIN'] = error if error
+        else
+          manifest = Puppet.lookup(:current_environment).manifest
+          files << manifest
+          Puppet.notice _("No manifest specified. Validating the default manifest %{manifest}") % { manifest: manifest }
+        end
+      end
+
+      missing_files = []
+
+      files.each do |file|
+        if Puppet::FileSystem.exist?(file)
+          error = validate_manifest(file)
+          parse_errors[file] = error if error
+        else
+          missing_files << file
+        end
+      end
+
+      unless missing_files.empty?
+        raise Puppet::Error, _("One or more file(s) specified did not exist:\n%{files}") % { files: missing_files.collect {|f| " " * 3 + f + "\n"} }
+      end
+
+      parse_errors
+    end
+
+    when_rendering :console do |errors|
+      unless errors.empty?
+        errors.each { |_, error| Puppet.log_exception(error) }
+
+        exit(1)
+      end
+
+      # Prevent face_base renderer from outputting "null"
+      exit(0)
+    end
+
+    when_rendering :json do |errors|
+      unless errors.empty?
+        ignore_error_keys = [ :arguments, :environment, :node ]
+
+        data = errors.map do |file, error|
+          file_errors = error.to_h.reject { |k, _| ignore_error_keys.include?(k) }
+          [file, file_errors]
+        end.to_h
+
+        puts Puppet::Util::Json.dump(Puppet::Pops::Serialization::ToDataConverter.convert(data, rich_data: false, symbol_as_string: true), :pretty => true)
+
+        exit(1)
+      end
+
+      # Prevent face_base renderer from outputting "null"
+      exit(0)
+    end
+  end
+
+
+  action (:dump) do
+    summary _("Outputs a dump of the internal parse tree for debugging")
+    arguments "[--format <old|pn|json>] [--pretty] { -e <source> | [<templates> ...] } "
+    returns _("A dump of the resulting AST model unless there are syntax or validation errors.")
+    description <<-'EOT'
+      This action parses and validates the Puppet DSL syntax without compiling a catalog
+      or syncing any resources.
+
+      The output format can be controlled using the --format <old|pn|json> where:
+      * 'old' is the default, but now deprecated format which is not API.
+      * 'pn' is the Puppet Extended S-Expression Notation.
+      * 'json' outputs the same graph as 'pn' but with JSON syntax.
+
+      The output will be "pretty printed" when the option --pretty is given together with --format 'pn' or 'json'.
+      This option has no effect on the 'old' format.
+
+      The command accepts one or more manifests (.pp) files, or an -e followed by the puppet
+      source text.
+      If no arguments are given, the stdin is read (unless it is attached to a terminal)
+
+      The output format of the dumped tree is intended for debugging purposes and is
+      not API, it may change from time to time.
+    EOT
+
+    option "--e " + _("<source>") do
+      default_to { nil }
+      summary _("dump one source expression given on the command line.")
+    end
+
+    option("--[no-]validate") do
+      summary _("Whether or not to validate the parsed result, if no-validate only syntax errors are reported")
+    end
+
+    option('--format ' + _('<old, pn, or json>')) do
+      summary _("Get result in 'old' (deprecated format), 'pn' (new format), or 'json' (new format in JSON).")
+    end
+
+    option('--pretty') do
+      summary _('Pretty print output. Only applicable together with --format pn or json')
+    end
+
+    when_invoked do |*args|
+      require_relative '../../puppet/pops'
+      options = args.pop
+      if options[:e]
+        dump_parse(options[:e], 'command-line-string', options, false)
+      elsif args.empty?
+        if ! STDIN.tty?
+          dump_parse(STDIN.read, 'stdin', options, false)
+        else
+          raise Puppet::Error, _("No input to parse given on command line or stdin")
+        end
+      else
+        files = args
+        available_files = files.select do |file|
+          Puppet::FileSystem.exist?(file)
+        end
+        missing_files = files - available_files
+
+        dumps = available_files.collect do |file|
+          dump_parse(Puppet::FileSystem.read(file, :encoding => 'utf-8'), file, options)
+        end.join("")
+
+        if missing_files.empty?
+          dumps
+        else
+          dumps + _("One or more file(s) specified did not exist:\n") + missing_files.collect { |f| "   #{f}" }.join("\n")
+        end
+      end
+    end
+  end
+
+  def dump_parse(source, filename, options, show_filename = true)
+    output = ""
+    evaluating_parser = Puppet::Pops::Parser::EvaluatingParser.new
+    begin
+      if options[:validate]
+        parse_result = evaluating_parser.parse_string(source, filename)
+      else
+        # side step the assert_and_report step
+        parse_result = evaluating_parser.parser.parse_string(source)
+      end
+      if show_filename
+        output << "--- #{filename}"
+      end
+      fmt = options[:format]
+      if fmt.nil? || fmt == 'old'
+        output << Puppet::Pops::Model::ModelTreeDumper.new.dump(parse_result) << "\n"
+      else
+        require_relative '../../puppet/pops/pn'
+        pn = Puppet::Pops::Model::PNTransformer.transform(parse_result)
+        case fmt
+        when 'json'
+          options[:pretty] ? JSON.pretty_unparse(pn.to_data) : JSON.dump(pn.to_data)
+        else
+          pn.format(options[:pretty] ? Puppet::Pops::PN::Indent.new('  ') : nil, output)
+        end
+      end
+    rescue Puppet::ParseError => detail
+      if show_filename
+        Puppet.err("--- #{filename}")
+      end
+      Puppet.err(detail.message)
+      ""
+    end
+  end
+
+  # @api private
+  def validate_manifest(manifest = nil)
+    env = Puppet.lookup(:current_environment)
+    loaders = Puppet::Pops::Loaders.new(env)
+
+    Puppet.override( {:loaders => loaders } , _('For puppet parser validate')) do
+      begin
+        validation_environment = manifest ? env.override_with(:manifest => manifest) : env
+        validation_environment.check_for_reparse
+        validation_environment.known_resource_types.clear
+      rescue Puppet::ParseError => parse_error
+        return parse_error
+      end
+    end
+
+    nil
+  end
+end

data/lib/puppet/face/plugin.rb

@@ -0,0 +1,60 @@
+require_relative '../../puppet/face'
+require_relative '../../puppet/configurer/plugin_handler'
+
+Puppet::Face.define(:plugin, '0.0.1') do
+  copyright "Puppet Inc.", 2011
+  license   _("Apache 2 license; see COPYING")
+
+  summary _("Interact with the Puppet plugin system.")
+  description <<-'EOT'
+    This subcommand provides network access to the puppet master's store of
+    plugins.
+
+    The puppet master serves Ruby code collected from the `lib` directories
+    of its modules. These plugins can be used on agent nodes to extend
+    Facter and implement custom types and providers. Plugins are normally
+    downloaded by puppet agent during the course of a run.
+  EOT
+
+  action :download do
+    summary _("Download plugins from the puppet master.")
+    description <<-'EOT'
+      Downloads plugins from the configured puppet master. Any plugins
+      downloaded in this way will be used in all subsequent Puppet activity.
+      This action modifies files on disk.
+    EOT
+    returns _(<<-'EOT')
+      A list of the files downloaded, or a confirmation that no files were
+      downloaded. When used from the Ruby API, this action returns an array of
+      the files downloaded, which will be empty if none were retrieved.
+    EOT
+    examples <<-'EOT'
+      Retrieve plugins from the puppet master:
+
+      $ puppet plugin download
+
+      Retrieve plugins from the puppet master (API example):
+
+      $ Puppet::Face[:plugin, '0.0.1'].download
+    EOT
+
+    when_invoked do |options|
+      remote_environment_for_plugins = Puppet::Node::Environment.remote(Puppet[:environment])
+
+      begin
+        handler = Puppet::Configurer::PluginHandler.new
+        handler.download_plugins(remote_environment_for_plugins)
+      ensure
+        Puppet.runtime[:http].close
+      end
+    end
+
+    when_rendering :console do |value|
+      if value.empty? then
+        _("No plugins downloaded.")
+      else
+        _("Downloaded these plugins: %{plugins}") % { plugins: value.join(', ') }
+      end
+    end
+  end
+end

data/lib/puppet/face/report.rb

@@ -0,0 +1,54 @@
+require_relative '../../puppet/indirector/face'
+
+Puppet::Indirector::Face.define(:report, '0.0.1') do
+  copyright "Puppet Inc.", 2011
+  license   _("Apache 2 license; see COPYING")
+
+  summary _("Create, display, and submit reports.")
+
+  save = get_action(:save)
+  save.summary _("API only: submit a report.")
+  save.arguments _("<report>")
+  save.returns _("Nothing.")
+  save.examples <<-'EOT'
+    From the implementation of `puppet report submit` (API example):
+
+        begin
+          Puppet::Transaction::Report.indirection.terminus_class = :rest
+          Puppet::Face[:report, "0.0.1"].save(report)
+          Puppet.notice "Uploaded report for #{report.name}"
+        rescue => detail
+          Puppet.log_exception(detail, "Could not send report: #{detail}")
+        end
+  EOT
+
+  action(:submit) do
+    summary _("API only: submit a report with error handling.")
+    description <<-'EOT'
+      API only: Submits a report to the puppet master. This action is
+      essentially a shortcut and wrapper for the `save` action with the `rest`
+      terminus, and provides additional details in the event of a failure.
+    EOT
+    arguments _("<report>")
+    examples <<-'EOT'
+      API example:
+
+          # ...
+          report  = Puppet::Face[:catalog, '0.0.1'].apply
+          Puppet::Face[:report, '0.0.1'].submit(report)
+          return report
+    EOT
+    when_invoked do |report, options|
+      begin
+        Puppet::Transaction::Report.indirection.terminus_class = :rest
+        Puppet::Face[:report, "0.0.1"].save(report)
+        Puppet.notice _("Uploaded report for %{name}") % { name: report.name }
+      rescue => detail
+        Puppet.log_exception(detail, _("Could not send report: %{detail}") % { detail: detail })
+      end
+    end
+  end
+  deactivate_action(:find)
+  deactivate_action(:search)
+  deactivate_action(:destroy)
+end

data/lib/puppet/face/resource.rb

@@ -0,0 +1,53 @@
+require_relative '../../puppet/indirector/face'
+
+Puppet::Indirector::Face.define(:resource, '0.0.1') do
+  copyright "Puppet Inc.", 2011
+  license   _("Apache 2 license; see COPYING")
+
+  summary _("API only: interact directly with resources via the RAL.")
+  description <<-'EOT'
+    API only: this face provides a Ruby API with functionality similar to the
+    puppet resource subcommand.
+  EOT
+
+  deactivate_action(:destroy)
+
+  search = get_action(:search)
+  search.summary _("API only: get all resources of a single type.")
+  search.arguments _("<resource_type>")
+  search.returns _("An array of Puppet::Resource objects.")
+  search.examples <<-'EOT'
+    Get a list of all user resources (API example):
+
+        all_users = Puppet::Face[:resource, '0.0.1'].search("user")
+  EOT
+
+  find = get_action(:find)
+  find.summary _("API only: get a single resource.")
+  find.arguments _("<type>/<title>")
+  find.returns _("A Puppet::Resource object.")
+  find.examples <<-'EOT'
+    Print information about a user on this system (API example):
+
+        puts Puppet::Face[:resource, '0.0.1'].find("user/luke").to_json
+  EOT
+
+  save = get_action(:save)
+  save.summary _("API only: create a new resource.")
+  save.description <<-EOT
+    API only: creates a new resource.
+  EOT
+  save.arguments _("<resource_object>")
+  save.returns _("The same resource object passed as an argument.")
+  save.examples <<-'EOT'
+    Create a new file resource (API example):
+
+        my_resource = Puppet::Resource.new(
+          :file,
+          "/tmp/demonstration",
+          :parameters => {:ensure => :present, :content => "some\nthing\n"}
+        )
+
+        Puppet::Face[:resource, '0.0.1'].save(my_resource)
+  EOT
+end

data/lib/puppet/face.rb

@@ -0,0 +1,12 @@
+# The public name of this feature is 'face', but we have hidden all the
+# plumbing over in the 'interfaces' namespace to make clear the distinction
+# between the two.
+#
+# This file exists to ensure that the public name is usable without revealing
+# the details of the implementation; you really only need go look at anything
+# under Interfaces if you are looking to extend the implementation.
+#
+# It isn't hidden to gratuitously hide things, just to make it easier to
+# separate out the interests people will have.  --daniel 2011-04-07
+require_relative '../puppet/interface'
+Puppet::Face = Puppet::Interface

data/lib/puppet/facter_impl.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+#
+# @api private
+# Default Facter implementation that delegates to Facter API
+#
+
+module Puppet
+  class FacterImpl
+    def initialize
+      require 'facter'
+
+      setup_logging
+    end
+
+    def value(fact_name)
+      ::Facter.value(fact_name)
+    end
+
+    def add(name, &block)
+      ::Facter.add(name, &block)
+    end
+
+    def to_hash
+      ::Facter.to_hash
+    end
+
+    def clear
+      ::Facter.clear
+    end
+
+    def reset
+      ::Facter.reset
+    end
+
+    def resolve(options)
+      ::Facter.resolve(options)
+    end
+
+    def search_external(dirs)
+      ::Facter.search_external(dirs)
+    end
+
+    def search(*dirs)
+      ::Facter.search(*dirs)
+    end
+
+    def trace(value)
+      ::Facter.trace(value) if ::Facter.respond_to? :trace
+    end
+
+    def debugging(value)
+      ::Facter.debugging(value) if ::Facter.respond_to?(:debugging)
+    end
+
+    def load_external?
+      ::Facter.respond_to?(:load_external)
+    end
+
+    def load_external(value)
+      ::Facter.load_external(value) if self.load_external?
+    end
+
+    private
+
+    def setup_logging
+      return unless ::Facter.respond_to? :on_message
+
+      ::Facter.on_message do |level, message|
+        case level
+        when :trace, :debug
+          level = :debug
+        when :info
+          # Same as Puppet
+        when :warn
+          level = :warning
+        when :error
+          level = :err
+        when :fatal
+          level = :crit
+        else
+          next
+        end
+
+        Puppet::Util::Log.create(
+          {
+            :level => level,
+            :source => 'Facter',
+            :message => message
+          }
+        )
+        nil
+      end
+    end
+  end
+end

data/lib/puppet/feature/base.rb

@@ -0,0 +1,76 @@
+require_relative '../../puppet/util/feature'
+
+# Add the simple features, all in one file.
+
+# Order is important as some features depend on others
+
+# We have a syslog implementation
+Puppet.features.add(:syslog, :libs => ["syslog"])
+
+# We can use POSIX user functions
+Puppet.features.add(:posix) do
+  require 'etc'
+  !Etc.getpwuid(0).nil? && Puppet.features.syslog?
+end
+
+# We can use Microsoft Windows functions
+Puppet.features.add(:microsoft_windows) { Puppet::Util::Platform.windows? }
+
+raise Puppet::Error,_("Cannot determine basic system flavour") unless Puppet.features.posix? or Puppet.features.microsoft_windows?
+
+# We've got LDAP available.
+Puppet.features.add(:ldap, :libs => ["ldap"])
+
+# We have the Rdoc::Usage library.
+Puppet.features.add(:usage, :libs => %w{rdoc/ri/ri_paths rdoc/usage})
+
+# We have libshadow, useful for managing passwords.
+Puppet.features.add(:libshadow, :libs => ["shadow"])
+
+# We're running as root.
+Puppet.features.add(:root) do
+  require_relative '../../puppet/util/suidmanager'
+  Puppet::Util::SUIDManager.root?
+end
+
+# We have lcs diff
+Puppet.features.add :diff, :libs => %w{diff/lcs diff/lcs/hunk}
+
+# We have OpenSSL
+Puppet.features.add(:openssl, :libs => ["openssl"])
+
+# We have sqlite
+Puppet.features.add(:sqlite, :libs => ["sqlite3"])
+
+# We have Hiera
+Puppet.features.add(:hiera, :libs => ["hiera"])
+
+Puppet.features.add(:minitar, :libs => ["archive/tar/minitar"])
+
+# We can manage symlinks
+Puppet.features.add(:manages_symlinks) do
+  if ! Puppet::Util::Platform.windows?
+    true
+  else
+    module WindowsSymlink
+      require 'ffi'
+      extend FFI::Library
+
+      def self.is_implemented
+        begin
+          ffi_lib :kernel32
+          attach_function :CreateSymbolicLinkW, [:lpwstr, :lpwstr, :dword], :boolean
+
+          true
+        rescue LoadError
+          Puppet.debug { "CreateSymbolicLink is not available" }
+          false
+        end
+      end
+    end
+
+    WindowsSymlink.is_implemented
+  end
+end
+
+Puppet.features.add(:puppetserver_ca, libs: ['puppetserver/ca', 'puppetserver/ca/action/clean'])

data/lib/puppet/feature/bolt.rb

@@ -0,0 +1,3 @@
+require_relative '../../puppet/util/feature'
+
+Puppet.features.add(:bolt, :libs => ['bolt'])

data/lib/puppet/feature/cfpropertylist.rb

@@ -0,0 +1,3 @@
+require_relative '../../puppet/util/feature'
+
+Puppet.features.add(:cfpropertylist, :libs => ['cfpropertylist'])

data/lib/puppet/feature/eventlog.rb

@@ -0,0 +1,5 @@
+require_relative '../../puppet/util/feature'
+
+if Puppet::Util::Platform.windows?
+  Puppet.features.add(:eventlog)
+end

data/lib/puppet/feature/hiera_eyaml.rb

@@ -0,0 +1,3 @@
+require_relative '../../puppet/util/feature'
+
+Puppet.features.add(:hiera_eyaml, :libs => ['hiera/backend/eyaml/parser/parser'])

data/lib/puppet/feature/hocon.rb

@@ -0,0 +1,3 @@
+require_relative '../../puppet/util/feature'
+
+Puppet.features.add(:hocon, :libs => ['hocon'])

data/lib/puppet/feature/libuser.rb

@@ -0,0 +1,8 @@
+require_relative '../../puppet/util/feature'
+require_relative '../../puppet/util/libuser'
+
+Puppet.features.add(:libuser) {
+   File.executable?("/usr/sbin/lgroupadd") and
+   File.executable?("/usr/sbin/luseradd")  and
+   Puppet::FileSystem.exist?(Puppet::Util::Libuser.getconf)
+}

data/lib/puppet/feature/msgpack.rb

@@ -0,0 +1,3 @@
+require_relative '../../puppet/util/feature'
+
+Puppet.features.add(:msgpack, :libs => ["msgpack"])

data/lib/puppet/feature/pe_license.rb

@@ -0,0 +1,4 @@
+require_relative '../../puppet/util/feature'
+
+#Is the pe license library installed providing the ability to read licenses.
+Puppet.features.add(:pe_license, :libs => %{pe_license})

data/lib/puppet/feature/selinux.rb

@@ -0,0 +1,3 @@
+require_relative '../../puppet/util/feature'
+
+Puppet.features.add(:selinux, :libs => ["selinux"])

data/lib/puppet/feature/ssh.rb

@@ -0,0 +1,3 @@
+require_relative '../../puppet/util/feature'
+
+Puppet.features.add(:ssh, :libs => %{net/ssh})

data/lib/puppet/feature/telnet.rb

@@ -0,0 +1,9 @@
+require_relative '../../puppet/util/feature'
+
+Puppet.features.add :telnet do
+  begin
+    require 'net/telnet'
+  rescue LoadError
+    false
+  end
+end

data/lib/puppet/feature/zlib.rb

@@ -0,0 +1,5 @@
+require_relative '../../puppet/util/feature'
+
+# We want this to load if possible, but it's not automatically
+# required.
+Puppet.features.add(:zlib, :libs => %{zlib})

data/lib/puppet/ffi/posix/constants.rb

@@ -0,0 +1,14 @@
+require_relative '../../../puppet/ffi/posix'
+
+module Puppet::FFI::POSIX
+  module Constants
+    extend FFI::Library
+  
+    # Maximum number of supplementary groups (groups
+    # that a user can be in plus its primary group)
+    # (64 + 1 primary group)
+    # Chosen a reasonable middle number from the list
+    # https://www.j3e.de/ngroups.html
+    MAXIMUM_NUMBER_OF_GROUPS = 65
+  end
+end