PVE/Storage/SheepdogPlugin.pm

   1 package PVE::Storage::SheepdogPlugin;
   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 $collie_cmd = sub {
  13     my ($scfg, $class, $op, @options) = @_;
  14
  15     my $portal = $scfg->{portal};
  16     my ($server, $port) = split(':', $portal);
  17     my $cmd = ['/usr/sbin/collie', $class, $op, '-a', $server];
  18     push @$cmd, '-p', $port if $port;
  19
  20     push @$cmd, @options if scalar(@options);
  21
  22     return $cmd;
  23 };
  24
  25 sub sheepdog_ls {
  26     my ($scfg, $storeid) = @_;
  27
  28     my $cmd = &$collie_cmd($scfg, 'vdi', 'graph');
  29
  30     my $relationship = {};
  31     my $child = undef;
  32
  33     run_command($cmd, outfunc => sub {
  34         my $line = shift;
  35
  36         my $parent = undef;
  37         my $name = undef;
  38
  39         $line = trim($line);
  40
  41         if ($line =~ /\"(\S+)\"\s->\s\"(\S+)\"/) {
  42             $parent = $1;
  43             $child = $2;
  44             $relationship->{$child}->{parent} = $parent;
  45         }
  46         elsif ($line =~ /group\s\=\s\"(\S+)\",/) {
  47             $name = $1;
  48             $relationship->{$child}->{name} = $name if $child;
  49
  50         }
  51
  52     });
  53
  54
  55     $cmd = &$collie_cmd($scfg, 'vdi', 'list', '-r');
  56
  57     my $list = {};
  58
  59     run_command($cmd, outfunc => sub {
  60         my $line = shift;
  61         $line = trim($line);
  62         if ($line =~ /(=|c) ((vm|base)-(\d+)-\S+)\s+(\d+)\s+(\d+)\s(\d+)\s(\d+)\s(\d+)\s(\S+)\s(\d+)/) {
  63             my $image = $2;
  64             my $owner = $4;
  65             my $size = $5;
  66             my $idvdi = $10;
  67             my $parentid = $relationship->{$idvdi}->{parent} if $relationship->{$idvdi}->{parent};
  68             my $parent = $relationship->{$parentid}->{name} if $parentid;
  69             $list->{$storeid}->{$image} = {
  70                 name => $image,
  71                 size => $size,
  72                 parent => $parent,
  73                 vmid => $owner
  74             };
  75         }
  76     });
  77
  78     return $list;
  79 }
  80
  81 sub sheepdog_snapshot_ls {
  82     my ($scfg, $volname) = @_;
  83
  84     my $cmd = &$collie_cmd($scfg, 'vdi', 'list', '-r');
  85
  86     my $list = {};
  87     run_command($cmd, outfunc => sub {
  88         my $line = shift;
  89         $line = trim($line);
  90         if ($line =~ m/s $volname (\d+) (\d+) (\d+) (\d+) (\d+) (\S+) (\d+) (\S+)/) {
  91             $list->{$8} = 1;
  92         }
  93     });
  94
  95     return $list;
  96 }
  97
  98 # Configuration
  99
 100
 101 sub type {
 102     return 'sheepdog';
 103 }
 104
 105 sub plugindata {
 106     return {
 107         content => [ {images => 1}, { images => 1 }],
 108     };
 109 }
 110
 111
 112 sub options {
 113     return {
 114         nodes => { optional => 1 },
 115         disable => { optional => 1 },
 116         portal => { fixed => 1 },
 117         content => { optional => 1 },
 118     };
 119 }
 120
 121 # Storage implementation
 122
 123 sub parse_volname {
 124     my ($class, $volname) = @_;
 125
 126     if ($volname =~ m/^((base-(\d+)-\S+)\/)?((base)?(vm)?-(\d+)-\S+)$/) {
 127         return ('images', $4, $7, $2, $3, $5);
 128     }
 129
 130     die "unable to parse rbd volume name '$volname'\n";
 131 }
 132
 133 sub path {
 134     my ($class, $scfg, $volname, $storeid) = @_;
 135
 136     my ($vtype, $name, $vmid) = $class->parse_volname($volname);
 137
 138     my $portal = $scfg->{portal};
 139     my ($server, $port) = split(':', $portal);
 140     $port = 7000 if !$port;
 141
 142     my $path = "sheepdog:$server:$port:$name";
 143
 144     return ($path, $vmid, $vtype);
 145 }
 146
 147 my $find_free_diskname = sub {
 148     my ($storeid, $scfg, $vmid) = @_;
 149
 150     my $sheepdog = sheepdog_ls($scfg, $storeid);
 151     my $dat = $sheepdog->{sheepdog};
 152     my $disk_ids = {};
 153
 154     foreach my $image (keys %$dat) {
 155         my $volname = $dat->{$image}->{name};
 156         if ($volname =~ m/(vm|base)-$vmid-disk-(\d+)/){
 157             $disk_ids->{$2} = 1;
 158         }
 159     }
 160
 161     for (my $i = 1; $i < 100; $i++) {
 162         if (!$disk_ids->{$i}) {
 163             return "vm-$vmid-disk-$i";
 164         }
 165     }
 166
 167     die "unable to allocate an image name for VM $vmid in storage '$storeid'\n";
 168 };
 169
 170 sub create_base {
 171     my ($class, $storeid, $scfg, $volname) = @_;
 172
 173     my $snap = '__base__';
 174
 175     my ($vtype, $name, $vmid, $basename, $basevmid, $isBase) =
 176         $class->parse_volname($volname);
 177
 178     die "create_base not possible with base image\n" if $isBase;
 179
 180     my $sheepdog = sheepdog_ls($scfg, $storeid);
 181     die "sheepdog volume info on '$name' failed\n" if !($sheepdog->{sheepdog}->{$name});
 182     my $parent = $sheepdog->{sheepdog}->{$name}->{parent};
 183
 184     die "volname '$volname' contains wrong information about parent $parent $basename\n"
 185         if $basename && (!$parent || $parent ne $basename);
 186
 187     my $newname = $name;
 188     $newname =~ s/^vm-/base-/;
 189
 190     my $newvolname = $basename ? "$basename/$newname" : "$newname";
 191
 192     #sheepdog can't rename, so we clone then delete the parent
 193
 194     my $tempsnap = '__tempforbase__';
 195
 196     my $cmd = &$collie_cmd($scfg, 'vdi', 'snapshot', '-s', $tempsnap, $name);
 197     run_command($cmd, errmsg => "sheepdog snapshot $volname' error");
 198
 199     $cmd = &$collie_cmd($scfg, 'vdi', 'clone', '-s', $tempsnap, $name, $newname);
 200     run_command($cmd, errmsg => "sheepdog clone $volname' error");
 201
 202     $cmd = &$collie_cmd($scfg, 'vdi', 'delete', '-s', $tempsnap, $name);
 203     run_command($cmd, errmsg => "sheepdog delete snapshot $volname' error");
 204
 205     $cmd = &$collie_cmd($scfg, 'vdi', 'delete' , $name);
 206     run_command($cmd, errmsg => "sheepdog delete $volname' error");
 207
 208     #create the base snapshot
 209     my $running  = undef; #fixme : is create_base always offline ?
 210
 211     $class->volume_snapshot($scfg, $storeid, $newname, $snap, $running);
 212
 213     return $newvolname;
 214 }
 215
 216 sub clone_image {
 217     my ($class, $scfg, $storeid, $volname, $vmid) = @_;
 218
 219     my $snap = '__base__';
 220
 221     my ($vtype, $basename, $basevmid, undef, undef, $isBase) =
 222         $class->parse_volname($volname);
 223
 224     die "clone_image only works on base images\n" if !$isBase;
 225
 226     my $name = &$find_free_diskname($storeid, $scfg, $vmid);
 227
 228     warn "clone $volname: $basename to $name\n";
 229
 230     my $newvol = "$basename/$name";
 231
 232     my $cmd = &$collie_cmd($scfg, 'vdi', 'clone', '-s', $snap, $basename, $name);
 233     run_command($cmd, errmsg => "sheepdog clone $volname' error");
 234
 235     return $newvol;
 236 }
 237
 238 sub alloc_image {
 239     my ($class, $storeid, $scfg, $vmid, $fmt, $name, $size) = @_;
 240
 241     die "illegal name '$name' - sould be 'vm-$vmid-*'\n"
 242         if  $name && $name !~ m/^vm-$vmid-/;
 243
 244     $name = &$find_free_diskname($storeid, $scfg, $vmid);
 245
 246     my $cmd = &$collie_cmd($scfg, 'vdi', 'create', $name , "${size}KB");
 247
 248     run_command($cmd, errmsg => "sheepdog create $name' error");
 249
 250     return $name;
 251 }
 252
 253 sub free_image {
 254     my ($class, $storeid, $scfg, $volname, $isBase) = @_;
 255
 256     my ($vtype, $name, $vmid, undef, undef, undef) =
 257         $class->parse_volname($volname);
 258
 259     my $snapshots = sheepdog_snapshot_ls($scfg, $name);
 260     while (my ($snapname) = each %$snapshots) {
 261         my $cmd = &$collie_cmd($scfg, 'vdi', 'delete' , '-s', $snapname, $name);
 262         run_command($cmd, errmsg => "sheepdog delete snapshot $snapname $name' error");
 263     }
 264
 265     my $cmd = &$collie_cmd($scfg, 'vdi', 'delete' , $name);
 266
 267     run_command($cmd, errmsg => "sheepdog delete $name' error");
 268
 269     return undef;
 270 }
 271
 272 sub list_images {
 273     my ($class, $storeid, $scfg, $vmid, $vollist, $cache) = @_;
 274
 275     $cache->{sheepdog} = sheepdog_ls($scfg, $storeid) if !$cache->{sheepdog};
 276     my $res = [];
 277
 278     if (my $dat = $cache->{sheepdog}->{$storeid}) {
 279         foreach my $image (keys %$dat) {
 280
 281             my $volname = $dat->{$image}->{name};
 282             my $parent = $dat->{$image}->{parent};
 283
 284             my $volid = undef;
 285             if ($parent && $parent ne $volname) {
 286                 $volid = "$storeid:$parent/$volname";
 287             } else {
 288                 $volid = "$storeid:$volname";
 289             }
 290
 291             my $owner = $dat->{$volname}->{vmid};
 292             if ($vollist) {
 293                 my $found = grep { $_ eq $volid } @$vollist;
 294                 next if !$found;
 295             } else {
 296                 next if defined ($vmid) && ($owner ne $vmid);
 297             }
 298
 299             my $info = $dat->{$volname};
 300             $info->{volid} = $volid;
 301             $info->{format} = 'raw';
 302             push @$res, $info;
 303         }
 304     }
 305
 306    return $res;
 307 }
 308
 309
 310 sub status {
 311     my ($class, $storeid, $scfg, $cache) = @_;
 312
 313     my $total = 0;
 314     my $free = 0;
 315     my $used = 0;
 316     my $active = 1;
 317
 318     my $cmd = &$collie_cmd($scfg, 'node', 'info' , '-r');
 319
 320     my $parser = sub {
 321         my $line = shift;
 322         if ($line =~ m/^Total\s(\d+)\s(\d+)\s/) {
 323             $total = $1;
 324             $used = $2;
 325             $free = $total - $used;
 326         }
 327     };
 328
 329     run_command($cmd, outfunc => $parser, errmsg => "sheepdog node info error");
 330
 331     return ($total,$free,$used,$active);
 332
 333     return undef;
 334 }
 335
 336 sub activate_storage {
 337     my ($class, $storeid, $scfg, $cache) = @_;
 338     return 1;
 339 }
 340
 341 sub deactivate_storage {
 342     my ($class, $storeid, $scfg, $cache) = @_;
 343     return 1;
 344 }
 345
 346 sub activate_volume {
 347     my ($class, $storeid, $scfg, $volname, $exclusive, $cache) = @_;
 348     return 1;
 349 }
 350
 351 sub deactivate_volume {
 352     my ($class, $storeid, $scfg, $volname, $exclusive, $cache) = @_;
 353     return 1;
 354 }
 355
 356 sub volume_size_info {
 357     my ($class, $scfg, $storeid, $volname, $timeout) = @_;
 358
 359     my ($vtype, $name, $vmid, $basename, $basevmid, $isBase) =
 360         $class->parse_volname($volname);
 361
 362     my $size = undef;
 363
 364     my $cmd = &$collie_cmd($scfg, 'vdi', 'list', '-r');
 365
 366     run_command($cmd, outfunc => sub {
 367         my $line = shift;
 368         $line = trim($line);
 369         if ($line =~ /(=|c) $name\s+(\d+)\s+(\d+)\s(\d+)\s(\d+)\s/) {
 370             $size = $3;
 371
 372         }
 373     });
 374
 375     return $size;
 376 }
 377
 378 sub volume_resize {
 379     my ($class, $scfg, $storeid, $volname, $size, $running) = @_;
 380
 381     my ($vtype, $name, $vmid, $basename, $basevmid, $isBase) =
 382         $class->parse_volname($volname);
 383
 384     my $cmd = &$collie_cmd($scfg, 'vdi', 'resize' , $name, $size);
 385     run_command($cmd, errmsg => "sheepdog resize $name' error");
 386
 387     return undef;
 388 }
 389
 390 sub volume_snapshot {
 391     my ($class, $scfg, $storeid, $volname, $snap, $running) = @_;
 392
 393     return 1 if $running;
 394
 395     my ($vtype, $name, $vmid, $basename, $basevmid, $isBase) =
 396         $class->parse_volname($volname);
 397
 398     my $cmd = &$collie_cmd($scfg, 'vdi', 'snapshot', '-s', $snap, $name);
 399     run_command($cmd, errmsg => "sheepdog snapshot $volname' error");
 400
 401     return undef;
 402 }
 403
 404 sub volume_snapshot_rollback {
 405     my ($class, $scfg, $storeid, $volname, $snap) = @_;
 406
 407     my ($vtype, $name, $vmid, $basename, $basevmid, $isBase) =
 408         $class->parse_volname($volname);
 409
 410     my $cmd = &$collie_cmd($scfg, 'vdi', 'rollback', '-s', $snap, $name);
 411     run_command($cmd, errmsg => "sheepdog snapshot $name' error");
 412
 413 }
 414
 415 sub volume_snapshot_delete {
 416     my ($class, $scfg, $storeid, $volname, $snap, $running) = @_;
 417
 418     return 1 if $running;
 419
 420     my ($vtype, $name, $vmid, $basename, $basevmid, $isBase) =
 421         $class->parse_volname($volname);
 422
 423     my $cmd = &$collie_cmd($scfg, 'vdi', 'delete', '-s', $snap, $name);
 424     run_command($cmd, errmsg => "sheepdog snapshot $name' error");
 425
 426     return undef;
 427 }
 428
 429 sub volume_has_feature {
 430     my ($class, $scfg, $feature, $storeid, $volname, $snapname, $running) = @_;
 431
 432     my $features = {
 433         snapshot => { current => 1, snap => 1},
 434         clone => { snap => 1},
 435     };
 436
 437     my $snap = $snapname ? 'snap' : 'current';
 438     return 1 if $features->{$feature}->{$snap};
 439
 440     return undef;
 441 }
 442
 443 1;