feat(web): UI for adding a partition

doc/dbus/bus/org.opensuse.Agama.Storage1.bus.xml

@@ -61,6 +61,10 @@
     <method name="GetConfigModel">
       <arg name="serialized_model" direction="out" type="s"/>
     </method>
+    <method name="SolveConfigModel">
+      <arg name="model" direction="in" type="s"/>
+      <arg name="solved_model" direction="out" type="s"/>
+    </method>
     <method name="Install">
     </method>
     <method name="Finish">

doc/dbus/org.opensuse.Agama.Storage1.doc.xml

@@ -116,6 +116,53 @@
       -->
       <arg name="serialized_model" direction="out" type="s"/>
     </method>
+    <!--
+      Solves the given storage config model.
+    -->
+    <method name="SolveConfigModel">
+      <!--
+        E.g.,
+        {
+          "drives": [
+            {
+              "name": "/dev/vda",
+              "partitions": [
+                {
+                  "mountPath": "/"
+                }
+              ]
+            }
+          ]
+        }
+      -->
+      <arg name="model" direction="in" type="s"/>
+      <!--
+        E.g.,
+        {
+          "drives": [
+            {
+              "name": "/dev/vda",
+              "spacePolicy": "keep",
+              "partitions": [
+                {
+                  "mountPath": "/",
+                  "filesystem": {
+                    "default": true,
+                    "type": "xfs"
+                  },
+                  "size": {
+                    "default": true,
+                    "min": "10 GiB",
+                    "max": "10 GiB"
+                  }
+                }
+              ]
+            }
+          ]
+        }
+      -->
+      <arg name="solved_model" direction="out" type="s"/>
+    </method>
     <method name="Install">
     </method>
     <method name="Finish">

rust/agama-lib/share/storage.model.schema.json

