moose-inventory 2.0 → 2.1

data/lib/moose_inventory/cli/child_relation_rendering.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Moose
+  module Inventory
+    module Cli
+      # Shared rendering helpers for child-group relation commands.
+      module ChildRelationRendering
+        private
+
+        def addchild_emitter
+          lambda do |event|
+            render_addchild_event(event)
+          end
+        end
+
+        def rmchild_emitter
+          lambda do |event|
+            render_rmchild_event(event)
+          end
+        end
+
+        def render_addchild_event(event)
+          payload = event.payload
+
+          return render_addchild_warning(event.type, payload) if addchild_warning?(event.type)
+          return render_addchild_existing(payload) if event.type == :already_exists_skipping
+          return render_child_relation_dry_run_summary if event.type == :dry_run_summary
+
+          case event.type
+          when :adding_child_association
+            fmt.puts 2, "- add association {group:#{payload[:parent]} <-> group:#{payload[:child]}}..."
+          when :child_group_creating_now
+            fmt.puts 4, '- child group does not exist, creating now...'
+          when :ok
+            fmt.puts payload[:indent], '- OK'
+          end
+        end
+
+        def render_child_relation_dry_run_summary
+          puts 'Dry run complete. No changes applied.'
+        end
+
+        def addchild_warning?(type)
+          %i[child_association_exists child_group_missing].include?(type)
+        end
+
+        def render_addchild_warning(type, payload)
+          if type == :child_association_exists
+            fmt.warn "Association {group:#{payload[:parent]} <-> group:#{payload[:child]}} already exists, skipping.\n"
+          else
+            fmt.warn "Group '#{payload[:name]}' does not exist and will be created.\n"
+          end
+        end
+
+        def render_addchild_existing(payload)
+          fmt.puts payload[:indent], '- already exists, skipping.'
+        end
+
+        def render_rmchild_event(event)
+          payload = event.payload
+
+          return render_rmchild_warning(payload) if event.type == :child_association_missing
+          return render_rmchild_missing(payload) if event.type == :missing_skipping
+          return render_rmchild_progress(event.type, payload) if rmchild_progress_event?(event.type)
+          return render_child_relation_dry_run_summary if event.type == :dry_run_summary
+
+          render_rmchild_status(event.type, payload)
+        end
+
+        def rmchild_progress_event?(type)
+          %i[
+            removing_child_association
+            recursively_delete_orphaned_group
+            removing_recursive_child_association
+          ].include?(type)
+        end
+
+        def render_rmchild_progress(type, payload)
+          case type
+          when :removing_child_association
+            fmt.puts 2, "- remove association {group:#{payload[:parent]} <-> group:#{payload[:child]}}..."
+          when :recursively_delete_orphaned_group
+            fmt.puts 2, "- Recursively delete orphaned group '#{payload[:name]}'..."
+          when :removing_recursive_child_association
+            fmt.puts 4, "- Remove association {group:#{payload[:parent]} <-> group:#{payload[:child]}}..."
+          end
+        end
+
+        def render_rmchild_status(type, payload)
+          case type
+          when :adding_automatic_group_to_host
+            fmt.puts payload[:indent], "- Adding automatic association {group:ungrouped <-> host:#{payload[:host]}}..."
+          when :destroying_group
+            fmt.puts payload[:indent], "- Destroy group '#{payload[:name]}'..."
+          when :ok
+            fmt.puts payload[:indent], '- OK'
+          end
+        end
+
+        def render_rmchild_warning(payload)
+          fmt.warn "Association {group:#{payload[:parent]} <-> group:#{payload[:child]}} does not exist, skipping.\n"
+        end
+
+        def render_rmchild_missing(payload)
+          fmt.puts payload[:indent], "- doesn't exist, skipping."
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/cli/console.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require 'shellwords'
+
+module Moose
+  module Inventory
+    module Cli
+      # Small read-only interactive console for browsing inventory state.
+      class Console
+        COMMANDS = ['help', 'hosts', 'groups', 'host NAME', 'group NAME',
+                    'tags host NAME', 'tags group NAME', 'audit [LIMIT]', 'quit'].freeze
+
+        def initialize(context:, input: $stdin, output: $stdout)
+          @context = context
+          @input = input
+          @output = output
+        end
+
+        def run
+          output.puts 'Moose Inventory console (read-only). Type help or quit.'
+          input.each_line do |line|
+            parts = parse_command(line)
+            next if parts.nil? || parts.empty?
+
+            break if quit_command?(parts)
+
+            dispatch(parts)
+          end
+          output.puts 'Goodbye.'
+        end
+
+        private
+
+        attr_reader :context, :input, :output
+
+        def parse_command(line)
+          command = line.strip
+          return [] if command.empty?
+
+          Shellwords.split(command)
+        rescue ArgumentError => e
+          output.puts "Invalid command syntax: #{e.message}"
+          nil
+        end
+
+        def dispatch(parts)
+          handlers = {
+            'help' => -> { render_exact(parts, 'help') { render_help } },
+            'hosts' => -> { render_exact(parts, 'hosts') { render_hosts } },
+            'groups' => -> { render_exact(parts, 'groups') { render_groups } },
+            'host' => -> { render_entity(:host, parts) },
+            'group' => -> { render_entity(:group, parts) },
+            'tags' => -> { render_tags(parts) },
+            'audit' => -> { render_audit(parts) }
+          }
+          handlers.fetch(parts.first, -> { output.puts "Unknown command: #{parts.join(' ')}" }).call
+        end
+
+        def quit_command?(parts)
+          parts.length == 1 && %w[quit exit].include?(parts.first)
+        end
+
+        def render_exact(parts, usage)
+          return output.puts("Usage: #{usage}") unless parts.length == 1
+
+          yield
+        end
+
+        def render_help
+          output.puts 'Commands:'
+          COMMANDS.each { |command| output.puts "- #{command}" }
+        end
+
+        def render_hosts
+          names = context.all_hosts.map(&:name).sort
+          output.puts(names.empty? ? 'No hosts.' : "Hosts: #{names.join(', ')}")
+        end
+
+        def render_groups
+          names = context.all_groups.map(&:name).sort
+          output.puts(names.empty? ? 'No groups.' : "Groups: #{names.join(', ')}")
+        end
+
+        def render_entity(type, parts)
+          return output.puts("Usage: #{type} NAME") unless parts.length == 2
+
+          name = parts[1]
+
+          entity = context.public_send("find_#{type}", name)
+          return output.puts("#{type.capitalize} '#{name}' not found.") if entity.nil?
+
+          output.puts "#{type.capitalize}: #{name}"
+          output.puts "Groups: #{entity.groups_dataset.map(:name).sort.join(', ')}" if type == :host
+          output.puts "Hosts: #{entity.hosts_dataset.map(:name).sort.join(', ')}" if type == :group
+          output.puts "Tags: #{entity.tags_dataset.map(:name).sort.join(', ')}"
+        end
+
+        def render_tags(parts)
+          type = parts[1]
+          name = parts[2]
+          return output.puts('Usage: tags host|group NAME') unless parts.length == 3 && %w[host group].include?(type)
+
+          entity = context.public_send("find_#{type}", name)
+          return output.puts("#{type.capitalize} '#{name}' not found.") if entity.nil?
+
+          tags = entity.tags_dataset.map(:name).sort
+          output.puts tags.empty? ? "#{type.capitalize} '#{name}' has no tags." : tags.join(', ')
+        end
+
+        def render_audit(parts)
+          limit = audit_limit(parts[1]) if parts.length <= 2
+          return output.puts('Usage: audit [LIMIT]') if parts.length > 2 || limit.nil?
+
+          events = context.audit_events(limit: limit)
+          return output.puts('No audit events recorded.') if events.empty?
+
+          events.each do |event|
+            output.puts "#{event.id} #{event.created_at} #{event.command} #{event.entity_type}=#{event.entity_name}"
+          end
+        end
+
+        def audit_limit(value)
+          return 10 if value.nil?
+
+          parsed = Integer(value)
+          return parsed if parsed.positive?
+
+          nil
+        rescue ArgumentError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/cli/db.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'thor'
+require 'json'
+
+require_relative 'formatter'
+
+module Moose
+  module Inventory
+    module Cli
+      # Database lifecycle commands.
+      class Db < Thor
+        desc 'status', 'Show database lifecycle status'
+        def status
+          render_status(Moose::Inventory::DB.status)
+        end
+
+        desc 'doctor', 'Check database schema state'
+        def doctor
+          status = Moose::Inventory::DB.status
+          missing = status[:tables].reject { |_name, present| present }.keys
+          if missing.empty? && status[:schema_version] == status[:expected_schema_version]
+            puts 'Database doctor found no issues.'
+            return
+          end
+
+          puts 'Database doctor found issue(s):'
+          puts "- Missing tables: #{missing.join(', ')}" unless missing.empty?
+          if status[:schema_version] != status[:expected_schema_version]
+            puts "- Schema version is #{status[:schema_version].inspect}; expected #{status[:expected_schema_version]}."
+          end
+          exit(1)
+        end
+
+        desc 'migrate', 'Create missing schema tables and record current schema version'
+        def migrate
+          status = Moose::Inventory::DB.migrate!
+          puts "Database schema is at version #{status[:schema_version]}."
+        end
+
+        desc 'backup FILE', 'Back up the configured sqlite3 database file'
+        def backup(file)
+          destination = Moose::Inventory::DB.backup(file)
+          puts "Backed up database to #{destination}."
+        rescue Moose::Inventory::DB.exceptions[:moose] => e
+          abort("ERROR: #{e.message}")
+        end
+
+        private
+
+        def render_status(status)
+          puts "Adapter: #{status[:adapter]}"
+          puts "Schema version: #{status[:schema_version] || 'unknown'}"
+          puts "Expected schema version: #{status[:expected_schema_version]}"
+          puts "SQLite file: #{status[:sqlite_file]}" unless status[:sqlite_file].nil?
+          puts 'Tables:'
+          status[:tables].each do |name, present|
+            puts "- #{name}: #{present ? 'present' : 'missing'}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/cli/factory.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative '../operations/query_inventory'
+
+module Moose
+  module Inventory
+    module Cli
+      # Small factory for command-side operations and query wrappers.
+      class Factory
+        def initialize(context:)
+          @context = context
+        end
+
+        def operation(operation_class, **)
+          operation_class.new(context: context, **)
+        end
+
+        def query_inventory
+          @query_inventory ||= Moose::Inventory::Operations::QueryInventory.new(context: context)
+        end
+
+        private
+
+        attr_reader :context
+      end
+    end
+  end
+end

