No OneTemporary
Actions

Size

43 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/differential/harbormaster/DifferentialBuildableEngine.php b/src/applications/differential/harbormaster/DifferentialBuildableEngine.php
	index df38885edf..8554f7be25 100644
	--- a/src/applications/differential/harbormaster/DifferentialBuildableEngine.php
	+++ b/src/applications/differential/harbormaster/DifferentialBuildableEngine.php
	@@ -1,57 +1,81 @@
	<?php

	final class DifferentialBuildableEngine
	extends HarbormasterBuildableEngine {

	protected function getPublishableObject() {
	$object = $this->getObject();

	if ($object instanceof DifferentialDiff) {
	return $object->getRevision();
	}

	return $object;
	}

	public function publishBuildable(
	HarbormasterBuildable $old,
	HarbormasterBuildable $new) {

	// If we're publishing to a diff that is not actually attached to a
	// revision, we have nothing to publish to, so just bail out.
	$revision = $this->getPublishableObject();
	if (!$revision) {
	return;
	}

	// Don't publish manual buildables.
	if ($new->getIsManualBuildable()) {
	return;
	}

	// Don't publish anything if the buildable is still building. Differential
	// treats more buildables as "building" than Harbormaster does, but the
	// Differential definition is a superset of the Harbormaster definition.
	if ($new->isBuilding()) {
	return;
	}

	$viewer = $this->getViewer();

	$old_status = $revision->getBuildableStatus($new->getPHID());
	$new_status = $revision->newBuildableStatus($viewer, $new->getPHID());
	if ($old_status === $new_status) {
	return;
	}

	$buildable_type = DifferentialRevisionBuildableTransaction::TRANSACTIONTYPE;

	$xaction = $this->newTransaction()
	->setMetadataValue('harbormaster:buildablePHID', $new->getPHID())
	->setTransactionType($buildable_type)
	->setNewValue($new_status);

	$this->applyTransactions(array($xaction));
	}

	+ public function getAuthorIdentity() {
	+ $object = $this->getObject();
	+
	+ if ($object instanceof DifferentialRevision) {
	+ $object = $object->loadActiveDiff();
	+ }
	+
	+ $authorship = $object->getDiffAuthorshipDict();
	+ if (!isset($authorship['authorName'])) {
	+ return null;
	+ }
	+
	+ $name = $authorship['authorName'];
	+ $address = idx($authorship, 'authorEmail');
	+
	+ $full = id(new PhutilEmailAddress())
	+ ->setDisplayName($name)
	+ ->setAddress($address);
	+
	+ return id(new PhabricatorRepositoryIdentity())
	+ ->setIdentityName((string)$full)
	+ ->makeEphemeral();
	+ }
	+
	}
	diff --git a/src/applications/diffusion/harbormaster/DiffusionBuildableEngine.php b/src/applications/diffusion/harbormaster/DiffusionBuildableEngine.php
	index bb222df28e..748386f1bd 100644
	--- a/src/applications/diffusion/harbormaster/DiffusionBuildableEngine.php
	+++ b/src/applications/diffusion/harbormaster/DiffusionBuildableEngine.php
	@@ -1,37 +1,43 @@
	<?php

	final class DiffusionBuildableEngine
	extends HarbormasterBuildableEngine {

	public function publishBuildable(
	HarbormasterBuildable $old,
	HarbormasterBuildable $new) {

	// Don't publish manual buildables.
	if ($new->getIsManualBuildable()) {
	return;
	}

	// Don't publish anything if the buildable status has not changed. At
	// least for now, Diffusion handles buildable status exactly the same
	// way that Harbormaster does.
	$old_status = $old->getBuildableStatus();
	$new_status = $new->getBuildableStatus();
	if ($old_status === $new_status) {
	return;
	}

	// Don't publish anything if the buildable is still building.
	if ($new->isBuilding()) {
	return;
	}

	$xaction = $this->newTransaction()
	->setMetadataValue('harbormaster:buildablePHID', $new->getPHID())
	->setTransactionType(DiffusionCommitBuildableTransaction::TRANSACTIONTYPE)
	->setNewValue($new->getBuildableStatus());

	$this->applyTransactions(array($xaction));
	}

	+ public function getAuthorIdentity() {
	+ return $this->getObject()
	+ ->loadIdentities($this->getViewer())
	+ ->getAuthorIdentity();
	+ }
	+
	}
	diff --git a/src/applications/harbormaster/engine/HarbormasterBuildableEngine.php b/src/applications/harbormaster/engine/HarbormasterBuildableEngine.php
	index 41d31673d1..25222975b7 100644
	--- a/src/applications/harbormaster/engine/HarbormasterBuildableEngine.php
	+++ b/src/applications/harbormaster/engine/HarbormasterBuildableEngine.php
	@@ -1,105 +1,108 @@
	<?php

	abstract class HarbormasterBuildableEngine
	extends Phobject {

	private $viewer;
	private $actingAsPHID;
	private $contentSource;
	private $object;

	final public function setViewer(PhabricatorUser $viewer) {
	$this->viewer = $viewer;
	return $this;
	}

	final public function getViewer() {
	return $this->viewer;
	}

	final public function setActingAsPHID($acting_as_phid) {
	$this->actingAsPHID = $acting_as_phid;
	return $this;
	}

	final public function getActingAsPHID() {
	return $this->actingAsPHID;
	}

	final public function setContentSource(
	PhabricatorContentSource $content_source) {
	$this->contentSource = $content_source;
	return $this;
	}

	final public function getContentSource() {
	return $this->contentSource;
	}

	final public function setObject(HarbormasterBuildableInterface $object) {
	$this->object = $object;
	return $this;
	}

	final public function getObject() {
	return $this->object;
	}

	protected function getPublishableObject() {
	return $this->getObject();
	}

	public function publishBuildable(
	HarbormasterBuildable $old,
	HarbormasterBuildable $new) {
	return;
	}

	final public static function newForObject(
	HarbormasterBuildableInterface $object,
	PhabricatorUser $viewer) {
	return $object->newBuildableEngine()
	->setViewer($viewer)
	->setObject($object);
	}

	final protected function newEditor() {
	$publishable = $this->getPublishableObject();

	$viewer = $this->getViewer();

	$editor = $publishable->getApplicationTransactionEditor()
	->setActor($viewer)
	->setContinueOnNoEffect(true)
	->setContinueOnMissingFields(true);

	$acting_as_phid = $this->getActingAsPHID();
	if ($acting_as_phid !== null) {
	$editor->setActingAsPHID($acting_as_phid);
	}

	$content_source = $this->getContentSource();
	if ($content_source !== null) {
	$editor->setContentSource($content_source);
	}

	return $editor;
	}

	final protected function newTransaction() {
	$publishable = $this->getPublishableObject();

	return $publishable->getApplicationTransactionTemplate();
	}

	final protected function applyTransactions(array $xactions) {
	$publishable = $this->getPublishableObject();
	$editor = $this->newEditor();

	$editor->applyTransactions(
	$publishable->getApplicationTransactionObject(),
	$xactions);
	}

	+ public function getAuthorIdentity() {
	+ return null;
	+ }

	}
	diff --git a/src/applications/harbormaster/step/HarbormasterBuildkiteBuildStepImplementation.php b/src/applications/harbormaster/step/HarbormasterBuildkiteBuildStepImplementation.php
	index 8a522c4926..ef4cc0daf1 100644
	--- a/src/applications/harbormaster/step/HarbormasterBuildkiteBuildStepImplementation.php
	+++ b/src/applications/harbormaster/step/HarbormasterBuildkiteBuildStepImplementation.php
	@@ -1,223 +1,237 @@
	<?php

	final class HarbormasterBuildkiteBuildStepImplementation
	extends HarbormasterBuildStepImplementation {

	public function getName() {
	return pht('Build with Buildkite');
	}

	public function getGenericDescription() {
	return pht('Trigger a build in Buildkite.');
	}

	public function getBuildStepGroupKey() {
	return HarbormasterExternalBuildStepGroup::GROUPKEY;
	}

	public function getDescription() {
	return pht('Run a build in Buildkite.');
	}

	public function getEditInstructions() {
	$hook_uri = '/harbormaster/hook/buildkite/';
	$hook_uri = PhabricatorEnv::getProductionURI($hook_uri);

	return pht(<<<EOTEXT
	WARNING: This build step is new and experimental!

	To build revisions with Buildkite, they must:

	- belong to a tracked repository;
	- the repository must have a Staging Area configured;
	- you must configure a Buildkite pipeline for that Staging Area; and
	- you must configure the webhook described below.

	To build commits with Buildkite, they must:

	- belong to a tracked repository;
	- you must configure a Buildkite pipeline for that repository; and
	- you must configure the webhook described below.

	Webhook Configuration
	=====================

	In {nav Settings} for your Organization in Buildkite, under
	{nav Notification Services}, add a new Webook Notification.

	Use these settings:

	- Webhook URL: %s
	- Token: The "Webhook Token" field below and the "Token" field in
	Buildkite should both be set to the same nonempty value (any random
	secret). You can use copy/paste the value Buildkite generates into
	this form.
	- Events: Only build.finish needs to be active.

	Environment
	===========

	These variables will be available in the build environment:

	\| Variable \| Description \|
	\|----------\|-------------\|
	\| `HARBORMASTER_BUILD_TARGET_PHID` \| PHID of the Build Target.
	EOTEXT
	,
	$hook_uri);
	}

	public function execute(
	HarbormasterBuild $build,
	HarbormasterBuildTarget $build_target) {
	$viewer = PhabricatorUser::getOmnipotentUser();

	if (PhabricatorEnv::getEnvConfig('phabricator.silent')) {
	$this->logSilencedCall($build, $build_target, pht('Buildkite'));
	throw new HarbormasterBuildFailureException();
	}

	$buildable = $build->getBuildable();

	$object = $buildable->getBuildableObject();
	if (!($object instanceof HarbormasterBuildkiteBuildableInterface)) {
	throw new Exception(
	pht('This object does not support builds with Buildkite.'));
	}

	$organization = $this->getSetting('organization');
	$pipeline = $this->getSetting('pipeline');

	$uri = urisprintf(
	'https://api.buildkite.com/v2/organizations/%s/pipelines/%s/builds',
	$organization,
	$pipeline);

	$data_structure = array(
	'commit' => $object->getBuildkiteCommit(),
	'branch' => $object->getBuildkiteBranch(),
	'message' => pht(
	'Harbormaster Build %s ("%s") for %s',
	$build->getID(),
	$build->getName(),
	$buildable->getMonogram()),
	'env' => array(
	'HARBORMASTER_BUILD_TARGET_PHID' => $build_target->getPHID(),
	),
	'meta_data' => array(
	'buildTargetPHID' => $build_target->getPHID(),

	// See PHI611. These are undocumented secret magic.
	'phabricator:build:id' => (int)$build->getID(),
	'phabricator:build:url' =>
	PhabricatorEnv::getProductionURI($build->getURI()),
	'phabricator:buildable:id' => (int)$buildable->getID(),
	'phabricator:buildable:url' =>
	PhabricatorEnv::getProductionURI($buildable->getURI()),
	),
	);

	+ $engine = HarbormasterBuildableEngine::newForObject(
	+ $object,
	+ $viewer);
	+
	+ $author_identity = $engine->getAuthorIdentity();
	+ if ($author_identity) {
	+ $data_structure += array(
	+ 'author' => array(
	+ 'name' => $author_identity->getIdentityDisplayName(),
	+ 'email' => $author_identity->getIdentityEmailAddress(),
	+ ),
	+ );
	+ }
	+
	$json_data = phutil_json_encode($data_structure);

	$credential_phid = $this->getSetting('token');
	$api_token = id(new PassphraseCredentialQuery())
	->setViewer($viewer)
	->withPHIDs(array($credential_phid))
	->needSecrets(true)
	->executeOne();
	if (!$api_token) {
	throw new Exception(
	pht(
	'Unable to load API token ("%s")!',
	$credential_phid));
	}

	$token = $api_token->getSecret()->openEnvelope();

	$future = id(new HTTPSFuture($uri, $json_data))
	->setMethod('POST')
	->addHeader('Content-Type', 'application/json')
	->addHeader('Accept', 'application/json')
	->addHeader('Authorization', "Bearer {$token}")
	->setTimeout(60);

	$this->resolveFutures(
	$build,
	$build_target,
	array($future));

	$this->logHTTPResponse($build, $build_target, $future, pht('Buildkite'));

	list($status, $body) = $future->resolve();
	if ($status->isError()) {
	throw new HarbormasterBuildFailureException();
	}

	$response = phutil_json_decode($body);

	$uri_key = 'web_url';
	$build_uri = idx($response, $uri_key);
	if (!$build_uri) {
	throw new Exception(
	pht(
	'Buildkite did not return a "%s"!',
	$uri_key));
	}

	$target_phid = $build_target->getPHID();

	$api_method = 'harbormaster.createartifact';
	$api_params = array(
	'buildTargetPHID' => $target_phid,
	'artifactType' => HarbormasterURIArtifact::ARTIFACTCONST,
	'artifactKey' => 'buildkite.uri',
	'artifactData' => array(
	'uri' => $build_uri,
	'name' => pht('View in Buildkite'),
	'ui.external' => true,
	),
	);

	id(new ConduitCall($api_method, $api_params))
	->setUser($viewer)
	->execute();
	}

	public function getFieldSpecifications() {
	return array(
	'token' => array(
	'name' => pht('API Token'),
	'type' => 'credential',
	'credential.type'
	=> PassphraseTokenCredentialType::CREDENTIAL_TYPE,
	'credential.provides'
	=> PassphraseTokenCredentialType::PROVIDES_TYPE,
	'required' => true,
	),
	'organization' => array(
	'name' => pht('Organization Name'),
	'type' => 'text',
	'required' => true,
	),
	'pipeline' => array(
	'name' => pht('Pipeline Name'),
	'type' => 'text',
	'required' => true,
	),
	'webhook.token' => array(
	'name' => pht('Webhook Token'),
	'type' => 'text',
	'required' => true,
	),
	);
	}

	public function supportsWaitForMessage() {
	return false;
	}

	public function shouldWaitForMessage(HarbormasterBuildTarget $target) {
	return true;
	}

	}
	diff --git a/src/applications/repository/storage/PhabricatorRepositoryCommit.php b/src/applications/repository/storage/PhabricatorRepositoryCommit.php
	index 4cb9def346..f36869686f 100644
	--- a/src/applications/repository/storage/PhabricatorRepositoryCommit.php
	+++ b/src/applications/repository/storage/PhabricatorRepositoryCommit.php
	@@ -1,842 +1,861 @@
	<?php

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

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

	const IMPORTED_MESSAGE = 1;
	const IMPORTED_CHANGE = 2;
	const IMPORTED_OWNERS = 4;
	const IMPORTED_HERALD = 8;
	const IMPORTED_ALL = 15;

	const IMPORTED_CLOSEABLE = 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',
	'mailKey' => 'bytes20',
	'authorPHID' => 'phid?',
	'authorIdentityPHID' => 'phid?',
	'committerIdentityPHID' => 'phid?',
	'auditStatus' => 'uint32',
	'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 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 loadAndAttachAuditAuthority(
	PhabricatorUser $viewer,
	$actor_phid = null) {

	if ($actor_phid === null) {
	$actor_phid = $viewer->getPHID();
	}

	// TODO: This method is a little weird and sketchy, but worlds better than
	// what came before it. Eventually, this should probably live in a Query
	// class.

	// Figure out which requests the actor has authority over: these are user
	// requests where they are the auditor, and packages and projects they are
	// a member of.

	if (!$actor_phid) {
	$attach_key = $viewer->getCacheFragment();
	$phids = array();
	} else {
	$attach_key = $actor_phid;
	// At least currently, when modifying your own commits, you act only on
	// behalf of yourself, not your packages/projects -- the idea being that
	// you can't accept your own commits. This may change or depend on
	// config.
	$actor_is_author = ($actor_phid == $this->getAuthorPHID());
	if ($actor_is_author) {
	$phids = array($actor_phid);
	} else {
	$phids = array();
	$phids[$actor_phid] = true;

	$owned_packages = id(new PhabricatorOwnersPackageQuery())
	->setViewer($viewer)
	->withAuthorityPHIDs(array($actor_phid))
	->execute();
	foreach ($owned_packages as $package) {
	$phids[$package->getPHID()] = true;
	}

	$projects = id(new PhabricatorProjectQuery())
	->setViewer($viewer)
	->withMemberPHIDs(array($actor_phid))
	->execute();
	foreach ($projects as $project) {
	$phids[$project->getPHID()] = true;
	}

	$phids = array_keys($phids);
	}
	}

	$this->auditAuthorityPHIDs[$attach_key] = array_fuse($phids);

	return $this;
	}

	public function hasAuditAuthority(
	PhabricatorUser $viewer,
	PhabricatorRepositoryAuditRequest $audit,
	$actor_phid = null) {

	if ($actor_phid === null) {
	$actor_phid = $viewer->getPHID();
	}

	if (!$actor_phid) {
	$attach_key = $viewer->getCacheFragment();
	} else {
	$attach_key = $actor_phid;
	}

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

	if (!$actor_phid) {
	return false;
	}

	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 save() {
	if (!$this->mailKey) {
	$this->mailKey = Filesystem::readRandomCharacters(20);
	}
	return parent::save();
	}

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

	$current_status = $this->getAuditStatus();
	$status_verify = PhabricatorAuditCommitStatusConstants::NEEDS_VERIFICATION;

	if ($any_concern) {
	if ($current_status == $status_verify) {
	// If the change is in "Needs Verification", we keep it there as
	// long as any auditors still have concerns.
	$status = $status_verify;
	} else {
	$status = PhabricatorAuditCommitStatusConstants::CONCERN_RAISED;
	}
	} else if ($any_accept) {
	if ($any_need) {
	$status = PhabricatorAuditCommitStatusConstants::PARTIALLY_AUDITED;
	} else {
	$status = PhabricatorAuditCommitStatusConstants::FULLY_AUDITED;
	}
	} else if ($any_need) {
	$status = PhabricatorAuditCommitStatusConstants::NEEDS_AUDIT;
	} else {
	$status = PhabricatorAuditCommitStatusConstants::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);
	}

	/**
	* Make a strong effort to find a way to render this commit's committer.
	* This currently attempts to use @{PhabricatorRepositoryIdentity}, and
	* falls back to examining the commit detail information. After we force
	* the migration to using identities, update this method to remove the
	* fallback. See T12164 for details.
	*/
	public function renderAnyCommitter(PhabricatorUser $viewer, $handles) {
	$committer = $this->renderCommitter($viewer, $handles);
	if ($committer) {
	return $committer;
	}

	return $this->renderAuthor($viewer, $handles);
	}

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

	$data = $this->getCommitData();
	$committer_name = $data->getCommitDetail('committer');
	if (strlen($committer_name)) {
	return DiffusionView::renderName($committer_name);
	}

	return null;
	}

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

	$data = $this->getCommitData();
	$author_name = $data->getAuthorName();
	if (strlen($author_name)) {
	return DiffusionView::renderName($author_name);
	}

	return null;
	}

	+ 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');
	}

	/* -( 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(),
	'mailKey' => $this->getMailKey(),
	'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 getApplicationTransactionObject() {
	return $this;
	}

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

	public function willRenderTimeline(
	PhabricatorApplicationTransactionView $timeline,
	AphrontRequest $request) {

	$xactions = $timeline->getTransactions();

	$path_ids = array();
	foreach ($xactions as $xaction) {
	if ($xaction->hasComment()) {
	$path_id = $xaction->getComment()->getPathID();
	if ($path_id) {
	$path_ids[] = $path_id;
	}
	}
	}

	$path_map = array();
	if ($path_ids) {
	$path_map = id(new DiffusionPathQuery())
	->withPathIDs($path_ids)
	->execute();
	$path_map = ipull($path_map, 'path', 'id');
	}

	return $timeline->setPathMap($path_map);
	}

	/* -( 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.')),
	);
	}

	public function getFieldValuesForConduit() {

	// NOTE: This data should be similar to the information returned about
	// commmits by "differential.diff.search" with the "commits" attachment.

	return array(
	'identifier' => $this->getCommitIdentifier(),
	);
	}

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

	}
	diff --git a/src/applications/repository/storage/PhabricatorRepositoryIdentity.php b/src/applications/repository/storage/PhabricatorRepositoryIdentity.php
	index f801e06b89..416d1a3cd2 100644
	--- a/src/applications/repository/storage/PhabricatorRepositoryIdentity.php
	+++ b/src/applications/repository/storage/PhabricatorRepositoryIdentity.php
	@@ -1,142 +1,152 @@
	<?php

	final class PhabricatorRepositoryIdentity
	extends PhabricatorRepositoryDAO
	implements
	PhabricatorPolicyInterface,
	PhabricatorApplicationTransactionInterface {

	protected $authorPHID;
	protected $identityNameHash;
	protected $identityNameRaw;
	protected $identityNameEncoding;
	protected $automaticGuessedUserPHID;
	protected $manuallySetUserPHID;
	protected $currentEffectiveUserPHID;

	private $effectiveUser = self::ATTACHABLE;

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

	public function getEffectiveUser() {
	return $this->assertAttached($this->effectiveUser);
	}

	protected function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_BINARY => array(
	'identityNameRaw' => true,
	),
	self::CONFIG_COLUMN_SCHEMA => array(
	'identityNameHash' => 'bytes12',
	'identityNameEncoding' => 'text16?',
	'automaticGuessedUserPHID' => 'phid?',
	'manuallySetUserPHID' => 'phid?',
	'currentEffectiveUserPHID' => 'phid?',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'key_identity' => array(
	'columns' => array('identityNameHash'),
	'unique' => true,
	),
	),
	) + parent::getConfiguration();
	}

	public function getPHIDType() {
	return PhabricatorRepositoryIdentityPHIDType::TYPECONST;
	}

	public function setIdentityName($name_raw) {
	$this->setIdentityNameRaw($name_raw);
	$this->setIdentityNameHash(PhabricatorHash::digestForIndex($name_raw));
	$this->setIdentityNameEncoding($this->detectEncodingForStorage($name_raw));

	return $this;
	}

	public function getIdentityName() {
	return $this->getUTF8StringFromStorage(
	$this->getIdentityNameRaw(),
	$this->getIdentityNameEncoding());
	}

	+ public function getIdentityEmailAddress() {
	+ $address = new PhutilEmailAddress($this->getIdentityName());
	+ return $address->getAddress();
	+ }
	+
	+ public function getIdentityDisplayName() {
	+ $address = new PhutilEmailAddress($this->getIdentityName());
	+ return $address->getDisplayName();
	+ }
	+
	public function getIdentityShortName() {
	// TODO
	return $this->getIdentityName();
	}

	public function getURI() {
	return '/diffusion/identity/view/'.$this->getID().'/';
	}

	public function hasEffectiveUser() {
	return ($this->currentEffectiveUserPHID != null);
	}

	public function getIdentityDisplayPHID() {
	if ($this->hasEffectiveUser()) {
	return $this->getCurrentEffectiveUserPHID();
	} else {
	return $this->getPHID();
	}
	}

	public function save() {
	if ($this->manuallySetUserPHID) {
	$this->currentEffectiveUserPHID = $this->manuallySetUserPHID;
	} else {
	$this->currentEffectiveUserPHID = $this->automaticGuessedUserPHID;
	}

	return parent::save();
	}


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


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

	public function getPolicy($capability) {
	return PhabricatorPolicies::getMostOpenPolicy();
	}

	public function hasAutomaticCapability(
	$capability, PhabricatorUser $viewer) {
	return false;
	}


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


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

	public function getApplicationTransactionObject() {
	return $this;
	}

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

	public function willRenderTimeline(
	PhabricatorApplicationTransactionView $timeline,
	AphrontRequest $request) {

	return $timeline;
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Apr 28, 12:49 AM (6 h, 36 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 107570
Default Alt Text: (43 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions