bolt 0.24.0 → 0.25.0

data/vendored/puppet/lib/puppet/face/module/search.rb

@@ -1,98 +0,0 @@
-require 'puppet/util/terminal'
-require 'puppet/forge'
-
-Puppet::Face.define(:module, '1.0.0') do
-  action(:search) do
-    summary _("Search the Puppet Forge for a module.")
-    description <<-EOT
-      Searches a repository for modules whose names, descriptions, or keywords
-      match the provided search term.
-    EOT
-
-    returns _("Array of module metadata hashes")
-
-    examples <<-EOT
-      Search the Puppet Forge for a module:
-
-      $ puppet module search puppetlabs
-      NAME          DESCRIPTION                          AUTHOR             KEYWORDS
-      bacula        This is a generic Apache module      @puppetlabs        backups
-    EOT
-
-    arguments _("<search_term>")
-
-    when_invoked do |term, options|
-      Puppet::ModuleTool.set_option_defaults options
-      Puppet::ModuleTool::Applications::Searcher.new(term, Puppet::Forge.new(options[:module_repository] || Puppet[:module_repository]), options).run
-    end
-
-    when_rendering :console do |results, term, options|
-      if results[:result] == :failure
-        raise results[:error][:multiline]
-      end
-
-      return _("No results found for '%{term}'.") % { term: term } if results[:answers].empty?
-
-      padding = '  '
-      headers = {
-        'full_name' => 'NAME',
-        'desc'      => 'DESCRIPTION',
-        'author'    => 'AUTHOR',
-        'tag_list'  => 'KEYWORDS',
-      }
-
-      min_widths = Hash[ *headers.map { |k,v| [k, v.length] }.flatten ]
-      min_widths['full_name'] = min_widths['author'] = 12
-
-      min_width = min_widths.inject(0) { |sum,pair| sum + pair.last } + (padding.length * (headers.length - 1))
-
-      terminal_width = [Puppet::Util::Terminal.width, min_width].max
-
-      columns = results[:answers].inject(min_widths) do |hash, result|
-        deprecated_buffer = result['deprecated_at'].nil? ? 0 : 11 # ' DEPRECATED'.length
-
-        {
-          'full_name' => [ hash['full_name'], result['full_name'].length + deprecated_buffer ].max,
-          'desc'      => [ hash['desc'],      result['desc'].length               ].max,
-          'author'    => [ hash['author'],    "@#{result['author']}".length       ].max,
-          'tag_list'  => [ hash['tag_list'],  result['tag_list'].join(' ').length ].max,
-        }
-      end
-
-      flex_width = terminal_width - columns['full_name'] - columns['author'] - (padding.length * (headers.length - 1))
-      tag_lists = results[:answers].map { |r| r['tag_list'] }
-
-      while (columns['tag_list'] > flex_width / 3)
-        longest_tag_list = tag_lists.sort_by { |tl| tl.join(' ').length }.last
-        break if [ [], [term] ].include? longest_tag_list
-        longest_tag_list.delete(longest_tag_list.sort_by { |t| t == term ? -1 : t.length }.last)
-        columns['tag_list'] =  tag_lists.map { |tl| tl.join(' ').length }.max
-      end
-
-      columns['tag_list'] = [
-        flex_width / 3,
-        tag_lists.map { |tl| tl.join(' ').length }.max,
-      ].max
-      columns['desc'] = flex_width - columns['tag_list']
-
-      format = %w{full_name desc author tag_list}.map do |k|
-        "%-#{ [ columns[k], min_widths[k] ].max }s"
-      end.join(padding) + "\n"
-
-      highlight = proc do |s|
-        s = s.gsub(term, colorize(:green, term))
-        s = s.gsub(term.gsub('/', '-'), colorize(:green, term.gsub('/', '-'))) if term =~ /\//
-        s = s.gsub(' DEPRECATED', colorize(:red, ' DEPRECATED'))
-        s
-      end
-
-      format % [ headers['full_name'], headers['desc'], headers['author'], headers['tag_list'] ] +
-      results[:answers].map do |match|
-        name, desc, author, keywords = %w{full_name desc author tag_list}.map { |k| match[k] }
-        name += ' DEPRECATED' unless match['deprecated_at'].nil?
-        desc = desc[0...(columns['desc'] - 3)] + '...' if desc.length > columns['desc']
-        highlight[format % [ name.sub('/', '-'), desc, "@#{author}", [keywords].flatten.join(' ') ]]
-      end.join
-    end
-  end
-end

