openvox 7.37.1

data/lib/puppet/application/apply.rb

@@ -0,0 +1,428 @@
+require_relative '../../puppet/application'
+require_relative '../../puppet/configurer'
+require_relative '../../puppet/util/profiler/aggregate'
+
+class Puppet::Application::Apply < Puppet::Application
+  require_relative '../../puppet/util/splayer'
+  include Puppet::Util::Splayer
+
+  option("--debug","-d")
+  option("--execute EXECUTE","-e") do |arg|
+    options[:code] = arg
+  end
+  option("--loadclasses","-L")
+  option("--test","-t")
+  option("--verbose","-v")
+  option("--use-nodes")
+  option("--detailed-exitcodes")
+
+  option("--write-catalog-summary") do |arg|
+    Puppet[:write_catalog_summary] = arg
+  end
+
+  option("--catalog catalog",  "-c catalog") do |arg|
+    options[:catalog] = arg
+  end
+
+  option("--logdest LOGDEST", "-l") do |arg|
+    handle_logdest_arg(arg)
+  end
+
+  option("--parseonly") do |args|
+    puts "--parseonly has been removed. Please use 'puppet parser validate <manifest>'"
+    exit 1
+  end
+
+  def summary
+    _("Apply Puppet manifests locally")
+  end
+
+  def help
+    <<-HELP
+
+puppet-apply(8) -- #{summary}
+========
+
+SYNOPSIS
+--------
+Applies a standalone Puppet manifest to the local system.
+
+
+USAGE
+-----
+puppet apply [-h|--help] [-V|--version] [-d|--debug] [-v|--verbose]
+  [-e|--execute] [--detailed-exitcodes] [-L|--loadclasses]
+  [-l|--logdest syslog|eventlog|<ABS FILEPATH>|console] [--noop]
+  [--catalog <catalog>] [--write-catalog-summary] <file>
+
+
+DESCRIPTION
+-----------
+This is the standalone puppet execution tool; use it to apply
+individual manifests.
+
+When provided with a modulepath, via command line or config file, puppet
+apply can effectively mimic the catalog that would be served by puppet
+master with access to the same modules, although there are some subtle
+differences. When combined with scheduling and an automated system for
+pushing manifests, this can be used to implement a serverless Puppet
+site.
+
+Most users should use 'puppet agent' and 'puppet master' for site-wide
+manifests.
+
+
+OPTIONS
+-------
+Any setting that's valid in the configuration
+file is a valid long argument for puppet apply. For example, 'tags' is a
+valid setting, so you can specify '--tags <class>,<tag>'
+as an argument.
+
+See the configuration file documentation at
+https://puppet.com/docs/puppet/latest/configuration.html for the
+full list of acceptable parameters. You can generate a commented list of all
+configuration options by running puppet with
+'--genconfig'.
+
+* --debug:
+  Enable full debugging.
+
+* --detailed-exitcodes:
+  Provide extra information about the run via exit codes. If enabled, 'puppet
+  apply' will use the following exit codes:
+
+  0: The run succeeded with no changes or failures; the system was already in
+  the desired state.
+
+  1: The run failed.
+
+  2: The run succeeded, and some resources were changed.
+
+  4: The run succeeded, and some resources failed.
+
+  6: The run succeeded, and included both changes and failures.
+
+* --help:
+  Print this help message
+
+* --loadclasses:
+  Load any stored classes. 'puppet agent' caches configured classes
+  (usually at /etc/puppetlabs/puppet/classes.txt), and setting this option causes
+  all of those classes to be set in your puppet manifest.
+
+* --logdest:
+  Where to send log messages. Choose between 'syslog' (the POSIX syslog
+  service), 'eventlog' (the Windows Event Log), 'console', or the path to a log
+  file. Defaults to 'console'.
+  Multiple destinations can be set using a comma separated list
+  (eg: `/path/file1,console,/path/file2`)"
+
+  A path ending with '.json' will receive structured output in JSON format. The
+  log file will not have an ending ']' automatically written to it due to the
+  appending nature of logging. It must be appended manually to make the content
+  valid JSON.
+
+  A path ending with '.jsonl' will receive structured output in JSON Lines
+  format.
+
+* --noop:
+  Use 'noop' mode where Puppet runs in a no-op or dry-run mode. This
+  is useful for seeing what changes Puppet will make without actually
+  executing the changes.
+
+* --execute:
+  Execute a specific piece of Puppet code
+
+* --test:
+  Enable the most common options used for testing. These are 'verbose',
+  'detailed-exitcodes' and 'show_diff'.
+
+* --verbose:
+  Print extra information.
+
+* --catalog:
+  Apply a JSON catalog (such as one generated with 'puppet master --compile'). You can
+  either specify a JSON file or pipe in JSON from standard input.
+
+* --write-catalog-summary
+  After compiling the catalog saves the resource list and classes list to the node
+  in the state directory named classes.txt and resources.txt
+
+EXAMPLE
+-------
+    $ puppet apply -l /tmp/manifest.log manifest.pp
+    $ puppet apply --modulepath=/root/dev/modules -e "include ntpd::server"
+    $ puppet apply --catalog catalog.json
+
+
+AUTHOR
+------
+Luke Kanies
+
+
+COPYRIGHT
+---------
+Copyright (c) 2011 Puppet Inc., LLC Licensed under the Apache 2.0 License
+
+    HELP
+  end
+
+  def app_defaults
+    super.merge({
+      :default_file_terminus => :file_server,
+      :write_catalog_summary => false
+    })
+  end
+
+  def run_command
+    if options[:catalog]
+      apply
+    else
+      main
+    end
+  ensure
+    if @profiler
+      Puppet::Util::Profiler.remove_profiler(@profiler)
+      @profiler.shutdown
+    end
+  end
+
+  def apply
+    if options[:catalog] == "-"
+      text = $stdin.read
+    else
+      text = Puppet::FileSystem.read(options[:catalog], :encoding => 'utf-8')
+    end
+    env = Puppet.lookup(:environments).get(Puppet[:environment])
+    Puppet.override(:current_environment => env, :loaders => create_loaders(env)) do
+      catalog = read_catalog(text)
+      apply_catalog(catalog)
+    end
+  end
+
+  def main
+    manifest          = get_manifest() # Get either a manifest or nil if apply should use content of Puppet[:code]
+    splay                              # splay if needed
+    facts             = get_facts()    # facts or nil
+    node              = get_node()     # node or error
+    apply_environment = get_configured_environment(node, manifest)
+
+    # TRANSLATORS "puppet apply" is a program command and should not be translated
+    Puppet.override({:current_environment => apply_environment, :loaders => create_loaders(apply_environment)}, _("For puppet apply")) do
+      configure_node_facts(node, facts)
+
+      # Allow users to load the classes that puppet agent creates.
+      if options[:loadclasses]
+        file = Puppet[:classfile]
+        if Puppet::FileSystem.exist?(file)
+          unless FileTest.readable?(file)
+            $stderr.puts _("%{file} is not readable") % { file: file }
+            exit(63)
+          end
+          node.classes = Puppet::FileSystem.read(file, :encoding => 'utf-8').split(/[\s]+/)
+        end
+      end
+
+      begin
+        # Compile the catalog
+        starttime = Time.now
+
+        # When compiling, the compiler traps and logs certain errors
+        # Those that do not lead to an immediate exit are caught by the general
+        # rule and gets logged.
+        #
+        catalog =
+        begin
+          Puppet::Resource::Catalog.indirection.find(node.name, :use_node => node)
+        rescue Puppet::Error
+          # already logged and handled by the compiler, including Puppet::ParseErrorWithIssue
+          exit(1)
+        end
+
+        # Resolve all deferred values and replace them / mutate the catalog
+        Puppet::Pops::Evaluator::DeferredResolver.resolve_and_replace(node.facts, catalog, apply_environment, Puppet[:preprocess_deferred])
+
+        # Translate it to a RAL catalog
+        catalog = catalog.to_ral
+
+        catalog.finalize
+
+        catalog.retrieval_duration = Time.now - starttime
+
+        # We accept either the global option `--write_catalog_summary`
+        # corresponding to the new setting, or the application option
+        # `--write-catalog-summary`. The latter is needed to maintain backwards
+        # compatibility.
+        #
+        # Puppet settings parse global options using PuppetOptionParser, but it
+        # only recognizes underscores, not dashes.
+        # The base application parses app specific options using ruby's builtin
+        # OptionParser. As of ruby 2.4, it will accept either underscores or
+        # dashes, but prefer dashes.
+        #
+        # So if underscores are used, the PuppetOptionParser will parse it and
+        # store that in Puppet[:write_catalog_summary]. If dashes are used,
+        # OptionParser will parse it, and set Puppet[:write_catalog_summary]. In
+        # either case, settings will contain the correct value.
+        if Puppet[:write_catalog_summary]
+          catalog.write_class_file
+          catalog.write_resource_file
+        end
+
+        exit_status = apply_catalog(catalog)
+
+        if not exit_status
+          exit(1)
+        elsif options[:detailed_exitcodes] then
+          exit(exit_status)
+        else
+          exit(0)
+        end
+      rescue => detail
+        Puppet.log_exception(detail)
+        exit(1)
+      end
+    end
+  end
+
+  # Enable all of the most common test options.
+  def setup_test
+    Puppet.settings.handlearg("--no-splay")
+    Puppet.settings.handlearg("--show_diff")
+    options[:verbose] = true
+    options[:detailed_exitcodes] = true
+  end
+
+  def setup
+    setup_test if options[:test]
+
+    exit(Puppet.settings.print_configs ? 0 : 1) if Puppet.settings.print_configs?
+
+    handle_logdest_arg(Puppet[:logdest])
+    Puppet::Util::Log.newdestination(:console) unless options[:setdest]
+
+    Signal.trap(:INT) do
+      $stderr.puts _("Exiting")
+      exit(1)
+    end
+
+    Puppet.settings.use :main, :agent, :ssl
+
+
+    if Puppet[:catalog_cache_terminus]
+      Puppet::Resource::Catalog.indirection.cache_class = Puppet[:catalog_cache_terminus]
+    end
+
+    # we want the last report to be persisted locally
+    Puppet::Transaction::Report.indirection.cache_class = :yaml
+
+    set_log_level
+
+    if Puppet[:profile]
+      @profiler = Puppet::Util::Profiler.add_profiler(Puppet::Util::Profiler::Aggregate.new(Puppet.method(:info), "apply"))
+    end
+  end
+
+  private
+
+  def create_loaders(env)
+    # Ignore both 'cached_puppet_lib' and pcore resource type loaders
+    Puppet::Pops::Loaders.new(env, false, false)
+  end
+
+  def read_catalog(text)
+    facts = get_facts()
+    node = get_node()
+    configured_environment = get_configured_environment(node)
+
+    # TRANSLATORS "puppet apply" is a program command and should not be translated
+    Puppet.override({:current_environment => configured_environment}, _("For puppet apply")) do
+      configure_node_facts(node, facts)
+
+      # NOTE: Does not set rich_data = true automatically (which would ensure always reading catalog with rich data
+      # on (seemingly the right thing to do)), but that would remove the ability to test what happens when a
+      # rich catalog is processed without rich_data being turned on.
+      format = Puppet::Resource::Catalog.default_format
+      begin
+        catalog = Puppet::Resource::Catalog.convert_from(format, text)
+      rescue => detail
+        raise Puppet::Error, _("Could not deserialize catalog from %{format}: %{detail}") % { format: format, detail: detail }, detail.backtrace
+      end
+      # Resolve all deferred values and replace them / mutate the catalog
+      Puppet::Pops::Evaluator::DeferredResolver.resolve_and_replace(node.facts, catalog, configured_environment, Puppet[:preprocess_deferred])
+
+      catalog.to_ral
+    end
+  end
+
+  def apply_catalog(catalog)
+    configurer = Puppet::Configurer.new
+    configurer.run(:catalog => catalog, :pluginsync => false)
+  end
+
+  # Returns facts or nil
+  #
+  def get_facts()
+    facts = nil
+    unless Puppet[:node_name_fact].empty?
+      # Collect our facts.
+      facts = Puppet::Node::Facts.indirection.find(Puppet[:node_name_value])
+      raise _("Could not find facts for %{node}") % { node: Puppet[:node_name_value] } unless facts
+
+      Puppet[:node_name_value] = facts.values[Puppet[:node_name_fact]]
+      facts.name = Puppet[:node_name_value]
+    end
+    facts
+  end
+
+  # Returns the node or raises and error if node not found.
+  #
+  def get_node()
+    node = Puppet::Node.indirection.find(Puppet[:node_name_value])
+    raise _("Could not find node %{node}") % { node: Puppet[:node_name_value] } unless node
+    node
+  end
+
+  # Returns either a manifest (filename) or nil if apply should use content of Puppet[:code]
+  #
+  def get_manifest()
+    manifest = nil
+    # Set our code or file to use.
+    if options[:code] or command_line.args.length == 0
+      Puppet[:code] = options[:code] || STDIN.read
+    else
+      manifest = command_line.args.shift
+      raise _("Could not find file %{manifest}") % { manifest: manifest } unless Puppet::FileSystem.exist?(manifest)
+      Puppet.warning(_("Only one file can be applied per run.  Skipping %{files}") % { files: command_line.args.join(', ') }) if command_line.args.size > 0
+    end
+    manifest
+  end
+
+  # Returns a configured environment, if a manifest is given it overrides what is configured for the environment
+  # specified by the node (or the current_environment found in the Puppet context).
+  # The node's resolved environment is modified  if needed.
+  #
+  def get_configured_environment(node, manifest = nil)
+    configured_environment = node.environment || Puppet.lookup(:current_environment)
+
+    apply_environment = manifest ?
+      configured_environment.override_with(:manifest => manifest) :
+      configured_environment
+
+    # Modify the node descriptor to use the special apply_environment.
+    # It is based on the actual environment from the node, or the locally
+    # configured environment if the node does not specify one.
+    # If a manifest file is passed on the command line, it overrides
+    # the :manifest setting of the apply_environment.
+    node.environment = apply_environment
+    apply_environment
+  end
+
+  # Mixes the facts into the node, and mixes in server facts
+  def configure_node_facts(node, facts)
+    node.merge(facts.values) if facts
+    # Add server facts so $server_facts[environment] exists when doing a puppet apply
+    node.add_server_facts({})
+  end
+end

data/lib/puppet/application/catalog.rb

@@ -0,0 +1,4 @@
+require_relative '../../puppet/application/indirection_base'
+
+class Puppet::Application::Catalog < Puppet::Application::IndirectionBase
+end

data/lib/puppet/application/config.rb

@@ -0,0 +1,5 @@
+require_relative '../../puppet/application/face_base'
+
+class Puppet::Application::Config < Puppet::Application::FaceBase
+  environment_mode :not_required
+end

data/lib/puppet/application/describe.rb

@@ -0,0 +1,253 @@
+require_relative '../../puppet/application'
+
+class Formatter
+
+  def initialize(width)
+    @width = width
+  end
+
+  def wrap(txt, opts)
+    return "" unless txt && !txt.empty?
+    work = (opts[:scrub] ? scrub(txt) : txt)
+    indent = (opts[:indent] ? opts[:indent] : 0)
+    textLen = @width - indent
+    patt = Regexp.new("\\A(.{0,#{textLen}})[ \n]")
+    prefix = " " * indent
+
+    res = []
+
+    while work.length > textLen
+      if work =~ patt
+        res << $1
+        work.slice!(0, $MATCH.length)
+      else
+        res << work.slice!(0, textLen)
+      end
+    end
+    res << work if work.length.nonzero?
+    prefix + res.join("\n#{prefix}")
+  end
+
+  def header(txt, sep = "-")
+    "\n#{txt}\n" + sep * txt.size
+  end
+
+  private
+
+  def scrub(text)
+    # For text with no carriage returns, there's nothing to do.
+    return text if text !~ /\n/
+
+    # If we can match an indentation, then just remove that same level of
+    # indent from every line.
+    if text =~ /^(\s+)/
+      indent = $1
+      return text.gsub(/^#{indent}/,'')
+    else
+      return text
+    end
+  end
+
+end
+
+class TypeDoc
+
+  def initialize
+    @format = Formatter.new(76)
+    @types = {}
+    Puppet::Type.loadall
+    Puppet::Type.eachtype { |type|
+      next if type.name == :component
+      @types[type.name] = type
+    }
+  end
+
+  def list_types
+    puts "These are the types known to puppet:\n"
+    @types.keys.sort_by(&:to_s).each do |name|
+      type = @types[name]
+      s = type.doc.gsub(/\s+/, " ")
+      if s.empty?
+        s = ".. no documentation .."
+      else
+        n = s.index(".") || s.length
+        if n > 45
+          s = s[0, 45] + " ..."
+        else
+          s = s[0, n]
+        end
+      end
+      printf "%-15s - %s\n", name, s
+    end
+  end
+
+  def format_type(name, opts)
+    name = name.to_sym
+    unless @types.has_key?(name)
+      puts "Unknown type #{name}"
+      return
+    end
+    type = @types[name]
+    puts @format.header(name.to_s, "=")
+    puts @format.wrap(type.doc, :indent => 0, :scrub => true) + "\n\n"
+
+    puts @format.header("Parameters")
+    if opts[:parameters]
+      format_attrs(type, [:property, :param])
+    else
+      list_attrs(type, [:property, :param])
+    end
+
+    if opts[:meta]
+      puts @format.header("Meta Parameters")
+      if opts[:parameters]
+        format_attrs(type, [:meta])
+      else
+        list_attrs(type, [:meta])
+      end
+    end
+
+    if type.providers.size > 0
+      puts @format.header("Providers")
+      if opts[:providers]
+        format_providers(type)
+      else
+        list_providers(type)
+      end
+    end
+  end
+
+  # List details about attributes
+  def format_attrs(type, attrs)
+    docs = {}
+    type.allattrs.each do |name|
+      kind = type.attrtype(name)
+      docs[name] = type.attrclass(name).doc if attrs.include?(kind) && name != :provider
+    end
+
+    docs.sort { |a,b|
+      a[0].to_s <=> b[0].to_s
+    }.each { |name, doc|
+      print "\n- **#{name}**"
+      if type.key_attributes.include?(name) and name != :name
+        puts " (*namevar*)"
+      else
+        puts ""
+      end
+      puts @format.wrap(doc, :indent => 4, :scrub => true)
+    }
+  end
+
+  # List the names of attributes
+  def list_attrs(type, attrs)
+    params = []
+    type.allattrs.each do |name|
+      kind = type.attrtype(name)
+      params << name.to_s if attrs.include?(kind) && name != :provider
+    end
+    puts @format.wrap(params.sort.join(", "), :indent => 4)
+  end
+
+  def format_providers(type)
+    type.providers.sort_by(&:to_s).each { |prov|
+      puts "\n- **#{prov}**"
+      puts @format.wrap(type.provider(prov).doc, :indent => 4, :scrub => true)
+    }
+  end
+
+  def list_providers(type)
+    list = type.providers.sort_by(&:to_s).join(", ")
+    puts @format.wrap(list, :indent => 4)
+  end
+
+end
+
+class Puppet::Application::Describe < Puppet::Application
+  banner "puppet describe [options] [type]"
+
+  option("--short", "-s", "Only list parameters without detail") do |arg|
+    options[:parameters] = false
+  end
+
+  option("--providers","-p")
+  option("--list", "-l")
+  option("--meta","-m")
+
+  def summary
+    _("Display help about resource types")
+  end
+
+  def help
+    <<-HELP
+
+puppet-describe(8) -- #{summary}
+========
+
+SYNOPSIS
+--------
+Prints help about Puppet resource types, providers, and metaparameters.
+
+
+USAGE
+-----
+puppet describe [-h|--help] [-s|--short] [-p|--providers] [-l|--list] [-m|--meta]
+
+
+OPTIONS
+-------
+* --help:
+  Print this help text
+
+* --providers:
+  Describe providers in detail for each type
+
+* --list:
+  List all types
+
+* --meta:
+  List all metaparameters
+
+* --short:
+  List only parameters without detail
+
+
+EXAMPLE
+-------
+    $ puppet describe --list
+    $ puppet describe file --providers
+    $ puppet describe user -s -m
+
+
+AUTHOR
+------
+David Lutterkort
+
+
+COPYRIGHT
+---------
+Copyright (c) 2011 Puppet Inc., LLC Licensed under the Apache 2.0 License
+
+    HELP
+  end
+
+  def preinit
+    options[:parameters] = true
+  end
+
+  def main
+    doc = TypeDoc.new
+
+    if options[:list]
+      doc.list_types
+    else
+      options[:types].each { |name| doc.format_type(name, options) }
+    end
+  end
+
+  def setup
+    options[:types] = command_line.args.dup
+    handle_help(nil) unless options[:list] || options[:types].size > 0
+    $stderr.puts "Warning: ignoring types when listing all types" if options[:list] && options[:types].size > 0
+  end
+
+end