nextcloud / server

lib/private/Files/Cache/Wrapper/CacheJail.php

Indentation +262 added lines, -262 removed lines

@@ -34,294 +34,294 @@
  * Jail to a subdirectory of the wrapped cache
  */
 class CacheJail extends CacheWrapper {
-	/**
-	 * @var string
-	 */
-	protected $root;
+    /**
+     * @var string
+     */
+    protected $root;
 
-	/**
-	 * @param \OCP\Files\Cache\ICache $cache
-	 * @param string $root
-	 */
-	public function __construct($cache, $root) {
-		parent::__construct($cache);
-		$this->root = $root;
-	}
+    /**
+     * @param \OCP\Files\Cache\ICache $cache
+     * @param string $root
+     */
+    public function __construct($cache, $root) {
+        parent::__construct($cache);
+        $this->root = $root;
+    }
 
-	protected function getSourcePath($path) {
-		if ($path === '') {
-			return $this->root;
-		} else {
-			return $this->root . '/' . ltrim($path, '/');
-		}
-	}
+    protected function getSourcePath($path) {
+        if ($path === '') {
+            return $this->root;
+        } else {
+            return $this->root . '/' . ltrim($path, '/');
+        }
+    }
 
-	/**
-	 * @param string $path
-	 * @return null|string the jailed path or null if the path is outside the jail
-	 */
-	protected function getJailedPath($path) {
-		if ($this->root === '') {
-			return $path;
-		}
-		$rootLength = strlen($this->root) + 1;
-		if ($path === $this->root) {
-			return '';
-		} else if (substr($path, 0, $rootLength) === $this->root . '/') {
-			return substr($path, $rootLength);
-		} else {
-			return null;
-		}
-	}
+    /**
+     * @param string $path
+     * @return null|string the jailed path or null if the path is outside the jail
+     */
+    protected function getJailedPath($path) {
+        if ($this->root === '') {
+            return $path;
+        }
+        $rootLength = strlen($this->root) + 1;
+        if ($path === $this->root) {
+            return '';
+        } else if (substr($path, 0, $rootLength) === $this->root . '/') {
+            return substr($path, $rootLength);
+        } else {
+            return null;
+        }
+    }
 
-	/**
-	 * @param ICacheEntry|array $entry
-	 * @return array
-	 */
-	protected function formatCacheEntry($entry) {
-		if (isset($entry['path'])) {
-			$entry['path'] = $this->getJailedPath($entry['path']);
-		}
-		return $entry;
-	}
+    /**
+     * @param ICacheEntry|array $entry
+     * @return array
+     */
+    protected function formatCacheEntry($entry) {
+        if (isset($entry['path'])) {
+            $entry['path'] = $this->getJailedPath($entry['path']);
+        }
+        return $entry;
+    }
 
-	protected function filterCacheEntry($entry) {
-		$rootLength = strlen($this->root) + 1;
-		return ($entry['path'] === $this->root) or (substr($entry['path'], 0, $rootLength) === $this->root . '/');
-	}
+    protected function filterCacheEntry($entry) {
+        $rootLength = strlen($this->root) + 1;
+        return ($entry['path'] === $this->root) or (substr($entry['path'], 0, $rootLength) === $this->root . '/');
+    }
 
-	/**
-	 * get the stored metadata of a file or folder
-	 *
-	 * @param string /int $file
-	 * @return ICacheEntry|false
-	 */
-	public function get($file) {
-		if (is_string($file) or $file == '') {
-			$file = $this->getSourcePath($file);
-		}
-		return parent::get($file);
-	}
+    /**
+     * get the stored metadata of a file or folder
+     *
+     * @param string /int $file
+     * @return ICacheEntry|false
+     */
+    public function get($file) {
+        if (is_string($file) or $file == '') {
+            $file = $this->getSourcePath($file);
+        }
+        return parent::get($file);
+    }
 
-	/**
-	 * insert meta data for a new file or folder
-	 *
-	 * @param string $file
-	 * @param array $data
-	 *
-	 * @return int file id
-	 * @throws \RuntimeException
-	 */
-	public function insert($file, array $data) {
-		return $this->getCache()->insert($this->getSourcePath($file), $data);
-	}
+    /**
+     * insert meta data for a new file or folder
+     *
+     * @param string $file
+     * @param array $data
+     *
+     * @return int file id
+     * @throws \RuntimeException
+     */
+    public function insert($file, array $data) {
+        return $this->getCache()->insert($this->getSourcePath($file), $data);
+    }
 
-	/**
-	 * update the metadata in the cache
-	 *
-	 * @param int $id
-	 * @param array $data
-	 */
-	public function update($id, array $data) {
-		$this->getCache()->update($id, $data);
-	}
+    /**
+     * update the metadata in the cache
+     *
+     * @param int $id
+     * @param array $data
+     */
+    public function update($id, array $data) {
+        $this->getCache()->update($id, $data);
+    }
 
-	/**
-	 * get the file id for a file
-	 *
-	 * @param string $file
-	 * @return int
-	 */
-	public function getId($file) {
-		return $this->getCache()->getId($this->getSourcePath($file));
-	}
+    /**
+     * get the file id for a file
+     *
+     * @param string $file
+     * @return int
+     */
+    public function getId($file) {
+        return $this->getCache()->getId($this->getSourcePath($file));
+    }
 
-	/**
-	 * get the id of the parent folder of a file
-	 *
-	 * @param string $file
-	 * @return int
-	 */
-	public function getParentId($file) {
-		return $this->getCache()->getParentId($this->getSourcePath($file));
-	}
+    /**
+     * get the id of the parent folder of a file
+     *
+     * @param string $file
+     * @return int
+     */
+    public function getParentId($file) {
+        return $this->getCache()->getParentId($this->getSourcePath($file));
+    }
 
-	/**
-	 * check if a file is available in the cache
-	 *
-	 * @param string $file
-	 * @return bool
-	 */
-	public function inCache($file) {
-		return $this->getCache()->inCache($this->getSourcePath($file));
-	}
+    /**
+     * check if a file is available in the cache
+     *
+     * @param string $file
+     * @return bool
+     */
+    public function inCache($file) {
+        return $this->getCache()->inCache($this->getSourcePath($file));
+    }
 
-	/**
-	 * remove a file or folder from the cache
-	 *
-	 * @param string $file
-	 */
-	public function remove($file) {
-		$this->getCache()->remove($this->getSourcePath($file));
-	}
+    /**
+     * remove a file or folder from the cache
+     *
+     * @param string $file
+     */
+    public function remove($file) {
+        $this->getCache()->remove($this->getSourcePath($file));
+    }
 
-	/**
-	 * Move a file or folder in the cache
-	 *
-	 * @param string $source
-	 * @param string $target
-	 */
-	public function move($source, $target) {
-		$this->getCache()->move($this->getSourcePath($source), $this->getSourcePath($target));
-	}
+    /**
+     * Move a file or folder in the cache
+     *
+     * @param string $source
+     * @param string $target
+     */
+    public function move($source, $target) {
+        $this->getCache()->move($this->getSourcePath($source), $this->getSourcePath($target));
+    }
 
-	/**
-	 * Get the storage id and path needed for a move
-	 *
-	 * @param string $path
-	 * @return array [$storageId, $internalPath]
-	 */
-	protected function getMoveInfo($path) {
-		return [$this->getNumericStorageId(), $this->getSourcePath($path)];
-	}
+    /**
+     * Get the storage id and path needed for a move
+     *
+     * @param string $path
+     * @return array [$storageId, $internalPath]
+     */
+    protected function getMoveInfo($path) {
+        return [$this->getNumericStorageId(), $this->getSourcePath($path)];
+    }
 
-	/**
-	 * remove all entries for files that are stored on the storage from the cache
-	 */
-	public function clear() {
-		$this->getCache()->remove($this->root);
-	}
+    /**
+     * remove all entries for files that are stored on the storage from the cache
+     */
+    public function clear() {
+        $this->getCache()->remove($this->root);
+    }
 
-	/**
-	 * @param string $file
-	 *
-	 * @return int Cache::NOT_FOUND, Cache::PARTIAL, Cache::SHALLOW or Cache::COMPLETE
-	 */
-	public function getStatus($file) {
-		return $this->getCache()->getStatus($this->getSourcePath($file));
-	}
+    /**
+     * @param string $file
+     *
+     * @return int Cache::NOT_FOUND, Cache::PARTIAL, Cache::SHALLOW or Cache::COMPLETE
+     */
+    public function getStatus($file) {
+        return $this->getCache()->getStatus($this->getSourcePath($file));
+    }
 
-	private function formatSearchResults($results) {
-		$results = array_filter($results, array($this, 'filterCacheEntry'));
-		$results = array_values($results);
-		return array_map(array($this, 'formatCacheEntry'), $results);
-	}
+    private function formatSearchResults($results) {
+        $results = array_filter($results, array($this, 'filterCacheEntry'));
+        $results = array_values($results);
+        return array_map(array($this, 'formatCacheEntry'), $results);
+    }
 
-	/**
-	 * search for files matching $pattern
-	 *
-	 * @param string $pattern
-	 * @return array an array of file data
-	 */
-	public function search($pattern) {
-		$results = $this->getCache()->search($pattern);
-		return $this->formatSearchResults($results);
-	}
+    /**
+     * search for files matching $pattern
+     *
+     * @param string $pattern
+     * @return array an array of file data
+     */
+    public function search($pattern) {
+        $results = $this->getCache()->search($pattern);
+        return $this->formatSearchResults($results);
+    }
 
-	/**
-	 * search for files by mimetype
-	 *
-	 * @param string $mimetype
-	 * @return array
-	 */
-	public function searchByMime($mimetype) {
-		$results = $this->getCache()->searchByMime($mimetype);
-		return $this->formatSearchResults($results);
-	}
+    /**
+     * search for files by mimetype
+     *
+     * @param string $mimetype
+     * @return array
+     */
+    public function searchByMime($mimetype) {
+        $results = $this->getCache()->searchByMime($mimetype);
+        return $this->formatSearchResults($results);
+    }
 
-	public function searchQuery(ISearchQuery $query) {
-		$results = $this->getCache()->searchQuery($query);
-		return $this->formatSearchResults($results);
-	}
+    public function searchQuery(ISearchQuery $query) {
+        $results = $this->getCache()->searchQuery($query);
+        return $this->formatSearchResults($results);
+    }
 
-	/**
-	 * search for files by mimetype
-	 *
-	 * @param string|int $tag name or tag id
-	 * @param string $userId owner of the tags
-	 * @return array
-	 */
-	public function searchByTag($tag, $userId) {
-		$results = $this->getCache()->searchByTag($tag, $userId);
-		return $this->formatSearchResults($results);
-	}
+    /**
+     * search for files by mimetype
+     *
+     * @param string|int $tag name or tag id
+     * @param string $userId owner of the tags
+     * @return array
+     */
+    public function searchByTag($tag, $userId) {
+        $results = $this->getCache()->searchByTag($tag, $userId);
+        return $this->formatSearchResults($results);
+    }
 
-	/**
-	 * update the folder size and the size of all parent folders
-	 *
-	 * @param string|boolean $path
-	 * @param array $data (optional) meta data of the folder
-	 */
-	public function correctFolderSize($path, $data = null) {
-		if ($this->getCache() instanceof Cache) {
-			$this->getCache()->correctFolderSize($this->getSourcePath($path), $data);
-		}
-	}
+    /**
+     * update the folder size and the size of all parent folders
+     *
+     * @param string|boolean $path
+     * @param array $data (optional) meta data of the folder
+     */
+    public function correctFolderSize($path, $data = null) {
+        if ($this->getCache() instanceof Cache) {
+            $this->getCache()->correctFolderSize($this->getSourcePath($path), $data);
+        }
+    }
 
-	/**
-	 * get the size of a folder and set it in the cache
-	 *
-	 * @param string $path
-	 * @param array $entry (optional) meta data of the folder
-	 * @return int
-	 */
-	public function calculateFolderSize($path, $entry = null) {
-		if ($this->getCache() instanceof Cache) {
-			return $this->getCache()->calculateFolderSize($this->getSourcePath($path), $entry);
-		} else {
-			return 0;
-		}
+    /**
+     * get the size of a folder and set it in the cache
+     *
+     * @param string $path
+     * @param array $entry (optional) meta data of the folder
+     * @return int
+     */
+    public function calculateFolderSize($path, $entry = null) {
+        if ($this->getCache() instanceof Cache) {
+            return $this->getCache()->calculateFolderSize($this->getSourcePath($path), $entry);
+        } else {
+            return 0;
+        }
 
-	}
+    }
 
-	/**
-	 * get all file ids on the files on the storage
-	 *
-	 * @return int[]
-	 */
-	public function getAll() {
-		// not supported
-		return array();
-	}
+    /**
+     * get all file ids on the files on the storage
+     *
+     * @return int[]
+     */
+    public function getAll() {
+        // not supported
+        return array();
+    }
 
-	/**
-	 * find a folder in the cache which has not been fully scanned
-	 *
-	 * If multiply incomplete folders are in the cache, the one with the highest id will be returned,
-	 * use the one with the highest id gives the best result with the background scanner, since that is most
-	 * likely the folder where we stopped scanning previously
-	 *
-	 * @return string|bool the path of the folder or false when no folder matched
-	 */
-	public function getIncomplete() {
-		// not supported
-		return false;
-	}
+    /**
+     * find a folder in the cache which has not been fully scanned
+     *
+     * If multiply incomplete folders are in the cache, the one with the highest id will be returned,
+     * use the one with the highest id gives the best result with the background scanner, since that is most
+     * likely the folder where we stopped scanning previously
+     *
+     * @return string|bool the path of the folder or false when no folder matched
+     */
+    public function getIncomplete() {
+        // not supported
+        return false;
+    }
 
-	/**
-	 * get the path of a file on this storage by it's id
-	 *
-	 * @param int $id
-	 * @return string|null
-	 */
-	public function getPathById($id) {
-		$path = $this->getCache()->getPathById($id);
-		return $this->getJailedPath($path);
-	}
+    /**
+     * get the path of a file on this storage by it's id
+     *
+     * @param int $id
+     * @return string|null
+     */
+    public function getPathById($id) {
+        $path = $this->getCache()->getPathById($id);
+        return $this->getJailedPath($path);
+    }
 
-	/**
-	 * Move a file or folder in the cache
-	 *
-	 * Note that this should make sure the entries are removed from the source cache
-	 *
-	 * @param \OCP\Files\Cache\ICache $sourceCache
-	 * @param string $sourcePath
-	 * @param string $targetPath
-	 */
-	public function moveFromCache(\OCP\Files\Cache\ICache $sourceCache, $sourcePath, $targetPath) {
-		if ($sourceCache === $this) {
-			return $this->move($sourcePath, $targetPath);
-		}
-		return $this->getCache()->moveFromCache($sourceCache, $sourcePath, $this->getSourcePath($targetPath));
-	}
+    /**
+     * Move a file or folder in the cache
+     *
+     * Note that this should make sure the entries are removed from the source cache
+     *
+     * @param \OCP\Files\Cache\ICache $sourceCache
+     * @param string $sourcePath
+     * @param string $targetPath
+     */
+    public function moveFromCache(\OCP\Files\Cache\ICache $sourceCache, $sourcePath, $targetPath) {
+        if ($sourceCache === $this) {
+            return $this->move($sourcePath, $targetPath);
+        }
+        return $this->getCache()->moveFromCache($sourceCache, $sourcePath, $this->getSourcePath($targetPath));
+    }
 }

