diff --git a/.arclint b/.arclint
index f215d93fdc..29258b5d3e 100644
--- a/.arclint
+++ b/.arclint
@@ -1,85 +1,86 @@
 {
   "exclude": [
     "(^externals/)",
     "(^webroot/rsrc/externals/(?!javelin/))",
     "(/__tests__/data/)"
   ],
   "linters": {
     "chmod": {
       "type": "chmod"
     },
     "filename": {
       "type": "filename"
     },
     "generated": {
       "type": "generated"
     },
     "javelin": {
       "type": "javelin",
       "include": "(\\.js$)",
       "exclude": [
         "(^support/aphlict/)"
       ]
     },
     "jshint-browser": {
       "type": "jshint",
       "include": "(\\.js$)",
       "exclude": [
         "(^support/aphlict/server/.*\\.js$)",
         "(^webroot/rsrc/externals/javelin/core/init_node\\.js$)"
       ],
       "jshint.jshintrc": "support/lint/browser.jshintrc"
     },
     "jshint-node": {
       "type": "jshint",
       "include": [
         "(^support/aphlict/server/.*\\.js$)",
         "(^webroot/rsrc/externals/javelin/core/init_node\\.js$)"
       ],
       "jshint.jshintrc": "support/lint/node.jshintrc"
     },
     "json": {
       "type": "json",
       "include": [
         "(^src/docs/book/.*\\.book$)",
         "(^support/lint/jshintrc$)",
         "(^\\.arcconfig$)",
         "(^\\.arclint$)",
         "(\\.json$)"
       ]
     },
     "merge-conflict": {
       "type": "merge-conflict"
     },
     "nolint": {
       "type": "nolint"
     },
     "phutil-library": {
       "type": "phutil-library",
       "include": "(\\.php$)"
     },
     "spelling": {
       "type": "spelling"
     },
     "text": {
       "type": "text",
       "exclude": [
         "(^src/(.*/)?__tests__/[^/]+/.*\\.(txt|json|expect))"
       ]
     },
     "text-without-length": {
       "type": "text",
       "include": [
         "(^src/(.*/)?__tests__/[^/]+/.*\\.(txt|json|expect))"
       ],
       "severity": {
         "3": "disabled"
       }
     },
     "xhpast": {
       "type": "xhpast",
       "include": "(\\.php$)",
-      "standard": "phutil.xhpast"
+      "standard": "phutil.xhpast",
+      "xhpast.php-version": "5.5"
     }
   }
 }
diff --git a/scripts/sql/manage_storage.php b/scripts/sql/manage_storage.php
index ec3f492e8c..20e006f348 100755
--- a/scripts/sql/manage_storage.php
+++ b/scripts/sql/manage_storage.php
@@ -1,249 +1,249 @@
 #!/usr/bin/env php
 <?php
 
 $root = dirname(dirname(dirname(__FILE__)));
 require_once $root.'/scripts/init/init-setup.php';
 
 $args = new PhutilArgumentParser($argv);
 $args->setTagline(pht('manage Phabricator storage and schemata'));
 $args->setSynopsis(<<<EOHELP
 **storage** __workflow__ [__options__]
 Manage Phabricator database storage and schema versioning.
 
 **storage** upgrade
 Initialize or upgrade Phabricator storage.
 
 **storage** upgrade --user __root__ --password __hunter2__
 Use administrative credentials for schema changes.
 EOHELP
 );
 $args->parseStandardArguments();
 
 $default_namespace  = PhabricatorLiskDAO::getDefaultStorageNamespace();
 
 try {
   $args->parsePartial(
     array(
       array(
         'name'    => 'force',
         'short'   => 'f',
         'help'    => pht(
           'Do not prompt before performing dangerous operations.'),
       ),
       array(
         'name' => 'host',
         'param' => 'hostname',
         'help' => pht(
           'Operate on the database server identified by __hostname__.'),
       ),
       array(
         'name' => 'ref',
         'param' => 'ref',
         'help' => pht(
           'Operate on the database identified by __ref__.'),
       ),
       array(
         'name'    => 'user',
         'short'   => 'u',
         'param'   => 'username',
         'help'    => pht(
           'Connect with __username__ instead of the configured default.'),
       ),
       array(
         'name'    => 'password',
         'short'   => 'p',
         'param'   => 'password',
         'help'    => pht('Use __password__ instead of the configured default.'),
       ),
       array(
         'name'    => 'namespace',
         'param'   => 'name',
         'default' => $default_namespace,
         'help'    => pht(
           "Use namespace __namespace__ instead of the configured ".
           "default ('%s'). This is an advanced feature used by unit tests; ".
           "you should not normally use this flag.",
           $default_namespace),
       ),
       array(
         'name'    => 'dryrun',
         'help'    => pht(
           'Do not actually change anything, just show what would be changed.'),
       ),
       array(
         'name'    => 'disable-utf8mb4',
         'help'    => pht(
           'Disable %s, even if the database supports it. This is an '.
           'advanced feature used for testing changes to Phabricator; you '.
           'should not normally use this flag.',
           'utf8mb4'),
       ),
     ));
 } catch (PhutilArgumentUsageException $ex) {
   $args->printUsageException($ex);
   exit(77);
 }
 
 // First, test that the Phabricator configuration is set up correctly. After
 // we know this works we'll test any administrative credentials specifically.
 
 $refs = PhabricatorDatabaseRef::getActiveDatabaseRefs();
 if (!$refs) {
   throw new PhutilArgumentUsageException(
     pht('No databases are configured.'));
 }
 
 $host = $args->getArg('host');
 $ref_key = $args->getArg('ref');
-if (strlen($host) || strlen($ref_key)) {
+if (($host !== null) || ($ref_key !== null)) {
   if ($host && $ref_key) {
     throw new PhutilArgumentUsageException(
       pht(
         'Use "--host" or "--ref" to select a database, but not both.'));
   }
 
   $refs = PhabricatorDatabaseRef::getActiveDatabaseRefs();
 
   $possible_refs = array();
   foreach ($refs as $possible_ref) {
     if ($host && ($possible_ref->getHost() == $host)) {
       $possible_refs[] = $possible_ref;
       break;
     }
     if ($ref_key && ($possible_ref->getRefKey() == $ref_key)) {
       $possible_refs[] = $possible_ref;
       break;
     }
   }
 
   if (!$possible_refs) {
     if ($host) {
       throw new PhutilArgumentUsageException(
         pht(
           'There is no configured database on host "%s". This command can '.
           'only interact with configured databases.',
           $host));
     } else {
       throw new PhutilArgumentUsageException(
         pht(
           'There is no configured database with ref "%s". This command can '.
           'only interact with configured databases.',
           $ref_key));
     }
   }
 
   if (count($possible_refs) > 1) {
     throw new PhutilArgumentUsageException(
       pht(
         'Host "%s" identifies more than one database. Use "--ref" to select '.
         'a specific database.',
         $host));
   }
 
   $refs = $possible_refs;
 }
 
 $apis = array();
 foreach ($refs as $ref) {
   $default_user = $ref->getUser();
   $default_host = $ref->getHost();
   $default_port = $ref->getPort();
 
   $test_api = id(new PhabricatorStorageManagementAPI())
     ->setUser($default_user)
     ->setHost($default_host)
     ->setPort($default_port)
     ->setPassword($ref->getPass())
     ->setNamespace($args->getArg('namespace'));
 
   try {
     queryfx(
       $test_api->getConn(null),
       'SELECT 1');
   } catch (AphrontQueryException $ex) {
     $message = phutil_console_format(
       "**%s**\n\n%s\n\n%s\n\n%s\n\n**%s**: %s\n",
       pht('MySQL Credentials Not Configured'),
       pht(
         'Unable to connect to MySQL using the configured credentials. '.
         'You must configure standard credentials before you can upgrade '.
         'storage. Run these commands to set up credentials:'),
       "  phabricator/ $ ./bin/config set mysql.host __host__\n".
       "  phabricator/ $ ./bin/config set mysql.user __username__\n".
       "  phabricator/ $ ./bin/config set mysql.pass __password__",
       pht(
         'These standard credentials are separate from any administrative '.
         'credentials provided to this command with __%s__ or '.
         '__%s__, and must be configured correctly before you can proceed.',
         '--user',
         '--password'),
       pht('Raw MySQL Error'),
       $ex->getMessage());
     echo phutil_console_wrap($message);
     exit(1);
   }
 
   if ($args->getArg('password') === null) {
     // This is already a PhutilOpaqueEnvelope.
     $password = $ref->getPass();
   } else {
     // Put this in a PhutilOpaqueEnvelope.
     $password = new PhutilOpaqueEnvelope($args->getArg('password'));
     PhabricatorEnv::overrideConfig('mysql.pass', $args->getArg('password'));
   }
 
   $selected_user = $args->getArg('user');
   if ($selected_user === null) {
     $selected_user = $default_user;
   }
 
   $api = id(new PhabricatorStorageManagementAPI())
     ->setUser($selected_user)
     ->setHost($default_host)
     ->setPort($default_port)
     ->setPassword($password)
     ->setNamespace($args->getArg('namespace'))
     ->setDisableUTF8MB4($args->getArg('disable-utf8mb4'));
   PhabricatorEnv::overrideConfig('mysql.user', $api->getUser());
 
   $ref->setUser($selected_user);
   $ref->setPass($password);
 
   try {
     queryfx(
       $api->getConn(null),
       'SELECT 1');
   } catch (AphrontQueryException $ex) {
     $message = phutil_console_format(
       "**%s**\n\n%s\n\n**%s**: %s\n",
       pht('Bad Administrative Credentials'),
       pht(
         'Unable to connect to MySQL using the administrative credentials '.
         'provided with the __%s__ and __%s__ flags. Check that '.
         'you have entered them correctly.',
         '--user',
         '--password'),
       pht('Raw MySQL Error'),
       $ex->getMessage());
     echo phutil_console_wrap($message);
     exit(1);
   }
 
   $api->setRef($ref);
   $apis[] = $api;
 }
 
 $workflows = id(new PhutilClassMapQuery())
   ->setAncestorClass('PhabricatorStorageManagementWorkflow')
   ->execute();
 
 $patches = PhabricatorSQLPatchList::buildAllPatches();
 
 foreach ($workflows as $workflow) {
   $workflow->setAPIs($apis);
   $workflow->setPatches($patches);
 }
 
 $workflows[] = new PhutilHelpArgumentWorkflow();
 
 $args->parseWorkflows($workflows);
diff --git a/src/applications/files/engine/PhabricatorLocalDiskFileStorageEngine.php b/src/applications/files/engine/PhabricatorLocalDiskFileStorageEngine.php
index d9f7caf123..afed9f20b3 100644
--- a/src/applications/files/engine/PhabricatorLocalDiskFileStorageEngine.php
+++ b/src/applications/files/engine/PhabricatorLocalDiskFileStorageEngine.php
@@ -1,136 +1,137 @@
 <?php
 
 /**
  * Local disk storage engine. Keeps files on local disk. This engine is easy
  * to set up, but it doesn't work if you have multiple web frontends!
  *
  * @task internal Internals
  */
 final class PhabricatorLocalDiskFileStorageEngine
   extends PhabricatorFileStorageEngine {
 
 
 /* -(  Engine Metadata  )---------------------------------------------------- */
 
 
   /**
    * This engine identifies as "local-disk".
    */
   public function getEngineIdentifier() {
     return 'local-disk';
   }
 
   public function getEnginePriority() {
     return 5;
   }
 
   public function canWriteFiles() {
     $path = PhabricatorEnv::getEnvConfig('storage.local-disk.path');
+    $path = phutil_string_cast($path);
     return (bool)strlen($path);
   }
 
 
 /* -(  Managing File Data  )------------------------------------------------- */
 
 
   /**
    * Write the file data to local disk. Returns the relative path as the
    * file data handle.
    * @task impl
    */
   public function writeFile($data, array $params) {
     $root = $this->getLocalDiskFileStorageRoot();
 
     // Generate a random, unique file path like "ab/29/1f918a9ac39201ff". We
     // put a couple of subdirectories up front to avoid a situation where we
     // have one directory with a zillion files in it, since this is generally
     // bad news.
     do {
       $name = md5(mt_rand());
       $name = preg_replace('/^(..)(..)(.*)$/', '\\1/\\2/\\3', $name);
       if (!Filesystem::pathExists($root.'/'.$name)) {
         break;
       }
     } while (true);
 
     $parent = $root.'/'.dirname($name);
     if (!Filesystem::pathExists($parent)) {
       execx('mkdir -p %s', $parent);
     }
 
     AphrontWriteGuard::willWrite();
     Filesystem::writeFile($root.'/'.$name, $data);
 
     return $name;
   }
 
 
   /**
    * Read the file data off local disk.
    * @task impl
    */
   public function readFile($handle) {
     $path = $this->getLocalDiskFileStorageFullPath($handle);
     return Filesystem::readFile($path);
   }
 
 
   /**
    * Deletes the file from local disk, if it exists.
    * @task impl
    */
   public function deleteFile($handle) {
     $path = $this->getLocalDiskFileStorageFullPath($handle);
     if (Filesystem::pathExists($path)) {
       AphrontWriteGuard::willWrite();
       Filesystem::remove($path);
     }
   }
 
 
 /* -(  Internals  )---------------------------------------------------------- */
 
 
   /**
    * Get the configured local disk path for file storage.
    *
    * @return string Absolute path to somewhere that files can be stored.
    * @task internal
    */
   private function getLocalDiskFileStorageRoot() {
     $root = PhabricatorEnv::getEnvConfig('storage.local-disk.path');
 
     if (!$root || $root == '/' || $root[0] != '/') {
       throw new PhabricatorFileStorageConfigurationException(
         pht(
           "Malformed local disk storage root. You must provide an absolute ".
           "path, and can not use '%s' as the root.",
           '/'));
     }
 
     return rtrim($root, '/');
   }
 
 
   /**
    * Convert a handle into an absolute local disk path.
    *
    * @param string File data handle.
    * @return string Absolute path to the corresponding file.
    * @task internal
    */
   private function getLocalDiskFileStorageFullPath($handle) {
     // Make sure there's no funny business going on here. Users normally have
     // no ability to affect the content of handles, but double-check that
     // we're only accessing local storage just in case.
     if (!preg_match('@^[a-f0-9]{2}/[a-f0-9]{2}/[a-f0-9]{28}\z@', $handle)) {
       throw new Exception(
         pht(
           "Local disk filesystem handle '%s' is malformed!",
           $handle));
     }
     $root = $this->getLocalDiskFileStorageRoot();
     return $root.'/'.$handle;
   }
 
 }
diff --git a/src/applications/meta/query/PhabricatorApplicationQuery.php b/src/applications/meta/query/PhabricatorApplicationQuery.php
index 63de1174cf..ff9aa5539a 100644
--- a/src/applications/meta/query/PhabricatorApplicationQuery.php
+++ b/src/applications/meta/query/PhabricatorApplicationQuery.php
@@ -1,173 +1,173 @@
 <?php
 
 final class PhabricatorApplicationQuery
   extends PhabricatorCursorPagedPolicyAwareQuery {
 
   private $installed;
   private $prototypes;
   private $firstParty;
   private $nameContains;
   private $unlisted;
   private $classes;
   private $launchable;
   private $applicationEmailSupport;
   private $phids;
 
   const ORDER_APPLICATION = 'order:application';
   const ORDER_NAME = 'order:name';
 
   private $order = self::ORDER_APPLICATION;
 
   public function withNameContains($name_contains) {
     $this->nameContains = $name_contains;
     return $this;
   }
 
   public function withInstalled($installed) {
     $this->installed = $installed;
     return $this;
   }
 
   public function withPrototypes($prototypes) {
     $this->prototypes = $prototypes;
     return $this;
   }
 
   public function withFirstParty($first_party) {
     $this->firstParty = $first_party;
     return $this;
   }
 
   public function withUnlisted($unlisted) {
     $this->unlisted = $unlisted;
     return $this;
   }
 
   public function withLaunchable($launchable) {
     $this->launchable = $launchable;
     return $this;
   }
 
   public function withApplicationEmailSupport($appemails) {
     $this->applicationEmailSupport = $appemails;
     return $this;
   }
 
   public function withClasses(array $classes) {
     $this->classes = $classes;
     return $this;
   }
 
   public function withPHIDs(array $phids) {
     $this->phids = $phids;
     return $this;
   }
 
   public function setOrder($order) {
     $this->order = $order;
     return $this;
   }
 
   protected function loadPage() {
     $apps = PhabricatorApplication::getAllApplications();
 
     if ($this->classes) {
       $classes = array_fuse($this->classes);
       foreach ($apps as $key => $app) {
         if (empty($classes[get_class($app)])) {
           unset($apps[$key]);
         }
       }
     }
 
     if ($this->phids) {
       $phids = array_fuse($this->phids);
       foreach ($apps as $key => $app) {
         if (empty($phids[$app->getPHID()])) {
           unset($apps[$key]);
         }
       }
     }
 
-    if (strlen($this->nameContains)) {
+    if ($this->nameContains !== null) {
       foreach ($apps as $key => $app) {
         if (stripos($app->getName(), $this->nameContains) === false) {
           unset($apps[$key]);
         }
       }
     }
 
     if ($this->installed !== null) {
       foreach ($apps as $key => $app) {
         if ($app->isInstalled() != $this->installed) {
           unset($apps[$key]);
         }
       }
     }
 
     if ($this->prototypes !== null) {
       foreach ($apps as $key => $app) {
         if ($app->isPrototype() != $this->prototypes) {
           unset($apps[$key]);
         }
       }
     }
 
     if ($this->firstParty !== null) {
       foreach ($apps as $key => $app) {
         if ($app->isFirstParty() != $this->firstParty) {
           unset($apps[$key]);
         }
       }
     }
 
     if ($this->unlisted !== null) {
       foreach ($apps as $key => $app) {
         if ($app->isUnlisted() != $this->unlisted) {
           unset($apps[$key]);
         }
       }
     }
 
     if ($this->launchable !== null) {
       foreach ($apps as $key => $app) {
         if ($app->isLaunchable() != $this->launchable) {
           unset($apps[$key]);
         }
       }
     }
 
     if ($this->applicationEmailSupport !== null) {
       foreach ($apps as $key => $app) {
         if ($app->supportsEmailIntegration() !=
             $this->applicationEmailSupport) {
           unset($apps[$key]);
         }
       }
     }
 
     switch ($this->order) {
       case self::ORDER_NAME:
         $apps = msort($apps, 'getName');
         break;
       case self::ORDER_APPLICATION:
         $apps = $apps;
         break;
       default:
         throw new Exception(
           pht('Unknown order "%s"!', $this->order));
     }
 
     return $apps;
   }
 
 
   public function getQueryApplicationClass() {
     // NOTE: Although this belongs to the "Applications" application, trying
     // to filter its results just leaves us recursing indefinitely. Users
     // always have access to applications regardless of other policy settings
     // anyway.
     return null;
   }
 
 }
diff --git a/src/applications/people/query/PhabricatorPeopleQuery.php b/src/applications/people/query/PhabricatorPeopleQuery.php
index 5e737aaf90..e122be0b2e 100644
--- a/src/applications/people/query/PhabricatorPeopleQuery.php
+++ b/src/applications/people/query/PhabricatorPeopleQuery.php
@@ -1,634 +1,634 @@
 <?php
 
 final class PhabricatorPeopleQuery
   extends PhabricatorCursorPagedPolicyAwareQuery {
 
   private $usernames;
   private $realnames;
   private $emails;
   private $phids;
   private $ids;
   private $dateCreatedAfter;
   private $dateCreatedBefore;
   private $isAdmin;
   private $isSystemAgent;
   private $isMailingList;
   private $isDisabled;
   private $isApproved;
   private $nameLike;
   private $nameTokens;
   private $namePrefixes;
   private $isEnrolledInMultiFactor;
 
   private $needPrimaryEmail;
   private $needProfile;
   private $needProfileImage;
   private $needAvailability;
   private $needBadgeAwards;
   private $cacheKeys = array();
 
   public function withIDs(array $ids) {
     $this->ids = $ids;
     return $this;
   }
 
   public function withPHIDs(array $phids) {
     $this->phids = $phids;
     return $this;
   }
 
   public function withEmails(array $emails) {
     $this->emails = $emails;
     return $this;
   }
 
   public function withRealnames(array $realnames) {
     $this->realnames = $realnames;
     return $this;
   }
 
   public function withUsernames(array $usernames) {
     $this->usernames = $usernames;
     return $this;
   }
 
   public function withDateCreatedBefore($date_created_before) {
     $this->dateCreatedBefore = $date_created_before;
     return $this;
   }
 
   public function withDateCreatedAfter($date_created_after) {
     $this->dateCreatedAfter = $date_created_after;
     return $this;
   }
 
   public function withIsAdmin($admin) {
     $this->isAdmin = $admin;
     return $this;
   }
 
   public function withIsSystemAgent($system_agent) {
     $this->isSystemAgent = $system_agent;
     return $this;
   }
 
   public function withIsMailingList($mailing_list) {
     $this->isMailingList = $mailing_list;
     return $this;
   }
 
   public function withIsDisabled($disabled) {
     $this->isDisabled = $disabled;
     return $this;
   }
 
   public function withIsApproved($approved) {
     $this->isApproved = $approved;
     return $this;
   }
 
   public function withNameLike($like) {
     $this->nameLike = $like;
     return $this;
   }
 
   public function withNameTokens(array $tokens) {
     $this->nameTokens = array_values($tokens);
     return $this;
   }
 
   public function withNamePrefixes(array $prefixes) {
     $this->namePrefixes = $prefixes;
     return $this;
   }
 
   public function withIsEnrolledInMultiFactor($enrolled) {
     $this->isEnrolledInMultiFactor = $enrolled;
     return $this;
   }
 
   public function needPrimaryEmail($need) {
     $this->needPrimaryEmail = $need;
     return $this;
   }
 
   public function needProfile($need) {
     $this->needProfile = $need;
     return $this;
   }
 
   public function needProfileImage($need) {
     $cache_key = PhabricatorUserProfileImageCacheType::KEY_URI;
 
     if ($need) {
       $this->cacheKeys[$cache_key] = true;
     } else {
       unset($this->cacheKeys[$cache_key]);
     }
 
     return $this;
   }
 
   public function needAvailability($need) {
     $this->needAvailability = $need;
     return $this;
   }
 
   public function needUserSettings($need) {
     $cache_key = PhabricatorUserPreferencesCacheType::KEY_PREFERENCES;
 
     if ($need) {
       $this->cacheKeys[$cache_key] = true;
     } else {
       unset($this->cacheKeys[$cache_key]);
     }
 
     return $this;
   }
 
   public function needBadgeAwards($need) {
     $cache_key = PhabricatorUserBadgesCacheType::KEY_BADGES;
 
     if ($need) {
       $this->cacheKeys[$cache_key] = true;
     } else {
       unset($this->cacheKeys[$cache_key]);
     }
 
     return $this;
   }
 
   public function newResultObject() {
     return new PhabricatorUser();
   }
 
   protected function loadPage() {
     return $this->loadStandardPage($this->newResultObject());
   }
 
   protected function didFilterPage(array $users) {
     if ($this->needProfile) {
       $user_list = mpull($users, null, 'getPHID');
       $profiles = new PhabricatorUserProfile();
       $profiles = $profiles->loadAllWhere(
         'userPHID IN (%Ls)',
         array_keys($user_list));
 
       $profiles = mpull($profiles, null, 'getUserPHID');
       foreach ($user_list as $user_phid => $user) {
         $profile = idx($profiles, $user_phid);
 
         if (!$profile) {
           $profile = PhabricatorUserProfile::initializeNewProfile($user);
         }
 
         $user->attachUserProfile($profile);
       }
     }
 
     if ($this->needAvailability) {
       $rebuild = array();
       foreach ($users as $user) {
         $cache = $user->getAvailabilityCache();
         if ($cache !== null) {
           $user->attachAvailability($cache);
         } else {
           $rebuild[] = $user;
         }
       }
 
       if ($rebuild) {
         $this->rebuildAvailabilityCache($rebuild);
       }
     }
 
     $this->fillUserCaches($users);
 
     return $users;
   }
 
   protected function shouldGroupQueryResultRows() {
     if ($this->nameTokens) {
       return true;
     }
 
     return parent::shouldGroupQueryResultRows();
   }
 
   protected function buildJoinClauseParts(AphrontDatabaseConnection $conn) {
     $joins = parent::buildJoinClauseParts($conn);
 
     if ($this->emails) {
       $email_table = new PhabricatorUserEmail();
       $joins[] = qsprintf(
         $conn,
         'JOIN %T email ON email.userPHID = user.PHID',
         $email_table->getTableName());
     }
 
     if ($this->nameTokens) {
       foreach ($this->nameTokens as $key => $token) {
         $token_table = 'token_'.$key;
         $joins[] = qsprintf(
           $conn,
           'JOIN %T %T ON %T.userID = user.id AND %T.token LIKE %>',
           PhabricatorUser::NAMETOKEN_TABLE,
           $token_table,
           $token_table,
           $token_table,
           $token);
       }
     }
 
     return  $joins;
   }
 
   protected function buildWhereClauseParts(AphrontDatabaseConnection $conn) {
     $where = parent::buildWhereClauseParts($conn);
 
     if ($this->usernames !== null) {
       $where[] = qsprintf(
         $conn,
         'user.userName IN (%Ls)',
         $this->usernames);
     }
 
     if ($this->namePrefixes) {
       $parts = array();
       foreach ($this->namePrefixes as $name_prefix) {
         $parts[] = qsprintf(
           $conn,
           'user.username LIKE %>',
           $name_prefix);
       }
       $where[] = qsprintf($conn, '%LO', $parts);
     }
 
     if ($this->emails !== null) {
       $where[] = qsprintf(
         $conn,
         'email.address IN (%Ls)',
         $this->emails);
     }
 
     if ($this->realnames !== null) {
       $where[] = qsprintf(
         $conn,
         'user.realName IN (%Ls)',
         $this->realnames);
     }
 
     if ($this->phids !== null) {
       $where[] = qsprintf(
         $conn,
         'user.phid IN (%Ls)',
         $this->phids);
     }
 
     if ($this->ids !== null) {
       $where[] = qsprintf(
         $conn,
         'user.id IN (%Ld)',
         $this->ids);
     }
 
     if ($this->dateCreatedAfter) {
       $where[] = qsprintf(
         $conn,
         'user.dateCreated >= %d',
         $this->dateCreatedAfter);
     }
 
     if ($this->dateCreatedBefore) {
       $where[] = qsprintf(
         $conn,
         'user.dateCreated <= %d',
         $this->dateCreatedBefore);
     }
 
     if ($this->isAdmin !== null) {
       $where[] = qsprintf(
         $conn,
         'user.isAdmin = %d',
         (int)$this->isAdmin);
     }
 
     if ($this->isDisabled !== null) {
       $where[] = qsprintf(
         $conn,
         'user.isDisabled = %d',
         (int)$this->isDisabled);
     }
 
     if ($this->isApproved !== null) {
       $where[] = qsprintf(
         $conn,
         'user.isApproved = %d',
         (int)$this->isApproved);
     }
 
     if ($this->isSystemAgent !== null) {
       $where[] = qsprintf(
         $conn,
         'user.isSystemAgent = %d',
         (int)$this->isSystemAgent);
     }
 
     if ($this->isMailingList !== null) {
       $where[] = qsprintf(
         $conn,
         'user.isMailingList = %d',
         (int)$this->isMailingList);
     }
 
-    if (strlen($this->nameLike)) {
+    if ($this->nameLike !== null) {
       $where[] = qsprintf(
         $conn,
         'user.username LIKE %~ OR user.realname LIKE %~',
         $this->nameLike,
         $this->nameLike);
     }
 
     if ($this->isEnrolledInMultiFactor !== null) {
       $where[] = qsprintf(
         $conn,
         'user.isEnrolledInMultiFactor = %d',
         (int)$this->isEnrolledInMultiFactor);
     }
 
     return $where;
   }
 
   protected function getPrimaryTableAlias() {
     return 'user';
   }
 
   public function getQueryApplicationClass() {
     return 'PhabricatorPeopleApplication';
   }
 
   public function getOrderableColumns() {
     return parent::getOrderableColumns() + array(
       'username' => array(
         'table' => 'user',
         'column' => 'username',
         'type' => 'string',
         'reverse' => true,
         'unique' => true,
       ),
     );
   }
 
   protected function newPagingMapFromPartialObject($object) {
     return array(
       'id' => (int)$object->getID(),
       'username' => $object->getUsername(),
     );
   }
 
   private function rebuildAvailabilityCache(array $rebuild) {
     $rebuild = mpull($rebuild, null, 'getPHID');
 
     // Limit the window we look at because far-future events are largely
     // irrelevant and this makes the cache cheaper to build and allows it to
     // self-heal over time.
     $min_range = PhabricatorTime::getNow();
     $max_range = $min_range + phutil_units('72 hours in seconds');
 
     // NOTE: We don't need to generate ghosts here, because we only care if
     // the user is attending, and you can't attend a ghost event: RSVP'ing
     // to it creates a real event.
 
     $events = id(new PhabricatorCalendarEventQuery())
       ->setViewer(PhabricatorUser::getOmnipotentUser())
       ->withInvitedPHIDs(array_keys($rebuild))
       ->withIsCancelled(false)
       ->withDateRange($min_range, $max_range)
       ->execute();
 
     // Group all the events by invited user. Only examine events that users
     // are actually attending.
     $map = array();
     $invitee_map = array();
     foreach ($events as $event) {
       foreach ($event->getInvitees() as $invitee) {
         if (!$invitee->isAttending()) {
           continue;
         }
 
         // If the user is set to "Available" for this event, don't consider it
         // when computing their away status.
         if (!$invitee->getDisplayAvailability($event)) {
           continue;
         }
 
         $invitee_phid = $invitee->getInviteePHID();
         if (!isset($rebuild[$invitee_phid])) {
           continue;
         }
 
         $map[$invitee_phid][] = $event;
 
         $event_phid = $event->getPHID();
         $invitee_map[$invitee_phid][$event_phid] = $invitee;
       }
     }
 
     // We need to load these users' timezone settings to figure out their
     // availability if they're attending all-day events.
     $this->needUserSettings(true);
     $this->fillUserCaches($rebuild);
 
     foreach ($rebuild as $phid => $user) {
       $events = idx($map, $phid, array());
 
       // We loaded events with the omnipotent user, but want to shift them
       // into the user's timezone before building the cache because they will
       // be unavailable during their own local day.
       foreach ($events as $event) {
         $event->applyViewerTimezone($user);
       }
 
       $cursor = $min_range;
       $next_event = null;
       if ($events) {
         // Find the next time when the user has no meetings. If we move forward
         // because of an event, we check again for events after that one ends.
         while (true) {
           foreach ($events as $event) {
             $from = $event->getStartDateTimeEpochForCache();
             $to = $event->getEndDateTimeEpochForCache();
             if (($from <= $cursor) && ($to > $cursor)) {
               $cursor = $to;
               if (!$next_event) {
                 $next_event = $event;
               }
               continue 2;
             }
           }
           break;
         }
       }
 
       if ($cursor > $min_range) {
         $invitee = $invitee_map[$phid][$next_event->getPHID()];
         $availability_type = $invitee->getDisplayAvailability($next_event);
         $availability = array(
           'until' => $cursor,
           'eventPHID' => $next_event->getPHID(),
           'availability' => $availability_type,
         );
 
         // We only cache this availability until the end of the current event,
         // since the event PHID (and possibly the availability type) are only
         // valid for that long.
 
         // NOTE: This doesn't handle overlapping events with the greatest
         // possible care. In theory, if you're attending multiple events
         // simultaneously we should accommodate that. However, it's complex
         // to compute, rare, and probably not confusing most of the time.
 
         $availability_ttl = $next_event->getEndDateTimeEpochForCache();
       } else {
         $availability = array(
           'until' => null,
           'eventPHID' => null,
           'availability' => null,
         );
 
         // Cache that the user is available until the next event they are
         // invited to starts.
         $availability_ttl = $max_range;
         foreach ($events as $event) {
           $from = $event->getStartDateTimeEpochForCache();
           if ($from > $cursor) {
             $availability_ttl = min($from, $availability_ttl);
           }
         }
       }
 
       // Never TTL the cache to longer than the maximum range we examined.
       $availability_ttl = min($availability_ttl, $max_range);
 
       $user->writeAvailabilityCache($availability, $availability_ttl);
       $user->attachAvailability($availability);
     }
   }
 
   private function fillUserCaches(array $users) {
     if (!$this->cacheKeys) {
       return;
     }
 
     $user_map = mpull($users, null, 'getPHID');
     $keys = array_keys($this->cacheKeys);
 
     $hashes = array();
     foreach ($keys as $key) {
       $hashes[] = PhabricatorHash::digestForIndex($key);
     }
 
     $types = PhabricatorUserCacheType::getAllCacheTypes();
 
     // First, pull any available caches. If we wanted to be particularly clever
     // we could do this with JOINs in the main query.
 
     $cache_table = new PhabricatorUserCache();
     $cache_conn = $cache_table->establishConnection('r');
 
     $cache_data = queryfx_all(
       $cache_conn,
       'SELECT cacheKey, userPHID, cacheData, cacheType FROM %T
         WHERE cacheIndex IN (%Ls) AND userPHID IN (%Ls)',
       $cache_table->getTableName(),
       $hashes,
       array_keys($user_map));
 
     $skip_validation = array();
 
     // After we read caches from the database, discard any which have data that
     // invalid or out of date. This allows cache types to implement TTLs or
     // versions instead of or in addition to explicit cache clears.
     foreach ($cache_data as $row_key => $row) {
       $cache_type = $row['cacheType'];
 
       if (isset($skip_validation[$cache_type])) {
         continue;
       }
 
       if (empty($types[$cache_type])) {
         unset($cache_data[$row_key]);
         continue;
       }
 
       $type = $types[$cache_type];
       if (!$type->shouldValidateRawCacheData()) {
         $skip_validation[$cache_type] = true;
         continue;
       }
 
       $user = $user_map[$row['userPHID']];
       $raw_data = $row['cacheData'];
       if (!$type->isRawCacheDataValid($user, $row['cacheKey'], $raw_data)) {
         unset($cache_data[$row_key]);
         continue;
       }
     }
 
     $need = array();
 
     $cache_data = igroup($cache_data, 'userPHID');
     foreach ($user_map as $user_phid => $user) {
       $raw_rows = idx($cache_data, $user_phid, array());
       $raw_data = ipull($raw_rows, 'cacheData', 'cacheKey');
 
       foreach ($keys as $key) {
         if (isset($raw_data[$key]) || array_key_exists($key, $raw_data)) {
           continue;
         }
         $need[$key][$user_phid] = $user;
       }
 
       $user->attachRawCacheData($raw_data);
     }
 
     // If we missed any cache values, bulk-construct them now. This is
     // usually much cheaper than generating them on-demand for each user
     // record.
 
     if (!$need) {
       return;
     }
 
     $writes = array();
     foreach ($need as $cache_key => $need_users) {
       $type = PhabricatorUserCacheType::getCacheTypeForKey($cache_key);
       if (!$type) {
         continue;
       }
 
       $data = $type->newValueForUsers($cache_key, $need_users);
 
       foreach ($data as $user_phid => $raw_value) {
         $data[$user_phid] = $raw_value;
         $writes[] = array(
           'userPHID' => $user_phid,
           'key' => $cache_key,
           'type' => $type,
           'value' => $raw_value,
         );
       }
 
       foreach ($need_users as $user_phid => $user) {
         if (isset($data[$user_phid]) || array_key_exists($user_phid, $data)) {
           $user->attachRawCacheData(
             array(
               $cache_key => $data[$user_phid],
             ));
         }
       }
     }
 
     PhabricatorUserCache::writeCaches($writes);
   }
 }
diff --git a/src/applications/people/storage/PhabricatorUser.php b/src/applications/people/storage/PhabricatorUser.php
index fa6dc08e9f..7276253085 100644
--- a/src/applications/people/storage/PhabricatorUser.php
+++ b/src/applications/people/storage/PhabricatorUser.php
@@ -1,1462 +1,1463 @@
 <?php
 
 /**
  * @task availability Availability
  * @task image-cache Profile Image Cache
  * @task factors Multi-Factor Authentication
  * @task handles Managing Handles
  * @task settings Settings
  * @task cache User Cache
  */
 final class PhabricatorUser
   extends PhabricatorUserDAO
   implements
     PhutilPerson,
     PhabricatorPolicyInterface,
     PhabricatorCustomFieldInterface,
     PhabricatorDestructibleInterface,
     PhabricatorSSHPublicKeyInterface,
     PhabricatorFlaggableInterface,
     PhabricatorApplicationTransactionInterface,
     PhabricatorFulltextInterface,
     PhabricatorFerretInterface,
     PhabricatorConduitResultInterface,
     PhabricatorAuthPasswordHashInterface {
 
   const SESSION_TABLE = 'phabricator_session';
   const NAMETOKEN_TABLE = 'user_nametoken';
   const MAXIMUM_USERNAME_LENGTH = 64;
 
   protected $userName;
   protected $realName;
   protected $profileImagePHID;
   protected $defaultProfileImagePHID;
   protected $defaultProfileImageVersion;
   protected $availabilityCache;
   protected $availabilityCacheTTL;
 
   protected $conduitCertificate;
 
   protected $isSystemAgent = 0;
   protected $isMailingList = 0;
   protected $isAdmin = 0;
   protected $isDisabled = 0;
   protected $isEmailVerified = 0;
   protected $isApproved = 0;
   protected $isEnrolledInMultiFactor = 0;
 
   protected $accountSecret;
 
   private $profile = null;
   private $availability = self::ATTACHABLE;
   private $preferences = null;
   private $omnipotent = false;
   private $customFields = self::ATTACHABLE;
   private $badgePHIDs = self::ATTACHABLE;
 
   private $alternateCSRFString = self::ATTACHABLE;
   private $session = self::ATTACHABLE;
   private $rawCacheData = array();
   private $usableCacheData = array();
 
   private $handlePool;
   private $csrfSalt;
 
   private $settingCacheKeys = array();
   private $settingCache = array();
   private $allowInlineCacheGeneration;
   private $conduitClusterToken = self::ATTACHABLE;
 
   protected function readField($field) {
     switch ($field) {
       // Make sure these return booleans.
       case 'isAdmin':
         return (bool)$this->isAdmin;
       case 'isDisabled':
         return (bool)$this->isDisabled;
       case 'isSystemAgent':
         return (bool)$this->isSystemAgent;
       case 'isMailingList':
         return (bool)$this->isMailingList;
       case 'isEmailVerified':
         return (bool)$this->isEmailVerified;
       case 'isApproved':
         return (bool)$this->isApproved;
       default:
         return parent::readField($field);
     }
   }
 
 
   /**
    * Is this a live account which has passed required approvals? Returns true
    * if this is an enabled, verified (if required), approved (if required)
    * account, and false otherwise.
    *
    * @return bool True if this is a standard, usable account.
    */
   public function isUserActivated() {
     if (!$this->isLoggedIn()) {
       return false;
     }
 
     if ($this->isOmnipotent()) {
       return true;
     }
 
     if ($this->getIsDisabled()) {
       return false;
     }
 
     if (!$this->getIsApproved()) {
       return false;
     }
 
     if (PhabricatorUserEmail::isEmailVerificationRequired()) {
       if (!$this->getIsEmailVerified()) {
         return false;
       }
     }
 
     return true;
   }
 
 
   /**
    * Is this a user who we can reasonably expect to respond to requests?
    *
    * This is used to provide a grey "disabled/unresponsive" dot cue when
    * rendering handles and tags, so it isn't a surprise if you get ignored
    * when you ask things of users who will not receive notifications or could
    * not respond to them (because they are disabled, unapproved, do not have
    * verified email addresses, etc).
    *
    * @return bool True if this user can receive and respond to requests from
    *   other humans.
    */
   public function isResponsive() {
     if (!$this->isUserActivated()) {
       return false;
     }
 
     if (!$this->getIsEmailVerified()) {
       return false;
     }
 
     return true;
   }
 
 
   public function canEstablishWebSessions() {
     if ($this->getIsMailingList()) {
       return false;
     }
 
     if ($this->getIsSystemAgent()) {
       return false;
     }
 
     return true;
   }
 
   public function canEstablishAPISessions() {
     if ($this->getIsDisabled()) {
       return false;
     }
 
     // Intracluster requests are permitted even if the user is logged out:
     // in particular, public users are allowed to issue intracluster requests
     // when browsing Diffusion.
     if (PhabricatorEnv::isClusterRemoteAddress()) {
       if (!$this->isLoggedIn()) {
         return true;
       }
     }
 
     if (!$this->isUserActivated()) {
       return false;
     }
 
     if ($this->getIsMailingList()) {
       return false;
     }
 
     return true;
   }
 
   public function canEstablishSSHSessions() {
     if (!$this->isUserActivated()) {
       return false;
     }
 
     if ($this->getIsMailingList()) {
       return false;
     }
 
     return true;
   }
 
   /**
    * Returns `true` if this is a standard user who is logged in. Returns `false`
    * for logged out, anonymous, or external users.
    *
    * @return bool `true` if the user is a standard user who is logged in with
    *              a normal session.
    */
   public function getIsStandardUser() {
     $type_user = PhabricatorPeopleUserPHIDType::TYPECONST;
     return $this->getPHID() && (phid_get_type($this->getPHID()) == $type_user);
   }
 
   protected function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_COLUMN_SCHEMA => array(
         'userName' => 'sort64',
         'realName' => 'text128',
         'profileImagePHID' => 'phid?',
         'conduitCertificate' => 'text255',
         'isSystemAgent' => 'bool',
         'isMailingList' => 'bool',
         'isDisabled' => 'bool',
         'isAdmin' => 'bool',
         'isEmailVerified' => 'uint32',
         'isApproved' => 'uint32',
         'accountSecret' => 'bytes64',
         'isEnrolledInMultiFactor' => 'bool',
         'availabilityCache' => 'text255?',
         'availabilityCacheTTL' => 'uint32?',
         'defaultProfileImagePHID' => 'phid?',
         'defaultProfileImageVersion' => 'text64?',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'key_phid' => null,
         'phid' => array(
           'columns' => array('phid'),
           'unique' => true,
         ),
         'userName' => array(
           'columns' => array('userName'),
           'unique' => true,
         ),
         'realName' => array(
           'columns' => array('realName'),
         ),
         'key_approved' => array(
           'columns' => array('isApproved'),
         ),
       ),
       self::CONFIG_NO_MUTATE => array(
         'availabilityCache' => true,
         'availabilityCacheTTL' => true,
       ),
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       PhabricatorPeopleUserPHIDType::TYPECONST);
   }
 
   public function getMonogram() {
     return '@'.$this->getUsername();
   }
 
   public function isLoggedIn() {
     return !($this->getPHID() === null);
   }
 
   public function saveWithoutIndex() {
     return parent::save();
   }
 
   public function save() {
     if (!$this->getConduitCertificate()) {
       $this->setConduitCertificate($this->generateConduitCertificate());
     }
 
-    if (!strlen($this->getAccountSecret())) {
+    $secret = $this->getAccountSecret();
+    if (($secret === null) || !strlen($secret)) {
       $this->setAccountSecret(Filesystem::readRandomCharacters(64));
     }
 
     $result = $this->saveWithoutIndex();
 
     if ($this->profile) {
       $this->profile->save();
     }
 
     $this->updateNameTokens();
 
     PhabricatorSearchWorker::queueDocumentForIndexing($this->getPHID());
 
     return $result;
   }
 
   public function attachSession(PhabricatorAuthSession $session) {
     $this->session = $session;
     return $this;
   }
 
   public function getSession() {
     return $this->assertAttached($this->session);
   }
 
   public function hasSession() {
     return ($this->session !== self::ATTACHABLE);
   }
 
   public function hasHighSecuritySession() {
     if (!$this->hasSession()) {
       return false;
     }
 
     return $this->getSession()->isHighSecuritySession();
   }
 
   private function generateConduitCertificate() {
     return Filesystem::readRandomCharacters(255);
   }
 
   const EMAIL_CYCLE_FREQUENCY = 86400;
   const EMAIL_TOKEN_LENGTH    = 24;
 
   public function getUserProfile() {
     return $this->assertAttached($this->profile);
   }
 
   public function attachUserProfile(PhabricatorUserProfile $profile) {
     $this->profile = $profile;
     return $this;
   }
 
   public function loadUserProfile() {
     if ($this->profile) {
       return $this->profile;
     }
 
     $profile_dao = new PhabricatorUserProfile();
     $this->profile = $profile_dao->loadOneWhere('userPHID = %s',
       $this->getPHID());
 
     if (!$this->profile) {
       $this->profile = PhabricatorUserProfile::initializeNewProfile($this);
     }
 
     return $this->profile;
   }
 
   public function loadPrimaryEmailAddress() {
     $email = $this->loadPrimaryEmail();
     if (!$email) {
       throw new Exception(pht('User has no primary email address!'));
     }
     return $email->getAddress();
   }
 
   public function loadPrimaryEmail() {
     return id(new PhabricatorUserEmail())->loadOneWhere(
       'userPHID = %s AND isPrimary = 1',
       $this->getPHID());
   }
 
 
 /* -(  Settings  )----------------------------------------------------------- */
 
 
   public function getUserSetting($key) {
     // NOTE: We store available keys and cached values separately to make it
     // faster to check for `null` in the cache, which is common.
     if (isset($this->settingCacheKeys[$key])) {
       return $this->settingCache[$key];
     }
 
     $settings_key = PhabricatorUserPreferencesCacheType::KEY_PREFERENCES;
     if ($this->getPHID()) {
       $settings = $this->requireCacheData($settings_key);
     } else {
       $settings = $this->loadGlobalSettings();
     }
 
     if (array_key_exists($key, $settings)) {
       $value = $settings[$key];
       return $this->writeUserSettingCache($key, $value);
     }
 
     $cache = PhabricatorCaches::getRuntimeCache();
     $cache_key = "settings.defaults({$key})";
     $cache_map = $cache->getKeys(array($cache_key));
 
     if ($cache_map) {
       $value = $cache_map[$cache_key];
     } else {
       $defaults = PhabricatorSetting::getAllSettings();
       if (isset($defaults[$key])) {
         $value = id(clone $defaults[$key])
           ->setViewer($this)
           ->getSettingDefaultValue();
       } else {
         $value = null;
       }
 
       $cache->setKey($cache_key, $value);
     }
 
     return $this->writeUserSettingCache($key, $value);
   }
 
 
   /**
    * Test if a given setting is set to a particular value.
    *
    * @param const Setting key.
    * @param wild Value to compare.
    * @return bool True if the setting has the specified value.
    * @task settings
    */
   public function compareUserSetting($key, $value) {
     $actual = $this->getUserSetting($key);
     return ($actual == $value);
   }
 
   private function writeUserSettingCache($key, $value) {
     $this->settingCacheKeys[$key] = true;
     $this->settingCache[$key] = $value;
     return $value;
   }
 
   public function getTranslation() {
     return $this->getUserSetting(PhabricatorTranslationSetting::SETTINGKEY);
   }
 
   public function getTimezoneIdentifier() {
     return $this->getUserSetting(PhabricatorTimezoneSetting::SETTINGKEY);
   }
 
   public static function getGlobalSettingsCacheKey() {
     return 'user.settings.globals.v1';
   }
 
   private function loadGlobalSettings() {
     $cache_key = self::getGlobalSettingsCacheKey();
     $cache = PhabricatorCaches::getMutableStructureCache();
 
     $settings = $cache->getKey($cache_key);
     if (!$settings) {
       $preferences = PhabricatorUserPreferences::loadGlobalPreferences($this);
       $settings = $preferences->getPreferences();
       $cache->setKey($cache_key, $settings);
     }
 
     return $settings;
   }
 
 
   /**
    * Override the user's timezone identifier.
    *
    * This is primarily useful for unit tests.
    *
    * @param string New timezone identifier.
    * @return this
    * @task settings
    */
   public function overrideTimezoneIdentifier($identifier) {
     $timezone_key = PhabricatorTimezoneSetting::SETTINGKEY;
     $this->settingCacheKeys[$timezone_key] = true;
     $this->settingCache[$timezone_key] = $identifier;
     return $this;
   }
 
   public function getGender() {
     return $this->getUserSetting(PhabricatorPronounSetting::SETTINGKEY);
   }
 
   /**
    * Populate the nametoken table, which used to fetch typeahead results. When
    * a user types "linc", we want to match "Abraham Lincoln" from on-demand
    * typeahead sources. To do this, we need a separate table of name fragments.
    */
   public function updateNameTokens() {
     $table  = self::NAMETOKEN_TABLE;
     $conn_w = $this->establishConnection('w');
 
     $tokens = PhabricatorTypeaheadDatasource::tokenizeString(
       $this->getUserName().' '.$this->getRealName());
 
     $sql = array();
     foreach ($tokens as $token) {
       $sql[] = qsprintf(
         $conn_w,
         '(%d, %s)',
         $this->getID(),
         $token);
     }
 
     queryfx(
       $conn_w,
       'DELETE FROM %T WHERE userID = %d',
       $table,
       $this->getID());
     if ($sql) {
       queryfx(
         $conn_w,
         'INSERT INTO %T (userID, token) VALUES %LQ',
         $table,
         $sql);
     }
   }
 
   public static function describeValidUsername() {
     return pht(
       'Usernames must contain only numbers, letters, period, underscore, and '.
       'hyphen, and can not end with a period. They must have no more than %d '.
       'characters.',
       new PhutilNumber(self::MAXIMUM_USERNAME_LENGTH));
   }
 
   public static function validateUsername($username) {
     // NOTE: If you update this, make sure to update:
     //
     //  - Remarkup rule for @mentions.
     //  - Routing rule for "/p/username/".
     //  - Unit tests, obviously.
     //  - describeValidUsername() method, above.
 
     if (strlen($username) > self::MAXIMUM_USERNAME_LENGTH) {
       return false;
     }
 
     return (bool)preg_match('/^[a-zA-Z0-9._-]*[a-zA-Z0-9_-]\z/', $username);
   }
 
   public static function getDefaultProfileImageURI() {
     return celerity_get_resource_uri('/rsrc/image/avatar.png');
   }
 
   public function getProfileImageURI() {
     $uri_key = PhabricatorUserProfileImageCacheType::KEY_URI;
     return $this->requireCacheData($uri_key);
   }
 
   public function getUnreadNotificationCount() {
     $notification_key = PhabricatorUserNotificationCountCacheType::KEY_COUNT;
     return $this->requireCacheData($notification_key);
   }
 
   public function getUnreadMessageCount() {
     $message_key = PhabricatorUserMessageCountCacheType::KEY_COUNT;
     return $this->requireCacheData($message_key);
   }
 
   public function getRecentBadgeAwards() {
     $badges_key = PhabricatorUserBadgesCacheType::KEY_BADGES;
     return $this->requireCacheData($badges_key);
   }
 
   public function getFullName() {
     if (strlen($this->getRealName())) {
       return $this->getUsername().' ('.$this->getRealName().')';
     } else {
       return $this->getUsername();
     }
   }
 
   public function getTimeZone() {
     return new DateTimeZone($this->getTimezoneIdentifier());
   }
 
   public function getTimeZoneOffset() {
     $timezone = $this->getTimeZone();
     $now = new DateTime('@'.PhabricatorTime::getNow());
     $offset = $timezone->getOffset($now);
 
     // Javascript offsets are in minutes and have the opposite sign.
     $offset = -(int)($offset / 60);
 
     return $offset;
   }
 
   public function getTimeZoneOffsetInHours() {
     $offset = $this->getTimeZoneOffset();
     $offset = (int)round($offset / 60);
     $offset = -$offset;
 
     return $offset;
   }
 
   public function formatShortDateTime($when, $now = null) {
     if ($now === null) {
       $now = PhabricatorTime::getNow();
     }
 
     try {
       $when = new DateTime('@'.$when);
       $now = new DateTime('@'.$now);
     } catch (Exception $ex) {
       return null;
     }
 
     $zone = $this->getTimeZone();
 
     $when->setTimeZone($zone);
     $now->setTimeZone($zone);
 
     if ($when->format('Y') !== $now->format('Y')) {
       // Different year, so show "Feb 31 2075".
       $format = 'M j Y';
     } else if ($when->format('Ymd') !== $now->format('Ymd')) {
       // Same year but different month and day, so show "Feb 31".
       $format = 'M j';
     } else {
       // Same year, month and day so show a time of day.
       $pref_time = PhabricatorTimeFormatSetting::SETTINGKEY;
       $format = $this->getUserSetting($pref_time);
     }
 
     return $when->format($format);
   }
 
   public function __toString() {
     return $this->getUsername();
   }
 
   public static function loadOneWithEmailAddress($address) {
     $email = id(new PhabricatorUserEmail())->loadOneWhere(
       'address = %s',
       $address);
     if (!$email) {
       return null;
     }
     return id(new PhabricatorUser())->loadOneWhere(
       'phid = %s',
       $email->getUserPHID());
   }
 
   public function getDefaultSpacePHID() {
     // TODO: We might let the user switch which space they're "in" later on;
     // for now just use the global space if one exists.
 
     // If the viewer has access to the default space, use that.
     $spaces = PhabricatorSpacesNamespaceQuery::getViewerActiveSpaces($this);
     foreach ($spaces as $space) {
       if ($space->getIsDefaultNamespace()) {
         return $space->getPHID();
       }
     }
 
     // Otherwise, use the space with the lowest ID that they have access to.
     // This just tends to keep the default stable and predictable over time,
     // so adding a new space won't change behavior for users.
     if ($spaces) {
       $spaces = msort($spaces, 'getID');
       return head($spaces)->getPHID();
     }
 
     return null;
   }
 
 
   public function hasConduitClusterToken() {
     return ($this->conduitClusterToken !== self::ATTACHABLE);
   }
 
   public function attachConduitClusterToken(PhabricatorConduitToken $token) {
     $this->conduitClusterToken = $token;
     return $this;
   }
 
   public function getConduitClusterToken() {
     return $this->assertAttached($this->conduitClusterToken);
   }
 
 
 /* -(  Availability  )------------------------------------------------------- */
 
 
   /**
    * @task availability
    */
   public function attachAvailability(array $availability) {
     $this->availability = $availability;
     return $this;
   }
 
 
   /**
    * Get the timestamp the user is away until, if they are currently away.
    *
    * @return int|null Epoch timestamp, or `null` if the user is not away.
    * @task availability
    */
   public function getAwayUntil() {
     $availability = $this->availability;
 
     $this->assertAttached($availability);
     if (!$availability) {
       return null;
     }
 
     return idx($availability, 'until');
   }
 
 
   public function getDisplayAvailability() {
     $availability = $this->availability;
 
     $this->assertAttached($availability);
     if (!$availability) {
       return null;
     }
 
     $busy = PhabricatorCalendarEventInvitee::AVAILABILITY_BUSY;
 
     return idx($availability, 'availability', $busy);
   }
 
 
   public function getAvailabilityEventPHID() {
     $availability = $this->availability;
 
     $this->assertAttached($availability);
     if (!$availability) {
       return null;
     }
 
     return idx($availability, 'eventPHID');
   }
 
 
   /**
    * Get cached availability, if present.
    *
    * @return wild|null Cache data, or null if no cache is available.
    * @task availability
    */
   public function getAvailabilityCache() {
     $now = PhabricatorTime::getNow();
     if ($this->availabilityCacheTTL <= $now) {
       return null;
     }
 
     try {
       return phutil_json_decode($this->availabilityCache);
     } catch (Exception $ex) {
       return null;
     }
   }
 
 
   /**
    * Write to the availability cache.
    *
    * @param wild Availability cache data.
    * @param int|null Cache TTL.
    * @return this
    * @task availability
    */
   public function writeAvailabilityCache(array $availability, $ttl) {
     if (PhabricatorEnv::isReadOnly()) {
       return $this;
     }
 
     $unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
     queryfx(
       $this->establishConnection('w'),
       'UPDATE %T SET availabilityCache = %s, availabilityCacheTTL = %nd
         WHERE id = %d',
       $this->getTableName(),
       phutil_json_encode($availability),
       $ttl,
       $this->getID());
     unset($unguarded);
 
     return $this;
   }
 
 
 /* -(  Multi-Factor Authentication  )---------------------------------------- */
 
 
   /**
    * Update the flag storing this user's enrollment in multi-factor auth.
    *
    * With certain settings, we need to check if a user has MFA on every page,
    * so we cache MFA enrollment on the user object for performance. Calling this
    * method synchronizes the cache by examining enrollment records. After
    * updating the cache, use @{method:getIsEnrolledInMultiFactor} to check if
    * the user is enrolled.
    *
    * This method should be called after any changes are made to a given user's
    * multi-factor configuration.
    *
    * @return void
    * @task factors
    */
   public function updateMultiFactorEnrollment() {
     $factors = id(new PhabricatorAuthFactorConfigQuery())
       ->setViewer($this)
       ->withUserPHIDs(array($this->getPHID()))
       ->withFactorProviderStatuses(
         array(
           PhabricatorAuthFactorProviderStatus::STATUS_ACTIVE,
           PhabricatorAuthFactorProviderStatus::STATUS_DEPRECATED,
         ))
       ->execute();
 
     $enrolled = count($factors) ? 1 : 0;
     if ($enrolled !== $this->isEnrolledInMultiFactor) {
       $unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
         queryfx(
           $this->establishConnection('w'),
           'UPDATE %T SET isEnrolledInMultiFactor = %d WHERE id = %d',
           $this->getTableName(),
           $enrolled,
           $this->getID());
       unset($unguarded);
 
       $this->isEnrolledInMultiFactor = $enrolled;
     }
   }
 
 
   /**
    * Check if the user is enrolled in multi-factor authentication.
    *
    * Enrolled users have one or more multi-factor authentication sources
    * attached to their account. For performance, this value is cached. You
    * can use @{method:updateMultiFactorEnrollment} to update the cache.
    *
    * @return bool True if the user is enrolled.
    * @task factors
    */
   public function getIsEnrolledInMultiFactor() {
     return $this->isEnrolledInMultiFactor;
   }
 
 
 /* -(  Omnipotence  )-------------------------------------------------------- */
 
 
   /**
    * Returns true if this user is omnipotent. Omnipotent users bypass all policy
    * checks.
    *
    * @return bool True if the user bypasses policy checks.
    */
   public function isOmnipotent() {
     return $this->omnipotent;
   }
 
 
   /**
    * Get an omnipotent user object for use in contexts where there is no acting
    * user, notably daemons.
    *
    * @return PhabricatorUser An omnipotent user.
    */
   public static function getOmnipotentUser() {
     static $user = null;
     if (!$user) {
       $user = new PhabricatorUser();
       $user->omnipotent = true;
       $user->makeEphemeral();
     }
     return $user;
   }
 
 
   /**
    * Get a scalar string identifying this user.
    *
    * This is similar to using the PHID, but distinguishes between omnipotent
    * and public users explicitly. This allows safe construction of cache keys
    * or cache buckets which do not conflate public and omnipotent users.
    *
    * @return string Scalar identifier.
    */
   public function getCacheFragment() {
     if ($this->isOmnipotent()) {
       return 'u.omnipotent';
     }
 
     $phid = $this->getPHID();
     if ($phid) {
       return 'u.'.$phid;
     }
 
     return 'u.public';
   }
 
 
 /* -(  Managing Handles  )--------------------------------------------------- */
 
 
   /**
    * Get a @{class:PhabricatorHandleList} which benefits from this viewer's
    * internal handle pool.
    *
    * @param list<phid> List of PHIDs to load.
    * @return PhabricatorHandleList Handle list object.
    * @task handle
    */
   public function loadHandles(array $phids) {
     if ($this->handlePool === null) {
       $this->handlePool = id(new PhabricatorHandlePool())
         ->setViewer($this);
     }
 
     return $this->handlePool->newHandleList($phids);
   }
 
 
   /**
    * Get a @{class:PHUIHandleView} for a single handle.
    *
    * This benefits from the viewer's internal handle pool.
    *
    * @param phid PHID to render a handle for.
    * @return PHUIHandleView View of the handle.
    * @task handle
    */
   public function renderHandle($phid) {
     return $this->loadHandles(array($phid))->renderHandle($phid);
   }
 
 
   /**
    * Get a @{class:PHUIHandleListView} for a list of handles.
    *
    * This benefits from the viewer's internal handle pool.
    *
    * @param list<phid> List of PHIDs to render.
    * @return PHUIHandleListView View of the handles.
    * @task handle
    */
   public function renderHandleList(array $phids) {
     return $this->loadHandles($phids)->renderList();
   }
 
   public function attachBadgePHIDs(array $phids) {
     $this->badgePHIDs = $phids;
     return $this;
   }
 
   public function getBadgePHIDs() {
     return $this->assertAttached($this->badgePHIDs);
   }
 
 /* -(  CSRF  )--------------------------------------------------------------- */
 
 
   public function getCSRFToken() {
     if ($this->isOmnipotent()) {
       // We may end up here when called from the daemons. The omnipotent user
       // has no meaningful CSRF token, so just return `null`.
       return null;
     }
 
     return $this->newCSRFEngine()
       ->newToken();
   }
 
   public function validateCSRFToken($token) {
     return $this->newCSRFengine()
       ->isValidToken($token);
   }
 
   public function getAlternateCSRFString() {
     return $this->assertAttached($this->alternateCSRFString);
   }
 
   public function attachAlternateCSRFString($string) {
     $this->alternateCSRFString = $string;
     return $this;
   }
 
   private function newCSRFEngine() {
     if ($this->getPHID()) {
       $vec = $this->getPHID().$this->getAccountSecret();
     } else {
       $vec = $this->getAlternateCSRFString();
     }
 
     if ($this->hasSession()) {
       $vec = $vec.$this->getSession()->getSessionKey();
     }
 
     $engine = new PhabricatorAuthCSRFEngine();
 
     if ($this->csrfSalt === null) {
       $this->csrfSalt = $engine->newSalt();
     }
 
     $engine
       ->setSalt($this->csrfSalt)
       ->setSecret(new PhutilOpaqueEnvelope($vec));
 
     return $engine;
   }
 
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
     );
   }
 
   public function getPolicy($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         return PhabricatorPolicies::POLICY_PUBLIC;
       case PhabricatorPolicyCapability::CAN_EDIT:
         if ($this->getIsSystemAgent() || $this->getIsMailingList()) {
           return PhabricatorPolicies::POLICY_ADMIN;
         } else {
           return PhabricatorPolicies::POLICY_NOONE;
         }
     }
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     return $this->getPHID() && ($viewer->getPHID() === $this->getPHID());
   }
 
   public function describeAutomaticCapability($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_EDIT:
         return pht('Only you can edit your information.');
       default:
         return null;
     }
   }
 
 
 /* -(  PhabricatorCustomFieldInterface  )------------------------------------ */
 
 
   public function getCustomFieldSpecificationForRole($role) {
     return PhabricatorEnv::getEnvConfig('user.fields');
   }
 
   public function getCustomFieldBaseClass() {
     return 'PhabricatorUserCustomField';
   }
 
   public function getCustomFields() {
     return $this->assertAttached($this->customFields);
   }
 
   public function attachCustomFields(PhabricatorCustomFieldAttachment $fields) {
     $this->customFields = $fields;
     return $this;
   }
 
 
 /* -(  PhabricatorDestructibleInterface  )----------------------------------- */
 
 
   public function destroyObjectPermanently(
     PhabricatorDestructionEngine $engine) {
 
     $viewer = $engine->getViewer();
 
     $this->openTransaction();
       $this->delete();
 
       $externals = id(new PhabricatorExternalAccountQuery())
         ->setViewer($viewer)
         ->withUserPHIDs(array($this->getPHID()))
         ->newIterator();
       foreach ($externals as $external) {
         $engine->destroyObject($external);
       }
 
       $prefs = id(new PhabricatorUserPreferencesQuery())
         ->setViewer($viewer)
         ->withUsers(array($this))
         ->execute();
       foreach ($prefs as $pref) {
         $engine->destroyObject($pref);
       }
 
       $profiles = id(new PhabricatorUserProfile())->loadAllWhere(
         'userPHID = %s',
         $this->getPHID());
       foreach ($profiles as $profile) {
         $profile->delete();
       }
 
       $keys = id(new PhabricatorAuthSSHKeyQuery())
         ->setViewer($viewer)
         ->withObjectPHIDs(array($this->getPHID()))
         ->execute();
       foreach ($keys as $key) {
         $engine->destroyObject($key);
       }
 
       $emails = id(new PhabricatorUserEmail())->loadAllWhere(
         'userPHID = %s',
         $this->getPHID());
       foreach ($emails as $email) {
         $engine->destroyObject($email);
       }
 
       $sessions = id(new PhabricatorAuthSession())->loadAllWhere(
         'userPHID = %s',
         $this->getPHID());
       foreach ($sessions as $session) {
         $session->delete();
       }
 
       $factors = id(new PhabricatorAuthFactorConfig())->loadAllWhere(
         'userPHID = %s',
         $this->getPHID());
       foreach ($factors as $factor) {
         $factor->delete();
       }
 
     $this->saveTransaction();
   }
 
 
 /* -(  PhabricatorSSHPublicKeyInterface  )----------------------------------- */
 
 
   public function getSSHPublicKeyManagementURI(PhabricatorUser $viewer) {
     if ($viewer->getPHID() == $this->getPHID()) {
       // If the viewer is managing their own keys, take them to the normal
       // panel.
       return '/settings/panel/ssh/';
     } else {
       // Otherwise, take them to the administrative panel for this user.
       return '/settings/user/'.$this->getUsername().'/page/ssh/';
     }
   }
 
   public function getSSHKeyDefaultName() {
     return 'id_rsa_phabricator';
   }
 
   public function getSSHKeyNotifyPHIDs() {
     return array(
       $this->getPHID(),
     );
   }
 
 
 /* -(  PhabricatorApplicationTransactionInterface  )------------------------- */
 
 
   public function getApplicationTransactionEditor() {
     return new PhabricatorUserTransactionEditor();
   }
 
   public function getApplicationTransactionTemplate() {
     return new PhabricatorUserTransaction();
   }
 
 
 /* -(  PhabricatorFulltextInterface  )--------------------------------------- */
 
 
   public function newFulltextEngine() {
     return new PhabricatorUserFulltextEngine();
   }
 
 
 /* -(  PhabricatorFerretInterface  )----------------------------------------- */
 
 
   public function newFerretEngine() {
     return new PhabricatorUserFerretEngine();
   }
 
 
 /* -(  PhabricatorConduitResultInterface  )---------------------------------- */
 
 
   public function getFieldSpecificationsForConduit() {
     return array(
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('username')
         ->setType('string')
         ->setDescription(pht("The user's username.")),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('realName')
         ->setType('string')
         ->setDescription(pht("The user's real name.")),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('roles')
         ->setType('list<string>')
         ->setDescription(pht('List of account roles.')),
     );
   }
 
   public function getFieldValuesForConduit() {
     $roles = array();
 
     if ($this->getIsDisabled()) {
       $roles[] = 'disabled';
     }
 
     if ($this->getIsSystemAgent()) {
       $roles[] = 'bot';
     }
 
     if ($this->getIsMailingList()) {
       $roles[] = 'list';
     }
 
     if ($this->getIsAdmin()) {
       $roles[] = 'admin';
     }
 
     if ($this->getIsEmailVerified()) {
       $roles[] = 'verified';
     }
 
     if ($this->getIsApproved()) {
       $roles[] = 'approved';
     }
 
     if ($this->isUserActivated()) {
       $roles[] = 'activated';
     }
 
     return array(
       'username' => $this->getUsername(),
       'realName' => $this->getRealName(),
       'roles' => $roles,
     );
   }
 
   public function getConduitSearchAttachments() {
     return array(
       id(new PhabricatorPeopleAvailabilitySearchEngineAttachment())
         ->setAttachmentKey('availability'),
     );
   }
 
 
 /* -(  User Cache  )--------------------------------------------------------- */
 
 
   /**
    * @task cache
    */
   public function attachRawCacheData(array $data) {
     $this->rawCacheData = $data + $this->rawCacheData;
     return $this;
   }
 
   public function setAllowInlineCacheGeneration($allow_cache_generation) {
     $this->allowInlineCacheGeneration = $allow_cache_generation;
     return $this;
   }
 
   /**
    * @task cache
    */
   protected function requireCacheData($key) {
     if (isset($this->usableCacheData[$key])) {
       return $this->usableCacheData[$key];
     }
 
     $type = PhabricatorUserCacheType::requireCacheTypeForKey($key);
 
     if (isset($this->rawCacheData[$key])) {
       $raw_value = $this->rawCacheData[$key];
 
       $usable_value = $type->getValueFromStorage($raw_value);
       $this->usableCacheData[$key] = $usable_value;
 
       return $usable_value;
     }
 
     // By default, we throw if a cache isn't available. This is consistent
     // with the standard `needX()` + `attachX()` + `getX()` interaction.
     if (!$this->allowInlineCacheGeneration) {
       throw new PhabricatorDataNotAttachedException($this);
     }
 
     $user_phid = $this->getPHID();
 
     // Try to read the actual cache before we generate a new value. We can
     // end up here via Conduit, which does not use normal sessions and can
     // not pick up a free cache load during session identification.
     if ($user_phid) {
       $raw_data = PhabricatorUserCache::readCaches(
         $type,
         $key,
         array($user_phid));
       if (array_key_exists($user_phid, $raw_data)) {
         $raw_value = $raw_data[$user_phid];
         $usable_value = $type->getValueFromStorage($raw_value);
         $this->rawCacheData[$key] = $raw_value;
         $this->usableCacheData[$key] = $usable_value;
         return $usable_value;
       }
     }
 
     $usable_value = $type->getDefaultValue();
 
     if ($user_phid) {
       $map = $type->newValueForUsers($key, array($this));
       if (array_key_exists($user_phid, $map)) {
         $raw_value = $map[$user_phid];
         $usable_value = $type->getValueFromStorage($raw_value);
 
         $this->rawCacheData[$key] = $raw_value;
         PhabricatorUserCache::writeCache(
           $type,
           $key,
           $user_phid,
           $raw_value);
       }
     }
 
     $this->usableCacheData[$key] = $usable_value;
 
     return $usable_value;
   }
 
 
   /**
    * @task cache
    */
   public function clearCacheData($key) {
     unset($this->rawCacheData[$key]);
     unset($this->usableCacheData[$key]);
     return $this;
   }
 
 
   public function getCSSValue($variable_key) {
     $preference = PhabricatorAccessibilitySetting::SETTINGKEY;
     $key = $this->getUserSetting($preference);
 
     $postprocessor = CelerityPostprocessor::getPostprocessor($key);
     $variables = $postprocessor->getVariables();
 
     if (!isset($variables[$variable_key])) {
       throw new Exception(
         pht(
           'Unknown CSS variable "%s"!',
           $variable_key));
     }
 
     return $variables[$variable_key];
   }
 
 /* -(  PhabricatorAuthPasswordHashInterface  )------------------------------- */
 
 
   public function newPasswordDigest(
     PhutilOpaqueEnvelope $envelope,
     PhabricatorAuthPassword $password) {
 
     // Before passwords are hashed, they are digested. The goal of digestion
     // is twofold: to reduce the length of very long passwords to something
     // reasonable; and to salt the password in case the best available hasher
     // does not include salt automatically.
 
     // Users may choose arbitrarily long passwords, and attackers may try to
     // attack the system by probing it with very long passwords. When large
     // inputs are passed to hashers -- which are intentionally slow -- it
     // can result in unacceptably long runtimes. The classic attack here is
     // to try to log in with a 64MB password and see if that locks up the
     // machine for the next century. By digesting passwords to a standard
     // length first, the length of the raw input does not impact the runtime
     // of the hashing algorithm.
 
     // Some hashers like bcrypt are self-salting, while other hashers are not.
     // Applying salt while digesting passwords ensures that hashes are salted
     // whether we ultimately select a self-salting hasher or not.
 
     // For legacy compatibility reasons, old VCS and Account password digest
     // algorithms are significantly more complicated than necessary to achieve
     // these goals. This is because they once used a different hashing and
     // salting process. When we upgraded to the modern modular hasher
     // infrastructure, we just bolted it onto the end of the existing pipelines
     // so that upgrading didn't break all users' credentials.
 
     // New implementations can (and, generally, should) safely select the
     // simple HMAC SHA256 digest at the bottom of the function, which does
     // everything that a digest callback should without any needless legacy
     // baggage on top.
 
     if ($password->getLegacyDigestFormat() == 'v1') {
       switch ($password->getPasswordType()) {
         case PhabricatorAuthPassword::PASSWORD_TYPE_VCS:
           // Old VCS passwords use an iterated HMAC SHA1 as a digest algorithm.
           // They originally used this as a hasher, but it became a digest
           // algorithm once hashing was upgraded to include bcrypt.
           $digest = $envelope->openEnvelope();
           $salt = $this->getPHID();
           for ($ii = 0; $ii < 1000; $ii++) {
             $digest = PhabricatorHash::weakDigest($digest, $salt);
           }
           return new PhutilOpaqueEnvelope($digest);
         case PhabricatorAuthPassword::PASSWORD_TYPE_ACCOUNT:
           // Account passwords previously used this weird mess of salt and did
           // not digest the input to a standard length.
 
           // Beyond this being a weird special case, there are two actual
           // problems with this, although neither are particularly severe:
 
           // First, because we do not normalize the length of passwords, this
           // algorithm may make us vulnerable to DOS attacks where an attacker
           // attempts to use a very long input to slow down hashers.
 
           // Second, because the username is part of the hash algorithm,
           // renaming a user breaks their password. This isn't a huge deal but
           // it's pretty silly. There's no security justification for this
           // behavior, I just didn't think about the implication when I wrote
           // it originally.
 
           $parts = array(
             $this->getUsername(),
             $envelope->openEnvelope(),
             $this->getPHID(),
             $password->getPasswordSalt(),
           );
 
           return new PhutilOpaqueEnvelope(implode('', $parts));
       }
     }
 
     // For passwords which do not have some crazy legacy reason to use some
     // other digest algorithm, HMAC SHA256 is an excellent choice. It satisfies
     // the digest requirements and is simple.
 
     $digest = PhabricatorHash::digestHMACSHA256(
       $envelope->openEnvelope(),
       $password->getPasswordSalt());
 
     return new PhutilOpaqueEnvelope($digest);
   }
 
   public function newPasswordBlocklist(
     PhabricatorUser $viewer,
     PhabricatorAuthPasswordEngine $engine) {
 
     $list = array();
     $list[] = $this->getUsername();
     $list[] = $this->getRealName();
 
     $emails = id(new PhabricatorUserEmail())->loadAllWhere(
       'userPHID = %s',
       $this->getPHID());
     foreach ($emails as $email) {
       $list[] = $email->getAddress();
     }
 
     return $list;
   }
 
 
 }
