Merge branch 'master' of https://github.com/EncoreTechnologies/puppet-patching

Author: msurato

CHANGELOG.md

@@ -4,6 +4,13 @@ All notable changes to this project will be documented in this file.
 
 ## Development
 
+* **BREAKING CHANGE** 
+  Converted from `nodes` to `targets` for all plans and tasks. This is in support of Bolt `2.0`.
+  Any calling plans or CLI will need to use the `targets` parameter to pass in the hosts
+  to be patched. (Feature)
+
+  Contributed by Nick Maludy (@nmaludy)
+
 
 ## Release 0.5.0 (2020-02-20)
 

plans/available_updates.pp

@@ -1,4 +1,4 @@
-# @summary Checks all nodes for available updates reported by their Operating System.
+# @summary Checks all targets for available updates reported by their Operating System.
 #
 # This uses the <code>patching::available_updates</code> task to query each Target's
 # Operating System for available updates. The results from the OS are parsed and formatted
@@ -13,7 +13,7 @@
 #    - Chocolatey: If installed, runs <code>choco outdated</code>.
 #      If not installed, Chocolatey is ignored.
 #
-# @param [TargetSpec] nodes
+# @param [TargetSpec] targets
 #   Set of targets to run against.
 # @param [Enum['none', 'pretty', 'csv']] format
 #   Output format for printing user-friendly information during the plan run.
@@ -31,27 +31,25 @@
 #   In this case, noop mode has no effect.
 #
 # @example CLI - Basic Usage
-#   bolt plan run patching::available_updates --nodes linux_hosts
+#   bolt plan run patching::available_updates --targets linux_hosts
 #
 # @example CLI - Get available update information in CSV format for creating reports
-#   bolt plan run patching::available_updates --nodes linux_hosts format=csv
+#   bolt plan run patching::available_updates --targets linux_hosts format=csv
 #
 # @example Plan - Basic Usage
-#   run_plan('patching::available_updates',
-#            nodes => $linux_hosts)
+#   run_plan('patching::available_updates', $linux_hosts)
 #
 # @example Plan - Get available update information in CSV format for creating reports
