moose-inventory 2.0 → 2.1

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

data/lib/moose_inventory/cli/helpers.rb

@@ -1,11 +1,31 @@
 # frozen_string_literal: true
 
+require_relative '../inventory_context'
+require_relative 'audit_recording'
+require_relative 'association_rendering'
+require_relative 'child_relation_rendering'
+require_relative 'factory'
+require_relative 'listvars_support'
+require_relative 'plan_rendering'
+require_relative 'relation_transaction_support'
+require_relative 'tag_support'
+require_relative 'variable_rendering'
+
 module Moose
   module Inventory
     module Cli
       ##
       # Shared helpers for Thor command classes.
       module Helpers
+        include Moose::Inventory::Cli::AssociationRendering
+        include Moose::Inventory::Cli::AuditRecording
+        include Moose::Inventory::Cli::ChildRelationRendering
+        include Moose::Inventory::Cli::ListvarsSupport
+        include Moose::Inventory::Cli::PlanRendering
+        include Moose::Inventory::Cli::RelationTransactionSupport
+        include Moose::Inventory::Cli::TagSupport
+        include Moose::Inventory::Cli::VariableRendering
+
         AUTOMATIC_GROUP = 'ungrouped'
 
         private
@@ -14,10 +34,38 @@ module Moose
           Moose::Inventory::DB
         end
 
+        def inventory_context
+          @inventory_context ||= Moose::Inventory::InventoryContext.new(db: db)
+        end
+
+        def cli_factory
+          @cli_factory ||= Moose::Inventory::Cli::Factory.new(context: inventory_context)
+        end
+
+        def build_operation(operation_class, **)
+          cli_factory.operation(operation_class, **)
+        end
+
+        def inventory_query
+          cli_factory.query_inventory
+        end
+
         def fmt
           Moose::Inventory::Cli::Formatter
         end
 
+        def runtime_options
+          Moose::Inventory::Config.runtime_options
+        end
+
+        def output_format
+          runtime_options.output_format
+        end
+
+        def ansible_mode?
+          runtime_options.ansible?
+        end
+
         def normalize_names(values)
           values.uniq.map(&:downcase)
         end
@@ -38,12 +86,31 @@ module Moose
           abort(message || "ERROR: Cannot manually manipulate the automatic group '#{AUTOMATIC_GROUP}'.")
         end
 
+        def confirm_destructive_action!(description)
+          return if options[:dry_run] || options[:yes]
+
+          abort("ERROR: #{description} is destructive. Re-run with --yes to confirm, or use --dry-run to preview.")
+        end
+
         def association_exists?(dataset, name)
           !dataset.nil? && !dataset[name: name].nil?
         end
 
+        def exception_to_s(error)
+          error.to_s
+        end
+
+        def print_warning_summary(result, success_message: 'Succeeded.', warning_message: 'Succeeded, with warnings.')
+          warning_count = result.respond_to?(:warning_count) ? result.warning_count : 0
+          print_success_summary(warning_count.zero? ? success_message : warning_message)
+        end
+
+        def print_success_summary(message = 'Succeeded.')
+          puts message
+        end
+
         def automatic_group
-          db.models[:group].find_or_create(name: AUTOMATIC_GROUP)
+          inventory_context.automatic_group
         end
 
         def remove_automatic_group_from_host(host, indent:, message:)

data/lib/moose_inventory/cli/host.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require 'thor'
 require 'json'
 
-require_relative './formatter.rb'
-require_relative './helpers.rb'
-require_relative '../db/exceptions.rb'
+require_relative 'formatter'
+require_relative 'helpers'
+require_relative '../db/exceptions'
 
 module Moose
   module Inventory
@@ -22,6 +24,7 @@ module Moose
         require_relative 'host_addvar'
         require_relative 'host_listvars'
         require_relative 'host_rmvar'
+        require_relative 'host_tags'
       end
     end
   end

data/lib/moose_inventory/cli/host_add.rb

@@ -15,12 +15,28 @@ module Moose
       ##
       # Class implementing the "host" methods of the CLI
       class Host