data/vendored/puppet/lib/puppet/face/module/uninstall.rb

@@ -1,89 +0,0 @@
-Puppet::Face.define(:module, '1.0.0') do
-  action(:uninstall) do
-    summary _("Uninstall a puppet module.")
-    description <<-EOT
-      Uninstalls a puppet module from the modulepath (or a specific
-      target directory).
-      Note: Module uninstall uses MD5 checksums, which are prohibited on FIPS enabled systems.
-    EOT
-
-    returns _("Hash of module objects representing uninstalled modules and related errors.")
-
-    examples <<-'EOT'
-      Uninstall a module:
-
-      $ puppet module uninstall puppetlabs-ssh
-      Removed /etc/puppetlabs/code/modules/ssh (v1.0.0)
-
-      Uninstall a module from a specific directory:
-
-      $ puppet module uninstall puppetlabs-ssh --modulepath /opt/puppetlabs/puppet/modules
-      Removed /opt/puppetlabs/puppet/modules/ssh (v1.0.0)
-
-      Uninstall a module from a specific environment:
-
-      $ puppet module uninstall puppetlabs-ssh --environment development
-      Removed /etc/puppetlabs/code/environments/development/modules/ssh (v1.0.0)
-
-      Uninstall a specific version of a module:
-
-      $ puppet module uninstall puppetlabs-ssh --version 2.0.0
-      Removed /etc/puppetlabs/code/modules/ssh (v2.0.0)
-    EOT
-
-    arguments _("<name>")
-
-    option "--force", "-f" do
-      summary _("Force uninstall of an installed module.")
-      description <<-EOT
-        Force the uninstall of an installed module even if there are local
-        changes or the possibility of causing broken dependencies.
-      EOT
-    end
-
-    option "--ignore-changes", "-c" do
-      summary _("Ignore any local changes made. (Implied by --force.)")
-      description <<-EOT
-        Uninstall an installed module even if there are local changes to it.  (Implied by --force.)
-      EOT
-    end
-
-    option "--version=" do
-      summary _("The version of the module to uninstall")
-      description <<-EOT
-        The version of the module to uninstall. When using this option, a module
-        matching the specified version must be installed or else an error is raised.
-      EOT
-    end
-
-    when_invoked do |name, options|
-      name = name.gsub('/', '-')
-
-      Puppet::ModuleTool.set_option_defaults options
-      message = if options[:version]
-                  module_version = colorize(:cyan, options[:version].sub(/^(?=\d)/, 'v'))
-                  _("Preparing to uninstall '%{name}' (%{module_version}) ...") % { name: name, module_version: module_version }
-                else
-                  _("Preparing to uninstall '%{name}' ...") % { name: name }
-                end
-      Puppet.notice message
-      Puppet::ModuleTool::Applications::Uninstaller.run(name, options)
-    end
-
-    when_rendering :console do |return_value|
-      if return_value[:result] == :failure
-        Puppet.err(return_value[:error][:multiline])
-        exit 1
-      else
-        mod = return_value[:affected_modules].first
-        message = if mod.version
-                    module_version = colorize(:cyan, mod.version.to_s.sub(/^(?=\d)/, 'v'))
-                    _("Removed '%{name}' (%{module_version}) from %{path}") % { name: return_value[:module_name], module_version: module_version, path: mod.modulepath }
-                  else
-                    _("Removed '%{name}' from %{path}") % { name: return_value[:module_name], path: mod.modulepath }
-                  end
-        message
-      end
-    end
-  end
-end

data/vendored/puppet/lib/puppet/face/module/upgrade.rb

