moose-inventory 1.0.9 → 2.0

data/lib/moose_inventory/operations/add_associations.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Moose
+  module Inventory
+    module Operations
+      # Adds host/group associations for existing primary entities.
+      class AddAssociations
+        AUTOMATIC_GROUP = 'ungrouped'
+        Event = Struct.new(:type, :payload, keyword_init: true)
+        Result = Struct.new(:events, :warning_count, keyword_init: true)
+
+        def initialize(context:)
+          @context = context
+        end
+
+        def host_to_groups(host:, host_name:, group_names:)
+          events = []
+          warning_count = 0
+
+          group_names.each do |group_name|
+            next if group_name.nil? || group_name.empty?
+
+            warning_count += add_group_to_host(host, host_name, group_name, events)
+          end
+
+          remove_automatic_group_from_host(host, host_name, events)
+
+          Result.new(events: events, warning_count: warning_count)
+        end
+
+        def group_to_hosts(group:, group_name:, host_names:)
+          events = []
+          warning_count = 0
+          hosts_dataset = group.hosts_dataset
+
+          host_names.each do |host_name|
+            next if host_name.nil? || host_name.empty?
+
+            warning_count += add_host_to_group(
+              group,
+              group_name,
+              host_name,
+              hosts_dataset,
+              events
+            )
+          end
+
+          Result.new(events: events, warning_count: warning_count)
+        end
+
+        private
+
+        attr_reader :context
+
+        def add_group_to_host(host, host_name, group_name, events)
+          warning_count = 0
+          groups_dataset = host.groups_dataset
+
+          emit(events, :adding_host_group_association, host: host_name, group: group_name)
+
+          if association_exists?(groups_dataset, group_name)
+            emit(events, :host_group_association_exists, host: host_name, group: group_name)
+            emit(events, :already_exists_skipping, indent: 4)
+            emit(events, :ok, indent: 4)
+            return warning_count + 1
+          end
+
+          group = context.find_group(group_name)
+          if group.nil?
+            emit(events, :group_missing_created, name: group_name)
+            emit(events, :group_creating_now, name: group_name)
+            group = context.create_group(group_name)
+            emit(events, :ok, indent: 6)
+            warning_count += 1
+          end
+
+          host.add_group(group)
+          emit(events, :ok, indent: 4)
+          warning_count
+        end
+
+        def add_host_to_group(group, group_name, host_name, hosts_dataset, events)
+          warning_count = 0
+          emit(events, :adding_group_host_association, group: group_name, host: host_name)
+
+          if association_exists?(hosts_dataset, host_name)
+            emit(events, :group_host_association_exists, group: group_name, host: host_name)
+            emit(events, :already_exists_skipping, indent: 4)
+            emit(events, :ok, indent: 4)
+            return warning_count + 1
+          end
+
+          host = context.find_host(host_name)
+          if host.nil?
+            emit(events, :host_missing_created, name: host_name)
+            emit(events, :host_creating_now, name: host_name)
+            host = context.create_host(host_name)
+            emit(events, :ok, indent: 6)
+            warning_count += 1
+          end
+
+          group.add_host(host)
+          emit(events, :ok, indent: 4)
+          remove_automatic_group_from_host(host, host_name, events)
+          warning_count
+        end
+
+        def remove_automatic_group_from_host(host, host_name, events)
+          ungrouped = host.groups_dataset[name: AUTOMATIC_GROUP]
+          return if ungrouped.nil?
+
+          emit(events, :removing_automatic_group, host: host_name)
+          host.remove_group(ungrouped)
+          emit(events, :ok, indent: 4)
+        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
+end

