openvox 8.19.0

data/lib/puppet/face/module/list.rb

@@ -0,0 +1,271 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+Puppet::Face.define(:module, '1.0.0') do
+  action(:list) do
+    summary _("List installed modules")
+    description <<-HEREDOC
+      Lists the installed puppet modules. By default, this action scans the
+      modulepath from puppet.conf's `[main]` block; use the --modulepath
+      option to change which directories are scanned.
+
+      The output of this action includes information from the module's
+      metadata, including version numbers and unmet module dependencies.
+    HEREDOC
+    returns _("hash of paths to module objects")
+
+    option "--tree" do
+      summary _("Whether to show dependencies as a tree view")
+    end
+
+    examples <<-'EOT'
+      List installed modules:
+
+      $ puppet module list
+        /etc/puppetlabs/code/modules
+        ├── bodepd-create_resources (v0.0.1)
+        ├── puppetlabs-bacula (v0.0.2)
+        ├── puppetlabs-mysql (v0.0.1)
+        ├── puppetlabs-sqlite (v0.0.1)
+        └── puppetlabs-stdlib (v2.2.1)
+        /opt/puppetlabs/puppet/modules (no modules installed)
+
+      List installed modules in a tree view:
+
+      $ puppet module list --tree
+        /etc/puppetlabs/code/modules
+        └─┬ puppetlabs-bacula (v0.0.2)
+          ├── puppetlabs-stdlib (v2.2.1)
+          ├─┬ puppetlabs-mysql (v0.0.1)
+          │ └── bodepd-create_resources (v0.0.1)
+          └── puppetlabs-sqlite (v0.0.1)
+        /opt/puppetlabs/puppet/modules (no modules installed)
+
+      List installed modules from a specified environment:
+
+      $ puppet module list --environment production
+        /etc/puppetlabs/code/modules
+        ├── bodepd-create_resources (v0.0.1)
+        ├── puppetlabs-bacula (v0.0.2)
+        ├── puppetlabs-mysql (v0.0.1)
+        ├── puppetlabs-sqlite (v0.0.1)
+        └── puppetlabs-stdlib (v2.2.1)
+        /opt/puppetlabs/puppet/modules (no modules installed)
+
+      List installed modules from a specified modulepath:
+
+      $ puppet module list --modulepath /opt/puppetlabs/puppet/modules
+        /opt/puppetlabs/puppet/modules (no modules installed)
+    EOT
+
+    when_invoked do |options|
+      Puppet::ModuleTool.set_option_defaults(options)
+      environment = options[:environment_instance]
+      modules_by_path = environment.modules_by_path
+
+      {
+        :environment => environment,
+        :modules_by_path => modules_by_path,
+        :unmet_dependencies => unmet_dependencies(environment),
+      }
+    end
+
+    when_rendering :console do |result, options|
+      environment     = result[:environment]
+      modules_by_path = result[:modules_by_path]
+
+      output = ''.dup
+
+      warn_unmet_dependencies(environment)
+
+      environment.modulepath.each do |path|
+        modules = modules_by_path[path]
+        no_mods = modules.empty? ? _(' (no modules installed)') : ''
+        output << "#{path}#{no_mods}\n"
+
+        if options[:tree]
+          # The modules with fewest things depending on them will be the
+          # parent of the tree.  Can't assume to start with 0 dependencies
+          # since dependencies may be cyclical.
+          modules_by_num_requires = modules.sort_by { |m| m.required_by.size }
+          @seen = {}
+          tree = list_build_tree(modules_by_num_requires, [], nil,
+                                 :label_unmet => true, :path => path, :label_invalid => false)
+        else
+          tree = []
+          modules.sort_by { |mod| mod.forge_name or mod.name }.each do |mod|
+            tree << list_build_node(mod, path, :label_unmet => false,
+                                               :path => path, :label_invalid => true)
+          end
+        end
+
+        output << Puppet::ModuleTool.format_tree(tree)
+      end
+
+      output
+    end
+  end
+
+  def unmet_dependencies(environment)
+    error_types = [:non_semantic_version, :version_mismatch, :missing]
+
+    unmet_deps = {}
+    error_types.each do |type|
+      unmet_deps[type] = Hash.new do |hash, key|
+        hash[key] = { :errors => [], :parent => nil }
+      end
+    end
+
+    # Prepare the unmet dependencies for display on the console.
+    environment.modules.sort_by(&:name).each do |mod|
+      unmet_grouped = Hash.new { |h, k| h[k] = [] }
+      unmet_grouped = mod.unmet_dependencies.each_with_object(unmet_grouped) do |dep, acc|
+        acc[dep[:reason]] << dep
+      end
+      unmet_grouped.each do |type, deps|
+        next if deps.empty?
+
+        unmet_grouped[type].sort_by { |dep| dep[:name] }.each do |dep|
+          dep_name           = dep[:name].tr('/', '-')
+          installed_version  = dep[:mod_details][:installed_version]
+          version_constraint = dep[:version_constraint]
+          parent_name        = dep[:parent][:name].tr('/', '-')
+          parent_version     = dep[:parent][:version]
+
+          msg = _("'%{parent_name}' (%{parent_version}) requires '%{dependency_name}' (%{dependency_version})") % { parent_name: parent_name, parent_version: parent_version, dependency_name: dep_name, dependency_version: version_constraint }
+          unmet_deps[type][dep[:name]][:errors] << msg
+          unmet_deps[type][dep[:name]][:parent] = {
+            :name => dep[:parent][:name],
+            :version => parent_version
+          }
+          unmet_deps[type][dep[:name]][:version] = installed_version
+        end
+      end
+    end
+    unmet_deps
+  end
+
+  def warn_unmet_dependencies(environment)
+    @unmet_deps = unmet_dependencies(environment)
+
+    # Display unmet dependencies by category.
+    error_display_order = [:non_semantic_version, :version_mismatch, :missing]
+    error_display_order.each do |type|
+      next if @unmet_deps[type].empty?
+
+      @unmet_deps[type].keys.sort.each do |dep|
+        name    = dep.tr('/', '-')
+        errors  = @unmet_deps[type][dep][:errors]
+        version = @unmet_deps[type][dep][:version]
+
+        msg = case type
+              when :version_mismatch
+                _("Module '%{name}' (v%{version}) fails to meet some dependencies:\n") % { name: name, version: version }
+              when :non_semantic_version
+                _("Non semantic version dependency %{name} (v%{version}):\n") % { name: name, version: version }
+              else
+                _("Missing dependency '%{name}':\n") % { name: name }
+              end
+
+        errors.each { |error_string| msg << "  #{error_string}\n" }
+        Puppet.warning msg.chomp
+      end
+    end
+  end
+
+  # Prepare a list of module objects and their dependencies for print in a
+  # tree view.
+  #
+  # Returns an Array of Hashes
+  #
+  # Example:
+  #
+  #   [
+  #     {
+  #       :text => "puppetlabs-bacula (v0.0.2)",
+  #       :dependencies=> [
+  #         { :text => "puppetlabs-stdlib (v2.2.1)", :dependencies => [] },
+  #         {
+  #           :text => "puppetlabs-mysql (v1.0.0)"
+  #           :dependencies => [
+  #             {
+  #               :text => "bodepd-create_resources (v0.0.1)",
+  #               :dependencies => []
+  #             }
+  #           ]
+  #         },
+  #         { :text => "puppetlabs-sqlite (v0.0.1)", :dependencies => [] },
+  #       ]
+  #     }
+  #   ]
+  #
+  # When the above data structure is passed to Puppet::ModuleTool.build_tree
+  # you end up with something like this:
+  #
+  #   /etc/puppetlabs/code/modules
+  #   └─┬ puppetlabs-bacula (v0.0.2)
+  #     ├── puppetlabs-stdlib (v2.2.1)
+  #     ├─┬ puppetlabs-mysql (v1.0.0)
+  #     │ └── bodepd-create_resources (v0.0.1)
+  #     └── puppetlabs-sqlite (v0.0.1)
+  #
+  def list_build_tree(list, ancestors = [], parent = nil, params = {})
+    list.filter_map do |mod|
+      next if @seen[(mod.forge_name or mod.name)]
+
+      node = list_build_node(mod, parent, params)
+      @seen[(mod.forge_name or mod.name)] = true
+
+      unless ancestors.include?(mod)
+        node[:dependencies] ||= []
+        missing_deps = mod.unmet_dependencies.select do |dep|
+          dep[:reason] == :missing
+        end
+        missing_deps.map do |mis_mod|
+          str = "#{colorize(:bg_red, _('UNMET DEPENDENCY'))} #{mis_mod[:name].tr('/', '-')} "
+          str << "(#{colorize(:cyan, mis_mod[:version_constraint])})"
+          node[:dependencies] << { :text => str }
+        end
+        node[:dependencies] += list_build_tree(mod.dependencies_as_modules,
+                                               ancestors + [mod], mod, params)
+      end
+
+      node
+    end
+  end
+
+  # Prepare a module object for print in a tree view.  Each node in the tree
+  # must be a Hash in the following format:
+  #
+  #    { :text => "puppetlabs-mysql (v1.0.0)" }
+  #
+  # The value of a module's :text is affected by three (3) factors: the format
+  # of the tree, its dependency status, and the location in the modulepath
+  # relative to its parent.
+  #
+  # Returns a Hash
+  #
+  def list_build_node(mod, parent, params)
+    str = ''.dup
+    str << (mod.forge_name ? mod.forge_name.tr('/', '-') : mod.name)
+    str << ' (' + colorize(:cyan, mod.version ? "v#{mod.version}" : '???') + ')'
+
+    unless File.dirname(mod.path) == params[:path]
+      str << " [#{File.dirname(mod.path)}]"
+    end
+
+    if @unmet_deps[:version_mismatch].include?(mod.forge_name)
+      if params[:label_invalid]
+        str << '  ' + colorize(:red, _('invalid'))
+      elsif parent.respond_to?(:forge_name)
+        unmet_parent = @unmet_deps[:version_mismatch][mod.forge_name][:parent]
+        if unmet_parent[:name] == parent.forge_name &&
+           unmet_parent[:version] == "v#{parent.version}"
+          str << '  ' + colorize(:red, _('invalid'))
+        end
+      end
+    end
+
+    { :text => str }
+  end
+end

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+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.tr('/', '-')
+
+      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/lib/puppet/face/module/upgrade.rb

