moose-inventory 2.0 → 2.1.1

data/lib/moose_inventory/cli/host_addgroup.rb

@@ -16,80 +16,44 @@ module Moose
       class Host
         desc 'addgroup HOSTNAME GROUPNAME [GROUPNAME ...]',
              'Associate the host with a group'
+        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)
 
-          context = Moose::Inventory::InventoryContext.new(db: db)
-          operation = Moose::Inventory::Operations::AddAssociations.new(context: context)
-
-          db.transaction do
-            puts "Associate host '#{name}' with groups '#{groups.join(',')}':"
-            host = fetch_existing_host_for_addgroup(context, name)
-            render_host_addgroup_events(
-              operation.host_to_groups(host: host, host_name: name, group_names: groups).events
-            )
-            fmt.puts 2, '- All OK'
+          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
-
-          puts 'Succeeded'
         end
 
         private
 
-        def fetch_existing_host_for_addgroup(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_addgroup_events(events)
-          events.each { |event| render_host_addgroup_event(event) }
-        end
-
-        def render_host_addgroup_event(event)
-          payload = event.payload
-
-          return render_host_addgroup_warning(event.type, payload) if host_addgroup_warning?(event.type)
-          return render_host_addgroup_status(payload) if event.type == :already_exists_skipping
-
-          render_host_addgroup_output(event.type, payload)
-        end
-
-        def host_addgroup_warning?(type)
-          %i[host_group_association_exists group_missing_created].include?(type)
-        end
-
-        def render_host_addgroup_warning(type, payload)
-          if type == :host_group_association_exists
-            fmt.warn "Association {host:#{payload[:host]} <-> group:#{payload[:group]}} already exists, skipping."
-          else
-            fmt.warn "Group '#{payload[:name]}' does not exist and will be created."
+        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
 
-        def render_host_addgroup_status(payload)
-          fmt.puts payload[:indent], '- Already exists, skipping.'
-        end
-
-        def render_host_addgroup_output(type, payload)
-          case type
-          when :adding_host_group_association
-            fmt.puts 2, "- Add association {host:#{payload[:host]} <-> group:#{payload[:group]}}..."
-          when :group_creating_now
-            fmt.puts 4, '- Group does not exist, creating now...'
-          when :removing_automatic_group
-            fmt.puts 2, "- Remove automatic association {host:#{payload[:host]} <-> group:ungrouped}..."
-          when :ok
-            fmt.puts payload[:indent], '- OK'
-          end
+        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

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