moose-inventory 2.0 → 2.1.1

data/lib/moose_inventory/cli/group_rmchild.rb

@@ -19,107 +19,51 @@ module Moose
                desc: 'Delete child groups that become orphaned'
         desc 'rmchild PARENTGROUP CHILDGROUP_1 [CHILDGROUP_2 ... ]',
              'Dissociate one or more child-groups CHILDGROUP_n from PARENTGROUP'
+        option :dry_run, type: :boolean
+        option :yes, type: :boolean, desc: 'Confirm destructive dissociation without prompting'
+        option :plan_format, type: :string, desc: 'Emit dry-run plan events as yaml|json|pjson'
         def rmchild(*argv)
           abort_if_missing_args(argv, 2, '2 or more')
+          validate_machine_plan_request!
 
           pname = argv[0].downcase
           cnames = normalize_names(argv.slice(1, argv.length - 1))
 
           abort_if_automatic_group([pname] + cnames)
+          confirm_destructive_action!("group rmchild #{pname} #{cnames.join(',')}")
 
           result = remove_children_from_group(pname, cnames)
+          return if machine_plan_output_rendered?(result, command: 'group rmchild')
 
-          if result.warning_count.zero?
-            puts 'Succeeded.'
-          else
-            puts 'Succeeded, with warnings.'
-          end
+          record_audit({ command: 'group rmchild', action: 'dissociate_child', entity_type: 'group',
+                         entity_names: pname }, result: result, dry_run: options[:dry_run])
+          print_warning_summary(result)
         end
 
         private
 
         def remove_children_from_group(parent_name, child_names)
-          context = Moose::Inventory::InventoryContext.new(db: db)
-          operation = Moose::Inventory::Operations::GroupChildRelations.new(context: context)
-
-          begin
-            db.transaction do
-              puts "Dissociate parent group '#{parent_name}' from child group(s) '#{child_names.join(',')}':"
-              parent_group = fetch_existing_group_for_rmchild(context, parent_name)
-              result = operation.remove_children(
-                parent_group: parent_group,
-                parent_name: parent_name,
-                child_names: child_names,
-                delete_orphans: options[:delete_orphans]
-              )
-              render_rmchild_events(result.events)
-              fmt.puts 2, '- all OK'
-              return result
-            end
-          rescue db.exceptions[:moose] => e
-            abort("ERROR: #{e}")
+          operation = build_operation(Moose::Inventory::Operations::GroupChildRelations)
+          run_group_relation_transaction(
+            heading: "Dissociate parent group '#{parent_name}' from child group(s) '#{child_names.join(',')}':",
+            on_error: method(:exception_to_s)
+          ) do
+            parent_group = fetch_existing_group_or_abort(parent_name)
+            result = operation.remove_children(
+              parent_group: parent_group,
+              parent_name: parent_name,
+              child_names: child_names,
+              delete_orphans: options[:delete_orphans],
+              dry_run: options[:dry_run]
+            )
+            render_rmchild_events(result.events) unless machine_plan_output_requested?
+            result
           end
         end
 
-        def fetch_existing_group_for_rmchild(context, name)
-          fmt.puts 2, "- retrieve group '#{name}'..."
-          group = context.find_group(name)
-          abort("ERROR: The group '#{name}' does not exist.") if group.nil?
-
-          fmt.puts 4, '- OK'
-          group
-        end
-
         def render_rmchild_events(events)
-          events.each { |event| render_rmchild_event(event) }
-        end
-
-        def render_rmchild_event(event)
-          payload = event.payload
-
-          return render_rmchild_warning(payload) if event.type == :child_association_missing
-          return render_rmchild_missing(payload) if event.type == :missing_skipping
-          return render_rmchild_progress(event.type, payload) if rmchild_progress_event?(event.type)
-
-          render_rmchild_status(event.type, payload)
-        end
-
-        def rmchild_progress_event?(type)
-          %i[
-            removing_child_association
-            recursively_delete_orphaned_group
-            removing_recursive_child_association
-          ].include?(type)
-        end
-
-        def render_rmchild_progress(type, payload)
-          case type
-          when :removing_child_association
-            fmt.puts 2, "- remove association {group:#{payload[:parent]} <-> group:#{payload[:child]}}..."
-          when :recursively_delete_orphaned_group
-            fmt.puts 2, "- Recursively delete orphaned group '#{payload[:name]}'..."
-          when :removing_recursive_child_association
-            fmt.puts 4, "- Remove association {group:#{payload[:parent]} <-> group:#{payload[:child]}}..."
-          end
-        end
-
-        def render_rmchild_status(type, payload)
-          case type
-          when :adding_automatic_group_to_host
-            fmt.puts payload[:indent], "- Adding automatic association {group:ungrouped <-> host:#{payload[:host]}}..."
-          when :destroying_group
-            fmt.puts payload[:indent], "- Destroy group '#{payload[:name]}'..."
-          when :ok
-            fmt.puts payload[:indent], '- OK'
-          end
-        end
-
-        def render_rmchild_warning(payload)
-          fmt.warn "Association {group:#{payload[:parent]} <-> group:#{payload[:child]}} does not exist, skipping.\n"
-        end
-
-        def render_rmchild_missing(payload)
-          fmt.puts payload[:indent], "- doesn't exist, skipping."
+          emitter = rmchild_emitter
+          events.each { |event| emitter.call(event) }
         end
       end
     end

data/lib/moose_inventory/cli/group_rmhost.rb

@@ -14,78 +14,43 @@ module Moose
         #==========================
         desc 'rmhost GROUPNAME HOSTNAME_1 [HOSTNAME_2 ...]',
              'Dissociate the hosts HOSTNAME_n from the group NAME'
+        option :dry_run, type: :boolean
+        option :yes, type: :boolean, desc: 'Confirm destructive dissociation without prompting'
+        option :plan_format, type: :string, desc: 'Emit dry-run plan events as yaml|json|pjson'
         def rmhost(*args)
           abort_if_missing_args(args, 2, '2 or more')
+          validate_machine_plan_request!
 
           name = args[0].downcase
           hosts = normalize_names(args.slice(1, args.length - 1))
 
           abort_if_automatic_group([name])
+          confirm_destructive_action!("group rmhost #{name} #{hosts.join(',')}")
 
           result = remove_hosts_from_group(name, hosts)
+          return if machine_plan_output_rendered?(result, command: 'group rmhost')
 
-          if result.warning_count.zero?
-            puts 'Succeeded.'
-          else
-            puts 'Succeeded, with warnings.'
-          end
+          record_audit({ command: 'group rmhost', action: 'dissociate', entity_type: 'group',
+                         entity_names: name }, result: result, dry_run: options[:dry_run])
+          print_warning_summary(result)
         end
 
         private
 
         def remove_hosts_from_group(name, hosts)
-          context = Moose::Inventory::InventoryContext.new(db: db)
-          operation = Moose::Inventory::Operations::RemoveAssociations.new(context: context)
-
-          begin
-            db.transaction do
-              puts "Dissociate group '#{name}' from host(s) '#{hosts.join(',')}':"
-              group = fetch_existing_group_for_rmhost(context, name)
-              result = operation.group_from_hosts(group: group, group_name: name, host_names: hosts)
-              render_group_rmhost_events(result.events)
-              fmt.puts 2, '- all OK'
-              return result
-            end
-          rescue db.exceptions[:moose] => e
-            abort("ERROR: #{e.message}")
+          operation = build_operation(Moose::Inventory::Operations::RemoveAssociations)
+          run_group_relation_transaction(heading: "Dissociate group '#{name}' from host(s) '#{hosts.join(',')}':") do
+            group = fetch_existing_group_or_abort(name)
+            result = operation.group_from_hosts(group: group, group_name: name, host_names: hosts,
+                                                dry_run: options[:dry_run])
+            render_group_rmhost_events(result.events) unless machine_plan_output_requested?
+            result
           end
         end
 
-        def fetch_existing_group_for_rmhost(context, name)
-          fmt.puts 2, "- retrieve group '#{name}'..."
-          group = context.find_group(name)
-          abort("ERROR: The group '#{name}' does not exist.") if group.nil?
-
-          fmt.puts 4, '- OK'
-          group
-        end
-
         def render_group_rmhost_events(events)
-          events.each { |event| render_group_rmhost_event(event) }
-        end
-
-        def render_group_rmhost_event(event)
-          payload = event.payload
-
-          return render_group_rmhost_warning(payload) if event.type == :group_host_association_missing
-          return render_group_rmhost_missing(payload) if event.type == :missing_skipping
-
-          case event.type
-          when :removing_group_host_association
-            fmt.puts 2, "- remove association {group:#{payload[:group]} <-> host:#{payload[:host]}}..."
-          when :adding_automatic_group
-            fmt.puts 2, "- add automatic association {group:ungrouped <-> host:#{payload[:host]}}..."
-          when :ok
-            fmt.puts payload[:indent], '- OK'
-          end
-        end
-
-        def render_group_rmhost_warning(payload)
-          fmt.warn "Association {group:#{payload[:group]} <-> host:#{payload[:host]}} doesn't exist, skipping.\n"
-        end
-
-        def render_group_rmhost_missing(payload)
-          fmt.puts payload[:indent], "- doesn't exist, skipping."
+          emitter = host_group_association_removal_emitter(perspective: :group)
+          events.each { |event| emitter.call(event) }
         end
       end
     end

data/lib/moose_inventory/cli/group_rmvar.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require 'thor'
-require_relative './formatter.rb'
+require_relative '../inventory_context'
+require_relative '../operations/remove_variables'
 
 module Moose
   module Inventory
@@ -10,54 +13,40 @@ module Moose
         #==========================
         desc 'rmvar NAME VARNAME',
              'Remove a variable VARNAME from the group NAME'
+        option :dry_run, type: :boolean
+        option :yes, type: :boolean, desc: 'Confirm destructive removal without prompting'
+        option :plan_format, type: :string, desc: 'Emit dry-run plan events as yaml|json|pjson'
         def rmvar(*args)
-          if args.length < 2
-            abort('ERROR: Wrong number of arguments, ' \
-                  "#{args.length} for 2 or more.")
-          end
-
-          # Convenience
-          db  = Moose::Inventory::DB
-          fmt = Moose::Inventory::Cli::Formatter
+          abort_if_missing_args(args, 2, '2 or more')
+          validate_machine_plan_request!
 
-          # Arguments
           name = args[0].downcase
           vars = args.slice(1, args.length - 1).uniq
+          confirm_destructive_action!("group rmvar #{name} #{vars.join(',')}")
+          operation = build_operation(Moose::Inventory::Operations::RemoveVariables,
+                                      entity_type: :group,
+                                      emitter: machine_plan_emitter(group_rmvar_emitter(name, vars)))
 
-          # Transaction
-          db.transaction do # Transaction start
-            puts "Remove variable(s) '#{vars.join(',')}' from group '#{name}':"
+          result = db.transaction do
+            operation.call(name: name, vars: vars, dry_run: options[:dry_run])
+          end
+
+          return if machine_plan_output_rendered?(result, command: 'group rmvar')
 
-            fmt.puts 2, "- retrieve group '#{name}'..."
-            group = db.models[:group].find(name: name)
-            if group.nil?
-              fail db.exceptions[:moose],
-                   "The group '#{name}' does not exist."
-            end
-            fmt.puts 4, '- OK'
+          record_audit({ command: 'group rmvar', action: 'remove_variable', entity_type: 'group',
+                         entity_names: name }, result: result, dry_run: options[:dry_run])
+          print_success_summary
+        end
 
-            groupvars_ds = group.groupvars_dataset
-            vars.each do |v|
-              fmt.puts 2, "- remove variable '#{v}'..."
-              vararray = v.split('=')
-              if v.start_with?('=') || v.scan('=').count > 1
-                fail db.exceptions[:moose],
-                     "Incorrect format in {#{v}}. " \
-                     'Expected \'key\' or \'key=value\'.'
-              end
+        private
 
-              # Check against existing associations
-              groupvar = groupvars_ds[name: vararray[0]]
-              unless groupvar.nil?
-                # remove the association
-                group.remove_groupvar(groupvar)
-                groupvar.destroy
-              end
-              fmt.puts 4, '- OK'
-            end
-            fmt.puts 2, '- all OK'
-          end # Transaction end
-          puts 'Succeeded.'
+        def group_rmvar_emitter(name, vars)
+          variable_operation_emitter(
+            action: :remove,
+            entity_label: 'group',
+            entity_name: name,
+            variables_label: vars.join(',')
+          )
         end
       end
     end

data/lib/moose_inventory/cli/group_tags.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Moose
+  module Inventory
+    module Cli
+      class Group
+        desc 'addtag GROUP TAG_1 [TAG_2 ...]', 'Add metadata tags to a group'
+        def addtag(*args)
+          abort_if_missing_args(args, 2, '2 or more')
+
+          add_tags('group', args[0].downcase, args.slice(1, args.length - 1))
+        end
+
+        desc 'rmtag GROUP TAG_1 [TAG_2 ...]', 'Remove metadata tags from a group'
+        option :yes, type: :boolean, desc: 'Confirm destructive tag removal without prompting'
+        def rmtag(*args)
+          abort_if_missing_args(args, 2, '2 or more')
+          confirm_destructive_action!("group rmtag #{args[0].downcase} #{args.slice(1, args.length - 1).join(',')}")
+
+          remove_tags('group', args[0].downcase, args.slice(1, args.length - 1))
+        end
+
+        desc 'listtags GROUP', 'List metadata tags for a group'
+        option :format, type: :string, desc: 'Emit tags as yaml|json|pjson'
+        def listtags(*args)
+          abort_if_missing_args(args, 1, '1')
+
+          list_tags('group', args[0].downcase)
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/cli/helpers.rb

@@ -1,11 +1,31 @@
 # frozen_string_literal: true
 
+require_relative '../inventory_context'
+require_relative 'audit_recording'
+require_relative 'association_rendering'
+require_relative 'child_relation_rendering'
+require_relative 'factory'
+require_relative 'listvars_support'
+require_relative 'plan_rendering'
+require_relative 'relation_transaction_support'
+require_relative 'tag_support'
+require_relative 'variable_rendering'
+
 module Moose
   module Inventory
     module Cli
       ##
       # Shared helpers for Thor command classes.
       module Helpers
+        include Moose::Inventory::Cli::AssociationRendering
+        include Moose::Inventory::Cli::AuditRecording
+        include Moose::Inventory::Cli::ChildRelationRendering
+        include Moose::Inventory::Cli::ListvarsSupport
+        include Moose::Inventory::Cli::PlanRendering
+        include Moose::Inventory::Cli::RelationTransactionSupport
+        include Moose::Inventory::Cli::TagSupport
+        include Moose::Inventory::Cli::VariableRendering
+
         AUTOMATIC_GROUP = 'ungrouped'
 
         private
@@ -14,10 +34,38 @@ module Moose
           Moose::Inventory::DB
         end
 
+        def inventory_context
+          @inventory_context ||= Moose::Inventory::InventoryContext.new(db: db)
+        end
+
+        def cli_factory
+          @cli_factory ||= Moose::Inventory::Cli::Factory.new(context: inventory_context)
+        end
+
+        def build_operation(operation_class, **)
+          cli_factory.operation(operation_class, **)
+        end
+
+        def inventory_query
+          cli_factory.query_inventory
+        end
+
         def fmt
           Moose::Inventory::Cli::Formatter
         end
 
+        def runtime_options
+          Moose::Inventory::Config.runtime_options
+        end
+
+        def output_format
+          runtime_options.output_format
+        end
+
+        def ansible_mode?
+          runtime_options.ansible?
+        end
+
         def normalize_names(values)
           values.uniq.map(&:downcase)
         end
@@ -38,12 +86,31 @@ module Moose
           abort(message || "ERROR: Cannot manually manipulate the automatic group '#{AUTOMATIC_GROUP}'.")
         end
 
+        def confirm_destructive_action!(description)
+          return if options[:dry_run] || options[:yes]
+
+          abort("ERROR: #{description} is destructive. Re-run with --yes to confirm, or use --dry-run to preview.")
+        end
+
         def association_exists?(dataset, name)
           !dataset.nil? && !dataset[name: name].nil?
         end
 
+        def exception_to_s(error)
+          error.to_s
+        end
+
+        def print_warning_summary(result, success_message: 'Succeeded.', warning_message: 'Succeeded, with warnings.')
+          warning_count = result.respond_to?(:warning_count) ? result.warning_count : 0
+          print_success_summary(warning_count.zero? ? success_message : warning_message)
+        end
+
+        def print_success_summary(message = 'Succeeded.')
+          puts message
+        end
+
         def automatic_group
-          db.models[:group].find_or_create(name: AUTOMATIC_GROUP)
+          inventory_context.automatic_group
         end
 
         def remove_automatic_group_from_host(host, indent:, message:)

data/lib/moose_inventory/cli/host.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require 'thor'
 require 'json'
 
-require_relative './formatter.rb'
-require_relative './helpers.rb'
-require_relative '../db/exceptions.rb'
+require_relative 'formatter'
+require_relative 'helpers'
+require_relative '../db/exceptions'
 
 module Moose
   module Inventory
@@ -22,6 +24,7 @@ module Moose
         require_relative 'host_addvar'
         require_relative 'host_listvars'
         require_relative 'host_rmvar'
+        require_relative 'host_tags'
       end
     end
   end

data/lib/moose_inventory/cli/host_add.rb

@@ -15,12 +15,28 @@ module Moose
       ##
       # Class implementing the "host" methods of the CLI
       class Host
