src/Utils.php

   1 <?php
   2 require_once("Exception.php");
   3 require_once("openmediavault/util.inc");
   4 require_once("Dataset.php");
   5 require_once("Zvol.php");
   6 require_once("Vdev.php");
   7 require_once("Zpool.php");
   8
   9 /**
  10  * Helper class for ZFS module
  11  */
  12 class OMVModuleZFSUtil {
  13
  14         /**
  15          * Manages relocation of ZFS filesystem mountpoints in the OMV backend.
  16          * Needed when the user changes mountpoint of a filesystem in the GUI.
  17          *
  18          */
  19         public static function relocateFilesystem($name) {
  20                 global $xmlConfig;
  21                 $poolname = OMVModuleZFSUtil::getPoolname($name);
  22                 $pooluuid = OMVModuleZFSUtil::getUUIDbyName($poolname);
  23                 $ds = new OMVModuleZFSDataset($name);
  24                 $dir = $ds->getMountPoint();
  25                 $xpath = "//system/fstab/mntent[fsname='" . $pooluuid . "' and dir='" . $dir . "' and type='zfs']";
  26                 $object = $xmlConfig->get($xpath);
  27                 $object['dir'] = $property['value'];
  28                 $xmlConfig->replace($xpath, $object);
  29                 return null;
  30         }
  31
  32         /**
  33          * Clears all ZFS labels on specified devices.
  34          * Needed for blkid to display proper data.
  35          *
  36          */
  37         public static function clearZFSLabel($disks) {
  38                 foreach ($disks as $disk) {
  39                         $cmd = "zpool labelclear /dev/" . $disk . "1";
  40                         OMVModuleZFSUtil::exec($cmd,$out,$res);
  41                 }
  42                 return null;
  43         }
  44
  45         /**
  46          * Return all disks in /dev/sdXX used by the pool
  47          *
  48          * @return array An array with all the disks
  49          */
  50         public static function getDevDisksByPool($name) {
  51                 $pool = new OMVModuleZFSZpool($name);
  52                 $disks = array();
  53                 $vdevs = $pool->getVdevs();
  54                 foreach ($vdevs as $vdev) {
  55                         $vdisks = $vdev->getDisks();
  56                         foreach ($vdisks as $vdisk) {
  57                                 if (preg_match('/^[a-z0-9]+$/', $vdisk)) {
  58                                         $disks[] = $vdisk;
  59                                         continue;
  60                                 }
  61                                 $cmd = "ls -la /dev/disk/by-path/" . $vdisk;
  62                                 unset($out);
  63                                 OMVModuleZFSUtil::exec($cmd,$out,$res);
  64                                 if (count($out) === 1) {
  65                                         if (preg_match('/^.*\/([a-z0-9]+)$/', $out[0], $match)) {
  66                                                 $disks[] = $match[1];
  67                                         }
  68                                 }
  69                         }
  70                 }
  71                 return($disks);
  72         }
  73
  74         /**
  75          * Deletes all shared folders pointing to the specifc path
  76          *
  77          */
  78         public static function deleteShares($name) {
  79                 global $xmlConfig;
  80                 $poolname = OMVModuleZFSUtil::getPoolname($name);
  81                 $pooluuid = OMVModuleZFSUtil::getUUIDbyName($poolname);
  82                 $ds = new OMVModuleZFSDataset($name);
  83                 $dir = $ds->getMountPoint();
  84                 $xpath = "//system/fstab/mntent[fsname='" . $pooluuid . "' and dir='" . $dir . "' and type='zfs']";
  85                 $mountpoint = $xmlConfig->get($xpath);
  86                 $mntentuuid = $mountpoint['uuid'];
  87                 $xpath = "//system/shares/sharedfolder[mntentref='" . $mntentuuid . "']";
  88                 $objects = $xmlConfig->getList($xpath);
  89                 foreach ($objects as $object) {
  90                         $tmpxpath = sprintf("//*[contains(name(),'sharedfolderref')]".
  91                                 "[contains(.,'%s')]", $object['uuid']);
  92                         if ($xmlConfig->exists($tmpxpath)) {
  93                                 throw new OMVModuleZFSException("The Filesystem is shared and in use. Please delete all references and try again.");
  94                         }
  95                 }
  96                 $xmlConfig->delete($xpath);
  97                 $dispatcher = &OMVNotifyDispatcher::getInstance();
  98                 $dispatcher->notify(OMV_NOTIFY_DELETE,"org.openmediavault.system.shares.sharedfolder",$object);
  99         }
 100
 101         /**
 102          * Get the relative path by complete path
 103          *
 104          * @return string Relative path of the complet path
 105          */
 106         public static function getReldirpath($path) {
 107                 $subdirs = preg_split('/\//',$path);
 108                 $reldirpath = "";
 109                 for ($i=2;$i<count($subdirs);$i++) {
 110                         $reldirpath .= $subdirs[$i] . "/";
 111                 }
 112                 return(rtrim($reldirpath, "/"));
 113
 114         }
 115
 116         /**
 117          * Get /dev/disk/by-path from /dev/sdX
 118          *
 119          * @return string Disk identifier
 120          */
 121         public static function getDiskPath($disk) {
 122                 preg_match("/^.*\/([A-Za-z0-9]+)$/", $disk, $identifier);
 123                 $cmd = "ls -la /dev/disk/by-path | grep '$identifier[1]$'";
 124                 OMVModuleZFSUtil::exec($cmd, $out, $res);
 125                 if (is_array($out)) {
 126                         $cols = preg_split('/[\s]+/', $out[0]);
 127                         return($cols[count($cols)-3]);
 128                 }
 129         }
 130
 131
 132         /**
 133          * Get poolname from name of dataset/volume etc.
 134          *
 135          * @return string Name of the pool
 136          */
 137         public static function getPoolname($name) {
 138                 $tmp = preg_split('/[\/]+/', $name);
 139                 return($tmp[0]);
 140         }
 141
 142         /**
 143          * Get UUID of ZFS pool by name
 144          *
 145          * @return string UUID of the pool
 146          */
 147         public static function getUUIDbyName($poolname) {
 148                 $cmd = "zpool get guid " . $poolname . " 2>&1";
 149                 OMVModuleZFSUtil::exec($cmd, $out, $res);
 150                 if (isset($out)) {
 151                         $headers = preg_split('/[\s]+/', $out[0]);
 152                         for ($i=0; $i<count($headers); $i++) {
 153                                 if (strcmp($headers[$i], "VALUE") === 0) {
 154                                         $valuecol=$i;
 155                                         break;
 156                                 }
 157                         }
 158                         $line = preg_split('/[\s]+/', $out[1]);
 159                         return $line[$valuecol];
 160                 }
 161                 return null;
 162         }
 163
 164         /**
 165          * Add any missing ZFS filesystems to the OMV backend
 166          *
 167          */
 168         public static function addMissingOMVMntEnt() {
 169                 global $xmlConfig;
 170                 $cmd = "zfs list -H -o name -t filesystem";
 171                 OMVModuleZFSUtil::exec($cmd, $out, $res);
 172                 foreach($out as $name) {
 173                         if (preg_match('/[\/]+/', $name)) {
 174                                 $poolname = OMVModuleZFSUtil::getPoolname($name);
 175                                 $pooluuid = OMVModuleZFSUtil::getUUIDbyName($poolname);
 176                                 $ds = new OMVModuleZFSDataset($name);
 177                                 $dir = $ds->getMountPoint();
 178                                 $xpath = "//system/fstab/mntent[fsname='" . $pooluuid . "' and dir='" . $dir . "' and type='zfs']";
 179                                 if (!($xmlConfig->exists($xpath))) {
 180                                         $uuid = OMVUtil::uuid();
 181                                         $object = array(
 182                                                 "uuid" => $uuid,
 183                                                 "fsname" => $pooluuid,
 184                                                 "dir" => $dir,
 185                                                 "type" => "zfs",
 186                                                 "opts" => "rw,relatime,xattr,noacl",
 187                                                 "freq" => "0",
 188                                                 "passno" => "0",
 189                                                 "hidden" => "1"
 190                                         );
 191                                         $xmlConfig->set("//system/fstab",array("mntent" => $object));
 192                                 }
 193                         }
 194                 }
 195                 return null;
 196         }
 197
 198         /**
 199          * Get an array with all ZFS objects
 200          *
 201          * @return An array with all ZFS objects
 202          */
 203         public static function getZFSFlatArray() {
 204                 $prefix = "root/pool-";
 205                 $objects = array();
 206                 $cmd = "zfs list -H -t all -o name,type 2>&1";
 207                 $expanded = true;
 208                 OMVModuleZFSUtil::exec($cmd,$out,$res);
 209                 foreach ($out as $line) {
 210                         $parts = preg_split('/\t/',$line);
 211                         $path = $parts[0];
 212                         $type = $parts[1];
 213                         $subdirs = preg_split('/\//',$path);
 214                         $root = $subdirs[0];
 215                         $tmp = array();
 216
 217                         switch ($type) {
 218                         case "filesystem":
 219                                 if (strpos($path,'/') === false) {
 220                                         //This is a Pool
 221                                         $tmp = array('id'=>$prefix . $path,
 222                                                 'parentid'=>'root',
 223                                                 'name'=>$path,
 224                                                 'type'=>'Pool',
 225                                                 'icon'=>'images/raid.png',
 226                                                 'expanded'=>$expanded,
 227                                                 'path'=>$path);
 228                                         $pool = new OMVModuleZFSZpool($path);
 229                                         $tmp['size'] = $pool->getSize();
 230                                         $tmp['used'] = $pool->getAttribute("allocated");
 231                                         $tmp['available'] = $pool->getAttribute("free");
 232                                         $tmp['mountpoint'] = $pool->getMountPoint();
 233                                         $vdevs = $pool->getVdevs();
 234                                         $vdev_type = $vdevs[0]->getType();
 235                                         switch ($vdev_type) {
 236                                         case OMVModuleZFSVdevType::OMVMODULEZFSMIRROR:
 237                                                 $pool_type = "Mirror";
 238                                                 break;
 239                                         case OMVModuleZFSVdevType::OMVMODULEZFSPLAIN:
 240                                                 $pool_type = "Basic";
 241                                                 break;
 242                                         case OMVModuleZFSVdevType::OMVMODULEZFSRAIDZ1:
 243                                                 $pool_type = "Raidz1";
 244                                                 break;
 245                                         case OMVModuleZFSVdevType::OMVMODULEZFSRAIDZ2:
 246                                                 $pool_type = "Raidz2";
 247                                                 break;
 248                                         case OMVModuleZFSVdevType::OMVMODULEZFSRAIDZ3:
 249                                                 $pool_type = "Raidz3";
 250                                                 break;
 251                                         }
 252                                         $tmp['pool_type'] = $pool_type;
 253                                         $tmp['nr_disks'] = count($vdevs[0]->getDisks());
 254                                         array_push($objects,$tmp);
 255                                 } else {
 256                                         //This is a Filesystem
 257                                         preg_match('/(.*)\/(.*)$/', $path, $result);
 258                                         $tmp = array('id'=>$prefix . $path,
 259                                                 'parentid'=>$prefix . $result[1],
 260                                                 'name'=>$result[2],
 261                                                 'icon'=>"images/filesystem.png",
 262                                                 'path'=>$path,
 263                                                 'expanded'=>$expanded);
 264                                         $ds =  new OMVModuleZFSDataset($path);
 265                                         if ($ds->isClone()) {
 266                                                 //This is a cloned Filesystem
 267                                                 $tmp['type'] = "Clone";
 268                                                 $tmp['origin'] = $ds->getOrigin();
 269                                         } else {
 270                                                 //This is a standard Filesystem.
 271                                                 $tmp['type']= ucfirst($type);
 272                                         }
 273                                         $tmp['size'] = "n/a";
 274                                         $used = $ds->getProperty("used");
 275                                         $tmp['used'] = $used['value'];
 276                                         $available = $ds->getProperty("available");
 277                                         $tmp['available'] = $available['value'];
 278                                         $tmp['mountpoint'] = $ds->getMountPoint();
 279                                         $tmp['pool_type'] = "n/a";
 280                                         $tmp['nr_disks'] = "n/a";
 281                                         array_push($objects,$tmp);
 282                                 }
 283                                 break;
 284
 285                         case "volume":
 286                                 preg_match('/(.*)\/(.*)$/', $path, $result);
 287                                 $tmp = array('id'=>$prefix . $path,
 288                                         'parentid'=>$prefix . $result[1],
 289                                         'name'=>$result[2],
 290                                         'type'=>ucfirst($type),
 291                                         'icon'=>"images/save.png",
 292                                         'path'=>$path,
 293                                         'expanded'=>$expanded);
 294                                 $vol = new OMVModuleZFSZvol();
 295                                 $tmp['size'] = $vol->getSize();
 296                                 $tmp['used'] = "n/a";
 297                                 $tmp['available'] = "n/a";
 298                                 $tmp['mountpoint'] = "n/a";
 299                                 $tmp['pool_type'] = "n/a";
 300                                 $tmp['nr_disks'] = "n/a";
 301                                 array_push($objects,$tmp);
 302                                 break;
 303
 304                         case "snapshot":
 305                                 preg_match('/(.*)\@(.*)$/', $path, $result);
 306                                 $subdirs = preg_split('/\//',$result[1]);
 307                                 $root = $subdirs[0];
 308                                 $tmp = array('id'=>$prefix . $path,
 309                                         'parentid'=>$prefix . $result[1],
 310                                         'name'=>$result[2],
 311                                         'type'=>ucfirst($type),
 312                                         'icon'=>'images/zfs_snap.png',
 313                                         'path'=>$path,
 314                                         'expanded'=>$expanded);
 315                                 $tmp['size'] = "n/a";
 316                                 $tmp['used'] = "n/a";
 317                                 $tmp['available'] = "n/a";
 318                                 $tmp['mountpoint'] = "n/a";
 319                                 $tmp['pool_type'] = "n/a";
 320                                 $tmp['nr_disks'] = "n/a";
 321                                 array_push($objects,$tmp);
 322                                 break;
 323
 324                         default:
 325                                 break;
 326                         }
 327                 }
 328                 return $objects;
 329         }
 330
 331         /**
 332          * Create a tree structured array
 333          *
 334          * @param &$list The flat array to convert to a tree structure
 335          * @param $parent Root node of the tree to create
 336          * @return Tree structured array
 337          *
 338          */
 339         public static function createTree(&$list, $parent){
 340                 $tree = array();
 341                 foreach ($parent as $k=>$l){
 342                         if(isset($list[$l['id']])){
 343                                 $l['leaf'] = false;
 344                                 $l['children'] = OMVModuleZFSUtil::createTree($list, $list[$l['id']]);
 345                         } else {
 346                                 $l['leaf'] = true;
 347                         }
 348                         $tree[] = $l;
 349                 }
 350                 return $tree;
 351         }
 352
 353         /**
 354          * Get all Datasets as objects
 355          *
 356          * @return An array with all the Datasets
 357          */
 358         public static function getAllDatasets() {
 359                 $datasets = array();
 360                 $cmd = "zfs list -H -t filesystem -o name 2>&1";
 361                 OMVModuleZFSUtil::exec($cmd, $out, $res);
 362                 foreach ($out as $name) {
 363                         $ds = new OMVModuleZFSDataset($name);
 364                         array_push($datasets, $ds);
 365                 }
 366                 return $datasets;
 367         }
 368
 369         /**
 370          * Helper function to execute a command and throw an exception on error
 371          * (requires stderr redirected to stdout for proper exception message).
 372          *
 373          * @param string $cmd Command to execute
 374          * @param array &$out If provided will contain output in an array
 375          * @param int &$res If provided will contain Exit status of the command
 376          * @return string Last line of output when executing the command
 377          * @throws OMVModuleZFSException
 378          * @access public
 379          */
 380         public static function exec($cmd, &$out = null, &$res = null) {
 381                 $tmp = OMVUtil::exec($cmd, $out, $res);
 382                 if ($res) {
 383                         throw new OMVModuleZFSException(implode("\n", $out));
 384                 }
 385                 return $tmp;
 386         }
 387
 388 }
 389
 390
 391 ?>