Refactor refresh new target to use save_ems_inventory

app/models/ems_event/automate.rb

@@ -27,9 +27,9 @@ def refresh_new_target
       ems = ext_management_system
       if ems.supports_refresh_new_target?
         ep_class = ems.class::EventParser
-        target_hash = ep_class.parse_new_target(full_data, message, ems, event_type)
+        target_hash, target_class, target_find = ep_class.parse_new_target(full_data, message, ems, event_type)
 
-        EmsRefresh.queue_refresh_new_target(target_hash, ems)
+        EmsRefresh.queue_refresh_new_target(ems, target_hash, target_class, target_find)
       else
         EmsRefresh.queue_refresh(ems)
       end

app/models/ems_refresh.rb

@@ -63,14 +63,14 @@ def self.queue_refresh(target, id = nil, opts = {})
     return task_ids if opts[:create_task]
   end
 
-  def self.queue_refresh_new_target(target_hash, ems)
+  def self.queue_refresh_new_target(ems, target_hash, target_class, target_find)
     MiqQueue.put(
       :queue_name  => MiqEmsRefreshWorker.queue_name_for_ems(ems),
       :class_name  => name,
       :method_name => 'refresh_new_target',
       :role        => "ems_inventory",
       :zone        => ems.my_zone,
-      :args        => [target_hash, ems.id],
+      :args        => [ems.id, target_hash, target_class, target_find],
       :msg_timeout => queue_timeout,
       :task_id     => nil
     )
@@ -98,16 +98,21 @@ def self.refresh(target, id = nil)
     end
   end
 
-  def self.refresh_new_target(target_hash, ems_id)
+  def self.refresh_new_target(ems_id, target_hash, target_class, target_find)
     ems = ExtManagementSystem.find(ems_id)
+    target_class = target_class.constantize if target_class.kind_of? String
 
-    target = save_new_target(ems, target_hash)
+    save_ems_inventory_no_disconnect(ems, target_hash)
+
+    target = target_class.find_by(target_find)
     if target.nil?
       _log.warn "Unknown target for event data: #{target_hash}."
       return
     end
 
     ems.refresher.refresh(get_target_objects(target))
+
+    target
   end
 
   def self.get_target_objects(target, single_id = nil)

app/models/ems_refresh/metadata_relats.rb

@@ -5,9 +5,10 @@ module EmsRefresh::MetadataRelats
   # TODO: Replace with more efficient lookup methods using new relationships
 
   def vmdb_relats(target, relats = nil)
-    _log.info "Getting VMDB relationships for #{target.class} [#{target.name}] id: [#{target.id}]..."
-
     relats ||= default_relats_hash
+    return relats if target.nil?
+
+    _log.info "Getting VMDB relationships for #{target.class} [#{target.name}] id: [#{target.id}]..."
     if target.kind_of?(ExtManagementSystem)
       vmdb_relats_ems(target, relats)
     else

app/models/ems_refresh/save_inventory.rb

@@ -1,13 +1,13 @@
 module EmsRefresh::SaveInventory
-  def save_ems_inventory(ems, hashes, target = nil)
+  def save_ems_inventory(ems, hashes, target = nil, disconnect = true)
     if hashes.kind_of?(Array)
       ManagerRefresh::SaveInventory.save_inventory(ems, hashes)
       return
     end
 
     case ems
-    when EmsCloud                                           then save_ems_cloud_inventory(ems, hashes, target)
-    when EmsInfra                                           then save_ems_infra_inventory(ems, hashes, target)
+    when EmsCloud                                           then save_ems_cloud_inventory(ems, hashes, target, disconnect)
+    when EmsInfra                                           then save_ems_infra_inventory(ems, hashes, target, disconnect)
     when EmsPhysicalInfra                                   then save_ems_physical_infra_inventory(ems, hashes, target)
     when ManageIQ::Providers::AutomationManager             then save_automation_manager_inventory(ems, hashes, target)
     when ManageIQ::Providers::ConfigurationManager          then save_configuration_manager_inventory(ems, hashes, target)
@@ -18,13 +18,17 @@ def save_ems_inventory(ems, hashes, target = nil)
     end
   end
 
+  def save_ems_inventory_no_disconnect(ems, hashes, target = nil)
+    save_ems_inventory(ems, hashes, target, false)
+  end
+
   #
   # Shared between Cloud and Infra
   #
 
-  def save_vms_inventory(ems, hashes, target = nil)
+  def save_vms_inventory(ems, hashes, target = nil, disconnect = true)
     return if hashes.nil?
-    target = ems if target.nil?
+    target = ems if target.nil? && disconnect
     log_header = "EMS: [#{ems.name}], id: [#{ems.id}]"
 
     disconnects = if target.kind_of?(ExtManagementSystem) || target.kind_of?(Host)
@@ -352,35 +356,6 @@ def save_event_logs_inventory(os, hashes)
     save_inventory_multi(os.event_logs, hashes, :use_association, [:uid])
   end
 
-  def save_new_target(ems, target_hash)
-    if target_hash[:vm]
-      vm_hash = target_hash[:vm]
-      existing_vm = VmOrTemplate.find_by(:ems_ref => vm_hash[:ems_ref], :ems_id => target_hash[:ems_id])
-      unless existing_vm.nil?
-        return existing_vm
-      end
-
-      old_cluster = get_cluster(ems, target_hash[:cluster], target_hash[:resource_pools], target_hash[:folders])
-
-      vm_hash[:ems_cluster_id] = old_cluster[:id]
-
-      new_vm = ems.vms_and_templates.create!(vm_hash)
-
-      dc = old_cluster.parent_datacenter
-      vm_folder = dc.children.select { |folder| folder.name == "vm" }[0]
-      vm_folder.add_vm(new_vm)
-      vm_folder.save!
-
-      resource_pool = old_cluster.children.first
-      resource_pool.add_vm(new_vm)
-      resource_pool.save!
-
-      new_vm
-    elsif target_hash[:folder]
-      ems.ems_folders.create!(target_hash[:folder])
-    end
-  end
-
   #
   # Storage managers can support many different types of storages. We thus rely
   # on the supports feature of the manager to choose which parts of the

app/models/ems_refresh/save_inventory_cloud.rb

@@ -29,13 +29,13 @@
 #
 
 module EmsRefresh::SaveInventoryCloud
-  def save_ems_cloud_inventory(ems, hashes, target = nil)
+  def save_ems_cloud_inventory(ems, hashes, target = nil, disconnect = true)
     target = ems if target.nil?
     log_header = "EMS: [#{ems.name}], id: [#{ems.id}]"
 
     # Check if the data coming in reflects a complete removal from the ems
     if hashes.blank?
-      target.disconnect_inv
+      target.disconnect_inv if disconnect
       return
     end
 
@@ -66,7 +66,7 @@ def save_ems_cloud_inventory(ems, hashes, target = nil)
     ]
 
     # Save and link other subsections
-    save_child_inventory(ems, hashes, child_keys, target)
+    save_child_inventory(ems, hashes, child_keys, target, disconnect)
 
     link_volumes_to_base_snapshots(hashes[:cloud_volumes]) if hashes.key?(:cloud_volumes)
     link_parents_to_cloud_tenant(hashes[:cloud_tenants]) if hashes.key?(:cloud_tenants)
@@ -79,15 +79,11 @@ def save_ems_cloud_inventory(ems, hashes, target = nil)
     ems
   end
 
-  def save_flavors_inventory(ems, hashes, target = nil)
+  def save_flavors_inventory(ems, hashes, target = nil, disconnect = true)
     target = ems if target.nil?
 
     ems.flavors.reset
-    deletes = if (target == ems)
-                :use_association
-              else
-                []
-              end
+    deletes = determine_deletes_using_association(ems, target, disconnect)
 
     hashes.each do |h|
       h[:cloud_tenant_ids] = (h.delete(:cloud_tenants) || []).compact.map { |x| x[:id] }.uniq
@@ -97,58 +93,42 @@ def save_flavors_inventory(ems, hashes, target = nil)
     store_ids_for_new_records(ems.flavors, hashes, :ems_ref)
   end
 
-  def save_availability_zones_inventory(ems, hashes, target = nil)
+  def save_availability_zones_inventory(ems, hashes, target = nil, disconnect = true)
     target = ems if target.nil?
 
     ems.availability_zones.reset
-    deletes = if (target == ems)
-                :use_association
-              else
-                []
-              end
+    deletes = determine_deletes_using_association(ems, target, disconnect)
 
     save_inventory_multi(ems.availability_zones, hashes, deletes, [:ems_ref])
     store_ids_for_new_records(ems.availability_zones, hashes, :ems_ref)
   end
 
-  def save_host_aggregates_inventory(ems, hashes, target = nil)
+  def save_host_aggregates_inventory(ems, hashes, target = nil, disconnect = true)
     target ||= ems
 
     ems.host_aggregates.reset
-    deletes = if (target == ems)
-                :use_association
-              else
-                []
-              end
+    deletes = determine_deletes_using_association(ems, target, disconnect)
 
     save_inventory_multi(ems.host_aggregates, hashes, deletes, [:ems_ref])
     store_ids_for_new_records(ems.host_aggregates, hashes, :ems_ref)
     # FIXME: what about hosts?
   end
 
-  def save_cloud_tenants_inventory(ems, hashes, target = nil)
+  def save_cloud_tenants_inventory(ems, hashes, target = nil, disconnect = true)
     target ||= ems
 
     ems.cloud_tenants.reset
-    deletes = if (target == ems)
-                :use_association
-              else
-                []
-              end
+    deletes = determine_deletes_using_association(ems, target, disconnect)
 
     save_inventory_multi(ems.cloud_tenants, hashes, deletes, [:ems_ref], nil, [:parent_id])
     store_ids_for_new_records(ems.cloud_tenants, hashes, :ems_ref)
   end
 
-  def save_cloud_resource_quotas_inventory(ems, hashes, target = nil)
+  def save_cloud_resource_quotas_inventory(ems, hashes, target = nil, disconnect = true)
     target ||= ems
 
     ems.cloud_resource_quotas.reset
-    deletes = if (target == ems)
-                :use_association
-              else
-                []
-              end
+    deletes = determine_deletes_using_association(ems, target, disconnect)
 
     hashes.each do |h|
       h[:cloud_tenant_id] = h.fetch_path(:cloud_tenant, :id)
@@ -158,29 +138,21 @@ def save_cloud_resource_quotas_inventory(ems, hashes, target = nil)
     store_ids_for_new_records(ems.cloud_resource_quotas, hashes, [:ems_ref, :name])
   end
 
-  def save_key_pairs_inventory(ems, hashes, target = nil)
+  def save_key_pairs_inventory(ems, hashes, target = nil, disconnect = true)
     target = ems if target.nil?
 
     ems.key_pairs.reset
-    deletes = if (target == ems)
-                :use_association
-              else
-                []
-              end
+    deletes = determine_deletes_using_association(ems, target, disconnect)
 
     save_inventory_multi(ems.key_pairs, hashes, deletes, [:name])
     store_ids_for_new_records(ems.key_pairs, hashes, :name)
   end
 
-  def save_cloud_volumes_inventory(ems, hashes, target = nil)
+  def save_cloud_volumes_inventory(ems, hashes, target = nil, disconnect = true)
     target = ems if target.nil?
 
     ems.cloud_volumes.reset
-    deletes = if (target == ems)
-                :use_association
-              else
-                []
-              end
+    deletes = determine_deletes_using_association(ems, target, disconnect)
 
     hashes.each do |h|
       h[:ems_id]               = ems.id
@@ -193,15 +165,11 @@ def save_cloud_volumes_inventory(ems, hashes, target = nil)
     store_ids_for_new_records(ems.cloud_volumes, hashes, :ems_ref)
   end
 
-  def save_cloud_volume_backups_inventory(ems, hashes, target = nil)
+  def save_cloud_volume_backups_inventory(ems, hashes, target = nil, disconnect = true)
     target = ems if target.nil?
 
     ems.cloud_volume_backups.reset
-    deletes = if target == ems
-                :use_association
-              else
-                []
-              end
+    deletes = determine_deletes_using_association(ems, target, disconnect)
 
     hashes.each do |h|
       h[:ems_id]          = ems.id
@@ -214,15 +182,11 @@ def save_cloud_volume_backups_inventory(ems, hashes, target = nil)
     store_ids_for_new_records(ems.cloud_volume_backups, hashes, :ems_ref)
   end
 
-  def save_cloud_volume_snapshots_inventory(ems, hashes, target = nil)
+  def save_cloud_volume_snapshots_inventory(ems, hashes, target = nil, disconnect = true)
     target = ems if target.nil?
 
     ems.cloud_volume_snapshots.reset
-    deletes = if (target == ems)
-                :use_association
-              else
-                []
-              end
+    deletes = determine_deletes_using_association(ems, target, disconnect)
 
     hashes.each do |h|
       h[:ems_id]          = ems.id
@@ -261,15 +225,11 @@ def link_parents_to_cloud_tenant(hashes)
     end
   end
 
-  def save_cloud_object_store_containers_inventory(ems, hashes, target = nil)
+  def save_cloud_object_store_containers_inventory(ems, hashes, target = nil, disconnect = true)
     target = ems if target.nil?
 
     ems.cloud_object_store_containers.reset
-    deletes = if target == ems
-                :use_association
-              else
-                []
-              end
+    deletes = determine_deletes_using_association(ems, target, disconnect)
 
     hashes.each do |h|
       h[:ems_id]          = ems.id
@@ -280,15 +240,11 @@ def save_cloud_object_store_containers_inventory(ems, hashes, target = nil)
     store_ids_for_new_records(ems.cloud_object_store_containers, hashes, :ems_ref)
   end
 
-  def save_cloud_object_store_objects_inventory(ems, hashes, target = nil)
+  def save_cloud_object_store_objects_inventory(ems, hashes, target = nil, disconnect = true)
     target = ems if target.nil?
 
     ems.cloud_object_store_objects.reset
-    deletes = if target == ems
-                :use_association
-              else
-                []
-              end
+    deletes = determine_deletes_using_association(ems, target, disconnect)
 
     hashes.each do |h|
       h[:ems_id]                          = ems.id
@@ -300,29 +256,21 @@ def save_cloud_object_store_objects_inventory(ems, hashes, target = nil)
     store_ids_for_new_records(ems.cloud_object_store_objects, hashes, :ems_ref)
   end
 
-  def save_resource_groups_inventory(ems, hashes, target = nil)
+  def save_resource_groups_inventory(ems, hashes, target = nil, disconnect = true)
     target = ems if target.nil?
 
     ems.resource_groups.reset
-    deletes = if (target == ems)
-                :use_association
-              else
-                []
-              end
+    deletes = determine_deletes_using_association(ems, target, disconnect)
 
     save_inventory_multi(ems.resource_groups, hashes, deletes, [:ems_ref])
     store_ids_for_new_records(ems.resource_groups, hashes, :ems_ref)
   end
 
-  def save_cloud_services_inventory(ems, hashes, target = nil)
+  def save_cloud_services_inventory(ems, hashes, target = nil, disconnect = true)
     target = ems if target.nil?
 
     ems.cloud_services.reset
-    deletes = if target == ems
-                :use_association
-              else
-                []
-              end
+    deletes = determine_deletes_using_association(ems, target, disconnect)
 
     save_inventory_multi(ems.cloud_services, hashes, deletes, [:ems_ref])
     store_ids_for_new_records(ems.cloud_services, hashes, :ems_ref)