+        ADD_HOST_EVENT_RENDERERS = {
+          host_started: :render_add_host_started,
+          creating_host: :render_add_host_creation,
+          host_exists: :render_add_host_exists_warning,
+          ok: :render_add_host_ok,
+          adding_association: :render_add_host_association,
+          group_missing_created: :render_add_host_missing_group_warning,
+          association_exists: :render_add_host_association_exists_warning,
+          adding_automatic_group: :render_add_host_automatic_group,
+          host_complete: :render_add_host_complete,
+          dry_run_summary: :render_dry_run_summary
+        }.freeze
+
         #==========================
         desc 'add HOSTNAME_1 [HOSTNAME_2 ...]',
              'Add a hosts HOSTNAME_n to the inventory'
         option :groups
+        option :dry_run, type: :boolean
+        option :plan_format, type: :string, desc: 'Emit dry-run plan events as yaml|json|pjson'
         def add(*argv)
           abort_if_missing_args(argv, 1, '1 or more')
+          validate_machine_plan_request!
 
           # Arguments
           names = normalize_names(argv)
@@ -32,11 +48,14 @@ module Moose
           # Sanity
           abort_if_automatic_group(groups)
 
-          result = Moose::Inventory::Operations::AddHosts
-                   .new(context: Moose::Inventory::InventoryContext.new(db: db))
-                   .call(names: names, groups: groups)
+          result = build_operation(Moose::Inventory::Operations::AddHosts)
+                   .call(names: names, groups: groups, dry_run: options[:dry_run])
+          return if machine_plan_output_rendered?(result, command: 'host add')
+
+          record_audit({ command: 'host add', action: 'add', entity_type: 'host',
+                         entity_names: names }, result: result, dry_run: options[:dry_run])
           render_add_hosts_events(result.events)
-          puts 'Succeeded'
+          print_warning_summary(result, success_message: 'Succeeded', warning_message: 'Succeeded')
         end
 
         private
@@ -46,31 +65,52 @@ module Moose
           events.each { |event| render_add_hosts_event(event) }
         end
 
-        def render_add_hosts_event(event) # rubocop:disable Metrics/CyclomaticComplexity
-          payload = event.payload
-          case event.type
-          when :host_started
-            puts "Add host '#{payload[:name]}':"
-          when :creating_host
-            fmt.puts 2, "- Creating host '#{payload[:name]}'..."
-          when :host_exists
-            fmt.warn "The host '#{payload[:name]}' already exists, skipping creation.\n"
-          when :ok
-            fmt.puts payload[:indent], '- OK'
-          when :adding_association
-            fmt.puts 2, "- Adding association {host:#{payload[:host]} <-> group:#{payload[:group]}}..."
-          when :group_missing_created
-            fmt.warn "The group '#{payload[:name]}' doesn't exist, but will be created.\n"
-          when :association_exists
-            fmt.warn(
-              "Association {host:#{payload[:host]} <-> group:#{payload[:group]}} " \
-              "already exists, skipping creation.\n"
-            )
-          when :adding_automatic_group
-            fmt.puts 2, "- Adding automatic association {host:#{payload[:host]} <-> group:#{payload[:group]}}..."
-          when :host_complete
-            fmt.puts 2, '- All OK'
-          end
+        def render_add_hosts_event(event)
+          renderer = ADD_HOST_EVENT_RENDERERS[event.type]
+          send(renderer, event.payload) unless renderer.nil?
+        end
+
+        def render_add_host_started(payload)
+          puts "Add host '#{payload[:name]}':"
+        end
+
+        def render_add_host_creation(payload)
+          fmt.puts 2, "- Creating host '#{payload[:name]}'..."
+        end
+
+        def render_add_host_exists_warning(payload)
+          fmt.warn "The host '#{payload[:name]}' already exists, skipping creation.\n"
+        end
+
+        def render_add_host_ok(payload)
+          fmt.puts payload[:indent], '- OK'
+        end
+
+        def render_add_host_association(payload)
+          fmt.puts 2, "- Adding association {host:#{payload[:host]} <-> group:#{payload[:group]}}..."
+        end
+
+        def render_add_host_missing_group_warning(payload)
+          fmt.warn "The group '#{payload[:name]}' doesn't exist, but will be created.\n"
+        end
+
+        def render_add_host_association_exists_warning(payload)
+          fmt.warn(
+            "Association {host:#{payload[:host]} <-> group:#{payload[:group]}} " \
+            "already exists, skipping creation.\n"
+          )
+        end
+
+        def render_add_host_automatic_group(payload)
+          fmt.puts 2, "- Adding automatic association {host:#{payload[:host]} <-> group:#{payload[:group]}}..."
+        end
+
+        def render_add_host_complete(_payload)
+          fmt.puts 2, '- All OK'
+        end
+
+        def render_dry_run_summary(_payload)
+          puts 'Dry run complete. No changes applied.'
         end
       end
     end