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