moose-inventory 1.0.9 → 2.1

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

@@ -1,5 +1,9 @@
+# frozen_string_literal: true
+
 require 'thor'
-require_relative './formatter.rb'
+require_relative 'formatter'
+require_relative '../inventory_context'
+require_relative '../operations/remove_groups'
 
 module Moose
   module Inventory
@@ -8,82 +12,110 @@ module Moose
       # Implementation of "group rm" methods of the CLI
       class Group
         #==========================
+        option :recursive,
+               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) # rubocop:disable Metrics/AbcSize
-          #
-          # Sanity
-          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)
-
-          # sanity
-          if names.include?('ungrouped')
-            abort("Cannot manually manipulate the automatic group 'ungrouped'\n")
+        def rm(*argv)
+          abort_if_missing_args(argv, 1, '1 or more')
+          validate_machine_plan_request!
+
+          names = normalize_names(argv)
+
+          abort_if_automatic_group(
+            names,
+            "Cannot manually manipulate the automatic group 'ungrouped'\n"
+          )
+          confirm_destructive_action!("group rm #{names.join(',')}")
+
+          result = remove_groups(names)
+          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)
+          operation = build_operation(Moose::Inventory::Operations::RemoveGroups)
+
+          db.transaction do
+            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
+
+        def render_group_rm_events(events)
+          events.each { |event| render_group_rm_event(event) }
+        end
+
+        def render_group_rm_event(event)
+          payload = event.payload
+
+          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
+
+        def group_rm_progress?(type)
+          %i[group_started retrieving_group removing_parent_association removing_child_association].include?(type)
+        end
+
+        def render_group_rm_warning(payload)
+          fmt.warn "Group '#{payload[:name]}' does not exist, skipping.\n"
+        end
+
+        def render_group_rm_progress(type, payload)
+          case type
+          when :group_started
+            puts "Remove group '#{payload[:name]}':"
+          when :retrieving_group
+            fmt.puts 2, "- Retrieve group '#{payload[:name]}'..."
+          when :removing_parent_association, :removing_child_association
+            fmt.puts 2, "- Remove association {group:#{payload[:group]} <-> group:#{payload[:related_group]}}..."
           end
+        end
+
+        def render_group_rm_status(type, payload)
+          return render_group_rm_secondary_status(type, payload) if group_rm_secondary_status?(type)
+
+          case type
+          when :group_missing
+            fmt.puts 4, '- No such group, skipping.'
+          when :destroying_group
+            fmt.puts payload[:indent], "- Destroy group '#{payload[:name]}'..."
+          when :group_complete
+            fmt.puts 2, '- All OK'
+          end
+        end
+
+        def group_rm_secondary_status?(type)
+          %i[
+            recursively_delete_orphaned_group
+            removing_recursive_child_association
+            adding_automatic_group_to_host
+            ok
+          ].include?(type)
+        end
 
-          # Transaction
-          warn_count = 0
-          db.transaction do # Transaction start
-            names.each do |name|
-              puts "Remove group '#{name}':"
-              fmt.puts 2, "- Retrieve group '#{name}'..."
-              group = db.models[:group].find(name: name)
-              if group.nil?
-                warn_count += 1
-                fmt.warn "Group '#{name}' does not exist, skipping.\n"
-                fmt.puts 4, '- No such group, skipping.'
-              end
-              fmt.puts 4, '- OK'
-              unless group.nil?
-                # Dissociate from any parent groups
-                pgroups_ds = group.parents_dataset
-                pgroups_ds.each do |parent|
-                  fmt.puts 2, "- Remove association {group:#{name} <-> group:#{parent.name}}..."
-                  parent.remove_child(group)
-                  fmt.puts 4, '- OK'
-                end
-
-                # Dissociate from any child groups
-                groups_ds = group.children_dataset
-                groups_ds.each do |child|
-                  fmt.puts 2, "- Remove association {group:#{name} <-> group:#{child.name}}..."
-                  group.remove_child(child)
-                  # TODO: Should we propagate the delete to orphaned children?
-                  fmt.puts 4, '- OK'
-                end
-
-                # Handle automatic group for any associated hosts
-                hosts_ds = group.hosts_dataset
-                hosts_ds.each do |host|
-                  host_groups_ds = host.groups_dataset
-                  next unless host_groups_ds.count == 1 # We're the only group
-                  fmt.puts 2, "- Adding automatic association {group:ungrouped <-> host:#{host[:name]}}..."
-                  ungrouped = db.models[:group].find_or_create(name: 'ungrouped')
-                  host.add_group(ungrouped)
-                  fmt.puts 4, '- OK'
-                end
-                # Remove the group
-                fmt.puts 2, "- Destroy group '#{name}'..."
-                group.remove_all_hosts
-                group.destroy
-                fmt.puts 4, '- OK'
-              end
-              fmt.puts 2, '- All OK'
-            end
-          end # Transaction end
-          if warn_count == 0
-            puts 'Succeeded.'
-          else
-            puts 'Succeeded, with warnings.'
+        def render_group_rm_secondary_status(type, payload)
+          case type
+          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]}}..."
+          when :adding_automatic_group_to_host
+            fmt.puts payload[:indent], "- Adding automatic association {group:ungrouped <-> host:#{payload[:host]}}..."
+          when :ok
+            fmt.puts payload[:indent], '- OK'
           end
         end
       end

data/lib/moose_inventory/cli/group_rmchild.rb

@@ -1,6 +1,10 @@
+# frozen_string_literal: true
+
 require 'thor'
 
-require_relative './formatter.rb'
+require_relative 'formatter'
+require_relative '../inventory_context'
+require_relative '../operations/group_child_relations'
 
 module Moose
   module Inventory
@@ -9,72 +13,58 @@ module Moose
       # Implemention of the "group rmchild" methods of the CLI
       class Group
         #==========================
+        option :delete_orphans,
+               type: :boolean,
+               default: false,
+               desc: 'Delete child groups that become orphaned'
         desc 'rmchild PARENTGROUP CHILDGROUP_1 [CHILDGROUP_2 ... ]',
              'Dissociate one or more child-groups CHILDGROUP_n from PARENTGROUP'
-        def rmchild(*_argv)
-          # Sanity check
-          if args.length < 2
-            abort("ERROR: Wrong number of arguments, #{args.length} "\
-              'for 2 or more.')
-          end
+        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!
 
-          # Arguments
-          pname = args[0].downcase
-          cnames = args.slice(1, args.length - 1).uniq.map(&:downcase)
-
-          # Sanity
-          if pname == 'ungrouped' || cnames.include?('ungrouped')
-            abort("ERROR: Cannot manually manipulate the automatic group 'ungrouped'.")
-          end
+          pname = argv[0].downcase
+          cnames = normalize_names(argv.slice(1, argv.length - 1))
 
-          # Convenience
-          db = Moose::Inventory::DB
-          fmt = Moose::Inventory::Cli::Formatter
+          abort_if_automatic_group([pname] + cnames)
+          confirm_destructive_action!("group rmchild #{pname} #{cnames.join(',')}")
 
-          # Transaction
-          warn_count = 0
-          begin
-            db.transaction do # Transaction start
-              puts "Dissociate parent group '#{pname}' from child group(s) '#{cnames.join(',')}':"
-              # Get the target group
-              fmt.puts 2, "- retrieve group '#{pname}'..."
-              pgroup = db.models[:group].find(name: pname)
-              if pgroup.nil?
-                abort("ERROR: The group '#{pname}' does not exist.")
-              end
-              fmt.puts 4, '- OK'
+          result = remove_children_from_group(pname, cnames)
+          return if machine_plan_output_rendered?(result, command: 'group rmchild')
 
-              # Dissociate parent group from the child groups
-              groups_ds = pgroup.children_dataset
-              cnames.each do |cname|
-                fmt.puts 2, "- remove association {group:#{pname} <-> group:#{cname}}..."
+          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
 
-                # Check against existing associations
-                if groups_ds[name: cname].nil?
-                  warn_count += 1
-                  fmt.warn "Association {group:#{pname} <-> group:#{cname}}"\
-                      " does not exist, skipping.\n"
-                  fmt.puts 4, "- doesn't exist, skipping."
-                  fmt.puts 4, '- OK'
-                  next
-                end
+        private
 
