WIP

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

@@ -34,7 +34,7 @@ class FromJSON
         # @param config_json [Hash]
         # @param product_config [Agama::Config, nil]
         def initialize(config_json, product_config: nil)
-          # Copies the JSON object to avoid changes in the given parameter, see {ConfigJSONSolver}.
+          # Copies the JSON hash to avoid changes in the given parameter, see {ConfigJSONSolver}.
           @config_json = json_dup(config_json)
           @product_config = product_config || Agama::Config.new
         end
@@ -46,8 +46,7 @@ def convert
           # TODO: Raise error if config_json does not match the JSON schema.
           #   Implementation idea: ConfigJSONChecker class which reports issues if:
           #   * The JSON does not match the schema.
-          #   * The JSON contains both "default" and "mandatory" for partitions or logical volumes.
-          #   * The JSON contains "default" or "mandatory" more than once.
+          #   * The JSON contains more than one "generate" for partitions and logical volumes.
           #   * The JSON contains invalid aliases (now checked by ConfigChecker).
           ConfigJSONSolver
             .new(product_config)

service/lib/agama/storage/config_json_solver.rb

@@ -69,7 +69,7 @@ def initialize(product_config = nil)
       def solve(config_json)
         @config_json = config_json
 
-        solve_keywords
+        solve_generate
       end
 
     private
@@ -80,52 +80,40 @@ def solve(config_json)
       # @return [Agama::Config]
       attr_reader :product_config
 
-      def solve_keywords
-        drives_with_keyword.each { |c| solve_partitions_keyword(c) }
-        volume_groups_with_keyword.each { |c| solve_logical_volumes_keyword(c) }
-      end
-
-      # @param config [Hash]
-      def solve_partitions_keyword(config)
-        partitions = config[:partitions]
-        return unless partitions
+      def solve_generate
+        configs = configs_with_generate
+        return unless configs.any?
 
-        solve_keyword(partitions)
+        expand_generate(configs.first)
+        configs.each { |c| remove_generate(c) }
       end
 
-      # @param config [Hash]
-      def solve_logical_volumes_keyword(config)
-        logical_volumes = config[:logicalVolumes]
-        return unless logical_volumes
+      def expand_generate(config)
+        configs = volume_configs(config)
+        index = configs.index { |v| with_generate?(v) }
 
-        solve_keyword(logical_volumes)
-      end
+        return unless index
 
-      # @param configs [Array<Hash>]
-      def solve_keyword(configs)
-        if with_default_keyword?(configs)
-          solve_default_keyword(configs)
-        elsif with_mandatory_keyword?(configs)
-          solve_mandatory_keyword(configs)
-        end
+        generate_config = configs[index]
+        configs[index] = volumes_from_generate(generate_config)
+        configs.flatten!
       end
 
-      # @param configs [Array<Hash>]
-      def solve_default_keyword(configs)
-        configs.delete("default")
-        configs.delete("mandatory")
-        configs.concat(missing_default_configs)
+      def remove_generate(config)
+        volume_configs(config).delete_if { |c| with_generate?(c) }
       end
 
-      # @param configs [Array<Hash>]
-      def solve_mandatory_keyword(configs)
-        configs.delete("mandatory")
-        configs.concat(missing_mandatory_configs)
+      def volumes_from_generate(config)
+        if with_generate_default?(config)
+          missing_default_volumes(config)
+        elsif with_generate_mandatory?(config)
+          missing_mandatory_volumes(config)
+        end
       end
 
       # @return [Array<Hash>]
-      def missing_default_configs
-        missing_default_paths.map { |p| volume_config(p) }
+      def missing_default_volumes(config)
+        missing_default_paths.map { |p| volume_from_generate(config, p) }
       end
 
       # @return [Array<String>]
@@ -147,8 +135,8 @@ def current_paths
       end
 
       # @return [Array<Hash>]
-      def missing_mandatory_configs
-        missing_mandatory_paths.map { |p| volume_config(p) }
+      def missing_mandatory_volumes(config)
+        missing_mandatory_paths.map { |p| volume_from_generate(config, p) }
       end
 
       # @return [Array<String>]
@@ -169,54 +157,21 @@ def mandatory_path?(path)
 
       # @param path [String]
       # @return [Hash]
-      def volume_config(path)
-        { filesystem: { path: path } }
-      end
-
-      # @return [Array<Hash>]
-      def drives_with_keyword
-        drive_configs.select { |c| with_partitions_keyword?(c) }
-      end
-
-      # @return [Array<Hash>]
-      def volume_groups_with_keyword
-        volume_group_configs.select { |c| with_logical_volumes_keyword?(c) }
-      end
-
-      # @param config [Hash]
-      # @return [Boolean]
-      def with_partitions_keyword?(config)
-        partitions = config[:partitions]
-        return false unless partitions
-
-        with_keyword?(partitions)
-      end
-
-      # @param config [Hash]
-      # @return [Boolean]
-      def with_logical_volumes_keyword?(config)
-        logical_volumes = config[:logicalVolumes]
-        return false unless logical_volumes
+      def volume_from_generate(config, path)
+        volume = { filesystem: { path: path } }
 
-        with_keyword?(logical_volumes)
-      end
+        return volume unless config[:generate].is_a?(Hash)
 
-      # @param configs [Array<Hash>]
-      # @return [Boolean]
-      def with_keyword?(configs)
-        with_default_keyword?(configs) || with_mandatory_keyword?(configs)
-      end
+        generate = config[:generate]
+        generate.delete(:partitions)
+        generate.delete(:logicalVolumes)
 
-      # @param configs [Array<Hash>]
-      # @return [Boolean]
-      def with_default_keyword?(configs)
-        configs.include?("default")
+        volume.merge(generate)
       end
 
-      # @param configs [Array<Hash>]
-      # @return [Boolean]
-      def with_mandatory_keyword?(configs)
-        configs.include?("mandatory")
+      def configs_with_generate
+        configs = drive_configs + volume_group_configs
+        configs.select { |c| with_volume_generate?(c) }
       end
 
       # @return [Array<Hash>]
@@ -254,6 +209,34 @@ def logical_volume_configs
           .compact
       end
 
+      def volume_configs(config)
+        config[:partitions] || config[:logicalVolumes] || []
+      end
+
+      def with_volume_generate?(config)
+        volume_configs(config).any? { |c| with_generate?(c) }
+      end
+
+      def with_generate?(config)
+        !config[:generate].nil?
+      end
+
+      def with_generate_default?(config)
+        with_generate_value?(config, "default")
+      end
+
+      def with_generate_mandatory?(config)
+        with_generate_value?(config, "mandatory")
+      end
+
+      def with_generate_value?(config, value)
+        generate = config[:generate]
+
+        return generate == value unless generate.is_a?(Hash)
+
+        generate[:partitions] == value || generate[:logicalVolumes] == value
+      end
+
       # @return [VolumeTemplatesBuilder]
       def volume_builder
         @volume_builder ||= VolumeTemplatesBuilder.new_from_config(product_config)