moose-inventory 1.0.9 → 2.0

data/lib/moose_inventory/cli/helpers.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Moose
+  module Inventory
+    module Cli
+      ##
+      # Shared helpers for Thor command classes.
+      module Helpers
+        AUTOMATIC_GROUP = 'ungrouped'
+
+        private
+
+        def db
+          Moose::Inventory::DB
+        end
+
+        def fmt
+          Moose::Inventory::Cli::Formatter
+        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 association_exists?(dataset, name)
+          !dataset.nil? && !dataset[name: name].nil?
+        end
+
+        def automatic_group
+          db.models[:group].find_or_create(name: 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

@@ -2,6 +2,7 @@ require 'thor'
 require 'json'
 
 require_relative './formatter.rb'
+require_relative './helpers.rb'
 require_relative '../db/exceptions.rb'
 
 module Moose
@@ -10,6 +11,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'

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
@@ -15,77 +19,58 @@ module Moose
         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
+        def add(*argv)
+          abort_if_missing_args(argv, 1, '1 or more')
 
           # 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
+          abort_if_automatic_group(groups)
 
-          # Process
-          db.transaction do # Transaction start
-            fmt.reset_indent
+          result = Moose::Inventory::Operations::AddHosts
+                   .new(context: Moose::Inventory::InventoryContext.new(db: db))
+                   .call(names: names, groups: groups)
+          render_add_hosts_events(result.events)
+          puts 'Succeeded'
+        end
 
-            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'
+        private
 
-              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
+        def render_add_hosts_events(events)
+          fmt.reset_indent
+          events.each { |event| render_add_hosts_event(event) }
+        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'
+        def render_add_hosts_event(event) # rubocop:disable Metrics/CyclomaticComplexity
+          payload = event.payload
+          case event.type
+          when :host_started
+            puts "Add host '#{payload[:name]}':"
+          when :creating_host
+            fmt.puts 2, "- Creating host '#{payload[:name]}'..."
+          when :host_exists
+            fmt.warn "The host '#{payload[:name]}' already exists, skipping creation.\n"
+          when :ok
+            fmt.puts payload[:indent], '- OK'
+          when :adding_association
+            fmt.puts 2, "- Adding association {host:#{payload[:host]} <-> group:#{payload[:group]}}..."
+          when :group_missing_created
+            fmt.warn "The group '#{payload[:name]}' doesn't exist, but will be created.\n"
+          when :association_exists
+            fmt.warn(
+              "Association {host:#{payload[:host]} <-> group:#{payload[:group]}} " \
+              "already exists, skipping creation.\n"
+            )
+          when :adding_automatic_group
+            fmt.puts 2, "- Adding automatic association {host:#{payload[:host]} <-> group:#{payload[:group]}}..."
+          when :host_complete
+            fmt.puts 2, '- All OK'
+          end
         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,76 +16,81 @@ 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.")
-          end
+        def addgroup(*args)
+          abort_if_missing_args(args, 2, '2 or more')
 
-          # Convenience
-          db = Moose::Inventory::DB
-          fmt = Moose::Inventory::Cli::Formatter
+          name = args[0].downcase
+          groups = normalize_names(args.slice(1, args.length - 1))
 
-          # Arguments
-          name   = args[0].downcase
-          groups = args.slice(1, args.length - 1).uniq.map(&:downcase)
+          abort_if_automatic_group(groups)
 
-          # Sanity
-          if groups.include?('ungrouped')
-            abort 'ERROR: Cannot manually manipulate the automatic '\
-              'group \'ungrouped\'.'
-          end
+          context = Moose::Inventory::InventoryContext.new(db: db)
+          operation = Moose::Inventory::Operations::AddAssociations.new(context: context)
 
-          # Transaction
-          db.transaction do # Transaction start
+          db.transaction do
             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
+            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'
-          end # Transaction end
+          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."
+          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
+        end
       end
     end
   end

data/lib/moose_inventory/cli/host_rmgroup.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/remove_associations'
 
 module Moose
   module Inventory
@@ -13,67 +17,66 @@ module Moose
         #==========================
         desc 'rmgroup HOSTNAME GROUPNAME [GROUPNAME ...]',
              'dissociation the host from a group'
-        # rubocop:disable Metrics/LineLength
-        def rmgroup(*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
+        def rmgroup(*args)
+          abort_if_missing_args(args, 2, '2 or more')
 
-          # Convenience
-          db = Moose::Inventory::DB
-          fmt = Moose::Inventory::Cli::Formatter
+          name = args[0].downcase
+          groups = normalize_names(args.slice(1, args.length - 1))
 
-          # arguments
-          name   = args[0].downcase
-          groups = args.slice(1, args.length - 1).uniq.map(&:downcase)
+          abort_if_automatic_group(groups)
 
-          # Sanity
-          if groups.include?('ungrouped')
-            abort 'ERROR: Cannot manually manipulate the automatic '\
-              'group \'ungrouped\'.'
-          end
+          context = Moose::Inventory::InventoryContext.new(db: db)
+          operation = Moose::Inventory::Operations::RemoveAssociations.new(context: context)
 
-          # Transaction
-          db.transaction do # Transaction start
+          db.transaction do
             puts "Dissociate host '#{name}' from groups '#{groups.join(',')}':"
-            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'
-
-            # dissociate host from the groups
-            groups_ds = host.groups_dataset
-            groups.each do |g|
-              fmt.puts 2, "- Remove association {host:#{name} <-> group:#{g}}..."
-
-              # Check against existing associations
-              if groups_ds[name: g].nil?
-                fmt.warn "Association {host:#{name} <-> group:#{g}} doesn't exist, skipping.\n"
-                fmt.puts 4, "- Doesn't exist, skipping."
-              else
-                group = db.models[:group].find(name: g)
-                host.remove_group(group) unless group.nil?
-              end
-              fmt.puts 4, '- OK'
-            end
-
-            # Handle 'ungrouped' group automation
-            if host.groups_dataset.count == 0
-              fmt.puts 2, '- Add automatic association '\
-                "{host:#{name} <-> group:ungrouped}..."
-              ungrouped = db.models[:group].find_or_create(name: 'ungrouped')
-              host.add_group(ungrouped) unless ungrouped.nil?
-              fmt.puts 4, '- OK'
-            end
+            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'
-          end # End transaction
+          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'
+          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."
+        end
       end
     end
   end

data/lib/moose_inventory/db/db.rb

@@ -92,7 +92,7 @@ module Moose
           case tries
           when 1..10
             if Moose::Inventory::Config._confopts[:trace] == true
-              STDERR.puts e.message
+              $stderr.puts e.message
             end
             sleep rand
             retry
@@ -108,8 +108,8 @@ module Moose
           warn 'An error occurred during a transaction, any changes have been rolled back.'
 
           if Moose::Inventory::Config._confopts[:trace] == true
-            STDERR.puts $ERROR_INFO.backtrace
-            abort("ERROR: #{e}")
+            $stderr.puts e.full_message(highlight: false, order: :top)
+            abort("ERROR: #{e.message}")
           else
             abort("ERROR: #{e.message}")
           end
@@ -272,15 +272,16 @@ module Moose
 
         # Quick check that expected keys are at least present
         config = Moose::Inventory::Config._settings[:config][:db]
-        [:host, :database, :user, :password].each do |key|
+        [:host, :database, :user].each do |key|
           if config[key].nil?
             fail @exceptions[:moose],
                  "Expected key #{key} missing in mysql configuration"
           end
         end
+        password = db_password(config, 'mysql')
 
         @db = Sequel.mysql2(user: config[:user],
-                            password: config[:password],
+                            password: password,
                             host: config[:host],
                             database: config[:database])
       end
@@ -291,18 +292,37 @@ module Moose
 
         # Quick check that expected keys are at least present
         config = Moose::Inventory::Config._settings[:config][:db]
-        [:host, :database, :user, :password].each do |key|
+        [:host, :database, :user].each do |key|
           if config[key].nil?
             fail @exceptions[:moose],
                  "Expected key #{key} missing in postgresql configuration"
           end
         end
+        password = db_password(config, 'postgresql')
 
         @db = Sequel.postgres(user: config[:user],
-                              password: config[:password],
+                              password: password,
                               host: config[:host],
                               database: config[:database])
       end
+
+      #--------------------
+      def self.db_password(config, adapter)
+        return config[:password] unless config[:password].nil?
+
+        if config[:password_env].nil?
+          fail @exceptions[:moose],
+               "Expected key password or password_env missing in #{adapter} configuration"
+        end
+
+        password = ENV.fetch(config[:password_env].to_s, nil)
+        if password.nil? || password.empty?
+          fail @exceptions[:moose],
+               "Environment variable #{config[:password_env]} is not set for #{adapter} password"
+        end
+
+        password
+      end
     end
   end
 end

data/lib/moose_inventory/inventory_context.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Moose
+  module Inventory
+    ##
+    # Thin facade over the current DB singleton.
+    #
+    # This gives new operation/service objects a small inventory-facing seam
+    # without forcing the legacy CLI to stop using the DB singleton all at once.
+    class InventoryContext
+      AUTOMATIC_GROUP = 'ungrouped'
+
+      def initialize(db: Moose::Inventory::DB)
+        @db = db
+      end
+
+      def transaction(&)
+        db.transaction(&)
+      end
+
+      def find_host(name)
+        db.models[:host].find(name: name)
+      end
+
+      def create_host(name)
+        db.models[:host].create(name: name)
+      end
+
+      def find_group(name)
+        db.models[:group].find(name: name)
+      end
+
+      def create_group(name)
+        db.models[:group].create(name: name)
+      end
+
+      def find_or_create_group(name)
+        db.models[:group].find_or_create(name: name)
+      end
+
+      def automatic_group
+        find_or_create_group(AUTOMATIC_GROUP)
+      end
+
+      private
+
+      attr_reader :db
+    end
+  end
+end