-#   run_plan('patching::available_updates',
-#            nodes  => $linux_hosts,
+#   run_plan('patching::available_updates', $linux_hosts,
 #            format => 'csv')
 #
 plan patching::available_updates (
-  TargetSpec $nodes,
+  TargetSpec $targets,
   # TODO JSON
   Enum['none', 'pretty', 'csv'] $format = 'pretty',
   Boolean                       $noop   = false,
 ) {
-  $available_results = run_task('patching::available_updates', $nodes,
+  $available_results = run_task('patching::available_updates', $targets,
                                 _noop => $noop)
   case $format {
     'none': {

plans/check_online.pp

@@ -3,10 +3,10 @@
 # Online checks are done querying for the node's Puppet version using the
 # <code>puppet_agent::version</code> task.
 # This plan is designed to be used ad-hoc as a quick health check of your inventory.
-# It is the intention of this plan to be used as "first pass" when onboarding new nodes
+# It is the intention of this plan to be used as "first pass" when onboarding new targets
 # into a Bolt rotation.
-# One would build their inventory file of all nodes from their trusted data sources.
-# Then take the inventory files and run this plan against them to isolate problem nodes
+# One would build their inventory file of all targets from their trusted data sources.
+# Then take the inventory files and run this plan against them to isolate problem targets
 # and remediate them.
 # Once this plan runs successfuly on your inventory, you know that Bolt can connect
 # and can begin the patching proces.
@@ -24,20 +24,20 @@
 #      The idea here is to give the end-user a easily digestible summary so that action
 #      can be taken to remediate these hosts.
 #
-# @param [TargetSpec] nodes
+# @param [TargetSpec] targets
 #   Set of targets to run against.
 #
 # @example CLI - Basic usage
 #   bolt plan run patching::check_online
 #
 plan patching::check_online (
-  TargetSpec $nodes,
+  TargetSpec $targets,
 ) {
-  $targets = get_targets($nodes)
-  ## This will check all nodes to verify online by checking their Puppet agent version
-  $targets_version = run_task('puppet_agent::version', $targets,
+  $_targets = get_targets($targets)
+  ## This will check all targets to verify online by checking their Puppet agent version
+  $targets_version = run_task('puppet_agent::version', $_targets,
                               _catch_errors => true)
-  # if we're filtering out offline nodes, then only accept the ok_set from the task above
+  # if we're filtering out offline targets, then only accept the ok_set from the task above
   if !$targets_version.error_set.empty() {
     $errors_array = Array($targets_version.error_set)
     $sorted_errors = $errors_array.sort|$a, $b| {
@@ -61,6 +61,6 @@
     fail_plan('Unable to connect to the targets above!')
   }
   else {
-    out::message('All nodes succeeded!')
+    out::message('All targets succeeded!')
   }
 }

plans/check_puppet.pp

@@ -1,66 +1,64 @@
-# @summary Checks each node to see if Puppet is installed, then gather Facts on all nodes.
+# @summary Checks each node to see if Puppet is installed, then gather Facts on all targets.
 #
 # Executes the <code>puppet_agent::version</code> task to check if Puppet is installed
-# on all of the nodes. Once finished, the result is split into two groups:
+# on all of the targets. Once finished, the result is split into two groups:
 #
-#  1. Nodes with puppet
-#  2. Nodes with no puppet
+#  1. Targets with puppet
+#  2. Targets with no puppet
 #
-# The nodes with puppet are queried for facts using the <code>patching::puppet_facts</code> plan.
-# Nodes without puppet are queried for facts using the simpler <code>facts</code> plan.
+# The targets with puppet are queried for facts using the <code>patching::puppet_facts</code> plan.
+# Targets without puppet are queried for facts using the simpler <code>facts</code> plan.
 #
 # This plan is designed to be the first plan executed in a patching workflow.
 # It can be used to stop the patching process if any hosts are offline by setting
-# <code>filter_offline_nodes=false</code> (default). It can also be used
-# to patch any hosts that are currently available and ignoring any offline nodes
-# by setting <code>filter_offline_nodes=true</code>.
+# <code>filter_offline_targets=false</code> (default). It can also be used
+# to patch any hosts that are currently available and ignoring any offline targets
+# by setting <code>filter_offline_targets=true</code>.
 #
-# @param [TargetSpec] nodes
+# @param [TargetSpec] targets
 #   Set of targets to run against.
-# @param [Boolean] filter_offline_nodes
-#   Flag to determine if offline nodes should be filtered out of the list of targets
+# @param [Boolean] filter_offline_targets
+#   Flag to determine if offline targets should be filtered out of the list of targets
 #   returned by this plan. If true, when running the <code>puppet_agent::version</code>
-#   check, any nodes that return an error will be filtered out and ignored.
+#   check, any targets that return an error will be filtered out and ignored.
 #   Those targets will not be returned in any of the data structures in the result of
-#   this plan. If false, then any nodes that are offline will cause this plan to error
+#   this plan. If false, then any targets that are offline will cause this plan to error
 #   immediately when performing the online check. This will result in a halt of the
 #   patching process.
 #
 # @return [Struct[{has_puppet => Array[TargetSpec],
 #                  no_puppet => Array[TargetSpec],
 #                  all => Array[TargetSpec]}]]
 #
-# @example CLI - Basic usage (error if any nodes are offline)
-#   bolt plan run patching::check_puppet --nodes linux_hosts
+# @example CLI - Basic usage (error if any targets are offline)
+#   bolt plan run patching::check_puppet --targets linux_hosts
 #
-# @example CLI - Filter offline nodes (only return online nodes)
-#   bolt plan run patching::check_puppet --nodes linux_hosts filter_offline_nodes=true
+# @example CLI - Filter offline targets (only return online targets)
+#   bolt plan run patching::check_puppet --targets linux_hosts filter_offline_targets=true
 #
-# @example Plan - Basic usage (error if any nodes are offline)
-#   $results = run_plan('patching::check_puppet',
-#                       nodes => $linux_hosts)
+# @example Plan - Basic usage (error if any targets are offline)
+#   $results = run_plan('patching::check_puppet', $linux_hosts)
 #   $targets_has_puppet = $results['has_puppet']
 #   $targets_no_puppet = $results['no_puppet']
 #   $targets_all = $results['all']
 #
-# @example Plan - Filter offline nodes (only return online nodes)
-#   $results = run_plan('patching::check_puppet',
-#                       nodes                => $linux_hosts,
-#                       filter_offline_nodes => true)
+# @example Plan - Filter offline targets (only return online targets)
+#   $results = run_plan('patching::check_puppet', $linux_hosts,
+#                       filter_offline_targets => true)
 #   $targets_online_has_puppet = $results['has_puppet']
 #   $targets_online_no_puppet = $results['no_puppet']
 #   $targets_online = $results['all']
 #
 plan patching::check_puppet (
-  TargetSpec $nodes,
-  Boolean $filter_offline_nodes = false,
+  TargetSpec $targets,
+  Boolean $filter_offline_targets = false,
 ) {
-  $targets = get_targets($nodes)
-  ## This will check all nodes to verify online by checking their Puppet agent version
-  $targets_version = run_task('puppet_agent::version', $targets,
-                              _catch_errors => $filter_offline_nodes)
-  # if we're filtering out offline nodes, then only accept the ok_set from the task above
-  if $filter_offline_nodes {
+  $_targets = get_targets($targets)
+  ## This will check all targets to verify online by checking their Puppet agent version
+  $targets_version = run_task('puppet_agent::version', $_targets,
+                              _catch_errors => $filter_offline_targets)
+  # if we're filtering out offline targets, then only accept the ok_set from the task above
+  if $filter_offline_targets {
     $targets_filtered = $targets_version.ok_set
   }
   else {
@@ -74,13 +72,11 @@
   if !$targets_with_puppet.empty() {
     # run `puppet facts` on targets with Puppet because it returns a more complete
     # set of facts than just running `facter`
-    run_plan('patching::puppet_facts',
-              nodes => $targets_with_puppet)
+    run_plan('patching::puppet_facts', $targets_with_puppet)
   }
   if !$targets_no_puppet.empty() {
     # run `facter` if it's available otherwise get basic facts
-    run_plan('facts',
-              nodes => $targets_no_puppet)
+    run_plan('facts', $targets_no_puppet)
   }
 
   return({

plans/deploy_scripts.pp

@@ -2,7 +2,7 @@
 #
 # TODO support deploying without Puppet on the end node?
 #
-# @param [TargetSpec] nodes
+# @param [TargetSpec] targets
 #   Set of targets to run against.
 #
 # @param [Hash] scripts
@@ -32,7 +32,7 @@
 # @example CLI deploy a pre and post patching script
 #   bolt plan run patching::deploy_scripts scripts='{"pre_patch.sh": {"source": "puppet:///modules/test/patching/pre_patch.sh"}, "post_patch.sh": {"source": "puppet:///modules/test/patching/post_patch.sh"}}'
 plan patching::deploy_scripts(
-  TargetSpec $nodes,
+  TargetSpec $targets,
   Hash $scripts,
   Optional[String] $patching_dir = undef,
   Optional[String] $bin_dir      = undef,
@@ -41,8 +41,8 @@
   Optional[String] $group        = undef,
   Optional[String] $mode         = undef,
 ) {
-  $targets = run_plan('patching::get_targets', nodes => $nodes)
-  return apply($targets) {
+  $_targets = run_plan('patching::get_targets', $targets)
+  return apply($_targets) {
     include patching::params
     class { 'patching':
       scripts      => $scripts,

plans/get_targets.pp

@@ -2,34 +2,34 @@
 #
 # A very common requirement when running individual plans from the commandline is that
 # each plan would need to perform the following steps:
-#  - Convert the TargetSpec from a string into an Array[Target] using <code>get_targets($nodes)</code>
-#  - Check for nodes that are online (calls plan <code>patching::check_puppet</code>
-#  - Gather facts about the nodes
+#  - Convert the TargetSpec from a string into an Array[Target] using <code>get_targets($targets)</code>
+#  - Check for targets that are online (calls plan <code>patching::check_puppet</code>
+#  - Gather facts about the targets
 #
 # This plan combines all of that into one so that it can be reused in all of the other
 # plans within this module. It also adds some smart checking so that, if multiple plans
 # invoke each other, each of which call this plan. The online check and facts gathering
 # only hapens once.
 #
-# @param [TargetSpec] nodes
+# @param [TargetSpec] targets
 #   Set of targets to run against.
 #
 # @return [Array[Target]] Targets converted to an array for use later in the calling plan
 #
 # @example Plan - Basic usage
 #   plan mymodule::myplan (
-#     TargetSpec $nodes
+#     TargetSpec $targets
 #   ) {
-#     $targets = run_plan('patching::get_targets', nodes => $ndoes)
+#     $targets = run_plan('patching::get_targets', $targets)
 #     # do normal stuff with your $targets
 #   }
 plan patching::get_targets (
-  TargetSpec $nodes,
+  TargetSpec $targets,
 ) {
-  $targets = get_targets($nodes)
-  $target_first_facts = facts($targets[0])
+  $_targets = get_targets($targets)
+  $target_first_facts = facts($_targets[0])
   if !$target_first_facts['os'] or !$target_first_facts['os']['family'] {
-    run_plan('patching::check_puppet', nodes => $targets)
+    run_plan('patching::check_puppet', $_targets)
   }
-  return $targets
+  return $_targets
 }