moose-inventory 1.0.8 → 2.0

data/lib/moose_inventory/cli/group_addchild.rb

@@ -1,92 +1,105 @@
+# frozen_string_literal: true
+
 require 'thor'
-require_relative './formatter.rb'
+require_relative 'formatter'
+require_relative '../inventory_context'
+require_relative '../operations/group_child_relations'
 
 module Moose
   module Inventory
     module Cli
       ##
       # Implemention of the "group addchild" methods of the CLI
-      class Group < Thor # rubocop:disable ClassLength
+      class Group < Thor
         #==========================
         desc 'addchild PARENTGROUP CHILDGROUP_1 [CHILDGROUP_2 ... ]',
              'Associate one or more child-groups CHILDGROUP_n with PARENTGROUP'
         def addchild(*argv)
-          
-          # Sanity check
-          if args.length < 2
-            abort("ERROR: Wrong number of arguments, #{args.length} "\
-              "for 2 or more.")
-          end
-          
-          # Arguments
-          pname = args[0].downcase
-          cnames = args.slice(1, args.length - 1).uniq.map(&:downcase)
-           
-          # Sanity
-          if pname == 'ungrouped' || cnames.include?('ungrouped')
-            abort("ERROR: Cannot manually manipulate the automatic group 'ungrouped'.")
+          abort_if_missing_args(argv, 2, '2 or more')
+
+          pname = argv[0].downcase
+          cnames = normalize_names(argv.slice(1, argv.length - 1))
+
+          abort_if_automatic_group([pname] + cnames)
+
+          result = add_children_to_group(pname, cnames)
+
+          if result.warning_count.zero?
+            puts 'Succeeded.'
+          else
+            puts 'Succeeded, with warnings.'
           end
-          
-          # Convenience
-          db = Moose::Inventory::DB
-          fmt = Moose::Inventory::Cli::Formatter
-
-          # Transaction
-          warn_count = 0
-          begin 
-            db.transaction do # Transaction start
-              puts "Associate parent group '#{pname}' with child group(s) '#{cnames.join(',')}':"
-              # Get the target group
-              fmt.puts 2, "- retrieve group '#{pname}'..."
-              pgroup = db.models[:group].find(name: pname)
-              if pgroup.nil?
-                abort("ERROR: The group '#{pname}' does not exist.")
-              end
-              fmt.puts 4, "- OK"
-              
-               # Associate parent group with the child groups
-
-               groups_ds = pgroup.children_dataset
-               cnames.each do |cname|
-                 fmt.puts 2, "- add association {group:#{pname} <-> group:#{cname}}..."
-                  
-                 # Check against existing associations
-                 unless groups_ds[name: cname].nil?
-                    warn_count += 1
-                    fmt.warn "Association {group:#{pname} <-> group:#{cname}}}"\
-                      " already exists, skipping.\n" 
-                    fmt.puts 4, '- already exists, skipping.'
-                    fmt.puts 4, '- OK'
-                    next
-                  end
-                  
-                  # Add new association
-                  cgroup = db.models[:group].find(name: cname)
-                  if cgroup.nil?
-                    warn_count += 1
-                    fmt.warn "Group '#{cname}' does not exist and will be created.\n"
-                    fmt.puts 4, '- child group does not exist, creating now...'
-                    cgroup = db.models[:group].create(name: cname)
-                    fmt.puts 6, '- OK'
-                  end
-                  pgroup.add_child(cgroup)
-                  fmt.puts 4, '- OK'
-                end
-                fmt.puts 2, '- all OK'
-            end # Transaction end
+        end
+
+        private
+
+        def add_children_to_group(parent_name, child_names)
+          context = Moose::Inventory::InventoryContext.new(db: db)
+          operation = Moose::Inventory::Operations::GroupChildRelations.new(context: context)
+
+          begin
+            db.transaction do
+              puts "Associate parent group '#{parent_name}' with child group(s) '#{child_names.join(',')}':"
+              parent_group = fetch_existing_group_for_child_relation(context, parent_name)
+              result = operation.add_children(
+                parent_group: parent_group,
+                parent_name: parent_name,
+                child_names: child_names
+              )
+              render_addchild_events(result.events)
+              fmt.puts 2, '- all OK'
+              return result
+            end
           rescue db.exceptions[:moose] => e
-              abort("ERROR: #{e}")
+            abort("ERROR: #{e}")
           end
-          if warn_count == 0
-            puts 'Succeeded.'
+        end
+
+        def fetch_existing_group_for_child_relation(context, name)
+          fmt.puts 2, "- retrieve group '#{name}'..."
+          group = context.find_group(name)
+          abort("ERROR: The group '#{name}' does not exist.") if group.nil?
+
+          fmt.puts 4, '- OK'
+          group
+        end
+
+        def render_addchild_events(events)
+          events.each { |event| render_addchild_event(event) }
+        end
+
+        def render_addchild_event(event)
+          payload = event.payload
+
+          return render_addchild_warning(event.type, payload) if addchild_warning?(event.type)
+          return render_addchild_existing(payload) if event.type == :already_exists_skipping
+
+          case event.type
+          when :adding_child_association
+            fmt.puts 2, "- add association {group:#{payload[:parent]} <-> group:#{payload[:child]}}..."
+          when :child_group_creating_now
+            fmt.puts 4, '- child group does not exist, creating now...'
+          when :ok
+            fmt.puts payload[:indent], '- OK'
+          end
+        end
+
+        def addchild_warning?(type)
+          %i[child_association_exists child_group_missing].include?(type)
+        end
+
+        def render_addchild_warning(type, payload)
+          if type == :child_association_exists
+            fmt.warn "Association {group:#{payload[:parent]} <-> group:#{payload[:child]}}} already exists, skipping.\n"
           else
-            puts 'Succeeded, with warnings.'
+            fmt.warn "Group '#{payload[:name]}' does not exist and will be created.\n"
           end
-                    
+        end
+
+        def render_addchild_existing(payload)
+          fmt.puts payload[:indent], '- already exists, skipping.'
         end
       end
     end
   end
 end
-
-

data/lib/moose_inventory/cli/group_addhost.rb

@@ -1,5 +1,9 @@
+# frozen_string_literal: true
+
 require 'thor'
-require_relative './formatter.rb'
+require_relative 'formatter'
+require_relative '../inventory_context'
+require_relative '../operations/add_associations'
 
 module Moose
   module Inventory
@@ -10,88 +14,93 @@ module Moose
         #==========================
         desc 'addhost NAME HOSTNAME',
              'Associate a host HOSTNAME with the group NAME'
-        def addhost(*args) # rubocop:disable Metrics/AbcSize
-          # Sanity
-          if args.length < 2
-            abort("ERROR: Wrong number of arguments, #{args.length} "\
-              "for 2 or more.")
-          end
+        def addhost(*args)
+          abort_if_missing_args(args, 2, '2 or more')
+
+          name = args[0].downcase
+          hosts = normalize_names(args.slice(1, args.length - 1))
+
+          abort_if_automatic_group([name])
 
-          # Arguments
-          name  = args[0].downcase
-          hosts = args.slice(1, args.length - 1).uniq.map(&:downcase)
+          result = add_hosts_to_group(name, hosts)
 
-          # Sanity
-          if name == 'ungrouped'
-            abort("ERROR: Cannot manually manipulate the automatic group 'ungrouped'.")
+          if result.warning_count.zero?
+            puts 'Succeeded.'
+          else
+            puts 'Succeeded, with warnings.'
           end
+        end
+
+        private
 
-          # Convenience
-          db = Moose::Inventory::DB
-          fmt = Moose::Inventory::Cli::Formatter
+        def add_hosts_to_group(name, hosts)
+          context = Moose::Inventory::InventoryContext.new(db: db)
+          operation = Moose::Inventory::Operations::AddAssociations.new(context: context)
 
-          # Transaction
-          warn_count = 0
-          begin 
-            db.transaction do # Transaction start
+          begin
+            db.transaction do
               puts "Associate group '#{name}' with host(s) '#{hosts.join(',')}':"