lib/private/Repair/RepairInvalidPaths.php

Spacing +2 added lines, -2 removed lines

@@ -101,7 +101,7 @@ 
 	private function repair() {
 		$entries = $this->getInvalidEntries();
 		foreach ($entries as $entry) {
-			$calculatedPath = $entry['parent_path'] . '/' . $entry['name'];
+			$calculatedPath = $entry['parent_path'].'/'.$entry['name'];
 			if ($newId = $this->getId($entry['storage'], $calculatedPath)) {
 				// a new entry with the correct path has already been created, reuse that one and delete the incorrect entry
 				$this->reparent($entry['fileid'], $newId);
@@ -116,6 +116,6 @@ 
 	public function run(IOutput $output) {
 		$count = $this->repair();
 
-		$output->info('Repaired ' . $count . ' paths');
+		$output->info('Repaired '.$count.' paths');
 	}
 }

Doc Comments +6 added lines

@@ -59,6 +59,9 @@ 
 		return $query->execute()->fetchAll();
 	}
 
+	/**
+	 * @param string $path
+	 */
 	private function getId($storage, $path) {
 		$builder = $this->connection->getQueryBuilder();
 
@@ -70,6 +73,9 @@ 
 		return $query->execute()->fetchColumn();
 	}
 
+	/**
+	 * @param string $newPath
+	 */
 	private function update($fileid, $newPath) {
 		$builder = $this->connection->getQueryBuilder();
 

Indentation +91 added lines, -91 removed lines

@@ -27,95 +27,95 @@
 use OCP\Migration\IRepairStep;
 
 class RepairInvalidPaths implements IRepairStep {
-	/** @var IDBConnection */
-	private $connection;
-
-	public function __construct(IDBConnection $connection) {
-		$this->connection = $connection;
-	}
-
-
-	public function getName() {
-		return 'Repair invalid paths in file cache';
-	}
-
-	private function getInvalidEntries() {
-		$builder = $this->connection->getQueryBuilder();
-
-		$computedPath = $builder->func()->concat(
-			'p.path',
-			$builder->func()->concat($builder->createNamedParameter('/'), 'f.name')
-		);
-
-		//select f.path, f.parent,p.path from oc_filecache f inner join oc_filecache p on f.parent=p.fileid and p.path!='' where f.path != p.path || '/' || f.name;
-		$query = $builder->select('f.fileid', 'f.path', 'p.path AS parent_path', 'f.name', 'f.parent', 'f.storage')
-			->from('filecache', 'f')
-			->innerJoin('f', 'filecache', 'p', $builder->expr()->andX(
-				$builder->expr()->eq('f.parent', 'p.fileid'),
-				$builder->expr()->neq('p.name', $builder->createNamedParameter(''))
-			))
-			->where($builder->expr()->neq('f.path', $computedPath));
-
-		return $query->execute()->fetchAll();
-	}
-
-	private function getId($storage, $path) {
-		$builder = $this->connection->getQueryBuilder();
-
-		$query = $builder->select('fileid')
-			->from('filecache')
-			->where($builder->expr()->eq('storage', $builder->createNamedParameter($storage)))
-			->andWhere($builder->expr()->eq('path', $builder->createNamedParameter($path)));
-
-		return $query->execute()->fetchColumn();
-	}
-
-	private function update($fileid, $newPath) {
-		$builder = $this->connection->getQueryBuilder();
-
-		$query = $builder->update('filecache')
-			->set('path', $builder->createNamedParameter($newPath))
-			->set('path_hash', $builder->createNamedParameter(md5($newPath)))
-			->where($builder->expr()->eq('fileid', $builder->createNamedParameter($fileid)));
-
-		$query->execute();
-	}
-
-	private function reparent($from, $to) {
-		$builder = $this->connection->getQueryBuilder();
-
-		$query = $builder->update('filecache')
-			->set('parent', $builder->createNamedParameter($to))
-			->where($builder->expr()->eq('fileid', $builder->createNamedParameter($from)));
-		$query->execute();
-	}
-
-	private function delete($fileid) {
-		$builder = $this->connection->getQueryBuilder();
-
-		$query = $builder->delete('filecache')
-			->where($builder->expr()->eq('fileid', $builder->createNamedParameter($fileid)));
-		$query->execute();
-	}
-
-	private function repair() {
-		$entries = $this->getInvalidEntries();
-		foreach ($entries as $entry) {
-			$calculatedPath = $entry['parent_path'] . '/' . $entry['name'];
-			if ($newId = $this->getId($entry['storage'], $calculatedPath)) {
-				// a new entry with the correct path has already been created, reuse that one and delete the incorrect entry
-				$this->reparent($entry['fileid'], $newId);
-				$this->delete($entry['fileid']);
-			} else {
-				$this->update($entry['fileid'], $calculatedPath);
-			}
-		}
-		return count($entries);
-	}
-
-	public function run(IOutput $output) {
-		$count = $this->repair();
-
-		$output->info('Repaired ' . $count . ' paths');
-	}
+    /** @var IDBConnection */
+    private $connection;
+
+    public function __construct(IDBConnection $connection) {
+        $this->connection = $connection;
+    }
+
+
+    public function getName() {
+        return 'Repair invalid paths in file cache';
+    }
+
+    private function getInvalidEntries() {
+        $builder = $this->connection->getQueryBuilder();
+
+        $computedPath = $builder->func()->concat(
+            'p.path',
+            $builder->func()->concat($builder->createNamedParameter('/'), 'f.name')
+        );
+
+        //select f.path, f.parent,p.path from oc_filecache f inner join oc_filecache p on f.parent=p.fileid and p.path!='' where f.path != p.path || '/' || f.name;
+        $query = $builder->select('f.fileid', 'f.path', 'p.path AS parent_path', 'f.name', 'f.parent', 'f.storage')
+            ->from('filecache', 'f')
+            ->innerJoin('f', 'filecache', 'p', $builder->expr()->andX(
+                $builder->expr()->eq('f.parent', 'p.fileid'),
+                $builder->expr()->neq('p.name', $builder->createNamedParameter(''))
+            ))
+            ->where($builder->expr()->neq('f.path', $computedPath));
+
+        return $query->execute()->fetchAll();
+    }
+
+    private function getId($storage, $path) {
+        $builder = $this->connection->getQueryBuilder();
+
+        $query = $builder->select('fileid')
+            ->from('filecache')
+            ->where($builder->expr()->eq('storage', $builder->createNamedParameter($storage)))
+            ->andWhere($builder->expr()->eq('path', $builder->createNamedParameter($path)));
+
+        return $query->execute()->fetchColumn();
+    }
+
+    private function update($fileid, $newPath) {
+        $builder = $this->connection->getQueryBuilder();
+
+        $query = $builder->update('filecache')
+            ->set('path', $builder->createNamedParameter($newPath))
+            ->set('path_hash', $builder->createNamedParameter(md5($newPath)))
+            ->where($builder->expr()->eq('fileid', $builder->createNamedParameter($fileid)));
+
+        $query->execute();
+    }
+
+    private function reparent($from, $to) {
+        $builder = $this->connection->getQueryBuilder();
+
+        $query = $builder->update('filecache')
+            ->set('parent', $builder->createNamedParameter($to))
+            ->where($builder->expr()->eq('fileid', $builder->createNamedParameter($from)));
+        $query->execute();
+    }
+
+    private function delete($fileid) {
+        $builder = $this->connection->getQueryBuilder();
+
+        $query = $builder->delete('filecache')
+            ->where($builder->expr()->eq('fileid', $builder->createNamedParameter($fileid)));
+        $query->execute();
+    }
+
+    private function repair() {
+        $entries = $this->getInvalidEntries();
+        foreach ($entries as $entry) {
+            $calculatedPath = $entry['parent_path'] . '/' . $entry['name'];
+            if ($newId = $this->getId($entry['storage'], $calculatedPath)) {
+                // a new entry with the correct path has already been created, reuse that one and delete the incorrect entry
+                $this->reparent($entry['fileid'], $newId);
+                $this->delete($entry['fileid']);
+            } else {
+                $this->update($entry['fileid'], $calculatedPath);
+            }
+        }
+        return count($entries);
+    }
+
+    public function run(IOutput $output) {
+        $count = $this->repair();
+
+        $output->info('Repaired ' . $count . ' paths');
+    }
 }

lib/private/Repair.php

Indentation +175 added lines, -175 removed lines

@@ -53,179 +53,179 @@
 use Symfony\Component\EventDispatcher\GenericEvent;
 
 class Repair implements IOutput{
-	/* @var IRepairStep[] */
-	private $repairSteps;
-	/** @var EventDispatcher */
-	private $dispatcher;
-	/** @var string */
-	private $currentStep;
-
-	/**
-	 * Creates a new repair step runner
-	 *
-	 * @param IRepairStep[] $repairSteps array of RepairStep instances
-	 * @param EventDispatcher $dispatcher
-	 */
-	public function __construct($repairSteps = [], EventDispatcher $dispatcher = null) {
-		$this->repairSteps = $repairSteps;
-		$this->dispatcher = $dispatcher;
-	}
-
-	/**
-	 * Run a series of repair steps for common problems
-	 */
-	public function run() {
-		if (count($this->repairSteps) === 0) {
-			$this->emit('\OC\Repair', 'info', array('No repair steps available'));
-			return;
-		}
-		// run each repair step
-		foreach ($this->repairSteps as $step) {
-			$this->currentStep = $step->getName();
-			$this->emit('\OC\Repair', 'step', [$this->currentStep]);
-			$step->run($this);
-		}
-	}
-
-	/**
-	 * Add repair step
-	 *
-	 * @param IRepairStep|string $repairStep repair step
-	 * @throws \Exception
-	 */
-	public function addStep($repairStep) {
-		if (is_string($repairStep)) {
-			try {
-				$s = \OC::$server->query($repairStep);
-			} catch (QueryException $e) {
-				if (class_exists($repairStep)) {
-					$s = new $repairStep();
-				} else {
-					throw new \Exception("Repair step '$repairStep' is unknown");
-				}
-			}
-
-			if ($s instanceof IRepairStep) {
-				$this->repairSteps[] = $s;
-			} else {
-				throw new \Exception("Repair step '$repairStep' is not of type \\OCP\\Migration\\IRepairStep");
-			}
-		} else {
-			$this->repairSteps[] = $repairStep;
-		}
-	}
-
-	/**
-	 * Returns the default repair steps to be run on the
-	 * command line or after an upgrade.
-	 *
-	 * @return IRepairStep[]
-	 */
-	public static function getRepairSteps() {
-		return [
-			new Collation(\OC::$server->getConfig(), \OC::$server->getLogger(), \OC::$server->getDatabaseConnection(), false),
-			new RepairMimeTypes(\OC::$server->getConfig()),
-			new CleanTags(\OC::$server->getDatabaseConnection(), \OC::$server->getUserManager()),
-			new RepairInvalidShares(\OC::$server->getConfig(), \OC::$server->getDatabaseConnection()),
-			new RemoveRootShares(\OC::$server->getDatabaseConnection(), \OC::$server->getUserManager(), \OC::$server->getLazyRootFolder()),
-			new MoveUpdaterStepFile(\OC::$server->getConfig()),
-			new MoveAvatars(
-				\OC::$server->getJobList(),
-				\OC::$server->getConfig()
-			),
-			new CleanPreviews(
-				\OC::$server->getJobList(),
-				\OC::$server->getUserManager(),
-				\OC::$server->getConfig()
-			),
-			new FixMountStorages(\OC::$server->getDatabaseConnection()),
-			new UpdateLanguageCodes(\OC::$server->getDatabaseConnection(), \OC::$server->getConfig()),
-			new InstallCoreBundle(
-				\OC::$server->query(BundleFetcher::class),
-				\OC::$server->getConfig(),
-				\OC::$server->query(Installer::class)
-			),
-			new RepairInvalidPaths(\OC::$server->getDatabaseConnection())
-		];
-	}
-
-	/**
-	 * Returns expensive repair steps to be run on the
-	 * command line with a special option.
-	 *
-	 * @return IRepairStep[]
-	 */
-	public static function getExpensiveRepairSteps() {
-		return [
-			new OldGroupMembershipShares(\OC::$server->getDatabaseConnection(), \OC::$server->getGroupManager())
-		];
-	}
-
-	/**
-	 * Returns the repair steps to be run before an
-	 * upgrade.
-	 *
-	 * @return IRepairStep[]
-	 */
-	public static function getBeforeUpgradeRepairSteps() {
-		$connection = \OC::$server->getDatabaseConnection();
-		$config = \OC::$server->getConfig();
-		$steps = [
-			new Collation(\OC::$server->getConfig(), \OC::$server->getLogger(), $connection, true),
-			new SqliteAutoincrement($connection),
-			new SaveAccountsTableData($connection, $config),
-		];
-
-		return $steps;
-	}
-
-	/**
-	 * @param string $scope
-	 * @param string $method
-	 * @param array $arguments
-	 */
-	public function emit($scope, $method, array $arguments = []) {
-		if (!is_null($this->dispatcher)) {
-			$this->dispatcher->dispatch("$scope::$method",
-				new GenericEvent("$scope::$method", $arguments));
-		}
-	}
-
-	public function info($string) {
-		// for now just emit as we did in the past
-		$this->emit('\OC\Repair', 'info', array($string));
-	}
-
-	/**
-	 * @param string $message
-	 */
-	public function warning($message) {
-		// for now just emit as we did in the past
-		$this->emit('\OC\Repair', 'warning', [$message]);
-	}
-
-	/**
-	 * @param int $max
-	 */
-	public function startProgress($max = 0) {
-		// for now just emit as we did in the past
-		$this->emit('\OC\Repair', 'startProgress', [$max, $this->currentStep]);
-	}
-
-	/**
-	 * @param int $step
-	 * @param string $description
-	 */
-	public function advance($step = 1, $description = '') {
-		// for now just emit as we did in the past
-		$this->emit('\OC\Repair', 'advance', [$step, $description]);
-	}
-
-	/**
-	 * @param int $max
-	 */
-	public function finishProgress() {
-		// for now just emit as we did in the past
-		$this->emit('\OC\Repair', 'finishProgress', []);
-	}
+    /* @var IRepairStep[] */
+    private $repairSteps;
+    /** @var EventDispatcher */
+    private $dispatcher;
+    /** @var string */
+    private $currentStep;
+
+    /**
+     * Creates a new repair step runner
+     *
+     * @param IRepairStep[] $repairSteps array of RepairStep instances
+     * @param EventDispatcher $dispatcher
+     */
+    public function __construct($repairSteps = [], EventDispatcher $dispatcher = null) {
+        $this->repairSteps = $repairSteps;
+        $this->dispatcher = $dispatcher;
+    }
+
+    /**
+     * Run a series of repair steps for common problems
+     */
+    public function run() {
+        if (count($this->repairSteps) === 0) {
+            $this->emit('\OC\Repair', 'info', array('No repair steps available'));
+            return;
+        }
+        // run each repair step
+        foreach ($this->repairSteps as $step) {
+            $this->currentStep = $step->getName();
+            $this->emit('\OC\Repair', 'step', [$this->currentStep]);
+            $step->run($this);
+        }
+    }
+
+    /**
+     * Add repair step
+     *
+     * @param IRepairStep|string $repairStep repair step
+     * @throws \Exception
+     */
+    public function addStep($repairStep) {
+        if (is_string($repairStep)) {
+            try {
+                $s = \OC::$server->query($repairStep);
+            } catch (QueryException $e) {
+                if (class_exists($repairStep)) {
+                    $s = new $repairStep();
+                } else {
+                    throw new \Exception("Repair step '$repairStep' is unknown");
+                }
+            }
+
+            if ($s instanceof IRepairStep) {
+                $this->repairSteps[] = $s;
+            } else {
+                throw new \Exception("Repair step '$repairStep' is not of type \\OCP\\Migration\\IRepairStep");
+            }
+        } else {
+            $this->repairSteps[] = $repairStep;
+        }
+    }
+
+    /**
+     * Returns the default repair steps to be run on the
+     * command line or after an upgrade.
+     *
+     * @return IRepairStep[]
+     */
+    public static function getRepairSteps() {
+        return [
+            new Collation(\OC::$server->getConfig(), \OC::$server->getLogger(), \OC::$server->getDatabaseConnection(), false),
+            new RepairMimeTypes(\OC::$server->getConfig()),
+            new CleanTags(\OC::$server->getDatabaseConnection(), \OC::$server->getUserManager()),
+            new RepairInvalidShares(\OC::$server->getConfig(), \OC::$server->getDatabaseConnection()),
+            new RemoveRootShares(\OC::$server->getDatabaseConnection(), \OC::$server->getUserManager(), \OC::$server->getLazyRootFolder()),
+            new MoveUpdaterStepFile(\OC::$server->getConfig()),
+            new MoveAvatars(
+                \OC::$server->getJobList(),
+                \OC::$server->getConfig()
+            ),
+            new CleanPreviews(
+                \OC::$server->getJobList(),
+                \OC::$server->getUserManager(),
+                \OC::$server->getConfig()
+            ),
+            new FixMountStorages(\OC::$server->getDatabaseConnection()),
+            new UpdateLanguageCodes(\OC::$server->getDatabaseConnection(), \OC::$server->getConfig()),
+            new InstallCoreBundle(
+                \OC::$server->query(BundleFetcher::class),
+                \OC::$server->getConfig(),
+                \OC::$server->query(Installer::class)
+            ),
+            new RepairInvalidPaths(\OC::$server->getDatabaseConnection())
+        ];
+    }
+
+    /**
+     * Returns expensive repair steps to be run on the
+     * command line with a special option.
+     *
+     * @return IRepairStep[]
+     */
+    public static function getExpensiveRepairSteps() {
+        return [
+            new OldGroupMembershipShares(\OC::$server->getDatabaseConnection(), \OC::$server->getGroupManager())
+        ];
+    }
+
+    /**
+     * Returns the repair steps to be run before an
+     * upgrade.
+     *
+     * @return IRepairStep[]
+     */
+    public static function getBeforeUpgradeRepairSteps() {
+        $connection = \OC::$server->getDatabaseConnection();
+        $config = \OC::$server->getConfig();
+        $steps = [
+            new Collation(\OC::$server->getConfig(), \OC::$server->getLogger(), $connection, true),
+            new SqliteAutoincrement($connection),
+            new SaveAccountsTableData($connection, $config),
+        ];
+
+        return $steps;
+    }
+
+    /**
+     * @param string $scope
+     * @param string $method
+     * @param array $arguments
+     */
+    public function emit($scope, $method, array $arguments = []) {
+        if (!is_null($this->dispatcher)) {
+            $this->dispatcher->dispatch("$scope::$method",
+                new GenericEvent("$scope::$method", $arguments));
+        }
+    }
+
+    public function info($string) {
+        // for now just emit as we did in the past
+        $this->emit('\OC\Repair', 'info', array($string));
+    }
+
+    /**
+     * @param string $message
+     */
+    public function warning($message) {
+        // for now just emit as we did in the past
+        $this->emit('\OC\Repair', 'warning', [$message]);
+    }
+
+    /**
+     * @param int $max
+     */
+    public function startProgress($max = 0) {
+        // for now just emit as we did in the past
+        $this->emit('\OC\Repair', 'startProgress', [$max, $this->currentStep]);
+    }
+
+    /**
+     * @param int $step
+     * @param string $description
+     */
+    public function advance($step = 1, $description = '') {
+        // for now just emit as we did in the past
+        $this->emit('\OC\Repair', 'advance', [$step, $description]);
+    }
+
+    /**
+     * @param int $max
+     */
+    public function finishProgress() {
+        // for now just emit as we did in the past
+        $this->emit('\OC\Repair', 'finishProgress', []);
+    }
 }