Storage
disk <Disk[]>
md <MD[]>
lvm <VolumeGroup[]>
bcache <BCache[]>
nfs <NFS[]>
multidevice_btrfs <MultideviceBtrfs[]>
Disk
name <string>
wipe [<boolean=false>]
encryption [<Encryption>]
filesystem [<Filesystem>]
mount_point [<MountPoint>]
partition_table [<PartitionTable>]
Encryption
method <string>
key [<string>]
pdkdf [<string>]
label [<string>]
cipher [<string>]
key_size [<number>]
Filesystem
type <string>
label [<string>]
mkfs_options [<string[]>]
mount_by [<string>]
btrfs [<Btrfs>]
Btrfs
subvolume_prefix <string>
subvolumes <Subvolume[]>
snapshots <boolean>
quotas <boolean>
MountPoint
path <string>
mount_options [<string[]>]
PartitionTable
type <string>
partitions [<Partition[]>]
Partition
alias [<string>]
uuid [<string>]
partition_number [<string>]
id [<string>]
type [<string>]
size [<number>]
filesystem [<Filesystem>]
mount_point [<MountPoint>]
VolumeGroup
name [<string>]
pesize [<number>]
physical_volumes [<string[]>]
logical_volumes [<LogicalVolume[]>]
LogicalVolume
name [<string>]
size [<number>]
pool [<boolean>]
used_pool [<string>]
stripes [<number>]
strip_size [<number>]
filesystem [<Filesystem>]
mount_point [<MountPoint>]
MD
name <string>
level [<string>]
chunk_size [<number>]
devices [<string[]>]
wipe [<boolean=false>]
encryption [<Encryption>]
filesystem [<Filesystem>]
mount_point [<MountPoint>]
partition_table [<PartitionTable>]
MultideviceBtrfs
uuid [<string>]
data_raid_level <string>
metadata_raid_level <string>
devices <string[]>
btrfs: [<Btrfs>]
-
Partition table
- create
- reuse if conditions (e.g., type matches) or create
- reuse if any or create
- create from scratch
- reuse
-
Filesystem
- create
- reuse if conditions (e.g., type matches) or create
storage: {
drive: [
{
conditions: {
all: [{ fact: 'size_gib', value: 5, operator: 'bigger_or_equal' }]
},
format: {
type: xfs
},
mount: {
path: '/home',
options: []
},
encrypt: {},
partition_table: {
conditions: {
any: [{ self: null }, { type: 'gpt' }]
},
type: 'msdos',
...
partitions: [
delete: [
],
reuse: [
],
create: [
],
{
conditions: {
name: '/dev/vda1'
},
format: {
filesystem: xfs
}
},
{
create: {
size: 10GiB
},
format: {
type: xfs
}
}
]
}
}
]
}
storage: {
disk: [
{
device: {
name: /dev/vda,
uuid: 244445555
},
wipe: true
}
]
}
// This can belong to agama library.
findDisks() =
agama.selectClass(agama.lshw, 'disk'),
// This can belong to agama library.
findDevices(fn, devices) =
local result = std.filter(fn, devices);
// This can belong to agama library.
findDevice(fn, devices) =
local result = findDevices(fn, devices);
if std.length(result) > 0 then
result[0]
else
error 'No device found',
// This can belong to agama library.
local used_devices = [];
// This can belong to agama library.
findUnusedDevice(fn, devices) =
local isUnused_(device) =
!std.contains(used_devices, device["name"])
local unused = findDevices(isUnused_, findDevices(fn, devices));
if std.length(unused) > 0 then
local name = unused[0]["name"];
used_devices = used_devices + [name];
name
else
error 'No unused device found',
findRootDisk() =
local isSuitable_(device) =
device.size_gib > 5,
findUnusedDisks(isSuitable_),
storage: {
disk: [
{
device: {
name: findRootDisk()
},
wipe: true
}
]
}
storage: {
disk: [
{
device: {
name: select_devices([
{ key: size_gib, value: 5, matcher: "bigger_or_equal" }
])
},
filesystem: {
type: xfs
}
},
{
device: {
name: /dev/vda
},
partition_table: {
delete: [
{
device: {
name: select_partitions([
{ key: filesystem_label, value: DELETEME, matcher: "equal" }
])
}
}
],
partitions: [
{
device: {
name: select_partition(
{ key: name, value: /dev/vda1, matcher: equal }
)
},
filesystem: {
type: xfs
}
},
{
size: 10GiB,
fileystem: {
type: xfs
}
}
]
}
}
]
}
storage: {
disk: [
{
name: /dev/vda,
wipe: true,
partition_table: {
type: gpt,
partitions: [
{
size: 15GiB,
filesystem:
type: btrfs
btrfs:
subvolume_prefix: @,
snapshots: true
mount_point:
path: /
},
{
size: 50 GiB,
filesystem:
type: xfs
mount_point:
path: /home
}
]
}
}
]
}
storage: {
disk: [
{
name: /dev/vda,
partition_table: {
partitions: [
{
uuid: 2344234r44,
filesystem: {
type: btrfs
}
btrfs: {
subvolume_prefix: @,
snapshots: true
},
mount_point: {
path: /
}
},
{
size: 50 GiB,
filesystem: {
type: xfs
},
mount_point: {
path: /home
}
}
]
}
}
]
}
storage: {
disk: [
{
name: /dev/vda,
partition_table: {
partitions: [
{
uuid: 2344234r44,
size: 10GiB,
filesystem: {
type: ext4
},
mount_point: {
path: /
}
}
]
}
}
]
}
storage: {
disk: [
{
name: /dev/vda,
partition_table: {
partitions: [
{
uuid: 2344234r44,
mount_point: {
path: /home
}
}
]
}
}
]
}
storage: {
disk: [
{
name: /dev/vda,
partition_table: {
partitions: [
{
size: 10GiB,
encryption: {
method: luks2,
key: secret
}
mount_point: {
path: /home
}
}
]
}
}
]
}
storage: {
disk: [
{
name: /dev/vda,
filesystem: {
type: ext4
},
mount_point: {
path: /data
}
}
]
}
storage: {
disk: [
{
name: /dev/vda,
partition_table: {
type: gpt,
partitions: [
{
alias: vda-part1,
size: 10GiB
},
{
alias: vda-part2,
uuid: 22323434343
}
]
}
},
{
name: /dev/vdb,
partition_table: {
type: gpt,
partitions: [
{
alias: vdb-part1,
size: 10GiB
}
]
}
}
],
lvm: [
{
name: vg0,
physical_volumes: [vda-part1, vda-part2, vdb-part1],
logical_volumes: [
{
size: 5GiB,
filesystem: {
type: ext4
},
mount_point: {
path: /home
}
}
]
}
]
}
storage: {
disk: [
{
name: /dev/vda,
partition_table: {
type: gpt,
partitions: [
{
alias: vda-part1,
size: 10GiB
}
]
}
},
{
name: /dev/vdb,
partition_table: {
type: gpt,
partitions: [
{
alias: vdb-part1,
size: 10GiB
}
]
}
}
],
md: [
{
name: md1,
devices: [vda-part1, vdb-part1]
}
]
}
storage: {
md: [
{
name: md1,
filesystem: {
type: ext4
}
}
]
}
storage: {
disk: [
{
name: /dev/vda,
partition_table: {
type: gpt,
partitions: [
{
alias: vda-part1,
size: 10GiB
}
]
}
},
{
name: /dev/vdb,
partition_table: {
type: gpt,
partitions: [
{
alias: vdb-part1,
size: 10GiB
}
]
}
}
],
multidevice_btrfs: [
{
data_raid_level: raid0,
metadata_raid_level: raid0,
devices: [vda-part1, vdb-part1]
}
]
}
storage: {
disk: [
{
device: {
name: /dev/vda,
uuid: 244445555
},
wipe: true
}
]
}
storage: {
disk: [
{
device: {
name: select_device([
{ key: size_gib, value: 10, condition: greatest_or_equal }
])
},
wipe: true
}
]
}
storage: {
disk: [
{
device: {
name: select_devices([
{ key: size_gib, value: 5, condition: equal },
{ key: name, value: /dev/vdb, condition: not_equal }
])
},
filesystem: {
type: xfs
}
}
]
}
storage: {
disk: [
{
device: {
name: /dev/vda
},
partition_table: {
delete: [
{
device: {
name: select_partitions([
{ key: name, value: /dev/vda\d+, condition: match },
{ key: filesystem_label, value: DELETEME }
])
}
}
],
partitions: [
{
device: {
name: select_partitions([
{ key: name, value: /dev/vda\d+, condition: match },
{ key: filesystem_label, value: DELETEME }
])
},
delete: true
}
]
}
}
]
}
storage: {
disk: [
{
device: {
name: /dev/vda
},
partition_table: {
delete: [
{
device: {
name: select_partitions([
{ key: name, value: /dev/vda\d+, condition: match },
{ key: filesystem_label, value: DELETEME }
])
}
}
],
partitions: [
{
device: {
name: select_partition([
{ key: name, value: /dev/vda1 }
])
},
filesystem: {
type: xfs
}
},
{
size: 10GiB,
fileystem: {
type: xfs
}
}
]
}
}
]
}
storage: {
disk: [
{
device: {
name: /dev/vda
}
partition_table: {
partitions: [
{
device: {
uuid: 2344234r44
},
size: 10GiB
}
]
}
}
]
}
storage: {
disk: [
{
device: {
name: /dev/vda
}
partition_table: {
partitions: [
{
device: {
name: /dev/vda1
},
filesystem: {
type: xfs
},
mount_point: {
path: /home
}
}
]
}
}
]
}
storage: {
disk: [
{
partition_table: {
partitions: [
{
size: 10GiB,
encryption: {
method: luks2,
key: secret
}
filesystem: {
type: btrfs
}
}
]
}
}
]
}
storage: {
disk: [
{
device: {
name: /dev/vda
},
filesystem: {
type: ext4
},
mount_point: {
path: /data
}
}
]
}
storage: {
disk: [
{
device: {
name: /dev/vda,
},
partition_table: {
type: gpt,
partitions: [
{
alias: vda-part1,
size: 10GiB
},
{
alias: vda-part2,
device: {
uuid: 22323434343
}
}
]
}
},
{
device: {
name: /dev/vdb,
},
partition_table: {
type: gpt,
partitions: [
{
alias: vdb-part1,
size: 10GiB
}
]
}
}
],
lvm: [
{
name: vg0,
physical_volumes: [vda_part1, vda-part2, vdb-part1],
logical_volumes: [
{
size: 5GiB,
filesystem: {
type: ext4
},
mount_point: {
path: /home
}
}
]
}
]
}
storage: {
disk: [
{
device: {
name: /dev/vda
},
partition_table: {
type: gpt,
partitions: [
{
alias: vda-part1,
size: 10GiB
}
]
}
},
{
device: {
name: /dev/vdb
},
wipe: true
}
],
md: [
{
name: md1,
devices: [vda-part1, /dev/vdb]
}
]
}
storage: {
md: [
{
device: {
name: md1
},
filesystem: {
type: ext4
}
}
]
}
storage: {
disk: [
{
device: {
name: /dev/vda
},
wipe: true,
partition_table: {
type: gpt,
partitions: [
{
alias: vda-part1,
size: 10GiB
}
]
}
},
{
device: {
name: /dev/vdb
}
wipe: true,
partition_table: {
type: gpt,
partitions: [
{
alias: vdb-part1,
size: 10GiB
}
]
}
}
],
multidevice_btrfs: [
{
data_raid_level: raid0,
metadata_raid_level: raid0,
devices: [vda-part1, vdb-part1]
}
]
}
https://doc.opensuse.org/projects/autoyast/#rules
AutoYaST offers rules to configure a system depending on the system attributes. If a rule passes, then a specific profile file is selected. As result, a result profile is generated as combination of all the profiles selected with the rules.
- Several rules can be indicated.
- Once a rule passes:
- The rest of rules are skipped by default.
- Allows to indicate whether it should continue checking the rest of rules.
- A rule can check one or more system attributes.
- Custom attributes can be defined.
- A custom property could use the output of a script.
- By default all attributes have to match, but it can be switch to 'or'.
Rule
attributeA
attributeB
custom1
script
custom2
operator: or
result
profile
continue
- Predefine attributes:
disksize
,totaldisk
,memsize
, etc. - Match types:
exact
,greater
,lower
,range
,regex
AttributeName
match
match_type
Pre-defined rules
NameRule
name <string>
operator <Operator>
SizeRule
size <string|number>
operator <Operator>
FilesystemRule
filesystem <string>
operator <Operator>
storage: {
drives: [
{
conditions: {
all: [{ size: '10GiB', operator: 'greater' }, { filesystem: 'xfs'}],
max: 1
},
mount: { path: '/home' }
}
]
}
Custom rules
TODO