moose-inventory 1.0.9 → 2.1

data/lib/moose_inventory/cli/helpers.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require_relative '../inventory_context'
+require_relative 'audit_recording'
+require_relative 'association_rendering'
+require_relative 'child_relation_rendering'
+require_relative 'factory'
+require_relative 'listvars_support'
+require_relative 'plan_rendering'
+require_relative 'relation_transaction_support'
+require_relative 'tag_support'
+require_relative 'variable_rendering'
+
+module Moose
+  module Inventory
+    module Cli
+      ##
+      # Shared helpers for Thor command classes.
+      module Helpers
+        include Moose::Inventory::Cli::AssociationRendering
+        include Moose::Inventory::Cli::AuditRecording
+        include Moose::Inventory::Cli::ChildRelationRendering
+        include Moose::Inventory::Cli::ListvarsSupport
+        include Moose::Inventory::Cli::PlanRendering
+        include Moose::Inventory::Cli::RelationTransactionSupport
+        include Moose::Inventory::Cli::TagSupport
+        include Moose::Inventory::Cli::VariableRendering
+
+        AUTOMATIC_GROUP = 'ungrouped'
+
+        private
+
+        def db
+          Moose::Inventory::DB
+        end
+
+        def inventory_context
+          @inventory_context ||= Moose::Inventory::InventoryContext.new(db: db)
+        end
+
+        def cli_factory
+          @cli_factory ||= Moose::Inventory::Cli::Factory.new(context: inventory_context)
+        end
+
+        def build_operation(operation_class, **)
+          cli_factory.operation(operation_class, **)
+        end
+
+        def inventory_query
+          cli_factory.query_inventory
+        end
+
+        def fmt
+          Moose::Inventory::Cli::Formatter
+        end
+
+        def runtime_options
+          Moose::Inventory::Config.runtime_options
+        end
+
+        def output_format
+          runtime_options.output_format
+        end
+
+        def ansible_mode?
+          runtime_options.ansible?
+        end
+
+        def normalize_names(values)
+          values.uniq.map(&:downcase)
+        end
+
+        def csv_option_names(value)
+          (value || '').downcase.split(',').uniq
+        end
+
+        def abort_if_missing_args(args, minimum, label)
+          return unless args.length < minimum
+
+          abort("ERROR: Wrong number of arguments, #{args.length} for #{label}.")
+        end
+
+        def abort_if_automatic_group(names, message = nil)
+          return unless names.include?(AUTOMATIC_GROUP)
+
+          abort(message || "ERROR: Cannot manually manipulate the automatic group '#{AUTOMATIC_GROUP}'.")
+        end
+
+        def confirm_destructive_action!(description)
+          return if options[:dry_run] || options[:yes]
+
+          abort("ERROR: #{description} is destructive. Re-run with --yes to confirm, or use --dry-run to preview.")
+        end
+
+        def association_exists?(dataset, name)
+          !dataset.nil? && !dataset[name: name].nil?
+        end
+
+        def exception_to_s(error)
+          error.to_s
+        end
+
+        def print_warning_summary(result, success_message: 'Succeeded.', warning_message: 'Succeeded, with warnings.')
+          warning_count = result.respond_to?(:warning_count) ? result.warning_count : 0
+          print_success_summary(warning_count.zero? ? success_message : warning_message)
+        end
+
+        def print_success_summary(message = 'Succeeded.')
+          puts message
+        end
+
+        def automatic_group
+          inventory_context.automatic_group
+        end
+
+        def remove_automatic_group_from_host(host, indent:, message:)
+          ungrouped = host.groups_dataset[name: AUTOMATIC_GROUP]
+          return if ungrouped.nil?
+
+          fmt.puts indent, message
+          host.remove_group(ungrouped)
+          fmt.puts indent + 2, '- OK'
+        end
+
+        def add_automatic_group_to_host_if_last_group(host, indent:, message:)
+          add_automatic_group_to_host_if_group_count(host, 1, indent: indent, message: message)
+        end
+
+        def add_automatic_group_to_host_if_no_groups(host, indent:, message:)
+          add_automatic_group_to_host_if_group_count(host, 0, indent: indent, message: message)
+        end
+
+        def add_automatic_group_to_host_if_group_count(host, group_count, indent:, message:)
+          return unless host.groups_dataset.count == group_count
+
+          fmt.puts indent, message
+          host.add_group(automatic_group)
+          fmt.puts indent + 2, '- OK'
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/cli/host.rb

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 require 'thor'
 require 'json'
 
-require_relative './formatter.rb'
-require_relative '../db/exceptions.rb'
+require_relative 'formatter'
+require_relative 'helpers'
+require_relative '../db/exceptions'
 
 module Moose
   module Inventory
@@ -10,6 +13,8 @@ module Moose
       ##
       # Class implementing the "host" methods of the CLI
       class Host < Thor
+        include Moose::Inventory::Cli::Helpers
+
         require_relative 'host_add'
         require_relative 'host_get'
         require_relative 'host_list'
@@ -19,6 +24,7 @@ module Moose
         require_relative 'host_addvar'
         require_relative 'host_listvars'
         require_relative 'host_rmvar'
+        require_relative 'host_tags'
       end
     end
   end

data/lib/moose_inventory/cli/host_add.rb

@@ -1,9 +1,13 @@
+# frozen_string_literal: true
+
 require 'thor'
 require 'json'
 require 'indentation'
 
-require_relative './formatter.rb'
-require_relative '../db/exceptions.rb'
+require_relative 'formatter'
+require_relative '../db/exceptions'
+require_relative '../inventory_context'
+require_relative '../operations/add_hosts'
 
 module Moose
   module Inventory
@@ -11,81 +15,102 @@ module Moose
       ##
       # Class implementing the "host" methods of the CLI
       class Host
+        ADD_HOST_EVENT_RENDERERS = {
+          host_started: :render_add_host_started,
+          creating_host: :render_add_host_creation,
+          host_exists: :render_add_host_exists_warning,
+          ok: :render_add_host_ok,
+          adding_association: :render_add_host_association,
+          group_missing_created: :render_add_host_missing_group_warning,
+          association_exists: :render_add_host_association_exists_warning,
+          adding_automatic_group: :render_add_host_automatic_group,
+          host_complete: :render_add_host_complete,
+          dry_run_summary: :render_dry_run_summary
+        }.freeze
+
         #==========================
         desc 'add HOSTNAME_1 [HOSTNAME_2 ...]',
              'Add a hosts HOSTNAME_n to the inventory'
         option :groups
-        # rubocop:disable Metrics/LineLength
-        def add(*argv) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-          # rubocop:enable Metrics/LineLength
-          if argv.empty?
-            abort('ERROR: Wrong number of arguments, '\
-              "#{argv.length} for 1 or more.")
-          end
-
-          # Convenience
-          db = Moose::Inventory::DB
-          fmt = Moose::Inventory::Cli::Formatter
+        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!
 
           # Arguments
-          names = argv.uniq.map(&:downcase)
+          names = normalize_names(argv)
 
           # split(/\W+/) splits on hyphens too, which is not what we want
           # groups = options[:groups].downcase.split(/\W+/).uniq
-          options[:groups].nil? && options[:groups] = ''
-          groups = options[:groups].downcase.split(',').uniq
+          groups = csv_option_names(options[:groups])
 
           # Sanity
-          if groups.include?('ungrouped')
-            abort('ERROR: Cannot manually manipulate '\
-              "the automatic group 'ungrouped'.")
-          end
-
-          # Process
-          db.transaction do # Transaction start
-            fmt.reset_indent
-
-            names.each do |name|
-              puts "Add host '#{name}':"
-              fmt.puts 2, "- Creating host '#{name}'..."
-              host = db.models[:host].find(name: name)
-              groups_ds = nil
-              if host.nil?
-                host = db.models[:host].create(name: name)
-              else
-                fmt.warn "The host '#{name}' already exists, skipping creation.\n"
-                groups_ds = host.groups_dataset
-              end
-              fmt.puts 4, '- OK'
-
-              groups.each do |g|
-                next if g.nil? || g.empty?
-                fmt.puts 2, "- Adding association {host:#{name} <-> group:#{g}}..."
-                group = db.models[:group].find(name: g)
-                if group.nil?
-                  fmt.warn "The group '#{g}' doesn't exist, but will be created.\n"
-                  group = db.models[:group].create(name: g)
-                end
-                if !groups_ds.nil? && !groups_ds[name: g].nil?
-                  fmt.warn "Association {host:#{name} <-> group:#{g}} already exists, skipping creation.\n"
-                else
-                  host.add_group(group)
-                end
-                fmt.puts 4, '- OK'
-              end
-
-              # Handle the automatic 'ungrouped' group
-              groups_ds = host.groups_dataset
-              if !groups_ds.nil? && groups_ds.count == 0
-                fmt.puts 2, "- Adding automatic association {host:#{name} <-> group:ungrouped}..."
-                ungrouped = db.models[:group].find_or_create(name: 'ungrouped')
-                host.add_group(ungrouped)
-                fmt.puts 4, '- OK'
-              end
-              fmt.puts 2, '- All OK'
-            end
-          end # Transaction end
-          puts 'Succeeded'
+          abort_if_automatic_group(groups)
+
+          result = build_operation(Moose::Inventory::Operations::AddHosts)
+                   .call(names: names, groups: groups, dry_run: options[:dry_run])
+          return if machine_plan_output_rendered?(result, command: 'host add')
+
+          record_audit({ command: 'host add', action: 'add', entity_type: 'host',
+                         entity_names: names }, result: result, dry_run: options[:dry_run])
+          render_add_hosts_events(result.events)
+          print_warning_summary(result, success_message: 'Succeeded', warning_message: 'Succeeded')
+        end
+
+        private
+
+        def render_add_hosts_events(events)
+          fmt.reset_indent
+          events.each { |event| render_add_hosts_event(event) }
+        end
+
+        def render_add_hosts_event(event)
+          renderer = ADD_HOST_EVENT_RENDERERS[event.type]
+          send(renderer, event.payload) unless renderer.nil?
+        end
+
+        def render_add_host_started(payload)
+          puts "Add host '#{payload[:name]}':"
+        end
+
+        def render_add_host_creation(payload)
+          fmt.puts 2, "- Creating host '#{payload[:name]}'..."
+        end
+
+        def render_add_host_exists_warning(payload)
+          fmt.warn "The host '#{payload[:name]}' already exists, skipping creation.\n"
+        end
+
+        def render_add_host_ok(payload)
+          fmt.puts payload[:indent], '- OK'
+        end
+
+        def render_add_host_association(payload)
+          fmt.puts 2, "- Adding association {host:#{payload[:host]} <-> group:#{payload[:group]}}..."
+        end
+
+        def render_add_host_missing_group_warning(payload)
+          fmt.warn "The group '#{payload[:name]}' doesn't exist, but will be created.\n"
+        end
+
+        def render_add_host_association_exists_warning(payload)
+          fmt.warn(
+            "Association {host:#{payload[:host]} <-> group:#{payload[:group]}} " \
+            "already exists, skipping creation.\n"
+          )
+        end
+
+        def render_add_host_automatic_group(payload)
+          fmt.puts 2, "- Adding automatic association {host:#{payload[:host]} <-> group:#{payload[:group]}}..."
+        end
+
+        def render_add_host_complete(_payload)
+          fmt.puts 2, '- All OK'
+        end
+
+        def render_dry_run_summary(_payload)
+          puts 'Dry run complete. No changes applied.'
         end
       end
     end

data/lib/moose_inventory/cli/host_addgroup.rb

@@ -1,8 +1,12 @@
+# frozen_string_literal: true
+
 require 'thor'
 require 'json'
 
-require_relative './formatter.rb'
-require_relative '../db/exceptions.rb'
+require_relative 'formatter'
+require_relative '../db/exceptions'
+require_relative '../inventory_context'
+require_relative '../operations/add_associations'
 
 module Moose
   module Inventory
@@ -12,75 +16,44 @@ module Moose
       class Host
         desc 'addgroup HOSTNAME GROUPNAME [GROUPNAME ...]',
              'Associate the host with a group'
