moose-inventory 2.0 → 2.1.1

data/lib/moose_inventory/cli/group_add.rb

@@ -14,8 +14,11 @@ module Moose
         #==========================
         desc 'add NAME', 'Add a group NAME to the inventory'
         option :hosts
+        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!
 
           names = normalize_names(argv)
           hosts = csv_option_names(options[:hosts])
@@ -25,16 +28,14 @@ module Moose
             "ERROR: Cannot manually manipulate the automatic group 'ungrouped'\n"
           )
 
-          result = Moose::Inventory::Operations::AddGroups
-                   .new(context: Moose::Inventory::InventoryContext.new(db: db))
-                   .call(names: names, hosts: hosts)
-          render_add_groups_events(result.events)
+          result = build_operation(Moose::Inventory::Operations::AddGroups)
+                   .call(names: names, hosts: hosts, dry_run: options[:dry_run])
+          return if machine_plan_output_rendered?(result, command: 'group add')
 
-          if result.warning_count.zero?
-            puts 'Succeeded'
-          else
-            puts 'Succeeded, with warnings.'
-          end
+          record_audit({ command: 'group add', action: 'add', entity_type: 'group',
+                         entity_names: names }, result: result, dry_run: options[:dry_run])
+          render_add_groups_events(result.events)
+          print_warning_summary(result, success_message: 'Succeeded')
         end
 
         private
@@ -48,6 +49,7 @@ module Moose
 
           return render_add_groups_event_puts(event.type, payload) if puts_event?(event.type)
           return render_add_groups_event_warn(event.type, payload) if warn_event?(event.type)
+          return puts 'Dry run complete. No changes applied.' if event.type == :dry_run_summary
 
           render_add_groups_event_fmt(event.type, payload)
         end

data/lib/moose_inventory/cli/group_addchild.rb

@@ -14,8 +14,11 @@ module Moose
         #==========================
         desc 'addchild PARENTGROUP CHILDGROUP_1 [CHILDGROUP_2 ... ]',
              'Associate one or more child-groups CHILDGROUP_n with PARENTGROUP'
+        option :dry_run, type: :boolean
+        option :plan_format, type: :string, desc: 'Emit dry-run plan events as yaml|json|pjson'
         def addchild(*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))
@@ -23,81 +26,36 @@ module Moose
           abort_if_automatic_group([pname] + cnames)
 
           result = add_children_to_group(pname, cnames)
+          return if machine_plan_output_rendered?(result, command: 'group addchild')
 
-          if result.warning_count.zero?
-            puts 'Succeeded.'
-          else
-            puts 'Succeeded, with warnings.'
-          end
+          record_audit({ command: 'group addchild', action: 'associate_child', entity_type: 'group',
+                         entity_names: pname }, result: result, dry_run: options[:dry_run])
+          print_warning_summary(result)
         end
 
         private
 
         def add_children_to_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 "Associate parent group '#{parent_name}' with child group(s) '#{child_names.join(',')}':"
-              parent_group = fetch_existing_group_for_child_relation(context, parent_name)
-              result = operation.add_children(
-                parent_group: parent_group,
-                parent_name: parent_name,
-                child_names: child_names
-              )
-              render_addchild_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: "Associate parent group '#{parent_name}' with child group(s) '#{child_names.join(',')}':",
+            on_error: method(:exception_to_s)
+          ) do
+            parent_group = fetch_existing_group_or_abort(parent_name)
+            result = operation.add_children(
+              parent_group: parent_group,
+              parent_name: parent_name,
+              child_names: child_names,
+              dry_run: options[:dry_run]
+            )
+            render_addchild_events(result.events) unless machine_plan_output_requested?
+            result
           end
         end
 
