No OneTemporary
Actions

Size

26 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/maniphest/editor/ManiphestTransactionEditor.php b/src/applications/maniphest/editor/ManiphestTransactionEditor.php
	index fc908726d7..427a635b6b 100644
	--- a/src/applications/maniphest/editor/ManiphestTransactionEditor.php
	+++ b/src/applications/maniphest/editor/ManiphestTransactionEditor.php
	@@ -1,440 +1,441 @@
	<?php

	/**
	* @group maniphest
	*/
	final class ManiphestTransactionEditor extends PhabricatorEditor {

	private $parentMessageID;
	private $auxiliaryFields = array();

	public function setAuxiliaryFields(array $fields) {
	assert_instances_of($fields, 'ManiphestAuxiliaryFieldSpecification');
	$this->auxiliaryFields = $fields;
	return $this;
	}

	public function setParentMessageID($parent_message_id) {
	$this->parentMessageID = $parent_message_id;
	return $this;
	}

	public function applyTransactions(ManiphestTask $task, array $transactions) {
	assert_instances_of($transactions, 'ManiphestTransaction');

	$email_cc = $task->getCCPHIDs();

	$email_to = array();
	$email_to[] = $task->getOwnerPHID();

	$pri_changed = $this->isCreate($transactions);

	foreach ($transactions as $key => $transaction) {
	$type = $transaction->getTransactionType();
	$new = $transaction->getNewValue();
	$email_to[] = $transaction->getAuthorPHID();

	$value_is_phid_set = false;

	switch ($type) {
	case ManiphestTransactionType::TYPE_NONE:
	$old = null;
	break;
	case ManiphestTransactionType::TYPE_STATUS:
	$old = $task->getStatus();
	break;
	case ManiphestTransactionType::TYPE_OWNER:
	$old = $task->getOwnerPHID();
	break;
	case ManiphestTransactionType::TYPE_CCS:
	$old = $task->getCCPHIDs();
	$value_is_phid_set = true;
	break;
	case ManiphestTransactionType::TYPE_PRIORITY:
	$old = $task->getPriority();
	break;
	case ManiphestTransactionType::TYPE_EDGE:
	$old = $transaction->getOldValue();
	break;
	case ManiphestTransactionType::TYPE_ATTACH:
	$old = $task->getAttached();
	break;
	case ManiphestTransactionType::TYPE_TITLE:
	$old = $task->getTitle();
	break;
	case ManiphestTransactionType::TYPE_DESCRIPTION:
	$old = $task->getDescription();
	break;
	case ManiphestTransactionType::TYPE_PROJECTS:
	$old = $task->getProjectPHIDs();
	$value_is_phid_set = true;
	break;
	case ManiphestTransactionType::TYPE_AUXILIARY:
	$aux_key = $transaction->getMetadataValue('aux:key');
	if (!$aux_key) {
	throw new Exception(
	"Expected 'aux:key' metadata on TYPE_AUXILIARY transaction.");
	}
	$old = $task->getAuxiliaryAttribute($aux_key);
	break;
	default:
	throw new Exception('Unknown action type.');
	}

	$old_cmp = $old;
	$new_cmp = $new;
	if ($value_is_phid_set) {

	// Normalize the old and new values if they are PHID sets so we don't
	// get any no-op transactions where the values differ only by keys,
	// order, duplicates, etc.

	if (is_array($old)) {
	$old = array_filter($old);
	$old = array_unique($old);
	sort($old);
	$old = array_values($old);
	$old_cmp = $old;
	}

	if (is_array($new)) {
	$new = array_filter($new);
	$new = array_unique($new);
	$transaction->setNewValue($new);

	$new_cmp = $new;
	sort($new_cmp);
	$new_cmp = array_values($new_cmp);
	}
	}

	if (($old !== null) && ($old_cmp == $new_cmp)) {
	if (count($transactions) > 1 && !$transaction->hasComments()) {
	// If we have at least one other transaction and this one isn't
	// doing anything and doesn't have any comments, just throw it
	// away.
	unset($transactions[$key]);
	continue;
	} else {
	$transaction->setOldValue(null);
	$transaction->setNewValue(null);
	$transaction->setTransactionType(ManiphestTransactionType::TYPE_NONE);
	}
	} else {
	switch ($type) {
	case ManiphestTransactionType::TYPE_NONE:
	break;
	case ManiphestTransactionType::TYPE_STATUS:
	$task->setStatus($new);
	break;
	case ManiphestTransactionType::TYPE_OWNER:
	if ($new) {
	$handles = id(new PhabricatorObjectHandleData(array($new)))
	->loadHandles();
	$task->setOwnerOrdering($handles[$new]->getName());
	} else {
	$task->setOwnerOrdering(null);
	}
	$task->setOwnerPHID($new);
	break;
	case ManiphestTransactionType::TYPE_CCS:
	$task->setCCPHIDs($new);
	break;
	case ManiphestTransactionType::TYPE_PRIORITY:
	$task->setPriority($new);
	$pri_changed = true;
	break;
	case ManiphestTransactionType::TYPE_ATTACH:
	$task->setAttached($new);
	break;
	case ManiphestTransactionType::TYPE_TITLE:
	$task->setTitle($new);
	break;
	case ManiphestTransactionType::TYPE_DESCRIPTION:
	$task->setDescription($new);
	break;
	case ManiphestTransactionType::TYPE_PROJECTS:
	$task->setProjectPHIDs($new);
	break;
	case ManiphestTransactionType::TYPE_AUXILIARY:
	$aux_key = $transaction->getMetadataValue('aux:key');
	$task->setAuxiliaryAttribute($aux_key, $new);
	break;
	case ManiphestTransactionType::TYPE_EDGE:
	// Edge edits are accomplished through PhabricatorEdgeEditor, which
	// has authority.
	break;
	default:
	throw new Exception('Unknown action type.');
	}

	$transaction->setOldValue($old);
	$transaction->setNewValue($new);
	}

	}

	if ($pri_changed) {
	$subpriority = ManiphestTransactionEditor::getNextSubpriority(
	$task->getPriority(),
	null);
	$task->setSubpriority($subpriority);
	}

	$task->save();
	foreach ($transactions as $transaction) {
	$transaction->setTaskID($task->getID());
	$transaction->save();
	}

	$email_to[] = $task->getOwnerPHID();
	$email_cc = array_merge(
	$email_cc,
	$task->getCCPHIDs());

	$mail = $this->sendEmail($task, $transactions, $email_to, $email_cc);

	$this->publishFeedStory(
	$task,
	$transactions,
	$mail->buildRecipientList());

	id(new PhabricatorSearchIndexer())
	->indexDocumentByPHID($task->getPHID());
	}

	protected function getSubjectPrefix() {
	return PhabricatorEnv::getEnvConfig('metamta.maniphest.subject-prefix');
	}

	private function sendEmail($task, $transactions, $email_to, $email_cc) {
	$email_to = array_filter(array_unique($email_to));
	$email_cc = array_filter(array_unique($email_cc));

	$phids = array();
	foreach ($transactions as $transaction) {
	foreach ($transaction->extractPHIDs() as $phid) {
	$phids[$phid] = true;
	}
	}
	foreach ($email_to as $phid) {
	$phids[$phid] = true;
	}
	foreach ($email_cc as $phid) {
	$phids[$phid] = true;
	}
	$phids = array_keys($phids);

	$handles = id(new PhabricatorObjectHandleData($phids))
	+ ->setViewer($this->getActor())
	->loadHandles();

	$view = new ManiphestTransactionDetailView();
	$view->setTransactionGroup($transactions);
	$view->setHandles($handles);
	$view->setAuxiliaryFields($this->auxiliaryFields);
	list($action, $main_body) = $view->renderForEmail($with_date = false);

	$is_create = $this->isCreate($transactions);

	$task_uri = PhabricatorEnv::getProductionURI('/T'.$task->getID());

	$reply_handler = $this->buildReplyHandler($task);

	$body = new PhabricatorMetaMTAMailBody();
	$body->addRawSection($main_body);
	if ($is_create) {
	$body->addTextSection(pht('TASK DESCRIPTION'), $task->getDescription());
	}
	$body->addTextSection(pht('TASK DETAIL'), $task_uri);
	$body->addReplySection($reply_handler->getReplyHandlerInstructions());

	$thread_id = 'maniphest-task-'.$task->getPHID();
	$task_id = $task->getID();
	$title = $task->getTitle();

	$mailtags = $this->getMailTags($transactions);

	$template = id(new PhabricatorMetaMTAMail())
	->setSubject("T{$task_id}: {$title}")
	->setSubjectPrefix($this->getSubjectPrefix())
	->setVarySubjectPrefix("[{$action}]")
	->setFrom($transaction->getAuthorPHID())
	->setParentMessageID($this->parentMessageID)
	->addHeader('Thread-Topic', "T{$task_id}: ".$task->getOriginalTitle())
	->setThreadID($thread_id, $is_create)
	->setRelatedPHID($task->getPHID())
	->setExcludeMailRecipientPHIDs($this->getExcludeMailRecipientPHIDs())
	->setIsBulk(true)
	->setMailTags($mailtags)
	->setBody($body->render());

	$mails = $reply_handler->multiplexMail(
	$template,
	array_select_keys($handles, $email_to),
	array_select_keys($handles, $email_cc));

	foreach ($mails as $mail) {
	$mail->saveAndSend();
	}

	$template->addTos($email_to);
	$template->addCCs($email_cc);
	return $template;
	}

	public function buildReplyHandler(ManiphestTask $task) {
	$handler_object = PhabricatorEnv::newObjectFromConfig(
	'metamta.maniphest.reply-handler');
	$handler_object->setMailReceiver($task);

	return $handler_object;
	}

	private function publishFeedStory(
	ManiphestTask $task,
	array $transactions,
	array $mailed_phids) {
	assert_instances_of($transactions, 'ManiphestTransaction');

	$actions = array(ManiphestAction::ACTION_UPDATE);
	$comments = null;
	foreach ($transactions as $transaction) {
	if ($transaction->hasComments()) {
	$comments = $transaction->getComments();
	}
	$type = $transaction->getTransactionType();
	switch ($type) {
	case ManiphestTransactionType::TYPE_OWNER:
	$actions[] = ManiphestAction::ACTION_ASSIGN;
	break;
	case ManiphestTransactionType::TYPE_STATUS:
	if ($task->getStatus() != ManiphestTaskStatus::STATUS_OPEN) {
	$actions[] = ManiphestAction::ACTION_CLOSE;
	} else if ($this->isCreate($transactions)) {
	$actions[] = ManiphestAction::ACTION_CREATE;
	} else {
	$actions[] = ManiphestAction::ACTION_REOPEN;
	}
	break;
	default:
	$actions[] = $type;
	break;
	}
	}

	$action_type = ManiphestAction::selectStrongestAction($actions);
	$owner_phid = $task->getOwnerPHID();
	$actor_phid = head($transactions)->getAuthorPHID();
	$author_phid = $task->getAuthorPHID();

	id(new PhabricatorFeedStoryPublisher())
	->setStoryType('PhabricatorFeedStoryManiphest')
	->setStoryData(array(
	'taskPHID' => $task->getPHID(),
	'transactionIDs' => mpull($transactions, 'getID'),
	'ownerPHID' => $owner_phid,
	'action' => $action_type,
	'comments' => $comments,
	'description' => $task->getDescription(),
	))
	->setStoryTime(time())
	->setStoryAuthorPHID($actor_phid)
	->setRelatedPHIDs(
	array_merge(
	array_filter(
	array(
	$task->getPHID(),
	$author_phid,
	$actor_phid,
	$owner_phid,
	)),
	$task->getProjectPHIDs()))
	->setPrimaryObjectPHID($task->getPHID())
	->setSubscribedPHIDs(
	array_merge(
	array_filter(
	array(
	$author_phid,
	$owner_phid,
	$actor_phid)),
	$task->getCCPHIDs()))
	->setMailRecipientPHIDs($mailed_phids)
	->publish();
	}

	private function isCreate(array $transactions) {
	assert_instances_of($transactions, 'ManiphestTransaction');
	$is_create = false;
	foreach ($transactions as $transaction) {
	$type = $transaction->getTransactionType();
	if (($type == ManiphestTransactionType::TYPE_STATUS) &&
	($transaction->getOldValue() === null) &&
	($transaction->getNewValue() == ManiphestTaskStatus::STATUS_OPEN)) {
	$is_create = true;
	}
	}
	return $is_create;
	}

	private function getMailTags(array $transactions) {
	assert_instances_of($transactions, 'ManiphestTransaction');

	$tags = array();
	foreach ($transactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case ManiphestTransactionType::TYPE_STATUS:
	$tags[] = MetaMTANotificationType::TYPE_MANIPHEST_STATUS;
	break;
	case ManiphestTransactionType::TYPE_OWNER:
	$tags[] = MetaMTANotificationType::TYPE_MANIPHEST_OWNER;
	break;
	case ManiphestTransactionType::TYPE_CCS:
	$tags[] = MetaMTANotificationType::TYPE_MANIPHEST_CC;
	break;
	case ManiphestTransactionType::TYPE_PROJECTS:
	$tags[] = MetaMTANotificationType::TYPE_MANIPHEST_PROJECTS;
	break;
	case ManiphestTransactionType::TYPE_PRIORITY:
	$tags[] = MetaMTANotificationType::TYPE_MANIPHEST_PRIORITY;
	break;
	case ManiphestTransactionType::TYPE_NONE:
	// this is a comment which we will check separately below for
	// content
	break;
	default:
	$tags[] = MetaMTANotificationType::TYPE_MANIPHEST_OTHER;
	break;
	}

	if ($xaction->hasComments()) {
	$tags[] = MetaMTANotificationType::TYPE_MANIPHEST_COMMENT;
	}
	}

	return array_unique($tags);
	}

	public static function getNextSubpriority($pri, $sub) {

	if ($sub === null) {
	$next = id(new ManiphestTask())->loadOneWhere(
	'priority = %d ORDER BY subpriority ASC LIMIT 1',
	$pri);
	if ($next) {
	return $next->getSubpriority() - ((double)(2 << 16));
	}
	} else {
	$next = id(new ManiphestTask())->loadOneWhere(
	'priority = %d AND subpriority > %s ORDER BY subpriority ASC LIMIT 1',
	$pri,
	$sub);
	if ($next) {
	return ($sub + $next->getSubpriority()) / 2;
	}
	}

	return (double)(2 << 32);
	}


	}
	diff --git a/src/applications/repository/worker/PhabricatorRepositoryCommitHeraldWorker.php b/src/applications/repository/worker/PhabricatorRepositoryCommitHeraldWorker.php
	index b1178df5d6..694db8e7d7 100644
	--- a/src/applications/repository/worker/PhabricatorRepositoryCommitHeraldWorker.php
	+++ b/src/applications/repository/worker/PhabricatorRepositoryCommitHeraldWorker.php
	@@ -1,389 +1,395 @@
	<?php

	final class PhabricatorRepositoryCommitHeraldWorker
	extends PhabricatorRepositoryCommitParserWorker {

	public function getRequiredLeaseTime() {
	// Herald rules may take a long time to process.
	return 4 * 60 * 60;
	}

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

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

	if (!$data) {
	// TODO: Permanent failure.
	return;
	}

	$rules = HeraldRule::loadAllByContentTypeWithFullData(
	HeraldContentTypeConfig::CONTENT_TYPE_COMMIT,
	$commit->getPHID());

	$adapter = new HeraldCommitAdapter(
	$repository,
	$commit,
	$data);
	$engine = new HeraldEngine();

	$effects = $engine->applyRules($rules, $adapter);
	$engine->applyEffects($effects, $adapter, $rules);

	$audit_phids = $adapter->getAuditMap();
	if ($audit_phids) {
	$this->createAudits($commit, $audit_phids, $rules);
	}

	$explicit_auditors = $this->createAuditsFromCommitMessage($commit, $data);

	if ($repository->getDetail('herald-disabled')) {
	// This just means "disable email"; audits are (mostly) idempotent.
	return;
	}

	$this->publishFeedStory($repository, $commit, $data);

	$herald_targets = $adapter->getEmailPHIDs();

	$email_phids = array_unique(
	array_merge(
	$explicit_auditors,
	$herald_targets));
	if (!$email_phids) {
	return;
	}

	$xscript = $engine->getTranscript();

	$revision = $adapter->loadDifferentialRevision();
	if ($revision) {
	$name = $revision->getTitle();
	} else {
	$name = $data->getSummary();
	}

	$author_phid = $data->getCommitDetail('authorPHID');
	$reviewer_phid = $data->getCommitDetail('reviewerPHID');

	$phids = array_filter(
	array(
	$author_phid,
	$reviewer_phid,
	$commit->getPHID(),
	));

	- $handles = id(new PhabricatorObjectHandleData($phids))->loadHandles();
	+ // TODO: This is complicated and needs to be sorted out properly for
	+ // repository policy stuff. We might need an omniscient user here?
	+ $viewer = new PhabricatorUser();
	+
	+ $handles = id(new PhabricatorObjectHandleData($phids))
	+ ->setViewer($viewer)
	+ ->loadHandles();

	$commit_handle = $handles[$commit->getPHID()];
	$commit_name = $commit_handle->getName();

	if ($author_phid) {
	$author_name = $handles[$author_phid]->getName();
	} else {
	$author_name = $data->getAuthorName();
	}

	if ($reviewer_phid) {
	$reviewer_name = $handles[$reviewer_phid]->getName();
	} else {
	$reviewer_name = null;
	}

	$who = implode(', ', array_filter(array($author_name, $reviewer_name)));

	$description = $data->getCommitMessage();

	$commit_uri = PhabricatorEnv::getProductionURI($commit_handle->getURI());
	$differential = $revision
	? PhabricatorEnv::getProductionURI('/D'.$revision->getID())
	: 'No revision.';

	$files = $adapter->loadAffectedPaths();
	sort($files);
	$files = implode("\n", $files);

	$xscript_id = $xscript->getID();

	$manage_uri = '/herald/view/commits/';
	$why_uri = '/herald/transcript/'.$xscript_id.'/';

	$reply_handler = PhabricatorAuditCommentEditor::newReplyHandlerForCommit(
	$commit);

	$template = new PhabricatorMetaMTAMail();

	$inline_patch_text = $this->buildPatch($template, $repository, $commit);

	$body = new PhabricatorMetaMTAMailBody();
	$body->addRawSection($description);
	$body->addTextSection(pht('DETAILS'), $commit_uri);
	$body->addTextSection(pht('DIFFERENTIAL REVISION'), $differential);
	$body->addTextSection(pht('AFFECTED FILES'), $files);
	$body->addReplySection($reply_handler->getReplyHandlerInstructions());
	$body->addHeraldSection($manage_uri, $why_uri);
	$body->addRawSection($inline_patch_text);
	$body = $body->render();

	$prefix = PhabricatorEnv::getEnvConfig('metamta.diffusion.subject-prefix');

	$threading = PhabricatorAuditCommentEditor::getMailThreading(
	$repository,
	$commit);
	list($thread_id, $thread_topic) = $threading;

	$template->setRelatedPHID($commit->getPHID());
	$template->setSubject("{$commit_name}: {$name}");
	$template->setSubjectPrefix($prefix);
	$template->setVarySubjectPrefix("[Commit]");
	$template->setBody($body);
	$template->setThreadID($thread_id, $is_new = true);
	$template->addHeader('Thread-Topic', $thread_topic);
	$template->setIsBulk(true);

	$template->addHeader('X-Herald-Rules', $xscript->getXHeraldRulesHeader());
	if ($author_phid) {
	$template->setFrom($author_phid);
	}

	$mails = $reply_handler->multiplexMail(
	$template,
	id(new PhabricatorObjectHandleData($email_phids))->loadHandles(),
	array());

	foreach ($mails as $mail) {
	$mail->saveAndSend();
	}
	}

	private function createAudits(
	PhabricatorRepositoryCommit $commit,
	array $map,
	array $rules) {
	assert_instances_of($rules, 'HeraldRule');

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

	$rules = mpull($rules, null, 'getID');
	foreach ($map as $phid => $rule_ids) {
	$request = idx($requests, $phid);
	if ($request) {
	continue;
	}
	$reasons = array();
	foreach ($rule_ids as $id) {
	$rule_name = '?';
	if ($rules[$id]) {
	$rule_name = $rules[$id]->getName();
	}
	$reasons[] = 'Herald Rule #'.$id.' "'.$rule_name.'" Triggered Audit';
	}

	$request = new PhabricatorRepositoryAuditRequest();
	$request->setCommitPHID($commit->getPHID());
	$request->setAuditorPHID($phid);
	$request->setAuditStatus(PhabricatorAuditStatusConstants::AUDIT_REQUIRED);
	$request->setAuditReasons($reasons);
	$request->save();
	}

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


	/**
	* Find audit requests in the "Auditors" field if it is present and trigger
	* explicit audit requests.
	*/
	private function createAuditsFromCommitMessage(
	PhabricatorRepositoryCommit $commit,
	PhabricatorRepositoryCommitData $data) {

	$message = $data->getCommitMessage();

	$matches = null;
	if (!preg_match('/^Auditors:\s(.)$/im', $message, $matches)) {
	return array();
	}

	$phids = DifferentialFieldSpecification::parseCommitMessageObjectList(
	$matches[1],
	$include_mailables = false,
	$allow_partial = true);

	if (!$phids) {
	return array();
	}

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

	foreach ($phids as $phid) {
	if (isset($requests[$phid])) {
	continue;
	}

	$request = new PhabricatorRepositoryAuditRequest();
	$request->setCommitPHID($commit->getPHID());
	$request->setAuditorPHID($phid);
	$request->setAuditStatus(
	PhabricatorAuditStatusConstants::AUDIT_REQUESTED);
	$request->setAuditReasons(
	array(
	'Requested by Author',
	));
	$request->save();

	$requests[$phid] = $request;
	}

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

	return $phids;
	}

	private function publishFeedStory(
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit,
	PhabricatorRepositoryCommitData $data) {

	if (time() > $commit->getEpoch() + (24 * 60 * 60)) {
	// Don't publish stories that are more than 24 hours old, to avoid
	// ridiculous levels of feed spam if a repository is imported without
	// disabling feed publishing.
	return;
	}

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

	$publisher = new PhabricatorFeedStoryPublisher();
	$publisher->setStoryType(PhabricatorFeedStoryTypeConstants::STORY_COMMIT);
	$publisher->setStoryData(
	array(
	'commitPHID' => $commit->getPHID(),
	'summary' => $data->getSummary(),
	'authorName' => $data->getAuthorName(),
	'authorPHID' => $author_phid,
	'committerName' => $data->getCommitDetail('committer'),
	'committerPHID' => $committer_phid,
	));
	$publisher->setStoryTime($commit->getEpoch());
	$publisher->setRelatedPHIDs(
	array_filter(
	array(
	$author_phid,
	$committer_phid,
	)));
	if ($author_phid) {
	$publisher->setStoryAuthorPHID($author_phid);
	}
	$publisher->publish();
	}

	private function buildPatch(
	PhabricatorMetaMTAMail $template,
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit) {

	$attach_key = 'metamta.diffusion.attach-patches';
	$inline_key = 'metamta.diffusion.inline-patches';

	$attach_patches = PhabricatorEnv::getEnvConfig($attach_key);
	$inline_patches = PhabricatorEnv::getEnvConfig($inline_key);

	if (!$attach_patches && !$inline_patches) {
	return;
	}

	$encoding = $repository->getDetail('encoding', 'UTF-8');

	$result = null;
	$patch_error = null;

	try {
	$raw_patch = $this->loadRawPatchText($repository, $commit);
	if ($attach_patches) {
	$commit_name = $repository->formatCommitName(
	$commit->getCommitIdentifier());

	$template->addAttachment(
	new PhabricatorMetaMTAAttachment(
	$raw_patch,
	$commit_name.'.patch',
	'text/x-patch; charset='.$encoding));
	}
	} catch (Exception $ex) {
	phlog($ex);
	$patch_error = 'Unable to generate: '.$ex->getMessage();
	}

	if ($patch_error) {
	$result = $patch_error;
	} else if ($inline_patches) {
	$len = substr_count($raw_patch, "\n");
	if ($len <= $inline_patches) {
	// We send email as utf8, so we need to convert the text to utf8 if
	// we can.
	if ($encoding) {
	$raw_patch = phutil_utf8_convert($raw_patch, 'UTF-8', $encoding);
	}
	$result = phutil_utf8ize($raw_patch);
	}
	}

	if ($result) {
	$result = "PATCH\n\n{$result}\n";
	}

	return $result;
	}

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

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

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

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

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

	$raw_diff = $raw_query->loadRawDiff();

	$size = strlen($raw_diff);
	if ($byte_limit && $size > $byte_limit) {
	$pretty_size = phabricator_format_bytes($size);
	$pretty_limit = phabricator_format_bytes($byte_limit);
	throw new Exception(
	"Patch size of {$pretty_size} exceeds configured byte size limit of ".
	"{$pretty_limit}.");
	}

	return $raw_diff;
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Sun, Jan 19, 12:46 (3 w, 4 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1124718
Default Alt Text: (26 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions