No OneTemporary
Actions

Size

67 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/config/check/PhabricatorExtraConfigSetupCheck.php b/src/applications/config/check/PhabricatorExtraConfigSetupCheck.php
	index f28a6ab648..9fbb52ca22 100644
	--- a/src/applications/config/check/PhabricatorExtraConfigSetupCheck.php
	+++ b/src/applications/config/check/PhabricatorExtraConfigSetupCheck.php
	@@ -1,414 +1,417 @@
	<?php

	final class PhabricatorExtraConfigSetupCheck extends PhabricatorSetupCheck {

	public function getDefaultGroup() {
	return self::GROUP_OTHER;
	}

	protected function executeChecks() {
	$ancient_config = self::getAncientConfig();

	$all_keys = PhabricatorEnv::getAllConfigKeys();
	$all_keys = array_keys($all_keys);
	sort($all_keys);

	$defined_keys = PhabricatorApplicationConfigOptions::loadAllOptions();

	foreach ($all_keys as $key) {
	if (isset($defined_keys[$key])) {
	continue;
	}

	if (isset($ancient_config[$key])) {
	$summary = pht(
	'This option has been removed. You may delete it at your '.
	'convenience.');
	$message = pht(
	"The configuration option '%s' has been removed. You may delete ".
	"it at your convenience.".
	"\n\n%s",
	$key,
	$ancient_config[$key]);
	$short = pht('Obsolete Config');
	$name = pht('Obsolete Configuration Option "%s"', $key);
	} else {
	$summary = pht('This option is not recognized. It may be misspelled.');
	$message = pht(
	"The configuration option '%s' is not recognized. It may be ".
	"misspelled, or it might have existed in an older version of ".
	"Phabricator. It has no effect, and should be corrected or deleted.",
	$key);
	$short = pht('Unknown Config');
	$name = pht('Unknown Configuration Option "%s"', $key);
	}

	$issue = $this->newIssue('config.unknown.'.$key)
	->setShortName($short)
	->setName($name)
	->setSummary($summary);

	$stack = PhabricatorEnv::getConfigSourceStack();
	$stack = $stack->getStack();

	$found = array();
	$found_local = false;
	$found_database = false;

	foreach ($stack as $source_key => $source) {
	$value = $source->getKeys(array($key));
	if ($value) {
	$found[] = $source->getName();
	if ($source instanceof PhabricatorConfigDatabaseSource) {
	$found_database = true;
	}
	if ($source instanceof PhabricatorConfigLocalSource) {
	$found_local = true;
	}
	}
	}

	$message = $message."\n\n".pht(
	'This configuration value is defined in these %d '.
	'configuration source(s): %s.',
	count($found),
	implode(', ', $found));
	$issue->setMessage($message);

	if ($found_local) {
	$command = csprintf('phabricator/ $ ./bin/config delete %s', $key);
	$issue->addCommand($command);
	}

	if ($found_database) {
	$issue->addPhabricatorConfig($key);
	}
	}

	$this->executeManiphestFieldChecks();
	}

	/**
	* Return a map of deleted config options. Keys are option keys; values are
	* explanations of what happened to the option.
	*/
	public static function getAncientConfig() {
	$reason_auth = pht(
	'This option has been migrated to the "Auth" application. Your old '.
	'configuration is still in effect, but now stored in "Auth" instead of '.
	'configuration. Going forward, you can manage authentication from '.
	'the web UI.');

	$auth_config = array(
	'controller.oauth-registration',
	'auth.password-auth-enabled',
	'facebook.auth-enabled',
	'facebook.registration-enabled',
	'facebook.auth-permanent',
	'facebook.application-id',
	'facebook.application-secret',
	'facebook.require-https-auth',
	'github.auth-enabled',
	'github.registration-enabled',
	'github.auth-permanent',
	'github.application-id',
	'github.application-secret',
	'google.auth-enabled',
	'google.registration-enabled',
	'google.auth-permanent',
	'google.application-id',
	'google.application-secret',
	'ldap.auth-enabled',
	'ldap.hostname',
	'ldap.port',
	'ldap.base_dn',
	'ldap.search_attribute',
	'ldap.search-first',
	'ldap.username-attribute',
	'ldap.real_name_attributes',
	'ldap.activedirectory_domain',
	'ldap.version',
	'ldap.referrals',
	'ldap.anonymous-user-name',
	'ldap.anonymous-user-password',
	'ldap.start-tls',
	'disqus.auth-enabled',
	'disqus.registration-enabled',
	'disqus.auth-permanent',
	'disqus.application-id',
	'disqus.application-secret',
	'phabricator.oauth-uri',
	'phabricator.auth-enabled',
	'phabricator.registration-enabled',
	'phabricator.auth-permanent',
	'phabricator.application-id',
	'phabricator.application-secret',
	);

	$ancient_config = array_fill_keys($auth_config, $reason_auth);

	$markup_reason = pht(
	'Custom remarkup rules are now added by subclassing '.
	'%s or %s.',
	'PhabricatorRemarkupCustomInlineRule',
	'PhabricatorRemarkupCustomBlockRule');

	$session_reason = pht(
	'Sessions now expire and are garbage collected rather than having an '.
	'arbitrary concurrency limit.');

	$differential_field_reason = pht(
	'All Differential fields are now managed through the configuration '.
	'option "%s". Use that option to configure which fields are shown.',
	'differential.fields');

	$reply_domain_reason = pht(
	'Individual application reply handler domains have been removed. '.
	'Configure a reply domain with "%s".',
	'metamta.reply-handler-domain');

	$reply_handler_reason = pht(
	'Reply handlers can no longer be overridden with configuration.');

	$monospace_reason = pht(
	'Phabricator no longer supports global customization of monospaced '.
	'fonts.');

	$public_mail_reason = pht(
	'Inbound mail addresses are now configured for each application '.
	'in the Applications tool.');

	$gc_reason = pht(
	'Garbage collectors are now configured with "%s".',
	'bin/garbage set-policy');

	$aphlict_reason = pht(
	'Configuration of the notification server has changed substantially. '.
	'For discussion, see T10794.');

	$stale_reason = pht(
	'The Differential revision list view age UI elements have been removed '.
	'to simplify the interface.');

	$global_settings_reason = pht(
	'The "Re: Prefix" and "Vary Subjects" settings are now configured '.
	'in global settings.');

	$dashboard_reason = pht(
	'This option has been removed, you can use Dashboards to provide '.
	'homepage customization. See T11533 for more details.');

	$ancient_config += array(
	'phid.external-loaders' =>
	pht(
	'External loaders have been replaced. Extend `%s` '.
	'to implement new PHID and handle types.',
	'PhabricatorPHIDType'),
	'maniphest.custom-task-extensions-class' =>
	pht(
	'Maniphest fields are now loaded automatically. '.
	'You can configure them with `%s`.',
	'maniphest.fields'),
	'maniphest.custom-fields' =>
	pht(
	'Maniphest fields are now defined in `%s`. '.
	'Existing definitions have been migrated.',
	'maniphest.custom-field-definitions'),
	'differential.custom-remarkup-rules' => $markup_reason,
	'differential.custom-remarkup-block-rules' => $markup_reason,
	'auth.sshkeys.enabled' => pht(
	'SSH keys are now actually useful, so they are always enabled.'),
	'differential.anonymous-access' => pht(
	'Phabricator now has meaningful global access controls. See `%s`.',
	'policy.allow-public'),
	'celerity.resource-path' => pht(
	'An alternate resource map is no longer supported. Instead, use '.
	'multiple maps. See T4222.'),
	'metamta.send-immediately' => pht(
	'Mail is now always delivered by the daemons.'),
	'auth.sessions.conduit' => $session_reason,
	'auth.sessions.web' => $session_reason,
	'tokenizer.ondemand' => pht(
	'Phabricator now manages typeahead strategies automatically.'),
	'differential.revision-custom-detail-renderer' => pht(
	'Obsolete; use standard rendering events instead.'),
	'differential.show-host-field' => $differential_field_reason,
	'differential.show-test-plan-field' => $differential_field_reason,
	'differential.field-selector' => $differential_field_reason,
	'phabricator.show-beta-applications' => pht(
	'This option has been renamed to `%s` to emphasize the '.
	'unfinished nature of many prototype applications. '.
	'Your existing setting has been migrated.',
	'phabricator.show-prototypes'),
	'notification.user' => pht(
	'The notification server no longer requires root permissions. Start '.
	'the server as the user you want it to run under.'),
	'notification.debug' => pht(
	'Notifications no longer have a dedicated debugging mode.'),
	'translation.provider' => pht(
	'The translation implementation has changed and providers are no '.
	'longer used or supported.'),
	'config.mask' => pht(
	'Use `%s` instead of this option.',
	'config.hide'),
	'phd.start-taskmasters' => pht(
	'Taskmasters now use an autoscaling pool. You can configure the '.
	'pool size with `%s`.',
	'phd.taskmasters'),
	'storage.engine-selector' => pht(
	'Phabricator now automatically discovers available storage engines '.
	'at runtime.'),
	'storage.upload-size-limit' => pht(
	'Phabricator now supports arbitrarily large files. Consult the '.
	'documentation for configuration details.'),
	'security.allow-outbound-http' => pht(
	'This option has been replaced with the more granular option `%s`.',
	'security.outbound-blacklist'),
	'metamta.reply.show-hints' => pht(
	'Phabricator no longer shows reply hints in mail.'),

	'metamta.differential.reply-handler-domain' => $reply_domain_reason,
	'metamta.diffusion.reply-handler-domain' => $reply_domain_reason,
	'metamta.macro.reply-handler-domain' => $reply_domain_reason,
	'metamta.maniphest.reply-handler-domain' => $reply_domain_reason,
	'metamta.pholio.reply-handler-domain' => $reply_domain_reason,

	'metamta.diffusion.reply-handler' => $reply_handler_reason,
	'metamta.differential.reply-handler' => $reply_handler_reason,
	'metamta.maniphest.reply-handler' => $reply_handler_reason,
	'metamta.package.reply-handler' => $reply_handler_reason,

	'metamta.precedence-bulk' => pht(
	'Phabricator now always sends transaction mail with '.
	'"Precedence: bulk" to improve deliverability.'),

	'style.monospace' => $monospace_reason,
	'style.monospace.windows' => $monospace_reason,

	'search.engine-selector' => pht(
	'Phabricator now automatically discovers available search engines '.
	'at runtime.'),

	'metamta.files.public-create-email' => $public_mail_reason,
	'metamta.maniphest.public-create-email' => $public_mail_reason,
	'metamta.maniphest.default-public-author' => $public_mail_reason,
	'metamta.paste.public-create-email' => $public_mail_reason,

	'security.allow-conduit-act-as-user' => pht(
	'Impersonating users over the API is no longer supported.'),

	'feed.public' => pht('The framable public feed is no longer supported.'),

	'auth.login-message' => pht(
	'This configuration option has been replaced with a modular '.
	'handler. See T9346.'),

	'gcdaemon.ttl.herald-transcripts' => $gc_reason,
	'gcdaemon.ttl.daemon-logs' => $gc_reason,
	'gcdaemon.ttl.differential-parse-cache' => $gc_reason,
	'gcdaemon.ttl.markup-cache' => $gc_reason,
	'gcdaemon.ttl.task-archive' => $gc_reason,
	'gcdaemon.ttl.general-cache' => $gc_reason,
	'gcdaemon.ttl.conduit-logs' => $gc_reason,

	'phd.variant-config' => pht(
	'This configuration is no longer relevant because daemons '.
	'restart automatically on configuration changes.'),

	'notification.ssl-cert' => $aphlict_reason,
	'notification.ssl-key' => $aphlict_reason,
	'notification.pidfile' => $aphlict_reason,
	'notification.log' => $aphlict_reason,
	'notification.enabled' => $aphlict_reason,
	'notification.client-uri' => $aphlict_reason,
	'notification.server-uri' => $aphlict_reason,

	'metamta.differential.unified-comment-context' => pht(
	'Inline comments are now always rendered with a limited amount '.
	'of context.'),

	'differential.days-fresh' => $stale_reason,
	'differential.days-stale' => $stale_reason,

	'metamta.re-prefix' => $global_settings_reason,
	'metamta.vary-subjects' => $global_settings_reason,

	'ui.custom-header' => pht(
	'This option has been replaced with `ui.logo`, which provides more '.
	'flexible configuration options.'),

	'welcome.html' => $dashboard_reason,
	'maniphest.priorities.unbreak-now' => $dashboard_reason,
	'maniphest.priorities.needs-triage' => $dashboard_reason,

	+ 'mysql.implementation' => pht(
	+ 'Phabricator now automatically selects the best available '.
	+ 'MySQL implementation.'),
	);

	return $ancient_config;
	}

	private function executeManiphestFieldChecks() {
	$maniphest_appclass = 'PhabricatorManiphestApplication';
	if (!PhabricatorApplication::isClassInstalled($maniphest_appclass)) {
	return;
	}

	$capabilities = array(
	ManiphestEditAssignCapability::CAPABILITY,
	ManiphestEditPoliciesCapability::CAPABILITY,
	ManiphestEditPriorityCapability::CAPABILITY,
	ManiphestEditProjectsCapability::CAPABILITY,
	ManiphestEditStatusCapability::CAPABILITY,
	);

	// Check for any of these capabilities set to anything other than
	// "All Users".

	$any_set = false;
	$app = new PhabricatorManiphestApplication();
	foreach ($capabilities as $capability) {
	$setting = $app->getPolicy($capability);
	if ($setting != PhabricatorPolicies::POLICY_USER) {
	$any_set = true;
	break;
	}
	}

	if (!$any_set) {
	return;
	}

	$issue_summary = pht(
	'Maniphest is currently configured with deprecated policy settings '.
	'which will be removed in a future version of Phabricator.');


	$message = pht(
	'Some policy settings in Maniphest are now deprecated and will be '.
	'removed in a future version of Phabricator. You are currently using '.
	'at least one of these settings.'.
	"\n\n".
	'The deprecated settings are "Can Assign Tasks", '.
	'"Can Edit Task Policies", "Can Prioritize Tasks", '.
	'"Can Edit Task Projects", and "Can Edit Task Status". You can '.
	'find these settings in Applications, or follow the link below.'.
	"\n\n".
	'You can find discussion of this change (including rationale and '.
	'recommendations on how to configure similar features) in the upstream, '.
	'at the link below.'.
	"\n\n".
	'To resolve this issue, set all of these policies to "All Users" after '.
	'making any necessary form customization changes.');

	$more_href = 'https://secure.phabricator.com/T10003';
	$edit_href = '/applications/view/PhabricatorManiphestApplication/';

	$issue = $this->newIssue('maniphest.T10003-per-field-policies')
	->setShortName(pht('Deprecated Policies'))
	->setName(pht('Deprecated Maniphest Field Policies'))
	->setSummary($issue_summary)
	->setMessage($message)
	->addLink($more_href, pht('Learn More: Upstream Discussion'))
	->addLink($edit_href, pht('Edit These Settings'));
	}

	}
	diff --git a/src/applications/config/option/PhabricatorMySQLConfigOptions.php b/src/applications/config/option/PhabricatorMySQLConfigOptions.php
	index 28fa78d2ab..2ddaf91488 100644
	--- a/src/applications/config/option/PhabricatorMySQLConfigOptions.php
	+++ b/src/applications/config/option/PhabricatorMySQLConfigOptions.php
	@@ -1,87 +1,70 @@
	<?php

	final class PhabricatorMySQLConfigOptions
	extends PhabricatorApplicationConfigOptions {

	public function getName() {
	return pht('MySQL');
	}

	public function getDescription() {
	return pht('Database configuration.');
	}

	public function getIcon() {
	return 'fa-database';
	}

	public function getGroup() {
	return 'core';
	}

	public function getOptions() {
	return array(
	$this->newOption('mysql.host', 'string', 'localhost')
	->setLocked(true)
	->setDescription(
	pht('MySQL database hostname.'))
	->addExample('localhost', pht('MySQL on this machine'))
	->addExample('db.example.com:3300', pht('Nonstandard port')),
	$this->newOption('mysql.user', 'string', 'root')
	->setLocked(true)
	->setDescription(
	pht('MySQL username to use when connecting to the database.')),
	$this->newOption('mysql.pass', 'string', null)
	->setHidden(true)
	->setDescription(
	pht('MySQL password to use when connecting to the database.')),
	$this->newOption(
	'mysql.configuration-provider',
	'class',
	'DefaultDatabaseConfigurationProvider')
	->setLocked(true)
	->setBaseClass('DatabaseConfigurationProvider')
	->setSummary(
	pht('Configure database configuration class.'))
	->setDescription(
	pht(
	'Phabricator chooses which database to connect to through a '.
	'swappable configuration provider. You almost certainly do not '.
	'need to change this.')),
	- $this->newOption(
	- 'mysql.implementation',
	- 'class',
	- (extension_loaded('mysqli')
	- ? 'AphrontMySQLiDatabaseConnection'
	- : 'AphrontMySQLDatabaseConnection'))
	- ->setLocked(true)
	- ->setBaseClass('AphrontMySQLDatabaseConnectionBase')
	- ->setSummary(
	- pht('Configure database connection class.'))
	- ->setDescription(
	- pht(
	- 'Phabricator connects to MySQL through a swappable abstraction '.
	- 'layer. You can choose an alternate implementation by setting '.
	- 'this option. To provide your own implementation, extend '.
	- '`%s`. It is very unlikely that you need to change this.',
	- 'AphrontMySQLDatabaseConnectionBase')),
	$this->newOption('storage.default-namespace', 'string', 'phabricator')
	->setLocked(true)
	->setSummary(
	pht('The namespace that Phabricator databases should use.'))
	->setDescription(
	pht(
	"Phabricator puts databases in a namespace, which defaults to ".
	"'phabricator' -- for instance, the Differential database is ".
	"named 'phabricator_differential' by default. You can change ".
	"this namespace if you want. Normally, you should not do this ".
	"unless you are developing Phabricator and using namespaces to ".
	"separate multiple sandbox datasets.")),
	$this->newOption('mysql.port', 'string', null)
	->setLocked(true)
	->setDescription(
	pht('MySQL port to use when connecting to the database.')),
	);
	}

	}
	diff --git a/src/applications/console/plugin/DarkConsoleServicesPlugin.php b/src/applications/console/plugin/DarkConsoleServicesPlugin.php
	index 055315d641..ea5a100550 100644
	--- a/src/applications/console/plugin/DarkConsoleServicesPlugin.php
	+++ b/src/applications/console/plugin/DarkConsoleServicesPlugin.php
	@@ -1,294 +1,292 @@
	<?php

	final class DarkConsoleServicesPlugin extends DarkConsolePlugin {

	protected $observations;

	public function getName() {
	return pht('Services');
	}

	public function getDescription() {
	return pht('Information about services.');
	}

	public static function getQueryAnalyzerHeader() {
	return 'X-Phabricator-QueryAnalyzer';
	}

	public static function isQueryAnalyzerRequested() {
	if (!empty($_REQUEST['__analyze__'])) {
	return true;
	}

	$header = AphrontRequest::getHTTPHeader(self::getQueryAnalyzerHeader());
	if ($header) {
	return true;
	}

	return false;
	}

	/**
	* @phutil-external-symbol class PhabricatorStartup
	*/
	public function generateData() {
	$should_analyze = self::isQueryAnalyzerRequested();

	$log = PhutilServiceProfiler::getInstance()->getServiceCallLog();
	foreach ($log as $key => $entry) {
	$config = idx($entry, 'config', array());
	unset($log[$key]['config']);

	if (!$should_analyze) {
	$log[$key]['explain'] = array(
	'sev' => 7,
	'size' => null,
	'reason' => pht('Disabled'),
	);
	// Query analysis is disabled for this request, so don't do any of it.
	continue;
	}

	if ($entry['type'] != 'query') {
	continue;
	}

	// For each SELECT query, go issue an EXPLAIN on it so we can flag stuff
	// causing table scans, etc.
	if (preg_match('/^\s*SELECT\b/i', $entry['query'])) {
	- $conn = PhabricatorEnv::newObjectFromConfig(
	- 'mysql.implementation',
	- array($entry['config']));
	+ $conn = PhabricatorDatabaseRef::newRawConnection($entry['config']);
	try {
	$explain = queryfx_all(
	$conn,
	'EXPLAIN %Q',
	$entry['query']);

	$badness = 0;
	$size = 1;
	$reason = null;

	foreach ($explain as $table) {
	$size *= (int)$table['rows'];

	switch ($table['type']) {
	case 'index':
	$cur_badness = 1;
	$cur_reason = 'Index';
	break;
	case 'const':
	$cur_badness = 1;
	$cur_reason = 'Const';
	break;
	case 'eq_ref';
	$cur_badness = 2;
	$cur_reason = 'EqRef';
	break;
	case 'range':
	$cur_badness = 3;
	$cur_reason = 'Range';
	break;
	case 'ref':
	$cur_badness = 3;
	$cur_reason = 'Ref';
	break;
	case 'fulltext':
	$cur_badness = 3;
	$cur_reason = 'Fulltext';
	break;
	case 'ALL':
	if (preg_match('/Using where/', $table['Extra'])) {
	if ($table['rows'] < 256 && !empty($table['possible_keys'])) {
	$cur_badness = 2;
	$cur_reason = pht('Small Table Scan');
	} else {
	$cur_badness = 6;
	$cur_reason = pht('TABLE SCAN!');
	}
	} else {
	$cur_badness = 3;
	$cur_reason = pht('Whole Table');
	}
	break;
	default:
	if (preg_match('/No tables used/i', $table['Extra'])) {
	$cur_badness = 1;
	$cur_reason = pht('No Tables');
	} else if (preg_match('/Impossible/i', $table['Extra'])) {
	$cur_badness = 1;
	$cur_reason = pht('Empty');
	} else {
	$cur_badness = 4;
	$cur_reason = pht("Can't Analyze");
	}
	break;
	}

	if ($cur_badness > $badness) {
	$badness = $cur_badness;
	$reason = $cur_reason;
	}
	}

	$log[$key]['explain'] = array(
	'sev' => $badness,
	'size' => $size,
	'reason' => $reason,
	);
	} catch (Exception $ex) {
	$log[$key]['explain'] = array(
	'sev' => 5,
	'size' => null,
	'reason' => $ex->getMessage(),
	);
	}
	}
	}

	return array(
	'start' => PhabricatorStartup::getStartTime(),
	'end' => microtime(true),
	'log' => $log,
	'analyzeURI' => (string)$this
	->getRequestURI()
	->alter('__analyze__', true),
	'didAnalyze' => $should_analyze,
	);
	}

	public function renderPanel() {
	$data = $this->getData();

	$log = $data['log'];
	$results = array();

	$results[] = phutil_tag(
	'div',
	array('class' => 'dark-console-panel-header'),
	array(
	phutil_tag(
	'a',
	array(
	'href' => $data['analyzeURI'],
	'class' => $data['didAnalyze'] ? 'disabled button' : 'green button',
	),
	pht('Analyze Query Plans')),
	phutil_tag('h1', array(), pht('Calls to External Services')),
	phutil_tag('div', array('style' => 'clear: both;')),
	));

	$page_total = $data['end'] - $data['start'];
	$totals = array();
	$counts = array();

	foreach ($log as $row) {
	$totals[$row['type']] = idx($totals, $row['type'], 0) + $row['duration'];
	$counts[$row['type']] = idx($counts, $row['type'], 0) + 1;
	}
	$totals['All Services'] = array_sum($totals);
	$counts['All Services'] = array_sum($counts);

	$totals['Entire Page'] = $page_total;
	$counts['Entire Page'] = 0;

	$summary = array();
	foreach ($totals as $type => $total) {
	$summary[] = array(
	$type,
	number_format($counts[$type]),
	pht('%s us', new PhutilNumber((int)(1000000 * $totals[$type]))),
	sprintf('%.1f%%', 100 * $totals[$type] / $page_total),
	);
	}
	$summary_table = new AphrontTableView($summary);
	$summary_table->setColumnClasses(
	array(
	'',
	'n',
	'n',
	'wide',
	));
	$summary_table->setHeaders(
	array(
	pht('Type'),
	pht('Count'),
	pht('Total Cost'),
	pht('Page Weight'),
	));

	$results[] = $summary_table->render();

	$rows = array();
	foreach ($log as $row) {

	$analysis = null;

	switch ($row['type']) {
	case 'query':
	$info = $row['query'];
	$info = wordwrap($info, 128, "\n", true);

	if (!empty($row['explain'])) {
	$analysis = phutil_tag(
	'span',
	array(
	'class' => 'explain-sev-'.$row['explain']['sev'],
	),
	$row['explain']['reason']);
	}

	break;
	case 'connect':
	$info = $row['host'].':'.$row['database'];
	break;
	case 'exec':
	$info = $row['command'];
	break;
	case 's3':
	case 'conduit':
	$info = $row['method'];
	break;
	case 'http':
	$info = $row['uri'];
	break;
	default:
	$info = '-';
	break;
	}

	$offset = ($row['begin'] - $data['start']);

	$rows[] = array(
	$row['type'],
	pht('+%s ms', new PhutilNumber(1000 * $offset)),
	pht('%s us', new PhutilNumber(1000000 * $row['duration'])),
	$info,
	$analysis,
	);
	}

	$table = new AphrontTableView($rows);
	$table->setColumnClasses(
	array(
	null,
	'n',
	'n',
	'wide',
	'',
	));
	$table->setHeaders(
	array(
	pht('Event'),
	pht('Start'),
	pht('Duration'),
	pht('Details'),
	pht('Analysis'),
	));

	$results[] = $table->render();

	return phutil_implode_html("\n", $results);
	}
	}
	diff --git a/src/infrastructure/cluster/PhabricatorDatabaseRef.php b/src/infrastructure/cluster/PhabricatorDatabaseRef.php
	index 0559ba0c32..461fe8f17c 100644
	--- a/src/infrastructure/cluster/PhabricatorDatabaseRef.php
	+++ b/src/infrastructure/cluster/PhabricatorDatabaseRef.php
	@@ -1,673 +1,677 @@
	<?php

	final class PhabricatorDatabaseRef
	extends Phobject {

	const STATUS_OKAY = 'okay';
	const STATUS_FAIL = 'fail';
	const STATUS_AUTH = 'auth';
	const STATUS_REPLICATION_CLIENT = 'replication-client';

	const REPLICATION_OKAY = 'okay';
	const REPLICATION_MASTER_REPLICA = 'master-replica';
	const REPLICATION_REPLICA_NONE = 'replica-none';
	const REPLICATION_SLOW = 'replica-slow';
	const REPLICATION_NOT_REPLICATING = 'not-replicating';

	const KEY_REFS = 'cluster.db.refs';
	const KEY_INDIVIDUAL = 'cluster.db.individual';

	private $host;
	private $port;
	private $user;
	private $pass;
	private $disabled;
	private $isMaster;
	private $isIndividual;

	private $connectionLatency;
	private $connectionStatus;
	private $connectionMessage;

	private $replicaStatus;
	private $replicaMessage;
	private $replicaDelay;

	private $healthRecord;
	private $didFailToConnect;

	private $isDefaultPartition;
	private $applicationMap = array();
	private $masterRef;
	private $replicaRefs = array();

	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 setUser($user) {
	$this->user = $user;
	return $this;
	}

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

	public function setPass(PhutilOpaqueEnvelope $pass) {
	$this->pass = $pass;
	return $this;
	}

	public function getPass() {
	return $this->pass;
	}

	public function setIsMaster($is_master) {
	$this->isMaster = $is_master;
	return $this;
	}

	public function getIsMaster() {
	return $this->isMaster;
	}

	public function setDisabled($disabled) {
	$this->disabled = $disabled;
	return $this;
	}

	public function getDisabled() {
	return $this->disabled;
	}

	public function setConnectionLatency($connection_latency) {
	$this->connectionLatency = $connection_latency;
	return $this;
	}

	public function getConnectionLatency() {
	return $this->connectionLatency;
	}

	public function setConnectionStatus($connection_status) {
	$this->connectionStatus = $connection_status;
	return $this;
	}

	public function getConnectionStatus() {
	if ($this->connectionStatus === null) {
	throw new PhutilInvalidStateException('queryAll');
	}

	return $this->connectionStatus;
	}

	public function setConnectionMessage($connection_message) {
	$this->connectionMessage = $connection_message;
	return $this;
	}

	public function getConnectionMessage() {
	return $this->connectionMessage;
	}

	public function setReplicaStatus($replica_status) {
	$this->replicaStatus = $replica_status;
	return $this;
	}

	public function getReplicaStatus() {
	return $this->replicaStatus;
	}

	public function setReplicaMessage($replica_message) {
	$this->replicaMessage = $replica_message;
	return $this;
	}

	public function getReplicaMessage() {
	return $this->replicaMessage;
	}

	public function setReplicaDelay($replica_delay) {
	$this->replicaDelay = $replica_delay;
	return $this;
	}

	public function getReplicaDelay() {
	return $this->replicaDelay;
	}

	public function setIsIndividual($is_individual) {
	$this->isIndividual = $is_individual;
	return $this;
	}

	public function getIsIndividual() {
	return $this->isIndividual;
	}

	public function setIsDefaultPartition($is_default_partition) {
	$this->isDefaultPartition = $is_default_partition;
	return $this;
	}

	public function getIsDefaultPartition() {
	return $this->isDefaultPartition;
	}

	public function setApplicationMap(array $application_map) {
	$this->applicationMap = $application_map;
	return $this;
	}

	public function getApplicationMap() {
	return $this->applicationMap;
	}

	public function setMasterRef(PhabricatorDatabaseRef $master_ref) {
	$this->masterRef = $master_ref;
	return $this;
	}

	public function getMasterRef() {
	return $this->masterRef;
	}

	public function addReplicaRef(PhabricatorDatabaseRef $replica_ref) {
	$this->replicaRefs[] = $replica_ref;
	return $this;
	}

	public function getReplicaRefs() {
	return $this->replicaRefs;
	}


	public function getRefKey() {
	$host = $this->getHost();

	$port = $this->getPort();
	if (strlen($port)) {
	return "{$host}:{$port}";
	}

	return $host;
	}

	public static function getConnectionStatusMap() {
	return array(
	self::STATUS_OKAY => array(
	'icon' => 'fa-exchange',
	'color' => 'green',
	'label' => pht('Okay'),
	),
	self::STATUS_FAIL => array(
	'icon' => 'fa-times',
	'color' => 'red',
	'label' => pht('Failed'),
	),
	self::STATUS_AUTH => array(
	'icon' => 'fa-key',
	'color' => 'red',
	'label' => pht('Invalid Credentials'),
	),
	self::STATUS_REPLICATION_CLIENT => array(
	'icon' => 'fa-eye-slash',
	'color' => 'yellow',
	'label' => pht('Missing Permission'),
	),
	);
	}

	public static function getReplicaStatusMap() {
	return array(
	self::REPLICATION_OKAY => array(
	'icon' => 'fa-download',
	'color' => 'green',
	'label' => pht('Okay'),
	),
	self::REPLICATION_MASTER_REPLICA => array(
	'icon' => 'fa-database',
	'color' => 'red',
	'label' => pht('Replicating Master'),
	),
	self::REPLICATION_REPLICA_NONE => array(
	'icon' => 'fa-download',
	'color' => 'red',
	'label' => pht('Not A Replica'),
	),
	self::REPLICATION_SLOW => array(
	'icon' => 'fa-hourglass',
	'color' => 'red',
	'label' => pht('Slow Replication'),
	),
	self::REPLICATION_NOT_REPLICATING => array(
	'icon' => 'fa-exclamation-triangle',
	'color' => 'red',
	'label' => pht('Not Replicating'),
	),
	);
	}

	public static function getClusterRefs() {
	$cache = PhabricatorCaches::getRequestCache();

	$refs = $cache->getKey(self::KEY_REFS);
	if (!$refs) {
	$refs = self::newRefs();
	$cache->setKey(self::KEY_REFS, $refs);
	}

	return $refs;
	}

	public static function getLiveIndividualRef() {
	$cache = PhabricatorCaches::getRequestCache();

	$ref = $cache->getKey(self::KEY_INDIVIDUAL);
	if (!$ref) {
	$ref = self::newIndividualRef();
	$cache->setKey(self::KEY_INDIVIDUAL, $ref);
	}

	return $ref;
	}

	public static function newRefs() {
	$default_port = PhabricatorEnv::getEnvConfig('mysql.port');
	$default_port = nonempty($default_port, 3306);

	$default_user = PhabricatorEnv::getEnvConfig('mysql.user');

	$default_pass = PhabricatorEnv::getEnvConfig('mysql.pass');
	$default_pass = new PhutilOpaqueEnvelope($default_pass);

	$config = PhabricatorEnv::getEnvConfig('cluster.databases');

	return id(new PhabricatorDatabaseRefParser())
	->setDefaultPort($default_port)
	->setDefaultUser($default_user)
	->setDefaultPass($default_pass)
	->newRefs($config);
	}

	public static function queryAll() {
	$refs = self::getActiveDatabaseRefs();
	return self::queryRefs($refs);
	}

	private static function queryRefs(array $refs) {
	foreach ($refs as $ref) {
	$conn = $ref->newManagementConnection();

	$t_start = microtime(true);
	$replica_status = false;
	try {
	$replica_status = queryfx_one($conn, 'SHOW SLAVE STATUS');
	$ref->setConnectionStatus(self::STATUS_OKAY);
	} catch (AphrontAccessDeniedQueryException $ex) {
	$ref->setConnectionStatus(self::STATUS_REPLICATION_CLIENT);
	$ref->setConnectionMessage(
	pht(
	'No permission to run "SHOW SLAVE STATUS". Grant this user '.
	'"REPLICATION CLIENT" permission to allow Phabricator to '.
	'monitor replica health.'));
	} catch (AphrontInvalidCredentialsQueryException $ex) {
	$ref->setConnectionStatus(self::STATUS_AUTH);
	$ref->setConnectionMessage($ex->getMessage());
	} catch (AphrontQueryException $ex) {
	$ref->setConnectionStatus(self::STATUS_FAIL);

	$class = get_class($ex);
	$message = $ex->getMessage();
	$ref->setConnectionMessage(
	pht(
	'%s: %s',
	get_class($ex),
	$ex->getMessage()));
	}
	$t_end = microtime(true);
	$ref->setConnectionLatency($t_end - $t_start);

	if ($replica_status !== false) {
	$is_replica = (bool)$replica_status;
	if ($ref->getIsMaster() && $is_replica) {
	$ref->setReplicaStatus(self::REPLICATION_MASTER_REPLICA);
	$ref->setReplicaMessage(
	pht(
	'This host has a "master" role, but is replicating data from '.
	'another host ("%s")!',
	idx($replica_status, 'Master_Host')));
	} else if (!$ref->getIsMaster() && !$is_replica) {
	$ref->setReplicaStatus(self::REPLICATION_REPLICA_NONE);
	$ref->setReplicaMessage(
	pht(
	'This host has a "replica" role, but is not replicating data '.
	'from a master (no output from "SHOW SLAVE STATUS").'));
	} else {
	$ref->setReplicaStatus(self::REPLICATION_OKAY);
	}

	if ($is_replica) {
	$latency = idx($replica_status, 'Seconds_Behind_Master');
	if (!strlen($latency)) {
	$ref->setReplicaStatus(self::REPLICATION_NOT_REPLICATING);
	} else {
	$latency = (int)$latency;
	$ref->setReplicaDelay($latency);
	if ($latency > 30) {
	$ref->setReplicaStatus(self::REPLICATION_SLOW);
	$ref->setReplicaMessage(
	pht(
	'This replica is lagging far behind the master. Data is at '.
	'risk!'));
	}
	}
	}
	}
	}

	return $refs;
	}

	public function newManagementConnection() {
	return $this->newConnection(
	array(
	'retries' => 0,
	'timeout' => 2,
	));
	}

	public function newApplicationConnection($database) {
	return $this->newConnection(
	array(
	'database' => $database,
	));
	}

	public function isSevered() {
	// If we only have an individual database, never sever our connection to
	// it, at least for now. It's possible that using the same severing rules
	// might eventually make sense to help alleviate load-related failures,
	// but we should wait for all the cluster stuff to stabilize first.
	if ($this->getIsIndividual()) {
	return false;
	}

	if ($this->didFailToConnect) {
	return true;
	}

	$record = $this->getHealthRecord();
	$is_healthy = $record->getIsHealthy();
	if (!$is_healthy) {
	return true;
	}

	return false;
	}

	public function isReachable(AphrontDatabaseConnection $connection) {
	$record = $this->getHealthRecord();
	$should_check = $record->getShouldCheck();

	if ($this->isSevered() && !$should_check) {
	return false;
	}

	try {
	$connection->openConnection();
	$reachable = true;
	} catch (AphrontSchemaQueryException $ex) {
	// We get one of these if the database we're trying to select does not
	// exist. In this case, just re-throw the exception. This is expected
	// during first-time setup, when databases like "config" will not exist
	// yet.
	throw $ex;
	} catch (Exception $ex) {
	$reachable = false;
	}

	if ($should_check) {
	$record->didHealthCheck($reachable);
	}

	if (!$reachable) {
	$this->didFailToConnect = true;
	}

	return $reachable;
	}

	public function checkHealth() {
	$health = $this->getHealthRecord();

	$should_check = $health->getShouldCheck();
	if ($should_check) {
	// This does an implicit health update.
	$connection = $this->newManagementConnection();
	$this->isReachable($connection);
	}

	return $this;
	}

	public function getHealthRecord() {
	if (!$this->healthRecord) {
	$this->healthRecord = new PhabricatorDatabaseHealthRecord($this);
	}
	return $this->healthRecord;
	}

	public static function getActiveDatabaseRefs() {
	$refs = array();

	foreach (self::getMasterDatabaseRefs() as $ref) {
	$refs[] = $ref;
	}

	foreach (self::getReplicaDatabaseRefs() as $ref) {
	$refs[] = $ref;
	}

	return $refs;
	}

	public static function getAllMasterDatabaseRefs() {
	$refs = self::getClusterRefs();

	if (!$refs) {
	return array(self::getLiveIndividualRef());
	}

	$masters = array();
	foreach ($refs as $ref) {
	if ($ref->getDisabled()) {
	continue;
	}
	if ($ref->getIsMaster()) {
	$masters[] = $ref;
	}
	}

	return $masters;
	}

	public static function getMasterDatabaseRefs() {
	$refs = self::getAllMasterDatabaseRefs();
	return self::getEnabledRefs($refs);
	}

	public function isApplicationHost($database) {
	return isset($this->applicationMap[$database]);
	}

	public function loadRawMySQLConfigValue($key) {
	$conn = $this->newManagementConnection();

	try {
	$value = queryfx_one($conn, 'SELECT @@%Q', $key);
	$value = $value['@@'.$key];
	} catch (AphrontQueryException $ex) {
	$value = null;
	}

	return $value;
	}

	public static function getMasterDatabaseRefForApplication($application) {
	$masters = self::getMasterDatabaseRefs();

	$application_master = null;
	$default_master = null;
	foreach ($masters as $master) {
	if ($master->isApplicationHost($application)) {
	$application_master = $master;
	break;
	}
	if ($master->getIsDefaultPartition()) {
	$default_master = $master;
	}
	}

	if ($application_master) {
	$masters = array($application_master);
	} else if ($default_master) {
	$masters = array($default_master);
	} else {
	$masters = array();
	}

	$masters = self::getEnabledRefs($masters);
	$master = head($masters);

	return $master;
	}

	public static function newIndividualRef() {
	$conf = PhabricatorEnv::newObjectFromConfig(
	'mysql.configuration-provider',
	array(null, 'w', null));

	return id(new self())
	->setHost($conf->getHost())
	->setPort($conf->getPort())
	->setUser($conf->getUser())
	->setPass($conf->getPassword())
	->setIsIndividual(true)
	->setIsMaster(true);
	}

	public static function getAllReplicaDatabaseRefs() {
	$refs = self::getClusterRefs();

	if (!$refs) {
	return array();
	}

	$replicas = array();
	foreach ($refs as $ref) {
	if ($ref->getIsMaster()) {
	continue;
	}

	$replicas[] = $ref;
	}

	return $replicas;
	}

	public static function getReplicaDatabaseRefs() {
	$refs = self::getAllReplicaDatabaseRefs();
	return self::getEnabledRefs($refs);
	}

	private static function getEnabledRefs(array $refs) {
	foreach ($refs as $key => $ref) {
	if ($ref->getDisabled()) {
	unset($refs[$key]);
	}
	}
	return $refs;
	}

	public static function getReplicaDatabaseRefForApplication($application) {
	$replicas = self::getReplicaDatabaseRefs();

	$application_replicas = array();
	$default_replicas = array();
	foreach ($replicas as $replica) {
	$master = $replica->getMaster();

	if ($master->isApplicationHost($application)) {
	$application_replicas[] = $replica;
	}

	if ($master->getIsDefaultPartition()) {
	$default_replicas[] = $replica;
	}
	}

	if ($application_replicas) {
	$replicas = $application_replicas;
	} else {
	$replicas = $default_replicas;
	}

	$replicas = self::getEnabledRefs($replicas);

	// TODO: We may have multiple replicas to choose from, and could make
	// more of an effort to pick the "best" one here instead of always
	// picking the first one. Once we've picked one, we should try to use
	// the same replica for the rest of the request, though.

	return head($replicas);
	}

	private function newConnection(array $options) {
	// If we believe the database is unhealthy, don't spend as much time
	// trying to connect to it, since it's likely to continue to fail and
	// hammering it can only make the problem worse.
	$record = $this->getHealthRecord();
	if ($record->getIsHealthy()) {
	$default_retries = 3;
	$default_timeout = 10;
	} else {
	$default_retries = 0;
	$default_timeout = 2;
	}

	$spec = $options + array(
	'user' => $this->getUser(),
	'pass' => $this->getPass(),
	'host' => $this->getHost(),
	'port' => $this->getPort(),
	'database' => null,
	'retries' => $default_retries,
	'timeout' => $default_timeout,
	);

	- return PhabricatorEnv::newObjectFromConfig(
	- 'mysql.implementation',
	- array(
	- $spec,
	- ));
	+ return self::newRawConnection($spec);
	+ }
	+
	+ public static function newRawConnection(array $options) {
	+ if (extension_loaded('mysqli')) {
	+ return new AphrontMySQLiDatabaseConnection($options);
	+ } else {
	+ return new AphrontMySQLDatabaseConnection($options);
	+ }
	}

	}
	diff --git a/src/infrastructure/storage/lisk/PhabricatorLiskDAO.php b/src/infrastructure/storage/lisk/PhabricatorLiskDAO.php
	index 3bc66720db..d206f20806 100644
	--- a/src/infrastructure/storage/lisk/PhabricatorLiskDAO.php
	+++ b/src/infrastructure/storage/lisk/PhabricatorLiskDAO.php
	@@ -1,359 +1,356 @@
	<?php

	/**
	* @task config Configuring Storage
	*/
	abstract class PhabricatorLiskDAO extends LiskDAO {

	private static $namespaceStack = array();

	const ATTACHABLE = '<attachable>';
	const CONFIG_APPLICATION_SERIALIZERS = 'phabricator/serializers';

	/* -( Configuring Storage )------------------------------------------------ */

	/**
	* @task config
	*/
	public static function pushStorageNamespace($namespace) {
	self::$namespaceStack[] = $namespace;
	}

	/**
	* @task config
	*/
	public static function popStorageNamespace() {
	array_pop(self::$namespaceStack);
	}

	/**
	* @task config
	*/
	public static function getDefaultStorageNamespace() {
	return PhabricatorEnv::getEnvConfig('storage.default-namespace');
	}

	/**
	* @task config
	*/
	public static function getStorageNamespace() {
	$namespace = end(self::$namespaceStack);
	if (!strlen($namespace)) {
	$namespace = self::getDefaultStorageNamespace();
	}
	if (!strlen($namespace)) {
	throw new Exception(pht('No storage namespace configured!'));
	}
	return $namespace;
	}

	/**
	* @task config
	*/
	protected function establishLiveConnection($mode) {
	$namespace = self::getStorageNamespace();
	$database = $namespace.'_'.$this->getApplicationName();

	$is_readonly = PhabricatorEnv::isReadOnly();

	if ($is_readonly && ($mode != 'r')) {
	$this->raiseImproperWrite($database);
	}

	$is_cluster = (bool)PhabricatorEnv::getEnvConfig('cluster.databases');
	if ($is_cluster) {
	$connection = $this->newClusterConnection(
	$this->getApplicationName(),
	$database,
	$mode);
	} else {
	$connection = $this->newBasicConnection($database, $mode, $namespace);
	}

	// TODO: This should be testing if the mode is "r", but that would probably
	// break a lot of things. Perform a more narrow test for readonly mode
	// until we have greater certainty that this works correctly most of the
	// time.
	if ($is_readonly) {
	$connection->setReadOnly(true);
	}

	// Unless this is a script running from the CLI:
	// - (T10849) Prevent any query from running for more than 30 seconds.
	// - (T11672) Use persistent connections.
	if (php_sapi_name() != 'cli') {

	// TODO: For now, disable this until after T11044: it's better at high
	// load, but causes us to use slightly more connections at low load and
	// is pushing users over limits like MySQL "max_connections".
	$use_persistent = false;

	$connection
	->setQueryTimeout(30)
	->setPersistent($use_persistent);
	}

	return $connection;
	}

	private function newBasicConnection($database, $mode, $namespace) {
	$conf = PhabricatorEnv::newObjectFromConfig(
	'mysql.configuration-provider',
	array($this, $mode, $namespace));

	- return PhabricatorEnv::newObjectFromConfig(
	- 'mysql.implementation',
	+ return PhabricatorDatabaseRef::newRawConnection(
	array(
	- array(
	- 'user' => $conf->getUser(),
	- 'pass' => $conf->getPassword(),
	- 'host' => $conf->getHost(),
	- 'port' => $conf->getPort(),
	- 'database' => $database,
	- 'retries' => 3,
	- 'timeout' => 10,
	- ),
	+ 'user' => $conf->getUser(),
	+ 'pass' => $conf->getPassword(),
	+ 'host' => $conf->getHost(),
	+ 'port' => $conf->getPort(),
	+ 'database' => $database,
	+ 'retries' => 3,
	+ 'timeout' => 10,
	));
	}

	private function newClusterConnection($application, $database, $mode) {
	$master = PhabricatorDatabaseRef::getMasterDatabaseRefForApplication(
	$application);

	if ($master && !$master->isSevered()) {
	$connection = $master->newApplicationConnection($database);
	if ($master->isReachable($connection)) {
	return $connection;
	} else {
	if ($mode == 'w') {
	$this->raiseImpossibleWrite($database);
	}
	PhabricatorEnv::setReadOnly(
	true,
	PhabricatorEnv::READONLY_UNREACHABLE);
	}
	}

	$replica = PhabricatorDatabaseRef::getReplicaDatabaseRefForApplication(
	$application);
	if ($replica) {
	$connection = $replica->newApplicationConnection($database);
	$connection->setReadOnly(true);
	if ($replica->isReachable($connection)) {
	return $connection;
	}
	}

	if (!$master && !$replica) {
	$this->raiseUnconfigured($database);
	}

	$this->raiseUnreachable($database);
	}

	private function raiseImproperWrite($database) {
	throw new PhabricatorClusterImproperWriteException(
	pht(
	'Unable to establish a write-mode connection (to application '.
	'database "%s") because Phabricator is in read-only mode. Whatever '.
	'you are trying to do does not function correctly in read-only mode.',
	$database));
	}

	private function raiseImpossibleWrite($database) {
	throw new PhabricatorClusterImpossibleWriteException(
	pht(
	'Unable to connect to master database ("%s"). This is a severe '.
	'failure; your request did not complete.',
	$database));
	}

	private function raiseUnconfigured($database) {
	throw new Exception(
	pht(
	'Unable to establish a connection to any database host '.
	'(while trying "%s"). No masters or replicas are configured.',
	$database));
	}

	private function raiseUnreachable($database) {
	throw new PhabricatorClusterStrandedException(
	pht(
	'Unable to establish a connection to any database host '.
	'(while trying "%s"). All masters and replicas are completely '.
	'unreachable.',
	$database));
	}


	/**
	* @task config
	*/
	public function getTableName() {
	$str = 'phabricator';
	$len = strlen($str);

	$class = strtolower(get_class($this));
	if (!strncmp($class, $str, $len)) {
	$class = substr($class, $len);
	}
	$app = $this->getApplicationName();
	if (!strncmp($class, $app, strlen($app))) {
	$class = substr($class, strlen($app));
	}

	if (strlen($class)) {
	return $app.'_'.$class;
	} else {
	return $app;
	}
	}

	/**
	* @task config
	*/
	abstract public function getApplicationName();

	protected function getConnectionNamespace() {
	return self::getStorageNamespace().'_'.$this->getApplicationName();
	}


	/**
	* Break a list of escaped SQL statement fragments (e.g., VALUES lists for
	* INSERT, previously built with @{function:qsprintf}) into chunks which will
	* fit under the MySQL 'max_allowed_packet' limit.
	*
	* Chunks are glued together with `$glue`, by default ", ".
	*
	* If a statement is too large to fit within the limit, it is broken into
	* its own chunk (but might fail when the query executes).
	*/
	public static function chunkSQL(
	array $fragments,
	$glue = ', ',
	$limit = null) {

	if ($limit === null) {
	// NOTE: Hard-code this at 1MB for now, minus a 10% safety buffer.
	// Eventually we could query MySQL or let the user configure it.
	$limit = (int)((1024 * 1024) * 0.90);
	}

	$result = array();

	$chunk = array();
	$len = 0;
	$glue_len = strlen($glue);
	foreach ($fragments as $fragment) {
	$this_len = strlen($fragment);

	if ($chunk) {
	// Chunks after the first also imply glue.
	$this_len += $glue_len;
	}

	if ($len + $this_len <= $limit) {
	$len += $this_len;
	$chunk[] = $fragment;
	} else {
	if ($chunk) {
	$result[] = $chunk;
	}
	$len = strlen($fragment);
	$chunk = array($fragment);
	}
	}

	if ($chunk) {
	$result[] = $chunk;
	}

	foreach ($result as $key => $fragment_list) {
	$result[$key] = implode($glue, $fragment_list);
	}

	return $result;
	}

	protected function assertAttached($property) {
	if ($property === self::ATTACHABLE) {
	throw new PhabricatorDataNotAttachedException($this);
	}
	return $property;
	}

	protected function assertAttachedKey($value, $key) {
	$this->assertAttached($value);
	if (!array_key_exists($key, $value)) {
	throw new PhabricatorDataNotAttachedException($this);
	}
	return $value[$key];
	}

	protected function detectEncodingForStorage($string) {
	return phutil_is_utf8($string) ? 'utf8' : null;
	}

	protected function getUTF8StringFromStorage($string, $encoding) {
	if ($encoding == 'utf8') {
	return $string;
	}

	if (function_exists('mb_detect_encoding')) {
	if (strlen($encoding)) {
	$try_encodings = array(
	$encoding,
	);
	} else {
	// TODO: This is pretty much a guess, and probably needs to be
	// configurable in the long run.
	$try_encodings = array(
	'JIS',
	'EUC-JP',
	'SJIS',
	'ISO-8859-1',
	);
	}

	$guess = mb_detect_encoding($string, $try_encodings);
	if ($guess) {
	return mb_convert_encoding($string, 'UTF-8', $guess);
	}
	}

	return phutil_utf8ize($string);
	}

	protected function willReadData(array &$data) {
	parent::willReadData($data);

	static $custom;
	if ($custom === null) {
	$custom = $this->getConfigOption(self::CONFIG_APPLICATION_SERIALIZERS);
	}

	if ($custom) {
	foreach ($custom as $key => $serializer) {
	$data[$key] = $serializer->willReadValue($data[$key]);
	}
	}
	}

	protected function willWriteData(array &$data) {
	static $custom;
	if ($custom === null) {
	$custom = $this->getConfigOption(self::CONFIG_APPLICATION_SERIALIZERS);
	}

	if ($custom) {
	foreach ($custom as $key => $serializer) {
	$data[$key] = $serializer->willWriteValue($data[$key]);
	}
	}

	parent::willWriteData($data);
	}


	}
	diff --git a/src/infrastructure/storage/management/PhabricatorStorageManagementAPI.php b/src/infrastructure/storage/management/PhabricatorStorageManagementAPI.php
	index 15b46300f1..d7104af323 100644
	--- a/src/infrastructure/storage/management/PhabricatorStorageManagementAPI.php
	+++ b/src/infrastructure/storage/management/PhabricatorStorageManagementAPI.php
	@@ -1,365 +1,362 @@
	<?php

	final class PhabricatorStorageManagementAPI extends Phobject {

	private $ref;
	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 setRef(PhabricatorDatabaseRef $ref) {
	$this->ref = $ref;
	return $this;
	}

	public function getRef() {
	return $this->ref;
	}

	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(
	+ $return = PhabricatorDatabaseRef::newRawConnection(
	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);
	}

	try {
	queryfx($conn, '%Q', $query);
	} catch (AphrontAccessDeniedQueryException $ex) {
	throw new PhutilProxyException(
	pht(
	'Unable to access a required database or table. This almost '.
	'always means that the user you are connecting with ("%s") does '.
	'not have sufficient permissions granted in MySQL. You can '.
	'use `bin/storage databases` to get a list of all databases '.
	'permission is required on.',
	$this->getUser()),
	$ex);
	}
	}
	}

	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,
	);
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Dec 1, 4:58 PM (1 d, 12 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 430763
Default Alt Text: (67 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions