Removing inventory builder, fixing inventory superclass

app/models/manageiq/providers/google/inventory.rb

@@ -1,5 +1,11 @@
-class ManageIQ::Providers::Google::Inventory < ManagerRefresh::Inventory
+class ManageIQ::Providers::Google::Inventory < ManageIQ::Providers::Inventory
   require_nested :Collector
   require_nested :Parser
   require_nested :Persister
+
+  # Default manager for building collector/parser/persister classes
+  # when failed to get class name from refresh target automatically
+  def self.default_manager_name
+    "CloudManager"
+  end
 end

app/models/manageiq/providers/google/inventory/parser/cloud_manager.rb

@@ -25,15 +25,15 @@ def parse
       image_os(persister_miq_template, image)
     end
 
-    instances do |persister_instance, parent_image_uid, flavor, instance|
-      instance_os(persister_instance, parent_image_uid)
+    instances do |persister_vm, parent_image_uid, flavor, instance|
+      instance_os(persister_vm, parent_image_uid)
 
-      instance_hardware(persister_instance, flavor) do |persister_hardware|
+      instance_hardware(persister_vm, flavor) do |persister_hardware|
         hardware_disks(persister_hardware, instance)
       end
 
-      instance_key_pairs(persister_instance, instance)
-      instance_advanced_settings(persister_instance, instance)
+      instance_key_pairs(persister_vm, instance)
+      instance_advanced_settings(persister_vm, instance)
     end
 
     _log.info("#{log_header}...Complete")
@@ -143,7 +143,7 @@ def instances
       flavor_uid = parse_uid_from_url(instance.machine_type)
       zone_uid = parse_uid_from_url(instance.zone)
 
-      # TODO(mslemr) if possible, change to lazy_find (now result needed immediately)
+      # TODO(mslemr) lazy_find (now result needed immediately)
       flavor = persister.flavors.find(flavor_uid)
 
       # If the flavor isn't found in our index, check if it is a custom flavor
@@ -152,20 +152,20 @@ def instances
 
       parent_image_uid = parse_instance_parent_image(instance)
 
-      persister_instance = persister.vms.build(
+      persister_vm = persister.vms.build(
         :availability_zone => persister.availability_zones.lazy_find(zone_uid),
         :description       => instance.description,
         :ems_ref           => uid,
         :flavor            => flavor,
-        :location          => "unknown", # TODO(mslemr) instance.self_link,
+        :location          => "unknown", # TODO(mslemr) instance.self_link?,
         :name              => instance.name || uid,
         :genealogy_parent  => persister.miq_templates.lazy_find(parent_image_uid),
         :raw_power_state   => instance.status,
         :uid_ems           => uid,
         :vendor            => VENDOR_GOOGLE,
       )
 
-      yield persister_instance, parent_image_uid, flavor, instance
+      yield persister_vm, parent_image_uid, flavor, instance
     end
   end
 
@@ -179,9 +179,9 @@ def key_pairs
     end
   end
 
-  # @param persister_instance [InventoryObject<ManageIQ::Providers::Google::CloudManager::Vm>]
+  # @param persister_vm [InventoryObject<ManageIQ::Providers::Google::CloudManager::Vm>]
   # @param instance [Fog::Compute::Google::Server]
-  def instance_key_pairs(persister_instance, instance)
+  def instance_key_pairs(persister_vm, instance)
     # Add project common ssh-keys with keys specific to this instance
     instance_ssh_keys = project_key_pairs | parse_compute_metadata_ssh_keys(instance.metadata)
 
@@ -192,26 +192,26 @@ def instance_key_pairs(persister_instance, instance)
       )
 
       key_pair.vms ||= []
-      key_pair.vms << persister_instance
+      key_pair.vms << persister_vm
     end
   end
 
-  # @param persister_instance [InventoryObject<ManageIQ::Providers::Google::CloudManager::Vm>]
+  # @param persister_vm [InventoryObject<ManageIQ::Providers::Google::CloudManager::Vm>]
   # @param series [InventoryObject<ManageIQ::Providers::Google::CloudManager::Flavor>]
