PVE/Storage/RBDPlugin.pm

   1 package PVE::Storage::RBDPlugin;
   2
   3 use strict;
   4 use warnings;
   5 use IO::File;
   6 use PVE::Tools qw(run_command trim);
   7 use PVE::Storage::Plugin;
   8 use PVE::JSONSchema qw(get_standard_option);
   9
  10 use base qw(PVE::Storage::Plugin);
  11
  12 my $rbd_cmd = sub {
  13     my ($scfg, $storeid, $op, @options) = @_;
  14
  15     my $monhost = $scfg->{monhost};
  16     $monhost =~ s/;/,/g;
  17
  18     my $cmd = ['/usr/bin/rbd', '-p', $scfg->{pool}, '-m', $monhost, '-n',
  19                "client.$scfg->{username}",
  20                '--keyring', "/etc/pve/priv/ceph/${storeid}.keyring",
  21                '--auth_supported', $scfg->{authsupported}, $op];
  22
  23     push @$cmd, @options if scalar(@options);
  24
  25     return $cmd;
  26 };
  27
  28 my $rados_cmd = sub {
  29     my ($scfg, $storeid, $op, @options) = @_;
  30
  31     my $monhost = $scfg->{monhost};
  32     $monhost =~ s/;/,/g;
  33
  34     my $cmd = ['/usr/bin/rados', '-p', $scfg->{pool}, '-m', $monhost, '-n',
  35                "client.$scfg->{username}",
  36                '--keyring', "/etc/pve/priv/ceph/${storeid}.keyring",
  37                '--auth_supported', $scfg->{authsupported}, $op];
  38
  39     push @$cmd, @options if scalar(@options);
  40
  41     return $cmd;
  42 };
  43
  44 sub rbd_ls {
  45     my ($scfg, $storeid) = @_;
  46
  47     my $cmd = &$rbd_cmd($scfg, $storeid, 'ls');
  48
  49     my $list = {};
  50
  51     my $parser = sub {
  52         my $line = shift;
  53
  54         if ($line =~ m/^(vm-(\d+)-\S+)$/) {
  55             my ($image, $owner) = ($1, $2);
  56
  57             $list->{$scfg->{pool}}->{$image} = {
  58                 name => $image,
  59                 size => 0,
  60                 vmid => $owner
  61             };
  62         }
  63     };
  64
  65     eval {
  66         run_command($cmd, errmsg => "rbd error", errfunc => sub {}, outfunc => $parser);
  67     };
  68     my $err = $@;
  69
  70     die $err if $err && $err !~ m/doesn't contain rbd images/ ;
  71
  72     return $list;
  73 }
  74
  75 sub addslashes {
  76     my $text = shift;
  77     $text =~ s/;/\\;/g;
  78     $text =~ s/:/\\:/g;
  79     return $text;
  80 }
  81
  82 # Configuration
  83
  84 PVE::JSONSchema::register_format('pve-storage-monhost', \&parse_monhost);
  85 sub parse_monhost {
  86     my ($name, $noerr) = @_;
  87
  88     if ($name !~ m/^[a-z][a-z0-9\-\_\.]*[a-z0-9]$/i) {
  89         return undef if $noerr;
  90         die "lvm name '$name' contains illegal characters\n";
  91     }
  92
  93     return $name;
  94 }
  95
  96 sub type {
  97     return 'rbd';
  98 }
  99
 100 sub plugindata {
 101     return {
 102         content => [ {images => 1}, { images => 1 }],
 103     };
 104 }
 105
 106 sub properties {
 107     return {
 108         monhost => {
 109             description => "Monitors daemon ips.",
 110             type => 'string',
 111         },
 112         pool => {
 113             description => "Pool.",
 114             type => 'string',
 115         },
 116         username => {
 117             description => "RBD Id.",
 118             type => 'string',
 119         },
 120         authsupported => {
 121             description => "Authsupported.",
 122             type => 'string',
 123         },
 124     };
 125 }
 126
 127 sub options {
 128     return {
 129         nodes => { optional => 1 },
 130         disable => { optional => 1 },
 131         monhost => { fixed => 1 },
 132         pool => { fixed => 1 },
 133         username => { fixed => 1 },
 134         authsupported => { fixed => 1 },
 135         content => { optional => 1 },
 136     };
 137 }
 138
 139 # Storage implementation
 140
 141 sub parse_volname {
 142     my ($class, $volname) = @_;
 143
 144     if ($volname =~ m/^(vm-(\d+)-\S+)$/) {
 145         return ('images', $1, $2);
 146     }
 147
 148     die "unable to parse rbd volume name '$volname'\n";
 149 }
 150
 151 sub path {
 152     my ($class, $scfg, $volname, $storeid) = @_;
 153
 154     my ($vtype, $name, $vmid) = $class->parse_volname($volname);
 155
 156     my $monhost = addslashes($scfg->{monhost});
 157     my $pool = $scfg->{pool};
 158     my $username = $scfg->{username};
 159     my $authsupported = addslashes($scfg->{authsupported});
 160
 161     my $path = "rbd:$pool/$name:id=$username:auth_supported=$authsupported:keyring=/etc/pve/priv/ceph/$storeid.keyring:mon_host=$monhost";
 162
 163     return ($path, $vmid, $vtype);
 164 }
 165
 166 sub alloc_image {
 167     my ($class, $storeid, $scfg, $vmid, $fmt, $name, $size) = @_;
 168
 169
 170     die "illegal name '$name' - sould be 'vm-$vmid-*'\n"
 171         if  $name && $name !~ m/^vm-$vmid-/;
 172
 173     if (!$name) {
 174         my $rdb = rbd_ls($scfg, $storeid);
 175
 176         for (my $i = 1; $i < 100; $i++) {
 177             my $tn = "vm-$vmid-disk-$i";
 178             if (!defined ($rdb->{$scfg->{pool}}->{$tn})) {
 179                 $name = $tn;
 180                 last;
 181             }
 182         }
 183     }
 184
 185     die "unable to allocate an image name for VM $vmid in storage '$storeid'\n"
 186         if !$name;
 187
 188     my $cmd = &$rbd_cmd($scfg, $storeid, 'create', '--size', ($size/1024), $name);
 189     run_command($cmd, errmsg => "rbd create $name' error", errfunc => sub {});
 190
 191     return $name;
 192 }
 193
 194 sub free_image {
 195     my ($class, $storeid, $scfg, $volname) = @_;
 196
 197     my $cmd = &$rbd_cmd($scfg, $storeid, 'rm', $volname);
 198     run_command($cmd, errmsg => "rbd rm $volname' error", outfunc => sub {}, errfunc => sub {});
 199
 200     return undef;
 201 }
 202
 203 sub list_images {
 204     my ($class, $storeid, $scfg, $vmid, $vollist, $cache) = @_;
 205
 206     $cache->{rbd} = rbd_ls($scfg, $storeid) if !$cache->{rbd};
 207
 208     my $res = [];
 209
 210     if (my $dat = $cache->{rbd}->{$scfg->{pool}}) {
 211         foreach my $image (keys %$dat) {
 212
 213             my $volname = $dat->{$image}->{name};
 214
 215             my $volid = "$storeid:$volname";
 216
 217             my $owner = $dat->{$volname}->{vmid};
 218             if ($vollist) {
 219                 my $found = grep { $_ eq $volid } @$vollist;
 220                 next if !$found;
 221             } else {
 222                 next if defined ($vmid) && ($owner ne $vmid);
 223             }
 224
 225             my $info = $dat->{$volname};
 226             $info->{volid} = $volid;
 227             $info->{format} = 'raw';
 228
 229             push @$res, $info;
 230         }
 231     }
 232
 233     return $res;
 234 }
 235
 236 sub status {
 237     my ($class, $storeid, $scfg, $cache) = @_;
 238
 239     my $cmd = &$rados_cmd($scfg, $storeid, 'df');
 240
 241     my $stats = {};
 242
 243     my $parser = sub {
 244         my $line = shift;
 245         if ($line =~ m/^\s+total\s(\S+)\s+(\d+)/) {
 246             $stats->{$1} = $2;
 247         }
 248     };
 249
 250     eval {
 251         run_command($cmd, errmsg => "rados error", errfunc => sub {}, outfunc => $parser);
 252     };
 253
 254     my $total = $stats->{space} ? $stats->{space}*1024 : 0;
 255     my $free = $stats->{avail} ? $stats->{avail}*1024 : 0;
 256     my $used = $stats->{used} ? $stats->{used}*1024: 0;
 257     my $active = 1;
 258
 259     return ($total, $free, $used, $active);
 260 }
 261
 262 sub activate_storage {
 263     my ($class, $storeid, $scfg, $cache) = @_;
 264     return 1;
 265 }
 266
 267 sub deactivate_storage {
 268     my ($class, $storeid, $scfg, $cache) = @_;
 269     return 1;
 270 }
 271
 272 sub activate_volume {
 273     my ($class, $storeid, $scfg, $volname, $exclusive, $cache) = @_;
 274     return 1;
 275 }
 276
 277 sub deactivate_volume {
 278     my ($class, $storeid, $scfg, $volname, $exclusive, $cache) = @_;
 279     return 1;
 280 }
 281
 282 sub volume_size_info {
 283     my ($class, $scfg, $storeid, $volname, $timeout) = @_;
 284
 285     my $cmd = &$rbd_cmd($scfg, $storeid, 'info', $volname);
 286     my $size = undef;
 287     my $parser = sub {
 288         my $line = shift;
 289
 290         if ($line =~ m/size (\d+) MB in (\d+) objects/) {
 291             $size = $1;
 292         }
 293     };
 294
 295     run_command($cmd, errmsg => "rbd error", errfunc => sub {}, outfunc => $parser);
 296
 297     $size = $size*1024*1024 if $size;
 298
 299     return $size;
 300 }
 301
 302 sub volume_resize {
 303     my ($class, $scfg, $storeid, $volname, $size, $running) = @_;
 304
 305     return 1 if $running;
 306
 307     my $cmd = &$rbd_cmd($scfg, $storeid, 'resize', '--size', ($size/1024/1024), $volname);
 308     run_command($cmd, errmsg => "rbd resize $volname' error", errfunc => sub {});
 309     return undef;
 310 }
 311
 312 sub volume_snapshot {
 313     my ($class, $scfg, $storeid, $volname, $snap, $running) = @_;
 314
 315     return 1 if $running;
 316
 317     my $cmd = &$rbd_cmd($scfg, $storeid, 'snap', 'create', '--snap', $snap, $volname);
 318     run_command($cmd, errmsg => "rbd snapshot $volname' error", errfunc => sub {});
 319     return undef;
 320 }
 321
 322 sub volume_snapshot_rollback {
 323     my ($class, $scfg, $storeid, $volname, $snap) = @_;
 324
 325     my $cmd = &$rbd_cmd($scfg, $storeid, 'snap', 'rollback', '--snap', $snap, $volname);
 326     run_command($cmd, errmsg => "rbd snapshot $volname to $snap' error", errfunc => sub {});
 327 }
 328
 329 sub volume_snapshot_delete {
 330     my ($class, $scfg, $storeid, $volname, $snap, $running) = @_;
 331
 332     return 1 if $running;
 333
 334     my $cmd = &$rbd_cmd($scfg, $storeid, 'snap', 'rm', '--snap', $snap, $volname);
 335     run_command($cmd, errmsg => "rbd snapshot $volname' error", errfunc => sub {});
 336     return undef;
 337 }
 338
 339 1;