moose-inventory 1.0.9 → 2.1

data/lib/moose_inventory/operations/add_hosts.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require_relative 'operation_event_support'
+
+module Moose
+  module Inventory
+    module Operations
+      ##
+      # Adds hosts and their optional group associations.
+      #
+      # The operation mutates inventory state and returns structured events for
+      # the CLI adapter to render. Keeping output out of this class makes the
+      # inventory behavior easier to exercise without binding every domain test
+      # to progress text.
+      class AddHosts
+        AUTOMATIC_GROUP = 'ungrouped'
+        include OperationEventSupport
+
+        def initialize(context:)
+          @context = context
+        end
+
+        def call(names:, groups:, dry_run: false)
+          events = []
+          @dry_run = dry_run
+
+          if dry_run
+            names.each do |name|
+              add_host(name, groups, events)
+            end
+            emit(events, :dry_run_summary)
+            return operation_result(events: events)
+          end
+
+          context.transaction do
+            names.each do |name|
+              add_host(name, groups, events)
+            end
+          end
+          operation_result(events: events)
+        end
+
+        private
+
+        attr_reader :context, :dry_run
+
+        def add_host(name, groups, events)
+          emit(events, :host_started, name: name)
+          host, groups_dataset = create_or_find_host(name, events)
+
+          groups.each do |group_name|
+            add_group_association(host, name, group_name, groups_dataset, events)
+          end
+
+          add_automatic_group_if_needed(host, name, groups, groups_dataset, events)
+          emit(events, :host_complete)
+        end
+
+        def create_or_find_host(name, events)
+          emit(events, :creating_host, name: name)
+          host = context.find_host(name)
+          groups_dataset = nil
+
+          if host.nil?
+            host = context.create_host(name) unless dry_run
+          else
+            emit(events, :host_exists, name: name)
+            groups_dataset = host.groups_dataset
+          end
+
+          emit(events, :ok, indent: 4)
+          [host, groups_dataset]
+        end
+
+        def add_group_association(host, host_name, group_name, groups_dataset, events)
+          return if group_name.nil? || group_name.empty?
+
+          emit(events, :adding_association, host: host_name, group: group_name)
+          group = find_or_create_group(group_name, events)
+
+          if association_exists?(groups_dataset, group_name)
+            emit(events, :association_exists, host: host_name, group: group_name)
+          elsif !dry_run
+            host.add_group(group)
+          end
+
+          emit(events, :ok, indent: 4)
+        end
+
+        def find_or_create_group(name, events)
+          group = context.find_group(name)
+          return group unless group.nil?
+
+          emit(events, :group_missing_created, name: name)
+          context.create_group(name) unless dry_run
+        end
+
+        def add_automatic_group_if_needed(host, host_name, requested_groups, groups_dataset, events)
+          return unless automatic_group_needed?(host, requested_groups, groups_dataset)
+
+          emit(events, :adding_automatic_group, host: host_name, group: AUTOMATIC_GROUP)
+          host.add_group(automatic_group) unless dry_run
+          emit(events, :ok, indent: 4)
+        end
+
+        def automatic_group_needed?(host, requested_groups, groups_dataset)
+          return requested_groups.empty? && (host.nil? || groups_dataset.nil? || groups_dataset.none?) if dry_run
+
+          groups_dataset = host.groups_dataset
+          !groups_dataset.nil? && groups_dataset.none?
+        end
+
+        def automatic_group
+          context.automatic_group
+        end
+
+        def association_exists?(dataset, name)
+          !dataset.nil? && !dataset[name: name].nil?
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/operations/add_variables.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative 'entity_variable_operation_support'
+
+module Moose
+  module Inventory
+    module Operations
+      # Adds host/group variables and updates existing values when needed.
+      class AddVariables
+        include EntityVariableOperationSupport
+
+        def call(name:, vars:, dry_run: false)
+          @events = []
+          @dry_run = dry_run
+
+          emit(:entity_started, name: name)
+          emit(:retrieving_entity, name: name)
+          entity = find_entity(name)
+          raise_missing_entity(name) if entity.nil?
+
+          emit(:ok, indent: 4)
+
+          dataset = entity.public_send("#{entity_type}vars_dataset")
+          vars.each do |variable|
+            add_variable(entity, dataset, variable)
+          end
+
+          emit(:entity_complete)
+          emit(:dry_run_summary) if dry_run
+          operation_result(events: events)
+        ensure
+          @events = nil
+          @dry_run = nil
+        end
+
+        private
+
+        attr_reader :dry_run
+
+        def add_variable(entity, dataset, variable)
+          emit(:adding_variable, variable: variable)
+          key, value = parse_variable(variable)
+
+          existing = dataset[name: key]
+          if existing.nil?
+            unless dry_run
+              record = context.create_variable(entity_type, name: key, value: value)
+              entity.public_send("add_#{entity_type}var", record)
+            end
+          elsif existing[:value] != value
+            emit(:updating_existing_variable)
+            unless dry_run
+              update = context.find_variable(entity_type, existing[:id])
+              update[:value] = value
+              update.save
+            end
+          end
+
+          emit(:ok, indent: 4)
+        end
+
+        def parse_variable(variable)
+          parts = variable.split('=')
+          invalid = variable.start_with?('=') || variable.end_with?('=') || parts.length != 2
+          raise_invalid_variable(variable) if invalid
+
+          parts
+        end
+
+        def raise_invalid_variable(variable)
+          raise context.moose_exception_class,
+                "Incorrect format in '{#{variable}}'. Expected 'key=value'."
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/operations/entity_variable_operation_support.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'operation_event_support'
+
+module Moose
+  module Inventory
+    module Operations
+      module EntityVariableOperationSupport
+        include OperationEventSupport
+
+        def initialize(context:, entity_type:, emitter: nil)
+          @context = context
+          @entity_type = entity_type
+          @emitter = emitter
+        end
+
+        private
+
+        attr_reader :context, :emitter, :entity_type, :events
+
+        def find_entity(name)
+          case entity_type
+          when :host
+            context.find_host(name)
+          when :group
+            context.find_group(name)
+          else
+            raise ArgumentError, "Unsupported entity type: #{entity_type.inspect}"
+          end
+        end
+
+        def raise_missing_entity(name)
+          label = entity_type == :host ? 'host' : 'group'
+          raise context.moose_exception_class, "The #{label} '#{name}' does not exist."
+        end
+
+        def emit(type, payload = {})
+          event = build_event(type, payload)
+          events << event
+          emitter&.call(event)
+          event
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/operations/group_child_relations.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require_relative 'operation_event_support'
+
+require_relative 'group_cleanup'
+
+module Moose
+  module Inventory
+    module Operations
+      class GroupChildRelations
+        include OperationEventSupport
+
+        def initialize(context:)
+          @context = context
+          @cleanup = Moose::Inventory::Operations::GroupCleanup.new(
+            context: context,
+            emitter: method(:emit)
+          )
+        end
+
+        def add_children(parent_group:, parent_name:, child_names:, dry_run: false)
+          events = []
+          warning_count = 0
+          children_dataset = parent_group.children_dataset
+          @dry_run = dry_run
+
+          child_names.each do |child_name|
+            next if child_name.nil? || child_name.empty?
+
+            warning_count += add_child(parent_group, parent_name, child_name, children_dataset, events)
+          end
+
+          emit(events, :dry_run_summary) if dry_run
+
+          operation_result(events: events, warning_count: warning_count)
+        end
+
+        def remove_children(parent_group:, parent_name:, child_names:, delete_orphans: false, dry_run: false)
+          events = []
+          warning_count = 0
+          children_dataset = parent_group.children_dataset
+          @dry_run = dry_run
+          cleanup.dry_run = dry_run
+
+          child_names.each do |child_name|
+            next if child_name.nil? || child_name.empty?
+
+            warning_count += remove_child(
+              {
+                parent_group: parent_group,
+                parent_name: parent_name,
+                child_name: child_name,
+                children_dataset: children_dataset,
+                events: events,
+                delete_orphans: delete_orphans,
+                dry_run: dry_run
+              }
+            )
+          end
+
+          emit(events, :dry_run_summary) if dry_run
+
+          operation_result(events: events, warning_count: warning_count)
+        end
+
+        private
+
+        attr_reader :cleanup, :context, :dry_run
+
+        def add_child(parent_group, parent_name, child_name, children_dataset, events)
+          emit(events, :adding_child_association, parent: parent_name, child: child_name)
+
+          if association_exists?(children_dataset, child_name)
+            emit(events, :child_association_exists, parent: parent_name, child: child_name)
+            emit(events, :already_exists_skipping, indent: 4)
+            emit(events, :ok, indent: 4)
+            return 1
+          end
+
+          child_group = context.find_group(child_name)
+          warning_count = 0
+          if child_group.nil?
+            emit(events, :child_group_missing, name: child_name)
+            emit(events, :child_group_creating_now, name: child_name)
+            child_group = context.create_group(child_name) unless dry_run
+            emit(events, :ok, indent: 6)
+            warning_count = 1
+          end
+
+          parent_group.add_child(child_group) unless dry_run
+          emit(events, :ok, indent: 4)
+          warning_count
+        end
+
+        def remove_child(input)
+          emit(
+            input[:events],
+            :removing_child_association,
+            parent: input[:parent_name],
+            child: input[:child_name]
+          )
+
+          unless association_exists?(input[:children_dataset], input[:child_name])
+            emit(input[:events], :child_association_missing, parent: input[:parent_name], child: input[:child_name])
+            emit(input[:events], :missing_skipping, indent: 4)
+            emit(input[:events], :ok, indent: 4)
+            return 1
+          end
+
+          child_group = context.find_group(input[:child_name])
+          input[:parent_group].remove_child(child_group) unless input[:dry_run]
+          emit(input[:events], :ok, indent: 4)
+          if input[:delete_orphans]
+            cleanup.delete_orphaned_group(child_group, input[:events], ignored_parent: input[:parent_group])
+          end
+          0
+        end
+
+        def association_exists?(dataset, name)
+          !dataset.nil? && !dataset[name: name].nil?
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/operations/group_cleanup.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative 'operation_event_support'
+
+module Moose
+  module Inventory
+    module Operations
+      # Recursively cleans up orphaned groups and their dependent relations.
+      class GroupCleanup
+        include OperationEventSupport
+
+        AUTOMATIC_GROUP = 'ungrouped'
+
+        attr_accessor :dry_run
+
+        def initialize(context:, emitter:)
+          @context = context
+          @emitter = emitter
+          @dry_run = false
+        end
+
+        def delete_orphaned_group(group, events, ignored_parent: nil)
+          return if group.name == AUTOMATIC_GROUP
+          return unless orphaned_after_planned_removal?(group, ignored_parent)
+
+          emit(events, :recursively_delete_orphaned_group, name: group.name)
+          group.children_dataset.each do |child|
+            emit(events, :removing_recursive_child_association, parent: group.name, child: child.name)
+            group.remove_child(child) unless dry_run
+            emit(events, :ok, indent: 6)
+            delete_orphaned_group(child, events, ignored_parent: group)
+          end
+          destroy_group(group, events, indent: 4)
+        end
+
+        def destroy_group(group, events, indent:)
+          group.hosts_dataset.each do |host|
+            next unless host.groups_dataset.one?
+
+            emit(events, :adding_automatic_group_to_host, host: host[:name], indent: indent)
+            host.add_group(context.automatic_group) unless dry_run
+            emit(events, :ok, indent: indent + 2)
+          end
+
+          emit(events, :destroying_group, name: group.name, indent: indent)
+          unless dry_run
+            group.remove_all_groupvars
+            group.remove_all_hosts
+            group.destroy
+          end
+          emit(events, :ok, indent: indent + 2)
+        end
+
+        private
+
+        attr_reader :context, :emitter
+
+        def orphaned_after_planned_removal?(group, ignored_parent)
+          group.parents_dataset.none? do |parent|
+            !ignored_parent || parent.name != ignored_parent.name
+          end
+        end
+
+        def emit(events, type, payload = {})
+          emitter.call(events, type, payload)
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/operations/import_inventory_snapshot.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative 'inventory_snapshot_applier'
+require_relative 'inventory_snapshot_preview'
+require_relative 'inventory_snapshot_validator'
+
+module Moose
+  module Inventory
+    module Operations
+      # Validates and imports a portable inventory snapshot.
+      class ImportInventorySnapshot
+        Result = InventorySnapshotApplier::Result
+
+        def initialize(context:)
+          @context = context
+          @validator = InventorySnapshotValidator.new(context: context)
+          @applier = InventorySnapshotApplier.new(context: context)
+          @previewer = InventorySnapshotPreview.new(context: context)
+        end
+
+        def call(snapshot:)
+          normalized = validator.call(snapshot: snapshot)
+
+          context.transaction do
+            applier.call(snapshot: normalized)
+          end
+        end
+
+        def preview(snapshot:)
+          normalized = validator.call(snapshot: snapshot)
+
+          previewer.call(snapshot: normalized)
+        end
+
+        private
+
+        attr_reader :context, :validator, :applier, :previewer
+      end
+    end
+  end
+end

