No OneTemporary
Actions

Size

59 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/config/schema/PhabricatorConfigDatabaseSchema.php b/src/applications/config/schema/PhabricatorConfigDatabaseSchema.php
	index bf0af3f480..216a778e56 100644
	--- a/src/applications/config/schema/PhabricatorConfigDatabaseSchema.php
	+++ b/src/applications/config/schema/PhabricatorConfigDatabaseSchema.php
	@@ -1,71 +1,85 @@
	<?php

	final class PhabricatorConfigDatabaseSchema
	extends PhabricatorConfigStorageSchema {

	private $characterSet;
	private $collation;
	private $tables = array();
	+ private $accessDenied;

	public function addTable(PhabricatorConfigTableSchema $table) {
	$key = $table->getName();
	if (isset($this->tables[$key])) {
	throw new Exception(
	pht('Trying to add duplicate table "%s"!', $key));
	}
	$this->tables[$key] = $table;
	return $this;
	}

	public function getTables() {
	return $this->tables;
	}

	public function getTable($key) {
	return idx($this->tables, $key);
	}

	protected function getSubschemata() {
	return $this->getTables();
	}

	protected function compareToSimilarSchema(
	PhabricatorConfigStorageSchema $expect) {

	$issues = array();
	- if ($this->getCharacterSet() != $expect->getCharacterSet()) {
	- $issues[] = self::ISSUE_CHARSET;
	- }
	-
	- if ($this->getCollation() != $expect->getCollation()) {
	- $issues[] = self::ISSUE_COLLATION;
	+ if ($this->getAccessDenied()) {
	+ $issues[] = self::ISSUE_ACCESSDENIED;
	+ } else {
	+ if ($this->getCharacterSet() != $expect->getCharacterSet()) {
	+ $issues[] = self::ISSUE_CHARSET;
	+ }
	+
	+ if ($this->getCollation() != $expect->getCollation()) {
	+ $issues[] = self::ISSUE_COLLATION;
	+ }
	}

	return $issues;
	}

	public function newEmptyClone() {
	$clone = clone $this;
	$clone->tables = array();
	return $clone;
	}

	public function setCollation($collation) {
	$this->collation = $collation;
	return $this;
	}

	public function getCollation() {
	return $this->collation;
	}

	public function setCharacterSet($character_set) {
	$this->characterSet = $character_set;
	return $this;
	}

	public function getCharacterSet() {
	return $this->characterSet;
	}

	+ public function setAccessDenied($access_denied) {
	+ $this->accessDenied = $access_denied;
	+ return $this;
	+ }
	+
	+ public function getAccessDenied() {
	+ return $this->accessDenied;
	+ }
	+
	}
	diff --git a/src/applications/config/schema/PhabricatorConfigSchemaQuery.php b/src/applications/config/schema/PhabricatorConfigSchemaQuery.php
	index c1e94619ce..ca9b44cc07 100644
	--- a/src/applications/config/schema/PhabricatorConfigSchemaQuery.php
	+++ b/src/applications/config/schema/PhabricatorConfigSchemaQuery.php
	@@ -1,287 +1,314 @@
	<?php

	final class PhabricatorConfigSchemaQuery extends Phobject {

	private $api;

	public function setAPI(PhabricatorStorageManagementAPI $api) {
	$this->api = $api;
	return $this;
	}

	protected function getAPI() {
	if (!$this->api) {
	throw new PhutilInvalidStateException('setAPI');
	}
	return $this->api;
	}

	protected function getConn() {
	return $this->getAPI()->getConn(null);
	}

	private function getDatabaseNames() {
	$api = $this->getAPI();
	$patches = PhabricatorSQLPatchList::buildAllPatches();
	return $api->getDatabaseList(
	$patches,
	$only_living = true);
	}

	public function loadActualSchema() {
	$databases = $this->getDatabaseNames();

	$conn = $this->getConn();
	$tables = queryfx_all(
	$conn,
	'SELECT TABLE_SCHEMA, TABLE_NAME, TABLE_COLLATION
	FROM INFORMATION_SCHEMA.TABLES
	WHERE TABLE_SCHEMA IN (%Ls)',
	$databases);

	$database_info = queryfx_all(
	$conn,
	'SELECT SCHEMA_NAME, DEFAULT_CHARACTER_SET_NAME, DEFAULT_COLLATION_NAME
	FROM INFORMATION_SCHEMA.SCHEMATA
	WHERE SCHEMA_NAME IN (%Ls)',
	$databases);
	$database_info = ipull($database_info, null, 'SCHEMA_NAME');

	+ // Find databases which exist, but which the user does not have permission
	+ // to see.
	+ $invisible_databases = array();
	+ foreach ($databases as $database_name) {
	+ if (isset($database_info[$database_name])) {
	+ continue;
	+ }
	+
	+ try {
	+ queryfx($conn, 'SHOW TABLES IN %T', $database_name);
	+ } catch (AphrontAccessDeniedQueryException $ex) {
	+ // This database exists, the user just doesn't have permission to
	+ // see it.
	+ $invisible_databases[] = $database_name;
	+ } catch (AphrontSchemaQueryException $ex) {
	+ // This database is legitimately missing.
	+ }
	+ }
	+
	$sql = array();
	foreach ($tables as $table) {
	$sql[] = qsprintf(
	$conn,
	'(TABLE_SCHEMA = %s AND TABLE_NAME = %s)',
	$table['TABLE_SCHEMA'],
	$table['TABLE_NAME']);
	}

	if ($sql) {
	$column_info = queryfx_all(
	$conn,
	'SELECT TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME, CHARACTER_SET_NAME,
	COLLATION_NAME, COLUMN_TYPE, IS_NULLABLE, EXTRA
	FROM INFORMATION_SCHEMA.COLUMNS
	WHERE (%Q)',
	'('.implode(') OR (', $sql).')');
	$column_info = igroup($column_info, 'TABLE_SCHEMA');
	} else {
	$column_info = array();
	}

	// NOTE: Tables like KEY_COLUMN_USAGE and TABLE_CONSTRAINTS only contain
	// primary, unique, and foreign keys, so we can't use them here. We pull
	// indexes later on using SHOW INDEXES.

	$server_schema = new PhabricatorConfigServerSchema();

	$tables = igroup($tables, 'TABLE_SCHEMA');
	foreach ($tables as $database_name => $database_tables) {
	$info = $database_info[$database_name];

	$database_schema = id(new PhabricatorConfigDatabaseSchema())
	->setName($database_name)
	->setCharacterSet($info['DEFAULT_CHARACTER_SET_NAME'])
	->setCollation($info['DEFAULT_COLLATION_NAME']);

	$database_column_info = idx($column_info, $database_name, array());
	$database_column_info = igroup($database_column_info, 'TABLE_NAME');

	foreach ($database_tables as $table) {
	$table_name = $table['TABLE_NAME'];

	$table_schema = id(new PhabricatorConfigTableSchema())
	->setName($table_name)
	->setCollation($table['TABLE_COLLATION']);

	$columns = idx($database_column_info, $table_name, array());
	foreach ($columns as $column) {
	if (strpos($column['EXTRA'], 'auto_increment') === false) {
	$auto_increment = false;
	} else {
	$auto_increment = true;
	}

	$column_schema = id(new PhabricatorConfigColumnSchema())
	->setName($column['COLUMN_NAME'])
	->setCharacterSet($column['CHARACTER_SET_NAME'])
	->setCollation($column['COLLATION_NAME'])
	->setColumnType($column['COLUMN_TYPE'])
	->setNullable($column['IS_NULLABLE'] == 'YES')
	->setAutoIncrement($auto_increment);

	$table_schema->addColumn($column_schema);
	}

	$key_parts = queryfx_all(
	$conn,
	'SHOW INDEXES FROM %T.%T',
	$database_name,
	$table_name);
	$keys = igroup($key_parts, 'Key_name');
	foreach ($keys as $key_name => $key_pieces) {
	$key_pieces = isort($key_pieces, 'Seq_in_index');
	$head = head($key_pieces);

	// This handles string indexes which index only a prefix of a field.
	$column_names = array();
	foreach ($key_pieces as $piece) {
	$name = $piece['Column_name'];
	if ($piece['Sub_part']) {
	$name = $name.'('.$piece['Sub_part'].')';
	}
	$column_names[] = $name;
	}

	$key_schema = id(new PhabricatorConfigKeySchema())
	->setName($key_name)
	->setColumnNames($column_names)
	->setUnique(!$head['Non_unique'])
	->setIndexType($head['Index_type']);

	$table_schema->addKey($key_schema);
	}

	$database_schema->addTable($table_schema);
	}

	$server_schema->addDatabase($database_schema);
	}

	+ foreach ($invisible_databases as $database_name) {
	+ $server_schema->addDatabase(
	+ id(new PhabricatorConfigDatabaseSchema())
	+ ->setName($database_name)
	+ ->setAccessDenied(true));
	+ }
	+
	return $server_schema;
	}

	public function loadExpectedSchema() {
	$databases = $this->getDatabaseNames();
	$info = $this->getAPI()->getCharsetInfo();

	$specs = id(new PhutilClassMapQuery())
	->setAncestorClass('PhabricatorConfigSchemaSpec')
	->execute();

	$server_schema = new PhabricatorConfigServerSchema();
	foreach ($specs as $spec) {
	$spec
	->setUTF8Charset(
	$info[PhabricatorStorageManagementAPI::CHARSET_DEFAULT])
	->setUTF8BinaryCollation(
	$info[PhabricatorStorageManagementAPI::COLLATE_TEXT])
	->setUTF8SortingCollation(
	$info[PhabricatorStorageManagementAPI::COLLATE_SORT])
	->setServer($server_schema)
	->buildSchemata($server_schema);
	}

	return $server_schema;
	}

	public function buildComparisonSchema(
	PhabricatorConfigServerSchema $expect,
	PhabricatorConfigServerSchema $actual) {

	$comp_server = $actual->newEmptyClone();

	$all_databases = $actual->getDatabases() + $expect->getDatabases();
	foreach ($all_databases as $database_name => $database_template) {
	$actual_database = $actual->getDatabase($database_name);
	$expect_database = $expect->getDatabase($database_name);

	$issues = $this->compareSchemata($expect_database, $actual_database);

	$comp_database = $database_template->newEmptyClone()
	->setIssues($issues);

	if (!$actual_database) {
	$actual_database = $expect_database->newEmptyClone();
	}
	+
	if (!$expect_database) {
	$expect_database = $actual_database->newEmptyClone();
	}

	$all_tables =
	$actual_database->getTables() +
	$expect_database->getTables();
	foreach ($all_tables as $table_name => $table_template) {
	$actual_table = $actual_database->getTable($table_name);
	$expect_table = $expect_database->getTable($table_name);

	$issues = $this->compareSchemata($expect_table, $actual_table);

	$comp_table = $table_template->newEmptyClone()
	->setIssues($issues);

	if (!$actual_table) {
	$actual_table = $expect_table->newEmptyClone();
	}
	if (!$expect_table) {
	$expect_table = $actual_table->newEmptyClone();
	}

	$all_columns =
	$actual_table->getColumns() +
	$expect_table->getColumns();
	foreach ($all_columns as $column_name => $column_template) {
	$actual_column = $actual_table->getColumn($column_name);
	$expect_column = $expect_table->getColumn($column_name);

	$issues = $this->compareSchemata($expect_column, $actual_column);

	$comp_column = $column_template->newEmptyClone()
	->setIssues($issues);

	$comp_table->addColumn($comp_column);
	}

	$all_keys =
	$actual_table->getKeys() +
	$expect_table->getKeys();
	foreach ($all_keys as $key_name => $key_template) {
	$actual_key = $actual_table->getKey($key_name);
	$expect_key = $expect_table->getKey($key_name);

	$issues = $this->compareSchemata($expect_key, $actual_key);

	$comp_key = $key_template->newEmptyClone()
	->setIssues($issues);

	$comp_table->addKey($comp_key);
	}

	$comp_database->addTable($comp_table);
	}
	$comp_server->addDatabase($comp_database);
	}

	return $comp_server;
	}

	private function compareSchemata(
	PhabricatorConfigStorageSchema $expect = null,
	PhabricatorConfigStorageSchema $actual = null) {

	$expect_is_key = ($expect instanceof PhabricatorConfigKeySchema);
	$actual_is_key = ($actual instanceof PhabricatorConfigKeySchema);

	if ($expect_is_key \|\| $actual_is_key) {
	$missing_issue = PhabricatorConfigStorageSchema::ISSUE_MISSINGKEY;
	$surplus_issue = PhabricatorConfigStorageSchema::ISSUE_SURPLUSKEY;
	} else {
	$missing_issue = PhabricatorConfigStorageSchema::ISSUE_MISSING;
	$surplus_issue = PhabricatorConfigStorageSchema::ISSUE_SURPLUS;
	}

	if (!$expect && !$actual) {
	throw new Exception(pht('Can not compare two missing schemata!'));
	} else if ($expect && !$actual) {
	$issues = array($missing_issue);
	} else if ($actual && !$expect) {
	$issues = array($surplus_issue);
	} else {
	$issues = $actual->compareTo($expect);
	}

	return $issues;
	}


	}
	diff --git a/src/applications/config/schema/PhabricatorConfigStorageSchema.php b/src/applications/config/schema/PhabricatorConfigStorageSchema.php
	index 74856053e4..706be80568 100644
	--- a/src/applications/config/schema/PhabricatorConfigStorageSchema.php
	+++ b/src/applications/config/schema/PhabricatorConfigStorageSchema.php
	@@ -1,224 +1,228 @@
	<?php

	abstract class PhabricatorConfigStorageSchema extends Phobject {

	const ISSUE_MISSING = 'missing';
	const ISSUE_MISSINGKEY = 'missingkey';
	const ISSUE_SURPLUS = 'surplus';
	const ISSUE_SURPLUSKEY = 'surpluskey';
	const ISSUE_CHARSET = 'charset';
	const ISSUE_COLLATION = 'collation';
	const ISSUE_COLUMNTYPE = 'columntype';
	const ISSUE_NULLABLE = 'nullable';
	const ISSUE_KEYCOLUMNS = 'keycolumns';
	const ISSUE_UNIQUE = 'unique';
	const ISSUE_LONGKEY = 'longkey';
	const ISSUE_SUBWARN = 'subwarn';
	const ISSUE_SUBFAIL = 'subfail';
	const ISSUE_AUTOINCREMENT = 'autoincrement';
	const ISSUE_UNKNOWN = 'unknown';
	+ const ISSUE_ACCESSDENIED = 'accessdenied';

	const STATUS_OKAY = 'okay';
	const STATUS_WARN = 'warn';
	const STATUS_FAIL = 'fail';

	private $issues = array();
	private $name;

	abstract public function newEmptyClone();
	abstract protected function compareToSimilarSchema(
	PhabricatorConfigStorageSchema $expect);
	abstract protected function getSubschemata();

	public function compareTo(PhabricatorConfigStorageSchema $expect) {
	if (get_class($expect) != get_class($this)) {
	throw new Exception(pht('Classes must match to compare schemata!'));
	}

	if ($this->getName() != $expect->getName()) {
	throw new Exception(pht('Names must match to compare schemata!'));
	}

	return $this->compareToSimilarSchema($expect);
	}

	public function setName($name) {
	$this->name = $name;
	return $this;
	}

	public function getName() {
	return $this->name;
	}

	public function setIssues(array $issues) {
	$this->issues = array_fuse($issues);
	return $this;
	}

	public function getIssues() {
	$issues = $this->issues;

	foreach ($this->getSubschemata() as $sub) {
	switch ($sub->getStatus()) {
	case self::STATUS_WARN:
	$issues[self::ISSUE_SUBWARN] = self::ISSUE_SUBWARN;
	break;
	case self::STATUS_FAIL:
	$issues[self::ISSUE_SUBFAIL] = self::ISSUE_SUBFAIL;
	break;
	}
	}

	return $issues;
	}

	public function getLocalIssues() {
	return $this->issues;
	}

	public function hasIssue($issue) {
	return (bool)idx($this->getIssues(), $issue);
	}

	public function getAllIssues() {
	$issues = $this->getIssues();
	foreach ($this->getSubschemata() as $sub) {
	$issues += $sub->getAllIssues();
	}
	return $issues;
	}

	public function getStatus() {
	$status = self::STATUS_OKAY;
	foreach ($this->getAllIssues() as $issue) {
	$issue_status = self::getIssueStatus($issue);
	$status = self::getStrongestStatus($status, $issue_status);
	}
	return $status;
	}

	public static function getIssueName($issue) {
	switch ($issue) {
	case self::ISSUE_MISSING:
	return pht('Missing');
	case self::ISSUE_MISSINGKEY:
	return pht('Missing Key');
	case self::ISSUE_SURPLUS:
	return pht('Surplus');
	case self::ISSUE_SURPLUSKEY:
	return pht('Surplus Key');
	case self::ISSUE_CHARSET:
	return pht('Better Character Set Available');
	case self::ISSUE_COLLATION:
	return pht('Better Collation Available');
	case self::ISSUE_COLUMNTYPE:
	return pht('Wrong Column Type');
	case self::ISSUE_NULLABLE:
	return pht('Wrong Nullable Setting');
	case self::ISSUE_KEYCOLUMNS:
	return pht('Key on Wrong Columns');
	case self::ISSUE_UNIQUE:
	return pht('Key has Wrong Uniqueness');
	case self::ISSUE_LONGKEY:
	return pht('Key is Too Long');
	case self::ISSUE_SUBWARN:
	return pht('Subschemata Have Warnings');
	case self::ISSUE_SUBFAIL:
	return pht('Subschemata Have Failures');
	case self::ISSUE_AUTOINCREMENT:
	return pht('Column has Wrong Autoincrement');
	case self::ISSUE_UNKNOWN:
	return pht('Column Has No Specification');
	+ case self::ISSUE_ACCESSDENIED:
	+ return pht('Access Denied');
	default:
	throw new Exception(pht('Unknown schema issue "%s"!', $issue));
	}
	}

	public static function getIssueDescription($issue) {
	switch ($issue) {
	case self::ISSUE_MISSING:
	return pht('This schema is expected to exist, but does not.');
	case self::ISSUE_MISSINGKEY:
	return pht('This key is expected to exist, but does not.');
	case self::ISSUE_SURPLUS:
	return pht('This schema is not expected to exist.');
	case self::ISSUE_SURPLUSKEY:
	return pht('This key is not expected to exist.');
	case self::ISSUE_CHARSET:
	return pht('This schema can use a better character set.');
	case self::ISSUE_COLLATION:
	return pht('This schema can use a better collation.');
	case self::ISSUE_COLUMNTYPE:
	return pht('This schema can use a better column type.');
	case self::ISSUE_NULLABLE:
	return pht('This schema has the wrong nullable setting.');
	case self::ISSUE_KEYCOLUMNS:
	return pht('This key is on the wrong columns.');
	case self::ISSUE_UNIQUE:
	return pht('This key has the wrong uniqueness setting.');
	case self::ISSUE_LONGKEY:
	return pht('This key is too long for utf8mb4.');
	case self::ISSUE_SUBWARN:
	return pht('Subschemata have setup warnings.');
	case self::ISSUE_SUBFAIL:
	return pht('Subschemata have setup failures.');
	case self::ISSUE_AUTOINCREMENT:
	return pht('This column has the wrong autoincrement setting.');
	case self::ISSUE_UNKNOWN:
	return pht('This column is missing a type specification.');
	default:
	throw new Exception(pht('Unknown schema issue "%s"!', $issue));
	}
	}

	public static function getIssueStatus($issue) {
	switch ($issue) {
	case self::ISSUE_MISSING:
	+ case self::ISSUE_ACCESSDENIED:
	case self::ISSUE_SURPLUS:
	case self::ISSUE_NULLABLE:
	case self::ISSUE_SUBFAIL:
	case self::ISSUE_UNKNOWN:
	return self::STATUS_FAIL;
	case self::ISSUE_SUBWARN:
	case self::ISSUE_COLUMNTYPE:
	case self::ISSUE_CHARSET:
	case self::ISSUE_COLLATION:
	case self::ISSUE_MISSINGKEY:
	case self::ISSUE_SURPLUSKEY:
	case self::ISSUE_UNIQUE:
	case self::ISSUE_KEYCOLUMNS:
	case self::ISSUE_LONGKEY:
	case self::ISSUE_AUTOINCREMENT:
	return self::STATUS_WARN;
	default:
	throw new Exception(pht('Unknown schema issue "%s"!', $issue));
	}
	}

	public static function getStatusSeverity($status) {
	switch ($status) {
	case self::STATUS_FAIL:
	return 2;
	case self::STATUS_WARN:
	return 1;
	case self::STATUS_OKAY:
	return 0;
	default:
	throw new Exception(pht('Unknown schema status "%s"!', $status));
	}
	}

	public static function getStrongestStatus($u, $v) {
	$u_sev = self::getStatusSeverity($u);
	$v_sev = self::getStatusSeverity($v);

	if ($u_sev >= $v_sev) {
	return $u;
	} else {
	return $v;
	}
	}


	}
	diff --git a/src/infrastructure/storage/management/PhabricatorStorageManagementAPI.php b/src/infrastructure/storage/management/PhabricatorStorageManagementAPI.php
	index 76e8e0a057..ae83be216c 100644
	--- a/src/infrastructure/storage/management/PhabricatorStorageManagementAPI.php
	+++ b/src/infrastructure/storage/management/PhabricatorStorageManagementAPI.php
	@@ -1,336 +1,346 @@
	<?php

	final class PhabricatorStorageManagementAPI extends Phobject {

	private $host;
	private $user;
	private $port;
	private $password;
	private $namespace;
	private $conns = array();
	private $disableUTF8MB4;

	const CHARSET_DEFAULT = 'CHARSET';
	const CHARSET_SORT = 'CHARSET_SORT';
	const CHARSET_FULLTEXT = 'CHARSET_FULLTEXT';
	const COLLATE_TEXT = 'COLLATE_TEXT';
	const COLLATE_SORT = 'COLLATE_SORT';
	const COLLATE_FULLTEXT = 'COLLATE_FULLTEXT';

	const TABLE_STATUS = 'patch_status';

	public function setDisableUTF8MB4($disable_utf8_mb4) {
	$this->disableUTF8MB4 = $disable_utf8_mb4;
	return $this;
	}

	public function getDisableUTF8MB4() {
	return $this->disableUTF8MB4;
	}

	public function setNamespace($namespace) {
	$this->namespace = $namespace;
	PhabricatorLiskDAO::pushStorageNamespace($namespace);
	return $this;
	}

	public function getNamespace() {
	return $this->namespace;
	}

	public function setUser($user) {
	$this->user = $user;
	return $this;
	}

	public function getUser() {
	return $this->user;
	}

	public function setPassword($password) {
	$this->password = $password;
	return $this;
	}

	public function getPassword() {
	return $this->password;
	}

	public function setHost($host) {
	$this->host = $host;
	return $this;
	}

	public function getHost() {
	return $this->host;
	}

	public function setPort($port) {
	$this->port = $port;
	return $this;
	}

	public function getPort() {
	return $this->port;
	}

	public function getDatabaseName($fragment) {
	return $this->namespace.'_'.$fragment;
	}

	public function getDatabaseList(array $patches, $only_living = false) {
	assert_instances_of($patches, 'PhabricatorStoragePatch');

	$list = array();

	foreach ($patches as $patch) {
	if ($patch->getType() == 'db') {
	if ($only_living && $patch->isDead()) {
	continue;
	}
	$list[] = $this->getDatabaseName($patch->getName());
	}
	}

	return $list;
	}

	public function getConn($fragment) {
	$database = $this->getDatabaseName($fragment);
	$return = &$this->conns[$this->host][$this->user][$database];
	if (!$return) {
	$return = PhabricatorEnv::newObjectFromConfig(
	'mysql.implementation',
	array(
	array(
	'user' => $this->user,
	'pass' => $this->password,
	'host' => $this->host,
	'port' => $this->port,
	'database' => $fragment
	? $database
	: null,
	),
	));
	}
	return $return;
	}

	public function getAppliedPatches() {
	try {
	$applied = queryfx_all(
	$this->getConn('meta_data'),
	'SELECT patch FROM %T',
	self::TABLE_STATUS);
	return ipull($applied, 'patch');
	+ } catch (AphrontAccessDeniedQueryException $ex) {
	+ throw new PhutilProxyException(
	+ pht(
	+ 'Failed while trying to read schema status: the database "%s" '.
	+ 'exists, but the current user ("%s") does not have permission to '.
	+ 'access it. GRANT the current user more permissions, or use a '.
	+ 'different user.',
	+ $this->getDatabaseName('meta_data'),
	+ $this->getUser()),
	+ $ex);
	} catch (AphrontQueryException $ex) {
	return null;
	}
	}

	public function getPatchDurations() {
	try {
	$rows = queryfx_all(
	$this->getConn('meta_data'),
	'SELECT patch, duration FROM %T WHERE duration IS NOT NULL',
	self::TABLE_STATUS);
	return ipull($rows, 'duration', 'patch');
	} catch (AphrontQueryException $ex) {
	return array();
	}
	}

	public function createDatabase($fragment) {
	$info = $this->getCharsetInfo();

	queryfx(
	$this->getConn(null),
	'CREATE DATABASE IF NOT EXISTS %T COLLATE %T',
	$this->getDatabaseName($fragment),
	$info[self::COLLATE_TEXT]);
	}

	public function createTable($fragment, $table, array $cols) {
	queryfx(
	$this->getConn($fragment),
	'CREATE TABLE IF NOT EXISTS %T.%T (%Q) '.
	'ENGINE=InnoDB, COLLATE utf8_general_ci',
	$this->getDatabaseName($fragment),
	$table,
	implode(', ', $cols));
	}

	public function getLegacyPatches(array $patches) {
	assert_instances_of($patches, 'PhabricatorStoragePatch');

	try {
	$row = queryfx_one(
	$this->getConn('meta_data'),
	'SELECT version FROM %T',
	'schema_version');
	$version = $row['version'];
	} catch (AphrontQueryException $ex) {
	return array();
	}

	$legacy = array();
	foreach ($patches as $key => $patch) {
	if ($patch->getLegacy() !== false && $patch->getLegacy() <= $version) {
	$legacy[] = $key;
	}
	}

	return $legacy;
	}

	public function markPatchApplied($patch, $duration = null) {
	$conn = $this->getConn('meta_data');

	queryfx(
	$conn,
	'INSERT INTO %T (patch, applied) VALUES (%s, %d)',
	self::TABLE_STATUS,
	$patch,
	time());

	// We didn't add this column for a long time, so it may not exist yet.
	if ($duration !== null) {
	try {
	queryfx(
	$conn,
	'UPDATE %T SET duration = %d WHERE patch = %s',
	self::TABLE_STATUS,
	(int)floor($duration * 1000000),
	$patch);
	} catch (AphrontQueryException $ex) {
	// Just ignore this, as it almost certainly indicates that we just
	// don't have the column yet.
	}
	}
	}

	public function applyPatch(PhabricatorStoragePatch $patch) {
	$type = $patch->getType();
	$name = $patch->getName();
	switch ($type) {
	case 'db':
	$this->createDatabase($name);
	break;
	case 'sql':
	$this->applyPatchSQL($name);
	break;
	case 'php':
	$this->applyPatchPHP($name);
	break;
	default:
	throw new Exception(pht("Unable to apply patch of type '%s'.", $type));
	}
	}

	public function applyPatchSQL($sql) {
	$sql = Filesystem::readFile($sql);
	$queries = preg_split('/;\s+/', $sql);
	$queries = array_filter($queries);

	$conn = $this->getConn(null);

	$charset_info = $this->getCharsetInfo();
	foreach ($charset_info as $key => $value) {
	$charset_info[$key] = qsprintf($conn, '%T', $value);
	}

	foreach ($queries as $query) {
	$query = str_replace('{$NAMESPACE}', $this->namespace, $query);

	foreach ($charset_info as $key => $value) {
	$query = str_replace('{$'.$key.'}', $value, $query);
	}

	queryfx(
	$conn,
	'%Q',
	$query);
	}
	}

	public function applyPatchPHP($script) {
	$schema_conn = $this->getConn(null);
	require_once $script;
	}

	public function isCharacterSetAvailable($character_set) {
	if ($character_set == 'utf8mb4') {
	if ($this->getDisableUTF8MB4()) {
	return false;
	}
	}

	$conn = $this->getConn(null);
	return self::isCharacterSetAvailableOnConnection($character_set, $conn);
	}

	public static function isCharacterSetAvailableOnConnection(
	$character_set,
	AphrontDatabaseConnection $conn) {
	$result = queryfx_one(
	$conn,
	'SELECT CHARACTER_SET_NAME FROM INFORMATION_SCHEMA.CHARACTER_SETS
	WHERE CHARACTER_SET_NAME = %s',
	$character_set);

	return (bool)$result;
	}

	public function getCharsetInfo() {
	if ($this->isCharacterSetAvailable('utf8mb4')) {
	// If utf8mb4 is available, we use it with the utf8mb4_unicode_ci
	// collation. This is most correct, and will sort properly.

	$charset = 'utf8mb4';
	$charset_sort = 'utf8mb4';
	$charset_full = 'utf8mb4';
	$collate_text = 'utf8mb4_bin';
	$collate_sort = 'utf8mb4_unicode_ci';
	$collate_full = 'utf8mb4_unicode_ci';
	} else {
	// If utf8mb4 is not available, we use binary for most data. This allows
	// us to store 4-byte unicode characters.
	//
	// It's possible that strings will be truncated in the middle of a
	// character on insert. We encourage users to set STRICT_ALL_TABLES
	// to prevent this.
	//
	// For "fulltext" and "sort" columns, we don't use binary.
	//
	// With "fulltext", we can not use binary because MySQL won't let us.
	// We use 3-byte utf8 instead and accept being unable to index 4-byte
	// characters.
	//
	// With "sort", if we use binary we lose case insensitivity (for
	// example, "ALincoln@logcabin.com" and "alincoln@logcabin.com" would no
	// longer be identified as the same email address). This can be very
	// confusing and is far worse overall than not supporting 4-byte unicode
	// characters, so we use 3-byte utf8 and accept limited 4-byte support as
	// a tradeoff to get sensible collation behavior. Many columns where
	// collation is important rarely contain 4-byte characters anyway, so we
	// are not giving up too much.

	$charset = 'binary';
	$charset_sort = 'utf8';
	$charset_full = 'utf8';
	$collate_text = 'binary';
	$collate_sort = 'utf8_general_ci';
	$collate_full = 'utf8_general_ci';
	}

	return array(
	self::CHARSET_DEFAULT => $charset,
	self::CHARSET_SORT => $charset_sort,
	self::CHARSET_FULLTEXT => $charset_full,
	self::COLLATE_TEXT => $collate_text,
	self::COLLATE_SORT => $collate_sort,
	self::COLLATE_FULLTEXT => $collate_full,
	);
	}

	}
	diff --git a/src/infrastructure/storage/management/workflow/PhabricatorStorageManagementWorkflow.php b/src/infrastructure/storage/management/workflow/PhabricatorStorageManagementWorkflow.php
	index cbb88ce818..cc917215ee 100644
	--- a/src/infrastructure/storage/management/workflow/PhabricatorStorageManagementWorkflow.php
	+++ b/src/infrastructure/storage/management/workflow/PhabricatorStorageManagementWorkflow.php
	@@ -1,902 +1,935 @@
	<?php

	abstract class PhabricatorStorageManagementWorkflow
	extends PhabricatorManagementWorkflow {

	private $api;
	private $dryRun;
	private $force;
	private $patches;

	final public function getAPI() {
	return $this->api;
	}

	final public function setAPI(PhabricatorStorageManagementAPI $api) {
	$this->api = $api;
	return $this;
	}

	final protected function isDryRun() {
	return $this->dryRun;
	}

	final protected function setDryRun($dry_run) {
	$this->dryRun = $dry_run;
	return $this;
	}

	final protected function isForce() {
	return $this->force;
	}

	final protected function setForce($force) {
	$this->force = $force;
	return $this;
	}

	public function getPatches() {
	return $this->patches;
	}

	public function setPatches(array $patches) {
	assert_instances_of($patches, 'PhabricatorStoragePatch');
	$this->patches = $patches;
	return $this;
	}


	public function execute(PhutilArgumentParser $args) {
	$this->setDryRun($args->getArg('dryrun'));
	$this->setForce($args->getArg('force'));

	$this->didExecute($args);
	}

	public function didExecute(PhutilArgumentParser $args) {}

	private function loadSchemata() {
	$query = id(new PhabricatorConfigSchemaQuery())
	->setAPI($this->getAPI());

	$actual = $query->loadActualSchema();
	$expect = $query->loadExpectedSchema();
	$comp = $query->buildComparisonSchema($expect, $actual);

	return array($comp, $expect, $actual);
	}

	final protected function adjustSchemata($unsafe) {
	$lock = $this->lock();

	try {
	$this->doAdjustSchemata($unsafe);
	} catch (Exception $ex) {
	$lock->unlock();
	throw $ex;
	}

	$lock->unlock();
	}

	final private function doAdjustSchemata($unsafe) {
	$console = PhutilConsole::getConsole();

	$console->writeOut(
	"%s\n",
	pht('Verifying database schemata...'));

	list($adjustments, $errors) = $this->findAdjustments();
	$api = $this->getAPI();

	if (!$adjustments) {
	$console->writeOut(
	"%s\n",
	pht('Found no adjustments for schemata.'));

	return $this->printErrors($errors, 0);
	}

	if (!$this->force && !$api->isCharacterSetAvailable('utf8mb4')) {
	$message = pht(
	"You have an old version of MySQL (older than 5.5) which does not ".
	"support the utf8mb4 character set. We strongly recomend upgrading to ".
	"5.5 or newer.\n\n".
	"If you apply adjustments now and later update MySQL to 5.5 or newer, ".
	"you'll need to apply adjustments again (and they will take a long ".
	"time).\n\n".
	"You can exit this workflow, update MySQL now, and then run this ".
	"workflow again. This is recommended, but may cause a lot of downtime ".
	"right now.\n\n".
	"You can exit this workflow, continue using Phabricator without ".
	"applying adjustments, update MySQL at a later date, and then run ".
	"this workflow again. This is also a good approach, and will let you ".
	"delay downtime until later.\n\n".
	"You can proceed with this workflow, and then optionally update ".
	"MySQL at a later date. After you do, you'll need to apply ".
	"adjustments again.\n\n".
	"For more information, see \"Managing Storage Adjustments\" in ".
	"the documentation.");

	$console->writeOut(
	"\n<bg:yellow> %s </bg>\n\n%s\n",
	pht('OLD MySQL VERSION'),
	phutil_console_wrap($message));

	$prompt = pht('Continue with old MySQL version?');
	if (!phutil_console_confirm($prompt, $default_no = true)) {
	return;
	}
	}

	$table = id(new PhutilConsoleTable())
	->addColumn('database', array('title' => pht('Database')))
	->addColumn('table', array('title' => pht('Table')))
	->addColumn('name', array('title' => pht('Name')))
	->addColumn('info', array('title' => pht('Issues')));

	foreach ($adjustments as $adjust) {
	$info = array();
	foreach ($adjust['issues'] as $issue) {
	$info[] = PhabricatorConfigStorageSchema::getIssueName($issue);
	}

	$table->addRow(array(
	'database' => $adjust['database'],
	'table' => idx($adjust, 'table'),
	'name' => idx($adjust, 'name'),
	'info' => implode(', ', $info),
	));
	}

	$console->writeOut("\n\n");

	$table->draw();

	if ($this->dryRun) {
	$console->writeOut(
	"%s\n",
	pht('DRYRUN: Would apply adjustments.'));
	return 0;
	} else if (!$this->force) {
	$console->writeOut(
	"\n%s\n",
	pht(
	"Found %s issues(s) with schemata, detailed above.\n\n".
	"You can review issues in more detail from the web interface, ".
	"in Config > Database Status. To better understand the adjustment ".
	"workflow, see \"Managing Storage Adjustments\" in the ".
	"documentation.\n\n".
	"MySQL needs to copy table data to make some adjustments, so these ".
	"migrations may take some time.",
	phutil_count($adjustments)));

	$prompt = pht('Fix these schema issues?');
	if (!phutil_console_confirm($prompt, $default_no = true)) {
	return 1;
	}
	}

	$console->writeOut(
	"%s\n",
	pht('Fixing schema issues...'));

	$conn = $api->getConn(null);

	if ($unsafe) {
	queryfx($conn, 'SET SESSION sql_mode = %s', '');
	} else {
	queryfx($conn, 'SET SESSION sql_mode = %s', 'STRICT_ALL_TABLES');
	}

	$failed = array();

	// We make changes in several phases.
	$phases = array(
	// Drop surplus autoincrements. This allows us to drop primary keys on
	// autoincrement columns.
	'drop_auto',

	// Drop all keys we're going to adjust. This prevents them from
	// interfering with column changes.
	'drop_keys',

	// Apply all database, table, and column changes.
	'main',

	// Restore adjusted keys.
	'add_keys',

	// Add missing autoincrements.
	'add_auto',
	);

	$bar = id(new PhutilConsoleProgressBar())
	->setTotal(count($adjustments) * count($phases));

	foreach ($phases as $phase) {
	foreach ($adjustments as $adjust) {
	try {
	switch ($adjust['kind']) {
	case 'database':
	if ($phase == 'main') {
	queryfx(
	$conn,
	'ALTER DATABASE %T CHARACTER SET = %s COLLATE = %s',
	$adjust['database'],
	$adjust['charset'],
	$adjust['collation']);
	}
	break;
	case 'table':
	if ($phase == 'main') {
	queryfx(
	$conn,
	'ALTER TABLE %T.%T COLLATE = %s',
	$adjust['database'],
	$adjust['table'],
	$adjust['collation']);
	}
	break;
	case 'column':
	$apply = false;
	$auto = false;
	$new_auto = idx($adjust, 'auto');
	if ($phase == 'drop_auto') {
	if ($new_auto === false) {
	$apply = true;
	$auto = false;
	}
	} else if ($phase == 'main') {
	$apply = true;
	if ($new_auto === false) {
	$auto = false;
	} else {
	$auto = $adjust['is_auto'];
	}
	} else if ($phase == 'add_auto') {
	if ($new_auto === true) {
	$apply = true;
	$auto = true;
	}
	}

	if ($apply) {
	$parts = array();

	if ($auto) {
	$parts[] = qsprintf(
	$conn,
	'AUTO_INCREMENT');
	}

	if ($adjust['charset']) {
	$parts[] = qsprintf(
	$conn,
	'CHARACTER SET %Q COLLATE %Q',
	$adjust['charset'],
	$adjust['collation']);
	}

	queryfx(
	$conn,
	'ALTER TABLE %T.%T MODIFY %T %Q %Q %Q',
	$adjust['database'],
	$adjust['table'],
	$adjust['name'],
	$adjust['type'],
	implode(' ', $parts),
	$adjust['nullable'] ? 'NULL' : 'NOT NULL');
	}
	break;
	case 'key':
	if (($phase == 'drop_keys') && $adjust['exists']) {
	if ($adjust['name'] == 'PRIMARY') {
	$key_name = 'PRIMARY KEY';
	} else {
	$key_name = qsprintf($conn, 'KEY %T', $adjust['name']);
	}

	queryfx(
	$conn,
	'ALTER TABLE %T.%T DROP %Q',
	$adjust['database'],
	$adjust['table'],
	$key_name);
	}

	if (($phase == 'add_keys') && $adjust['keep']) {
	// Different keys need different creation syntax. Notable
	// special cases are primary keys and fulltext keys.
	if ($adjust['name'] == 'PRIMARY') {
	$key_name = 'PRIMARY KEY';
	} else if ($adjust['indexType'] == 'FULLTEXT') {
	$key_name = qsprintf($conn, 'FULLTEXT %T', $adjust['name']);
	} else {
	if ($adjust['unique']) {
	$key_name = qsprintf(
	$conn,
	'UNIQUE KEY %T',
	$adjust['name']);
	} else {
	$key_name = qsprintf(
	$conn,
	'/* NONUNIQUE */ KEY %T',
	$adjust['name']);
	}
	}

	queryfx(
	$conn,
	'ALTER TABLE %T.%T ADD %Q (%Q)',
	$adjust['database'],
	$adjust['table'],
	$key_name,
	implode(', ', $adjust['columns']));
	}
	break;
	default:
	throw new Exception(
	pht('Unknown schema adjustment kind "%s"!', $adjust['kind']));
	}
	} catch (AphrontQueryException $ex) {
	$failed[] = array($adjust, $ex);
	}
	$bar->update(1);
	}
	}
	$bar->done();

	if (!$failed) {
	$console->writeOut(
	"%s\n",
	pht('Completed fixing all schema issues.'));

	$err = 0;
	} else {
	$table = id(new PhutilConsoleTable())
	->addColumn('target', array('title' => pht('Target')))
	->addColumn('error', array('title' => pht('Error')));

	foreach ($failed as $failure) {
	list($adjust, $ex) = $failure;

	$pieces = array_select_keys(
	$adjust,
	array('database', 'table', 'name'));
	$pieces = array_filter($pieces);
	$target = implode('.', $pieces);

	$table->addRow(
	array(
	'target' => $target,
	'error' => $ex->getMessage(),
	));
	}

	$console->writeOut("\n");
	$table->draw();
	$console->writeOut(
	"\n%s\n",
	pht('Failed to make some schema adjustments, detailed above.'));
	$console->writeOut(
	"%s\n",
	pht(
	'For help troubleshooting adjustments, see "Managing Storage '.
	'Adjustments" in the documentation.'));

	$err = 1;
	}

	return $this->printErrors($errors, $err);
	}

	private function findAdjustments() {
	list($comp, $expect, $actual) = $this->loadSchemata();

	$issue_charset = PhabricatorConfigStorageSchema::ISSUE_CHARSET;
	$issue_collation = PhabricatorConfigStorageSchema::ISSUE_COLLATION;
	$issue_columntype = PhabricatorConfigStorageSchema::ISSUE_COLUMNTYPE;
	$issue_surpluskey = PhabricatorConfigStorageSchema::ISSUE_SURPLUSKEY;
	$issue_missingkey = PhabricatorConfigStorageSchema::ISSUE_MISSINGKEY;
	$issue_columns = PhabricatorConfigStorageSchema::ISSUE_KEYCOLUMNS;
	$issue_unique = PhabricatorConfigStorageSchema::ISSUE_UNIQUE;
	$issue_longkey = PhabricatorConfigStorageSchema::ISSUE_LONGKEY;
	$issue_auto = PhabricatorConfigStorageSchema::ISSUE_AUTOINCREMENT;

	$adjustments = array();
	$errors = array();
	foreach ($comp->getDatabases() as $database_name => $database) {
	foreach ($this->findErrors($database) as $issue) {
	$errors[] = array(
	'database' => $database_name,
	'issue' => $issue,
	);
	}

	$expect_database = $expect->getDatabase($database_name);
	$actual_database = $actual->getDatabase($database_name);

	if (!$expect_database \|\| !$actual_database) {
	// If there's a real issue here, skip this stuff.
	continue;
	}

	+ if ($actual_database->getAccessDenied()) {
	+ // If we can't access the database, we can't access the tables either.
	+ continue;
	+ }
	+
	$issues = array();
	if ($database->hasIssue($issue_charset)) {
	$issues[] = $issue_charset;
	}
	if ($database->hasIssue($issue_collation)) {
	$issues[] = $issue_collation;
	}

	if ($issues) {
	$adjustments[] = array(
	'kind' => 'database',
	'database' => $database_name,
	'issues' => $issues,
	'charset' => $expect_database->getCharacterSet(),
	'collation' => $expect_database->getCollation(),
	);
	}

	foreach ($database->getTables() as $table_name => $table) {
	foreach ($this->findErrors($table) as $issue) {
	$errors[] = array(
	'database' => $database_name,
	'table' => $table_name,
	'issue' => $issue,
	);
	}

	$expect_table = $expect_database->getTable($table_name);
	$actual_table = $actual_database->getTable($table_name);

	if (!$expect_table \|\| !$actual_table) {
	continue;
	}

	$issues = array();
	if ($table->hasIssue($issue_collation)) {
	$issues[] = $issue_collation;
	}

	if ($issues) {
	$adjustments[] = array(
	'kind' => 'table',
	'database' => $database_name,
	'table' => $table_name,
	'issues' => $issues,
	'collation' => $expect_table->getCollation(),
	);
	}

	foreach ($table->getColumns() as $column_name => $column) {
	foreach ($this->findErrors($column) as $issue) {
	$errors[] = array(
	'database' => $database_name,
	'table' => $table_name,
	'name' => $column_name,
	'issue' => $issue,
	);
	}

	$expect_column = $expect_table->getColumn($column_name);
	$actual_column = $actual_table->getColumn($column_name);

	if (!$expect_column \|\| !$actual_column) {
	continue;
	}

	$issues = array();
	if ($column->hasIssue($issue_collation)) {
	$issues[] = $issue_collation;
	}
	if ($column->hasIssue($issue_charset)) {
	$issues[] = $issue_charset;
	}
	if ($column->hasIssue($issue_columntype)) {
	$issues[] = $issue_columntype;
	}
	if ($column->hasIssue($issue_auto)) {
	$issues[] = $issue_auto;
	}

	if ($issues) {
	if ($expect_column->getCharacterSet() === null) {
	// For non-text columns, we won't be specifying a collation or
	// character set.
	$charset = null;
	$collation = null;
	} else {
	$charset = $expect_column->getCharacterSet();
	$collation = $expect_column->getCollation();
	}

	$adjustment = array(
	'kind' => 'column',
	'database' => $database_name,
	'table' => $table_name,
	'name' => $column_name,
	'issues' => $issues,
	'collation' => $collation,
	'charset' => $charset,
	'type' => $expect_column->getColumnType(),

	// NOTE: We don't adjust column nullability because it is
	// dangerous, so always use the current nullability.
	'nullable' => $actual_column->getNullable(),

	// NOTE: This always stores the current value, because we have
	// to make these updates separately.
	'is_auto' => $actual_column->getAutoIncrement(),
	);

	if ($column->hasIssue($issue_auto)) {
	$adjustment['auto'] = $expect_column->getAutoIncrement();
	}

	$adjustments[] = $adjustment;
	}
	}

	foreach ($table->getKeys() as $key_name => $key) {
	foreach ($this->findErrors($key) as $issue) {
	$errors[] = array(
	'database' => $database_name,
	'table' => $table_name,
	'name' => $key_name,
	'issue' => $issue,
	);
	}

	$expect_key = $expect_table->getKey($key_name);
	$actual_key = $actual_table->getKey($key_name);

	$issues = array();
	$keep_key = true;
	if ($key->hasIssue($issue_surpluskey)) {
	$issues[] = $issue_surpluskey;
	$keep_key = false;
	}

	if ($key->hasIssue($issue_missingkey)) {
	$issues[] = $issue_missingkey;
	}

	if ($key->hasIssue($issue_columns)) {
	$issues[] = $issue_columns;
	}

	if ($key->hasIssue($issue_unique)) {
	$issues[] = $issue_unique;
	}

	// NOTE: We can't really fix this, per se, but we may need to remove
	// the key to change the column type. In the best case, the new
	// column type won't be overlong and recreating the key really will
	// fix the issue. In the worst case, we get the right column type and
	// lose the key, which is still better than retaining the key having
	// the wrong column type.
	if ($key->hasIssue($issue_longkey)) {
	$issues[] = $issue_longkey;
	}

	if ($issues) {
	$adjustment = array(
	'kind' => 'key',
	'database' => $database_name,
	'table' => $table_name,
	'name' => $key_name,
	'issues' => $issues,
	'exists' => (bool)$actual_key,
	'keep' => $keep_key,
	);

	if ($keep_key) {
	$adjustment += array(
	'columns' => $expect_key->getColumnNames(),
	'unique' => $expect_key->getUnique(),
	'indexType' => $expect_key->getIndexType(),
	);
	}

	$adjustments[] = $adjustment;
	}
	}
	}
	}

	return array($adjustments, $errors);
	}

	private function findErrors(PhabricatorConfigStorageSchema $schema) {
	$result = array();
	foreach ($schema->getLocalIssues() as $issue) {
	$status = PhabricatorConfigStorageSchema::getIssueStatus($issue);
	if ($status == PhabricatorConfigStorageSchema::STATUS_FAIL) {
	$result[] = $issue;
	}
	}
	return $result;
	}

	private function printErrors(array $errors, $default_return) {
	if (!$errors) {
	return $default_return;
	}

	$console = PhutilConsole::getConsole();

	$table = id(new PhutilConsoleTable())
	->addColumn('target', array('title' => pht('Target')))
	->addColumn('error', array('title' => pht('Error')));

	$any_surplus = false;
	$all_surplus = true;
	+ $any_access = false;
	+ $all_access = true;
	foreach ($errors as $error) {
	$pieces = array_select_keys(
	$error,
	array('database', 'table', 'name'));
	$pieces = array_filter($pieces);
	$target = implode('.', $pieces);

	$name = PhabricatorConfigStorageSchema::getIssueName($error['issue']);

	- if ($error['issue'] === PhabricatorConfigStorageSchema::ISSUE_SURPLUS) {
	+ $issue = $error['issue'];
	+
	+ if ($issue === PhabricatorConfigStorageSchema::ISSUE_SURPLUS) {
	$any_surplus = true;
	} else {
	$all_surplus = false;
	}

	+ if ($issue === PhabricatorConfigStorageSchema::ISSUE_ACCESSDENIED) {
	+ $any_access = true;
	+ } else {
	+ $all_access = false;
	+ }
	+
	$table->addRow(
	array(
	'target' => $target,
	'error' => $name,
	));
	}

	$console->writeOut("\n");
	$table->draw();
	$console->writeOut("\n");


	$message = array();
	if ($all_surplus) {
	$message[] = pht(
	'You have surplus schemata (extra tables or columns which Phabricator '.
	'does not expect). For information on resolving these '.
	'issues, see the "Surplus Schemata" section in the "Managing Storage '.
	'Adjustments" article in the documentation.');
	+ } else if ($all_access) {
	+ $message[] = pht(
	+ 'The user you are connecting to MySQL with does not have the correct '.
	+ 'permissions, and can not access some databases or tables that it '.
	+ 'needs to be able to access. GRANT the user additional permissions.');
	} else {
	$message[] = pht(
	'The schemata have errors (detailed above) which the adjustment '.
	'workflow can not fix.');

	+ if ($any_access) {
	+ $message[] = pht(
	+ 'Some of these errors are caused by access control problems. '.
	+ 'The user you are connecting with does not have permission to see '.
	+ 'all of the database or tables that Phabricator uses. You need to '.
	+ 'GRANT the user more permission, or use a different user.');
	+ }
	+
	if ($any_surplus) {
	$message[] = pht(
	'Some of these errors are caused by surplus schemata (extra '.
	'tables or columns which Phabricator does not expect). These are '.
	'not serious. For information on resolving these issues, see the '.
	'"Surplus Schemata" section in the "Managing Storage Adjustments" '.
	'article in the documentation.');
	}

	$message[] = pht(
	'If you are not developing Phabricator itself, report this issue to '.
	'the upstream.');

	$message[] = pht(
	'If you are developing Phabricator, these errors usually indicate '.
	'that your schema specifications do not agree with the schemata your '.
	'code actually builds.');
	}
	$message = implode("\n\n", $message);

	if ($all_surplus) {
	$console->writeOut(
	"<bg:yellow> %s </bg>\n\n%s\n",
	pht('SURPLUS SCHEMATA'),
	phutil_console_wrap($message));
	+ } else if ($all_access) {
	+ $console->writeOut(
	+ "<bg:yellow> %s </bg>\n\n%s\n",
	+ pht('ACCESS DENIED'),
	+ phutil_console_wrap($message));
	} else {
	$console->writeOut(
	"<bg:red> %s </bg>\n\n%s\n",
	pht('SCHEMATA ERRORS'),
	phutil_console_wrap($message));
	}

	return 2;
	}

	final protected function upgradeSchemata(
	$apply_only = null,
	$no_quickstart = false,
	$init_only = false) {

	$lock = $this->lock();

	try {
	$this->doUpgradeSchemata($apply_only, $no_quickstart, $init_only);
	} catch (Exception $ex) {
	$lock->unlock();
	throw $ex;
	}

	$lock->unlock();
	}

	final private function doUpgradeSchemata(
	$apply_only,
	$no_quickstart,
	$init_only) {

	$api = $this->getAPI();

	$applied = $this->getApi()->getAppliedPatches();
	if ($applied === null) {
	if ($this->dryRun) {
	echo pht(
	"DRYRUN: Patch metadata storage doesn't exist yet, ".
	"it would be created.\n");
	return 0;
	}

	if ($apply_only) {
	throw new PhutilArgumentUsageException(
	pht(
	'Storage has not been initialized yet, you must initialize '.
	'storage before selectively applying patches.'));
	return 1;
	}

	$legacy = $api->getLegacyPatches($this->patches);
	if ($legacy \|\| $no_quickstart \|\| $init_only) {

	// If we have legacy patches, we can't quickstart.

	$api->createDatabase('meta_data');
	$api->createTable(
	'meta_data',
	'patch_status',
	array(
	'patch VARCHAR(255) NOT NULL PRIMARY KEY COLLATE utf8_general_ci',
	'applied INT UNSIGNED NOT NULL',
	));

	foreach ($legacy as $patch) {
	$api->markPatchApplied($patch);
	}
	} else {
	echo pht('Loading quickstart template...')."\n";
	$root = dirname(phutil_get_library_root('phabricator'));
	$sql = $root.'/resources/sql/quickstart.sql';
	$api->applyPatchSQL($sql);
	}
	}

	if ($init_only) {
	echo pht('Storage initialized.')."\n";
	return 0;
	}

	$applied = $api->getAppliedPatches();
	$applied = array_fuse($applied);

	$skip_mark = false;
	if ($apply_only) {
	if (isset($applied[$apply_only])) {

	unset($applied[$apply_only]);
	$skip_mark = true;

	if (!$this->force && !$this->dryRun) {
	echo phutil_console_wrap(
	pht(
	"Patch '%s' has already been applied. Are you sure you want ".
	"to apply it again? This may put your storage in a state ".
	"that the upgrade scripts can not automatically manage.",
	$apply_only));
	if (!phutil_console_confirm(pht('Apply patch again?'))) {
	echo pht('Cancelled.')."\n";
	return 1;
	}
	}
	}
	}

	while (true) {
	$applied_something = false;
	foreach ($this->patches as $key => $patch) {
	if (isset($applied[$key])) {
	unset($this->patches[$key]);
	continue;
	}

	if ($apply_only && $apply_only != $key) {
	unset($this->patches[$key]);
	continue;
	}

	$can_apply = true;
	foreach ($patch->getAfter() as $after) {
	if (empty($applied[$after])) {
	if ($apply_only) {
	echo pht(
	"Unable to apply patch '%s' because it depends ".
	"on patch '%s', which has not been applied.\n",
	$apply_only,
	$after);
	return 1;
	}
	$can_apply = false;
	break;
	}
	}

	if (!$can_apply) {
	continue;
	}

	$applied_something = true;

	if ($this->dryRun) {
	echo pht("DRYRUN: Would apply patch '%s'.", $key)."\n";
	} else {
	echo pht("Applying patch '%s'...", $key)."\n";

	$t_begin = microtime(true);
	$api->applyPatch($patch);
	$t_end = microtime(true);

	if (!$skip_mark) {
	$api->markPatchApplied($key, ($t_end - $t_begin));
	}
	}

	unset($this->patches[$key]);
	$applied[$key] = true;
	}

	if (!$applied_something) {
	if (count($this->patches)) {
	throw new Exception(
	pht(
	'Some patches could not be applied: %s',
	implode(', ', array_keys($this->patches))));
	} else if (!$this->dryRun && !$apply_only) {
	echo pht(
	"Storage is up to date. Use '%s' for details.",
	'storage status')."\n";
	}
	break;
	}
	}
	}

	final protected function getBareHostAndPort($host) {
	// Split out port information, since the command-line client requires a
	// separate flag for the port.
	$uri = new PhutilURI('mysql://'.$host);
	if ($uri->getPort()) {
	$port = $uri->getPort();
	$bare_hostname = $uri->getDomain();
	} else {
	$port = null;
	$bare_hostname = $host;
	}

	return array($bare_hostname, $port);
	}

	/**
	* Acquires a @{class:PhabricatorGlobalLock}.
	*
	* @return PhabricatorGlobalLock
	*/
	final protected function lock() {
	return PhabricatorGlobalLock::newLock(__CLASS__)
	->useSpecificConnection($this->getApi()->getConn(null))
	->lock();
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Apr 28, 9:47 AM (1 d, 16 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 107911
Default Alt Text: (59 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions