No OneTemporary
Actions

Size

124 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/audit/query/PhabricatorCommitSearchEngine.php b/src/applications/audit/query/PhabricatorCommitSearchEngine.php
	index 37e8d563b4..8b7751c795 100644
	--- a/src/applications/audit/query/PhabricatorCommitSearchEngine.php
	+++ b/src/applications/audit/query/PhabricatorCommitSearchEngine.php
	@@ -1,277 +1,277 @@
	<?php

	final class PhabricatorCommitSearchEngine
	extends PhabricatorApplicationSearchEngine {

	public function getResultTypeDescription() {
	return pht('Diffusion Commits');
	}

	public function getApplicationClassName() {
	return 'PhabricatorDiffusionApplication';
	}

	public function newQuery() {
	return id(new DiffusionCommitQuery())
	->needAuditRequests(true)
	->needCommitData(true)
	->needIdentities(true)
	->needDrafts(true);
	}

	protected function newResultBuckets() {
	return DiffusionCommitResultBucket::getAllResultBuckets();
	}

	protected function buildQueryFromParameters(array $map) {
	$query = $this->newQuery();

	if ($map['responsiblePHIDs']) {
	$query->withResponsiblePHIDs($map['responsiblePHIDs']);
	}

	if ($map['auditorPHIDs']) {
	$query->withAuditorPHIDs($map['auditorPHIDs']);
	}

	if ($map['authorPHIDs']) {
	$query->withAuthorPHIDs($map['authorPHIDs']);
	}

	if ($map['statuses']) {
	$query->withStatuses($map['statuses']);
	}

	if ($map['repositoryPHIDs']) {
	$query->withRepositoryPHIDs($map['repositoryPHIDs']);
	}

	if ($map['packagePHIDs']) {
	$query->withPackagePHIDs($map['packagePHIDs']);
	}

	if ($map['unreachable'] !== null) {
	$query->withUnreachable($map['unreachable']);
	}

	- if ($map['unpublished'] !== null) {
	- $query->withUnpublished($map['unpublished']);
	+ if ($map['permanent'] !== null) {
	+ $query->withPermanent($map['permanent']);
	}

	if ($map['ancestorsOf']) {
	$query->withAncestorsOf($map['ancestorsOf']);
	}

	if ($map['identifiers']) {
	$query->withIdentifiers($map['identifiers']);
	}

	return $query;
	}

	protected function buildCustomSearchFields() {
	return array(
	id(new PhabricatorSearchDatasourceField())
	->setLabel(pht('Responsible Users'))
	->setKey('responsiblePHIDs')
	->setConduitKey('responsible')
	->setAliases(array('responsible', 'responsibles', 'responsiblePHID'))
	->setDatasource(new DifferentialResponsibleDatasource())
	->setDescription(
	pht(
	'Find commits where given users, projects, or packages are '.
	'responsible for the next steps in the audit workflow.')),
	id(new PhabricatorUsersSearchField())
	->setLabel(pht('Authors'))
	->setKey('authorPHIDs')
	->setConduitKey('authors')
	->setAliases(array('author', 'authors', 'authorPHID'))
	->setDescription(pht('Find commits authored by particular users.')),
	id(new PhabricatorSearchDatasourceField())
	->setLabel(pht('Auditors'))
	->setKey('auditorPHIDs')
	->setConduitKey('auditors')
	->setAliases(array('auditor', 'auditors', 'auditorPHID'))
	->setDatasource(new DiffusionAuditorFunctionDatasource())
	->setDescription(
	pht(
	'Find commits where given users, projects, or packages are '.
	'auditors.')),
	id(new PhabricatorSearchCheckboxesField())
	->setLabel(pht('Audit Status'))
	->setKey('statuses')
	->setAliases(array('status'))
	->setOptions(DiffusionCommitAuditStatus::newOptions())
	->setDeprecatedOptions(
	DiffusionCommitAuditStatus::newDeprecatedOptions())
	->setDescription(pht('Find commits with given audit statuses.')),
	id(new PhabricatorSearchDatasourceField())
	->setLabel(pht('Repositories'))
	->setKey('repositoryPHIDs')
	->setConduitKey('repositories')
	->setAliases(array('repository', 'repositories', 'repositoryPHID'))
	->setDatasource(new DiffusionRepositoryFunctionDatasource())
	->setDescription(pht('Find commits in particular repositories.')),
	id(new PhabricatorSearchDatasourceField())
	->setLabel(pht('Packages'))
	->setKey('packagePHIDs')
	->setConduitKey('packages')
	->setAliases(array('package', 'packages', 'packagePHID'))
	->setDatasource(new PhabricatorOwnersPackageDatasource())
	->setDescription(
	pht('Find commits which affect given packages.')),
	id(new PhabricatorSearchThreeStateField())
	->setLabel(pht('Unreachable'))
	->setKey('unreachable')
	->setOptions(
	pht('(Show All)'),
	pht('Show Only Unreachable Commits'),
	pht('Hide Unreachable Commits'))
	->setDescription(
	pht(
	'Find or exclude unreachable commits which are not ancestors of '.
	'any branch, tag, or ref.')),
	id(new PhabricatorSearchThreeStateField())
	- ->setLabel(pht('Unpublished'))
	- ->setKey('unpublished')
	+ ->setLabel(pht('Permanent'))
	+ ->setKey('permanent')
	->setOptions(
	pht('(Show All)'),
	- pht('Show Only Unpublished Commits'),
	- pht('Hide Unpublished Commits'))
	+ pht('Show Only Permanent Commits'),
	+ pht('Hide Permanent Commits'))
	->setDescription(
	pht(
	- 'Find or exclude unpublished commits which are not ancestors of '.
	+ 'Find or exclude permanent commits which are ancestors of '.
	'any permanent branch, tag, or ref.')),
	id(new PhabricatorSearchStringListField())
	->setLabel(pht('Ancestors Of'))
	->setKey('ancestorsOf')
	->setDescription(
	pht(
	'Find commits which are ancestors of a particular ref, '.
	'like "master".')),
	id(new PhabricatorSearchStringListField())
	->setLabel(pht('Identifiers'))
	->setKey('identifiers')
	->setDescription(
	pht(
	'Find commits with particular identifiers (usually, hashes). '.
	'Supports full or partial identifiers (like "abcd12340987..." or '.
	'"abcd1234") and qualified or unqualified identifiers (like '.
	'"rXabcd1234" or "abcd1234").')),
	);
	}

	protected function getURI($path) {
	return '/diffusion/commit/'.$path;
	}

	protected function getBuiltinQueryNames() {
	$names = array();

	if ($this->requireViewer()->isLoggedIn()) {
	$names['active'] = pht('Active Audits');
	$names['authored'] = pht('Authored');
	$names['audited'] = pht('Audited');
	}

	$names['all'] = pht('All Commits');

	return $names;
	}

	public function buildSavedQueryFromBuiltin($query_key) {
	$query = $this->newSavedQuery();
	$query->setQueryKey($query_key);
	$viewer = $this->requireViewer();

	$viewer_phid = $viewer->getPHID();
	switch ($query_key) {
	case 'all':
	return $query;
	case 'active':
	$bucket_key = DiffusionCommitRequiredActionResultBucket::BUCKETKEY;

	$open = DiffusionCommitAuditStatus::getOpenStatusConstants();

	$query
	->setParameter('responsiblePHIDs', array($viewer_phid))
	->setParameter('statuses', $open)
	->setParameter('bucket', $bucket_key)
	->setParameter('unreachable', false);
	return $query;
	case 'authored':
	$query
	->setParameter('authorPHIDs', array($viewer_phid));
	return $query;
	case 'audited':
	$query
	->setParameter('auditorPHIDs', array($viewer_phid));
	return $query;
	}

	return parent::buildSavedQueryFromBuiltin($query_key);
	}

	protected function renderResultList(
	array $commits,
	PhabricatorSavedQuery $query,
	array $handles) {
	assert_instances_of($commits, 'PhabricatorRepositoryCommit');
	$viewer = $this->requireViewer();

	$bucket = $this->getResultBucket($query);

	$template = id(new DiffusionCommitGraphView())
	->setViewer($viewer)
	->setShowAuditors(true);

	$views = array();
	if ($bucket) {
	$bucket->setViewer($viewer);

	try {
	$groups = $bucket->newResultGroups($query, $commits);

	foreach ($groups as $group) {
	// Don't show groups in Dashboard Panels
	if ($group->getObjects() \|\| !$this->isPanelContext()) {
	$item_list = id(clone $template)
	->setCommits($group->getObjects())
	->newObjectItemListView();

	$views[] = $item_list
	->setHeader($group->getName())
	->setNoDataString($group->getNoDataString());
	}
	}
	} catch (Exception $ex) {
	$this->addError($ex->getMessage());
	}
	}

	if (!$views) {
	$item_list = id(clone $template)
	->setCommits($commits)
	->newObjectItemListView();

	$views[] = $item_list
	->setNoDataString(pht('No commits found.'));
	}

	return id(new PhabricatorApplicationSearchResultView())
	->setContent($views);
	}

	protected function getNewUserBody() {

	$view = id(new PHUIBigInfoView())
	->setIcon('fa-check-circle-o')
	->setTitle(pht('Welcome to Audit'))
	->setDescription(
	pht('Post-commit code review and auditing. Audits you are assigned '.
	'to will appear here.'));

	return $view;
	}

	}
	diff --git a/src/applications/diffusion/query/DiffusionCommitQuery.php b/src/applications/diffusion/query/DiffusionCommitQuery.php
	index 2854aecbdd..7b4e80bfec 100644
	--- a/src/applications/diffusion/query/DiffusionCommitQuery.php
	+++ b/src/applications/diffusion/query/DiffusionCommitQuery.php
	@@ -1,995 +1,995 @@
	<?php

	final class DiffusionCommitQuery
	extends PhabricatorCursorPagedPolicyAwareQuery {

	private $ids;
	private $phids;
	private $authorPHIDs;
	private $defaultRepository;
	private $identifiers;
	private $repositoryIDs;
	private $repositoryPHIDs;
	private $identifierMap;
	private $responsiblePHIDs;
	private $statuses;
	private $packagePHIDs;
	private $unreachable;
	- private $unpublished;
	+ private $permanent;

	private $needAuditRequests;
	private $needAuditAuthority;
	private $auditIDs;
	private $auditorPHIDs;
	private $epochMin;
	private $epochMax;
	private $importing;
	private $ancestorsOf;

	private $needCommitData;
	private $needDrafts;
	private $needIdentities;

	private $mustFilterRefs = false;
	private $refRepository;

	public function withIDs(array $ids) {
	$this->ids = $ids;
	return $this;
	}

	public function withPHIDs(array $phids) {
	$this->phids = $phids;
	return $this;
	}

	public function withAuthorPHIDs(array $phids) {
	$this->authorPHIDs = $phids;
	return $this;
	}

	/**
	* Load commits by partial or full identifiers, e.g. "rXab82393", "rX1234",
	* or "a9caf12". When an identifier matches multiple commits, they will all
	* be returned; callers should be prepared to deal with more results than
	* they queried for.
	*/
	public function withIdentifiers(array $identifiers) {
	// Some workflows (like blame lookups) can pass in large numbers of
	// duplicate identifiers. We only care about unique identifiers, so
	// get rid of duplicates immediately.
	$identifiers = array_fuse($identifiers);

	$this->identifiers = $identifiers;
	return $this;
	}

	/**
	* Look up commits in a specific repository. This is a shorthand for calling
	* @{method:withDefaultRepository} and @{method:withRepositoryIDs}.
	*/
	public function withRepository(PhabricatorRepository $repository) {
	$this->withDefaultRepository($repository);
	$this->withRepositoryIDs(array($repository->getID()));
	return $this;
	}

	/**
	* Look up commits in a specific repository. Prefer
	* @{method:withRepositoryIDs}; the underlying table is keyed by ID such
	* that this method requires a separate initial query to map PHID to ID.
	*/
	public function withRepositoryPHIDs(array $phids) {
	$this->repositoryPHIDs = $phids;
	return $this;
	}

	/**
	* If a default repository is provided, ambiguous commit identifiers will
	* be assumed to belong to the default repository.
	*
	* For example, "r123" appearing in a commit message in repository X is
	* likely to be unambiguously "rX123". Normally the reference would be
	* considered ambiguous, but if you provide a default repository it will
	* be correctly resolved.
	*/
	public function withDefaultRepository(PhabricatorRepository $repository) {
	$this->defaultRepository = $repository;
	return $this;
	}

	public function withRepositoryIDs(array $repository_ids) {
	$this->repositoryIDs = array_unique($repository_ids);
	return $this;
	}

	public function needCommitData($need) {
	$this->needCommitData = $need;
	return $this;
	}

	public function needDrafts($need) {
	$this->needDrafts = $need;
	return $this;
	}

	public function needIdentities($need) {
	$this->needIdentities = $need;
	return $this;
	}

	public function needAuditRequests($need) {
	$this->needAuditRequests = $need;
	return $this;
	}

	public function needAuditAuthority(array $users) {
	assert_instances_of($users, 'PhabricatorUser');
	$this->needAuditAuthority = $users;
	return $this;
	}

	public function withAuditIDs(array $ids) {
	$this->auditIDs = $ids;
	return $this;
	}

	public function withAuditorPHIDs(array $auditor_phids) {
	$this->auditorPHIDs = $auditor_phids;
	return $this;
	}

	public function withResponsiblePHIDs(array $responsible_phids) {
	$this->responsiblePHIDs = $responsible_phids;
	return $this;
	}

	public function withPackagePHIDs(array $package_phids) {
	$this->packagePHIDs = $package_phids;
	return $this;
	}

	public function withUnreachable($unreachable) {
	$this->unreachable = $unreachable;
	return $this;
	}

	- public function withUnpublished($unpublished) {
	- $this->unpublished = $unpublished;
	+ public function withPermanent($permanent) {
	+ $this->permanent = $permanent;
	return $this;
	}

	public function withStatuses(array $statuses) {
	$this->statuses = $statuses;
	return $this;
	}

	public function withEpochRange($min, $max) {
	$this->epochMin = $min;
	$this->epochMax = $max;
	return $this;
	}

	public function withImporting($importing) {
	$this->importing = $importing;
	return $this;
	}

	public function withAncestorsOf(array $refs) {
	$this->ancestorsOf = $refs;
	return $this;
	}

	public function getIdentifierMap() {
	if ($this->identifierMap === null) {
	throw new Exception(
	pht(
	'You must %s the query before accessing the identifier map.',
	'execute()'));
	}
	return $this->identifierMap;
	}

	protected function getPrimaryTableAlias() {
	return 'commit';
	}

	protected function willExecute() {
	if ($this->identifierMap === null) {
	$this->identifierMap = array();
	}
	}

	public function newResultObject() {
	return new PhabricatorRepositoryCommit();
	}

	protected function loadPage() {
	$table = $this->newResultObject();
	$conn = $table->establishConnection('r');

	$empty_exception = null;
	$subqueries = array();
	if ($this->responsiblePHIDs) {
	$base_authors = $this->authorPHIDs;
	$base_auditors = $this->auditorPHIDs;

	$responsible_phids = $this->responsiblePHIDs;
	if ($base_authors) {
	$all_authors = array_merge($base_authors, $responsible_phids);
	} else {
	$all_authors = $responsible_phids;
	}

	if ($base_auditors) {
	$all_auditors = array_merge($base_auditors, $responsible_phids);
	} else {
	$all_auditors = $responsible_phids;
	}

	$this->authorPHIDs = $all_authors;
	$this->auditorPHIDs = $base_auditors;
	try {
	$subqueries[] = $this->buildStandardPageQuery(
	$conn,
	$table->getTableName());
	} catch (PhabricatorEmptyQueryException $ex) {
	$empty_exception = $ex;
	}

	$this->authorPHIDs = $base_authors;
	$this->auditorPHIDs = $all_auditors;
	try {
	$subqueries[] = $this->buildStandardPageQuery(
	$conn,
	$table->getTableName());
	} catch (PhabricatorEmptyQueryException $ex) {
	$empty_exception = $ex;
	}
	} else {
	$subqueries[] = $this->buildStandardPageQuery(
	$conn,
	$table->getTableName());
	}

	if (!$subqueries) {
	throw $empty_exception;
	}

	if (count($subqueries) > 1) {
	$unions = null;
	foreach ($subqueries as $subquery) {
	if (!$unions) {
	$unions = qsprintf(
	$conn,
	'(%Q)',
	$subquery);
	continue;
	}

	$unions = qsprintf(
	$conn,
	'%Q UNION DISTINCT (%Q)',
	$unions,
	$subquery);
	}

	$query = qsprintf(
	$conn,
	'%Q %Q %Q',
	$unions,
	$this->buildOrderClause($conn, true),
	$this->buildLimitClause($conn));
	} else {
	$query = head($subqueries);
	}

	$rows = queryfx_all($conn, '%Q', $query);
	$rows = $this->didLoadRawRows($rows);

	return $table->loadAllFromArray($rows);
	}

	protected function willFilterPage(array $commits) {
	$repository_ids = mpull($commits, 'getRepositoryID', 'getRepositoryID');
	$repos = id(new PhabricatorRepositoryQuery())
	->setViewer($this->getViewer())
	->withIDs($repository_ids)
	->execute();

	$min_qualified = PhabricatorRepository::MINIMUM_QUALIFIED_HASH;
	$result = array();

	foreach ($commits as $key => $commit) {
	$repo = idx($repos, $commit->getRepositoryID());
	if ($repo) {
	$commit->attachRepository($repo);
	} else {
	$this->didRejectResult($commit);
	unset($commits[$key]);
	continue;
	}

	// Build the identifierMap
	if ($this->identifiers !== null) {
	$ids = $this->identifiers;
	$prefixes = array(
	'r'.$commit->getRepository()->getCallsign(),
	'r'.$commit->getRepository()->getCallsign().':',
	'R'.$commit->getRepository()->getID().':',
	'', // No prefix is valid too and will only match the commitIdentifier
	);
	$suffix = $commit->getCommitIdentifier();

	if ($commit->getRepository()->isSVN()) {
	foreach ($prefixes as $prefix) {
	if (isset($ids[$prefix.$suffix])) {
	$result[$prefix.$suffix][] = $commit;
	}
	}
	} else {
	// This awkward construction is so we can link the commits up in O(N)
	// time instead of O(N^2).
	for ($ii = $min_qualified; $ii <= strlen($suffix); $ii++) {
	$part = substr($suffix, 0, $ii);
	foreach ($prefixes as $prefix) {
	if (isset($ids[$prefix.$part])) {
	$result[$prefix.$part][] = $commit;
	}
	}
	}
	}
	}
	}

	if ($result) {
	foreach ($result as $identifier => $matching_commits) {
	if (count($matching_commits) == 1) {
	$result[$identifier] = head($matching_commits);
	} else {
	// This reference is ambiguous (it matches more than one commit) so
	// don't link it.
	unset($result[$identifier]);
	}
	}
	$this->identifierMap += $result;
	}

	return $commits;
	}

	protected function didFilterPage(array $commits) {
	$viewer = $this->getViewer();

	if ($this->mustFilterRefs) {
	// If this flag is set, the query has an "Ancestors Of" constraint and
	// at least one of the constraining refs had too many ancestors for us
	// to apply the constraint with a big "commitIdentifier IN (%Ls)" clause.
	// We're going to filter each page and hope we get a full result set
	// before the query overheats.

	$ancestor_list = mpull($commits, 'getCommitIdentifier');
	$ancestor_list = array_values($ancestor_list);

	foreach ($this->ancestorsOf as $ref) {
	try {
	$ancestor_list = DiffusionQuery::callConduitWithDiffusionRequest(
	$viewer,
	DiffusionRequest::newFromDictionary(
	array(
	'repository' => $this->refRepository,
	'user' => $viewer,
	)),
	'diffusion.internal.ancestors',
	array(
	'ref' => $ref,
	'commits' => $ancestor_list,
	));
	} catch (ConduitClientException $ex) {
	throw new PhabricatorSearchConstraintException(
	$ex->getMessage());
	}

	if (!$ancestor_list) {
	break;
	}
	}

	$ancestor_list = array_fuse($ancestor_list);
	foreach ($commits as $key => $commit) {
	$identifier = $commit->getCommitIdentifier();
	if (!isset($ancestor_list[$identifier])) {
	$this->didRejectResult($commit);
	unset($commits[$key]);
	}
	}

	if (!$commits) {
	return $commits;
	}
	}

	if ($this->needCommitData) {
	$data = id(new PhabricatorRepositoryCommitData())->loadAllWhere(
	'commitID in (%Ld)',
	mpull($commits, 'getID'));
	$data = mpull($data, null, 'getCommitID');
	foreach ($commits as $commit) {
	$commit_data = idx($data, $commit->getID());
	if (!$commit_data) {
	$commit_data = new PhabricatorRepositoryCommitData();
	}
	$commit->attachCommitData($commit_data);
	}
	}

	if ($this->needAuditRequests) {
	$requests = id(new PhabricatorRepositoryAuditRequest())->loadAllWhere(
	'commitPHID IN (%Ls)',
	mpull($commits, 'getPHID'));

	$requests = mgroup($requests, 'getCommitPHID');
	foreach ($commits as $commit) {
	$audit_requests = idx($requests, $commit->getPHID(), array());
	$commit->attachAudits($audit_requests);
	foreach ($audit_requests as $audit_request) {
	$audit_request->attachCommit($commit);
	}
	}
	}

	if ($this->needIdentities) {
	$identity_phids = array_merge(
	mpull($commits, 'getAuthorIdentityPHID'),
	mpull($commits, 'getCommitterIdentityPHID'));

	$data = id(new PhabricatorRepositoryIdentityQuery())
	->withPHIDs($identity_phids)
	->setViewer($this->getViewer())
	->execute();
	$data = mpull($data, null, 'getPHID');

	foreach ($commits as $commit) {
	$author_identity = idx($data, $commit->getAuthorIdentityPHID());
	$committer_identity = idx($data, $commit->getCommitterIdentityPHID());
	$commit->attachIdentities($author_identity, $committer_identity);
	}
	}

	if ($this->needDrafts) {
	PhabricatorDraftEngine::attachDrafts(
	$viewer,
	$commits);
	}

	if ($this->needAuditAuthority) {
	$authority_users = $this->needAuditAuthority;

	// NOTE: This isn't very efficient since we're running two queries per
	// user, but there's currently no way to figure out authority for
	// multiple users in one query. Today, we only ever request authority for
	// a single user and single commit, so this has no practical impact.

	// NOTE: We're querying with the viewership of query viewer, not the
	// actual users. If the viewer can't see a project or package, they
	// won't be able to see who has authority on it. This is safer than
	// showing them true authority, and should never matter today, but it
	// also doesn't seem like a significant disclosure and might be
	// reasonable to adjust later if it causes something weird or confusing
	// to happen.

	$authority_map = array();
	foreach ($authority_users as $authority_user) {
	$authority_phid = $authority_user->getPHID();
	if (!$authority_phid) {
	continue;
	}

	$result_phids = array();

	// Users have authority over themselves.
	$result_phids[] = $authority_phid;

	// Users have authority over packages they own.
	$owned_packages = id(new PhabricatorOwnersPackageQuery())
	->setViewer($viewer)
	->withAuthorityPHIDs(array($authority_phid))
	->execute();
	foreach ($owned_packages as $package) {
	$result_phids[] = $package->getPHID();
	}

	// Users have authority over projects they're members of.
	$projects = id(new PhabricatorProjectQuery())
	->setViewer($viewer)
	->withMemberPHIDs(array($authority_phid))
	->execute();
	foreach ($projects as $project) {
	$result_phids[] = $project->getPHID();
	}

	$result_phids = array_fuse($result_phids);

	foreach ($commits as $commit) {
	$attach_phids = $result_phids;

	// NOTE: When modifying your own commits, you act only on behalf of
	// yourself, not your packages or projects. The idea here is that you
	// can't accept your own commits. In the future, this might change or
	// depend on configuration.
	$author_phid = $commit->getAuthorPHID();
	if ($author_phid == $authority_phid) {
	$attach_phids = array($author_phid);
	$attach_phids = array_fuse($attach_phids);
	}

	$commit->attachAuditAuthority($authority_user, $attach_phids);
	}
	}
	}

	return $commits;
	}

	protected function buildWhereClauseParts(AphrontDatabaseConnection $conn) {
	$where = parent::buildWhereClauseParts($conn);

	if ($this->repositoryPHIDs !== null) {
	$map_repositories = id(new PhabricatorRepositoryQuery())
	->setViewer($this->getViewer())
	->withPHIDs($this->repositoryPHIDs)
	->execute();

	if (!$map_repositories) {
	throw new PhabricatorEmptyQueryException();
	}
	$repository_ids = mpull($map_repositories, 'getID');
	if ($this->repositoryIDs !== null) {
	$repository_ids = array_merge($repository_ids, $this->repositoryIDs);
	}
	$this->withRepositoryIDs($repository_ids);
	}

	if ($this->ancestorsOf !== null) {
	if (count($this->repositoryIDs) !== 1) {
	throw new PhabricatorSearchConstraintException(
	pht(
	'To search for commits which are ancestors of particular refs, '.
	'you must constrain the search to exactly one repository.'));
	}

	$repository_id = head($this->repositoryIDs);
	$history_limit = $this->getRawResultLimit() * 32;
	$viewer = $this->getViewer();

	$repository = id(new PhabricatorRepositoryQuery())
	->setViewer($viewer)
	->withIDs(array($repository_id))
	->executeOne();

	if (!$repository) {
	throw new PhabricatorEmptyQueryException();
	}

	if ($repository->isSVN()) {
	throw new PhabricatorSearchConstraintException(
	pht(
	'Subversion does not support searching for ancestors of '.
	'a particular ref. This operation is not meaningful in '.
	'Subversion.'));
	}

	if ($repository->isHg()) {
	throw new PhabricatorSearchConstraintException(
	pht(
	'Mercurial does not currently support searching for ancestors of '.
	'a particular ref.'));
	}

	$can_constrain = true;
	$history_identifiers = array();
	foreach ($this->ancestorsOf as $key => $ref) {
	try {
	$raw_history = DiffusionQuery::callConduitWithDiffusionRequest(
	$viewer,
	DiffusionRequest::newFromDictionary(
	array(
	'repository' => $repository,
	'user' => $viewer,
	)),
	'diffusion.historyquery',
	array(
	'commit' => $ref,
	'limit' => $history_limit,
	));
	} catch (ConduitClientException $ex) {
	throw new PhabricatorSearchConstraintException(
	$ex->getMessage());
	}

	$ref_identifiers = array();
	foreach ($raw_history['pathChanges'] as $change) {
	$ref_identifiers[] = $change['commitIdentifier'];
	}

	// If this ref had fewer total commits than the limit, we're safe to
	// apply the constraint as a large `IN (...)` query for a list of
	// commit identifiers. This is efficient.
	if ($history_limit) {
	if (count($ref_identifiers) >= $history_limit) {
	$can_constrain = false;
	break;
	}
	}

	$history_identifiers += array_fuse($ref_identifiers);
	}

	// If all refs had a small number of ancestors, we can just put the
	// constraint into the query here and we're done. Otherwise, we need
	// to filter each page after it comes out of the MySQL layer.
	if ($can_constrain) {
	$where[] = qsprintf(
	$conn,
	'commit.commitIdentifier IN (%Ls)',
	$history_identifiers);
	} else {
	$this->mustFilterRefs = true;
	$this->refRepository = $repository;
	}
	}

	if ($this->ids !== null) {
	$where[] = qsprintf(
	$conn,
	'commit.id IN (%Ld)',
	$this->ids);
	}

	if ($this->phids !== null) {
	$where[] = qsprintf(
	$conn,
	'commit.phid IN (%Ls)',
	$this->phids);
	}

	if ($this->repositoryIDs !== null) {
	$where[] = qsprintf(
	$conn,
	'commit.repositoryID IN (%Ld)',
	$this->repositoryIDs);
	}

	if ($this->authorPHIDs !== null) {
	$author_phids = $this->authorPHIDs;
	if ($author_phids) {
	$author_phids = $this->selectPossibleAuthors($author_phids);
	if (!$author_phids) {
	throw new PhabricatorEmptyQueryException(
	pht('Author PHIDs contain no possible authors.'));
	}
	}

	$where[] = qsprintf(
	$conn,
	'commit.authorPHID IN (%Ls)',
	$author_phids);
	}

	if ($this->epochMin !== null) {
	$where[] = qsprintf(
	$conn,
	'commit.epoch >= %d',
	$this->epochMin);
	}

	if ($this->epochMax !== null) {
	$where[] = qsprintf(
	$conn,
	'commit.epoch <= %d',
	$this->epochMax);
	}

	if ($this->importing !== null) {
	if ($this->importing) {
	$where[] = qsprintf(
	$conn,
	'(commit.importStatus & %d) != %d',
	PhabricatorRepositoryCommit::IMPORTED_ALL,
	PhabricatorRepositoryCommit::IMPORTED_ALL);
	} else {
	$where[] = qsprintf(
	$conn,
	'(commit.importStatus & %d) = %d',
	PhabricatorRepositoryCommit::IMPORTED_ALL,
	PhabricatorRepositoryCommit::IMPORTED_ALL);
	}
	}

	if ($this->identifiers !== null) {
	$min_unqualified = PhabricatorRepository::MINIMUM_UNQUALIFIED_HASH;
	$min_qualified = PhabricatorRepository::MINIMUM_QUALIFIED_HASH;

	$refs = array();
	$bare = array();
	foreach ($this->identifiers as $identifier) {
	$matches = null;
	preg_match('/^(?:[rR]([A-Z]+:?\|[0-9]+:))?(.*)$/',
	$identifier, $matches);
	$repo = nonempty(rtrim($matches[1], ':'), null);
	$commit_identifier = nonempty($matches[2], null);

	if ($repo === null) {
	if ($this->defaultRepository) {
	$repo = $this->defaultRepository->getPHID();
	}
	}

	if ($repo === null) {
	if (strlen($commit_identifier) < $min_unqualified) {
	continue;
	}
	$bare[] = $commit_identifier;
	} else {
	$refs[] = array(
	'repository' => $repo,
	'identifier' => $commit_identifier,
	);
	}
	}

	$sql = array();

	foreach ($bare as $identifier) {
	$sql[] = qsprintf(
	$conn,
	'(commit.commitIdentifier LIKE %> AND '.
	'LENGTH(commit.commitIdentifier) = 40)',
	$identifier);
	}

	if ($refs) {
	$repositories = ipull($refs, 'repository');

	$repos = id(new PhabricatorRepositoryQuery())
	->setViewer($this->getViewer())
	->withIdentifiers($repositories);
	$repos->execute();

	$repos = $repos->getIdentifierMap();
	foreach ($refs as $key => $ref) {
	$repo = idx($repos, $ref['repository']);
	if (!$repo) {
	continue;
	}

	if ($repo->isSVN()) {
	if (!ctype_digit((string)$ref['identifier'])) {
	continue;
	}
	$sql[] = qsprintf(
	$conn,
	'(commit.repositoryID = %d AND commit.commitIdentifier = %s)',
	$repo->getID(),
	// NOTE: Because the 'commitIdentifier' column is a string, MySQL
	// ignores the index if we hand it an integer. Hand it a string.
	// See T3377.
	(int)$ref['identifier']);
	} else {
	if (strlen($ref['identifier']) < $min_qualified) {
	continue;
	}

	$identifier = $ref['identifier'];
	if (strlen($identifier) == 40) {
	// MySQL seems to do slightly better with this version if the
	// clause, so issue it if we have a full commit hash.
	$sql[] = qsprintf(
	$conn,
	'(commit.repositoryID = %d
	AND commit.commitIdentifier = %s)',
	$repo->getID(),
	$identifier);
	} else {
	$sql[] = qsprintf(
	$conn,
	'(commit.repositoryID = %d
	AND commit.commitIdentifier LIKE %>)',
	$repo->getID(),
	$identifier);
	}
	}
	}
	}

	if (!$sql) {
	// If we discarded all possible identifiers (e.g., they all referenced
	// bogus repositories or were all too short), make sure the query finds
	// nothing.
	throw new PhabricatorEmptyQueryException(
	pht('No commit identifiers.'));
	}

	$where[] = qsprintf($conn, '%LO', $sql);
	}

	if ($this->auditIDs !== null) {
	$where[] = qsprintf(
	$conn,
	'auditor.id IN (%Ld)',
	$this->auditIDs);
	}

	if ($this->auditorPHIDs !== null) {
	$where[] = qsprintf(
	$conn,
	'auditor.auditorPHID IN (%Ls)',
	$this->auditorPHIDs);
	}

	if ($this->statuses !== null) {
	$statuses = DiffusionCommitAuditStatus::newModernKeys(
	$this->statuses);

	$where[] = qsprintf(
	$conn,
	'commit.auditStatus IN (%Ls)',
	$statuses);
	}

	if ($this->packagePHIDs !== null) {
	$where[] = qsprintf(
	$conn,
	'package.dst IN (%Ls)',
	$this->packagePHIDs);
	}

	if ($this->unreachable !== null) {
	if ($this->unreachable) {
	$where[] = qsprintf(
	$conn,
	'(commit.importStatus & %d) = %d',
	PhabricatorRepositoryCommit::IMPORTED_UNREACHABLE,
	PhabricatorRepositoryCommit::IMPORTED_UNREACHABLE);
	} else {
	$where[] = qsprintf(
	$conn,
	'(commit.importStatus & %d) = 0',
	PhabricatorRepositoryCommit::IMPORTED_UNREACHABLE);
	}
	}

	- if ($this->unpublished !== null) {
	- if ($this->unpublished) {
	+ if ($this->permanent !== null) {
	+ if ($this->permanent) {
	$where[] = qsprintf(
	$conn,
	- '(commit.importStatus & %d) = 0',
	- PhabricatorRepositoryCommit::IMPORTED_CLOSEABLE);
	+ '(commit.importStatus & %d) = %d',
	+ PhabricatorRepositoryCommit::IMPORTED_PERMANENT,
	+ PhabricatorRepositoryCommit::IMPORTED_PERMANENT);
	} else {
	$where[] = qsprintf(
	$conn,
	- '(commit.importStatus & %d) = %d',
	- PhabricatorRepositoryCommit::IMPORTED_CLOSEABLE,
	- PhabricatorRepositoryCommit::IMPORTED_CLOSEABLE);
	+ '(commit.importStatus & %d) = 0',
	+ PhabricatorRepositoryCommit::IMPORTED_PERMANENT);
	}
	}

	return $where;
	}

	protected function didFilterResults(array $filtered) {
	if ($this->identifierMap) {
	foreach ($this->identifierMap as $name => $commit) {
	if (isset($filtered[$commit->getPHID()])) {
	unset($this->identifierMap[$name]);
	}
	}
	}
	}

	private function shouldJoinAuditor() {
	return ($this->auditIDs \|\| $this->auditorPHIDs);
	}

	private function shouldJoinOwners() {
	return (bool)$this->packagePHIDs;
	}

	protected function buildJoinClauseParts(AphrontDatabaseConnection $conn) {
	$join = parent::buildJoinClauseParts($conn);
	$audit_request = new PhabricatorRepositoryAuditRequest();

	if ($this->shouldJoinAuditor()) {
	$join[] = qsprintf(
	$conn,
	'JOIN %T auditor ON commit.phid = auditor.commitPHID',
	$audit_request->getTableName());
	}

	if ($this->shouldJoinOwners()) {
	$join[] = qsprintf(
	$conn,
	'JOIN %T package ON commit.phid = package.src
	AND package.type = %s',
	PhabricatorEdgeConfig::TABLE_NAME_EDGE,
	DiffusionCommitHasPackageEdgeType::EDGECONST);
	}

	return $join;
	}

	protected function shouldGroupQueryResultRows() {
	if ($this->shouldJoinAuditor()) {
	return true;
	}

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

	return parent::shouldGroupQueryResultRows();
	}

	public function getQueryApplicationClass() {
	return 'PhabricatorDiffusionApplication';
	}

	public function getOrderableColumns() {
	return parent::getOrderableColumns() + array(
	'epoch' => array(
	'table' => $this->getPrimaryTableAlias(),
	'column' => 'epoch',
	'type' => 'int',
	'reverse' => false,
	),
	);
	}

	protected function newPagingMapFromPartialObject($object) {
	return array(
	'id' => (int)$object->getID(),
	'epoch' => (int)$object->getEpoch(),
	);
	}

	public function getBuiltinOrders() {
	$parent = parent::getBuiltinOrders();

	// Rename the default ID-based orders.
	$parent['importnew'] = array(
	'name' => pht('Import Date (Newest First)'),
	) + $parent['newest'];

	$parent['importold'] = array(
	'name' => pht('Import Date (Oldest First)'),
	) + $parent['oldest'];

	return array(
	'newest' => array(
	'vector' => array('epoch', 'id'),
	'name' => pht('Commit Date (Newest First)'),
	),
	'oldest' => array(
	'vector' => array('-epoch', '-id'),
	'name' => pht('Commit Date (Oldest First)'),
	),
	) + $parent;
	}

	private function selectPossibleAuthors(array $phids) {
	// See PHI1057. Select PHIDs which might possibly be commit authors from
	// a larger list of PHIDs. This primarily filters out packages and projects
	// from "Responsible Users: ..." queries. Our goal in performing this
	// filtering is to improve the performance of the final query.

	foreach ($phids as $key => $phid) {
	if (phid_get_type($phid) !== PhabricatorPeopleUserPHIDType::TYPECONST) {
	unset($phids[$key]);
	}
	}

	return $phids;
	}


	}
	diff --git a/src/applications/repository/engine/PhabricatorRepositoryCommitRef.php b/src/applications/repository/engine/PhabricatorRepositoryCommitRef.php
	index 31c859d5d8..148b99f3e0 100644
	--- a/src/applications/repository/engine/PhabricatorRepositoryCommitRef.php
	+++ b/src/applications/repository/engine/PhabricatorRepositoryCommitRef.php
	@@ -1,56 +1,56 @@
	<?php

	final class PhabricatorRepositoryCommitRef extends Phobject {

	private $identifier;
	private $epoch;
	private $branch;
	- private $canCloseImmediately;
	+ private $isPermanent;
	private $parents = array();

	public function setIdentifier($identifier) {
	$this->identifier = $identifier;
	return $this;
	}

	public function getIdentifier() {
	return $this->identifier;
	}

	public function setEpoch($epoch) {
	$this->epoch = $epoch;
	return $this;
	}

	public function getEpoch() {
	return $this->epoch;
	}

	public function setBranch($branch) {
	$this->branch = $branch;
	return $this;
	}

	public function getBranch() {
	return $this->branch;
	}

	- public function setCanCloseImmediately($can_close_immediately) {
	- $this->canCloseImmediately = $can_close_immediately;
	+ public function setIsPermanent($is_permanent) {
	+ $this->isPermanent = $is_permanent;
	return $this;
	}

	- public function getCanCloseImmediately() {
	- return $this->canCloseImmediately;
	+ public function getIsPermanent() {
	+ return $this->isPermanent;
	}

	public function setParents(array $parents) {
	$this->parents = $parents;
	return $this;
	}

	public function getParents() {
	return $this->parents;
	}

	}
	diff --git a/src/applications/repository/engine/PhabricatorRepositoryDiscoveryEngine.php b/src/applications/repository/engine/PhabricatorRepositoryDiscoveryEngine.php
	index 8ac52b0b57..1c27e38e99 100644
	--- a/src/applications/repository/engine/PhabricatorRepositoryDiscoveryEngine.php
	+++ b/src/applications/repository/engine/PhabricatorRepositoryDiscoveryEngine.php
	@@ -1,996 +1,996 @@
	<?php

	/**
	* @task discover Discovering Repositories
	* @task svn Discovering Subversion Repositories
	* @task git Discovering Git Repositories
	* @task hg Discovering Mercurial Repositories
	* @task internal Internals
	*/
	final class PhabricatorRepositoryDiscoveryEngine
	extends PhabricatorRepositoryEngine {

	private $repairMode;
	private $commitCache = array();
	private $workingSet = array();

	const MAX_COMMIT_CACHE_SIZE = 65535;


	/* -( Discovering Repositories )------------------------------------------- */


	public function setRepairMode($repair_mode) {
	$this->repairMode = $repair_mode;
	return $this;
	}


	public function getRepairMode() {
	return $this->repairMode;
	}


	/**
	* @task discovery
	*/
	public function discoverCommits() {
	$repository = $this->getRepository();

	$lock = $this->newRepositoryLock($repository, 'repo.look', false);

	try {
	$lock->lock();
	} catch (PhutilLockException $ex) {
	throw new DiffusionDaemonLockException(
	pht(
	'Another process is currently discovering repository "%s", '.
	'skipping discovery.',
	$repository->getDisplayName()));
	}

	try {
	$result = $this->discoverCommitsWithLock();
	} catch (Exception $ex) {
	$lock->unlock();
	throw $ex;
	}

	$lock->unlock();

	return $result;
	}

	private function discoverCommitsWithLock() {
	$repository = $this->getRepository();
	$viewer = $this->getViewer();

	$vcs = $repository->getVersionControlSystem();
	switch ($vcs) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	$refs = $this->discoverSubversionCommits();
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	$refs = $this->discoverMercurialCommits();
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	$refs = $this->discoverGitCommits();
	break;
	default:
	throw new Exception(pht("Unknown VCS '%s'!", $vcs));
	}

	if ($this->isInitialImport($refs)) {
	$this->log(
	pht(
	'Discovered more than %s commit(s) in an empty repository, '.
	'marking repository as importing.',
	new PhutilNumber(PhabricatorRepository::IMPORT_THRESHOLD)));

	$repository->markImporting();
	}

	// Clear the working set cache.
	$this->workingSet = array();

	$task_priority = $this->getImportTaskPriority($repository, $refs);

	// Record discovered commits and mark them in the cache.
	foreach ($refs as $ref) {
	$this->recordCommit(
	$repository,
	$ref->getIdentifier(),
	$ref->getEpoch(),
	- $ref->getCanCloseImmediately(),
	+ $ref->getIsPermanent(),
	$ref->getParents(),
	$task_priority);

	$this->commitCache[$ref->getIdentifier()] = true;
	}

	$this->markUnreachableCommits($repository);

	$version = $this->getObservedVersion($repository);
	if ($version !== null) {
	id(new DiffusionRepositoryClusterEngine())
	->setViewer($viewer)
	->setRepository($repository)
	->synchronizeWorkingCopyAfterDiscovery($version);
	}

	return $refs;
	}


	/* -( Discovering Git Repositories )--------------------------------------- */


	/**
	* @task git
	*/
	private function discoverGitCommits() {
	$repository = $this->getRepository();
	$publisher = $repository->newPublisher();

	$heads = id(new DiffusionLowLevelGitRefQuery())
	->setRepository($repository)
	->execute();

	if (!$heads) {
	// This repository has no heads at all, so we don't need to do
	// anything. Generally, this means the repository is empty.
	return array();
	}

	$heads = $this->sortRefs($heads);
	$head_commits = mpull($heads, 'getCommitIdentifier');

	$this->log(
	pht(
	'Discovering commits in repository "%s".',
	$repository->getDisplayName()));

	$this->fillCommitCache($head_commits);

	$refs = array();
	foreach ($heads as $ref) {
	$name = $ref->getShortName();
	$commit = $ref->getCommitIdentifier();

	$this->log(
	pht(
	'Examining "%s" (%s) at "%s".',
	$name,
	$ref->getRefType(),
	$commit));

	if (!$repository->shouldTrackRef($ref)) {
	$this->log(pht('Skipping, ref is untracked.'));
	continue;
	}

	if ($this->isKnownCommit($commit)) {
	$this->log(pht('Skipping, HEAD is known.'));
	continue;
	}

	// In Git, it's possible to tag anything. We just skip tags that don't
	// point to a commit. See T11301.
	$fields = $ref->getRawFields();
	$ref_type = idx($fields, 'objecttype');
	$tag_type = idx($fields, '*objecttype');
	if ($ref_type != 'commit' && $tag_type != 'commit') {
	$this->log(pht('Skipping, this is not a commit.'));
	continue;
	}

	$this->log(pht('Looking for new commits.'));

	$head_refs = $this->discoverStreamAncestry(
	new PhabricatorGitGraphStream($repository, $commit),
	$commit,
	$publisher->shouldPublishRef($ref));

	$this->didDiscoverRefs($head_refs);

	$refs[] = $head_refs;
	}

	return array_mergev($refs);
	}


	/* -( Discovering Subversion Repositories )-------------------------------- */


	/**
	* @task svn
	*/
	private function discoverSubversionCommits() {
	$repository = $this->getRepository();

	if (!$repository->isHosted()) {
	$this->verifySubversionRoot($repository);
	}

	$upper_bound = null;
	$limit = 1;
	$refs = array();
	do {
	// Find all the unknown commits on this path. Note that we permit
	// importing an SVN subdirectory rather than the entire repository, so
	// commits may be nonsequential.

	if ($upper_bound === null) {
	$at_rev = 'HEAD';
	} else {
	$at_rev = ($upper_bound - 1);
	}

	try {
	list($xml, $stderr) = $repository->execxRemoteCommand(
	'log --xml --quiet --limit %d %s',
	$limit,
	$repository->getSubversionBaseURI($at_rev));
	} catch (CommandException $ex) {
	$stderr = $ex->getStderr();
	if (preg_match('/(path\|File) not found/', $stderr)) {
	// We've gone all the way back through history and this path was not
	// affected by earlier commits.
	break;
	}
	throw $ex;
	}

	$xml = phutil_utf8ize($xml);
	$log = new SimpleXMLElement($xml);
	foreach ($log->logentry as $entry) {
	$identifier = (int)$entry['revision'];
	$epoch = (int)strtotime((string)$entry->date[0]);
	$refs[$identifier] = id(new PhabricatorRepositoryCommitRef())
	->setIdentifier($identifier)
	->setEpoch($epoch)
	- ->setCanCloseImmediately(true);
	+ ->setIsPermanent(true);

	if ($upper_bound === null) {
	$upper_bound = $identifier;
	} else {
	$upper_bound = min($upper_bound, $identifier);
	}
	}

	// Discover 2, 4, 8, ... 256 logs at a time. This allows us to initially
	// import large repositories fairly quickly, while pulling only as much
	// data as we need in the common case (when we've already imported the
	// repository and are just grabbing one commit at a time).
	$limit = min($limit * 2, 256);

	} while ($upper_bound > 1 && !$this->isKnownCommit($upper_bound));

	krsort($refs);
	while ($refs && $this->isKnownCommit(last($refs)->getIdentifier())) {
	array_pop($refs);
	}
	$refs = array_reverse($refs);

	$this->didDiscoverRefs($refs);

	return $refs;
	}


	private function verifySubversionRoot(PhabricatorRepository $repository) {
	list($xml) = $repository->execxRemoteCommand(
	'info --xml %s',
	$repository->getSubversionPathURI());

	$xml = phutil_utf8ize($xml);
	$xml = new SimpleXMLElement($xml);

	$remote_root = (string)($xml->entry[0]->repository[0]->root[0]);
	$expect_root = $repository->getSubversionPathURI();

	$normal_type_svn = ArcanistRepositoryURINormalizer::TYPE_SVN;

	$remote_normal = id(new ArcanistRepositoryURINormalizer(
	$normal_type_svn,
	$remote_root))->getNormalizedPath();

	$expect_normal = id(new ArcanistRepositoryURINormalizer(
	$normal_type_svn,
	$expect_root))->getNormalizedPath();

	if ($remote_normal != $expect_normal) {
	throw new Exception(
	pht(
	'Repository "%s" does not have a correctly configured remote URI. '.
	'The remote URI for a Subversion repository MUST point at the '.
	'repository root. The root for this repository is "%s", but the '.
	'configured URI is "%s". To resolve this error, set the remote URI '.
	'to point at the repository root. If you want to import only part '.
	'of a Subversion repository, use the "Import Only" option.',
	$repository->getDisplayName(),
	$remote_root,
	$expect_root));
	}
	}


	/* -( Discovering Mercurial Repositories )--------------------------------- */


	/**
	* @task hg
	*/
	private function discoverMercurialCommits() {
	$repository = $this->getRepository();

	$branches = id(new DiffusionLowLevelMercurialBranchesQuery())
	->setRepository($repository)
	->execute();

	$this->fillCommitCache(mpull($branches, 'getCommitIdentifier'));

	$refs = array();
	foreach ($branches as $branch) {
	// NOTE: Mercurial branches may have multiple heads, so the names may
	// not be unique.
	$name = $branch->getShortName();
	$commit = $branch->getCommitIdentifier();

	$this->log(pht('Examining branch "%s" head "%s".', $name, $commit));
	if (!$repository->shouldTrackBranch($name)) {
	$this->log(pht('Skipping, branch is untracked.'));
	continue;
	}

	if ($this->isKnownCommit($commit)) {
	$this->log(pht('Skipping, this head is a known commit.'));
	continue;
	}

	$this->log(pht('Looking for new commits.'));

	$branch_refs = $this->discoverStreamAncestry(
	new PhabricatorMercurialGraphStream($repository, $commit),
	$commit,
	- $close_immediately = true);
	+ $is_permanent = true);

	$this->didDiscoverRefs($branch_refs);

	$refs[] = $branch_refs;
	}

	return array_mergev($refs);
	}


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


	private function discoverStreamAncestry(
	PhabricatorRepositoryGraphStream $stream,
	$commit,
	- $close_immediately) {
	+ $is_permanent) {

	$discover = array($commit);
	$graph = array();
	$seen = array();

	// Find all the reachable, undiscovered commits. Build a graph of the
	// edges.
	while ($discover) {
	$target = array_pop($discover);

	if (empty($graph[$target])) {
	$graph[$target] = array();
	}

	$parents = $stream->getParents($target);
	foreach ($parents as $parent) {
	if ($this->isKnownCommit($parent)) {
	continue;
	}

	$graph[$target][$parent] = true;

	if (empty($seen[$parent])) {
	$seen[$parent] = true;
	$discover[] = $parent;
	}
	}
	}

	// Now, sort them topologically.
	$commits = $this->reduceGraph($graph);

	$refs = array();
	foreach ($commits as $commit) {
	$epoch = $stream->getCommitDate($commit);

	// If the epoch doesn't fit into a uint32, treat it as though it stores
	// the current time. For discussion, see T11537.
	if ($epoch > 0xFFFFFFFF) {
	$epoch = PhabricatorTime::getNow();
	}

	// If the epoch is not present at all, treat it as though it stores the
	// value "0". For discussion, see T12062. This behavior is consistent
	// with the behavior of "git show".
	if (!strlen($epoch)) {
	$epoch = 0;
	}

	$refs[] = id(new PhabricatorRepositoryCommitRef())
	->setIdentifier($commit)
	->setEpoch($epoch)
	- ->setCanCloseImmediately($close_immediately)
	+ ->setIsPermanent($is_permanent)
	->setParents($stream->getParents($commit));
	}

	return $refs;
	}


	private function reduceGraph(array $edges) {
	foreach ($edges as $commit => $parents) {
	$edges[$commit] = array_keys($parents);
	}

	$graph = new PhutilDirectedScalarGraph();
	$graph->addNodes($edges);

	$commits = $graph->getNodesInTopologicalOrder();

	// NOTE: We want the most ancestral nodes first, so we need to reverse the
	// list we get out of AbstractDirectedGraph.
	$commits = array_reverse($commits);

	return $commits;
	}


	private function isKnownCommit($identifier) {
	if (isset($this->commitCache[$identifier])) {
	return true;
	}

	if (isset($this->workingSet[$identifier])) {
	return true;
	}

	$this->fillCommitCache(array($identifier));

	return isset($this->commitCache[$identifier]);
	}

	private function fillCommitCache(array $identifiers) {
	if (!$identifiers) {
	return;
	}

	if ($this->repairMode) {
	// In repair mode, rediscover the entire repository, ignoring the
	// database state. The engine still maintains a local cache (the
	// "Working Set") but we just give up before looking in the database.
	return;
	}

	$max_size = self::MAX_COMMIT_CACHE_SIZE;

	// If we're filling more identifiers than would fit in the cache, ignore
	// the ones that don't fit. Because the cache is FIFO, overfilling it can
	// cause the entire cache to miss. See T12296.
	if (count($identifiers) > $max_size) {
	$identifiers = array_slice($identifiers, 0, $max_size);
	}

	// When filling the cache we ignore commits which have been marked as
	// unreachable, treating them as though they do not exist. When recording
	// commits later we'll revive commits that exist but are unreachable.

	$commits = id(new PhabricatorRepositoryCommit())->loadAllWhere(
	'repositoryID = %d AND commitIdentifier IN (%Ls)
	AND (importStatus & %d) != %d',
	$this->getRepository()->getID(),
	$identifiers,
	PhabricatorRepositoryCommit::IMPORTED_UNREACHABLE,
	PhabricatorRepositoryCommit::IMPORTED_UNREACHABLE);

	foreach ($commits as $commit) {
	$this->commitCache[$commit->getCommitIdentifier()] = true;
	}

	while (count($this->commitCache) > $max_size) {
	array_shift($this->commitCache);
	}
	}

	/**
	- * Sort branches so we process closeable branches first. This makes the
	- * whole import process a little cheaper, since we can close these commits
	+ * Sort branches so we process permanent branches first. This makes the
	+ * whole import process a little cheaper, since we can publish these commits
	* the first time through rather than catching them in the refs step.
	*
	* @task internal
	*
	* @param list<DiffusionRepositoryRef> List of refs.
	* @return list<DiffusionRepositoryRef> Sorted list of refs.
	*/
	private function sortRefs(array $refs) {
	$repository = $this->getRepository();
	$publisher = $repository->newPublisher();

	$head_refs = array();
	$tail_refs = array();
	foreach ($refs as $ref) {
	if ($publisher->shouldPublishRef($ref)) {
	$head_refs[] = $ref;
	} else {
	$tail_refs[] = $ref;
	}
	}

	return array_merge($head_refs, $tail_refs);
	}


	private function recordCommit(
	PhabricatorRepository $repository,
	$commit_identifier,
	$epoch,
	- $close_immediately,
	+ $is_permanent,
	array $parents,
	$task_priority) {

	$commit = new PhabricatorRepositoryCommit();
	$conn_w = $repository->establishConnection('w');

	// First, try to revive an existing unreachable commit (if one exists) by
	// removing the "unreachable" flag. If we succeed, we don't need to do
	// anything else: we already discovered this commit some time ago.
	queryfx(
	$conn_w,
	'UPDATE %T SET importStatus = (importStatus & ~%d)
	WHERE repositoryID = %d AND commitIdentifier = %s',
	$commit->getTableName(),
	PhabricatorRepositoryCommit::IMPORTED_UNREACHABLE,
	$repository->getID(),
	$commit_identifier);
	if ($conn_w->getAffectedRows()) {
	$commit = $commit->loadOneWhere(
	'repositoryID = %d AND commitIdentifier = %s',
	$repository->getID(),
	$commit_identifier);

	// After reviving a commit, schedule new daemons for it.
	$this->didDiscoverCommit($repository, $commit, $epoch, $task_priority);
	return;
	}

	$commit->setRepositoryID($repository->getID());
	$commit->setCommitIdentifier($commit_identifier);
	$commit->setEpoch($epoch);
	- if ($close_immediately) {
	- $commit->setImportStatus(PhabricatorRepositoryCommit::IMPORTED_CLOSEABLE);
	+ if ($is_permanent) {
	+ $commit->setImportStatus(PhabricatorRepositoryCommit::IMPORTED_PERMANENT);
	}

	$data = new PhabricatorRepositoryCommitData();

	try {
	// If this commit has parents, look up their IDs. The parent commits
	// should always exist already.

	$parent_ids = array();
	if ($parents) {
	$parent_rows = queryfx_all(
	$conn_w,
	'SELECT id, commitIdentifier FROM %T
	WHERE commitIdentifier IN (%Ls) AND repositoryID = %d',
	$commit->getTableName(),
	$parents,
	$repository->getID());

	$parent_map = ipull($parent_rows, 'id', 'commitIdentifier');

	foreach ($parents as $parent) {
	if (empty($parent_map[$parent])) {
	throw new Exception(
	pht('Unable to identify parent "%s"!', $parent));
	}
	$parent_ids[] = $parent_map[$parent];
	}
	} else {
	// Write an explicit 0 so we can distinguish between "really no
	// parents" and "data not available".
	if (!$repository->isSVN()) {
	$parent_ids = array(0);
	}
	}

	$commit->openTransaction();
	$commit->save();

	$data->setCommitID($commit->getID());
	$data->save();

	foreach ($parent_ids as $parent_id) {
	queryfx(
	$conn_w,
	'INSERT IGNORE INTO %T (childCommitID, parentCommitID)
	VALUES (%d, %d)',
	PhabricatorRepository::TABLE_PARENTS,
	$commit->getID(),
	$parent_id);
	}
	$commit->saveTransaction();

	$this->didDiscoverCommit($repository, $commit, $epoch, $task_priority);

	if ($this->repairMode) {
	// Normally, the query should throw a duplicate key exception. If we
	// reach this in repair mode, we've actually performed a repair.
	$this->log(pht('Repaired commit "%s".', $commit_identifier));
	}

	PhutilEventEngine::dispatchEvent(
	new PhabricatorEvent(
	PhabricatorEventType::TYPE_DIFFUSION_DIDDISCOVERCOMMIT,
	array(
	'repository' => $repository,
	'commit' => $commit,
	)));

	} catch (AphrontDuplicateKeyQueryException $ex) {
	$commit->killTransaction();
	// Ignore. This can happen because we discover the same new commit
	// more than once when looking at history, or because of races or
	// data inconsistency or cosmic radiation; in any case, we're still
	// in a good state if we ignore the failure.
	}
	}

	private function didDiscoverCommit(
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit,
	$epoch,
	$task_priority) {

	$this->insertTask($repository, $commit, $task_priority);

	// Update the repository summary table.
	queryfx(
	$commit->establishConnection('w'),
	'INSERT INTO %T (repositoryID, size, lastCommitID, epoch)
	VALUES (%d, 1, %d, %d)
	ON DUPLICATE KEY UPDATE
	size = size + 1,
	lastCommitID =
	IF(VALUES(epoch) > epoch, VALUES(lastCommitID), lastCommitID),
	epoch = IF(VALUES(epoch) > epoch, VALUES(epoch), epoch)',
	PhabricatorRepository::TABLE_SUMMARY,
	$repository->getID(),
	$commit->getID(),
	$epoch);
	}

	private function didDiscoverRefs(array $refs) {
	foreach ($refs as $ref) {
	$this->workingSet[$ref->getIdentifier()] = true;
	}
	}

	private function insertTask(
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit,
	$task_priority,
	$data = array()) {

	$vcs = $repository->getVersionControlSystem();
	switch ($vcs) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	$class = 'PhabricatorRepositoryGitCommitMessageParserWorker';
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	$class = 'PhabricatorRepositorySvnCommitMessageParserWorker';
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	$class = 'PhabricatorRepositoryMercurialCommitMessageParserWorker';
	break;
	default:
	throw new Exception(pht("Unknown repository type '%s'!", $vcs));
	}

	$data['commitID'] = $commit->getID();

	$options = array(
	'priority' => $task_priority,
	);

	PhabricatorWorker::scheduleTask($class, $data, $options);
	}

	private function isInitialImport(array $refs) {
	$commit_count = count($refs);

	if ($commit_count <= PhabricatorRepository::IMPORT_THRESHOLD) {
	// If we fetched a small number of commits, assume it's an initial
	// commit or a stack of a few initial commits.
	return false;
	}

	$viewer = $this->getViewer();
	$repository = $this->getRepository();

	$any_commits = id(new DiffusionCommitQuery())
	->setViewer($viewer)
	->withRepository($repository)
	->setLimit(1)
	->execute();

	if ($any_commits) {
	// If the repository already has commits, this isn't an import.
	return false;
	}

	return true;
	}


	private function getObservedVersion(PhabricatorRepository $repository) {
	if ($repository->isHosted()) {
	return null;
	}

	if ($repository->isGit()) {
	return $this->getGitObservedVersion($repository);
	}

	return null;
	}

	private function getGitObservedVersion(PhabricatorRepository $repository) {
	$refs = id(new DiffusionLowLevelGitRefQuery())
	->setRepository($repository)
	->execute();
	if (!$refs) {
	return null;
	}

	// In Git, the observed version is the most recently discovered commit
	// at any repository HEAD. It's possible for this to regress temporarily
	// if a branch is pushed and then deleted. This is acceptable because it
	// doesn't do anything meaningfully bad and will fix itself on the next
	// push.

	$ref_identifiers = mpull($refs, 'getCommitIdentifier');
	$ref_identifiers = array_fuse($ref_identifiers);

	$version = queryfx_one(
	$repository->establishConnection('w'),
	'SELECT MAX(id) version FROM %T WHERE repositoryID = %d
	AND commitIdentifier IN (%Ls)',
	id(new PhabricatorRepositoryCommit())->getTableName(),
	$repository->getID(),
	$ref_identifiers);

	if (!$version) {
	return null;
	}

	return (int)$version['version'];
	}

	private function markUnreachableCommits(PhabricatorRepository $repository) {
	// For now, this is only supported for Git.
	if (!$repository->isGit()) {
	return;
	}

	// Find older versions of refs which we haven't processed yet. We're going
	// to make sure their commits are still reachable.
	$old_refs = id(new PhabricatorRepositoryOldRef())->loadAllWhere(
	'repositoryPHID = %s',
	$repository->getPHID());

	// If we don't have any refs to update, bail out before building a graph
	// stream. In particular, this improves behavior in empty repositories,
	// where `git log` exits with an error.
	if (!$old_refs) {
	return;
	}

	// We can share a single graph stream across all the checks we need to do.
	$stream = new PhabricatorGitGraphStream($repository);

	foreach ($old_refs as $old_ref) {
	$identifier = $old_ref->getCommitIdentifier();
	$this->markUnreachableFrom($repository, $stream, $identifier);

	// If nothing threw an exception, we're all done with this ref.
	$old_ref->delete();
	}
	}

	private function markUnreachableFrom(
	PhabricatorRepository $repository,
	PhabricatorGitGraphStream $stream,
	$identifier) {

	$unreachable = array();

	$commit = id(new PhabricatorRepositoryCommit())->loadOneWhere(
	'repositoryID = %s AND commitIdentifier = %s',
	$repository->getID(),
	$identifier);
	if (!$commit) {
	return;
	}

	$look = array($commit);
	$seen = array();
	while ($look) {
	$target = array_pop($look);

	// If we've already checked this commit (for example, because history
	// branches and then merges) we don't need to check it again.
	$target_identifier = $target->getCommitIdentifier();
	if (isset($seen[$target_identifier])) {
	continue;
	}

	$seen[$target_identifier] = true;

	// See PHI1688. If this commit is already marked as unreachable, we don't
	// need to consider its ancestors. This may skip a lot of work if many
	// branches with a lot of shared ancestry are deleted at the same time.
	if ($target->isUnreachable()) {
	continue;
	}

	try {
	$stream->getCommitDate($target_identifier);
	$reachable = true;
	} catch (Exception $ex) {
	$reachable = false;
	}

	if ($reachable) {
	// This commit is reachable, so we don't need to go any further
	// down this road.
	continue;
	}

	$unreachable[] = $target;

	// Find the commit's parents and check them for reachability, too. We
	// have to look in the database since we no may longer have the commit
	// in the repository.
	$rows = queryfx_all(
	$commit->establishConnection('w'),
	'SELECT commit.* FROM %T commit
	JOIN %T parents ON commit.id = parents.parentCommitID
	WHERE parents.childCommitID = %d',
	$commit->getTableName(),
	PhabricatorRepository::TABLE_PARENTS,
	$target->getID());
	if (!$rows) {
	continue;
	}

	$parents = id(new PhabricatorRepositoryCommit())
	->loadAllFromArray($rows);
	foreach ($parents as $parent) {
	$look[] = $parent;
	}
	}

	$unreachable = array_reverse($unreachable);

	$flag = PhabricatorRepositoryCommit::IMPORTED_UNREACHABLE;
	foreach ($unreachable as $unreachable_commit) {
	$unreachable_commit->writeImportStatusFlag($flag);
	}

	// If anything was unreachable, just rebuild the whole summary table.
	// We can't really update it incrementally when a commit becomes
	// unreachable.
	if ($unreachable) {
	$this->rebuildSummaryTable($repository);
	}
	}

	private function rebuildSummaryTable(PhabricatorRepository $repository) {
	$conn_w = $repository->establishConnection('w');

	$data = queryfx_one(
	$conn_w,
	'SELECT COUNT(*) N, MAX(id) id, MAX(epoch) epoch
	FROM %T WHERE repositoryID = %d AND (importStatus & %d) != %d',
	id(new PhabricatorRepositoryCommit())->getTableName(),
	$repository->getID(),
	PhabricatorRepositoryCommit::IMPORTED_UNREACHABLE,
	PhabricatorRepositoryCommit::IMPORTED_UNREACHABLE);

	queryfx(
	$conn_w,
	'INSERT INTO %T (repositoryID, size, lastCommitID, epoch)
	VALUES (%d, %d, %d, %d)
	ON DUPLICATE KEY UPDATE
	size = VALUES(size),
	lastCommitID = VALUES(lastCommitID),
	epoch = VALUES(epoch)',
	PhabricatorRepository::TABLE_SUMMARY,
	$repository->getID(),
	$data['N'],
	$data['id'],
	$data['epoch']);
	}

	private function getImportTaskPriority(
	PhabricatorRepository $repository,
	array $refs) {

	// If the repository is importing for the first time, we schedule tasks
	// at IMPORT priority, which is very low. Making progress on importing a
	// new repository for the first time is less important than any other
	// daemon task.

	// If the repository has finished importing and we're just catching up
	// on recent commits, we usually schedule discovery at COMMIT priority,
	// which is slightly below the default priority.

	// Note that followup tasks and triggered tasks (like those generated by
	// Herald or Harbormaster) will queue at DEFAULT priority, so that each
	// commit tends to fully import before we start the next one. This tends
	// to give imports fairly predictable progress. See T11677 for some
	// discussion.

	if ($repository->isImporting()) {
	$this->log(
	pht(
	'Importing %s commit(s) at low priority ("PRIORITY_IMPORT") '.
	'because this repository is still importing.',
	phutil_count($refs)));

	return PhabricatorWorker::PRIORITY_IMPORT;
	}

	// See T13369. If we've discovered a lot of commits at once, import them
	// at lower priority.

	// This is mostly aimed at reducing the impact that synchronizing thousands
	// of commits from a remote upstream has on other repositories. The queue
	// is "mostly FIFO", so queueing a thousand commit imports can stall other
	// repositories.

	// In a perfect world we'd probably give repositories round-robin queue
	// priority, but we don't currently have the primitives for this and there
	// isn't a strong case for building them.

	// Use "a whole lot of commits showed up at once" as a heuristic for
	// detecting "someone synchronized an upstream", and import them at a lower
	// priority to more closely approximate fair scheduling.

	if (count($refs) >= PhabricatorRepository::LOWPRI_THRESHOLD) {
	$this->log(
	pht(
	'Importing %s commit(s) at low priority ("PRIORITY_IMPORT") '.
	'because many commits were discovered at once.',
	phutil_count($refs)));

	return PhabricatorWorker::PRIORITY_IMPORT;
	}

	// Otherwise, import at normal priority.

	if ($refs) {
	$this->log(
	pht(
	'Importing %s commit(s) at normal priority ("PRIORITY_COMMIT").',
	phutil_count($refs)));
	}

	return PhabricatorWorker::PRIORITY_COMMIT;
	}

	}
	diff --git a/src/applications/repository/engine/PhabricatorRepositoryRefEngine.php b/src/applications/repository/engine/PhabricatorRepositoryRefEngine.php
	index 0166e8e53c..18dbf754f9 100644
	--- a/src/applications/repository/engine/PhabricatorRepositoryRefEngine.php
	+++ b/src/applications/repository/engine/PhabricatorRepositoryRefEngine.php
	@@ -1,721 +1,721 @@
	<?php

	/**
	* Update the ref cursors for a repository, which track the positions of
	* branches, bookmarks, and tags.
	*/
	final class PhabricatorRepositoryRefEngine
	extends PhabricatorRepositoryEngine {

	private $newPositions = array();
	private $deadPositions = array();
	- private $closeCommits = array();
	+ private $permanentCommits = array();
	private $rebuild;

	public function setRebuild($rebuild) {
	$this->rebuild = $rebuild;
	return $this;
	}

	public function getRebuild() {
	return $this->rebuild;
	}

	public function updateRefs() {
	$this->newPositions = array();
	$this->deadPositions = array();
	- $this->closeCommits = array();
	+ $this->permanentCommits = array();

	$repository = $this->getRepository();
	$viewer = $this->getViewer();

	$branches_may_close = false;

	$vcs = $repository->getVersionControlSystem();
	switch ($vcs) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	// No meaningful refs of any type in Subversion.
	$maps = array();
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	$branches = $this->loadMercurialBranchPositions($repository);
	$bookmarks = $this->loadMercurialBookmarkPositions($repository);
	$maps = array(
	PhabricatorRepositoryRefCursor::TYPE_BRANCH => $branches,
	PhabricatorRepositoryRefCursor::TYPE_BOOKMARK => $bookmarks,
	);

	$branches_may_close = true;
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	$maps = $this->loadGitRefPositions($repository);
	break;
	default:
	throw new Exception(pht('Unknown VCS "%s"!', $vcs));
	}

	// Fill in any missing types with empty lists.
	$maps = $maps + array(
	PhabricatorRepositoryRefCursor::TYPE_BRANCH => array(),
	PhabricatorRepositoryRefCursor::TYPE_TAG => array(),
	PhabricatorRepositoryRefCursor::TYPE_BOOKMARK => array(),
	PhabricatorRepositoryRefCursor::TYPE_REF => array(),
	);

	$all_cursors = id(new PhabricatorRepositoryRefCursorQuery())
	->setViewer($viewer)
	->withRepositoryPHIDs(array($repository->getPHID()))
	->needPositions(true)
	->execute();
	$cursor_groups = mgroup($all_cursors, 'getRefType');

	// Find all the heads of permanent refs.
	$all_closing_heads = array();
	foreach ($all_cursors as $cursor) {

	// See T13284. Note that we're considering whether this ref was a
	// permanent ref or not the last time we updated refs for this
	// repository. This allows us to handle things properly when a ref
	// is reconfigured from non-permanent to permanent.

	$was_permanent = $cursor->getIsPermanent();
	if (!$was_permanent) {
	continue;
	}

	foreach ($cursor->getPositionIdentifiers() as $identifier) {
	$all_closing_heads[] = $identifier;
	}
	}

	$all_closing_heads = array_unique($all_closing_heads);
	$all_closing_heads = $this->removeMissingCommits($all_closing_heads);

	foreach ($maps as $type => $refs) {
	$cursor_group = idx($cursor_groups, $type, array());
	$this->updateCursors($cursor_group, $refs, $type, $all_closing_heads);
	}

	- if ($this->closeCommits) {
	- $this->setCloseFlagOnCommits($this->closeCommits);
	+ if ($this->permanentCommits) {
	+ $this->setPermanentFlagOnCommits($this->permanentCommits);
	}

	$save_cursors = $this->getCursorsForUpdate($all_cursors);

	if ($this->newPositions \|\| $this->deadPositions \|\| $save_cursors) {
	$repository->openTransaction();

	$this->saveNewPositions();
	$this->deleteDeadPositions();

	foreach ($save_cursors as $cursor) {
	$cursor->save();
	}

	$repository->saveTransaction();
	}

	$branches = $maps[PhabricatorRepositoryRefCursor::TYPE_BRANCH];
	if ($branches && $branches_may_close) {
	$this->updateBranchStates($repository, $branches);
	}
	}

	private function getCursorsForUpdate(array $cursors) {
	assert_instances_of($cursors, 'PhabricatorRepositoryRefCursor');

	$results = array();

	foreach ($cursors as $cursor) {
	$ref_type = $cursor->getRefType();
	$ref_name = $cursor->getRefName();

	$is_permanent = $this->isPermanentRef($ref_type, $ref_name);

	if ($is_permanent == $cursor->getIsPermanent()) {
	continue;
	}

	$cursor->setIsPermanent((int)$is_permanent);
	$results[] = $cursor;
	}

	return $results;
	}

	private function updateBranchStates(
	PhabricatorRepository $repository,
	array $branches) {

	assert_instances_of($branches, 'DiffusionRepositoryRef');
	$viewer = $this->getViewer();

	$all_cursors = id(new PhabricatorRepositoryRefCursorQuery())
	->setViewer($viewer)
	->withRepositoryPHIDs(array($repository->getPHID()))
	->needPositions(true)
	->execute();

	$state_map = array();
	$type_branch = PhabricatorRepositoryRefCursor::TYPE_BRANCH;
	foreach ($all_cursors as $cursor) {
	if ($cursor->getRefType() !== $type_branch) {
	continue;
	}
	$raw_name = $cursor->getRefNameRaw();

	foreach ($cursor->getPositions() as $position) {
	$hash = $position->getCommitIdentifier();
	$state_map[$raw_name][$hash] = $position;
	}
	}

	$updates = array();
	foreach ($branches as $branch) {
	$position = idx($state_map, $branch->getShortName(), array());
	$position = idx($position, $branch->getCommitIdentifier());
	if (!$position) {
	continue;
	}

	$fields = $branch->getRawFields();

	$position_state = (bool)$position->getIsClosed();
	$branch_state = (bool)idx($fields, 'closed');

	if ($position_state != $branch_state) {
	$updates[$position->getID()] = (int)$branch_state;
	}
	}

	if ($updates) {
	$position_table = id(new PhabricatorRepositoryRefPosition());
	$conn = $position_table->establishConnection('w');

	$position_table->openTransaction();
	foreach ($updates as $position_id => $branch_state) {
	queryfx(
	$conn,
	'UPDATE %T SET isClosed = %d WHERE id = %d',
	$position_table->getTableName(),
	$branch_state,
	$position_id);
	}
	$position_table->saveTransaction();
	}
	}

	private function markPositionNew(
	PhabricatorRepositoryRefPosition $position) {
	$this->newPositions[] = $position;
	return $this;
	}

	private function markPositionDead(
	PhabricatorRepositoryRefPosition $position) {
	$this->deadPositions[] = $position;
	return $this;
	}

	- private function markCloseCommits(array $identifiers) {
	+ private function markPermanentCommits(array $identifiers) {
	foreach ($identifiers as $identifier) {
	- $this->closeCommits[$identifier] = $identifier;
	+ $this->permanentCommits[$identifier] = $identifier;
	}
	return $this;
	}

	/**
	* Remove commits which no longer exist in the repository from a list.
	*
	* After a force push and garbage collection, we may have branch cursors which
	* point at commits which no longer exist. This can make commands issued later
	* fail. See T5839 for discussion.
	*
	* @param list<string> List of commit identifiers.
	* @return list<string> List with nonexistent identifiers removed.
	*/
	private function removeMissingCommits(array $identifiers) {
	if (!$identifiers) {
	return array();
	}

	$resolved = id(new DiffusionLowLevelResolveRefsQuery())
	->setRepository($this->getRepository())
	->withRefs($identifiers)
	->execute();

	foreach ($identifiers as $key => $identifier) {
	if (empty($resolved[$identifier])) {
	unset($identifiers[$key]);
	}
	}

	return $identifiers;
	}

	private function updateCursors(
	array $cursors,
	array $new_refs,
	$ref_type,
	array $all_closing_heads) {
	$repository = $this->getRepository();

	// NOTE: Mercurial branches may have multiple branch heads; this logic
	// is complex primarily to account for that.

	$cursors = mpull($cursors, null, 'getRefNameRaw');

	// Group all the new ref values by their name. As above, these groups may
	// have multiple members in Mercurial.
	$ref_groups = mgroup($new_refs, 'getShortName');

	foreach ($ref_groups as $name => $refs) {
	$new_commits = mpull($refs, 'getCommitIdentifier', 'getCommitIdentifier');

	$ref_cursor = idx($cursors, $name);
	if ($ref_cursor) {
	$old_positions = $ref_cursor->getPositions();
	} else {
	$old_positions = array();
	}

	// We're going to delete all the cursors pointing at commits which are
	// no longer associated with the refs. This primarily makes the Mercurial
	// multiple head case easier, and means that when we update a ref we
	// delete the old one and write a new one.
	foreach ($old_positions as $old_position) {
	$hash = $old_position->getCommitIdentifier();
	if (isset($new_commits[$hash])) {
	// This ref previously pointed at this commit, and still does.
	$this->log(
	pht(
	'Ref %s "%s" still points at %s.',
	$ref_type,
	$name,
	$hash));
	continue;
	}

	// This ref previously pointed at this commit, but no longer does.
	$this->log(
	pht(
	'Ref %s "%s" no longer points at %s.',
	$ref_type,
	$name,
	$hash));

	// Nuke the obsolete cursor.
	$this->markPositionDead($old_position);
	}

	// Now, we're going to insert new cursors for all the commits which are
	// associated with this ref that don't currently have cursors.
	$old_commits = mpull($old_positions, 'getCommitIdentifier');
	$old_commits = array_fuse($old_commits);

	$added_commits = array_diff_key($new_commits, $old_commits);
	foreach ($added_commits as $identifier) {
	$this->log(
	pht(
	'Ref %s "%s" now points at %s.',
	$ref_type,
	$name,
	$identifier));

	if (!$ref_cursor) {
	// If this is the first time we've seen a particular ref (for
	// example, a new branch) we need to insert a RefCursor record
	// for it before we can insert a RefPosition.

	$ref_cursor = $this->newRefCursor(
	$repository,
	$ref_type,
	$name);
	}

	$new_position = id(new PhabricatorRepositoryRefPosition())
	->setCursorID($ref_cursor->getID())
	->setCommitIdentifier($identifier)
	->setIsClosed(0);

	$this->markPositionNew($new_position);
	}

	if ($this->isPermanentRef($ref_type, $name)) {

	// See T13284. If this cursor was already marked as permanent, we
	// only need to publish the newly created ref positions. However, if
	// this cursor was not previously permanent but has become permanent,
	// we need to publish all the ref positions.

	// This corresponds to users reconfiguring a branch to make it
	// permanent without pushing any new commits to it.

	$is_rebuild = $this->getRebuild();
	$was_permanent = $ref_cursor->getIsPermanent();

	if ($is_rebuild \|\| !$was_permanent) {
	$update_all = true;
	} else {
	$update_all = false;
	}

	if ($update_all) {
	$update_commits = $new_commits;
	} else {
	$update_commits = $added_commits;
	}

	if ($is_rebuild) {
	$exclude = array();
	} else {
	$exclude = $all_closing_heads;
	}

	foreach ($update_commits as $identifier) {
	$new_identifiers = $this->loadNewCommitIdentifiers(
	$identifier,
	$exclude);

	- $this->markCloseCommits($new_identifiers);
	+ $this->markPermanentCommits($new_identifiers);
	}
	}
	}

	// Find any cursors for refs which no longer exist. This happens when a
	// branch, tag or bookmark is deleted.

	foreach ($cursors as $name => $cursor) {
	if (!empty($ref_groups[$name])) {
	// This ref still has some positions, so we don't need to wipe it
	// out. Try the next one.
	continue;
	}

	foreach ($cursor->getPositions() as $position) {
	$this->log(
	pht(
	'Ref %s "%s" no longer exists.',
	$cursor->getRefType(),
	$cursor->getRefName()));

	$this->markPositionDead($position);
	}
	}
	}

	private function isPermanentRef($ref_type, $ref_name) {
	if ($ref_type !== PhabricatorRepositoryRefCursor::TYPE_BRANCH) {
	return false;
	}

	return $this->getRepository()->isBranchPermanentRef($ref_name);
	}

	/**
	* Find all ancestors of a new closing branch head which are not ancestors
	* of any old closing branch head.
	*/
	private function loadNewCommitIdentifiers(
	$new_head,
	array $all_closing_heads) {

	$repository = $this->getRepository();
	$vcs = $repository->getVersionControlSystem();
	switch ($vcs) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	if ($all_closing_heads) {
	$parts = array();
	foreach ($all_closing_heads as $head) {
	$parts[] = hgsprintf('%s', $head);
	}

	// See T5896. Mercurial can not parse an "X or Y or ..." rev list
	// with more than about 300 items, because it exceeds the maximum
	// allowed recursion depth. Split all the heads into chunks of
	// 256, and build a query like this:
	//
	// ((1 or 2 or ... or 255) or (256 or 257 or ... 511))
	//
	// If we have more than 65535 heads, we'll do that again:
	//
	// (((1 or ...) or ...) or ((65536 or ...) or ...))

	$chunk_size = 256;
	while (count($parts) > $chunk_size) {
	$chunks = array_chunk($parts, $chunk_size);
	foreach ($chunks as $key => $chunk) {
	$chunks[$key] = '('.implode(' or ', $chunk).')';
	}
	$parts = array_values($chunks);
	}
	$parts = '('.implode(' or ', $parts).')';

	list($stdout) = $this->getRepository()->execxLocalCommand(
	'log --template %s --rev %s',
	'{node}\n',
	hgsprintf('%s', $new_head).' - '.$parts);
	} else {
	list($stdout) = $this->getRepository()->execxLocalCommand(
	'log --template %s --rev %s',
	'{node}\n',
	hgsprintf('%s', $new_head));
	}

	$stdout = trim($stdout);
	if (!strlen($stdout)) {
	return array();
	}
	return phutil_split_lines($stdout, $retain_newlines = false);
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	if ($all_closing_heads) {

	// See PHI1474. This length of list may exceed the maximum size of
	// a command line argument list, so pipe the list in using "--stdin"
	// instead.

	$ref_list = array();
	$ref_list[] = $new_head;
	foreach ($all_closing_heads as $old_head) {
	$ref_list[] = '^'.$old_head;
	}
	$ref_list[] = '--';
	$ref_list = implode("\n", $ref_list)."\n";

	$future = $this->getRepository()->getLocalCommandFuture(
	'log %s --stdin --',
	'--format=%H');

	list($stdout) = $future
	->write($ref_list)
	->resolvex();
	} else {
	list($stdout) = $this->getRepository()->execxLocalCommand(
	'log %s %s --',
	'--format=%H',
	gitsprintf('%s', $new_head));
	}

	$stdout = trim($stdout);
	if (!strlen($stdout)) {
	return array();
	}
	return phutil_split_lines($stdout, $retain_newlines = false);
	default:
	throw new Exception(pht('Unsupported VCS "%s"!', $vcs));
	}
	}

	/**
	- * Mark a list of commits as closeable, and queue workers for those commits
	+ * Mark a list of commits as permanent, and queue workers for those commits
	* which don't already have the flag.
	*/
	- private function setCloseFlagOnCommits(array $identifiers) {
	+ private function setPermanentFlagOnCommits(array $identifiers) {
	$repository = $this->getRepository();
	$commit_table = new PhabricatorRepositoryCommit();
	$conn = $commit_table->establishConnection('w');

	$vcs = $repository->getVersionControlSystem();
	switch ($vcs) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	$class = 'PhabricatorRepositoryGitCommitMessageParserWorker';
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	$class = 'PhabricatorRepositorySvnCommitMessageParserWorker';
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	$class = 'PhabricatorRepositoryMercurialCommitMessageParserWorker';
	break;
	default:
	throw new Exception(pht("Unknown repository type '%s'!", $vcs));
	}

	$identifier_tokens = array();
	foreach ($identifiers as $identifier) {
	$identifier_tokens[] = qsprintf(
	$conn,
	'%s',
	$identifier);
	}

	$all_commits = array();
	foreach (PhabricatorLiskDAO::chunkSQL($identifier_tokens) as $chunk) {
	$rows = queryfx_all(
	$conn,
	'SELECT id, phid, commitIdentifier, importStatus FROM %T
	WHERE repositoryID = %d AND commitIdentifier IN (%LQ)',
	$commit_table->getTableName(),
	$repository->getID(),
	$chunk);
	foreach ($rows as $row) {
	$all_commits[] = $row;
	}
	}

	- $closeable_flag = PhabricatorRepositoryCommit::IMPORTED_CLOSEABLE;
	+ $permanent_flag = PhabricatorRepositoryCommit::IMPORTED_PERMANENT;
	$published_flag = PhabricatorRepositoryCommit::IMPORTED_PUBLISH;

	$all_commits = ipull($all_commits, null, 'commitIdentifier');
	foreach ($identifiers as $identifier) {
	$row = idx($all_commits, $identifier);

	if (!$row) {
	throw new Exception(
	pht(
	'Commit "%s" has not been discovered yet! Run discovery before '.
	'updating refs.',
	$identifier));
	}

	$import_status = $row['importStatus'];
	- if (!($import_status & $closeable_flag)) {
	- // Set the "closeable" flag.
	- $import_status = ($import_status \| $closeable_flag);
	+ if (!($import_status & $permanent_flag)) {
	+ // Set the "permanent" flag.
	+ $import_status = ($import_status \| $permanent_flag);

	// See T13580. Clear the "published" flag, so publishing executes
	// again. We may have previously performed a no-op "publish" on the
	// commit to make sure it has all bits in the "IMPORTED_ALL" bitmask.
	$import_status = ($import_status & ~$published_flag);

	queryfx(
	$conn,
	'UPDATE %T SET importStatus = %d WHERE id = %d',
	$commit_table->getTableName(),
	$import_status,
	$row['id']);

	$data = array(
	'commitID' => $row['id'],
	);

	PhabricatorWorker::scheduleTask(
	$class,
	$data,
	array(
	'priority' => PhabricatorWorker::PRIORITY_COMMIT,
	'objectPHID' => $row['phid'],
	));
	}
	}

	return $this;
	}

	private function newRefCursor(
	PhabricatorRepository $repository,
	$ref_type,
	$ref_name) {

	$is_permanent = $this->isPermanentRef($ref_type, $ref_name);

	$cursor = id(new PhabricatorRepositoryRefCursor())
	->setRepositoryPHID($repository->getPHID())
	->setRefType($ref_type)
	->setRefName($ref_name)
	->setIsPermanent((int)$is_permanent);

	try {
	return $cursor->save();
	} catch (AphrontDuplicateKeyQueryException $ex) {
	// If we raced another daemon to create this position and lost the race,
	// load the cursor the other daemon created instead.
	}

	$viewer = $this->getViewer();

	$cursor = id(new PhabricatorRepositoryRefCursorQuery())
	->setViewer($viewer)
	->withRepositoryPHIDs(array($repository->getPHID()))
	->withRefTypes(array($ref_type))
	->withRefNames(array($ref_name))
	->needPositions(true)
	->executeOne();
	if (!$cursor) {
	throw new Exception(
	pht(
	'Failed to create a new ref cursor (for "%s", of type "%s", in '.
	'repository "%s") because it collided with an existing cursor, '.
	'but then failed to load that cursor.',
	$ref_name,
	$ref_type,
	$repository->getDisplayName()));
	}

	return $cursor;
	}

	private function saveNewPositions() {
	$positions = $this->newPositions;

	foreach ($positions as $position) {
	try {
	$position->save();
	} catch (AphrontDuplicateKeyQueryException $ex) {
	// We may race another daemon to create this position. If we do, and
	// we lose the race, that's fine: the other daemon did our work for
	// us and we can continue.
	}
	}

	$this->newPositions = array();
	}

	private function deleteDeadPositions() {
	$positions = $this->deadPositions;
	$repository = $this->getRepository();

	foreach ($positions as $position) {
	// Shove this ref into the old refs table so the discovery engine
	// can check if any commits have been rendered unreachable.
	id(new PhabricatorRepositoryOldRef())
	->setRepositoryPHID($repository->getPHID())
	->setCommitIdentifier($position->getCommitIdentifier())
	->save();

	$position->delete();
	}

	$this->deadPositions = array();
	}



	/* -( Updating Git Refs )-------------------------------------------------- */


	/**
	* @task git
	*/
	private function loadGitRefPositions(PhabricatorRepository $repository) {
	$refs = id(new DiffusionLowLevelGitRefQuery())
	->setRepository($repository)
	->execute();

	return mgroup($refs, 'getRefType');
	}


	/* -( Updating Mercurial Refs )-------------------------------------------- */


	/**
	* @task hg
	*/
	private function loadMercurialBranchPositions(
	PhabricatorRepository $repository) {
	return id(new DiffusionLowLevelMercurialBranchesQuery())
	->setRepository($repository)
	->execute();
	}


	/**
	* @task hg
	*/
	private function loadMercurialBookmarkPositions(
	PhabricatorRepository $repository) {
	// TODO: Implement support for Mercurial bookmarks.
	return array();
	}

	}
	diff --git a/src/applications/repository/storage/PhabricatorRepositoryCommit.php b/src/applications/repository/storage/PhabricatorRepositoryCommit.php
	index 586f1e2d0a..5fb089953d 100644
	--- a/src/applications/repository/storage/PhabricatorRepositoryCommit.php
	+++ b/src/applications/repository/storage/PhabricatorRepositoryCommit.php
	@@ -1,969 +1,969 @@
	<?php

	final class PhabricatorRepositoryCommit
	extends PhabricatorRepositoryDAO
	implements
	PhabricatorPolicyInterface,
	PhabricatorFlaggableInterface,
	PhabricatorProjectInterface,
	PhabricatorTokenReceiverInterface,
	PhabricatorSubscribableInterface,
	PhabricatorMentionableInterface,
	HarbormasterBuildableInterface,
	HarbormasterCircleCIBuildableInterface,
	HarbormasterBuildkiteBuildableInterface,
	PhabricatorCustomFieldInterface,
	PhabricatorApplicationTransactionInterface,
	PhabricatorTimelineInterface,
	PhabricatorFulltextInterface,
	PhabricatorFerretInterface,
	PhabricatorConduitResultInterface,
	PhabricatorDraftInterface {

	protected $repositoryID;
	protected $phid;
	protected $authorIdentityPHID;
	protected $committerIdentityPHID;
	protected $commitIdentifier;
	protected $epoch;
	protected $authorPHID;
	protected $auditStatus = DiffusionCommitAuditStatus::NONE;
	protected $summary = '';
	protected $importStatus = 0;

	const IMPORTED_MESSAGE = 1;
	const IMPORTED_CHANGE = 2;
	const IMPORTED_PUBLISH = 8;
	const IMPORTED_ALL = 11;

	- const IMPORTED_CLOSEABLE = 1024;
	+ const IMPORTED_PERMANENT = 1024;
	const IMPORTED_UNREACHABLE = 2048;

	private $commitData = self::ATTACHABLE;
	private $audits = self::ATTACHABLE;
	private $repository = self::ATTACHABLE;
	private $customFields = self::ATTACHABLE;
	private $authorIdentity = self::ATTACHABLE;
	private $committerIdentity = self::ATTACHABLE;

	private $drafts = array();
	private $auditAuthorityPHIDs = array();

	public function attachRepository(PhabricatorRepository $repository) {
	$this->repository = $repository;
	return $this;
	}

	public function getRepository($assert_attached = true) {
	if ($assert_attached) {
	return $this->assertAttached($this->repository);
	}
	return $this->repository;
	}

	public function isPartiallyImported($mask) {
	return (($mask & $this->getImportStatus()) == $mask);
	}

	public function isImported() {
	return $this->isPartiallyImported(self::IMPORTED_ALL);
	}

	public function isUnreachable() {
	return $this->isPartiallyImported(self::IMPORTED_UNREACHABLE);
	}

	public function writeImportStatusFlag($flag) {
	return $this->adjustImportStatusFlag($flag, true);
	}

	public function clearImportStatusFlag($flag) {
	return $this->adjustImportStatusFlag($flag, false);
	}

	private function adjustImportStatusFlag($flag, $set) {
	$conn_w = $this->establishConnection('w');
	$table_name = $this->getTableName();
	$id = $this->getID();

	if ($set) {
	queryfx(
	$conn_w,
	'UPDATE %T SET importStatus = (importStatus \| %d) WHERE id = %d',
	$table_name,
	$flag,
	$id);

	$this->setImportStatus($this->getImportStatus() \| $flag);
	} else {
	queryfx(
	$conn_w,
	'UPDATE %T SET importStatus = (importStatus & ~%d) WHERE id = %d',
	$table_name,
	$flag,
	$id);

	$this->setImportStatus($this->getImportStatus() & ~$flag);
	}

	return $this;
	}

	protected function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_TIMESTAMPS => false,
	self::CONFIG_COLUMN_SCHEMA => array(
	'commitIdentifier' => 'text40',
	'authorPHID' => 'phid?',
	'authorIdentityPHID' => 'phid?',
	'committerIdentityPHID' => 'phid?',
	'auditStatus' => 'text32',
	'summary' => 'text255',
	'importStatus' => 'uint32',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'key_phid' => null,
	'phid' => array(
	'columns' => array('phid'),
	'unique' => true,
	),
	'repositoryID' => array(
	'columns' => array('repositoryID', 'importStatus'),
	),
	'authorPHID' => array(
	'columns' => array('authorPHID', 'auditStatus', 'epoch'),
	),
	'repositoryID_2' => array(
	'columns' => array('repositoryID', 'epoch'),
	),
	'key_commit_identity' => array(
	'columns' => array('commitIdentifier', 'repositoryID'),
	'unique' => true,
	),
	'key_epoch' => array(
	'columns' => array('epoch'),
	),
	'key_author' => array(
	'columns' => array('authorPHID', 'epoch'),
	),
	),
	self::CONFIG_NO_MUTATE => array(
	'importStatus',
	),
	) + parent::getConfiguration();
	}

	public function generatePHID() {
	return PhabricatorPHID::generateNewPHID(
	PhabricatorRepositoryCommitPHIDType::TYPECONST);
	}

	public function loadCommitData() {
	if (!$this->getID()) {
	return null;
	}
	return id(new PhabricatorRepositoryCommitData())->loadOneWhere(
	'commitID = %d',
	$this->getID());
	}

	public function attachCommitData(
	PhabricatorRepositoryCommitData $data = null) {
	$this->commitData = $data;
	return $this;
	}

	public function hasCommitData() {
	return ($this->commitData !== self::ATTACHABLE) &&
	($this->commitData !== null);
	}

	public function getCommitData() {
	return $this->assertAttached($this->commitData);
	}

	public function attachAudits(array $audits) {
	assert_instances_of($audits, 'PhabricatorRepositoryAuditRequest');
	$this->audits = $audits;
	return $this;
	}

	public function getAudits() {
	return $this->assertAttached($this->audits);
	}

	public function hasAttachedAudits() {
	return ($this->audits !== self::ATTACHABLE);
	}

	public function attachIdentities(
	PhabricatorRepositoryIdentity $author = null,
	PhabricatorRepositoryIdentity $committer = null) {

	$this->authorIdentity = $author;
	$this->committerIdentity = $committer;

	return $this;
	}

	public function getAuthorIdentity() {
	return $this->assertAttached($this->authorIdentity);
	}

	public function getCommitterIdentity() {
	return $this->assertAttached($this->committerIdentity);
	}

	public function attachAuditAuthority(
	PhabricatorUser $user,
	array $authority) {

	$user_phid = $user->getPHID();
	if (!$user->getPHID()) {
	throw new Exception(
	pht('You can not attach audit authority for a user with no PHID.'));
	}

	$this->auditAuthorityPHIDs[$user_phid] = $authority;

	return $this;
	}

	public function hasAuditAuthority(
	PhabricatorUser $user,
	PhabricatorRepositoryAuditRequest $audit) {

	$user_phid = $user->getPHID();
	if (!$user_phid) {
	return false;
	}

	$map = $this->assertAttachedKey($this->auditAuthorityPHIDs, $user_phid);

	return isset($map[$audit->getAuditorPHID()]);
	}

	public function writeOwnersEdges(array $package_phids) {
	$src_phid = $this->getPHID();
	$edge_type = DiffusionCommitHasPackageEdgeType::EDGECONST;

	$editor = new PhabricatorEdgeEditor();

	$dst_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
	$src_phid,
	$edge_type);

	foreach ($dst_phids as $dst_phid) {
	$editor->removeEdge($src_phid, $edge_type, $dst_phid);
	}

	foreach ($package_phids as $package_phid) {
	$editor->addEdge($src_phid, $edge_type, $package_phid);
	}

	$editor->save();

	return $this;
	}

	public function getAuditorPHIDsForEdit() {
	$audits = $this->getAudits();
	return mpull($audits, 'getAuditorPHID');
	}

	public function delete() {
	$data = $this->loadCommitData();
	$audits = id(new PhabricatorRepositoryAuditRequest())
	->loadAllWhere('commitPHID = %s', $this->getPHID());
	$this->openTransaction();

	if ($data) {
	$data->delete();
	}
	foreach ($audits as $audit) {
	$audit->delete();
	}
	$result = parent::delete();

	$this->saveTransaction();
	return $result;
	}

	public function getDateCreated() {
	// This is primarily to make analysis of commits with the Fact engine work.
	return $this->getEpoch();
	}

	public function getURI() {
	return '/'.$this->getMonogram();
	}

	/**
	* Synchronize a commit's overall audit status with the individual audit
	* triggers.
	*/
	public function updateAuditStatus(array $requests) {
	assert_instances_of($requests, 'PhabricatorRepositoryAuditRequest');

	$any_concern = false;
	$any_accept = false;
	$any_need = false;

	foreach ($requests as $request) {
	switch ($request->getAuditStatus()) {
	case PhabricatorAuditStatusConstants::AUDIT_REQUIRED:
	case PhabricatorAuditStatusConstants::AUDIT_REQUESTED:
	$any_need = true;
	break;
	case PhabricatorAuditStatusConstants::ACCEPTED:
	$any_accept = true;
	break;
	case PhabricatorAuditStatusConstants::CONCERNED:
	$any_concern = true;
	break;
	}
	}

	if ($any_concern) {
	if ($this->isAuditStatusNeedsVerification()) {
	// If the change is in "Needs Verification", we keep it there as
	// long as any auditors still have concerns.
	$status = DiffusionCommitAuditStatus::NEEDS_VERIFICATION;
	} else {
	$status = DiffusionCommitAuditStatus::CONCERN_RAISED;
	}
	} else if ($any_accept) {
	if ($any_need) {
	$status = DiffusionCommitAuditStatus::PARTIALLY_AUDITED;
	} else {
	$status = DiffusionCommitAuditStatus::AUDITED;
	}
	} else if ($any_need) {
	$status = DiffusionCommitAuditStatus::NEEDS_AUDIT;
	} else {
	$status = DiffusionCommitAuditStatus::NONE;
	}

	return $this->setAuditStatus($status);
	}

	public function getMonogram() {
	$repository = $this->getRepository();
	$callsign = $repository->getCallsign();
	$identifier = $this->getCommitIdentifier();
	if ($callsign !== null) {
	return "r{$callsign}{$identifier}";
	} else {
	$id = $repository->getID();
	return "R{$id}:{$identifier}";
	}
	}

	public function getDisplayName() {
	$repository = $this->getRepository();
	$identifier = $this->getCommitIdentifier();
	return $repository->formatCommitName($identifier);
	}

	/**
	* Return a local display name for use in the context of the containing
	* repository.
	*
	* In Git and Mercurial, this returns only a short hash, like "abcdef012345".
	* See @{method:getDisplayName} for a short name that always includes
	* repository context.
	*
	* @return string Short human-readable name for use inside a repository.
	*/
	public function getLocalName() {
	$repository = $this->getRepository();
	$identifier = $this->getCommitIdentifier();
	return $repository->formatCommitName($identifier, $local = true);
	}

	public function loadIdentities(PhabricatorUser $viewer) {
	if ($this->authorIdentity !== self::ATTACHABLE) {
	return $this;
	}

	$commit = id(new DiffusionCommitQuery())
	->setViewer($viewer)
	->withIDs(array($this->getID()))
	->needIdentities(true)
	->executeOne();

	$author_identity = $commit->getAuthorIdentity();
	$committer_identity = $commit->getCommitterIdentity();

	return $this->attachIdentities($author_identity, $committer_identity);
	}

	public function hasCommitterIdentity() {
	return ($this->getCommitterIdentity() !== null);
	}

	public function hasAuthorIdentity() {
	return ($this->getAuthorIdentity() !== null);
	}

	public function getCommitterDisplayPHID() {
	if ($this->hasCommitterIdentity()) {
	return $this->getCommitterIdentity()->getIdentityDisplayPHID();
	}

	$data = $this->getCommitData();
	return $data->getCommitDetail('committerPHID');
	}

	public function getAuthorDisplayPHID() {
	if ($this->hasAuthorIdentity()) {
	return $this->getAuthorIdentity()->getIdentityDisplayPHID();
	}

	$data = $this->getCommitData();
	return $data->getCommitDetail('authorPHID');
	}

	public function getEffectiveAuthorPHID() {
	if ($this->hasAuthorIdentity()) {
	$identity = $this->getAuthorIdentity();
	if ($identity->hasEffectiveUser()) {
	return $identity->getCurrentEffectiveUserPHID();
	}
	}

	$data = $this->getCommitData();
	return $data->getCommitDetail('authorPHID');
	}

	public function getAuditStatusObject() {
	$status = $this->getAuditStatus();
	return DiffusionCommitAuditStatus::newForStatus($status);
	}

	public function isAuditStatusNoAudit() {
	return $this->getAuditStatusObject()->isNoAudit();
	}

	public function isAuditStatusNeedsAudit() {
	return $this->getAuditStatusObject()->isNeedsAudit();
	}

	public function isAuditStatusConcernRaised() {
	return $this->getAuditStatusObject()->isConcernRaised();
	}

	public function isAuditStatusNeedsVerification() {
	return $this->getAuditStatusObject()->isNeedsVerification();
	}

	public function isAuditStatusPartiallyAudited() {
	return $this->getAuditStatusObject()->isPartiallyAudited();
	}

	public function isAuditStatusAudited() {
	return $this->getAuditStatusObject()->isAudited();
	}

	public function isPermanentCommit() {
	- return (bool)$this->isPartiallyImported(self::IMPORTED_CLOSEABLE);
	+ return (bool)$this->isPartiallyImported(self::IMPORTED_PERMANENT);
	}

	public function newCommitAuthorView(PhabricatorUser $viewer) {
	$author_phid = $this->getAuthorDisplayPHID();
	if ($author_phid) {
	$handles = $viewer->loadHandles(array($author_phid));
	return $handles[$author_phid]->renderLink();
	}

	$author = $this->getRawAuthorStringForDisplay();
	if (strlen($author)) {
	return DiffusionView::renderName($author);
	}

	return null;
	}

	public function newCommitCommitterView(PhabricatorUser $viewer) {
	$committer_phid = $this->getCommitterDisplayPHID();
	if ($committer_phid) {
	$handles = $viewer->loadHandles(array($committer_phid));
	return $handles[$committer_phid]->renderLink();
	}

	$committer = $this->getRawCommitterStringForDisplay();
	if (strlen($committer)) {
	return DiffusionView::renderName($committer);
	}

	return null;
	}

	public function isAuthorSameAsCommitter() {
	$author_phid = $this->getAuthorDisplayPHID();
	$committer_phid = $this->getCommitterDisplayPHID();

	if ($author_phid && $committer_phid) {
	return ($author_phid === $committer_phid);
	}

	if ($author_phid \|\| $committer_phid) {
	return false;
	}

	$author = $this->getRawAuthorStringForDisplay();
	$committer = $this->getRawCommitterStringForDisplay();

	return ($author === $committer);
	}

	private function getRawAuthorStringForDisplay() {
	$data = $this->getCommitData();
	return $data->getAuthorString();
	}

	private function getRawCommitterStringForDisplay() {
	$data = $this->getCommitData();
	return $data->getCommitterString();
	}

	public function newCommitRef(PhabricatorUser $viewer) {
	$repository = $this->getRepository();

	$future = $repository->newConduitFuture(
	$viewer,
	'internal.commit.search',
	array(
	'constraints' => array(
	'repositoryPHIDs' => array($repository->getPHID()),
	'phids' => array($this->getPHID()),
	),
	));
	$result = $future->resolve();

	$commit_display = $this->getMonogram();

	if (empty($result['data'])) {
	throw new Exception(
	pht(
	'Unable to retrieve details for commit "%s"!',
	$commit_display));
	}

	if (count($result['data']) !== 1) {
	throw new Exception(
	pht(
	'Got too many results (%s) for commit "%s", expected %s.',
	phutil_count($result['data']),
	$commit_display,
	1));
	}

	$record = head($result['data']);
	$ref_record = idxv($record, array('fields', 'ref'));

	if (!$ref_record) {
	throw new Exception(
	pht(
	'Unable to retrieve CommitRef record for commit "%s".',
	$commit_display));
	}

	return DiffusionCommitRef::newFromDictionary($ref_record);
	}

	/* -( PhabricatorPolicyInterface )----------------------------------------- */

	public function getCapabilities() {
	return array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	);
	}

	public function getPolicy($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	return $this->getRepository()->getPolicy($capability);
	case PhabricatorPolicyCapability::CAN_EDIT:
	return PhabricatorPolicies::POLICY_USER;
	}
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	return $this->getRepository()->hasAutomaticCapability($capability, $viewer);
	}

	public function describeAutomaticCapability($capability) {
	return pht(
	'Commits inherit the policies of the repository they belong to.');
	}


	/* -( PhabricatorTokenReceiverInterface )---------------------------------- */

	public function getUsersToNotifyOfTokenGiven() {
	return array(
	$this->getAuthorPHID(),
	);
	}

	/* -( Stuff for serialization )---------------------------------------------- */

	/**
	* NOTE: this is not a complete serialization; only the 'protected' fields are
	* involved. This is due to ease of (ab)using the Lisk abstraction to get this
	* done, as well as complexity of the other fields.
	*/
	public function toDictionary() {
	return array(
	'repositoryID' => $this->getRepositoryID(),
	'phid' => $this->getPHID(),
	'commitIdentifier' => $this->getCommitIdentifier(),
	'epoch' => $this->getEpoch(),
	'authorPHID' => $this->getAuthorPHID(),
	'auditStatus' => $this->getAuditStatus(),
	'summary' => $this->getSummary(),
	'importStatus' => $this->getImportStatus(),
	);
	}

	public static function newFromDictionary(array $dict) {
	return id(new PhabricatorRepositoryCommit())
	->loadFromArray($dict);
	}


	/* -( HarbormasterBuildableInterface )------------------------------------- */


	public function getHarbormasterBuildableDisplayPHID() {
	return $this->getHarbormasterBuildablePHID();
	}

	public function getHarbormasterBuildablePHID() {
	return $this->getPHID();
	}

	public function getHarbormasterContainerPHID() {
	return $this->getRepository()->getPHID();
	}

	public function getBuildVariables() {
	$results = array();

	$results['buildable.commit'] = $this->getCommitIdentifier();
	$repo = $this->getRepository();

	$results['repository.callsign'] = $repo->getCallsign();
	$results['repository.phid'] = $repo->getPHID();
	$results['repository.vcs'] = $repo->getVersionControlSystem();
	$results['repository.uri'] = $repo->getPublicCloneURI();

	return $results;
	}

	public function getAvailableBuildVariables() {
	return array(
	'buildable.commit' => pht('The commit identifier, if applicable.'),
	'repository.callsign' =>
	pht('The callsign of the repository in Phabricator.'),
	'repository.phid' =>
	pht('The PHID of the repository in Phabricator.'),
	'repository.vcs' =>
	pht('The version control system, either "svn", "hg" or "git".'),
	'repository.uri' =>
	pht('The URI to clone or checkout the repository from.'),
	);
	}

	public function newBuildableEngine() {
	return new DiffusionBuildableEngine();
	}


	/* -( HarbormasterCircleCIBuildableInterface )----------------------------- */


	public function getCircleCIGitHubRepositoryURI() {
	$repository = $this->getRepository();

	$commit_phid = $this->getPHID();
	$repository_phid = $repository->getPHID();

	if ($repository->isHosted()) {
	throw new Exception(
	pht(
	'This commit ("%s") is associated with a hosted repository '.
	'("%s"). Repositories must be imported from GitHub to be built '.
	'with CircleCI.',
	$commit_phid,
	$repository_phid));
	}

	$remote_uri = $repository->getRemoteURI();
	$path = HarbormasterCircleCIBuildStepImplementation::getGitHubPath(
	$remote_uri);
	if (!$path) {
	throw new Exception(
	pht(
	'This commit ("%s") is associated with a repository ("%s") that '.
	'with a remote URI ("%s") that does not appear to be hosted on '.
	'GitHub. Repositories must be hosted on GitHub to be built with '.
	'CircleCI.',
	$commit_phid,
	$repository_phid,
	$remote_uri));
	}

	return $remote_uri;
	}

	public function getCircleCIBuildIdentifierType() {
	return 'revision';
	}

	public function getCircleCIBuildIdentifier() {
	return $this->getCommitIdentifier();
	}


	/* -( HarbormasterBuildkiteBuildableInterface )---------------------------- */


	public function getBuildkiteBranch() {
	$viewer = PhabricatorUser::getOmnipotentUser();
	$repository = $this->getRepository();

	$branches = DiffusionQuery::callConduitWithDiffusionRequest(
	$viewer,
	DiffusionRequest::newFromDictionary(
	array(
	'repository' => $repository,
	'user' => $viewer,
	)),
	'diffusion.branchquery',
	array(
	'contains' => $this->getCommitIdentifier(),
	'repository' => $repository->getPHID(),
	));

	if (!$branches) {
	throw new Exception(
	pht(
	'Commit "%s" is not an ancestor of any branch head, so it can not '.
	'be built with Buildkite.',
	$this->getCommitIdentifier()));
	}

	$branch = head($branches);

	return 'refs/heads/'.$branch['shortName'];
	}

	public function getBuildkiteCommit() {
	return $this->getCommitIdentifier();
	}


	/* -( PhabricatorCustomFieldInterface )------------------------------------ */


	public function getCustomFieldSpecificationForRole($role) {
	return PhabricatorEnv::getEnvConfig('diffusion.fields');
	}

	public function getCustomFieldBaseClass() {
	return 'PhabricatorCommitCustomField';
	}

	public function getCustomFields() {
	return $this->assertAttached($this->customFields);
	}

	public function attachCustomFields(PhabricatorCustomFieldAttachment $fields) {
	$this->customFields = $fields;
	return $this;
	}


	/* -( PhabricatorSubscribableInterface )----------------------------------- */


	public function isAutomaticallySubscribed($phid) {

	// TODO: This should also list auditors, but handling that is a bit messy
	// right now because we are not guaranteed to have the data. (It should not
	// include resigned auditors.)

	return ($phid == $this->getAuthorPHID());
	}


	/* -( PhabricatorApplicationTransactionInterface )------------------------- */


	public function getApplicationTransactionEditor() {
	return new PhabricatorAuditEditor();
	}

	public function getApplicationTransactionTemplate() {
	return new PhabricatorAuditTransaction();
	}

	/* -( PhabricatorFulltextInterface )--------------------------------------- */


	public function newFulltextEngine() {
	return new DiffusionCommitFulltextEngine();
	}


	/* -( PhabricatorFerretInterface )----------------------------------------- */


	public function newFerretEngine() {
	return new DiffusionCommitFerretEngine();
	}


	/* -( PhabricatorConduitResultInterface )---------------------------------- */

	public function getFieldSpecificationsForConduit() {
	return array(
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('identifier')
	->setType('string')
	->setDescription(pht('The commit identifier.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('repositoryPHID')
	->setType('phid')
	->setDescription(pht('The repository this commit belongs to.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('author')
	->setType('map<string, wild>')
	->setDescription(pht('Information about the commit author.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('committer')
	->setType('map<string, wild>')
	->setDescription(pht('Information about the committer.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('isImported')
	->setType('bool')
	->setDescription(pht('True if the commit is fully imported.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('isUnreachable')
	->setType('bool')
	->setDescription(
	pht(
	'True if the commit is not the ancestor of any tag, branch, or '.
	'ref.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('auditStatus')
	->setType('map<string, wild>')
	->setDescription(pht('Information about the current audit status.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('message')
	->setType('string')
	->setDescription(pht('The commit message.')),
	);
	}

	public function getFieldValuesForConduit() {
	$data = $this->getCommitData();

	$author_identity = $this->getAuthorIdentity();
	if ($author_identity) {
	$author_name = $author_identity->getIdentityDisplayName();
	$author_email = $author_identity->getIdentityEmailAddress();
	$author_raw = $author_identity->getIdentityName();
	$author_identity_phid = $author_identity->getPHID();
	$author_user_phid = $author_identity->getCurrentEffectiveUserPHID();
	} else {
	$author_name = null;
	$author_email = null;
	$author_raw = null;
	$author_identity_phid = null;
	$author_user_phid = null;
	}

	$committer_identity = $this->getCommitterIdentity();
	if ($committer_identity) {
	$committer_name = $committer_identity->getIdentityDisplayName();
	$committer_email = $committer_identity->getIdentityEmailAddress();
	$committer_raw = $committer_identity->getIdentityName();
	$committer_identity_phid = $committer_identity->getPHID();
	$committer_user_phid = $committer_identity->getCurrentEffectiveUserPHID();
	} else {
	$committer_name = null;
	$committer_email = null;
	$committer_raw = null;
	$committer_identity_phid = null;
	$committer_user_phid = null;
	}

	$author_epoch = $data->getAuthorEpoch();

	$audit_status = $this->getAuditStatusObject();

	return array(
	'identifier' => $this->getCommitIdentifier(),
	'repositoryPHID' => $this->getRepository()->getPHID(),
	'author' => array(
	'name' => $author_name,
	'email' => $author_email,
	'raw' => $author_raw,
	'epoch' => $author_epoch,
	'identityPHID' => $author_identity_phid,
	'userPHID' => $author_user_phid,
	),
	'committer' => array(
	'name' => $committer_name,
	'email' => $committer_email,
	'raw' => $committer_raw,
	'epoch' => (int)$this->getEpoch(),
	'identityPHID' => $committer_identity_phid,
	'userPHID' => $committer_user_phid,
	),
	'isUnreachable' => (bool)$this->isUnreachable(),
	'isImported' => (bool)$this->isImported(),
	'auditStatus' => array(
	'value' => $audit_status->getKey(),
	'name' => $audit_status->getName(),
	'closed' => (bool)$audit_status->getIsClosed(),
	'color.ansi' => $audit_status->getAnsiColor(),
	),
	'message' => $data->getCommitMessage(),
	);
	}

	public function getConduitSearchAttachments() {
	return array();
	}


	/* -( PhabricatorDraftInterface )------------------------------------------ */

	public function newDraftEngine() {
	return new DiffusionCommitDraftEngine();
	}

	public function getHasDraft(PhabricatorUser $viewer) {
	return $this->assertAttachedKey($this->drafts, $viewer->getCacheFragment());
	}

	public function attachHasDraft(PhabricatorUser $viewer, $has_draft) {
	$this->drafts[$viewer->getCacheFragment()] = $has_draft;
	return $this;
	}


	/* -( PhabricatorTimelineInterface )--------------------------------------- */


	public function newTimelineEngine() {
	return new DiffusionCommitTimelineEngine();
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Sun, Nov 24, 3:39 PM (1 d, 15 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1042
Default Alt Text: (124 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions