moose-inventory 2.0 → 2.1

data/lib/moose_inventory/cli/host_list.rb

@@ -1,38 +1,41 @@
+# frozen_string_literal: true
+
 require 'thor'
 require 'json'
 
-require_relative './formatter.rb'
-require_relative '../db/exceptions.rb'
+require_relative '../inventory_context'
+require_relative '../operations/query_inventory'
 
 module Moose
   module Inventory
     module Cli
-      ##
       # Implementation of the "host list" method of the CLI
       class Host
         desc 'list', 'List the contents of the inventory by host'
-        def list # rubocop:disable Metrics/AbcSize
-          # Convenience
-          db = Moose::Inventory::DB
-          fmt = Moose::Inventory::Cli::Formatter
+        option :group, type: :string, desc: 'Only include hosts in all comma-separated groups'
+        option :tag, type: :string, desc: 'Only include hosts with all comma-separated tags'
+        option :var, type: :string, desc: 'Only include hosts with comma-separated key=value variables'
+        def list
+          fmt.dump(inventory_query.list_hosts(filters: host_list_filters), output_format)
+        end
 
-          # Process
-          results = {}
-          db.models[:host].all.each do |host|
-            groups = host.groups_dataset.map(:name)
-            results[host[:name].to_sym] = {}
-            results[host[:name].to_sym][:groups] = groups
+        private
+
+        def host_list_filters
+          {
+            groups: csv_option_names(options[:group]),
+            tags: csv_option_names(options[:tag]),
+            variables: variable_filter_options(options[:var])
+          }
+        end
 
-            hostvars = {}
-            host.hostvars_dataset.each do |hv|
-              hostvars[hv[:name].to_sym] = hv[:value]
-            end
+        def variable_filter_options(value)
+          csv_option_names(value).to_h do |entry|
+            key, variable_value = entry.split('=', 2)
+            abort("ERROR: Invalid variable filter '#{entry}'. Expected key=value.") if variable_value.nil?
 
-            unless hostvars.empty?
-              results[host[:name].to_sym][:hostvars] = hostvars
-            end
+            [key, variable_value]
           end
-          fmt.dump(results)
         end
       end
     end

data/lib/moose_inventory/cli/host_listvars.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require 'thor'
 require 'json'
 
-require_relative './formatter.rb'
-require_relative '../db/exceptions.rb'
+require_relative '../inventory_context'
+require_relative '../operations/query_inventory'
 
 module Moose
   module Inventory
@@ -13,68 +15,13 @@ module Moose
         #==========================
         desc 'listvar', 'List all variables associated with the host'
         def listvars(*argv)
-          # Convenience
-          confopts = Moose::Inventory::Config._confopts
-
-          # sanity
-          if confopts[:ansible] == true
-            if argv.length != 1
-              abort('ERROR: Wrong number of arguments for Ansible mode, '\
-                    "#{args.length} for 1.")
-            end
-          else
-            if argv.empty?
-              abort('ERROR: Wrong number of arguments, '\
-                    "#{args.length} for 1 or more.")
-            end
-          end
-
-          # Convenience
-          db = Moose::Inventory::DB
-          fmt = Moose::Inventory::Cli::Formatter
-
-          # Arguments
-          names = argv.uniq.map(&:downcase)
-
-          # process
-          results = {}
-
-          if confopts[:ansible] == true
-            # This is the implementation per Ansible specs
-            name = names.first
-            host = db.models[:host].find(name: name)
-            if host.nil?
-              fmt.warn "The host #{name} does not exist.\n"
-            else
-              host.hostvars_dataset.each do |hv|
-                results[hv[:name].to_sym] = hv[:value]
-              end
-            end
+          validate_listvars_args(argv)
 
-            # Add the Ansible 1.3 '_meta' tag
-            # see http://docs.ansible.com/ansible/developing_inventory.html#tuning-the-external-inventory-script
-            results['_meta'.to_sym] = {}
-            results['_meta'.to_sym]['hostvars'.to_sym] = {}
-            db.models[:host].each do |host|
-              results['_meta'.to_sym]['hostvars'.to_sym][host.name.to_sym] = {}
-              host.hostvars_dataset.each do |hv|
-                results['_meta'.to_sym]['hostvars'.to_sym][host.name.to_sym][hv[:name].to_sym] = hv[:value]
-              end
-            end
+          names = normalize_names(argv)
+          results = inventory_query.list_host_vars(names: names, ansible: ansible_mode?)
+          warn_if_missing_ansible_listvars_entity(:host, names.first)
 
-          else
-            # This our more flexible implementation, which is not compatible
-            # with the Ansible specs
-            names.each do |name|
-              host = db.models[:host].find(name: name)
-              next if host.nil?
-              results[name.to_sym] = {}
-              host.hostvars_dataset.each do |hv|
-                results[name.to_sym][hv[:name].to_sym] = hv[:value]
-              end
-            end
-          end
-          fmt.dump(results)
+          fmt.dump(results, output_format)
         end
       end
     end

data/lib/moose_inventory/cli/host_rm.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require 'thor'
 require 'json'
 
-require_relative './formatter.rb'
-require_relative '../db/exceptions.rb'
+require_relative '../inventory_context'
+require_relative '../operations/remove_hosts'
 
 module Moose
   module Inventory
@@ -13,49 +15,65 @@ module Moose
         #==========================
         desc 'rm HOSTNAME_1 [HOSTNAME_2 ...]',
              'Remove hosts HOSTNAME_n from the inventory'
-        def rm(*argv) # rubocop:disable Metrics/AbcSize
-          #
-          # Sanity
-          if argv.empty?
-            abort('ERROR: Wrong number of arguments, '\
-              "#{argv.length} for 1 or more.")
-          end
+        option :dry_run, type: :boolean
+        option :yes, type: :boolean, desc: 'Confirm destructive removal without prompting'
+        option :plan_format, type: :string, desc: 'Emit dry-run plan events as yaml|json|pjson'
+        def rm(*argv)
+          abort_if_missing_args(argv, 1, '1 or more')
+          validate_machine_plan_request!
+
+          names = normalize_names(argv)
+          confirm_destructive_action!("host rm #{names.join(',')}")
+          result = remove_hosts_operation.call(names: names, dry_run: options[:dry_run])
+          return if machine_plan_output_rendered?(result, command: 'host rm')
+
+          record_audit({ command: 'host rm', action: 'remove', entity_type: 'host',
+                         entity_names: names }, result: result, dry_run: options[:dry_run])
+          render_remove_hosts_events(result.events)
+          print_warning_summary(result)
+        end
+
+        private
+
+        def remove_hosts_operation
+          build_operation(Moose::Inventory::Operations::RemoveHosts)
+        end
+
+        def render_remove_hosts_events(events)
+          events.each { |event| render_remove_hosts_event(event) }
+        end
 
-          # Convenience
-          db = Moose::Inventory::DB
-          fmt = Moose::Inventory::Cli::Formatter
-
-          # Arguments
-          names = argv.uniq.map(&:downcase)
-
-          # Transaction
-          warn_count = 0
-          db.transaction do # Transaction start
-            names.each do |name|
-              puts "Remove host '#{name}':"
-              fmt.puts 2, "- Retrieve host '#{name}'..."
-              host = db.models[:host].find(name: name)
-              if host.nil?
-                warn_count += 1
-                fmt.warn "Host '#{name}' does not exist, skipping.\n"
-                fmt.puts 4, '- No such host, skipping.'
-              end
-              fmt.puts 4, '- OK'
-              unless host.nil?
-                fmt.puts 2, "- Destroy host '#{name}'..."
-                host.remove_all_groups
-                host.destroy
-                fmt.puts 4, '- OK'
-              end
-              fmt.puts 2, '- All OK'
-            end
-          end # Transaction end
-          if warn_count == 0
-            puts 'Succeeded.'
-          else
-            puts 'Succeeded, with warnings.'
+        def render_remove_hosts_event(event)
+          payload = event.payload
+
+          return render_host_rm_progress(event.type, payload) if host_rm_progress_event?(event.type)
+          return render_host_rm_warning(payload) if event.type == :host_missing
+          return fmt.puts(payload[:indent], '- No such host, skipping.') if event.type == :missing_skipping
+          return fmt.puts(payload[:indent], '- OK') if event.type == :ok
+
+          return fmt.puts 2, '- All OK' if event.type == :host_complete
+
+          puts 'Dry run complete. No changes applied.' if event.type == :dry_run_summary
+        end
+
+        def host_rm_progress_event?(type)
+          %i[host_started retrieving_host destroying_host].include?(type)
+        end
+
+        def render_host_rm_progress(type, payload)
+          case type
+          when :host_started
+            puts "Remove host '#{payload[:name]}':"
+          when :retrieving_host
+            fmt.puts 2, "- Retrieve host '#{payload[:name]}'..."
+          when :destroying_host
+            fmt.puts 2, "- Destroy host '#{payload[:name]}'..."
           end
         end
+
+        def render_host_rm_warning(payload)
+          fmt.warn "Host '#{payload[:name]}' does not exist, skipping.\n"
+        end
       end
     end
   end

data/lib/moose_inventory/cli/host_rmgroup.rb

@@ -17,65 +17,46 @@ module Moose
         #==========================
         desc 'rmgroup HOSTNAME GROUPNAME [GROUPNAME ...]',
              'dissociation the host from a group'
+        option :dry_run, type: :boolean
+        option :yes, type: :boolean, desc: 'Confirm destructive dissociation without prompting'
+        option :plan_format, type: :string, desc: 'Emit dry-run plan events as yaml|json|pjson'
         def rmgroup(*args)
           abort_if_missing_args(args, 2, '2 or more')
+          validate_machine_plan_request!
 
           name = args[0].downcase
           groups = normalize_names(args.slice(1, args.length - 1))
 
           abort_if_automatic_group(groups)
-
-          context = Moose::Inventory::InventoryContext.new(db: db)
-          operation = Moose::Inventory::Operations::RemoveAssociations.new(context: context)
-
-          db.transaction do
-            puts "Dissociate host '#{name}' from groups '#{groups.join(',')}':"
-            host = fetch_existing_host_for_rmgroup(context, name)
-            render_host_rmgroup_events(
-              operation.host_from_groups(host: host, host_name: name, group_names: groups).events
-            )
-            fmt.puts 2, '- All OK'
+          confirm_destructive_action!("host rmgroup #{name} #{groups.join(',')}")
+
+          result = remove_groups_from_host(name, groups)
+          unless machine_plan_output_rendered?(
+            result, command: 'host rmgroup'
+          )
+            record_audit({ command: 'host rmgroup', action: 'dissociate', entity_type: 'host',
+                           entity_names: name }, result: result, dry_run: options[:dry_run])
+            print_warning_summary(result, success_message: 'Succeeded',
+                                          warning_message: 'Succeeded')
           end
-          puts 'Succeeded'
         end
 
         private
 
-        def fetch_existing_host_for_rmgroup(context, name)
-          fmt.puts 2, "- Retrieve host '#{name}'..."
-          host = context.find_host(name)
-          raise db.exceptions[:moose], "The host '#{name}' was not found in the database." if host.nil?
-
-          fmt.puts 4, '- OK'
-          host
-        end
-
-        def render_host_rmgroup_events(events)
-          events.each { |event| render_host_rmgroup_event(event) }
-        end
-
-        def render_host_rmgroup_event(event)
-          payload = event.payload
-
-          return render_host_rmgroup_warning(payload) if event.type == :host_group_association_missing
-          return render_host_rmgroup_missing(payload) if event.type == :missing_skipping
-
-          case event.type
-          when :removing_host_group_association
-            fmt.puts 2, "- Remove association {host:#{payload[:host]} <-> group:#{payload[:group]}}..."
-          when :adding_automatic_group
-            fmt.puts 2, "- Add automatic association {host:#{payload[:host]} <-> group:ungrouped}..."
-          when :ok
-            fmt.puts payload[:indent], '- OK'
+        def remove_groups_from_host(name, groups)
+          operation = build_operation(Moose::Inventory::Operations::RemoveAssociations)
+          run_host_relation_transaction(heading: "Dissociate host '#{name}' from groups '#{groups.join(',')}':") do
+            host = fetch_existing_host_or_raise(name)
+            result = operation.host_from_groups(host: host, host_name: name, group_names: groups,
+                                                dry_run: options[:dry_run])
+            render_host_rmgroup_events(result.events) unless machine_plan_output_requested?
+            result
           end
         end
 
-        def render_host_rmgroup_warning(payload)
-          fmt.warn "Association {host:#{payload[:host]} <-> group:#{payload[:group]}} doesn't exist, skipping.\n"
-        end
-
-        def render_host_rmgroup_missing(payload)
-          fmt.puts payload[:indent], "- Doesn't exist, skipping."
+        def render_host_rmgroup_events(events)
+          emitter = host_group_association_removal_emitter(perspective: :host)
+          events.each { |event| emitter.call(event) }
         end
       end
     end

data/lib/moose_inventory/cli/host_rmvar.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require 'thor'
 require 'json'
 
-require_relative './formatter.rb'
-require_relative '../db/exceptions.rb'
+require_relative '../inventory_context'
+require_relative '../operations/remove_variables'
 
 module Moose
   module Inventory
@@ -12,56 +14,40 @@ module Moose
       class Host
         #==========================
         desc 'rmvar', 'Remove a variable from the host'
-        # rubocop:disable Metrics/LineLength
-        def rmvar(*args) # rubocop:disable Metrics/AbcSize
-          # rubocop:enableMetrics/LineLength
-          if args.length < 2
-            abort('ERROR: Wrong number of arguments, ' \
-                  "#{args.length} for 2 or more.")
-          end
-
-          # Convenience
-          db  = Moose::Inventory::DB
-          fmt = Moose::Inventory::Cli::Formatter
+        option :dry_run, type: :boolean
+        option :yes, type: :boolean, desc: 'Confirm destructive removal without prompting'
+        option :plan_format, type: :string, desc: 'Emit dry-run plan events as yaml|json|pjson'
+        def rmvar(*args)
+          abort_if_missing_args(args, 2, '2 or more')
+          validate_machine_plan_request!
 
-          # Arguments
           name = args[0].downcase
           vars = args.slice(1, args.length - 1).uniq
+          confirm_destructive_action!("host rmvar #{name} #{vars.join(',')}")
+          operation = build_operation(Moose::Inventory::Operations::RemoveVariables,
+                                      entity_type: :host,
+                                      emitter: machine_plan_emitter(host_rmvar_emitter(name, vars)))
 
-          # Transaction
-          db.transaction do # Transaction start
-            puts "Remove variable(s) '#{vars.join(',')}' from host '#{name}':"
+          result = db.transaction do
+            operation.call(name: name, vars: vars, dry_run: options[:dry_run])
+          end
+
+          return if machine_plan_output_rendered?(result, command: 'host rmvar')
 
-            fmt.puts 2, "- retrieve host '#{name}'..."
-            host = db.models[:host].find(name: name)
-            if host.nil?
-              fail db.exceptions[:moose],
-                   "The host '#{name}' does not exist."
-            end
-            fmt.puts 4, '- OK'
+          record_audit({ command: 'host rmvar', action: 'remove_variable', entity_type: 'host',
+                         entity_names: name }, result: result, dry_run: options[:dry_run])
+          print_success_summary
+        end
 
-            hostvars_ds = host.hostvars_dataset
-            vars.each do |v|
-              fmt.puts 2, "- remove variable '#{v}'..."
-              vararray = v.split('=')
-              if v.start_with?('=') || v.scan('=').count > 1
-                fail db.exceptions[:moose],
-                     "Incorrect format in {#{v}}. " \
-                     'Expected \'key\' or \'key=value\'.'
-              end
+        private
 
-              # Check against existing associations
-              hostvar = hostvars_ds[name: vararray[0]]
-              unless hostvar.nil?
-                # remove the association
-                host.remove_hostvar(hostvar)
-                hostvar.destroy
-              end
-              fmt.puts 4, '- OK'
-            end
-            fmt.puts 2, '- all OK'
-          end # Transaction end
-          puts 'Succeeded.'
+        def host_rmvar_emitter(name, vars)
+          variable_operation_emitter(
+            action: :remove,
+            entity_label: 'host',
+            entity_name: name,
+            variables_label: vars.join(',')
+          )
         end
       end
     end