data/lib/moose_inventory/cli/formatter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'json'
 require 'yaml'
 require 'indentation'
@@ -5,24 +7,18 @@ require 'indentation'
 module Moose
   module Inventory
     module Cli
-      ##
-      # TODO: Documentation
       module Formatter
         # rubocop:disable Style/ModuleFunction
         extend self
         # rubocop:enable Style/ModuleFunction
 
-        def self.dump(arg, format = nil)
+        def self.dump(arg, format = 'json')
           out(arg, format)
         end
 
-        def self.out(arg, format = nil)
+        def self.out(arg, format = 'json')
           return if arg.nil?
 
-          if format.nil?
-            format = Moose::Inventory::Config._confopts[:format].downcase
-          end
-
           case format
           when 'yaml', 'y'
             $stdout.puts arg.to_yaml
@@ -50,7 +46,7 @@ module Moose
           when 'STDOUT'
             $stdout.puts msg.indent(indent)
           when 'STDERR'
-            $stderr.puts msg.indent(indent)
+            $stderr.print("#{msg.indent(indent)}\n")
           else
             abort("Output stream '#{stream}' is not known.")
           end
@@ -67,12 +63,12 @@ module Moose
           end
         end
 
-        def info(_indent, _msg, stream = 'STDOUT')
+        def info(indent, msg, stream = 'STDOUT')
           case stream
           when 'STDOUT'
-            $stdout.print 'INFO: {msg}'
+            $stdout.print "INFO: #{msg}".indent(indent)
           when 'STDERR'
-            $stderr.print 'INFO: {msg}'
+            $stderr.print "INFO: #{msg}".indent(indent)
           else
             abort("Output stream '#{stream}' is not known.")
           end

data/lib/moose_inventory/cli/group.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 require 'thor'
-require_relative './formatter.rb'
-require_relative './helpers.rb'
+require_relative 'formatter'
+require_relative 'helpers'
 
 module Moose
   module Inventory
@@ -21,6 +23,7 @@ module Moose
         require_relative 'group_addvar'
         require_relative 'group_listvars'
         require_relative 'group_rmvar'
+        require_relative 'group_tags'
       end
     end
   end

data/lib/moose_inventory/cli/group_add.rb

@@ -14,8 +14,11 @@ module Moose
         #==========================
         desc 'add NAME', 'Add a group NAME to the inventory'
         option :hosts
+        option :dry_run, type: :boolean
+        option :plan_format, type: :string, desc: 'Emit dry-run plan events as yaml|json|pjson'
         def add(*argv)
           abort_if_missing_args(argv, 1, '1 or more')
+          validate_machine_plan_request!
 
           names = normalize_names(argv)
           hosts = csv_option_names(options[:hosts])
@@ -25,16 +28,14 @@ module Moose
             "ERROR: Cannot manually manipulate the automatic group 'ungrouped'\n"
           )
 
-          result = Moose::Inventory::Operations::AddGroups
-                   .new(context: Moose::Inventory::InventoryContext.new(db: db))
-                   .call(names: names, hosts: hosts)
-          render_add_groups_events(result.events)
+          result = build_operation(Moose::Inventory::Operations::AddGroups)
+                   .call(names: names, hosts: hosts, dry_run: options[:dry_run])
+          return if machine_plan_output_rendered?(result, command: 'group add')
 
-          if result.warning_count.zero?
-            puts 'Succeeded'
-          else
-            puts 'Succeeded, with warnings.'
-          end
+          record_audit({ command: 'group add', action: 'add', entity_type: 'group',
+                         entity_names: names }, result: result, dry_run: options[:dry_run])
+          render_add_groups_events(result.events)
+          print_warning_summary(result, success_message: 'Succeeded')
         end
 
         private
@@ -48,6 +49,7 @@ module Moose
 
           return render_add_groups_event_puts(event.type, payload) if puts_event?(event.type)
           return render_add_groups_event_warn(event.type, payload) if warn_event?(event.type)
+          return puts 'Dry run complete. No changes applied.' if event.type == :dry_run_summary
 
           render_add_groups_event_fmt(event.type, payload)
         end

data/lib/moose_inventory/cli/group_addchild.rb

@@ -14,8 +14,11 @@ module Moose
         #==========================
         desc 'addchild PARENTGROUP CHILDGROUP_1 [CHILDGROUP_2 ... ]',
              'Associate one or more child-groups CHILDGROUP_n with PARENTGROUP'
+        option :dry_run, type: :boolean
+        option :plan_format, type: :string, desc: 'Emit dry-run plan events as yaml|json|pjson'
         def addchild(*argv)
           abort_if_missing_args(argv, 2, '2 or more')
+          validate_machine_plan_request!
 
           pname = argv[0].downcase
           cnames = normalize_names(argv.slice(1, argv.length - 1))
@@ -23,81 +26,36 @@ module Moose
           abort_if_automatic_group([pname] + cnames)
 
           result = add_children_to_group(pname, cnames)
