inventory_refresh 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f587f79d9daabcefff5a1b479301971cdd31f940d517cfc058480a0c17bc3abc
-  data.tar.gz: ac2962c044aba21b8bb5963ae06c788fdeb3863d29a34b33933360ffef432438
+  metadata.gz: 666554cf2d3928670cd6772706360d2c2523fc0475b63f2aead1e7e2bec675d7
+  data.tar.gz: 992aa863fdd2d020878f3bd18e0c83d7bf37aa79d6363814e10fdc5cd311a35a
 SHA512:
-  metadata.gz: 9487530c2f5a42191a61c632fb85d30cbf6113ba6b5208bc2a0f3f2bee6c7634e8018d5896e9ba4bbe5db4bf12c1c5b41084f1eb1e36c66a89d6a5e7b4ef082e
-  data.tar.gz: 66381139ddee4c8f29bc0b0b1e08864f71b4805c6fc354c4dfb372641c5bb56ebb43cc4670b2958d6431a7a0195ef4a60c468a39ace586178b7cc760259f2369
+  metadata.gz: 1ce760c31989eaa2ec3d230031c176007953b9d5790d7d5e0c85d7b62e43f6d7d45cbe88651a70df3ca77c11f4d7b5587348e2ba0d951add5d8d76a90ba9d0e0
+  data.tar.gz: 4084a11ccd8ab92142e44399159290d5b14be05aa111f5c681571c6ba034a4ecb55587f0d3c2dda9d0ef765e4c5aefa9f2ea9e4183c27b81d4547b3719ae8393

data/.codeclimate.yml

@@ -34,7 +34,6 @@ engines:
   rubocop:
     enabled: true
     config: '.rubocop_cc.yml'
-    channel: rubocop-0-69
 prepare:
   fetch:
   - url: "https://raw.githubusercontent.com/ManageIQ/guides/master/.rubocop_base.yml"

data/.travis.yml

@@ -1,12 +1,12 @@
----
+dist: xenial
 sudo: false
 language: ruby
 cache: bundler
 rvm:
-- 2.5.7
-- 2.6.5
+- 2.4.4
+- 2.3.6
 addons:
-  postgresql: '9.5'
+  postgresql: '10'
 env:
   global:
   - CC_TEST_REPORTER_ID=1ef1a3a3d007395b11083d634a6fdac1e3d979b6428c39d2cd8d58556cdd68f7
@@ -14,12 +14,10 @@ before_install:
 - gem install bundler -v 2.0.1
 - psql -c "CREATE USER root SUPERUSER PASSWORD 'smartvm';" -U postgres
 before_script:
-# Code Climate
-- curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
+- curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64
+  > ./cc-test-reporter
 - chmod +x ./cc-test-reporter
 - "./cc-test-reporter before-build"
-# inventory_refresh
 - bundle exec rake spec:setup
 after_script:
-# Code Climate
 - "./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT"

data/inventory_refresh.gemspec

@@ -23,15 +23,13 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "activerecord", "~> 5.0"
-  spec.add_dependency "more_core_extensions", ">=3.5", "< 5"
+  spec.add_dependency "more_core_extensions", "~> 3.5"
   spec.add_dependency "pg", "> 0"
 
   spec.add_development_dependency "ancestry"
-  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "bundler", "~> 2.0.1"
   spec.add_development_dependency "factory_bot", "~> 4.11.1"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency "rubocop"
-  spec.add_development_dependency "rubocop-performance"
   spec.add_development_dependency "simplecov"
 end

data/lib/inventory_refresh.rb

@@ -6,6 +6,4 @@ require "inventory_refresh/logging"
 require "inventory_refresh/null_logger"
 require "inventory_refresh/persister"
 require "inventory_refresh/save_inventory"
-require "inventory_refresh/target"
-require "inventory_refresh/target_collection"
 require "inventory_refresh/version"

data/lib/inventory_refresh/application_record_iterator.rb

@@ -1,20 +1,12 @@
 module InventoryRefresh
   class ApplicationRecordIterator
-    attr_reader :inventory_collection, :manager_uuids_set, :iterator, :query
+    attr_reader :inventory_collection
 
-    # An iterator that can fetch batches of the AR objects based on a set of manager refs, or just mimics AR relation
-    # when given an iterator. Or given query, acts as iterator by selecting batches.
+    # An iterator that can fetch batches of the AR objects based on a set of attribute_indexes
     #
     # @param inventory_collection [InventoryRefresh::InventoryCollection] Inventory collection owning the iterator
-    # @param manager_uuids_set [Array<InventoryRefresh::InventoryCollection::Reference>] Array of references we want to
-    #        fetch from the DB
-    # @param iterator [Proc] Block based iterator
-    # @query query [ActiveRecord::Relation] Existing query we want to use for querying the db
-    def initialize(inventory_collection: nil, manager_uuids_set: nil, iterator: nil, query: nil)
+    def initialize(inventory_collection: nil)
       @inventory_collection = inventory_collection
-      @manager_uuids_set    = manager_uuids_set
-      @iterator             = iterator
-      @query                = query
     end
 
     # Iterator that mimics find_in_batches of ActiveRecord::Relation. This iterator serves for making more optimized query
@@ -25,28 +17,19 @@ module InventoryRefresh
     # and relation.where(:id => 500ids)
     #
     # @param batch_size [Integer] A batch size we want to fetch from DB
+    # @param attributes_index [Hash{String => Hash}] Indexed hash with data we will be saving
     # @yield Code processing the batches
-    def find_in_batches(batch_size: 1000)
-      if iterator
-        iterator.call do |batch|
-          yield(batch)
-        end
-      elsif query
-        manager_uuids_set.each_slice(batch_size) do |batch|
-          yield(query.where(inventory_collection.targeted_selection_for(batch)))
-        end
-      else
-        manager_uuids_set.each_slice(batch_size) do |batch|
-          yield(inventory_collection.db_collection_for_comparison_for(batch))
-        end
+    def find_in_batches(batch_size: 1000, attributes_index: {})
+      attributes_index.each_slice(batch_size) do |batch|
+        yield(inventory_collection.db_collection_for_comparison_for(batch))
       end
     end
 
     # Iterator that mimics find_each of ActiveRecord::Relation using find_in_batches (see #find_in_batches)
     #
     # @yield Code processing the batches
-    def find_each
-      find_in_batches do |batch|
+    def find_each(attributes_index: {})
+      find_in_batches(:attributes_index => attributes_index) do |batch|
         batch.each do |item|
           yield(item)
         end

data/lib/inventory_refresh/exception.rb

@@ -0,0 +1,8 @@
+module InventoryRefresh
+  module Exception
+    class SweeperError < StandardError; end
+    class SweeperNonExistentScopeKeyFoundError < SweeperError; end
+    class SweeperNonUniformScopeKeyFoundError < SweeperError; end
+    class SweeperScopeBadFormat < SweeperError; end
+  end
+end

data/lib/inventory_refresh/inventory_collection.rb

@@ -71,32 +71,14 @@ module InventoryRefresh
     #   InventoryCollection, since it is already persisted into the DB.
     attr_accessor :saved
 
-    # If present, InventoryCollection switches into delete_complement mode, where it will
-    # delete every record from the DB, that is not present in this list. This is used for the batch processing,
-    # where we don't know which InventoryObject should be deleted, but we know all manager_uuids of all
-    # InventoryObject objects that exists in the provider.
-    #
-    # @return [Array, nil] nil or a list of all :manager_uuids that are present in the Provider's InventoryCollection.
-    attr_accessor :all_manager_uuids
-
-    # @return [Array, nil] Scope for applying :all_manager_uuids
-    attr_accessor :all_manager_uuids_scope
-
-    # @return [String] Timestamp in UTC before fetching :all_manager_uuids
-    attr_accessor :all_manager_uuids_timestamp
-
     # @return [Set] A set of InventoryCollection objects that depends on this InventoryCollection object.
     attr_accessor :dependees
 
-    # @return [Array<Symbol>] @see #parent_inventory_collections documentation of InventoryCollection.new's initialize_ic_relations()
-    #   parameters
-    attr_accessor :parent_inventory_collections
-
     attr_reader :model_class, :strategy, :attributes_blacklist, :attributes_whitelist, :custom_save_block, :parent,
-                :internal_attributes, :delete_method, :dependency_attributes, :manager_ref, :create_only,
+                :internal_attributes, :dependency_attributes, :manager_ref, :secondary_refs, :create_only,
                 :association, :complete, :update_only, :transitive_dependency_attributes, :check_changed, :arel,
-                :inventory_object_attributes, :name, :saver_strategy, :targeted_scope, :default_values,
-                :targeted_arel, :targeted, :manager_ref_allowed_nil, :use_ar_object,
+                :inventory_object_attributes, :name, :saver_strategy, :default_values,
+                :manager_ref_allowed_nil, :use_ar_object,
                 :created_records, :updated_records, :deleted_records, :retention_strategy,
                 :custom_reconnect_block, :batch_extra_attributes, :references_storage, :unconnected_edges,
                 :assert_graph_integrity
@@ -130,7 +112,6 @@ module InventoryRefresh
              :lazy_find_by,
              :named_ref,
              :primary_index,
-             :reindex_secondary_indexes!,
              :skeletal_primary_index,
              :to => :index_proxy
 
@@ -153,28 +134,18 @@ module InventoryRefresh
                  properties[:check_changed],
                  properties[:update_only],
                  properties[:use_ar_object],
-                 properties[:targeted],
                  properties[:assert_graph_integrity])
 
       init_strategies(properties[:strategy],
-                      properties[:saver_strategy],
-                      properties[:retention_strategy],
-                      properties[:delete_method])
+                      properties[:retention_strategy])
 
       init_references(properties[:manager_ref],
                       properties[:manager_ref_allowed_nil],
-                      properties[:secondary_refs],
-                      properties[:manager_uuids])
+                      properties[:secondary_refs])
 
-      init_all_manager_uuids(properties[:all_manager_uuids],
-                             properties[:all_manager_uuids_scope],
-                             properties[:all_manager_uuids_timestamp])
+      init_ic_relations(properties[:dependency_attributes])
 
-      init_ic_relations(properties[:dependency_attributes],
-                        properties[:parent_inventory_collections])
-
-      init_arels(properties[:arel],
-                 properties[:targeted_arel])
+      init_arels(properties[:arel])
 
       init_custom_procs(properties[:custom_save_block],
                         properties[:custom_reconnect_block])
@@ -311,6 +282,11 @@ module InventoryRefresh
       @base_columns ||= (unique_index_columns + internal_columns + not_null_columns).uniq
     end
 
+    # @return [Array<Symbol>] Array of all column names on the InventoryCollection
+    def all_column_names
+      @all_column_names ||= model_class.columns.map { |x| x.name.to_sym }
+    end
+
     # @param value [Object] Object we want to test
     # @return [Boolean] true is value is kind of InventoryRefresh::InventoryObject
     def inventory_object?(value)
@@ -335,7 +311,7 @@ module InventoryRefresh
 
     # Convert manager_ref list of attributes to list of DB columns
     #
-    # @return [Array<String>] true is processing of this InventoryCollection will be in targeted mode
+    # @return [Array<String>] Converted manager_ref list of attributes to list of DB columns
     def manager_ref_to_cols
       # TODO(lsmola) this should contain the polymorphic _type, otherwise the IC with polymorphic unique key will get
       # conflicts
@@ -434,7 +410,6 @@ module InventoryRefresh
                               :parent                => parent,
                               :arel                  => arel,
                               :strategy              => strategy,
-                              :saver_strategy        => saver_strategy,
                               :custom_save_block     => custom_save_block,
                               # We want cloned IC to be update only, since this is used for cycle resolution
                               :update_only           => true,
@@ -472,78 +447,31 @@ module InventoryRefresh
 
     # @return [Integer] default batch size for talking to the DB
     def batch_size
-      # TODO(lsmola) mode to the settings
       1000
     end
 
     # @return [Integer] default batch size for talking to the DB if not using ApplicationRecord objects
     def batch_size_pure_sql
-      # TODO(lsmola) mode to the settings
       10_000
     end
 
-    # Returns a list of stringified uuids of all scoped InventoryObjects, which is used for scoping in targeted mode
-    #
-    # @return [Array<String>] list of stringified uuids of all scoped InventoryObjects
-    def manager_uuids
-      # TODO(lsmola) LEGACY: this is still being used by :targetel_arel definitions and it expects array of strings
-      raise "This works only for :manager_ref size 1" if manager_ref.size > 1
-      key = manager_ref.first
-      transform_references_to_hashes(targeted_scope.primary_references).map { |x| x[key] }
-    end
-
     # Builds a multiselection conditions like (table1.a = a1 AND table2.b = b1) OR (table1.a = a2 AND table2.b = b2)
     #
     # @param hashes [Array<Hash>] data we want to use for the query
     # @param keys [Array<Symbol>] keys of attributes involved
     # @return [String] A condition usable in .where of an ActiveRecord relation
-    def build_multi_selection_condition(hashes, keys = manager_ref)
+    def build_multi_selection_condition(hashes, keys = unique_index_keys)
       arel_table = model_class.arel_table
       # We do pure SQL OR, since Arel is nesting every .or into another parentheses, otherwise this would be just
       # inject(:or) instead of to_sql with .join(" OR ")
       hashes.map { |hash| "(#{keys.map { |key| arel_table[key].eq(hash[key]) }.inject(:and).to_sql})" }.join(" OR ")
     end
 
-    # @return [ActiveRecord::Relation] A relation that can fetch all data of this InventoryCollection from the DB
-    def db_collection_for_comparison
-      if targeted?
-        if targeted_arel.respond_to?(:call)
-          targeted_arel.call(self)
-        elsif parent_inventory_collections.present?
-          targeted_arel_default
-        else
-          targeted_iterator_for(targeted_scope.primary_references)
-        end
-      else
-        full_collection_for_comparison
-      end
-    end
-
-    # Builds targeted query limiting the results by the :references defined in parent_inventory_collections
-    #
-    # @return [InventoryRefresh::ApplicationRecordIterator] an iterator for default targeted arel
-    def targeted_arel_default
-      if parent_inventory_collections.collect { |x| x.model_class.base_class }.uniq.count > 1
-        raise "Multiple :parent_inventory_collections with different base class are not supported by default. Write "\
-              ":targeted_arel manually, or separate [#{self}] into 2 InventoryCollection objects."
-      end
-      parent_collection = parent_inventory_collections.first
-      references        = parent_inventory_collections.map { |x| x.targeted_scope.primary_references }.reduce({}, :merge!)
-
-      parent_collection.targeted_iterator_for(references, full_collection_for_comparison)
-    end
-
-    # Gets targeted references and transforms them into list of hashes
+    # Returns iterator for the passed references and a query
     #
-    # @param references [Array, InventoryRefresh::InventoryCollection::TargetedScope] passed references
-    # @return [Array<Hash>] References transformed into the array of hashes
-    def transform_references_to_hashes(references)
-      if references.kind_of?(Array)
-        # Sliced InventoryRefresh::InventoryCollection::TargetedScope
-        references.map { |x| x.second.full_reference }
-      else
-        references.values.map(&:full_reference)
-      end
+    # @return [InventoryRefresh::ApplicationRecordIterator] Iterator for the references and query
+    def db_collection_for_comparison
+      InventoryRefresh::ApplicationRecordIterator.new(:inventory_collection => self)
     end
 
     # Builds a multiselection conditions like (table1.a = a1 AND table2.b = b1) OR (table1.a = a2 AND table2.b = b2)
@@ -552,20 +480,20 @@ module InventoryRefresh
     # @param references [Hash{String => InventoryRefresh::InventoryCollection::Reference}] passed references
     # @return [String] A condition usable in .where of an ActiveRecord relation
     def targeted_selection_for(references)
-      build_multi_selection_condition(transform_references_to_hashes(references))
+      build_multi_selection_condition(references.map(&:second))
     end
 
-    # Returns iterator for the passed references and a query
-    #
-    # @param references [Hash{String => InventoryRefresh::InventoryCollection::Reference}] Passed references
-    # @param query [ActiveRecord::Relation] relation that can fetch all data of this InventoryCollection from the DB
-    # @return [InventoryRefresh::ApplicationRecordIterator] Iterator for the references and query
-    def targeted_iterator_for(references, query = nil)
-      InventoryRefresh::ApplicationRecordIterator.new(
-        :inventory_collection => self,
-        :manager_uuids_set    => references,
-        :query                => query
-      )
+    def select_keys
+      @select_keys ||= [@model_class.primary_key] + manager_ref_to_cols.map(&:to_s) + internal_columns.map(&:to_s)
+    end
+
+    # @return [ActiveRecord::ConnectionAdapters::AbstractAdapter] ActiveRecord connection
+    def get_connection
+      ActiveRecord::Base.connection
+    end
+
+    def pure_sql_record_fetching?
+      !use_ar_object?
     end
 
     # Builds an ActiveRecord::Relation that can fetch all the references from the DB
@@ -573,14 +501,18 @@ module InventoryRefresh
     # @param references [Hash{String => InventoryRefresh::InventoryCollection::Reference}] passed references
     # @return [ActiveRecord::Relation] relation that can fetch all the references from the DB
     def db_collection_for_comparison_for(references)
-      full_collection_for_comparison.where(targeted_selection_for(references))
+      query = full_collection_for_comparison.where(targeted_selection_for(references))
+      if pure_sql_record_fetching?
+        return get_connection.query(query.select(*select_keys).to_sql)
+      end
+
+      query
     end
 
     # @return [ActiveRecord::Relation] relation that can fetch all the references from the DB
     def full_collection_for_comparison
       return arel unless arel.nil?
       rel = parent.send(association)
-      rel = rel.active if rel && supports_column?(:archived_at) && retention_strategy == :archive
       rel
     end
 
@@ -634,11 +566,5 @@ module InventoryRefresh
         :id => identity
       }
     end
-
-    # TODO: Not used!
-    # @return [Array<Symbol>] all association attributes and foreign keys of the model class
-    def association_attributes
-      model_class.reflect_on_all_associations.map { |x| [x.name, x.foreign_key] }.flatten.compact.map(&:to_sym)
-    end
   end
 end

data/lib/inventory_refresh/inventory_collection/builder.rb

@@ -4,16 +4,16 @@ module InventoryRefresh
       class MissingModelClassError < StandardError; end
 
       def self.allowed_properties
-        %i(all_manager_uuids            arel                    association
+        %i(arel                         association
            attributes_blacklist         attributes_whitelist    batch_extra_attributes
            complete                     create_only             custom_save_block
-           custom_reconnect_block       default_values          delete_method
+           custom_reconnect_block       default_values
            dependency_attributes        check_changed           inventory_object_attributes
-           manager_ref                  manager_ref_allowed_nil manager_uuids
+           manager_ref                  manager_ref_allowed_nil
            model_class                  name                    parent
-           parent_inventory_collections retention_strategy      strategy
-           saver_strategy               secondary_refs          targeted
-           targeted_arel                update_only             use_ar_object
+           retention_strategy           strategy
+           secondary_refs
+           update_only                  use_ar_object
            assert_graph_integrity).to_set
       end
 

data/lib/inventory_refresh/inventory_collection/data_storage.rb

@@ -70,15 +70,6 @@ module InventoryRefresh
         build(hash)
       end
 
-      # Finds InventoryObject.
-      #
-      # @param hash [Hash] Hash that needs to contain attributes defined in :manager_ref of the InventoryCollection
-      # @return [InventoryRefresh::InventoryObject] Found or built InventoryObject object
-      def find_in_data(hash)
-        _hash, _uuid, inventory_object = primary_index_scan(hash)
-        inventory_object
-      end
-
       # Finds of builds a new InventoryObject. By building it, we also put in into the InventoryCollection's storage.
       #
       # @param hash [Hash] Hash that needs to contain attributes defined in :manager_ref of the

data/lib/inventory_refresh/inventory_collection/helpers/initialize_helper.rb

@@ -35,26 +35,14 @@ module InventoryRefresh
         #         - :local_db_find_missing_references => InventoryObject objects of the InventoryCollection will be saved to
         #                                                the DB. Then if we reference an object that is not present, it will
         #                                                load them from the db using :local_db_find_references strategy.
-        # @param saver_strategy [Symbol] A strategy that will be used for InventoryCollection persisting into the DB.
-        #        Allowed saver strategies are:
-        #        - :default => Using Rails saving methods, this way is not safe to run in multiple workers concurrently,
-        #          since it will lead to non consistent data.
-        #        - :batch => Using batch SQL queries, this way is not safe to run in multiple workers
-        #          concurrently, since it will lead to non consistent data.
-        #        - :concurrent_safe_batch => It uses atomic upsert to avoid data duplication and it uses timestamp based
-        #          atomic checks to avoid new data being overwritten by the the old data. The upsert/update queries are
-        #          executed as batched SQL queries, instead of sending 1 query per record.
         # @param retention_strategy [Symbol] A retention strategy for this collection. Allowed values are:
         #        - :destroy => Will destroy the inactive records.
         #        - :archive => Will archive the inactive records by setting :archived_at timestamp.
-        # @param delete_method [Symbol] A delete method that will be used for deleting of the InventoryObject, if the
-        #        object is marked for deletion. A default is :destroy, the instance method must be defined on the
-        #        :model_class.
-        def init_strategies(strategy, saver_strategy, retention_strategy, delete_method)
-          @saver_strategy     = process_saver_strategy(saver_strategy)
+        def init_strategies(strategy, retention_strategy)
+          @saver_strategy     = :concurrent_safe_batch
           @strategy           = process_strategy(strategy)
+          # TODO(lsmola) why don't we just set this strategy based on :archived_at column? Lets do that
           @retention_strategy = process_retention_strategy(retention_strategy)
-          @delete_method      = delete_method || :destroy
         end
 
         # @param manager_ref [Array] Array of Symbols, that are keys of the InventoryObject's data, inserted into this
@@ -67,42 +55,10 @@ module InventoryRefresh
         #        avoid this usecase by a proper modeling.
         #        Note that InventoryObject's data has to be build with <foreign_key> => nil, it means that key cannot be missing!
         # @param secondary_refs [Hash] TODO
-        # @param manager_uuids [Array|Proc] Array of manager_uuids of the InventoryObjects we want to create/update/delete. Using
-        #        this attribute, the db_collection_for_comparison will be automatically limited by the manager_uuids, in a
-        #        case of a simple relation. In a case of a complex relation, we can leverage :manager_uuids in a
-        #        custom :targeted_arel. We can pass also lambda, for lazy_evaluation.
-        def init_references(manager_ref, manager_ref_allowed_nil, secondary_refs,  manager_uuids)
+        def init_references(manager_ref, manager_ref_allowed_nil, secondary_refs)
           @manager_ref             = manager_ref || %i(ems_ref)
           @manager_ref_allowed_nil = manager_ref_allowed_nil || []
           @secondary_refs          = secondary_refs || {}
-          @manager_uuids           = manager_uuids || []
-        end
-
-        # @param all_manager_uuids [Array] Array of all manager_uuids of the InventoryObjects. With the :targeted true,
-        #        having this parameter defined will invoke only :delete_method on a complement of this set, making sure
-        #        the DB has only this set of data after. This :attribute serves for deleting of top level
-        #        InventoryCollections, i.e. InventoryCollections having parent_inventory_collections nil. The deleting of
-        #        child collections is already handled by the scope of the parent_inventory_collections and using Rails
-        #        :dependent => :destroy,
-        # @param all_manager_uuids_scope [Array] A scope limiting the :all_manager_uuids parameter. E.g. we can send
-        #        all_manager_uuids for 1 region, leading to delete a complement of the entities just under that 1
-        #        region.
-        #        If all_manager_uuids_scope is used with :all_manager_uuids => nil, it will do delete_complement of the
-        #        scope itself. E.g. sending a list of all active regions, we will delete complement entities not
-        #        belonging to those regions.
-        #        Example:
-        #          :all_manager_uuids       => [{:source_ref => x}, {:source_ref => y}],
-        #          :all_manager_uuids_scope => [{:region => regions.lazy_find(X)}, {:region => regions.lazy_find(Y)}]
-        #
-        #        Will cause deletion/archival or all entities that don't have source_ref "x" or "y", but only under
-        #        regions X and Y.
-        # @param all_manager_uuids_timestamp [String] A timestamp in UTC marking a time before we collected all of the
-        #        all_manager_uuids. Meaning we won't be archiving any newer entities.
-        def init_all_manager_uuids(all_manager_uuids, all_manager_uuids_scope, all_manager_uuids_timestamp)
-          # TODO(lsmola) Should we refactor this to use references too?
-          @all_manager_uuids           = all_manager_uuids
-          @all_manager_uuids_scope     = all_manager_uuids_scope
-          @all_manager_uuids_timestamp = all_manager_uuids_timestamp
         end
 
         # @param dependency_attributes [Hash] Manually defined dependencies of this InventoryCollection. We can use this
@@ -119,48 +75,9 @@ module InventoryRefresh
         #        This example is used in Example2 of the <param custom_save_block> and it means that our :custom_save_block
         #        will be invoked after the InventoryCollection :orchestration_stacks and :orchestration_stacks_resources
         #        are saved.
-        # @param parent_inventory_collections [Array] Array of symbols having a name pointing to the
-        #        InventoryRefresh::InventoryCollection objects, that serve as parents to this InventoryCollection. There are
-        #        several scenarios to consider, when deciding if InventoryCollection has parent collections, see the example.
-        #
-        #        Example:
-        #          taking inventory collections :vms and :disks (local disks), if we write that:
-        #          inventory_collection = InventoryCollection.new({
-        #                       :model_class                 => ::Disk,
-        #                       :association                 => :disks,
-        #                       :manager_ref                 => [:vm, :location]
-        #                       :parent_inventory_collection => [:vms],
-        #                     })
-        #
-        #          Then the decision for having :parent_inventory_collection => [:vms] was probably driven by these
-        #          points:
-        #          1. We can get list of all disks only by doing SQL query through the parent object (so there will be join
-        #             from vms to disks table).
-        #          2. There is no API query for getting all disks from the provider API, we get them inside VM data, or as
-        #             a Vm subquery
-        #          3. Part of the manager_ref of the IC is the VM object (foreign key), so the disk's location is unique
-        #             only under 1 Vm. (In current models, this modeled going through Hardware model)
-        #          4. In targeted refresh, we always expect that each Vm will be saved with all its disks.
-        #
-        #          Then having the above points, adding :parent_inventory_collection => [:vms], will bring these
-        #          implications:
-        #          1. By archiving/deleting Vm, we can no longer see the disk, because those were owned by the Vm. Any
-        #             archival/deletion of the Disk model, must be then done by cascade delete/hooks logic.
-        #          2. Having Vm as a parent ensures we always process it first. So e.g. when providing no Vms for saving
-        #             we would have no graph dependency (no data --> no edges --> no dependencies) and Disk could be
-        #             archived/removed before the Vm, while we always want to archive the VM first.
-        #          3. For targeted refresh, we always expect that all disks are saved with a VM. So for targeting :disks,
-        #             we are not using #manager_uuids attribute, since the scope is "all disks of all targeted VMs", so we
-        #             always use #manager_uuids of the parent. (that is why :parent_inventory_collections and
-        #             :manager_uuids are mutually exclusive attributes)
-        #          4. For automatically building the #targeted_arel query, we need the parent to know what is the root node.
-        #             While this information can be introspected from the data, it creates a scope for create&update&delete,
-        #             which means it has to work with no data provided (causing delete all). So with no data we cannot
-        #             introspect anything.
-        def init_ic_relations(dependency_attributes, parent_inventory_collections = nil)
-          @dependency_attributes        = dependency_attributes || {}
-          @dependees                    = Set.new
-          @parent_inventory_collections = parent_inventory_collections
+        def init_ic_relations(dependency_attributes)
+          @dependency_attributes = dependency_attributes || {}
+          @dependees             = Set.new
         end
 
         # @param complete [Boolean] By default true, :complete is marking we are sending a complete dataset and therefore
@@ -175,18 +92,13 @@ module InventoryRefresh
         # @param use_ar_object [Boolean] True or False. Whether we need to initialize AR object as part of the saving
         #        it's needed if the model have special setters, serialize of columns, etc. This setting is relevant only
         #        for the batch saver strategy.
-        # @param targeted [Boolean] True if the collection is targeted, in that case it will be leveraging :manager_uuids
-        #        :parent_inventory_collections and :targeted_arel to save a subgraph of a data.
-        def init_flags(complete, create_only, check_changed,
-                       update_only, use_ar_object, targeted,
-                       assert_graph_integrity)
+        def init_flags(complete, create_only, check_changed, update_only, use_ar_object, assert_graph_integrity)
           @complete               = complete.nil? ? true : complete
           @create_only            = create_only.nil? ? false : create_only
           @check_changed          = check_changed.nil? ? true : check_changed
           @saved                  = false
           @update_only            = update_only.nil? ? false : update_only
           @use_ar_object          = use_ar_object || false
-          @targeted               = !!targeted
           @assert_graph_integrity = assert_graph_integrity.nil? ? true : assert_graph_integrity
         end
 
@@ -230,7 +142,7 @@ module InventoryRefresh
           @attributes_whitelist             = Set.new
           @batch_extra_attributes           = batch_extra_attributes || []
           @inventory_object_attributes      = inventory_object_attributes
-          @internal_attributes              = %i(__feedback_edge_set_parent __parent_inventory_collections __all_manager_uuids_scope)
+          @internal_attributes              = %i(__feedback_edge_set_parent)
           @transitive_dependency_attributes = Set.new
 
           blacklist_attributes!(attributes_blacklist) if attributes_blacklist.present?
@@ -240,7 +152,6 @@ module InventoryRefresh
         def init_storages
           @data_storage       = ::InventoryRefresh::InventoryCollection::DataStorage.new(self, @secondary_refs)
           @references_storage = ::InventoryRefresh::InventoryCollection::ReferencesStorage.new(index_proxy)
-          @targeted_scope     = ::InventoryRefresh::InventoryCollection::ReferencesStorage.new(index_proxy).merge!(@manager_uuids)
         end
 
         # @param arel [ActiveRecord::Associations::CollectionProxy|Arel::SelectManager] Instead of :parent and :association
@@ -248,35 +159,18 @@ module InventoryRefresh
         #        doing create/update/delete.
         #
         #        Example:
-        #        for a targeted refresh, we want to delete/update/create only a list of vms specified with a list of
-        #        ems_refs:
-        #            :arel => manager.vms.where(:ems_ref => manager_refs)
-        #        Then we want to do the same for the hardwares of only those vms:
-        #             :arel => manager.hardwares.joins(:vm_or_template).where(
-        #               'vms' => {:ems_ref => manager_refs}
-        #             )
-        #        And etc. for the other Vm related records.
-        # @param targeted_arel [Proc] A callable block that receives this InventoryCollection as a first argument. In there
-        #        we can leverage a :parent_inventory_collections or :manager_uuids to limit the query based on the
-        #        manager_uuids available.
-        #        Example:
-        #          targeted_arel = lambda do |inventory_collection|
-        #            # Getting ems_refs of parent :vms and :miq_templates
-        #            manager_uuids = inventory_collection.parent_inventory_collections.collect(&:manager_uuids).flatten
-        #            inventory_collection.db_collection_for_comparison.hardwares.joins(:vm_or_template).where(
-        #              'vms' => {:ems_ref => manager_uuids}
+        #          add_collection(:cross_link_vms) do |builder|
+        #            builder.add_properties(
+        #              :arel        => Vm.where(:tenant => manager.tenant),
+        #              :association => nil,
+        #              :model_class => Vm,
+        #              :name        => :cross_link_vms,
+        #              :manager_ref => [:uid_ems],
+        #              :strategy    => :local_db_find_references,
         #            )
         #          end
-        #
-        #          inventory_collection = InventoryCollection.new({
-        #                                   :model_class                 => ::Hardware,
-        #                                   :association                 => :hardwares,
-        #                                   :parent_inventory_collection => [:vms, :miq_templates],
-        #                                   :targeted_arel               => targeted_arel,
-        #                                 })
-        def init_arels(arel, targeted_arel)
-          @arel                   = arel
-          @targeted_arel          = targeted_arel
+        def init_arels(arel)
+          @arel = arel
         end
 
         # @param custom_save_block [Proc] A custom lambda/proc for persisting in the DB, for cases where it's not enough
@@ -392,23 +286,6 @@ module InventoryRefresh
           @deleted_records = []
         end
 
-        # Processes passed saver strategy
-        #
-        # @param saver_strategy [Symbol] Passed saver strategy
-        # @return [Symbol] Returns back the passed strategy if supported, or raises exception
-        def process_saver_strategy(saver_strategy)
-          return :default unless saver_strategy
-
-          saver_strategy = saver_strategy.to_sym
-          case saver_strategy
-          when :default, :batch, :concurrent_safe_batch
-            saver_strategy
-          else
-            raise "Unknown InventoryCollection saver strategy: :#{saver_strategy}, allowed strategies are "\
-              ":default, :batch and :concurrent_safe_batch"
-          end
-        end
-
         # Processes passed strategy, modifies :data_collection_finalized and :saved attributes for db only strategies
         #
         # @param strategy_name [Symbol] Passed saver strategy
@@ -434,12 +311,26 @@ module InventoryRefresh
           strategy_name
         end
 
+        # Saves passed strategy, modifies :data_collection_finalized and :saved attributes for db only strategies
+        #
+        # @param strategy [Symbol] Passed saver strategy
+        # @return [Symbol] Returns back the passed strategy if supported, or raises exception
+        def strategy=(strategy)
+          @strategy = process_strategy(strategy)
+        end
+
         # Processes passed retention strategy
         #
         # @param retention_strategy [Symbol] Passed retention strategy
         # @return [Symbol] Returns back the passed strategy if supported, or raises exception
         def process_retention_strategy(retention_strategy)
-          return unless retention_strategy
+          unless retention_strategy
+            if supports_column?(:archived_at)
+              return :archive
+            else
+              return :destroy
+            end
+          end
 
           retention_strategy = retention_strategy.to_sym
           case retention_strategy