OC\DB\MigrationService

Complexity

Total Complexity

53

Size/Duplication

Total Lines	362
Duplicated Lines	8.01 %

Coupling/Cohesion

Components	1
Dependencies	15

Importance

Changes

0

22 Methods

Rating	Name	Duplication	Size	Complexity
B	createMigrationTable()	0	27	3
B	__construct()	0	26	6
A	requireOnce()	0	3	1
A	getApp()	0	3	1
A	getMigratedVersions()	15	15	1
A	getAvailableVersions()	0	4	1
B	findMigrations()	0	31	4
B	getMigrationsToExecute()	0	16	5
A	shallBeExecuted()	0	7	2
A	markAsExecuted()	0	6	1
A	getMigrationsTableName()	0	3	1
A	getMigrationsNamespace()	0	3	1
A	getMigrationsDirectory()	0	3	1
B	getMigration()	0	15	5
A	getRelativeVersion()	0	13	3
A	getCurrentVersion()	0	7	2
A	getClass()	0	9	2
A	setOutput()	0	3	1
A	migrate()	0	7	2
A	createInstance()	14	14	3
B	executeStep()	0	19	5
A	ensureMigrationsAreLoaded()	0	5	2

<?php
/**
 * @author Thomas Müller <thomas.mueller@tmit.eu>
 *
 * @copyright Copyright (c) 2016, ownCloud GmbH.
 * @license AGPL-3.0
 *
 * This code is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License, version 3,
 * as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License, version 3,
 * along with this program.  If not, see <http://www.gnu.org/licenses/>
 *
 */

namespace OC\DB;

use OC\IntegrityCheck\Helpers\AppLocator;
use OC\Migration\SimpleOutput;
use OCP\AppFramework\QueryException;
use OCP\IDBConnection;
use OCP\Migration\IOutput;
use OCP\Migration\ISchemaMigration;
use OCP\Migration\ISimpleMigration;
use OCP\Migration\ISqlMigration;
use Doctrine\DBAL\Schema\Column;
use Doctrine\DBAL\Schema\Table;
use Doctrine\DBAL\Types\Type;

class MigrationService {

	/** @var boolean */
	private $migrationTableCreated;
	/** @var array */
	private $migrations;
	/** @var IOutput */
	private $output;
	/** @var Connection */
	private $connection;
	/** @var string */
	private $appName;

	/**
	 * MigrationService constructor.
	 *
	 * @param $appName
	 * @param IDBConnection $connection
	 * @param AppLocator $appLocator
	 * @param IOutput|null $output
	 * @throws \Exception
	 */
	function __construct($appName, IDBConnection $connection, IOutput $output = null, AppLocator $appLocator = null) {
		$this->appName = $appName;
		$this->connection = $connection;

$connection is of type object<OCP\IDBConnection>, but the property $connection was declared to be of type object<OC\DB\Connection>. Are you sure that you always receive this specific sub-class here, or does it make sense to add an instanceof check?

		$this->output = $output;
		if (is_null($this->output)) {
			$this->output = new SimpleOutput(\OC::$server->getLogger(), $appName);
		}

		if ($appName === 'core') {
			$this->migrationsPath = \OC::$SERVERROOT . '/core/Migrations';

The property migrationsPath does not seem to exist. Did you mean migrations?

			$this->migrationsNamespace = 'OC\\Migrations';

The property migrationsNamespace does not seem to exist. Did you mean migrations?

		} else {
			if (is_null($appLocator)) {
				$appLocator = new AppLocator();
			}
			$appPath = $appLocator->getAppPath($appName);
			$this->migrationsPath = "$appPath/appinfo/Migrations";

The property migrationsPath does not seem to exist. Did you mean migrations?

			$this->migrationsNamespace = "OCA\\$appName\\Migrations";

The property migrationsNamespace does not seem to exist. Did you mean migrations?

		}

		if (!is_dir($this->migrationsPath)) {

The property migrationsPath does not seem to exist. Did you mean migrations?

			if (!mkdir($this->migrationsPath)) {

The property migrationsPath does not seem to exist. Did you mean migrations?

				throw new \Exception("Could not create migration folder \"{$this->migrationsPath}\"");

The property migrationsPath does not seem to exist. Did you mean migrations?

			};
		}
	}

	private static function requireOnce($file) {
		require_once $file;
	}

	/**
	 * Returns the name of the app for which this migration is executed
	 *
	 * @return string
	 */
	public function getApp() {
		return $this->appName;
	}

	/**
	 * @return bool
	 * @codeCoverageIgnore - this will implicitly tested on installation
	 */
	private function createMigrationTable() {
		if ($this->migrationTableCreated) {
			return false;
		}

		if ($this->connection->tableExists('migrations')) {
			$this->migrationTableCreated = true;
			return false;
		}

		$tableName = $this->connection->getPrefix() . 'migrations';
		$tableName = $this->connection->getDatabasePlatform()->quoteIdentifier($tableName);

		$columns = [
			'app' => new Column($this->connection->getDatabasePlatform()->quoteIdentifier('app'), Type::getType('string'), ['length' => 255]),
			'version' => new Column($this->connection->getDatabasePlatform()->quoteIdentifier('version'), Type::getType('string'), ['length' => 255]),
		];
		$table = new Table($tableName, $columns);
		$table->setPrimaryKey([
			$this->connection->getDatabasePlatform()->quoteIdentifier('app'),
			$this->connection->getDatabasePlatform()->quoteIdentifier('version')]);
		$this->connection->getSchemaManager()->createTable($table);

		$this->migrationTableCreated = true;

		return true;
	}

	/**
	 * Returns all versions which have already been applied
	 *
	 * @return string[]
	 * @codeCoverageIgnore - no need to test this
	 */
	public function getMigratedVersions() {
		$this->createMigrationTable();
		$qb = $this->connection->getQueryBuilder();

		$qb->select('version')
			->from('migrations')
			->where($qb->expr()->eq('app', $qb->createNamedParameter($this->getApp())))
			->orderBy('version');

		$result = $qb->execute();
		$rows = $result->fetchAll(\PDO::FETCH_COLUMN);
		$result->closeCursor();

		return $rows;
	}

	/**
	 * Returns all versions which are available in the migration folder
	 *
	 * @return array
	 */
	public function getAvailableVersions() {
		$this->ensureMigrationsAreLoaded();
		return array_keys($this->migrations);
	}

	protected function findMigrations() {
		$directory = realpath($this->migrationsPath);

The property migrationsPath does not seem to exist. Did you mean migrations?

		$iterator = new \RegexIterator(
			new \RecursiveIteratorIterator(
				new \RecursiveDirectoryIterator($directory, \FilesystemIterator::SKIP_DOTS),
				\RecursiveIteratorIterator::LEAVES_ONLY
			),
			'#^.+\\/Version[^\\/]{1,255}\\.php$#i',
			\RegexIterator::GET_MATCH);

		$files = array_keys(iterator_to_array($iterator));
		uasort($files, function ($a, $b) {
			return (basename($a) < basename($b)) ? -1 : 1;
		});

		$migrations = [];

		foreach ($files as $file) {
			static::requireOnce($file);

Since requireOnce() is declared private, calling it with static will lead to errors in possible sub-classes. You can either use self, or increase the visibility of requireOnce() to at least protected.

			$className = basename($file, '.php');
			$version = (string) substr($className, 7);
			if ($version === '0') {
				throw new \InvalidArgumentException(
					"Cannot load a migrations with the name '$version' because it is a reserved number"
				);
			}
			$migrations[$version] = sprintf('%s\\%s', $this->migrationsNamespace, $className);

The property migrationsNamespace does not seem to exist. Did you mean migrations?

		}

		return $migrations;
	}

	/**
	 * @param string $to
	 */
	private function getMigrationsToExecute($to) {
		$knownMigrations = $this->getMigratedVersions();
		$availableMigrations = $this->getAvailableVersions();

		$toBeExecuted = [];
		foreach ($availableMigrations as $v) {
			if ($to !== 'latest' && $v > $to) {
				continue;
			}
			if ($this->shallBeExecuted($v, $knownMigrations)) {
				$toBeExecuted[] = $v;
			}
		}

		return $toBeExecuted;
	}

	/**
	 * @param string[] $knownMigrations
	 */
	private function shallBeExecuted($m, $knownMigrations) {
		if (in_array($m, $knownMigrations)) {
			return false;
		}

		return true;
	}