+          return if machine_plan_output_rendered?(result, command: 'group addchild')
 
-          if result.warning_count.zero?
-            puts 'Succeeded.'
-          else
-            puts 'Succeeded, with warnings.'
-          end
+          record_audit({ command: 'group addchild', action: 'associate_child', entity_type: 'group',
+                         entity_names: pname }, result: result, dry_run: options[:dry_run])
+          print_warning_summary(result)
         end
 
         private
 
         def add_children_to_group(parent_name, child_names)
-          context = Moose::Inventory::InventoryContext.new(db: db)
-          operation = Moose::Inventory::Operations::GroupChildRelations.new(context: context)
-
-          begin
-            db.transaction do
-              puts "Associate parent group '#{parent_name}' with child group(s) '#{child_names.join(',')}':"
-              parent_group = fetch_existing_group_for_child_relation(context, parent_name)
-              result = operation.add_children(
-                parent_group: parent_group,
-                parent_name: parent_name,
-                child_names: child_names
-              )
-              render_addchild_events(result.events)
-              fmt.puts 2, '- all OK'
-              return result
-            end
-          rescue db.exceptions[:moose] => e
-            abort("ERROR: #{e}")
+          operation = build_operation(Moose::Inventory::Operations::GroupChildRelations)
+          run_group_relation_transaction(
+            heading: "Associate parent group '#{parent_name}' with child group(s) '#{child_names.join(',')}':",
+            on_error: method(:exception_to_s)
+          ) do
+            parent_group = fetch_existing_group_or_abort(parent_name)
+            result = operation.add_children(
+              parent_group: parent_group,
+              parent_name: parent_name,
+              child_names: child_names,
+              dry_run: options[:dry_run]
+            )
+            render_addchild_events(result.events) unless machine_plan_output_requested?
+            result
           end
         end
 
-        def fetch_existing_group_for_child_relation(context, name)
-          fmt.puts 2, "- retrieve group '#{name}'..."
-          group = context.find_group(name)
-          abort("ERROR: The group '#{name}' does not exist.") if group.nil?
-
-          fmt.puts 4, '- OK'
-          group
-        end
-
         def render_addchild_events(events)
-          events.each { |event| render_addchild_event(event) }
-        end
-
-        def render_addchild_event(event)
-          payload = event.payload
-
-          return render_addchild_warning(event.type, payload) if addchild_warning?(event.type)
-          return render_addchild_existing(payload) if event.type == :already_exists_skipping
-
-          case event.type
-          when :adding_child_association
-            fmt.puts 2, "- add association {group:#{payload[:parent]} <-> group:#{payload[:child]}}..."
-          when :child_group_creating_now
-            fmt.puts 4, '- child group does not exist, creating now...'
-          when :ok
-            fmt.puts payload[:indent], '- OK'
-          end
-        end
-
-        def addchild_warning?(type)
-          %i[child_association_exists child_group_missing].include?(type)
-        end
-
-        def render_addchild_warning(type, payload)
-          if type == :child_association_exists
-            fmt.warn "Association {group:#{payload[:parent]} <-> group:#{payload[:child]}}} already exists, skipping.\n"
-          else
-            fmt.warn "Group '#{payload[:name]}' does not exist and will be created.\n"
-          end
-        end
-
-        def render_addchild_existing(payload)
-          fmt.puts payload[:indent], '- already exists, skipping.'
+          emitter = addchild_emitter
+          events.each { |event| emitter.call(event) }
         end
       end
     end

data/lib/moose_inventory/cli/group_addhost.rb

@@ -14,8 +14,11 @@ module Moose
         #==========================
         desc 'addhost NAME HOSTNAME',
              'Associate a host HOSTNAME with the group NAME'
+        option :dry_run, type: :boolean
+        option :plan_format, type: :string, desc: 'Emit dry-run plan events as yaml|json|pjson'
         def addhost(*args)
           abort_if_missing_args(args, 2, '2 or more')