data/lib/moose_inventory/operations/inventory_doctor.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/ClassLength
+module Moose
+  module Inventory
+    module Operations
+      # Runs read-only inventory health checks for humans and CI.
+      class InventoryDoctor
+        AUTOMATIC_GROUP = 'ungrouped'
+
+        def initialize(context:, config: Moose::Inventory::Config)
+          @context = context
+          @config = config
+        end
+
+        def call
+          issues = []
+          issues.concat(check_database_config)
+          issues.concat(check_plaintext_password_config)
+          issues.concat(check_hosts_only_in_automatic_group)
+          issues.concat(check_orphaned_groups)
+          issues.concat(check_empty_groups)
+          issues.concat(check_duplicateish_names)
+          issues.concat(check_invalid_variables)
+          issues.concat(check_group_cycles)
+
+          {
+            ok: issues.empty?,
+            issue_count: issues.length,
+            issues: issues
+          }
+        end
+
+        private
+
+        attr_reader :context, :config
+
+        def check_database_config
+          settings = config.db_settings
+          return [issue('missing_db_config', 'error', 'Database configuration is missing.')] unless settings.is_a?(Hash)
+          return [] if settings[:adapter].to_s.strip != ''
+
+          [issue('missing_db_adapter', 'error', 'Database adapter is missing from configuration.')]
+        rescue StandardError => e
+          [issue('missing_db_config', 'error', "Database configuration could not be read: #{e.message}")]
+        end
+
+        def check_plaintext_password_config
+          settings = config.db_settings
+          return [] unless settings.is_a?(Hash) && settings.key?(:password)
+
+          [
+            issue('plaintext_password_config', 'warning',
+                  'Database configuration uses plaintext password; prefer password_env.')
+          ]
+        end
+
+        def check_hosts_only_in_automatic_group
+          context.all_hosts.filter_map do |host|
+            groups = host.groups_dataset.map(:name)
+            next unless groups == [AUTOMATIC_GROUP]
+
+            issue('host_only_in_ungrouped', 'warning', "Host '#{host.name}' is only in automatic group 'ungrouped'.",
+                  subject: host.name)
+          end
+        end
+
+        def check_orphaned_groups
+          context.all_groups.filter_map do |group|
+            next if group.name == AUTOMATIC_GROUP
+            next unless group.parents_dataset.empty? && group.hosts_dataset.empty?
+
+            issue('orphaned_group', 'warning', "Group '#{group.name}' has no parents and no hosts.",
+                  subject: group.name)
+          end
+        end
+
+        def check_empty_groups
+          context.all_groups.filter_map do |group|
+            next if group.name == AUTOMATIC_GROUP
+            next unless group.hosts_dataset.empty? && group.children_dataset.empty? && group.groupvars_dataset.empty?
+
+            issue('empty_group', 'warning', "Group '#{group.name}' is empty.", subject: group.name)
+          end
+        end
+
+        def check_duplicateish_names
+          host_issues = duplicateish_issues(context.all_hosts.map(&:name), 'host')
+          group_issues = duplicateish_issues(context.all_groups.map(&:name), 'group')
+          host_issues + group_issues
+        end
+
+        def duplicateish_issues(names, label)
+          names.group_by { |name| normalize_name(name) }.filter_map do |normalized, originals|
+            unique = originals.uniq
+            next if normalized.empty? || unique.length < 2
+
+            issue("duplicateish_#{label}_names", 'warning',
+                  "#{label.capitalize} names look duplicate-ish: #{unique.sort.join(', ')}.", subject: unique.sort)
+          end
+        end
+
+        def normalize_name(name)
+          name.to_s.downcase.gsub(/[^a-z0-9]/, '')
+        end
+
+        def check_invalid_variables
+          host_var_issues = context.all_hosts.flat_map do |host|
+            invalid_variable_issues(host.hostvars_dataset, "host '#{host.name}'")
+          end
+          group_var_issues = context.all_groups.flat_map do |group|
+            invalid_variable_issues(group.groupvars_dataset, "group '#{group.name}'")
+          end
+          host_var_issues + group_var_issues
+        end
+
+        def invalid_variable_issues(dataset, owner)
+          dataset.filter_map do |variable|
+            next unless variable.name.to_s.strip.empty? || variable.value.nil?
+
+            issue('invalid_variable_shape', 'error', "Variable on #{owner} has an empty name or nil value.",
+                  subject: owner)
+          end
+        end
+
+        def check_group_cycles
+          groups = context.all_groups.to_h { |group| [group.name, group.children_dataset.map(:name)] }
+          visiting = {}
+          visited = {}
+          cycles = []
+
+          state = { groups: groups, visiting: visiting, visited: visited, cycles: cycles }
+          groups.each_key do |name|
+            visit_group(name, state, [])
+          end
+
+          cycles.uniq.map do |cycle|
+            issue('circular_group_relationship', 'error', "Group hierarchy contains a cycle: #{cycle.join(' -> ')}.",
+                  subject: cycle)
+          end
+        end
+
+        def visit_group(name, state, path)
+          return if state[:visited][name]
+
+          if state[:visiting][name]
+            cycle_start = path.index(name) || 0
+            state[:cycles] << (path[cycle_start..] + [name])
+            return
+          end
+
+          state[:visiting][name] = true
+          state[:groups].fetch(name, []).each do |child|
+            visit_group(child, state, path + [name])
+          end
+          state[:visiting].delete(name)
+          state[:visited][name] = true
+        end
+
+        def issue(id, severity, message, subject: nil)
+          {
+            id: id,
+            severity: severity,
+            message: message,
+            subject: subject
+          }.compact
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/ClassLength