-        def fetch_existing_group_for_child_relation(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_addchild_events(events)
-          events.each { |event| render_addchild_event(event) }
-        end
-
-        def render_addchild_event(event)
-          payload = event.payload
-
-          return render_addchild_warning(event.type, payload) if addchild_warning?(event.type)
-          return render_addchild_existing(payload) if event.type == :already_exists_skipping
-
-          case event.type
-          when :adding_child_association
-            fmt.puts 2, "- add association {group:#{payload[:parent]} <-> group:#{payload[:child]}}..."
-          when :child_group_creating_now
-            fmt.puts 4, '- child group does not exist, creating now...'
-          when :ok
-            fmt.puts payload[:indent], '- OK'
-          end
-        end
-
-        def addchild_warning?(type)
-          %i[child_association_exists child_group_missing].include?(type)
-        end
-
-        def render_addchild_warning(type, payload)
-          if type == :child_association_exists
-            fmt.warn "Association {group:#{payload[:parent]} <-> group:#{payload[:child]}}} already exists, skipping.\n"
-          else
-            fmt.warn "Group '#{payload[:name]}' does not exist and will be created.\n"
-          end
-        end
-
-        def render_addchild_existing(payload)
-          fmt.puts payload[:indent], '- already exists, skipping.'
+          emitter = addchild_emitter
+          events.each { |event| emitter.call(event) }
         end
       end
     end

data/lib/moose_inventory/cli/group_addhost.rb

@@ -14,8 +14,11 @@ module Moose
         #==========================
         desc 'addhost NAME HOSTNAME',
              'Associate a host HOSTNAME with the group NAME'
+        option :dry_run, type: :boolean
+        option :plan_format, type: :string, desc: 'Emit dry-run plan events as yaml|json|pjson'
         def addhost(*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))
@@ -23,83 +26,29 @@ module Moose
           abort_if_automatic_group([name])
 
           result = add_hosts_to_group(name, hosts)
+          return if machine_plan_output_rendered?(result, command: 'group addhost')
 
-          if result.warning_count.zero?
-            puts 'Succeeded.'
-          else
-            puts 'Succeeded, with warnings.'
-          end
+          record_audit({ command: 'group addhost', action: 'associate', entity_type: 'group',
+                         entity_names: name }, result: result, dry_run: options[:dry_run])
+          print_warning_summary(result)
         end
 
         private
 
         def add_hosts_to_group(name, hosts)
-          context = Moose::Inventory::InventoryContext.new(db: db)
-          operation = Moose::Inventory::Operations::AddAssociations.new(context: context)
-
-          begin
-            db.transaction do
-              puts "Associate group '#{name}' with host(s) '#{hosts.join(',')}':"
-              group = fetch_existing_group_for_addhost(context, name)
-              result = operation.group_to_hosts(group: group, group_name: name, host_names: hosts)
-              render_group_addhost_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::AddAssociations)
+          run_group_relation_transaction(heading: "Associate group '#{name}' with host(s) '#{hosts.join(',')}':") do
+            group = fetch_existing_group_or_abort(name)
+            result = operation.group_to_hosts(group: group, group_name: name, host_names: hosts,
+                                              dry_run: options[:dry_run])
+            render_group_addhost_events(result.events) unless machine_plan_output_requested?
+            result
           end
         end
 
-        def fetch_existing_group_for_addhost(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_addhost_events(events)
-          events.each { |event| render_group_addhost_event(event) }
-        end
-
-        def render_group_addhost_event(event)
-          payload = event.payload
-
-          return render_group_addhost_warning(event.type, payload) if group_addhost_warning?(event.type)
-          return render_group_addhost_status(payload) if event.type == :already_exists_skipping
-
-          render_group_addhost_output(event.type, payload)
-        end
-
-        def group_addhost_warning?(type)
-          %i[group_host_association_exists host_missing_created].include?(type)
-        end
-
-        def render_group_addhost_warning(type, payload)
-          if type == :group_host_association_exists
-            fmt.warn "Association {group:#{payload[:group]} <-> host:#{payload[:host]}} already exists, skipping.\n"
-          else
-            fmt.warn "Host '#{payload[:name]}' does not exist and will be created.\n"
-          end
-        end
-
-        def render_group_addhost_status(payload)
-          fmt.puts payload[:indent], '- already exists, skipping.'
-        end
-
-        def render_group_addhost_output(type, payload)
-          case type
-          when :adding_group_host_association
-            fmt.puts 2, "- add association {group:#{payload[:group]} <-> host:#{payload[:host]}}..."
-          when :host_creating_now
-            fmt.puts 4, '- host does not exist, creating now...'
-          when :removing_automatic_group
-            fmt.puts 2, "- remove automatic association {group:ungrouped <-> host:#{payload[:host]}}..."
-          when :ok
-            fmt.puts payload[:indent], '- OK'
-          end
+          emitter = host_group_association_addition_emitter(perspective: :group)
+          events.each { |event| emitter.call(event) }
         end
       end
     end

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