495 lines
14 KiB
Ruby
495 lines
14 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
# Copyright (c) [2024-2025] SUSE LLC
|
|
#
|
|
# All Rights Reserved.
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify it
|
|
# under the terms of version 2 of the GNU General Public License as published
|
|
# by the Free Software Foundation.
|
|
#
|
|
# This program is distributed in the hope that it will be useful, but WITHOUT
|
|
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
# more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License along
|
|
# with this program; if not, contact SUSE LLC.
|
|
#
|
|
# To contact SUSE LLC about this file by physical or electronic mail, you may
|
|
# find current contact information at www.suse.com.
|
|
|
|
require_relative "../agama/storage/storage_helpers"
|
|
require "agama/config"
|
|
require "agama/storage/config"
|
|
require "agama/storage/config_conversions/from_json"
|
|
require "agama/storage/system"
|
|
require "y2storage"
|
|
require "y2storage/agama_proposal"
|
|
|
|
describe Y2Storage::AgamaProposal do
|
|
using Y2Storage::Refinements::SizeCasts
|
|
include Agama::RSpec::StorageHelpers
|
|
|
|
subject(:proposal) do
|
|
described_class.new(config, storage_system, issues_list: issues_list)
|
|
end
|
|
|
|
let(:storage_system) { Agama::Storage::System.new }
|
|
|
|
let(:config) { config_from_json }
|
|
|
|
let(:config_from_json) do
|
|
Agama::Storage::ConfigConversions::FromJSON
|
|
.new(config_json)
|
|
.convert
|
|
end
|
|
|
|
let(:issues_list) { [] }
|
|
|
|
before do
|
|
mock_storage(devicegraph: scenario)
|
|
# To speed-up the tests
|
|
allow(Y2Storage::EncryptionMethod::TPM_FDE).to receive(:possible?).and_return(true)
|
|
end
|
|
|
|
let(:scenario) { "empty-hd-50GiB.yaml" }
|
|
|
|
describe "#propose" do
|
|
context "when the config has LVM volume groups" do
|
|
let(:scenario) { "empty-hd-50GiB.yaml" }
|
|
|
|
let(:config_json) do
|
|
{
|
|
drives: [
|
|
{
|
|
partitions: [
|
|
{
|
|
alias: "system-pv",
|
|
size: "40 GiB"
|
|
},
|
|
{
|
|
alias: "vg1-pv",
|
|
size: "5 GiB"
|
|
}
|
|
]
|
|
}
|
|
],
|
|
volumeGroups: [
|
|
{
|
|
name: "system",
|
|
extentSize: "2 MiB",
|
|
physicalVolumes: ["system-pv"],
|
|
logicalVolumes: [
|
|
{
|
|
name: "root",
|
|
size: "10 GiB",
|
|
filesystem: {
|
|
path: "/",
|
|
type: "btrfs"
|
|
},
|
|
encryption: {
|
|
luks2: { password: "12345" }
|
|
}
|
|
},
|
|
{
|
|
alias: "system-pool",
|
|
name: "pool",
|
|
pool: true,
|
|
size: "20 GiB",
|
|
stripes: 10,
|
|
stripeSize: "4 KiB"
|
|
},
|
|
{
|
|
name: "data",
|
|
size: "50 GiB",
|
|
usedPool: "system-pool",
|
|
filesystem: { type: "xfs" }
|
|
}
|
|
]
|
|
},
|
|
{
|
|
name: "vg1",
|
|
physicalVolumes: ["vg1-pv"],
|
|
logicalVolumes: [
|
|
{
|
|
name: "home",
|
|
filesystem: {
|
|
path: "/home",
|
|
type: "xfs"
|
|
},
|
|
size: "2 GiB"
|
|
}
|
|
]
|
|
}
|
|
]
|
|
}
|
|
end
|
|
|
|
it "proposes the expected devices" do
|
|
devicegraph = proposal.propose
|
|
|
|
expect(devicegraph.lvm_vgs).to contain_exactly(
|
|
an_object_having_attributes(
|
|
vg_name: "system",
|
|
extent_size: 2.MiB
|
|
),
|
|
an_object_having_attributes(
|
|
vg_name: "vg1",
|
|
extent_size: 4.MiB
|
|
)
|
|
)
|
|
|
|
system_vg = devicegraph.find_by_name("/dev/system")
|
|
system_pvs = system_vg.lvm_pvs.map(&:plain_blk_device)
|
|
system_lvs = system_vg.lvm_lvs
|
|
|
|
expect(system_pvs).to contain_exactly(
|
|
an_object_having_attributes(name: "/dev/sda2", size: 40.GiB)
|
|
)
|
|
expect(system_lvs).to contain_exactly(
|
|
an_object_having_attributes(
|
|
lv_name: "root",
|
|
lv_type: Y2Storage::LvType::NORMAL,
|
|
size: 10.GiB,
|
|
filesystem: an_object_having_attributes(
|
|
type: Y2Storage::Filesystems::Type::BTRFS,
|
|
mount_path: "/"
|
|
),
|
|
encryption: an_object_having_attributes(
|
|
type: Y2Storage::EncryptionType::LUKS2,
|
|
password: "12345"
|
|
)
|
|
),
|
|
an_object_having_attributes(
|
|
lv_name: "pool",
|
|
lv_type: Y2Storage::LvType::THIN_POOL,
|
|
size: 20.GiB,
|
|
filesystem: be_nil,
|
|
encryption: be_nil,
|
|
stripes: 10,
|
|
stripe_size: 4.KiB,
|
|
lvm_lvs: contain_exactly(
|
|
an_object_having_attributes(
|
|
lv_name: "data",
|
|
lv_type: Y2Storage::LvType::THIN,
|
|
size: 50.GiB,
|
|
filesystem: an_object_having_attributes(
|
|
type: Y2Storage::Filesystems::Type::XFS
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
vg1 = devicegraph.find_by_name("/dev/vg1")
|
|
vg1_pvs = vg1.lvm_pvs.map(&:plain_blk_device)
|
|
vg1_lvs = vg1.lvm_lvs
|
|
expect(vg1_pvs).to contain_exactly(
|
|
an_object_having_attributes(name: "/dev/sda3", size: 5.GiB)
|
|
)
|
|
expect(vg1_lvs).to contain_exactly(
|
|
an_object_having_attributes(
|
|
lv_name: "home",
|
|
lv_type: Y2Storage::LvType::NORMAL,
|
|
size: 2.GiB,
|
|
filesystem: an_object_having_attributes(
|
|
type: Y2Storage::Filesystems::Type::XFS,
|
|
mount_path: "/home"
|
|
)
|
|
)
|
|
)
|
|
end
|
|
end
|
|
|
|
context "when a LVM physical volume is not found" do
|
|
let(:config_json) do
|
|
{
|
|
drives: [
|
|
{
|
|
partitions: [
|
|
{
|
|
size: "40 GiB"
|
|
},
|
|
{
|
|
alias: "pv1",
|
|
size: "5 GiB"
|
|
}
|
|
]
|
|
}
|
|
],
|
|
volumeGroups: [
|
|
{
|
|
name: "system",
|
|
extentSize: "2 MiB",
|
|
physicalVolumes: ["pv1", "pv2"],
|
|
logicalVolumes: [
|
|
{
|
|
name: "root",
|
|
filesystem: {
|
|
path: "/"
|
|
}
|
|
}
|
|
]
|
|
}
|
|
]
|
|
}
|
|
end
|
|
|
|
it "aborts the proposal process" do
|
|
proposal.propose
|
|
expect(proposal.failed?).to eq true
|
|
end
|
|
|
|
it "reports the corresponding error" do
|
|
proposal.propose
|
|
expect(proposal.issues_list).to include an_object_having_attributes(
|
|
description: /no LVM physical volume with alias 'pv2'/,
|
|
severity: Agama::Issue::Severity::ERROR
|
|
)
|
|
end
|
|
end
|
|
|
|
context "when a LVM thin pool volume is not found" do
|
|
let(:config_json) do
|
|
{
|
|
drives: [
|
|
{
|
|
partitions: [
|
|
{
|
|
size: "40 GiB"
|
|
},
|
|
{
|
|
alias: "pv1",
|
|
size: "5 GiB"
|
|
}
|
|
]
|
|
}
|
|
],
|
|
volumeGroups: [
|
|
{
|
|
name: "system",
|
|
extentSize: "2 MiB",
|
|
physicalVolumes: ["pv1"],
|
|
logicalVolumes: [
|
|
{
|
|
pool: true
|
|
},
|
|
{
|
|
name: "root",
|
|
filesystem: {
|
|
path: "/"
|
|
},
|
|
usedPool: "pool"
|
|
}
|
|
]
|
|
}
|
|
]
|
|
}
|
|
end
|
|
|
|
it "aborts the proposal process" do
|
|
proposal.propose
|
|
expect(proposal.failed?).to eq true
|
|
end
|
|
|
|
it "reports the corresponding error" do
|
|
proposal.propose
|
|
expect(proposal.issues_list).to include an_object_having_attributes(
|
|
description: /no LVM thin pool volume with alias 'pool'/,
|
|
severity: Agama::Issue::Severity::ERROR
|
|
)
|
|
end
|
|
end
|
|
|
|
context "when the config has LVM volume groups with generated physical volumes" do
|
|
let(:scenario) { "disks.yaml" }
|
|
|
|
let(:config_json) do
|
|
{
|
|
drives: [
|
|
{
|
|
alias: "vda",
|
|
partitions: [
|
|
{
|
|
search: "/dev/vda2",
|
|
size: { min: "0", max: "current" }
|
|
},
|
|
{
|
|
size: { min: "4 GiB" },
|
|
filesystem: { path: "/foo" }
|
|
}
|
|
]
|
|
},
|
|
{
|
|
alias: "vdb"
|
|
}
|
|
],
|
|
volumeGroups: [
|
|
{
|
|
name: "system",
|
|
physicalVolumes: [
|
|
{ generate: { targetDevices: ["vda"] } }
|
|
],
|
|
logicalVolumes: [
|
|
{
|
|
name: "root",
|
|
size: "10 GiB",
|
|
filesystem: {
|
|
path: "/",
|
|
type: "btrfs"
|
|
}
|
|
},
|
|
{
|
|
name: "data",
|
|
size: "10 GiB",
|
|
filesystem: { type: "xfs" }
|
|
}
|
|
]
|
|
},
|
|
{
|
|
name: "vg1",
|
|
physicalVolumes: [
|
|
{
|
|
generate: {
|
|
targetDevices: ["vdb"],
|
|
encryption: { luks2: { password: "s3cr3t" } }
|
|
}
|
|
}
|
|
],
|
|
logicalVolumes: [
|
|
{
|
|
name: "home",
|
|
filesystem: {
|
|
path: "/home",
|
|
type: "xfs"
|
|
},
|
|
size: "20 GiB"
|
|
}
|
|
]
|
|
}
|
|
]
|
|
}
|
|
end
|
|
|
|
before do
|
|
allow_any_instance_of(Y2Storage::Partition)
|
|
.to(receive(:detect_resize_info))
|
|
.and_return(resize_info)
|
|
end
|
|
|
|
let(:resize_info) do
|
|
instance_double(
|
|
Y2Storage::ResizeInfo, resize_ok?: true,
|
|
min_size: Y2Storage::DiskSize::GiB(3), max_size: Y2Storage::DiskSize::GiB(35)
|
|
)
|
|
end
|
|
|
|
it "proposes the expected devices" do
|
|
devicegraph = proposal.propose
|
|
|
|
resized = devicegraph.find_by_name("/dev/vda2")
|
|
expect(resized.filesystem.label).to eq("previous_root")
|
|
expect(resized.size).to be > 15.GiB
|
|
expect(resized.size).to be < 16.GiB
|
|
|
|
foo = devicegraph.find_by_name("/dev/vda4")
|
|
expect(foo.filesystem.mount_path).to eq("/foo")
|
|
expect(foo.size).to be > 4.GiB
|
|
expect(foo.size).to be < 5.GiB
|
|
|
|
system = devicegraph.find_by_name("/dev/system")
|
|
expect(system.lvm_lvs.size).to eq 2
|
|
expect(Y2Storage::DiskSize.sum(system.lvm_lvs.map(&:size))).to eq 20.GiB
|
|
expect(system.lvm_pvs.size).to eq 2
|
|
|
|
vg1 = devicegraph.find_by_name("/dev/vg1")
|
|
expect(vg1.lvm_lvs.size).to eq 1
|
|
expect(vg1.lvm_lvs.first.size).to eq 20.GiB
|
|
expect(vg1.lvm_pvs.size).to eq 1
|
|
|
|
pv_vg1 = vg1.lvm_pvs.first
|
|
expect(pv_vg1.blk_device.is?(:encryption)).to eq true
|
|
expect(pv_vg1.blk_device.type.is?(:luks2)).to eq true
|
|
end
|
|
end
|
|
|
|
context "when two volume groups with generated physical volumes share a disk" do
|
|
let(:scenario) { "disks.yaml" }
|
|
|
|
let(:config_json) do
|
|
{
|
|
drives: [
|
|
{ alias: "vda" },
|
|
{ alias: "vdb" },
|
|
{ alias: "vdc" }
|
|
],
|
|
volumeGroups: [
|
|
{
|
|
name: "system",
|
|
physicalVolumes: [
|
|
{ generate: { targetDevices: ["vdb", "vdc"] } }
|
|
],
|
|
logicalVolumes: [
|
|
{
|
|
name: "root",
|
|
size: "10 GiB",
|
|
filesystem: {
|
|
path: "/",
|
|
type: "btrfs"
|
|
}
|
|
},
|
|
{
|
|
name: "home",
|
|
size: {
|
|
min: "30 GiB"
|
|
},
|
|
filesystem: {
|
|
path: "/home",
|
|
type: "xfs"
|
|
}
|
|
}
|
|
]
|
|
},
|
|
{
|
|
name: "vg1",
|
|
physicalVolumes: [
|
|
{
|
|
generate: {
|
|
targetDevices: ["vdc"],
|
|
encryption: { luks1: { password: "s3cr3t" } }
|
|
}
|
|
}
|
|
],
|
|
logicalVolumes: [
|
|
{
|
|
name: "data",
|
|
filesystem: { type: "xfs" },
|
|
size: { min: "30 GiB", max: "40 GiB" }
|
|
}
|
|
]
|
|
}
|
|
]
|
|
}
|
|
end
|
|
|
|
it "proposes the expected devices" do
|
|
devicegraph = proposal.propose
|
|
|
|
system = devicegraph.find_by_name("/dev/system")
|
|
expect(system.lvm_lvs.map { |lv| lv.mount_point.path }).to contain_exactly("/", "/home")
|
|
expect(system.lvm_pvs.map { |pv| pv.blk_device.partitionable.name })
|
|
.to contain_exactly("/dev/vdb", "/dev/vdc")
|
|
|
|
vg1 = devicegraph.find_by_name("/dev/vg1")
|
|
expect(vg1.lvm_lvs.map(&:lv_name)).to contain_exactly("data")
|
|
expect(vg1.lvm_pvs.map { |pv| pv.plain_blk_device.partitionable.name })
|
|
.to contain_exactly("/dev/vdc")
|
|
|
|
pv_vg1 = vg1.lvm_pvs.first
|
|
expect(pv_vg1.blk_device.is?(:encryption)).to eq true
|
|
expect(pv_vg1.blk_device.type.is?(:luks1)).to eq true
|
|
end
|
|
end
|
|
end
|
|
end
|