moose-inventory 1.0.9 → 2.1

data/lib/moose_inventory/cli/group_add.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_groups'
 
 module Moose
   module Inventory
@@ -10,84 +14,98 @@ module Moose
         #==========================
         desc 'add NAME', 'Add a group NAME to the inventory'
         option :hosts
-        # rubocop:disable Metrics/LineLength
-        def add(*argv) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
-          # rubocop:enable Metrics/LineLength
-          if argv.empty?
-            abort("ERROR: Wrong number of arguments, #{argv.length} for 1 or more.")
+        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])
+
+          abort_if_automatic_group(
+            names,
+            "ERROR: Cannot manually manipulate the automatic group 'ungrouped'\n"
+          )
+
+          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')
+
+          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
+
+        def render_add_groups_events(events)
+          events.each { |event| render_add_groups_event(event) }
+        end
+
+        def render_add_groups_event(event)
+          payload = event.payload
+
+          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
+
+        def puts_event?(type)
+          type == :group_started
+        end
+
+        def warn_event?(type)
+          %i[group_exists host_missing_created association_exists].include?(type)
+        end
+
+        def render_add_groups_event_puts(type, payload)
+          puts "Add group '#{payload[:name]}':" if type == :group_started
+        end
+
+        def render_add_groups_event_warn(type, payload)
+          case type
+          when :group_exists
+            fmt.warn "Group '#{payload[:name]}' already exists, skipping creation.\n"
+          when :host_missing_created
+            fmt.warn "Host '#{payload[:name]}' doesn't exist, but will be created.\n"
+          when :association_exists
+            fmt.warn(
+              "Association {group:#{payload[:group]} <-> host:#{payload[:host]}} " \
+              "already exists, skipping creation.\n"
+            )
           end
+        end
 
-          # Arguments
-          names = argv.uniq.map(&:downcase)
-          options[:hosts] = '' if options[:hosts].nil?
-          hosts = options[:hosts].downcase.split(',').uniq
+        def render_add_groups_event_fmt(type, payload)
+          return render_add_groups_event_status(type, payload) if status_event?(type)
 
-          # sanity
-          if names.include?('ungrouped')
-            abort("ERROR: Cannot manually manipulate the automatic group 'ungrouped'\n")
+          case type
+          when :creating_group
+            fmt.puts 2, '- create group...'
+          when :adding_association
+            fmt.puts 2, "- add association {group:#{payload[:group]} <-> host:#{payload[:host]}}..."
+          when :host_creating_now
+            fmt.puts 4, '- host doesn\'t exist, creating now...'
+          when :removing_automatic_group
+            fmt.puts 2, "- remove automatic association {group:ungrouped <-> host:#{payload[:host]}}..."
+          when :group_complete
+            fmt.puts 2, '- all OK'
           end
+        end
+
+        def status_event?(type)
+          %i[already_exists_skipping ok].include?(type)
+        end
 
-          # Convenience
-          db = Moose::Inventory::DB
-          fmt = Moose::Inventory::Cli::Formatter
-
-          # Transaction
-          warn_count = 0
-          db.transaction do # Transaction start
-            names.each do |name|
-              # Add the group
-              puts "Add group '#{name}':"
-              group = db.models[:group].find(name: name)
-              hosts_ds = nil
-              fmt.puts 2, '- create group...'
-              if group.nil?
-                group = db.models[:group].create(name: name)
-                fmt.puts 4, '- OK'
-              else
-                warn_count += 1
-                fmt.warn "Group '#{name}' already exists, skipping creation.\n"
-                fmt.puts 4, '- already exists, skipping.'
-                hosts_ds = group.hosts_dataset
-                fmt.puts 4, '- OK'
-              end
-
-              # Associate with hosts
-              hosts.each do |h|
-                next if h.nil? || h.empty?
-                fmt.puts 2, "- add association {group:#{name} <-> host:#{h}}..."
-                host = db.models[:host].find(name: h)
-                if host.nil?
-                  warn_count += 1
-                  fmt.warn "Host '#{h}' doesn't exist, but will be created.\n"
-                  fmt.puts 4, "- host doesn't exist, creating now..."
-                  host = db.models[:host].create(name: h)
-                  fmt.puts 6, '- OK'
-                end
-                if !hosts_ds.nil? && !hosts_ds[name: h].nil?
-                  warn_count += 1
-                  fmt.warn "Association {group:#{name} <-> host:#{h}}"\
-                    " already exists, skipping creation.\n"
-                  fmt.puts 4, '- already exists, skipping.'
-                else
-                  group.add_host(host)
-                end
-                fmt.puts 4, '- OK'
-
-                # Handle the host's automatic 'ungrouped' group
-                ungrouped = host.groups_dataset[name: 'ungrouped']
-                next if ungrouped.nil?
-                fmt.puts 2, '- remove automatic association {group:ungrouped'\
-                  " <-> host:#{h}}..."
-                host.remove_group(ungrouped) unless ungrouped.nil?
-                fmt.puts 4, '- OK'
-              end
-              fmt.puts 2, '- all OK'
-            end
-          end # Transaction end
-          if warn_count == 0
-            puts 'Succeeded'
+        def render_add_groups_event_status(type, payload)
+          if type == :already_exists_skipping
+            fmt.puts payload[:indent], '- already exists, skipping.'
           else
