disk manage: draid: style clean ups

[pve-storage.git] / PVE / API2 / Disks / ZFS.pm

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;