No OneTemporary
Actions

Size

49 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/auth/controller/PhabricatorAuthStartController.php b/src/applications/auth/controller/PhabricatorAuthStartController.php
	index 7e9b17feff..0c42f53556 100644
	--- a/src/applications/auth/controller/PhabricatorAuthStartController.php
	+++ b/src/applications/auth/controller/PhabricatorAuthStartController.php
	@@ -1,340 +1,340 @@
	<?php

	final class PhabricatorAuthStartController
	extends PhabricatorAuthController {

	public function shouldRequireLogin() {
	return false;
	}

	public function handleRequest(AphrontRequest $request) {
	$viewer = $request->getUser();

	if ($viewer->isLoggedIn()) {
	// Kick the user home if they are already logged in.
	return id(new AphrontRedirectResponse())->setURI('/');
	}

	if ($request->isAjax()) {
	return $this->processAjaxRequest();
	}

	if ($request->isConduit()) {
	return $this->processConduitRequest();
	}

	// If the user gets this far, they aren't logged in, so if they have a
	// user session token we can conclude that it's invalid: if it was valid,
	// they'd have been logged in above and never made it here. Try to clear
	// it and warn the user they may need to nuke their cookies.

	$session_token = $request->getCookie(PhabricatorCookies::COOKIE_SESSION);
	$did_clear = $request->getStr('cleared');

	if (strlen($session_token)) {
	$kind = PhabricatorAuthSessionEngine::getSessionKindFromToken(
	$session_token);
	switch ($kind) {
	case PhabricatorAuthSessionEngine::KIND_ANONYMOUS:
	// If this is an anonymous session. It's expected that they won't
	// be logged in, so we can just continue.
	break;
	default:
	// The session cookie is invalid, so try to clear it.
	$request->clearCookie(PhabricatorCookies::COOKIE_USERNAME);
	$request->clearCookie(PhabricatorCookies::COOKIE_SESSION);

	// We've previously tried to clear the cookie but we ended up back
	// here, so it didn't work. Hard fatal instead of trying again.
	if ($did_clear) {
	return $this->renderError(
	pht(
	'Your login session is invalid, and clearing the session '.
	'cookie was unsuccessful. Try clearing your browser cookies.'));
	}

	$redirect_uri = $request->getRequestURI();
	$redirect_uri->replaceQueryParam('cleared', 1);
	return id(new AphrontRedirectResponse())->setURI($redirect_uri);
	}
	}

	// If we just cleared the session cookie and it worked, clean up after
	// ourselves by redirecting to get rid of the "cleared" parameter. The
	// the workflow will continue normally.
	if ($did_clear) {
	$redirect_uri = $request->getRequestURI();
	$redirect_uri->removeQueryParam('cleared');
	return id(new AphrontRedirectResponse())->setURI($redirect_uri);
	}

	$providers = PhabricatorAuthProvider::getAllEnabledProviders();
	foreach ($providers as $key => $provider) {
	if (!$provider->shouldAllowLogin()) {
	unset($providers[$key]);
	}
	}

	$configs = array();
	foreach ($providers as $provider) {
	$configs[] = $provider->getProviderConfig();
	}

	if (!$providers) {
	if ($this->isFirstTimeSetup()) {
	// If this is a fresh install, let the user register their admin
	// account.
	return id(new AphrontRedirectResponse())
	->setURI($this->getApplicationURI('/register/'));
	}

	return $this->renderError(
	pht(
	'This Phabricator install is not configured with any enabled '.
	'authentication providers which can be used to log in. If you '.
	'have accidentally locked yourself out by disabling all providers, '.
	'you can use `%s` to recover access to an account.',
	'phabricator/bin/auth recover <username>'));
	}

	$next_uri = $request->getStr('next');
	if (!strlen($next_uri)) {
	if ($this->getDelegatingController()) {
	// Only set a next URI from the request path if this controller was
	// delegated to, which happens when a user tries to view a page which
	// requires them to login.

	// If this controller handled the request directly, we're on the main
	// login page, and never want to redirect the user back here after they
	// login.
	$next_uri = (string)$this->getRequest()->getRequestURI();
	}
	}

	if (!$request->isFormPost()) {
	if (strlen($next_uri)) {
	PhabricatorCookies::setNextURICookie($request, $next_uri);
	}
	PhabricatorCookies::setClientIDCookie($request);
	}

	$auto_response = $this->tryAutoLogin($providers);
	if ($auto_response) {
	return $auto_response;
	}

	$invite = $this->loadInvite();

	$not_buttons = array();
	$are_buttons = array();
	$providers = msort($providers, 'getLoginOrder');
	foreach ($providers as $provider) {
	if ($invite) {
	$form = $provider->buildInviteForm($this);
	} else {
	$form = $provider->buildLoginForm($this);
	}
	if ($provider->isLoginFormAButton()) {
	$are_buttons[] = $form;
	} else {
	$not_buttons[] = $form;
	}
	}

	$out = array();
	$out[] = $not_buttons;
	if ($are_buttons) {
	require_celerity_resource('auth-css');

	foreach ($are_buttons as $key => $button) {
	$are_buttons[$key] = phutil_tag(
	'div',
	array(
	'class' => 'phabricator-login-button mmb',
	),
	$button);
	}

	// If we only have one button, add a second pretend button so that we
	// always have two columns. This makes it easier to get the alignments
	// looking reasonable.
	if (count($are_buttons) == 1) {
	$are_buttons[] = null;
	}

	$button_columns = id(new AphrontMultiColumnView())
	->setFluidLayout(true);
	$are_buttons = array_chunk($are_buttons, ceil(count($are_buttons) / 2));
	foreach ($are_buttons as $column) {
	$button_columns->addColumn($column);
	}

	$out[] = phutil_tag(
	'div',
	array(
	'class' => 'phabricator-login-buttons',
	),
	$button_columns);
	}

	$invite_message = null;
	if ($invite) {
	$invite_message = $this->renderInviteHeader($invite);
	}

	$custom_message = $this->newCustomStartMessage();

	$email_login = $this->newEmailLoginView($configs);

	$crumbs = $this->buildApplicationCrumbs();
	$crumbs->addTextCrumb(pht('Login'));
	$crumbs->setBorder(true);

	$title = pht('Login');
	$view = array(
	$invite_message,
	$custom_message,
	$out,
	$email_login,
	);

	return $this->newPage()
	->setTitle($title)
	->setCrumbs($crumbs)
	->appendChild($view);
	}


	private function processAjaxRequest() {
	$request = $this->getRequest();
	$viewer = $request->getUser();

	// We end up here if the user clicks a workflow link that they need to
	// login to use. We give them a dialog saying "You need to login...".

	if ($request->isDialogFormPost()) {
	return id(new AphrontRedirectResponse())->setURI(
	$request->getRequestURI());
	}

	// Often, users end up here by clicking a disabled action link in the UI
	// (for example, they might click "Edit Subtasks" on a Maniphest task
	// page). After they log in we want to send them back to that main object
	// page if we can, since it's confusing to end up on a standalone page with
	// only a dialog (particularly if that dialog is another error,
	// like a policy exception).

	$via_header = AphrontRequest::getViaHeaderName();
	$via_uri = AphrontRequest::getHTTPHeader($via_header);
	if (strlen($via_uri)) {
	PhabricatorCookies::setNextURICookie($request, $via_uri, $force = true);
	}

	return $this->newDialog()
	->setTitle(pht('Login Required'))
	->appendParagraph(pht('You must log in to take this action.'))
	->addSubmitButton(pht('Log In'))
	->addCancelButton('/');
	}


	private function processConduitRequest() {
	$request = $this->getRequest();
	$viewer = $request->getUser();

	// A common source of errors in Conduit client configuration is getting
	// the request path wrong. The client will end up here, so make some
	// effort to give them a comprehensible error message.

	$request_path = $this->getRequest()->getPath();
	$conduit_path = '/api/<method>';
	$example_path = '/api/conduit.ping';

	$message = pht(
	'ERROR: You are making a Conduit API request to "%s", but the correct '.
	- 'HTTP request path to use in order to access a COnduit method is "%s" '.
	+ 'HTTP request path to use in order to access a Conduit method is "%s" '.
	'(for example, "%s"). Check your configuration.',
	$request_path,
	$conduit_path,
	$example_path);

	return id(new AphrontPlainTextResponse())->setContent($message);
	}

	protected function renderError($message) {
	return $this->renderErrorPage(
	pht('Authentication Failure'),
	array($message));
	}

	private function tryAutoLogin(array $providers) {
	$request = $this->getRequest();

	// If the user just logged out, don't immediately log them in again.
	if ($request->getURIData('loggedout')) {
	return null;
	}

	// If we have more than one provider, we can't autologin because we
	// don't know which one the user wants.
	if (count($providers) != 1) {
	return null;
	}

	$provider = head($providers);
	if (!$provider->supportsAutoLogin()) {
	return null;
	}

	$config = $provider->getProviderConfig();
	if (!$config->getShouldAutoLogin()) {
	return null;
	}

	$auto_uri = $provider->getAutoLoginURI($request);

	return id(new AphrontRedirectResponse())
	->setIsExternal(true)
	->setURI($auto_uri);
	}

	private function newEmailLoginView(array $configs) {
	assert_instances_of($configs, 'PhabricatorAuthProviderConfig');

	// Check if password auth is enabled. If it is, the password login form
	// renders a "Forgot password?" link, so we don't need to provide a
	// supplemental link.

	$has_password = false;
	foreach ($configs as $config) {
	$provider = $config->getProvider();
	if ($provider instanceof PhabricatorPasswordAuthProvider) {
	$has_password = true;
	}
	}

	if ($has_password) {
	return null;
	}

	$view = array(
	pht('Trouble logging in?'),
	' ',
	phutil_tag(
	'a',
	array(
	'href' => '/login/email/',
	),
	pht('Send a login link to your email address.')),
	);

	return phutil_tag(
	'div',
	array(
	'class' => 'auth-custom-message',
	),
	$view);
	}


	}
	diff --git a/src/applications/config/controller/PhabricatorConfigConsoleController.php b/src/applications/config/controller/PhabricatorConfigConsoleController.php
	index b8eae9c213..0528be347a 100644
	--- a/src/applications/config/controller/PhabricatorConfigConsoleController.php
	+++ b/src/applications/config/controller/PhabricatorConfigConsoleController.php
	@@ -1,336 +1,336 @@
	<?php

	final class PhabricatorConfigConsoleController
	extends PhabricatorConfigController {

	public function handleRequest(AphrontRequest $request) {
	$viewer = $request->getViewer();

	$menu = id(new PHUIObjectItemListView())
	->setViewer($viewer)
	->setBig(true);

	$menu->addItem(
	id(new PHUIObjectItemView())
	->setHeader(pht('Settings'))
	->setHref($this->getApplicationURI('settings/'))
	->setImageIcon('fa-wrench')
	->setClickable(true)
	->addAttribute(
	pht(
	'Review and modify configuration settings.')));

	$menu->addItem(
	id(new PHUIObjectItemView())
	->setHeader(pht('Setup Issues'))
	->setHref($this->getApplicationURI('issue/'))
	->setImageIcon('fa-exclamation-triangle')
	->setClickable(true)
	->addAttribute(
	pht(
	'Show unresolved issues with setup and configuration.')));

	$menu->addItem(
	id(new PHUIObjectItemView())
	->setHeader(pht('Services'))
	->setHref($this->getApplicationURI('cluster/databases/'))
	->setImageIcon('fa-server')
	->setClickable(true)
	->addAttribute(
	pht(
	'View status information for databases, caches, repositories, '.
	'and other services.')));

	$menu->addItem(
	id(new PHUIObjectItemView())
	->setHeader(pht('Extensions/Modules'))
	->setHref($this->getApplicationURI('module/'))
	->setImageIcon('fa-gear')
	->setClickable(true)
	->addAttribute(
	pht(
	'Show installed extensions and modules.')));

	$crumbs = $this->buildApplicationCrumbs()
	->addTextCrumb(pht('Console'))
	->setBorder(true);

	$box = id(new PHUIObjectBoxView())
	- ->setHeaderText(pht('Phabricator Configuation'))
	+ ->setHeaderText(pht('Phabricator Configuration'))
	->setBackground(PHUIObjectBoxView::WHITE_CONFIG)
	->setObjectList($menu);

	$versions = $this->newLibraryVersionTable($viewer);
	$binary_versions = $this->newBinaryVersionTable();

	$launcher_view = id(new PHUILauncherView())
	->appendChild($box)
	->appendChild($versions)
	->appendChild($binary_versions);

	$view = id(new PHUITwoColumnView())
	->setFooter($launcher_view);

	return $this->newPage()
	- ->setTitle(pht('Phabricator Configuation'))
	+ ->setTitle(pht('Phabricator Configuration'))
	->setCrumbs($crumbs)
	->appendChild($view);
	}

	public function newLibraryVersionTable() {
	$viewer = $this->getViewer();

	$versions = $this->loadVersions($viewer);

	$rows = array();
	foreach ($versions as $name => $info) {
	$branchpoint = $info['branchpoint'];
	if (strlen($branchpoint)) {
	$branchpoint = substr($branchpoint, 0, 12);
	} else {
	$branchpoint = null;
	}

	$version = $info['hash'];
	if (strlen($version)) {
	$version = substr($version, 0, 12);
	} else {
	$version = pht('Unknown');
	}


	$epoch = $info['epoch'];
	if ($epoch) {
	$epoch = phabricator_date($epoch, $viewer);
	} else {
	$epoch = null;
	}

	$rows[] = array(
	$name,
	$version,
	$epoch,
	$branchpoint,
	);
	}

	$table_view = id(new AphrontTableView($rows))
	->setHeaders(
	array(
	pht('Library'),
	pht('Version'),
	pht('Date'),
	pht('Branchpoint'),
	))
	->setColumnClasses(
	array(
	'pri',
	null,
	null,
	'wide',
	));

	return id(new PHUIObjectBoxView())
	->setHeaderText(pht('Phabricator Version Information'))
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	->appendChild($table_view);
	}

	private function loadVersions(PhabricatorUser $viewer) {
	$specs = array(
	'phabricator',
	'arcanist',
	);

	$all_libraries = PhutilBootloader::getInstance()->getAllLibraries();
	// This puts the core libraries at the top:
	$other_libraries = array_diff($all_libraries, $specs);
	$specs = array_merge($specs, $other_libraries);

	$log_futures = array();
	$remote_futures = array();

	foreach ($specs as $lib) {
	$root = dirname(phutil_get_library_root($lib));

	$log_command = csprintf(
	'git log --format=%s -n 1 --',
	'%H %ct');

	$remote_command = csprintf(
	'git remote -v');

	$log_futures[$lib] = id(new ExecFuture('%C', $log_command))
	->setCWD($root);

	$remote_futures[$lib] = id(new ExecFuture('%C', $remote_command))
	->setCWD($root);
	}

	$all_futures = array_merge($log_futures, $remote_futures);

	id(new FutureIterator($all_futures))
	->resolveAll();

	// A repository may have a bunch of remotes, but we're only going to look
	// for remotes we host to try to figure out where this repository branched.
	$upstream_pattern = '(github\.com/phacility/\|secure\.phabricator\.com/)';

	$upstream_futures = array();
	$lib_upstreams = array();
	foreach ($specs as $lib) {
	$remote_future = $remote_futures[$lib];

	list($err, $stdout) = $remote_future->resolve();
	if ($err) {
	// If this fails for whatever reason, just move on.
	continue;
	}

	// These look like this, with a tab separating the first two fields:
	// remote-name http://remote.uri/ (push)

	$upstreams = array();

	$remotes = phutil_split_lines($stdout, false);
	foreach ($remotes as $remote) {
	$remote_pattern = '/^([^\t]+)\t([^ ]+) $([^)]+)$\z/';
	$matches = null;
	if (!preg_match($remote_pattern, $remote, $matches)) {
	continue;
	}

	// Remote URIs are either "push" or "fetch": we only care about "fetch"
	// URIs.
	$type = $matches[3];
	if ($type != 'fetch') {
	continue;
	}

	$uri = $matches[2];
	$is_upstream = preg_match($upstream_pattern, $uri);
	if (!$is_upstream) {
	continue;
	}

	$name = $matches[1];
	$upstreams[$name] = $name;
	}

	// If we have several suitable upstreams, try to pick the one named
	// "origin", if it exists. Otherwise, just pick the first one.
	if (isset($upstreams['origin'])) {
	$upstream = $upstreams['origin'];
	} else if ($upstreams) {
	$upstream = head($upstreams);
	} else {
	$upstream = null;
	}

	if (!$upstream) {
	continue;
	}

	$lib_upstreams[$lib] = $upstream;

	$merge_base_command = csprintf(
	'git merge-base HEAD %s/master --',
	$upstream);

	$root = dirname(phutil_get_library_root($lib));

	$upstream_futures[$lib] = id(new ExecFuture('%C', $merge_base_command))
	->setCWD($root);
	}

	if ($upstream_futures) {
	id(new FutureIterator($upstream_futures))
	->resolveAll();
	}

	$results = array();
	foreach ($log_futures as $lib => $future) {
	list($err, $stdout) = $future->resolve();
	if (!$err) {
	list($hash, $epoch) = explode(' ', $stdout);
	} else {
	$hash = null;
	$epoch = null;
	}

	$result = array(
	'hash' => $hash,
	'epoch' => $epoch,
	'upstream' => null,
	'branchpoint' => null,
	);

	$upstream_future = idx($upstream_futures, $lib);
	if ($upstream_future) {
	list($err, $stdout) = $upstream_future->resolve();
	if (!$err) {
	$branchpoint = trim($stdout);
	if (strlen($branchpoint)) {
	// We only list a branchpoint if it differs from HEAD.
	if ($branchpoint != $hash) {
	$result['upstream'] = $lib_upstreams[$lib];
	$result['branchpoint'] = trim($stdout);
	}
	}
	}
	}

	$results[$lib] = $result;
	}

	return $results;
	}

	private function newBinaryVersionTable() {
	$rows = array();

	$rows[] = array(
	'php',
	phpversion(),
	php_sapi_name(),
	);

	$binaries = PhutilBinaryAnalyzer::getAllBinaries();
	foreach ($binaries as $binary) {
	if (!$binary->isBinaryAvailable()) {
	$binary_version = pht('Not Available');
	$binary_path = null;
	} else {
	$binary_version = $binary->getBinaryVersion();
	$binary_path = $binary->getBinaryPath();
	}

	$rows[] = array(
	$binary->getBinaryName(),
	$binary_version,
	$binary_path,
	);
	}

	$table_view = id(new AphrontTableView($rows))
	->setHeaders(
	array(
	pht('Binary'),
	pht('Version'),
	pht('Path'),
	))
	->setColumnClasses(
	array(
	'pri',
	null,
	'wide',
	));

	return id(new PHUIObjectBoxView())
	->setHeaderText(pht('Other Version Information'))
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	->appendChild($table_view);
	}


	}
	diff --git a/src/applications/repository/storage/PhabricatorRepositoryCommit.php b/src/applications/repository/storage/PhabricatorRepositoryCommit.php
	index 31413ea0c2..0303e36919 100644
	--- a/src/applications/repository/storage/PhabricatorRepositoryCommit.php
	+++ b/src/applications/repository/storage/PhabricatorRepositoryCommit.php
	@@ -1,978 +1,978 @@
	<?php

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

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

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

	const IMPORTED_PERMANENT = 1024;
	const IMPORTED_UNREACHABLE = 2048;

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

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

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

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

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

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

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

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

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

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

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

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

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

	return $this;
	}

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

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

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

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

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

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

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

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

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

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

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

	return $this;
	}

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

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

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

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

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

	return $this;
	}

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

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

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

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

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

	$editor = new PhabricatorEdgeEditor();

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

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

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

	$editor->save();

	return $this;
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return null;
	}

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

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

	return null;
	}

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

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

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

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

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

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

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

	public function getCommitMessageForDisplay() {
	$data = $this->getCommitData();
	$message = $data->getCommitMessage();
	return $message;
	}

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

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

	$commit_display = $this->getMonogram();

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

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

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

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

	return DiffusionCommitRef::newFromDictionary($ref_record);
	}

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

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

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

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

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


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

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

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

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

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


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


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

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

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

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

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

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

	return $results;
	}

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

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


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


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

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

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

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

	return $remote_uri;
	}

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

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


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


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

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

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

	$branch = head($branches);

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

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


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


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

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

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

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


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


	public function isAutomaticallySubscribed($phid) {

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

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


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


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

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

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


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


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


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


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

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

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

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

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

	$author_epoch = $data->getAuthorEpoch();

	$audit_status = $this->getAuditStatusObject();

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

	public function getConduitSearchAttachments() {
	return array(
	id(new DiffusionAuditorsSearchEngineAttachment())
	->setAttachmentKey('auditors'),
	);
	}


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

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

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

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


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


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

	}

File Metadata

Mime Type: text/x-diff
Expires: Wed, Nov 26, 7:39 PM (18 h, 26 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 420170
Default Alt Text: (49 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions