diff --git a/src/applications/config/option/PhabricatorCoreConfigOptions.php b/src/applications/config/option/PhabricatorCoreConfigOptions.php
index 8d6e4b30f9..2521e58f9c 100644
--- a/src/applications/config/option/PhabricatorCoreConfigOptions.php
+++ b/src/applications/config/option/PhabricatorCoreConfigOptions.php
@@ -1,292 +1,315 @@
 <?php
 
 final class PhabricatorCoreConfigOptions
   extends PhabricatorApplicationConfigOptions {
 
   public function getName() {
     return pht('Core');
   }
 
   public function getDescription() {
     return pht('Configure core options, including URIs.');
   }
 
   public function getFontIcon() {
     return 'fa-bullseye';
   }
 
   public function getGroup() {
     return 'core';
   }
 
   public function getOptions() {
     if (phutil_is_windows()) {
       $paths = array();
     } else {
       $paths = array(
         '/bin',
         '/usr/bin',
         '/usr/local/bin',
       );
     }
 
     $path = getenv('PATH');
 
     $proto_doc_href = PhabricatorEnv::getDoclink(
       'User Guide: Prototype Applications');
     $proto_doc_name = pht('User Guide: Prototype Applications');
     $applications_app_href = '/applications/';
 
     return array(
       $this->newOption('phabricator.base-uri', 'string', null)
         ->setLocked(true)
         ->setSummary(pht('URI where Phabricator is installed.'))
         ->setDescription(
           pht(
             'Set the URI where Phabricator is installed. Setting this '.
             'improves security by preventing cookies from being set on other '.
             'domains, and allows daemons to send emails with links that have '.
             'the correct domain.'))
         ->addExample('http://phabricator.example.com/', pht('Valid Setting')),
       $this->newOption('phabricator.production-uri', 'string', null)
         ->setSummary(
           pht('Primary install URI, for multi-environment installs.'))
         ->setDescription(
           pht(
             'If you have multiple Phabricator environments (like a '.
             'development/staging environment for working on testing '.
             'Phabricator, and a production environment for deploying it), '.
             'set the production environment URI here so that emails and other '.
             'durable URIs will always generate with links pointing at the '.
             'production environment. If unset, defaults to '.
             '{{phabricator.base-uri}}. Most installs do not need to set '.
             'this option.'))
         ->addExample('http://phabricator.example.com/', pht('Valid Setting')),
       $this->newOption('phabricator.allowed-uris', 'list<string>', array())
         ->setLocked(true)
         ->setSummary(pht('Alternative URIs that can access Phabricator.'))
         ->setDescription(
           pht(
             "These alternative URIs will be able to access 'normal' pages ".
               "on your Phabricator install. Other features such as OAuth ".
               "won't work. The major use case for this is moving installs ".
               "across domains."))
         ->addExample(
           "http://phabricator2.example.com/\n".
           "http://phabricator3.example.com/",
           pht('Valid Setting')),
       $this->newOption('phabricator.timezone', 'string', null)
         ->setSummary(
           pht('The timezone Phabricator should use.'))
         ->setDescription(
           pht(
             "PHP requires that you set a timezone in your php.ini before ".
             "using date functions, or it will emit a warning. If this isn't ".
             "possible (for instance, because you are using HPHP) you can set ".
             "some valid constant for date_default_timezone_set() here and ".
             "Phabricator will set it on your behalf, silencing the warning."))
         ->addExample('America/New_York', pht('US East (EDT)'))
         ->addExample('America/Chicago', pht('US Central (CDT)'))
         ->addExample('America/Boise', pht('US Mountain (MDT)'))
         ->addExample('America/Los_Angeles', pht('US West (PDT)')),
       $this->newOption('phabricator.cookie-prefix', 'string', null)
         ->setLocked(true)
         ->setSummary(
           pht('Set a string Phabricator should use to prefix '.
               'cookie names.'))
         ->setDescription(
           pht(
             'Cookies set for x.com are also sent for y.x.com. Assuming '.
             'Phabricator instances are running on both domains, this will '.
             'create a collision preventing you from logging in.'))
         ->addExample('dev', pht('Prefix cookie with "dev"')),
       $this->newOption('phabricator.show-prototypes', 'bool', false)
         ->setLocked(true)
         ->setBoolOptions(
           array(
             pht('Enable Prototypes'),
             pht('Disable Prototypes'),
           ))
         ->setSummary(
           pht(
             'Install applications which are still under development.'))
         ->setDescription(
           pht(
             "IMPORTANT: The upstream does not provide support for prototype ".
             "applications.".
             "\n\n".
             "Phabricator includes prototype applications which are in an ".
             "**early stage of development**. By default, prototype ".
             "applications are not installed, because they are often not yet ".
             "developed enough to be generally usable. You can enable ".
             "this option to install them if you're developing Phabricator ".
             "or are interested in previewing upcoming features.".
             "\n\n".
             "To learn more about prototypes, see [[ %s | %s ]].".
             "\n\n".
             "After enabling prototypes, you can selectively uninstall them ".
             "(like normal applications).",
             $proto_doc_href,
             $proto_doc_name)),
       $this->newOption('phabricator.serious-business', 'bool', false)
         ->setBoolOptions(
           array(
             pht('Serious business'),
             pht('Shenanigans'), // That should be interesting to translate. :P
           ))
         ->setSummary(
           pht('Allows you to remove levity and jokes from the UI.'))
         ->setDescription(
           pht(
             'By default, Phabricator includes some flavor text in the UI, '.
             'like a prompt to "Weigh In" rather than "Add Comment" in '.
             'Maniphest. If you\'d prefer more traditional UI strings like '.
             '"Add Comment", you can set this flag to disable most of the '.
             'extra flavor.')),
       $this->newOption('remarkup.ignored-object-names', 'string', '/^(Q|V)\d$/')
         ->setSummary(
           pht('Text values that match this regex and are also object names '.
           'will not be linked.'))
         ->setDescription(
           pht(
             'By default, Phabricator links object names in Remarkup fields '.
             'to the corresponding object. This regex can be used to modify '.
             'this behavior; object names that match this regex will not be '.
             'linked.')),
       $this->newOption('environment.append-paths', 'list<string>', $paths)
         ->setSummary(
           pht('These paths get appended to your \$PATH envrionment variable.'))
         ->setDescription(
           pht(
             "Phabricator occasionally shells out to other binaries on the ".
             "server. An example of this is the `pygmentize` command, used ".
             "to syntax-highlight code written in languages other than PHP. ".
             "By default, it is assumed that these binaries are in the \$PATH ".
             "of the user running Phabricator (normally 'apache', 'httpd', or ".
             "'nobody'). Here you can add extra directories to the \$PATH ".
             "environment variable, for when these binaries are in ".
             "non-standard locations.\n\n".
             "Note that you can also put binaries in ".
             "`phabricator/support/bin/` (for example, by symlinking them).\n\n".
             "The current value of PATH after configuration is applied is:\n\n".
             "  lang=text\n".
             "  %s", $path))
         ->setLocked(true)
         ->addExample('/usr/local/bin', pht('Add One Path'))
         ->addExample("/usr/bin\n/usr/local/bin", pht('Add Multiple Paths')),
       $this->newOption('config.lock', 'set', array())
         ->setLocked(true)
         ->setDescription(pht('Additional configuration options to lock.')),
       $this->newOption('config.hide', 'set', array())
         ->setLocked(true)
         ->setDescription(pht('Additional configuration options to hide.')),
       $this->newOption('config.ignore-issues', 'set', array())
         ->setLocked(true)
         ->setDescription(pht('Setup issues to ignore.')),
       $this->newOption('phabricator.env', 'string', null)
         ->setLocked(true)
         ->setDescription(pht('Internal.')),
       $this->newOption('test.value', 'wild', null)
         ->setLocked(true)
         ->setDescription(pht('Unit test value.')),
       $this->newOption('phabricator.uninstalled-applications', 'set', array())
         ->setLocked(true)
         ->setLockedMessage(pht(
           'Use the %s to manage installed applications.',
           phutil_tag(
             'a',
             array(
               'href' => $applications_app_href,
             ),
             pht('Applications application'))))
         ->setDescription(
           pht('Array containing list of Uninstalled applications.')),
       $this->newOption('phabricator.application-settings', 'wild', array())
         ->setLocked(true)
         ->setDescription(
           pht('Customized settings for Phabricator applications.')),
       $this->newOption('welcome.html', 'string', null)
         ->setLocked(true)
         ->setDescription(
           pht('Custom HTML to show on the main Phabricator dashboard.')),
       $this->newOption('phabricator.cache-namespace', 'string', null)
         ->setLocked(true)
         ->setDescription(pht('Cache namespace.')),
       $this->newOption('phabricator.allow-email-users', 'bool', false)
         ->setBoolOptions(
-            array(
-              pht('Allow'),
-              pht('Disallow'),
-              ))->setDescription(
-                 pht(
-                   'Allow non-members to interact with tasks over email.')),
+          array(
+            pht('Allow'),
+            pht('Disallow'),
+          ))
+        ->setDescription(
+           pht('Allow non-members to interact with tasks over email.')),
+      $this->newOption('phabricator.silent', 'bool', false)
+        ->setLocked(true)
+        ->setBoolOptions(
+          array(
+            pht('Run Silently'),
+            pht('Run Normally'),
+          ))
+        ->setSummary(pht('Stop Phabricator from sending any email, etc.'))
+        ->setDescription(
+          pht(
+            'This option allows you to stop Phabricator from sending '.
+            'any data to external services. Among other things, it will '.
+            'disable email, SMS, repository mirroring, and HTTP hooks.'.
+            "\n\n".
+            'This option is intended to allow a Phabricator instance to '.
+            'be exported, copied, imported, and run in a test environment '.
+            'without impacting users. For example, if you are migrating '.
+            'to new hardware, you could perform a test migration first, '.
+            'make sure things work, and then do a production cutover '.
+            'later with higher confidence and less disruption. Without '.
+            'this flag, users would receive duplicate email during the '.
+            'time the test instance and old production instance were '.
+            'both in operation.')),
       );
 
   }
 
   protected function didValidateOption(
     PhabricatorConfigOption $option,
     $value) {
 
     $key = $option->getKey();
     if ($key == 'phabricator.base-uri' ||
         $key == 'phabricator.production-uri') {
 
       $uri = new PhutilURI($value);
       $protocol = $uri->getProtocol();
       if ($protocol !== 'http' && $protocol !== 'https') {
         throw new PhabricatorConfigValidationException(
           pht(
             "Config option '%s' is invalid. The URI must start with ".
             "'http://' or 'https://'.",
             $key));
       }
 
       $domain = $uri->getDomain();
       if (strpos($domain, '.') === false) {
         throw new PhabricatorConfigValidationException(
           pht(
             "Config option '%s' is invalid. The URI must contain a dot ('.'), ".
             "like 'http://example.com/', not just a bare name like ".
             "'http://example/'. Some web browsers will not set cookies on ".
             "domains with no TLD.",
             $key));
       }
 
       $path = $uri->getPath();
       if ($path !== '' && $path !== '/') {
         throw new PhabricatorConfigValidationException(
           pht(
             "Config option '%s' is invalid. The URI must NOT have a path, ".
             "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.",
             $key));
       }
     }
 
 
     if ($key === 'phabricator.timezone') {
       $old = date_default_timezone_get();
       $ok = @date_default_timezone_set($value);
       @date_default_timezone_set($old);
 
       if (!$ok) {
         throw new PhabricatorConfigValidationException(
           pht(
             "Config option '%s' is invalid. The timezone identifier must ".
             "be a valid timezone identifier recognized by PHP, like ".
             "'America/Los_Angeles'. You can find a list of valid identifiers ".
             "here: %s",
             $key,
             'http://php.net/manual/timezones.php'));
       }
     }
 
 
 
   }
 
 
 }
diff --git a/src/applications/diffusion/controller/DiffusionRepositoryEditMainController.php b/src/applications/diffusion/controller/DiffusionRepositoryEditMainController.php
index de72ce394b..0b270998f0 100644
--- a/src/applications/diffusion/controller/DiffusionRepositoryEditMainController.php
+++ b/src/applications/diffusion/controller/DiffusionRepositoryEditMainController.php
@@ -1,1195 +1,1203 @@
 <?php
 
 final class DiffusionRepositoryEditMainController
   extends DiffusionRepositoryEditController {
 
   protected function processDiffusionRequest(AphrontRequest $request) {
     $viewer = $request->getUser();
     $drequest = $this->diffusionRequest;
     $repository = $drequest->getRepository();
 
     PhabricatorPolicyFilter::requireCapability(
       $viewer,
       $repository,
       PhabricatorPolicyCapability::CAN_EDIT);
 
     $is_svn = false;
     $is_git = false;
     $is_hg = false;
     switch ($repository->getVersionControlSystem()) {
       case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
         $is_git = true;
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
         $is_svn = true;
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
         $is_hg = true;
         break;
     }
 
     $has_branches = ($is_git || $is_hg);
     $has_local = $repository->usesLocalWorkingCopy();
 
     $crumbs = $this->buildApplicationCrumbs($is_main = true);
 
     $title = pht('Edit %s', $repository->getName());
 
     $header = id(new PHUIHeaderView())
       ->setHeader($title);
     if ($repository->isTracked()) {
       $header->setStatus('fa-check', 'bluegrey', pht('Active'));
     } else {
       $header->setStatus('fa-ban', 'dark', pht('Inactive'));
     }
 
     $basic_actions = $this->buildBasicActions($repository);
     $basic_properties =
       $this->buildBasicProperties($repository, $basic_actions);
 
     $policy_actions = $this->buildPolicyActions($repository);
     $policy_properties =
       $this->buildPolicyProperties($repository, $policy_actions);
 
     $remote_properties = null;
     if (!$repository->isHosted()) {
       $remote_properties = $this->buildRemoteProperties(
         $repository,
         $this->buildRemoteActions($repository));
     }
 
     $encoding_actions = $this->buildEncodingActions($repository);
     $encoding_properties =
       $this->buildEncodingProperties($repository, $encoding_actions);
 
     $hosting_properties = $this->buildHostingProperties(
       $repository,
       $this->buildHostingActions($repository));
 
 
     $branches_properties = null;
     if ($has_branches) {
       $branches_properties = $this->buildBranchesProperties(
         $repository,
         $this->buildBranchesActions($repository));
     }
 
     $subversion_properties = null;
     if ($is_svn) {
       $subversion_properties = $this->buildSubversionProperties(
         $repository,
         $this->buildSubversionActions($repository));
     }
 
     $storage_properties = null;
     if ($has_local) {
       $storage_properties = $this->buildStorageProperties(
         $repository,
         $this->buildStorageActions($repository));
     }
 
     $actions_properties = $this->buildActionsProperties(
       $repository,
       $this->buildActionsActions($repository));
 
     $timeline = $this->buildTransactionTimeline(
       $repository,
       new PhabricatorRepositoryTransactionQuery());
     $timeline->setShouldTerminate(true);
 
     $boxes = array();
 
     $boxes[] = id(new PHUIObjectBoxView())
       ->setHeader($header)
       ->addPropertyList($basic_properties);
 
     $boxes[] = id(new PHUIObjectBoxView())
       ->setHeaderText(pht('Policies'))
       ->addPropertyList($policy_properties);
 
     $boxes[] = id(new PHUIObjectBoxView())
       ->setHeaderText(pht('Hosting'))
       ->addPropertyList($hosting_properties);
 
     if ($repository->canMirror()) {
       $mirror_actions = $this->buildMirrorActions($repository);
       $mirror_properties = $this->buildMirrorProperties(
         $repository,
         $mirror_actions);
 
       $mirrors = id(new PhabricatorRepositoryMirrorQuery())
         ->setViewer($viewer)
         ->withRepositoryPHIDs(array($repository->getPHID()))
         ->execute();
 
       $mirror_list = $this->buildMirrorList($repository, $mirrors);
 
       $boxes[] = id(new PhabricatorAnchorView())->setAnchorName('mirrors');
 
+      $mirror_info = array();
+      if (PhabricatorEnv::getEnvConfig('phabricator.silent')) {
+        $mirror_info[] = pht(
+          'Phabricator is running in silent mode, so changes will not '.
+          'be pushed to mirrors.');
+      }
+
       $boxes[] = id(new PHUIObjectBoxView())
+        ->setFormErrors($mirror_info)
         ->setHeaderText(pht('Mirrors'))
         ->addPropertyList($mirror_properties);
 
       $boxes[] = $mirror_list;
     }
 
     if ($remote_properties) {
       $boxes[] = id(new PHUIObjectBoxView())
         ->setHeaderText(pht('Remote'))
         ->addPropertyList($remote_properties);
     }
 
     if ($storage_properties) {
       $boxes[] = id(new PHUIObjectBoxView())
         ->setHeaderText(pht('Storage'))
         ->addPropertyList($storage_properties);
     }
 
     $boxes[] = id(new PHUIObjectBoxView())
       ->setHeaderText(pht('Text Encoding'))
       ->addPropertyList($encoding_properties);
 
     if ($branches_properties) {
       $boxes[] = id(new PHUIObjectBoxView())
         ->setHeaderText(pht('Branches'))
         ->addPropertyList($branches_properties);
     }
 
     if ($subversion_properties) {
       $boxes[] = id(new PHUIObjectBoxView())
         ->setHeaderText(pht('Subversion'))
         ->addPropertyList($subversion_properties);
     }
 
     $boxes[] = id(new PHUIObjectBoxView())
       ->setHeaderText(pht('Actions'))
       ->addPropertyList($actions_properties);
 
     return $this->buildApplicationPage(
       array(
         $crumbs,
         $boxes,
         $timeline,
       ),
       array(
         'title' => $title,
       ));
   }
 
   private function buildBasicActions(PhabricatorRepository $repository) {
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PhabricatorActionListView())
       ->setObjectURI($this->getRequest()->getRequestURI())
       ->setUser($viewer);
 
     $edit = id(new PhabricatorActionView())
       ->setIcon('fa-pencil')
       ->setName(pht('Edit Basic Information'))
       ->setHref($this->getRepositoryControllerURI($repository, 'edit/basic/'));
     $view->addAction($edit);
 
     $edit = id(new PhabricatorActionView())
       ->setIcon('fa-refresh')
       ->setName(pht('Update Now'))
       ->setWorkflow(true)
       ->setHref(
         $this->getRepositoryControllerURI($repository, 'edit/update/'));
     $view->addAction($edit);
 
     $activate = id(new PhabricatorActionView())
       ->setHref(
         $this->getRepositoryControllerURI($repository, 'edit/activate/'))
       ->setWorkflow(true);
 
     if ($repository->isTracked()) {
       $activate
         ->setIcon('fa-pause')
         ->setName(pht('Deactivate Repository'));
     } else {
       $activate
         ->setIcon('fa-play')
         ->setName(pht('Activate Repository'));
     }
 
     $view->addAction($activate);
 
     $view->addAction(
       id(new PhabricatorActionView())
         ->setName(pht('Delete Repository'))
         ->setIcon('fa-times')
         ->setHref(
           $this->getRepositoryControllerURI($repository, 'edit/delete/'))
         ->setDisabled(true)
         ->setWorkflow(true));
 
     return $view;
   }
 
   private function buildBasicProperties(
     PhabricatorRepository $repository,
     PhabricatorActionListView $actions) {
 
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PHUIPropertyListView())
       ->setUser($viewer)
       ->setActionList($actions);
 
     $type = PhabricatorRepositoryType::getNameForRepositoryType(
       $repository->getVersionControlSystem());
 
     $view->addProperty(pht('Type'), $type);
     $view->addProperty(pht('Callsign'), $repository->getCallsign());
 
 
     $clone_name = $repository->getDetail('clone-name');
 
     if ($repository->isHosted()) {
       $view->addProperty(
         pht('Clone/Checkout As'),
         $clone_name
           ? $clone_name.'/'
           : phutil_tag('em', array(), $repository->getCloneName().'/'));
     }
 
     $project_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
       $repository->getPHID(),
       PhabricatorProjectObjectHasProjectEdgeType::EDGECONST);
     if ($project_phids) {
       $this->loadHandles($project_phids);
       $project_text = $this->renderHandlesForPHIDs($project_phids);
     } else {
       $project_text = phutil_tag('em', array(), pht('None'));
     }
     $view->addProperty(
       pht('Projects'),
       $project_text);
 
     $view->addProperty(
       pht('Status'),
       $this->buildRepositoryStatus($repository));
 
     $view->addProperty(
       pht('Update Frequency'),
       $this->buildRepositoryUpdateInterval($repository));
 
     $description = $repository->getDetail('description');
     $view->addSectionHeader(pht('Description'));
     if (!strlen($description)) {
       $description = phutil_tag('em', array(), pht('No description provided.'));
     } else {
       $description = PhabricatorMarkupEngine::renderOneObject(
         $repository,
         'description',
         $viewer);
     }
     $view->addTextContent($description);
 
     return $view;
   }
 
   private function buildEncodingActions(PhabricatorRepository $repository) {
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PhabricatorActionListView())
       ->setObjectURI($this->getRequest()->getRequestURI())
       ->setUser($viewer);
 
     $edit = id(new PhabricatorActionView())
       ->setIcon('fa-pencil')
       ->setName(pht('Edit Text Encoding'))
       ->setHref(
         $this->getRepositoryControllerURI($repository, 'edit/encoding/'));
     $view->addAction($edit);
 
     return $view;
   }
 
   private function buildEncodingProperties(
     PhabricatorRepository $repository,
     PhabricatorActionListView $actions) {
 
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PHUIPropertyListView())
       ->setUser($viewer)
       ->setActionList($actions);
 
     $encoding = $repository->getDetail('encoding');
     if (!$encoding) {
       $encoding = phutil_tag('em', array(), pht('Use Default (UTF-8)'));
     }
 
     $view->addProperty(pht('Encoding'), $encoding);
 
     return $view;
   }
 
   private function buildPolicyActions(PhabricatorRepository $repository) {
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PhabricatorActionListView())
       ->setObjectURI($this->getRequest()->getRequestURI())
       ->setUser($viewer);
 
     $edit = id(new PhabricatorActionView())
       ->setIcon('fa-pencil')
       ->setName(pht('Edit Policies'))
       ->setHref(
         $this->getRepositoryControllerURI($repository, 'edit/policy/'));
     $view->addAction($edit);
 
     return $view;
   }
 
   private function buildPolicyProperties(
     PhabricatorRepository $repository,
     PhabricatorActionListView $actions) {
 
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PHUIPropertyListView())
       ->setUser($viewer)
       ->setActionList($actions);
 
     $descriptions = PhabricatorPolicyQuery::renderPolicyDescriptions(
       $viewer,
       $repository);
 
     $view->addProperty(
       pht('Visible To'),
       $descriptions[PhabricatorPolicyCapability::CAN_VIEW]);
 
     $view->addProperty(
       pht('Editable By'),
       $descriptions[PhabricatorPolicyCapability::CAN_EDIT]);
 
     $pushable = $repository->isHosted()
       ? $descriptions[DiffusionPushCapability::CAPABILITY]
       : phutil_tag('em', array(), pht('Not a Hosted Repository'));
     $view->addProperty(pht('Pushable By'), $pushable);
 
     return $view;
   }
 
   private function buildBranchesActions(PhabricatorRepository $repository) {
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PhabricatorActionListView())
       ->setObjectURI($this->getRequest()->getRequestURI())
       ->setUser($viewer);
 
     $edit = id(new PhabricatorActionView())
       ->setIcon('fa-pencil')
       ->setName(pht('Edit Branches'))
       ->setHref(
         $this->getRepositoryControllerURI($repository, 'edit/branches/'));
     $view->addAction($edit);
 
     return $view;
   }
 
   private function buildBranchesProperties(
     PhabricatorRepository $repository,
     PhabricatorActionListView $actions) {
 
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PHUIPropertyListView())
       ->setUser($viewer)
       ->setActionList($actions);
 
     $default_branch = nonempty(
       $repository->getHumanReadableDetail('default-branch'),
       phutil_tag('em', array(), $repository->getDefaultBranch()));
     $view->addProperty(pht('Default Branch'), $default_branch);
 
     $track_only = nonempty(
       $repository->getHumanReadableDetail('branch-filter', array()),
       phutil_tag('em', array(), pht('Track All Branches')));
     $view->addProperty(pht('Track Only'), $track_only);
 
     $autoclose_only = nonempty(
       $repository->getHumanReadableDetail('close-commits-filter', array()),
       phutil_tag('em', array(), pht('Autoclose On All Branches')));
 
     if ($repository->getDetail('disable-autoclose')) {
       $autoclose_only = phutil_tag('em', array(), pht('Disabled'));
     }
 
     $view->addProperty(pht('Autoclose Only'), $autoclose_only);
 
     return $view;
   }
 
   private function buildSubversionActions(PhabricatorRepository $repository) {
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PhabricatorActionListView())
       ->setObjectURI($this->getRequest()->getRequestURI())
       ->setUser($viewer);
 
     $edit = id(new PhabricatorActionView())
       ->setIcon('fa-pencil')
       ->setName(pht('Edit Subversion Info'))
       ->setHref(
         $this->getRepositoryControllerURI($repository, 'edit/subversion/'));
     $view->addAction($edit);
 
     return $view;
   }
 
   private function buildSubversionProperties(
     PhabricatorRepository $repository,
     PhabricatorActionListView $actions) {
 
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PHUIPropertyListView())
       ->setUser($viewer)
       ->setActionList($actions);
 
     $svn_uuid = nonempty(
       $repository->getUUID(),
       phutil_tag('em', array(), pht('Not Configured')));
     $view->addProperty(pht('Subversion UUID'), $svn_uuid);
 
     $svn_subpath = nonempty(
       $repository->getHumanReadableDetail('svn-subpath'),
       phutil_tag('em', array(), pht('Import Entire Repository')));
     $view->addProperty(pht('Import Only'), $svn_subpath);
 
     return $view;
   }
 
   private function buildActionsActions(PhabricatorRepository $repository) {
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PhabricatorActionListView())
       ->setObjectURI($this->getRequest()->getRequestURI())
       ->setUser($viewer);
 
     $edit = id(new PhabricatorActionView())
       ->setIcon('fa-pencil')
       ->setName(pht('Edit Actions'))
       ->setHref(
         $this->getRepositoryControllerURI($repository, 'edit/actions/'));
     $view->addAction($edit);
 
     return $view;
   }
 
   private function buildActionsProperties(
     PhabricatorRepository $repository,
     PhabricatorActionListView $actions) {
 
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PHUIPropertyListView())
       ->setUser($viewer)
       ->setActionList($actions);
 
     $notify = $repository->getDetail('herald-disabled')
       ? pht('Off')
       : pht('On');
     $notify = phutil_tag('em', array(), $notify);
     $view->addProperty(pht('Publish/Notify'), $notify);
 
     $autoclose = $repository->getDetail('disable-autoclose')
       ? pht('Off')
       : pht('On');
     $autoclose = phutil_tag('em', array(), $autoclose);
     $view->addProperty(pht('Autoclose'), $autoclose);
 
     return $view;
   }
 
   private function buildRemoteActions(PhabricatorRepository $repository) {
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PhabricatorActionListView())
       ->setObjectURI($this->getRequest()->getRequestURI())
       ->setUser($viewer);
 
     $edit = id(new PhabricatorActionView())
       ->setIcon('fa-pencil')
       ->setName(pht('Edit Remote'))
       ->setHref(
         $this->getRepositoryControllerURI($repository, 'edit/remote/'));
     $view->addAction($edit);
 
     return $view;
   }
 
   private function buildRemoteProperties(
     PhabricatorRepository $repository,
     PhabricatorActionListView $actions) {
 
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PHUIPropertyListView())
       ->setUser($viewer)
       ->setActionList($actions);
 
     $view->addProperty(
       pht('Remote URI'),
       $repository->getHumanReadableDetail('remote-uri'));
 
     $credential_phid = $repository->getCredentialPHID();
     if ($credential_phid) {
       $this->loadHandles(array($credential_phid));
       $view->addProperty(
         pht('Credential'),
         $this->getHandle($credential_phid)->renderLink());
     }
 
     return $view;
   }
 
   private function buildStorageActions(PhabricatorRepository $repository) {
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PhabricatorActionListView())
       ->setObjectURI($this->getRequest()->getRequestURI())
       ->setUser($viewer);
 
     $edit = id(new PhabricatorActionView())
       ->setIcon('fa-pencil')
       ->setName(pht('Edit Storage'))
       ->setHref(
         $this->getRepositoryControllerURI($repository, 'edit/storage/'));
     $view->addAction($edit);
 
     return $view;
   }
 
   private function buildStorageProperties(
     PhabricatorRepository $repository,
     PhabricatorActionListView $actions) {
 
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PHUIPropertyListView())
       ->setUser($viewer)
       ->setActionList($actions);
 
     $service_phid = $repository->getAlmanacServicePHID();
     if ($service_phid) {
       $handles = $this->loadViewerHandles(array($service_phid));
       $v_service = $handles[$service_phid]->renderLink();
     } else {
       $v_service = phutil_tag(
         'em',
         array(),
         pht('Local'));
     }
 
     $view->addProperty(
       pht('Storage Service'),
       $v_service);
 
     $view->addProperty(
       pht('Storage Path'),
       $repository->getHumanReadableDetail('local-path'));
 
     return $view;
   }
 
   private function buildHostingActions(PhabricatorRepository $repository) {
     $user = $this->getRequest()->getUser();
 
     $view = id(new PhabricatorActionListView())
       ->setObjectURI($this->getRequest()->getRequestURI())
       ->setUser($user);
 
     $edit = id(new PhabricatorActionView())
       ->setIcon('fa-pencil')
       ->setName(pht('Edit Hosting'))
       ->setHref(
         $this->getRepositoryControllerURI($repository, 'edit/hosting/'));
     $view->addAction($edit);
 
     if ($repository->canAllowDangerousChanges()) {
       if ($repository->shouldAllowDangerousChanges()) {
         $changes = id(new PhabricatorActionView())
           ->setIcon('fa-shield')
           ->setName(pht('Prevent Dangerous Changes'))
           ->setHref(
             $this->getRepositoryControllerURI($repository, 'edit/dangerous/'))
           ->setWorkflow(true);
       } else {
         $changes = id(new PhabricatorActionView())
           ->setIcon('fa-bullseye')
           ->setName(pht('Allow Dangerous Changes'))
           ->setHref(
             $this->getRepositoryControllerURI($repository, 'edit/dangerous/'))
           ->setWorkflow(true);
       }
       $view->addAction($changes);
     }
 
     return $view;
   }
 
   private function buildHostingProperties(
     PhabricatorRepository $repository,
     PhabricatorActionListView $actions) {
 
     $user = $this->getRequest()->getUser();
 
     $view = id(new PHUIPropertyListView())
       ->setUser($user)
       ->setActionList($actions);
 
     $hosting = $repository->isHosted()
       ? pht('Hosted on Phabricator')
       : pht('Hosted Elsewhere');
     $view->addProperty(pht('Hosting'), phutil_tag('em', array(), $hosting));
 
     $view->addProperty(
       pht('Serve over HTTP'),
       phutil_tag(
         'em',
         array(),
         PhabricatorRepository::getProtocolAvailabilityName(
           $repository->getServeOverHTTP())));
 
     $view->addProperty(
       pht('Serve over SSH'),
       phutil_tag(
         'em',
         array(),
         PhabricatorRepository::getProtocolAvailabilityName(
           $repository->getServeOverSSH())));
 
     if ($repository->canAllowDangerousChanges()) {
       if ($repository->shouldAllowDangerousChanges()) {
         $description = pht('Allowed');
       } else {
         $description = pht('Not Allowed');
       }
 
       $view->addProperty(
         pht('Dangerous Changes'),
         $description);
     }
 
     return $view;
   }
 
   private function buildRepositoryStatus(
     PhabricatorRepository $repository) {
 
     $viewer = $this->getRequest()->getUser();
     $is_cluster = $repository->getAlmanacServicePHID();
 
     $view = new PHUIStatusListView();
 
     $messages = id(new PhabricatorRepositoryStatusMessage())
       ->loadAllWhere('repositoryID = %d', $repository->getID());
     $messages = mpull($messages, null, 'getStatusType');
 
     if ($repository->isTracked()) {
       $view->addItem(
         id(new PHUIStatusItemView())
           ->setIcon(PHUIStatusItemView::ICON_ACCEPT, 'green')
           ->setTarget(pht('Repository Active')));
     } else {
       $view->addItem(
         id(new PHUIStatusItemView())
           ->setIcon(PHUIStatusItemView::ICON_WARNING, 'bluegrey')
           ->setTarget(pht('Repository Inactive'))
           ->setNote(
             pht('Activate this repository to begin or resume import.')));
       return $view;
     }
 
     $binaries = array();
     $svnlook_check = false;
     switch ($repository->getVersionControlSystem()) {
       case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
         $binaries[] = 'git';
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
         $binaries[] = 'svn';
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
         $binaries[] = 'hg';
         break;
     }
 
     if ($repository->isHosted()) {
       if ($repository->getServeOverHTTP() != PhabricatorRepository::SERVE_OFF) {
         switch ($repository->getVersionControlSystem()) {
           case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
             $binaries[] = 'git-http-backend';
             break;
           case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
             $binaries[] = 'svnserve';
             $binaries[] = 'svnadmin';
             $binaries[] = 'svnlook';
             $svnlook_check = true;
             break;
           case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
             $binaries[] = 'hg';
             break;
         }
       }
       if ($repository->getServeOverSSH() != PhabricatorRepository::SERVE_OFF) {
         switch ($repository->getVersionControlSystem()) {
           case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
             $binaries[] = 'git-receive-pack';
             $binaries[] = 'git-upload-pack';
             break;
           case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
             $binaries[] = 'svnserve';
             $binaries[] = 'svnadmin';
             $binaries[] = 'svnlook';
             $svnlook_check = true;
             break;
           case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
             $binaries[] = 'hg';
             break;
         }
       }
     }
 
     $binaries = array_unique($binaries);
     if (!$is_cluster) {
       // We're only checking for binaries if we aren't running with a cluster
       // configuration. In theory, we could check for binaries on the
       // repository host machine, but we'd need to make this more complicated
       // to do that.
 
       foreach ($binaries as $binary) {
         $where = Filesystem::resolveBinary($binary);
         if (!$where) {
           $view->addItem(
             id(new PHUIStatusItemView())
               ->setIcon(PHUIStatusItemView::ICON_WARNING, 'red')
               ->setTarget(
                 pht('Missing Binary %s', phutil_tag('tt', array(), $binary)))
               ->setNote(pht(
                 "Unable to find this binary in the webserver's PATH. You may ".
                 "need to configure %s.",
                 $this->getEnvConfigLink())));
         } else {
           $view->addItem(
             id(new PHUIStatusItemView())
               ->setIcon(PHUIStatusItemView::ICON_ACCEPT, 'green')
               ->setTarget(
                 pht('Found Binary %s', phutil_tag('tt', array(), $binary)))
               ->setNote(phutil_tag('tt', array(), $where)));
         }
       }
 
       // This gets checked generically above. However, for svn commit hooks, we
       // need this to be in environment.append-paths because subversion strips
       // PATH.
       if ($svnlook_check) {
         $where = Filesystem::resolveBinary('svnlook');
         if ($where) {
           $path = substr($where, 0, strlen($where) - strlen('svnlook'));
           $dirs = PhabricatorEnv::getEnvConfig('environment.append-paths');
           $in_path = false;
           foreach ($dirs as $dir) {
             if (Filesystem::isDescendant($path, $dir)) {
               $in_path = true;
               break;
             }
           }
           if (!$in_path) {
             $view->addItem(
               id(new PHUIStatusItemView())
               ->setIcon(PHUIStatusItemView::ICON_WARNING, 'red')
               ->setTarget(
                 pht('Missing Binary %s', phutil_tag('tt', array(), $binary)))
               ->setNote(pht(
                   'Unable to find this binary in `environment.append-paths`. '.
                   'You need to configure %s and include %s.',
                   $this->getEnvConfigLink(),
                   $path)));
           }
         }
       }
     }
 
     $doc_href = PhabricatorEnv::getDocLink('Managing Daemons with phd');
 
     $daemon_instructions = pht(
       'Use %s to start daemons. See %s.',
       phutil_tag('tt', array(), 'bin/phd start'),
       phutil_tag(
         'a',
         array(
           'href' => $doc_href,
         ),
         pht('Managing Daemons with phd')));
 
 
     $pull_daemon = id(new PhabricatorDaemonLogQuery())
       ->setViewer(PhabricatorUser::getOmnipotentUser())
       ->withStatus(PhabricatorDaemonLogQuery::STATUS_ALIVE)
       ->withDaemonClasses(array('PhabricatorRepositoryPullLocalDaemon'))
       ->setLimit(1)
       ->execute();
 
     if ($pull_daemon) {
 
       // TODO: In a cluster environment, we need a daemon on this repository's
       // host, specifically, and we aren't checking for that right now. This
       // is a reasonable proxy for things being more-or-less correctly set up,
       // though.
 
       $view->addItem(
         id(new PHUIStatusItemView())
           ->setIcon(PHUIStatusItemView::ICON_ACCEPT, 'green')
           ->setTarget(pht('Pull Daemon Running')));
     } else {
       $view->addItem(
         id(new PHUIStatusItemView())
           ->setIcon(PHUIStatusItemView::ICON_WARNING, 'red')
           ->setTarget(pht('Pull Daemon Not Running'))
           ->setNote($daemon_instructions));
     }
 
 
     $task_daemon = id(new PhabricatorDaemonLogQuery())
       ->setViewer(PhabricatorUser::getOmnipotentUser())
       ->withStatus(PhabricatorDaemonLogQuery::STATUS_ALIVE)
       ->withDaemonClasses(array('PhabricatorTaskmasterDaemon'))
       ->setLimit(1)
       ->execute();
     if ($task_daemon) {
       $view->addItem(
         id(new PHUIStatusItemView())
           ->setIcon(PHUIStatusItemView::ICON_ACCEPT, 'green')
           ->setTarget(pht('Task Daemon Running')));
     } else {
       $view->addItem(
         id(new PHUIStatusItemView())
           ->setIcon(PHUIStatusItemView::ICON_WARNING, 'red')
           ->setTarget(pht('Task Daemon Not Running'))
           ->setNote($daemon_instructions));
     }
 
 
     if ($is_cluster) {
       // Just omit this status check for now in cluster environments. We
       // could make a service call and pull it from the repository host
       // eventually.
     } else if ($repository->usesLocalWorkingCopy()) {
       $local_parent = dirname($repository->getLocalPath());
       if (Filesystem::pathExists($local_parent)) {
         $view->addItem(
           id(new PHUIStatusItemView())
             ->setIcon(PHUIStatusItemView::ICON_ACCEPT, 'green')
             ->setTarget(pht('Storage Directory OK'))
             ->setNote(phutil_tag('tt', array(), $local_parent)));
       } else {
         $view->addItem(
           id(new PHUIStatusItemView())
             ->setIcon(PHUIStatusItemView::ICON_WARNING, 'red')
             ->setTarget(pht('No Storage Directory'))
             ->setNote(
               pht(
                 'Storage directory %s does not exist, or is not readable by '.
                 'the webserver. Create this directory or make it readable.',
                 phutil_tag('tt', array(), $local_parent))));
         return $view;
       }
 
       $local_path = $repository->getLocalPath();
       $message = idx($messages, PhabricatorRepositoryStatusMessage::TYPE_INIT);
       if ($message) {
         switch ($message->getStatusCode()) {
           case PhabricatorRepositoryStatusMessage::CODE_ERROR:
             $view->addItem(
               id(new PHUIStatusItemView())
               ->setIcon(PHUIStatusItemView::ICON_WARNING, 'red')
                 ->setTarget(pht('Initialization Error'))
                 ->setNote($message->getParameter('message')));
             return $view;
           case PhabricatorRepositoryStatusMessage::CODE_OKAY:
               if (Filesystem::pathExists($local_path)) {
                 $view->addItem(
                   id(new PHUIStatusItemView())
                     ->setIcon(PHUIStatusItemView::ICON_ACCEPT, 'green')
                     ->setTarget(pht('Working Copy OK'))
                     ->setNote(phutil_tag('tt', array(), $local_path)));
               } else {
                 $view->addItem(
                   id(new PHUIStatusItemView())
                     ->setIcon(PHUIStatusItemView::ICON_WARNING, 'red')
                     ->setTarget(pht('Working Copy Error'))
                     ->setNote(
                       pht(
                         'Working copy %s has been deleted, or is not '.
                         'readable by the webserver. Make this directory '.
                         'readable. If it has been deleted, the daemons should '.
                         'restore it automatically.',
                         phutil_tag('tt', array(), $local_path))));
                 return $view;
               }
             break;
           case PhabricatorRepositoryStatusMessage::CODE_WORKING:
             $view->addItem(
               id(new PHUIStatusItemView())
                 ->setIcon(PHUIStatusItemView::ICON_CLOCK, 'green')
                 ->setTarget(pht('Initializing Working Copy'))
                 ->setNote(pht('Daemons are initializing the working copy.')));
             return $view;
           default:
             $view->addItem(
               id(new PHUIStatusItemView())
                 ->setIcon(PHUIStatusItemView::ICON_WARNING, 'red')
                 ->setTarget(pht('Unknown Init Status'))
                 ->setNote($message->getStatusCode()));
             return $view;
         }
       } else {
         $view->addItem(
           id(new PHUIStatusItemView())
             ->setIcon(PHUIStatusItemView::ICON_CLOCK, 'orange')
             ->setTarget(pht('No Working Copy Yet'))
             ->setNote(
               pht('Waiting for daemons to build a working copy.')));
         return $view;
       }
     }
 
     $message = idx($messages, PhabricatorRepositoryStatusMessage::TYPE_FETCH);
     if ($message) {
       switch ($message->getStatusCode()) {
         case PhabricatorRepositoryStatusMessage::CODE_ERROR:
           $message = $message->getParameter('message');
 
           $suggestion = null;
           if (preg_match('/Permission denied \(publickey\)./', $message)) {
             $suggestion = pht(
               'Public Key Error: This error usually indicates that the '.
               'keypair you have configured does not have permission to '.
               'access the repository.');
           }
 
           $message = phutil_escape_html_newlines($message);
 
           if ($suggestion !== null) {
             $message = array(
               phutil_tag('strong', array(), $suggestion),
               phutil_tag('br'),
               phutil_tag('br'),
               phutil_tag('em', array(), pht('Raw Error')),
               phutil_tag('br'),
               $message,
             );
           }
 
           $view->addItem(
             id(new PHUIStatusItemView())
               ->setIcon(PHUIStatusItemView::ICON_WARNING, 'red')
               ->setTarget(pht('Update Error'))
               ->setNote($message));
           return $view;
         case PhabricatorRepositoryStatusMessage::CODE_OKAY:
           $ago = (PhabricatorTime::getNow() - $message->getEpoch());
           $view->addItem(
             id(new PHUIStatusItemView())
               ->setIcon(PHUIStatusItemView::ICON_ACCEPT, 'green')
               ->setTarget(pht('Updates OK'))
               ->setNote(
                 pht(
                   'Last updated %s (%s ago).',
                   phabricator_datetime($message->getEpoch(), $viewer),
                   phutil_format_relative_time_detailed($ago))));
           break;
       }
     } else {
       $view->addItem(
         id(new PHUIStatusItemView())
           ->setIcon(PHUIStatusItemView::ICON_CLOCK, 'orange')
           ->setTarget(pht('Waiting For Update'))
           ->setNote(
             pht('Waiting for daemons to read updates.')));
     }
 
     if ($repository->isImporting()) {
       $progress = queryfx_all(
         $repository->establishConnection('r'),
         'SELECT importStatus, count(*) N FROM %T WHERE repositoryID = %d
           GROUP BY importStatus',
         id(new PhabricatorRepositoryCommit())->getTableName(),
         $repository->getID());
 
       $done = 0;
       $total = 0;
       foreach ($progress as $row) {
         $total += $row['N'] * 4;
         $status = $row['importStatus'];
         if ($status & PhabricatorRepositoryCommit::IMPORTED_MESSAGE) {
           $done += $row['N'];
         }
         if ($status & PhabricatorRepositoryCommit::IMPORTED_CHANGE) {
           $done += $row['N'];
         }
         if ($status & PhabricatorRepositoryCommit::IMPORTED_OWNERS) {
           $done += $row['N'];
         }
         if ($status & PhabricatorRepositoryCommit::IMPORTED_HERALD) {
           $done += $row['N'];
         }
       }
 
       if ($total) {
         $percentage = 100 * ($done / $total);
       } else {
         $percentage = 0;
       }
 
       // Cap this at "99.99%", because it's confusing to users when the actual
       // fraction is "99.996%" and it rounds up to "100.00%".
       if ($percentage > 99.99) {
         $percentage = 99.99;
       }
 
       $percentage = sprintf('%.2f%%', $percentage);
 
       $view->addItem(
         id(new PHUIStatusItemView())
           ->setIcon(PHUIStatusItemView::ICON_CLOCK, 'green')
           ->setTarget(pht('Importing'))
           ->setNote(
             pht('%s Complete', $percentage)));
     } else {
       $view->addItem(
         id(new PHUIStatusItemView())
           ->setIcon(PHUIStatusItemView::ICON_ACCEPT, 'green')
           ->setTarget(pht('Fully Imported')));
     }
 
     if (idx($messages, PhabricatorRepositoryStatusMessage::TYPE_NEEDS_UPDATE)) {
       $view->addItem(
         id(new PHUIStatusItemView())
           ->setIcon(PHUIStatusItemView::ICON_UP, 'indigo')
           ->setTarget(pht('Prioritized'))
           ->setNote(pht('This repository will be updated soon!')));
     }
 
     return $view;
   }
 
   private function buildRepositoryUpdateInterval(
     PhabricatorRepository $repository) {
 
     $smart_wait = $repository->loadUpdateInterval();
 
     $doc_href = PhabricatorEnv::getDoclink(
       'Diffusion User Guide: Repository Updates');
 
     return array(
       phutil_format_relative_time_detailed($smart_wait),
       " \xC2\xB7 ",
       phutil_tag(
         'a',
         array(
           'href' => $doc_href,
           'target' => '_blank',
         ),
         pht('Learn More')),
     );
   }
 
 
   private function buildMirrorActions(
     PhabricatorRepository $repository) {
 
     $viewer = $this->getRequest()->getUser();
 
     $mirror_actions = id(new PhabricatorActionListView())
       ->setObjectURI($this->getRequest()->getRequestURI())
       ->setUser($viewer);
 
     $new_mirror_uri = $this->getRepositoryControllerURI(
       $repository,
       'mirror/edit/');
 
     $mirror_actions->addAction(
       id(new PhabricatorActionView())
         ->setName(pht('Add Mirror'))
         ->setIcon('fa-plus')
         ->setHref($new_mirror_uri)
         ->setWorkflow(true));
 
     return $mirror_actions;
   }
 
   private function buildMirrorProperties(
     PhabricatorRepository $repository,
     PhabricatorActionListView $actions) {
 
     $viewer = $this->getRequest()->getUser();
 
     $mirror_properties = id(new PHUIPropertyListView())
       ->setUser($viewer)
       ->setActionList($actions);
 
     $mirror_properties->addProperty(
       '',
       phutil_tag(
         'em',
         array(),
         pht('Automatically push changes into other remotes.')));
 
     return $mirror_properties;
   }
 
   private function buildMirrorList(
     PhabricatorRepository $repository,
     array $mirrors) {
     assert_instances_of($mirrors, 'PhabricatorRepositoryMirror');
 
     $mirror_list = id(new PHUIObjectItemListView())
       ->setNoDataString(pht('This repository has no configured mirrors.'));
 
     foreach ($mirrors as $mirror) {
       $item = id(new PHUIObjectItemView())
         ->setHeader($mirror->getRemoteURI());
 
       $edit_uri = $this->getRepositoryControllerURI(
         $repository,
         'mirror/edit/'.$mirror->getID().'/');
 
       $delete_uri = $this->getRepositoryControllerURI(
         $repository,
         'mirror/delete/'.$mirror->getID().'/');
 
       $item->addAction(
         id(new PHUIListItemView())
           ->setIcon('fa-pencil')
           ->setHref($edit_uri)
           ->setWorkflow(true));
 
       $item->addAction(
         id(new PHUIListItemView())
           ->setIcon('fa-times')
           ->setHref($delete_uri)
           ->setWorkflow(true));
 
       $mirror_list->addItem($item);
     }
 
     return $mirror_list;
   }
 
   private function getEnvConfigLink() {
     $config_href = '/config/edit/environment.append-paths/';
     return phutil_tag(
       'a',
       array(
         'href' => $config_href,
       ),
       'environment.append-paths');
   }
 
 }
diff --git a/src/applications/doorkeeper/worker/DoorkeeperFeedWorker.php b/src/applications/doorkeeper/worker/DoorkeeperFeedWorker.php
index f73451ee87..a280e85fbb 100644
--- a/src/applications/doorkeeper/worker/DoorkeeperFeedWorker.php
+++ b/src/applications/doorkeeper/worker/DoorkeeperFeedWorker.php
@@ -1,196 +1,201 @@
 <?php
 
 /**
  * Publish events (like comments on a revision) to external objects which are
  * linked through Doorkeeper (like a linked JIRA or Asana task).
  *
  * These workers are invoked by feed infrastructure during normal task queue
  * operations. They read feed stories and publish information about them to
  * external systems, generally mirroring comments and updates in Phabricator
  * into remote systems by making API calls.
  *
  * @task publish  Publishing Stories
  * @task context  Story Context
  * @task internal Internals
  */
 abstract class DoorkeeperFeedWorker extends FeedPushWorker {
 
   private $publisher;
   private $feedStory;
   private $storyObject;
 
 
 /* -(  Publishing Stories  )------------------------------------------------- */
 
 
   /**
    * Actually publish the feed story. Subclasses will generally make API calls
    * to publish some version of the story into external systems.
    *
    * @return void
    * @task publish
    */
   abstract protected function publishFeedStory();
 
 
   /**
    * Enable or disable the worker. Normally, this checks configuration to
    * see if Phabricator is linked to applicable external systems.
    *
    * @return bool True if this worker should try to publish stories.
    * @task publish
    */
   abstract public function isEnabled();
 
 
 /* -(  Story Context  )------------------------------------------------------ */
 
 
   /**
    * Get the @{class:PhabricatorFeedStory} that should be published.
    *
    * @return PhabricatorFeedStory The story to publish.
    * @task context
    */
   protected function getFeedStory() {
     if (!$this->feedStory) {
       $story = $this->loadFeedStory();
       $this->feedStory = $story;
     }
     return $this->feedStory;
   }
 
 
   /**
    * Get the viewer for the act of publishing.
    *
    * NOTE: Publishing currently uses the omnipotent viewer because it depends
    * on loading external accounts. Possibly we should tailor this. See T3732.
    * Using the actor for most operations might make more sense.
    *
    * @return PhabricatorUser Viewer.
    * @task context
    */
   protected function getViewer() {
     return PhabricatorUser::getOmnipotentUser();
   }
 
 
   /**
    * Get the @{class:DoorkeeperFeedStoryPublisher} which handles this object.
    *
    * @return DoorkeeperFeedStoryPublisher Object publisher.
    * @task context
    */
   protected function getPublisher() {
     return $this->publisher;
   }
 
 
   /**
    * Get the primary object the story is about, like a
    * @{class:DifferentialRevision} or @{class:ManiphestTask}.
    *
    * @return object Object which the story is about.
    * @task context
    */
   protected function getStoryObject() {
     if (!$this->storyObject) {
       $story = $this->getFeedStory();
       try {
         $object = $story->getPrimaryObject();
       } catch (Exception $ex) {
         throw new PhabricatorWorkerPermanentFailureException(
           $ex->getMessage());
       }
       $this->storyObject = $object;
     }
     return $this->storyObject;
   }
 
 
 /* -(  Internals  )---------------------------------------------------------- */
 
 
   /**
    * Load the @{class:DoorkeeperFeedStoryPublisher} which corresponds to this
    * object. Publishers provide a common API for pushing object updates into
    * foreign systems.
    *
    * @return DoorkeeperFeedStoryPublisher Publisher for the story's object.
    * @task internal
    */
   private function loadPublisher() {
     $story = $this->getFeedStory();
     $viewer = $this->getViewer();
     $object = $this->getStoryObject();
 
     $publishers = id(new PhutilSymbolLoader())
       ->setAncestorClass('DoorkeeperFeedStoryPublisher')
       ->loadObjects();
 
     foreach ($publishers as $publisher) {
       if (!$publisher->canPublishStory($story, $object)) {
         continue;
       }
 
       $publisher
         ->setViewer($viewer)
         ->setFeedStory($story);
 
       $object = $publisher->willPublishStory($object);
       $this->storyObject = $object;
 
       $this->publisher = $publisher;
       break;
     }
 
     return $this->publisher;
   }
 
 
 /* -(  Inherited  )---------------------------------------------------------- */
 
 
   /**
    * Doorkeeper workers set up some context, then call
    * @{method:publishFeedStory}.
    */
   final protected function doWork() {
+    if (PhabricatorEnv::getEnvConfig('phabricator.silent')) {
+      $this->log(pht('Phabricator is running in silent mode.'));
+      return;
+    }
+
     if (!$this->isEnabled()) {
       $this->log("Doorkeeper worker '%s' is not enabled.\n", get_class($this));
       return;
     }
 
     $publisher = $this->loadPublisher();
     if (!$publisher) {
       $this->log("Story is about an unsupported object type.\n");
       return;
     } else {
       $this->log("Using publisher '%s'.\n", get_class($publisher));
     }
 
     $this->publishFeedStory();
   }
 
 
   /**
    * By default, Doorkeeper workers perform a small number of retries with
    * exponential backoff. A consideration in this policy is that many of these
    * workers are laden with side effects.
    */
   public function getMaximumRetryCount() {
     return 4;
   }
 
 
   /**
    * See @{method:getMaximumRetryCount} for a description of Doorkeeper
    * retry defaults.
    */
   public function getWaitBeforeRetry(PhabricatorWorkerTask $task) {
     $count = $task->getFailureCount();
     return (5 * 60) * pow(8, $count);
   }
 
 }
diff --git a/src/applications/feed/worker/FeedPublisherHTTPWorker.php b/src/applications/feed/worker/FeedPublisherHTTPWorker.php
index e4e0600cb1..4742e52a29 100644
--- a/src/applications/feed/worker/FeedPublisherHTTPWorker.php
+++ b/src/applications/feed/worker/FeedPublisherHTTPWorker.php
@@ -1,34 +1,39 @@
 <?php
 
 final class FeedPublisherHTTPWorker extends FeedPushWorker {
 
   protected function doWork() {
+    if (PhabricatorEnv::getEnvConfig('phabricator.silent')) {
+      // Don't invoke hooks in silent mode.
+      return;
+    }
+
     $story = $this->loadFeedStory();
     $data = $story->getStoryData();
 
     $uri = idx($this->getTaskData(), 'uri');
     $valid_uris = PhabricatorEnv::getEnvConfig('feed.http-hooks');
     if (!in_array($uri, $valid_uris)) {
       throw new PhabricatorWorkerPermanentFailureException();
     }
 
     $post_data = array(
       'storyID'         => $data->getID(),
       'storyType'       => $data->getStoryType(),
       'storyData'       => $data->getStoryData(),
       'storyAuthorPHID' => $data->getAuthorPHID(),
       'storyText'       => $story->renderText(),
       'epoch'           => $data->getEpoch(),
     );
 
     id(new HTTPSFuture($uri, $post_data))
       ->setMethod('POST')
       ->setTimeout(30)
       ->resolvex();
   }
 
   public function getWaitBeforeRetry(PhabricatorWorkerTask $task) {
     return max($task->getFailureCount(), 1) * 60;
   }
 
 }
diff --git a/src/applications/metamta/storage/PhabricatorMetaMTAMail.php b/src/applications/metamta/storage/PhabricatorMetaMTAMail.php
index e6d8e52c45..0fb118252a 100644
--- a/src/applications/metamta/storage/PhabricatorMetaMTAMail.php
+++ b/src/applications/metamta/storage/PhabricatorMetaMTAMail.php
@@ -1,969 +1,978 @@
 <?php
 
 /**
  * @task recipients   Managing Recipients
  */
 final class PhabricatorMetaMTAMail extends PhabricatorMetaMTADAO {
 
   const STATUS_QUEUE = 'queued';
   const STATUS_SENT  = 'sent';
   const STATUS_FAIL  = 'fail';
   const STATUS_VOID  = 'void';
 
   const RETRY_DELAY   = 5;
 
   protected $parameters;
   protected $status;
   protected $message;
   protected $relatedPHID;
 
   private $recipientExpansionMap;
 
   public function __construct() {
 
     $this->status     = self::STATUS_QUEUE;
     $this->parameters = array();
 
     parent::__construct();
   }
 
   protected function getConfiguration() {
     return array(
       self::CONFIG_SERIALIZATION => array(
         'parameters'  => self::SERIALIZATION_JSON,
       ),
       self::CONFIG_COLUMN_SCHEMA => array(
         'status' => 'text32',
         'relatedPHID' => 'phid?',
 
         // T6203/NULLABILITY
         // This should just be empty if there's no body.
         'message' => 'text?',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'status' => array(
           'columns' => array('status'),
         ),
         'relatedPHID' => array(
           'columns' => array('relatedPHID'),
         ),
         'key_created' => array(
           'columns' => array('dateCreated'),
         ),
       ),
     ) + parent::getConfiguration();
   }
 
   protected function setParam($param, $value) {
     $this->parameters[$param] = $value;
     return $this;
   }
 
   protected function getParam($param, $default = null) {
     return idx($this->parameters, $param, $default);
   }
 
   /**
    * Set tags (@{class:MetaMTANotificationType} constants) which identify the
    * content of this mail in a general way. These tags are used to allow users
    * to opt out of receiving certain types of mail, like updates when a task's
    * projects change.
    *
    * @param list<const> List of @{class:MetaMTANotificationType} constants.
    * @return this
    */
   public function setMailTags(array $tags) {
     $this->setParam('mailtags', array_unique($tags));
     return $this;
   }
 
   public function getMailTags() {
     return $this->getParam('mailtags', array());
   }
 
   /**
    * In Gmail, conversations will be broken if you reply to a thread and the
    * server sends back a response without referencing your Message-ID, even if
    * it references a Message-ID earlier in the thread. To avoid this, use the
    * parent email's message ID explicitly if it's available. This overwrites the
    * "In-Reply-To" and "References" headers we would otherwise generate. This
    * needs to be set whenever an action is triggered by an email message. See
    * T251 for more details.
    *
    * @param   string The "Message-ID" of the email which precedes this one.
    * @return  this
    */
   public function setParentMessageID($id) {
     $this->setParam('parent-message-id', $id);
     return $this;
   }
 
   public function getParentMessageID() {
     return $this->getParam('parent-message-id');
   }
 
   public function getSubject() {
     return $this->getParam('subject');
   }
 
   public function addTos(array $phids) {
     $phids = array_unique($phids);
     $this->setParam('to', $phids);
     return $this;
   }
 
   public function addRawTos(array $raw_email) {
 
     // Strip addresses down to bare emails, since the MailAdapter API currently
     // requires we pass it just the address (like `alincoln@logcabin.org`), not
     // a full string like `"Abraham Lincoln" <alincoln@logcabin.org>`.
     foreach ($raw_email as $key => $email) {
       $object = new PhutilEmailAddress($email);
       $raw_email[$key] = $object->getAddress();
     }
 
     $this->setParam('raw-to', $raw_email);
     return $this;
   }
 
   public function addCCs(array $phids) {
     $phids = array_unique($phids);
     $this->setParam('cc', $phids);
     return $this;
   }
 
   public function setExcludeMailRecipientPHIDs(array $exclude) {
     $this->setParam('exclude', $exclude);
     return $this;
   }
 
   private function getExcludeMailRecipientPHIDs() {
     return $this->getParam('exclude', array());
   }
 
   public function getTranslation(array $objects) {
     $default_translation = PhabricatorEnv::getEnvConfig('translation.provider');
     $return = null;
     $recipients = array_merge(
       idx($this->parameters, 'to', array()),
       idx($this->parameters, 'cc', array()));
     foreach (array_select_keys($objects, $recipients) as $object) {
       $translation = null;
       if ($object instanceof PhabricatorUser) {
         $translation = $object->getTranslation();
       }
       if (!$translation) {
         $translation = $default_translation;
       }
       if ($return && $translation != $return) {
         return $default_translation;
       }
       $return = $translation;
     }
 
     if (!$return) {
       $return = $default_translation;
     }
 
     return $return;
   }
 
   public function addPHIDHeaders($name, array $phids) {
     foreach ($phids as $phid) {
       $this->addHeader($name, '<'.$phid.'>');
     }
     return $this;
   }
 
   public function addHeader($name, $value) {
     $this->parameters['headers'][] = array($name, $value);
     return $this;
   }
 
   public function addAttachment(PhabricatorMetaMTAAttachment $attachment) {
     $this->parameters['attachments'][] = $attachment->toDictionary();
     return $this;
   }
 
   public function getAttachments() {
     $dicts = $this->getParam('attachments');
 
     $result = array();
     foreach ($dicts as $dict) {
       $result[] = PhabricatorMetaMTAAttachment::newFromDictionary($dict);
     }
     return $result;
   }
 
   public function setAttachments(array $attachments) {
     assert_instances_of($attachments, 'PhabricatorMetaMTAAttachment');
     $this->setParam('attachments', mpull($attachments, 'toDictionary'));
     return $this;
   }
 
   public function setFrom($from) {
     $this->setParam('from', $from);
     return $this;
   }
 
   public function setRawFrom($raw_email, $raw_name) {
     $this->setParam('raw-from', array($raw_email, $raw_name));
     return $this;
   }
 
   public function setReplyTo($reply_to) {
     $this->setParam('reply-to', $reply_to);
     return $this;
   }
 
   public function setSubject($subject) {
     $this->setParam('subject', $subject);
     return $this;
   }
 
   public function setSubjectPrefix($prefix) {
     $this->setParam('subject-prefix', $prefix);
     return $this;
   }
 
   public function setVarySubjectPrefix($prefix) {
     $this->setParam('vary-subject-prefix', $prefix);
     return $this;
   }
 
   public function setBody($body) {
     $this->setParam('body', $body);
     return $this;
   }
 
   public function setHTMLBody($html) {
     $this->setParam('html-body', $html);
     return $this;
   }
 
   public function getBody() {
     return $this->getParam('body');
   }
 
   public function getHTMLBody() {
     return $this->getParam('html-body');
   }
 
   public function setIsErrorEmail($is_error) {
     $this->setParam('is-error', $is_error);
     return $this;
   }
 
   public function getIsErrorEmail() {
     return $this->getParam('is-error', false);
   }
 
   public function getToPHIDs() {
     return $this->getParam('to', array());
   }
 
   public function getRawToAddresses() {
     return $this->getParam('raw-to', array());
   }
 
   public function getCcPHIDs() {
     return $this->getParam('cc', array());
   }
 
   /**
    * Force delivery of a message, even if recipients have preferences which
    * would otherwise drop the message.
    *
    * This is primarily intended to let users who don't want any email still
    * receive things like password resets.
    *
    * @param bool  True to force delivery despite user preferences.
    * @return this
    */
   public function setForceDelivery($force) {
     $this->setParam('force', $force);
     return $this;
   }
 
   public function getForceDelivery() {
     return $this->getParam('force', false);
   }
 
   /**
    * Flag that this is an auto-generated bulk message and should have bulk
    * headers added to it if appropriate. Broadly, this means some flavor of
    * "Precedence: bulk" or similar, but is implementation and configuration
    * dependent.
    *
    * @param bool  True if the mail is automated bulk mail.
    * @return this
    */
   public function setIsBulk($is_bulk) {
     $this->setParam('is-bulk', $is_bulk);
     return $this;
   }
 
   /**
    * Use this method to set an ID used for message threading. MetaMTA will
    * set appropriate headers (Message-ID, In-Reply-To, References and
    * Thread-Index) based on the capabilities of the underlying mailer.
    *
    * @param string  Unique identifier, appropriate for use in a Message-ID,
    *                In-Reply-To or References headers.
    * @param bool    If true, indicates this is the first message in the thread.
    * @return this
    */
   public function setThreadID($thread_id, $is_first_message = false) {
     $this->setParam('thread-id', $thread_id);
     $this->setParam('is-first-message', $is_first_message);
     return $this;
   }
 
   /**
    * Save a newly created mail to the database. The mail will eventually be
    * delivered by the MetaMTA daemon.
    *
    * @return this
    */
   public function saveAndSend() {
     return $this->save();
   }
 
   public function save() {
     if ($this->getID()) {
       return parent::save();
     }
 
     // NOTE: When mail is sent from CLI scripts that run tasks in-process, we
     // may re-enter this method from within scheduleTask(). The implementation
     // is intended to avoid anything awkward if we end up reentering this
     // method.
 
     $this->openTransaction();
       // Save to generate a task ID.
       $result = parent::save();
 
       // Queue a task to send this mail.
       $mailer_task = PhabricatorWorker::scheduleTask(
         'PhabricatorMetaMTAWorker',
         $this->getID(),
         array(
           'priority' => PhabricatorWorker::PRIORITY_ALERTS,
         ));
 
     $this->saveTransaction();
 
     return $result;
   }
 
   public function buildDefaultMailer() {
     return PhabricatorEnv::newObjectFromConfig('metamta.mail-adapter');
   }
 
 
   /**
    * Attempt to deliver an email immediately, in this process.
    *
    * @param bool  Try to deliver this email even if it has already been
    *              delivered or is in backoff after a failed delivery attempt.
    * @param PhabricatorMailImplementationAdapter Use a specific mail adapter,
    *              instead of the default.
    *
    * @return void
    */
   public function sendNow(
     $force_send = false,
     PhabricatorMailImplementationAdapter $mailer = null) {
 
     if ($mailer === null) {
       $mailer = $this->buildDefaultMailer();
     }
 
     if (!$force_send) {
       if ($this->getStatus() != self::STATUS_QUEUE) {
         throw new Exception('Trying to send an already-sent mail!');
       }
     }
 
     try {
       $params = $this->parameters;
 
       $actors = $this->loadAllActors();
       $deliverable_actors = $this->filterDeliverableActors($actors);
 
       $default_from = PhabricatorEnv::getEnvConfig('metamta.default-address');
       if (empty($params['from'])) {
         $mailer->setFrom($default_from);
       }
 
       $is_first = idx($params, 'is-first-message');
       unset($params['is-first-message']);
 
       $is_threaded = (bool)idx($params, 'thread-id');
 
       $reply_to_name = idx($params, 'reply-to-name', '');
       unset($params['reply-to-name']);
 
       $add_cc = array();
       $add_to = array();
 
       // Only try to use preferences if everything is multiplexed, so we
       // get consistent behavior.
       $use_prefs = self::shouldMultiplexAllMail();
 
       $prefs = null;
       if ($use_prefs) {
 
         // If multiplexing is enabled, some recipients will be in "Cc"
         // rather than "To". We'll move them to "To" later (or supply a
         // dummy "To") but need to look for the recipient in either the
         // "To" or "Cc" fields here.
         $target_phid = head(idx($params, 'to', array()));
         if (!$target_phid) {
           $target_phid = head(idx($params, 'cc', array()));
         }
 
         if ($target_phid) {
           $user = id(new PhabricatorUser())->loadOneWhere(
             'phid = %s',
             $target_phid);
           if ($user) {
             $prefs = $user->loadPreferences();
           }
         }
       }
 
       foreach ($params as $key => $value) {
         switch ($key) {
           case 'raw-from':
             list($from_email, $from_name) = $value;
             $mailer->setFrom($from_email, $from_name);
             break;
           case 'from':
             $from = $value;
             $actor_email = null;
             $actor_name = null;
             $actor = idx($actors, $from);
             if ($actor) {
               $actor_email = $actor->getEmailAddress();
               $actor_name = $actor->getName();
             }
             $can_send_as_user = $actor_email &&
               PhabricatorEnv::getEnvConfig('metamta.can-send-as-user');
 
             if ($can_send_as_user) {
               $mailer->setFrom($actor_email, $actor_name);
             } else {
               $from_email = coalesce($actor_email, $default_from);
               $from_name = coalesce($actor_name, pht('Phabricator'));
 
               if (empty($params['reply-to'])) {
                 $params['reply-to'] = $from_email;
                 $params['reply-to-name'] = $from_name;
               }
 
               $mailer->setFrom($default_from, $from_name);
             }
             break;
           case 'reply-to':
             $mailer->addReplyTo($value, $reply_to_name);
             break;
           case 'to':
             $to_phids = $this->expandRecipients($value);
             $to_actors = array_select_keys($deliverable_actors, $to_phids);
             $add_to = array_merge(
               $add_to,
               mpull($to_actors, 'getEmailAddress'));
             break;
           case 'raw-to':
             $add_to = array_merge($add_to, $value);
             break;
           case 'cc':
             $cc_phids = $this->expandRecipients($value);
             $cc_actors = array_select_keys($deliverable_actors, $cc_phids);
             $add_cc = array_merge(
               $add_cc,
               mpull($cc_actors, 'getEmailAddress'));
             break;
           case 'headers':
             foreach ($value as $pair) {
               list($header_key, $header_value) = $pair;
 
               // NOTE: If we have \n in a header, SES rejects the email.
               $header_value = str_replace("\n", ' ', $header_value);
 
               $mailer->addHeader($header_key, $header_value);
             }
             break;
           case 'attachments':
             $value = $this->getAttachments();
             foreach ($value as $attachment) {
               $mailer->addAttachment(
                 $attachment->getData(),
                 $attachment->getFilename(),
                 $attachment->getMimeType());
             }
             break;
           case 'subject':
             $subject = array();
 
             if ($is_threaded) {
               $add_re = PhabricatorEnv::getEnvConfig('metamta.re-prefix');
 
               if ($prefs) {
                 $add_re = $prefs->getPreference(
                   PhabricatorUserPreferences::PREFERENCE_RE_PREFIX,
                   $add_re);
               }
 
               if ($add_re) {
                 $subject[] = 'Re:';
               }
             }
 
             $subject[] = trim(idx($params, 'subject-prefix'));
 
             $vary_prefix = idx($params, 'vary-subject-prefix');
             if ($vary_prefix != '') {
               $use_subject = PhabricatorEnv::getEnvConfig(
                 'metamta.vary-subjects');
 
               if ($prefs) {
                 $use_subject = $prefs->getPreference(
                   PhabricatorUserPreferences::PREFERENCE_VARY_SUBJECT,
                   $use_subject);
               }
 
               if ($use_subject) {
                 $subject[] = $vary_prefix;
               }
             }
 
             $subject[] = $value;
 
             $mailer->setSubject(implode(' ', array_filter($subject)));
             break;
           case 'is-bulk':
             if ($value) {
               if (PhabricatorEnv::getEnvConfig('metamta.precedence-bulk')) {
                 $mailer->addHeader('Precedence', 'bulk');
               }
             }
             break;
           case 'thread-id':
 
             // NOTE: Gmail freaks out about In-Reply-To and References which
             // aren't in the form "<string@domain.tld>"; this is also required
             // by RFC 2822, although some clients are more liberal in what they
             // accept.
             $domain = PhabricatorEnv::getEnvConfig('metamta.domain');
             $value = '<'.$value.'@'.$domain.'>';
 
             if ($is_first && $mailer->supportsMessageIDHeader()) {
               $mailer->addHeader('Message-ID',  $value);
             } else {
               $in_reply_to = $value;
               $references = array($value);
               $parent_id = $this->getParentMessageID();
               if ($parent_id) {
                 $in_reply_to = $parent_id;
                 // By RFC 2822, the most immediate parent should appear last
                 // in the "References" header, so this order is intentional.
                 $references[] = $parent_id;
               }
               $references = implode(' ', $references);
               $mailer->addHeader('In-Reply-To', $in_reply_to);
               $mailer->addHeader('References',  $references);
             }
             $thread_index = $this->generateThreadIndex($value, $is_first);
             $mailer->addHeader('Thread-Index', $thread_index);
             break;
           case 'mailtags':
             // Handled below.
             break;
           case 'subject-prefix':
           case 'vary-subject-prefix':
             // Handled above.
             break;
           default:
             // Just discard.
         }
       }
 
       $body = idx($params, 'body', '');
       $max = PhabricatorEnv::getEnvConfig('metamta.email-body-limit');
       if (strlen($body) > $max) {
         $body = id(new PhutilUTF8StringTruncator())
           ->setMaximumBytes($max)
           ->truncateString($body);
         $body .= "\n";
         $body .= pht('(This email was truncated at %d bytes.)', $max);
       }
       $mailer->setBody($body);
 
       $html_emails = false;
       if ($use_prefs && $prefs) {
         $html_emails = $prefs->getPreference(
           PhabricatorUserPreferences::PREFERENCE_HTML_EMAILS,
           $html_emails);
       }
 
       if ($html_emails && isset($params['html-body'])) {
         $mailer->setHTMLBody($params['html-body']);
       }
 
       if (!$add_to && !$add_cc) {
         $this->setStatus(self::STATUS_VOID);
         $this->setMessage(
           'Message has no valid recipients: all To/Cc are disabled, invalid, '.
           'or configured not to receive this mail.');
         return $this->save();
       }
 
       if ($this->getIsErrorEmail()) {
         $all_recipients = array_merge($add_to, $add_cc);
         if ($this->shouldRateLimitMail($all_recipients)) {
           $this->setStatus(self::STATUS_VOID);
           $this->setMessage(
             pht(
               'This is an error email, but one or more recipients have '.
               'exceeded the error email rate limit. Declining to deliver '.
               'message.'));
           return $this->save();
         }
       }
 
+      if (PhabricatorEnv::getEnvConfig('phabricator.silent')) {
+        $this->setStatus(self::STATUS_VOID);
+        $this->setMessage(
+          pht(
+            'Phabricator is running in silent mode. See `phabricator.silent` '.
+            'in the configuration to change this setting.'));
+        return $this->save();
+      }
+
       $mailer->addHeader('X-Phabricator-Sent-This-Message', 'Yes');
       $mailer->addHeader('X-Mail-Transport-Agent', 'MetaMTA');
 
       // Some clients respect this to suppress OOF and other auto-responses.
       $mailer->addHeader('X-Auto-Response-Suppress', 'All');
 
       // If the message has mailtags, filter out any recipients who don't want
       // to receive this type of mail.
       $mailtags = $this->getParam('mailtags');
       if ($mailtags) {
         $tag_header = array();
         foreach ($mailtags as $mailtag) {
           $tag_header[] = '<'.$mailtag.'>';
         }
         $tag_header = implode(', ', $tag_header);
         $mailer->addHeader('X-Phabricator-Mail-Tags', $tag_header);
       }
 
       // Some mailers require a valid "To:" in order to deliver mail. If we
       // don't have any "To:", try to fill it in with a placeholder "To:".
       // If that also fails, move the "Cc:" line to "To:".
       if (!$add_to) {
         $placeholder_key = 'metamta.placeholder-to-recipient';
         $placeholder = PhabricatorEnv::getEnvConfig($placeholder_key);
         if ($placeholder !== null) {
           $add_to = array($placeholder);
         } else {
           $add_to = $add_cc;
           $add_cc = array();
         }
       }
 
       $add_to = array_unique($add_to);
       $add_cc = array_diff(array_unique($add_cc), $add_to);
 
       $mailer->addTos($add_to);
       if ($add_cc) {
         $mailer->addCCs($add_cc);
       }
     } catch (Exception $ex) {
       $this
         ->setStatus(self::STATUS_FAIL)
         ->setMessage($ex->getMessage())
         ->save();
 
       throw $ex;
     }
 
     try {
       $ok = $mailer->send();
       if (!$ok) {
         // TODO: At some point, we should clean this up and make all mailers
         // throw.
         throw new Exception(
           pht('Mail adapter encountered an unexpected, unspecified failure.'));
       }
 
       $this->setStatus(self::STATUS_SENT);
       $this->save();
 
       return $this;
     } catch (PhabricatorMetaMTAPermanentFailureException $ex) {
       $this
         ->setStatus(self::STATUS_FAIL)
         ->setMessage($ex->getMessage())
         ->save();
 
       throw $ex;
     } catch (Exception $ex) {
       $this
         ->setMessage($ex->getMessage()."\n".$ex->getTraceAsString())
         ->save();
 
       throw $ex;
     }
   }
 
   public static function getReadableStatus($status_code) {
     static $readable = array(
       self::STATUS_QUEUE => 'Queued for Delivery',
       self::STATUS_FAIL  => 'Delivery Failed',
       self::STATUS_SENT  => 'Sent',
       self::STATUS_VOID  => 'Void',
     );
     $status_code = coalesce($status_code, '?');
     return idx($readable, $status_code, $status_code);
   }
 
   private function generateThreadIndex($seed, $is_first_mail) {
     // When threading, Outlook ignores the 'References' and 'In-Reply-To'
     // headers that most clients use. Instead, it uses a custom 'Thread-Index'
     // header. The format of this header is something like this (from
     // camel-exchange-folder.c in Evolution Exchange):
 
     /* A new post to a folder gets a 27-byte-long thread index. (The value
      * is apparently unique but meaningless.) Each reply to a post gets a
      * 32-byte-long thread index whose first 27 bytes are the same as the
      * parent's thread index. Each reply to any of those gets a
      * 37-byte-long thread index, etc. The Thread-Index header contains a
      * base64 representation of this value.
      */
 
     // The specific implementation uses a 27-byte header for the first email
     // a recipient receives, and a random 5-byte suffix (32 bytes total)
     // thereafter. This means that all the replies are (incorrectly) siblings,
     // but it would be very difficult to keep track of the entire tree and this
     // gets us reasonable client behavior.
 
     $base = substr(md5($seed), 0, 27);
     if (!$is_first_mail) {
       // Not totally sure, but it seems like outlook orders replies by
       // thread-index rather than timestamp, so to get these to show up in the
       // right order we use the time as the last 4 bytes.
       $base .= ' '.pack('N', time());
     }
 
     return base64_encode($base);
   }
 
   public static function shouldMultiplexAllMail() {
     return PhabricatorEnv::getEnvConfig('metamta.one-mail-per-recipient');
   }
 
 
 /* -(  Managing Recipients  )------------------------------------------------ */
 
 
   /**
    * Get all of the recipients for this mail, after preference filters are
    * applied. This list has all objects to whom delivery will be attempted.
    *
    * @return  list<phid>  A list of all recipients to whom delivery will be
    *                      attempted.
    * @task recipients
    */
   public function buildRecipientList() {
     $actors = $this->loadActors(
       array_merge(
         $this->getToPHIDs(),
         $this->getCcPHIDs()));
     $actors = $this->filterDeliverableActors($actors);
     return mpull($actors, 'getPHID');
   }
 
   public function loadAllActors() {
     $actor_phids = array_merge(
       array($this->getParam('from')),
       $this->getToPHIDs(),
       $this->getCcPHIDs());
 
     $this->loadRecipientExpansions($actor_phids);
     $actor_phids = $this->expandRecipients($actor_phids);
 
     return $this->loadActors($actor_phids);
   }
 
   private function loadRecipientExpansions(array $phids) {
     $expansions = id(new PhabricatorMetaMTAMemberQuery())
       ->setViewer(PhabricatorUser::getOmnipotentUser())
       ->withPHIDs($phids)
       ->execute();
 
     $this->recipientExpansionMap = $expansions;
 
     return $this;
   }
 
   /**
    * Expand a list of recipient PHIDs (possibly including aggregate recipients
    * like projects) into a deaggregated list of individual recipient PHIDs.
    * For example, this will expand project PHIDs into a list of the project's
    * members.
    *
    * @param list<phid>  List of recipient PHIDs, possibly including aggregate
    *                    recipients.
    * @return list<phid> Deaggregated list of mailable recipients.
    */
   private function expandRecipients(array $phids) {
     if ($this->recipientExpansionMap === null) {
       throw new Exception(
         pht(
           'Call loadRecipientExpansions() before expandRecipients()!'));
     }
 
     $results = array();
     foreach ($phids as $phid) {
       if (!isset($this->recipientExpansionMap[$phid])) {
         $results[$phid] = $phid;
       } else {
         foreach ($this->recipientExpansionMap[$phid] as $recipient_phid) {
           $results[$recipient_phid] = $recipient_phid;
         }
       }
     }
 
     return array_keys($results);
   }
 
   private function filterDeliverableActors(array $actors) {
     assert_instances_of($actors, 'PhabricatorMetaMTAActor');
     $deliverable_actors = array();
     foreach ($actors as $phid => $actor) {
       if ($actor->isDeliverable()) {
         $deliverable_actors[$phid] = $actor;
       }
     }
     return $deliverable_actors;
   }
 
   private function loadActors(array $actor_phids) {
     $actor_phids = array_filter($actor_phids);
     $viewer = PhabricatorUser::getOmnipotentUser();
 
     $actors = id(new PhabricatorMetaMTAActorQuery())
       ->setViewer($viewer)
       ->withPHIDs($actor_phids)
       ->execute();
 
     if (!$actors) {
       return array();
     }
 
     if ($this->getForceDelivery()) {
       // If we're forcing delivery, skip all the opt-out checks.
       return $actors;
     }
 
     // Exclude explicit recipients.
     foreach ($this->getExcludeMailRecipientPHIDs() as $phid) {
       $actor = idx($actors, $phid);
       if (!$actor) {
         continue;
       }
       $actor->setUndeliverable(
         pht(
           'This message is a response to another email message, and this '.
           'recipient received the original email message, so we are not '.
           'sending them this substantially similar message (for example, '.
           'the sender used "Reply All" instead of "Reply" in response to '.
           'mail from Phabricator).'));
     }
 
     // Exclude the actor if their preferences are set.
     $from_phid = $this->getParam('from');
     $from_actor = idx($actors, $from_phid);
     if ($from_actor) {
       $from_user = id(new PhabricatorPeopleQuery())
         ->setViewer($viewer)
         ->withPHIDs(array($from_phid))
         ->execute();
       $from_user = head($from_user);
       if ($from_user) {
         $pref_key = PhabricatorUserPreferences::PREFERENCE_NO_SELF_MAIL;
         $exclude_self = $from_user
           ->loadPreferences()
           ->getPreference($pref_key);
         if ($exclude_self) {
           $from_actor->setUndeliverable(
             pht(
               'This recipient is the user whose actions caused delivery of '.
               'this message, but they have set preferences so they do not '.
               'receive mail about their own actions (Settings > Email '.
               'Preferences > Self Actions).'));
         }
       }
     }
 
     $all_prefs = id(new PhabricatorUserPreferences())->loadAllWhere(
       'userPHID in (%Ls)',
       $actor_phids);
     $all_prefs = mpull($all_prefs, null, 'getUserPHID');
 
     // Exclude recipients who don't want any mail.
     foreach ($all_prefs as $phid => $prefs) {
       $exclude = $prefs->getPreference(
         PhabricatorUserPreferences::PREFERENCE_NO_MAIL,
         false);
       if ($exclude) {
         $actors[$phid]->setUndeliverable(
           pht(
             'This recipient has disabled all email notifications '.
             '(Settings > Email Preferences > Email Notifications).'));
       }
     }
 
     $value_email = PhabricatorUserPreferences::MAILTAG_PREFERENCE_EMAIL;
 
     // Exclude all recipients who have set preferences to not receive this type
     // of email (for example, a user who says they don't want emails about task
     // CC changes).
     $tags = $this->getParam('mailtags');
     if ($tags) {
       foreach ($all_prefs as $phid => $prefs) {
         $user_mailtags = $prefs->getPreference(
           PhabricatorUserPreferences::PREFERENCE_MAILTAGS,
           array());
 
         // The user must have elected to receive mail for at least one
         // of the mailtags.
         $send = false;
         foreach ($tags as $tag) {
           if (((int)idx($user_mailtags, $tag, $value_email)) == $value_email) {
             $send = true;
             break;
           }
         }
 
         if (!$send) {
           $actors[$phid]->setUndeliverable(
             pht(
               'This mail has tags which control which users receive it, and '.
               'this recipient has not elected to receive mail with any of '.
               'the tags on this message (Settings > Email Preferences).'));
         }
       }
     }
 
     return $actors;
   }
 
   private function shouldRateLimitMail(array $all_recipients) {
     try {
       PhabricatorSystemActionEngine::willTakeAction(
         $all_recipients,
         new PhabricatorMetaMTAErrorMailAction(),
         1);
       return false;
     } catch (PhabricatorSystemActionRateLimitException $ex) {
       return true;
     }
   }
 
 
 }
diff --git a/src/applications/repository/engine/PhabricatorRepositoryMirrorEngine.php b/src/applications/repository/engine/PhabricatorRepositoryMirrorEngine.php
index d73b2bed0f..8d3dd9f8f9 100644
--- a/src/applications/repository/engine/PhabricatorRepositoryMirrorEngine.php
+++ b/src/applications/repository/engine/PhabricatorRepositoryMirrorEngine.php
@@ -1,99 +1,105 @@
 <?php
 
 /**
  * Pushes a repository to its mirrors.
  */
 final class PhabricatorRepositoryMirrorEngine
   extends PhabricatorRepositoryEngine {
 
   public function pushToMirrors() {
     $repository = $this->getRepository();
 
     if (!$repository->canMirror()) {
       return;
     }
 
+    if (PhabricatorEnv::getEnvConfig('phabricator.silent')) {
+      $this->log(
+        pht('Phabricator is running in silent mode; declining to mirror.'));
+      return;
+    }
+
     $mirrors = id(new PhabricatorRepositoryMirrorQuery())
       ->setViewer($this->getViewer())
       ->withRepositoryPHIDs(array($repository->getPHID()))
       ->execute();
 
     $exceptions = array();
     foreach ($mirrors as $mirror) {
       try {
         $this->pushRepositoryToMirror($repository, $mirror);
       } catch (Exception $ex) {
         $exceptions[] = $ex;
       }
     }
 
     if ($exceptions) {
       throw new PhutilAggregateException(
         pht(
           'Exceptions occurred while mirroring the "%s" repository.',
           $repository->getCallsign()),
         $exceptions);
     }
   }
 
   private function pushRepositoryToMirror(
     PhabricatorRepository $repository,
     PhabricatorRepositoryMirror $mirror) {
 
     // TODO: This is a little bit janky, but we don't have first-class
     // infrastructure for running remote commands against an arbitrary remote
     // right now. Just make an emphemeral copy of the repository and muck with
     // it a little bit. In the medium term, we should pull this command stuff
     // out and use it here and for "Land to ...".
 
     $proxy = clone $repository;
     $proxy->makeEphemeral();
 
     $proxy->setDetail('hosting-enabled', false);
     $proxy->setDetail('remote-uri', $mirror->getRemoteURI());
     $proxy->setCredentialPHID($mirror->getCredentialPHID());
 
     $this->log(pht('Pushing to remote "%s"...', $mirror->getRemoteURI()));
 
     if ($proxy->isGit()) {
       $this->pushToGitRepository($proxy);
     } else if ($proxy->isHg()) {
       $this->pushToHgRepository($proxy);
     } else {
       throw new Exception(pht('Unsupported VCS!'));
     }
   }
 
   private function pushToGitRepository(
     PhabricatorRepository $proxy) {
 
     $future = $proxy->getRemoteCommandFuture(
       'push --verbose --mirror -- %P',
       $proxy->getRemoteURIEnvelope());
 
     $future
       ->setCWD($proxy->getLocalPath())
       ->resolvex();
   }
 
   private function pushToHgRepository(
     PhabricatorRepository $proxy) {
 
     $future = $proxy->getRemoteCommandFuture(
       'push --verbose --rev tip -- %P',
       $proxy->getRemoteURIEnvelope());
 
     try {
       $future
         ->setCWD($proxy->getLocalPath())
         ->resolvex();
     } catch (CommandException $ex) {
       if (preg_match('/no changes found/', $ex->getStdOut())) {
         // mercurial says nothing changed, but that's good
       } else {
         throw $ex;
       }
     }
   }
 
 }
