moose-inventory 1.0.9 → 2.1

data/lib/moose_inventory/operations/query_inventory/host_queries.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Moose
+  module Inventory
+    module Operations
+      class QueryInventory
+        # Host-focused read queries.
+        class HostQueries < BaseQuery
+          def get_hosts(names:)
+            names.each_with_object({}) do |name, results|
+              host = context.find_host(name)
+              next if host.nil?
+
+              results[host.name.to_sym] = host_data(host)
+            end
+          end
+
+          def list_hosts(filters: {})
+            dataset = filtered_hosts_dataset(filters)
+            return {} if dataset.nil?
+
+            dataset.order(:id).all.to_h do |host|
+              [host.name.to_sym, host_data(host)]
+            end
+          end
+
+          def list_host_vars(names:, ansible:)
+            return ansible_host_vars(names.first) if ansible
+
+            names.each_with_object({}) do |name, results|
+              host = context.find_host(name)
+              next if host.nil?
+
+              results[name.to_sym] = variables_hash(host.hostvars_dataset)
+            end
+          end
+
+          private
+
+          def host_data(host)
+            {}.tap do |data|
+              groups = host.groups_dataset.map(:name)
+              data[:groups] = groups unless groups.empty?
+
+              tags = host.tags_dataset.map(:name).sort
+              data[:tags] = tags unless tags.empty?
+
+              hostvars = variables_hash(host.hostvars_dataset)
+              data[:hostvars] = hostvars unless hostvars.empty?
+            end
+          end
+
+          def filtered_hosts_dataset(filters)
+            dataset = context.hosts_dataset
+            dataset = filter_hosts_by_groups(dataset, filters.fetch(:groups, []))
+            return nil if dataset.nil?
+
+            dataset = filter_hosts_by_tags(dataset, filters.fetch(:tags, []))
+            return nil if dataset.nil?
+
+            filter_hosts_by_variables(dataset, filters.fetch(:variables, {}))
+          end
+
+          def filter_hosts_by_groups(dataset, groups)
+            groups.reduce(dataset) do |current_dataset, group_name|
+              group = context.find_group(group_name)
+              return nil if group.nil?
+
+              current_dataset.where(id: context.db_dataset(:groups_hosts).where(group_id: group.id).select(:host_id))
+            end
+          end
+
+          def filter_hosts_by_tags(dataset, tags)
+            tags.reduce(dataset) do |current_dataset, tag_name|
+              tag = context.find_tag(tag_name)
+              return nil if tag.nil?
+
+              current_dataset.where(id: context.db_dataset(:hosts_tags).where(tag_id: tag.id).select(:host_id))
+            end
+          end
+
+          def filter_hosts_by_variables(dataset, variables)
+            variables.reduce(dataset) do |current_dataset, (name, value)|
+              current_dataset.where(
+                id: context.db_dataset(:hostvars).where(name: name, value: value).select(:host_id)
+              )
+            end
+          end
+
+          def ansible_host_vars(name)
+            results = {}
+            host = context.find_host(name)
+            results.merge!(variables_hash(host.hostvars_dataset)) unless host.nil?
+
+            results[:_meta] = {
+              hostvars: context.all_hosts.to_h do |entry|
+                [entry.name.to_sym, variables_hash(entry.hostvars_dataset)]
+              end
+            }
+            results
+          end
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/operations/query_inventory.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'query_inventory/base_query'
+require_relative 'query_inventory/host_queries'
+require_relative 'query_inventory/group_queries'
+
+module Moose
+  module Inventory
+    module Operations
+      # Read-only inventory query seam for host/group CLI commands.
+      class QueryInventory
+        def initialize(context:)
+          @host_queries = HostQueries.new(context: context)
+          @group_queries = GroupQueries.new(context: context)
+        end
+
+        def get_hosts(names:)
+          host_queries.get_hosts(names: names)
+        end
+
+        def list_hosts(filters: {})
+          host_queries.list_hosts(filters: filters)
+        end
+
+        def list_host_vars(names:, ansible:)
+          host_queries.list_host_vars(names: names, ansible: ansible)
+        end
+
+        def get_groups(names:)
+          group_queries.get_groups(names: names)
+        end
+
+        def list_groups(ansible:)
+          group_queries.list_groups(ansible: ansible)
+        end
+
+        def list_group_vars(names:, ansible:)
+          group_queries.list_group_vars(names: names, ansible: ansible)
+        end
+
+        private
+
+        attr_reader :group_queries, :host_queries
+      end
+    end
+  end
+end