diff --git a/src/applications/phid/handle/pool/PhabricatorHandleList.php b/src/applications/phid/handle/pool/PhabricatorHandleList.php
index c3c6f40324..1418a107c0 100644
--- a/src/applications/phid/handle/pool/PhabricatorHandleList.php
+++ b/src/applications/phid/handle/pool/PhabricatorHandleList.php
@@ -1,196 +1,206 @@
 <?php
 
 /**
  * A list of object handles.
  *
  * This is a convenience class which behaves like an array but makes working
  * with handles more convenient, improves their caching and batching semantics,
  * and provides some utility behavior.
  *
  * Load a handle list by calling `loadHandles()` on a `$viewer`:
  *
  *   $handles = $viewer->loadHandles($phids);
  *
  * This creates a handle list object, which behaves like an array of handles.
  * However, it benefits from the viewer's internal handle cache and performs
  * just-in-time bulk loading.
  */
 final class PhabricatorHandleList
   extends Phobject
   implements
     Iterator,
     ArrayAccess,
     Countable {
 
   private $handlePool;
   private $phids;
   private $count;
   private $handles;
   private $cursor;
   private $map;
 
   public function setHandlePool(PhabricatorHandlePool $pool) {
     $this->handlePool = $pool;
     return $this;
   }
 
   public function setPHIDs(array $phids) {
     $this->phids = $phids;
     $this->count = count($phids);
     return $this;
   }
 
   private function loadHandles() {
     $this->handles = $this->handlePool->loadPHIDs($this->phids);
   }
 
   private function getHandle($phid) {
     if ($this->handles === null) {
       $this->loadHandles();
     }
 
     if (empty($this->handles[$phid])) {
       throw new Exception(
         pht(
           'Requested handle "%s" was not loaded.',
           $phid));
     }
 
     return $this->handles[$phid];
   }
 
 
   /**
    * Get a handle from this list if it exists.
    *
    * This has similar semantics to @{function:idx}.
    */
   public function getHandleIfExists($phid, $default = null) {
     if ($this->handles === null) {
       $this->loadHandles();
     }
 
     return idx($this->handles, $phid, $default);
   }
 
 
   /**
    * Create a new list with a subset of the PHIDs in this list.
    */
   public function newSublist(array $phids) {
     foreach ($phids as $phid) {
       if (!isset($this[$phid])) {
         throw new Exception(
           pht(
             'Trying to create a new sublist of an existing handle list, '.
             'but PHID "%s" does not appear in the parent list.',
             $phid));
       }
     }
 
     return $this->handlePool->newHandleList($phids);
   }
 
 
 /* -(  Rendering  )---------------------------------------------------------- */
 
 
   /**
    * Return a @{class:PHUIHandleListView} which can render the handles in
    * this list.
    */
   public function renderList() {
     return id(new PHUIHandleListView())
       ->setHandleList($this);
   }
 
   public function newListView() {
     return id(new FuelHandleListView())
       ->addHandleList($this);
   }
 
   /**
    * Return a @{class:PHUIHandleView} which can render a specific handle.
    */
   public function renderHandle($phid) {
     if (!isset($this[$phid])) {
       throw new Exception(
         pht('Trying to render a handle which does not exist!'));
     }
 
     return id(new PHUIHandleView())
       ->setHandleList($this)
       ->setHandlePHID($phid);
   }
 
 /* -(  Iterator  )----------------------------------------------------------- */
 
 
+  #[\ReturnTypeWillChange]
   public function rewind() {
     $this->cursor = 0;
   }
 
+  #[\ReturnTypeWillChange]
   public function current() {
     return $this->getHandle($this->phids[$this->cursor]);
   }
 
+  #[\ReturnTypeWillChange]
   public function key() {
     return $this->phids[$this->cursor];
   }
 
+  #[\ReturnTypeWillChange]
   public function next() {
     ++$this->cursor;
   }
 
+  #[\ReturnTypeWillChange]
   public function valid() {
     return ($this->cursor < $this->count);
   }
 
 
 /* -(  ArrayAccess  )-------------------------------------------------------- */
 
 
+  #[\ReturnTypeWillChange]
   public function offsetExists($offset) {
     // NOTE: We're intentionally not loading handles here so that isset()
     // checks do not trigger fetches. This gives us better bulk loading
     // behavior, particularly when invoked through methods like renderHandle().
 
     if ($this->map === null) {
       $this->map = array_fill_keys($this->phids, true);
     }
 
     return isset($this->map[$offset]);
   }
 
+  #[\ReturnTypeWillChange]
   public function offsetGet($offset) {
     if ($this->handles === null) {
       $this->loadHandles();
     }
     return $this->handles[$offset];
   }
 
+  #[\ReturnTypeWillChange]
   public function offsetSet($offset, $value) {
     $this->raiseImmutableException();
   }
 
+  #[\ReturnTypeWillChange]
   public function offsetUnset($offset) {
     $this->raiseImmutableException();
   }
 
   private function raiseImmutableException() {
     throw new Exception(
       pht(
         'Trying to mutate a %s, but this is not permitted; '.
         'handle lists are immutable.',
         __CLASS__));
   }
 
 
 /* -(  Countable  )---------------------------------------------------------- */
 
 
+  #[\ReturnTypeWillChange]
   public function count() {
     return $this->count;
   }
 
 }
diff --git a/src/infrastructure/cluster/PhabricatorDatabaseRef.php b/src/infrastructure/cluster/PhabricatorDatabaseRef.php
index 478f95750b..da9f5e0d5e 100644
--- a/src/infrastructure/cluster/PhabricatorDatabaseRef.php
+++ b/src/infrastructure/cluster/PhabricatorDatabaseRef.php
@@ -1,747 +1,748 @@
 <?php
 
 final class PhabricatorDatabaseRef
   extends Phobject {
 
   const STATUS_OKAY = 'okay';
   const STATUS_FAIL = 'fail';
   const STATUS_AUTH = 'auth';
   const STATUS_REPLICATION_CLIENT = 'replication-client';
 
   const REPLICATION_OKAY = 'okay';
   const REPLICATION_MASTER_REPLICA = 'master-replica';
   const REPLICATION_REPLICA_NONE = 'replica-none';
   const REPLICATION_SLOW = 'replica-slow';
   const REPLICATION_NOT_REPLICATING = 'not-replicating';
 
   const KEY_HEALTH = 'cluster.db.health';
   const KEY_REFS = 'cluster.db.refs';
   const KEY_INDIVIDUAL = 'cluster.db.individual';
 
   private $host;
   private $port;
   private $user;
   private $pass;
   private $disabled;
   private $isMaster;
   private $isIndividual;
 
   private $connectionLatency;
   private $connectionStatus;
   private $connectionMessage;
   private $connectionException;
 
   private $replicaStatus;
   private $replicaMessage;
   private $replicaDelay;
 
   private $healthRecord;
   private $didFailToConnect;
 
   private $isDefaultPartition;
   private $applicationMap = array();
   private $masterRef;
   private $replicaRefs = array();
   private $usePersistentConnections;
 
   public function setHost($host) {
     $this->host = $host;
     return $this;
   }
 
   public function getHost() {
     return $this->host;
   }
 
   public function setPort($port) {
     $this->port = $port;
     return $this;
   }
 
   public function getPort() {
     return $this->port;
   }
 
   public function setUser($user) {
     $this->user = $user;
     return $this;
   }
 
   public function getUser() {
     return $this->user;
   }
 
   public function setPass(PhutilOpaqueEnvelope $pass) {
     $this->pass = $pass;
     return $this;
   }
 
   public function getPass() {
     return $this->pass;
   }
 
   public function setIsMaster($is_master) {
     $this->isMaster = $is_master;
     return $this;
   }
 
   public function getIsMaster() {
     return $this->isMaster;
   }
 
   public function setDisabled($disabled) {
     $this->disabled = $disabled;
     return $this;
   }
 
   public function getDisabled() {
     return $this->disabled;
   }
 
   public function setConnectionLatency($connection_latency) {
     $this->connectionLatency = $connection_latency;
     return $this;
   }
 
   public function getConnectionLatency() {
     return $this->connectionLatency;
   }
 
   public function setConnectionStatus($connection_status) {
     $this->connectionStatus = $connection_status;
     return $this;
   }
 
   public function getConnectionStatus() {
     if ($this->connectionStatus === null) {
       throw new PhutilInvalidStateException('queryAll');
     }
 
     return $this->connectionStatus;
   }
 
   public function setConnectionMessage($connection_message) {
     $this->connectionMessage = $connection_message;
     return $this;
   }
 
   public function getConnectionMessage() {
     return $this->connectionMessage;
   }
 
   public function setReplicaStatus($replica_status) {
     $this->replicaStatus = $replica_status;
     return $this;
   }
 
   public function getReplicaStatus() {
     return $this->replicaStatus;
   }
 
   public function setReplicaMessage($replica_message) {
     $this->replicaMessage = $replica_message;
     return $this;
   }
 
   public function getReplicaMessage() {
     return $this->replicaMessage;
   }
 
   public function setReplicaDelay($replica_delay) {
     $this->replicaDelay = $replica_delay;
     return $this;
   }
 
   public function getReplicaDelay() {
     return $this->replicaDelay;
   }
 
   public function setIsIndividual($is_individual) {
     $this->isIndividual = $is_individual;
     return $this;
   }
 
   public function getIsIndividual() {
     return $this->isIndividual;
   }
 
   public function setIsDefaultPartition($is_default_partition) {
     $this->isDefaultPartition = $is_default_partition;
     return $this;
   }
 
   public function getIsDefaultPartition() {
     return $this->isDefaultPartition;
   }
 
   public function setUsePersistentConnections($use_persistent_connections) {
     $this->usePersistentConnections = $use_persistent_connections;
     return $this;
   }
 
   public function getUsePersistentConnections() {
     return $this->usePersistentConnections;
   }
 
   public function setApplicationMap(array $application_map) {
     $this->applicationMap = $application_map;
     return $this;
   }
 
   public function getApplicationMap() {
     return $this->applicationMap;
   }
 
   public function getPartitionStateForCommit() {
     $state = PhabricatorEnv::getEnvConfig('cluster.databases');
     foreach ($state as $key => $value) {
       // Don't store passwords, since we don't care if they differ and
       // users may find it surprising.
       unset($state[$key]['pass']);
     }
 
     return phutil_json_encode($state);
   }
 
   public function setMasterRef(PhabricatorDatabaseRef $master_ref) {
     $this->masterRef = $master_ref;
     return $this;
   }
 
   public function getMasterRef() {
     return $this->masterRef;
   }
 
   public function addReplicaRef(PhabricatorDatabaseRef $replica_ref) {
     $this->replicaRefs[] = $replica_ref;
     return $this;
   }
 
   public function getReplicaRefs() {
     return $this->replicaRefs;
   }
 
   public function getDisplayName() {
     return $this->getRefKey();
   }
 
   public function getRefKey() {
     $host = $this->getHost();
 
     $port = $this->getPort();
     if (strlen($port)) {
       return "{$host}:{$port}";
     }
 
     return $host;
   }
 
   public static function getConnectionStatusMap() {
     return array(
       self::STATUS_OKAY => array(
         'icon' => 'fa-exchange',
         'color' => 'green',
         'label' => pht('Okay'),
       ),
       self::STATUS_FAIL => array(
         'icon' => 'fa-times',
         'color' => 'red',
         'label' => pht('Failed'),
       ),
       self::STATUS_AUTH => array(
         'icon' => 'fa-key',
         'color' => 'red',
         'label' => pht('Invalid Credentials'),
       ),
       self::STATUS_REPLICATION_CLIENT => array(
         'icon' => 'fa-eye-slash',
         'color' => 'yellow',
         'label' => pht('Missing Permission'),
       ),
     );
   }
 
   public static function getReplicaStatusMap() {
     return array(
       self::REPLICATION_OKAY => array(
         'icon' => 'fa-download',
         'color' => 'green',
         'label' => pht('Okay'),
       ),
       self::REPLICATION_MASTER_REPLICA => array(
         'icon' => 'fa-database',
         'color' => 'red',
         'label' => pht('Replicating Master'),
       ),
       self::REPLICATION_REPLICA_NONE => array(
         'icon' => 'fa-download',
         'color' => 'red',
         'label' => pht('Not A Replica'),
       ),
       self::REPLICATION_SLOW => array(
         'icon' => 'fa-hourglass',
         'color' => 'red',
         'label' => pht('Slow Replication'),
       ),
       self::REPLICATION_NOT_REPLICATING => array(
         'icon' => 'fa-exclamation-triangle',
         'color' => 'red',
         'label' => pht('Not Replicating'),
       ),
     );
   }
 
   public static function getClusterRefs() {
     $cache = PhabricatorCaches::getRequestCache();
 
     $refs = $cache->getKey(self::KEY_REFS);
     if (!$refs) {
       $refs = self::newRefs();
       $cache->setKey(self::KEY_REFS, $refs);
     }
 
     return $refs;
   }
 
   public static function getLiveIndividualRef() {
     $cache = PhabricatorCaches::getRequestCache();
 
     $ref = $cache->getKey(self::KEY_INDIVIDUAL);
     if (!$ref) {
       $ref = self::newIndividualRef();
       $cache->setKey(self::KEY_INDIVIDUAL, $ref);
     }
 
     return $ref;
   }
 
   public static function newRefs() {
     $default_port = PhabricatorEnv::getEnvConfig('mysql.port');
     $default_port = nonempty($default_port, 3306);
 
     $default_user = PhabricatorEnv::getEnvConfig('mysql.user');
 
     $default_pass = PhabricatorEnv::getEnvConfig('mysql.pass');
+    $default_pass = phutil_string_cast($default_pass);
     $default_pass = new PhutilOpaqueEnvelope($default_pass);
 
     $config = PhabricatorEnv::getEnvConfig('cluster.databases');
 
     return id(new PhabricatorDatabaseRefParser())
       ->setDefaultPort($default_port)
       ->setDefaultUser($default_user)
       ->setDefaultPass($default_pass)
       ->newRefs($config);
   }
 
   public static function queryAll() {
     $refs = self::getActiveDatabaseRefs();
     return self::queryRefs($refs);
   }
 
   private static function queryRefs(array $refs) {
     foreach ($refs as $ref) {
       $conn = $ref->newManagementConnection();
 
       $t_start = microtime(true);
       $replica_status = false;
       try {
         $replica_status = queryfx_one($conn, 'SHOW SLAVE STATUS');
         $ref->setConnectionStatus(self::STATUS_OKAY);
       } catch (AphrontAccessDeniedQueryException $ex) {
         $ref->setConnectionStatus(self::STATUS_REPLICATION_CLIENT);
         $ref->setConnectionMessage(
           pht(
             'No permission to run "SHOW SLAVE STATUS". Grant this user '.
             '"REPLICATION CLIENT" permission to allow Phabricator to '.
             'monitor replica health.'));
       } catch (AphrontInvalidCredentialsQueryException $ex) {
         $ref->setConnectionStatus(self::STATUS_AUTH);
         $ref->setConnectionMessage($ex->getMessage());
       } catch (AphrontQueryException $ex) {
         $ref->setConnectionStatus(self::STATUS_FAIL);
 
         $class = get_class($ex);
         $message = $ex->getMessage();
         $ref->setConnectionMessage(
           pht(
             '%s: %s',
             get_class($ex),
             $ex->getMessage()));
       }
       $t_end = microtime(true);
       $ref->setConnectionLatency($t_end - $t_start);
 
       if ($replica_status !== false) {
         $is_replica = (bool)$replica_status;
         if ($ref->getIsMaster() && $is_replica) {
           $ref->setReplicaStatus(self::REPLICATION_MASTER_REPLICA);
           $ref->setReplicaMessage(
             pht(
               'This host has a "master" role, but is replicating data from '.
               'another host ("%s")!',
               idx($replica_status, 'Master_Host')));
         } else if (!$ref->getIsMaster() && !$is_replica) {
           $ref->setReplicaStatus(self::REPLICATION_REPLICA_NONE);
           $ref->setReplicaMessage(
             pht(
               'This host has a "replica" role, but is not replicating data '.
               'from a master (no output from "SHOW SLAVE STATUS").'));
         } else {
           $ref->setReplicaStatus(self::REPLICATION_OKAY);
         }
 
         if ($is_replica) {
           $latency = idx($replica_status, 'Seconds_Behind_Master');
           if (!strlen($latency)) {
             $ref->setReplicaStatus(self::REPLICATION_NOT_REPLICATING);
           } else {
             $latency = (int)$latency;
             $ref->setReplicaDelay($latency);
             if ($latency > 30) {
               $ref->setReplicaStatus(self::REPLICATION_SLOW);
               $ref->setReplicaMessage(
                 pht(
                   'This replica is lagging far behind the master. Data is at '.
                   'risk!'));
             }
           }
         }
       }
     }
 
     return $refs;
   }
 
   public function newManagementConnection() {
     return $this->newConnection(
       array(
         'retries' => 0,
         'timeout' => 2,
       ));
   }
 
   public function newApplicationConnection($database) {
     return $this->newConnection(
       array(
         'database' => $database,
       ));
   }
 
   public function isSevered() {
     // If we only have an individual database, never sever our connection to
     // it, at least for now. It's possible that using the same severing rules
     // might eventually make sense to help alleviate load-related failures,
     // but we should wait for all the cluster stuff to stabilize first.
     if ($this->getIsIndividual()) {
       return false;
     }
 
     if ($this->didFailToConnect) {
       return true;
     }
 
     $record = $this->getHealthRecord();
     $is_healthy = $record->getIsHealthy();
     if (!$is_healthy) {
       return true;
     }
 
     return false;
   }
 
   public function isReachable(AphrontDatabaseConnection $connection) {
     $record = $this->getHealthRecord();
     $should_check = $record->getShouldCheck();
 
     if ($this->isSevered() && !$should_check) {
       return false;
     }
 
     $this->connectionException = null;
     try {
       $connection->openConnection();
       $reachable = true;
     } catch (AphrontSchemaQueryException $ex) {
       // We get one of these if the database we're trying to select does not
       // exist. In this case, just re-throw the exception. This is expected
       // during first-time setup, when databases like "config" will not exist
       // yet.
       throw $ex;
     } catch (Exception $ex) {
       $this->connectionException = $ex;
       $reachable = false;
     }
 
     if ($should_check) {
       $record->didHealthCheck($reachable);
     }
 
     if (!$reachable) {
       $this->didFailToConnect = true;
     }
 
     return $reachable;
   }
 
   public function checkHealth() {
     $health = $this->getHealthRecord();
 
     $should_check = $health->getShouldCheck();
     if ($should_check) {
       // This does an implicit health update.
       $connection = $this->newManagementConnection();
       $this->isReachable($connection);
     }
 
     return $this;
   }
 
   private function getHealthRecordCacheKey() {
     $host = $this->getHost();
     $port = $this->getPort();
     $key = self::KEY_HEALTH;
 
     return "{$key}({$host}, {$port})";
   }
 
   public function getHealthRecord() {
     if (!$this->healthRecord) {
       $this->healthRecord = new PhabricatorClusterServiceHealthRecord(
         $this->getHealthRecordCacheKey());
     }
     return $this->healthRecord;
   }
 
   public function getConnectionException() {
     return $this->connectionException;
   }
 
   public static function getActiveDatabaseRefs() {
     $refs = array();
 
     foreach (self::getMasterDatabaseRefs() as $ref) {
       $refs[] = $ref;
     }
 
     foreach (self::getReplicaDatabaseRefs() as $ref) {
       $refs[] = $ref;
     }
 
     return $refs;
   }
 
   public static function getAllMasterDatabaseRefs() {
     $refs = self::getClusterRefs();
 
     if (!$refs) {
       return array(self::getLiveIndividualRef());
     }
 
     $masters = array();
     foreach ($refs as $ref) {
       if ($ref->getIsMaster()) {
         $masters[] = $ref;
       }
     }
 
     return $masters;
   }
 
   public static function getMasterDatabaseRefs() {
     $refs = self::getAllMasterDatabaseRefs();
     return self::getEnabledRefs($refs);
   }
 
   public function isApplicationHost($database) {
     return isset($this->applicationMap[$database]);
   }
 
   public function loadRawMySQLConfigValue($key) {
     $conn = $this->newManagementConnection();
 
     try {
       $value = queryfx_one($conn, 'SELECT @@%C', $key);
 
       // NOTE: Although MySQL allows us to escape configuration values as if
       // they are column names, the escaping is included in the column name
       // of the return value: if we select "@@`x`", we get back a column named
       // "@@`x`", not "@@x" as we might expect.
       $value = head($value);
 
     } catch (AphrontQueryException $ex) {
       $value = null;
     }
 
     return $value;
   }
 
   public static function getMasterDatabaseRefForApplication($application) {
     $masters = self::getMasterDatabaseRefs();
 
     $application_master = null;
     $default_master = null;
     foreach ($masters as $master) {
       if ($master->isApplicationHost($application)) {
         $application_master = $master;
         break;
       }
       if ($master->getIsDefaultPartition()) {
         $default_master = $master;
       }
     }
 
     if ($application_master) {
       $masters = array($application_master);
     } else if ($default_master) {
       $masters = array($default_master);
     } else {
       $masters = array();
     }
 
     $masters = self::getEnabledRefs($masters);
     $master = head($masters);
 
     return $master;
   }
 
   public static function newIndividualRef() {
     $default_user = PhabricatorEnv::getEnvConfig('mysql.user');
     $default_pass = new PhutilOpaqueEnvelope(
       PhabricatorEnv::getEnvConfig('mysql.pass'));
     $default_host = PhabricatorEnv::getEnvConfig('mysql.host');
     $default_port = PhabricatorEnv::getEnvConfig('mysql.port');
 
     return id(new self())
       ->setUser($default_user)
       ->setPass($default_pass)
       ->setHost($default_host)
       ->setPort($default_port)
       ->setIsIndividual(true)
       ->setIsMaster(true)
       ->setIsDefaultPartition(true)
       ->setUsePersistentConnections(false);
   }
 
   public static function getAllReplicaDatabaseRefs() {
     $refs = self::getClusterRefs();
 
     if (!$refs) {
       return array();
     }
 
     $replicas = array();
     foreach ($refs as $ref) {
       if ($ref->getIsMaster()) {
         continue;
       }
 
       $replicas[] = $ref;
     }
 
     return $replicas;
   }
 
   public static function getReplicaDatabaseRefs() {
     $refs = self::getAllReplicaDatabaseRefs();
     return self::getEnabledRefs($refs);
   }
 
   private static function getEnabledRefs(array $refs) {
     foreach ($refs as $key => $ref) {
       if ($ref->getDisabled()) {
         unset($refs[$key]);
       }
     }
     return $refs;
   }
 
   public static function getReplicaDatabaseRefForApplication($application) {
     $replicas = self::getReplicaDatabaseRefs();
 
     $application_replicas = array();
     $default_replicas = array();
     foreach ($replicas as $replica) {
       $master = $replica->getMasterRef();
 
       if ($master->isApplicationHost($application)) {
         $application_replicas[] = $replica;
       }
 
       if ($master->getIsDefaultPartition()) {
         $default_replicas[] = $replica;
       }
     }
 
     if ($application_replicas) {
       $replicas = $application_replicas;
     } else {
       $replicas = $default_replicas;
     }
 
     $replicas = self::getEnabledRefs($replicas);
 
     // TODO: We may have multiple replicas to choose from, and could make
     // more of an effort to pick the "best" one here instead of always
     // picking the first one. Once we've picked one, we should try to use
     // the same replica for the rest of the request, though.
 
     return head($replicas);
   }
 
   private function newConnection(array $options) {
     // If we believe the database is unhealthy, don't spend as much time
     // trying to connect to it, since it's likely to continue to fail and
     // hammering it can only make the problem worse.
     $record = $this->getHealthRecord();
     if ($record->getIsHealthy()) {
       $default_retries = 3;
       $default_timeout = 10;
     } else {
       $default_retries = 0;
       $default_timeout = 2;
     }
 
     $spec = $options + array(
       'user' => $this->getUser(),
       'pass' => $this->getPass(),
       'host' => $this->getHost(),
       'port' => $this->getPort(),
       'database' => null,
       'retries' => $default_retries,
       'timeout' => $default_timeout,
       'persistent' => $this->getUsePersistentConnections(),
     );
 
     $is_cli = (php_sapi_name() == 'cli');
 
     $use_persistent = false;
     if (!empty($spec['persistent']) && !$is_cli) {
       $use_persistent = true;
     }
     unset($spec['persistent']);
 
     $connection = self::newRawConnection($spec);
 
     // If configured, use persistent connections. See T11672 for details.
     if ($use_persistent) {
       $connection->setPersistent($use_persistent);
     }
 
     // Unless this is a script running from the CLI, prevent any query from
     // running for more than 30 seconds. See T10849 for details.
     if (!$is_cli) {
       $connection->setQueryTimeout(30);
     }
 
     return $connection;
   }
 
   public static function newRawConnection(array $options) {
     if (extension_loaded('mysqli')) {
       return new AphrontMySQLiDatabaseConnection($options);
     } else {
       return new AphrontMySQLDatabaseConnection($options);
     }
   }
 
 }
