No OneTemporary
Actions

Size

58 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/repository/engine/PhabricatorRepositoryDiscoveryEngine.php b/src/applications/repository/engine/PhabricatorRepositoryDiscoveryEngine.php
	index ae6f941c14..e8c58ed52f 100644
	--- a/src/applications/repository/engine/PhabricatorRepositoryDiscoveryEngine.php
	+++ b/src/applications/repository/engine/PhabricatorRepositoryDiscoveryEngine.php
	@@ -1,719 +1,734 @@
	<?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 = 2048;


	/* -( 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();

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

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

	$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();

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

	$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 ref "%s", at "%s".', $name, $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;
	}

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

	$head_refs = $this->discoverStreamAncestry(
	new PhabricatorGitGraphStream($repository, $commit),
	$commit,
	$repository->shouldAutocloseRef($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);

	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 = PhabricatorRepositoryURINormalizer::TYPE_SVN;

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

	$expect_normal = id(new PhabricatorRepositoryURINormalizer(
	$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);

	$this->didDiscoverRefs($branch_refs);

	$refs[] = $branch_refs;
	}

	return array_mergev($refs);
	}


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


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

	$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 topographically.
	$commits = $this->reduceGraph($graph);

	$refs = array();
	foreach ($commits as $commit) {
	$refs[] = id(new PhabricatorRepositoryCommitRef())
	->setIdentifier($commit)
	->setEpoch($stream->getCommitDate($commit))
	->setCanCloseImmediately($close_immediately)
	->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->getTopographicallySortedNodes();

	// 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;
	}

	if ($this->repairMode) {
	// In repair mode, rediscover the entire repository, ignoring the
	// database state. We can hit the local cache above, but if we miss it
	// stop the script from going to the database cache.
	return false;
	}

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

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

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

	// 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) > self::MAX_COMMIT_CACHE_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
	* 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();

	$head_refs = array();
	$tail_refs = array();
	foreach ($refs as $ref) {
	if ($repository->shouldAutocloseRef($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,
	array $parents) {

	$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);
	return;
	}

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

	$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->insertTask($repository, $commit);
	-
	- queryfx(
	- $conn_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);
	+ $this->didDiscoverCommit($repository, $commit, $epoch);

	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) {
	+
	+ $this->insertTask($repository, $commit);
	+
	+ // 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,
	$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();

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

	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'];
	}

	}
	diff --git a/src/applications/repository/worker/PhabricatorRepositoryCommitHeraldWorker.php b/src/applications/repository/worker/PhabricatorRepositoryCommitHeraldWorker.php
	index 9ad8ef2b66..4bd9344409 100644
	--- a/src/applications/repository/worker/PhabricatorRepositoryCommitHeraldWorker.php
	+++ b/src/applications/repository/worker/PhabricatorRepositoryCommitHeraldWorker.php
	@@ -1,134 +1,144 @@
	<?php

	final class PhabricatorRepositoryCommitHeraldWorker
	extends PhabricatorRepositoryCommitParserWorker {

	+ protected function getImportStepFlag() {
	+ return PhabricatorRepositoryCommit::IMPORTED_HERALD;
	+ }
	+
	public function getRequiredLeaseTime() {
	// Herald rules may take a long time to process.
	return phutil_units('4 hours in seconds');
	}

	protected function parseCommit(
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit) {

	+ if ($this->shouldSkipImportStep()) {
	+ // This worker has no followup tasks, so we can just bail out
	+ // right away without queueing anything.
	+ return;
	+ }
	+
	// Reload the commit to pull commit data and audit requests.
	$commit = id(new DiffusionCommitQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withIDs(array($commit->getID()))
	->needCommitData(true)
	->needAuditRequests(true)
	->executeOne();
	$data = $commit->getCommitData();

	if (!$data) {
	throw new PhabricatorWorkerPermanentFailureException(
	pht(
	'Unable to load commit data. The data for this task is invalid '.
	'or no longer exists.'));
	}

	$commit->attachRepository($repository);

	$content_source = $this->newContentSource();

	$committer_phid = $data->getCommitDetail('committerPHID');
	$author_phid = $data->getCommitDetail('authorPHID');
	$acting_as_phid = nonempty(
	$committer_phid,
	$author_phid,
	id(new PhabricatorDiffusionApplication())->getPHID());

	$editor = id(new PhabricatorAuditEditor())
	->setActor(PhabricatorUser::getOmnipotentUser())
	->setActingAsPHID($acting_as_phid)
	->setContinueOnMissingFields(true)
	->setContinueOnNoEffect(true)
	->setContentSource($content_source);

	$xactions = array();
	$xactions[] = id(new PhabricatorAuditTransaction())
	->setTransactionType(PhabricatorAuditTransaction::TYPE_COMMIT)
	->setDateCreated($commit->getEpoch())
	->setNewValue(array(
	'description' => $data->getCommitMessage(),
	'summary' => $data->getSummary(),
	'authorName' => $data->getAuthorName(),
	'authorPHID' => $commit->getAuthorPHID(),
	'committerName' => $data->getCommitDetail('committer'),
	'committerPHID' => $data->getCommitDetail('committerPHID'),
	));

	$reverts_refs = id(new DifferentialCustomFieldRevertsParser())
	->parseCorpus($data->getCommitMessage());
	$reverts = array_mergev(ipull($reverts_refs, 'monograms'));

	if ($reverts) {
	$reverted_commits = id(new DiffusionCommitQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withRepository($repository)
	->withIdentifiers($reverts)
	->execute();
	$reverted_commit_phids = mpull($reverted_commits, 'getPHID', 'getPHID');

	// NOTE: Skip any write attempts if a user cleverly implies a commit
	// reverts itself.
	unset($reverted_commit_phids[$commit->getPHID()]);

	$reverts_edge = DiffusionCommitRevertsCommitEdgeType::EDGECONST;
	$xactions[] = id(new PhabricatorAuditTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
	->setMetadataValue('edge:type', $reverts_edge)
	->setNewValue(array('+' => array_fuse($reverted_commit_phids)));
	}

	try {
	$raw_patch = $this->loadRawPatchText($repository, $commit);
	} catch (Exception $ex) {
	$raw_patch = pht('Unable to generate patch: %s', $ex->getMessage());
	}
	$editor->setRawPatch($raw_patch);

	return $editor->applyTransactions($commit, $xactions);
	}

	private function loadRawPatchText(
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit) {

	$drequest = DiffusionRequest::newFromDictionary(
	array(
	'user' => PhabricatorUser::getOmnipotentUser(),
	'repository' => $repository,
	'commit' => $commit->getCommitIdentifier(),
	));

	$raw_query = DiffusionRawDiffQuery::newFromDiffusionRequest($drequest);
	$raw_query->setLinesOfContext(3);

	$time_key = 'metamta.diffusion.time-limit';
	$byte_key = 'metamta.diffusion.byte-limit';
	$time_limit = PhabricatorEnv::getEnvConfig($time_key);
	$byte_limit = PhabricatorEnv::getEnvConfig($byte_key);

	if ($time_limit) {
	$raw_query->setTimeout($time_limit);
	}

	$raw_diff = $raw_query->loadRawDiff();

	$size = strlen($raw_diff);
	if ($byte_limit && $size > $byte_limit) {
	$pretty_size = phutil_format_bytes($size);
	$pretty_limit = phutil_format_bytes($byte_limit);
	throw new Exception(pht(
	'Patch size of %s exceeds configured byte size limit (%s) of %s.',
	$pretty_size,
	$byte_key,
	$pretty_limit));
	}

	return $raw_diff;
	}

	}
	diff --git a/src/applications/repository/worker/PhabricatorRepositoryCommitOwnersWorker.php b/src/applications/repository/worker/PhabricatorRepositoryCommitOwnersWorker.php
	index 3f41226b9f..8f94df90be 100644
	--- a/src/applications/repository/worker/PhabricatorRepositoryCommitOwnersWorker.php
	+++ b/src/applications/repository/worker/PhabricatorRepositoryCommitOwnersWorker.php
	@@ -1,168 +1,172 @@
	<?php

	final class PhabricatorRepositoryCommitOwnersWorker
	extends PhabricatorRepositoryCommitParserWorker {

	+ protected function getImportStepFlag() {
	+ return PhabricatorRepositoryCommit::IMPORTED_OWNERS;
	+ }
	+
	protected function parseCommit(
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit) {

	- $this->triggerOwnerAudits($repository, $commit);
	-
	- $commit->writeImportStatusFlag(
	- PhabricatorRepositoryCommit::IMPORTED_OWNERS);
	+ if (!$this->shouldSkipImportStep()) {
	+ $this->triggerOwnerAudits($repository, $commit);
	+ $commit->writeImportStatusFlag($this->getImportStepFlag());
	+ }

	if ($this->shouldQueueFollowupTasks()) {
	$this->queueTask(
	'PhabricatorRepositoryCommitHeraldWorker',
	array(
	'commitID' => $commit->getID(),
	));
	}
	}

	private function triggerOwnerAudits(
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit) {

	if (!$repository->shouldPublish()) {
	return;
	}

	$affected_paths = PhabricatorOwnerPathQuery::loadAffectedPaths(
	$repository,
	$commit,
	PhabricatorUser::getOmnipotentUser());

	$affected_packages = PhabricatorOwnersPackage::loadAffectedPackages(
	$repository,
	$affected_paths);

	if (!$affected_packages) {
	return;
	}

	$data = id(new PhabricatorRepositoryCommitData())->loadOneWhere(
	'commitID = %d',
	$commit->getID());
	$commit->attachCommitData($data);

	$author_phid = $data->getCommitDetail('authorPHID');
	$revision_id = $data->getCommitDetail('differential.revisionID');
	if ($revision_id) {
	$revision = id(new DifferentialRevisionQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withIDs(array($revision_id))
	->needReviewerStatus(true)
	->executeOne();
	} else {
	$revision = null;
	}

	$requests = id(new PhabricatorRepositoryAuditRequest())
	->loadAllWhere(
	'commitPHID = %s',
	$commit->getPHID());
	$requests = mpull($requests, null, 'getAuditorPHID');


	foreach ($affected_packages as $package) {
	$request = idx($requests, $package->getPHID());
	if ($request) {
	// Don't update request if it exists already.
	continue;
	}

	if ($package->isArchived()) {
	// Don't trigger audits if the package is archived.
	continue;
	}

	if ($package->getAuditingEnabled()) {
	$reasons = $this->checkAuditReasons(
	$commit,
	$package,
	$author_phid,
	$revision);

	if ($reasons) {
	$audit_status = PhabricatorAuditStatusConstants::AUDIT_REQUIRED;
	} else {
	$audit_status = PhabricatorAuditStatusConstants::AUDIT_NOT_REQUIRED;
	}
	} else {
	$reasons = array();
	$audit_status = PhabricatorAuditStatusConstants::NONE;
	}

	$relationship = new PhabricatorRepositoryAuditRequest();
	$relationship->setAuditorPHID($package->getPHID());
	$relationship->setCommitPHID($commit->getPHID());
	$relationship->setAuditReasons($reasons);
	$relationship->setAuditStatus($audit_status);

	$relationship->save();

	$requests[$package->getPHID()] = $relationship;
	}

	$commit->updateAuditStatus($requests);
	$commit->save();
	}

	private function checkAuditReasons(
	PhabricatorRepositoryCommit $commit,
	PhabricatorOwnersPackage $package,
	$author_phid,
	$revision) {

	$owner_phids = PhabricatorOwnersOwner::loadAffiliatedUserPHIDs(
	array(
	$package->getID(),
	));
	$owner_phids = array_fuse($owner_phids);

	$reasons = array();

	if (!$author_phid) {
	$reasons[] = pht('Commit Author Not Recognized');
	} else if (isset($owner_phids[$author_phid])) {
	return $reasons;
	}

	if (!$revision) {
	$reasons[] = pht('No Revision Specified');
	return $reasons;
	}

	$accepted_statuses = array(
	DifferentialReviewerStatus::STATUS_ACCEPTED,
	DifferentialReviewerStatus::STATUS_ACCEPTED_OLDER,
	);
	$accepted_statuses = array_fuse($accepted_statuses);

	$found_accept = false;
	foreach ($revision->getReviewerStatus() as $reviewer) {
	$reviewer_phid = $reviewer->getReviewerPHID();

	// If this reviewer isn't a package owner, just ignore them.
	if (empty($owner_phids[$reviewer_phid])) {
	continue;
	}

	// If this reviewer accepted the revision and owns the package, we're
	// all clear and do not need to trigger an audit.
	if (isset($accepted_statuses[$reviewer->getStatus()])) {
	$found_accept = true;
	break;
	}
	}

	if (!$found_accept) {
	$reasons[] = pht('Owners Not Involved');
	}

	return $reasons;
	}

	}
	diff --git a/src/applications/repository/worker/PhabricatorRepositoryCommitParserWorker.php b/src/applications/repository/worker/PhabricatorRepositoryCommitParserWorker.php
	index aa2aaa270b..f6e2661b87 100644
	--- a/src/applications/repository/worker/PhabricatorRepositoryCommitParserWorker.php
	+++ b/src/applications/repository/worker/PhabricatorRepositoryCommitParserWorker.php
	@@ -1,80 +1,124 @@
	<?php

	abstract class PhabricatorRepositoryCommitParserWorker
	extends PhabricatorWorker {

	protected $commit;
	protected $repository;

	private function loadCommit() {
	if ($this->commit) {
	return $this->commit;
	}

	$commit_id = idx($this->getTaskData(), 'commitID');
	if (!$commit_id) {
	throw new PhabricatorWorkerPermanentFailureException(
	pht('No "%s" in task data.', 'commitID'));
	}

	$commit = id(new DiffusionCommitQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withIDs(array($commit_id))
	->executeOne();
	if (!$commit) {
	throw new PhabricatorWorkerPermanentFailureException(
	pht('Commit "%s" does not exist.', $commit_id));
	}

	+ if ($commit->isUnreachable()) {
	+ throw new PhabricatorWorkerPermanentFailureException(
	+ pht(
	+ 'Commit "%s" has been deleted: it is no longer reachable from '.
	+ 'any ref.',
	+ $commit_id));
	+ }
	+
	$this->commit = $commit;

	return $commit;
	}

	final protected function doWork() {
	$commit = $this->loadCommit();
	$repository = $commit->getRepository();

	$this->repository = $repository;

	$this->parseCommit($repository, $this->commit);
	}

	final protected function shouldQueueFollowupTasks() {
	return !idx($this->getTaskData(), 'only');
	}

	+ protected function getImportStepFlag() {
	+ return null;
	+ }
	+
	+ final protected function shouldSkipImportStep() {
	+ // If this step has already been performed and this is a "natural" task
	+ // which was queued by the normal daemons, decline to do the work again.
	+ // This mitigates races if commits are rapidly deleted and revived.
	+ $flag = $this->getImportStepFlag();
	+ if (!$flag) {
	+ // This step doesn't have an associated flag.
	+ return false;
	+ }
	+
	+ $commit = $this->commit;
	+ if (!$commit->isPartiallyImported($flag)) {
	+ // This commit doesn't have the flag set yet.
	+ return false;
	+ }
	+
	+
	+ if (!$this->shouldQueueFollowupTasks()) {
	+ // This task was queued by administrative tools, so do the work even
	+ // if it duplicates existing work.
	+ return false;
	+ }
	+
	+ $this->log(
	+ "%s\n",
	+ pht(
	+ 'Skipping import step; this step was previously completed for '.
	+ 'this commit.'));
	+
	+ return true;
	+ }
	+
	abstract protected function parseCommit(
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit);

	protected function isBadCommit(PhabricatorRepositoryCommit $commit) {
	$repository = new PhabricatorRepository();

	$bad_commit = queryfx_one(
	$repository->establishConnection('w'),
	'SELECT * FROM %T WHERE fullCommitName = %s',
	PhabricatorRepository::TABLE_BADCOMMIT,
	$commit->getMonogram());

	return (bool)$bad_commit;
	}

	public function renderForDisplay(PhabricatorUser $viewer) {
	$suffix = parent::renderForDisplay($viewer);

	$commit = id(new DiffusionCommitQuery())
	->setViewer($viewer)
	->withIDs(array(idx($this->getTaskData(), 'commitID')))
	->executeOne();
	if (!$commit) {
	return $suffix;
	}

	$link = DiffusionView::linkCommit(
	$commit->getRepository(),
	$commit->getCommitIdentifier());

	return array($link, $suffix);
	}
	}
	diff --git a/src/applications/repository/worker/commitchangeparser/PhabricatorRepositoryCommitChangeParserWorker.php b/src/applications/repository/worker/commitchangeparser/PhabricatorRepositoryCommitChangeParserWorker.php
	index 6a0161fd06..f58856d614 100644
	--- a/src/applications/repository/worker/commitchangeparser/PhabricatorRepositoryCommitChangeParserWorker.php
	+++ b/src/applications/repository/worker/commitchangeparser/PhabricatorRepositoryCommitChangeParserWorker.php
	@@ -1,151 +1,155 @@
	<?php

	abstract class PhabricatorRepositoryCommitChangeParserWorker
	extends PhabricatorRepositoryCommitParserWorker {

	+ protected function getImportStepFlag() {
	+ return PhabricatorRepositoryCommit::IMPORTED_CHANGE;
	+ }
	+
	public function getRequiredLeaseTime() {
	// It can take a very long time to parse commits; some commits in the
	// Facebook repository affect many millions of paths. Acquire 24h leases.
	return phutil_units('24 hours in seconds');
	}

	abstract protected function parseCommitChanges(
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit);

	protected function parseCommit(
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit) {

	$this->log("%s\n", pht('Parsing "%s"...', $commit->getMonogram()));
	if ($this->isBadCommit($commit)) {
	$this->log(pht('This commit is marked bad!'));
	return;
	}

	- $results = $this->parseCommitChanges($repository, $commit);
	- if ($results) {
	- $this->writeCommitChanges($repository, $commit, $results);
	+ if (!$this->shouldSkipImportStep()) {
	+ $results = $this->parseCommitChanges($repository, $commit);
	+ if ($results) {
	+ $this->writeCommitChanges($repository, $commit, $results);
	+ }
	+
	+ $commit->writeImportStatusFlag($this->getImportStepFlag());
	+
	+ PhabricatorSearchWorker::queueDocumentForIndexing($commit->getPHID());
	}

	$this->finishParse();
	}

	public function parseChangesForUnitTest(
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit) {
	return $this->parseCommitChanges($repository, $commit);
	}

	public static function lookupOrCreatePaths(array $paths) {
	$repository = new PhabricatorRepository();
	$conn_w = $repository->establishConnection('w');

	$result_map = self::lookupPaths($paths);

	$missing_paths = array_fill_keys($paths, true);
	$missing_paths = array_diff_key($missing_paths, $result_map);
	$missing_paths = array_keys($missing_paths);

	if ($missing_paths) {
	foreach (array_chunk($missing_paths, 128) as $path_chunk) {
	$sql = array();
	foreach ($path_chunk as $path) {
	$sql[] = qsprintf($conn_w, '(%s, %s)', $path, md5($path));
	}
	queryfx(
	$conn_w,
	'INSERT IGNORE INTO %T (path, pathHash) VALUES %Q',
	PhabricatorRepository::TABLE_PATH,
	implode(', ', $sql));
	}
	$result_map += self::lookupPaths($missing_paths);
	}

	return $result_map;
	}

	private static function lookupPaths(array $paths) {
	$repository = new PhabricatorRepository();
	$conn_w = $repository->establishConnection('w');

	$result_map = array();
	foreach (array_chunk($paths, 128) as $path_chunk) {
	$chunk_map = queryfx_all(
	$conn_w,
	'SELECT path, id FROM %T WHERE pathHash IN (%Ls)',
	PhabricatorRepository::TABLE_PATH,
	array_map('md5', $path_chunk));
	foreach ($chunk_map as $row) {
	$result_map[$row['path']] = $row['id'];
	}
	}
	return $result_map;
	}

	protected function finishParse() {
	$commit = $this->commit;
	-
	- $commit->writeImportStatusFlag(
	- PhabricatorRepositoryCommit::IMPORTED_CHANGE);
	-
	- PhabricatorSearchWorker::queueDocumentForIndexing($commit->getPHID());
	-
	if ($this->shouldQueueFollowupTasks()) {
	$this->queueTask(
	'PhabricatorRepositoryCommitOwnersWorker',
	array(
	'commitID' => $commit->getID(),
	));
	}
	}

	private function writeCommitChanges(
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit,
	array $changes) {

	$repository_id = (int)$repository->getID();
	$commit_id = (int)$commit->getID();

	// NOTE: This SQL is being built manually instead of with qsprintf()
	// because some SVN changes affect an enormous number of paths (millions)
	// and this showed up as significantly slow on a profile at some point.

	$changes_sql = array();
	foreach ($changes as $change) {
	$values = array(
	$repository_id,
	(int)$change->getPathID(),
	$commit_id,
	nonempty((int)$change->getTargetPathID(), 'null'),
	nonempty((int)$change->getTargetCommitID(), 'null'),
	(int)$change->getChangeType(),
	(int)$change->getFileType(),
	(int)$change->getIsDirect(),
	(int)$change->getCommitSequence(),
	);
	$changes_sql[] = '('.implode(', ', $values).')';
	}

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

	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE commitID = %d',
	PhabricatorRepository::TABLE_PATHCHANGE,
	$commit_id);

	foreach (PhabricatorLiskDAO::chunkSQL($changes_sql) as $chunk) {
	queryfx(
	$conn_w,
	'INSERT INTO %T
	(repositoryID, pathID, commitID, targetPathID, targetCommitID,
	changeType, fileType, isDirect, commitSequence)
	VALUES %Q',
	PhabricatorRepository::TABLE_PATHCHANGE,
	$chunk);
	}
	}

	}
	diff --git a/src/applications/repository/worker/commitmessageparser/PhabricatorRepositoryCommitMessageParserWorker.php b/src/applications/repository/worker/commitmessageparser/PhabricatorRepositoryCommitMessageParserWorker.php
	index 4e92a0f32e..e28cd78cc7 100644
	--- a/src/applications/repository/worker/commitmessageparser/PhabricatorRepositoryCommitMessageParserWorker.php
	+++ b/src/applications/repository/worker/commitmessageparser/PhabricatorRepositoryCommitMessageParserWorker.php
	@@ -1,354 +1,364 @@
	<?php

	abstract class PhabricatorRepositoryCommitMessageParserWorker
	extends PhabricatorRepositoryCommitParserWorker {

	- abstract protected function parseCommitWithRef(
	- PhabricatorRepository $repository,
	- PhabricatorRepositoryCommit $commit,
	- DiffusionCommitRef $ref);
	+ protected function getImportStepFlag() {
	+ return PhabricatorRepositoryCommit::IMPORTED_MESSAGE;
	+ }
	+
	+ abstract protected function getFollowupTaskClass();

	final protected function parseCommit(
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit) {

	- $viewer = PhabricatorUser::getOmnipotentUser();
	+ if (!$this->shouldSkipImportStep()) {
	+ $viewer = PhabricatorUser::getOmnipotentUser();

	- $refs_raw = DiffusionQuery::callConduitWithDiffusionRequest(
	- $viewer,
	- DiffusionRequest::newFromDictionary(
	+ $refs_raw = DiffusionQuery::callConduitWithDiffusionRequest(
	+ $viewer,
	+ DiffusionRequest::newFromDictionary(
	+ array(
	+ 'repository' => $repository,
	+ 'user' => $viewer,
	+ )),
	+ 'diffusion.querycommits',
	array(
	- 'repository' => $repository,
	- 'user' => $viewer,
	- )),
	- 'diffusion.querycommits',
	- array(
	- 'repositoryPHID' => $repository->getPHID(),
	- 'phids' => array($commit->getPHID()),
	- 'bypassCache' => true,
	- 'needMessages' => true,
	- ));
	-
	- if (empty($refs_raw['data'])) {
	- throw new Exception(
	- pht(
	- 'Unable to retrieve details for commit "%s"!',
	- $commit->getPHID()));
	- }
	+ 'repositoryPHID' => $repository->getPHID(),
	+ 'phids' => array($commit->getPHID()),
	+ 'bypassCache' => true,
	+ 'needMessages' => true,
	+ ));
	+
	+ if (empty($refs_raw['data'])) {
	+ throw new Exception(
	+ pht(
	+ 'Unable to retrieve details for commit "%s"!',
	+ $commit->getPHID()));
	+ }

	- $ref = DiffusionCommitRef::newFromConduitResult(head($refs_raw['data']));
	+ $ref = DiffusionCommitRef::newFromConduitResult(head($refs_raw['data']));
	+ $this->updateCommitData($ref);
	+ }

	- $this->parseCommitWithRef($repository, $commit, $ref);
	+ if ($this->shouldQueueFollowupTasks()) {
	+ $this->queueTask(
	+ $this->getFollowupTaskClass(),
	+ array(
	+ 'commitID' => $commit->getID(),
	+ ));
	+ }
	}

	final protected function updateCommitData(DiffusionCommitRef $ref) {
	$commit = $this->commit;
	$author = $ref->getAuthor();
	$message = $ref->getMessage();
	$committer = $ref->getCommitter();
	$hashes = $ref->getHashes();

	$data = id(new PhabricatorRepositoryCommitData())->loadOneWhere(
	'commitID = %d',
	$commit->getID());
	if (!$data) {
	$data = new PhabricatorRepositoryCommitData();
	}
	$data->setCommitID($commit->getID());
	$data->setAuthorName(id(new PhutilUTF8StringTruncator())
	->setMaximumBytes(255)
	->truncateString((string)$author));

	$data->setCommitDetail('authorEpoch', $ref->getAuthorEpoch());
	$data->setCommitDetail('authorName', $ref->getAuthorName());
	$data->setCommitDetail('authorEmail', $ref->getAuthorEmail());

	$data->setCommitDetail(
	'authorPHID',
	$this->resolveUserPHID($commit, $author));

	$data->setCommitMessage($message);

	if (strlen($committer)) {
	$data->setCommitDetail('committer', $committer);

	$data->setCommitDetail('committerName', $ref->getCommitterName());
	$data->setCommitDetail('committerEmail', $ref->getCommitterEmail());

	$data->setCommitDetail(
	'committerPHID',
	$this->resolveUserPHID($commit, $committer));
	}

	$repository = $this->repository;

	$author_phid = $data->getCommitDetail('authorPHID');
	$committer_phid = $data->getCommitDetail('committerPHID');

	$user = new PhabricatorUser();
	if ($author_phid) {
	$user = $user->loadOneWhere(
	'phid = %s',
	$author_phid);
	}

	$differential_app = 'PhabricatorDifferentialApplication';
	$revision_id = null;
	$low_level_query = null;
	if (PhabricatorApplication::isClassInstalled($differential_app)) {
	$low_level_query = id(new DiffusionLowLevelCommitFieldsQuery())
	->setRepository($repository)
	->withCommitRef($ref);
	$field_values = $low_level_query->execute();
	$revision_id = idx($field_values, 'revisionID');

	if (!empty($field_values['reviewedByPHIDs'])) {
	$data->setCommitDetail(
	'reviewerPHID',
	reset($field_values['reviewedByPHIDs']));
	}

	$data->setCommitDetail('differential.revisionID', $revision_id);
	}

	if ($author_phid != $commit->getAuthorPHID()) {
	$commit->setAuthorPHID($author_phid);
	}

	$commit->setSummary($data->getSummary());
	$commit->save();

	// Figure out if we're going to try to "autoclose" related objects (e.g.,
	// close linked tasks and related revisions) and, if not, record why we
	// aren't. Autoclose can be disabled for various reasons at the repository
	// or commit levels.

	$force_autoclose = idx($this->getTaskData(), 'forceAutoclose', false);
	if ($force_autoclose) {
	$autoclose_reason = PhabricatorRepository::BECAUSE_AUTOCLOSE_FORCED;
	} else {
	$autoclose_reason = $repository->shouldSkipAutocloseCommit($commit);
	}
	$data->setCommitDetail('autocloseReason', $autoclose_reason);
	$should_autoclose = $force_autoclose \|\|
	$repository->shouldAutocloseCommit($commit);


	// When updating related objects, we'll act under an omnipotent user to
	// ensure we can see them, but take actions as either the committer or
	// author (if we recognize their accounts) or the Diffusion application
	// (if we do not).

	$actor = PhabricatorUser::getOmnipotentUser();
	$acting_as_phid = nonempty(
	$committer_phid,
	$author_phid,
	id(new PhabricatorDiffusionApplication())->getPHID());

	$conn_w = id(new DifferentialRevision())->establishConnection('w');

	// NOTE: The `differential_commit` table has a unique ID on `commitPHID`,
	// preventing more than one revision from being associated with a commit.
	// Generally this is good and desirable, but with the advent of hash
	// tracking we may end up in a situation where we match several different
	// revisions. We just kind of ignore this and pick one, we might want to
	// revisit this and do something differently. (If we match several revisions
	// someone probably did something very silly, though.)

	$revision = null;
	if ($revision_id) {
	$revision_query = id(new DifferentialRevisionQuery())
	->withIDs(array($revision_id))
	->setViewer($actor)
	->needReviewerStatus(true)
	->needActiveDiffs(true);

	$revision = $revision_query->executeOne();

	if ($revision) {
	if (!$data->getCommitDetail('precommitRevisionStatus')) {
	$data->setCommitDetail(
	'precommitRevisionStatus',
	$revision->getStatus());
	}
	$commit_drev = DiffusionCommitHasRevisionEdgeType::EDGECONST;
	id(new PhabricatorEdgeEditor())
	->addEdge($commit->getPHID(), $commit_drev, $revision->getPHID())
	->save();

	queryfx(
	$conn_w,
	'INSERT IGNORE INTO %T (revisionID, commitPHID) VALUES (%d, %s)',
	DifferentialRevision::TABLE_COMMIT,
	$revision->getID(),
	$commit->getPHID());

	$status_closed = ArcanistDifferentialRevisionStatus::CLOSED;
	$should_close = ($revision->getStatus() != $status_closed) &&
	$should_autoclose;

	if ($should_close) {
	$commit_close_xaction = id(new DifferentialTransaction())
	->setTransactionType(DifferentialTransaction::TYPE_ACTION)
	->setNewValue(DifferentialAction::ACTION_CLOSE)
	->setMetadataValue('isCommitClose', true);

	$commit_close_xaction->setMetadataValue(
	'commitPHID',
	$commit->getPHID());
	$commit_close_xaction->setMetadataValue(
	'committerPHID',
	$committer_phid);
	$commit_close_xaction->setMetadataValue(
	'committerName',
	$data->getCommitDetail('committer'));
	$commit_close_xaction->setMetadataValue(
	'authorPHID',
	$author_phid);
	$commit_close_xaction->setMetadataValue(
	'authorName',
	$data->getAuthorName());

	if ($low_level_query) {
	$commit_close_xaction->setMetadataValue(
	'revisionMatchData',
	$low_level_query->getRevisionMatchData());
	$data->setCommitDetail(
	'revisionMatchData',
	$low_level_query->getRevisionMatchData());
	}

	$extraction_engine = id(new DifferentialDiffExtractionEngine())
	->setViewer($actor)
	->setAuthorPHID($acting_as_phid);

	$content_source = $this->newContentSource();

	$update_data = $extraction_engine->updateRevisionWithCommit(
	$revision,
	$commit,
	array(
	$commit_close_xaction,
	),
	$content_source);

	foreach ($update_data as $key => $value) {
	$data->setCommitDetail($key, $value);
	}
	}
	}
	}

	if ($should_autoclose) {
	$this->closeTasks(
	$actor,
	$acting_as_phid,
	$repository,
	$commit,
	$message);
	}

	$data->save();

	$commit->writeImportStatusFlag(
	PhabricatorRepositoryCommit::IMPORTED_MESSAGE);
	}

	private function resolveUserPHID(
	PhabricatorRepositoryCommit $commit,
	$user_name) {

	return id(new DiffusionResolveUserQuery())
	->withCommit($commit)
	->withName($user_name)
	->execute();
	}

	private function closeTasks(
	PhabricatorUser $actor,
	$acting_as,
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit,
	$message) {

	$maniphest = 'PhabricatorManiphestApplication';
	if (!PhabricatorApplication::isClassInstalled($maniphest)) {
	return;
	}

	$prefixes = ManiphestTaskStatus::getStatusPrefixMap();
	$suffixes = ManiphestTaskStatus::getStatusSuffixMap();

	$matches = id(new ManiphestCustomFieldStatusParser())
	->parseCorpus($message);

	$task_statuses = array();
	foreach ($matches as $match) {
	$prefix = phutil_utf8_strtolower($match['prefix']);
	$suffix = phutil_utf8_strtolower($match['suffix']);

	$status = idx($suffixes, $suffix);
	if (!$status) {
	$status = idx($prefixes, $prefix);
	}

	foreach ($match['monograms'] as $task_monogram) {
	$task_id = (int)trim($task_monogram, 'tT');
	$task_statuses[$task_id] = $status;
	}
	}

	if (!$task_statuses) {
	return;
	}

	$tasks = id(new ManiphestTaskQuery())
	->setViewer($actor)
	->withIDs(array_keys($task_statuses))
	->needProjectPHIDs(true)
	->execute();

	foreach ($tasks as $task_id => $task) {
	$xactions = array();

	$edge_type = ManiphestTaskHasCommitEdgeType::EDGECONST;
	$edge_xaction = id(new ManiphestTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
	->setMetadataValue('edge:type', $edge_type)
	->setNewValue(
	array(
	'+' => array(
	$commit->getPHID() => $commit->getPHID(),
	),
	));

	$status = $task_statuses[$task_id];
	if ($status) {
	if ($task->getStatus() != $status) {
	$xactions[] = id(new ManiphestTransaction())
	->setTransactionType(ManiphestTransaction::TYPE_STATUS)
	->setMetadataValue('commitPHID', $commit->getPHID())
	->setNewValue($status);

	$edge_xaction->setMetadataValue('commitPHID', $commit->getPHID());
	}
	}

	$xactions[] = $edge_xaction;

	$content_source = $this->newContentSource();

	$editor = id(new ManiphestTransactionEditor())
	->setActor($actor)
	->setActingAsPHID($acting_as)
	->setContinueOnNoEffect(true)
	->setContinueOnMissingFields(true)
	->setUnmentionablePHIDMap(
	array($commit->getPHID() => $commit->getPHID()))
	->setContentSource($content_source);

	$editor->applyTransactions($task, $xactions);
	}
	}

	}
	diff --git a/src/applications/repository/worker/commitmessageparser/PhabricatorRepositoryGitCommitMessageParserWorker.php b/src/applications/repository/worker/commitmessageparser/PhabricatorRepositoryGitCommitMessageParserWorker.php
	index b41f4c421c..0c83a27fab 100644
	--- a/src/applications/repository/worker/commitmessageparser/PhabricatorRepositoryGitCommitMessageParserWorker.php
	+++ b/src/applications/repository/worker/commitmessageparser/PhabricatorRepositoryGitCommitMessageParserWorker.php
	@@ -1,22 +1,10 @@
	<?php

	final class PhabricatorRepositoryGitCommitMessageParserWorker
	extends PhabricatorRepositoryCommitMessageParserWorker {

	- protected function parseCommitWithRef(
	- PhabricatorRepository $repository,
	- PhabricatorRepositoryCommit $commit,
	- DiffusionCommitRef $ref) {
	-
	- $this->updateCommitData($ref);
	-
	- if ($this->shouldQueueFollowupTasks()) {
	- $this->queueTask(
	- 'PhabricatorRepositoryGitCommitChangeParserWorker',
	- array(
	- 'commitID' => $commit->getID(),
	- ));
	- }
	+ protected function getFollowupTaskClass() {
	+ return 'PhabricatorRepositoryGitCommitChangeParserWorker';
	}

	}
	diff --git a/src/applications/repository/worker/commitmessageparser/PhabricatorRepositoryMercurialCommitMessageParserWorker.php b/src/applications/repository/worker/commitmessageparser/PhabricatorRepositoryMercurialCommitMessageParserWorker.php
	index 72d187d896..654083e736 100644
	--- a/src/applications/repository/worker/commitmessageparser/PhabricatorRepositoryMercurialCommitMessageParserWorker.php
	+++ b/src/applications/repository/worker/commitmessageparser/PhabricatorRepositoryMercurialCommitMessageParserWorker.php
	@@ -1,22 +1,10 @@
	<?php

	final class PhabricatorRepositoryMercurialCommitMessageParserWorker
	extends PhabricatorRepositoryCommitMessageParserWorker {

	- protected function parseCommitWithRef(
	- PhabricatorRepository $repository,
	- PhabricatorRepositoryCommit $commit,
	- DiffusionCommitRef $ref) {
	-
	- $this->updateCommitData($ref);
	-
	- if ($this->shouldQueueFollowupTasks()) {
	- $this->queueTask(
	- 'PhabricatorRepositoryMercurialCommitChangeParserWorker',
	- array(
	- 'commitID' => $commit->getID(),
	- ));
	- }
	+ protected function getFollowupTaskClass() {
	+ return 'PhabricatorRepositoryMercurialCommitChangeParserWorker';
	}

	}
	diff --git a/src/applications/repository/worker/commitmessageparser/PhabricatorRepositorySvnCommitMessageParserWorker.php b/src/applications/repository/worker/commitmessageparser/PhabricatorRepositorySvnCommitMessageParserWorker.php
	index 648c8adaaf..7006957b50 100644
	--- a/src/applications/repository/worker/commitmessageparser/PhabricatorRepositorySvnCommitMessageParserWorker.php
	+++ b/src/applications/repository/worker/commitmessageparser/PhabricatorRepositorySvnCommitMessageParserWorker.php
	@@ -1,22 +1,10 @@
	<?php

	final class PhabricatorRepositorySvnCommitMessageParserWorker
	extends PhabricatorRepositoryCommitMessageParserWorker {

	- protected function parseCommitWithRef(
	- PhabricatorRepository $repository,
	- PhabricatorRepositoryCommit $commit,
	- DiffusionCommitRef $ref) {
	-
	- $this->updateCommitData($ref);
	-
	- if ($this->shouldQueueFollowupTasks()) {
	- $this->queueTask(
	- 'PhabricatorRepositorySvnCommitChangeParserWorker',
	- array(
	- 'commitID' => $commit->getID(),
	- ));
	- }
	+ protected function getFollowupTaskClass() {
	+ return 'PhabricatorRepositorySvnCommitChangeParserWorker';
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Fri, Mar 14, 4:12 PM (1 d, 14 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 72024
Default Alt Text: (58 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions