bolt 0.20.0 → 0.20.2

data/vendored/puppet/lib/puppet/face/facts.rb

@@ -0,0 +1,87 @@
+require 'puppet/indirector/face'
+require 'puppet/node/facts'
+
+Puppet::Indirector::Face.define(:facts, '0.0.1') do
+  copyright "Puppet Inc.", 2011
+  license   _("Apache 2 license; see COPYING")
+
+  summary _("Retrieve and store facts.")
+  description <<-'EOT'
+    This subcommand manages facts, which are collections of normalized system
+    information used by Puppet. It can read facts directly from the local system
+    (with the default `facter` terminus).
+  EOT
+
+  find = get_action(:find)
+  find.summary _("Retrieve a node's facts.")
+  find.arguments _("[<node_certname>]")
+  find.returns <<-'EOT'
+    A hash containing some metadata and (under the "values" key) the set
+    of facts for the requested node. When used from the Ruby API: A
+    Puppet::Node::Facts object.
+
+    RENDERING ISSUES: Facts cannot currently be rendered as a string; use yaml
+    or json.
+  EOT
+  find.notes <<-'EOT'
+    When using the `facter` terminus, the host argument is ignored.
+  EOT
+  find.examples <<-'EOT'
+    Get facts from the local system:
+
+    $ puppet facts find
+  EOT
+  find.default = true
+
+  deactivate_action(:destroy)
+  deactivate_action(:search)
+
+  action(:upload) do
+    summary _("Upload local facts to the puppet master.")
+    description <<-'EOT'
+      Reads facts from the local system using the `facter` terminus, then
+      saves the returned facts using the rest terminus.
+    EOT
+    returns "Nothing."
+    notes <<-'EOT'
+      This action requires that the puppet master's `auth.conf` file
+      allow `PUT` or `save` access to the `/puppet/v3/facts` API endpoint.
+
+      For details on configuring Puppet Server's `auth.conf`, see:
+
+      <https://puppet.com/docs/puppetserver/latest/config_file_auth.html>
+
+      For legacy Rack-based Puppet Masters, see:
+
+      <https://puppet.com/docs/puppet/latest/config_file_auth.html>
+    EOT
+    examples <<-'EOT'
+      Upload facts:
+
+      $ puppet facts upload
+    EOT
+
+    render_as :json
+
+    when_invoked do |options|
+      # Use `agent` sections  settings for certificates, Puppet Server URL,
+      # etc. instead of `user` section settings.
+      Puppet.settings.preferred_run_mode = :agent
+      Puppet::Node::Facts.indirection.terminus_class = :facter
+
+      facts = Puppet::Node::Facts.indirection.find(Puppet[:node_name_value])
+      unless Puppet[:node_name_fact].empty?
+        Puppet[:node_name_value] = facts.values[Puppet[:node_name_fact]]
+        facts.name = Puppet[:node_name_value]
+      end
+
+      Puppet::Node::Facts.indirection.terminus_class = :rest
+      server = Puppet::Node::Facts::Rest.server
+      Puppet.notice(_("Uploading facts for '%{node}' to: '%{server}'") % {
+                    node: Puppet[:node_name_value],
+                    server: server})
+
+      Puppet::Node::Facts.indirection.save(facts)
+    end
+  end
+end

data/vendored/puppet/lib/puppet/face/generate.rb

@@ -0,0 +1,64 @@
+require 'puppet/face'
+require 'puppet/generate/type'
+
+# Create the Generate face
+Puppet::Face.define(:generate, '0.1.0') do
+  copyright 'Puppet Inc.', 2016
+  license   _('Apache 2 license; see COPYING')
+
+  summary _('Generates Puppet code from Ruby definitions.')
+
+  action(:types) do
+    summary _('Generates Puppet code for custom types')
+
+    description <<-'EOT'
+      Generates definitions for custom resource types using Puppet code.
+
+      Types defined in Puppet code can be used to isolate custom type definitions
+      between different environments.
+    EOT
+
+    examples <<-'EOT'
+      Generate Puppet type definitions for all custom resource types in the current environment:
+
+          $ puppet generate types
+
+      Generate Puppet type definitions for all custom resource types in the specified environment:
+
+          $ puppet generate types --environment development
+    EOT
+
+    option '--format ' + _('<format>') do
+      summary _('The generation output format to use. Supported formats: pcore.')
+      default_to { 'pcore' }
+
+      before_action do |_, _, options|
+        raise ArgumentError, _("'%{format}' is not a supported format for type generation.") % { format: options[:format] } unless ['pcore'].include?(options[:format])
+      end
+    end
+
+    option '--force' do
+      summary _('Forces the generation of output files (skips up-to-date checks).')
+      default_to { false }
+    end
+
+    when_invoked do |options|
+      generator = Puppet::Generate::Type
+      inputs = generator.find_inputs(options[:format].to_sym)
+      environment = Puppet.lookup(:current_environment)
+
+      # get the common output directory (in <envroot>/.resource_types) - create it if it does not exists
+      # error if it exists and is not a directory
+      #
+      path_to_env = environment.configuration.path_to_env
+      outputdir = File.join(path_to_env, '.resource_types')
+      if Puppet::FileSystem.exist?(outputdir) && !Puppet::FileSystem.directory?(outputdir)
+        raise ArgumentError, _("The output directory '%{outputdir}' exists and is not a directory") % { outputdir: outputdir }
+      end
+      Puppet::FileSystem::mkpath(outputdir)
+
+      generator.generate(inputs, outputdir, options[:force])
+      nil
+    end
+  end
+end