diff --git a/src/infrastructure/query/PhabricatorQuery.php b/src/infrastructure/query/PhabricatorQuery.php
index 4315ef79ae..f4ce35adaf 100644
--- a/src/infrastructure/query/PhabricatorQuery.php
+++ b/src/infrastructure/query/PhabricatorQuery.php
@@ -1,97 +1,97 @@
 <?php
 
 /**
  * @task format Formatting Query Clauses
  */
 abstract class PhabricatorQuery extends Phobject {
 
 
   abstract public function execute();
 
 
 /* -(  Formatting Query Clauses  )------------------------------------------- */
 
 
   /**
    * @task format
    */
   protected function formatWhereClause(
     AphrontDatabaseConnection $conn,
     array $parts) {
 
     $parts = $this->flattenSubclause($parts);
     if (!$parts) {
       return qsprintf($conn, '');
     }
 
     return qsprintf($conn, 'WHERE %LA', $parts);
   }
 
 
 
   /**
    * @task format
    */
   protected function formatSelectClause(
     AphrontDatabaseConnection $conn,
     array $parts) {
 
     $parts = $this->flattenSubclause($parts);
     if (!$parts) {
       throw new Exception(pht('Can not build empty SELECT clause!'));
     }
 
     return qsprintf($conn, 'SELECT %LQ', $parts);
   }
 
 
   /**
    * @task format
    */
   protected function formatJoinClause(
     AphrontDatabaseConnection $conn,
     array $parts) {
 
     $parts = $this->flattenSubclause($parts);
     if (!$parts) {
       return qsprintf($conn, '');
     }
 
     return qsprintf($conn, '%LJ', $parts);
   }
 
 
   /**
    * @task format
    */
   protected function formatHavingClause(
     AphrontDatabaseConnection $conn,
     array $parts) {
 
     $parts = $this->flattenSubclause($parts);
     if (!$parts) {
       return qsprintf($conn, '');
     }
 
     return qsprintf($conn, 'HAVING %LA', $parts);
   }
 
 
   /**
    * @task format
    */
   private function flattenSubclause(array $parts) {
     $result = array();
     foreach ($parts as $part) {
       if (is_array($part)) {
         foreach ($this->flattenSubclause($part) as $subpart) {
           $result[] = $subpart;
         }
-      } else if (strlen($part)) {
+      } else if (($part !== null) && strlen($part)) {
         $result[] = $part;
       }
     }
     return $result;
   }
 
 }
diff --git a/src/infrastructure/storage/connection/mysql/AphrontMySQLiDatabaseConnection.php b/src/infrastructure/storage/connection/mysql/AphrontMySQLiDatabaseConnection.php
index 6a0bc759a7..887f4318d2 100644
--- a/src/infrastructure/storage/connection/mysql/AphrontMySQLiDatabaseConnection.php
+++ b/src/infrastructure/storage/connection/mysql/AphrontMySQLiDatabaseConnection.php
@@ -1,272 +1,279 @@
 <?php
 
 /**
  * @phutil-external-symbol class mysqli
  */
 final class AphrontMySQLiDatabaseConnection
   extends AphrontBaseMySQLDatabaseConnection {
 
   private $connectionOpen = false;
 
   public function escapeUTF8String($string) {
     $this->validateUTF8String($string);
     return $this->escapeBinaryString($string);
   }
 
   public function escapeBinaryString($string) {
     return $this->requireConnection()->escape_string($string);
   }
 
   public function getInsertID() {
     return $this->requireConnection()->insert_id;
   }
 
   public function getAffectedRows() {
     return $this->requireConnection()->affected_rows;
   }
 
   protected function closeConnection() {
     if ($this->connectionOpen) {
       $this->requireConnection()->close();
       $this->connectionOpen = false;
     }
   }
 
   protected function connect() {
     if (!class_exists('mysqli', false)) {
       throw new Exception(pht(
         'About to call new %s, but the PHP MySQLi extension is not available!',
         'mysqli()'));
     }
 
     $user = $this->getConfiguration('user');
     $host = $this->getConfiguration('host');
     $port = $this->getConfiguration('port');
     $database = $this->getConfiguration('database');
 
     $pass = $this->getConfiguration('pass');
     if ($pass instanceof PhutilOpaqueEnvelope) {
       $pass = $pass->openEnvelope();
     }
 
     // If the host is "localhost", the port is ignored and mysqli attempts to
     // connect over a socket.
     if ($port) {
       if ($host === 'localhost' || $host === null) {
         $host = '127.0.0.1';
       }
     }
 
+    // See T13588. In PHP 8.1, the default "report mode" for MySQLi has
+    // changed, which causes MySQLi to raise exceptions. Disable exceptions
+    // to align behavior with older default behavior under MySQLi, which
+    // this code expects. Plausibly, this code could be updated to use
+    // MySQLi exceptions to handle errors under a wider range of PHP versions.
+    mysqli_report(MYSQLI_REPORT_OFF);
+
     $conn = mysqli_init();
 
     $timeout = $this->getConfiguration('timeout');
     if ($timeout) {
       $conn->options(MYSQLI_OPT_CONNECT_TIMEOUT, $timeout);
     }
 
     if ($this->getPersistent()) {
       $host = 'p:'.$host;
     }
 
     $trap = new PhutilErrorTrap();
 
     $ok = @$conn->real_connect(
       $host,
       $user,
       $pass,
       $database,
       $port);
 
     $call_error = $trap->getErrorsAsString();
     $trap->destroy();
 
     $errno = $conn->connect_errno;
     if ($errno) {
       $error = $conn->connect_error;
       $this->throwConnectionException($errno, $error, $user, $host);
     }
 
     // See T13403. If the parameters to "real_connect()" are wrong, it may
     // fail without setting an error code. In this case, raise a generic
     // exception. (One way to reproduce this is to pass a string to the
     // "port" parameter.)
 
     if (!$ok) {
       if (strlen($call_error)) {
         $message = pht(
           'mysqli->real_connect() failed: %s',
           $call_error);
       } else {
         $message = pht(
           'mysqli->real_connect() failed, but did not set an error code '.
           'or emit a message.');
       }
 
       $this->throwConnectionException(
         self::CALLERROR_CONNECT,
         $message,
         $user,
         $host);
     }
 
     // See T13238. Attempt to prevent "LOAD DATA LOCAL INFILE", which allows a
     // malicious server to ask the client for any file. At time of writing,
     // this option MUST be set after "real_connect()" on all PHP versions.
     $conn->options(MYSQLI_OPT_LOCAL_INFILE, 0);
 
     $this->connectionOpen = true;
 
     $ok = @$conn->set_charset('utf8mb4');
     if (!$ok) {
       $ok = $conn->set_charset('binary');
     }
 
     return $conn;
   }
 
   protected function rawQuery($raw_query) {
     $conn = $this->requireConnection();
     $time_limit = $this->getQueryTimeout();
 
     // If we have a query time limit, run this query synchronously but use
     // the async API. This allows us to kill queries which take too long
     // without requiring any configuration on the server side.
     if ($time_limit && $this->supportsAsyncQueries()) {
       $conn->query($raw_query, MYSQLI_ASYNC);
 
       $read = array($conn);
       $error = array($conn);
       $reject = array($conn);
 
       $result = mysqli::poll($read, $error, $reject, $time_limit);
 
       if ($result === false) {
         $this->closeConnection();
         throw new Exception(
           pht('Failed to poll mysqli connection!'));
       } else if ($result === 0) {
         $this->closeConnection();
         throw new AphrontQueryTimeoutQueryException(
           pht(
             'Query timed out after %s second(s)!',
             new PhutilNumber($time_limit)));
       }
 
       return @$conn->reap_async_query();
     }
 
     $trap = new PhutilErrorTrap();
 
     $result = @$conn->query($raw_query);
 
     $err = $trap->getErrorsAsString();
     $trap->destroy();
 
     // See T13238 and PHI1014. Sometimes, the call to "$conn->query()" may fail
     // without setting an error code on the connection. One way to reproduce
     // this is to use "LOAD DATA LOCAL INFILE" with "mysqli.allow_local_infile"
     // disabled.
 
     // If we have no result and no error code, raise a synthetic query error
     // with whatever error message was raised as a local PHP warning.
 
     if (!$result) {
       $error_code = $this->getErrorCode($conn);
       if (!$error_code) {
         if (strlen($err)) {
           $message = $err;
          } else {
           $message = pht(
             'Call to "mysqli->query()" failed, but did not set an error '.
             'code or emit an error message.');
         }
         $this->throwQueryCodeException(self::CALLERROR_QUERY, $message);
       }
     }
 
     return $result;
   }
 
   protected function rawQueries(array $raw_queries) {
     $conn = $this->requireConnection();
 
     $have_result = false;
     $results = array();
 
     foreach ($raw_queries as $key => $raw_query) {
       if (!$have_result) {
         // End line in front of semicolon to allow single line comments at the
         // end of queries.
         $have_result = $conn->multi_query(implode("\n;\n\n", $raw_queries));
       } else {
         $have_result = $conn->next_result();
       }
 
       array_shift($raw_queries);
 
       $result = $conn->store_result();
       if (!$result && !$this->getErrorCode($conn)) {
         $result = true;
       }
       $results[$key] = $this->processResult($result);
     }
 
     if ($conn->more_results()) {
       throw new Exception(
         pht('There are some results left in the result set.'));
     }
 
     return $results;
   }
 
   protected function freeResult($result) {
     $result->free_result();
   }
 
   protected function fetchAssoc($result) {
     return $result->fetch_assoc();
   }
 
   protected function getErrorCode($connection) {
     return $connection->errno;
   }
 
   protected function getErrorDescription($connection) {
     return $connection->error;
   }
 
   public function supportsAsyncQueries() {
     return defined('MYSQLI_ASYNC');
   }
 
   public function asyncQuery($raw_query) {
     $this->checkWrite($raw_query);
     $async = $this->beginAsyncConnection();
     $async->query($raw_query, MYSQLI_ASYNC);
     return $async;
   }
 
   public static function resolveAsyncQueries(array $conns, array $asyncs) {
     assert_instances_of($conns, __CLASS__);
     assert_instances_of($asyncs, 'mysqli');
 
     $read = $error = $reject = array();
     foreach ($asyncs as $async) {
       $read[] = $error[] = $reject[] = $async;
     }
 
     if (!mysqli::poll($read, $error, $reject, 0)) {
       return array();
     }
 
     $results = array();
     foreach ($read as $async) {
       $key = array_search($async, $asyncs, $strict = true);
       $conn = $conns[$key];
       $conn->endAsyncConnection($async);
       $results[$key] = $conn->processResult($async->reap_async_query());
     }
     return $results;
   }
 
 }
