moose-inventory 1.0.9 → 2.0

data/lib/moose_inventory/cli/group_addhost.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/add_associations'
 
 module Moose
   module Inventory
@@ -10,82 +14,91 @@ module Moose
         #==========================
         desc 'addhost NAME HOSTNAME',
              'Associate a host HOSTNAME with the group NAME'
-        def addhost(*args) # rubocop:disable Metrics/AbcSize
-          # Sanity
-          if args.length < 2
-            abort("ERROR: Wrong number of arguments, #{args.length} "\
-              'for 2 or more.')
-          end
+        def addhost(*args)
+          abort_if_missing_args(args, 2, '2 or more')
+
+          name = args[0].downcase
+          hosts = normalize_names(args.slice(1, args.length - 1))
+
+          abort_if_automatic_group([name])
 
-          # Arguments
-          name  = args[0].downcase
-          hosts = args.slice(1, args.length - 1).uniq.map(&:downcase)
+          result = add_hosts_to_group(name, hosts)
 
-          # Sanity
-          if name == 'ungrouped'
-            abort("ERROR: Cannot manually manipulate the automatic group 'ungrouped'.")
+          if result.warning_count.zero?
+            puts 'Succeeded.'
+          else
+            puts 'Succeeded, with warnings.'
           end
+        end
 
-          # Convenience
-          db = Moose::Inventory::DB
-          fmt = Moose::Inventory::Cli::Formatter
+        private
+
+        def add_hosts_to_group(name, hosts)
+          context = Moose::Inventory::InventoryContext.new(db: db)
+          operation = Moose::Inventory::Operations::AddAssociations.new(context: context)
 
-          # Transaction
-          warn_count = 0
           begin
-            db.transaction do # Transaction start
+            db.transaction do
               puts "Associate group '#{name}' with host(s) '#{hosts.join(',')}':"
-              # Get the target group
-              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'
-
-              # Associate group with the hosts
-              ungrouped = db.models[:group].find_or_create(name: 'ungrouped')
-              hosts_ds = group.hosts_dataset
-              hosts.each do |h|
-                fmt.puts 2, "- add association {group:#{name} <-> host:#{h}}..."
-
-                # Check against existing associations
-                unless hosts_ds[name: h].nil?
-                  warn_count += 1
-                  fmt.warn "Association {group:#{name} <-> host:#{h}} already"\
-                    " exists, skipping.\n"
-                  fmt.puts 4, '- already exists, skipping.'
-                  fmt.puts 4, '- OK'
-                  next
-                end
-
-                # Add new association
-                host = db.models[:host].find(name: h)
-                if host.nil?
-                  warn_count += 1
-                  fmt.warn "Host '#{h}' does not exist and will be created.\n"
-                  fmt.puts 4, '- host does not exist, creating now...'
-                  host = db.models[:host].create(name: h)
-                  fmt.puts 6, '- OK'
-                end
-
-                group.add_host(host)
-                fmt.puts 4, '- OK'
-
-                # Remove the host from the ungrouped group, if necessary
-                next if host.groups_dataset[name: 'ungrouped'].nil?
-                fmt.puts 2, '- remove automatic association '\
-                  "{group:ungrouped <-> host:#{h}}..."
-                host.remove_group(ungrouped)
-                fmt.puts 4, '- OK'
-              end
+              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'
-            end # Transaction end
+              return result
+            end
           rescue db.exceptions[:moose] => e
             abort("ERROR: #{e.message}")
           end
-          if warn_count == 0
-            puts 'Succeeded.'
+        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
-            puts 'Succeeded, with warnings.'
+            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
         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,84 +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'
         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")
-          end
+        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"
+          )
 
-          # 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
+          result = remove_groups(names)
+
+          if result.warning_count.zero?
             puts 'Succeeded.'
           else
             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
     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,114 @@ 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
+        def rmchild(*argv)
+          abort_if_missing_args(argv, 2, '2 or more')
+
+          pname = argv[0].downcase
+          cnames = normalize_names(argv.slice(1, argv.length - 1))
+
+          abort_if_automatic_group([pname] + cnames)
 
-          # Arguments
-          pname = args[0].downcase
-          cnames = args.slice(1, args.length - 1).uniq.map(&:downcase)
+          result = remove_children_from_group(pname, cnames)
 
-          # Sanity
-          if pname == 'ungrouped' || cnames.include?('ungrouped')
-            abort("ERROR: Cannot manually manipulate the automatic group 'ungrouped'.")
+          if result.warning_count.zero?
+            puts 'Succeeded.'
+          else
+            puts 'Succeeded, with warnings.'
           end
+        end
 
-          # Convenience
-          db = Moose::Inventory::DB
-          fmt = Moose::Inventory::Cli::Formatter
+        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)
 
-          # 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
@@ -10,75 +14,79 @@ 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
+        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])
+
+          result = remove_hosts_from_group(name, hosts)
 
-          # Sanity
-          if name == 'ungrouped'
-            abort("ERROR: Cannot manually manipulate the automatic group 'ungrouped'.")
+          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)
-              abort("ERROR: The group '#{name}' does not exist.") if group.nil?
-              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|
-                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
-                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
+              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