@@ -1,87 +0,0 @@
-# encoding: UTF-8
-
-Puppet::Face.define(:module, '1.0.0') do
-  action(:upgrade) do
-    summary _("Upgrade a puppet module.")
-    description <<-EOT
-      Upgrades a puppet module.
-      Note: Module upgrade uses MD5 checksums, which are prohibited on FIPS enabled systems.
-    EOT
-
-    returns "Hash"
-
-    examples <<-EOT
-      upgrade an installed module to the latest version
-
-      $ puppet module upgrade puppetlabs-apache
-      /etc/puppetlabs/puppet/modules
-      └── puppetlabs-apache (v1.0.0 -> v2.4.0)
-
-      upgrade an installed module to a specific version
-
-      $ puppet module upgrade puppetlabs-apache --version 2.1.0
-      /etc/puppetlabs/puppet/modules
-      └── puppetlabs-apache (v1.0.0 -> v2.1.0)
-
-      upgrade an installed module for a specific environment
-
-      $ puppet module upgrade puppetlabs-apache --environment test
-      /etc/puppetlabs/code/environments/test/modules
-      └── puppetlabs-apache (v1.0.0 -> v2.4.0)
-    EOT
-
-    arguments _("<name>")
-
-    option "--force", "-f" do
-      summary _("Force upgrade of an installed module. (Implies --ignore-dependencies.)")
-      description <<-EOT
-        Force the upgrade of an installed module even if there are local
-        changes or the possibility of causing broken dependencies.
-        Implies --ignore-dependencies.
-      EOT
-    end
-
-    option "--ignore-dependencies" do
-      summary _("Do not attempt to install dependencies. (Implied by --force.)")
-      description <<-EOT
-        Do not attempt to install dependencies. Implied by --force.
-      EOT
-    end
-
-    option "--ignore-changes", "-c" do
-      summary _("Ignore and overwrite any local changes made. (Implied by --force.)")
-      description <<-EOT
-        Upgrade an installed module even if there are local changes to it.  (Implied by --force.)
-      EOT
-    end
-
-    option "--version=" do
-      summary _("The version of the module to upgrade to.")
-      description <<-EOT
-        The version of the module to upgrade to.
-      EOT
-    end
-
-    when_invoked do |name, options|
-      name = name.gsub('/', '-')
-      Puppet.notice _("Preparing to upgrade '%{name}' ...") % { name: name }
-      Puppet::ModuleTool.set_option_defaults options
-      Puppet::ModuleTool::Applications::Upgrader.new(name, options).run
-    end
-
-    when_rendering :console do |return_value|
-      if return_value[:result] == :noop
-        Puppet.notice return_value[:error][:multiline]
-        exit 0
-      elsif return_value[:result] == :failure
-        Puppet.err(return_value[:error][:multiline])
-        exit 1
-      else
-        tree = Puppet::ModuleTool.build_tree(return_value[:graph], return_value[:base_dir])
-
-        "#{return_value[:base_dir]}\n" +
-        Puppet::ModuleTool.format_tree(tree)
-      end
-    end
-  end
-end

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

@@ -1,43 +0,0 @@
-require 'puppet/indirector/face'
-Puppet::Indirector::Face.define(:node, '0.0.1') do
-  copyright "Puppet Inc.", 2011
-  license   _("Apache 2 license; see COPYING")
-
-  summary _("View and manage node definitions.")
-  description <<-'EOT'
-    This subcommand interacts with node objects, which are used by Puppet to
-    build a catalog. A node object consists of the node's facts, environment,
-    node parameters (exposed in the parser as top-scope variables), and classes.
-  EOT
-
-  deactivate_action(:destroy)
-  deactivate_action(:search)
-  deactivate_action(:save)
-
-  find = get_action(:find)
-  find.summary _("Retrieve a node object.")
-  find.arguments _("<host>")
-  #TRANSLATORS the following are specific names and should not be translated `classes`, `environment`, `expiration`, `name`, `parameters`, Puppet::Node
-  find.returns _(<<-'EOT')
-    A hash containing the node's `classes`, `environment`, `expiration`, `name`,
-    `parameters` (its facts, combined with any ENC-set parameters), and `time`.
-    When used from the Ruby API: a Puppet::Node object.
-
-    RENDERING ISSUES: Rendering as string and json are currently broken;
-    node objects can only be rendered as yaml.
-  EOT
-  find.examples <<-'EOT'
-    Retrieve an "empty" (no classes, no ENC-imposed parameters, and an
-    environment of "production") node:
-
-    $ puppet node find somenode.puppetlabs.lan --terminus plain --render-as yaml
-
-    Retrieve a node using the puppet master's configured ENC:
-
-    $ puppet node find somenode.puppetlabs.lan --terminus exec --run_mode master --render-as yaml
-
-    Retrieve the same node from the puppet master:
-
-    $ puppet node find somenode.puppetlabs.lan --terminus rest --render-as yaml
-  EOT
-end

data/vendored/puppet/lib/puppet/face/node/clean.rb

@@ -1,100 +0,0 @@
-Puppet::Face.define(:node, '0.0.1') do
-  action(:clean) do
-
-    summary _("Clean up signed certs, cached facts, node objects, and reports for a node stored by the puppetmaster")
-    arguments _("<host1> [<host2> ...]")
-    description <<-'EOT'
-      Cleans up the following information a puppet master knows about a node:
-
-      <Signed certificates> - ($vardir/ssl/ca/signed/node.domain.pem)
-
-      <Cached facts> - ($vardir/yaml/facts/node.domain.yaml)
-
-      <Cached node objects> - ($vardir/yaml/node/node.domain.yaml)
-
-      <Reports> - ($vardir/reports/node.domain)
-
-      NOTE: this action now cleans up certs via Puppet Server's CA API. A running server is required for certs to be cleaned.
-    EOT
-
-    when_invoked do |*args|
-      nodes = args[0..-2]
-      options = args.last
-      raise _("At least one node should be passed") if nodes.empty? || nodes == options
-
-      # This seems really bad; run_mode should be set as part of a class
-      # definition, and should not be modifiable beyond that.  This is one of
-      # the only places left in the code that tries to manipulate it. Other
-      # parts of code that handle certificates behave differently if the
-      # run_mode is master. Those other behaviors are needed for cleaning the
-      # certificates correctly.
-      Puppet.settings.preferred_run_mode = "master"
-
-      Puppet::Node::Facts.indirection.terminus_class = :yaml
-      Puppet::Node::Facts.indirection.cache_class = :yaml
-      Puppet::Node.indirection.terminus_class = :yaml
-      Puppet::Node.indirection.cache_class = :yaml
-
-      nodes.each { |node| cleanup(node.downcase) }
-    end
-  end
-
-  def cleanup(node)
-    clean_cert(node)
-    clean_cached_facts(node)
-    clean_cached_node(node)
-    clean_reports(node)
-  end
-
-  class LoggerIO
-    def err(message)
-      Puppet.err(message) unless message =~ /^\s*Error:\s*/
-    end
-
-    def inform(message)
-      Puppet.notice(message)
-    end
-  end
-
-  # clean signed cert for +host+
-  def clean_cert(node)
-    if Puppet.features.puppetserver_ca?
-      require 'puppetserver/ca/action/clean'
-      Puppetserver::Ca::Action::Clean.new(LoggerIO.new).run({ 'certnames' => [node] })
-    else
-      Puppet.info _("Not managing %{node} certs as this host is not a CA") % { node: node }
-    end
-  end
-
-  # clean facts for +host+
-  def clean_cached_facts(node)
-    Puppet::Node::Facts.indirection.destroy(node)
-    Puppet.info _("%{node}'s facts removed") % { node: node }
-  end
-
-  # clean cached node +host+
-  def clean_cached_node(node)
-    Puppet::Node.indirection.destroy(node)
-    Puppet.info _("%{node}'s cached node removed") % { node: node }
-  end
-
-  # clean node reports for +host+
-  def clean_reports(node)
-    Puppet::Transaction::Report.indirection.destroy(node)
-    Puppet.info _("%{node}'s reports removed") % { node: node }
-  end
-
-  def environment
-    @environment ||= Puppet.lookup(:current_environment)
-  end
-
-  def type_is_ensurable(resource)
-    if (type = Puppet::Type.type(resource.restype)) && type.validattr?(:ensure)
-      return true
-    else
-      type = environment.known_resource_types.find_definition(resource.restype)
-      return true if type && type.arguments.keys.include?('ensure')
-    end
-    return false
-  end
-end

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

@@ -1,187 +0,0 @@
-require 'puppet/face'
-require '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|
-      args.pop
-      files = args
-      if files.empty?
-        if not STDIN.tty?
-          Puppet[:code] = STDIN.read
-          validate_manifest
-        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)
-          validate_manifest(file)
-        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
-      nil
-    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 '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 '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 => detail
-        Puppet.log_exception(detail)
-        exit(1)
-      end
-    end
-  end
-end