	/**
	 * @param string $version
	 */
	private function markAsExecuted($version) {
		$this->connection->insertIfNotExist('*PREFIX*migrations', [
			'app' => $this->appName,
			'version' => $version
		]);
	}

	/**
	 * Returns the name of the table which holds the already applied versions
	 *
	 * @return string
	 */
	public function getMigrationsTableName() {
		return $this->connection->getPrefix() . 'migrations';
	}

	/**
	 * Returns the namespace of the version classes
	 *
	 * @return string
	 */
	public function getMigrationsNamespace() {
		return $this->migrationsNamespace;

The property migrationsNamespace does not seem to exist. Did you mean migrations?

	}

	/**
	 * Returns the directory which holds the versions
	 *
	 * @return string
	 */
	public function getMigrationsDirectory() {
		return $this->migrationsPath;

The property migrationsPath does not seem to exist. Did you mean migrations?

	}

	/**
	 * Return the explicit version for the aliases; current, next, prev, latest
	 *
	 * @param string $alias
	 * @return mixed|null|string
	 */
	public function getMigration($alias) {
		switch($alias) {
			case 'current':
				return $this->getCurrentVersion();
			case 'next':
				return $this->getRelativeVersion($this->getCurrentVersion(), 1);
			case 'prev':
				return $this->getRelativeVersion($this->getCurrentVersion(), -1);
			case 'latest':
				$this->ensureMigrationsAreLoaded();

				return @end($this->getAvailableVersions());

$this->getAvailableVersions() cannot be passed to end() as the parameter $array expects a reference.

		}
		return '0';
	}

	/**
	 * @param string $version
	 * @param int $delta
	 * @return null|string
	 */
	private function getRelativeVersion($version, $delta) {
		$this->ensureMigrationsAreLoaded();

		$versions = $this->getAvailableVersions();
		array_unshift($versions, 0);
		$offset = array_search($version, $versions);
		if ($offset === false || !isset($versions[$offset + $delta])) {
			// Unknown version or delta out of bounds.
			return null;
		}

		return (string) $versions[$offset + $delta];
	}

	/**
	 * @return string
	 */
	private function getCurrentVersion() {
		$m = $this->getMigratedVersions();
		if (count($m) === 0) {
			return '0';
		}
		return @end(array_values($m));

array_values($m) cannot be passed to end() as the parameter $array expects a reference.

	}

	/**
	 * @return string
	 */
	private function getClass($version) {
		$this->ensureMigrationsAreLoaded();

		if (isset($this->migrations[$version])) {
			return $this->migrations[$version];
		}

		throw new \InvalidArgumentException("Version $version is unknown.");
	}

	/**
	 * Allows to set an IOutput implementation which is used for logging progress and messages
	 *
	 * @param IOutput $output
	 */
	public function setOutput(IOutput $output) {
		$this->output = $output;
	}

	/**
	 * Applies all not yet applied versions up to $to
	 *
	 * @param string $to
	 */
	public function migrate($to = 'latest') {
		// read known migrations
		$toBeExecuted = $this->getMigrationsToExecute($to);
		foreach ($toBeExecuted as $version) {
			$this->executeStep($version);
		}
	}

	/**
	 * @param string $version
	 */
	protected function createInstance($version) {
		$class = $this->getClass($version);
		try {
			$s = \OC::$server->query($class);
		} catch (QueryException $e) {
			if (class_exists($class)) {
				$s = new $class();
			} else {
				throw new \Exception("Migration step '$class' is unknown");
			}
		}

		return $s;
	}

	/**
	 * Executes one explicit version
	 *
	 * @param string $version
	 */
	public function executeStep($version) {

		$instance = $this->createInstance($version);
		if ($instance instanceof ISimpleMigration) {
			$instance->run($this->output);
		}
		if ($instance instanceof ISqlMigration) {
			$sqls = $instance->sql($this->connection);
			foreach ($sqls as $s) {
				$this->connection->executeQuery($s);
			}
		}
		if ($instance instanceof ISchemaMigration) {
			$toSchema = $this->connection->createSchema();
			$instance->changeSchema($toSchema, ['tablePrefix' => $this->connection->getPrefix()]);
			$this->connection->migrateToSchema($toSchema);
		}
		$this->markAsExecuted($version);
	}

	private function ensureMigrationsAreLoaded() {
		if (empty($this->migrations)) {
			$this->migrations = $this->findMigrations();
		}
	}
}