[pve-storage.git] / pvesm

#!/usr/bin/perl

use strict;
use warnings;
use Getopt::Long;
use Fcntl ':flock';
use File::Path;

use PVE::SafeSyslog;
use PVE::Cluster;
use PVE::INotify;
use PVE::RPCEnvironment;
use PVE::Storage;
use PVE::API2::Storage::Config;
use PVE::API2::Storage::Content;
use PVE::API2::Storage::Status;
use PVE::API2::Storage::Scan;
use PVE::JSONSchema qw(get_standard_option);

use PVE::CLIHandler;

use base qw(PVE::CLIHandler);

$ENV{'PATH'} = '/sbin:/bin:/usr/sbin:/usr/bin';

initlog ('pvesm');

die "please run as root\n" if $> != 0;

PVE::INotify::inotify_init();

my $rpcenv = PVE::RPCEnvironment->init('cli');

$rpcenv->init_request();
$rpcenv->set_language($ENV{LANG});
$rpcenv->set_user('root@pam');

__PACKAGE__->register_method ({
    name => 'path',
    path => 'path',
    method => 'GET',
    description => "Get filesystem path for specified volume",
    parameters => {
    	additionalProperties => 0,
	properties => {
	    volume => {
		description => "Volume identifier",
		type => 'string', format => 'pve-volume-id',
	    },
	},
    },
    returns => { type => 'null' },

    code => sub {
	my ($param) = @_;

	my $cfg = PVE::Storage::config();

	my $path = PVE::Storage::path ($cfg, $param->{volume});

	print "$path\n";

	return undef;

    }});

my $print_content = sub {
    my ($list) = @_;

    my $maxlenname = 0;
    foreach my $info (@$list) {

	my $volid = $info->{volid};
	my $sidlen =  length ($volid);
	$maxlenname = $sidlen if $sidlen > $maxlenname;
    }

    foreach my $info (@$list) {
	next if !$info->{vmid};
	my $volid = $info->{volid};

	printf "%-${maxlenname}s %5s %10d %d\n", $volid,
	$info->{format}, $info->{size}, $info->{vmid};
    }

    foreach my $info (sort { $a->{format} cmp $b->{format} } @$list) {
	next if $info->{vmid};
	my $volid = $info->{volid};

	printf "%-${maxlenname}s %5s %10d\n", $volid,
	$info->{format}, $info->{size};
    }
};

my $print_status = sub {
    my $res = shift;

    my $maxlen = 0;
    foreach my $res (@$res) {
	my $storeid = $res->{storage};
	$maxlen = length ($storeid) if length ($storeid) > $maxlen;
    }
    $maxlen+=1;

    foreach my $res (sort { $a->{storage} cmp $b->{storage} } @$res) {
	my $storeid = $res->{storage};

	my $sum = $res->{used} + $res->{avail};
	my $per = $sum ? (0.5 + ($res->{used}*100)/$sum) : 100;

	printf "%-${maxlen}s %5s %1d %15d %15d %15d %.2f%%\n", $storeid,
	$res->{type}, $res->{active},
	$res->{total}/1024, $res->{used}/1024, $res->{avail}/1024, $per;
    }
};

my $nodename = PVE::INotify::nodename();