-            puts 'Succeeded, with warnings.'
+            fmt.puts payload[:indent], '- OK'
           end
         end
       end

data/lib/moose_inventory/cli/group_addchild.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/group_child_relations'
 
 module Moose
   module Inventory
@@ -10,78 +14,49 @@ module Moose
         #==========================
         desc 'addchild PARENTGROUP CHILDGROUP_1 [CHILDGROUP_2 ... ]',
              'Associate one or more child-groups CHILDGROUP_n with PARENTGROUP'
-        def addchild(*_argv)
-          # Sanity check
-          if args.length < 2
-            abort("ERROR: Wrong number of arguments, #{args.length} "\
-              'for 2 or more.')
-          end
-
-          # 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
+        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!
 
-          # Convenience
-          db = Moose::Inventory::DB
-          fmt = Moose::Inventory::Cli::Formatter
+          pname = argv[0].downcase
+          cnames = normalize_names(argv.slice(1, argv.length - 1))
 
-          # Transaction
-          warn_count = 0
-          begin
-            db.transaction do # Transaction start
-              puts "Associate parent group '#{pname}' with 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'
+          abort_if_automatic_group([pname] + cnames)
 
-              # Associate parent group with the child groups
+          result = add_children_to_group(pname, cnames)
+          return if machine_plan_output_rendered?(result, command: 'group addchild')
 
-              groups_ds = pgroup.children_dataset
-              cnames.each do |cname|
-                fmt.puts 2, "- add association {group:#{pname} <-> group:#{cname}}..."
-
-                # Check against existing associations
-                unless groups_ds[name: cname].nil?
-                  warn_count += 1
-                  fmt.warn "Association {group:#{pname} <-> group:#{cname}}}"\
-                    " already exists, skipping.\n"
-                  fmt.puts 4, '- already exists, skipping.'
-                  fmt.puts 4, '- OK'
-                  next
-                 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
 
-                # Add new association
-                cgroup = db.models[:group].find(name: cname)
-                if cgroup.nil?
-                  warn_count += 1
-                  fmt.warn "Group '#{cname}' does not exist and will be created.\n"
-                  fmt.puts 4, '- child group does not exist, creating now...'
-                  cgroup = db.models[:group].create(name: cname)
-                  fmt.puts 6, '- OK'
-                end
-                pgroup.add_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.'
+        private
+
+        def add_children_to_group(parent_name, child_names)
+          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 render_addchild_events(events)
+          emitter = addchild_emitter
+          events.each { |event| emitter.call(event) }
+        end
       end
     end
   end

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,84 +14,42 @@ 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
-
-          # 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
+        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!
 
-          # Convenience
-          db = Moose::Inventory::DB
-          fmt = Moose::Inventory::Cli::Formatter
+          name = args[0].downcase
+          hosts = normalize_names(args.slice(1, args.length - 1))
 
-          # Transaction
-          warn_count = 0
-          begin
-            db.transaction do # Transaction start
-              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'
+          abort_if_automatic_group([name])
 
-              # 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}}..."
+          result = add_hosts_to_group(name, hosts)
+          return if machine_plan_output_rendered?(result, command: 'group addhost')
 
-                # 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
+          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
 
-                group.add_host(host)
-                fmt.puts 4, '- OK'
+        private
 
-                # 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
-              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 add_hosts_to_group(name, hosts)
+          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 render_group_addhost_events(events)
+          emitter = host_group_association_addition_emitter(perspective: :group)
+          events.each { |event| emitter.call(event) }
+        end
       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