-        # rubocop:disable Metrics/LineLength
-        def addgroup(*args) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
-          # rubocop:enable Metrics/LineLength
-          # Sanity
-          if args.length < 2
-            abort('ERROR: Wrong number of arguments, '\
-              "#{args.length} for 2 or more.")
+        option :dry_run, type: :boolean
+        option :plan_format, type: :string, desc: 'Emit dry-run plan events as yaml|json|pjson'
+        def addgroup(*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)
+
+          result = add_groups_to_host(name, groups)
+          unless machine_plan_output_rendered?(
+            result, command: 'host addgroup'
+          )
+            record_audit({ command: 'host addgroup', action: 'associate', entity_type: 'host',
+                           entity_names: name }, result: result, dry_run: options[:dry_run])
+            print_warning_summary(result, success_message: 'Succeeded',
+                                          warning_message: 'Succeeded')
           end
+        end
 
-          # Convenience
-          db = Moose::Inventory::DB
-          fmt = Moose::Inventory::Cli::Formatter
-
-          # Arguments
-          name   = args[0].downcase
-          groups = args.slice(1, args.length - 1).uniq.map(&:downcase)
+        private
 
-          # Sanity
-          if groups.include?('ungrouped')
-            abort 'ERROR: Cannot manually manipulate the automatic '\
-              'group \'ungrouped\'.'
+        def add_groups_to_host(name, groups)
+          operation = build_operation(Moose::Inventory::Operations::AddAssociations)
+          run_host_relation_transaction(heading: "Associate host '#{name}' with groups '#{groups.join(',')}':") do
+            host = fetch_existing_host_or_raise(name)
+            result = operation.host_to_groups(host: host, host_name: name, group_names: groups,
+                                              dry_run: options[:dry_run])
+            render_host_addgroup_events(result.events) unless machine_plan_output_requested?
+            result
           end
+        end
 
-          # Transaction
-          db.transaction do # Transaction start
-            puts "Associate host '#{name}' with groups '#{groups.join(',')}':"
-            # Get the target host
-            fmt.puts 2, "- Retrieve host '#{name}'..."
-            host = db.models[:host].find(name: name)
-            if host.nil?
-              fail db.exceptions[:moose], "The host '#{name}' "\
-                'was not found in the database.'
-            end
-            fmt.puts 4, '- OK'
-
-            # Associate host with the groups
-            groups_ds = host.groups_dataset
-            groups.each do |g|
-              fmt.puts 2,  "- Add association {host:#{name} <-> group:#{g}}..."
-
-              # Check against existing associations
-              if !groups_ds[name: g].nil?
-                fmt.warn "Association {host:#{name} <-> group:#{g}} already exists, skipping."
-                fmt.puts 4, '- Already exists, skipping.'
-              else
-                # Add new association
-                group = db.models[:group].find(name: g)
-                if group.nil?
-                  fmt.warn "Group '#{g}' does not exist and will be created."
-                  fmt.puts 4, '- Group does not exist, creating now...'
-                  group = db.models[:group].create(name: g)
-                  fmt.puts 6, '- OK'
-                end
-                host.add_group(group)
-              end
-              fmt.puts 4, '- OK'
-            end
-
-            # Handle 'ungrouped' group automation
-            unless groups_ds[name: 'ungrouped'].nil?
-              fmt.puts 2, '- Remove automatic association '\
-                "{host:#{name} <-> group:ungrouped}..."
-              ungrouped = db.models[:group].find(name: 'ungrouped')
-              host.remove_group(ungrouped) unless ungrouped.nil?
-              fmt.puts 4, '- OK'
-            end
-            fmt.puts 2, '- All OK'
-          end # Transaction end
-          puts 'Succeeded'
+        def render_host_addgroup_events(events)
+          emitter = host_group_association_addition_emitter(perspective: :host)
+          events.each { |event| emitter.call(event) }
         end
       end
     end

data/lib/moose_inventory/cli/host_addvar.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/add_variables'
 
 module Moose
   module Inventory
@@ -12,64 +14,38 @@ module Moose
       class Host
         #==========================
         desc 'addvar', 'Add a variable to the host'
-        # rubocop:disable Metrics/LineLength
-        def addvar(*args) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
-          # rubocop:enable Metrics/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 :plan_format, type: :string, desc: 'Emit dry-run plan events as yaml|json|pjson'
+        def addvar(*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
+          operation = build_operation(Moose::Inventory::Operations::AddVariables,
+                                      entity_type: :host,
+                                      emitter: machine_plan_emitter(host_addvar_emitter(name, vars)))
 
-          # Transaction
-          db.transaction do # Transaction start
-            puts "Add variables '#{vars.join(',')}' to host '#{name}':"
+          result = db.transaction do
+            operation.call(name: name, vars: vars, dry_run: options[:dry_run])
+          end
 
-            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'
+          return if machine_plan_output_rendered?(result, command: 'host addvar')
 
-            hostvars_ds = host.hostvars_dataset
-            vars.each do |v|
-              fmt.puts 2, "- add variable '#{v}'..."
-              vararray = v.split('=')
-              if v.start_with?('=') || v.end_with?('=') || vararray.length != 2
-                fail db.exceptions[:moose],
-                     "Incorrect format in '{#{v}}'. Expected 'key=value'."
-              end
+          record_audit({ command: 'host addvar', action: 'add_variable', entity_type: 'host',
+                         entity_names: name }, result: result, dry_run: options[:dry_run])
+          print_success_summary
+        end
 
-              # Check against existing associations
-              hostvar = hostvars_ds[name: vararray[0]]
-              if !hostvar.nil?
-                unless hostvar[:value] == vararray[1]
-                  fmt.puts 4, '- already exists, applying as an update...'
-                  update = db.models[:hostvar].find(id: hostvar[:id])
-                  update[:value] = vararray[1]
-                  update.save
-                end
-              else
-                # hostvar doesn't exist, so create and associate
-                hostvar = db.models[:hostvar].create(name: vararray[0],
-                                                     value: vararray[1])
-                host.add_hostvar(hostvar)
-              end
-              fmt.puts 4, '- OK'
-            end
-            fmt.puts 2, '- all OK'
-          end # Transaction end
+        private
 
-          puts 'Succeeded.'
+        def host_addvar_emitter(name, vars)
+          variable_operation_emitter(
+            action: :add,
+            entity_label: 'host',
+            entity_name: name,
+            variables_label: vars.join(',')
+          )
         end
       end
     end

data/lib/moose_inventory/cli/host_get.rb

@@ -1,54 +1,26 @@
+# 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
-      ##
       # Class implementing the "host get" method of the CLI
       class Host
         require_relative 'host_add'
 
-        #==========================
         desc 'get HOST_1 [HOST_2 ...]',
              'Get hosts HOST_n from the inventory'
-        def get(*argv) # rubocop:disable Metrics/AbcSize
-          if argv.empty?
-            abort('ERROR: Wrong number of arguments, '\
-              "#{argv.length} for 1 or more")
-          end
-
-          # Convenience
-          db = Moose::Inventory::DB
-          fmt = Moose::Inventory::Cli::Formatter
-
-          # Arguments
-          names = argv.uniq.map(&:downcase)
-
-          # Process
-          results = {}
-          names.each do |name|
-            host = db.models[:host].find(name: name)
-
-            next if host.nil?
-            groups = host.groups_dataset.map(:name)
-
-            hostvars = {}
-            host.hostvars_dataset.each do |hv|
-              hostvars[hv[:name].to_sym] = hv[:value]
-            end
-
-            results[host[:name].to_sym] = {}
-            results[host[:name].to_sym][:groups] = groups unless groups.empty?
-            unless hostvars.empty?
-              results[host[:name].to_sym][:hostvars] = hostvars
-            end
-          end
+        def get(*argv)
+          abort("ERROR: Wrong number of arguments, #{argv.length} for 1 or more") if argv.empty?
 
-          fmt.dump(results)
+          names = normalize_names(argv)
+          results = inventory_query.get_hosts(names: names)
+          fmt.dump(results, output_format)
         end
       end
     end