my $cmddef = {
    add => [ "PVE::API2::Storage::Config", 'create', ['type', 'storage'] ],
    set => [ "PVE::API2::Storage::Config", 'update', ['storage'] ],
    remove => [ "PVE::API2::Storage::Config", 'delete', ['storage'] ],
    status => [ "PVE::API2::Storage::Status", 'index', [],
		{ node => $nodename }, $print_status ],
    list => [ "PVE::API2::Storage::Content", 'index', ['storage'],
	      { node => $nodename }, $print_content ],
    alloc => [ "PVE::API2::Storage::Content", 'create', ['storage', 'vmid', 'filename', 'size'],
	       { node => $nodename }, sub {
		   my $volid = shift;
		   print "sucessfuly created '$volid'\n";
	       }],
    free => [ "PVE::API2::Storage::Content", 'delete', ['volume'],
	      { node => $nodename } ],
    nfsscan => [ "PVE::API2::Storage::Scan", 'nfsscan', ['server'],
		 { node => $nodename }, sub  {
		     my $res = shift;

		     my $maxlen = 0;
		     foreach my $rec (@$res) {
			 my $len = length ($rec->{path});
			 $maxlen = $len if $len > $maxlen;
		     }
		     foreach my $rec (@$res) {
			 printf "%-${maxlen}s %s\n", $rec->{path}, $rec->{options};
		     }
		 }],
    glusterfsscan => [ "PVE::API2::Storage::Scan", 'glusterfsscan', ['server'],
		 { node => $nodename }, sub  {
		     my $res = shift;

		     foreach my $rec (@$res) {
			 printf "%s\n", $rec->{volname};
		     }
		 }],
    iscsiscan => [ "PVE::API2::Storage::Scan", 'iscsiscan', ['server'],
		   { node => $nodename }, sub  {
		       my $res = shift;

		       my $maxlen = 0;
		       foreach my $rec (@$res) {
			   my $len = length ($rec->{target});
			   $maxlen = $len if $len > $maxlen;
		       }
		       foreach my $rec (@$res) {
			   printf "%-${maxlen}s %s\n", $rec->{target}, $rec->{portal};
		       }
		   }],
    lvmscan => [ "PVE::API2::Storage::Scan", 'lvmscan', [],
		 { node => $nodename }, sub  {
		     my $res = shift;
		     foreach my $rec (@$res) {
			 printf "$rec->{vg}\n";
		     }
		 }],
    zfsscan => [ "PVE::API2::Storage::Scan", 'zfsscan', [],
		 { node => $nodename }, sub  {
		     my $res = shift;

		     foreach my $rec (@$res) {
			 printf "$rec->{pool}\n";
		     }
		 }],
    path => [ __PACKAGE__, 'path', ['volume']],
};

my $cmd = shift;

PVE::CLIHandler::handle_cmd($cmddef, "pvesm", $cmd, \@ARGV, undef, $0);

exit 0;

__END__

=head1 NAME

pvesm - PVE Storage Manager

=head1 SYNOPSIS

=include synopsis

=head1 DESCRIPTION

=head2 Storage pools

Each storage pool is uniquely identified by its <STORAGE_ID>.

=head3 Storage content

A storage can support several content types, for example virtual disk
images, cdrom iso images, openvz templates or openvz root directories
(C<images>, C<iso>, C<vztmpl>, C<rootdir>).

=head2 Volumes

A volume is identified by the <STORAGE_ID>, followed by a storage type
dependent volume name, separated by colon. A valid <VOLUME_ID> looks like:

 local:230/example-image.raw

 local:iso/debian-501-amd64-netinst.iso

 local:vztmpl/debian-5.0-joomla_1.5.9-1_i386.tar.gz

 iscsi-storage:0.0.2.scsi-14f504e46494c4500494b5042546d2d646744372d31616d61

To get the filesystem path for a <VOLUME_ID> use:

 pvesm path <VOLUME_ID>


=head1 EXAMPLES

 # scan iscsi host for available targets
 pvesm iscsiscan -portal <HOST[:PORT]>

 # scan nfs server for available exports
 pvesm nfsscan <HOST>

 # add storage pools
 pvesm add <TYPE> <STORAGE_ID> <OPTIONS>
 pvesm add dir <STORAGE_ID> --path <PATH>
 pvesm add nfs <STORAGE_ID> --path <PATH> --server <SERVER> --export <EXPORT>
 pvesm add lvm <STORAGE_ID> --vgname <VGNAME>
 pvesm add iscsi <STORAGE_ID> --portal <HOST[:PORT]> --target <TARGET>

 # disable storage pools
 pvesm set <STORAGE_ID> --disable 1

 # enable storage pools
 pvesm set <STORAGE_ID> --disable 0

 # change/set storage options
 pvesm set <STORAGE_ID> <OPTIONS>
 pvesm set <STORAGE_ID> --shared 1
 pvesm set local --format qcow2
 pvesm set <STORAGE_ID> --content iso

 # remove storage pools - does not delete any data
 pvesm remove <STORAGE_ID>

 # alloc volumes
 pvesm alloc <STORAGE_ID> <VMID> <name> <size> [--format <raw|qcow2>]

 # alloc 4G volume in local storage - use auto generated name
 pvesm alloc local <VMID> '' 4G

 # free volumes (warning: destroy/deletes all volume data)
 pvesm free <VOLUME_ID>

 # list storage status
 pvesm status

 # list storage contents
 pvesm list <STORAGE_ID> [--vmid <VMID>]

 # list volumes allocated by VMID
 pvesm list <STORAGE_ID> --vmid <VMID>

 # list iso images
 pvesm list <STORAGE_ID> --iso

 # list openvz templates
 pvesm list <STORAGE_ID> --vztmpl

 # show filesystem path for a volume
 pvesm path <VOLUME_ID>

=include pve_copyright
Commit	Line	Data
ffd6f2f3	1	#!/usr/bin/perl
b6cf0a66 DM	2
b6cf0a66 DM	3	use strict;
ffd6f2f3	4	use warnings;
b6cf0a66 DM	5	use Getopt::Long;
	6	use Fcntl ':flock';
	7	use File::Path;
	8
	9	use PVE::SafeSyslog;
	10	use PVE::Cluster;
	11	use PVE::INotify;
	12	use PVE::RPCEnvironment;
	13	use PVE::Storage;
	14	use PVE::API2::Storage::Config;
	15	use PVE::API2::Storage::Content;
	16	use PVE::API2::Storage::Status;
	17	use PVE::API2::Storage::Scan;
	18	use PVE::JSONSchema qw(get_standard_option);
	19
	20	use PVE::CLIHandler;
	21
	22	use base qw(PVE::CLIHandler);
	23
	24	$ENV{'PATH'} = '/sbin:/bin:/usr/sbin:/usr/bin';
	25
	26	initlog ('pvesm');
	27
	28	die "please run as root\n" if $> != 0;
	29
	30	PVE::INotify::inotify_init();
	31
	32	my $rpcenv = PVE::RPCEnvironment->init('cli');
	33
	34	$rpcenv->init_request();
	35	$rpcenv->set_language($ENV{LANG});
