No OneTemporary
Actions

Size

85 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/config/check/PhabricatorSetupCheck.php b/src/applications/config/check/PhabricatorSetupCheck.php
	index 187236c174..4648965e4e 100644
	--- a/src/applications/config/check/PhabricatorSetupCheck.php
	+++ b/src/applications/config/check/PhabricatorSetupCheck.php
	@@ -1,79 +1,118 @@
	<?php

	abstract class PhabricatorSetupCheck {

	private $issues;

	abstract protected function executeChecks();

	final protected function newIssue($key) {
	$issue = id(new PhabricatorSetupIssue())
	->setIssueKey($key);

	$this->issues[$key] = $issue;

	return $issue;
	}

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

	final public function runSetupChecks() {
	$this->issues = array();
	$this->executeChecks();
	}

	final public static function getOpenSetupIssueCount() {
	$cache = PhabricatorCaches::getSetupCache();
	return $cache->getKey('phabricator.setup.issues');
	}

	final public static function setOpenSetupIssueCount($count) {
	$cache = PhabricatorCaches::getSetupCache();
	$cache->setKey('phabricator.setup.issues', $count);
	}

	+ final public static function getConfigNeedsRepair() {
	+ $cache = PhabricatorCaches::getSetupCache();
	+ return $cache->getKey('phabricator.setup.needs-repair');
	+ }
	+
	+ final public static function setConfigNeedsRepair($needs_repair) {
	+ $cache = PhabricatorCaches::getSetupCache();
	+ $cache->setKey('phabricator.setup.needs-repair', $needs_repair);
	+ }
	+
	+ final public static function deleteSetupCheckCache() {
	+ $cache = PhabricatorCaches::getSetupCache();
	+ $cache->deleteKeys(
	+ array(
	+ 'phabricator.setup.needs-repair',
	+ 'phabricator.setup.issues',
	+ ));
	+ }
	+
	final public static function willProcessRequest() {
	$issue_count = self::getOpenSetupIssueCount();
	- if ($issue_count !== null) {
	- // We've already run setup checks, didn't hit any fatals, and then set
	- // an issue count. This means we're good and don't need to do any extra
	- // work.
	- return null;
	+ if ($issue_count === null) {
	+ $issues = self::runAllChecks();
	+ self::setOpenSetupIssueCount(count($issues));
	}

	- $issues = self::runAllChecks();
	-
	- self::setOpenSetupIssueCount(count($issues));
	-
	- return null;
	+ // Try to repair configuration unless we have a clean bill of health on it.
	+ // We need to keep doing this on every page load until all the problems
	+ // are fixed, which is why it's separate from setup checks (which run
	+ // once per restart).
	+ $needs_repair = self::getConfigNeedsRepair();
	+ if ($needs_repair !== false) {
	+ $needs_repair = self::repairConfig();
	+ self::setConfigNeedsRepair($needs_repair);
	+ }
	}

	final public static function runAllChecks() {
	$symbols = id(new PhutilSymbolLoader())
	->setAncestorClass('PhabricatorSetupCheck')
	->setConcreteOnly(true)
	->selectAndLoadSymbols();

	$checks = array();
	foreach ($symbols as $symbol) {
	$checks[] = newv($symbol['name'], array());
	}

	$issues = array();
	foreach ($checks as $check) {
	$check->runSetupChecks();
	foreach ($check->getIssues() as $key => $issue) {
	if (isset($issues[$key])) {
	throw new Exception(
	"Two setup checks raised an issue with key '{$key}'!");
	}
	$issues[$key] = $issue;
	}
	}

	return $issues;
	}

	+ final public static function repairConfig() {
	+ $needs_repair = false;
	+
	+ $options = PhabricatorApplicationConfigOptions::loadAllOptions();
	+ foreach ($options as $option) {
	+ try {
	+ $option->getGroup()->validateOption(
	+ $option,
	+ PhabricatorEnv::getEnvConfig($option->getKey()));
	+ } catch (PhabricatorConfigValidationException $ex) {
	+ PhabricatorEnv::repairConfig($option->getKey(), $option->getDefault());
	+ $needs_repair = true;
	+ }
	+ }
	+
	+ return $needs_repair;
	+ }
	+
	}
	diff --git a/src/applications/config/check/PhabricatorSetupCheckInvalidConfig.php b/src/applications/config/check/PhabricatorSetupCheckInvalidConfig.php
	index 39b7d77cf3..d17c830ee0 100644
	--- a/src/applications/config/check/PhabricatorSetupCheckInvalidConfig.php
	+++ b/src/applications/config/check/PhabricatorSetupCheckInvalidConfig.php
	@@ -1,29 +1,30 @@
	<?php

	final class PhabricatorSetupCheckInvalidConfig extends PhabricatorSetupCheck {

	protected function executeChecks() {
	$groups = PhabricatorApplicationConfigOptions::loadAll();
	foreach ($groups as $group) {
	$options = $group->getOptions();
	foreach ($options as $option) {
	try {
	$group->validateOption(
	$option,
	- PhabricatorEnv::getEnvConfig($option->getKey()));
	+ PhabricatorEnv::getUnrepairedEnvConfig($option->getKey()));
	} catch (PhabricatorConfigValidationException $ex) {
	$this
	->newIssue('config.invalid.'.$option->getKey())
	->setName(pht("Config '%s' Invalid", $option->getKey()))
	->setMessage(
	pht(
	- "Configuration option '%s' has invalid value: %s",
	+ "Configuration option '%s' has invalid value and ".
	+ "was restored to the default: %s",
	$option->getKey(),
	$ex->getMessage()))
	->addPhabricatorConfig($option->getKey());
	}
	}
	}
	}

	}
	diff --git a/src/applications/config/editor/PhabricatorConfigEditor.php b/src/applications/config/editor/PhabricatorConfigEditor.php
	index 673eff2307..a2ca330fdf 100644
	--- a/src/applications/config/editor/PhabricatorConfigEditor.php
	+++ b/src/applications/config/editor/PhabricatorConfigEditor.php
	@@ -1,102 +1,107 @@
	<?php

	final class PhabricatorConfigEditor
	extends PhabricatorApplicationTransactionEditor {

	public function getTransactionTypes() {
	$types = parent::getTransactionTypes();

	$types[] = PhabricatorConfigTransaction::TYPE_EDIT;

	return $types;
	}

	protected function getCustomTransactionOldValue(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	case PhabricatorConfigTransaction::TYPE_EDIT:
	return array(
	'deleted' => (bool)$object->getIsDeleted(),
	'value' => $object->getValue(),
	);
	}
	}

	protected function getCustomTransactionNewValue(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	case PhabricatorConfigTransaction::TYPE_EDIT:
	return $xaction->getNewValue();
	}
	}

	protected function applyCustomInternalTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	case PhabricatorConfigTransaction::TYPE_EDIT:
	$v = $xaction->getNewValue();

	// If this is a defined configuration option (vs a straggler from an
	// old version of Phabricator or a configuration file misspelling)
	// submit it to the validation gauntlet.
	$key = $object->getConfigKey();
	$all_options = PhabricatorApplicationConfigOptions::loadAllOptions();
	$option = idx($all_options, $key);
	if ($option) {
	$option->getGroup()->validateOption(
	$option,
	$v['value']);
	}

	$object->setIsDeleted($v['deleted']);
	$object->setValue($v['value']);
	break;
	}
	}

	protected function applyCustomExternalTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	return;
	}

	protected function mergeTransactions(
	PhabricatorApplicationTransaction $u,
	PhabricatorApplicationTransaction $v) {

	$type = $u->getTransactionType();
	switch ($type) {
	case PhabricatorConfigTransaction::TYPE_EDIT:
	return $v;
	}

	return parent::mergeTransactions($u, $v);
	}

	protected function transactionHasEffect(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	$old = $xaction->getOldValue();
	$new = $xaction->getNewValue();

	$type = $xaction->getTransactionType();
	switch ($type) {
	case PhabricatorConfigTransaction::TYPE_EDIT:
	// If an edit deletes an already-deleted entry, no-op it.
	if (idx($old, 'deleted') && idx($new, 'deleted')) {
	return false;
	}
	break;
	}

	return parent::transactionHasEffect($object, $xaction);
	}

	+ protected function didApplyTransactions(array $xactions) {
	+ // Force all the setup checks to run on the next page load.
	+ PhabricatorSetupCheck::deleteSetupCheckCache();
	+ }
	+
	}
	diff --git a/src/applications/config/view/PhabricatorSetupIssueView.php b/src/applications/config/view/PhabricatorSetupIssueView.php
	index 2d8004ea00..3d33a7cd6a 100644
	--- a/src/applications/config/view/PhabricatorSetupIssueView.php
	+++ b/src/applications/config/view/PhabricatorSetupIssueView.php
	@@ -1,323 +1,323 @@
	<?php

	final class PhabricatorSetupIssueView extends AphrontView {

	private $issue;

	public function setIssue(PhabricatorSetupIssue $issue) {
	$this->issue = $issue;
	return $this;
	}

	public function getIssue() {
	return $this->issue;
	}

	public function render() {
	$issue = $this->getIssue();

	$description = phutil_render_tag(
	'div',
	array(
	'class' => 'setup-issue-instructions',
	),
	nl2br(phutil_escape_html($issue->getMessage())));

	$configs = $issue->getPHPConfig();
	if ($configs) {
	$description .= $this->renderPHPConfig($configs);
	}

	$configs = $issue->getPhabricatorConfig();
	if ($configs) {
	$description .= $this->renderPhabricatorConfig($configs);
	}

	$commands = $issue->getCommands();
	if ($commands) {
	$run_these = pht("Run these %d command(s):", count($commands));
	$description .= phutil_render_tag(
	'div',
	array(
	'class' => 'setup-issue-config',
	),
	phutil_render_tag('p', array(), $run_these).
	phutil_render_tag('pre', array(), implode("\n", $commands)));
	}

	$extensions = $issue->getPHPExtensions();
	if ($extensions) {
	$install_these = pht(
	"Install these %d PHP extension(s):", count($extensions));

	$install_info = pht(
	"You can usually install a PHP extension using <tt>apt-get</tt> or ".
	"<tt>yum</tt>. Common package names are ".
	"<tt>php-<em>extname</em></tt> or <tt>php5-<em>extname</em></tt>. ".
	"Try commands like these:");

	// TODO: We should do a better job of detecting how to install extensions
	// on the current system.
	$install_commands = array(
	"$ sudo apt-get install php5-<em>extname</em> # Debian / Ubuntu",
	"$ sudo yum install php-<em>extname</em> # Red Hat / Derivatives",
	);
	$install_commands = implode("\n", $install_commands);

	$fallback_info = pht(
	"If those commands don't work, try Google. The process of installing ".
	"PHP extensions is not specific to Phabricator, and any instructions ".
	"you can find for installing them on your system should work. On Mac ".
	"OS X, you might want to try Homebrew.");

	$restart_info = pht(
	"After installing new PHP extensions, <strong>restart your webserver ".
	"for the changes to take effect</strong>.");

	$description .= phutil_render_tag(
	'div',
	array(
	'class' => 'setup-issue-config',
	),
	phutil_render_tag('p', array(), $install_these).
	phutil_render_tag('pre', array(), implode("\n", $extensions)).
	phutil_render_tag('p', array(), $install_info).
	phutil_render_tag('pre', array(), $install_commands).
	phutil_render_tag('p', array(), $fallback_info).
	phutil_render_tag('p', array(), $restart_info));

	}

	$next = phutil_render_tag(
	'div',
	array(
	'class' => 'setup-issue-next',
	),
	pht('To continue, resolve this problem and reload the page.'));

	$name = phutil_render_tag(
	'div',
	array(
	'class' => 'setup-issue-name',
	),
	phutil_escape_html($issue->getName()));

	return phutil_render_tag(
	'div',
	array(
	'class' => 'setup-issue',
	),
	$name.$description.$next);
	}

	private function renderPhabricatorConfig(array $configs) {
	$issue = $this->getIssue();

	$table_info = phutil_render_tag(
	'p',
	array(),
	pht(
	"The current Phabricator configuration has these %d value(s):",
	count($configs)));

	$table = array();
	foreach ($configs as $key) {
	$table[] = '<tr>';
	$table[] = '<th>'.phutil_escape_html($key).'</th>';

	- $value = PhabricatorEnv::getEnvConfig($key);
	+ $value = PhabricatorEnv::getUnrepairedEnvConfig($key);
	if ($value === null) {
	$value = '<em>null</em>';
	} else if ($value === false) {
	$value = '<em>false</em>';
	} else if ($value === true) {
	$value = '<em>true</em>';
	} else {
	$value = phutil_escape_html(
	PhabricatorConfigJSON::prettyPrintJSON($value));
	}

	$table[] = '<td>'.$value.'</td>';
	$table[] = '</tr>';
	}

	$table = phutil_render_tag(
	'table',
	array(
	),
	implode("\n", $table));

	if ($this->getIssue()->getIsFatal()) {
	$update_info = phutil_render_tag(
	'p',
	array(),
	pht(
	"To update these %d value(s), run these command(s) from the command ".
	"line:",
	count($configs)));

	$update = array();
	foreach ($configs as $key) {
	$cmd = '<tt>phabricator/ $</tt> ./bin/config set '.
	phutil_escape_html($key).' '.
	'<em>value</em>';
	$update[] = $cmd;
	}
	$update = phutil_render_tag('pre', array(), implode("\n", $update));
	} else {
	$update_info = phutil_render_tag(
	'p',
	array(),
	pht("You can update these %d value(s) here:", count($configs)));
	$update = array();
	foreach ($configs as $config) {
	$link = phutil_render_tag(
	'a',
	array(
	'href' => '/config/edit/'.$config.'/?issue='.$issue->getIssueKey(),
	),
	pht('Edit %s', phutil_escape_html($config)));
	$update[] = '<li>'.$link.'</li>';
	}
	$update = '<ul>'.implode("\n", $update).'</ul>';
	}

	return phutil_render_tag(
	'div',
	array(
	'class' => 'setup-issue-config',
	),
	self::renderSingleView(
	array(
	$table_info,
	$table,
	$update_info,
	$update,
	)));
	}

	private function renderPHPConfig(array $configs) {
	$table_info = phutil_render_tag(
	'p',
	array(),
	pht(
	"The current PHP configuration has these %d value(s):",
	count($configs)));

	$table = array();
	foreach ($configs as $key) {
	$table[] = '<tr>';
	$table[] = '<th>'.phutil_escape_html($key).'</th>';

	$value = ini_get($key);
	if ($value === null) {
	$value = '<em>null</em>';
	} else if ($value === false) {
	$value = '<em>false</em>';
	} else if ($value === true) {
	$value = '<em>true</em>';
	} else if ($value === '') {
	$value = '<em>(empty string)</em>';
	} else {
	$value = phutil_escape_html($value);
	}

	$table[] = '<td>'.$value.'</td>';
	$table[] = '</tr>';
	}

	$table = phutil_render_tag(
	'table',
	array(

	),
	implode("\n", $table));

	ob_start();
	phpinfo();
	$phpinfo = ob_get_clean();


	$rex = '@Loaded Configuration File\s</td><td class="v">(.?)</td>@i';
	$matches = null;

	$ini_loc = null;
	if (preg_match($rex, $phpinfo, $matches)) {
	$ini_loc = trim($matches[1]);
	}

	$rex = '@Additional \.ini files parsed\s</td><td class="v">(.?)</td>@i';

	$more_loc = array();
	if (preg_match($rex, $phpinfo, $matches)) {
	$more_loc = trim($matches[1]);
	if ($more_loc == '(none)') {
	$more_loc = array();
	} else {
	$more_loc = preg_split('/\s,\s/', $more_loc);
	}
	}

	if (!$ini_loc) {
	$info = phutil_render_tag(
	'p',
	array(),
	pht(
	"To update these %d value(s), edit your PHP configuration file.",
	count($configs)));
	} else {
	$info = phutil_render_tag(
	'p',
	array(),
	pht(
	"To update these %d value(s), edit your PHP configuration file, ".
	"located here:",
	count($configs)));
	$info .= phutil_render_tag(
	'pre',
	array(),
	phutil_escape_html($ini_loc));
	}

	if ($more_loc) {
	$info .= phutil_render_tag(
	'p',
	array(),
	pht(
	"PHP also loaded these configuration file(s):",
	count($more_loc)));
	$info .= phutil_render_tag(
	'pre',
	array(),
	phutil_escape_html(implode("\n", $more_loc)));
	}

	$info .= phutil_render_tag(
	'p',
	array(),
	pht(
	"You can find more information about PHP configuration values in the ".
	"%s.",
	phutil_render_tag(
	'a',
	array(
	'href' => 'http://php.net/manual/ini.list.php',
	),
	pht('PHP Documentation'))));

	$info .= phutil_render_tag(
	'p',
	array(),
	pht(
	"After editing the PHP configuration, <strong>restart your ".
	"webserver for the changes to take effect</strong>."));

	return phutil_render_tag(
	'div',
	array(
	'class' => 'setup-issue-config',
	),
	$table_info.$table.$info);
	}

	}
	diff --git a/src/applications/transactions/editor/PhabricatorApplicationTransactionEditor.php b/src/applications/transactions/editor/PhabricatorApplicationTransactionEditor.php
	index c9510f636d..ec717468d3 100644
	--- a/src/applications/transactions/editor/PhabricatorApplicationTransactionEditor.php
	+++ b/src/applications/transactions/editor/PhabricatorApplicationTransactionEditor.php
	@@ -1,885 +1,892 @@
	<?php

	/**
	* @task mail Sending Mail
	* @task feed Publishing Feed Stories
	* @task search Search Index
	*/
	abstract class PhabricatorApplicationTransactionEditor
	extends PhabricatorEditor {

	private $contentSource;
	private $object;
	private $xactions;

	private $isNewObject;
	private $mentionedPHIDs;
	private $continueOnNoEffect;

	private $isPreview;

	/**
	* When the editor tries to apply transactions that have no effect, should
	* it raise an exception (default) or drop them and continue?
	*
	* Generally, you will set this flag for edits coming from "Edit" interfaces,
	* and leave it cleared for edits coming from "Comment" interfaces, so the
	* user will get a useful error if they try to submit a comment that does
	* nothing (e.g., empty comment with a status change that has already been
	* performed by another user).
	*
	* @param bool True to drop transactions without effect and continue.
	* @return this
	*/
	public function setContinueOnNoEffect($continue) {
	$this->continueOnNoEffect = $continue;
	return $this;
	}

	public function getContinueOnNoEffect() {
	return $this->continueOnNoEffect;
	}

	protected function getIsNewObject() {
	return $this->isNewObject;
	}

	protected function getMentionedPHIDs() {
	return $this->mentionedPHIDs;
	}

	public function setIsPreview($is_preview) {
	$this->isPreview = $is_preview;
	return $this;
	}

	public function getIsPreview() {
	return $this->isPreview;
	}

	public function getTransactionTypes() {
	$types = array();

	if ($this->object instanceof PhabricatorSubscribableInterface) {
	$types[] = PhabricatorTransactions::TYPE_SUBSCRIBERS;
	}

	return $types;
	}

	private function adjustTransactionValues(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	$old = $this->getTransactionOldValue($object, $xaction);
	$xaction->setOldValue($old);

	$new = $this->getTransactionNewValue($object, $xaction);
	$xaction->setNewValue($new);
	}

	private function getTransactionOldValue(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_SUBSCRIBERS:
	if ($object->getPHID()) {
	$old_phids = PhabricatorSubscribersQuery::loadSubscribersForPHID(
	$object->getPHID());
	} else {
	$old_phids = array();
	}
	return array_values($old_phids);
	case PhabricatorTransactions::TYPE_VIEW_POLICY:
	return $object->getViewPolicy();
	case PhabricatorTransactions::TYPE_EDIT_POLICY:
	return $object->getEditPolicy();
	default:
	return $this->getCustomTransactionOldValue($object, $xaction);
	}
	}

	private function getTransactionNewValue(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_SUBSCRIBERS:
	return $this->getPHIDTransactionNewValue($xaction);
	case PhabricatorTransactions::TYPE_VIEW_POLICY:
	case PhabricatorTransactions::TYPE_EDIT_POLICY:
	return $xaction->getNewValue();
	default:
	return $this->getCustomTransactionNewValue($object, $xaction);
	}
	}

	protected function getCustomTransactionOldValue(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	throw new Exception("Capability not supported!");
	}

	protected function getCustomTransactionNewValue(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	throw new Exception("Capability not supported!");
	}

	protected function transactionHasEffect(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COMMENT:
	return $xaction->hasComment();
	}

	return ($xaction->getOldValue() !== $xaction->getNewValue());
	}

	private function applyInternalEffects(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COMMENT:
	break;
	case PhabricatorTransactions::TYPE_VIEW_POLICY:
	$object->setViewPolicy($xaction->getNewValue());
	break;
	case PhabricatorTransactions::TYPE_EDIT_POLICY:
	$object->setEditPolicy($xaction->getNewValue());
	break;
	default:
	return $this->applyCustomInternalTransaction($object, $xaction);
	}
	}

	private function applyExternalEffects(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COMMENT:
	break;
	case PhabricatorTransactions::TYPE_SUBSCRIBERS:
	$subeditor = id(new PhabricatorSubscriptionsEditor())
	->setObject($object)
	->setActor($this->requireActor())
	->subscribeExplicit($xaction->getNewValue())
	->save();
	break;
	default:
	return $this->applyCustomExternalTransaction($object, $xaction);
	}
	}

	protected function applyCustomInternalTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	throw new Exception("Capability not supported!");
	}

	protected function applyCustomExternalTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	throw new Exception("Capability not supported!");
	}

	public function setContentSource(PhabricatorContentSource $content_source) {
	$this->contentSource = $content_source;
	return $this;
	}

	public function getContentSource() {
	return $this->contentSource;
	}

	final public function applyTransactions(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$this->object = $object;
	$this->xactions = $xactions;
	$this->isNewObject = ($object->getPHID() === null);

	$this->validateEditParameters($object, $xactions);


	$actor = $this->requireActor();

	$mention_xaction = $this->buildMentionTransaction($object, $xactions);
	if ($mention_xaction) {
	$xactions[] = $mention_xaction;
	}

	$xactions = $this->combineTransactions($xactions);

	foreach ($xactions as $xaction) {
	// TODO: This needs to be more sophisticated once we have meta-policies.
	$xaction->setViewPolicy(PhabricatorPolicies::POLICY_PUBLIC);
	$xaction->setEditPolicy($actor->getPHID());

	$xaction->setAuthorPHID($actor->getPHID());
	$xaction->setContentSource($this->getContentSource());
	}

	foreach ($xactions as $xaction) {
	$this->adjustTransactionValues($object, $xaction);
	}

	$xactions = $this->filterTransactions($object, $xactions);

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

	$xactions = $this->sortTransactions($xactions);

	if ($this->getIsPreview()) {
	$this->loadHandles($xactions);
	return $xactions;
	}

	$comment_editor = id(new PhabricatorApplicationTransactionCommentEditor())
	->setActor($actor)
	->setContentSource($this->getContentSource());

	$object->openTransaction();
	foreach ($xactions as $xaction) {
	$this->applyInternalEffects($object, $xaction);
	}

	$object->save();

	foreach ($xactions as $xaction) {
	$xaction->setObjectPHID($object->getPHID());
	if ($xaction->getComment()) {
	$xaction->setPHID($xaction->generatePHID());
	$comment_editor->applyEdit($xaction, $xaction->getComment());
	} else {
	$xaction->save();
	}
	}

	foreach ($xactions as $xaction) {
	$this->applyExternalEffects($object, $xaction);
	}
	$object->saveTransaction();

	$this->loadHandles($xactions);

	$mail = null;
	if ($this->supportsMail()) {
	$mail = $this->sendMail($object, $xactions);
	}

	if ($this->supportsSearch()) {
	id(new PhabricatorSearchIndexer())
	->indexDocumentByPHID($object->getPHID());
	}

	if ($this->supportsFeed()) {
	$mailed = array();
	if ($mail) {
	$mailed = $mail->buildRecipientList();
	}
	$this->publishFeedStory(
	$object,
	$xactions,
	$mailed);
	}

	+ $this->didApplyTransactions($xactions);
	+
	return $xactions;
	}

	+ protected function didApplyTransactions(array $xactions) {
	+ // Hook for subclasses.
	+ return;
	+ }
	+
	private function loadHandles(array $xactions) {
	$phids = array();
	foreach ($xactions as $key => $xaction) {
	$phids[$key] = $xaction->getRequiredHandlePHIDs();
	}
	$handles = array();
	$merged = array_mergev($phids);
	if ($merged) {
	$handles = id(new PhabricatorObjectHandleData($merged))
	->setViewer($this->requireActor())
	->loadHandles();
	}
	foreach ($xactions as $key => $xaction) {
	$xaction->setHandles(array_select_keys($handles, $phids[$key]));
	}
	}

	private function validateEditParameters(
	PhabricatorLiskDAO $object,
	array $xactions) {

	if (!$this->getContentSource()) {
	throw new Exception(
	"Call setContentSource() before applyTransactions()!");
	}

	// Do a bunch of sanity checks that the incoming transactions are fresh.
	// They should be unsaved and have only "transactionType" and "newValue"
	// set.

	$types = array_fill_keys($this->getTransactionTypes(), true);

	assert_instances_of($xactions, 'PhabricatorApplicationTransaction');
	foreach ($xactions as $xaction) {
	if ($xaction->getPHID() \|\| $xaction->getID()) {
	throw new Exception(
	"You can not apply transactions which already have IDs/PHIDs!");
	}
	if ($xaction->getObjectPHID()) {
	throw new Exception(
	"You can not apply transactions which already have objectPHIDs!");
	}
	if ($xaction->getAuthorPHID()) {
	throw new Exception(
	"You can not apply transactions which already have authorPHIDs!");
	}
	if ($xaction->getCommentPHID()) {
	throw new Exception(
	"You can not apply transactions which already have commentPHIDs!");
	}
	if ($xaction->getCommentVersion() !== 0) {
	throw new Exception(
	"You can not apply transactions which already have commentVersions!");
	}
	if ($xaction->getOldValue() !== null) {
	throw new Exception(
	"You can not apply transactions which already have oldValue!");
	}

	$type = $xaction->getTransactionType();
	if (empty($types[$type])) {
	throw new Exception("Transaction has unknown type '{$type}'.");
	}
	}

	// The actor must have permission to view and edit the object.

	$actor = $this->requireActor();

	PhabricatorPolicyFilter::requireCapability(
	$actor,
	$xaction,
	PhabricatorPolicyCapability::CAN_VIEW);

	PhabricatorPolicyFilter::requireCapability(
	$actor,
	$xaction,
	PhabricatorPolicyCapability::CAN_EDIT);
	}

	private function buildMentionTransaction(
	PhabricatorLiskDAO $object,
	array $xactions) {

	if (!($object instanceof PhabricatorSubscribableInterface)) {
	return null;
	}

	$texts = array();
	foreach ($xactions as $xaction) {
	$texts[] = $this->getMentionableTextsFromTransaction($xaction);
	}
	$texts = array_mergev($texts);

	$phids = PhabricatorMarkupEngine::extractPHIDsFromMentions($texts);

	$this->mentionedPHIDs = $phids;

	if (!$phids) {
	return null;
	}

	if ($object->getPHID()) {
	// Don't try to subscribe already-subscribed mentions: we want to generate
	// a dialog about an action having no effect if the user explicitly adds
	// existing CCs, but not if they merely mention existing subscribers.
	$current = PhabricatorSubscribersQuery::loadSubscribersForPHID(
	$object->getPHID());
	$phids = array_diff($phids, $current);
	}

	if (!$phids) {
	return null;
	}

	$xaction = newv(get_class(head($xactions)), array());
	$xaction->setTransactionType(PhabricatorTransactions::TYPE_SUBSCRIBERS);
	$xaction->setNewValue(array('+' => $phids));

	return $xaction;
	}

	protected function getMentionableTextsFromTransaction(
	PhabricatorApplicationTransaction $transaction) {
	$texts = array();
	if ($transaction->getComment()) {
	$texts[] = $transaction->getComment()->getContent();
	}
	return $texts;
	}

	protected function mergeTransactions(
	PhabricatorApplicationTransaction $u,
	PhabricatorApplicationTransaction $v) {

	$type = $u->getTransactionType();

	switch ($type) {
	case PhabricatorTransactions::TYPE_SUBSCRIBERS:
	return $this->mergePHIDTransactions($u, $v);
	}

	// By default, do not merge the transactions.
	return null;
	}


	/**
	* Attempt to combine similar transactions into a smaller number of total
	* transactions. For example, two transactions which edit the title of an
	* object can be merged into a single edit.
	*/
	private function combineTransactions(array $xactions) {
	$stray_comments = array();

	$result = array();
	$types = array();
	foreach ($xactions as $key => $xaction) {
	$type = $xaction->getTransactionType();
	if (isset($types[$type])) {
	foreach ($types[$type] as $other_key) {
	$merged = $this->mergeTransactions($result[$other_key], $xaction);
	if ($merged) {
	$result[$other_key] = $merged;

	if ($xaction->getComment() &&
	($xaction->getComment() !== $merged->getComment())) {
	$stray_comments[] = $xaction->getComment();
	}

	if ($result[$other_key]->getComment() &&
	($result[$other_key]->getComment() !== $merged->getComment())) {
	$stray_comments[] = $result[$other_key]->getComment();
	}

	// Move on to the next transaction.
	continue 2;
	}
	}
	}
	$result[$key] = $xaction;
	$types[$type][] = $key;
	}

	// If we merged any comments away, restore them.
	foreach ($stray_comments as $comment) {
	$xaction = newv(get_class(head($result)), array());
	$xaction->setTransactionType(PhabricatorTransactions::TYPE_COMMENT);
	$xaction->setComment($comment);
	$result[] = $xaction;
	}

	return array_values($result);
	}

	protected function mergePHIDTransactions(
	PhabricatorApplicationTransaction $u,
	PhabricatorApplicationTransaction $v) {

	$result = $u->getNewValue();
	foreach ($v->getNewValue() as $key => $value) {
	$result[$key] = array_merge($value, idx($result, $key, array()));
	}
	$u->setNewValue($result);

	return $u;
	}


	protected function getPHIDTransactionNewValue(
	PhabricatorApplicationTransaction $xaction) {

	$old = array_combine($xaction->getOldValue(), $xaction->getOldValue());

	$new = $xaction->getNewValue();
	$new_add = idx($new, '+', array());
	unset($new['+']);
	$new_rem = idx($new, '-', array());
	unset($new['-']);
	$new_set = idx($new, '=', null);
	if ($new_set !== null) {
	$new_set = array_combine($new_set, $new_set);
	}
	unset($new['=']);

	if ($new) {
	throw new Exception(
	"Invalid 'new' value for PHID transaction. Value should contain only ".
	"keys '+' (add PHIDs), '-' (remove PHIDs) and '=' (set PHIDS).");
	}

	$result = array();

	foreach ($old as $phid) {
	if ($new_set !== null && empty($new_set[$phid])) {
	continue;
	}
	$result[$phid] = $phid;
	}

	if ($new_set !== null) {
	foreach ($new_set as $phid) {
	$result[$phid] = $phid;
	}
	}

	foreach ($new_add as $phid) {
	$result[$phid] = $phid;
	}

	foreach ($new_rem as $phid) {
	unset($result[$phid]);
	}

	return array_values($result);
	}

	protected function sortTransactions(array $xactions) {
	$head = array();
	$tail = array();

	// Move bare comments to the end, so the actions preceed them.
	foreach ($xactions as $xaction) {
	$type = $xaction->getTransactionType();
	if ($type == PhabricatorTransactions::TYPE_COMMENT) {
	$tail[] = $xaction;
	} else {
	$head[] = $xaction;
	}
	}

	return array_values(array_merge($head, $tail));
	}


	protected function filterTransactions(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$type_comment = PhabricatorTransactions::TYPE_COMMENT;

	$no_effect = array();
	$has_comment = false;
	$any_effect = false;
	foreach ($xactions as $key => $xaction) {
	if ($this->transactionHasEffect($object, $xaction)) {
	if ($xaction->getTransactionType() != $type_comment) {
	$any_effect = true;
	}
	} else {
	$no_effect[$key] = $xaction;
	}
	if ($xaction->hasComment()) {
	$has_comment = true;
	}
	}

	if (!$no_effect) {
	return $xactions;
	}

	if (!$this->getContinueOnNoEffect() && !$this->getIsPreview()) {
	throw new PhabricatorApplicationTransactionNoEffectException(
	$no_effect,
	$any_effect,
	$has_comment);
	}

	if (!$any_effect && !$has_comment) {
	// If we only have empty comment transactions, just drop them all.
	return array();
	}

	foreach ($no_effect as $key => $xaction) {
	if ($xaction->getComment()) {
	$xaction->setTransactionType($type_comment);
	$xaction->setOldValue(null);
	$xaction->setNewValue(null);
	} else {
	unset($xactions[$key]);
	}
	}

	return $xactions;
	}



	/* -( Sending Mail )------------------------------------------------------- */


	/**
	* @task mail
	*/
	protected function supportsMail() {
	return false;
	}


	/**
	* @task mail
	*/
	protected function sendMail(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$email_to = $this->getMailTo($object);
	$email_cc = $this->getMailCC($object);

	$phids = array_merge($email_to, $email_cc);
	$handles = id(new PhabricatorObjectHandleData($phids))
	->setViewer($this->requireActor())
	->loadHandles();

	$template = $this->buildMailTemplate($object);
	$body = $this->buildMailBody($object, $xactions);

	$mail_tags = $this->getMailTags($object, $xactions);

	$action = $this->getStrongestAction($object, $xactions)->getActionName();

	$template
	->setFrom($this->requireActor()->getPHID())
	->setSubjectPrefix($this->getMailSubjectPrefix())
	->setVarySubjectPrefix('['.$action.']')
	->setThreadID($object->getPHID(), $this->getIsNewObject())
	->setRelatedPHID($object->getPHID())
	->setExcludeMailRecipientPHIDs($this->getExcludeMailRecipientPHIDs())
	->setMailTags($mail_tags)
	->setIsBulk(true)
	->setBody($body->render());

	// TODO
	// ->setParentMessageID(...)

	$mails = $this
	->buildReplyHandler($object)
	->multiplexMail(
	$template,
	array_select_keys($handles, $email_to),
	array_select_keys($handles, $email_cc));

	foreach ($mails as $mail) {
	$mail->saveAndSend();
	}

	$template->addTos($email_to);
	$template->addCCs($email_cc);

	return $template;
	}


	/**
	* @task mail
	*/
	protected function getStrongestAction(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return last(msort($xactions, 'getActionStrength'));
	}


	/**
	* @task mail
	*/
	protected function buildReplyHandler(PhabricatorLiskDAO $object) {
	throw new Exception("Capability not supported.");
	}


	/**
	* @task mail
	*/
	protected function getMailSubjectPrefix() {
	throw new Exception("Capability not supported.");
	}


	/**
	* @task mail
	*/
	protected function getMailTags(
	PhabricatorLiskDAO $object,
	array $xactions) {
	$tags = array();

	foreach ($xactions as $xaction) {
	$tags[] = $xaction->getMailTags();
	}

	return array_mergev($tags);
	}


	/**
	* @task mail
	*/
	protected function buildMailTemplate(PhabricatorLiskDAO $object) {
	throw new Exception("Capability not supported.");
	}


	/**
	* @task mail
	*/
	protected function getMailTo(PhabricatorLiskDAO $object) {
	throw new Exception("Capability not supported.");
	}


	/**
	* @task mail
	*/
	protected function getMailCC(PhabricatorLiskDAO $object) {
	if ($object instanceof PhabricatorSubscribableInterface) {
	$phid = $object->getPHID();
	return PhabricatorSubscribersQuery::loadSubscribersForPHID($phid);
	}
	throw new Exception("Capability not supported.");
	}


	/**
	* @task mail
	*/
	protected function buildMailBody(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$headers = array();
	$comments = array();

	foreach ($xactions as $xaction) {
	$headers[] = id(clone $xaction)->setRenderingTarget('text')->getTitle();
	$comment = $xaction->getComment();
	if ($comment && strlen($comment->getContent())) {
	$comments[] = $comment->getContent();
	}
	}

	$body = new PhabricatorMetaMTAMailBody();
	$body->addRawSection(implode("\n", $headers));

	foreach ($comments as $comment) {
	$body->addRawSection($comment);
	}

	return $body;
	}


	/* -( Publishing Feed Stories )-------------------------------------------- */


	/**
	* @task feed
	*/
	protected function supportsFeed() {
	return false;
	}


	/**
	* @task feed
	*/
	protected function getFeedStoryType() {
	return 'PhabricatorApplicationTransactionFeedStory';
	}


	/**
	* @task feed
	*/
	protected function getFeedRelatedPHIDs(
	PhabricatorLiskDAO $object,
	array $xactions) {

	return array(
	$object->getPHID(),
	$this->requireActor()->getPHID(),
	);
	}


	/**
	* @task feed
	*/
	protected function getFeedNotifyPHIDs(
	PhabricatorLiskDAO $object,
	array $xactions) {

	return array_merge(
	$this->getMailTo($object),
	$this->getMailCC($object));
	}


	/**
	* @task feed
	*/
	protected function getFeedStoryData(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$xactions = msort($xactions, 'getActionStrength');
	$xactions = array_reverse($xactions);

	return array(
	'objectPHID' => $object->getPHID(),
	'transactionPHIDs' => mpull($xactions, 'getPHID'),
	);
	}


	/**
	* @task feed
	*/
	protected function publishFeedStory(
	PhabricatorLiskDAO $object,
	array $xactions,
	array $mailed_phids) {

	$related_phids = $this->getFeedRelatedPHIDs($object, $xactions);
	$subscribed_phids = $this->getFeedNotifyPHIDs($object, $xactions);

	$story_type = $this->getFeedStoryType();
	$story_data = $this->getFeedStoryData($object, $xactions);

	id(new PhabricatorFeedStoryPublisher())
	->setStoryType($story_type)
	->setStoryData($story_data)
	->setStoryTime(time())
	->setStoryAuthorPHID($this->requireActor()->getPHID())
	->setRelatedPHIDs($related_phids)
	->setPrimaryObjectPHID($object->getPHID())
	->setSubscribedPHIDs($subscribed_phids)
	->setMailRecipientPHIDs($mailed_phids)
	->publish();
	}


	/* -( Search Index )------------------------------------------------------- */


	/**
	* @task search
	*/
	protected function supportsSearch() {
	return false;
	}

	}
	diff --git a/src/infrastructure/PhabricatorSetup.php b/src/infrastructure/PhabricatorSetup.php
	index 96d2f725fd..e7e6a30261 100644
	--- a/src/infrastructure/PhabricatorSetup.php
	+++ b/src/infrastructure/PhabricatorSetup.php
	@@ -1,798 +1,775 @@
	<?php

	final class PhabricatorSetup {

	public static function runSetup() {
	header("Content-Type: text/plain");
	self::write("PHABRICATOR SETUP\n\n");

	// Force browser to stop buffering.
	self::write(str_repeat(' ', 2048));
	usleep(250000);

	self::write("This setup mode will guide you through setting up your ".
	"Phabricator configuration.\n");

	self::writeHeader("CORE CONFIGURATION");

	// NOTE: Test this first since other tests depend on the ability to
	// execute system commands and will fail if safe_mode is enabled.
	$safe_mode = ini_get('safe_mode');
	if ($safe_mode) {
	self::writeFailure();
	self::write(
	"Setup failure! You have 'safe_mode' enabled. Phabricator will not ".
	"run in safe mode, and it has been deprecated in PHP 5.3 and removed ".
	"in PHP 5.4.\n");
	return;
	} else {
	self::write(" okay PHP's deprecated 'safe_mode' is disabled.\n");
	}

	// NOTE: Also test this early since we can't include files from other
	// libraries if this is set strictly.

	$open_basedir = ini_get('open_basedir');
	if ($open_basedir) {

	// 'open_basedir' restricts which files we're allowed to access with
	// file operations. This might be okay -- we don't need to write to
	// arbitrary places in the filesystem -- but we need to access certain
	// resources. This setting is unlikely to be providing any real measure
	// of security so warn even if things look OK.

	try {
	$open_libphutil = class_exists('Future');
	} catch (Exception $ex) {
	$message = $ex->getMessage();
	self::write("Unable to load modules from libphutil: {$message}\n");
	$open_libphutil = false;
	}

	try {
	$open_arcanist = class_exists('ArcanistDiffParser');
	} catch (Exception $ex) {
	$message = $ex->getMessage();
	self::write("Unable to load modules from Arcanist: {$message}\n");
	$open_arcanist = false;
	}

	$open_urandom = false;
	try {
	Filesystem::readRandomBytes(1);
	$open_urandom = true;
	} catch (FilesystemException $ex) {
	self::write($ex->getMessage()."\n");
	}

	try {
	$tmp = new TempFile();
	file_put_contents($tmp, '.');
	$open_tmp = @fopen((string)$tmp, 'r');
	} catch (Exception $ex) {
	$message = $ex->getMessage();
	$dir = sys_get_temp_dir();
	self::write("Unable to open temp files from '{$dir}': {$message}\n");
	$open_tmp = false;
	}

	if (!$open_urandom \|\| !$open_tmp \|\| !$open_libphutil \|\| !$open_arcanist) {
	self::writeFailure();
	self::write(
	"Setup failure! Your server is configured with 'open_basedir' in ".
	"php.ini which prevents Phabricator from opening files it needs to ".
	"access. Either make the setting more permissive or remove it. It ".
	"is unlikely you derive significant security benefits from having ".
	"this configured; files outside this directory can still be ".
	"accessed through system command execution.");
	return;
	} else {
	self::write(
	"[WARN] You have an 'open_basedir' configured in your php.ini. ".
	"Although the setting seems permissive enough that Phabricator ".
	"will run properly, you may run into problems because of it. It is ".
	"unlikely you gain much real security benefit from having it ".
	"configured, because the application can still access files outside ".
	"the 'open_basedir' by running system commands.\n");
	}
	} else {
	self::write(" okay 'open_basedir' is not set.\n");
	}

	if (!PhabricatorEnv::getEnvConfig('security.alternate-file-domain')) {
	self::write(
	"[WARN] You have not configured 'security.alternate-file-domain'. ".
	"This makes your installation vulnerable to attack. Make sure you ".
	"read the documentation for this parameter and understand the ".
	"consequences of leaving it unconfigured.\n");
	}

	$path = getenv('PATH');
	if (empty($path)) {
	self::writeFailure();
	self::write(
	"Setup failure! The environmental \$PATH variable is empty. ".
	"Phabricator needs to execute system commands like 'svn', 'git', ".
	"'hg', and 'diff'. Set up your webserver so that it passes a valid ".
	"\$PATH to the PHP process.\n\n");
	if (php_sapi_name() == 'fpm-fcgi') {
	self::write(
	"You're running php-fpm, so the easiest way to do this is to add ".
	"this line to your php-fpm.conf:\n\n".
	" env[PATH] = /usr/local/bin:/usr/bin:/bin\n\n".
	"Then restart php-fpm.\n");
	}
	return;
	} else {
	self::write(" okay \$PATH is nonempty.\n");
	}

	self::write("[OKAY] Core configuration OKAY.\n");

	self::writeHeader("REQUIRED PHP EXTENSIONS");
	$extensions = array(
	'mysql',
	'hash',
	'json',
	'openssl',
	'mbstring',
	'iconv',

	// There is a chance we might not need this, but some configurations (like
	// OAuth or Amazon SES) will require it. Just mark it 'required' since
	// it's widely available and relatively core.
	'curl',
	);
	foreach ($extensions as $extension) {
	$ok = self::requireExtension($extension);
	if (!$ok) {
	self::writeFailure();
	self::write("Setup failure! Install PHP extension '{$extension}'.");
	return;
	}
	}

	list($err, $stdout, $stderr) = exec_manual('which php');
	if ($err) {
	self::writeFailure();
	self::write("Unable to locate 'php' on the command line from the web ".
	"server. Verify that 'php' is in the webserver's PATH.\n".
	" err: {$err}\n".
	"stdout: {$stdout}\n".
	"stderr: {$stderr}\n");
	return;
	} else {
	self::write(" okay PHP binary found on the command line.\n");
	$php_bin = trim($stdout);
	}

	// NOTE: In cPanel + suphp installs, 'php' may be the PHP CGI SAPI, not the
	// PHP CLI SAPI. proc_open() will pass the environment to the child process,
	// which will re-execute the webpage (causing an infinite number of
	// processes to spawn). To test that the 'php' binary is safe to execute,
	// we call php_sapi_name() using "env -i" to wipe the environment so it
	// doesn't execute another reuqest if it's the wrong binary. We can't use
	// "-r" because php-cgi doesn't support that flag.

	$tmp_file = new TempFile('sapi.php');
	Filesystem::writeFile($tmp_file, '<?php echo php_sapi_name();');

	list($err, $stdout, $stderr) = exec_manual(
	'/usr/bin/env -i %s -f %s',
	$php_bin,
	$tmp_file);
	if ($err) {
	self::writeFailure();
	self::write("Unable to execute 'php' on the command line from the web ".
	"server.\n".
	" err: {$err}\n".
	"stdout: {$stdout}\n".
	"stderr: {$stderr}\n");
	return;
	} else {
	self::write(" okay PHP is available from the command line.\n");

	$sapi = trim($stdout);
	if ($sapi != 'cli') {
	self::writeFailure();
	self::write(
	"The 'php' binary on this system uses the '{$sapi}' SAPI, but the ".
	"'cli' SAPI is expected. Replace 'php' with the php-cli SAPI ".
	"binary, or edit your webserver configuration so the first 'php' ".
	"in PATH is the 'cli' SAPI.\n\n".
	"If you're running cPanel with suphp, the easiest way to fix this ".
	"is to add '/usr/local/bin' before '/usr/bin' for 'env_path' in ".
	"suconf.php:\n\n".
	' env_path="/bin:/usr/local/bin:/usr/bin"'.
	"\n\n");
	return;
	} else {
	self::write(" okay 'php' is CLI SAPI.\n");
	}
	}

	$root = dirname(phutil_get_library_root('phabricator'));

	// On RHEL6, doing a distro install of pcntl makes it available from the
	// CLI binary but not from the Apache module. This isn't entirely
	// unreasonable and we don't need it from Apache, so do an explicit test
	// for CLI availability.
	list($err, $stdout, $stderr) = exec_manual(
	'php %s',
	"{$root}/scripts/setup/pcntl_available.php");
	if ($err) {
	self::writeFailure();
	self::write("Unable to execute scripts/setup/pcntl_available.php to ".
	"test for the availability of pcntl from the CLI.\n".
	" err: {$err}\n".
	"stdout: {$stdout}\n".
	"stderr: {$stderr}\n");
	return;
	} else {
	if (trim($stdout) == 'YES') {
	self::write(" okay pcntl is available from the command line.\n");
	self::write("[OKAY] All extensions OKAY\n");
	} else {
	self::write(" warn pcntl is not available!\n");
	self::write("[WARN] * WARNING * pcntl extension not available. ".
	"You will not be able to run daemons.\n");
	}
	}

	self::writeHeader("GIT SUBMODULES");
	if (!Filesystem::pathExists($root.'/.git')) {
	self::write(" skip Not a git clone.\n\n");
	} else {
	list($info) = execx(
	'(cd %s && git submodule status)',
	$root);
	foreach (explode("\n", rtrim($info)) as $line) {
	$matches = null;
	if (!preg_match('/^(.)([0-9a-f]{40}) (\S+)(?: \|$)/', $line, $matches)) {
	self::writeFailure();
	self::write(
	"Setup failure! 'git submodule' produced unexpected output:\n".
	$line);
	return;
	}

	$status = $matches[1];
	$module = $matches[3];

	switch ($status) {
	case '-':
	case '+':
	case 'U':
	self::writeFailure();
	self::write(
	"Setup failure! Git submodule '{$module}' is not up to date. ".
	"Run:\n\n".
	" cd {$root} && git submodule update --init\n\n".
	"...to update submodules.");
	return;
	case ' ':
	self::write(" okay Git submodule '{$module}' up to date.\n");
	break;
	default:
	self::writeFailure();
	self::write(
	"Setup failure! 'git submodule' reported unknown status ".
	"'{$status}' for submodule '{$module}'. This is a bug; report ".
	"it to the Phabricator maintainers.");
	return;
	}
	}
	}
	self::write("[OKAY] All submodules OKAY.\n");

	self::writeHeader("BASIC CONFIGURATION");

	$env = PhabricatorEnv::getEnvConfig('phabricator.env');
	if ($env == 'production' \|\| $env == 'default' \|\| $env == 'development') {
	self::writeFailure();
	self::write(
	"Setup failure! Your PHABRICATOR_ENV is set to '{$env}', which is ".
	"a Phabricator environmental default. You should create a custom ".
	"environmental configuration instead of editing the defaults ".
	"directly. See this document for instructions:\n");
	self::writeDoc('article/Configuration_Guide.html');
	return;
	} else {
	$host = PhabricatorEnv::getEnvConfig('phabricator.base-uri');
	$host_uri = new PhutilURI($host);
	$protocol = $host_uri->getProtocol();
	$allowed_protocols = array(
	'http' => true,
	'https' => true,
	);
	if (empty($allowed_protocols[$protocol])) {
	self::writeFailure();
	self::write(
	"You must specify the protocol over which your host works (e.g.: ".
	"\"http:// or https://\")\nin your custom config file.\nRefer to ".
	"'default.conf.php' for documentation on configuration options.\n");
	return;
	}
	if (preg_match('/.*\/$/', $host)) {
	self::write(" okay phabricator.base-uri protocol\n");
	} else {
	self::writeFailure();
	self::write(
	"You must add a trailing slash at the end of the host\n(e.g.: ".
	"\"http://phabricator.example.com/ instead of ".
	"http://phabricator.example.com\")\nin your custom config file.".
	"\nRefer to 'default.conf.php' for documentation on configuration ".
	"options.\n");
	return;
	}

	$host_domain = $host_uri->getDomain();
	if (strpos($host_domain, '.') !== false) {
	self::write(" okay phabricator.base-uri domain\n");
	} else {
	self::writeFailure();
	self::write(
	"You must host Phabricator on a domain that contains a dot ('.'). ".
	"The current domain, '{$host_domain}', does not have a dot, so some ".
	"browsers will not set cookies on it. For instance, ".
	"'http://example.com/ is OK, but 'http://example/' won't work. ".
	"If you are using localhost, create an entry in the hosts file like ".
	"'127.0.0.1 example.com', and access the localhost with ".
	"'http://example.com/'.");
	return;
	}

	$host_path = $host_uri->getPath();
	if ($host_path == '/') {
	self::write(" okay phabricator.base-uri path\n");
	} else {
	self::writeFailure();
	self::write(
	"Your 'phabricator.base-uri' setting includes a path, but should ".
	"not (e.g., 'http://phabricator.example.com/' is OK, but ".
	"'http://example.com/phabricator/' is not). Phabricator must be ".
	"installed on an entire domain, it can not be installed on a ".
	"path alongside other applications. Consult the documentation ".
	"for more details.");
	return;
	}
	}

	$timezone = nonempty(
	PhabricatorEnv::getEnvConfig('phabricator.timezone'),
	ini_get('date.timezone'));
	if (!$timezone) {
	self::writeFailure();
	self::write(
	"Setup failure! Your configuration fails to specify a server ".
	"timezone. Either set 'date.timezone' in your php.ini or ".
	"'phabricator.timezone' in your Phabricator configuration. See the ".
	"PHP documentation for a list of supported timezones:\n\n".
	"http://www.php.net/manual/en/timezones.php\n");
	return;
	} else {
	self::write(" okay Timezone '{$timezone}' configured.\n");
	}

	self::write("[OKAY] Basic configuration OKAY\n");


	$issue_gd_warning = false;
	self::writeHeader('GD LIBRARY');
	if (extension_loaded('gd')) {
	self::write(" okay Extension 'gd' is loaded.\n");
	$image_type_map = array(
	'imagepng' => 'PNG',
	'imagegif' => 'GIF',
	'imagejpeg' => 'JPEG',
	);
	foreach ($image_type_map as $function => $image_type) {
	if (function_exists($function)) {
	self::write(" okay Support for '{$image_type}' is available.\n");
	} else {
	self::write(" warn Support for '{$image_type}' is not available!\n");
	$issue_gd_warning = true;
	}
	}
	} else {
	self::write(" warn Extension 'gd' is not loaded.\n");
	$issue_gd_warning = true;
	}

	if ($issue_gd_warning) {
	self::write(
	"[WARN] The 'gd' library is missing or lacks full support. ".
	"Phabricator will not be able to generate image thumbnails without ".
	"gd.\n");
	} else {
	self::write("[OKAY] 'gd' loaded and has full image type support.\n");
	}


	self::writeHeader('FACEBOOK INTEGRATION');
	$fb_auth = PhabricatorEnv::getEnvConfig('facebook.auth-enabled');
	if (!$fb_auth) {
	self::write(" skip 'facebook.auth-enabled' not enabled.\n");
	} else {
	self::write(" okay 'facebook.auth-enabled' is enabled.\n");
	$app_id = PhabricatorEnv::getEnvConfig('facebook.application-id');
	$app_secret = PhabricatorEnv::getEnvConfig('facebook.application-secret');

	if (!$app_id) {
	self::writeFailure();
	self::write(
	"Setup failure! 'facebook.auth-enabled' is true but there is no ".
	"setting for 'facebook.application-id'.\n");
	return;
	} else {
	self::write(" okay 'facebook.application-id' is set.\n");
	}

	if (!is_string($app_id)) {
	self::writeFailure();
	self::write(
	"Setup failure! 'facebook.application-id' should be a string.");
	return;
	} else {
	self::write(" okay 'facebook.application-id' is string.\n");
	}

	if (!$app_secret) {
	self::writeFailure();
	self::write(
	"Setup failure! 'facebook.auth-enabled' is true but there is no ".
	"setting for 'facebook.application-secret'.");
	return;
	} else {
	self::write(" okay 'facebook.application-secret is set.\n");
	}

	self::write("[OKAY] Facebook integration OKAY\n");
	}

	self::writeHeader("MySQL DATABASE & STORAGE CONFIGURATION");

	$conf = PhabricatorEnv::newObjectFromConfig('mysql.configuration-provider');
	$conn_user = $conf->getUser();
	$conn_pass = $conf->getPassword();
	$conn_host = $conf->getHost();

	$timeout = ini_get('mysql.connect_timeout');
	if ($timeout > 5) {
	self::writeNote(
	"Your MySQL connect timeout is very high ({$timeout} seconds). ".
	"Consider reducing it to 5 or below by setting ".
	"'mysql.connect_timeout' in your php.ini.");
	}

	self::write(" okay Trying to connect to MySQL database ".
	"{$conn_user}@{$conn_host}...\n");

	ini_set('mysql.connect_timeout', 2);

	$conn_raw = PhabricatorEnv::newObjectFromConfig(
	'mysql.implementation',
	array(
	array(
	'user' => $conn_user,
	'pass' => $conn_pass,
	'host' => $conn_host,
	'database' => null,
	),
	));

	try {
	queryfx($conn_raw, 'SELECT 1');
	self::write(" okay Connection successful!\n");
	} catch (AphrontQueryConnectionException $ex) {
	$message = $ex->getMessage();
	self::writeFailure();
	self::write(
	"Setup failure! MySQL exception: {$message} \n".
	"Edit Phabricator configuration keys 'mysql.user', ".
	"'mysql.host' and 'mysql.pass' to enable Phabricator ".
	"to connect.");
	return;
	}

	$engines = queryfx_all($conn_raw, 'SHOW ENGINES');
	$engines = ipull($engines, 'Support', 'Engine');

	$innodb = idx($engines, 'InnoDB');
	if ($innodb != 'YES' && $innodb != 'DEFAULT') {
	self::writeFailure();
	self::write(
	"Setup failure! The 'InnoDB' engine is not available. Enable ".
	"InnoDB in your MySQL configuration. If you already created tables, ".
	"MySQL incorrectly used some other engine. You need to convert ".
	"them or drop and reinitialize them.");
	return;
	} else {
	self::write(" okay InnoDB is available.\n");
	}

	$namespace = PhabricatorEnv::getEnvConfig('storage.default-namespace');

	$databases = queryfx_all($conn_raw, 'SHOW DATABASES');
	$databases = ipull($databases, 'Database', 'Database');
	if (empty($databases[$namespace.'_meta_data'])) {
	self::writeFailure();
	self::write(
	"Setup failure! You haven't run 'bin/storage upgrade'. See this ".
	"article for instructions:\n");
	self::writeDoc('article/Configuration_Guide.html');
	return;
	} else {
	self::write(" okay Databases have been initialized.\n");
	}

	$index_min_length = queryfx_one(
	$conn_raw,
	'SHOW VARIABLES LIKE %s',
	'ft_min_word_len');
	$index_min_length = idx($index_min_length, 'Value', 4);
	if ($index_min_length >= 4) {
	self::writeNote(
	"MySQL is configured with a 'ft_min_word_len' of 4 or greater, which ".
	"means you will not be able to search for 3-letter terms. Consider ".
	"setting this in your configuration:\n".
	"\n".
	" [mysqld]\n".
	" ft_min_word_len=3\n".
	"\n".
	"Then optionally run:\n".
	"\n".
	" REPAIR TABLE {$namespace}_search.search_documentfield QUICK;\n".
	"\n".
	"...to reindex existing documents.");
	}

	$max_allowed_packet = queryfx_one(
	$conn_raw,
	'SHOW VARIABLES LIKE %s',
	'max_allowed_packet');
	$max_allowed_packet = idx($max_allowed_packet, 'Value', PHP_INT_MAX);

	$recommended_minimum = 1024 * 1024;
	if ($max_allowed_packet < $recommended_minimum) {
	self::writeNote(
	"MySQL is configured with a small 'max_allowed_packet' ".
	"('{$max_allowed_packet}'), which may cause some large writes to ".
	"fail. Consider raising this to at least {$recommended_minimum}.");
	} else {
	self::write(" okay max_allowed_packet = {$max_allowed_packet}.\n");
	}

	$local_key = 'storage.local-disk.path';
	$local_path = PhabricatorEnv::getEnvConfig($local_key);
	if ($local_path) {
	if (!Filesystem::pathExists($local_path) \|\|
	!is_readable($local_path) \|\|
	!is_writable($local_path)) {
	self::writeFailure();
	self::write(
	"Setup failure! You have configured local disk storage but the ".
	"path you specified ('{$local_path}') does not exist or is not ".
	"readable or writable.\n");
	if ($open_basedir) {
	self::write(
	"You have an 'open_basedir' setting -- make sure Phabricator is ".
	"allowed to open files in the local storage directory.\n");
	}
	return;
	} else {
	self::write(" okay Local disk storage exists and is writable.\n");
	}
	} else {
	self::write(" skip Not configured for local disk storage.\n");
	}

	$selector = PhabricatorEnv::getEnvConfig('storage.engine-selector');

	try {
	$storage_selector_exists = class_exists($selector);
	} catch (Exception $ex) {
	$storage_selector_exists = false;
	}

	if ($storage_selector_exists) {
	self::write(" okay Using '{$selector}' as a storage engine selector.\n");
	} else {
	self::writeFailure();
	self::write(
	"Setup failure! You have configured '{$selector}' as a storage engine ".
	"selector but it does not exist or could not be loaded.\n");
	return;
	}

	self::write("[OKAY] Database and storage configuration OKAY\n");


	self::writeHeader("OUTBOUND EMAIL CONFIGURATION");

	$have_adapter = false;
	$is_ses = false;

	$adapter = PhabricatorEnv::getEnvConfig('metamta.mail-adapter');
	switch ($adapter) {
	case 'PhabricatorMailImplementationPHPMailerLiteAdapter':

	$have_adapter = true;

	if (!Filesystem::pathExists('/usr/bin/sendmail') &&
	!Filesystem::pathExists('/usr/sbin/sendmail')) {
	self::writeFailure();
	self::write(
	"Setup failure! You don't have a 'sendmail' binary on this system ".
	"but outbound email is configured to use sendmail. Install an MTA ".
	"(like sendmail, qmail or postfix) or use a different outbound ".
	"mail configuration. See this guide for configuring outbound ".
	"email:\n");
	self::writeDoc('article/Configuring_Outbound_Email.html');
	return;
	} else {
	self::write(" okay Sendmail is configured.\n");
	}

	break;
	case 'PhabricatorMailImplementationAmazonSESAdapter':

	$is_ses = true;
	$have_adapter = true;

	if (PhabricatorEnv::getEnvConfig('metamta.can-send-as-user')) {
	self::writeFailure();
	self::write(
	"Setup failure! 'metamta.can-send-as-user' must be false when ".
	"configured with Amazon SES.");
	return;
	} else {
	self::write(" okay Sender config looks okay.\n");
	}

	if (!PhabricatorEnv::getEnvConfig('amazon-ses.access-key')) {
	self::writeFailure();
	self::write(
	"Setup failure! 'amazon-ses.access-key' is not set, but ".
	"outbound mail is configured to deliver via Amazon SES.");
	return;
	} else {
	self::write(" okay Amazon SES access key is set.\n");
	}

	if (!PhabricatorEnv::getEnvConfig('amazon-ses.secret-key')) {
	self::writeFailure();
	self::write(
	"Setup failure! 'amazon-ses.secret-key' is not set, but ".
	"outbound mail is configured to deliver via Amazon SES.");
	return;
	} else {
	self::write(" okay Amazon SES secret key is set.\n");
	}

	if (PhabricatorEnv::getEnvConfig('metamta.send-immediately')) {
	self::writeNote(
	"Your configuration uses Amazon SES to deliver email but tries ".
	"to send it immediately. This will work, but it's slow. ".
	"Consider configuring the MetaMTA daemon.");
	}
	break;
	case 'PhabricatorMailImplementationTestAdapter':
	self::write(" skip You have disabled outbound email.\n");
	break;
	default:
	self::write(" skip Configured with a custom adapter.\n");
	break;
	}

	if ($have_adapter) {
	$default = PhabricatorEnv::getEnvConfig('metamta.default-address');
	if (!$default \|\| $default == 'noreply@example.com') {
	self::writeFailure();
	self::write(
	"Setup failure! You have not set 'metamta.default-address'.");
	return;
	} else {
	self::write(" okay metamta.default-address is set.\n");
	}

	if ($is_ses) {
	self::writeNote(
	"Make sure you've verified your 'from' address ('{$default}') with ".
	"Amazon SES. Until you verify it, you will be unable to send mail ".
	"using Amazon SES.");
	}

	$domain = PhabricatorEnv::getEnvConfig('metamta.domain');
	if (!$domain \|\| $domain == 'example.com') {
	self::writeFailure();
	self::write(
	"Setup failure! You have not set 'metamta.domain'.");
	return;
	} else {
	self::write(" okay metamta.domain is set.\n");
	}

	self::write("[OKAY] Mail configuration OKAY\n");
	}

	- self::writeHeader('CONFIG CLASSES');
	- foreach (PhabricatorEnv::getRequiredClasses() as $key => $instanceof) {
	- $config = PhabricatorEnv::getEnvConfig($key);
	- if (!$config) {
	- self::writeNote("'$key' is not set.");
	- } else {
	- try {
	- $r = new ReflectionClass($config);
	- if (!$r->isSubclassOf($instanceof)) {
	- throw new Exception(
	- "Config setting '$key' must be an instance of '$instanceof'.");
	- } else if (!$r->isInstantiable()) {
	- throw new Exception("Config setting '$key' must be instantiable.");
	- }
	- } catch (Exception $ex) {
	- self::writeFailure();
	- self::write("Setup failure! ".$ex->getMessage());
	- return;
	- }
	- }
	- }
	- self::write("[OKAY] Config classes OKAY\n");
	-
	self::writeHeader('SUCCESS!');
	self::write(
	"Congratulations! Your setup seems mostly correct, or at least fairly ".
	"reasonable.\n\n".
	"* NEXT STEP *\n".
	"Edit your configuration file (conf/{$env}.conf.php) and remove the ".
	"'phabricator.setup' line to finish installation.");

	}

	public static function requireExtension($extension) {
	if (extension_loaded($extension)) {
	self::write(" okay Extension '{$extension}' installed.\n");
	return true;
	} else {
	self::write("[FAIL] Extension '{$extension}' is NOT INSTALLED!\n");
	return false;
	}
	}

	private static function writeFailure() {
	self::write("\n\n<<< * FAILURE! * >>>\n");
	}

	private static function write($str) {
	echo $str;
	ob_flush();
	flush();

	// This, uh, makes it look cool. -_-
	usleep(20000);
	}

	private static function writeNote($note) {
	$note = "*** NOTE: ".wordwrap($note, 75, "\n", true);
	$note = "\n".str_replace("\n", "\n ", $note)."\n\n";
	self::write($note);
	}

	public static function writeHeader($header) {
	$template = '>>>'.str_repeat('-', 77);
	$template = substr_replace(
	$template,
	' '.$header.' ',
	3,
	strlen($header) + 4);
	self::write("\n\n{$template}\n\n");
	}

	public static function writeDoc($doc) {
	self::write(
	"\n".
	' http://www.phabricator.com/docs/phabricator/'.$doc.
	"\n\n");
	}

	}
	diff --git a/src/infrastructure/env/PhabricatorEnv.php b/src/infrastructure/env/PhabricatorEnv.php
	index 970114d9d7..afa90883c6 100644
	--- a/src/infrastructure/env/PhabricatorEnv.php
	+++ b/src/infrastructure/env/PhabricatorEnv.php
	@@ -1,457 +1,447 @@
	<?php

	/**
	* Manages the execution environment configuration, exposing APIs to read
	* configuration settings and other similar values that are derived directly
	* from configuration settings.
	*
	*
	* = Reading Configuration =
	*
	* The primary role of this class is to provide an API for reading
	* Phabricator configuration, @{method:getEnvConfig}:
	*
	* $value = PhabricatorEnv::getEnvConfig('some.key', $default);
	*
	* The class also handles some URI construction based on configuration, via
	* the methods @{method:getURI}, @{method:getProductionURI},
	* @{method:getCDNURI}, and @{method:getDoclink}.
	*
	* For configuration which allows you to choose a class to be responsible for
	* some functionality (e.g., which mail adapter to use to deliver email),
	* @{method:newObjectFromConfig} provides a simple interface that validates
	* the configured value.
	*
	*
	* = Unit Test Support =
	*
	* In unit tests, you can use @{method:beginScopedEnv} to create a temporary,
	* mutable environment. The method returns a scope guard object which restores
	* the environment when it is destroyed. For example:
	*
	* public function testExample() {
	* $env = PhabricatorEnv::beginScopedEnv();
	* $env->overrideEnv('some.key', 'new-value-for-this-test');
	*
	* // Some test which depends on the value of 'some.key'.
	*
	* }
	*
	* Your changes will persist until the `$env` object leaves scope or is
	* destroyed.
	*
	* You should //not// use this in normal code.
	*
	*
	* @task read Reading Configuration
	* @task uri URI Validation
	* @task test Unit Test Support
	* @task internal Internals
	*/
	final class PhabricatorEnv {

	private static $sourceStack;
	+ private static $repairSource;

	/**
	* @phutil-external-symbol class PhabricatorStartup
	*/
	public static function initializeWebEnvironment() {
	$env = self::getSelectedEnvironmentName();
	if (!$env) {
	PhabricatorStartup::didFatal(
	"The 'PHABRICATOR_ENV' environmental variable is not defined. Modify ".
	"your httpd.conf to include 'SetEnv PHABRICATOR_ENV <env>', where ".
	"'<env>' is one of 'development', 'production', or a custom ".
	"environment.");
	}

	self::initializeCommonEnvironment();
	}

	public static function initializeScriptEnvironment() {
	$env = self::getSelectedEnvironmentName();
	if (!$env) {
	echo phutil_console_wrap(
	phutil_console_format(
	"ERROR: PHABRICATOR_ENV Not Set\n\n".
	"Define the __PHABRICATOR_ENV__ environment variable before ".
	"running this script. You can do it on the command line like ".
	"this:\n\n".
	" $ PHABRICATOR_ENV=__custom/myconfig__ %s ...\n\n".
	"Replace __custom/myconfig__ with the path to your configuration ".
	"file. For more information, see the 'Configuration Guide' in the ".
	"Phabricator documentation.\n\n",
	$GLOBALS['argv'][0]));
	exit(1);
	}

	self::initializeCommonEnvironment();

	// NOTE: This is dangerous in general, but we know we're in a script context
	// and are not vulnerable to CSRF.
	AphrontWriteGuard::allowDangerousUnguardedWrites(true);

	// There are several places where we log information (about errors, events,
	// service calls, etc.) for analysis via DarkConsole or similar. These are
	// useful for web requests, but grow unboundedly in long-running scripts and
	// daemons. Discard data as it arrives in these cases.
	PhutilServiceProfiler::getInstance()->enableDiscardMode();
	DarkConsoleErrorLogPluginAPI::enableDiscardMode();
	DarkConsoleEventPluginAPI::enableDiscardMode();
	}


	private static function initializeCommonEnvironment() {
	self::buildConfigurationSourceStack();

	PhutilErrorHandler::initialize();

	$tz = PhabricatorEnv::getEnvConfig('phabricator.timezone');
	if ($tz) {
	date_default_timezone_set($tz);
	}

	// Append any paths to $PATH if we need to.
	$paths = PhabricatorEnv::getEnvConfig('environment.append-paths');
	if (!empty($paths)) {
	$current_env_path = getenv('PATH');
	$new_env_paths = implode(PATH_SEPARATOR, $paths);
	putenv('PATH='.$current_env_path.PATH_SEPARATOR.$new_env_paths);
	}

	foreach (PhabricatorEnv::getEnvConfig('load-libraries') as $library) {
	phutil_load_library($library);
	}

	PhabricatorEventEngine::initialize();

	$translation = PhabricatorEnv::newObjectFromConfig('translation.provider');
	PhutilTranslator::getInstance()
	->setLanguage($translation->getLanguage())
	->addTranslations($translation->getTranslations());
	}

	private static function buildConfigurationSourceStack() {
	$stack = new PhabricatorConfigStackSource();
	self::$sourceStack = $stack;

	$stack->pushSource(
	id(new PhabricatorConfigDefaultSource())
	->setName(pht('Global Default')));

	$env = self::getSelectedEnvironmentName();
	$stack->pushSource(
	id(new PhabricatorConfigFileSource($env))
	->setName(pht("File '%s'", $env)));

	$stack->pushSource(
	id(new PhabricatorConfigLocalSource())
	->setName(pht("Local Config")));

	// NOTE: This must happen after the other sources are pushed, because it
	// will draw from lower-level config to bootstrap itself.
	$stack->pushSource(
	id(new PhabricatorConfigDatabaseSource('default'))
	->setName(pht("Database")));
	}

	+ public static function repairConfig($key, $value) {
	+ if (!self::$repairSource) {
	+ self::$repairSource = id(new PhabricatorConfigDictionarySource(array()))
	+ ->setName(pht("Repaired Config"));
	+ self::$sourceStack->pushSource(self::$repairSource);
	+ }
	+ self::$repairSource->setKeys(array($key => $value));
	+ }
	+
	+ public static function getUnrepairedEnvConfig($key, $default = null) {
	+ foreach (self::$sourceStack->getStack() as $source) {
	+ if ($source === self::$repairSource) {
	+ continue;
	+ }
	+ $result = $source->getKeys(array($key));
	+ if ($result) {
	+ return $result[$key];
	+ }
	+ }
	+ return $default;
	+ }
	+
	public static function getSelectedEnvironmentName() {
	$env_var = 'PHABRICATOR_ENV';

	$env = idx($_SERVER, $env_var);

	if (!$env) {
	$env = getenv($env_var);
	}

	if (!$env) {
	$env = idx($_ENV, $env_var);
	}

	if (!$env) {
	$root = dirname(phutil_get_library_root('phabricator'));
	$path = $root.'/conf/local/ENVIRONMENT';
	if (Filesystem::pathExists($path)) {
	$env = trim(Filesystem::readFile($path));
	}
	}

	return $env;
	}


	/* -( Reading Configuration )---------------------------------------------- */


	/**
	* Get the current configuration setting for a given key.
	*
	* @task read
	*/
	public static function getEnvConfig($key, $default = null) {
	$result = self::$sourceStack->getKeys(array($key));
	return idx($result, $key, $default);
	}


	/**
	* Get the fully-qualified URI for a path.
	*
	* @task read
	*/
	public static function getURI($path) {
	return rtrim(self::getEnvConfig('phabricator.base-uri'), '/').$path;
	}


	/**
	* Get the fully-qualified production URI for a path.
	*
	* @task read
	*/
	public static function getProductionURI($path) {
	// If we're passed a URI which already has a domain, simply return it
	// unmodified. In particular, files may have URIs which point to a CDN
	// domain.
	$uri = new PhutilURI($path);
	if ($uri->getDomain()) {
	return $path;
	}

	$production_domain = self::getEnvConfig('phabricator.production-uri');
	if (!$production_domain) {
	$production_domain = self::getEnvConfig('phabricator.base-uri');
	}
	return rtrim($production_domain, '/').$path;
	}


	/**
	* Get the fully-qualified production URI for a static resource path.
	*
	* @task read
	*/
	public static function getCDNURI($path) {
	$alt = self::getEnvConfig('security.alternate-file-domain');
	if (!$alt) {
	$alt = self::getEnvConfig('phabricator.base-uri');
	}
	$uri = new PhutilURI($alt);
	$uri->setPath($path);
	return (string)$uri;
	}


	/**
	* Get the fully-qualified production URI for a documentation resource.
	*
	* @task read
	*/
	public static function getDoclink($resource) {
	return 'http://www.phabricator.com/docs/phabricator/'.$resource;
	}


	/**
	* Build a concrete object from a configuration key.
	*
	* @task read
	*/
	public static function newObjectFromConfig($key, $args = array()) {
	$class = self::getEnvConfig($key);
	- $object = newv($class, $args);
	- $instanceof = idx(self::getRequiredClasses(), $key);
	- if (!($object instanceof $instanceof)) {
	- throw new Exception("Config setting '$key' must be an instance of ".
	- "'$instanceof', is '".get_class($object)."'.");
	- }
	- return $object;
	+ return newv($class, $args);
	}


	/* -( Unit Test Support )-------------------------------------------------- */


	/**
	* @task test
	*/
	public static function beginScopedEnv() {
	return new PhabricatorScopedEnv(self::pushTestEnvironment());
	}


	/**
	* @task test
	*/
	private static function pushTestEnvironment() {
	$source = new PhabricatorConfigDictionarySource(array());
	self::$sourceStack->pushSource($source);
	return spl_object_hash($source);
	}


	/**
	* @task test
	*/
	public static function popTestEnvironment($key) {
	$source = self::$sourceStack->popSource();
	$stack_key = spl_object_hash($source);
	if ($stack_key !== $key) {
	self::$sourceStack->pushSource($source);
	throw new Exception(
	"Scoped environments were destroyed in a diffent order than they ".
	"were initialized.");
	}
	}


	/* -( URI Validation )----------------------------------------------------- */


	/**
	* Detect if a URI satisfies either @{method:isValidLocalWebResource} or
	* @{method:isValidRemoteWebResource}, i.e. is a page on this server or the
	* URI of some other resource which has a valid protocol. This rejects
	* garbage URIs and URIs with protocols which do not appear in the
	* ##uri.allowed-protocols## configuration, notably 'javascript:' URIs.
	*
	* NOTE: This method is generally intended to reject URIs which it may be
	* unsafe to put in an "href" link attribute.
	*
	* @param string URI to test.
	* @return bool True if the URI identifies a web resource.
	* @task uri
	*/
	public static function isValidWebResource($uri) {
	return self::isValidLocalWebResource($uri) \|\|
	self::isValidRemoteWebResource($uri);
	}


	/**
	* Detect if a URI identifies some page on this server.
	*
	* NOTE: This method is generally intended to reject URIs which it may be
	* unsafe to issue a "Location:" redirect to.
	*
	* @param string URI to test.
	* @return bool True if the URI identifies a local page.
	* @task uri
	*/
	public static function isValidLocalWebResource($uri) {
	$uri = (string)$uri;

	if (!strlen($uri)) {
	return false;
	}

	if (preg_match('/\s/', $uri)) {
	// PHP hasn't been vulnerable to header injection attacks for a bunch of
	// years, but we can safely reject these anyway since they're never valid.
	return false;
	}

	// Valid URIs must begin with '/', followed by the end of the string or some
	// other non-'/' character. This rejects protocol-relative URIs like
	// "//evil.com/evil_stuff/".
	return (bool)preg_match('@^/([^/]\|$)@', $uri);
	}


	/**
	* Detect if a URI identifies some valid remote resource.
	*
	* @param string URI to test.
	* @return bool True if a URI idenfies a remote resource with an allowed
	* protocol.
	* @task uri
	*/
	public static function isValidRemoteWebResource($uri) {
	$uri = (string)$uri;

	$proto = id(new PhutilURI($uri))->getProtocol();
	if (!$proto) {
	return false;
	}

	$allowed = self::getEnvConfig('uri.allowed-protocols');
	if (empty($allowed[$proto])) {
	return false;
	}

	return true;
	}


	/* -( Internals )---------------------------------------------------------- */


	- /**
	- * @task internal
	- */
	- public static function getRequiredClasses() {
	- return array(
	- 'translation.provider' => 'PhabricatorTranslation',
	- 'metamta.mail-adapter' => 'PhabricatorMailImplementationAdapter',
	- 'metamta.maniphest.reply-handler' => 'PhabricatorMailReplyHandler',
	- 'metamta.differential.reply-handler' => 'PhabricatorMailReplyHandler',
	- 'metamta.diffusion.reply-handler' => 'PhabricatorMailReplyHandler',
	- 'metamta.package.reply-handler' => 'PhabricatorMailReplyHandler',
	- 'storage.engine-selector' => 'PhabricatorFileStorageEngineSelector',
	- 'search.engine-selector' => 'PhabricatorSearchEngineSelector',
	- 'differential.field-selector' => 'DifferentialFieldSelector',
	- 'maniphest.custom-task-extensions-class' => 'ManiphestTaskExtensions',
	- 'aphront.default-application-configuration-class' =>
	- 'AphrontApplicationConfiguration',
	- 'controller.oauth-registration' =>
	- 'PhabricatorOAuthRegistrationController',
	- 'mysql.implementation' => 'AphrontMySQLDatabaseConnectionBase',
	- 'differential.attach-task-class' => 'DifferentialTasksAttacher',
	- 'mysql.configuration-provider' => 'DatabaseConfigurationProvider',
	- 'syntax-highlighter.engine' => 'PhutilSyntaxHighlighterEngine',
	- );
	- }
	-
	-
	/**
	* @task internal
	*/
	public static function envConfigExists($key) {
	return array_key_exists($key, self::$sourceStack->getKeys(array($key)));
	}


	/**
	* @task internal
	*/
	public static function getAllConfigKeys() {
	return self::$sourceStack->getAllKeys();
	}

	public static function getConfigSourceStack() {
	return self::$sourceStack;
	}

	/**
	* @task internal
	*/
	public static function overrideTestEnvConfig($stack_key, $key, $value) {
	$tmp = array();

	// If we don't have the right key, we'll throw when popping the last
	// source off the stack.
	do {
	$source = self::$sourceStack->popSource();
	array_unshift($tmp, $source);
	if (spl_object_hash($source) == $stack_key) {
	$source->setKeys(array($key => $value));
	break;
	}
	} while (true);

	foreach ($tmp as $source) {
	self::$sourceStack->pushSource($source);
	}
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Fri, Nov 14, 9:09 AM (1 d, 5 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 336908
Default Alt Text: (85 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions