No OneTemporary
Actions

Size

23 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/conduit/call/ConduitCall.php b/src/applications/conduit/call/ConduitCall.php
	index f4cac28956..b9e5a1491a 100644
	--- a/src/applications/conduit/call/ConduitCall.php
	+++ b/src/applications/conduit/call/ConduitCall.php
	@@ -1,186 +1,187 @@
	<?php

	/**
	* Run a conduit method in-process, without requiring HTTP requests. Usage:
	*
	* $call = new ConduitCall('method.name', array('param' => 'value'));
	* $call->setUser($user);
	* $result = $call->execute();
	*
	*/
	final class ConduitCall {

	private $method;
	private $request;
	private $user;
	private $servers;
	private $forceLocal;

	public function __construct($method, array $params) {
	$this->method = $method;
	$this->handler = $this->buildMethodHandler($method);
	$this->servers = PhabricatorEnv::getEnvConfig('conduit.servers');
	$this->forceLocal = false;

	$invalid_params = array_diff_key(
	$params,
	$this->handler->defineParamTypes());
	if ($invalid_params) {
	throw new ConduitException(
	"Method '{$method}' doesn't define these parameters: '" .
	implode("', '", array_keys($invalid_params)) . "'.");
	}

	if ($this->servers) {
	$current_host = AphrontRequest::getHTTPHeader('HOST');
	foreach ($this->servers as $server) {
	if ($current_host === id(new PhutilURI($server))->getDomain()) {
	$this->forceLocal = true;
	break;
	}
	}
	}

	$this->request = new ConduitAPIRequest($params);
	}

	public function setUser(PhabricatorUser $user) {
	$this->user = $user;
	return $this;
	}

	public function getUser() {
	return $this->user;
	}

	public function setForceLocal($force_local) {
	$this->forceLocal = $force_local;
	return $this;
	}

	public function shouldForceLocal() {
	return $this->forceLocal;
	}

	public function shouldRequireAuthentication() {
	return $this->handler->shouldRequireAuthentication();
	}

	public function shouldAllowUnguardedWrites() {
	return $this->handler->shouldAllowUnguardedWrites();
	}

	public function getRequiredScope() {
	return $this->handler->getRequiredScope();
	}

	public function getErrorDescription($code) {
	return $this->handler->getErrorDescription($code);
	}

	public function execute() {
	$user = $this->getUser();
	if (!$user) {
	$user = new PhabricatorUser();
	}

	$this->request->setUser($user);

	if ($this->shouldRequireAuthentication()) {
	- if (!$user->isLoggedIn()) {
	+ // TODO: As per below, this should get centralized and cleaned up.
	+ if (!$user->isLoggedIn() && !$user->isOmnipotent()) {
	throw new ConduitException("ERR-INVALID-AUTH");
	}

	// TODO: This would be slightly cleaner by just using a Query, but the
	// Conduit auth workflow requires the Call and User be built separately.
	// Just do it this way for the moment.
	$application = $this->handler->getApplication();
	if ($application) {
	$can_view = PhabricatorPolicyFilter::hasCapability(
	$user,
	$application,
	PhabricatorPolicyCapability::CAN_VIEW);

	if (!$can_view) {
	throw new ConduitException(
	pht(
	"You do not have access to the application which provides this ".
	"API method."));
	}
	}
	}

	if (!$this->shouldForceLocal() && $this->servers) {
	$server = $this->pickRandomServer($this->servers);
	$client = new ConduitClient($server);
	$params = $this->request->getAllParameters();

	$params["__conduit__"]["isProxied"] = true;

	if ($this->handler->shouldRequireAuthentication()) {
	$client->callMethodSynchronous(
	'conduit.connect',
	array(
	'client' => 'PhabricatorConduit',
	'clientVersion' => '1.0',
	'user' => $this->getUser()->getUserName(),
	'certificate' => $this->getUser()->getConduitCertificate(),
	'__conduit__' => $params["__conduit__"],
	));
	}

	return $client->callMethodSynchronous(
	$this->method,
	$params);
	} else {
	return $this->handler->executeMethod($this->request);
	}
	}

	protected function pickRandomServer($servers) {
	return $servers[array_rand($servers)];
	}

	protected function buildMethodHandler($method) {
	$method_class = ConduitAPIMethod::getClassNameFromAPIMethodName($method);

	// Test if the method exists.
	$ok = false;
	try {
	$ok = class_exists($method_class);
	} catch (Exception $ex) {
	// Discard, we provide a more specific exception below.
	}
	if (!$ok) {
	throw new ConduitException(
	"Conduit method '{$method}' does not exist.");
	}

	$class_info = new ReflectionClass($method_class);
	if ($class_info->isAbstract()) {
	throw new ConduitException(
	"Method '{$method}' is not valid; the implementation is an abstract ".
	"base class.");
	}

	$method = newv($method_class, array());

	if (!($method instanceof ConduitAPIMethod)) {
	throw new ConduitException(
	"Method '{$method_class}' is not valid; the implementation must be ".
	"a subclass of ConduitAPIMethod.");
	}

	$application = $method->getApplication();
	if ($application && !$application->isInstalled()) {
	$app_name = $application->getName();
	throw new ConduitException(
	"Method '{$method_class}' belongs to application '{$app_name}', ".
	"which is not installed.");
	}

	return $method;
	}


	}
	diff --git a/src/applications/repository/worker/commitmessageparser/PhabricatorRepositoryCommitMessageParserWorker.php b/src/applications/repository/worker/commitmessageparser/PhabricatorRepositoryCommitMessageParserWorker.php
	index d7f66b0457..71f88f1a1e 100644
	--- a/src/applications/repository/worker/commitmessageparser/PhabricatorRepositoryCommitMessageParserWorker.php
	+++ b/src/applications/repository/worker/commitmessageparser/PhabricatorRepositoryCommitMessageParserWorker.php
	@@ -1,541 +1,541 @@
	<?php

	abstract class PhabricatorRepositoryCommitMessageParserWorker
	extends PhabricatorRepositoryCommitParserWorker {

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

	final protected function updateCommitData($author, $message,
	$committer = null) {

	$commit = $this->commit;

	$data = id(new PhabricatorRepositoryCommitData())->loadOneWhere(
	'commitID = %d',
	$commit->getID());
	if (!$data) {
	$data = new PhabricatorRepositoryCommitData();
	}
	$data->setCommitID($commit->getID());
	$data->setAuthorName($author);
	$data->setCommitDetail(
	'authorPHID',
	$this->resolveUserPHID($author));

	$data->setCommitMessage($message);

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

	$repository = $this->repository;

	$author_phid = $this->lookupUser(
	$commit,
	$data->getAuthorName(),
	$data->getCommitDetail('authorPHID'));
	$data->setCommitDetail('authorPHID', $author_phid);

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

	$call = new ConduitCall(
	'differential.parsecommitmessage',
	array(
	'corpus' => $message,
	'partial' => true,
	));
	- $call->setUser($user);
	+ $call->setUser(PhabricatorUser::getOmnipotentUser());
	$result = $call->execute();

	$field_values = $result['fields'];

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

	$revision_id = idx($field_values, 'revisionID');
	if (!$revision_id) {
	$hashes = $this->getCommitHashes(
	$repository,
	$commit);
	if ($hashes) {
	$revisions = id(new DifferentialRevisionQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withCommitHashes($hashes)
	->execute();

	if (!empty($revisions)) {
	$revision = $this->identifyBestRevision($revisions);
	$revision_id = $revision->getID();
	}
	}
	}

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

	$committer_phid = $this->lookupUser(
	$commit,
	$data->getCommitDetail('committer'),
	$data->getCommitDetail('committerPHID'));
	$data->setCommitDetail('committerPHID', $committer_phid);

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

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

	$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;
	$should_autoclose = $repository->shouldAutocloseCommit($commit, $data);

	if ($revision_id) {
	$lock = PhabricatorGlobalLock::newLock(get_class($this).':'.$revision_id);
	$lock->lock(5 * 60);

	// TODO: Check if a more restrictive viewer could be set here
	$revision = id(new DifferentialRevisionQuery())
	->withIDs(array($revision_id))
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->needRelationships(true)
	->needReviewerStatus(true)
	->executeOne();

	if ($revision) {
	$commit_drev = PhabricatorEdgeConfig::TYPE_COMMIT_HAS_DREV;
	id(new PhabricatorEdgeEditor())
	->setActor($user)
	->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) {
	$actor_phid = nonempty(
	$committer_phid,
	$author_phid,
	$revision->getAuthorPHID());
	$actor = id(new PhabricatorUser())
	->loadOneWhere('phid = %s', $actor_phid);

	$diff = $this->attachToRevision($revision, $actor_phid);

	$revision->setDateCommitted($commit->getEpoch());
	$editor = new DifferentialCommentEditor(
	$revision,
	DifferentialAction::ACTION_CLOSE);
	$editor->setActor($actor);
	$editor->setIsDaemonWorkflow(true);

	$vs_diff = $this->loadChangedByCommit($diff);
	if ($vs_diff) {
	$data->setCommitDetail('vsDiff', $vs_diff->getID());

	$changed_by_commit = PhabricatorEnv::getProductionURI(
	'/D'.$revision->getID().
	'?vs='.$vs_diff->getID().
	'&id='.$diff->getID().
	'#toc');
	$editor->setChangedByCommit($changed_by_commit);
	}

	$commit_name = $repository->formatCommitName(
	$commit->getCommitIdentifier());

	$committer_name = $this->loadUserName(
	$committer_phid,
	$data->getCommitDetail('committer'),
	$actor);

	$author_name = $this->loadUserName(
	$author_phid,
	$data->getAuthorName(),
	$actor);

	$info = array();
	$info[] = "authored by {$author_name}";
	if ($committer_name && ($committer_name != $author_name)) {
	$info[] = "committed by {$committer_name}";
	}
	$info = implode(', ', $info);

	$editor
	->setMessage("Closed by commit {$commit_name} ({$info}).")
	->save();
	}

	}

	$lock->unlock();
	}

	if ($should_autoclose) {
	$fields = DifferentialFieldSelector::newSelector()
	->getFieldSpecifications();
	foreach ($fields as $key => $field) {
	if (!$field->shouldAppearOnCommitMessage()) {
	continue;
	}
	$field->setUser($user);
	$value = idx($field_values, $field->getCommitMessageKey());
	$field->setValueFromParsedCommitMessage($value);
	if ($revision) {
	$field->setRevision($revision);
	}
	$field->didParseCommit($repository, $commit, $data);
	}
	}

	$data->save();
	}

	private function loadUserName($user_phid, $default, PhabricatorUser $actor) {
	if (!$user_phid) {
	return $default;
	}
	$handle = id(new PhabricatorHandleQuery())
	->setViewer($actor)
	->withPHIDs(array($user_phid))
	->executeOne();

	return '@'.$handle->getName();
	}

	private function attachToRevision(
	DifferentialRevision $revision,
	$actor_phid) {

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

	$raw_diff = DiffusionRawDiffQuery::newFromDiffusionRequest($drequest)
	->loadRawDiff();

	// TODO: Support adds, deletes and moves under SVN.
	$changes = id(new ArcanistDiffParser())->parseDiff($raw_diff);
	$diff = DifferentialDiff::newFromRawChanges($changes)
	->setRevisionID($revision->getID())
	->setAuthorPHID($actor_phid)
	->setCreationMethod('commit')
	->setSourceControlSystem($this->repository->getVersionControlSystem())
	->setLintStatus(DifferentialLintStatus::LINT_SKIP)
	->setUnitStatus(DifferentialUnitStatus::UNIT_SKIP)
	->setDateCreated($this->commit->getEpoch())
	->setDescription(
	'Commit r'.
	$this->repository->getCallsign().
	$this->commit->getCommitIdentifier());

	// TODO: This is not correct in SVN where one repository can have multiple
	// Arcanist projects.
	$arcanist_project = id(new PhabricatorRepositoryArcanistProject())
	->loadOneWhere('repositoryID = %d LIMIT 1', $this->repository->getID());
	if ($arcanist_project) {
	$diff->setArcanistProjectPHID($arcanist_project->getPHID());
	}

	$parents = DiffusionCommitParentsQuery::newFromDiffusionRequest($drequest)
	->loadParents();
	if ($parents) {
	$diff->setSourceControlBaseRevision(head_key($parents));
	}

	// TODO: Attach binary files.

	$revision->setLineCount($diff->getLineCount());

	return $diff->save();
	}

	private function loadChangedByCommit(DifferentialDiff $diff) {
	$repository = $this->repository;

	$vs_changesets = array();
	$vs_diff = id(new DifferentialDiff())->loadOneWhere(
	'revisionID = %d AND creationMethod != %s ORDER BY id DESC LIMIT 1',
	$diff->getRevisionID(),
	'commit');
	foreach ($vs_diff->loadChangesets() as $changeset) {
	$path = $changeset->getAbsoluteRepositoryPath($repository, $vs_diff);
	$path = ltrim($path, '/');
	$vs_changesets[$path] = $changeset;
	}

	$changesets = array();
	foreach ($diff->getChangesets() as $changeset) {
	$path = $changeset->getAbsoluteRepositoryPath($repository, $diff);
	$path = ltrim($path, '/');
	$changesets[$path] = $changeset;
	}

	if (array_fill_keys(array_keys($changesets), true) !=
	array_fill_keys(array_keys($vs_changesets), true)) {
	return $vs_diff;
	}

	$hunks = id(new DifferentialHunk())->loadAllWhere(
	'changesetID IN (%Ld)',
	mpull($vs_changesets, 'getID'));
	$hunks = mgroup($hunks, 'getChangesetID');
	foreach ($vs_changesets as $changeset) {
	$changeset->attachHunks(idx($hunks, $changeset->getID(), array()));
	}

	$file_phids = array();
	foreach ($vs_changesets as $changeset) {
	$metadata = $changeset->getMetadata();
	$file_phid = idx($metadata, 'new:binary-phid');
	if ($file_phid) {
	$file_phids[$file_phid] = $file_phid;
	}
	}

	$files = array();
	if ($file_phids) {
	$files = id(new PhabricatorFileQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withPHIDs($file_phids)
	->execute();
	$files = mpull($files, null, 'getPHID');
	}

	foreach ($changesets as $path => $changeset) {
	$vs_changeset = $vs_changesets[$path];

	$file_phid = idx($vs_changeset->getMetadata(), 'new:binary-phid');
	if ($file_phid) {
	if (!isset($files[$file_phid])) {
	return $vs_diff;
	}
	$drequest = DiffusionRequest::newFromDictionary(array(
	'user' => PhabricatorUser::getOmnipotentUser(),
	'initFromConduit' => false,
	'repository' => $this->repository,
	'commit' => $this->commit->getCommitIdentifier(),
	'path' => $path,
	));
	$corpus = DiffusionFileContentQuery::newFromDiffusionRequest($drequest)
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->loadFileContent()
	->getCorpus();
	if ($files[$file_phid]->loadFileData() != $corpus) {
	return $vs_diff;
	}
	} else {
	$context = implode("\n", $changeset->makeChangesWithContext());
	$vs_context = implode("\n", $vs_changeset->makeChangesWithContext());

	// We couldn't just compare $context and $vs_context because following
	// diffs will be considered different:
	//
	// -(empty line)
	// -echo 'test';
	// (empty line)
	//
	// (empty line)
	// -echo "test";
	// -(empty line)

	$hunk = id(new DifferentialHunk())->setChanges($context);
	$vs_hunk = id(new DifferentialHunk())->setChanges($vs_context);
	if ($hunk->makeOldFile() != $vs_hunk->makeOldFile() \|\|
	$hunk->makeNewFile() != $vs_hunk->makeNewFile()) {
	return $vs_diff;
	}
	}
	}

	return null;
	}

	/**
	* When querying for revisions by hash, more than one revision may be found.
	* This function identifies the "best" revision from such a set. Typically,
	* there is only one revision found. Otherwise, we try to pick an accepted
	* revision first, followed by an open revision, and otherwise we go with a
	* closed or abandoned revision as a last resort.
	*/
	private function identifyBestRevision(array $revisions) {
	assert_instances_of($revisions, 'DifferentialRevision');
	// get the simplest, common case out of the way
	if (count($revisions) == 1) {
	return reset($revisions);
	}

	$first_choice = array();
	$second_choice = array();
	$third_choice = array();
	foreach ($revisions as $revision) {
	switch ($revision->getStatus()) {
	// "Accepted" revisions -- ostensibly what we're looking for!
	case ArcanistDifferentialRevisionStatus::ACCEPTED:
	$first_choice[] = $revision;
	break;
	// "Open" revisions
	case ArcanistDifferentialRevisionStatus::NEEDS_REVIEW:
	case ArcanistDifferentialRevisionStatus::NEEDS_REVISION:
	$second_choice[] = $revision;
	break;
	// default is a wtf? here
	default:
	case ArcanistDifferentialRevisionStatus::ABANDONED:
	case ArcanistDifferentialRevisionStatus::CLOSED:
	$third_choice[] = $revision;
	break;
	}
	}

	// go down the ladder like a bro at last call
	if (!empty($first_choice)) {
	return $this->identifyMostRecentRevision($first_choice);
	}
	if (!empty($second_choice)) {
	return $this->identifyMostRecentRevision($second_choice);
	}
	if (!empty($third_choice)) {
	return $this->identifyMostRecentRevision($third_choice);
	}
	}

	/**
	* Given a set of revisions, returns the revision with the latest
	* updated time. This is ostensibly the most recent revision.
	*/
	private function identifyMostRecentRevision(array $revisions) {
	assert_instances_of($revisions, 'DifferentialRevision');
	$revisions = msort($revisions, 'getDateModified');
	return end($revisions);
	}

	/**
	* Emit an event so installs can do custom lookup of commit authors who may
	* not be naturally resolvable.
	*/
	private function lookupUser(
	PhabricatorRepositoryCommit $commit,
	$query,
	$guess) {

	$type = PhabricatorEventType::TYPE_DIFFUSION_LOOKUPUSER;
	$data = array(
	'commit' => $commit,
	'query' => $query,
	'result' => $guess,
	);

	$event = new PhabricatorEvent($type, $data);
	PhutilEventEngine::dispatchEvent($event);

	return $event->getValue('result');
	}

	private function resolveUserPHID($user_name) {
	if (!strlen($user_name)) {
	return null;
	}

	$phid = $this->findUserByUserName($user_name);
	if ($phid) {
	return $phid;
	}
	$phid = $this->findUserByEmailAddress($user_name);
	if ($phid) {
	return $phid;
	}
	$phid = $this->findUserByRealName($user_name);
	if ($phid) {
	return $phid;
	}

	// No hits yet, try to parse it as an email address.

	$email = new PhutilEmailAddress($user_name);

	$phid = $this->findUserByEmailAddress($email->getAddress());
	if ($phid) {
	return $phid;
	}

	$display_name = $email->getDisplayName();
	if ($display_name) {
	$phid = $this->findUserByUserName($display_name);
	if ($phid) {
	return $phid;
	}
	$phid = $this->findUserByRealName($display_name);
	if ($phid) {
	return $phid;
	}
	}

	return null;
	}

	private function findUserByUserName($user_name) {
	$by_username = id(new PhabricatorUser())->loadOneWhere(
	'userName = %s',
	$user_name);
	if ($by_username) {
	return $by_username->getPHID();
	}
	return null;
	}

	private function findUserByRealName($real_name) {
	// Note, real names are not guaranteed unique, which is why we do it this
	// way.
	$by_realname = id(new PhabricatorUser())->loadAllWhere(
	'realName = %s',
	$real_name);
	if (count($by_realname) == 1) {
	return reset($by_realname)->getPHID();
	}
	return null;
	}

	private function findUserByEmailAddress($email_address) {
	$by_email = PhabricatorUser::loadOneWithEmailAddress($email_address);
	if ($by_email) {
	return $by_email->getPHID();
	}
	return null;
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Jul 28, 12:59 PM (1 w, 2 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 186845
Default Alt Text: (23 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions