moose-inventory 2.0 → 2.1

data/lib/moose_inventory/cli/group_addvar.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require 'thor'
-require_relative './formatter.rb'
+require_relative '../inventory_context'
+require_relative '../operations/add_variables'
 
 module Moose
   module Inventory
@@ -10,61 +13,38 @@ module Moose
         #==========================
         desc 'addvar NAME VARNAME=VALUE',
              'Add a variable VARNAME with value VALUE to the group NAME'
+        option :dry_run, type: :boolean
+        option :plan_format, type: :string, desc: 'Emit dry-run plan events as yaml|json|pjson'
         def addvar(*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
+          operation = build_operation(Moose::Inventory::Operations::AddVariables,
+                                      entity_type: :group,
+                                      emitter: machine_plan_emitter(group_addvar_emitter(name, vars)))
 
-          # Transaction
-          db.transaction do # Transaction start
-            puts "Add variables '#{vars.join(',')}' to group '#{name}':"
-            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'
+          result = db.transaction do
+            operation.call(name: name, vars: vars, dry_run: options[:dry_run])
+          end
 
-            groupvars_ds = group.groupvars_dataset
-            vars.each do |v|
-              fmt.puts 2, "- add variable '#{v}'..."
-              vararray = v.split('=')
+          return if machine_plan_output_rendered?(result, command: 'group addvar')
 
-              if v.start_with?('=') || v.end_with?('=') || vararray.length != 2
-                fail db.exceptions[:moose],
-                     "Incorrect format in '{#{v}}'. Expected 'key=value'."
-              end
+          record_audit({ command: 'group addvar', action: 'add_variable', entity_type: 'group',
+                         entity_names: name }, result: result, dry_run: options[:dry_run])
+          print_success_summary
+        end
 
-              # Check against existing associations
-              groupvar = groupvars_ds[name: vararray[0]]
-              if !groupvar.nil?
-                unless groupvar[:value] == vararray[1]
-                  fmt.puts 4, '- already exists, applying as an update...'
-                  update = db.models[:groupvar].find(id: groupvar[:id])
-                  update[:value] = vararray[1]
-                  update.save
-                end
-              else
-                # groupvar doesn't exist, so create and associate
-                groupvar = db.models[:groupvar].create(name: vararray[0],
-                                                       value: vararray[1])
-                group.add_groupvar(groupvar)
-              end
-              fmt.puts 4, '- OK'
-            end
-            fmt.puts 2, '- all OK'
-          end # Transaction end
+        private
 
-          puts 'Succeeded.'
+        def group_addvar_emitter(name, vars)
+          variable_operation_emitter(
+            action: :add,
+            entity_label: 'group',
+            entity_name: name,
+            variables_label: vars.join(',')
+          )
         end
       end
     end

data/lib/moose_inventory/cli/group_get.rb

@@ -1,54 +1,20 @@
+# frozen_string_literal: true
+
 require 'thor'
-require_relative './formatter.rb'
+require_relative '../inventory_context'
+require_relative '../operations/query_inventory'
 
 module Moose
   module Inventory
     module Cli
-      ##
       # Implementation of the "group get" method of the CLI
       class Group
         desc 'get GROUP_1 [GROUP_2 ...]', 'Get groups GROUP_n from the inventory'
-        def get(*argv) # rubocop:disable Metrics/AbcSize
-          if argv.empty?
-            abort('ERROR: Wrong number of arguments, '\
-              "#{argv.length} for 1 or more")
-          end
-
-          # Convenience
-          db = Moose::Inventory::DB
-          fmt = Moose::Inventory::Cli::Formatter
-
-          # Arguments
-          names = argv.uniq.map(&:downcase)
-
-          # Process
-          results = {}
-          names.each do |name|
-            group = db.models[:group].find(name: name)
-
-            next if group.nil?
-            hosts = group.hosts_dataset.map(:name)
-
-            children = group.children_dataset.map(:name)
-
-            groupvars = {}
-            group.groupvars_dataset.each do |gv|
-              groupvars[gv[:name].to_sym] = gv[:value]
-            end
-
-            results[group[:name].to_sym] = {}
-            results[group[:name].to_sym][:hosts] = hosts unless hosts.empty?
-
-            unless children.empty?
-              results[group[:name].to_sym][:children] = children
-            end
-
-            unless groupvars.empty?
-              results[group[:name].to_sym][:groupvars] = groupvars
-            end
-          end
+        def get(*argv)
+          abort("ERROR: Wrong number of arguments, #{argv.length} for 1 or more") if argv.empty?
 
-          fmt.dump(results)
+          names = normalize_names(argv)
+          fmt.dump(inventory_query.get_groups(names: names), output_format)
         end
       end
     end

data/lib/moose_inventory/cli/group_list.rb

@@ -1,52 +1,19 @@
+# frozen_string_literal: true
+
 require 'thor'
-require_relative './formatter.rb'
+require_relative '../inventory_context'
+require_relative '../operations/query_inventory'
 
 module Moose
   module Inventory
     module Cli
-      ##
       # Implementation of the "group list" method of the CLI
       class Group
-        #==========================
         desc 'list',
              'List the groups, together with any associated hosts and groupvars'
-        def list # rubocop:disable Metrics/AbcSize
-          # Convenience
-          db = Moose::Inventory::DB
-          confopts = Moose::Inventory::Config._confopts
-
-          # Process
-          results = {}
-          db.models[:group].all.each do |group|
-            hosts = group.hosts_dataset.map(:name)
-
-            # Hide the automatic ungrouped group, if it's empty
-            next if group[:name] == 'ungrouped' && hosts.empty?
-
-            children = group.children_dataset.map(:name)
-
-            groupvars = {}
-            group.groupvars_dataset.each do |gv|
-              groupvars[gv[:name].to_sym] = gv[:value]
-            end
-
-            results[group[:name].to_sym] = {}
-            unless hosts.empty? && (confopts[:ansible] != true)
-              results[group[:name].to_sym][:hosts] = hosts
-            end
-
-            unless children.empty?
-              results[group[:name].to_sym][:children] = children
-            end
-
-            next if groupvars.empty?
-            if confopts[:ansible] == true
-              results[group[:name].to_sym][:vars] = groupvars
-            else
-              results[group[:name].to_sym][:groupvars] = groupvars
-            end
-          end
-          Formatter.out(results)
+        def list
+          results = inventory_query.list_groups(ansible: ansible_mode?)
+          fmt.dump(results, output_format)
         end
       end
     end

data/lib/moose_inventory/cli/group_listvars.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require 'thor'
 require 'json'
 
-require_relative './formatter.rb'
-require_relative '../db/exceptions.rb'
+require_relative '../inventory_context'
+require_relative '../operations/query_inventory'
 
 module Moose
   module Inventory
@@ -13,61 +15,13 @@ module Moose
         #==========================
         desc 'listvar', 'List all variables associated with the group'
         def listvars(*argv)
-          # Convenience
-          confopts = Moose::Inventory::Config._confopts
-
-          # Note, the Ansible spects don't call for a "--group GROUPNAME" method.
-          # So, strictly, there is no Ansible compatibility for this method.
-          # Instead, the Ansible compatibility included herein is for consistency
-          # with the "hosts listvars" method, which services the Ansible
-          # "--host HOSTNAME" specs.
-
-          # sanity
-          if confopts[:ansible] == true
-            if argv.length != 1
-              abort('ERROR: Wrong number of arguments for Ansible mode, '\
-                    "#{args.length} for 1.")
-            end
-          else
-            if argv.empty?
-              abort('ERROR: Wrong number of arguments, '\
-                    "#{args.length} for 1 or more.")
-            end
-          end
-
-          # Convenience
-          db = Moose::Inventory::DB
-          fmt = Moose::Inventory::Cli::Formatter
-
-          # Arguments
-          names = argv.uniq.map(&:downcase)
+          validate_listvars_args(argv)
 
-          # process
-          results = {}
+          names = normalize_names(argv)
+          results = inventory_query.list_group_vars(names: names, ansible: ansible_mode?)
+          warn_if_missing_ansible_listvars_entity(:group, names.first)
 
-          if confopts[:ansible] == true
-            # This is the implementation per Ansible specs
-            name = names.first
-            group = db.models[:group].find(name: name)
-            if group.nil?
-              fmt.warn "The Group #{name} does not exist."
-            else
-              group.groupvars_dataset.each do |gv|
-                results[gv[:name].to_sym] = gv[:value]
-              end
-            end
-          else
-            # This our more flexible implementation
-            names.each do |name|
-              group = db.models[:group].find(name: name)
-              next if group.nil?
-              results[name.to_sym] = {}
-              group.groupvars_dataset.each do |gv|
-                results[name.to_sym][gv[:name].to_sym] = gv[:value]
-              end
-            end
-          end
-          fmt.dump(results)
+          fmt.dump(results, output_format)
         end
       end
     end

data/lib/moose_inventory/cli/group_rm.rb

@@ -16,10 +16,14 @@ module Moose
                type: :boolean,
                default: false,
                desc: 'Also delete child groups that become orphaned'
+        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'
         desc 'rm NAME',
              'Remove a group NAME from the inventory'
         def rm(*argv)
           abort_if_missing_args(argv, 1, '1 or more')
+          validate_machine_plan_request!
 
           names = normalize_names(argv)
 
@@ -27,25 +31,22 @@ module Moose
             names,
             "Cannot manually manipulate the automatic group 'ungrouped'\n"
           )
