Reuse devices first; reuse later

src/lib/y2storage/proposal/autoinst_devices_creator.rb

@@ -140,8 +140,8 @@ def best_distribution(planned_partitions, disk_names)
       def process_partitions(planned_devices, disk_names)
         planned_partitions = sized_partitions(planned_devices.disk_partitions)
         parts_to_reuse, parts_to_create = planned_partitions.partition(&:reuse?)
-        creator_result = create_partitions(parts_to_create, disk_names)
-        reuse_devices(parts_to_reuse, creator_result.devicegraph)
+        reuse_devices(parts_to_reuse, original_graph)
+        creator_result = create_partitions(original_graph, parts_to_create, disk_names)
 
         [parts_to_create, parts_to_reuse, creator_result]
       end
@@ -156,8 +156,8 @@ def process_partitions(planned_devices, disk_names)
       def process_mds(planned_devices, devs_to_reuse, creator_result)
         mds_to_reuse, mds_to_create = planned_devices.mds.partition(&:reuse?)
         devs_to_reuse_in_md = reusable_by_md(devs_to_reuse)
-        creator_result.merge!(create_mds(planned_devices.mds, creator_result, devs_to_reuse_in_md))
         reuse_mds(mds_to_reuse, creator_result)
+        creator_result.merge!(create_mds(planned_devices.mds, creator_result, devs_to_reuse_in_md))
 
         [mds_to_create, mds_to_reuse, creator_result]
       end
@@ -171,9 +171,9 @@ def process_mds(planned_devices, devs_to_reuse, creator_result)
       # @return [Array<Array<Planned::Md>, Array<Planned::Md>, CreatorResult>]
       def process_vgs(planned_devices, devs_to_reuse, creator_result)
         planned_vgs = planned_devices.vgs
-        creator_result.merge!(set_up_lvm(planned_vgs, creator_result, devs_to_reuse))
         vgs_to_reuse = planned_vgs.select(&:reuse?)
         creator_result = reuse_vgs(vgs_to_reuse, creator_result)
+        creator_result.merge!(set_up_lvm(planned_vgs, creator_result, devs_to_reuse))
 
         [planned_vgs, creator_result]
       end
@@ -199,14 +199,14 @@ def process_disk_like_devs(planned_devices, devicegraph)
       # @param new_partitions [Array<Planned::Partition>] Devices to create
       # @param disk_names     [Array<String>]             Disks to consider
       # @return [PartitionCreatorResult]
-      def create_partitions(new_partitions, disk_names)
+      def create_partitions(devicegraph, new_partitions, disk_names)
         log.info "Partitions to create: #{new_partitions}"
         primary, non_primary = new_partitions.partition(&:primary)
         parts_to_create = primary + non_primary
 
         dist = best_distribution(parts_to_create, disk_names)
         raise NoDiskSpaceError, "Could not find a valid partitioning distribution" if dist.nil?
-        part_creator = Proposal::PartitionCreator.new(original_graph)
+        part_creator = Proposal::PartitionCreator.new(devicegraph)
         part_creator.create_partitions(dist)
       end
 

test/y2storage/proposal/autoinst_devices_creator_test.rb

@@ -285,18 +285,25 @@
         end
       end
 
-      let(:home) do
-        Y2Storage::Planned::Partition.new("/home", filesystem_type).tap do |part|
-          part.reuse_name = "/dev/sda2"
+      let(:srv) do
+        Y2Storage::Planned::Partition.new("/srv", filesystem_type).tap do |part|
+          part.reuse_name = "/dev/sda3"
           part.resize = true
-          part.size = 52.GiB
+          part.min_size = 5.GiB
+          part.max_size = 5.GiB
         end
       end
 
+      let(:new_part) do
+        planned_partition(
+          mount_point: "/data", filesystem_type: filesystem_type, min_size: 240.GiB, max_size: 240.GiB
+        )
+      end
+
       let(:resize_info) do
         {
           "/dev/sda1" => info_sda1,
-          "/dev/sda2" => info_sda2
+          "/dev/sda3" => info_sda3
         }
       end
 
@@ -307,14 +314,14 @@
         )
       end
 
-      let(:info_sda2) do
+      let(:info_sda3) do
         instance_double(
-          Y2Storage::ResizeInfo, min_size: 1.GiB, max_size: 52.GiB, resize_ok?: true,
+          Y2Storage::ResizeInfo, min_size: 1.GiB, max_size: 248.GiB, resize_ok?: true,
           reasons: 0, reason_texts: []
         )
       end
 
-      let(:partitions) { [home, root] }
+      let(:partitions) { [root, srv, new_part] }
 
       before do
         allow_any_instance_of(Y2Storage::Partition).to receive(:detect_resize_info) do |part|
@@ -329,8 +336,16 @@
         root = devicegraph.partitions.find { |p| p.filesystem_mountpoint == "/" }
         expect(root.size).to eq(200.GiB)
 
-        home = devicegraph.partitions.find { |p| p.filesystem_mountpoint == "/home" }
-        expect(home.size).to eq(52.GiB)
+        srv = devicegraph.partitions.find { |p| p.filesystem_mountpoint == "/srv" }
+        expect(srv.size).to eq(5.GiB)
+      end
+
+      it "reuses the space for new partitions" do
+        result = creator.populated_devicegraph(planned_devices, "/dev/sda")
+        devicegraph = result.devicegraph
+
+        data = devicegraph.partitions.find { |p| p.filesystem_mountpoint == "/data" }
+        expect(data.size).to eq(240.GiB)
       end
     end