-  def instance_hardware(persister_instance, series)
+  def instance_hardware(persister_vm, series)
     persister_hardware = persister.hardwares.build(
-      :vm_or_template  => persister_instance, # manager_ref
+      :vm_or_template  => persister_vm, # manager_ref
       :cpu_total_cores => series[:cpus],
       :memory_mb       => series[:memory] / 1.megabyte
     )
     yield persister_hardware
   end
 
-  # @param persister_instance [InventoryObject<ManageIQ::Providers::Google::CloudManager::Vm>]
+  # @param persister_vm [InventoryObject<ManageIQ::Providers::Google::CloudManager::Vm>]
   # @param instance [Fog::Compute::Google::Server]
-  def instance_advanced_settings(persister_instance, instance)
+  def instance_advanced_settings(persister_vm, instance)
     persister.vms_and_templates_advanced_settings.build(
-      :resource     => persister_instance, # manager_ref
+      :resource     => persister_vm, # manager_ref
       :name         => "preemptible?",
       :display_name => N_("Is VM Preemptible"),
       :description  => N_("Whether or not the VM is 'preemptible'. See"\
@@ -250,7 +250,6 @@ def instance_os(persister_vm, parent_image_uid)
   # @param instance [Fog::Compute::Google::Server]
   def hardware_disks(persister_hardware, instance)
     instance.disks.each do |attached_disk|
-      # TODO(mslemr): can't be better solution?
       cloud_volume_ems_ref = @cloud_volume_url_to_id[attached_disk[:source]]
       persister_cloud_volume = persister.cloud_volumes.find(cloud_volume_ems_ref)
       next if persister_cloud_volume.nil?

app/models/manageiq/providers/google/inventory/parser/network_manager.rb

@@ -37,16 +37,17 @@ def parse
     floating_ips
 
     load_balancers do |forwarding_rules|
-      load_balancer_pools do |persister_load_balancer_pool, target_pool|
-        load_balancer_pool_members(persister_load_balancer_pool, target_pool)
-        load_balancer_health_check(target_pool) do |persister_load_balancer_health_check|
-          load_balancer_health_check_members(persister_load_balancer_health_check, target_pool)
+      load_balancer_pools do |persister_lb_pool, target_pool|
+        load_balancer_pool_members(persister_lb_pool, target_pool)
+
+        load_balancer_health_check(target_pool) do |persister_lb_health_check|
+          load_balancer_health_check_members(persister_lb_health_check, target_pool)
         end
       end
 
       forwarding_rules.each do |forwarding_rule|
-        load_balancer_listener(forwarding_rule) do |persister_load_balancer_listener|
-          load_balancer_listener_pool(persister_load_balancer_listener, forwarding_rule)
+        load_balancer_listener(forwarding_rule) do |persister_lb_listener|
+          load_balancer_listener_pool(persister_lb_listener, forwarding_rule)
         end
       end
     end
@@ -219,7 +220,7 @@ def load_balancer_listener(forwarding_rule)
     has_ports = %w(TCP UDP SCTP).include?(forwarding_rule.ip_protocol)
     port_range = (parse_port_range(forwarding_rule.port_range) if has_ports)
 
-    persister_load_balancer_listener = persister.load_balancer_listeners.build(
+    persister_lb_listener = persister.load_balancer_listeners.build(
       :name                     => forwarding_rule.name,
       :ems_ref                  => forwarding_rule.id.to_s,
       :load_balancer_protocol   => forwarding_rule.ip_protocol,
@@ -229,37 +230,37 @@ def load_balancer_listener(forwarding_rule)
       :load_balancer            => persister.load_balancers.lazy_find(forwarding_rule.id.to_s)
     )
 
-    yield persister_load_balancer_listener
+    yield persister_lb_listener
   end
 
-  # @param persister_load_balancer_listener [InventoryObject<ManageIQ::Providers::google::NetworkManager::LoadBalancerListener]
+  # @param persister_lb_listener [InventoryObject<ManageIQ::Providers::google::NetworkManager::LoadBalancerListener]
   # @param forwarding_rule [Fog::Compute::Google::ForwardingRule]
-  def load_balancer_listener_pool(persister_load_balancer_listener, forwarding_rule)
+  def load_balancer_listener_pool(persister_lb_listener, forwarding_rule)
     persister_lb_listener_pool = persister.load_balancer_listener_pools.build(
-      :load_balancer_listener => persister_load_balancer_listener,
+      :load_balancer_listener => persister_lb_listener,
       :load_balancer_pool     => @target_pool_index[forwarding_rule.target]
     )
 
-    persister_load_balancer_listener.load_balancer_listener_pools ||= []
-    persister_load_balancer_listener.load_balancer_listener_pools << persister_lb_listener_pool
+    persister_lb_listener.load_balancer_listener_pools ||= []
+    persister_lb_listener.load_balancer_listener_pools << persister_lb_listener_pool
   end
 
   def load_balancer_pools
     collector.target_pools.each do |target_pool|
-      persister_load_balancer_pool = persister.load_balancer_pools.build(
+      persister_lb_pool = persister.load_balancer_pools.build(
         :ems_ref => target_pool.id.to_s,
         :name    => target_pool.name
       )
 
-      @target_pool_index[target_pool.self_link] = persister_load_balancer_pool
+      @target_pool_index[target_pool.self_link] = persister_lb_pool
 
-      yield persister_load_balancer_pool, target_pool
+      yield persister_lb_pool, target_pool
     end
   end
 
-  # @param persister_load_balancer_pool [InventoryObject<ManageIQ::Providers::Google::NetworkManager::LoadBalancerPool>]
+  # @param persister_lb_pool [InventoryObject<ManageIQ::Providers::Google::NetworkManager::LoadBalancerPool>]
   # @param target_pool [Fog::Compute::Google::TargetPool]
-  def load_balancer_pool_members(persister_load_balancer_pool, target_pool)
+  def load_balancer_pool_members(persister_lb_pool, target_pool)
     target_pool.instances.to_a.each do |member_link|
       persister_lb_pool_member = persister.load_balancer_pool_members.find(Digest::MD5.base64digest(member_link))
 
@@ -272,7 +273,7 @@ def load_balancer_pool_members(persister_load_balancer_pool, target_pool)
         )
       end
       persister.load_balancer_pool_member_pools.build(
-        :load_balancer_pool        => persister_load_balancer_pool,
+        :load_balancer_pool        => persister_lb_pool,
         :load_balancer_pool_member => persister_lb_pool_member
       )
     end
@@ -298,7 +299,7 @@ def load_balancer_health_check(target_pool)
       # return nil if load_balancer_listener.nil? #TODO: return inside collect?
 
       uid = "#{persister_load_balancer.ems_ref}_#{target_pool.id}_#{health_check.id}"
-      persister_load_balancer_health_check = \
+      persister_lb_health_check = \
         persister.load_balancer_health_checks.build(
           :ems_ref                => uid,
           :healthy_threshold      => health_check.healthy_threshold,
@@ -313,13 +314,13 @@ def load_balancer_health_check(target_pool)
           :url_path               => health_check.request_path,
         )
 
-      yield persister_load_balancer_health_check
+      yield persister_lb_health_check
     end
   end
 
-  # @param persister_load_balancer_health_check [InventoryObject<ManageIQ::Providers::Google::NetworkManager::LoadBalancerHealthCheck>]
+  # @param persister_lb_health_check [InventoryObject<ManageIQ::Providers::Google::NetworkManager::LoadBalancerHealthCheck>]
   # @param target_pool [Fog::Compute::Google::TargetPool]
-  def load_balancer_health_check_members(persister_load_balancer_health_check, target_pool)
+  def load_balancer_health_check_members(persister_lb_health_check, target_pool)
     return if target_pool.instances.blank?
     # First attempt to get the health of the instance
     # Due to a bug in fog, there's no way to get the health of an individual
@@ -345,7 +346,7 @@ def load_balancer_health_check_members(persister_load_balancer_health_check, tar
       end
 
       persister.load_balancer_health_check_members.build(
-        :load_balancer_health_check => persister_load_balancer_health_check,
+        :load_balancer_health_check => persister_lb_health_check,
         :load_balancer_pool_member  => member,
         :status                     => status,
         :status_reason              => ""