630f436a	36	$rpcenv->set_user('root@pam');
b6cf0a66 DM	37
b6cf0a66 DM	38	__PACKAGE__->register_method ({
630f436a	39	name => 'path',
b6cf0a66 DM	40	path => 'path',
	41	method => 'GET',
	42	description => "Get filesystem path for specified volume",
	43	parameters => {
	44	additionalProperties => 0,
	45	properties => {
	46	volume => {
	47	description => "Volume identifier",
	48	type => 'string', format => 'pve-volume-id',
	49	},
	50	},
	51	},
	52	returns => { type => 'null' },
630f436a	53
b6cf0a66 DM	54	code => sub {
	55	my ($param) = @_;
	56
	57	my $cfg = PVE::Storage::config();
	58
	59	my $path = PVE::Storage::path ($cfg, $param->{volume});
	60
	61	print "$path\n";
	62
	63	return undef;
	64
	65	}});
	66
	67	my $print_content = sub {
	68	my ($list) = @_;
	69
	70	my $maxlenname = 0;
	71	foreach my $info (@$list) {
	72
	73	my $volid = $info->{volid};
	74	my $sidlen = length ($volid);
	75	$maxlenname = $sidlen if $sidlen > $maxlenname;
	76	}
	77
	78	foreach my $info (@$list) {
	79	next if !$info->{vmid};
	80	my $volid = $info->{volid};
	81
630f436a DM	82	printf "%-${maxlenname}s %5s %10d %d\n", $volid,
630f436a DM	83	$info->{format}, $info->{size}, $info->{vmid};
b6cf0a66 DM	84	}
	85
	86	foreach my $info (sort { $a->{format} cmp $b->{format} } @$list) {
	87	next if $info->{vmid};
	88	my $volid = $info->{volid};
	89
630f436a DM	90	printf "%-${maxlenname}s %5s %10d\n", $volid,
630f436a DM	91	$info->{format}, $info->{size};
b6cf0a66 DM	92	}
	93	};
	94
	95	my $print_status = sub {
	96	my $res = shift;
	97
	98	my $maxlen = 0;
	99	foreach my $res (@$res) {
	100	my $storeid = $res->{storage};
	101	$maxlen = length ($storeid) if length ($storeid) > $maxlen;
	102	}
	103	$maxlen+=1;
630f436a	104
b6cf0a66 DM	105	foreach my $res (sort { $a->{storage} cmp $b->{storage} } @$res) {
	106	my $storeid = $res->{storage};
	107
	108	my $sum = $res->{used} + $res->{avail};
	109	my $per = $sum ? (0.5 + ($res->{used}*100)/$sum) : 100;
	110
630f436a	111	printf "%-${maxlen}s %5s %1d %15d %15d %15d %.2f%%\n", $storeid,
b6cf0a66	112	$res->{type}, $res->{active},
630f436a	113	$res->{total}/1024, $res->{used}/1024, $res->{avail}/1024, $per;
b6cf0a66 DM	114	}
	115	};
	116
	117	my $nodename = PVE::INotify::nodename();
	118
	119	my $cmddef = {
6ec76eec	120	add => [ "PVE::API2::Storage::Config", 'create', ['type', 'storage'] ],
b6cf0a66 DM	121	set => [ "PVE::API2::Storage::Config", 'update', ['storage'] ],
b6cf0a66 DM	122	remove => [ "PVE::API2::Storage::Config", 'delete', ['storage'] ],
630f436a	123	status => [ "PVE::API2::Storage::Status", 'index', [],
b6cf0a66	124	{ node => $nodename }, $print_status ],
630f436a	125	list => [ "PVE::API2::Storage::Content", 'index', ['storage'],
b6cf0a66	126	{ node => $nodename }, $print_content ],
630f436a	127	alloc => [ "PVE::API2::Storage::Content", 'create', ['storage', 'vmid', 'filename', 'size'],
b6cf0a66 DM	128	{ node => $nodename }, sub {
	129	my $volid = shift;
	130	print "sucessfuly created '$volid'\n";
	131	}],
	132	free => [ "PVE::API2::Storage::Content", 'delete', ['volume'],
	133	{ node => $nodename } ],
	134	nfsscan => [ "PVE::API2::Storage::Scan", 'nfsscan', ['server'],
	135	{ node => $nodename }, sub {
	136	my $res = shift;
	137
	138	my $maxlen = 0;
	139	foreach my $rec (@$res) {
	140	my $len = length ($rec->{path});
	141	$maxlen = $len if $len > $maxlen;
	142	}
	143	foreach my $rec (@$res) {
	144	printf "%-${maxlen}s %s\n", $rec->{path}, $rec->{options};
	145	}
3cf5e19e DM	146	}],
	147	glusterfsscan => [ "PVE::API2::Storage::Scan", 'glusterfsscan', ['server'],
	148	{ node => $nodename }, sub {
	149	my $res = shift;
	150
	151	foreach my $rec (@$res) {
	152	printf "%s\n", $rec->{volname};
	153	}
b6cf0a66 DM	154	}],
	155	iscsiscan => [ "PVE::API2::Storage::Scan", 'iscsiscan', ['server'],
	156	{ node => $nodename }, sub {
	157	my $res = shift;
	158
	159	my $maxlen = 0;
	160	foreach my $rec (@$res) {
	161	my $len = length ($rec->{target});
	162	$maxlen = $len if $len > $maxlen;
	163	}
	164	foreach my $rec (@$res) {
	165	printf "%-${maxlen}s %s\n", $rec->{target}, $rec->{portal};
	166	}
	167	}],
	168	lvmscan => [ "PVE::API2::Storage::Scan", 'lvmscan', [],
	169	{ node => $nodename }, sub {
	170	my $res = shift;
	171	foreach my $rec (@$res) {
	172	printf "$rec->{vg}\n";
	173	}
	174	}],
584d97f6 DM	175	zfsscan => [ "PVE::API2::Storage::Scan", 'zfsscan', [],
	176	{ node => $nodename }, sub {
	177	my $res = shift;
	178
	179	foreach my $rec (@$res) {
	180	printf "$rec->{pool}\n";
	181	}
	182	}],
b6cf0a66 DM	183	path => [ __PACKAGE__, 'path', ['volume']],
	184	};
	185
	186	my $cmd = shift;
	187
630f436a	188	PVE::CLIHandler::handle_cmd($cmddef, "pvesm", $cmd, \@ARGV, undef, $0);
b6cf0a66 DM	189
	190	exit 0;
	191
	192	__END__
	193
	194	=head1 NAME
	195
	196	pvesm - PVE Storage Manager
	197
	198	=head1 SYNOPSIS
	199