+        ADD_HOST_EVENT_RENDERERS = {
+          host_started: :render_add_host_started,
+          creating_host: :render_add_host_creation,
+          host_exists: :render_add_host_exists_warning,
+          ok: :render_add_host_ok,
+          adding_association: :render_add_host_association,
+          group_missing_created: :render_add_host_missing_group_warning,
+          association_exists: :render_add_host_association_exists_warning,
+          adding_automatic_group: :render_add_host_automatic_group,
+          host_complete: :render_add_host_complete,
+          dry_run_summary: :render_dry_run_summary
+        }.freeze
+
         #==========================
         desc 'add HOSTNAME_1 [HOSTNAME_2 ...]',
              'Add a hosts HOSTNAME_n to the inventory'
         option :groups
+        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!
 
           # Arguments
           names = normalize_names(argv)
@@ -32,11 +48,14 @@ module Moose
           # Sanity
           abort_if_automatic_group(groups)
 
-          result = Moose::Inventory::Operations::AddHosts
-                   .new(context: Moose::Inventory::InventoryContext.new(db: db))
-                   .call(names: names, groups: groups)
+          result = build_operation(Moose::Inventory::Operations::AddHosts)
+                   .call(names: names, groups: groups, dry_run: options[:dry_run])
+          return if machine_plan_output_rendered?(result, command: 'host add')
+
+          record_audit({ command: 'host add', action: 'add', entity_type: 'host',
+                         entity_names: names }, result: result, dry_run: options[:dry_run])
           render_add_hosts_events(result.events)
-          puts 'Succeeded'
+          print_warning_summary(result, success_message: 'Succeeded', warning_message: 'Succeeded')
         end
 
         private
@@ -46,31 +65,52 @@ module Moose
           events.each { |event| render_add_hosts_event(event) }
         end
 
-        def render_add_hosts_event(event) # rubocop:disable Metrics/CyclomaticComplexity
-          payload = event.payload
-          case event.type
-          when :host_started
-            puts "Add host '#{payload[:name]}':"
-          when :creating_host
-            fmt.puts 2, "- Creating host '#{payload[:name]}'..."
-          when :host_exists
-            fmt.warn "The host '#{payload[:name]}' already exists, skipping creation.\n"
-          when :ok
-            fmt.puts payload[:indent], '- OK'
-          when :adding_association
-            fmt.puts 2, "- Adding association {host:#{payload[:host]} <-> group:#{payload[:group]}}..."
-          when :group_missing_created
-            fmt.warn "The group '#{payload[:name]}' doesn't exist, but will be created.\n"
-          when :association_exists
-            fmt.warn(
-              "Association {host:#{payload[:host]} <-> group:#{payload[:group]}} " \
-              "already exists, skipping creation.\n"
-            )
-          when :adding_automatic_group
-            fmt.puts 2, "- Adding automatic association {host:#{payload[:host]} <-> group:#{payload[:group]}}..."
-          when :host_complete
-            fmt.puts 2, '- All OK'
-          end
+        def render_add_hosts_event(event)
+          renderer = ADD_HOST_EVENT_RENDERERS[event.type]
+          send(renderer, event.payload) unless renderer.nil?
+        end
+
+        def render_add_host_started(payload)
+          puts "Add host '#{payload[:name]}':"
+        end
+
+        def render_add_host_creation(payload)
+          fmt.puts 2, "- Creating host '#{payload[:name]}'..."
+        end
+
+        def render_add_host_exists_warning(payload)
+          fmt.warn "The host '#{payload[:name]}' already exists, skipping creation.\n"
+        end
+
+        def render_add_host_ok(payload)
+          fmt.puts payload[:indent], '- OK'
+        end
+
+        def render_add_host_association(payload)
+          fmt.puts 2, "- Adding association {host:#{payload[:host]} <-> group:#{payload[:group]}}..."
+        end
+
+        def render_add_host_missing_group_warning(payload)
+          fmt.warn "The group '#{payload[:name]}' doesn't exist, but will be created.\n"
+        end
+
+        def render_add_host_association_exists_warning(payload)
+          fmt.warn(
+            "Association {host:#{payload[:host]} <-> group:#{payload[:group]}} " \
+            "already exists, skipping creation.\n"
+          )
+        end
+
+        def render_add_host_automatic_group(payload)
+          fmt.puts 2, "- Adding automatic association {host:#{payload[:host]} <-> group:#{payload[:group]}}..."
+        end
+
+        def render_add_host_complete(_payload)
+          fmt.puts 2, '- All OK'
+        end
+
+        def render_dry_run_summary(_payload)
+          puts 'Dry run complete. No changes applied.'
         end
       end
     end

