storage: add size solver

- New config solver for sizes (current, defaults, etc).
- Move logic related to fallback sizes to ConfigBuilder.

service/lib/agama/storage/config.rb

@@ -19,7 +19,8 @@
 # To contact SUSE LLC about this file by physical or electronic mail, you may
 # find current contact information at www.suse.com.
 
-require "agama/storage/configs"
+require "agama/storage/configs/boot"
+require "agama/storage/config_conversions/from_json"
 
 module Agama
  module Storage
@@ -92,24 +93,6 @@ def implicit_boot_device
  root_drive&.found_device&.name
  end
 
- # Sets min and max sizes for all partitions and logical volumes with default size
- #
- # @param volume_builder [VolumeTemplatesBuilder] used to check the configuration of the
- # product volume templates
- def calculate_default_sizes(volume_builder)
- default_size_devices.each do |dev|
- dev.size.min = default_size(dev, :min, volume_builder)
- dev.size.max = default_size(dev, :max, volume_builder)
- end
- end
-
- private
-
- # return [Array<Configs::Filesystem>]
- def filesystems
- (drives + partitions + logical_volumes).map(&:filesystem).compact
- end
-
  # return [Array<Configs::Partition>]
  def partitions
  drives.flat_map(&:partitions)
@@ -119,83 +102,6 @@ def partitions
  def logical_volumes
  volume_groups.flat_map(&:logical_volumes)
  end
-
- # return [Array<Configs::Partition, Configs::LogicalVolume>]
- def default_size_devices
- (partitions + logical_volumes).select { |p| p.size&.default? }
- end
-
- # Min or max size that should be used for the given partition or logical volume
- #
- # @param device [Configs::Partition] device configured to have a default size
- # @param attr [Symbol] :min or :max
- # @param builder [VolumeTemplatesBuilder] see {#calculate_default_sizes}
- def default_size(device, attr, builder)
- path = device.filesystem&.path || ""
- vol = builder.for(path)
- return fallback_size(attr) unless vol
-
- # Theoretically, neither Volume#min_size or Volume#max_size can be nil
- # At most they will be zero or unlimited, respectively
- return vol.send(:"#{attr}_size") unless vol.auto_size?
-
- outline = vol.outline
- size = size_with_fallbacks(outline, attr, builder)
- size = size_with_ram(size, outline)
- size_with_snapshots(size, device, outline)
- end
-
- # TODO: these are the fallbacks used when constructing volumes, not sure if repeating them
- # here is right
- def fallback_size(attr)
- return Y2Storage::DiskSize.zero if attr == :min
-
- Y2Storage::DiskSize.unlimited
- end
-
- # @see #default_size
- def size_with_fallbacks(outline, attr, builder)
- fallback_paths = outline.send(:"#{attr}_size_fallback_for")
- missing_paths = fallback_paths.reject { |p| proposed_path?(p) }
-
- size = outline.send(:"base_#{attr}_size")
- missing_paths.inject(size) { |total, p| total + builder.for(p).send(:"#{attr}_size") }
- end
-
- # @see #default_size
- def size_with_ram(initial_size, outline)
- return initial_size unless outline.adjust_by_ram?
-
- [initial_size, ram_size].max
- end
-
- # @see #default_size
- def size_with_snapshots(initial_size, device, outline)
- return initial_size unless device.filesystem.btrfs_snapshots?
- return initial_size unless outline.snapshots_affect_sizes?
-
- if outline.snapshots_size && outline.snapshots_size > DiskSize.zero
- initial_size + outline.snapshots_size
- else
- multiplicator = 1.0 + (outline.snapshots_percentage / 100.0)
- initial_size * multiplicator
- end
- end
-
- # Whether there is a separate filesystem configured for the given path
- #
- # @param path [String, Pathname]
- # @return [Boolean]
- def proposed_path?(path)
- filesystems.any? { |fs| fs.path?(path) }
- end
-
- # Return the total amount of RAM as DiskSize
- #
- # @return [DiskSize] current RAM size
- def ram_size
- @ram_size ||= Y2Storage::DiskSize.new(Y2Storage::StorageManager.instance.arch.ram_size)
- end
  end
  end
 end

service/lib/agama/storage/config_builder.rb

@@ -22,6 +22,9 @@
 require "agama/storage/configs"
 require "agama/storage/proposal_settings_reader"
 require "agama/storage/volume_templates_builder"
+require "pathname"
+require "y2storage/disk_size"
+require "y2storage/storage_manager"
 
 module Agama
  module Storage
@@ -55,6 +58,23 @@ def default_filesystem(path = nil)
  end
  end
 
+ # Default size config from the product definition.
+ #
+ # @param path [String, nil]
+ # @return [Configs::Size]
+ def default_size(path = nil, having_paths: [], with_snapshots: true)
+ volume = volume_builder.for(path || "")
+
+ return unlimited_size unless volume
+
+ return auto_size(volume.outline, having_paths, with_snapshots) if volume.auto_size?
+
+ Configs::Size.new.tap do |config|
+ config.min = volume.min_size
+ config.max = volume.max_size
+ end
+ end
+
  private
 
  # @return [Agama::Config]