diff --git a/src/infrastructure/storage/lisk/LiskDAO.php b/src/infrastructure/storage/lisk/LiskDAO.php
index 13b2f8d319..2e81b4641a 100644
--- a/src/infrastructure/storage/lisk/LiskDAO.php
+++ b/src/infrastructure/storage/lisk/LiskDAO.php
@@ -1,1912 +1,1912 @@
 <?php
 
 /**
  * Simple object-authoritative data access object that makes it easy to build
  * stuff that you need to save to a database. Basically, it means that the
  * amount of boilerplate code (and, particularly, boilerplate SQL) you need
  * to write is greatly reduced.
  *
  * Lisk makes it fairly easy to build something quickly and end up with
  * reasonably high-quality code when you're done (e.g., getters and setters,
  * objects, transactions, reasonably structured OO code). It's also very thin:
  * you can break past it and use MySQL and other lower-level tools when you
  * need to in those couple of cases where it doesn't handle your workflow
  * gracefully.
  *
  * However, Lisk won't scale past one database and lacks many of the features
  * of modern DAOs like Hibernate: for instance, it does not support joins or
  * polymorphic storage.
  *
  * This means that Lisk is well-suited for tools like Differential, but often a
  * poor choice elsewhere. And it is strictly unsuitable for many projects.
  *
  * Lisk's model is object-authoritative: the PHP class definition is the
  * master authority for what the object looks like.
  *
  * =Building New Objects=
  *
  * To create new Lisk objects, extend @{class:LiskDAO} and implement
  * @{method:establishLiveConnection}. It should return an
  * @{class:AphrontDatabaseConnection}; this will tell Lisk where to save your
  * objects.
  *
  *   class Dog extends LiskDAO {
  *
  *     protected $name;
  *     protected $breed;
  *
  *     public function establishLiveConnection() {
  *       return $some_connection_object;
  *     }
  *   }
  *
  * Now, you should create your table:
  *
  *   lang=sql
  *   CREATE TABLE dog (
  *     id int unsigned not null auto_increment primary key,
  *     name varchar(32) not null,
  *     breed varchar(32) not null,
  *     dateCreated int unsigned not null,
  *     dateModified int unsigned not null
  *   );
  *
  * For each property in your class, add a column with the same name to the table
  * (see @{method:getConfiguration} for information about changing this mapping).
  * Additionally, you should create the three columns `id`,  `dateCreated` and
  * `dateModified`. Lisk will automatically manage these, using them to implement
  * autoincrement IDs and timestamps. If you do not want to use these features,
  * see @{method:getConfiguration} for information on disabling them. At a bare
  * minimum, you must normally have an `id` column which is a primary or unique
  * key with a numeric type, although you can change its name by overriding
  * @{method:getIDKey} or disable it entirely by overriding @{method:getIDKey} to
  * return null. Note that many methods rely on a single-part primary key and
  * will no longer work (they will throw) if you disable it.
  *
  * As you add more properties to your class in the future, remember to add them
  * to the database table as well.
  *
  * Lisk will now automatically handle these operations: getting and setting
  * properties, saving objects, loading individual objects, loading groups
  * of objects, updating objects, managing IDs, updating timestamps whenever
  * an object is created or modified, and some additional specialized
  * operations.
  *
  * = Creating, Retrieving, Updating, and Deleting =
  *
  * To create and persist a Lisk object, use @{method:save}:
  *
  *   $dog = id(new Dog())
  *     ->setName('Sawyer')
  *     ->setBreed('Pug')
  *     ->save();
  *
  * Note that **Lisk automatically builds getters and setters for all of your
  * object's protected properties** via @{method:__call}. If you want to add
  * custom behavior to your getters or setters, you can do so by overriding the
  * @{method:readField} and @{method:writeField} methods.
  *
  * Calling @{method:save} will persist the object to the database. After calling
  * @{method:save}, you can call @{method:getID} to retrieve the object's ID.
  *
  * To load objects by ID, use the @{method:load} method:
  *
  *   $dog = id(new Dog())->load($id);
  *
  * This will load the Dog record with ID $id into $dog, or `null` if no such
  * record exists (@{method:load} is an instance method rather than a static
  * method because PHP does not support late static binding, at least until PHP
  * 5.3).
  *
  * To update an object, change its properties and save it:
  *
  *   $dog->setBreed('Lab')->save();
  *
  * To delete an object, call @{method:delete}:
  *
  *   $dog->delete();
  *
  * That's Lisk CRUD in a nutshell.
  *
  * = Queries =
  *
  * Often, you want to load a bunch of objects, or execute a more specialized
  * query. Use @{method:loadAllWhere} or @{method:loadOneWhere} to do this:
  *
  *   $pugs = $dog->loadAllWhere('breed = %s', 'Pug');
  *   $sawyer = $dog->loadOneWhere('name = %s', 'Sawyer');
  *
  * These methods work like @{function@arcanist:queryfx}, but only take half of
  * a query (the part after the WHERE keyword). Lisk will handle the connection,
  * columns, and object construction; you are responsible for the rest of it.
  * @{method:loadAllWhere} returns a list of objects, while
  * @{method:loadOneWhere} returns a single object (or `null`).
  *
  * There's also a @{method:loadRelatives} method which helps to prevent the 1+N
  * queries problem.
  *
  * = Managing Transactions =
  *
  * Lisk uses a transaction stack, so code does not generally need to be aware
  * of the transactional state of objects to implement correct transaction
  * semantics:
  *
  *   $obj->openTransaction();
  *     $obj->save();
  *     $other->save();
  *     // ...
  *     $other->openTransaction();
  *       $other->save();
  *       $another->save();
  *     if ($some_condition) {
  *       $other->saveTransaction();
  *     } else {
  *       $other->killTransaction();
  *     }
  *     // ...
  *   $obj->saveTransaction();
  *
  * Assuming ##$obj##, ##$other## and ##$another## live on the same database,
  * this code will work correctly by establishing savepoints.
  *
  * Selects whose data are used later in the transaction should be included in
  * @{method:beginReadLocking} or @{method:beginWriteLocking} block.
  *
  * @task   conn    Managing Connections
  * @task   config  Configuring Lisk
  * @task   load    Loading Objects
  * @task   info    Examining Objects
  * @task   save    Writing Objects
  * @task   hook    Hooks and Callbacks
  * @task   util    Utilities
  * @task   xaction Managing Transactions
  * @task   isolate Isolation for Unit Testing
  */
 abstract class LiskDAO extends Phobject
   implements AphrontDatabaseTableRefInterface {
 
   const CONFIG_IDS                  = 'id-mechanism';
   const CONFIG_TIMESTAMPS           = 'timestamps';
   const CONFIG_AUX_PHID             = 'auxiliary-phid';
   const CONFIG_SERIALIZATION        = 'col-serialization';
   const CONFIG_BINARY               = 'binary';
   const CONFIG_COLUMN_SCHEMA        = 'col-schema';
   const CONFIG_KEY_SCHEMA           = 'key-schema';
   const CONFIG_NO_TABLE             = 'no-table';
   const CONFIG_NO_MUTATE            = 'no-mutate';
 
   const SERIALIZATION_NONE          = 'id';
   const SERIALIZATION_JSON          = 'json';
   const SERIALIZATION_PHP           = 'php';
 
   const IDS_AUTOINCREMENT           = 'ids-auto';
   const IDS_COUNTER                 = 'ids-counter';
   const IDS_MANUAL                  = 'ids-manual';
 
   const COUNTER_TABLE_NAME          = 'lisk_counter';
 
   private static $processIsolationLevel     = 0;
   private static $transactionIsolationLevel = 0;
 
   private $ephemeral = false;
   private $forcedConnection;
 
   private static $connections       = array();
 
+  private static $liskMetadata = array();
+
   protected $id;
   protected $phid;
   protected $dateCreated;
   protected $dateModified;
 
   /**
    *  Build an empty object.
    *
    *  @return obj Empty object.
    */
   public function __construct() {
     $id_key = $this->getIDKey();
     if ($id_key) {
       $this->$id_key = null;
     }
   }
 
 
 /* -(  Managing Connections  )----------------------------------------------- */
 
 
   /**
    * Establish a live connection to a database service. This method should
    * return a new connection. Lisk handles connection caching and management;
    * do not perform caching deeper in the stack.
    *
    * @param string Mode, either 'r' (reading) or 'w' (reading and writing).
    * @return AphrontDatabaseConnection New database connection.
    * @task conn
    */
   abstract protected function establishLiveConnection($mode);
 
 
   /**
    * Return a namespace for this object's connections in the connection cache.
    * Generally, the database name is appropriate. Two connections are considered
    * equivalent if they have the same connection namespace and mode.
    *
    * @return string Connection namespace for cache
    * @task conn
    */
   protected function getConnectionNamespace() {
     return $this->getDatabaseName();
   }
 
   abstract protected function getDatabaseName();
 
   /**
    * Get an existing, cached connection for this object.
    *
    * @param mode Connection mode.
    * @return AphrontDatabaseConnection|null  Connection, if it exists in cache.
    * @task conn
    */
   protected function getEstablishedConnection($mode) {
     $key = $this->getConnectionNamespace().':'.$mode;
     if (isset(self::$connections[$key])) {
       return self::$connections[$key];
     }
     return null;
   }
 
 
   /**
    * Store a connection in the connection cache.
    *
    * @param mode Connection mode.
    * @param AphrontDatabaseConnection Connection to cache.
    * @return this
    * @task conn
    */
   protected function setEstablishedConnection(
     $mode,
     AphrontDatabaseConnection $connection,
     $force_unique = false) {
 
     $key = $this->getConnectionNamespace().':'.$mode;
 
     if ($force_unique) {
       $key .= ':unique';
       while (isset(self::$connections[$key])) {
         $key .= '!';
       }
     }
 
     self::$connections[$key] = $connection;
     return $this;
   }
 
 
   /**
    * Force an object to use a specific connection.
    *
    * This overrides all connection management and forces the object to use
    * a specific connection when interacting with the database.
    *
    * @param AphrontDatabaseConnection Connection to force this object to use.
    * @task conn
    */
   public function setForcedConnection(AphrontDatabaseConnection $connection) {
     $this->forcedConnection = $connection;
     return $this;
   }
 
 
 /* -(  Configuring Lisk  )--------------------------------------------------- */
 
 
   /**
    * Change Lisk behaviors, like ID configuration and timestamps. If you want
    * to change these behaviors, you should override this method in your child
    * class and change the options you're interested in. For example:
    *
    *   protected function getConfiguration() {
    *     return array(
    *       Lisk_DataAccessObject::CONFIG_EXAMPLE => true,
    *     ) + parent::getConfiguration();
    *   }
    *
    * The available options are:
    *
    * CONFIG_IDS
    * Lisk objects need to have a unique identifying ID. The three mechanisms
    * available for generating this ID are IDS_AUTOINCREMENT (default, assumes
    * the ID column is an autoincrement primary key), IDS_MANUAL (you are taking
    * full responsibility for ID management), or IDS_COUNTER (see below).
    *
    * InnoDB does not persist the value of `auto_increment` across restarts,
    * and instead initializes it to `MAX(id) + 1` during startup. This means it
    * may reissue the same autoincrement ID more than once, if the row is deleted
    * and then the database is restarted. To avoid this, you can set an object to
    * use a counter table with IDS_COUNTER. This will generally behave like
    * IDS_AUTOINCREMENT, except that the counter value will persist across
    * restarts and inserts will be slightly slower. If a database stores any
    * DAOs which use this mechanism, you must create a table there with this
    * schema:
    *
    *   CREATE TABLE lisk_counter (
    *     counterName VARCHAR(64) COLLATE utf8_bin PRIMARY KEY,
    *     counterValue BIGINT UNSIGNED NOT NULL
    *   ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    *
    * CONFIG_TIMESTAMPS
    * Lisk can automatically handle keeping track of a `dateCreated' and
    * `dateModified' column, which it will update when it creates or modifies
    * an object. If you don't want to do this, you may disable this option.
    * By default, this option is ON.
    *
    * CONFIG_AUX_PHID
    * This option can be enabled by being set to some truthy value. The meaning
    * of this value is defined by your PHID generation mechanism. If this option
    * is enabled, a `phid' property will be populated with a unique PHID when an
    * object is created (or if it is saved and does not currently have one). You
    * need to override generatePHID() and hook it into your PHID generation
    * mechanism for this to work. By default, this option is OFF.
    *
    * CONFIG_SERIALIZATION
    * You can optionally provide a column serialization map that will be applied
    * to values when they are written to the database. For example:
    *
    *   self::CONFIG_SERIALIZATION => array(
    *     'complex' => self::SERIALIZATION_JSON,
    *   )
    *
    * This will cause Lisk to JSON-serialize the 'complex' field before it is
    * written, and unserialize it when it is read.
    *
    * CONFIG_BINARY
    * You can optionally provide a map of columns to a flag indicating that
    * they store binary data. These columns will not raise an error when
    * handling binary writes.
    *
    * CONFIG_COLUMN_SCHEMA
    * Provide a map of columns to schema column types.
    *
    * CONFIG_KEY_SCHEMA
    * Provide a map of key names to key specifications.
    *
    * CONFIG_NO_TABLE
    * Allows you to specify that this object does not actually have a table in
    * the database.
    *
    * CONFIG_NO_MUTATE
    * Provide a map of columns which should not be included in UPDATE statements.
    * If you have some columns which are always written to explicitly and should
    * never be overwritten by a save(), you can specify them here. This is an
    * advanced, specialized feature and there are usually better approaches for
    * most locking/contention problems.
    *
    * @return dictionary  Map of configuration options to values.
    *
    * @task   config
    */
   protected function getConfiguration() {
     return array(
       self::CONFIG_IDS                      => self::IDS_AUTOINCREMENT,
       self::CONFIG_TIMESTAMPS               => true,
     );
   }
 
 
   /**
    *  Determine the setting of a configuration option for this class of objects.
    *
    *  @param  const       Option name, one of the CONFIG_* constants.
    *  @return mixed       Option value, if configured (null if unavailable).
    *
    *  @task   config
    */
   public function getConfigOption($option_name) {
-    static $options = null;
+    $options = $this->getLiskMetadata('config');
 
-    if (!isset($options)) {
+    if ($options === null) {
       $options = $this->getConfiguration();
+      $this->setLiskMetadata('config', $options);
     }
 
     return idx($options, $option_name);
   }
 
 
 /* -(  Loading Objects  )---------------------------------------------------- */
 
 
   /**
    * Load an object by ID. You need to invoke this as an instance method, not
    * a class method, because PHP doesn't have late static binding (until
    * PHP 5.3.0). For example:
    *
    *   $dog = id(new Dog())->load($dog_id);
    *
    * @param  int       Numeric ID identifying the object to load.
    * @return obj|null  Identified object, or null if it does not exist.
    *
    * @task   load
    */
   public function load($id) {
     if (is_object($id)) {
       $id = (string)$id;
     }
 
     if (!$id || (!is_int($id) && !ctype_digit($id))) {
       return null;
     }
 
     return $this->loadOneWhere(
       '%C = %d',
-      $this->getIDKeyForUse(),
+      $this->getIDKey(),
       $id);
   }
 
 
   /**
    * Loads all of the objects, unconditionally.
    *
    * @return dict    Dictionary of all persisted objects of this type, keyed
    *                 on object ID.
    *
    * @task   load
    */
   public function loadAll() {
     return $this->loadAllWhere('1 = 1');
   }
 
 
   /**
    * Load all objects which match a WHERE clause. You provide everything after
    * the 'WHERE'; Lisk handles everything up to it. For example:
    *
    *   $old_dogs = id(new Dog())->loadAllWhere('age > %d', 7);
    *
    * The pattern and arguments are as per queryfx().
    *
    * @param  string  queryfx()-style SQL WHERE clause.
    * @param  ...     Zero or more conversions.
    * @return dict    Dictionary of matching objects, keyed on ID.
    *
    * @task   load
    */
   public function loadAllWhere($pattern /* , $arg, $arg, $arg ... */) {
     $args = func_get_args();
     $data = call_user_func_array(
       array($this, 'loadRawDataWhere'),
       $args);
     return $this->loadAllFromArray($data);
   }
 
 
   /**
    * Load a single object identified by a 'WHERE' clause. You provide
    * everything after the 'WHERE', and Lisk builds the first half of the
    * query. See loadAllWhere(). This method is similar, but returns a single
    * result instead of a list.
    *
    * @param  string    queryfx()-style SQL WHERE clause.
    * @param  ...       Zero or more conversions.
    * @return obj|null  Matching object, or null if no object matches.
    *
    * @task   load
    */
   public function loadOneWhere($pattern /* , $arg, $arg, $arg ... */) {
     $args = func_get_args();
     $data = call_user_func_array(
       array($this, 'loadRawDataWhere'),
       $args);
 
     if (count($data) > 1) {
       throw new AphrontCountQueryException(
         pht(
           'More than one result from %s!',
           __FUNCTION__.'()'));
     }
 
     $data = reset($data);
     if (!$data) {
       return null;
     }
 
     return $this->loadFromArray($data);
   }
 
 
   protected function loadRawDataWhere($pattern /* , $args... */) {
     $conn = $this->establishConnection('r');
 
     if ($conn->isReadLocking()) {
       $lock_clause = qsprintf($conn, 'FOR UPDATE');
     } else if ($conn->isWriteLocking()) {
       $lock_clause = qsprintf($conn, 'LOCK IN SHARE MODE');
     } else {
       $lock_clause = qsprintf($conn, '');
     }
 
     $args = func_get_args();
     $args = array_slice($args, 1);
 
     $pattern = 'SELECT * FROM %R WHERE '.$pattern.' %Q';
     array_unshift($args, $this);
     array_push($args, $lock_clause);
     array_unshift($args, $pattern);
 
     return call_user_func_array(array($conn, 'queryData'), $args);
   }
 
 
   /**
    * Reload an object from the database, discarding any changes to persistent
    * properties. This is primarily useful after entering a transaction but
    * before applying changes to an object.
    *
    * @return this
    *
    * @task   load
    */
   public function reload() {
     if (!$this->getID()) {
       throw new Exception(
         pht("Unable to reload object that hasn't been loaded!"));
     }
 
     $result = $this->loadOneWhere(
       '%C = %d',
-      $this->getIDKeyForUse(),
+      $this->getIDKey(),
       $this->getID());
 
     if (!$result) {
       throw new AphrontObjectMissingQueryException();
     }
 
     return $this;
   }
 
 
   /**
    * Initialize this object's properties from a dictionary. Generally, you
    * load single objects with loadOneWhere(), but sometimes it may be more
    * convenient to pull data from elsewhere directly (e.g., a complicated
    * join via @{method:queryData}) and then load from an array representation.
    *
    * @param  dict  Dictionary of properties, which should be equivalent to
    *               selecting a row from the table or calling
    *               @{method:getProperties}.
    * @return this
    *
    * @task   load
    */
   public function loadFromArray(array $row) {
-    static $valid_properties = array();
+    $valid_map = $this->getLiskMetadata('validMap', array());
 
     $map = array();
+    $updated = false;
     foreach ($row as $k => $v) {
       // We permit (but ignore) extra properties in the array because a
       // common approach to building the array is to issue a raw SELECT query
       // which may include extra explicit columns or joins.
 
       // This pathway is very hot on some pages, so we're inlining a cache
       // and doing some microoptimization to avoid a strtolower() call for each
       // assignment. The common path (assigning a valid property which we've
       // already seen) always incurs only one empty(). The second most common
       // path (assigning an invalid property which we've already seen) costs
       // an empty() plus an isset().
 
-      if (empty($valid_properties[$k])) {
-        if (isset($valid_properties[$k])) {
+      if (empty($valid_map[$k])) {
+        if (isset($valid_map[$k])) {
           // The value is set but empty, which means it's false, so we've
           // already determined it's not valid. We don't need to check again.
           continue;
         }
-        $valid_properties[$k] = $this->hasProperty($k);
-        if (!$valid_properties[$k]) {
+        $valid_map[$k] = $this->hasProperty($k);
+        $updated = true;
+        if (!$valid_map[$k]) {
           continue;
         }
       }
 
       $map[$k] = $v;
     }
 
+    if ($updated) {
+      $this->setLiskMetadata('validMap', $valid_map);
+    }
+
     $this->willReadData($map);
 
     foreach ($map as $prop => $value) {
       $this->$prop = $value;
     }
 
     $this->didReadData();
 
     return $this;
   }
 
 
   /**
    * Initialize a list of objects from a list of dictionaries. Usually you
    * load lists of objects with @{method:loadAllWhere}, but sometimes that
    * isn't flexible enough. One case is if you need to do joins to select the
    * right objects:
    *
    *   function loadAllWithOwner($owner) {
    *     $data = $this->queryData(
    *       'SELECT d.*
    *         FROM owner o
    *           JOIN owner_has_dog od ON o.id = od.ownerID
    *           JOIN dog d ON od.dogID = d.id
    *         WHERE o.id = %d',
    *       $owner);
    *     return $this->loadAllFromArray($data);
    *   }
    *
    * This is a lot messier than @{method:loadAllWhere}, but more flexible.
    *
    * @param  list  List of property dictionaries.
    * @return dict  List of constructed objects, keyed on ID.
    *
    * @task   load
    */
   public function loadAllFromArray(array $rows) {
     $result = array();
 
     $id_key = $this->getIDKey();
 
     foreach ($rows as $row) {
       $obj = clone $this;
       if ($id_key && isset($row[$id_key])) {
         $row_id = $row[$id_key];
 
         if (isset($result[$row_id])) {
           throw new Exception(
             pht(
               'Rows passed to "loadAllFromArray(...)" include two or more '.
               'rows with the same ID ("%s"). Rows must have unique IDs. '.
               'An underlying query may be missing a GROUP BY.',
               $row_id));
         }
 
         $result[$row_id] = $obj->loadFromArray($row);
       } else {
         $result[] = $obj->loadFromArray($row);
       }
     }
 
     return $result;
   }
 
 
 /* -(  Examining Objects  )-------------------------------------------------- */
 
 
   /**
    * Set unique ID identifying this object. You normally don't need to call this
    * method unless with `IDS_MANUAL`.
    *
    * @param  mixed   Unique ID.
    * @return this
    * @task   save
    */
   public function setID($id) {
-    static $id_key = null;
-    if ($id_key === null) {
-      $id_key = $this->getIDKeyForUse();
-    }
+    $id_key = $this->getIDKey();
     $this->$id_key = $id;
     return $this;
   }
 
 
   /**
    * Retrieve the unique ID identifying this object. This value will be null if
    * the object hasn't been persisted and you didn't set it manually.
    *
    * @return mixed   Unique ID.
    *
    * @task   info
    */
   public function getID() {
-    static $id_key = null;
-    if ($id_key === null) {
-      $id_key = $this->getIDKeyForUse();
-    }
+    $id_key = $this->getIDKey();
     return $this->$id_key;
   }
 
 
   public function getPHID() {
     return $this->phid;
   }
 
 
   /**
    * Test if a property exists.
    *
    * @param   string    Property name.
    * @return  bool      True if the property exists.
    * @task info
    */
   public function hasProperty($property) {
     return (bool)$this->checkProperty($property);
   }
 
 
   /**
    * Retrieve a list of all object properties. This list only includes
    * properties that are declared as protected, and it is expected that
    * all properties returned by this function should be persisted to the
    * database.
    * Properties that should not be persisted must be declared as private.
    *
    * @return dict  Dictionary of normalized (lowercase) to canonical (original
    *               case) property names.
    *
    * @task   info
    */
   protected function getAllLiskProperties() {
-    static $properties = null;
-    if (!isset($properties)) {
-      $class = new ReflectionClass(get_class($this));
+    $properties = $this->getLiskMetadata('properties');
+
+    if ($properties === null) {
+      $class = new ReflectionClass(static::class);
       $properties = array();
       foreach ($class->getProperties(ReflectionProperty::IS_PROTECTED) as $p) {
         $properties[strtolower($p->getName())] = $p->getName();
       }
 
       $id_key = $this->getIDKey();
       if ($id_key != 'id') {
         unset($properties['id']);
       }
 
       if (!$this->getConfigOption(self::CONFIG_TIMESTAMPS)) {
         unset($properties['datecreated']);
         unset($properties['datemodified']);
       }
 
       if ($id_key != 'phid' && !$this->getConfigOption(self::CONFIG_AUX_PHID)) {
         unset($properties['phid']);
       }
+
+      $this->setLiskMetadata('properties', $properties);
     }
+
     return $properties;
   }
 
 
   /**
    * Check if a property exists on this object.
    *
    * @return string|null   Canonical property name, or null if the property
    *                       does not exist.
    *
    * @task   info
    */
   protected function checkProperty($property) {
-    static $properties = null;
-    if ($properties === null) {
-      $properties = $this->getAllLiskProperties();
-    }
+    $properties = $this->getAllLiskProperties();
 
     $property = strtolower($property);
     if (empty($properties[$property])) {
       return null;
     }
 
     return $properties[$property];
   }
 
 
   /**
    * Get or build the database connection for this object.
    *
    * @param  string 'r' for read, 'w' for read/write.
    * @param  bool True to force a new connection. The connection will not
    *              be retrieved from or saved into the connection cache.
    * @return AphrontDatabaseConnection   Lisk connection object.
    *
    * @task   info
    */
   public function establishConnection($mode, $force_new = false) {
     if ($mode != 'r' && $mode != 'w') {
       throw new Exception(
         pht(
           "Unknown mode '%s', should be 'r' or 'w'.",
           $mode));
     }
 
     if ($this->forcedConnection) {
       return $this->forcedConnection;
     }
 
     if (self::shouldIsolateAllLiskEffectsToCurrentProcess()) {
       $mode = 'isolate-'.$mode;
 
       $connection = $this->getEstablishedConnection($mode);
       if (!$connection) {
         $connection = $this->establishIsolatedConnection($mode);
         $this->setEstablishedConnection($mode, $connection);
       }
 
       return $connection;
     }
 
     if (self::shouldIsolateAllLiskEffectsToTransactions()) {
       // If we're doing fixture transaction isolation, force the mode to 'w'
       // so we always get the same connection for reads and writes, and thus
       // can see the writes inside the transaction.
       $mode = 'w';
     }
 
     // TODO: There is currently no protection on 'r' queries against writing.
 
     $connection = null;
     if (!$force_new) {
       if ($mode == 'r') {
         // If we're requesting a read connection but already have a write
         // connection, reuse the write connection so that reads can take place
         // inside transactions.
         $connection = $this->getEstablishedConnection('w');
       }
 
       if (!$connection) {
         $connection = $this->getEstablishedConnection($mode);
       }
     }
 
     if (!$connection) {
       $connection = $this->establishLiveConnection($mode);
       if (self::shouldIsolateAllLiskEffectsToTransactions()) {
         $connection->openTransaction();
       }
       $this->setEstablishedConnection(
         $mode,
         $connection,
         $force_unique = $force_new);
     }
 
     return $connection;
   }
 
 
   /**
    * Convert this object into a property dictionary. This dictionary can be
    * restored into an object by using @{method:loadFromArray} (unless you're
    * using legacy features with CONFIG_CONVERT_CAMELCASE, but in that case you
    * should just go ahead and die in a fire).
    *
    * @return dict  Dictionary of object properties.
    *
    * @task   info
    */
   protected function getAllLiskPropertyValues() {
     $map = array();
     foreach ($this->getAllLiskProperties() as $p) {
       // We may receive a warning here for properties we've implicitly added
       // through configuration; squelch it.
       $map[$p] = @$this->$p;
     }
     return $map;
   }
 
 
 /* -(  Writing Objects  )---------------------------------------------------- */
 
 
   /**
    * Make an object read-only.
    *
    * Making an object ephemeral indicates that you will be changing state in
    * such a way that you would never ever want it to be written back to the
    * storage.
    */
   public function makeEphemeral() {
     $this->ephemeral = true;
     return $this;
   }
 
   private function isEphemeralCheck() {
     if ($this->ephemeral) {
       throw new LiskEphemeralObjectException();
     }
   }
 
   /**
    * Persist this object to the database. In most cases, this is the only
    * method you need to call to do writes. If the object has not yet been
    * inserted this will do an insert; if it has, it will do an update.
    *
    * @return this
    *
    * @task   save
    */
   public function save() {
     if ($this->shouldInsertWhenSaved()) {
       return $this->insert();
     } else {
       return $this->update();
     }
   }
 
 
   /**
    * Save this object, forcing the query to use REPLACE regardless of object
    * state.
    *
    * @return this
    *
    * @task   save
    */
   public function replace() {
     $this->isEphemeralCheck();
     return $this->insertRecordIntoDatabase('REPLACE');
   }
 
 
   /**
    * Save this object, forcing the query to use INSERT regardless of object
    * state.
    *
    * @return this
    *
    * @task   save
    */
   public function insert() {
     $this->isEphemeralCheck();
     return $this->insertRecordIntoDatabase('INSERT');
   }
 
 
   /**
    * Save this object, forcing the query to use UPDATE regardless of object
    * state.
    *
    * @return this
    *
    * @task   save
    */
   public function update() {
     $this->isEphemeralCheck();
 
     $this->willSaveObject();
     $data = $this->getAllLiskPropertyValues();
 
     // Remove columns flagged as nonmutable from the update statement.
     $no_mutate = $this->getConfigOption(self::CONFIG_NO_MUTATE);
     if ($no_mutate) {
       foreach ($no_mutate as $column) {
         unset($data[$column]);
       }
     }
 
     $this->willWriteData($data);
 
     $map = array();
     foreach ($data as $k => $v) {
       $map[$k] = $v;
     }
 
     $conn = $this->establishConnection('w');
     $binary = $this->getBinaryColumns();
 
     foreach ($map as $key => $value) {
       if (!empty($binary[$key])) {
         $map[$key] = qsprintf($conn, '%C = %nB', $key, $value);
       } else {
         $map[$key] = qsprintf($conn, '%C = %ns', $key, $value);
       }
     }
 
     $id = $this->getID();
     $conn->query(
       'UPDATE %R SET %LQ WHERE %C = '.(is_int($id) ? '%d' : '%s'),
       $this,
       $map,
-      $this->getIDKeyForUse(),
+      $this->getIDKey(),
       $id);
     // We can't detect a missing object because updating an object without
     // changing any values doesn't affect rows. We could jiggle timestamps
     // to catch this for objects which track them if we wanted.
 
     $this->didWriteData();
 
     return $this;
   }
 
 
   /**
    * Delete this object, permanently.
    *
    * @return this
    *
    * @task   save
    */
   public function delete() {
     $this->isEphemeralCheck();
     $this->willDelete();
 
     $conn = $this->establishConnection('w');
     $conn->query(
       'DELETE FROM %R WHERE %C = %d',
       $this,
-      $this->getIDKeyForUse(),
+      $this->getIDKey(),
       $this->getID());
 
     $this->didDelete();
 
     return $this;
   }
 
   /**
    * Internal implementation of INSERT and REPLACE.
    *
    * @param  const   Either "INSERT" or "REPLACE", to force the desired mode.
    * @return this
    *
    * @task   save
    */
   protected function insertRecordIntoDatabase($mode) {
     $this->willSaveObject();
     $data = $this->getAllLiskPropertyValues();
 
     $conn = $this->establishConnection('w');
 
     $id_mechanism = $this->getConfigOption(self::CONFIG_IDS);
     switch ($id_mechanism) {
       case self::IDS_AUTOINCREMENT:
         // If we are using autoincrement IDs, let MySQL assign the value for the
         // ID column, if it is empty. If the caller has explicitly provided a
         // value, use it.
-        $id_key = $this->getIDKeyForUse();
+        $id_key = $this->getIDKey();
         if (empty($data[$id_key])) {
           unset($data[$id_key]);
         }
         break;
       case self::IDS_COUNTER:
         // If we are using counter IDs, assign a new ID if we don't already have
         // one.
-        $id_key = $this->getIDKeyForUse();
+        $id_key = $this->getIDKey();
         if (empty($data[$id_key])) {
           $counter_name = $this->getTableName();
           $id = self::loadNextCounterValue($conn, $counter_name);
           $this->setID($id);
           $data[$id_key] = $id;
         }
         break;
       case self::IDS_MANUAL:
         break;
       default:
         throw new Exception(pht('Unknown %s mechanism!', 'CONFIG_IDs'));
     }
 
     $this->willWriteData($data);
 
     $columns = array_keys($data);
     $binary = $this->getBinaryColumns();
 
     foreach ($data as $key => $value) {
       try {
         if (!empty($binary[$key])) {
           $data[$key] = qsprintf($conn, '%nB', $value);
         } else {
           $data[$key] = qsprintf($conn, '%ns', $value);
         }
       } catch (AphrontParameterQueryException $parameter_exception) {
         throw new PhutilProxyException(
           pht(
             "Unable to insert or update object of class %s, field '%s' ".
             "has a non-scalar value.",
             get_class($this),
             $key),
           $parameter_exception);
       }
     }
 
     switch ($mode) {
       case 'INSERT':
         $verb = qsprintf($conn, 'INSERT');
         break;
       case 'REPLACE':
         $verb = qsprintf($conn, 'REPLACE');
         break;
       default:
         throw new Exception(
           pht(
             'Insert mode verb "%s" is not recognized, use INSERT or REPLACE.',
             $mode));
     }
 
     $conn->query(
       '%Q INTO %R (%LC) VALUES (%LQ)',
       $verb,
       $this,
       $columns,
       $data);
 
     // Only use the insert id if this table is using auto-increment ids
     if ($id_mechanism === self::IDS_AUTOINCREMENT) {
       $this->setID($conn->getInsertID());
     }
 
     $this->didWriteData();
 
     return $this;
   }
 
 
   /**
    * Method used to determine whether to insert or update when saving.
    *
    * @return bool true if the record should be inserted
    */
   protected function shouldInsertWhenSaved() {
     $key_type = $this->getConfigOption(self::CONFIG_IDS);
 
     if ($key_type == self::IDS_MANUAL) {
       throw new Exception(
         pht(
           'You are using manual IDs. You must override the %s method '.
           'to properly detect when to insert a new record.',
           __FUNCTION__.'()'));
     } else {
       return !$this->getID();
     }
   }
 
 
 /* -(  Hooks and Callbacks  )------------------------------------------------ */
 
 
   /**
    * Retrieve the database table name. By default, this is the class name.
    *
    * @return string  Table name for object storage.
    *
    * @task   hook
    */
   public function getTableName() {
     return get_class($this);
   }
 
 
   /**
    * Retrieve the primary key column, "id" by default. If you can not
    * reasonably name your ID column "id", override this method.
    *
    * @return string  Name of the ID column.
    *
    * @task   hook
    */
   public function getIDKey() {
     return 'id';
   }
 
-
-  protected function getIDKeyForUse() {
-    $id_key = $this->getIDKey();
-    if (!$id_key) {
-      throw new Exception(
-        pht(
-          'This DAO does not have a single-part primary key. The method you '.
-          'called requires a single-part primary key.'));
-    }
-    return $id_key;
-  }
-
-
   /**
    * Generate a new PHID, used by CONFIG_AUX_PHID.
    *
    * @return phid    Unique, newly allocated PHID.
    *
    * @task   hook
    */
   public function generatePHID() {
     $type = $this->getPHIDType();
     return PhabricatorPHID::generateNewPHID($type);
   }
 
   public function getPHIDType() {
     throw new PhutilMethodNotImplementedException();
   }
 
 
   /**
    * Hook to apply serialization or validation to data before it is written to
    * the database. See also @{method:willReadData}.
    *
    * @task hook
    */
   protected function willWriteData(array &$data) {
     $this->applyLiskDataSerialization($data, false);
   }
 
 
   /**
    * Hook to perform actions after data has been written to the database.
    *
    * @task hook
    */
   protected function didWriteData() {}
 
 
   /**
    * Hook to make internal object state changes prior to INSERT, REPLACE or
    * UPDATE.
    *
    * @task hook
    */
   protected function willSaveObject() {
     $use_timestamps = $this->getConfigOption(self::CONFIG_TIMESTAMPS);
 
     if ($use_timestamps) {
       if (!$this->getDateCreated()) {
         $this->setDateCreated(time());
       }
       $this->setDateModified(time());
     }
 
     if ($this->getConfigOption(self::CONFIG_AUX_PHID) && !$this->getPHID()) {
       $this->setPHID($this->generatePHID());
     }
   }
 
 
   /**
    * Hook to apply serialization or validation to data as it is read from the
    * database. See also @{method:willWriteData}.
    *
    * @task hook
    */
   protected function willReadData(array &$data) {
     $this->applyLiskDataSerialization($data, $deserialize = true);
   }
 
   /**
    * Hook to perform an action on data after it is read from the database.
    *
    * @task hook
    */
   protected function didReadData() {}
 
   /**
    * Hook to perform an action before the deletion of an object.
    *
    * @task hook
    */
   protected function willDelete() {}
 
   /**
    * Hook to perform an action after the deletion of an object.
    *
    * @task hook
    */
   protected function didDelete() {}
 
   /**
    * Reads the value from a field. Override this method for custom behavior
    * of @{method:getField} instead of overriding getField directly.
    *
    * @param  string  Canonical field name
    * @return mixed   Value of the field
    *
    * @task hook
    */
   protected function readField($field) {
     if (isset($this->$field)) {
       return $this->$field;
     }
     return null;
   }
 
   /**
    * Writes a value to a field. Override this method for custom behavior of
    * setField($value) instead of overriding setField directly.
    *
    * @param  string  Canonical field name
    * @param  mixed   Value to write
    *
    * @task hook
    */
   protected function writeField($field, $value) {
     $this->$field = $value;
   }
 
 
 /* -(  Manging Transactions  )----------------------------------------------- */
 
 
   /**
    * Increase transaction stack depth.
    *
    * @return this
    */
   public function openTransaction() {
     $this->establishConnection('w')->openTransaction();
     return $this;
   }
 
 
   /**
    * Decrease transaction stack depth, saving work.
    *
    * @return this
    */
   public function saveTransaction() {
     $this->establishConnection('w')->saveTransaction();
     return $this;
   }
 
 
   /**
    * Decrease transaction stack depth, discarding work.
    *
    * @return this
    */
   public function killTransaction() {
     $this->establishConnection('w')->killTransaction();
     return $this;
   }
 
 
   /**
    * Begins read-locking selected rows with SELECT ... FOR UPDATE, so that
    * other connections can not read them (this is an enormous oversimplification
    * of FOR UPDATE semantics; consult the MySQL documentation for details). To
    * end read locking, call @{method:endReadLocking}. For example:
    *
    *   $beach->openTransaction();
    *     $beach->beginReadLocking();
    *
    *       $beach->reload();
    *       $beach->setGrainsOfSand($beach->getGrainsOfSand() + 1);
    *       $beach->save();
    *
    *     $beach->endReadLocking();
    *   $beach->saveTransaction();
    *
    * @return this
    * @task xaction
    */
   public function beginReadLocking() {
     $this->establishConnection('w')->beginReadLocking();
     return $this;
   }
 
 
   /**
    * Ends read-locking that began at an earlier @{method:beginReadLocking} call.
    *
    * @return this
    * @task xaction
    */
   public function endReadLocking() {
     $this->establishConnection('w')->endReadLocking();
     return $this;
   }
 
   /**
    * Begins write-locking selected rows with SELECT ... LOCK IN SHARE MODE, so
    * that other connections can not update or delete them (this is an
    * oversimplification of LOCK IN SHARE MODE semantics; consult the
    * MySQL documentation for details). To end write locking, call
    * @{method:endWriteLocking}.
    *
    * @return this
    * @task xaction
    */
   public function beginWriteLocking() {
     $this->establishConnection('w')->beginWriteLocking();
     return $this;
   }
 
 
   /**
    * Ends write-locking that began at an earlier @{method:beginWriteLocking}
    * call.
    *
    * @return this
    * @task xaction
    */
   public function endWriteLocking() {
     $this->establishConnection('w')->endWriteLocking();
     return $this;
   }
 
 
 /* -(  Isolation  )---------------------------------------------------------- */
 
 
   /**
    * @task isolate
    */
   public static function beginIsolateAllLiskEffectsToCurrentProcess() {
     self::$processIsolationLevel++;
   }
 
   /**
    * @task isolate
    */
   public static function endIsolateAllLiskEffectsToCurrentProcess() {
     self::$processIsolationLevel--;
     if (self::$processIsolationLevel < 0) {
       throw new Exception(
         pht('Lisk process isolation level was reduced below 0.'));
     }
   }
 
   /**
    * @task isolate
    */
   public static function shouldIsolateAllLiskEffectsToCurrentProcess() {
     return (bool)self::$processIsolationLevel;
   }
 
   /**
    * @task isolate
    */
   private function establishIsolatedConnection($mode) {
     $config = array();
     return new AphrontIsolatedDatabaseConnection($config);
   }
 
   /**
    * @task isolate
    */
   public static function beginIsolateAllLiskEffectsToTransactions() {
     if (self::$transactionIsolationLevel === 0) {
       self::closeAllConnections();
     }
     self::$transactionIsolationLevel++;
   }
 
   /**
    * @task isolate
    */
   public static function endIsolateAllLiskEffectsToTransactions() {
     self::$transactionIsolationLevel--;
     if (self::$transactionIsolationLevel < 0) {
       throw new Exception(
         pht('Lisk transaction isolation level was reduced below 0.'));
     } else if (self::$transactionIsolationLevel == 0) {
       foreach (self::$connections as $key => $conn) {
         if ($conn) {
           $conn->killTransaction();
         }
       }
       self::closeAllConnections();
     }
   }
 
   /**
    * @task isolate
    */
   public static function shouldIsolateAllLiskEffectsToTransactions() {
     return (bool)self::$transactionIsolationLevel;
   }
 
   /**
    * Close any connections with no recent activity.
    *
    * Long-running processes can use this method to clean up connections which
    * have not been used recently.
    *
    * @param int Close connections with no activity for this many seconds.
    * @return void
    */
   public static function closeInactiveConnections($idle_window) {
     $connections = self::$connections;
 
     $now = PhabricatorTime::getNow();
     foreach ($connections as $key => $connection) {
       // If the connection is not idle, never consider it inactive.
       if (!$connection->isIdle()) {
         continue;
       }
 
       $last_active = $connection->getLastActiveEpoch();
 
       $idle_duration = ($now - $last_active);
       if ($idle_duration <= $idle_window) {
         continue;
       }
 
       self::closeConnection($key);
     }
   }
 
 
   public static function closeAllConnections() {
     $connections = self::$connections;
 
     foreach ($connections as $key => $connection) {
       self::closeConnection($key);
     }
   }
 
   public static function closeIdleConnections() {
     $connections = self::$connections;
 
     foreach ($connections as $key => $connection) {
       if (!$connection->isIdle()) {
         continue;
       }
 
       self::closeConnection($key);
     }
   }
 
   private static function closeConnection($key) {
     if (empty(self::$connections[$key])) {
       throw new Exception(
         pht(
           'No database connection with connection key "%s" exists!',
           $key));
     }
 
     $connection = self::$connections[$key];
     unset(self::$connections[$key]);
 
     $connection->close();
   }
 
 
 /* -(  Utilities  )---------------------------------------------------------- */
 
 
   /**
    * Applies configured serialization to a dictionary of values.
    *
    * @task util
    */
   protected function applyLiskDataSerialization(array &$data, $deserialize) {
     $serialization = $this->getConfigOption(self::CONFIG_SERIALIZATION);
     if ($serialization) {
       foreach (array_intersect_key($serialization, $data) as $col => $format) {
         switch ($format) {
           case self::SERIALIZATION_NONE:
             break;
           case self::SERIALIZATION_PHP:
             if ($deserialize) {
               $data[$col] = unserialize($data[$col]);
             } else {
               $data[$col] = serialize($data[$col]);
             }
             break;
           case self::SERIALIZATION_JSON:
             if ($deserialize) {
               $data[$col] = json_decode($data[$col], true);
             } else {
               $data[$col] = phutil_json_encode($data[$col]);
             }
             break;
           default:
             throw new Exception(
               pht("Unknown serialization format '%s'.", $format));
         }
       }
     }
   }
 
   /**
    * Black magic. Builds implied get*() and set*() for all properties.
    *
    * @param  string  Method name.
    * @param  list    Argument vector.
    * @return mixed   get*() methods return the property value. set*() methods
    *                 return $this.
    * @task   util
    */
   public function __call($method, $args) {
-    // NOTE: PHP has a bug that static variables defined in __call() are shared
-    // across all children classes. Call a different method to work around this
-    // bug.
-    return $this->call($method, $args);
-  }
+    $dispatch_map = $this->getLiskMetadata('dispatchMap', array());
 
-  /**
-   * @task   util
-   */
-  final protected function call($method, $args) {
     // NOTE: This method is very performance-sensitive (many thousands of calls
     // per page on some pages), and thus has some silliness in the name of
     // optimizations.
 
-    static $dispatch_map = array();
-
     if ($method[0] === 'g') {
       if (isset($dispatch_map[$method])) {
         $property = $dispatch_map[$method];
       } else {
         if (substr($method, 0, 3) !== 'get') {
           throw new Exception(pht("Unable to resolve method '%s'!", $method));
         }
         $property = substr($method, 3);
         if (!($property = $this->checkProperty($property))) {
           throw new Exception(pht('Bad getter call: %s', $method));
         }
         $dispatch_map[$method] = $property;
+        $this->setLiskMetadata('dispatchMap', $dispatch_map);
       }
 
       return $this->readField($property);
     }
 
     if ($method[0] === 's') {
       if (isset($dispatch_map[$method])) {
         $property = $dispatch_map[$method];
       } else {
         if (substr($method, 0, 3) !== 'set') {
           throw new Exception(pht("Unable to resolve method '%s'!", $method));
         }
+
         $property = substr($method, 3);
         $property = $this->checkProperty($property);
         if (!$property) {
           throw new Exception(pht('Bad setter call: %s', $method));
         }
         $dispatch_map[$method] = $property;
+        $this->setLiskMetadata('dispatchMap', $dispatch_map);
       }
 
       $this->writeField($property, $args[0]);
 
       return $this;
     }
 
     throw new Exception(pht("Unable to resolve method '%s'.", $method));
   }
 
   /**
    * Warns against writing to undeclared property.
    *
    * @task   util
    */
   public function __set($name, $value) {
     // Hack for policy system hints, see PhabricatorPolicyRule for notes.
     if ($name != '_hashKey') {
       phlog(
         pht(
           'Wrote to undeclared property %s.',
           get_class($this).'::$'.$name));
     }
     $this->$name = $value;
   }
 
 
   /**
    * Increments a named counter and returns the next value.
    *
    * @param   AphrontDatabaseConnection   Database where the counter resides.
    * @param   string                      Counter name to create or increment.
    * @return  int                         Next counter value.
    *
    * @task util
    */
   public static function loadNextCounterValue(
     AphrontDatabaseConnection $conn_w,
     $counter_name) {
 
     // NOTE: If an insert does not touch an autoincrement row or call
     // LAST_INSERT_ID(), MySQL normally does not change the value of
     // LAST_INSERT_ID(). This can cause a counter's value to leak to a
     // new counter if the second counter is created after the first one is
     // updated. To avoid this, we insert LAST_INSERT_ID(1), to ensure the
     // LAST_INSERT_ID() is always updated and always set correctly after the
     // query completes.
 
     queryfx(
       $conn_w,
       'INSERT INTO %T (counterName, counterValue) VALUES
           (%s, LAST_INSERT_ID(1))
         ON DUPLICATE KEY UPDATE
           counterValue = LAST_INSERT_ID(counterValue + 1)',
       self::COUNTER_TABLE_NAME,
       $counter_name);
 
     return $conn_w->getInsertID();
   }
 
 
   /**
    * Returns the current value of a named counter.
    *
    * @param AphrontDatabaseConnection Database where the counter resides.
    * @param string Counter name to read.
    * @return int|null Current value, or `null` if the counter does not exist.
    *
    * @task util
    */
   public static function loadCurrentCounterValue(
     AphrontDatabaseConnection $conn_r,
     $counter_name) {
 
     $row = queryfx_one(
       $conn_r,
       'SELECT counterValue FROM %T WHERE counterName = %s',
       self::COUNTER_TABLE_NAME,
       $counter_name);
     if (!$row) {
       return null;
     }
 
     return (int)$row['counterValue'];
   }
 
 
   /**
    * Overwrite a named counter, forcing it to a specific value.
    *
    * If the counter does not exist, it is created.
    *
    * @param AphrontDatabaseConnection Database where the counter resides.
    * @param string Counter name to create or overwrite.
    * @return void
    *
    * @task util
    */
   public static function overwriteCounterValue(
     AphrontDatabaseConnection $conn_w,
     $counter_name,
     $counter_value) {
 
     queryfx(
       $conn_w,
       'INSERT INTO %T (counterName, counterValue) VALUES (%s, %d)
         ON DUPLICATE KEY UPDATE counterValue = VALUES(counterValue)',
       self::COUNTER_TABLE_NAME,
       $counter_name,
       $counter_value);
   }
 
   private function getBinaryColumns() {
     return $this->getConfigOption(self::CONFIG_BINARY);
   }
 
   public function getSchemaColumns() {
     $custom_map = $this->getConfigOption(self::CONFIG_COLUMN_SCHEMA);
     if (!$custom_map) {
       $custom_map = array();
     }
 
     $serialization = $this->getConfigOption(self::CONFIG_SERIALIZATION);
     if (!$serialization) {
       $serialization = array();
     }
 
     $serialization_map = array(
       self::SERIALIZATION_JSON => 'text',
       self::SERIALIZATION_PHP => 'bytes',
     );
 
     $binary_map = $this->getBinaryColumns();
 
     $id_mechanism = $this->getConfigOption(self::CONFIG_IDS);
     if ($id_mechanism == self::IDS_AUTOINCREMENT) {
       $id_type = 'auto';
     } else {
       $id_type = 'id';
     }
 
     $builtin = array(
       'id' => $id_type,
       'phid' => 'phid',
       'viewPolicy' => 'policy',
       'editPolicy' => 'policy',
       'epoch' => 'epoch',
       'dateCreated' => 'epoch',
       'dateModified' => 'epoch',
     );
 
     $map = array();
     foreach ($this->getAllLiskProperties() as $property) {
       // First, use types specified explicitly in the table configuration.
       if (array_key_exists($property, $custom_map)) {
         $map[$property] = $custom_map[$property];
         continue;
       }
 
       // If we don't have an explicit type, try a builtin type for the
       // column.
       $type = idx($builtin, $property);
       if ($type) {
         $map[$property] = $type;
         continue;
       }
 
       // If the column has serialization, we can infer the column type.
       if (isset($serialization[$property])) {
         $type = idx($serialization_map, $serialization[$property]);
         if ($type) {
           $map[$property] = $type;
           continue;
         }
       }
 
       if (isset($binary_map[$property])) {
         $map[$property] = 'bytes';
         continue;
       }
 
       if ($property === 'spacePHID') {
         $map[$property] = 'phid?';
         continue;
       }
 
       // If the column is named `somethingPHID`, infer it is a PHID.
       if (preg_match('/[a-z]PHID$/', $property)) {
         $map[$property] = 'phid';
         continue;
       }
 
       // If the column is named `somethingID`, infer it is an ID.
       if (preg_match('/[a-z]ID$/', $property)) {
         $map[$property] = 'id';
         continue;
       }
 
       // We don't know the type of this column.
       $map[$property] = PhabricatorConfigSchemaSpec::DATATYPE_UNKNOWN;
     }
 
     return $map;
   }
 
   public function getSchemaKeys() {
     $custom_map = $this->getConfigOption(self::CONFIG_KEY_SCHEMA);
     if (!$custom_map) {
       $custom_map = array();
     }
 
     $default_map = array();
     foreach ($this->getAllLiskProperties() as $property) {
       switch ($property) {
         case 'id':
           $default_map['PRIMARY'] = array(
             'columns' => array('id'),
             'unique' => true,
           );
           break;
         case 'phid':
           $default_map['key_phid'] = array(
             'columns' => array('phid'),
             'unique' => true,
           );
           break;
         case 'spacePHID':
           $default_map['key_space'] = array(
             'columns' => array('spacePHID'),
           );
           break;
       }
     }
 
     return $custom_map + $default_map;
   }
 
   public function getColumnMaximumByteLength($column) {
     $map = $this->getSchemaColumns();
 
     if (!isset($map[$column])) {
       throw new Exception(
         pht(
           'Object (of class "%s") does not have a column "%s".',
           get_class($this),
           $column));
     }
 
     $data_type = $map[$column];
 
     return id(new PhabricatorStorageSchemaSpec())
       ->getMaximumByteLengthForDataType($data_type);
   }
 
   public function getSchemaPersistence() {
     return null;
   }
 
 
 /* -(  AphrontDatabaseTableRefInterface  )----------------------------------- */
 
 
   public function getAphrontRefDatabaseName() {
     return $this->getDatabaseName();
   }
 
   public function getAphrontRefTableName() {
     return $this->getTableName();
   }
 
 
+  private function getLiskMetadata($key, $default = null) {
+    if (isset(self::$liskMetadata[static::class][$key])) {
+      return self::$liskMetadata[static::class][$key];
+    }
+
+    if (!isset(self::$liskMetadata[static::class])) {
+      self::$liskMetadata[static::class] = array();
+    }
+
+    return idx(self::$liskMetadata[static::class], $key, $default);
+  }
+
+  private function setLiskMetadata($key, $value) {
+    self::$liskMetadata[static::class][$key] = $value;
+  }
+
 }
diff --git a/src/infrastructure/util/PhabricatorHash.php b/src/infrastructure/util/PhabricatorHash.php
index d717778eb3..fdd6609288 100644
--- a/src/infrastructure/util/PhabricatorHash.php
+++ b/src/infrastructure/util/PhabricatorHash.php
@@ -1,281 +1,281 @@
 <?php
 
 final class PhabricatorHash extends Phobject {
 
   const INDEX_DIGEST_LENGTH = 12;
   const ANCHOR_DIGEST_LENGTH = 12;
 
   /**
    * Digest a string using HMAC+SHA1.
    *
    * Because a SHA1 collision is now known, this method should be considered
    * weak. Callers should prefer @{method:digestWithNamedKey}.
    *
    * @param   string  Input string.
    * @return  string  32-byte hexadecimal SHA1+HMAC hash.
    */
   public static function weakDigest($string, $key = null) {
     if ($key === null) {
       $key = PhabricatorEnv::getEnvConfig('security.hmac-key');
     }
 
     if (!$key) {
       throw new Exception(
         pht(
           "Set a '%s' in your Phabricator configuration!",
           'security.hmac-key'));
     }
 
     return hash_hmac('sha1', $string, $key);
   }
 
 
   /**
    * Digest a string for use in, e.g., a MySQL index. This produces a short
    * (12-byte), case-sensitive alphanumeric string with 72 bits of entropy,
    * which is generally safe in most contexts (notably, URLs).
    *
    * This method emphasizes compactness, and should not be used for security
    * related hashing (for general purpose hashing, see @{method:digest}).
    *
    * @param   string  Input string.
    * @return  string  12-byte, case-sensitive, mostly-alphanumeric hash of
    *                  the string.
    */
   public static function digestForIndex($string) {
     $hash = sha1($string, $raw_output = true);
 
     static $map;
     if ($map === null) {
       $map = '0123456789'.
              'abcdefghij'.
              'klmnopqrst'.
              'uvwxyzABCD'.
              'EFGHIJKLMN'.
              'OPQRSTUVWX'.
              'YZ._';
     }
 
     $result = '';
     for ($ii = 0; $ii < self::INDEX_DIGEST_LENGTH; $ii++) {
       $result .= $map[(ord($hash[$ii]) & 0x3F)];
     }
 
     return $result;
   }
 
   /**
    * Digest a string for use in HTML page anchors. This is similar to
    * @{method:digestForIndex} but produces purely alphanumeric output.
    *
    * This tries to be mostly compatible with the index digest to limit how
    * much stuff we're breaking by switching to it. For additional discussion,
    * see T13045.
    *
    * @param   string  Input string.
    * @return  string  12-byte, case-sensitive, purely-alphanumeric hash of
    *                  the string.
    */
   public static function digestForAnchor($string) {
     $hash = sha1($string, $raw_output = true);
 
     static $map;
     if ($map === null) {
       $map = '0123456789'.
              'abcdefghij'.
              'klmnopqrst'.
              'uvwxyzABCD'.
              'EFGHIJKLMN'.
              'OPQRSTUVWX'.
              'YZ';
     }
 
     $result = '';
     $accum = 0;
     $map_size = strlen($map);
     for ($ii = 0; $ii < self::ANCHOR_DIGEST_LENGTH; $ii++) {
       $byte = ord($hash[$ii]);
       $low_bits = ($byte & 0x3F);
       $accum = ($accum + $byte) % $map_size;
 
       if ($low_bits < $map_size) {
         // If an index digest would produce any alphanumeric character, just
         // use that character. This means that these digests are the same as
         // digests created with "digestForIndex()" in all positions where the
         // output character is some character other than "." or "_".
         $result .= $map[$low_bits];
       } else {
         // If an index digest would produce a non-alphumeric character ("." or
         // "_"), pick an alphanumeric character instead. We accumulate an
         // index into the alphanumeric character list to try to preserve
         // entropy here. We could use this strategy for all bytes instead,
         // but then these digests would differ from digests created with
         // "digestForIndex()" in all positions, instead of just a small number
         // of positions.
         $result .= $map[$accum];
       }
     }
 
     return $result;
   }
 
 
   public static function digestToRange($string, $min, $max) {
     if ($min > $max) {
       throw new Exception(pht('Maximum must be larger than minimum.'));
     }
 
     if ($min == $max) {
       return $min;
     }
 
     $hash = sha1($string, $raw_output = true);
     // Make sure this ends up positive, even on 32-bit machines.
     $value = head(unpack('L', $hash)) & 0x7FFFFFFF;
 
     return $min + ($value % (1 + $max - $min));
   }
 
 
   /**
    * Shorten a string to a maximum byte length in a collision-resistant way
    * while retaining some degree of human-readability.
    *
    * This function converts an input string into a prefix plus a hash. For
    * example, a very long string beginning with "crabapplepie..." might be
    * digested to something like "crabapp-N1wM1Nz3U84k".
    *
    * This allows the maximum length of identifiers to be fixed while
    * maintaining a high degree of collision resistance and a moderate degree
    * of human readability.
    *
    * @param string The string to shorten.
    * @param int Maximum length of the result.
    * @return string String shortened in a collision-resistant way.
    */
   public static function digestToLength($string, $length) {
     // We need at least two more characters than the hash length to fit in a
     // a 1-character prefix and a separator.
     $min_length = self::INDEX_DIGEST_LENGTH + 2;
     if ($length < $min_length) {
       throw new Exception(
         pht(
           'Length parameter in %s must be at least %s, '.
           'but %s was provided.',
           'digestToLength()',
           new PhutilNumber($min_length),
           new PhutilNumber($length)));
     }
 
     // We could conceivably return the string unmodified if it's shorter than
     // the specified length. Instead, always hash it. This makes the output of
     // the method more recognizable and consistent (no surprising new behavior
     // once you hit a string longer than `$length`) and prevents an attacker
     // who can control the inputs from intentionally using the hashed form
     // of a string to cause a collision.
 
     $hash = self::digestForIndex($string);
 
     $prefix = substr($string, 0, ($length - ($min_length - 1)));
 
     return $prefix.'-'.$hash;
   }
 
   public static function digestWithNamedKey($message, $key_name) {
     $key_bytes = self::getNamedHMACKey($key_name);
     return self::digestHMACSHA256($message, $key_bytes);
   }
 
   public static function digestHMACSHA256($message, $key) {
     if (!is_string($message)) {
       throw new Exception(
         pht('HMAC-SHA256 can only digest strings.'));
     }
 
     if (!is_string($key)) {
       throw new Exception(
         pht('HMAC-SHA256 keys must be strings.'));
     }
 
     if (!strlen($key)) {
       throw new Exception(
         pht('HMAC-SHA256 requires a nonempty key.'));
     }
 
     $result = hash_hmac('sha256', $message, $key, $raw_output = false);
 
     // Although "hash_hmac()" is documented as returning `false` when it fails,
     // it can also return `null` if you pass an object as the "$message".
     if ($result === false || $result === null) {
       throw new Exception(
         pht('Unable to compute HMAC-SHA256 digest of message.'));
     }
 
     return $result;
   }
 
 
 /* -(  HMAC Key Management  )------------------------------------------------ */
 
 
   private static function getNamedHMACKey($hmac_name) {
     $cache = PhabricatorCaches::getImmutableCache();
 
     $cache_key = "hmac.key({$hmac_name})";
 
     $hmac_key = $cache->getKey($cache_key);
-    if (!strlen($hmac_key)) {
+    if (($hmac_key === null) || !strlen($hmac_key)) {
       $hmac_key = self::readHMACKey($hmac_name);
 
       if ($hmac_key === null) {
         $hmac_key = self::newHMACKey($hmac_name);
         self::writeHMACKey($hmac_name, $hmac_key);
       }
 
       $cache->setKey($cache_key, $hmac_key);
     }
 
     // The "hex2bin()" function doesn't exist until PHP 5.4.0 so just
     // implement it inline.
     $result = '';
     for ($ii = 0; $ii < strlen($hmac_key); $ii += 2) {
       $result .= pack('H*', substr($hmac_key, $ii, 2));
     }
 
     return $result;
   }
 
   private static function newHMACKey($hmac_name) {
     $hmac_key = Filesystem::readRandomBytes(64);
     return bin2hex($hmac_key);
   }
 
   private static function writeHMACKey($hmac_name, $hmac_key) {
     $unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
 
       id(new PhabricatorAuthHMACKey())
         ->setKeyName($hmac_name)
         ->setKeyValue($hmac_key)
         ->save();
 
     unset($unguarded);
   }
 
   private static function readHMACKey($hmac_name) {
     $table = new PhabricatorAuthHMACKey();
     $conn = $table->establishConnection('r');
 
     $row = queryfx_one(
       $conn,
       'SELECT keyValue FROM %T WHERE keyName = %s',
       $table->getTableName(),
       $hmac_name);
     if (!$row) {
       return null;
     }
 
     return $row['keyValue'];
   }
 
 
 }
diff --git a/src/infrastructure/util/PhabricatorMetronome.php b/src/infrastructure/util/PhabricatorMetronome.php
index 24f58127f6..d56fa55b74 100644
--- a/src/infrastructure/util/PhabricatorMetronome.php
+++ b/src/infrastructure/util/PhabricatorMetronome.php
@@ -1,92 +1,92 @@
 <?php
 
 /**
  * Tick at a given frequency with a specifiable offset.
  *
  * One use case for this is to flatten out load spikes caused by periodic
  * service calls. Give each host a metronome that ticks at the same frequency,
  * but with different offsets. Then, have hosts make service calls only after
  * their metronome ticks. This spreads service calls out evenly more quickly
  * and more predictably than adding random jitter.
  */
 final class PhabricatorMetronome
   extends Phobject {
 
   private $offset = 0;
   private $frequency;
 
   public function setOffset($offset) {
     if (!is_int($offset)) {
       throw new Exception(pht('Metronome offset must be an integer.'));
     }
 
     if ($offset < 0) {
       throw new Exception(pht('Metronome offset must be 0 or more.'));
     }
 
     // We're not requiring that the offset be smaller than the frequency. If
     // the offset is larger, we'll just clamp it to the frequency before we
     // use it. This allows the offset to be configured before the frequency
     // is configured, which is useful for using a hostname as an offset seed.
 
     $this->offset = $offset;
 
     return $this;
   }
 
   public function setFrequency($frequency) {
     if (!is_int($frequency)) {
       throw new Exception(pht('Metronome frequency must be an integer.'));
     }
 
     if ($frequency < 1) {
       throw new Exception(pht('Metronome frequency must be 1 or more.'));
     }
 
     $this->frequency = $frequency;
 
     return $this;
   }
 
   public function setOffsetFromSeed($seed) {
-    $offset = PhabricatorHash::digestToRange($seed, 0, PHP_INT_MAX);
+    $offset = PhabricatorHash::digestToRange($seed, 0, 0x7FFFFFFF);
     return $this->setOffset($offset);
   }
 
   public function getFrequency() {
     if ($this->frequency === null) {
       throw new PhutilInvalidStateException('setFrequency');
     }
     return $this->frequency;
   }
 
   public function getOffset() {
     $frequency = $this->getFrequency();
     return ($this->offset % $frequency);
   }
 
   public function getNextTickAfter($epoch) {
     $frequency = $this->getFrequency();
     $offset = $this->getOffset();
 
     $remainder = ($epoch % $frequency);
 
     if ($remainder < $offset) {
       return ($epoch - $remainder) + $offset;
     } else {
       return ($epoch - $remainder) + $frequency + $offset;
     }
   }
 
   public function didTickBetween($min, $max) {
     if ($max < $min) {
       throw new Exception(
         pht(
           'Maximum tick window must not be smaller than minimum tick window.'));
     }
 
     $next = $this->getNextTickAfter($min);
     return ($next <= $max);
   }
 
 }