data/lib/moose_inventory/operations/remove_associations.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative 'operation_event_support'
+
+module Moose
+  module Inventory
+    module Operations
+      # Removes host/group associations for existing primary entities.
+      class RemoveAssociations
+        AUTOMATIC_GROUP = 'ungrouped'
+        include OperationEventSupport
+
+        def initialize(context:)
+          @context = context
+        end
+
+        def host_from_groups(host:, host_name:, group_names:, dry_run: false)
+          events = []
+          warning_count = 0
+          @dry_run = dry_run
+
+          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,
+                                        planned_empty: planned_host_groups_empty?(host, group_names))
+          emit(events, :dry_run_summary) if dry_run
+
+          operation_result(events: events, warning_count: warning_count)
+        end
+
+        def group_from_hosts(group:, group_name:, host_names:, dry_run: false)
+          events = []
+          warning_count = 0
+          @dry_run = dry_run
+          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
+
+          emit(events, :dry_run_summary) if dry_run
+
+          operation_result(events: events, warning_count: warning_count)
+        end
+
+        private
+
+        attr_reader :context, :dry_run
+
+        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? || dry_run
+          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? || dry_run
+          emit(events, :ok, indent: 4)
+          add_automatic_group_if_needed(host, host_name, events,
+                                        planned_empty: dry_run && !host.nil? && host.groups_dataset.one?)
+          0
+        end
+
+        def add_automatic_group_if_needed(host, host_name, events, planned_empty: false)
+          return if host.nil?
+          return unless planned_empty || host.groups_dataset.none?
+
+          emit(events, :adding_automatic_group, host: host_name)
+          host.add_group(context.automatic_group) unless dry_run
+          emit(events, :ok, indent: 4)
+        end
+
+        def planned_host_groups_empty?(host, group_names)
+          return false unless dry_run
+
+          remaining = host.groups_dataset.map(&:name) - group_names
+          remaining.empty?
+        end
+
+        def association_exists?(dataset, name)
+          !dataset.nil? && !dataset[name: name].nil?
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/operations/remove_groups.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative 'operation_event_support'
+
+require_relative 'group_cleanup'
+
+module Moose
+  module Inventory
+    module Operations
+      # Removes top-level groups and their direct associations.
+      class RemoveGroups
+        include OperationEventSupport
+
+        def initialize(context:)
+          @context = context
+          @cleanup = Moose::Inventory::Operations::GroupCleanup.new(
+            context: context,
+            emitter: method(:emit)
+          )
+        end
+
+        def call(names:, recursive: false, dry_run: false)
+          events = []
+          warning_count = 0
+          @dry_run = dry_run
+          cleanup.dry_run = dry_run
+
+          names.each do |name|
+            warning_count += remove_group(name, events, recursive: recursive)
+          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 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) unless dry_run
+            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) unless dry_run
+            emit(events, :ok, indent: 4)
+            cleanup.delete_orphaned_group(child, events, ignored_parent: group) if recursive
+          end
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/operations/remove_hosts.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative 'operation_event_support'
+
+module Moose
+  module Inventory
+    module Operations
+      # Removes hosts and returns structured progress/warning events.
+      class RemoveHosts
+        include OperationEventSupport
+
+        def initialize(context:)
+          @context = context
+        end
+
+        def call(names:, dry_run: false)
+          events = []
+          warning_count = 0
+          @dry_run = dry_run
+
+          if dry_run
+            names.each do |name|
+              warning_count += remove_host(name, events)
+            end
+            emit(events, :dry_run_summary)
+            return operation_result(events: events, warning_count: warning_count)
+          end
+
+          context.transaction do
+            names.each do |name|
+              warning_count += remove_host(name, events)
+            end
+          end
+
+          operation_result(events: events, warning_count: warning_count)
+        end
+
+        private
+
+        attr_reader :context, :dry_run
+
+        def remove_host(name, events)
+          emit(events, :host_started, name: name)
+          emit(events, :retrieving_host, name: name)
+          host = context.find_host(name)
+
+          if host.nil?
+            emit(events, :host_missing, name: name)
+            emit(events, :missing_skipping, indent: 4)
+            emit(events, :ok, indent: 4)
+            emit(events, :host_complete)
+            return 1
+          end
+
+          emit(events, :ok, indent: 4)
+          emit(events, :destroying_host, name: name)
+          unless dry_run
+            host.remove_all_groups
+            host.destroy
+          end
+          emit(events, :ok, indent: 4)
+          emit(events, :host_complete)
+          0
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/operations/remove_variables.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative 'entity_variable_operation_support'
+
+module Moose
+  module Inventory
+    module Operations
+      # Removes host/group variables by key.
+      class RemoveVariables
+        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|
+            remove_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 remove_variable(entity, dataset, variable)
+          emit(:removing_variable, variable: variable)
+          key = parse_variable_name(variable)
+
+          existing = dataset[name: key]
+          unless existing.nil? || dry_run
+            entity.public_send("remove_#{entity_type}var", existing)
+            existing.destroy
+          end
+
+          emit(:ok, indent: 4)
+        end
+
+        def parse_variable_name(variable)
+          invalid = variable.start_with?('=') || variable.count('=') > 1
+          raise_invalid_variable(variable) if invalid
+
+          variable.split('=').first
+        end
+
+        def raise_invalid_variable(variable)
+          raise context.moose_exception_class,
+                "Incorrect format in {#{variable}}. Expected 'key' or 'key=value'."
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/runtime_options.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Moose
+  module Inventory
+    # Small value object for resolved runtime CLI options.
+    class RuntimeOptions
+      attr_reader :argv, :config, :env, :format
+
+      def initialize(argv:, config:, env:, format:, flags:)
+        @argv = argv
+        @config = config
+        @env = env
+        @format = format
+        @ansible = flags[:ansible] == true
+        @trace = flags[:trace] == true
+      end
+
+      def ansible?
+        @ansible
+      end
+
+      def trace?
+        @trace
+      end
+
+      def output_format
+        format.to_s.downcase
+      end
+    end
+  end
+end

