moose-inventory 2.0 → 2.1

data/lib/moose_inventory/cli/tag_support.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Moose
+  module Inventory
+    module Cli
+      # Shared host/group metadata tag commands.
+      module TagSupport
+        private
+
+        def add_tags(entity_type, entity_name, tag_names)
+          entity = fetch_tag_entity(entity_type, entity_name)
+          normalized = normalize_tags(tag_names)
+          changed = []
+
+          db.transaction do
+            normalized.each do |tag_name|
+              tag = inventory_context.find_or_create_tag(tag_name)
+              next unless entity.tags_dataset[name: tag_name].nil?
+
+              entity.add_tag(tag)
+              changed << tag_name
+            end
+          end
+
+          result = tag_result(events: changed.map { |tag| tag_event(:tag_added, entity_type, entity_name, tag) })
+          record_tag_audit(command: 'addtag', action: 'add_tag', entity_type: entity_type,
+                           entity_name: entity_name, result: result, changed: changed)
+          puts "Added #{entity_type} tag(s) to '#{entity_name}': #{changed.join(', ')}."
+        end
+
+        def remove_tags(entity_type, entity_name, tag_names)
+          entity = fetch_tag_entity(entity_type, entity_name)
+          normalized = normalize_tags(tag_names)
+          changed = []
+
+          db.transaction do
+            normalized.each do |tag_name|
+              tag = entity.tags_dataset[name: tag_name]
+              next if tag.nil?
+
+              entity.remove_tag(tag)
+              changed << tag_name
+            end
+          end
+
+          result = tag_result(events: changed.map { |tag| tag_event(:tag_removed, entity_type, entity_name, tag) })
+          record_tag_audit(command: 'rmtag', action: 'remove_tag', entity_type: entity_type,
+                           entity_name: entity_name, result: result, changed: changed)
+          puts "Removed #{entity_type} tag(s) from '#{entity_name}': #{changed.join(', ')}."
+        end
+
+        def list_tags(entity_type, entity_name)
+          entity = fetch_tag_entity(entity_type, entity_name)
+          tags = entity.tags_dataset.order(:name).map(:name)
+
+          if options[:format]
+            fmt.dump({ entity_type => entity_name, tags: tags }, options[:format].downcase)
+          elsif tags.empty?
+            puts "#{entity_type.capitalize} '#{entity_name}' has no tags."
+          else
+            puts "#{entity_type.capitalize} '#{entity_name}' tags: #{tags.join(', ')}"
+          end
+        end
+
+        def fetch_tag_entity(entity_type, entity_name)
+          entity = inventory_context.public_send("find_#{entity_type}", entity_name)
+          abort("ERROR: The #{entity_type} '#{entity_name}' does not exist.") if entity.nil?
+
+          entity
+        end
+
+        def normalize_tags(values)
+          inventory_context.normalize_tag_names(values)
+        end
+
+        def tag_result(events:)
+          Moose::Inventory::Operations::OperationEventSupport::Result.new(events: events, warning_count: 0)
+        end
+
+        def tag_event(type, entity_type, entity_name, tag_name)
+          Moose::Inventory::Operations::OperationEventSupport::Event.new(
+            type: type,
+            payload: { entity_type: entity_type, entity_name: entity_name, tag: tag_name }
+          )
+        end
+
+        def record_tag_audit(metadata)
+          return if metadata.fetch(:changed).empty?
+
+          record_audit({ command: "#{metadata.fetch(:entity_type)} #{metadata.fetch(:command)}",
+                         action: metadata.fetch(:action), entity_type: metadata.fetch(:entity_type),
+                         entity_names: metadata.fetch(:entity_name) }, result: metadata.fetch(:result))
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/cli/variable_rendering.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Moose
+  module Inventory
+    module Cli
+      # Shared rendering helpers for variable add/remove commands.
+      module VariableRendering
+        private
+
+        def variable_operation_emitter(action:, entity_label:, entity_name:, variables_label:)
+          lambda do |event|
+            render_variable_event(
+              event,
+              action: action,
+              entity_label: entity_label,
+              entity_name: entity_name,
+              variables_label: variables_label
+            )
+          end
+        end
+
+        def render_variable_event(event, action:, entity_label:, entity_name:, variables_label:)
+          if event.type == :entity_started
+            return puts(variable_operation_heading(action:, entity_label:, entity_name:,
+                                                   variables_label:))
+          end
+          return render_variable_change(event, entity_label) if variable_change_event?(event.type)
+          return puts 'Dry run complete. No changes applied.' if event.type == :dry_run_summary
+
+          render_variable_status(event)
+        end
+
+        def variable_operation_heading(action:, entity_label:, entity_name:, variables_label:)
+          return "Add variables '#{variables_label}' to #{entity_label} '#{entity_name}':" if action == :add
+
+          "Remove variable(s) '#{variables_label}' from #{entity_label} '#{entity_name}':"
+        end
+
+        def variable_change_event?(type)
+          %i[retrieving_entity adding_variable removing_variable updating_existing_variable].include?(type)
+        end
+
+        def render_variable_change(event, entity_label)
+          case event.type
+          when :retrieving_entity
+            fmt.puts 2, "- retrieve #{entity_label} '#{event.payload[:name]}'..."
+          when :adding_variable
+            fmt.puts 2, "- add variable '#{event.payload[:variable]}'..."
+          when :removing_variable
+            fmt.puts 2, "- remove variable '#{event.payload[:variable]}'..."
+          when :updating_existing_variable
+            fmt.puts 4, '- already exists, applying as an update...'
+          end
+        end
+
+        def render_variable_status(event)
+          case event.type
+          when :entity_complete
+            fmt.puts 2, '- all OK'
+          when :ok
+            fmt.puts event.payload[:indent], '- OK'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/config/config.rb

@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
 # Configuration
 
 require 'yaml'
 
+require_relative '../runtime_options'
+
 module Moose
   module Inventory
     ##
@@ -11,16 +15,16 @@ module Moose
       extend self
       # rubocop:enable Style/ModuleFunction
 
-      @_argv     = []
+      @_argv = []
       @_confopts = {}
       @_settings = {}
+      @runtime_options = nil
 
-      attr_reader :_argv
-      attr_reader :_confopts
-      attr_reader :_settings
+      attr_reader :_argv, :_confopts, :_settings
 
       #----------------------
       def self.init(args)
+        reset_runtime_state
         @_argv = args.dup
 
         top_level_help
@@ -28,6 +32,46 @@ module Moose
         ansible_args
         resolve_config_file
         load
+        refresh_runtime_options
+      end
+
+      def self.reset_runtime_state
+        @_argv = []
+        @_confopts = default_confopts
+        @_settings = {}
+        @runtime_options = nil
+      end
+
+      def self.default_confopts
+        { env: '', format: 'json', ansible: false, trace: false }
+      end
+
+      def self.runtime_options
+        @runtime_options ||= build_runtime_options
+      end
+
+      def self.application_args
+        runtime_options.argv
+      end
+
+      def self.output_format
+        runtime_options.output_format
+      end
+
+      def self.ansible?
+        runtime_options.ansible? || @_confopts[:ansible] == true
+      end
+
+      def self.trace_enabled?
+        runtime_options.trace? || @_confopts[:trace] == true
+      end
+
+      def self.db_settings
+        @_settings[:config][:db]
+      end
+
+      def self._runtime_options
+        @runtime_options
       end
 
       #----------------------
@@ -51,50 +95,26 @@ module Moose
         # -- trace       => Enable more complete exceptions for db transactions
         #                   Default is not to trace.
 
-        @_confopts = { env: '', format: 'json', ansible: false, trace: false }
-
-        # Check for two-part flags
-        %w(config env format).each do |var|
-          @_argv.each_with_index do |val, index|
-            next if val != "--#{var}"
-            @_confopts[var.to_sym] = @_argv[index + 1]
-            1.downto(0) { |offset| @_argv.delete_at(index + offset) }
-            break
-          end
-        end
-
-        # Check for one-part flags
-        %w(ansible trace).each do |var|
-          @_argv.each_with_index do |val, index|
-            next if val != "--#{var}"
-            @_confopts[var.to_sym] = true
-            @_argv.delete_at(index)
-            break
-          end
-        end
-
-        # Sanity
-        # - Ansible output format must be json - pjson is permitted, but yaml is not.
-        if @_confopts[:ansible] == true
-          unless @_confopts[:format] =~ /p|pjson|j|json/
-            @_confopts[:format] = 'json'
-          end
-        end
+        extract_value_flags(%w[config env format])
+        extract_boolean_flags(%w[ansible trace])
+        normalize_ansible_format!
       end
 
       #----------------------
       def self.top_level_help
-        if @_argv[0] == 'help'
-          puts 'Global flags:'
-          printf '  %-31s %-10s', '--ansible', "# Force Ansible mode (automatically set when using ansible flags)\n"
-          printf '  %-31s %-10s', '--config FILE', "# Specifies a configuration file to use\n"
-          printf '  %-31s %-10s', '--env ENV', "# Specifies the environment section of the config to use\n"
-          printf '  %-31s %-10s', '--format yaml|json|pjson', "# Format for the output of 'get', 'list', and 'listvars' subcommands\n"
-          printf '  %-31s %-10s', '--trace', "# Enable more complete exception dumps for database transactions\n"
-          puts "\nAnsible flags:"
-          printf '  %-31s %-10s', '--host HOSTNAME', "# Retrieves host variables for the specified host (alias for 'host listvars HOSTNAME')\n"
-          printf '  %-31s %-10s', '--list', "# Retrieves the list of groups (alias for 'group list')\n\n"
-        end
+        return unless @_argv[0] == 'help'
+
+        puts 'Global flags:'
+        printf '  %-31s %-10s', '--ansible', "# Force Ansible mode (automatically set when using ansible flags)\n"
+        printf '  %-31s %-10s', '--config FILE', "# Specifies a configuration file to use\n"
+        printf '  %-31s %-10s', '--env ENV', "# Specifies the environment section of the config to use\n"
+        printf '  %-31s %-10s', '--format yaml|json|pjson',
+               "# Format for the output of 'get', 'list', and 'listvars' subcommands\n"
+        printf '  %-31s %-10s', '--trace', "# Enable more complete exception dumps for database transactions\n"
+        puts "\nAnsible flags:"
+        printf '  %-31s %-10s', '--host HOSTNAME',
+               "# Retrieves host variables for the specified host (alias for 'host listvars HOSTNAME')\n"
+        printf '  %-31s %-10s', '--list', "# Retrieves the list of groups (alias for 'group list')\n\n"
       end
 
       #----------------------
@@ -108,95 +128,152 @@ module Moose
 
         case @_argv[0]
         when '--list'
-          @_confopts[:ansible] = true
-          @_confopts[:format] = 'json' unless @_confopts[:format] =~ /p|pjson|j|json/
-          @_argv.clear
-          @_argv.concat(%w(group list)).flatten
+          apply_ansible_alias!(%w[group list])
         when '--host'
-          @_confopts[:ansible] = true
-          @_confopts[:format] = 'json' unless @_confopts[:format] =~ /p|pjson|j|json/
           host = @_argv[1]
-          @_argv.clear
-          @_argv.concat(['host', 'listvars', host.to_s]).flatten
+          apply_ansible_alias!(['host', 'listvars', host.to_s])
         end
       end
 
       #----------------------
       def self.resolve_config_file
-        if !@_confopts[:config].nil?
-          path = File.expand_path(@_confopts[:config])
-          if File.exist?(path)
-            @_confopts[:config] = path
-          else
-            fail("The configuration file #{path} does not exist")
-          end
-        else
-          possibles = ['./.moose-tools/inventory/config',
-                       '~/.moose-tools/inventory/config',
-                       '~/local/etc/moose-tools/inventory/config',
-                       '/etc/moose-tools/inventory/config']
-          possibles.each do |f|
-            file = File.expand_path(f)
-            @_confopts[:config] = file if File.exist?(file)
-          end
-        end
+        explicit_path = @_confopts[:config]
+        @_confopts[:config] = if explicit_path.nil?
+                                find_default_config_file
+                              else
+                                validated_config_path(explicit_path)
+                              end
 
-        if @_confopts[:config].nil?
-          fail('No configuration either given or found in standard locations.')
-        end
+        raise('No configuration either given or found in standard locations.') if @_confopts[:config].nil?
       end
 
       #----------------------
       def self.symbolize_keys(hash)
-        # rubocop:disable Style/EachWithObject
-        hash.inject({}) do |result, (key, value)|
-          new_key = case key
-                    when String then key.to_sym
-                    else key
-                    end
-          new_value = case value
-                      when Hash then symbolize_keys(value)
-                      else value
-                      end
-          result[new_key] = new_value
-          result
+        hash.each_with_object({}) do |(key, value), result|
+          result[symbolize_key(key)] = value.is_a?(Hash) ? symbolize_keys(value) : value
         end
-        # rubocop:enable Style/EachWithObject
       end
 
       #----------------------
-      # rubocop:disable PerceivedComplexity
-      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize
       def self.load
-        newsets = symbolize_keys(YAML.safe_load_file(
-          @_confopts[:config],
-          aliases: false,
-          permitted_classes: [],
-          permitted_symbols: []
-        ))
-
+        newsets = load_config_file(@_confopts[:config])
         path = @_confopts[:config]
 
-        # Get the "general" section
-        @_settings[:general] = newsets[:general]
-        @_settings[:general].nil? && fail("Missing 'general' root in #{path}")
+        @_settings[:general] = fetch_general_settings(newsets, path)
+
+        env, settings = resolve_environment_settings(newsets, path)
+        @_settings[:config] = settings
+        @_settings[:config].nil? && raise("Missing '#{env}' root in #{path}")
+      end
+
+      def self.load_config_file(path)
+        symbolize_keys(YAML.safe_load_file(
+                         path,
+                         aliases: false,
+                         permitted_classes: [],
+                         permitted_symbols: []
+                       ))
+      end
 
-        # Get the config for the correct environment
+      def self.fetch_general_settings(newsets, path)
+        general = newsets[:general]
+        general.nil? && raise("Missing 'general' root in #{path}")
+        general
+      end
+
+      def self.resolve_environment_settings(newsets, path)
+        env = selected_environment(newsets, path)
+        [env, newsets[env.to_sym]]
+      end
 
-        if @_confopts[:env] && !@_confopts[:env].empty?
-          env = @_confopts[:env]
-          @_settings[:config] = newsets[@_confopts[:env].to_sym]
-        else
-          env = @_settings[:general][:defaultenv]
-          (env.nil? || env.empty?) && fail("No defaultenv set in #{path}")
-          @_settings[:config] = newsets[env.to_sym]
+      def self.selected_environment(newsets, path)
+        return @_confopts[:env] if @_confopts[:env] && !@_confopts[:env].empty?
+
+        env = newsets.dig(:general, :defaultenv)
+        (env.nil? || env.empty?) && raise("No defaultenv set in #{path}")
+        env
+      end
+
+      def self.standard_config_paths
+        ['./.moose-tools/inventory/config',
+         '~/.moose-tools/inventory/config',
+         '~/local/etc/moose-tools/inventory/config',
+         '/etc/moose-tools/inventory/config']
+      end
+
+      def self.find_default_config_file
+        standard_config_paths.map { |path| File.expand_path(path) }.find do |path|
+          File.exist?(path)
         end
+      end
+
+      def self.validated_config_path(path)
+        expanded = File.expand_path(path)
+        raise("The configuration file #{expanded} does not exist") unless File.exist?(expanded)
+
+        expanded
+      end
+
+      def self.extract_value_flags(flags)
+        flags.each { |flag| extract_value_flag(flag) }
+      end
+
+      def self.extract_value_flag(flag)
+        index = @_argv.index("--#{flag}")
+        return if index.nil?
 
-        @_settings[:config].nil? && fail("Missing '#{env}' root in #{path}")
+        value = @_argv[index + 1]
+        raise("Expected a value after --#{flag}") if value.nil? || value.start_with?('--')
+
+        @_confopts[flag.to_sym] = value
+        @_argv.slice!(index, 2)
+      end
+
+      def self.extract_boolean_flags(flags)
+        flags.each { |flag| extract_boolean_flag(flag) }
+      end
+
+      def self.extract_boolean_flag(flag)
+        index = @_argv.index("--#{flag}")
+        return if index.nil?
+
+        @_confopts[flag.to_sym] = true
+        @_argv.delete_at(index)
+      end
+
+      def self.normalize_ansible_format!
+        return unless @_confopts[:ansible] == true
+        return if @_confopts[:format] =~ /p|pjson|j|json/
+
+        @_confopts[:format] = 'json'
+      end
+
+      def self.apply_ansible_alias!(argv)
+        @_confopts[:ansible] = true
+        normalize_ansible_format!
+        @_argv = argv
+      end
+
+      def self.refresh_runtime_options
+        @runtime_options = build_runtime_options
+      end
+
+      def self.build_runtime_options
+        Moose::Inventory::RuntimeOptions.new(
+          argv: @_argv.dup,
+          config: @_confopts[:config],
+          env: @_confopts[:env],
+          format: @_confopts[:format],
+          flags: {
+            ansible: @_confopts[:ansible],
+            trace: @_confopts[:trace]
+          }
+        )
+      end
 
-        # And now we should have a valid config stuffed into @_options[:config]
+      def self.symbolize_key(key)
+        key.is_a?(String) ? key.to_sym : key
       end
-      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize
     end
   end
 end