data/lib/moose_inventory/cli/host_addgroup.rb

@@ -16,80 +16,44 @@ module Moose
       class Host
         desc 'addgroup HOSTNAME GROUPNAME [GROUPNAME ...]',
              'Associate the host with a group'
+        option :dry_run, type: :boolean
+        option :plan_format, type: :string, desc: 'Emit dry-run plan events as yaml|json|pjson'
         def addgroup(*args)
           abort_if_missing_args(args, 2, '2 or more')
+          validate_machine_plan_request!
 
           name = args[0].downcase
           groups = normalize_names(args.slice(1, args.length - 1))
 
           abort_if_automatic_group(groups)
 
-          context = Moose::Inventory::InventoryContext.new(db: db)
-          operation = Moose::Inventory::Operations::AddAssociations.new(context: context)
-
-          db.transaction do
-            puts "Associate host '#{name}' with groups '#{groups.join(',')}':"
-            host = fetch_existing_host_for_addgroup(context, name)
-            render_host_addgroup_events(
-              operation.host_to_groups(host: host, host_name: name, group_names: groups).events
-            )
-            fmt.puts 2, '- All OK'
+          result = add_groups_to_host(name, groups)
+          unless machine_plan_output_rendered?(
+            result, command: 'host addgroup'
+          )
+            record_audit({ command: 'host addgroup', action: 'associate', entity_type: 'host',
+                           entity_names: name }, result: result, dry_run: options[:dry_run])
+            print_warning_summary(result, success_message: 'Succeeded',
+                                          warning_message: 'Succeeded')
           end
-
-          puts 'Succeeded'
         end
 
         private
 
-        def fetch_existing_host_for_addgroup(context, name)
-          fmt.puts 2, "- Retrieve host '#{name}'..."
-          host = context.find_host(name)
-          raise db.exceptions[:moose], "The host '#{name}' was not found in the database." if host.nil?
-
-          fmt.puts 4, '- OK'
-          host
-        end
-
-        def render_host_addgroup_events(events)
-          events.each { |event| render_host_addgroup_event(event) }
-        end
-
-        def render_host_addgroup_event(event)
-          payload = event.payload
-
-          return render_host_addgroup_warning(event.type, payload) if host_addgroup_warning?(event.type)
-          return render_host_addgroup_status(payload) if event.type == :already_exists_skipping
-
-          render_host_addgroup_output(event.type, payload)
-        end
-
-        def host_addgroup_warning?(type)
-          %i[host_group_association_exists group_missing_created].include?(type)
-        end
-
-        def render_host_addgroup_warning(type, payload)
-          if type == :host_group_association_exists
-            fmt.warn "Association {host:#{payload[:host]} <-> group:#{payload[:group]}} already exists, skipping."
-          else
-            fmt.warn "Group '#{payload[:name]}' does not exist and will be created."
+        def add_groups_to_host(name, groups)
+          operation = build_operation(Moose::Inventory::Operations::AddAssociations)
+          run_host_relation_transaction(heading: "Associate host '#{name}' with groups '#{groups.join(',')}':") do
+            host = fetch_existing_host_or_raise(name)
+            result = operation.host_to_groups(host: host, host_name: name, group_names: groups,
+                                              dry_run: options[:dry_run])
+            render_host_addgroup_events(result.events) unless machine_plan_output_requested?
+            result
           end
         end
 
