moose-inventory 2.0 → 2.1.1

data/lib/moose_inventory/cli/host_rmvar.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/remove_variables'
 
 module Moose
   module Inventory
@@ -12,56 +14,40 @@ module Moose
       class Host
         #==========================
         desc 'rmvar', 'Remove a variable from the host'
-        # rubocop:disable Metrics/LineLength
-        def rmvar(*args) # rubocop:disable Metrics/AbcSize
-          # rubocop:enableMetrics/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 :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)
+          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!("host rmvar #{name} #{vars.join(',')}")
+          operation = build_operation(Moose::Inventory::Operations::RemoveVariables,
+                                      entity_type: :host,
+                                      emitter: machine_plan_emitter(host_rmvar_emitter(name, vars)))
 
-          # Transaction
-          db.transaction do # Transaction start
-            puts "Remove variable(s) '#{vars.join(',')}' from host '#{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: 'host rmvar')
 
-            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'
+          record_audit({ command: 'host rmvar', action: 'remove_variable', entity_type: 'host',
+                         entity_names: name }, result: result, dry_run: options[:dry_run])
+          print_success_summary
+        end
 
-            hostvars_ds = host.hostvars_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
-              hostvar = hostvars_ds[name: vararray[0]]
-              unless hostvar.nil?
-                # remove the association
-                host.remove_hostvar(hostvar)
-                hostvar.destroy
-              end
-              fmt.puts 4, '- OK'
-            end
-            fmt.puts 2, '- all OK'
-          end # Transaction end
-          puts 'Succeeded.'
+        def host_rmvar_emitter(name, vars)
+          variable_operation_emitter(
+            action: :remove,
+            entity_label: 'host',
+            entity_name: name,
+            variables_label: vars.join(',')
+          )
         end
       end
     end