@@ -80,6 +80,7 @@
       "additionalProperties": false,
       "required": ["default"],
       "properties": {
+        "reuse": { "type": "boolean" },
         "default": { "type": "boolean" },
         "type": { "$ref": "#/$defs/filesystemType" },
         "snapshots": { "type": "boolean" }

rust/agama-lib/src/storage/client.rs

@@ -159,7 +159,7 @@ impl<'a> StorageClient<'a> {
         Ok(settings)
     }
 
-    /// Set the storage config according to the JSON schema
+    /// Set the storage config model according to the JSON schema
     pub async fn set_config_model(&self, model: Box<RawValue>) -> Result<u32, ServiceError> {
         Ok(self
             .storage_proxy
@@ -174,6 +174,13 @@ impl<'a> StorageClient<'a> {
         Ok(config_model)
     }
 
+    /// Solves the storage config model
+    pub async fn solve_config_model(&self, model: &str) -> Result<Box<RawValue>, ServiceError> {
+        let serialized_solved_model = self.storage_proxy.solve_config_model(model).await?;
+        let solved_model = serde_json::from_str(serialized_solved_model.as_str()).unwrap();
+        Ok(solved_model)
+    }
+
     pub async fn calculate(&self, settings: ProposalSettingsPatch) -> Result<u32, ServiceError> {
         let map: HashMap<&str, zbus::zvariant::Value> = settings.into();
         let options: HashMap<&str, &zbus::zvariant::Value> =

rust/agama-lib/src/storage/proxies/storage1.rs

@@ -71,6 +71,9 @@ pub trait Storage1 {
     /// Get the storage config model according to the JSON schema
     fn get_config_model(&self) -> zbus::Result<String>;
 
+    /// Solve a storage config model
+    fn solve_config_model(&self, model: &str) -> zbus::Result<String>;
+
     /// DeprecatedSystem property
     #[zbus(property)]
     fn deprecated_system(&self) -> zbus::Result<bool>;

rust/agama-server/src/software/web.rs

@@ -57,7 +57,7 @@ use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use tokio_stream::{Stream, StreamExt};
 
-use super::license::{License, LicenseContent};
+use super::license::License;
 
 #[derive(Clone)]
 struct SoftwareState<'a> {

rust/agama-server/src/storage/web.rs

@@ -115,6 +115,7 @@ pub async fn storage_service(dbus: zbus::Connection) -> Result<Router, ServiceEr
     let router = Router::new()
         .route("/config", put(set_config).get(get_config))
         .route("/config_model", put(set_config_model).get(get_config_model))
+        .route("/config_model/solve", get(solve_config_model))
         .route("/probe", post(probe))
         .route("/reprobe", post(reprobe))
         .route("/devices/dirty", get(devices_dirty))
@@ -235,6 +236,36 @@ async fn set_config_model(
     Ok(Json(()))
 }
 
+/// Solves a storage config model.
+#[utoipa::path(
+    get,
+    path = "/config_model/solve",
+    context_path = "/api/storage",
+    params(SolveModelQuery),
+    operation_id = "solve_storage_config_model",
+    responses(
+        (status = 200, description = "Solve the storage config model", body = String),
+        (status = 400, description = "The D-Bus service could not perform the action")
+    )
+)]
+async fn solve_config_model(
+    State(state): State<StorageState<'_>>,
+    query: Query<SolveModelQuery>,
+) -> Result<Json<Box<RawValue>>, Error> {
+    let solved_model = state
+        .client
+        .solve_config_model(query.model.as_str())
+        .await
+        .map_err(Error::Service)?;
+    Ok(Json(solved_model))
+}
+
+#[derive(Deserialize, utoipa::IntoParams)]
+struct SolveModelQuery {
+    /// Serialized config model.
+    model: String,
+}
+
 /// Probes the storage devices.
 #[utoipa::path(
     post,

service/lib/agama/dbus/storage/manager.rb

@@ -147,6 +147,18 @@ def recover_model
           JSON.pretty_generate(json)
         end
 
+        # Solves the given serialized config model.
+        #
+        # @param serialized_model [String] Serialized storage config model.
+        # @return [String] Serialized solved model.
+        def solve_model(serialized_model)
+          logger.info("Solving storage config model from D-Bus: #{serialized_model}")
+
+          model_json = JSON.parse(serialized_model, symbolize_names: true)
+          solved_model_json = proposal.solve_model(model_json)
+          JSON.pretty_generate(solved_model_json)
+        end
+
         def install
           busy_while { backend.install }
         end
@@ -173,6 +185,9 @@ def deprecated_system
             busy_while { apply_config_model(serialized_model) }
           end
           dbus_method(:GetConfigModel, "out serialized_model:s") { recover_model }
+          dbus_method(:SolveConfigModel, "in sparse_model:s, out solved_model:s") do |sparse_model|
+            solve_model(sparse_model)
+          end
           dbus_method(:Install) { install }
           dbus_method(:Finish) { finish }
           dbus_reader(:deprecated_system, "b")

service/lib/agama/dbus/storage/volume_conversion/to_dbus.rb

@@ -51,7 +51,7 @@ def convert
               "Target"        => volume.location.target.to_s,
               "TargetDevice"  => volume.location.device.to_s,
               "FsType"        => volume.fs_type&.to_human_string || "",
-              "MinSize"       => volume.min_size&.to_i,
+              "MinSize"       => min_size_conversion,
               "AutoSize"      => volume.auto_size?,
               "Snapshots"     => volume.btrfs.snapshots?,
               "Transactional" => volume.btrfs.read_only?,
@@ -67,11 +67,20 @@ def convert
           # @return [Agama::Storage::Volume]
           attr_reader :volume
 
+          # @return [Integer]
+          def min_size_conversion
+            min_size = volume.min_size
+            min_size = volume.outline.base_min_size if volume.auto_size?
+            min_size.to_i
+          end
+
           # @param target [Hash]
           def max_size_conversion(target)
-            return if volume.max_size.nil? || volume.max_size.unlimited?
+            max_size = volume.max_size
+            max_size = volume.outline.base_max_size if volume.auto_size?
+            return if max_size.unlimited?
 
-            target["MaxSize"] = volume.max_size.to_i
+            target["MaxSize"] = max_size.to_i
           end
 
           # Converts volume outline to D-Bus.

service/lib/agama/storage/config_conversions/from_model_conversions/filesystem.rb

@@ -41,8 +41,9 @@ def default_config
           # @return [Hash]
           def conversions
             {
-              path: model_json[:mountPath],
-              type: convert_type
+              reuse: model_json.dig(:filesystem, :reuse),
+              path:  model_json[:mountPath],
+              type:  convert_type
             }
           end
 

service/lib/agama/storage/config_conversions/from_model_conversions/partition.rb

@@ -55,8 +55,8 @@ def conversions
               filesystem:       convert_filesystem,
               size:             convert_size,
               id:               convert_id,
-              delete:           partition_model[:delete],
-              delete_if_needed: partition_model[:deleteIfNeeded]
+              delete:           convert_delete,
+              delete_if_needed: convert_delete_if_needed
             }
           end
 
@@ -67,6 +67,24 @@ def convert_id
 
             Y2Storage::PartitionId.find(value)
           end
+
+          # TODO: do not delete if the partition is used by other device (VG, RAID, etc).
+          # @return [Boolean]
+          def convert_delete
+            # Do not mark to delete if the partition is used.
+            return false if partition_model[:mountPath]
+
+            partition_model[:delete]
+          end
+
+          # TODO: do not delete if the partition is used by other device (VG, RAID, etc).
+          # @return [Boolean]
+          def convert_delete_if_needed
+            # Do not mark to delete if the partition is used.
+            return false if partition_model[:mountPath]
+
+            partition_model[:deleteIfNeeded]
+          end
         end
       end
     end

service/lib/agama/storage/config_conversions/to_model_conversions/filesystem.rb

@@ -38,6 +38,7 @@ def initialize(config)
           # @see Base#conversions
           def conversions
             {
+              reuse:     config.reuse?,
               default:   convert_default,
               type:      convert_type,
               snapshots: convert_snapshots

service/lib/agama/storage/config_solvers/search.rb

@@ -144,7 +144,9 @@ def filter_by_disk_analyzer(devices)
         # Finds the partitions matching the given search config, if any
         #
         # @param search_config [Agama::Storage::Configs::Search]
-        # @return [Y2Storage::Device, nil]
+        # @param device [#partitions]
+        #
+        # @return [Array<Y2Storage::Partition>]
         def find_partitions(search_config, device)
           candidates = candidate_devices(search_config, default: device.partitions)
           candidates.select! { |d| d.is?(:partition) }
@@ -175,7 +177,7 @@ def find_device(search_config)
         #
         # @param devices [Array<Y2Storage::Device>]
         # @param search [Config::Search]
-        # @return [Y2Storage::Device, nil]
+        # @return [Array<Y2Storage::Device>]
         def next_unassigned_devices(devices, search)
           devices
             .reject { |d| sids.include?(d.sid) }

service/lib/agama/storage/proposal.rb

@@ -22,6 +22,7 @@
 require "agama/issue"
 require "agama/storage/actions_generator"
 require "agama/storage/config_conversions"
+require "agama/storage/config_solver"
 require "agama/storage/proposal_settings"
 require "agama/storage/proposal_strategies"
 require "json"
@@ -100,6 +101,24 @@ def model_json
         ConfigConversions::ToModel.new(config).convert
       end
 
+      # Solves a given model.
+      #
+      # @param model_json [Hash] Config model according to the JSON schema.
+      # @return [Hash, nil] Solved config model or nil if the model cannot be solved yet.
+      def solve_model(model_json)
+        return unless storage_manager.probed?
+
+        config = ConfigConversions::FromModel
+          .new(model_json, product_config: product_config)
+          .convert
+
+        ConfigSolver
+          .new(product_config, storage_manager.probed, disk_analyzer: disk_analyzer)
+          .solve(config)
+
+        ConfigConversions::ToModel.new(config).convert
+      end
+
       # Calculates a new proposal using the given JSON.
       #
       # @raise If the JSON is not valid.