-        def render_host_addgroup_status(payload)
-          fmt.puts payload[:indent], '- Already exists, skipping.'
-        end
-
-        def render_host_addgroup_output(type, payload)
-          case type
-          when :adding_host_group_association
-            fmt.puts 2, "- Add association {host:#{payload[:host]} <-> group:#{payload[:group]}}..."
-          when :group_creating_now
-            fmt.puts 4, '- Group does not exist, creating now...'
-          when :removing_automatic_group
-            fmt.puts 2, "- Remove automatic association {host:#{payload[:host]} <-> group:ungrouped}..."
-          when :ok
-            fmt.puts payload[:indent], '- OK'
-          end
+        def render_host_addgroup_events(events)
+          emitter = host_group_association_addition_emitter(perspective: :host)
+          events.each { |event| emitter.call(event) }
         end
       end
     end

data/lib/moose_inventory/cli/host_addvar.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/add_variables'
 
 module Moose
   module Inventory
@@ -12,64 +14,38 @@ module Moose
       class Host
         #==========================
         desc 'addvar', 'Add a variable to the host'
-        # rubocop:disable Metrics/LineLength
-        def addvar(*args) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
-          # rubocop:enable Metrics/LineLength
-          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
+        option :dry_run, type: :boolean
+        option :plan_format, type: :string, desc: 'Emit dry-run plan events as yaml|json|pjson'
+        def addvar(*args)
+          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: :host,
+                                      emitter: machine_plan_emitter(host_addvar_emitter(name, vars)))
 
-          # Transaction
-          db.transaction do # Transaction start
-            puts "Add variables '#{vars.join(',')}' to host '#{name}':"
+          result = db.transaction do
+            operation.call(name: name, vars: vars, dry_run: options[:dry_run])
+          end
 
-            fmt.puts 2, "- retrieve host '#{name}'..."
-            host = db.models[:host].find(name: name)
-            if host.nil?
-              fail db.exceptions[:moose],
-                   "The host '#{name}' does not exist."
-            end
-            fmt.puts 4, '- OK'
+          return if machine_plan_output_rendered?(result, command: 'host addvar')
 
-            hostvars_ds = host.hostvars_dataset
-            vars.each do |v|
-              fmt.puts 2, "- add variable '#{v}'..."
-              vararray = v.split('=')
-              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: 'host addvar', action: 'add_variable', entity_type: 'host',
+                         entity_names: name }, result: result, dry_run: options[:dry_run])
+          print_success_summary
+        end
 
-              # Check against existing associations
-              hostvar = hostvars_ds[name: vararray[0]]
-              if !hostvar.nil?
-                unless hostvar[:value] == vararray[1]
-                  fmt.puts 4, '- already exists, applying as an update...'
-                  update = db.models[:hostvar].find(id: hostvar[:id])
-                  update[:value] = vararray[1]
-                  update.save
-                end
-              else
-                # hostvar doesn't exist, so create and associate
-                hostvar = db.models[:hostvar].create(name: vararray[0],
-                                                     value: vararray[1])
-                host.add_hostvar(hostvar)
-              end
-              fmt.puts 4, '- OK'
-            end
-            fmt.puts 2, '- all OK'
-          end # Transaction end
+        private
 
-          puts 'Succeeded.'
+        def host_addvar_emitter(name, vars)
+          variable_operation_emitter(
+            action: :add,
+            entity_label: 'host',
+            entity_name: name,
+            variables_label: vars.join(',')
+          )
         end
       end
     end

data/lib/moose_inventory/cli/host_get.rb

@@ -1,54 +1,26 @@
+# 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
     module Cli
-      ##
       # Class implementing the "host get" method of the CLI
       class Host
         require_relative 'host_add'
 
-        #==========================
         desc 'get HOST_1 [HOST_2 ...]',
              'Get hosts HOST_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|
-            host = db.models[:host].find(name: name)
-
-            next if host.nil?
-            groups = host.groups_dataset.map(:name)
-
-            hostvars = {}
-            host.hostvars_dataset.each do |hv|
-              hostvars[hv[:name].to_sym] = hv[:value]
-            end
-
-            results[host[:name].to_sym] = {}
-            results[host[:name].to_sym][:groups] = groups unless groups.empty?
-            unless hostvars.empty?
-              results[host[:name].to_sym][:hostvars] = hostvars
-            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)
+          results = inventory_query.get_hosts(names: names)
+          fmt.dump(results, output_format)
         end
       end
     end