data/lib/moose_inventory/cli/host_tags.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Moose
+  module Inventory
+    module Cli
+      class Host
+        desc 'addtag HOST TAG_1 [TAG_2 ...]', 'Add metadata tags to a host'
+        def addtag(*args)
+          abort_if_missing_args(args, 2, '2 or more')
+
+          add_tags('host', args[0].downcase, args.slice(1, args.length - 1))
+        end
+
+        desc 'rmtag HOST TAG_1 [TAG_2 ...]', 'Remove metadata tags from a host'
+        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!("host rmtag #{args[0].downcase} #{args.slice(1, args.length - 1).join(',')}")
+
+          remove_tags('host', args[0].downcase, args.slice(1, args.length - 1))
+        end
+
+        desc 'listtags HOST', 'List metadata tags for a host'
+        option :format, type: :string, desc: 'Emit tags as yaml|json|pjson'
+        def listtags(*args)
+          abort_if_missing_args(args, 1, '1')
+
+          list_tags('host', args[0].downcase)
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/cli/listvars_support.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Moose
+  module Inventory
+    module Cli
+      # Shared argument and warning helpers for host/group listvars commands.
+      module ListvarsSupport
+        private
+
+        def validate_listvars_args(args)
+          if ansible_mode?
+            abort_if_wrong_ansible_listvars_arg_count(args, 1)
+          else
+            abort_if_missing_args(args, 1, '1 or more')
+          end
+        end
+
+        def warn_if_missing_ansible_listvars_entity(entity_type, name)
+          return unless ansible_mode?
+          return unless missing_listvars_entity?(entity_type, name)
+
+          fmt.warn missing_ansible_listvars_warning(entity_type, name)
+        end
+
+        def abort_if_wrong_ansible_listvars_arg_count(args, expected)
+          return if args.length == expected
+
+          abort("ERROR: Wrong number of arguments for Ansible mode, #{args.length} for #{expected}.")
+        end
+
+        def missing_listvars_entity?(entity_type, name)
+          case entity_type
+          when :host
+            inventory_context.find_host(name).nil?
+          when :group
+            inventory_context.find_group(name).nil?
+          else
+            raise ArgumentError, "Unsupported listvars entity type: #{entity_type.inspect}"
+          end
+        end
+
+        def missing_ansible_listvars_warning(entity_type, name)
+          case entity_type
+          when :host
+            "The host #{name} does not exist.\n"
+          when :group
+            "The Group #{name} does not exist."
+          else
+            raise ArgumentError, "Unsupported listvars entity type: #{entity_type.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/cli/plan_rendering.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Moose
+  module Inventory
+    module Cli
+      # Shared machine-readable dry-run plan rendering helpers.
+      module PlanRendering
+        private
+
+        def machine_plan_output_requested?
+          respond_to?(:options) && !options[:plan_format].nil?
+        end
+
+        def validate_machine_plan_request!
+          abort('ERROR: --plan-format requires --dry-run.') if machine_plan_output_requested? && !options[:dry_run]
+        end
+
+        def machine_plan_emitter(emitter)
+          machine_plan_output_requested? ? nil : emitter
+        end
+
+        def machine_plan_output_rendered?(result, command:)
+          return false unless machine_plan_output_requested?
+
+          fmt.dump(
+            {
+              command: command,
+              dry_run: true,
+              changes_applied: false,
+              events: result.events.map { |event| serialize_plan_event(event) }
+            },
+            options[:plan_format].downcase
+          )
+          true
+        end
+
+        def serialize_plan_event(event)
+          {
+            type: event.type.to_s,
+            payload: stringify_plan_payload(event.payload)
+          }
+        end
+
+        def stringify_plan_payload(payload)
+          payload.to_h.transform_keys(&:to_s)
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/cli/relation_transaction_support.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Moose
+  module Inventory
+    module Cli
+      # Shared transaction/fetch helpers for host/group relation commands.
+      module RelationTransactionSupport
+        private
+
+        def fetch_existing_group_or_abort(name)
+          fmt.puts 2, "- retrieve group '#{name}'..." unless machine_plan_output_requested?
+          group = inventory_context.find_group(name)
+          abort("ERROR: The group '#{name}' does not exist.") if group.nil?
+
+          fmt.puts 4, '- OK' unless machine_plan_output_requested?
+          group
+        end
+
+        def fetch_existing_host_or_raise(name)
+          fmt.puts 2, "- Retrieve host '#{name}'..." unless machine_plan_output_requested?
+          host = inventory_context.find_host(name)
+          raise db.exceptions[:moose], "The host '#{name}' was not found in the database." if host.nil?
+
+          fmt.puts 4, '- OK' unless machine_plan_output_requested?
+          host
+        end
+
+        def run_group_relation_transaction(heading:, on_error: nil, &)
+          run_relation_transaction(heading: heading, all_ok_message: '- all OK', on_error: on_error, &)
+        end
+
+        def run_host_relation_transaction(heading:, on_error: nil, &)
+          run_relation_transaction(heading: heading, all_ok_message: '- All OK', on_error: on_error, &)
+        end
+
+        def run_relation_transaction(heading:, all_ok_message:, on_error: nil)
+          result = nil
+          db.transaction do
+            puts heading unless machine_plan_output_requested?
+            result = yield
+            fmt.puts 2, all_ok_message unless machine_plan_output_requested?
+          end
+          result
+        rescue db.exceptions[:moose] => e
+          message = on_error ? on_error.call(e) : e.message
+          abort("ERROR: #{message}")
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/cli/tag_support.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Moose
+  module Inventory
+    module Cli
+      # Shared host/group metadata tag commands.
+      module TagSupport
+        private
+
+        def add_tags(entity_type, entity_name, tag_names)
+          entity = fetch_tag_entity(entity_type, entity_name)
+          normalized = normalize_tags(tag_names)
+          changed = []
+
+          db.transaction do
+            normalized.each do |tag_name|
+              tag = inventory_context.find_or_create_tag(tag_name)
+              next unless entity.tags_dataset[name: tag_name].nil?
+
+              entity.add_tag(tag)
+              changed << tag_name
+            end
+          end
+
+          result = tag_result(events: changed.map { |tag| tag_event(:tag_added, entity_type, entity_name, tag) })
+          record_tag_audit(command: 'addtag', action: 'add_tag', entity_type: entity_type,
+                           entity_name: entity_name, result: result, changed: changed)
+          puts "Added #{entity_type} tag(s) to '#{entity_name}': #{changed.join(', ')}."
+        end
+
+        def remove_tags(entity_type, entity_name, tag_names)
+          entity = fetch_tag_entity(entity_type, entity_name)
+          normalized = normalize_tags(tag_names)
+          changed = []
+
+          db.transaction do
+            normalized.each do |tag_name|
+              tag = entity.tags_dataset[name: tag_name]
+              next if tag.nil?
+
+              entity.remove_tag(tag)
+              changed << tag_name
+            end
+          end
+
+          result = tag_result(events: changed.map { |tag| tag_event(:tag_removed, entity_type, entity_name, tag) })
+          record_tag_audit(command: 'rmtag', action: 'remove_tag', entity_type: entity_type,
+                           entity_name: entity_name, result: result, changed: changed)
+          puts "Removed #{entity_type} tag(s) from '#{entity_name}': #{changed.join(', ')}."
+        end
+
+        def list_tags(entity_type, entity_name)
+          entity = fetch_tag_entity(entity_type, entity_name)
+          tags = entity.tags_dataset.order(:name).map(:name)
+
+          if options[:format]
+            fmt.dump({ entity_type => entity_name, tags: tags }, options[:format].downcase)
+          elsif tags.empty?
+            puts "#{entity_type.capitalize} '#{entity_name}' has no tags."
+          else
+            puts "#{entity_type.capitalize} '#{entity_name}' tags: #{tags.join(', ')}"
+          end
+        end
+
+        def fetch_tag_entity(entity_type, entity_name)
+          entity = inventory_context.public_send("find_#{entity_type}", entity_name)
+          abort("ERROR: The #{entity_type} '#{entity_name}' does not exist.") if entity.nil?
+
+          entity
+        end
+
+        def normalize_tags(values)
+          inventory_context.normalize_tag_names(values)
+        end
+
+        def tag_result(events:)
+          Moose::Inventory::Operations::OperationEventSupport::Result.new(events: events, warning_count: 0)
+        end
+
+        def tag_event(type, entity_type, entity_name, tag_name)
+          Moose::Inventory::Operations::OperationEventSupport::Event.new(
+            type: type,
+            payload: { entity_type: entity_type, entity_name: entity_name, tag: tag_name }
+          )
+        end
+
+        def record_tag_audit(metadata)
+          return if metadata.fetch(:changed).empty?
+
+          record_audit({ command: "#{metadata.fetch(:entity_type)} #{metadata.fetch(:command)}",
+                         action: metadata.fetch(:action), entity_type: metadata.fetch(:entity_type),
+                         entity_names: metadata.fetch(:entity_name) }, result: metadata.fetch(:result))
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/cli/variable_rendering.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Moose
+  module Inventory
+    module Cli
+      # Shared rendering helpers for variable add/remove commands.
+      module VariableRendering
+        private
+
+        def variable_operation_emitter(action:, entity_label:, entity_name:, variables_label:)
+          lambda do |event|
+            render_variable_event(
+              event,
+              action: action,
+              entity_label: entity_label,
+              entity_name: entity_name,
+              variables_label: variables_label
+            )
+          end
+        end
+
+        def render_variable_event(event, action:, entity_label:, entity_name:, variables_label:)
+          if event.type == :entity_started
+            return puts(variable_operation_heading(action:, entity_label:, entity_name:,
+                                                   variables_label:))
+          end
+          return render_variable_change(event, entity_label) if variable_change_event?(event.type)
+          return puts 'Dry run complete. No changes applied.' if event.type == :dry_run_summary
+
+          render_variable_status(event)
+        end
+
+        def variable_operation_heading(action:, entity_label:, entity_name:, variables_label:)
+          return "Add variables '#{variables_label}' to #{entity_label} '#{entity_name}':" if action == :add
+
+          "Remove variable(s) '#{variables_label}' from #{entity_label} '#{entity_name}':"
+        end
+
+        def variable_change_event?(type)
+          %i[retrieving_entity adding_variable removing_variable updating_existing_variable].include?(type)
+        end
+
+        def render_variable_change(event, entity_label)
+          case event.type
+          when :retrieving_entity
+            fmt.puts 2, "- retrieve #{entity_label} '#{event.payload[:name]}'..."
+          when :adding_variable
+            fmt.puts 2, "- add variable '#{event.payload[:variable]}'..."
+          when :removing_variable
+            fmt.puts 2, "- remove variable '#{event.payload[:variable]}'..."
+          when :updating_existing_variable
+            fmt.puts 4, '- already exists, applying as an update...'
+          end
+        end
+
+        def render_variable_status(event)
+          case event.type
+          when :entity_complete
+            fmt.puts 2, '- all OK'
+          when :ok
+            fmt.puts event.payload[:indent], '- OK'
+          end
+        end
+      end
+    end
+  end
+end