-                # remove association
-                cgroup = db.models[:group].find(name: cname)
-                pgroup.remove_child(cgroup)
-                fmt.puts 4, '- OK'
-              end
-              fmt.puts 2, '- all OK'
-            end # Transaction end
-          rescue db.exceptions[:moose] => e
-            abort("ERROR: #{e}")
-          end
-          if warn_count == 0
-            puts 'Succeeded.'
-          else
-            puts 'Succeeded, with warnings.'
+        def remove_children_from_group(parent_name, child_names)
+          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 render_rmchild_events(events)
+          emitter = rmchild_emitter
+          events.each { |event| emitter.call(event) }
+        end
       end
     end
   end

data/lib/moose_inventory/cli/group_rmhost.rb

@@ -1,5 +1,9 @@
+# frozen_string_literal: true
+
 require 'thor'
-require_relative './formatter.rb'
+require_relative 'formatter'
+require_relative '../inventory_context'
+require_relative '../operations/remove_associations'
 
 module Moose
   module Inventory
@@ -10,75 +14,44 @@ module Moose
         #==========================
         desc 'rmhost GROUPNAME HOSTNAME_1 [HOSTNAME_2 ...]',
              'Dissociate the hosts HOSTNAME_n from the group NAME'
-        # rubocop:disable Metrics/LineLength
-        def rmhost(*args) # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/MethodLength, Metrics/CyclomaticComplexity
-          # rubocop:enable Metrics/LineLength
-          # Sanity
-          if args.length < 2
-            abort("ERROR: Wrong number of arguments, #{args.length} for 2 or more.")
-          end
+        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!
 
-          # Arguments
           name = args[0].downcase
-          hosts = args.slice(1, args.length - 1).uniq.map(&:downcase)
-
-          # Sanity
-          if name == 'ungrouped'
-            abort("ERROR: Cannot manually manipulate the automatic group 'ungrouped'.")
-          end
-
-          # Convenience
-          db = Moose::Inventory::DB
-          fmt = Moose::Inventory::Cli::Formatter
+          hosts = normalize_names(args.slice(1, args.length - 1))
 
-          # Transaction
-          warn_count = 0
-          begin
-            db.transaction do # Transaction start
-              # Get the target group
-              puts "Dissociate group '#{name}' from host(s) '#{hosts.join(',')}':"
-              fmt.puts 2, "- retrieve group '#{name}'..."
-              group = db.models[:group].find(name: name)
-              abort("ERROR: The group '#{name}' does not exist.") if group.nil?
-              fmt.puts 4, '- OK'
+          abort_if_automatic_group([name])
+          confirm_destructive_action!("group rmhost #{name} #{hosts.join(',')}")
 
-              # dissociate group from the hosts
-              ungrouped = db.models[:group].find_or_create(name: 'ungrouped')
-              hosts_ds = group.hosts_dataset
-              hosts.each do |h|
-                fmt.puts 2, "- remove association {group:#{name} <-> host:#{h}}..."
+          result = remove_hosts_from_group(name, hosts)
+          return if machine_plan_output_rendered?(result, command: 'group rmhost')
 
-                # Check against existing associations
-                if hosts_ds[name: h].nil?
-                  warn_count += 1
-                  fmt.warn "Association {group:#{name} <-> host:#{h}} doesn't"\
-                    " exist, skipping.\n"
-                  fmt.puts 4, '- doesn\'t exist, skipping.'
-                  fmt.puts 4, '- OK'
-                  next
-                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
 
-                host = db.models[:host].find(name: h)
-                group.remove_host(host) unless host.nil?
-                fmt.puts 4, '- OK'
+        private
 
-                # Add the host to the ungrouped group if not in any other group
-                next unless host.groups_dataset.count == 0
-                fmt.puts 2, "- add automatic association {group:ungrouped <-> host:#{h}}..."
-                host.add_group(ungrouped)
-                fmt.puts 4, '- OK'
-              end
-              fmt.puts 2, '- all OK'
-            end # Transaction end
-          rescue db.exceptions[:moose] => e
-            abort("ERROR: #{e.message}")
-          end
-          if warn_count == 0
-            puts 'Succeeded.'
-          else
-            puts 'Succeeded, with warnings.'
+        def remove_hosts_from_group(name, hosts)
+          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 render_group_rmhost_events(events)
+          emitter = host_group_association_removal_emitter(perspective: :group)
+          events.each { |event| emitter.call(event) }
+        end
       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