630f436a	200	=include synopsis
b6cf0a66	201
630f436a	202	=head1 DESCRIPTION
b6cf0a66	203
630f436a	204	=head2 Storage pools
b6cf0a66	205
630f436a	206	Each storage pool is uniquely identified by its <STORAGE_ID>.
b6cf0a66	207
630f436a	208	=head3 Storage content
b6cf0a66	209
630f436a DM	210	A storage can support several content types, for example virtual disk
	211	images, cdrom iso images, openvz templates or openvz root directories
	212	(C<images>, C<iso>, C<vztmpl>, C<rootdir>).
b6cf0a66	213
630f436a	214	=head2 Volumes
b6cf0a66	215
630f436a DM	216	A volume is identified by the <STORAGE_ID>, followed by a storage type
630f436a DM	217	dependent volume name, separated by colon. A valid <VOLUME_ID> looks like:
b6cf0a66	218
630f436a	219	local:230/example-image.raw
b6cf0a66	220
630f436a	221	local:iso/debian-501-amd64-netinst.iso
b6cf0a66	222
630f436a	223	local:vztmpl/debian-5.0-joomla_1.5.9-1_i386.tar.gz
b6cf0a66	224
630f436a	225	iscsi-storage:0.0.2.scsi-14f504e46494c4500494b5042546d2d646744372d31616d61
b6cf0a66	226
630f436a	227	To get the filesystem path for a <VOLUME_ID> use:
b6cf0a66	228
630f436a	229	pvesm path <VOLUME_ID>
b6cf0a66	230
b6cf0a66	231
630f436a	232	=head1 EXAMPLES
b6cf0a66	233
630f436a	234	# scan iscsi host for available targets
c1d4b2fd	235	pvesm iscsiscan -portal <HOST[:PORT]>
b6cf0a66	236
630f436a	237	# scan nfs server for available exports
c1d4b2fd	238	pvesm nfsscan <HOST>
b6cf0a66	239
630f436a	240	# add storage pools
6ec76eec DM	241	pvesm add <TYPE> <STORAGE_ID> <OPTIONS>
	242	pvesm add dir <STORAGE_ID> --path <PATH>
	243	pvesm add nfs <STORAGE_ID> --path <PATH> --server <SERVER> --export <EXPORT>
	244	pvesm add lvm <STORAGE_ID> --vgname <VGNAME>
	245	pvesm add iscsi <STORAGE_ID> --portal <HOST[:PORT]> --target <TARGET>
b6cf0a66	246
630f436a DM	247	# disable storage pools
630f436a DM	248	pvesm set <STORAGE_ID> --disable 1
b6cf0a66	249
630f436a DM	250	# enable storage pools
630f436a DM	251	pvesm set <STORAGE_ID> --disable 0
b6cf0a66	252
630f436a DM	253	# change/set storage options
	254	pvesm set <STORAGE_ID> <OPTIONS>
	255	pvesm set <STORAGE_ID> --shared 1
	256	pvesm set local --format qcow2
	257	pvesm set <STORAGE_ID> --content iso
b6cf0a66	258
630f436a DM	259	# remove storage pools - does not delete any data
630f436a DM	260	pvesm remove <STORAGE_ID>
b6cf0a66	261
630f436a DM	262	# alloc volumes
630f436a DM	263	pvesm alloc <STORAGE_ID> <VMID> <name> <size> [--format <raw\|qcow2>]
b6cf0a66	264
630f436a DM	265	# alloc 4G volume in local storage - use auto generated name
630f436a DM	266	pvesm alloc local <VMID> '' 4G
b6cf0a66	267
630f436a DM	268	# free volumes (warning: destroy/deletes all volume data)
630f436a DM	269	pvesm free <VOLUME_ID>
b6cf0a66	270
630f436a DM	271	# list storage status
630f436a DM	272	pvesm status
b6cf0a66	273
630f436a DM	274	# list storage contents
630f436a DM	275	pvesm list <STORAGE_ID> [--vmid <VMID>]
b6cf0a66	276
630f436a DM	277	# list volumes allocated by VMID
630f436a DM	278	pvesm list <STORAGE_ID> --vmid <VMID>
b6cf0a66	279
630f436a DM	280	# list iso images
630f436a DM	281	pvesm list <STORAGE_ID> --iso
b6cf0a66	282
630f436a DM	283	# list openvz templates
	284	pvesm list <STORAGE_ID> --vztmpl
	285
	286	# show filesystem path for a volume
b6cf0a66 DM	287	pvesm path <VOLUME_ID>
b6cf0a66 DM	288
630f436a	289	=include pve_copyright