-              # Get the target group
-              fmt.puts 2, "- retrieve group '#{name}'..."
-              group = db.models[:group].find(name: name)
-              if group.nil?
-                abort("ERROR: The group '#{name}' does not exist.")
-              end
-              fmt.puts 4,  '- OK'
-
-              # Associate group with the hosts
-              ungrouped  = db.models[:group].find_or_create(name: 'ungrouped')
-              hosts_ds = group.hosts_dataset
-              hosts.each do |h| # rubocop:disable Style/Next
-                fmt.puts 2, "- add association {group:#{name} <-> host:#{ h }}..."
-
-                # Check against existing associations
-                unless hosts_ds[name: h].nil?
-                  warn_count += 1
-                  fmt.warn "Association {group:#{name} <-> host:#{ h }} already"\
-                    " exists, skipping.\n"
-                  fmt.puts 4, '- already exists, skipping.'
-                  fmt.puts 4, '- OK'
-                  next
-                end
-
-                # Add new association
-                host = db.models[:host].find(name: h)
-                if host.nil?
-                  warn_count += 1
-                  fmt.warn "Host '#{h}' does not exist and will be created.\n"
-                  fmt.puts 4, '- host does not exist, creating now...'
-                  host = db.models[:host].create(name: h)
-                  fmt.puts 6, '- OK'
-                end
-                  
-                group.add_host(host)
-                fmt.puts 4, '- OK'
-
-                # Remove the host from the ungrouped group, if necessary
-                unless host.groups_dataset[name: 'ungrouped'].nil?
-                  fmt.puts 2,'- remove automatic association '\
-                    "{group:ungrouped <-> host:#{h}}..."
-                  host.remove_group(ungrouped)
-                  fmt.puts 4, '- OK'
-                end
-              end
+              group = fetch_existing_group_for_addhost(context, name)
+              result = operation.group_to_hosts(group: group, group_name: name, host_names: hosts)
+              render_group_addhost_events(result.events)
               fmt.puts 2, '- all OK'
-            end # Transaction end
+              return result
+            end
           rescue db.exceptions[:moose] => e
             abort("ERROR: #{e.message}")
           end
-          if warn_count == 0
-            puts 'Succeeded.'
+        end
+
+        def fetch_existing_group_for_addhost(context, name)
+          fmt.puts 2, "- retrieve group '#{name}'..."
+          group = context.find_group(name)
+          abort("ERROR: The group '#{name}' does not exist.") if group.nil?
+
+          fmt.puts 4, '- OK'
+          group
+        end
+
+        def render_group_addhost_events(events)
+          events.each { |event| render_group_addhost_event(event) }
+        end
+
+        def render_group_addhost_event(event)
+          payload = event.payload
+
+          return render_group_addhost_warning(event.type, payload) if group_addhost_warning?(event.type)
+          return render_group_addhost_status(payload) if event.type == :already_exists_skipping
+
+          render_group_addhost_output(event.type, payload)
+        end
+
+        def group_addhost_warning?(type)
+          %i[group_host_association_exists host_missing_created].include?(type)
+        end
+
+        def render_group_addhost_warning(type, payload)
+          if type == :group_host_association_exists
+            fmt.warn "Association {group:#{payload[:group]} <-> host:#{payload[:host]}} already exists, skipping.\n"
           else
-            puts 'Succeeded, with warnings.'
+            fmt.warn "Host '#{payload[:name]}' does not exist and will be created.\n"
           end
         end
 
+        def render_group_addhost_status(payload)
+          fmt.puts payload[:indent], '- already exists, skipping.'
+        end
+
+        def render_group_addhost_output(type, payload)
+          case type
+          when :adding_group_host_association
+            fmt.puts 2, "- add association {group:#{payload[:group]} <-> host:#{payload[:host]}}..."
+          when :host_creating_now
+            fmt.puts 4, '- host does not exist, creating now...'
+          when :removing_automatic_group
+            fmt.puts 2, "- remove automatic association {group:ungrouped <-> host:#{payload[:host]}}..."
+          when :ok
+            fmt.puts payload[:indent], '- OK'
+          end
+        end
       end
     end
   end

data/lib/moose_inventory/cli/group_addvar.rb

@@ -22,49 +22,49 @@ module Moose
           # Arguments
           name = args[0].downcase
           vars = args.slice(1, args.length - 1).uniq