data/lib/moose_inventory/operations/add_groups.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Moose
+  module Inventory
+    module Operations
+      ##
+      # Adds groups and their optional host associations.
+      class AddGroups
+        AUTOMATIC_GROUP = 'ungrouped'
+        Event = Struct.new(:type, :payload, keyword_init: true)
+        Result = Struct.new(:events, :warning_count, keyword_init: true)
+
+        def initialize(context:)
+          @context = context
+        end
+
+        def call(names:, hosts:)
+          events = []
+          warning_count = 0
+
+          context.transaction do
+            names.each do |name|
+              warning_count += add_group(name, hosts, events)
+            end
+          end
+
+          Result.new(events: events, warning_count: warning_count)
+        end
+
+        private
+
+        attr_reader :context
+
+        def add_group(name, hosts, events)
+          warning_count = 0
+          emit(events, :group_started, name: name)
+          group, hosts_dataset, created = create_or_find_group(name, events)
+          warning_count += 1 unless created
+
+          hosts.each do |host_name|
+            next if host_name.nil? || host_name.empty?
+
+            warning_count += add_host_association(group, name, host_name, hosts_dataset, events)
+          end
+
+          emit(events, :group_complete)
+          warning_count
+        end
+
+        def create_or_find_group(name, events)
+          emit(events, :creating_group)
+          group = context.find_group(name)
+
+          if group.nil?
+            group = context.create_group(name)
+            emit(events, :ok, indent: 4)
+            [group, nil, true]
+          else
+            emit(events, :group_exists, name: name)
+            emit(events, :already_exists_skipping, indent: 4)
+            emit(events, :ok, indent: 4)
+            [group, group.hosts_dataset, false]
+          end
+        end
+
+        def add_host_association(group, group_name, host_name, hosts_dataset, events)
+          warning_count = 0
+          emit(events, :adding_association, group: group_name, host: host_name)
+          host, created = find_or_create_host(host_name, events)
+          warning_count += 1 if created == :warned_create
+
+          if association_exists?(hosts_dataset, host_name)
+            emit(events, :association_exists, group: group_name, host: host_name)
+            emit(events, :already_exists_skipping, indent: 4)
+            warning_count += 1
+          else
+            group.add_host(host)
+          end
+          emit(events, :ok, indent: 4)
+
+          remove_automatic_group_from_host(host, host_name, events)
+          warning_count
+        end
+
+        def find_or_create_host(name, events)
+          host = context.find_host(name)
+          return [host, :existing] unless host.nil?
+
+          emit(events, :host_missing_created, name: name)
+          emit(events, :host_creating_now, name: name)
+          host = context.create_host(name)
+          emit(events, :ok, indent: 6)
+          [host, :warned_create]
+        end
+
+        def remove_automatic_group_from_host(host, host_name, events)
+          ungrouped = host.groups_dataset[name: AUTOMATIC_GROUP]
+          return if ungrouped.nil?
+
+          emit(events, :removing_automatic_group, host: host_name)
+          host.remove_group(ungrouped)
+          emit(events, :ok, indent: 4)
+        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
+end

data/lib/moose_inventory/operations/add_hosts.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+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'
+        Event = Struct.new(:type, :payload, keyword_init: true)
+        Result = Struct.new(:events, keyword_init: true)
+
+        def initialize(context:)
+          @context = context
+        end
+
+        def call(names:, groups:)
+          events = []
+          context.transaction do
+            names.each do |name|
+              add_host(name, groups, events)
+            end
+          end
+          Result.new(events: events)
+        end
+
+        private
+
+        attr_reader :context
+
+        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, 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)
+          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)
+          else
+            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)
+        end
+
+        def add_automatic_group_if_needed(host, host_name, events)
+          groups_dataset = host.groups_dataset
+          return if groups_dataset.nil? || groups_dataset.any?
+
+          emit(events, :adding_automatic_group, host: host_name, group: AUTOMATIC_GROUP)
+          host.add_group(automatic_group)
+          emit(events, :ok, indent: 4)
+        end
+
+        def automatic_group
+          context.automatic_group
+        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
+end

data/lib/moose_inventory/operations/group_child_relations.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+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)
+
+        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:)
+          events = []
+          warning_count = 0
+          children_dataset = parent_group.children_dataset
+
+          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
+
+          Result.new(events: events, warning_count: warning_count)
+        end
+
+        def remove_children(parent_group:, parent_name:, child_names:, delete_orphans: false)
+          events = []
+          warning_count = 0
+          children_dataset = parent_group.children_dataset
+
+          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
+              }
+            )
+          end
+
+          Result.new(events: events, warning_count: warning_count)
+        end
+
+        private
+
+        attr_reader :cleanup, :context
+
+        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)
+            emit(events, :ok, indent: 6)
+            warning_count = 1
+          end
+
+          parent_group.add_child(child_group)
+          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)
+          emit(input[:events], :ok, indent: 4)
+          cleanup.delete_orphaned_group(child_group, input[:events]) if input[:delete_orphans]
+          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
+end