@@ -73,6 +93,88 @@ def default_fstype(path = nil)
  end
  end
 
+ # @return [Configs::Size]
+ def unlimited_size
+ Configs::Size.new.tap do |config|
+ config.min = Y2Storage::DiskSize.zero
+ config.max = Y2Storage::DiskSize.unlimited
+ end
+ end
+
+ # @see #default_size
+ #
+ # @param outline [VolumeOutline]
+ # @param paths [Array<String>]
+ # @param snapshots [Boolean]
+ #
+ # @return [Configs::Size]
+ def auto_size(outline, paths, snapshots)
+ min_fallbacks = remove_paths(outline.min_size_fallback_for, paths)
+ min_size_fallbacks = min_fallbacks.map { |p| volume_builder.for(p).min_size }
+ min = min_size_fallbacks.reduce(outline.base_min_size, &:+)
+
+ max_fallbacks = remove_paths(outline.max_size_fallback_for, paths)
+ max_size_fallbacks = max_fallbacks.map { |p| volume_builder.for(p).max_size }
+ max = max_size_fallbacks.reduce(outline.base_max_size, &:+)
+
+ if outline.adjust_by_ram?
+ min = size_with_ram(min)
+ max = size_with_ram(max)
+ end
+
+ if snapshots
+ min = size_with_snapshots(min, outline)
+ max = size_with_snapshots(max, outline)
+ end
+
+ Configs::Size.new.tap do |config|
+ config.min = min
+ config.max = max
+ end
+ end
+
+ # @see #default_size
+ #
+ # @param size [Y2Storage::DiskSize]
+ # @return [Y2Storage::DiskSize]
+ def size_with_ram(size)
+ [size, ram_size].max
+ end
+
+ # @see #default_size
+ #
+ # @param size [Y2Storage::DiskSize]
+ # @param outline [VolumeOutline]
+ #
+ # @return [Y2Storage::DiskSize]
+ def size_with_snapshots(size, outline)
+ return size unless outline.snapshots_affect_sizes?
+
+ if outline.snapshots_size && outline.snapshots_size > Y2Storage::DiskSize.zero
+ size + outline.snapshots_size
+ else
+ multiplicator = 1.0 + (outline.snapshots_percentage / 100.0)
+ size * multiplicator
+ end
+ end
+
+ # @param paths [Array<String>]
+ # @param paths_to_remove [Array<String>]
+ #
+ # @return [Array<String>]
+ def remove_paths(paths, paths_to_remove)
+ paths.reject do |path|
+ paths_to_remove.any? { |p| Pathname.new(p).cleanpath == Pathname.new(path).cleanpath }
+ end
+ end
+
+ # Total amount of RAM.
+ #
+ # @return [DiskSize]
+ def ram_size
+ @ram_size ||= Y2Storage::DiskSize.new(Y2Storage::StorageManager.instance.arch.ram_size)
+ end
+
  # @return [ProposalSettings]
  def settings
  @settings ||= ProposalSettingsReader.new(product_config).read

service/lib/agama/storage/config_conversions/from_json.rb

@@ -19,34 +19,31 @@
 # To contact SUSE LLC about this file by physical or electronic mail, you may
 # find current contact information at www.suse.com.
 
+require "agama/config"
 require "agama/storage/config_builder"
 require "agama/storage/config_conversions/from_json_conversions/config"
-require "agama/storage/volume_templates_builder"
 
 module Agama
  module Storage
  module ConfigConversions
  # Config conversion from JSON hash according to schema.
  class FromJSON
  # @param config_json [Hash]
- # @param product_config [Agama::Config]
- def initialize(config_json, product_config:)
+ # @param product_config [Agama::Config, nil]
+ def initialize(config_json, product_config: nil)
  # TODO: Replace product_config param by a ProductDefinition.
  @config_json = config_json
- @product_config = product_config
+ @product_config = product_config || Agama::Config.new
  end
 
  # Performs the conversion from Hash according to the JSON schema.
  #
  # @return [Storage::Config]
  def convert
  # TODO: Raise error if config_json does not match the JSON schema.
- config = FromJSONConversions::Config
+ FromJSONConversions::Config
  .new(config_json, config_builder: config_builder)
  .convert
-
- config.calculate_default_sizes(volume_builder)
- config
  end
 
  private
@@ -61,11 +58,6 @@ def convert
  def config_builder
  @config_builder ||= ConfigBuilder.new(product_config)
  end
-
- # @return [VolumeTemplatesBuilder]
- def volume_builder
- @volume_builder ||= VolumeTemplatesBuilder.new_from_config(product_config)
- end
  end
  end
  end