-          
-        # Transaction
-        db.transaction do # Transaction start
-          puts "Add variables '#{vars.join(",")}' to group '#{name}':"
-          fmt.puts 2,"- retrieve group '#{name}'..."
-          group = db.models[:group].find(name: name)
-          if group.nil?
-            fail db.exceptions[:moose],
-                 "The group '#{name}' does not exist."
-          end
-          fmt.puts 4, '- OK'
-
-          groupvars_ds = group.groupvars_dataset
-          vars.each do |v|
-            fmt.puts 2, "- add variable '#{v}'..."
-            vararray = v.split('=')
 
-            if v.start_with?('=') ||  v.end_with?('=') || vararray.length != 2
+          # Transaction
+          db.transaction do # Transaction start
+            puts "Add variables '#{vars.join(',')}' to group '#{name}':"
+            fmt.puts 2, "- retrieve group '#{name}'..."
+            group = db.models[:group].find(name: name)
+            if group.nil?
               fail db.exceptions[:moose],
-                   "Incorrect format in '{#{v}}'. Expected 'key=value'."
+                   "The group '#{name}' does not exist."
             end
- 
-            # Check against existing associations
-            groupvar = groupvars_ds[name: vararray[0]]
-            if !groupvar.nil?
-              unless groupvar[:value] == vararray[1]
-                fmt.puts 4, '- already exists, applying as an update...'
-                update = db.models[:groupvar].find(id: groupvar[:id])
-                update[:value] = vararray[1]
-                update.save
+            fmt.puts 4, '- OK'
+
+            groupvars_ds = group.groupvars_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
-            else
-              # groupvar doesn't exist, so create and associate
-              groupvar = db.models[:groupvar].create(name: vararray[0],
-                                                    value: vararray[1])
-              group.add_groupvar(groupvar)
+
+              # Check against existing associations
+              groupvar = groupvars_ds[name: vararray[0]]
+              if !groupvar.nil?
+                unless groupvar[:value] == vararray[1]
+                  fmt.puts 4, '- already exists, applying as an update...'
+                  update = db.models[:groupvar].find(id: groupvar[:id])
+                  update[:value] = vararray[1]
+                  update.save
+                end
+              else
+                # groupvar doesn't exist, so create and associate
+                groupvar = db.models[:groupvar].create(name: vararray[0],
+                                                       value: vararray[1])
+                group.add_groupvar(groupvar)
+              end
+              fmt.puts 4, '- OK'
             end
-            fmt.puts 4, '- OK'
-          end
-          fmt.puts 2, '- all OK'
-        end # Transaction end
+            fmt.puts 2, '- all OK'
+          end # Transaction end
 
-        puts 'Succeeded.'
+          puts 'Succeeded.'
         end
       end
     end

data/lib/moose_inventory/cli/group_get.rb

@@ -9,13 +9,13 @@ module Moose
       class Group
         desc 'get GROUP_1 [GROUP_2 ...]', 'Get groups GROUP_n from the inventory'
         def get(*argv) # rubocop:disable Metrics/AbcSize
-          if argv.length < 1
+          if argv.empty?
             abort('ERROR: Wrong number of arguments, '\
               "#{argv.length} for 1 or more")
           end
 
           # Convenience
-          db    = Moose::Inventory::DB
+          db = Moose::Inventory::DB
           fmt = Moose::Inventory::Cli::Formatter
 
           # Arguments
@@ -25,32 +25,29 @@ module Moose
           results = {}
           names.each do |name|
             group = db.models[:group].find(name: name)
-              
-            unless group.nil?
-              hosts = group.hosts_dataset.map(:name)
-            
-              children = group.children_dataset.map(:name)
-              
-              groupvars = {}
-              group.groupvars_dataset.each do |gv|
-                groupvars[gv[:name].to_sym] = gv[:value]
-              end
-
-              results[group[:name].to_sym] = {}
-              unless hosts.length == 0
-                results[group[:name].to_sym][:hosts]     = hosts
-              end
-
-              unless children.length == 0
-                results[group[:name].to_sym][:children] = children
-              end
-              
-              unless groupvars.length == 0
-                results[group[:name].to_sym][:groupvars] = groupvars
-              end
+
+            next if group.nil?
+            hosts = group.hosts_dataset.map(:name)
+
+            children = group.children_dataset.map(:name)
+
+            groupvars = {}
+            group.groupvars_dataset.each do |gv|
+              groupvars[gv[:name].to_sym] = gv[:value]
+            end
+
+            results[group[:name].to_sym] = {}
+            results[group[:name].to_sym][:hosts] = hosts unless hosts.empty?
+
+            unless children.empty?
+              results[group[:name].to_sym][:children] = children
+            end
+
+            unless groupvars.empty?
+              results[group[:name].to_sym][:groupvars] = groupvars
             end
           end
-          
+
           fmt.dump(results)
         end
       end

data/lib/moose_inventory/cli/group_list.rb

@@ -12,41 +12,38 @@ module Moose
              'List the groups, together with any associated hosts and groupvars'
         def list # rubocop:disable Metrics/AbcSize
           # Convenience
-          db    = Moose::Inventory::DB
+          db = Moose::Inventory::DB
           confopts = Moose::Inventory::Config._confopts
-          
+
           # Process
           results = {}
           db.models[:group].all.each do |group|
-            
             hosts = group.hosts_dataset.map(:name)
 
             # Hide the automatic ungrouped group, if it's empty
-            next if group[:name] == 'ungrouped' && hosts.length == 0
+            next if group[:name] == 'ungrouped' && hosts.empty?
 
             children = group.children_dataset.map(:name)
-                          
+
             groupvars = {}
             group.groupvars_dataset.each do |gv|
               groupvars[gv[:name].to_sym] = gv[:value]
             end
 
-              
             results[group[:name].to_sym] = {}
-            unless hosts.length == 0  and confopts[:ansible] != true 
+            unless hosts.empty? && (confopts[:ansible] != true)
               results[group[:name].to_sym][:hosts] = hosts
             end
 
-            unless children.length == 0
+            unless children.empty?
               results[group[:name].to_sym][:children] = children
             end
-            
-            unless groupvars.length == 0
-              if confopts[:ansible] == true
-                results[group[:name].to_sym][:vars] = groupvars
-              else
-                results[group[:name].to_sym][:groupvars] = groupvars
-              end
+
+            next if groupvars.empty?
+            if confopts[:ansible] == true
+              results[group[:name].to_sym][:vars] = groupvars
+            else
+              results[group[:name].to_sym][:groupvars] = groupvars
             end
           end
           Formatter.out(results)

data/lib/moose_inventory/cli/group_listvars.rb

@@ -19,23 +19,22 @@ module Moose
           # Note, the Ansible spects don't call for a "--group GROUPNAME" method.
           # So, strictly, there is no Ansible compatibility for this method.
           # Instead, the Ansible compatibility included herein is for consistency
-          # with the "hosts listvars" method, which services the Ansible 
+          # with the "hosts listvars" method, which services the Ansible
           # "--host HOSTNAME" specs.
-                     
+
           # sanity
           if confopts[:ansible] == true
             if argv.length != 1
-            abort('ERROR: Wrong number of arguments for Ansible mode, '\
-                  "#{args.length} for 1.")
+              abort('ERROR: Wrong number of arguments for Ansible mode, '\
+                    "#{args.length} for 1.")
             end
           else
-            if argv.length < 1
+            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
@@ -43,10 +42,10 @@ module Moose
           # Arguments
           names = argv.uniq.map(&:downcase)
 
-          #process
+          # process
           results = {}
-            
-          if confopts[:ansible] == true 
+
+          if confopts[:ansible] == true
             # This is the implementation per Ansible specs
             name = names.first
             group = db.models[:group].find(name: name)
@@ -61,11 +60,10 @@ module Moose
             # This our more flexible implementation
             names.each do |name|
               group = db.models[:group].find(name: name)
-              unless group.nil?
-                results[name.to_sym] = {}
-                group.groupvars_dataset.each do |gv|
-                  results[name.to_sym][gv[:name].to_sym] = gv[:value]
-                end
+              next if group.nil?
+              results[name.to_sym] = {}
+              group.groupvars_dataset.each do |gv|
+                results[name.to_sym][gv[:name].to_sym] = gv[:value]
               end
             end
           end