data/lib/moose_inventory/operations/group_cleanup.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Moose
+  module Inventory
+    module Operations
+      # Recursively cleans up orphaned groups and their dependent relations.
+      class GroupCleanup
+        AUTOMATIC_GROUP = 'ungrouped'
+
+        def initialize(context:, emitter:)
+          @context = context
+          @emitter = emitter
+        end
+
+        def delete_orphaned_group(group, events)
+          return if group.name == AUTOMATIC_GROUP
+          return unless group.parents_dataset.none?
+
+          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)
+            emit(events, :ok, indent: 6)
+            delete_orphaned_group(child, events)
+          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)
+            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
+          emit(events, :ok, indent: indent + 2)
+        end
+
+        private
+
+        attr_reader :context, :emitter
+
+        def emit(events, type, payload = {})
+          emitter.call(events, type, payload)
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/operations/remove_associations.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Moose
+  module Inventory
+    module Operations
+      # Removes host/group associations for existing primary entities.
+      class RemoveAssociations
+        AUTOMATIC_GROUP = 'ungrouped'
+        Event = Struct.new(:type, :payload, keyword_init: true)
+        Result = Struct.new(:events, :warning_count, keyword_init: true)
+
+        def initialize(context:)
+          @context = context
+        end
+
+        def host_from_groups(host:, host_name:, group_names:)
+          events = []
+          warning_count = 0
+
+          group_names.each do |group_name|
+            next if group_name.nil? || group_name.empty?
+
+            warning_count += remove_group_from_host(host, host_name, group_name, events)
+          end
+
+          add_automatic_group_if_needed(host, host_name, events)
+
+          Result.new(events: events, warning_count: warning_count)
+        end
+
+        def group_from_hosts(group:, group_name:, host_names:)
+          events = []
+          warning_count = 0
+          hosts_dataset = group.hosts_dataset
+
+          host_names.each do |host_name|
+            next if host_name.nil? || host_name.empty?
+
+            warning_count += remove_host_from_group(group, group_name, host_name, hosts_dataset, events)
+          end
+
+          Result.new(events: events, warning_count: warning_count)
+        end
+
+        private
+
+        attr_reader :context
+
+        def remove_group_from_host(host, host_name, group_name, events)
+          groups_dataset = host.groups_dataset
+          emit(events, :removing_host_group_association, host: host_name, group: group_name)
+
+          unless association_exists?(groups_dataset, group_name)
+            emit(events, :host_group_association_missing, host: host_name, group: group_name)
+            emit(events, :missing_skipping, indent: 4)
+            emit(events, :ok, indent: 4)
+            return 1
+          end
+
+          group = context.find_group(group_name)
+          host.remove_group(group) unless group.nil?
+          emit(events, :ok, indent: 4)
+          0
+        end
+
+        def remove_host_from_group(group, group_name, host_name, hosts_dataset, events)
+          emit(events, :removing_group_host_association, group: group_name, host: host_name)
+
+          unless association_exists?(hosts_dataset, host_name)
+            emit(events, :group_host_association_missing, group: group_name, host: host_name)
+            emit(events, :missing_skipping, indent: 4)
+            emit(events, :ok, indent: 4)
+            return 1
+          end
+
+          host = context.find_host(host_name)
+          group.remove_host(host) unless host.nil?
+          emit(events, :ok, indent: 4)
+          add_automatic_group_if_needed(host, host_name, events)
+          0
+        end
+
+        def add_automatic_group_if_needed(host, host_name, events)
+          return unless host.groups_dataset.none?
+
+          emit(events, :adding_automatic_group, host: host_name)
+          host.add_group(context.automatic_group)
+          emit(events, :ok, indent: 4)
+        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
+end

data/lib/moose_inventory/operations/remove_groups.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative 'group_cleanup'
+
+module Moose
+  module Inventory
+    module Operations
+      # Removes top-level groups and their direct associations.
+      class RemoveGroups
+        Event = Struct.new(:type, :payload, keyword_init: true)
+        Result = Struct.new(:events, :warning_count, keyword_init: true)
+
+        def initialize(context:)
+          @context = context
+          @cleanup = Moose::Inventory::Operations::GroupCleanup.new(
+            context: context,
+            emitter: method(:emit)
+          )
+        end
+
+        def call(names:, recursive: false)
+          events = []
+          warning_count = 0
+
+          names.each do |name|
+            warning_count += remove_group(name, events, recursive: recursive)
+          end
+
+          Result.new(events: events, warning_count: warning_count)
+        end
+
+        private
+
+        attr_reader :cleanup, :context
+
+        def remove_group(name, events, recursive:)
+          emit(events, :group_started, name: name)
+          emit(events, :retrieving_group, name: name)
+          group = context.find_group(name)
+
+          if group.nil?
+            emit(events, :group_missing, name: name)
+            emit(events, :ok, indent: 4)
+            emit(events, :group_complete)
+            return 1
+          end
+
+          emit(events, :ok, indent: 4)
+          remove_parent_associations(group, name, events)
+          remove_child_associations(group, name, events, recursive: recursive)
+          cleanup.destroy_group(group, events, indent: 2)
+          emit(events, :group_complete)
+          0
+        end
+
+        def remove_parent_associations(group, name, events)
+          group.parents_dataset.each do |parent|
+            emit(events, :removing_parent_association, group: name, related_group: parent.name)
+            parent.remove_child(group)
+            emit(events, :ok, indent: 4)
+          end
+        end
+
+        def remove_child_associations(group, name, events, recursive:)
+          group.children_dataset.each do |child|
+            emit(events, :removing_child_association, group: name, related_group: child.name)
+            group.remove_child(child)
+            emit(events, :ok, indent: 4)
+            cleanup.delete_orphaned_group(child, events) if recursive
+          end
+        end
+
+        def emit(events, type, payload = {})
+          events << Event.new(type: type, payload: payload)
+        end
+      end
+    end
+  end
+end