+          confirm_destructive_action!("group rm #{names.join(',')}")
 
           result = remove_groups(names)
-
-          if result.warning_count.zero?
-            puts 'Succeeded.'
-          else
-            puts 'Succeeded, with warnings.'
-          end
+          record_audit({ command: 'group rm', action: 'remove', entity_type: 'group',
+                         entity_names: names }, result: result, dry_run: options[:dry_run])
+          print_warning_summary(result) unless machine_plan_output_requested?
         end
 
         private
 
         def remove_groups(names)
-          context = Moose::Inventory::InventoryContext.new(db: db)
-          operation = Moose::Inventory::Operations::RemoveGroups.new(context: context)
+          operation = build_operation(Moose::Inventory::Operations::RemoveGroups)
 
           db.transaction do
-            result = operation.call(names: names, recursive: options[:recursive])
-            render_group_rm_events(result.events)
+            result = operation.call(names: names, recursive: options[:recursive], dry_run: options[:dry_run])
+            machine_plan_output_rendered?(result, command: 'group rm') || render_group_rm_events(result.events)
             return result
           end
         end
@@ -59,6 +60,7 @@ module Moose
 
           render_group_rm_warning(payload) if event.type == :group_missing
           return render_group_rm_progress(event.type, payload) if group_rm_progress?(event.type)
+          return puts 'Dry run complete. No changes applied.' if event.type == :dry_run_summary
 
           render_group_rm_status(event.type, payload)
         end

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