data/lib/moose_inventory/version.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module Moose
   ##
   # The Moose-Tools dynamic inventory management library
   module Inventory
-    VERSION = '1.0.9'.freeze
+    VERSION = '2.1'
   end
 end

data/lib/moose_inventory.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require 'thor'
-require_relative './moose_inventory/config/config.rb'
-require_relative './moose_inventory/db/db.rb'
-require_relative './moose_inventory/cli/application.rb'
+require_relative 'moose_inventory/config/config'
+require_relative 'moose_inventory/db/db'
+require_relative 'moose_inventory/cli/application'
 
 module Moose
   module Inventory
@@ -12,13 +14,14 @@ module Moose
       extend self
       # rubocop:enable Style/ModuleFunction
 
-      def start(args)
+      def start(args, config: Moose::Inventory::Config, db: Moose::Inventory::DB,
+                application: Moose::Inventory::Cli::Application)
         # initialization stuff.
-        Moose::Inventory::Config.init(args)
-        Moose::Inventory::DB.init
+        config.init(args)
+        db.init
 
         # Start the main application
-        Moose::Inventory::Cli::Application.start(Moose::Inventory::Config._argv)
+        application.start(config.application_args)
       end
     end
   end

data/moose-inventory.gemspec

@@ -1,60 +1,47 @@
+# frozen_string_literal: true
+
 # -*- mode: ruby -*-
 # vi: set ft=ruby :
 
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'moose_inventory/version'
 
+# rubocop:disable Metrics/BlockLength
 Gem::Specification.new do |spec|
   spec.name          = 'moose-inventory'
   spec.version       = Moose::Inventory::VERSION
   spec.authors       = ['Russell Davies']
   spec.email         = ['russell@blakemere.ca']
   spec.summary       = 'Moose-tools inventory manager'
-  # rubocop:disable Metrics/LineLength
-  spec.description   = 'The Moosecastle CLI tool for Ansible-compatable dynamic inventory management.'
-  # rubocop:enable Metrics/LineLength
+  spec.description   = 'The Moosecastle CLI tool for Ansible-compatible dynamic inventory management.'
   spec.homepage      = 'https://github.com/RusDavies/moose-inventory'
   spec.license       = 'MIT'
   spec.required_ruby_version = '>= 3.2'
+  spec.metadata['rubygems_mfa_required'] = 'true'
 
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-#  spec.add_runtime_dependency 'indentation', '~> 0.1'
-#  spec.add_runtime_dependency 'json',        '~>1.8'
-#  #spec.add_runtime_dependency 'mysql',       '~>2.9' # This causes lots of problems.  Need to migrate to the newer mysql2.
-#  #spec.add_runtime_dependency 'mysql2',    '~>0.3'
-#  spec.add_runtime_dependency 'mysql2'
-#  spec.add_runtime_dependency 'pg',        '~>0.17'
-#  spec.add_runtime_dependency 'sequel',    '~>4.22'
-#  spec.add_runtime_dependency 'sqlite3',   '~>1.3'
-#  spec.add_runtime_dependency 'thor',      '~>0.19'
-#  # spec.add_runtime_dependency   'yaml',      '~>1.0'
-
-#  spec.add_development_dependency 'bundler',      '~> 1.7'
-#  spec.add_development_dependency 'coveralls',    '~> 0.8'
-#  spec.add_development_dependency 'guard',        '~> 2.12'
-#  spec.add_development_dependency 'guard-rspec',  '~> 4.5'
-#  spec.add_development_dependency 'guard-rubocop', '~> 1.2'
-#  spec.add_development_dependency 'rake',         '~> 10.1'
-#  spec.add_development_dependency 'rspec',        '~>3.2'
-#  spec.add_development_dependency 'rubocop',      '>= 0.19'
-#  spec.add_development_dependency 'simplecov',    '~> 0.10'
-
-  spec.add_runtime_dependency 'indentation', '~> 0'
-  spec.add_runtime_dependency 'json', '>= 2.7', '< 3'
-  spec.add_runtime_dependency 'mysql2', '>= 0.5.7', '< 0.6'
-  spec.add_runtime_dependency 'pg', '>= 1.5', '< 2'
-  spec.add_runtime_dependency 'sequel', '>= 5.80', '< 6'
-  spec.add_runtime_dependency 'sqlite3', '>= 1.7', '< 3'
-  spec.add_runtime_dependency 'thor', '>= 1.3', '< 2'
-
+  spec.add_dependency 'indentation', '~> 0'
+  spec.add_dependency 'json', '>= 2.7', '< 3'
+  spec.add_dependency 'mysql2', '>= 0.5.7', '< 0.6'
+  spec.add_dependency 'pg', '>= 1.5', '< 2'
+  spec.add_dependency 'sequel', '>= 5.80', '< 6'
+  spec.add_dependency 'sqlite3', '>= 1.7', '< 3'
+  spec.add_dependency 'thor', '>= 1.3', '< 2'
+
+  # rubocop:disable Gemspec/DevelopmentDependencies
+  # Development dependencies intentionally remain here because this project uses
+  # `gemspec` as its Gemfile dependency source.
   spec.add_development_dependency 'bundler', '>= 2.2.33', '< 3'
+  spec.add_development_dependency 'bundler-audit', '>= 0.9', '< 1'
+  spec.add_development_dependency 'parallel', '>= 1.10', '< 2.0'
   spec.add_development_dependency 'rake', '>= 13.0', '< 14'
   spec.add_development_dependency 'rspec', '~> 3'
+  spec.add_development_dependency 'rubocop', '>= 1.72', '< 2'
   spec.add_development_dependency 'simplecov', '~> 0'
-
+  # rubocop:enable Gemspec/DevelopmentDependencies
 end
+# rubocop:enable Metrics/BlockLength

data/scripts/check.sh

@@ -2,7 +2,10 @@
 set -euo pipefail
 
 bundle exec rspec --format progress
+scripts/ci/check_rubocop.sh
 git diff --check
 scripts/ci/check_permissions.sh
+scripts/ci/check_generated_artifacts.sh
 scripts/ci/check_security.sh
+scripts/ci/check_secrets.sh
 scripts/ci/package_sanity.sh