+          validate_machine_plan_request!
 
           name = args[0].downcase
           hosts = normalize_names(args.slice(1, args.length - 1))
@@ -23,83 +26,29 @@ module Moose
           abort_if_automatic_group([name])
 
           result = add_hosts_to_group(name, hosts)
+          return if machine_plan_output_rendered?(result, command: 'group addhost')
 
-          if result.warning_count.zero?
-            puts 'Succeeded.'
-          else
-            puts 'Succeeded, with warnings.'
-          end
+          record_audit({ command: 'group addhost', action: 'associate', entity_type: 'group',
+                         entity_names: name }, result: result, dry_run: options[:dry_run])
+          print_warning_summary(result)
         end
 
         private
 
         def add_hosts_to_group(name, hosts)
-          context = Moose::Inventory::InventoryContext.new(db: db)
-          operation = Moose::Inventory::Operations::AddAssociations.new(context: context)
-
-          begin
-            db.transaction do
-              puts "Associate group '#{name}' with host(s) '#{hosts.join(',')}':"
-              group = fetch_existing_group_for_addhost(context, name)
-              result = operation.group_to_hosts(group: group, group_name: name, host_names: hosts)
-              render_group_addhost_events(result.events)
-              fmt.puts 2, '- all OK'
-              return result
-            end
-          rescue db.exceptions[:moose] => e
-            abort("ERROR: #{e.message}")
+          operation = build_operation(Moose::Inventory::Operations::AddAssociations)
+          run_group_relation_transaction(heading: "Associate group '#{name}' with host(s) '#{hosts.join(',')}':") do
+            group = fetch_existing_group_or_abort(name)
+            result = operation.group_to_hosts(group: group, group_name: name, host_names: hosts,
+                                              dry_run: options[:dry_run])
+            render_group_addhost_events(result.events) unless machine_plan_output_requested?
+            result
           end
         end
 
-        def fetch_existing_group_for_addhost(context, name)
-          fmt.puts 2, "- retrieve group '#{name}'..."
-          group = context.find_group(name)
-          abort("ERROR: The group '#{name}' does not exist.") if group.nil?
-
-          fmt.puts 4, '- OK'
-          group
-        end
-
         def render_group_addhost_events(events)
-          events.each { |event| render_group_addhost_event(event) }
-        end
-
-        def render_group_addhost_event(event)
-          payload = event.payload
-
-          return render_group_addhost_warning(event.type, payload) if group_addhost_warning?(event.type)
-          return render_group_addhost_status(payload) if event.type == :already_exists_skipping
-
-          render_group_addhost_output(event.type, payload)
-        end
-
-        def group_addhost_warning?(type)
-          %i[group_host_association_exists host_missing_created].include?(type)
-        end
-
-        def render_group_addhost_warning(type, payload)
-          if type == :group_host_association_exists
-            fmt.warn "Association {group:#{payload[:group]} <-> host:#{payload[:host]}} already exists, skipping.\n"
-          else
-            fmt.warn "Host '#{payload[:name]}' does not exist and will be created.\n"
-          end
-        end
-
-        def render_group_addhost_status(payload)
-          fmt.puts payload[:indent], '- already exists, skipping.'
-        end
-
-        def render_group_addhost_output(type, payload)
-          case type
-          when :adding_group_host_association
-            fmt.puts 2, "- add association {group:#{payload[:group]} <-> host:#{payload[:host]}}..."
-          when :host_creating_now
-            fmt.puts 4, '- host does not exist, creating now...'
-          when :removing_automatic_group
-            fmt.puts 2, "- remove automatic association {group:ungrouped <-> host:#{payload[:host]}}..."
-          when :ok
-            fmt.puts payload[:indent], '- OK'
-          end
+          emitter = host_group_association_addition_emitter(perspective: :group)
+          events.each { |event| emitter.call(event) }
         end
       end
     end