@@ -0,0 +1,89 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+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.tr('/', '-')
+      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|
+      case return_value[:result]
+      when :noop
+        Puppet.notice return_value[:error][:multiline]
+        exit 0
+      when :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/lib/puppet/face/module.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative '../../puppet/face'
+require_relative '../../puppet/module_tool'
+require_relative '../../puppet/util/colors'
+
+Puppet::Face.define(:module, '1.0.0') do
+  extend Puppet::Util::Colors
+
+  copyright "Puppet Inc., Vox Pupuli", 2012
+  license   _("Apache 2 license; see COPYING")
+
+  summary _("Creates, installs and searches for modules on the Puppet Forge.")
+  description <<-EOT
+    This subcommand can find, install, and manage modules from the Puppet Forge,
+    a repository of user-contributed Puppet code. It can also generate empty
+    modules, and prepare locally developed modules for release on the Forge.
+  EOT
+
+  display_global_options "environment", "modulepath"
+end

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+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 server. Those other behaviors are needed for cleaning the
+      # certificates correctly.
+      Puppet.settings.preferred_run_mode = "server"
+
+      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 debug(message)
+      Puppet.debug(message)
+    end
+
+    def warn(message)
+      Puppet.warning(message) unless message =~ /cadir is currently configured to be inside/
+    end
+
+    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?
+      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
+
+    false
+  end
+end

data/lib/puppet/face/node.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative '../../puppet/indirector/face'
+Puppet::Indirector::Face.define(:node, '0.0.1') do
+  copyright "Puppet Inc., Vox Pupuli", 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 OpenVox 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 Server's configured ENC:
+
+    $ puppet node find somenode.puppetlabs.lan --terminus exec --run_mode server --render-as yaml
+
+    Retrieve the same node from the Puppet Server:
+
+    $ puppet node find somenode.puppetlabs.lan --terminus rest --render-as yaml
+  EOT
+end