separate packaging and source build system
Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com>
This commit is contained in:
Thomas Lamprecht
409
src/PVE/API2/Disks/Directory.pm
Normal file
409
src/PVE/API2/Disks/Directory.pm
Normal file
@ -0,0 +1,409 @@
|
||||
package PVE::API2::Disks::Directory;
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
|
||||
use POSIX;
|
||||
|
||||
use PVE::Diskmanage;
|
||||
use PVE::JSONSchema qw(get_standard_option);
|
||||
use PVE::RESTHandler;
|
||||
use PVE::RPCEnvironment;
|
||||
use PVE::Systemd;
|
||||
use PVE::Tools qw(run_command trim file_set_contents file_get_contents dir_glob_foreach lock_file);
|
||||
|
||||
use PVE::API2::Storage::Config;
|
||||
|
||||
use base qw(PVE::RESTHandler);
|
||||
|
||||
my $SGDISK = '/sbin/sgdisk';
|
||||
my $MKFS = '/sbin/mkfs';
|
||||
my $BLKID = '/sbin/blkid';
|
||||
|
||||
my $read_ini = sub {
|
||||
my ($filename) = @_;
|
||||
|
||||
my $content = file_get_contents($filename);
|
||||
my @lines = split /\n/, $content;
|
||||
|
||||
my $result = {};
|
||||
my $section;
|
||||
|
||||
foreach my $line (@lines) {
|
||||
$line = trim($line);
|
||||
if ($line =~ m/^\[([^\]]+)\]/) {
|
||||
$section = $1;
|
||||
if (!defined($result->{$section})) {
|
||||
$result->{$section} = {};
|
||||
}
|
||||
} elsif ($line =~ m/^(.*?)=(.*)$/) {
|
||||
my ($key, $val) = ($1, $2);
|
||||
if (!$section) {
|
||||
warn "key value pair found without section, skipping\n";
|
||||
next;
|
||||
}
|
||||
|
||||
if ($result->{$section}->{$key}) {
|
||||
# make duplicate properties to arrays to keep the order
|
||||
my $prop = $result->{$section}->{$key};
|
||||
if (ref($prop) eq 'ARRAY') {
|
||||
push @$prop, $val;
|
||||
} else {
|
||||
$result->{$section}->{$key} = [$prop, $val];
|
||||
}
|
||||
} else {
|
||||
$result->{$section}->{$key} = $val;
|
||||
}
|
||||
}
|
||||
# ignore everything else
|
||||
}
|
||||
|
||||
return $result;
|
||||
};
|
||||
|
||||
my $write_ini = sub {
|
||||
my ($ini, $filename) = @_;
|
||||
|
||||
my $content = "";
|
||||
|
||||
foreach my $sname (sort keys %$ini) {
|
||||
my $section = $ini->{$sname};
|
||||
|
||||
$content .= "[$sname]\n";
|
||||
|
||||
foreach my $pname (sort keys %$section) {
|
||||
my $prop = $section->{$pname};
|
||||
|
||||
if (!ref($prop)) {
|
||||
$content .= "$pname=$prop\n";
|
||||
} elsif (ref($prop) eq 'ARRAY') {
|
||||
foreach my $val (@$prop) {
|
||||
$content .= "$pname=$val\n";
|
||||
}
|
||||
} else {
|
||||
die "invalid property '$pname'\n";
|
||||
}
|
||||
}
|
||||
$content .= "\n";
|
||||
}
|
||||
|
||||
file_set_contents($filename, $content);
|
||||
};
|
||||
|
||||
__PACKAGE__->register_method ({
|
||||
name => 'index',
|
||||
path => '',
|
||||
method => 'GET',
|
||||
proxyto => 'node',
|
||||
protected => 1,
|
||||
permissions => {
|
||||
check => ['perm', '/', ['Sys.Audit', 'Datastore.Audit'], any => 1],
|
||||
},
|
||||
description => "PVE Managed Directory storages.",
|
||||
parameters => {
|
||||
additionalProperties => 0,
|
||||
properties => {
|
||||
node => get_standard_option('pve-node'),
|
||||
},
|
||||
},
|
||||
returns => {
|
||||
type => 'array',
|
||||
items => {
|
||||
type => 'object',
|
||||
properties => {
|
||||
unitfile => {
|
||||
type => 'string',
|
||||
description => 'The path of the mount unit.',
|
||||
},
|
||||
path => {
|
||||
type => 'string',
|
||||
description => 'The mount path.',
|
||||
},
|
||||
device => {
|
||||
type => 'string',
|
||||
description => 'The mounted device.',
|
||||
},
|
||||
type => {
|
||||
type => 'string',
|
||||
description => 'The filesystem type.',
|
||||
},
|
||||
options => {
|
||||
type => 'string',
|
||||
description => 'The mount options.',
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
code => sub {
|
||||
my ($param) = @_;
|
||||
|
||||
my $result = [];
|
||||
|
||||
dir_glob_foreach('/etc/systemd/system', '^mnt-pve-(.+)\.mount$', sub {
|
||||
my ($filename, $storid) = @_;
|
||||
$storid = PVE::Systemd::unescape_unit($storid);
|
||||
|
||||
my $unitfile = "/etc/systemd/system/$filename";
|
||||
my $unit = $read_ini->($unitfile);
|
||||
|
||||
push @$result, {
|
||||
unitfile => $unitfile,
|
||||
path => "/mnt/pve/$storid",
|
||||
device => $unit->{'Mount'}->{'What'},
|
||||
type => $unit->{'Mount'}->{'Type'},
|
||||
options => $unit->{'Mount'}->{'Options'},
|
||||
};
|
||||
});
|
||||
|
||||
return $result;
|
||||
}});
|
||||
|
||||
__PACKAGE__->register_method ({
|
||||
name => 'create',
|
||||
path => '',
|
||||
method => 'POST',
|
||||
proxyto => 'node',
|
||||
protected => 1,
|
||||
permissions => {
|
||||
check => ['perm', '/', ['Sys.Modify', 'Datastore.Allocate']],
|
||||
},
|
||||
description => "Create a Filesystem on an unused disk. Will be mounted under '/mnt/pve/NAME'.",
|
||||
parameters => {
|
||||
additionalProperties => 0,
|
||||
properties => {
|
||||
node => get_standard_option('pve-node'),
|
||||
name => get_standard_option('pve-storage-id'),
|
||||
device => {
|
||||
type => 'string',
|
||||
description => 'The block device you want to create the filesystem on.',
|
||||
},
|
||||
add_storage => {
|
||||
description => "Configure storage using the directory.",
|
||||
type => 'boolean',
|
||||
optional => 1,
|
||||
default => 0,
|
||||
},
|
||||
filesystem => {
|
||||
description => "The desired filesystem.",
|
||||
type => 'string',
|
||||
enum => ['ext4', 'xfs'],
|
||||
optional => 1,
|
||||
default => 'ext4',
|
||||
},
|
||||
},
|
||||
},
|
||||
returns => { type => 'string' },
|
||||
code => sub {
|
||||
my ($param) = @_;
|
||||
|
||||
my $rpcenv = PVE::RPCEnvironment::get();
|
||||
my $user = $rpcenv->get_user();
|
||||
|
||||
my $name = $param->{name};
|
||||
my $dev = $param->{device};
|
||||
my $node = $param->{node};
|
||||
my $type = $param->{filesystem} // 'ext4';
|
||||
my $path = "/mnt/pve/$name";
|
||||
my $mountunitname = PVE::Systemd::escape_unit($path, 1) . ".mount";
|
||||
my $mountunitpath = "/etc/systemd/system/$mountunitname";
|
||||
|
||||
$dev = PVE::Diskmanage::verify_blockdev_path($dev);
|
||||
PVE::Diskmanage::assert_disk_unused($dev);
|
||||
|
||||
my $storage_params = {
|
||||
type => 'dir',
|
||||
storage => $name,
|
||||
content => 'rootdir,images,iso,backup,vztmpl,snippets',
|
||||
is_mountpoint => 1,
|
||||
path => $path,
|
||||
nodes => $node,
|
||||
};
|
||||
my $verify_params = [qw(path)];
|
||||
|
||||
if ($param->{add_storage}) {
|
||||
PVE::API2::Storage::Config->create_or_update(
|
||||
$name,
|
||||
$node,
|
||||
$storage_params,
|
||||
$verify_params,
|
||||
1,
|
||||
);
|
||||
}
|
||||
|
||||
my $mounted = PVE::Diskmanage::mounted_paths();
|
||||
die "the path for '${name}' is already mounted: ${path} ($mounted->{$path})\n"
|
||||
if $mounted->{$path};
|
||||
die "a systemd mount unit already exists: ${mountunitpath}\n" if -e $mountunitpath;
|
||||
|
||||
my $worker = sub {
|
||||
PVE::Diskmanage::locked_disk_action(sub {
|
||||
PVE::Diskmanage::assert_disk_unused($dev);
|
||||
|
||||
my $part = $dev;
|
||||
|
||||
if (PVE::Diskmanage::is_partition($dev)) {
|
||||
eval { PVE::Diskmanage::change_parttype($dev, '8300'); };
|
||||
warn $@ if $@;
|
||||
} else {
|
||||
# create partition
|
||||
my $cmd = [$SGDISK, '-n1', '-t1:8300', $dev];
|
||||
print "# ", join(' ', @$cmd), "\n";
|
||||
run_command($cmd);
|
||||
|
||||
my ($devname) = $dev =~ m|^/dev/(.*)$|;
|
||||
$part = "/dev/";
|
||||
dir_glob_foreach("/sys/block/$devname", qr/\Q$devname\E.+/, sub {
|
||||
my ($partition) = @_;
|
||||
$part .= $partition;
|
||||
});
|
||||
}
|
||||
|
||||
# create filesystem
|
||||
my $cmd = [$MKFS, '-t', $type, $part];
|
||||
print "# ", join(' ', @$cmd), "\n";
|
||||
run_command($cmd);
|
||||
|
||||
# create systemd mount unit and enable & start it
|
||||
my $ini = {
|
||||
'Unit' => {
|
||||
'Description' => "Mount storage '$name' under /mnt/pve",
|
||||
},
|
||||
'Install' => {
|
||||
'WantedBy' => 'multi-user.target',
|
||||
},
|
||||
};
|
||||
|
||||
my $uuid_path;
|
||||
my $uuid;
|
||||
|
||||
$cmd = [$BLKID, $part, '-o', 'export'];
|
||||
print "# ", join(' ', @$cmd), "\n";
|
||||
run_command($cmd, outfunc => sub {
|
||||
my ($line) = @_;
|
||||
|
||||
if ($line =~ m/^UUID=(.*)$/) {
|
||||
$uuid = $1;
|
||||
$uuid_path = "/dev/disk/by-uuid/$uuid";
|
||||
}
|
||||
});
|
||||
|
||||
die "could not get UUID of device '$part'\n" if !$uuid;
|
||||
|
||||
$ini->{'Mount'} = {
|
||||
'What' => $uuid_path,
|
||||
'Where' => $path,
|
||||
'Type' => $type,
|
||||
'Options' => 'defaults',
|
||||
};
|
||||
|
||||
$write_ini->($ini, $mountunitpath);
|
||||
|
||||
PVE::Diskmanage::udevadm_trigger($part);
|
||||
|
||||
run_command(['systemctl', 'daemon-reload']);
|
||||
run_command(['systemctl', 'enable', $mountunitname]);
|
||||
run_command(['systemctl', 'start', $mountunitname]);
|
||||
|
||||
if ($param->{add_storage}) {
|
||||
PVE::API2::Storage::Config->create_or_update(
|
||||
$name,
|
||||
$node,
|
||||
$storage_params,
|
||||
$verify_params,
|
||||
);
|
||||
}
|
||||
});
|
||||
};
|
||||
|
||||
return $rpcenv->fork_worker('dircreate', $name, $user, $worker);
|
||||
}});
|
||||
|
||||
__PACKAGE__->register_method ({
|
||||
name => 'delete',
|
||||
path => '{name}',
|
||||
method => 'DELETE',
|
||||
proxyto => 'node',
|
||||
protected => 1,
|
||||
permissions => {
|
||||
check => ['perm', '/', ['Sys.Modify', 'Datastore.Allocate']],
|
||||
},
|
||||
description => "Unmounts the storage and removes the mount unit.",
|
||||
parameters => {
|
||||
additionalProperties => 0,
|
||||
properties => {
|
||||
node => get_standard_option('pve-node'),
|
||||
name => get_standard_option('pve-storage-id'),
|
||||
'cleanup-config' => {
|
||||
description => "Marks associated storage(s) as not available on this node anymore ".
|
||||
"or removes them from the configuration (if configured for this node only).",
|
||||
type => 'boolean',
|
||||
optional => 1,
|
||||
default => 0,
|
||||
},
|
||||
'cleanup-disks' => {
|
||||
description => "Also wipe disk so it can be repurposed afterwards.",
|
||||
type => 'boolean',
|
||||
optional => 1,
|
||||
default => 0,
|
||||
},
|
||||
},
|
||||
},
|
||||
returns => { type => 'string' },
|
||||
code => sub {
|
||||
my ($param) = @_;
|
||||
|
||||
my $rpcenv = PVE::RPCEnvironment::get();
|
||||
my $user = $rpcenv->get_user();
|
||||
|
||||
my $name = $param->{name};
|
||||
my $node = $param->{node};
|
||||
|
||||
my $worker = sub {
|
||||
my $path = "/mnt/pve/$name";
|
||||
my $mountunitname = PVE::Systemd::escape_unit($path, 1) . ".mount";
|
||||
my $mountunitpath = "/etc/systemd/system/$mountunitname";
|
||||
|
||||
PVE::Diskmanage::locked_disk_action(sub {
|
||||
my $to_wipe;
|
||||
if ($param->{'cleanup-disks'}) {
|
||||
my $unit = $read_ini->($mountunitpath);
|
||||
|
||||
my $dev = PVE::Diskmanage::verify_blockdev_path($unit->{'Mount'}->{'What'});
|
||||
$to_wipe = $dev;
|
||||
|
||||
# clean up whole device if this is the only partition
|
||||
$dev =~ s|^/dev/||;
|
||||
my $info = PVE::Diskmanage::get_disks($dev, 1, 1);
|
||||
die "unable to obtain information for disk '$dev'\n" if !$info->{$dev};
|
||||
$to_wipe = $info->{$dev}->{parent}
|
||||
if $info->{$dev}->{parent} && scalar(keys $info->%*) == 2;
|
||||
}
|
||||
|
||||
run_command(['systemctl', 'stop', $mountunitname]);
|
||||
run_command(['systemctl', 'disable', $mountunitname]);
|
||||
|
||||
unlink $mountunitpath or $! == ENOENT or die "cannot remove $mountunitpath - $!\n";
|
||||
|
||||
my $config_err;
|
||||
if ($param->{'cleanup-config'}) {
|
||||
my $match = sub {
|
||||
my ($scfg) = @_;
|
||||
return $scfg->{type} eq 'dir' && $scfg->{path} eq $path;
|
||||
};
|
||||
eval { PVE::API2::Storage::Config->cleanup_storages_for_node($match, $node); };
|
||||
warn $config_err = $@ if $@;
|
||||
}
|
||||
|
||||
if ($to_wipe) {
|
||||
PVE::Diskmanage::wipe_blockdev($to_wipe);
|
||||
PVE::Diskmanage::udevadm_trigger($to_wipe);
|
||||
}
|
||||
|
||||
die "config cleanup failed - $config_err" if $config_err;
|
||||
});
|
||||
};
|
||||
|
||||
return $rpcenv->fork_worker('dirremove', $name, $user, $worker);
|
||||
}});
|
||||
|
||||
1;
|
||||
281
src/PVE/API2/Disks/LVM.pm
Normal file
281
src/PVE/API2/Disks/LVM.pm
Normal file
@ -0,0 +1,281 @@
|
||||
package PVE::API2::Disks::LVM;
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
|
||||
use PVE::Storage::LVMPlugin;
|
||||
use PVE::Diskmanage;
|
||||
use PVE::JSONSchema qw(get_standard_option);
|
||||
use PVE::API2::Storage::Config;
|
||||
use PVE::Tools qw(lock_file run_command);
|
||||
|
||||
use PVE::RPCEnvironment;
|
||||
use PVE::RESTHandler;
|
||||
|
||||
use base qw(PVE::RESTHandler);
|
||||
|
||||
__PACKAGE__->register_method ({
|
||||
name => 'index',
|
||||
path => '',
|
||||
method => 'GET',
|
||||
proxyto => 'node',
|
||||
protected => 1,
|
||||
permissions => {
|
||||
check => ['perm', '/', ['Sys.Audit', 'Datastore.Audit'], any => 1],
|
||||
},
|
||||
description => "List LVM Volume Groups",
|
||||
parameters => {
|
||||
additionalProperties => 0,
|
||||
properties => {
|
||||
node => get_standard_option('pve-node'),
|
||||
},
|
||||
},
|
||||
returns => {
|
||||
type => 'object',
|
||||
properties => {
|
||||
leaf => {
|
||||
type => 'boolean',
|
||||
},
|
||||
children => {
|
||||
type => 'array',
|
||||
items => {
|
||||
type => "object",
|
||||
properties => {
|
||||
leaf => {
|
||||
type => 'boolean',
|
||||
},
|
||||
name => {
|
||||
type => 'string',
|
||||
description => 'The name of the volume group',
|
||||
},
|
||||
size => {
|
||||
type => 'integer',
|
||||
description => 'The size of the volume group in bytes',
|
||||
},
|
||||
free => {
|
||||
type => 'integer',
|
||||
description => 'The free bytes in the volume group',
|
||||
},
|
||||
children => {
|
||||
optional => 1,
|
||||
type => 'array',
|
||||
description => 'The underlying physical volumes',
|
||||
items => {
|
||||
type => 'object',
|
||||
properties => {
|
||||
leaf => {
|
||||
type => 'boolean',
|
||||
},
|
||||
name => {
|
||||
type => 'string',
|
||||
description => 'The name of the physical volume',
|
||||
},
|
||||
size => {
|
||||
type => 'integer',
|
||||
description => 'The size of the physical volume in bytes',
|
||||
},
|
||||
free => {
|
||||
type => 'integer',
|
||||
description => 'The free bytes in the physical volume',
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
code => sub {
|
||||
my ($param) = @_;
|
||||
|
||||
my $result = [];
|
||||
|
||||
my $vgs = PVE::Storage::LVMPlugin::lvm_vgs(1);
|
||||
|
||||
foreach my $vg_name (sort keys %$vgs) {
|
||||
my $vg = $vgs->{$vg_name};
|
||||
$vg->{name} = $vg_name;
|
||||
$vg->{leaf} = 0;
|
||||
foreach my $pv (@{$vg->{pvs}}) {
|
||||
$pv->{leaf} = 1;
|
||||
}
|
||||
$vg->{children} = delete $vg->{pvs};
|
||||
push @$result, $vg;
|
||||
}
|
||||
|
||||
return {
|
||||
leaf => 0,
|
||||
children => $result,
|
||||
};
|
||||
}});
|
||||
|
||||
__PACKAGE__->register_method ({
|
||||
name => 'create',
|
||||
path => '',
|
||||
method => 'POST',
|
||||
proxyto => 'node',
|
||||
protected => 1,
|
||||
permissions => {
|
||||
check => ['perm', '/', ['Sys.Modify', 'Datastore.Allocate']],
|
||||
},
|
||||
description => "Create an LVM Volume Group",
|
||||
parameters => {
|
||||
additionalProperties => 0,
|
||||
properties => {
|
||||
node => get_standard_option('pve-node'),
|
||||
name => get_standard_option('pve-storage-id'),
|
||||
device => {
|
||||
type => 'string',
|
||||
description => 'The block device you want to create the volume group on',
|
||||
},
|
||||
add_storage => {
|
||||
description => "Configure storage using the Volume Group",
|
||||
type => 'boolean',
|
||||
optional => 1,
|
||||
default => 0,
|
||||
},
|
||||
},
|
||||
},
|
||||
returns => { type => 'string' },
|
||||
code => sub {
|
||||
my ($param) = @_;
|
||||
|
||||
my $rpcenv = PVE::RPCEnvironment::get();
|
||||
my $user = $rpcenv->get_user();
|
||||
|
||||
my $name = $param->{name};
|
||||
my $dev = $param->{device};
|
||||
my $node = $param->{node};
|
||||
|
||||
$dev = PVE::Diskmanage::verify_blockdev_path($dev);
|
||||
PVE::Diskmanage::assert_disk_unused($dev);
|
||||
|
||||
my $storage_params = {
|
||||
type => 'lvm',
|
||||
vgname => $name,
|
||||
storage => $name,
|
||||
content => 'rootdir,images',
|
||||
shared => 0,
|
||||
nodes => $node,
|
||||
};
|
||||
my $verify_params = [qw(vgname)];
|
||||
|
||||
if ($param->{add_storage}) {
|
||||
PVE::API2::Storage::Config->create_or_update(
|
||||
$name,
|
||||
$node,
|
||||
$storage_params,
|
||||
$verify_params,
|
||||
1,
|
||||
);
|
||||
}
|
||||
|
||||
my $worker = sub {
|
||||
PVE::Diskmanage::locked_disk_action(sub {
|
||||
PVE::Diskmanage::assert_disk_unused($dev);
|
||||
die "volume group with name '${name}' already exists on node '${node}'\n"
|
||||
if PVE::Storage::LVMPlugin::lvm_vgs()->{$name};
|
||||
|
||||
if (PVE::Diskmanage::is_partition($dev)) {
|
||||
eval { PVE::Diskmanage::change_parttype($dev, '8E00'); };
|
||||
warn $@ if $@;
|
||||
}
|
||||
|
||||
PVE::Storage::LVMPlugin::lvm_create_volume_group($dev, $name);
|
||||
|
||||
PVE::Diskmanage::udevadm_trigger($dev);
|
||||
|
||||
if ($param->{add_storage}) {
|
||||
PVE::API2::Storage::Config->create_or_update(
|
||||
$name,
|
||||
$node,
|
||||
$storage_params,
|
||||
$verify_params,
|
||||
);
|
||||
}
|
||||
});
|
||||
};
|
||||
|
||||
return $rpcenv->fork_worker('lvmcreate', $name, $user, $worker);
|
||||
}});
|
||||
|
||||
__PACKAGE__->register_method ({
|
||||
name => 'delete',
|
||||
path => '{name}',
|
||||
method => 'DELETE',
|
||||
proxyto => 'node',
|
||||
protected => 1,
|
||||
permissions => {
|
||||
check => ['perm', '/', ['Sys.Modify', 'Datastore.Allocate']],
|
||||
},
|
||||
description => "Remove an LVM Volume Group.",
|
||||
parameters => {
|
||||
additionalProperties => 0,
|
||||
properties => {
|
||||
node => get_standard_option('pve-node'),
|
||||
name => get_standard_option('pve-storage-id'),
|
||||
'cleanup-config' => {
|
||||
description => "Marks associated storage(s) as not available on this node anymore ".
|
||||
"or removes them from the configuration (if configured for this node only).",
|
||||
type => 'boolean',
|
||||
optional => 1,
|
||||
default => 0,
|
||||
},
|
||||
'cleanup-disks' => {
|
||||
description => "Also wipe disks so they can be repurposed afterwards.",
|
||||
type => 'boolean',
|
||||
optional => 1,
|
||||
default => 0,
|
||||
},
|
||||
},
|
||||
},
|
||||
returns => { type => 'string' },
|
||||
code => sub {
|
||||
my ($param) = @_;
|
||||
|
||||
my $rpcenv = PVE::RPCEnvironment::get();
|
||||
my $user = $rpcenv->get_user();
|
||||
|
||||
my $name = $param->{name};
|
||||
my $node = $param->{node};
|
||||
|
||||
my $worker = sub {
|
||||
PVE::Diskmanage::locked_disk_action(sub {
|
||||
my $vgs = PVE::Storage::LVMPlugin::lvm_vgs(1);
|
||||
die "no such volume group '$name'\n" if !$vgs->{$name};
|
||||
|
||||
PVE::Storage::LVMPlugin::lvm_destroy_volume_group($name);
|
||||
|
||||
my $config_err;
|
||||
if ($param->{'cleanup-config'}) {
|
||||
my $match = sub {
|
||||
my ($scfg) = @_;
|
||||
return $scfg->{type} eq 'lvm' && $scfg->{vgname} eq $name;
|
||||
};
|
||||
eval { PVE::API2::Storage::Config->cleanup_storages_for_node($match, $node); };
|
||||
warn $config_err = $@ if $@;
|
||||
}
|
||||
|
||||
if ($param->{'cleanup-disks'}) {
|
||||
my $wiped = [];
|
||||
eval {
|
||||
for my $pv ($vgs->{$name}->{pvs}->@*) {
|
||||
my $dev = PVE::Diskmanage::verify_blockdev_path($pv->{name});
|
||||
PVE::Diskmanage::wipe_blockdev($dev);
|
||||
push $wiped->@*, $dev;
|
||||
}
|
||||
};
|
||||
my $err = $@;
|
||||
PVE::Diskmanage::udevadm_trigger($wiped->@*);
|
||||
die "cleanup failed - $err" if $err;
|
||||
}
|
||||
|
||||
die "config cleanup failed - $config_err" if $config_err;
|
||||
});
|
||||
};
|
||||
|
||||
return $rpcenv->fork_worker('lvmremove', $name, $user, $worker);
|
||||
}});
|
||||
|
||||
1;
|
||||
271
src/PVE/API2/Disks/LVMThin.pm
Normal file
271
src/PVE/API2/Disks/LVMThin.pm
Normal file
@ -0,0 +1,271 @@
|
||||
package PVE::API2::Disks::LVMThin;
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
|
||||
use PVE::Storage::LvmThinPlugin;
|
||||
use PVE::Diskmanage;
|
||||
use PVE::JSONSchema qw(get_standard_option);
|
||||
use PVE::API2::Storage::Config;
|
||||
use PVE::Storage;
|
||||
use PVE::Tools qw(run_command lock_file);
|
||||
|
||||
use PVE::RPCEnvironment;
|
||||
use PVE::RESTHandler;
|
||||
|
||||
use base qw(PVE::RESTHandler);
|
||||
|
||||
__PACKAGE__->register_method ({
|
||||
name => 'index',
|
||||
path => '',
|
||||
method => 'GET',
|
||||
proxyto => 'node',
|
||||
protected => 1,
|
||||
permissions => {
|
||||
check => ['perm', '/', ['Sys.Audit', 'Datastore.Audit'], any => 1],
|
||||
},
|
||||
description => "List LVM thinpools",
|
||||
parameters => {
|
||||
additionalProperties => 0,
|
||||
properties => {
|
||||
node => get_standard_option('pve-node'),
|
||||
},
|
||||
},
|
||||
returns => {
|
||||
type => 'array',
|
||||
items => {
|
||||
type => 'object',
|
||||
properties => {
|
||||
lv => {
|
||||
type => 'string',
|
||||
description => 'The name of the thinpool.',
|
||||
},
|
||||
vg => {
|
||||
type => 'string',
|
||||
description => 'The associated volume group.',
|
||||
},
|
||||
lv_size => {
|
||||
type => 'integer',
|
||||
description => 'The size of the thinpool in bytes.',
|
||||
},
|
||||
used => {
|
||||
type => 'integer',
|
||||
description => 'The used bytes of the thinpool.',
|
||||
},
|
||||
metadata_size => {
|
||||
type => 'integer',
|
||||
description => 'The size of the metadata lv in bytes.',
|
||||
},
|
||||
metadata_used => {
|
||||
type => 'integer',
|
||||
description => 'The used bytes of the metadata lv.',
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
code => sub {
|
||||
my ($param) = @_;
|
||||
return PVE::Storage::LvmThinPlugin::list_thinpools(undef);
|
||||
}});
|
||||
|
||||
__PACKAGE__->register_method ({
|
||||
name => 'create',
|
||||
path => '',
|
||||
method => 'POST',
|
||||
proxyto => 'node',
|
||||
protected => 1,
|
||||
permissions => {
|
||||
check => ['perm', '/', ['Sys.Modify', 'Datastore.Allocate']],
|
||||
},
|
||||
description => "Create an LVM thinpool",
|
||||
parameters => {
|
||||
additionalProperties => 0,
|
||||
properties => {
|
||||
node => get_standard_option('pve-node'),
|
||||
name => get_standard_option('pve-storage-id'),
|
||||
device => {
|
||||
type => 'string',
|
||||
description => 'The block device you want to create the thinpool on.',
|
||||
},
|
||||
add_storage => {
|
||||
description => "Configure storage using the thinpool.",
|
||||
type => 'boolean',
|
||||
optional => 1,
|
||||
default => 0,
|
||||
},
|
||||
},
|
||||
},
|
||||
returns => { type => 'string' },
|
||||
code => sub {
|
||||
my ($param) = @_;
|
||||
|
||||
my $rpcenv = PVE::RPCEnvironment::get();
|
||||
my $user = $rpcenv->get_user();
|
||||
|
||||
my $name = $param->{name};
|
||||
my $dev = $param->{device};
|
||||
my $node = $param->{node};
|
||||
|
||||
$dev = PVE::Diskmanage::verify_blockdev_path($dev);
|
||||
PVE::Diskmanage::assert_disk_unused($dev);
|
||||
|
||||
my $storage_params = {
|
||||
type => 'lvmthin',
|
||||
vgname => $name,
|
||||
thinpool => $name,
|
||||
storage => $name,
|
||||
content => 'rootdir,images',
|
||||
nodes => $node,
|
||||
};
|
||||
my $verify_params = [qw(vgname thinpool)];
|
||||
|
||||
if ($param->{add_storage}) {
|
||||
PVE::API2::Storage::Config->create_or_update(
|
||||
$name,
|
||||
$node,
|
||||
$storage_params,
|
||||
$verify_params,
|
||||
1,
|
||||
);
|
||||
}
|
||||
|
||||
my $worker = sub {
|
||||
PVE::Diskmanage::locked_disk_action(sub {
|
||||
PVE::Diskmanage::assert_disk_unused($dev);
|
||||
|
||||
die "volume group with name '${name}' already exists on node '${node}'\n"
|
||||
if PVE::Storage::LVMPlugin::lvm_vgs()->{$name};
|
||||
|
||||
if (PVE::Diskmanage::is_partition($dev)) {
|
||||
eval { PVE::Diskmanage::change_parttype($dev, '8E00'); };
|
||||
warn $@ if $@;
|
||||
}
|
||||
|
||||
PVE::Storage::LVMPlugin::lvm_create_volume_group($dev, $name);
|
||||
my $pv = PVE::Storage::LVMPlugin::lvm_pv_info($dev);
|
||||
# keep some free space just in case
|
||||
my $datasize = $pv->{size} - 128*1024;
|
||||
# default to 1% for metadata
|
||||
my $metadatasize = $datasize/100;
|
||||
# but at least 1G, as recommended in lvmthin man
|
||||
$metadatasize = 1024*1024 if $metadatasize < 1024*1024;
|
||||
# but at most 16G, which is the current lvm max
|
||||
$metadatasize = 16*1024*1024 if $metadatasize > 16*1024*1024;
|
||||
# shrink data by needed amount for metadata
|
||||
$datasize -= 2*$metadatasize;
|
||||
|
||||
run_command([
|
||||
'/sbin/lvcreate',
|
||||
'--type', 'thin-pool',
|
||||
"-L${datasize}K",
|
||||
'--poolmetadatasize', "${metadatasize}K",
|
||||
'-n', $name,
|
||||
$name
|
||||
]);
|
||||
|
||||
PVE::Diskmanage::udevadm_trigger($dev);
|
||||
|
||||
if ($param->{add_storage}) {
|
||||
PVE::API2::Storage::Config->create_or_update(
|
||||
$name,
|
||||
$node,
|
||||
$storage_params,
|
||||
$verify_params,
|
||||
);
|
||||
}
|
||||
});
|
||||
};
|
||||
|
||||
return $rpcenv->fork_worker('lvmthincreate', $name, $user, $worker);
|
||||
}});
|
||||
|
||||
__PACKAGE__->register_method ({
|
||||
name => 'delete',
|
||||
path => '{name}',
|
||||
method => 'DELETE',
|
||||
proxyto => 'node',
|
||||
protected => 1,
|
||||
permissions => {
|
||||
check => ['perm', '/', ['Sys.Modify', 'Datastore.Allocate']],
|
||||
},
|
||||
description => "Remove an LVM thin pool.",
|
||||
parameters => {
|
||||
additionalProperties => 0,
|
||||
properties => {
|
||||
node => get_standard_option('pve-node'),
|
||||
name => get_standard_option('pve-storage-id'),
|
||||
'volume-group' => get_standard_option('pve-storage-id'),
|
||||
'cleanup-config' => {
|
||||
description => "Marks associated storage(s) as not available on this node anymore ".
|
||||
"or removes them from the configuration (if configured for this node only).",
|
||||
type => 'boolean',
|
||||
optional => 1,
|
||||
default => 0,
|
||||
},
|
||||
'cleanup-disks' => {
|
||||
description => "Also wipe disks so they can be repurposed afterwards.",
|
||||
type => 'boolean',
|
||||
optional => 1,
|
||||
default => 0,
|
||||
},
|
||||
},
|
||||
},
|
||||
returns => { type => 'string' },
|
||||
code => sub {
|
||||
my ($param) = @_;
|
||||
|
||||
my $rpcenv = PVE::RPCEnvironment::get();
|
||||
my $user = $rpcenv->get_user();
|
||||
|
||||
my $vg = $param->{'volume-group'};
|
||||
my $lv = $param->{name};
|
||||
my $node = $param->{node};
|
||||
|
||||
my $worker = sub {
|
||||
PVE::Diskmanage::locked_disk_action(sub {
|
||||
my $thinpools = PVE::Storage::LvmThinPlugin::list_thinpools();
|
||||
|
||||
die "no such thin pool ${vg}/${lv}\n"
|
||||
if !grep { $_->{lv} eq $lv && $_->{vg} eq $vg } $thinpools->@*;
|
||||
|
||||
run_command(['lvremove', '-y', "${vg}/${lv}"]);
|
||||
|
||||
my $config_err;
|
||||
if ($param->{'cleanup-config'}) {
|
||||
my $match = sub {
|
||||
my ($scfg) = @_;
|
||||
return $scfg->{type} eq 'lvmthin'
|
||||
&& $scfg->{vgname} eq $vg
|
||||
&& $scfg->{thinpool} eq $lv;
|
||||
};
|
||||
eval { PVE::API2::Storage::Config->cleanup_storages_for_node($match, $node); };
|
||||
warn $config_err = $@ if $@;
|
||||
}
|
||||
|
||||
if ($param->{'cleanup-disks'}) {
|
||||
my $vgs = PVE::Storage::LVMPlugin::lvm_vgs(1);
|
||||
|
||||
die "no such volume group '$vg'\n" if !$vgs->{$vg};
|
||||
die "volume group '$vg' still in use\n" if $vgs->{$vg}->{lvcount} > 0;
|
||||
|
||||
my $wiped = [];
|
||||
eval {
|
||||
for my $pv ($vgs->{$vg}->{pvs}->@*) {
|
||||
my $dev = PVE::Diskmanage::verify_blockdev_path($pv->{name});
|
||||
PVE::Diskmanage::wipe_blockdev($dev);
|
||||
push $wiped->@*, $dev;
|
||||
}
|
||||
};
|
||||
my $err = $@;
|
||||
PVE::Diskmanage::udevadm_trigger($wiped->@*);
|
||||
die "cleanup failed - $err" if $err;
|
||||
}
|
||||
|
||||
die "config cleanup failed - $config_err" if $config_err;
|
||||
});
|
||||
};
|
||||
|
||||
return $rpcenv->fork_worker('lvmthinremove', "${vg}-${lv}", $user, $worker);
|
||||
}});
|
||||
|
||||
1;
|
||||
9
src/PVE/API2/Disks/Makefile
Normal file
9
src/PVE/API2/Disks/Makefile
Normal file
@ -0,0 +1,9 @@
|
||||
|
||||
SOURCES= LVM.pm\
|
||||
LVMThin.pm\
|
||||
ZFS.pm\
|
||||
Directory.pm
|
||||
|
||||
.PHONY: install
|
||||
install:
|
||||
for i in ${SOURCES}; do install -D -m 0644 $$i ${DESTDIR}${PERLDIR}/PVE/API2/Disks/$$i; done
|
||||
612
src/PVE/API2/Disks/ZFS.pm
Normal file
612
src/PVE/API2/Disks/ZFS.pm
Normal file
@ -0,0 +1,612 @@
|
||||
package PVE::API2::Disks::ZFS;
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
|
||||
use PVE::Diskmanage;
|
||||
use PVE::JSONSchema qw(get_standard_option parse_property_string);
|
||||
use PVE::Systemd;
|
||||
use PVE::API2::Storage::Config;
|
||||
use PVE::Storage;
|
||||
use PVE::Tools qw(run_command lock_file trim);
|
||||
|
||||
use PVE::RPCEnvironment;
|
||||
use PVE::RESTHandler;
|
||||
|
||||
use base qw(PVE::RESTHandler);
|
||||
|
||||
my $ZPOOL = '/sbin/zpool';
|
||||
my $ZFS = '/sbin/zfs';
|
||||
|
||||
sub get_pool_data {
|
||||
die "zfsutils-linux not installed\n" if ! -f $ZPOOL;
|
||||
|
||||
my $propnames = [qw(name size alloc free frag dedup health)];
|
||||
my $numbers = {
|
||||
size => 1,
|
||||
alloc => 1,
|
||||
free => 1,
|
||||
frag => 1,
|
||||
dedup => 1,
|
||||
};
|
||||
|
||||
my $pools = [];
|
||||
run_command([$ZPOOL, 'list', '-HpPLo', join(',', @$propnames)], outfunc => sub {
|
||||
my ($line) = @_;
|
||||
|
||||
my @props = split('\s+', trim($line));
|
||||
my $pool = {};
|
||||
for (my $i = 0; $i < scalar(@$propnames); $i++) {
|
||||
if ($numbers->{$propnames->[$i]}) {
|
||||
$pool->{$propnames->[$i]} = $props[$i] + 0;
|
||||
} else {
|
||||
$pool->{$propnames->[$i]} = $props[$i];
|
||||
}
|
||||
}
|
||||
|
||||
push @$pools, $pool;
|
||||
});
|
||||
|
||||
return $pools;
|
||||
}
|
||||
|
||||
__PACKAGE__->register_method ({
|
||||
name => 'index',
|
||||
path => '',
|
||||
method => 'GET',
|
||||
proxyto => 'node',
|
||||
protected => 1,
|
||||
permissions => {
|
||||
check => ['perm', '/', ['Sys.Audit', 'Datastore.Audit'], any => 1],
|
||||
},
|
||||
description => "List Zpools.",
|
||||
parameters => {
|
||||
additionalProperties => 0,
|
||||
properties => {
|
||||
node => get_standard_option('pve-node'),
|
||||
},
|
||||
},
|
||||
returns => {
|
||||
type => 'array',
|
||||
items => {
|
||||
type => 'object',
|
||||
properties => {
|
||||
name => {
|
||||
type => 'string',
|
||||
description => "",
|
||||
},
|
||||
size => {
|
||||
type => 'integer',
|
||||
description => "",
|
||||
},
|
||||
alloc => {
|
||||
type => 'integer',
|
||||
description => "",
|
||||
},
|
||||
free => {
|
||||
type => 'integer',
|
||||
description => "",
|
||||
},
|
||||
frag => {
|
||||
type => 'integer',
|
||||
description => "",
|
||||
},
|
||||
dedup => {
|
||||
type => 'number',
|
||||
description => "",
|
||||
},
|
||||
health => {
|
||||
type => 'string',
|
||||
description => "",
|
||||
},
|
||||
},
|
||||
},
|
||||
links => [ { rel => 'child', href => "{name}" } ],
|
||||
},
|
||||
code => sub {
|
||||
my ($param) = @_;
|
||||
|
||||
return get_pool_data();
|
||||
}});
|
||||
|
||||
sub preparetree {
|
||||
my ($el) = @_;
|
||||
delete $el->{lvl};
|
||||
if ($el->{children} && scalar(@{$el->{children}})) {
|
||||
$el->{leaf} = 0;
|
||||
foreach my $child (@{$el->{children}}) {
|
||||
preparetree($child);
|
||||
}
|
||||
} else {
|
||||
$el->{leaf} = 1;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
__PACKAGE__->register_method ({
|
||||
name => 'detail',
|
||||
path => '{name}',
|
||||
method => 'GET',
|
||||
proxyto => 'node',
|
||||
protected => 1,
|
||||
permissions => {
|
||||
check => ['perm', '/', ['Sys.Audit', 'Datastore.Audit'], any => 1],
|
||||
},
|
||||
description => "Get details about a zpool.",
|
||||
parameters => {
|
||||
additionalProperties => 0,
|
||||
properties => {
|
||||
node => get_standard_option('pve-node'),
|
||||
name => get_standard_option('pve-storage-id'),
|
||||
},
|
||||
},
|
||||
returns => {
|
||||
type => 'object',
|
||||
properties => {
|
||||
name => {
|
||||
type => 'string',
|
||||
description => 'The name of the zpool.',
|
||||
},
|
||||
state => {
|
||||
type => 'string',
|
||||
description => 'The state of the zpool.',
|
||||
},
|
||||
status => {
|
||||
optional => 1,
|
||||
type => 'string',
|
||||
description => 'Information about the state of the zpool.',
|
||||
},
|
||||
action => {
|
||||
optional => 1,
|
||||
type => 'string',
|
||||
description => 'Information about the recommended action to fix the state.',
|
||||
},
|
||||
scan => {
|
||||
optional => 1,
|
||||
type => 'string',
|
||||
description => 'Information about the last/current scrub.',
|
||||
},
|
||||
errors => {
|
||||
type => 'string',
|
||||
description => 'Information about the errors on the zpool.',
|
||||
},
|
||||
children => {
|
||||
type => 'array',
|
||||
description => "The pool configuration information, including the vdevs for each section (e.g. spares, cache), may be nested.",
|
||||
items => {
|
||||
type => 'object',
|
||||
properties => {
|
||||
name => {
|
||||
type => 'string',
|
||||
description => 'The name of the vdev or section.',
|
||||
},
|
||||
state => {
|
||||
optional => 1,
|
||||
type => 'string',
|
||||
description => 'The state of the vdev.',
|
||||
},
|
||||
read => {
|
||||
optional => 1,
|
||||
type => 'number',
|
||||
},
|
||||
write => {
|
||||
optional => 1,
|
||||
type => 'number',
|
||||
},
|
||||
cksum => {
|
||||
optional => 1,
|
||||
type => 'number',
|
||||
},
|
||||
msg => {
|
||||
type => 'string',
|
||||
description => 'An optional message about the vdev.'
|
||||
}
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
code => sub {
|
||||
my ($param) = @_;
|
||||
|
||||
if (!-f $ZPOOL) {
|
||||
die "zfsutils-linux not installed\n";
|
||||
}
|
||||
|
||||
my $cmd = [$ZPOOL, 'status', '-P', $param->{name}];
|
||||
|
||||
my $pool = {
|
||||
lvl => 0,
|
||||
};
|
||||
|
||||
my $curfield;
|
||||
my $config = 0;
|
||||
|
||||
my $stack = [$pool];
|
||||
my $curlvl = 0;
|
||||
|
||||
run_command($cmd, outfunc => sub {
|
||||
my ($line) = @_;
|
||||
|
||||
if ($line =~ m/^\s*(\S+): (\S+.*)$/) {
|
||||
$curfield = $1;
|
||||
$pool->{$curfield} = $2;
|
||||
|
||||
$config = 0 if $curfield eq 'errors';
|
||||
} elsif (!$config && $line =~ m/^\s+(\S+.*)$/) {
|
||||
$pool->{$curfield} .= " " . $1;
|
||||
} elsif (!$config && $line =~ m/^\s*config:/) {
|
||||
$config = 1;
|
||||
} elsif ($config && $line =~ m/^(\s+)(\S+)\s*(\S+)?(?:\s+(\S+)\s+(\S+)\s+(\S+))?\s*(.*)$/) {
|
||||
my ($space, $name, $state, $read, $write, $cksum, $msg) = ($1, $2, $3, $4, $5, $6, $7);
|
||||
if ($name ne "NAME") {
|
||||
my $lvl = int(length($space) / 2) + 1; # two spaces per level
|
||||
my $vdev = {
|
||||
name => $name,
|
||||
msg => $msg,
|
||||
lvl => $lvl,
|
||||
};
|
||||
|
||||
$vdev->{state} = $state if defined($state);
|
||||
$vdev->{read} = $read + 0 if defined($read);
|
||||
$vdev->{write} = $write + 0 if defined($write);
|
||||
$vdev->{cksum} = $cksum + 0 if defined($cksum);
|
||||
|
||||
my $cur = pop @$stack;
|
||||
|
||||
if ($lvl > $curlvl) {
|
||||
$cur->{children} = [ $vdev ];
|
||||
} elsif ($lvl == $curlvl) {
|
||||
$cur = pop @$stack;
|
||||
push @{$cur->{children}}, $vdev;
|
||||
} else {
|
||||
while ($lvl <= $cur->{lvl} && $cur->{lvl} != 0) {
|
||||
$cur = pop @$stack;
|
||||
}
|
||||
push @{$cur->{children}}, $vdev;
|
||||
}
|
||||
|
||||
push @$stack, $cur;
|
||||
push @$stack, $vdev;
|
||||
$curlvl = $lvl;
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
# change treenodes for extjs tree
|
||||
$pool->{name} = delete $pool->{pool};
|
||||
preparetree($pool);
|
||||
|
||||
return $pool;
|
||||
}});
|
||||
|
||||
my $draid_config_format = {
|
||||
spares => {
|
||||
type => 'integer',
|
||||
minimum => 0,
|
||||
description => 'Number of dRAID spares.',
|
||||
},
|
||||
data => {
|
||||
type => 'integer',
|
||||
minimum => 1,
|
||||
description => 'The number of data devices per redundancy group. (dRAID)',
|
||||
},
|
||||
};
|
||||
|
||||
__PACKAGE__->register_method ({
|
||||
name => 'create',
|
||||
path => '',
|
||||
method => 'POST',
|
||||
proxyto => 'node',
|
||||
protected => 1,
|
||||
permissions => {
|
||||
check => ['perm', '/', ['Sys.Modify', 'Datastore.Allocate']],
|
||||
},
|
||||
description => "Create a ZFS pool.",
|
||||
parameters => {
|
||||
additionalProperties => 0,
|
||||
properties => {
|
||||
node => get_standard_option('pve-node'),
|
||||
name => get_standard_option('pve-storage-id'),
|
||||
raidlevel => {
|
||||
type => 'string',
|
||||
description => 'The RAID level to use.',
|
||||
enum => [
|
||||
'single', 'mirror',
|
||||
'raid10', 'raidz', 'raidz2', 'raidz3',
|
||||
'draid', 'draid2', 'draid3',
|
||||
],
|
||||
},
|
||||
devices => {
|
||||
type => 'string', format => 'string-list',
|
||||
description => 'The block devices you want to create the zpool on.',
|
||||
},
|
||||
'draid-config' => {
|
||||
type => 'string',
|
||||
format => $draid_config_format,
|
||||
optional => 1,
|
||||
},
|
||||
ashift => {
|
||||
type => 'integer',
|
||||
minimum => 9,
|
||||
maximum => 16,
|
||||
optional => 1,
|
||||
default => 12,
|
||||
description => 'Pool sector size exponent.',
|
||||
},
|
||||
compression => {
|
||||
type => 'string',
|
||||
description => 'The compression algorithm to use.',
|
||||
enum => ['on', 'off', 'gzip', 'lz4', 'lzjb', 'zle', 'zstd'],
|
||||
optional => 1,
|
||||
default => 'on',
|
||||
},
|
||||
add_storage => {
|
||||
description => "Configure storage using the zpool.",
|
||||
type => 'boolean',
|
||||
optional => 1,
|
||||
default => 0,
|
||||
},
|
||||
},
|
||||
},
|
||||
returns => { type => 'string' },
|
||||
code => sub {
|
||||
my ($param) = @_;
|
||||
|
||||
my $rpcenv = PVE::RPCEnvironment::get();
|
||||
my $user = $rpcenv->get_user();
|
||||
|
||||
my $name = $param->{name};
|
||||
my $node = $param->{node};
|
||||
my $devs = [PVE::Tools::split_list($param->{devices})];
|
||||
my $raidlevel = $param->{raidlevel};
|
||||
my $compression = $param->{compression} // 'on';
|
||||
|
||||
my $draid_config;
|
||||
if (exists $param->{'draid-config'}) {
|
||||
die "draid-config set without using dRAID level\n" if $raidlevel !~ m/^draid/;
|
||||
$draid_config = parse_property_string($draid_config_format, $param->{'draid-config'});
|
||||
}
|
||||
|
||||
for my $dev (@$devs) {
|
||||
$dev = PVE::Diskmanage::verify_blockdev_path($dev);
|
||||
PVE::Diskmanage::assert_disk_unused($dev);
|
||||
|
||||
}
|
||||
my $storage_params = {
|
||||
type => 'zfspool',
|
||||
pool => $name,
|
||||
storage => $name,
|
||||
content => 'rootdir,images',
|
||||
nodes => $node,
|
||||
};
|
||||
my $verify_params = [qw(pool)];
|
||||
|
||||
if ($param->{add_storage}) {
|
||||
PVE::API2::Storage::Config->create_or_update(
|
||||
$name,
|
||||
$node,
|
||||
$storage_params,
|
||||
$verify_params,
|
||||
1,
|
||||
);
|
||||
}
|
||||
|
||||
my $pools = get_pool_data();
|
||||
die "pool '${name}' already exists on node '${node}'\n"
|
||||
if grep { $_->{name} eq $name } @{$pools};
|
||||
|
||||
my $numdisks = scalar(@$devs);
|
||||
my $mindisks = {
|
||||
single => 1,
|
||||
mirror => 2,
|
||||
raid10 => 4,
|
||||
raidz => 3,
|
||||
raidz2 => 4,
|
||||
raidz3 => 5,
|
||||
draid => 3,
|
||||
draid2 => 4,
|
||||
draid3 => 5,
|
||||
};
|
||||
|
||||
# sanity checks
|
||||
die "raid10 needs an even number of disks\n"
|
||||
if $raidlevel eq 'raid10' && $numdisks % 2 != 0;
|
||||
|
||||
die "please give only one disk for single disk mode\n"
|
||||
if $raidlevel eq 'single' && $numdisks > 1;
|
||||
|
||||
die "$raidlevel needs at least $mindisks->{$raidlevel} disks\n"
|
||||
if $numdisks < $mindisks->{$raidlevel};
|
||||
|
||||
# draid checks
|
||||
if ($raidlevel =~ m/^draid/) {
|
||||
# bare minimum would be two drives: one for parity & one for data, but forbid that
|
||||
# because it makes no sense in practice, at least one spare disk should be used
|
||||
my $draid_min = $mindisks->{$raidlevel} - 2;
|
||||
if ($draid_config) {
|
||||
$draid_min += $draid_config->{data} || 0;
|
||||
$draid_min += $draid_config->{spares} || 0;
|
||||
}
|
||||
die "At least $draid_min disks needed for current dRAID config\n"
|
||||
if $numdisks < $draid_min;
|
||||
}
|
||||
|
||||
my $code = sub {
|
||||
for my $dev (@$devs) {
|
||||
PVE::Diskmanage::assert_disk_unused($dev);
|
||||
|
||||
my $is_partition = PVE::Diskmanage::is_partition($dev);
|
||||
|
||||
if ($is_partition) {
|
||||
eval {
|
||||
PVE::Diskmanage::change_parttype($dev, '6a898cc3-1dd2-11b2-99a6-080020736631');
|
||||
};
|
||||
warn $@ if $@;
|
||||
}
|
||||
|
||||
my $sysfsdev = $is_partition ? PVE::Diskmanage::get_blockdev($dev) : $dev;
|
||||
|
||||
$sysfsdev =~ s!^/dev/!/sys/block/!;
|
||||
if ($is_partition) {
|
||||
my $part = $dev =~ s!^/dev/!!r;
|
||||
$sysfsdev .= "/${part}";
|
||||
}
|
||||
|
||||
my $udevinfo = PVE::Diskmanage::get_udev_info($sysfsdev);
|
||||
$dev = $udevinfo->{by_id_link} if defined($udevinfo->{by_id_link});
|
||||
}
|
||||
|
||||
# create zpool with desired raidlevel
|
||||
my $ashift = $param->{ashift} // 12;
|
||||
|
||||
my $cmd = [$ZPOOL, 'create', '-o', "ashift=$ashift", $name];
|
||||
|
||||
if ($raidlevel eq 'raid10') {
|
||||
for (my $i = 0; $i < @$devs; $i+=2) {
|
||||
push @$cmd, 'mirror', $devs->[$i], $devs->[$i+1];
|
||||
}
|
||||
} elsif ($raidlevel eq 'single') {
|
||||
push @$cmd, $devs->[0];
|
||||
} elsif ($raidlevel =~ m/^draid/) {
|
||||
my $draid_cmd = $raidlevel;
|
||||
$draid_cmd .= ":$draid_config->{data}d" if $draid_config->{data};
|
||||
$draid_cmd .= ":$draid_config->{spares}s" if $draid_config->{spares};
|
||||
push @$cmd, $draid_cmd, @$devs;
|
||||
} else {
|
||||
push @$cmd, $raidlevel, @$devs;
|
||||
}
|
||||
|
||||
print "# ", join(' ', @$cmd), "\n";
|
||||
run_command($cmd);
|
||||
|
||||
$cmd = [$ZFS, 'set', "compression=$compression", $name];
|
||||
print "# ", join(' ', @$cmd), "\n";
|
||||
run_command($cmd);
|
||||
|
||||
if (-e '/lib/systemd/system/zfs-import@.service') {
|
||||
my $importunit = 'zfs-import@'. PVE::Systemd::escape_unit($name, undef) . '.service';
|
||||
$cmd = ['systemctl', 'enable', $importunit];
|
||||
print "# ", join(' ', @$cmd), "\n";
|
||||
run_command($cmd);
|
||||
}
|
||||
|
||||
PVE::Diskmanage::udevadm_trigger($devs->@*);
|
||||
|
||||
if ($param->{add_storage}) {
|
||||
PVE::API2::Storage::Config->create_or_update(
|
||||
$name,
|
||||
$node,
|
||||
$storage_params,
|
||||
$verify_params,
|
||||
);
|
||||
}
|
||||
};
|
||||
|
||||
return $rpcenv->fork_worker('zfscreate', $name, $user, sub {
|
||||
PVE::Diskmanage::locked_disk_action($code);
|
||||
});
|
||||
}});
|
||||
|
||||
__PACKAGE__->register_method ({
|
||||
name => 'delete',
|
||||
path => '{name}',
|
||||
method => 'DELETE',
|
||||
proxyto => 'node',
|
||||
protected => 1,
|
||||
permissions => {
|
||||
check => ['perm', '/', ['Sys.Modify', 'Datastore.Allocate']],
|
||||
},
|
||||
description => "Destroy a ZFS pool.",
|
||||
parameters => {
|
||||
additionalProperties => 0,
|
||||
properties => {
|
||||
node => get_standard_option('pve-node'),
|
||||
name => get_standard_option('pve-storage-id'),
|
||||
'cleanup-config' => {
|
||||
description => "Marks associated storage(s) as not available on this node anymore ".
|
||||
"or removes them from the configuration (if configured for this node only).",
|
||||
type => 'boolean',
|
||||
optional => 1,
|
||||
default => 0,
|
||||
},
|
||||
'cleanup-disks' => {
|
||||
description => "Also wipe disks so they can be repurposed afterwards.",
|
||||
type => 'boolean',
|
||||
optional => 1,
|
||||
default => 0,
|
||||
},
|
||||
},
|
||||
},
|
||||
returns => { type => 'string' },
|
||||
code => sub {
|
||||
my ($param) = @_;
|
||||
|
||||
my $rpcenv = PVE::RPCEnvironment::get();
|
||||
my $user = $rpcenv->get_user();
|
||||
|
||||
my $name = $param->{name};
|
||||
my $node = $param->{node};
|
||||
|
||||
my $worker = sub {
|
||||
PVE::Diskmanage::locked_disk_action(sub {
|
||||
my $to_wipe = [];
|
||||
if ($param->{'cleanup-disks'}) {
|
||||
# Using -o name does not only output the name in combination with -v.
|
||||
run_command(['zpool', 'list', '-vHPL', $name], outfunc => sub {
|
||||
my ($line) = @_;
|
||||
|
||||
my ($name) = PVE::Tools::split_list($line);
|
||||
return if $name !~ m|^/dev/.+|;
|
||||
|
||||
my $dev = PVE::Diskmanage::verify_blockdev_path($name);
|
||||
my $wipe = $dev;
|
||||
|
||||
$dev =~ s|^/dev/||;
|
||||
my $info = PVE::Diskmanage::get_disks($dev, 1, 1);
|
||||
die "unable to obtain information for disk '$dev'\n" if !$info->{$dev};
|
||||
|
||||
# Wipe whole disk if usual ZFS layout with partition 9 as ZFS reserved.
|
||||
my $parent = $info->{$dev}->{parent};
|
||||
if ($parent && scalar(keys $info->%*) == 3) {
|
||||
$parent =~ s|^/dev/||;
|
||||
my $info9 = $info->{"${parent}9"};
|
||||
|
||||
$wipe = $info->{$dev}->{parent} # need leading /dev/
|
||||
if $info9 && $info9->{used} && $info9->{used} =~ m/^ZFS reserved/;
|
||||
}
|
||||
|
||||
push $to_wipe->@*, $wipe;
|
||||
});
|
||||
}
|
||||
|
||||
if (-e '/lib/systemd/system/zfs-import@.service') {
|
||||
my $importunit = 'zfs-import@' . PVE::Systemd::escape_unit($name) . '.service';
|
||||
run_command(['systemctl', 'disable', $importunit]);
|
||||
}
|
||||
|
||||
run_command(['zpool', 'destroy', $name]);
|
||||
|
||||
my $config_err;
|
||||
if ($param->{'cleanup-config'}) {
|
||||
my $match = sub {
|
||||
my ($scfg) = @_;
|
||||
return $scfg->{type} eq 'zfspool' && $scfg->{pool} eq $name;
|
||||
};
|
||||
eval { PVE::API2::Storage::Config->cleanup_storages_for_node($match, $node); };
|
||||
warn $config_err = $@ if $@;
|
||||
}
|
||||
|
||||
eval { PVE::Diskmanage::wipe_blockdev($_) for $to_wipe->@*; };
|
||||
my $err = $@;
|
||||
PVE::Diskmanage::udevadm_trigger($to_wipe->@*);
|
||||
die "cleanup failed - $err" if $err;
|
||||
|
||||
die "config cleanup failed - $config_err" if $config_err;
|
||||
});
|
||||
};
|
||||
|
||||
return $rpcenv->fork_worker('zfsremove', $name, $user, $worker);
|
||||
}});
|
||||
|
||||
1;
|
||||
Reference in New Issue
Block a user