No OneTemporary
Actions

Size

80 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/diffusion/controller/DiffusionRepositoryController.php b/src/applications/diffusion/controller/DiffusionRepositoryController.php
	index d1486d3f21..a8fc14f4d6 100644
	--- a/src/applications/diffusion/controller/DiffusionRepositoryController.php
	+++ b/src/applications/diffusion/controller/DiffusionRepositoryController.php
	@@ -1,613 +1,611 @@
	<?php

	final class DiffusionRepositoryController extends DiffusionController {

	public function shouldAllowPublic() {
	return true;
	}

	public function processRequest() {
	$drequest = $this->getDiffusionRequest();
	$repository = $drequest->getRepository();

	$content = array();

	$crumbs = $this->buildCrumbs();
	$content[] = $crumbs;

	$content[] = $this->buildPropertiesTable($drequest->getRepository());
	$phids = array();

	try {
	$history_results = $this->callConduitWithDiffusionRequest(
	'diffusion.historyquery',
	array(
	'commit' => $drequest->getCommit(),
	'path' => $drequest->getPath(),
	'offset' => 0,
	'limit' => 15));
	$history = DiffusionPathChange::newFromConduit(
	$history_results['pathChanges']);

	foreach ($history as $item) {
	$data = $item->getCommitData();
	if ($data) {
	if ($data->getCommitDetail('authorPHID')) {
	$phids[$data->getCommitDetail('authorPHID')] = true;
	}
	if ($data->getCommitDetail('committerPHID')) {
	$phids[$data->getCommitDetail('committerPHID')] = true;
	}
	}
	}
	$history_exception = null;
	} catch (Exception $ex) {
	$history_results = null;
	$history = null;
	$history_exception = $ex;
	}

	try {
	$browse_results = DiffusionBrowseResultSet::newFromConduit(
	$this->callConduitWithDiffusionRequest(
	'diffusion.browsequery',
	array(
	'path' => $drequest->getPath(),
	'commit' => $drequest->getCommit(),
	)));
	$browse_paths = $browse_results->getPaths();

	foreach ($browse_paths as $item) {
	$data = $item->getLastCommitData();
	if ($data) {
	if ($data->getCommitDetail('authorPHID')) {
	$phids[$data->getCommitDetail('authorPHID')] = true;
	}
	if ($data->getCommitDetail('committerPHID')) {
	$phids[$data->getCommitDetail('committerPHID')] = true;
	}
	}
	}

	$browse_exception = null;
	} catch (Exception $ex) {
	$browse_results = null;
	$browse_paths = null;
	$browse_exception = $ex;
	}

	$phids = array_keys($phids);
	$handles = $this->loadViewerHandles($phids);

	if ($browse_results) {
	$readme = $this->callConduitWithDiffusionRequest(
	'diffusion.readmequery',
	array(
	'paths' => $browse_results->getPathDicts()
	));
	} else {
	$readme = null;
	}

	$content[] = $this->buildHistoryTable(
	$history_results,
	$history,
	$history_exception,
	$handles);

	$content[] = $this->buildBrowseTable(
	$browse_results,
	$browse_paths,
	$browse_exception,
	$handles);

	try {
	$content[] = $this->buildTagListTable($drequest);
	} catch (Exception $ex) {
	if (!$repository->isImporting()) {
	$content[] = $this->renderStatusMessage(
	pht('Unable to Load Tags'),
	$ex->getMessage());
	}
	}

	try {
	$content[] = $this->buildBranchListTable($drequest);
	} catch (Exception $ex) {
	if (!$repository->isImporting()) {
	$content[] = $this->renderStatusMessage(
	pht('Unable to Load Branches'),
	$ex->getMessage());
	}
	}

	if ($readme) {
	$box = new PHUIBoxView();
	$box->appendChild($readme);
	$box->addPadding(PHUI::PADDING_LARGE);

	$panel = new PHUIObjectBoxView();
	$panel->setHeaderText(pht('README'));
	$panel->appendChild($box);
	$content[] = $panel;
	}

	return $this->buildApplicationPage(
	$content,
	array(
	'title' => $drequest->getRepository()->getName(),
	'device' => true,
	));
	}

	private function buildPropertiesTable(PhabricatorRepository $repository) {
	$user = $this->getRequest()->getUser();

	$header = id(new PHUIHeaderView())
	->setHeader($repository->getName())
	->setUser($user)
	->setPolicyObject($repository);

	if (!$repository->isTracked()) {
	$header->setStatus('policy-noone', '', pht('Inactive'));
	} else if ($repository->isImporting()) {
	$header->setStatus('time', 'red', pht('Importing...'));
	} else {
	$header->setStatus('oh-ok', '', pht('Active'));
	}


	$actions = $this->buildActionList($repository);

	$view = id(new PHUIPropertyListView())
	->setUser($user);
	$view->addProperty(pht('Callsign'), $repository->getCallsign());

	$project_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
	$repository->getPHID(),
	PhabricatorEdgeConfig::TYPE_OBJECT_HAS_PROJECT);
	if ($project_phids) {
	$this->loadHandles($project_phids);
	$view->addProperty(
	pht('Projects'),
	$this->renderHandlesForPHIDs($project_phids));
	}

	if ($repository->isHosted()) {
	$ssh_uri = $repository->getSSHCloneURIObject();
	if ($ssh_uri) {
	$clone_uri = $this->renderCloneCommand(
	$repository,
	$ssh_uri,
	$repository->getServeOverSSH(),
	'/settings/panel/ssh/');

	$view->addProperty(
	$repository->isSVN()
	? pht('Checkout (SSH)')
	: pht('Clone (SSH)'),
	$clone_uri);
	}

	$http_uri = $repository->getHTTPCloneURIObject();
	if ($http_uri) {
	$clone_uri = $this->renderCloneCommand(
	$repository,
	$http_uri,
	$repository->getServeOverHTTP(),
	PhabricatorEnv::getEnvConfig('diffusion.allow-http-auth')
	? '/settings/panel/vcspassword/'
	: null);

	$view->addProperty(
	$repository->isSVN()
	? pht('Checkout (HTTP)')
	: pht('Clone (HTTP)'),
	$clone_uri);
	}
	} else {
	switch ($repository->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	$view->addProperty(
	pht('Clone'),
	$this->renderCloneCommand(
	$repository,
	$repository->getPublicCloneURI()));
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	$view->addProperty(
	pht('Checkout'),
	$this->renderCloneCommand(
	$repository,
	$repository->getPublicCloneURI()));
	break;
	}
	}

	$description = $repository->getDetail('description');
	if (strlen($description)) {
	$description = PhabricatorMarkupEngine::renderOneObject(
	$repository,
	'description',
	$user);
	$view->addSectionHeader(pht('Description'));
	$view->addTextContent($description);
	}

	$view->setActionList($actions);

	return id(new PHUIObjectBoxView())
	->setHeader($header)
	->addPropertyList($view);

	}

	private function buildBranchListTable(DiffusionRequest $drequest) {
	$viewer = $this->getRequest()->getUser();

	if ($drequest->getBranch() === null) {
	return null;
	}

	$limit = 15;

	$branches = $this->callConduitWithDiffusionRequest(
	'diffusion.branchquery',
	array(
	'limit' => $limit + 1,
	));
	if (!$branches) {
	return null;
	}

	$more_branches = (count($branches) > $limit);
	$branches = array_slice($branches, 0, $limit);

	$branches = DiffusionRepositoryRef::loadAllFromDictionaries($branches);

	$commits = id(new DiffusionCommitQuery())
	->setViewer($viewer)
	->withIdentifiers(mpull($branches, 'getCommitIdentifier'))
	->withRepository($drequest->getRepository())
	->execute();

	$table = id(new DiffusionBranchTableView())
	->setUser($viewer)
	->setDiffusionRequest($drequest)
	->setBranches($branches)
	->setCommits($commits);

	$panel = new PHUIObjectBoxView();
	$header = new PHUIHeaderView();
	$header->setHeader(pht('Branches'));

	if ($more_branches) {
	$header->setSubHeader(pht('Showing %d branches.', $limit));
	}

	$icon = id(new PHUIIconView())
	->setSpriteSheet(PHUIIconView::SPRITE_ICONS)
	->setSpriteIcon('fork');

	$button = new PHUIButtonView();
	$button->setText(pht("Show All Branches"));
	$button->setTag('a');
	$button->setIcon($icon);
	$button->setHref($drequest->generateURI(
	array(
	'action' => 'branches',
	)));

	$header->addActionLink($button);
	$panel->setHeader($header);
	$panel->appendChild($table);

	return $panel;
	}

	private function buildTagListTable(DiffusionRequest $drequest) {
	$viewer = $this->getRequest()->getUser();

	$tag_limit = 15;
	$tags = array();
	try {
	$tags = DiffusionRepositoryTag::newFromConduit(
	$this->callConduitWithDiffusionRequest(
	'diffusion.tagsquery',
	array(
	// On the home page, we want to find tags on any branch.
	'commit' => null,
	'limit' => $tag_limit + 1,
	)));
	} catch (ConduitException $e) {
	if ($e->getMessage() != 'ERR-UNSUPPORTED-VCS') {
	throw $e;
	}
	}

	if (!$tags) {
	return null;
	}

	$more_tags = (count($tags) > $tag_limit);
	$tags = array_slice($tags, 0, $tag_limit);

	$commits = id(new DiffusionCommitQuery())
	->setViewer($viewer)
	->withIdentifiers(mpull($tags, 'getCommitIdentifier'))
	->withRepository($drequest->getRepository())
	->needCommitData(true)
	->execute();

	$view = id(new DiffusionTagListView())
	->setUser($viewer)
	->setDiffusionRequest($drequest)
	->setTags($tags)
	->setCommits($commits);

	$phids = $view->getRequiredHandlePHIDs();
	$handles = $this->loadViewerHandles($phids);
	$view->setHandles($handles);

	$panel = new PHUIObjectBoxView();
	$header = new PHUIHeaderView();
	$header->setHeader(pht('Tags'));

	if ($more_tags) {
	$header->setSubHeader(
	pht('Showing the %d most recent tags.', $tag_limit));
	}

	$icon = id(new PHUIIconView())
	->setSpriteSheet(PHUIIconView::SPRITE_ICONS)
	->setSpriteIcon('tag');

	$button = new PHUIButtonView();
	$button->setText(pht("Show All Tags"));
	$button->setTag('a');
	$button->setIcon($icon);
	$button->setHref($drequest->generateURI(
	array(
	'action' => 'tags',
	)));

	$header->addActionLink($button);

	$panel->setHeader($header);
	$panel->appendChild($view);

	return $panel;
	}

	private function buildActionList(PhabricatorRepository $repository) {
	$viewer = $this->getRequest()->getUser();

	$view_uri = $this->getApplicationURI($repository->getCallsign().'/');
	$edit_uri = $this->getApplicationURI($repository->getCallsign().'/edit/');

	$view = id(new PhabricatorActionListView())
	->setUser($viewer)
	->setObject($repository)
	->setObjectURI($view_uri);

	$can_edit = PhabricatorPolicyFilter::hasCapability(
	$viewer,
	$repository,
	PhabricatorPolicyCapability::CAN_EDIT);

	$view->addAction(
	id(new PhabricatorActionView())
	->setName(pht('Edit Repository'))
	->setIcon('edit')
	->setHref($edit_uri)
	->setWorkflow(!$can_edit)
	->setDisabled(!$can_edit));

	if ($repository->isHosted()) {
	$callsign = $repository->getCallsign();
	$push_uri = $this->getApplicationURI(
	'pushlog/?repositories=r'.$callsign);

	$view->addAction(
	id(new PhabricatorActionView())
	->setName(pht('View Push Logs'))
	->setIcon('transcript')
	->setHref($push_uri));
	}

	return $view;
	}

	private function buildHistoryTable(
	$history_results,
	$history,
	$history_exception,
	array $handles) {

	$request = $this->getRequest();
	$viewer = $request->getUser();
	$drequest = $this->getDiffusionRequest();
	$repository = $drequest->getRepository();

	if ($history_exception) {
	if ($repository->isImporting()) {
	return $this->renderStatusMessage(
	pht('Still Importing...'),
	pht(
	'This repository is still importing. History is not yet '.
	'available.'));
	} else {
	return $this->renderStatusMessage(
	pht('Unable to Retrieve History'),
	$history_exception->getMessage());
	}
	}

	$history_table = id(new DiffusionHistoryTableView())
	->setUser($viewer)
	->setDiffusionRequest($drequest)
	->setHandles($handles)
	->setHistory($history);

	// TODO: Super sketchy.
	$history_table->loadRevisions();

	if ($history_results) {
	$history_table->setParents($history_results['parents']);
	}

	$history_table->setIsHead(true);
	$callsign = $drequest->getRepository()->getCallsign();

	$icon = id(new PHUIIconView())
	->setSpriteSheet(PHUIIconView::SPRITE_ICONS)
	->setSpriteIcon('transcript');

	$button = id(new PHUIButtonView())
	->setText(pht('View Full History'))
	->setHref($drequest->generateURI(
	array(
	'action' => 'history',
	)))
	->setTag('a')
	->setIcon($icon);

	$panel = new PHUIObjectBoxView();
	$header = id(new PHUIHeaderView())
	->setHeader(pht('Recent Commits'))
	->addActionLink($button);
	$panel->setHeader($header);
	$panel->appendChild($history_table);

	return $panel;
	}

	private function buildBrowseTable(
	$browse_results,
	$browse_paths,
	$browse_exception,
	array $handles) {

	$request = $this->getRequest();
	$viewer = $request->getUser();
	$drequest = $this->getDiffusionRequest();
	$repository = $drequest->getRepository();

	if ($browse_exception) {
	if ($repository->isImporting()) {
	// The history table renders a useful message.
	return null;
	} else {
	return $this->renderStatusMessage(
	pht('Unable to Retrieve Paths'),
	$browse_exception->getMessage());
	}
	}

	$browse_table = id(new DiffusionBrowseTableView())
	->setUser($viewer)
	->setDiffusionRequest($drequest)
	->setHandles($handles);
	if ($browse_paths) {
	$browse_table->setPaths($browse_paths);
	} else {
	$browse_table->setPaths(array());
	}

	$browse_uri = $drequest->generateURI(array('action' => 'browse'));

	$browse_panel = new PHUIObjectBoxView();
	$header = id(new PHUIHeaderView())
	->setHeader(pht('Repository'));

	$icon = id(new PHUIIconView())
	->setSpriteSheet(PHUIIconView::SPRITE_ICONS)
	->setSpriteIcon('data');

	$button = new PHUIButtonView();
	$button->setText(pht('Browse Repository'));
	$button->setTag('a');
	$button->setIcon($icon);
	$button->setHref($browse_uri);

	$header->addActionLink($button);
	$browse_panel->setHeader($header);
	$browse_panel->appendChild($browse_table);

	return $browse_panel;
	}

	private function renderCloneCommand(
	PhabricatorRepository $repository,
	$uri,
	$serve_mode = null,
	$manage_uri = null) {

	require_celerity_resource('diffusion-icons-css');

	Javelin::initBehavior('select-on-click');

	switch ($repository->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	$command = csprintf(
	- 'git clone %s %s',
	- $uri,
	- $repository->getCloneName());
	+ 'git clone %s',
	+ $uri);
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	$command = csprintf(
	- 'hg clone %s %s',
	- $uri,
	- $repository->getCloneName());
	+ 'hg clone %s',
	+ $uri);
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	$command = csprintf(
	'svn checkout %s %s',
	$uri,
	$repository->getCloneName());
	break;
	}

	$input = javelin_tag(
	'input',
	array(
	'type' => 'text',
	'value' => (string)$command,
	'class' => 'diffusion-clone-uri',
	'sigil' => 'select-on-click',
	'readonly' => 'true',
	));

	$extras = array();
	if ($serve_mode) {
	if ($serve_mode === PhabricatorRepository::SERVE_READONLY) {
	$extras[] = pht('(Read Only)');
	}
	}

	if ($manage_uri) {
	if ($this->getRequest()->getUser()->isLoggedIn()) {
	$extras[] = phutil_tag(
	'a',
	array(
	'href' => $manage_uri,
	),
	pht('Manage Credentials'));
	}
	}

	if ($extras) {
	$extras = phutil_implode_html(' ', $extras);
	$extras = phutil_tag(
	'div',
	array(
	'class' => 'diffusion-clone-extras',
	),
	$extras);
	}

	return array($input, $extras);
	}

	}
	diff --git a/src/applications/diffusion/controller/DiffusionRepositoryDefaultController.php b/src/applications/diffusion/controller/DiffusionRepositoryDefaultController.php
	index e939d0e54b..f81c8f9bbe 100644
	--- a/src/applications/diffusion/controller/DiffusionRepositoryDefaultController.php
	+++ b/src/applications/diffusion/controller/DiffusionRepositoryDefaultController.php
	@@ -1,11 +1,17 @@
	<?php

	final class DiffusionRepositoryDefaultController extends DiffusionController {

	public function processRequest() {
	// NOTE: This controller is just here to make sure we call
	// willBeginExecution() on any /diffusion/X/ URI, so we can intercept
	// `git`, `hg` and `svn` HTTP protocol requests.
	- return new Aphront404Response();
	+
	+ // If we made it here, it's probably because the user copy-pasted a
	+ // clone URI with "/anything.git" at the end into their web browser.
	+ // Send them to the canonical repository URI.
	+
	+ return id(new AphrontRedirectResponse())
	+ ->setURI($this->getDiffusionRequest()->getRepository()->getURI());
	}
	}
	diff --git a/src/applications/diffusion/controller/DiffusionServeController.php b/src/applications/diffusion/controller/DiffusionServeController.php
	index ea5a8c8a68..9cd7b2aee0 100644
	--- a/src/applications/diffusion/controller/DiffusionServeController.php
	+++ b/src/applications/diffusion/controller/DiffusionServeController.php
	@@ -1,568 +1,592 @@
	<?php

	final class DiffusionServeController extends DiffusionController {

	public static function isVCSRequest(AphrontRequest $request) {
	if (!self::getCallsign($request)) {
	return null;
	}

	$content_type = $request->getHTTPHeader('Content-Type');
	$user_agent = idx($_SERVER, 'HTTP_USER_AGENT');

	$vcs = null;
	if ($request->getExists('service')) {
	$service = $request->getStr('service');
	// We get this initially for `info/refs`.
	// Git also gives us a User-Agent like "git/1.8.2.3".
	$vcs = PhabricatorRepositoryType::REPOSITORY_TYPE_GIT;
	} else if (strncmp($user_agent, "git/", 4) === 0) {
	$vcs = PhabricatorRepositoryType::REPOSITORY_TYPE_GIT;
	} else if ($content_type == 'application/x-git-upload-pack-request') {
	// We get this for `git-upload-pack`.
	$vcs = PhabricatorRepositoryType::REPOSITORY_TYPE_GIT;
	} else if ($content_type == 'application/x-git-receive-pack-request') {
	// We get this for `git-receive-pack`.
	$vcs = PhabricatorRepositoryType::REPOSITORY_TYPE_GIT;
	} else if ($request->getExists('cmd')) {
	// Mercurial also sends an Accept header like
	// "application/mercurial-0.1", and a User-Agent like
	// "mercurial/proto-1.0".
	$vcs = PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL;
	} else {
	// Subversion also sends an initial OPTIONS request (vs GET/POST), and
	// has a User-Agent like "SVN/1.8.3 (x86_64-apple-darwin11.4.2)
	// serf/1.3.2".
	$dav = $request->getHTTPHeader('DAV');
	$dav = new PhutilURI($dav);
	if ($dav->getDomain() === 'subversion.tigris.org') {
	$vcs = PhabricatorRepositoryType::REPOSITORY_TYPE_SVN;
	}
	}

	return $vcs;
	}

	private static function getCallsign(AphrontRequest $request) {
	$uri = $request->getRequestURI();

	$regex = '@^/diffusion/(?P<callsign>[A-Z]+)(/\|$)@';
	$matches = null;
	if (!preg_match($regex, (string)$uri, $matches)) {
	return null;
	}
	+
	return $matches['callsign'];
	}

	public function processRequest() {
	$request = $this->getRequest();
	$callsign = self::getCallsign($request);

	// If authentication credentials have been provided, try to find a user
	// that actually matches those credentials.
	if (isset($_SERVER['PHP_AUTH_USER']) && isset($_SERVER['PHP_AUTH_PW'])) {
	$username = $_SERVER['PHP_AUTH_USER'];
	$password = new PhutilOpaqueEnvelope($_SERVER['PHP_AUTH_PW']);

	$viewer = $this->authenticateHTTPRepositoryUser($username, $password);
	if (!$viewer) {
	return new PhabricatorVCSResponse(
	403,
	pht('Invalid credentials.'));
	}
	} else {
	// User hasn't provided credentials, which means we count them as
	// being "not logged in".
	$viewer = new PhabricatorUser();
	}

	$allow_public = PhabricatorEnv::getEnvConfig('policy.allow-public');
	$allow_auth = PhabricatorEnv::getEnvConfig('diffusion.allow-http-auth');
	if (!$allow_public) {
	if (!$viewer->isLoggedIn()) {
	if ($allow_auth) {
	return new PhabricatorVCSResponse(
	401,
	pht('You must log in to access repositories.'));
	} else {
	return new PhabricatorVCSResponse(
	403,
	pht('Public and authenticated HTTP access are both forbidden.'));
	}
	}
	}

	try {
	$repository = id(new PhabricatorRepositoryQuery())
	->setViewer($viewer)
	->withCallsigns(array($callsign))
	->executeOne();
	if (!$repository) {
	return new PhabricatorVCSResponse(
	404,
	pht('No such repository exists.'));
	}
	} catch (PhabricatorPolicyException $ex) {
	if ($viewer->isLoggedIn()) {
	return new PhabricatorVCSResponse(
	403,
	pht('You do not have permission to access this repository.'));
	} else {
	if ($allow_auth) {
	return new PhabricatorVCSResponse(
	401,
	pht('You must log in to access this repository.'));
	} else {
	return new PhabricatorVCSResponse(
	403,
	pht(
	'This repository requires authentication, which is forbidden '.
	'over HTTP.'));
	}
	}
	}

	if (!$repository->isTracked()) {
	return new PhabricatorVCSResponse(
	403,
	pht('This repository is inactive.'));
	}

	$is_push = !$this->isReadOnlyRequest($repository);

	switch ($repository->getServeOverHTTP()) {
	case PhabricatorRepository::SERVE_READONLY:
	if ($is_push) {
	return new PhabricatorVCSResponse(
	403,
	pht('This repository is read-only over HTTP.'));
	}
	break;
	case PhabricatorRepository::SERVE_READWRITE:
	if ($is_push) {
	$can_push = PhabricatorPolicyFilter::hasCapability(
	$viewer,
	$repository,
	DiffusionCapabilityPush::CAPABILITY);
	if (!$can_push) {
	if ($viewer->isLoggedIn()) {
	return new PhabricatorVCSResponse(
	403,
	pht('You do not have permission to push to this repository.'));
	} else {
	if ($allow_auth) {
	return new PhabricatorVCSResponse(
	401,
	pht('You must log in to push to this repository.'));
	} else {
	return new PhabricatorVCSResponse(
	403,
	pht(
	'Pushing to this repository requires authentication, '.
	'which is forbidden over HTTP.'));
	}
	}
	}
	}
	break;
	case PhabricatorRepository::SERVE_OFF:
	default:
	return new PhabricatorVCSResponse(
	403,
	pht('This repository is not available over HTTP.'));
	}

	$vcs_type = $repository->getVersionControlSystem();
	$req_type = $this->isVCSRequest($request);

	if ($vcs_type != $req_type) {
	switch ($req_type) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	$result = new PhabricatorVCSResponse(
	500,
	pht('This is not a Git repository.'));
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	$result = new PhabricatorVCSResponse(
	500,
	pht('This is not a Mercurial repository.'));
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	$result = new PhabricatorVCSResponse(
	500,
	pht('This is not a Subversion repository.'));
	break;
	default:
	$result = new PhabricatorVCSResponse(
	500,
	pht('Unknown request type.'));
	break;
	}
	} else {
	switch ($vcs_type) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	$result = $this->serveGitRequest($repository, $viewer);
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	$result = $this->serveMercurialRequest($repository, $viewer);
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	$result = new PhabricatorVCSResponse(
	500,
	pht(
	'Phabricator does not support HTTP access to Subversion '.
	'repositories.'));
	break;
	default:
	$result = new PhabricatorVCSResponse(
	500,
	pht('Unknown version control system.'));
	break;
	}
	}

	$code = $result->getHTTPResponseCode();

	if ($is_push && ($code == 200)) {
	$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
	$repository->writeStatusMessage(
	PhabricatorRepositoryStatusMessage::TYPE_NEEDS_UPDATE,
	PhabricatorRepositoryStatusMessage::CODE_OKAY);
	unset($unguarded);
	}

	return $result;
	}

	private function isReadOnlyRequest(
	PhabricatorRepository $repository) {
	$request = $this->getRequest();
	$method = $_SERVER['REQUEST_METHOD'];

	// TODO: This implementation is safe by default, but very incomplete.

	switch ($repository->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	$service = $request->getStr('service');
	- $path = $this->getRequestDirectoryPath();
	+ $path = $this->getRequestDirectoryPath($repository);
	// NOTE: Service names are the reverse of what you might expect, as they
	// are from the point of view of the server. The main read service is
	// "git-upload-pack", and the main write service is "git-receive-pack".

	if ($method == 'GET' &&
	$path == '/info/refs' &&
	$service == 'git-upload-pack') {
	return true;
	}

	if ($path == '/git-upload-pack') {
	return true;
	}

	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	$cmd = $request->getStr('cmd');
	if ($cmd == 'batch') {
	$cmds = idx($this->getMercurialArguments(), 'cmds');
	return DiffusionMercurialWireProtocol::isReadOnlyBatchCommand($cmds);
	}
	return DiffusionMercurialWireProtocol::isReadOnlyCommand($cmd);
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	break;
	}

	return false;
	}

	/**
	* @phutil-external-symbol class PhabricatorStartup
	*/
	private function serveGitRequest(
	PhabricatorRepository $repository,
	PhabricatorUser $viewer) {
	$request = $this->getRequest();

	- $request_path = $this->getRequestDirectoryPath();
	+ $request_path = $this->getRequestDirectoryPath($repository);
	$repository_root = $repository->getLocalPath();

	// Rebuild the query string to strip `__magic__` parameters and prevent
	// issues where we might interpret inputs like "service=read&service=write"
	// differently than the server does and pass it an unsafe command.

	// NOTE: This does not use getPassthroughRequestParameters() because
	// that code is HTTP-method agnostic and will encode POST data.

	$query_data = $_GET;
	foreach ($query_data as $key => $value) {
	if (!strncmp($key, '__', 2)) {
	unset($query_data[$key]);
	}
	}
	$query_string = http_build_query($query_data, '', '&');

	// We're about to wipe out PATH with the rest of the environment, so
	// resolve the binary first.
	$bin = Filesystem::resolveBinary('git-http-backend');
	if (!$bin) {
	throw new Exception("Unable to find `git-http-backend` in PATH!");
	}

	$env = array(
	'REQUEST_METHOD' => $_SERVER['REQUEST_METHOD'],
	'QUERY_STRING' => $query_string,
	'CONTENT_TYPE' => $request->getHTTPHeader('Content-Type'),
	'HTTP_CONTENT_ENCODING' => $request->getHTTPHeader('Content-Encoding'),
	'REMOTE_ADDR' => $_SERVER['REMOTE_ADDR'],
	'GIT_PROJECT_ROOT' => $repository_root,
	'GIT_HTTP_EXPORT_ALL' => '1',
	'PATH_INFO' => $request_path,

	'REMOTE_USER' => $viewer->getUsername(),

	// TODO: Set these correctly.
	// GIT_COMMITTER_NAME
	// GIT_COMMITTER_EMAIL
	) + $this->getCommonEnvironment($viewer);

	$input = PhabricatorStartup::getRawInput();

	$command = csprintf('%s', $bin);
	$command = PhabricatorDaemon::sudoCommandAsDaemonUser($command);

	list($err, $stdout, $stderr) = id(new ExecFuture('%C', $command))
	->setEnv($env, true)
	->write($input)
	->resolve();

	if ($err) {
	if ($this->isValidGitShallowCloneResponse($stdout, $stderr)) {
	// Ignore the error if the response passes this special check for
	// validity.
	$err = 0;
	}
	}

	if ($err) {
	return new PhabricatorVCSResponse(
	500,
	pht('Error %d: %s', $err, $stderr));
	}

	return id(new DiffusionGitResponse())->setGitData($stdout);
	}

	- private function getRequestDirectoryPath() {
	+ private function getRequestDirectoryPath(PhabricatorRepository $repository) {
	$request = $this->getRequest();
	$request_path = $request->getRequestURI()->getPath();
	- return preg_replace('@^/diffusion/[A-Z]+@', '', $request_path);
	+ $base_path = preg_replace('@^/diffusion/[A-Z]+@', '', $request_path);
	+
	+ // For Git repositories, strip an optional directory component if it
	+ // isn't the name of a known Git resource. This allows users to clone
	+ // repositories as "/diffusion/X/anything.git", for example.
	+ if ($repository->isGit()) {
	+ $known = array(
	+ 'info',
	+ 'git-upload-pack',
	+ 'git-receive-pack',
	+ );
	+
	+ foreach ($known as $key => $path) {
	+ $known[$key] = preg_quote($path, '@');
	+ }
	+
	+ $known = implode('\|', $known);
	+
	+ if (preg_match('@^/([^/]+)/('.$known.')(/\|$)@', $base_path)) {
	+ $base_path = preg_replace('@^/([^/]+)@', '', $base_path);
	+ }
	+ }
	+
	+ return $base_path;
	}

	private function authenticateHTTPRepositoryUser(
	$username,
	PhutilOpaqueEnvelope $password) {

	if (!PhabricatorEnv::getEnvConfig('diffusion.allow-http-auth')) {
	// No HTTP auth permitted.
	return null;
	}

	if (!strlen($username)) {
	// No username.
	return null;
	}

	if (!strlen($password->openEnvelope())) {
	// No password.
	return null;
	}

	$user = id(new PhabricatorPeopleQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withUsernames(array($username))
	->executeOne();
	if (!$user) {
	// Username doesn't match anything.
	return null;
	}

	if (!$user->isUserActivated()) {
	// User is not activated.
	return null;
	}

	$password_entry = id(new PhabricatorRepositoryVCSPassword())
	->loadOneWhere('userPHID = %s', $user->getPHID());
	if (!$password_entry) {
	// User doesn't have a password set.
	return null;
	}

	if (!$password_entry->comparePassword($password, $user)) {
	// Password doesn't match.
	return null;
	}

	return $user;
	}

	private function serveMercurialRequest(
	PhabricatorRepository $repository,
	PhabricatorUser $viewer) {
	$request = $this->getRequest();

	$bin = Filesystem::resolveBinary('hg');
	if (!$bin) {
	throw new Exception("Unable to find `hg` in PATH!");
	}

	$env = $this->getCommonEnvironment($viewer);
	$input = PhabricatorStartup::getRawInput();

	$cmd = $request->getStr('cmd');

	$args = $this->getMercurialArguments();
	$args = $this->formatMercurialArguments($cmd, $args);

	if (strlen($input)) {
	$input = strlen($input)."\n".$input."0\n";
	}

	$command = csprintf('%s serve --stdio', $bin);
	$command = PhabricatorDaemon::sudoCommandAsDaemonUser($command);

	list($err, $stdout, $stderr) = id(new ExecFuture('%C', $command))
	->setEnv($env, true)
	->setCWD($repository->getLocalPath())
	->write("{$cmd}\n{$args}{$input}")
	->resolve();

	if ($err) {
	return new PhabricatorVCSResponse(
	500,
	pht('Error %d: %s', $err, $stderr));
	}

	if ($cmd == 'getbundle' \|\|
	$cmd == 'changegroup' \|\|
	$cmd == 'changegroupsubset') {
	// We're not completely sure that "changegroup" and "changegroupsubset"
	// actually work, they're for very old Mercurial.
	$body = gzcompress($stdout);
	} else if ($cmd == 'unbundle') {
	// This includes diagnostic information and anything echoed by commit
	// hooks. We ignore `stdout` since it just has protocol garbage, and
	// substitute `stderr`.
	$body = strlen($stderr)."\n".$stderr;
	} else {
	list($length, $body) = explode("\n", $stdout, 2);
	}

	return id(new DiffusionMercurialResponse())->setContent($body);
	}


	private function getMercurialArguments() {
	// Mercurial sends arguments in HTTP headers. "Why?", you might wonder,
	// "Why would you do this?".

	$args_raw = array();
	for ($ii = 1; ; $ii++) {
	$header = 'HTTP_X_HGARG_'.$ii;
	if (!array_key_exists($header, $_SERVER)) {
	break;
	}
	$args_raw[] = $_SERVER[$header];
	}
	$args_raw = implode('', $args_raw);

	return id(new PhutilQueryStringParser())
	->parseQueryString($args_raw);
	}

	private function formatMercurialArguments($command, array $arguments) {
	$spec = DiffusionMercurialWireProtocol::getCommandArgs($command);

	$out = array();

	// Mercurial takes normal arguments like this:
	//
	// name <length(value)>
	// value

	$has_star = false;
	foreach ($spec as $arg_key) {
	if ($arg_key == '*') {
	$has_star = true;
	continue;
	}
	if (isset($arguments[$arg_key])) {
	$value = $arguments[$arg_key];
	$size = strlen($value);
	$out[] = "{$arg_key} {$size}\n{$value}";
	unset($arguments[$arg_key]);
	}
	}

	if ($has_star) {

	// Mercurial takes arguments for variable argument lists roughly like
	// this:
	//
	// * <count(args)>
	// argname1 <length(argvalue1)>
	// argvalue1
	// argname2 <length(argvalue2)>
	// argvalue2

	$count = count($arguments);

	$out[] = "* {$count}\n";

	foreach ($arguments as $key => $value) {
	if (in_array($key, $spec)) {
	// We already added this argument above, so skip it.
	continue;
	}
	$size = strlen($value);
	$out[] = "{$key} {$size}\n{$value}";
	}
	}

	return implode('', $out);
	}

	private function isValidGitShallowCloneResponse($stdout, $stderr) {
	// If you execute `git clone --depth N ...`, git sends a request which
	// `git-http-backend` responds to by emitting valid output and then exiting
	// with a failure code and an error message. If we ignore this error,
	// everything works.

	// This is a pretty funky fix: it would be nice to more precisely detect
	// that a request is a `--depth N` clone request, but we don't have any code
	// to decode protocol frames yet. Instead, look for reasonable evidence
	// in the error and output that we're looking at a `--depth` clone.

	// For evidence this isn't completely crazy, see:
	// https://github.com/schacon/grack/pull/7

	$stdout_regexp = '(^Content-Type: application/x-git-upload-pack-result)m';
	$stderr_regexp = '(The remote end hung up unexpectedly)';

	$has_pack = preg_match($stdout_regexp, $stdout);
	$is_hangup = preg_match($stderr_regexp, $stderr);

	return $has_pack && $is_hangup;
	}

	private function getCommonEnvironment(PhabricatorUser $viewer) {
	$remote_addr = $this->getRequest()->getRemoteAddr();

	return array(
	DiffusionCommitHookEngine::ENV_USER => $viewer->getUsername(),
	DiffusionCommitHookEngine::ENV_REMOTE_ADDRESS => $remote_addr,
	DiffusionCommitHookEngine::ENV_REMOTE_PROTOCOL => 'http',
	);
	}

	}

	diff --git a/src/applications/repository/data/PhabricatorRepositoryURINormalizer.php b/src/applications/repository/data/PhabricatorRepositoryURINormalizer.php
	index 403f5e4f38..bcfd6b061c 100644
	--- a/src/applications/repository/data/PhabricatorRepositoryURINormalizer.php
	+++ b/src/applications/repository/data/PhabricatorRepositoryURINormalizer.php
	@@ -1,114 +1,123 @@
	<?php

	/**
	* Normalize repository URIs. For example, these URIs are generally equivalent
	* and all point at the same repository:
	*
	* ssh://user@host/repo
	* ssh://user@host/repo/
	* ssh://user@host:22/repo
	* user@host:/repo
	* ssh://user@host/repo.git
	*
	* This class can be used to normalize URIs like this, in order to detect
	* alternate spellings of the same repository URI. In particular, the
	* @{method:getNormalizedPath} method will return:
	*
	* repo
	*
	* ...for all of these URIs. Generally, usage looks like this:
	*
	* $norm_a = new PhabricatorRepositoryURINormalizer($type, $uri_a);
	* $norm_b = new PhabricatorRepositoryURINormalizer($type, $uri_b);
	*
	* if ($norm_a->getNormalizedPath() == $norm_b->getNormalizedPath()) {
	* // URIs appear to point at the same repository.
	* } else {
	* // URIs are very unlikely to be the same repository.
	* }
	*
	* Because a repository can be hosted at arbitrarly many arbitrary URIs, there
	* is no way to completely prevent false negatives by only examining URIs
	* (that is, repositories with totally different URIs could really be the same).
	* However, normalization is relatively agressive and false negatives should
	* be rare: if normalization says two URIs are different repositories, they
	* probably are.
	*
	* @task normal Normalizing URIs
	*/
	final class PhabricatorRepositoryURINormalizer extends Phobject {

	const TYPE_GIT = 'git';
	const TYPE_SVN = 'svn';
	const TYPE_MERCURIAL = 'hg';

	private $type;
	private $uri;

	public function __construct($type, $uri) {
	switch ($type) {
	case self::TYPE_GIT:
	case self::TYPE_SVN:
	case self::TYPE_MERCURIAL:
	break;
	default:
	throw new Exception(pht('Unknown URI type "%s"!'));
	}

	$this->type = $type;
	$this->uri = $uri;
	}


	/* -( Normalizing URIs )--------------------------------------------------- */


	/**
	* @task normal
	*/
	public function getPath() {
	switch ($this->type) {
	case self::TYPE_GIT:
	$uri = new PhutilURI($this->uri);
	if ($uri->getProtocol()) {
	return $uri->getPath();
	}

	$uri = new PhutilGitURI($this->uri);
	if ($uri->getDomain()) {
	return $uri->getPath();
	}

	return $this->uri;
	case self::TYPE_SVN:
	case self::TYPE_MERCURIAL:
	$uri = new PhutilURI($this->uri);
	if ($uri->getProtocol()) {
	return $uri->getPath();
	}

	return $this->uri;
	}
	}


	/**
	* @task normal
	*/
	public function getNormalizedPath() {
	$path = $this->getPath();
	$path = trim($path, '/');

	switch ($this->type) {
	case self::TYPE_GIT:
	$path = preg_replace('/\.git$/', '', $path);
	break;
	case self::TYPE_SVN:
	case self::TYPE_MERCURIAL:
	break;
	}

	+ // If this is a Phabricator URI, strip it down to the callsign. We mutably
	+ // allow you to clone repositories as "/diffusion/X/anything.git", for
	+ // example.
	+
	+ $matches = null;
	+ if (preg_match('@^(diffusion/[A-Z]+)@', $path, $matches)) {
	+ $path = $matches[1];
	+ }
	+
	return $path;
	}

	}
	diff --git a/src/applications/repository/data/__tests__/PhabricatorRepositoryURINormalizerTestCase.php b/src/applications/repository/data/__tests__/PhabricatorRepositoryURINormalizerTestCase.php
	index d69d98bb54..81dd735562 100644
	--- a/src/applications/repository/data/__tests__/PhabricatorRepositoryURINormalizerTestCase.php
	+++ b/src/applications/repository/data/__tests__/PhabricatorRepositoryURINormalizerTestCase.php
	@@ -1,49 +1,51 @@
	<?php

	final class PhabricatorRepositoryURINormalizerTestCase
	extends PhabricatorTestCase {

	public function testGitURINormalizer() {
	$cases = array(
	'ssh://user@domain.com/path.git' => 'path',
	'https://user@domain.com/path.git' => 'path',
	'git@domain.com:path.git' => 'path',
	'ssh://user@gitserv002.com/path.git' => 'path',
	'ssh://htaft@domain.com/path.git' => 'path',
	'ssh://user@domain.com/bananas.git' => 'bananas',
	'git@domain.com:bananas.git' => 'bananas',
	'user@domain.com:path/repo' => 'path/repo',
	'user@domain.com:path/repo/' => 'path/repo',
	'file:///path/to/local/repo.git' => 'path/to/local/repo',
	'/path/to/local/repo.git' => 'path/to/local/repo',
	+ 'ssh://something.com/diffusion/X/anything.git' => 'diffusion/X',
	+ 'ssh://something.com/diffusion/X/' => 'diffusion/X',
	);

	$type_git = PhabricatorRepositoryURINormalizer::TYPE_GIT;

	foreach ($cases as $input => $expect) {
	$normal = new PhabricatorRepositoryURINormalizer($type_git, $input);
	$this->assertEqual(
	$expect,
	$normal->getNormalizedPath(),
	pht('Normalized Git path for "%s".', $input));
	}
	}

	public function testSVNURINormalizer() {
	$cases = array(
	'file:///path/to/repo' => 'path/to/repo',
	'file:///path/to/repo/' => 'path/to/repo',
	);

	$type_svn = PhabricatorRepositoryURINormalizer::TYPE_SVN;

	foreach ($cases as $input => $expect) {
	$normal = new PhabricatorRepositoryURINormalizer($type_svn, $input);
	$this->assertEqual(
	$expect,
	$normal->getNormalizedPath(),
	pht('Normalized SVN path for "%s".', $input));
	}
	}

	}
	diff --git a/src/applications/repository/storage/PhabricatorRepository.php b/src/applications/repository/storage/PhabricatorRepository.php
	index dd70348b82..be8a0d25e8 100644
	--- a/src/applications/repository/storage/PhabricatorRepository.php
	+++ b/src/applications/repository/storage/PhabricatorRepository.php
	@@ -1,1283 +1,1295 @@
	<?php

	/**
	* @task uri Repository URI Management
	*/
	final class PhabricatorRepository extends PhabricatorRepositoryDAO
	implements
	PhabricatorPolicyInterface,
	PhabricatorFlaggableInterface,
	PhabricatorMarkupInterface {

	/**
	* Shortest hash we'll recognize in raw "a829f32" form.
	*/
	const MINIMUM_UNQUALIFIED_HASH = 7;

	/**
	* Shortest hash we'll recognize in qualified "rXab7ef2f8" form.
	*/
	const MINIMUM_QUALIFIED_HASH = 5;

	const TABLE_PATH = 'repository_path';
	const TABLE_PATHCHANGE = 'repository_pathchange';
	const TABLE_FILESYSTEM = 'repository_filesystem';
	const TABLE_SUMMARY = 'repository_summary';
	const TABLE_BADCOMMIT = 'repository_badcommit';
	const TABLE_LINTMESSAGE = 'repository_lintmessage';

	const SERVE_OFF = 'off';
	const SERVE_READONLY = 'readonly';
	const SERVE_READWRITE = 'readwrite';

	protected $name;
	protected $callsign;
	protected $uuid;
	protected $viewPolicy;
	protected $editPolicy;
	protected $pushPolicy;

	protected $versionControlSystem;
	protected $details = array();
	protected $credentialPHID;

	private $commitCount = self::ATTACHABLE;
	private $mostRecentCommit = self::ATTACHABLE;
	private $projectPHIDs = self::ATTACHABLE;

	public static function initializeNewRepository(PhabricatorUser $actor) {
	$app = id(new PhabricatorApplicationQuery())
	->setViewer($actor)
	->withClasses(array('PhabricatorApplicationDiffusion'))
	->executeOne();

	$view_policy = $app->getPolicy(DiffusionCapabilityDefaultView::CAPABILITY);
	$edit_policy = $app->getPolicy(DiffusionCapabilityDefaultEdit::CAPABILITY);
	$push_policy = $app->getPolicy(DiffusionCapabilityDefaultPush::CAPABILITY);

	return id(new PhabricatorRepository())
	->setViewPolicy($view_policy)
	->setEditPolicy($edit_policy)
	->setPushPolicy($push_policy);
	}

	public function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_SERIALIZATION => array(
	'details' => self::SERIALIZATION_JSON,
	),
	) + parent::getConfiguration();
	}

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

	public function toDictionary() {
	return array(
	'id' => $this->getID(),
	'name' => $this->getName(),
	'phid' => $this->getPHID(),
	'callsign' => $this->getCallsign(),
	'monogram' => $this->getMonogram(),
	'vcs' => $this->getVersionControlSystem(),
	'uri' => PhabricatorEnv::getProductionURI($this->getURI()),
	'remoteURI' => (string)$this->getRemoteURI(),
	'description' => $this->getDetail('description'),
	'isActive' => $this->isTracked(),
	'isHosted' => $this->isHosted(),
	'isImporting' => $this->isImporting(),
	);
	}

	public function getMonogram() {
	return 'r'.$this->getCallsign();
	}

	public function getDetail($key, $default = null) {
	return idx($this->details, $key, $default);
	}

	public function getHumanReadableDetail($key, $default = null) {
	$value = $this->getDetail($key, $default);

	switch ($key) {
	case 'branch-filter':
	case 'close-commits-filter':
	$value = array_keys($value);
	$value = implode(', ', $value);
	break;
	}

	return $value;
	}

	public function setDetail($key, $value) {
	$this->details[$key] = $value;
	return $this;
	}

	public function attachCommitCount($count) {
	$this->commitCount = $count;
	return $this;
	}

	public function getCommitCount() {
	return $this->assertAttached($this->commitCount);
	}

	public function attachMostRecentCommit(
	PhabricatorRepositoryCommit $commit = null) {
	$this->mostRecentCommit = $commit;
	return $this;
	}

	public function getMostRecentCommit() {
	return $this->assertAttached($this->mostRecentCommit);
	}

	public function getDiffusionBrowseURIForPath(
	PhabricatorUser $user,
	$path,
	$line = null,
	$branch = null) {

	$drequest = DiffusionRequest::newFromDictionary(
	array(
	'user' => $user,
	'repository' => $this,
	'path' => $path,
	'branch' => $branch,
	));

	return $drequest->generateURI(
	array(
	'action' => 'browse',
	'line' => $line,
	));
	}

	public function getLocalPath() {
	return $this->getDetail('local-path');
	}

	public function getSubversionBaseURI($commit = null) {
	$subpath = $this->getDetail('svn-subpath');
	if (!strlen($subpath)) {
	$subpath = null;
	}
	return $this->getSubversionPathURI($subpath, $commit);
	}

	public function getSubversionPathURI($path = null, $commit = null) {
	$vcs = $this->getVersionControlSystem();
	if ($vcs != PhabricatorRepositoryType::REPOSITORY_TYPE_SVN) {
	throw new Exception("Not a subversion repository!");
	}

	if ($this->isHosted()) {
	$uri = 'file://'.$this->getLocalPath();
	} else {
	$uri = $this->getDetail('remote-uri');
	}

	$uri = rtrim($uri, '/');

	if (strlen($path)) {
	$path = rawurlencode($path);
	$path = str_replace('%2F', '/', $path);
	$uri = $uri.'/'.ltrim($path, '/');
	}

	if ($path !== null \|\| $commit !== null) {
	$uri .= '@';
	}

	if ($commit !== null) {
	$uri .= $commit;
	}

	return $uri;
	}

	public function attachProjectPHIDs(array $project_phids) {
	$this->projectPHIDs = $project_phids;
	return $this;
	}

	public function getProjectPHIDs() {
	return $this->assertAttached($this->projectPHIDs);
	}


	/**
	* Get the name of the directory this repository should clone or checkout
	* into. For example, if the repository name is "Example Repository", a
	* reasonable name might be "example-repository". This is used to help users
	* get reasonable results when cloning repositories, since they generally do
	* not want to clone into directories called "X/" or "Example Repository/".
	*
	* @return string
	*/
	public function getCloneName() {
	$name = $this->getDetail('clone-name');

	// Make some reasonable effort to produce reasonable default directory
	// names from repository names.
	if (!strlen($name)) {
	$name = $this->getName();
	$name = phutil_utf8_strtolower($name);
	$name = preg_replace('@[/ -:]+@', '-', $name);
	$name = trim($name, '-');
	if (!strlen($name)) {
	$name = $this->getCallsign();
	}
	}

	return $name;
	}


	/* -( Remote Command Execution )------------------------------------------- */


	public function execRemoteCommand($pattern /* , $arg, ... */) {
	$args = func_get_args();
	return $this->newRemoteCommandFuture($args)->resolve();
	}

	public function execxRemoteCommand($pattern /* , $arg, ... */) {
	$args = func_get_args();
	return $this->newRemoteCommandFuture($args)->resolvex();
	}

	public function getRemoteCommandFuture($pattern /* , $arg, ... */) {
	$args = func_get_args();
	return $this->newRemoteCommandFuture($args);
	}

	public function passthruRemoteCommand($pattern /* , $arg, ... */) {
	$args = func_get_args();
	return $this->newRemoteCommandPassthru($args)->execute();
	}

	private function newRemoteCommandFuture(array $argv) {
	$argv = $this->formatRemoteCommand($argv);
	$future = newv('ExecFuture', $argv);
	$future->setEnv($this->getRemoteCommandEnvironment());
	return $future;
	}

	private function newRemoteCommandPassthru(array $argv) {
	$argv = $this->formatRemoteCommand($argv);
	$passthru = newv('PhutilExecPassthru', $argv);
	$passthru->setEnv($this->getRemoteCommandEnvironment());
	return $passthru;
	}


	/* -( Local Command Execution )-------------------------------------------- */


	public function execLocalCommand($pattern /* , $arg, ... */) {
	$args = func_get_args();
	return $this->newLocalCommandFuture($args)->resolve();
	}

	public function execxLocalCommand($pattern /* , $arg, ... */) {
	$args = func_get_args();
	return $this->newLocalCommandFuture($args)->resolvex();
	}

	public function getLocalCommandFuture($pattern /* , $arg, ... */) {
	$args = func_get_args();
	return $this->newLocalCommandFuture($args);
	}

	public function passthruLocalCommand($pattern /* , $arg, ... */) {
	$args = func_get_args();
	return $this->newLocalCommandPassthru($args)->execute();
	}

	private function newLocalCommandFuture(array $argv) {
	$this->assertLocalExists();

	$argv = $this->formatLocalCommand($argv);
	$future = newv('ExecFuture', $argv);
	$future->setEnv($this->getLocalCommandEnvironment());

	if ($this->usesLocalWorkingCopy()) {
	$future->setCWD($this->getLocalPath());
	}

	return $future;
	}

	private function newLocalCommandPassthru(array $argv) {
	$this->assertLocalExists();

	$argv = $this->formatLocalCommand($argv);
	$future = newv('PhutilExecPassthru', $argv);
	$future->setEnv($this->getLocalCommandEnvironment());

	if ($this->usesLocalWorkingCopy()) {
	$future->setCWD($this->getLocalPath());
	}

	return $future;
	}


	/* -( Command Infrastructure )--------------------------------------------- */


	private function getSSHWrapper() {
	$root = dirname(phutil_get_library_root('phabricator'));
	return $root.'/bin/ssh-connect';
	}

	private function getCommonCommandEnvironment() {
	$env = array(
	// NOTE: Force the language to "en_US.UTF-8", which overrides locale
	// settings. This makes stuff print in English instead of, e.g., French,
	// so we can parse the output of some commands, error messages, etc.
	'LANG' => 'en_US.UTF-8',

	// Propagate PHABRICATOR_ENV explicitly. For discussion, see T4155.
	'PHABRICATOR_ENV' => PhabricatorEnv::getSelectedEnvironmentName(),
	);

	switch ($this->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	// NOTE: See T2965. Some time after Git 1.7.5.4, Git started fataling if
	// it can not read $HOME. For many users, $HOME points at /root (this
	// seems to be a default result of Apache setup). Instead, explicitly
	// point $HOME at a readable, empty directory so that Git looks for the
	// config file it's after, fails to locate it, and moves on. This is
	// really silly, but seems like the least damaging approach to
	// mitigating the issue.

	$root = dirname(phutil_get_library_root('phabricator'));
	$env['HOME'] = $root.'/support/empty/';
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	// NOTE: This overrides certain configuration, extensions, and settings
	// which make Mercurial commands do random unusual things.
	$env['HGPLAIN'] = 1;
	break;
	default:
	throw new Exception("Unrecognized version control system.");
	}

	return $env;
	}

	private function getLocalCommandEnvironment() {
	return $this->getCommonCommandEnvironment();
	}

	private function getRemoteCommandEnvironment() {
	$env = $this->getCommonCommandEnvironment();

	if ($this->shouldUseSSH()) {
	// NOTE: This is read by `bin/ssh-connect`, and tells it which credentials
	// to use.
	$env['PHABRICATOR_CREDENTIAL'] = $this->getCredentialPHID();
	switch ($this->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	// Force SVN to use `bin/ssh-connect`.
	$env['SVN_SSH'] = $this->getSSHWrapper();
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	// Force Git to use `bin/ssh-connect`.
	$env['GIT_SSH'] = $this->getSSHWrapper();
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	// We force Mercurial through `bin/ssh-connect` too, but it uses a
	// command-line flag instead of an environmental variable.
	break;
	default:
	throw new Exception("Unrecognized version control system.");
	}
	}

	return $env;
	}

	private function formatRemoteCommand(array $args) {
	$pattern = $args[0];
	$args = array_slice($args, 1);

	switch ($this->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	if ($this->shouldUseHTTP() \|\| $this->shouldUseSVNProtocol()) {
	$flags = array();
	$flag_args = array();
	$flags[] = '--non-interactive';
	$flags[] = '--no-auth-cache';
	if ($this->shouldUseHTTP()) {
	$flags[] = '--trust-server-cert';
	}

	$credential_phid = $this->getCredentialPHID();
	if ($credential_phid) {
	$key = PassphrasePasswordKey::loadFromPHID(
	$credential_phid,
	PhabricatorUser::getOmnipotentUser());
	$flags[] = '--username %P';
	$flags[] = '--password %P';
	$flag_args[] = $key->getUsernameEnvelope();
	$flag_args[] = $key->getPasswordEnvelope();
	}

	$flags = implode(' ', $flags);
	$pattern = "svn {$flags} {$pattern}";
	$args = array_mergev(array($flag_args, $args));
	} else {
	$pattern = "svn --non-interactive {$pattern}";
	}
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	$pattern = "git {$pattern}";
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	if ($this->shouldUseSSH()) {
	$pattern = "hg --config ui.ssh=%s {$pattern}";
	array_unshift(
	$args,
	$this->getSSHWrapper());
	} else {
	$pattern = "hg {$pattern}";
	}
	break;
	default:
	throw new Exception("Unrecognized version control system.");
	}

	array_unshift($args, $pattern);

	return $args;
	}

	private function formatLocalCommand(array $args) {
	$pattern = $args[0];
	$args = array_slice($args, 1);

	switch ($this->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	$pattern = "svn --non-interactive {$pattern}";
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	$pattern = "git {$pattern}";
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	$pattern = "hg {$pattern}";
	break;
	default:
	throw new Exception("Unrecognized version control system.");
	}

	array_unshift($args, $pattern);

	return $args;
	}

	/**
	* Sanitize output of an `hg` command invoked with the `--debug` flag to make
	* it usable.
	*
	* @param string Output from `hg --debug ...`
	* @return string Usable output.
	*/
	public static function filterMercurialDebugOutput($stdout) {
	// When hg commands are run with `--debug` and some config file isn't
	// trusted, Mercurial prints out a warning to stdout, twice, after Feb 2011.
	//
	// http://selenic.com/pipermail/mercurial-devel/2011-February/028541.html

	$lines = preg_split('/(?<=\n)/', $stdout);
	$regex = '/ignoring untrusted configuration option .*\n$/';

	foreach ($lines as $key => $line) {
	$lines[$key] = preg_replace($regex, '', $line);
	}

	return implode('', $lines);
	}

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

	public function getNormalizedPath() {
	$uri = (string)$this->getCloneURIObject();

	switch ($this->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	$normalized_uri = new PhabricatorRepositoryURINormalizer(
	PhabricatorRepositoryURINormalizer::TYPE_GIT,
	$uri);
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	$normalized_uri = new PhabricatorRepositoryURINormalizer(
	PhabricatorRepositoryURINormalizer::TYPE_SVN,
	$uri);
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	$normalized_uri = new PhabricatorRepositoryURINormalizer(
	PhabricatorRepositoryURINormalizer::TYPE_MERCURIAL,
	$uri);
	break;
	default:
	throw new Exception("Unrecognized version control system.");
	}

	return $normalized_uri->getNormalizedPath();
	}

	public function isTracked() {
	return $this->getDetail('tracking-enabled', false);
	}

	public function getDefaultBranch() {
	$default = $this->getDetail('default-branch');
	if (strlen($default)) {
	return $default;
	}

	$default_branches = array(
	PhabricatorRepositoryType::REPOSITORY_TYPE_GIT => 'master',
	PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL => 'default',
	);

	return idx($default_branches, $this->getVersionControlSystem());
	}

	public function getDefaultArcanistBranch() {
	return coalesce($this->getDefaultBranch(), 'svn');
	}

	private function isBranchInFilter($branch, $filter_key) {
	$vcs = $this->getVersionControlSystem();

	$is_git = ($vcs == PhabricatorRepositoryType::REPOSITORY_TYPE_GIT);

	$use_filter = ($is_git);

	if ($use_filter) {
	$filter = $this->getDetail($filter_key, array());
	if ($filter && empty($filter[$branch])) {
	return false;
	}
	}

	// By default, all branches pass.
	return true;
	}

	public function shouldTrackBranch($branch) {
	return $this->isBranchInFilter($branch, 'branch-filter');
	}

	public function shouldAutocloseBranch($branch) {
	if ($this->isImporting()) {
	return false;
	}

	if ($this->getDetail('disable-autoclose', false)) {
	return false;
	}

	return $this->isBranchInFilter($branch, 'close-commits-filter');
	}

	public function shouldAutocloseCommit(
	PhabricatorRepositoryCommit $commit,
	PhabricatorRepositoryCommitData $data) {

	if ($this->getDetail('disable-autoclose', false)) {
	return false;
	}

	switch ($this->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	return true;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	return true;
	default:
	throw new Exception("Unrecognized version control system.");
	}

	$closeable_flag = PhabricatorRepositoryCommit::IMPORTED_CLOSEABLE;
	if ($commit->isPartiallyImported($closeable_flag)) {
	return true;
	}

	// TODO: Remove this eventually, it's no longer written to by the import
	// pipeline (however, old tasks may still be queued which don't reflect
	// the new data format).
	$branches = $data->getCommitDetail('seenOnBranches', array());
	foreach ($branches as $branch) {
	if ($this->shouldAutocloseBranch($branch)) {
	return true;
	}
	}

	return false;
	}

	public function formatCommitName($commit_identifier) {
	$vcs = $this->getVersionControlSystem();

	$type_git = PhabricatorRepositoryType::REPOSITORY_TYPE_GIT;
	$type_hg = PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL;

	$is_git = ($vcs == $type_git);
	$is_hg = ($vcs == $type_hg);
	if ($is_git \|\| $is_hg) {
	$short_identifier = substr($commit_identifier, 0, 12);
	} else {
	$short_identifier = $commit_identifier;
	}

	return 'r'.$this->getCallsign().$short_identifier;
	}

	public function isImporting() {
	return (bool)$this->getDetail('importing', false);
	}


	/* -( Repository URI Management )------------------------------------------ */


	/**
	* Get the remote URI for this repository.
	*
	* @return string
	* @task uri
	*/
	public function getRemoteURI() {
	return (string)$this->getRemoteURIObject();
	}


	/**
	* Get the remote URI for this repository, including credentials if they're
	* used by this repository.
	*
	* @return PhutilOpaqueEnvelope URI, possibly including credentials.
	* @task uri
	*/
	public function getRemoteURIEnvelope() {
	$uri = $this->getRemoteURIObject();

	$remote_protocol = $this->getRemoteProtocol();
	if ($remote_protocol == 'http' \|\| $remote_protocol == 'https') {
	// For SVN, we use `--username` and `--password` flags separately, so
	// don't add any credentials here.
	if (!$this->isSVN()) {
	$credential_phid = $this->getCredentialPHID();
	if ($credential_phid) {
	$key = PassphrasePasswordKey::loadFromPHID(
	$credential_phid,
	PhabricatorUser::getOmnipotentUser());

	$uri->setUser($key->getUsernameEnvelope()->openEnvelope());
	$uri->setPass($key->getPasswordEnvelope()->openEnvelope());
	}
	}
	}

	return new PhutilOpaqueEnvelope((string)$uri);
	}


	/**
	* Get the clone (or checkout) URI for this repository, without authentication
	* information.
	*
	* @return string Repository URI.
	* @task uri
	*/
	public function getPublicCloneURI() {
	$uri = $this->getCloneURIObject();

	// Make sure we don't leak anything if this repo is using HTTP Basic Auth
	// with the credentials in the URI or something zany like that.

	// If repository is not accessed over SSH we remove both username and
	// password.
	if (!$this->isHosted()) {
	if (!$this->shouldUseSSH()) {
	$uri->setUser(null);

	// This might be a Git URI or a normal URI. If it's Git, there's no
	// password support.
	if ($uri instanceof PhutilURI) {
	$uri->setPass(null);
	}
	}
	}

	return (string)$uri;
	}


	/**
	* Get the protocol for the repository's remote.
	*
	* @return string Protocol, like "ssh" or "git".
	* @task uri
	*/
	public function getRemoteProtocol() {
	$uri = $this->getRemoteURIObject();

	if ($uri instanceof PhutilGitURI) {
	return 'ssh';
	} else {
	return $uri->getProtocol();
	}
	}


	/**
	* Get a parsed object representation of the repository's remote URI. This
	* may be a normal URI (returned as a @{class@libphutil:PhutilURI}) or a git
	* URI (returned as a @{class@libphutil:PhutilGitURI}).
	*
	* @return wild A @{class@libphutil:PhutilURI} or
	* @{class@libphutil:PhutilGitURI}.
	* @task uri
	*/
	public function getRemoteURIObject() {
	$raw_uri = $this->getDetail('remote-uri');
	if (!$raw_uri) {
	return new PhutilURI('');
	}

	if (!strncmp($raw_uri, '/', 1)) {
	return new PhutilURI('file://'.$raw_uri);
	}

	$uri = new PhutilURI($raw_uri);
	if ($uri->getProtocol()) {
	return $uri;
	}

	$uri = new PhutilGitURI($raw_uri);
	if ($uri->getDomain()) {
	return $uri;
	}

	throw new Exception("Remote URI '{$raw_uri}' could not be parsed!");
	}


	/**
	* Get the "best" clone/checkout URI for this repository, on any protocol.
	*/
	public function getCloneURIObject() {
	if (!$this->isHosted()) {
	return $this->getRemoteURIObject();
	}

	// Choose the best URI: pick a read/write URI over a URI which is not
	// read/write, and SSH over HTTP.

	$serve_ssh = $this->getServeOverSSH();
	$serve_http = $this->getServeOverHTTP();

	if ($serve_ssh === self::SERVE_READWRITE) {
	return $this->getSSHCloneURIObject();
	} else if ($serve_http === self::SERVE_READWRITE) {
	return $this->getHTTPCloneURIObject();
	} else if ($serve_ssh !== self::SERVE_OFF) {
	return $this->getSSHCloneURIObject();
	} else if ($serve_http !== self::SERVE_OFF) {
	return $this->getHTTPCloneURIObject();
	} else {
	return null;
	}
	}


	/**
	* Get the repository's SSH clone/checkout URI, if one exists.
	*/
	public function getSSHCloneURIObject() {
	if (!$this->isHosted()) {
	if ($this->shouldUseSSH()) {
	return $this->getRemoteURIObject();
	} else {
	return null;
	}
	}

	$serve_ssh = $this->getServeOverSSH();
	if ($serve_ssh === self::SERVE_OFF) {
	return null;
	}

	$uri = new PhutilURI(PhabricatorEnv::getProductionURI($this->getURI()));

	if ($this->isSVN()) {
	$uri->setProtocol('svn+ssh');
	} else {
	$uri->setProtocol('ssh');
	}

	+ if ($this->isGit()) {
	+ $uri->setPath($uri->getPath().$this->getCloneName().'.git');
	+ } else if ($this->isHg()) {
	+ $uri->setPath($uri->getPath().$this->getCloneName().'/');
	+ }
	+
	$ssh_user = PhabricatorEnv::getEnvConfig('diffusion.ssh-user');
	if ($ssh_user) {
	$uri->setUser($ssh_user);
	}

	$uri->setPort(PhabricatorEnv::getEnvConfig('diffusion.ssh-port'));

	return $uri;
	}


	/**
	* Get the repository's HTTP clone/checkout URI, if one exists.
	*/
	public function getHTTPCloneURIObject() {
	if (!$this->isHosted()) {
	if ($this->shouldUseHTTP()) {
	return $this->getRemoteURIObject();
	} else {
	return null;
	}
	}

	$serve_http = $this->getServeOverHTTP();
	if ($serve_http === self::SERVE_OFF) {
	return null;
	}

	-
	$uri = PhabricatorEnv::getProductionURI($this->getURI());
	+ $uri = new PhutilURI($uri);
	+
	+ if ($this->isGit()) {
	+ $uri->setPath($uri->getPath().$this->getCloneName().'.git');
	+ } else if ($this->isHg()) {
	+ $uri->setPath($uri->getPath().$this->getCloneName().'/');
	+ }

	return $uri;
	}


	/**
	* Determine if we should connect to the remote using SSH flags and
	* credentials.
	*
	* @return bool True to use the SSH protocol.
	* @task uri
	*/
	private function shouldUseSSH() {
	if ($this->isHosted()) {
	return false;
	}

	$protocol = $this->getRemoteProtocol();
	if ($this->isSSHProtocol($protocol)) {
	return true;
	}

	return false;
	}


	/**
	* Determine if we should connect to the remote using HTTP flags and
	* credentials.
	*
	* @return bool True to use the HTTP protocol.
	* @task uri
	*/
	private function shouldUseHTTP() {
	if ($this->isHosted()) {
	return false;
	}

	$protocol = $this->getRemoteProtocol();
	return ($protocol == 'http' \|\| $protocol == 'https');
	}


	/**
	* Determine if we should connect to the remote using SVN flags and
	* credentials.
	*
	* @return bool True to use the SVN protocol.
	* @task uri
	*/
	private function shouldUseSVNProtocol() {
	if ($this->isHosted()) {
	return false;
	}

	$protocol = $this->getRemoteProtocol();
	return ($protocol == 'svn');
	}


	/**
	* Determine if a protocol is SSH or SSH-like.
	*
	* @param string A protocol string, like "http" or "ssh".
	* @return bool True if the protocol is SSH-like.
	* @task uri
	*/
	private function isSSHProtocol($protocol) {
	return ($protocol == 'ssh' \|\| $protocol == 'svn+ssh');
	}

	public function delete() {
	$this->openTransaction();

	$paths = id(new PhabricatorOwnersPath())
	->loadAllWhere('repositoryPHID = %s', $this->getPHID());
	foreach ($paths as $path) {
	$path->delete();
	}

	$projects = id(new PhabricatorRepositoryArcanistProject())
	->loadAllWhere('repositoryID = %d', $this->getID());
	foreach ($projects as $project) {
	// note each project deletes its PhabricatorRepositorySymbols
	$project->delete();
	}

	$commits = id(new PhabricatorRepositoryCommit())
	->loadAllWhere('repositoryID = %d', $this->getID());
	foreach ($commits as $commit) {
	// note PhabricatorRepositoryAuditRequests and
	// PhabricatorRepositoryCommitData are deleted here too.
	$commit->delete();
	}

	$mirrors = id(new PhabricatorRepositoryMirror())
	->loadAllWhere('repositoryPHID = %s', $this->getPHID());
	foreach ($mirrors as $mirror) {
	$mirror->delete();
	}

	$ref_cursors = id(new PhabricatorRepositoryRefCursor())
	->loadAllWhere('repositoryPHID = %s', $this->getPHID());
	foreach ($ref_cursors as $cursor) {
	$cursor->delete();
	}

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

	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE repositoryID = %d',
	self::TABLE_FILESYSTEM,
	$this->getID());

	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE repositoryID = %d',
	self::TABLE_PATHCHANGE,
	$this->getID());

	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE repositoryID = %d',
	self::TABLE_SUMMARY,
	$this->getID());

	$result = parent::delete();

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

	public function isGit() {
	$vcs = $this->getVersionControlSystem();
	return ($vcs == PhabricatorRepositoryType::REPOSITORY_TYPE_GIT);
	}

	public function isSVN() {
	$vcs = $this->getVersionControlSystem();
	return ($vcs == PhabricatorRepositoryType::REPOSITORY_TYPE_SVN);
	}

	public function isHg() {
	$vcs = $this->getVersionControlSystem();
	return ($vcs == PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL);
	}

	public function isHosted() {
	return (bool)$this->getDetail('hosting-enabled', false);
	}

	public function setHosted($enabled) {
	return $this->setDetail('hosting-enabled', $enabled);
	}

	public function getServeOverHTTP() {
	if ($this->isSVN()) {
	return self::SERVE_OFF;
	}
	$serve = $this->getDetail('serve-over-http', self::SERVE_OFF);
	return $this->normalizeServeConfigSetting($serve);
	}

	public function setServeOverHTTP($mode) {
	return $this->setDetail('serve-over-http', $mode);
	}

	public function getServeOverSSH() {
	$serve = $this->getDetail('serve-over-ssh', self::SERVE_OFF);
	return $this->normalizeServeConfigSetting($serve);
	}

	public function setServeOverSSH($mode) {
	return $this->setDetail('serve-over-ssh', $mode);
	}

	public static function getProtocolAvailabilityName($constant) {
	switch ($constant) {
	case self::SERVE_OFF:
	return pht('Off');
	case self::SERVE_READONLY:
	return pht('Read Only');
	case self::SERVE_READWRITE:
	return pht('Read/Write');
	default:
	return pht('Unknown');
	}
	}

	private function normalizeServeConfigSetting($value) {
	switch ($value) {
	case self::SERVE_OFF:
	case self::SERVE_READONLY:
	return $value;
	case self::SERVE_READWRITE:
	if ($this->isHosted()) {
	return self::SERVE_READWRITE;
	} else {
	return self::SERVE_READONLY;
	}
	default:
	return self::SERVE_OFF;
	}
	}


	/**
	* Raise more useful errors when there are basic filesystem problems.
	*/
	private function assertLocalExists() {
	if (!$this->usesLocalWorkingCopy()) {
	return;
	}

	$local = $this->getLocalPath();
	Filesystem::assertExists($local);
	Filesystem::assertIsDirectory($local);
	Filesystem::assertReadable($local);
	}

	/**
	* Determine if the working copy is bare or not. In Git, this corresponds
	* to `--bare`. In Mercurial, `--noupdate`.
	*/
	public function isWorkingCopyBare() {
	switch ($this->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	return false;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	$local = $this->getLocalPath();
	if (Filesystem::pathExists($local.'/.git')) {
	return false;
	} else {
	return true;
	}
	}
	}

	public function usesLocalWorkingCopy() {
	switch ($this->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	return $this->isHosted();
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	return true;
	}
	}

	public function getHookDirectories() {
	$directories = array();
	if (!$this->isHosted()) {
	return $directories;
	}

	$root = $this->getLocalPath();

	switch ($this->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	if ($this->isWorkingCopyBare()) {
	$directories[] = $root.'/hooks/pre-receive-phabricator.d/';
	} else {
	$directories[] = $root.'/.git/hooks/pre-receive-phabricator.d/';
	}
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	$directories[] = $root.'/hooks/pre-commit-phabricator.d/';
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	// NOTE: We don't support custom Mercurial hooks for now because they're
	// messy and we can't easily just drop a `hooks.d/` directory next to
	// the hooks.
	break;
	}

	return $directories;
	}

	public function canDestroyWorkingCopy() {
	if ($this->isHosted()) {
	// Never destroy hosted working copies.
	return false;
	}

	$default_path = PhabricatorEnv::getEnvConfig(
	'repository.default-local-path');
	return Filesystem::isDescendant($this->getLocalPath(), $default_path);
	}

	public function canMirror() {
	if ($this->isGit() \|\| $this->isHg()) {
	return true;
	}

	return false;
	}

	public function canAllowDangerousChanges() {
	if (!$this->isHosted()) {
	return false;
	}

	if ($this->isGit() \|\| $this->isHg()) {
	return true;
	}

	return false;
	}

	public function shouldAllowDangerousChanges() {
	return (bool)$this->getDetail('allow-dangerous-changes');
	}

	public function writeStatusMessage(
	$status_type,
	$status_code,
	array $parameters = array()) {

	$table = new PhabricatorRepositoryStatusMessage();
	$conn_w = $table->establishConnection('w');
	$table_name = $table->getTableName();

	if ($status_code === null) {
	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE repositoryID = %d AND statusType = %s',
	$table_name,
	$this->getID(),
	$status_type);
	} else {
	queryfx(
	$conn_w,
	'INSERT INTO %T
	(repositoryID, statusType, statusCode, parameters, epoch)
	VALUES (%d, %s, %s, %s, %d)
	ON DUPLICATE KEY UPDATE
	statusCode = VALUES(statusCode),
	parameters = VALUES(parameters),
	epoch = VALUES(epoch)',
	$table_name,
	$this->getID(),
	$status_type,
	$status_code,
	json_encode($parameters),
	time());
	}

	return $this;
	}


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


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

	public function getPolicy($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	return $this->getViewPolicy();
	case PhabricatorPolicyCapability::CAN_EDIT:
	return $this->getEditPolicy();
	case DiffusionCapabilityPush::CAPABILITY:
	return $this->getPushPolicy();
	}
	}

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

	public function describeAutomaticCapability($capability) {
	return null;
	}



	/* -( PhabricatorMarkupInterface )----------------------------------------- */


	public function getMarkupFieldKey($field) {
	$hash = PhabricatorHash::digestForIndex($this->getMarkupText($field));
	return "repo:{$hash}";
	}

	public function newMarkupEngine($field) {
	return PhabricatorMarkupEngine::newMarkupEngine(array());
	}

	public function getMarkupText($field) {
	return $this->getDetail('description');
	}

	public function didMarkupText(
	$field,
	$output,
	PhutilMarkupEngine $engine) {
	require_celerity_resource('phabricator-remarkup-css');
	return phutil_tag(
	'div',
	array(
	'class' => 'phabricator-remarkup',
	),
	$output);
	}

	public function shouldUseMarkupCache($field) {
	return true;
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Dec 1, 9:38 AM (1 d, 10 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 430342
Default Alt Text: (80 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions