inventory_refresh 0.1.3 → 0.2.0

data/lib/inventory_refresh/inventory_collection/scanner.rb

@@ -13,7 +13,7 @@ module InventoryRefresh
           indexed_inventory_collections = inventory_collections.index_by(&:name)
 
           inventory_collections.each do |inventory_collection|
-            new(inventory_collection, indexed_inventory_collections).scan!
+            new(inventory_collection, indexed_inventory_collections, build_association_hash(inventory_collections)).scan!
           end
 
           inventory_collections.each do |inventory_collection|
@@ -22,9 +22,21 @@ module InventoryRefresh
             end
           end
         end
+
+        def build_association_hash(inventory_collections)
+          associations_hash = {}
+          parents = inventory_collections.map(&:parent).compact.uniq
+          parents.each do |parent|
+            parent.class.reflect_on_all_associations(:has_many).each do |association|
+              through_assoc = association.options.try(:[], :through)
+              associations_hash[association.name] = through_assoc if association.options.try(:[], :through)
+            end
+          end
+          associations_hash
+        end
       end
 
-      attr_reader :inventory_collection, :indexed_inventory_collections
+      attr_reader :associations_hash, :inventory_collection, :indexed_inventory_collections
 
       # Boolean helpers the scanner uses from the :inventory_collection
       delegate :inventory_object_lazy?,
@@ -40,19 +52,26 @@ module InventoryRefresh
                :to => :inventory_collection
 
       # The data scanner modifies inside of the :inventory_collection
-      delegate :attribute_references,
+      delegate :all_manager_uuids_scope,
+               :association,
+               :arel,
+               :attribute_references,
+               :custom_save_block,
                :data_collection_finalized=,
                :dependency_attributes,
+               :targeted?,
                :targeted_scope,
+               :parent,
                :parent_inventory_collections,
                :parent_inventory_collections=,
                :references,
                :transitive_dependency_attributes,
                :to => :inventory_collection
 
-      def initialize(inventory_collection, indexed_inventory_collections)
+      def initialize(inventory_collection, indexed_inventory_collections, associations_hash)
         @inventory_collection          = inventory_collection
         @indexed_inventory_collections = indexed_inventory_collections
+        @associations_hash             = associations_hash
       end
 
       def scan!
@@ -66,26 +85,85 @@ module InventoryRefresh
           end
         end
 
-        # Transform :parent_inventory_collections symbols to InventoryCollection objects
-        if parent_inventory_collections.present?
-          self.parent_inventory_collections = parent_inventory_collections.map do |inventory_collection_index|
-            ic = indexed_inventory_collections[inventory_collection_index]
-            if ic.nil?
-              raise "Can't find InventoryCollection #{inventory_collection_index} from #{inventory_collection}" if targeted?
-            else
-              # Add parent_inventory_collection as a dependency, so e.g. disconnect is done in a right order
-              (dependency_attributes[:__parent_inventory_collections] ||= Set.new) << ic
-              ic
-            end
-          end.compact
+        # Scan InventoryCollection skeletal data
+        inventory_collection.skeletal_primary_index.each_value do |inventory_object|
+          scan_inventory_object!(inventory_object)
         end
 
+        build_parent_inventory_collections!
+        scan_all_manager_uuids_scope!
+
         # Mark InventoryCollection as finalized aka. scanned
         self.data_collection_finalized = true
       end
 
       private
 
+      def scan_all_manager_uuids_scope!
+        return if all_manager_uuids_scope.nil?
+
+        all_manager_uuids_scope.each do |scope|
+          scope.each_value do |value|
+            scan_all_manager_uuids_scope_attribute!(value)
+          end
+        end
+      end
+
+      def build_parent_inventory_collections!
+        if parent_inventory_collections.nil?
+          build_parent_inventory_collection!
+        else
+          # We can't figure out what immediate parent is, we'll add parent_inventory_collections as dependencies
+          parent_inventory_collections.each { |ic_name| add_parent_inventory_collection_dependency!(ic_name) }
+        end
+
+        return if parent_inventory_collections.blank?
+
+        # Transform InventoryCollection object names to actual objects
+        self.parent_inventory_collections = parent_inventory_collections.map { |x| load_inventory_collection_by_name(x) }
+      end
+
+      def build_parent_inventory_collection!
+        return unless supports_building_inventory_collection?
+
+        if association.present? && parent.present? && associations_hash[association].present?
+          # Add immediate parent IC as dependency
+          add_parent_inventory_collection_dependency!(associations_hash[association])
+          # Add root IC in parent_inventory_collections
+          self.parent_inventory_collections = [find_parent_inventory_collection(associations_hash, inventory_collection.association)]
+        end
+      end
+
+      def supports_building_inventory_collection?
+        # Don't try to introspect ICs with custom query or saving code
+        return if arel.present? || custom_save_block.present?
+        # We support :parent_inventory_collections only for targeted mode, where all ICs are present
+        return unless targeted?
+
+        true
+      end
+
+      def add_parent_inventory_collection_dependency!(ic_name)
+        ic = load_inventory_collection_by_name(ic_name)
+        (dependency_attributes[:__parent_inventory_collections] ||= Set.new) << ic if ic
+      end
+
+      def find_parent_inventory_collection(hash, name)
+        if hash[name]
+          find_parent_inventory_collection(hash, hash[name])
+        else
+          name
+        end
+      end
+
+      def load_inventory_collection_by_name(name)
+        ic = indexed_inventory_collections[name]
+        if ic.nil?
+          raise "Can't find InventoryCollection :#{name} referenced from #{inventory_collection}" if targeted?
+        end
+        ic
+      end
+
       def scan_inventory_object!(inventory_object)
         inventory_object.data.each do |key, value|
           if value.kind_of?(Array)
@@ -96,8 +174,23 @@ module InventoryRefresh
         end
       end
 
+      def loadable?(value)
+        inventory_object_lazy?(value) || inventory_object?(value)
+      end
+
+      def add_reference(value_inventory_collection, value)
+        value_inventory_collection.add_reference(value.reference, :key => value.key)
+      end
+
+      def scan_all_manager_uuids_scope_attribute!(value)
+        return unless loadable?(value)
+
+        add_reference(value.inventory_collection, value)
+        (dependency_attributes[:__all_manager_uuids_scope] ||= Set.new) << value.inventory_collection
+      end
+
       def scan_inventory_object_attribute!(key, value)
-        return if !inventory_object_lazy?(value) && !inventory_object?(value)
+        return unless loadable?(value)
         value_inventory_collection = value.inventory_collection
 
         # Storing attributes and their dependencies
@@ -105,7 +198,7 @@ module InventoryRefresh
 
         # Storing a reference in the target inventory_collection, then each IC knows about all the references and can
         # e.g. load all the referenced uuids from a DB
-        value_inventory_collection.add_reference(value.reference, :key => value.key)
+        add_reference(value_inventory_collection, value)
 
         if inventory_object_lazy?(value)
           # Storing if attribute is a transitive dependency, so a lazy_find :key results in dependency

data/lib/inventory_refresh/inventory_collection/serialization.rb

@@ -4,6 +4,7 @@ module InventoryRefresh
   class InventoryCollection
     class Serialization
       delegate :all_manager_uuids,
+               :all_manager_uuids=,
                :build,
                :targeted_scope,
                :data,
@@ -27,18 +28,17 @@ module InventoryRefresh
       # @param available_inventory_collections [Array<InventoryRefresh::InventoryCollection>] List of available
       #        InventoryCollection objects
       def from_hash(inventory_objects_data, available_inventory_collections)
-        targeted_scope.merge!(inventory_objects_data["manager_uuids"].map(&:symbolize_keys!))
+        targeted_scope.merge!(inventory_objects_data["manager_uuids"].map(&:symbolize_keys!)) if inventory_objects_data["manager_uuids"]
 
-        inventory_objects_data['data'].each do |inventory_object_data|
+        (inventory_objects_data['data'] || []).each do |inventory_object_data|
           build(hash_to_data(inventory_object_data, available_inventory_collections).symbolize_keys!)
         end
 
-        inventory_objects_data['partial_data'].each do |inventory_object_data|
+        (inventory_objects_data['partial_data'] || []).each do |inventory_object_data|
           skeletal_primary_index.build(hash_to_data(inventory_object_data, available_inventory_collections).symbolize_keys!)
         end
 
-        # TODO(lsmola) add support for all_manager_uuids serialization
-        # self.all_manager_uuids = inventory_objects_data['all_manager_uuids']
+        self.all_manager_uuids = inventory_objects_data['all_manager_uuids']
       end
 
       # Serializes InventoryCollection's data storage into Array of Hashes
@@ -105,9 +105,9 @@ module InventoryRefresh
         raise "Nested lazy_relation of #{inventory_collection} is too deep, left processing: #{hash}" if depth > 20
 
         hash.transform_values do |value|
-          if value.kind_of?(Hash) && value['type'] == "InventoryRefresh::InventoryObjectLazy"
+          if value.kind_of?(Hash) && value['inventory_collection_name']
             hash_to_lazy_relation(value, available_inventory_collections, depth)
-          elsif value.kind_of?(Array) && value.first.kind_of?(Hash) && value.first['type'] == "InventoryRefresh::InventoryObjectLazy"
+          elsif value.kind_of?(Array) && value.first.kind_of?(Hash) && value.first['inventory_collection_name']
             # TODO(lsmola) do we need to compact it sooner? What if first element is nil? On the other hand, we want to
             # deprecate this Vm HABTM assignment because it's not effective
             value.compact.map { |x| hash_to_lazy_relation(x, available_inventory_collections, depth) }

data/lib/inventory_refresh/inventory_collection/unconnected_edge.rb

@@ -0,0 +1,19 @@
+require "active_support/core_ext/module/delegation"
+
+module InventoryRefresh
+  class InventoryCollection
+    class UnconnectedEdge
+      attr_reader :inventory_object, :inventory_object_key, :inventory_object_lazy
+
+      # @param inventory_object [InventoryRefresh::InventoryObject] InventoryObject that couldn't connect the relation
+      # @param inventory_object_key [String] Relation name that couldn't be connected
+      # @param inventory_object_lazy [InventoryRefresh::InventoryObjectLazy] The lazy relation that failed to load
+      #                              this can happen only for relations with key, or pointing to DB only relations
+      def initialize(inventory_object, inventory_object_key, inventory_object_lazy)
+        @inventory_object      = inventory_object
+        @inventory_object_key  = inventory_object_key
+        @inventory_object_lazy = inventory_object_lazy
+      end
+    end
+  end
+end