diff --git a/src/infrastructure/sms/worker/PhabricatorSMSSendWorker.php b/src/infrastructure/sms/worker/PhabricatorSMSSendWorker.php
index fa56336809..0ee9aebb77 100644
--- a/src/infrastructure/sms/worker/PhabricatorSMSSendWorker.php
+++ b/src/infrastructure/sms/worker/PhabricatorSMSSendWorker.php
@@ -1,76 +1,85 @@
 <?php
 
 final class PhabricatorSMSSendWorker
   extends PhabricatorSMSWorker {
 
   public function getMaximumRetryCount() {
     return PhabricatorSMS::MAXIMUM_SEND_TRIES;
   }
 
   public function getWaitBeforeRetry(PhabricatorWorkerTask $task) {
     return phutil_units('1 minute in seconds');
   }
 
   protected function doWork() {
     $viewer = PhabricatorUser::getOmnipotentUser();
 
     $task_data = $this->getTaskData();
 
     $sms = id(new PhabricatorSMS())
       ->loadOneWhere('id = %d', $task_data['smsID']);
 
     if (!$sms) {
       throw new PhabricatorWorkerPermanentFailureException(
         pht('SMS object was not found.'));
     }
 
     // this has the potential to be updated asynchronously
     if ($sms->getSendStatus() == PhabricatorSMS::STATUS_SENT) {
       return;
     }
 
     $adapter = PhabricatorEnv::getEnvConfig('sms.default-adapter');
     $adapter = newv($adapter, array());
     if ($sms->hasBeenSentAtLeastOnce()) {
       $up_to_date_status = $adapter->pollSMSSentStatus($sms);
       if ($up_to_date_status) {
         $sms->setSendStatus($up_to_date_status);
         if ($up_to_date_status  == PhabricatorSMS::STATUS_SENT) {
           $sms->save();
           return;
         }
       }
       // TODO - re-jigger this so we can try if appropos (e.g. rate limiting)
       return;
     }
 
     $from_number = PhabricatorEnv::getEnvConfig('sms.default-sender');
     // always set the from number if we get this far in case of configuration
     // changes.
     $sms->setFromNumber($from_number);
 
     $adapter->setTo($sms->getToNumber());
     $adapter->setFrom($sms->getFromNumber());
     $adapter->setBody($sms->getBody());
     // give the provider name the same treatment as phone number
     $sms->setProviderShortName($adapter->getProviderShortName());
 
+    if (PhabricatorEnv::getEnvConfig('phabricator.silent')) {
+      $sms->setSendStatus(PhabricatorSMS::STATUS_FAILED_PERMANENTLY);
+      $sms->save();
+      throw new PhabricatorWorkerPermanentFailureException(
+        pht(
+          'Phabricator is running in silent mode. See `phabricator.silent` '.
+          'in the configuration to change this setting.'));
+    }
+
     try {
       $result = $adapter->send();
       list($sms_id, $sent_status) = $adapter->getSMSDataFromResult($result);
     } catch (PhabricatorWorkerPermanentFailureException $e) {
       $sms->setSendStatus(PhabricatorSMS::STATUS_FAILED_PERMANENTLY);
       $sms->save();
       throw $e;
     } catch (Exception $e) {
       $sms->setSendStatus(PhabricatorSMS::STATUS_FAILED_PERMANENTLY);
       $sms->save();
       throw new PhabricatorWorkerPermanentFailureException(
         $e->getMessage());
     }
     $sms->setProviderSMSID($sms_id);
     $sms->setSendStatus($sent_status);
     $sms->save();
   }
 
 }
diff --git a/src/infrastructure/testing/PhabricatorTestCase.php b/src/infrastructure/testing/PhabricatorTestCase.php
index 53950ddf73..2a2834c93f 100644
--- a/src/infrastructure/testing/PhabricatorTestCase.php
+++ b/src/infrastructure/testing/PhabricatorTestCase.php
@@ -1,229 +1,232 @@
 <?php
 
 abstract class PhabricatorTestCase extends ArcanistPhutilTestCase {
 
   const NAMESPACE_PREFIX = 'phabricator_unittest_';
 
   /**
    * If true, put Lisk in process-isolated mode for the duration of the tests so
    * that it will establish only isolated, side-effect-free database
    * connections. Defaults to true.
    *
    * NOTE: You should disable this only in rare circumstances. Unit tests should
    * not rely on external resources like databases, and should not produce
    * side effects.
    */
   const PHABRICATOR_TESTCONFIG_ISOLATE_LISK           = 'isolate-lisk';
 
   /**
    * If true, build storage fixtures before running tests, and connect to them
    * during test execution. This will impose a performance penalty on test
    * execution (currently, it takes roughly one second to build the fixture)
    * but allows you to perform tests which require data to be read from storage
    * after writes. The fixture is shared across all test cases in this process.
    * Defaults to false.
    *
    * NOTE: All connections to fixture storage open transactions when established
    * and roll them back when tests complete. Each test must independently
    * write data it relies on; data will not persist across tests.
    *
    * NOTE: Enabling this implies disabling process isolation.
    */
   const PHABRICATOR_TESTCONFIG_BUILD_STORAGE_FIXTURES = 'storage-fixtures';
 
   private $configuration;
   private $env;
 
   private static $storageFixtureReferences = 0;
   private static $storageFixture;
   private static $storageFixtureObjectSeed = 0;
   private static $testsAreRunning = 0;
 
   protected function getPhabricatorTestCaseConfiguration() {
     return array();
   }
 
   private function getComputedConfiguration() {
     $config = $this->getPhabricatorTestCaseConfiguration() + array(
       self::PHABRICATOR_TESTCONFIG_ISOLATE_LISK             => true,
       self::PHABRICATOR_TESTCONFIG_BUILD_STORAGE_FIXTURES   => false,
     );
 
     if ($config[self::PHABRICATOR_TESTCONFIG_BUILD_STORAGE_FIXTURES]) {
       // Fixtures don't make sense with process isolation.
       $config[self::PHABRICATOR_TESTCONFIG_ISOLATE_LISK] = false;
     }
 
     return $config;
   }
 
   public function willRunTestCases(array $test_cases) {
     $root = dirname(phutil_get_library_root('phabricator'));
     require_once $root.'/scripts/__init_script__.php';
 
     $config = $this->getComputedConfiguration();
 
     if ($config[self::PHABRICATOR_TESTCONFIG_BUILD_STORAGE_FIXTURES]) {
       ++self::$storageFixtureReferences;
       if (!self::$storageFixture) {
         self::$storageFixture = $this->newStorageFixture();
       }
     }
 
     ++self::$testsAreRunning;
   }
 
   public function didRunTestCases(array $test_cases) {
     if (self::$storageFixture) {
       self::$storageFixtureReferences--;
       if (!self::$storageFixtureReferences) {
         self::$storageFixture = null;
       }
     }
 
     --self::$testsAreRunning;
   }
 
   protected function willRunTests() {
     $config = $this->getComputedConfiguration();
 
     if ($config[self::PHABRICATOR_TESTCONFIG_ISOLATE_LISK]) {
       LiskDAO::beginIsolateAllLiskEffectsToCurrentProcess();
     }
 
     $this->env = PhabricatorEnv::beginScopedEnv();
 
     // NOTE: While running unit tests, we act as though all applications are
     // installed, regardless of the install's configuration. Tests which need
     // to uninstall applications are responsible for adjusting state themselves
     // (such tests are exceedingly rare).
 
     $this->env->overrideEnvConfig(
       'phabricator.uninstalled-applications',
       array());
     $this->env->overrideEnvConfig(
       'phabricator.show-prototypes',
       true);
 
     // Reset application settings to defaults, particularly policies.
     $this->env->overrideEnvConfig(
       'phabricator.application-settings',
       array());
 
     // We can't stub this service right now, and it's not generally useful
     // to publish notifications about test execution.
     $this->env->overrideEnvConfig(
       'notification.enabled',
       false);
 
     $this->env->overrideEnvConfig(
       'phabricator.base-uri',
       'http://phabricator.example.com');
+
+    // Tests do their own stubbing/voiding for events.
+    $this->env->overrideEnvConfig('phabricator.silent', false);
   }
 
   protected function didRunTests() {
     $config = $this->getComputedConfiguration();
 
     if ($config[self::PHABRICATOR_TESTCONFIG_ISOLATE_LISK]) {
       LiskDAO::endIsolateAllLiskEffectsToCurrentProcess();
     }
 
     try {
       if (phutil_is_hiphop_runtime()) {
         $this->env->__destruct();
       }
       unset($this->env);
     } catch (Exception $ex) {
       throw new Exception(
         'Some test called PhabricatorEnv::beginScopedEnv(), but is still '.
         'holding a reference to the scoped environment!');
     }
   }
 
   protected function willRunOneTest($test) {
     $config = $this->getComputedConfiguration();
 
     if ($config[self::PHABRICATOR_TESTCONFIG_BUILD_STORAGE_FIXTURES]) {
       LiskDAO::beginIsolateAllLiskEffectsToTransactions();
     }
   }
 
   protected function didRunOneTest($test) {
     $config = $this->getComputedConfiguration();
 
     if ($config[self::PHABRICATOR_TESTCONFIG_BUILD_STORAGE_FIXTURES]) {
       LiskDAO::endIsolateAllLiskEffectsToTransactions();
     }
   }
 
   protected function newStorageFixture() {
     $bytes = Filesystem::readRandomCharacters(24);
     $name = self::NAMESPACE_PREFIX.$bytes;
 
     return new PhabricatorStorageFixtureScopeGuard($name);
   }
 
   protected function getLink($method) {
     $phabricator_project = 'PHID-APRJ-3f1fc779edeab89b2171';
     return
       'https://secure.phabricator.com/diffusion/symbol/'.$method.
       '/?lang=php&projects='.$phabricator_project.
       '&jump=true&context='.get_class($this);
   }
 
   /**
    * Returns an integer seed to use when building unique identifiers (e.g.,
    * non-colliding usernames). The seed is unstable and its value will change
    * between test runs, so your tests must not rely on it.
    *
    * @return int A unique integer.
    */
   protected function getNextObjectSeed() {
     self::$storageFixtureObjectSeed += mt_rand(1, 100);
     return self::$storageFixtureObjectSeed;
   }
 
   protected function generateNewTestUser() {
     $seed = $this->getNextObjectSeed();
 
     $user = id(new PhabricatorUser())
       ->setRealName("Test User {$seed}}")
       ->setUserName("test{$seed}")
       ->setIsApproved(1);
 
     $email = id(new PhabricatorUserEmail())
       ->setAddress("testuser{$seed}@example.com")
       ->setIsVerified(1);
 
     $editor = new PhabricatorUserEditor();
     $editor->setActor($user);
     $editor->createNewUser($user, $email);
 
     return $user;
   }
 
 
   /**
    * Throws unless tests are currently executing. This method can be used to
    * guard code which is specific to unit tests and should not normally be
    * reachable.
    *
    * If tests aren't currently being executed, throws an exception.
    */
   public static function assertExecutingUnitTests() {
     if (!self::$testsAreRunning) {
       throw new Exception(
         'Executing test code outside of test execution! This code path can '.
         'only be run during unit tests.');
     }
   }
 
   protected function requireBinaryForTest($binary) {
     if (!Filesystem::binaryExists($binary)) {
       $this->assertSkipped(
         pht('No binary "%s" found on this system, skipping test.', $binary));
     }
   }
 
 
 }