data/vendored/puppet/lib/puppet/face/help.rb

@@ -0,0 +1,201 @@
+require 'puppet/face'
+require 'puppet/application/face_base'
+require 'puppet/util/constant_inflector'
+require 'pathname'
+require 'erb'
+
+Puppet::Face.define(:help, '0.0.1') do
+  copyright "Puppet Inc.", 2011
+  license   _("Apache 2 license; see COPYING")
+
+  summary _("Display Puppet help.")
+
+  action(:help) do
+    summary _("Display help about Puppet subcommands and their actions.")
+    arguments _("[<subcommand>] [<action>]")
+    returns _("Short help text for the specified subcommand or action.")
+    examples _(<<-'EOT')
+      Get help for an action:
+
+      $ puppet help
+    EOT
+
+    option "--version " + _("VERSION") do
+      summary _("The version of the subcommand for which to show help.")
+    end
+
+    default
+    when_invoked do |*args|
+      options = args.pop
+
+      if default_case?(args) || help_for_help?(args)
+        return erb('global.erb').result(binding)
+      end
+
+      if args.length > 2
+        #TRANSLATORS 'puppet help' is a command line and should not be translated
+        raise ArgumentError, _("The 'puppet help' command takes two (optional) arguments: a subcommand and an action")
+      end
+
+      version = :current
+      if options.has_key? :version
+        if options[:version].to_s !~ /^current$/i
+          version = options[:version]
+        else
+          if args.length == 0
+            #TRANSLATORS '--version' is a command line option and should not be translated
+            raise ArgumentError, _("Supplying a '--version' only makes sense when a Faces subcommand is given")
+          end
+        end
+      end
+
+      facename, actionname = args
+      if legacy_applications.include? facename
+        if actionname
+          raise ArgumentError, _("The legacy subcommand '%{sub_command}' does not support supplying an action") % { sub_command: facename }
+        end
+        return render_application_help(facename)
+      else
+        return render_face_help(facename, actionname, version)
+      end
+    end
+  end
+
+  def default_case?(args)
+    args.empty?
+  end
+
+  def help_for_help?(args)
+    args.length == 1 && args.first == 'help'
+  end
+
+  def render_application_help(applicationname)
+    return Puppet::Application[applicationname].help
+  rescue StandardError, LoadError => detail
+    message = []
+    message << _('Could not load help for the application %{application_name}.') % { application_name: applicationname }
+    message << _('Please check the error logs for more information.')
+    message << ''
+    message << _('Detail: "%{detail}"') % { detail: detail.message }
+    fail ArgumentError, message.join("\n"), detail.backtrace
+  end
+
+  def render_face_help(facename, actionname, version)
+    face, action = load_face_help(facename, actionname, version)
+    return template_for(face, action).result(binding)
+  rescue StandardError, LoadError => detail
+    message = []
+    message << _('Could not load help for the face %{face_name}.') % { face_name: facename }
+    message << _('Please check the error logs for more information.')
+    message << ''
+    message << _('Detail: "%{detail}"') % { detail: detail.message }
+    fail ArgumentError, message.join("\n"), detail.backtrace
+  end
+
+  def load_face_help(facename, actionname, version)
+    face = Puppet::Face[facename.to_sym, version]
+    if actionname
+      action = face.get_action(actionname.to_sym)
+      if ! action
+        fail ArgumentError, _("Unable to load action %{actionname} from %{face}") % { actionname: actionname, face: face }
+      end
+    end
+
+    [face, action]
+  end
+
+  def template_for(face, action)
+    if action.nil?
+      erb('face.erb')
+    else
+      erb('action.erb')
+    end
+  end
+
+  def erb(name)
+    template = (Pathname(__FILE__).dirname + "help" + name)
+    erb = ERB.new(template.read, nil, '-')
+    erb.filename = template.to_s
+    return erb
+  end
+
+  # Return a list of applications that are not simply just stubs for Faces.
+  def legacy_applications
+    Puppet::Application.available_application_names.reject do |appname|
+      (is_face_app?(appname)) or (exclude_from_docs?(appname))
+    end.sort
+  end
+
+  # Return a list of all applications (both legacy and Face applications), along with a summary
+  #  of their functionality.
+  # @return [Array] An Array of Arrays.  The outer array contains one entry per application; each
+  #  element in the outer array is a pair whose first element is a String containing the application
+  #  name, and whose second element is a String containing the summary for that application.
+  def all_application_summaries()
+    Puppet::Application.available_application_names.sort.inject([]) do |result, appname|
+      next result if exclude_from_docs?(appname)
+
+      if (is_face_app?(appname))
+        begin
+          face = Puppet::Face[appname, :current]
+          # Add deprecation message to summary if the face is deprecated
+          summary = face.deprecated? ? face.summary + ' ' + _("(Deprecated)") : face.summary
+          result << [appname, summary]
+        rescue StandardError, LoadError
+          error_message = _("!%{sub_command}! Subcommand unavailable due to error.") % { sub_command: appname }
+          error_message += ' ' + _("Check error logs.")
+          result << [ error_message ]
+        end
+      else
+        begin
+          summary = Puppet::Application[appname].summary
+          if summary.empty?
+            summary = horribly_extract_summary_from(appname)
+          end
+          result << [appname, summary]
+        rescue StandardError, LoadError
+          error_message = _("!%{sub_command}! Subcommand unavailable due to error.") % { sub_command: appname }
+          error_message += ' ' + _("Check error logs.")
+          result << [ error_message ]
+        end
+      end
+    end
+  end
+
+  def horribly_extract_summary_from(appname)
+    help = Puppet::Application[appname].help.split("\n")
+    # Now we find the line with our summary, extract it, and return it.  This
+    # depends on the implementation coincidence of how our pages are
+    # formatted.  If we can't match the pattern we expect we return the empty
+    # string to ensure we don't blow up in the summary. --daniel 2011-04-11
+    while line = help.shift do
+      if md = /^puppet-#{appname}\([^\)]+\) -- (.*)$/.match(line)
+        return md[1]
+      end
+    end
+    return ''
+  end
+  # This should absolutely be a private method, but for some reason it appears
+  #  that you can't use the 'private' keyword inside of a Face definition.
+  #  See #14205.
+  #private :horribly_extract_summary_from
+
+  def exclude_from_docs?(appname)
+    %w{face_base indirection_base}.include? appname
+  end
+  # This should absolutely be a private method, but for some reason it appears
+  #  that you can't use the 'private' keyword inside of a Face definition.
+  #  See #14205.
+  #private :exclude_from_docs?
+
+  def is_face_app?(appname)
+    clazz = Puppet::Application.find(appname)
+
+    clazz.ancestors.include?(Puppet::Application::FaceBase)
+  end
+  # This should probably be a private method, but for some reason it appears
+  #  that you can't use the 'private' keyword inside of a Face definition.
+  #  See #14205.
+  #private :is_face_app?
+
+end

data/vendored/puppet/lib/puppet/face/key.rb

@@ -0,0 +1,16 @@
+require 'puppet/indirector/face'
+
+Puppet::Indirector::Face.define(:key, '0.0.1') do
+  copyright "Puppet Inc.", 2011
+  license   _("Apache 2 license; see COPYING")
+
+  summary _("Create, save, and remove certificate keys.")
+  description <<-'EOT'
+    This subcommand manages certificate private keys. Keys are created
+    automatically by puppet agent and when certificate requests are generated
+    with 'puppet certificate generate'; it should not be necessary to use this
+    subcommand directly.
+  EOT
+
+  deprecate
+end

data/vendored/puppet/lib/puppet/face/man.rb

@@ -0,0 +1,145 @@
+require 'puppet/face'
+require 'puppet/util'
+require 'pathname'
+require 'erb'
+
+Puppet::Face.define(:man, '0.0.1') do
+  copyright "Puppet Inc.", 2011
+  license   _("Apache 2 license; see COPYING")
+
+  summary _("Display Puppet manual pages.")
+
+  description <<-EOT
+    Please use the command 'puppet help <subcommand>' or the system manpage system
+    'man puppet-<subcommand>' to display information about Puppet subcommands. The
+    deprecated man subcommand displays manual pages for all Puppet subcommands. If
+    the `ronn` gem (<https://github.com/rtomayko/ronn/>) is installed on your
+    system, puppet man will display fully-formatted man pages. If `ronn` is not
+    available, puppet man will display the raw (but human-readable) source text
+    in a pager.
+  EOT
+
+  notes <<-EOT
+    The pager used for display will be the first found of `$MANPAGER`, `$PAGER`,
+    `less`, `most`, or `more`.
+  EOT
+
+  action(:man) do
+    summary _("Display the manual page for a Puppet subcommand.")
+    arguments _("<subcommand>")
+    #TRANSLATORS '--render-as s' is a command line option and should not be translated
+    returns _(<<-'EOT')
+      The man data, in Markdown format, suitable for consumption by Ronn.
+
+      RENDERING ISSUES: To skip fancy formatting and output the raw Markdown
+      text (e.g. for use in a pipeline), call this action with '--render-as s'.
+    EOT
+    examples <<-'EOT'
+      View the installed manual page for the subcommand 'config':
+
+      $ man puppet-config
+
+      (Deprecated) View the manual page for the subcommand 'config':
+
+      $ puppet man config
+    EOT
+
+    default
+    when_invoked do |*args|
+      # 'args' is an array of the subcommand and arguments from the command line and an options hash
+      # [<arg1>, ..., {options}]
+      _options = args.pop
+
+      unless valid_command_line?(args)
+        print_man_help
+        #TRANSLATORS 'puppet man' is a specific command line and should not be translated
+        raise ArgumentError, _("The 'puppet man' command takes a single subcommand to review the subcommand's manpage")
+      end
+
+      manpage = args.first
+      if default_case?(manpage)
+        print_man_help
+        return nil
+      end
+
+      if legacy_applications.include?(manpage)
+        return Puppet::Application[manpage].help
+      end
+
+      # set 'face' as it's used in the erb processing.
+      face = Puppet::Face[manpage.to_sym, :current]
+      _face = face # suppress the unused variable warning
+
+      file = (Pathname(__FILE__).dirname + "help" + 'man.erb')
+      erb = ERB.new(file.read, nil, '-')
+      erb.filename = file.to_s
+
+      # Run the ERB template in our current binding, including all the local
+      # variables we established just above. --daniel 2011-04-11
+      return erb.result(binding)
+    end
+
+    when_rendering :console do |text|
+      # OK, if we have Ronn on the path we can delegate to it and override the
+      # normal output process.  Otherwise delegate to a pager on the raw text,
+      # otherwise we finally just delegate to our parent.  Oh, well.
+
+      # These are the same options for less that git normally uses.
+      # -R : Pass through color control codes (allows display of colors)
+      # -X : Don't init/deinit terminal (leave display on screen on exit)
+      # -F : automatically exit if display fits entirely on one screen
+      # -S : don't wrap long lines
+      ENV['LESS'] ||= 'FRSX'
+
+      ronn  = Puppet::Util.which('ronn')
+      pager = [ENV['MANPAGER'], ENV['PAGER'], 'less', 'most', 'more'].
+        detect {|x| x and x.length > 0 and Puppet::Util.which(x) }
+
+      if ronn
+        # ronn is a stupid about pager selection, we can be smarter. :)
+        ENV['PAGER'] = pager if pager
+
+        args  = "--man --manual='Puppet Manual' --organization='Puppet Inc., LLC'"
+        # manual pages could contain UTF-8 text
+        IO.popen("#{ronn} #{args}", 'w:UTF-8') do |fh| fh.write text end
+
+        ''                      # suppress local output, neh?
+      elsif pager
+        # manual pages could contain UTF-8 text
+        IO.popen(pager, 'w:UTF-8') do |fh| fh.write text end
+        ''
+      else
+        text
+      end
+    end
+  end
+
+  def valid_command_line?(args)
+    # not too many arguments
+    # This allows the command line case of "puppet man man man" to not throw an error because face_based eats
+    # one of the "man"'s, which means this command line ends up looking like this in the code: 'manface.man("man")'
+    # However when we generate manpages, we do the same call. So we have to allow it and generate the real manpage.
+    args.length <= 1
+  end
+
+  # by default, if you ask for the man manpage "puppet man man" face_base removes the "man" from the args that we
+  # are passed, so we get nil instead
+  def default_case?(manpage)
+    manpage.nil?
+  end
+
+  def print_man_help
+    puts Puppet::Face[:help, :current].help(:man)
+  end
+
+  def legacy_applications
+    # The list of applications, less those that are duplicated as a face.
+    Puppet::Application.available_application_names.reject do |appname|
+      Puppet::Face.face? appname.to_sym, :current or
+        # ...this is a nasty way to exclude non-applications. :(
+        %w{face_base indirection_base}.include? appname
+    end
+  end
+
+  deprecate
+end