moose-inventory 1.0.8 → 2.0

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
@@ -7,85 +11,109 @@ 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'
         desc 'rm NAME',
              'Remove a group NAME from the inventory'
-        def rm(*argv) # rubocop:disable Metrics/AbcSize
-          #
-          # Sanity
-          if argv.length < 1
-               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")
-          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
-                  if 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
-                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."
+        def rm(*argv)
+          abort_if_missing_args(argv, 1, '1 or more')
+
+          names = normalize_names(argv)
+
+          abort_if_automatic_group(
+            names,
+            "Cannot manually manipulate the automatic group 'ungrouped'\n"
+          )
+
+          result = remove_groups(names)
+
+          if result.warning_count.zero?
+            puts 'Succeeded.'
           else
-            puts "Succeeded, with warnings."
+            puts 'Succeeded, with warnings.'
+          end
+        end
+
+        private
+
+        def remove_groups(names)
+          context = Moose::Inventory::InventoryContext.new(db: db)
+          operation = Moose::Inventory::Operations::RemoveGroups.new(context: context)
+
+          db.transaction do
+            result = operation.call(names: names, recursive: options[:recursive])
+            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)
+
+          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
+
+        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,81 +1,126 @@
+# 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
     module Cli
       ##
       # Implemention of the "group rmchild" methods of the CLI
-      class Group < Thor # rubocop:disable ClassLength
+      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'
+             'Dissociate one or more child-groups CHILDGROUP_n from PARENTGROUP'
         def rmchild(*argv)
+          abort_if_missing_args(argv, 2, '2 or more')
 
-          # Sanity check
-          if args.length < 2
-            abort("ERROR: Wrong number of arguments, #{args.length} "\
-              "for 2 or more.")
-          end
+          pname = argv[0].downcase
+          cnames = normalize_names(argv.slice(1, argv.length - 1))
 
-          # Arguments
-          pname = args[0].downcase
-          cnames = args.slice(1, args.length - 1).uniq.map(&:downcase)
+          abort_if_automatic_group([pname] + cnames)
 
-          # Sanity
-          if pname == 'ungrouped' || cnames.include?('ungrouped')
-            abort("ERROR: Cannot manually manipulate the automatic group 'ungrouped'.")
+          result = remove_children_from_group(pname, cnames)
+
+          if result.warning_count.zero?
+            puts 'Succeeded.'
+          else
+            puts 'Succeeded, with warnings.'
           end
+        end
+
+        private
 
-          # Convenience
-          db = Moose::Inventory::DB
-          fmt = Moose::Inventory::Cli::Formatter
+        def remove_children_from_group(parent_name, child_names)
+          context = Moose::Inventory::InventoryContext.new(db: db)
+          operation = Moose::Inventory::Operations::GroupChildRelations.new(context: context)
 
-          # 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"
-
-              # 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}}..."
-
-                # 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
-
-                # remove association
-                cgroup = db.models[:group].find(name: cname)
-                pgroup.remove_child(cgroup)
-                fmt.puts 4, '- OK'
-              end
+            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'
-            end # Transaction end
+              return result
+            end
           rescue db.exceptions[:moose] => e
             abort("ERROR: #{e}")
           end
-          if warn_count == 0
-            puts 'Succeeded.'
-          else
-            puts 'Succeeded, with warnings.'
+        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."
+        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
@@ -7,82 +11,82 @@ module Moose
       ##
       # Implementation of the "group rmhost" method of the CLI
       class Group
-
         #==========================
         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
+        def rmhost(*args)
+          abort_if_missing_args(args, 2, '2 or more')
 
-          # Arguments 
           name = args[0].downcase
-          hosts = args.slice(1, args.length - 1).uniq.map(&:downcase)
+          hosts = normalize_names(args.slice(1, args.length - 1))
+
+          abort_if_automatic_group([name])
 
-          # Sanity
-          if name == 'ungrouped'
-            abort("ERROR: Cannot manually manipulate the automatic group 'ungrouped'.")
+          result = remove_hosts_from_group(name, hosts)
+
+          if result.warning_count.zero?
+            puts 'Succeeded.'
+          else
+            puts 'Succeeded, with warnings.'
           end
+        end
+
+        private
 
-          # Convenience
-          db    = Moose::Inventory::DB
-          fmt = Moose::Inventory::Cli::Formatter
+        def remove_hosts_from_group(name, hosts)
+          context = Moose::Inventory::InventoryContext.new(db: db)
+          operation = Moose::Inventory::Operations::RemoveAssociations.new(context: context)
 
-          # Transaction
-          warn_count = 0
           begin
-            db.transaction do # Transaction start
-              # Get the target group
+            db.transaction do
               puts "Dissociate group '#{name}' from host(s) '#{hosts.join(',')}':"
-              fmt.puts 2, "- retrieve group '#{name}'..."
-              group = db.models[:group].find(name: name)
-              if group.nil?
-                abort("ERROR: The group '#{name}' does not exist.")
-              end
-              fmt.puts 4, '- OK'
-
-              # dissociate group from the hosts
-              ungrouped  = db.models[:group].find_or_create(name: 'ungrouped')
-              hosts_ds = group.hosts_dataset
-              hosts.each do |h| # rubocop:disable Style/Next
-                fmt.puts 2, "- remove association {group:#{name} <-> host:#{ h }}..."
-
-                # 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
-
-                host = db.models[:host].find(name: h)
-                group.remove_host(host) unless host.nil?
-                fmt.puts 4,'- OK'
-
-                # Add the host to the ungrouped group if not in any other group
-                if host.groups_dataset.count == 0
-                  fmt.puts 2, "- add automatic association {group:ungrouped <-> host:#{h}}..."
-                  host.add_group(ungrouped)
-                  fmt.puts 4, '- OK'
-                end
-              end
+              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'
-            end # Transaction end
+              return result
+            end
           rescue db.exceptions[:moose] => e
             abort("ERROR: #{e.message}")
           end
-          if warn_count == 0
-            puts 'Succeeded.'
-          else
-            puts 'Succeeded, with warnings.'
+        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."
+        end
       end
     end
   end

data/lib/moose_inventory/cli/group_rmvar.rb

@@ -15,7 +15,7 @@ module Moose
             abort('ERROR: Wrong number of arguments, ' \
                   "#{args.length} for 2 or more.")
           end
-          
+
           # Convenience
           db  = Moose::Inventory::DB
           fmt = Moose::Inventory::Cli::Formatter
@@ -26,8 +26,8 @@ module Moose
 
           # Transaction
           db.transaction do # Transaction start
-            puts "Remove variable(s) '#{vars.join(",")}' from group '#{name}':"
-            
+            puts "Remove variable(s) '#{vars.join(',')}' from group '#{name}':"
+
             fmt.puts 2, "- retrieve group '#{name}'..."
             group = db.models[:group].find(name: name)
             if group.nil?
@@ -35,7 +35,7 @@ module Moose
                    "The group '#{name}' does not exist."
             end
             fmt.puts 4, '- OK'
-            
+
             groupvars_ds = group.groupvars_dataset
             vars.each do |v|
               fmt.puts 2, "- remove variable '#{v}'..."
@@ -45,7 +45,7 @@ module Moose
                      "Incorrect format in {#{v}}. " \
                      'Expected \'key\' or \'key=value\'.'
               end
-            
+
               # Check against existing associations
               groupvar = groupvars_ds[name: vararray[0]]
               unless groupvar.nil?

data/lib/moose_inventory/cli/helpers.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Moose
+  module Inventory
+    module Cli
+      ##
+      # Shared helpers for Thor command classes.
+      module Helpers
+        AUTOMATIC_GROUP = 'ungrouped'
+
+        private
+
+        def db
+          Moose::Inventory::DB
+        end
+
+        def fmt
+          Moose::Inventory::Cli::Formatter
+        end
+
+        def normalize_names(values)
+          values.uniq.map(&:downcase)
+        end
+
+        def csv_option_names(value)
+          (value || '').downcase.split(',').uniq
+        end
+
+        def abort_if_missing_args(args, minimum, label)
+          return unless args.length < minimum
+
+          abort("ERROR: Wrong number of arguments, #{args.length} for #{label}.")
+        end
+
+        def abort_if_automatic_group(names, message = nil)
+          return unless names.include?(AUTOMATIC_GROUP)
+
+          abort(message || "ERROR: Cannot manually manipulate the automatic group '#{AUTOMATIC_GROUP}'.")
+        end
+
+        def association_exists?(dataset, name)
+          !dataset.nil? && !dataset[name: name].nil?
+        end
+
+        def automatic_group
+          db.models[:group].find_or_create(name: AUTOMATIC_GROUP)
+        end
+
+        def remove_automatic_group_from_host(host, indent:, message:)
+          ungrouped = host.groups_dataset[name: AUTOMATIC_GROUP]
+          return if ungrouped.nil?
+
+          fmt.puts indent, message
+          host.remove_group(ungrouped)
+          fmt.puts indent + 2, '- OK'
+        end
+
+        def add_automatic_group_to_host_if_last_group(host, indent:, message:)
+          add_automatic_group_to_host_if_group_count(host, 1, indent: indent, message: message)
+        end
+
+        def add_automatic_group_to_host_if_no_groups(host, indent:, message:)
+          add_automatic_group_to_host_if_group_count(host, 0, indent: indent, message: message)
+        end
+
+        def add_automatic_group_to_host_if_group_count(host, group_count, indent:, message:)
+          return unless host.groups_dataset.count == group_count
+
+          fmt.puts indent, message
+          host.add_group(automatic_group)
+          fmt.puts indent + 2, '- OK'
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/cli/host.rb

@@ -2,6 +2,7 @@ require 'thor'
 require 'json'
 
 require_relative './formatter.rb'
+require_relative './helpers.rb'
 require_relative '../db/exceptions.rb'
 
 module Moose
@@ -9,7 +10,9 @@ module Moose
     module Cli
       ##
       # Class implementing the "host" methods of the CLI
-      class Host < Thor # rubocop:disable Metrics/ClassLength
+      class Host < Thor
+        include Moose::Inventory::Cli::Helpers
+
         require_relative 'host_add'
         require_relative 'host_get'
         require_relative 'host_list'