data/lib/moose_inventory/cli/host_tags.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Moose
+  module Inventory
+    module Cli
+      class Host
+        desc 'addtag HOST TAG_1 [TAG_2 ...]', 'Add metadata tags to a host'
+        def addtag(*args)
+          abort_if_missing_args(args, 2, '2 or more')
+
+          add_tags('host', args[0].downcase, args.slice(1, args.length - 1))
+        end
+
+        desc 'rmtag HOST TAG_1 [TAG_2 ...]', 'Remove metadata tags from a host'
+        option :yes, type: :boolean, desc: 'Confirm destructive tag removal without prompting'
+        def rmtag(*args)
+          abort_if_missing_args(args, 2, '2 or more')
+          confirm_destructive_action!("host rmtag #{args[0].downcase} #{args.slice(1, args.length - 1).join(',')}")
+
+          remove_tags('host', args[0].downcase, args.slice(1, args.length - 1))
+        end
+
+        desc 'listtags HOST', 'List metadata tags for a host'
+        option :format, type: :string, desc: 'Emit tags as yaml|json|pjson'
+        def listtags(*args)
+          abort_if_missing_args(args, 1, '1')
+
+          list_tags('host', args[0].downcase)
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/cli/listvars_support.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Moose
+  module Inventory
+    module Cli
+      # Shared argument and warning helpers for host/group listvars commands.
+      module ListvarsSupport
+        private
+
+        def validate_listvars_args(args)
+          if ansible_mode?
+            abort_if_wrong_ansible_listvars_arg_count(args, 1)
+          else
+            abort_if_missing_args(args, 1, '1 or more')
+          end
+        end
+
+        def warn_if_missing_ansible_listvars_entity(entity_type, name)
+          return unless ansible_mode?
+          return unless missing_listvars_entity?(entity_type, name)
+
+          fmt.warn missing_ansible_listvars_warning(entity_type, name)
+        end
+
+        def abort_if_wrong_ansible_listvars_arg_count(args, expected)
+          return if args.length == expected
+
+          abort("ERROR: Wrong number of arguments for Ansible mode, #{args.length} for #{expected}.")
+        end
+
+        def missing_listvars_entity?(entity_type, name)
+          case entity_type
+          when :host
+            inventory_context.find_host(name).nil?
+          when :group
+            inventory_context.find_group(name).nil?
+          else
+            raise ArgumentError, "Unsupported listvars entity type: #{entity_type.inspect}"
+          end
+        end
+
+        def missing_ansible_listvars_warning(entity_type, name)
+          case entity_type
+          when :host
+            "The host #{name} does not exist.\n"
+          when :group
+            "The Group #{name} does not exist."
+          else
+            raise ArgumentError, "Unsupported listvars entity type: #{entity_type.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/cli/plan_rendering.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Moose
+  module Inventory
+    module Cli
+      # Shared machine-readable dry-run plan rendering helpers.
+      module PlanRendering
+        private
+
+        def machine_plan_output_requested?
+          respond_to?(:options) && !options[:plan_format].nil?
+        end
+
+        def validate_machine_plan_request!
+          abort('ERROR: --plan-format requires --dry-run.') if machine_plan_output_requested? && !options[:dry_run]
+        end
+
+        def machine_plan_emitter(emitter)
+          machine_plan_output_requested? ? nil : emitter
+        end
+
+        def machine_plan_output_rendered?(result, command:)
+          return false unless machine_plan_output_requested?
+
+          fmt.dump(
+            {
+              command: command,
+              dry_run: true,
+              changes_applied: false,
+              events: result.events.map { |event| serialize_plan_event(event) }
+            },
+            options[:plan_format].downcase
+          )
+          true
+        end
+
+        def serialize_plan_event(event)
+          {
+            type: event.type.to_s,
+            payload: stringify_plan_payload(event.payload)
+          }
+        end
+
+        def stringify_plan_payload(payload)
+          payload.to_h.transform_keys(&:to_s)
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/cli/relation_transaction_support.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Moose
+  module Inventory
+    module Cli
+      # Shared transaction/fetch helpers for host/group relation commands.
+      module RelationTransactionSupport
+        private
+
+        def fetch_existing_group_or_abort(name)
+          fmt.puts 2, "- retrieve group '#{name}'..." unless machine_plan_output_requested?
+          group = inventory_context.find_group(name)
+          abort("ERROR: The group '#{name}' does not exist.") if group.nil?
+
+          fmt.puts 4, '- OK' unless machine_plan_output_requested?
+          group
+        end
+
+        def fetch_existing_host_or_raise(name)
+          fmt.puts 2, "- Retrieve host '#{name}'..." unless machine_plan_output_requested?
+          host = inventory_context.find_host(name)
+          raise db.exceptions[:moose], "The host '#{name}' was not found in the database." if host.nil?
+
+          fmt.puts 4, '- OK' unless machine_plan_output_requested?
+          host
+        end
+
+        def run_group_relation_transaction(heading:, on_error: nil, &)
+          run_relation_transaction(heading: heading, all_ok_message: '- all OK', on_error: on_error, &)
+        end
+
+        def run_host_relation_transaction(heading:, on_error: nil, &)
+          run_relation_transaction(heading: heading, all_ok_message: '- All OK', on_error: on_error, &)
+        end
+
+        def run_relation_transaction(heading:, all_ok_message:, on_error: nil)
+          result = nil
+          db.transaction do
+            puts heading unless machine_plan_output_requested?
+            result = yield
+            fmt.puts 2, all_ok_message unless machine_plan_output_requested?
+          end
+          result
+        rescue db.exceptions[:moose] => e
+          message = on_error ? on_error.call(e) : e.message
+          abort("ERROR: #{message}")
+        end
+      end
+    end
+  end
+end