moose-inventory 2.0 → 2.1

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

@@ -1,13 +1,14 @@
 # frozen_string_literal: true
 
+require_relative 'operation_event_support'
+
 require_relative 'group_cleanup'
 
 module Moose
   module Inventory
     module Operations
       class GroupChildRelations
-        Event = Struct.new(:type, :payload, keyword_init: true)
-        Result = Struct.new(:events, :warning_count, keyword_init: true)
+        include OperationEventSupport
 
         def initialize(context:)
           @context = context
@@ -17,10 +18,11 @@ module Moose
           )
         end
 
-        def add_children(parent_group:, parent_name:, child_names:)
+        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?
@@ -28,13 +30,17 @@ module Moose
             warning_count += add_child(parent_group, parent_name, child_name, children_dataset, events)
           end
 
-          Result.new(events: events, warning_count: warning_count)
+          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)
+        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?
@@ -46,17 +52,20 @@ module Moose
                 child_name: child_name,
                 children_dataset: children_dataset,
                 events: events,
-                delete_orphans: delete_orphans
+                delete_orphans: delete_orphans,
+                dry_run: dry_run
               }
             )
           end
 
-          Result.new(events: events, warning_count: warning_count)
+          emit(events, :dry_run_summary) if dry_run
+
+          operation_result(events: events, warning_count: warning_count)
         end
 
         private
 
-        attr_reader :cleanup, :context
+        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)
@@ -73,12 +82,12 @@ module Moose
           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)
+            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)
+          parent_group.add_child(child_group) unless dry_run
           emit(events, :ok, indent: 4)
           warning_count
         end
@@ -99,19 +108,17 @@ module Moose
           end
 
           child_group = context.find_group(input[:child_name])
-          input[:parent_group].remove_child(child_group)
+          input[:parent_group].remove_child(child_group) unless input[:dry_run]
           emit(input[:events], :ok, indent: 4)
-          cleanup.delete_orphaned_group(child_group, input[:events]) if input[:delete_orphans]
+          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
-
-        def emit(events, type, payload = {})
-          events << Event.new(type: type, payload: payload)
-        end
       end
     end
   end

data/lib/moose_inventory/operations/group_cleanup.rb

@@ -1,27 +1,34 @@
 # 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)
+        def delete_orphaned_group(group, events, ignored_parent: nil)
           return if group.name == AUTOMATIC_GROUP
-          return unless group.parents_dataset.none?
+          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)
+            group.remove_child(child) unless dry_run
             emit(events, :ok, indent: 6)
-            delete_orphaned_group(child, events)
+            delete_orphaned_group(child, events, ignored_parent: group)
           end
           destroy_group(group, events, indent: 4)
         end
@@ -31,14 +38,16 @@ module Moose
             next unless host.groups_dataset.one?
 
             emit(events, :adding_automatic_group_to_host, host: host[:name], indent: indent)
-            host.add_group(context.automatic_group)
+            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)
-          group.remove_all_groupvars
-          group.remove_all_hosts
-          group.destroy
+          unless dry_run
+            group.remove_all_groupvars
+            group.remove_all_hosts
+            group.destroy
+          end
           emit(events, :ok, indent: indent + 2)
         end
 
@@ -46,6 +55,12 @@ module Moose
 
         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

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

data/lib/moose_inventory/operations/inventory_snapshot.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Moose
+  module Inventory
+    module Operations
+      # Builds a canonical, portable representation of the current inventory.
+      class InventorySnapshot
+        VERSION = 1
+
+        def initialize(context:)
+          @context = context
+        end
+
+        def export
+          {
+            'version' => VERSION,
+            'hosts' => export_hosts,
+            'groups' => export_groups
+          }
+        end
+
+        private
+
+        attr_reader :context
+
+        def export_hosts
+          context.all_hosts.sort_by(&:name).to_h do |host|
+            [host.name, host_payload(host)]
+          end
+        end
+
+        def host_payload(host)
+          {
+            'groups' => host.groups_dataset.map(:name).sort,
+            'tags' => host.tags_dataset.map(:name).sort,
+            'vars' => variables_hash(host.hostvars_dataset)
+          }
+        end
+
+        def export_groups
+          context.all_groups.sort_by(&:name).to_h do |group|
+            [group.name, group_payload(group)]
+          end
+        end
+
+        def group_payload(group)
+          {
+            'children' => group.children_dataset.map(:name).sort,
+            'tags' => group.tags_dataset.map(:name).sort,
+            'vars' => variables_hash(group.groupvars_dataset)
+          }
+        end
+
+        def variables_hash(dataset)
+          dataset.all.sort_by(&:name).to_h { |entry| [entry.name, entry.value] }
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/operations/inventory_snapshot_applier.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Moose
+  module Inventory
+    module Operations
+      # Applies an already-validated inventory snapshot to the current inventory.
+      class InventorySnapshotApplier
+        Result = Struct.new(:created_hosts, :created_groups, :updated_variables, :associations, keyword_init: true)
+
+        def initialize(context:)
+          @context = context
+        end
+
+        def call(snapshot:)
+          apply_snapshot(snapshot)
+        end
+
+        private
+
+        attr_reader :context
+
+        def apply_snapshot(snapshot)
+          result = Result.new(created_hosts: 0, created_groups: 0, updated_variables: 0, associations: 0)
+
+          snapshot['groups'].each_key { |name| result.created_groups += 1 if ensure_group(name).nil? }
+          snapshot['hosts'].each_key { |name| result.created_hosts += 1 if ensure_host(name).nil? }
+          apply_group_payloads(snapshot['groups'], result)
+          apply_host_payloads(snapshot['hosts'], result)
+          result
+        end
+
+        def apply_group_payloads(groups, result)
+          groups.each do |name, payload|
+            group = context.find_group(name)
+            result.updated_variables += apply_variables(group, :group, payload.fetch('vars', {}))
+            apply_tags(group, array_value(payload, 'tags'), result)
+            array_value(payload, 'children').each do |child_name|
+              child = context.find_group(child_name)
+              next unless group.children_dataset[name: child_name].nil?
+
+              group.add_child(child)
+              result.associations += 1
+            end
+          end
+        end
+
+        def apply_host_payloads(hosts, result)
+          hosts.each do |name, payload|
+            host = context.find_host(name)
+            result.updated_variables += apply_variables(host, :host, payload.fetch('vars', {}))
+            apply_tags(host, array_value(payload, 'tags'), result)
+            array_value(payload, 'groups').each do |group_name|
+              group = context.find_group(group_name)
+              next unless host.groups_dataset[name: group_name].nil?
+
+              host.add_group(group)
+              result.associations += 1
+            end
+          end
+        end
+
+        def apply_tags(entity, tags, result)
+          context.normalize_tag_names(tags).each do |tag_name|
+            tag = context.find_or_create_tag(tag_name)
+            next unless entity.tags_dataset[name: tag_name].nil?
+
+            entity.add_tag(tag)
+            result.associations += 1
+          end
+        end
+
+        def apply_variables(entity, type, variables)
+          variables.count do |name, value|
+            dataset = entity.public_send("#{type}vars_dataset")
+            existing = dataset[name: name]
+            if existing.nil?
+              record = context.create_variable(type, name: name, value: value.to_s)
+              entity.public_send("add_#{type}var", record)
+              true
+            elsif existing.value != value.to_s
+              existing.value = value.to_s
+              existing.save
+              true
+            else
+              false
+            end
+          end
+        end
+
+        def ensure_group(name)
+          existing = context.find_group(name)
+          return existing unless existing.nil?
+
+          context.create_group(name)
+          nil
+        end
+
+        def ensure_host(name)
+          existing = context.find_host(name)
+          return existing unless existing.nil?
+
+          context.create_host(name)
+          nil
+        end
+
+        def array_value(payload, key)
+          payload.fetch(key, []).map(&:to_s)
+        end
+      end
+    end
+  end
+end