No OneTemporary
Actions

Size

77 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/audit/mail/PhabricatorAuditReplyHandler.php b/src/applications/audit/mail/PhabricatorAuditReplyHandler.php
	index 698be5b9ef..db254fb4d1 100644
	--- a/src/applications/audit/mail/PhabricatorAuditReplyHandler.php
	+++ b/src/applications/audit/mail/PhabricatorAuditReplyHandler.php
	@@ -1,63 +1,63 @@
	<?php

	final class PhabricatorAuditReplyHandler extends PhabricatorMailReplyHandler {

	public function validateMailReceiver($mail_receiver) {
	if (!($mail_receiver instanceof PhabricatorRepositoryCommit)) {
	throw new Exception('Mail receiver is not a commit!');
	}
	}

	public function getPrivateReplyHandlerEmailAddress(
	PhabricatorObjectHandle $handle) {
	return $this->getDefaultPrivateReplyHandlerEmailAddress($handle, 'C');
	}

	public function getPublicReplyHandlerEmailAddress() {
	return $this->getDefaultPublicReplyHandlerEmailAddress('C');
	}

	public function getReplyHandlerDomain() {
	- return PhabricatorEnv::getEnvConfig(
	+ return $this->getCustomReplyHandlerDomainIfExists(
	'metamta.diffusion.reply-handler-domain');
	}

	public function getReplyHandlerInstructions() {
	if ($this->supportsReplies()) {
	return pht('Reply to comment.');
	} else {
	return null;
	}
	}

	protected function receiveEmail(PhabricatorMetaMTAReceivedMail $mail) {
	$commit = $this->getMailReceiver();
	$actor = $this->getActor();
	$message = $mail->getCleanTextBody();

	$content_source = PhabricatorContentSource::newForSource(
	PhabricatorContentSource::SOURCE_EMAIL,
	array(
	'id' => $mail->getID(),
	));

	// TODO: Support !raise, !accept, etc.

	$xactions = array();

	$xactions[] = id(new PhabricatorAuditTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_COMMENT)
	->attachComment(
	id(new PhabricatorAuditTransactionComment())
	->setCommitPHID($commit->getPHID())
	->setContent($message));

	$editor = id(new PhabricatorAuditEditor())
	->setActor($actor)
	->setContentSource($content_source)
	->setExcludeMailRecipientPHIDs($this->getExcludeMailRecipientPHIDs())
	->setContinueOnMissingFields(true)
	->applyTransactions($commit, $xactions);
	}

	}
	diff --git a/src/applications/config/option/PhabricatorMetaMTAConfigOptions.php b/src/applications/config/option/PhabricatorMetaMTAConfigOptions.php
	index fb4667a0ff..7952c4273d 100644
	--- a/src/applications/config/option/PhabricatorMetaMTAConfigOptions.php
	+++ b/src/applications/config/option/PhabricatorMetaMTAConfigOptions.php
	@@ -1,360 +1,361 @@
	<?php

	final class PhabricatorMetaMTAConfigOptions
	extends PhabricatorApplicationConfigOptions {

	public function getName() {
	return pht('Mail');
	}

	public function getDescription() {
	return pht('Configure Mail.');
	}

	public function getFontIcon() {
	return 'fa-send';
	}

	public function getGroup() {
	return 'core';
	}

	public function getOptions() {
	$send_as_user_desc = $this->deformat(pht(<<<EODOC
	When a user takes an action which generates an email notification (like
	commenting on a Differential revision), Phabricator can either send that mail
	"From" the user's email address (like "alincoln@logcabin.com") or "From" the
	'metamta.default-address' address.

	The user experience is generally better if Phabricator uses the user's real
	address as the "From" since the messages are easier to organize when they appear
	in mail clients, but this will only work if the server is authorized to send
	email on behalf of the "From" domain. Practically, this means:

	- If you are doing an install for Example Corp and all the users will have
	corporate @corp.example.com addresses and any hosts Phabricator is running
	on are authorized to send email from corp.example.com, you can enable this
	to make the user experience a little better.
	- If you are doing an install for an open source project and your users will
	be registering via Facebook and using personal email addresses, you probably
	should not enable this or all of your outgoing email might vanish into SFP
	blackholes.
	- If your install is anything else, you're safer leaving this off, at least
	initially, since the risk in turning it on is that your outgoing mail will
	never arrive.
	EODOC
	));

	$one_mail_per_recipient_desc = $this->deformat(pht(<<<EODOC
	When a message is sent to multiple recipients (for example, several reviewers on
	a code review), Phabricator can either deliver one email to everyone (e.g., "To:
	alincoln, usgrant, htaft") or separate emails to each user (e.g., "To:
	alincoln", "To: usgrant", "To: htaft"). The major advantages and disadvantages
	of each approach are:

	- One mail to everyone:
	- Recipients can see To/Cc at a glance.
	- If you use mailing lists, you won't get duplicate mail if you're
	a normal recipient and also Cc'd on a mailing list.
	- Getting threading to work properly is harder, and probably requires
	making mail less useful by turning off options.
	- Sometimes people will "Reply All" and everyone will get two mails,
	one from the user and one from Phabricator turning their mail into
	a comment.
	- Not supported with a private reply-to address.
	- Mails are sent in the server default translation.
	- One mail to each user:
	- Recipients need to look in the mail body to see To/Cc.
	- If you use mailing lists, recipients may sometimes get duplicate
	mail.
	- Getting threading to work properly is easier, and threading settings
	can be customzied by each user.
	- "Reply All" no longer spams all other users.
	- Required if private reply-to addresses are configured.
	- Mails are sent in the language of user preference.

	In the code, splitting one outbound email into one-per-recipient is sometimes
	referred to as "multiplexing".
	EODOC
	));

	$herald_hints_description = $this->deformat(pht(<<<EODOC
	You can disable the Herald hints in email if users prefer smaller messages.
	These are the links under the header "WHY DID I GET THIS EMAIL?". If you set
	this to true, they will not appear in any mail. Users can still navigate to
	the links via the web interface.
	EODOC
	));

	$reply_hints_description = $this->deformat(pht(<<<EODOC
	You can disable the hints under "REPLY HANDLER ACTIONS" if users prefer
	smaller messages. The actions themselves will still work properly.
	EODOC
	));

	$recipient_hints_description = $this->deformat(pht(<<<EODOC
	You can disable the "To:" and "Cc:" footers in mail if users prefer smaller
	messages.
	EODOC
	));

	$bulk_description = $this->deformat(pht(<<<EODOC
	If this option is enabled, Phabricator will add a "Precedence: bulk" header to
	transactional mail (e.g., Differential, Maniphest and Herald notifications).
	This may improve the behavior of some auto-responder software and prevent it
	from replying. However, it may also cause deliverability issues -- notably, you
	currently can not send this header via Amazon SES, and enabling this option with
	SES will prevent delivery of any affected mail.
	EODOC
	));

	$email_preferences_description = $this->deformat(pht(<<<EODOC
	You can disable the email preference link in emails if users prefer smaller
	emails.
	EODOC
	));

	$re_prefix_description = $this->deformat(pht(<<<EODOC
	Mail.app on OS X Lion won't respect threading headers unless the subject is
	prefixed with "Re:". If you enable this option, Phabricator will add "Re:" to
	the subject line of all mail which is expected to thread. If you've set
	'metamta.one-mail-per-recipient', users can override this setting in their
	preferences.
	EODOC
	));

	$vary_subjects_description = $this->deformat(pht(<<<EODOC
	If true, allow MetaMTA to change mail subjects to put text like '[Accepted]' and
	'[Commented]' in them. This makes subjects more useful, but might break
	threading on some clients. If you've set 'metamta.one-mail-per-recipient', users
	can override this setting in their preferences.
	EODOC
	));

	$reply_to_description = $this->deformat(pht(<<<EODOC
	If you enable {{metamta.public-replies}}, Phabricator uses "From" to
	authenticate users. You can additionally enable this setting to try to
	authenticate with 'Reply-To'. Note that this is completely spoofable and
	insecure (any user can set any 'Reply-To' address) but depending on the nature
	of your install or other deliverability conditions this might be okay.
	Generally, you can't do much more by spoofing Reply-To than be annoying (you can
	write but not read content). But this is still COMPLETELY INSECURE.
	EODOC
	));

	$adapter_description = $this->deformat(pht(<<<EODOC
	Adapter class to use to transmit mail to the MTA. The default uses
	PHPMailerLite, which will invoke "sendmail". This is appropriate if sendmail
	actually works on your host, but if you haven't configured mail it may not be so
	great. A number of other mailers are available (e.g., SES, SendGrid, SMTP,
	custom mailers), consult "Configuring Outbound Email" in the documentation for
	details.
	EODOC
	));

	$placeholder_description = $this->deformat(pht(<<<EODOC
	When sending a message that has no To recipient (i.e. all recipients are CC'd,
	for example when multiplexing mail), set the To field to the following value. If
	no value is set, messages with no To will have their CCs upgraded to To.
	EODOC
	));

	$public_replies_description = $this->deformat(pht(<<<EODOC
	By default, Phabricator generates unique reply-to addresses and sends a separate
	email to each recipient when you enable reply handling. This is more secure than
	using "From" to establish user identity, but can mean users may receive multiple
	emails when they are on mailing lists. Instead, you can use a single, non-unique
	reply to address and authenticate users based on the "From" address by setting
	this to 'true'. This trades away a little bit of security for convenience, but
	it's reasonable in many installs. Object interactions are still protected using
	hashes in the single public email address, so objects can not be replied to
	blindly.
	EODOC
	));

	$single_description = $this->deformat(pht(<<<EODOC
	If you want to use a single mailbox for Phabricator reply mail, you can use this
	and set a common prefix for reply addresses generated by Phabricator. It will
	make use of the fact that a mail-address such as
	`phabricator+D123+1hjk213h@example.com` will be delivered to the `phabricator`
	user's mailbox. Set this to the left part of the email address and it will be
	prepended to all generated reply addresses.

	For example, if you want to use `phabricator@example.com`, this should be set
	to `phabricator`.
	EODOC
	));

	$address_description = $this->deformat(pht(<<<EODOC
	When email is sent, what format should Phabricator use for user's email
	addresses? Valid values are:

	- `short`: 'gwashington <gwashington@example.com>'
	- `real`: 'George Washington <gwashington@example.com>'
	- `full`: 'gwashington (George Washington) <gwashington@example.com>'

	The default is `full`.
	EODOC
	));

	return array(
	$this->newOption(
	'metamta.default-address',
	'string',
	'noreply@phabricator.example.com')
	->setDescription(pht('Default "From" address.')),
	$this->newOption(
	'metamta.domain',
	'string',
	'phabricator.example.com')
	->setDescription(pht('Domain used to generate Message-IDs.')),
	$this->newOption(
	'metamta.mail-adapter',
	'class',
	'PhabricatorMailImplementationPHPMailerLiteAdapter')
	->setBaseClass('PhabricatorMailImplementationAdapter')
	->setSummary(pht('Control how mail is sent.'))
	->setDescription($adapter_description),
	$this->newOption(
	'metamta.one-mail-per-recipient',
	'bool',
	true)
	->setBoolOptions(
	array(
	pht('Send Mail To Each Recipient'),
	pht('Send Mail To All Recipients'),
	))
	->setSummary(
	pht(
	'Controls whether Phabricator sends one email with multiple '.
	'recipients in the "To:" line, or multiple emails, each with a '.
	'single recipient in the "To:" line.'))
	->setDescription($one_mail_per_recipient_desc),
	$this->newOption('metamta.can-send-as-user', 'bool', false)
	->setBoolOptions(
	array(
	pht('Send as User Taking Action'),
	pht('Send as Phabricator'),
	))
	->setSummary(
	pht(
	'Controls whether Phabricator sends email "From" users.'))
	->setDescription($send_as_user_desc),
	$this->newOption(
	'metamta.reply-handler-domain',
	'string',
	- 'phabricator.example.com')
	+ null)
	->setDescription(pht(
	'Domain used for reply email addresses. Some applications can '.
	- 'configure this domain.')),
	+ 'override this configuration with a different domain.'))
	+ ->addExample('phabricator.example.com', ''),
	$this->newOption('metamta.reply.show-hints', 'bool', true)
	->setBoolOptions(
	array(
	pht('Show Reply Handler Hints'),
	pht('No Reply Handler Hints'),
	))
	->setSummary(pht('Show hints about reply handler actions in email.'))
	->setDescription($reply_hints_description),
	$this->newOption('metamta.herald.show-hints', 'bool', true)
	->setBoolOptions(
	array(
	pht('Show Herald Hints'),
	pht('No Herald Hints'),
	))
	->setSummary(pht('Show hints about Herald rules in email.'))
	->setDescription($herald_hints_description),
	$this->newOption('metamta.recipients.show-hints', 'bool', true)
	->setBoolOptions(
	array(
	pht('Show Recipient Hints'),
	pht('No Recipient Hints'),
	))
	->setSummary(pht('Show "To:" and "Cc:" footer hints in email.'))
	->setDescription($recipient_hints_description),
	$this->newOption('metamta.email-preferences', 'bool', true)
	->setBoolOptions(
	array(
	pht('Show Email Preferences Link'),
	pht('No Email Preferences Link'),
	))
	->setSummary(pht('Show email preferences link in email.'))
	->setDescription($email_preferences_description),
	$this->newOption('metamta.precedence-bulk', 'bool', false)
	->setBoolOptions(
	array(
	pht('Add "Precedence: bulk" Header'),
	pht('No "Precedence: bulk" Header'),
	))
	->setSummary(pht('Control the "Precedence: bulk" header.'))
	->setDescription($bulk_description),
	$this->newOption('metamta.re-prefix', 'bool', false)
	->setBoolOptions(
	array(
	pht('Force "Re:" Subject Prefix'),
	pht('No "Re:" Subject Prefix'),
	))
	->setSummary(pht('Control "Re:" subject prefix, for Mail.app.'))
	->setDescription($re_prefix_description),
	$this->newOption('metamta.vary-subjects', 'bool', true)
	->setBoolOptions(
	array(
	pht('Allow Varied Subjects'),
	pht('Always Use the Same Thread Subject'),
	))
	->setSummary(pht('Control subject variance, for some mail clients.'))
	->setDescription($vary_subjects_description),
	$this->newOption('metamta.insecure-auth-with-reply-to', 'bool', false)
	->setBoolOptions(
	array(
	pht('Allow Insecure Reply-To Auth'),
	pht('Disallow Reply-To Auth'),
	))
	->setSummary(pht('Trust "Reply-To" headers for authentication.'))
	->setDescription($reply_to_description),
	$this->newOption('metamta.placeholder-to-recipient', 'string', null)
	->setSummary(pht('Placeholder for mail with only CCs.'))
	->setDescription($placeholder_description),
	$this->newOption('metamta.public-replies', 'bool', false)
	->setBoolOptions(
	array(
	pht('Use Public Replies (Less Secure)'),
	pht('Use Private Replies (More Secure)'),
	))
	->setSummary(
	pht(
	'Phabricator can use less-secure but mailing list friendly public '.
	'reply addresses.'))
	->setDescription($public_replies_description),
	$this->newOption('metamta.single-reply-handler-prefix', 'string', null)
	->setSummary(
	pht('Allow Phabricator to use a single mailbox for all replies.'))
	->setDescription($single_description),
	$this->newOption('metamta.user-address-format', 'enum', 'full')
	->setEnumOptions(
	array(
	'short' => 'short',
	'real' => 'real',
	'full' => 'full',
	))
	->setSummary(pht('Control how Phabricator renders user names in mail.'))
	->setDescription($address_description)
	->addExample('gwashington <gwashington@example.com>', 'short')
	->addExample('George Washington <gwashington@example.com>', 'real')
	->addExample(
	'gwashington (George Washington) <gwashington@example.com>',
	'full'),
	$this->newOption('metamta.email-body-limit', 'int', 524288)
	->setDescription(
	pht(
	'You can set a limit for the maximum byte size of outbound mail. '.
	'Mail which is larger than this limit will be truncated before '.
	'being sent. This can be useful if your MTA rejects mail which '.
	'exceeds some limit (this is reasonably common). Specify a value '.
	'in bytes.'))
	->setSummary(pht('Global cap for size of generated emails (bytes).'))
	->addExample(524288, pht('Truncate at 512KB'))
	->addExample(1048576, pht('Truncate at 1MB')),
	);
	}

	}
	diff --git a/src/applications/differential/mail/DifferentialReplyHandler.php b/src/applications/differential/mail/DifferentialReplyHandler.php
	index 92d888f3db..7dd64b51c5 100644
	--- a/src/applications/differential/mail/DifferentialReplyHandler.php
	+++ b/src/applications/differential/mail/DifferentialReplyHandler.php
	@@ -1,176 +1,176 @@
	<?php

	/**
	* NOTE: Do not extend this!
	*
	* @concrete-extensible
	*/
	class DifferentialReplyHandler extends PhabricatorMailReplyHandler {

	private $receivedMail;

	public function validateMailReceiver($mail_receiver) {
	if (!($mail_receiver instanceof DifferentialRevision)) {
	throw new Exception('Receiver is not a DifferentialRevision!');
	}
	}

	public function getPrivateReplyHandlerEmailAddress(
	PhabricatorObjectHandle $handle) {
	return $this->getDefaultPrivateReplyHandlerEmailAddress($handle, 'D');
	}

	public function getPublicReplyHandlerEmailAddress() {
	return $this->getDefaultPublicReplyHandlerEmailAddress('D');
	}

	public function getReplyHandlerDomain() {
	- return PhabricatorEnv::getEnvConfig(
	+ return $this->getCustomReplyHandlerDomainIfExists(
	'metamta.differential.reply-handler-domain');
	}

	/*
	* Generate text like the following from the supported commands.
	* "
	*
	* ACTIONS
	* Reply to comment, or !accept, !reject, !abandon, !resign, !reclaim.
	*
	* "
	*/
	public function getReplyHandlerInstructions() {
	if (!$this->supportsReplies()) {
	return null;
	}

	$supported_commands = $this->getSupportedCommands();
	$text = '';
	if (empty($supported_commands)) {
	return $text;
	}

	$comment_command_printed = false;
	if (in_array(DifferentialAction::ACTION_COMMENT, $supported_commands)) {
	$text .= pht('Reply to comment');
	$comment_command_printed = true;

	$supported_commands = array_diff(
	$supported_commands, array(DifferentialAction::ACTION_COMMENT));
	}

	if (!empty($supported_commands)) {
	if ($comment_command_printed) {
	$text .= ', or ';
	}

	$modified_commands = array();
	foreach ($supported_commands as $command) {
	$modified_commands[] = '!'.$command;
	}

	$text .= implode(', ', $modified_commands);
	}

	$text .= '.';

	return $text;
	}

	public function getSupportedCommands() {
	$actions = array(
	DifferentialAction::ACTION_COMMENT,
	DifferentialAction::ACTION_REJECT,
	DifferentialAction::ACTION_ABANDON,
	DifferentialAction::ACTION_RECLAIM,
	DifferentialAction::ACTION_RESIGN,
	DifferentialAction::ACTION_RETHINK,
	'unsubscribe',
	);

	if (PhabricatorEnv::getEnvConfig('differential.enable-email-accept')) {
	$actions[] = DifferentialAction::ACTION_ACCEPT;
	}

	return $actions;
	}

	protected function receiveEmail(PhabricatorMetaMTAReceivedMail $mail) {
	$this->receivedMail = $mail;
	$this->handleAction($mail->getCleanTextBody(), $mail->getAttachments());
	}

	public function handleAction($body, array $attachments) {
	// all commands start with a bang and separated from the body by a newline
	// to make sure that actual feedback text couldn't trigger an action.
	// unrecognized commands will be parsed as part of the comment.
	$command = DifferentialAction::ACTION_COMMENT;
	$supported_commands = $this->getSupportedCommands();
	$regex = "/\A\n!(".implode('\|', $supported_commands).")\n/";
	$matches = array();
	if (preg_match($regex, $body, $matches)) {
	$command = $matches[1];
	$body = trim(str_replace('!'.$command, '', $body));
	}

	$actor = $this->getActor();
	if (!$actor) {
	throw new Exception('No actor is set for the reply action.');
	}

	switch ($command) {
	case 'unsubscribe':
	id(new PhabricatorSubscriptionsEditor())
	->setActor($actor)
	->setObject($this->getMailReceiver())
	->unsubscribe(array($actor->getPHID()))
	->save();
	// TODO: Send the user a confirmation email?
	return null;
	}

	$body = $this->enhanceBodyWithAttachments($body, $attachments);

	$xactions = array();

	if ($command && ($command != DifferentialAction::ACTION_COMMENT)) {
	$xactions[] = id(new DifferentialTransaction())
	->setTransactionType(DifferentialTransaction::TYPE_ACTION)
	->setNewValue($command);
	}

	if (strlen($body)) {
	$xactions[] = id(new DifferentialTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_COMMENT)
	->attachComment(
	id(new DifferentialTransactionComment())
	->setContent($body));
	}

	$editor = id(new DifferentialTransactionEditor())
	->setActor($actor)
	->setExcludeMailRecipientPHIDs($this->getExcludeMailRecipientPHIDs())
	->setContinueOnMissingFields(true)
	->setContinueOnNoEffect(true);

	// NOTE: We have to be careful about this because Facebook's
	// implementation jumps straight into handleAction() and will not have
	// a PhabricatorMetaMTAReceivedMail object.
	if ($this->receivedMail) {
	$content_source = PhabricatorContentSource::newForSource(
	PhabricatorContentSource::SOURCE_EMAIL,
	array(
	'id' => $this->receivedMail->getID(),
	));
	$editor->setContentSource($content_source);
	$editor->setParentMessageID($this->receivedMail->getMessageID());
	} else {
	$content_source = PhabricatorContentSource::newForSource(
	PhabricatorContentSource::SOURCE_LEGACY,
	array());
	$editor->setContentSource($content_source);
	}

	$editor->applyTransactions($this->getMailReceiver(), $xactions);
	}

	}
	diff --git a/src/applications/fund/mail/FundInitiativeReplyHandler.php b/src/applications/fund/mail/FundInitiativeReplyHandler.php
	index 1665eb9729..a2bd2587df 100644
	--- a/src/applications/fund/mail/FundInitiativeReplyHandler.php
	+++ b/src/applications/fund/mail/FundInitiativeReplyHandler.php
	@@ -1,38 +1,34 @@
	<?php

	final class FundInitiativeReplyHandler extends PhabricatorMailReplyHandler {

	public function validateMailReceiver($mail_receiver) {
	if (!($mail_receiver instanceof FundInitiative)) {
	throw new Exception('Mail receiver is not a FundInitiative!');
	}
	}

	public function getPrivateReplyHandlerEmailAddress(
	PhabricatorObjectHandle $handle) {
	return $this->getDefaultPrivateReplyHandlerEmailAddress($handle, 'I');
	}

	public function getPublicReplyHandlerEmailAddress() {
	return $this->getDefaultPublicReplyHandlerEmailAddress('I');
	}

	- public function getReplyHandlerDomain() {
	- return PhabricatorEnv::getEnvConfig('metamta.reply-handler-domain');
	- }
	-
	public function getReplyHandlerInstructions() {
	if ($this->supportsReplies()) {
	// TODO: Implement.
	return null;
	} else {
	return null;
	}
	}

	protected function receiveEmail(PhabricatorMetaMTAReceivedMail $mail) {
	// TODO: Implement.
	return null;
	}

	}
	diff --git a/src/applications/legalpad/mail/LegalpadReplyHandler.php b/src/applications/legalpad/mail/LegalpadReplyHandler.php
	index 006b3efd80..08699d9bdd 100644
	--- a/src/applications/legalpad/mail/LegalpadReplyHandler.php
	+++ b/src/applications/legalpad/mail/LegalpadReplyHandler.php
	@@ -1,86 +1,81 @@
	<?php

	final class LegalpadReplyHandler extends PhabricatorMailReplyHandler {

	public function validateMailReceiver($mail_receiver) {
	if (!($mail_receiver instanceof LegalpadDocument)) {
	throw new Exception('Mail receiver is not a LegalpadDocument!');
	}
	}

	public function getPrivateReplyHandlerEmailAddress(
	PhabricatorObjectHandle $handle) {
	return $this->getDefaultPrivateReplyHandlerEmailAddress($handle, 'L');
	}

	public function getPublicReplyHandlerEmailAddress() {
	return $this->getDefaultPublicReplyHandlerEmailAddress('L');
	}

	- public function getReplyHandlerDomain() {
	- return PhabricatorEnv::getEnvConfig(
	- 'metamta.reply-handler-domain');
	- }
	-
	public function getReplyHandlerInstructions() {
	if ($this->supportsReplies()) {
	return pht('Reply to comment or !unsubscribe.');
	} else {
	return null;
	}
	}

	protected function receiveEmail(PhabricatorMetaMTAReceivedMail $mail) {
	$actor = $this->getActor();
	$document = $this->getMailReceiver();

	$body_data = $mail->parseBody();
	$body = $body_data['body'];
	$body = $this->enhanceBodyWithAttachments($body, $mail->getAttachments());

	$content_source = PhabricatorContentSource::newForSource(
	PhabricatorContentSource::SOURCE_EMAIL,
	array(
	'id' => $mail->getID(),
	));


	$xactions = array();
	$command = $body_data['command'];

	switch ($command) {
	case 'unsubscribe':
	$xaction = id(new LegalpadTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_SUBSCRIBERS)
	->setNewValue(array('-' => array($actor->getPHID())));
	$xactions[] = $xaction;
	break;
	}

	$xactions[] = id(new LegalpadTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_COMMENT)
	->attachComment(
	id(new LegalpadTransactionComment())
	->setDocumentID($document->getID())
	->setLineNumber(0)
	->setLineLength(0)
	->setContent($body));

	$editor = id(new LegalpadDocumentEditor())
	->setActor($actor)
	->setContentSource($content_source)
	->setContinueOnNoEffect(true)
	->setIsPreview(false);

	try {
	$xactions = $editor->applyTransactions($document, $xactions);
	} catch (PhabricatorApplicationTransactionNoEffectException $ex) {
	// just do nothing, though unclear why you're sending a blank email
	return true;
	}

	$head_xaction = head($xactions);
	return $head_xaction->getID();
	}

	}
	diff --git a/src/applications/macro/mail/PhabricatorMacroReplyHandler.php b/src/applications/macro/mail/PhabricatorMacroReplyHandler.php
	index b447895d7f..c2cf90352b 100644
	--- a/src/applications/macro/mail/PhabricatorMacroReplyHandler.php
	+++ b/src/applications/macro/mail/PhabricatorMacroReplyHandler.php
	@@ -1,40 +1,40 @@
	<?php

	final class PhabricatorMacroReplyHandler extends PhabricatorMailReplyHandler {

	public function validateMailReceiver($mail_receiver) {
	if (!($mail_receiver instanceof PhabricatorFileImageMacro)) {
	throw new Exception('Mail receiver is not a PhabricatorFileImageMacro!');
	}
	}

	public function getPrivateReplyHandlerEmailAddress(
	PhabricatorObjectHandle $handle) {
	return $this->getDefaultPrivateReplyHandlerEmailAddress($handle, 'MCRO');
	}

	public function getPublicReplyHandlerEmailAddress() {
	return $this->getDefaultPublicReplyHandlerEmailAddress('MCRO');
	}

	public function getReplyHandlerDomain() {
	- return PhabricatorEnv::getEnvConfig(
	+ return $this->getCustomReplyHandlerDomainIfExists(
	'metamta.macro.reply-handler-domain');
	}

	public function getReplyHandlerInstructions() {
	if ($this->supportsReplies()) {
	// TODO: Implement.
	return null;
	return pht('Reply to comment.');
	} else {
	return null;
	}
	}

	protected function receiveEmail(PhabricatorMetaMTAReceivedMail $mail) {
	// TODO: Implement this.
	return null;
	}

	}
	diff --git a/src/applications/maniphest/mail/ManiphestReplyHandler.php b/src/applications/maniphest/mail/ManiphestReplyHandler.php
	index c853c0f8ec..1c04093f4c 100644
	--- a/src/applications/maniphest/mail/ManiphestReplyHandler.php
	+++ b/src/applications/maniphest/mail/ManiphestReplyHandler.php
	@@ -1,190 +1,190 @@
	<?php

	final class ManiphestReplyHandler extends PhabricatorMailReplyHandler {

	public function validateMailReceiver($mail_receiver) {
	if (!($mail_receiver instanceof ManiphestTask)) {
	throw new Exception('Mail receiver is not a ManiphestTask!');
	}
	}

	public function getPrivateReplyHandlerEmailAddress(
	PhabricatorObjectHandle $handle) {
	return $this->getDefaultPrivateReplyHandlerEmailAddress($handle, 'T');
	}

	public function getPublicReplyHandlerEmailAddress() {
	return $this->getDefaultPublicReplyHandlerEmailAddress('T');
	}

	public function getReplyHandlerDomain() {
	- return PhabricatorEnv::getEnvConfig(
	+ return $this->getCustomReplyHandlerDomainIfExists(
	'metamta.maniphest.reply-handler-domain');
	}

	public function getReplyHandlerInstructions() {
	if ($this->supportsReplies()) {
	return pht(
	'Reply to comment or attach files, or !close, !claim, '.
	'!unsubscribe or !assign <username>.');
	} else {
	return null;
	}
	}

	protected function receiveEmail(PhabricatorMetaMTAReceivedMail $mail) {
	// NOTE: We'll drop in here on both the "reply to a task" and "create a
	// new task" workflows! Make sure you test both if you make changes!

	$task = $this->getMailReceiver();

	$is_new_task = !$task->getID();

	$user = $this->getActor();

	$body_data = $mail->parseBody();
	$body = $body_data['body'];
	$body = $this->enhanceBodyWithAttachments($body, $mail->getAttachments());

	$xactions = array();
	$content_source = PhabricatorContentSource::newForSource(
	PhabricatorContentSource::SOURCE_EMAIL,
	array(
	'id' => $mail->getID(),
	));

	$template = new ManiphestTransaction();

	$is_unsub = false;
	if ($is_new_task) {
	$task = ManiphestTask::initializeNewTask($user);

	$xactions[] = id(new ManiphestTransaction())
	->setTransactionType(ManiphestTransaction::TYPE_STATUS)
	->setNewValue(ManiphestTaskStatus::getDefaultStatus());

	$xactions[] = id(new ManiphestTransaction())
	->setTransactionType(ManiphestTransaction::TYPE_TITLE)
	->setNewValue(nonempty($mail->getSubject(), pht('Untitled Task')));

	$xactions[] = id(new ManiphestTransaction())
	->setTransactionType(ManiphestTransaction::TYPE_DESCRIPTION)
	->setNewValue($body);

	} else {

	$command = $body_data['command'];
	$command_value = $body_data['command_value'];

	$ttype = PhabricatorTransactions::TYPE_COMMENT;
	$new_value = null;
	switch ($command) {
	case 'close':
	$ttype = ManiphestTransaction::TYPE_STATUS;
	$new_value = ManiphestTaskStatus::getDefaultClosedStatus();
	break;
	case 'claim':
	$ttype = ManiphestTransaction::TYPE_OWNER;
	$new_value = $user->getPHID();
	break;
	case 'assign':
	$ttype = ManiphestTransaction::TYPE_OWNER;
	if ($command_value) {
	$assign_users = id(new PhabricatorPeopleQuery())
	->setViewer($user)
	->withUsernames(array($command_value))
	->execute();
	if ($assign_users) {
	$assign_user = head($assign_users);
	$new_value = $assign_user->getPHID();
	}
	}
	// assign to the user by default
	if (!$new_value) {
	$new_value = $user->getPHID();
	}
	break;
	case 'unsubscribe':
	$is_unsub = true;
	$ttype = PhabricatorTransactions::TYPE_SUBSCRIBERS;
	$ccs = $task->getSubscriberPHIDs();
	foreach ($ccs as $k => $phid) {
	if ($phid == $user->getPHID()) {
	unset($ccs[$k]);
	}
	}
	$new_value = array('=' => array_values($ccs));
	break;
	}

	if ($ttype != PhabricatorTransactions::TYPE_COMMENT) {
	$xaction = clone $template;
	$xaction->setTransactionType($ttype);
	$xaction->setNewValue($new_value);
	$xactions[] = $xaction;
	}

	if (strlen($body)) {
	$xaction = clone $template;
	$xaction->setTransactionType(PhabricatorTransactions::TYPE_COMMENT);
	$xaction->attachComment(
	id(new ManiphestTransactionComment())
	->setContent($body));
	$xactions[] = $xaction;
	}
	}

	$ccs = $mail->loadCCPHIDs();
	$old_ccs = $task->getSubscriberPHIDs();
	$new_ccs = array_merge($old_ccs, $ccs);
	if (!$is_unsub) {
	$new_ccs[] = $user->getPHID();
	}
	$new_ccs = array_unique($new_ccs);

	if (array_diff($new_ccs, $old_ccs)) {
	$cc_xaction = clone $template;
	$cc_xaction->setTransactionType(
	PhabricatorTransactions::TYPE_SUBSCRIBERS);
	$cc_xaction->setNewValue(array('=' => $new_ccs));
	$xactions[] = $cc_xaction;
	}

	$event = new PhabricatorEvent(
	PhabricatorEventType::TYPE_MANIPHEST_WILLEDITTASK,
	array(
	'task' => $task,
	'mail' => $mail,
	'new' => $is_new_task,
	'transactions' => $xactions,
	));
	$event->setUser($user);
	PhutilEventEngine::dispatchEvent($event);

	$task = $event->getValue('task');
	$xactions = $event->getValue('transactions');

	$editor = id(new ManiphestTransactionEditor())
	->setActor($user)
	->setParentMessageID($mail->getMessageID())
	->setExcludeMailRecipientPHIDs($this->getExcludeMailRecipientPHIDs())
	->setContinueOnNoEffect(true)
	->setContinueOnMissingFields(true)
	->setContentSource($content_source);
	if ($this->getApplicationEmail()) {
	$editor->setApplicationEmail($this->getApplicationEmail());
	}
	$editor->applyTransactions($task, $xactions);

	$event = new PhabricatorEvent(
	PhabricatorEventType::TYPE_MANIPHEST_DIDEDITTASK,
	array(
	'task' => $task,
	'new' => $is_new_task,
	'transactions' => $xactions,
	));
	$event->setUser($user);
	PhutilEventEngine::dispatchEvent($event);
	}

	}
	diff --git a/src/applications/meta/query/PhabricatorAppSearchEngine.php b/src/applications/meta/query/PhabricatorAppSearchEngine.php
	index a25260b6f6..a9d262724e 100644
	--- a/src/applications/meta/query/PhabricatorAppSearchEngine.php
	+++ b/src/applications/meta/query/PhabricatorAppSearchEngine.php
	@@ -1,255 +1,274 @@
	<?php

	final class PhabricatorAppSearchEngine
	extends PhabricatorApplicationSearchEngine {

	public function getResultTypeDescription() {
	return pht('Applications');
	}

	public function getApplicationClassName() {
	return 'PhabricatorApplicationsApplication';
	}

	public function getPageSize(PhabricatorSavedQuery $saved) {
	return INF;
	}

	public function buildSavedQueryFromRequest(AphrontRequest $request) {
	$saved = new PhabricatorSavedQuery();

	$saved->setParameter('name', $request->getStr('name'));

	$saved->setParameter(
	'installed',
	$this->readBoolFromRequest($request, 'installed'));
	$saved->setParameter(
	'prototypes',
	$this->readBoolFromRequest($request, 'prototypes'));
	$saved->setParameter(
	'firstParty',
	$this->readBoolFromRequest($request, 'firstParty'));
	$saved->setParameter(
	'launchable',
	$this->readBoolFromRequest($request, 'launchable'));
	+ $saved->setParameter(
	+ 'appemails',
	+ $this->readBoolFromRequest($request, 'appemails'));

	return $saved;
	}

	public function buildQueryFromSavedQuery(PhabricatorSavedQuery $saved) {
	$query = id(new PhabricatorApplicationQuery())
	->setOrder(PhabricatorApplicationQuery::ORDER_NAME)
	->withUnlisted(false);

	$name = $saved->getParameter('name');
	if (strlen($name)) {
	$query->withNameContains($name);
	}

	$installed = $saved->getParameter('installed');
	if ($installed !== null) {
	$query->withInstalled($installed);
	}

	$prototypes = $saved->getParameter('prototypes');

	if ($prototypes === null) {
	// NOTE: This is the old name of the 'prototypes' option, see T6084.
	$prototypes = $saved->getParameter('beta');
	$saved->setParameter('prototypes', $prototypes);
	}

	if ($prototypes !== null) {
	$query->withPrototypes($prototypes);
	}

	$first_party = $saved->getParameter('firstParty');
	if ($first_party !== null) {
	$query->withFirstParty($first_party);
	}

	$launchable = $saved->getParameter('launchable');
	if ($launchable !== null) {
	$query->withLaunchable($launchable);
	}

	+ $appemails = $saved->getParameter('appemails');
	+ if ($appemails !== null) {
	+ $query->withApplicationEmailSupport($appemails);
	+ }
	+
	return $query;
	}

	public function buildSearchForm(
	AphrontFormView $form,
	PhabricatorSavedQuery $saved) {

	$form
	->appendChild(
	id(new AphrontFormTextControl())
	->setLabel(pht('Name Contains'))
	->setName('name')
	->setValue($saved->getParameter('name')))
	->appendChild(
	id(new AphrontFormSelectControl())
	->setLabel(pht('Installed'))
	->setName('installed')
	->setValue($this->getBoolFromQuery($saved, 'installed'))
	->setOptions(
	array(
	'' => pht('Show All Applications'),
	'true' => pht('Show Installed Applications'),
	'false' => pht('Show Uninstalled Applications'),
	)))
	->appendChild(
	id(new AphrontFormSelectControl())
	->setLabel(pht('Prototypes'))
	->setName('prototypes')
	->setValue($this->getBoolFromQuery($saved, 'prototypes'))
	->setOptions(
	array(
	'' => pht('Show All Applications'),
	'true' => pht('Show Prototype Applications'),
	'false' => pht('Show Released Applications'),
	)))
	->appendChild(
	id(new AphrontFormSelectControl())
	->setLabel(pht('Provenance'))
	->setName('firstParty')
	->setValue($this->getBoolFromQuery($saved, 'firstParty'))
	->setOptions(
	array(
	'' => pht('Show All Applications'),
	'true' => pht('Show First-Party Applications'),
	'false' => pht('Show Third-Party Applications'),
	)))
	->appendChild(
	id(new AphrontFormSelectControl())
	->setLabel(pht('Launchable'))
	->setName('launchable')
	->setValue($this->getBoolFromQuery($saved, 'launchable'))
	->setOptions(
	array(
	'' => pht('Show All Applications'),
	'true' => pht('Show Launchable Applications'),
	'false' => pht('Show Non-Launchable Applications'),
	+ )))
	+ ->appendChild(
	+ id(new AphrontFormSelectControl())
	+ ->setLabel(pht('Application Emails'))
	+ ->setName('appemails')
	+ ->setValue($this->getBoolFromQuery($saved, 'appemails'))
	+ ->setOptions(
	+ array(
	+ '' => pht('Show All Applications'),
	+ 'true' => pht('Show Applications w/ App Email Support'),
	+ 'false' => pht('Show Applications w/o App Email Support'),
	)));
	}

	protected function getURI($path) {
	return '/applications/'.$path;
	}

	protected function getBuiltinQueryNames() {
	return array(
	'launcher' => pht('Launcher'),
	'all' => pht('All Applications'),
	);
	}

	public function buildSavedQueryFromBuiltin($query_key) {
	$query = $this->newSavedQuery();
	$query->setQueryKey($query_key);

	switch ($query_key) {
	case 'launcher':
	return $query
	->setParameter('installed', true)
	->setParameter('launchable', true);
	case 'all':
	return $query;
	}

	return parent::buildSavedQueryFromBuiltin($query_key);
	}

	protected function renderResultList(
	array $all_applications,
	PhabricatorSavedQuery $query,
	array $handle) {
	assert_instances_of($all_applications, 'PhabricatorApplication');

	$all_applications = msort($all_applications, 'getName');

	if ($query->getQueryKey() == 'launcher') {
	$groups = mgroup($all_applications, 'getApplicationGroup');
	} else {
	$groups = array($all_applications);
	}

	$group_names = PhabricatorApplication::getApplicationGroups();
	$groups = array_select_keys($groups, array_keys($group_names)) + $groups;

	$results = array();
	foreach ($groups as $group => $applications) {
	if (count($groups) > 1) {
	$results[] = phutil_tag(
	'h1',
	array(
	'class' => 'launcher-header',
	),
	idx($group_names, $group, $group));
	}

	$list = new PHUIObjectItemListView();
	$list->addClass('phui-object-item-launcher-list');

	foreach ($applications as $application) {
	$icon = $application->getFontIcon();
	if (!$icon) {
	$icon = 'application';
	}

	// TODO: This sheet doesn't work the same way other sheets do so it
	// ends up with the wrong classes if we try to use PHUIIconView. This
	// is probably all changing in the redesign anyway.

	$icon_view = javelin_tag(
	'span',
	array(
	'class' => 'phui-icon-view phui-font-fa '.$icon,
	'aural' => false,
	),
	'');

	$description = phutil_tag(
	'div',
	array(
	'style' => 'white-space: nowrap; '.
	'overflow: hidden; '.
	'text-overflow: ellipsis;',
	),
	$application->getShortDescription());

	$item = id(new PHUIObjectItemView())
	->setHeader($application->getName())
	->setImageIcon($icon_view)
	->addAttribute($description)
	->addAction(
	id(new PHUIListItemView())
	->setName(pht('Help/Options'))
	->setIcon('fa-cog')
	->setHref('/applications/view/'.get_class($application).'/'));

	if ($application->getBaseURI() && $application->isInstalled()) {
	$item->setHref($application->getBaseURI());
	}

	if (!$application->isInstalled()) {
	$item->addIcon('fa-times', pht('Uninstalled'));
	}

	if ($application->isPrototype()) {
	$item->addIcon('fa-bomb grey', pht('Prototype'));
	}

	if (!$application->isFirstParty()) {
	$item->addIcon('fa-puzzle-piece', pht('Extension'));
	}

	$list->addItem($item);
	}

	$results[] = $list;
	}

	return $results;
	}

	}
	diff --git a/src/applications/meta/query/PhabricatorApplicationQuery.php b/src/applications/meta/query/PhabricatorApplicationQuery.php
	index cd42089fc6..63de1174cf 100644
	--- a/src/applications/meta/query/PhabricatorApplicationQuery.php
	+++ b/src/applications/meta/query/PhabricatorApplicationQuery.php
	@@ -1,159 +1,173 @@
	<?php

	final class PhabricatorApplicationQuery
	extends PhabricatorCursorPagedPolicyAwareQuery {

	private $installed;
	private $prototypes;
	private $firstParty;
	private $nameContains;
	private $unlisted;
	private $classes;
	private $launchable;
	+ private $applicationEmailSupport;
	private $phids;

	const ORDER_APPLICATION = 'order:application';
	const ORDER_NAME = 'order:name';

	private $order = self::ORDER_APPLICATION;

	public function withNameContains($name_contains) {
	$this->nameContains = $name_contains;
	return $this;
	}

	public function withInstalled($installed) {
	$this->installed = $installed;
	return $this;
	}

	public function withPrototypes($prototypes) {
	$this->prototypes = $prototypes;
	return $this;
	}

	public function withFirstParty($first_party) {
	$this->firstParty = $first_party;
	return $this;
	}

	public function withUnlisted($unlisted) {
	$this->unlisted = $unlisted;
	return $this;
	}

	public function withLaunchable($launchable) {
	$this->launchable = $launchable;
	return $this;
	}

	+ public function withApplicationEmailSupport($appemails) {
	+ $this->applicationEmailSupport = $appemails;
	+ return $this;
	+ }
	+
	public function withClasses(array $classes) {
	$this->classes = $classes;
	return $this;
	}

	public function withPHIDs(array $phids) {
	$this->phids = $phids;
	return $this;
	}

	public function setOrder($order) {
	$this->order = $order;
	return $this;
	}

	protected function loadPage() {
	$apps = PhabricatorApplication::getAllApplications();

	if ($this->classes) {
	$classes = array_fuse($this->classes);
	foreach ($apps as $key => $app) {
	if (empty($classes[get_class($app)])) {
	unset($apps[$key]);
	}
	}
	}

	if ($this->phids) {
	$phids = array_fuse($this->phids);
	foreach ($apps as $key => $app) {
	if (empty($phids[$app->getPHID()])) {
	unset($apps[$key]);
	}
	}
	}

	if (strlen($this->nameContains)) {
	foreach ($apps as $key => $app) {
	if (stripos($app->getName(), $this->nameContains) === false) {
	unset($apps[$key]);
	}
	}
	}

	if ($this->installed !== null) {
	foreach ($apps as $key => $app) {
	if ($app->isInstalled() != $this->installed) {
	unset($apps[$key]);
	}
	}
	}

	if ($this->prototypes !== null) {
	foreach ($apps as $key => $app) {
	if ($app->isPrototype() != $this->prototypes) {
	unset($apps[$key]);
	}
	}
	}

	if ($this->firstParty !== null) {
	foreach ($apps as $key => $app) {
	if ($app->isFirstParty() != $this->firstParty) {
	unset($apps[$key]);
	}
	}
	}

	if ($this->unlisted !== null) {
	foreach ($apps as $key => $app) {
	if ($app->isUnlisted() != $this->unlisted) {
	unset($apps[$key]);
	}
	}
	}

	if ($this->launchable !== null) {
	foreach ($apps as $key => $app) {
	if ($app->isLaunchable() != $this->launchable) {
	unset($apps[$key]);
	}
	}
	}

	+ if ($this->applicationEmailSupport !== null) {
	+ foreach ($apps as $key => $app) {
	+ if ($app->supportsEmailIntegration() !=
	+ $this->applicationEmailSupport) {
	+ unset($apps[$key]);
	+ }
	+ }
	+ }

	switch ($this->order) {
	case self::ORDER_NAME:
	$apps = msort($apps, 'getName');
	break;
	case self::ORDER_APPLICATION:
	$apps = $apps;
	break;
	default:
	throw new Exception(
	pht('Unknown order "%s"!', $this->order));
	}

	return $apps;
	}


	public function getQueryApplicationClass() {
	// NOTE: Although this belongs to the "Applications" application, trying
	// to filter its results just leaves us recursing indefinitely. Users
	// always have access to applications regardless of other policy settings
	// anyway.
	return null;
	}

	}
	diff --git a/src/applications/metamta/replyhandler/PhabricatorMailReplyHandler.php b/src/applications/metamta/replyhandler/PhabricatorMailReplyHandler.php
	index be6511e6fc..c320de9b78 100644
	--- a/src/applications/metamta/replyhandler/PhabricatorMailReplyHandler.php
	+++ b/src/applications/metamta/replyhandler/PhabricatorMailReplyHandler.php
	@@ -1,374 +1,385 @@
	<?php

	abstract class PhabricatorMailReplyHandler {

	private $mailReceiver;
	private $applicationEmail;
	private $actor;
	private $excludePHIDs = array();

	final public function setMailReceiver($mail_receiver) {
	$this->validateMailReceiver($mail_receiver);
	$this->mailReceiver = $mail_receiver;
	return $this;
	}

	final public function getMailReceiver() {
	return $this->mailReceiver;
	}

	public function setApplicationEmail(
	PhabricatorMetaMTAApplicationEmail $email) {
	$this->applicationEmail = $email;
	return $this;
	}

	public function getApplicationEmail() {
	return $this->applicationEmail;
	}

	final public function setActor(PhabricatorUser $actor) {
	$this->actor = $actor;
	return $this;
	}

	final public function getActor() {
	return $this->actor;
	}

	final public function setExcludeMailRecipientPHIDs(array $exclude) {
	$this->excludePHIDs = $exclude;
	return $this;
	}

	final public function getExcludeMailRecipientPHIDs() {
	return $this->excludePHIDs;
	}

	abstract public function validateMailReceiver($mail_receiver);
	abstract public function getPrivateReplyHandlerEmailAddress(
	PhabricatorObjectHandle $handle);
	public function getReplyHandlerDomain() {
	+ return $this->getDefaultReplyHandlerDomain();
	+ }
	+ protected function getCustomReplyHandlerDomainIfExists($config_key) {
	+ $domain = PhabricatorEnv::getEnvConfig($config_key);
	+ if ($domain) {
	+ return $domain;
	+ }
	+ return $this->getDefaultReplyHandlerDomain();
	+ }
	+ private function getDefaultReplyHandlerDomain() {
	return PhabricatorEnv::getEnvConfig(
	'metamta.reply-handler-domain');
	}
	+
	abstract public function getReplyHandlerInstructions();
	abstract protected function receiveEmail(
	PhabricatorMetaMTAReceivedMail $mail);

	public function processEmail(PhabricatorMetaMTAReceivedMail $mail) {
	$this->dropEmptyMail($mail);

	return $this->receiveEmail($mail);
	}

	private function dropEmptyMail(PhabricatorMetaMTAReceivedMail $mail) {
	$body = $mail->getCleanTextBody();
	$attachments = $mail->getAttachments();

	if (strlen($body) \|\| $attachments) {
	return;
	}

	// Only send an error email if the user is talking to just Phabricator.
	// We can assume if there is only one "To" address it is a Phabricator
	// address since this code is running and everything.
	$is_direct_mail = (count($mail->getToAddresses()) == 1) &&
	(count($mail->getCCAddresses()) == 0);

	if ($is_direct_mail) {
	$status_code = MetaMTAReceivedMailStatus::STATUS_EMPTY;
	} else {
	$status_code = MetaMTAReceivedMailStatus::STATUS_EMPTY_IGNORED;
	}

	throw new PhabricatorMetaMTAReceivedMailProcessingException(
	$status_code,
	pht(
	'Your message does not contain any body text or attachments, so '.
	'Phabricator can not do anything useful with it. Make sure comment '.
	'text appears at the top of your message: quoted replies, inline '.
	'text, and signatures are discarded and ignored.'));
	}

	public function supportsPrivateReplies() {
	return (bool)$this->getReplyHandlerDomain() &&
	!$this->supportsPublicReplies();
	}

	public function supportsPublicReplies() {
	if (!PhabricatorEnv::getEnvConfig('metamta.public-replies')) {
	return false;
	}
	if (!$this->getReplyHandlerDomain()) {
	return false;
	}
	return (bool)$this->getPublicReplyHandlerEmailAddress();
	}

	final public function supportsReplies() {
	return $this->supportsPrivateReplies() \|\|
	$this->supportsPublicReplies();
	}

	public function getPublicReplyHandlerEmailAddress() {
	return null;
	}

	final public function getRecipientsSummary(
	array $to_handles,
	array $cc_handles) {
	assert_instances_of($to_handles, 'PhabricatorObjectHandle');
	assert_instances_of($cc_handles, 'PhabricatorObjectHandle');

	$body = '';

	if (PhabricatorEnv::getEnvConfig('metamta.recipients.show-hints')) {
	if ($to_handles) {
	$body .= "To: ".implode(', ', mpull($to_handles, 'getName'))."\n";
	}
	if ($cc_handles) {
	$body .= "Cc: ".implode(', ', mpull($cc_handles, 'getName'))."\n";
	}
	}

	return $body;
	}

	final public function getRecipientsSummaryHTML(
	array $to_handles,
	array $cc_handles) {
	assert_instances_of($to_handles, 'PhabricatorObjectHandle');
	assert_instances_of($cc_handles, 'PhabricatorObjectHandle');

	if (PhabricatorEnv::getEnvConfig('metamta.recipients.show-hints')) {
	$body = array();
	if ($to_handles) {
	$body[] = phutil_tag('strong', array(), 'To: ');
	$body[] = phutil_implode_html(', ', mpull($to_handles, 'getName'));
	$body[] = phutil_tag('br');
	}
	if ($cc_handles) {
	$body[] = phutil_tag('strong', array(), 'Cc: ');
	$body[] = phutil_implode_html(', ', mpull($cc_handles, 'getName'));
	$body[] = phutil_tag('br');
	}
	return phutil_tag('div', array(), $body);
	} else {
	return '';
	}

	}

	final public function multiplexMail(
	PhabricatorMetaMTAMail $mail_template,
	array $to_handles,
	array $cc_handles) {
	assert_instances_of($to_handles, 'PhabricatorObjectHandle');
	assert_instances_of($cc_handles, 'PhabricatorObjectHandle');

	$result = array();

	// If MetaMTA is configured to always multiplex, skip the single-email
	// case.
	if (!PhabricatorMetaMTAMail::shouldMultiplexAllMail()) {
	// If private replies are not supported, simply send one email to all
	// recipients and CCs. This covers cases where we have no reply handler,
	// or we have a public reply handler.
	if (!$this->supportsPrivateReplies()) {
	$mail = clone $mail_template;
	$mail->addTos(mpull($to_handles, 'getPHID'));
	$mail->addCCs(mpull($cc_handles, 'getPHID'));

	if ($this->supportsPublicReplies()) {
	$reply_to = $this->getPublicReplyHandlerEmailAddress();
	$mail->setReplyTo($reply_to);
	}

	$result[] = $mail;

	return $result;
	}
	}

	// TODO: This is pretty messy. We should really be doing all of this
	// multiplexing in the task queue, but that requires significant rewriting
	// in the general case. ApplicationTransactions can do it fairly easily,
	// but other mail sites currently can not, so we need to support this
	// junky version until they catch up and we can swap things over.

	$to_handles = $this->expandRecipientHandles($to_handles);
	$cc_handles = $this->expandRecipientHandles($cc_handles);

	$tos = mpull($to_handles, null, 'getPHID');
	$ccs = mpull($cc_handles, null, 'getPHID');

	// Merge all the recipients together. TODO: We could keep the CCs as real
	// CCs and send to a "noreply@domain.com" type address, but keep it simple
	// for now.
	$recipients = $tos + $ccs;

	// When multiplexing mail, explicitly include To/Cc information in the
	// message body and headers.

	$mail_template = clone $mail_template;

	$mail_template->addPHIDHeaders('X-Phabricator-To', array_keys($tos));
	$mail_template->addPHIDHeaders('X-Phabricator-Cc', array_keys($ccs));

	$body = $mail_template->getBody();
	$body .= "\n";
	$body .= $this->getRecipientsSummary($to_handles, $cc_handles);

	$html_body = $mail_template->getHTMLBody();
	if (strlen($html_body)) {
	$html_body .= hsprintf('%s',
	$this->getRecipientsSummaryHTML($to_handles, $cc_handles));
	}

	foreach ($recipients as $phid => $recipient) {

	$mail = clone $mail_template;
	if (isset($to_handles[$phid])) {
	$mail->addTos(array($phid));
	} else if (isset($cc_handles[$phid])) {
	$mail->addCCs(array($phid));
	} else {
	// not good - they should be a to or a cc
	continue;
	}

	$mail->setBody($body);
	$mail->setHTMLBody($html_body);

	$reply_to = null;
	if (!$reply_to && $this->supportsPrivateReplies()) {
	$reply_to = $this->getPrivateReplyHandlerEmailAddress($recipient);
	}

	if (!$reply_to && $this->supportsPublicReplies()) {
	$reply_to = $this->getPublicReplyHandlerEmailAddress();
	}

	if ($reply_to) {
	$mail->setReplyTo($reply_to);
	}

	$result[] = $mail;
	}

	return $result;
	}

	protected function getDefaultPublicReplyHandlerEmailAddress($prefix) {

	$receiver = $this->getMailReceiver();
	$receiver_id = $receiver->getID();
	$domain = $this->getReplyHandlerDomain();

	// We compute a hash using the object's own PHID to prevent an attacker
	// from blindly interacting with objects that they haven't ever received
	// mail about by just sending to D1@, D2@, etc...
	$hash = PhabricatorObjectMailReceiver::computeMailHash(
	$receiver->getMailKey(),
	$receiver->getPHID());

	$address = "{$prefix}{$receiver_id}+public+{$hash}@{$domain}";
	return $this->getSingleReplyHandlerPrefix($address);
	}

	protected function getSingleReplyHandlerPrefix($address) {
	$single_handle_prefix = PhabricatorEnv::getEnvConfig(
	'metamta.single-reply-handler-prefix');
	return ($single_handle_prefix)
	? $single_handle_prefix.'+'.$address
	: $address;
	}

	protected function getDefaultPrivateReplyHandlerEmailAddress(
	PhabricatorObjectHandle $handle,
	$prefix) {

	if ($handle->getType() != PhabricatorPeopleUserPHIDType::TYPECONST) {
	// You must be a real user to get a private reply handler address.
	return null;
	}

	$user = id(new PhabricatorPeopleQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withPHIDs(array($handle->getPHID()))
	->executeOne();

	if (!$user) {
	// This may happen if a user was subscribed to something, and was then
	// deleted.
	return null;
	}

	$receiver = $this->getMailReceiver();
	$receiver_id = $receiver->getID();
	$user_id = $user->getID();
	$hash = PhabricatorObjectMailReceiver::computeMailHash(
	$receiver->getMailKey(),
	$handle->getPHID());
	$domain = $this->getReplyHandlerDomain();

	$address = "{$prefix}{$receiver_id}+{$user_id}+{$hash}@{$domain}";
	return $this->getSingleReplyHandlerPrefix($address);
	}

	final protected function enhanceBodyWithAttachments(
	$body,
	array $attachments,
	$format = '- {F%d, layout=link}') {
	if (!$attachments) {
	return $body;
	}

	$files = id(new PhabricatorFileQuery())
	->setViewer($this->getActor())
	->withPHIDs($attachments)
	->execute();

	// if we have some text then double return before adding our file list
	if ($body) {
	$body .= "\n\n";
	}

	foreach ($files as $file) {
	$file_str = sprintf($format, $file->getID());
	$body .= $file_str."\n";
	}

	return rtrim($body);
	}

	private function expandRecipientHandles(array $handles) {
	if (!$handles) {
	return array();
	}

	$phids = mpull($handles, 'getPHID');
	$map = id(new PhabricatorMetaMTAMemberQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withPHIDs($phids)
	->execute();

	$results = array();
	foreach ($phids as $phid) {
	if (isset($map[$phid])) {
	foreach ($map[$phid] as $expanded_phid) {
	$results[$expanded_phid] = $expanded_phid;
	}
	} else {
	$results[$phid] = $phid;
	}
	}

	return id(new PhabricatorHandleQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withPHIDs($results)
	->execute();
	}

	}
	diff --git a/src/applications/pholio/mail/PholioReplyHandler.php b/src/applications/pholio/mail/PholioReplyHandler.php
	index 08ba11e393..ce7578ff92 100644
	--- a/src/applications/pholio/mail/PholioReplyHandler.php
	+++ b/src/applications/pholio/mail/PholioReplyHandler.php
	@@ -1,40 +1,40 @@
	<?php

	final class PholioReplyHandler extends PhabricatorMailReplyHandler {

	public function validateMailReceiver($mail_receiver) {
	if (!($mail_receiver instanceof PholioMock)) {
	throw new Exception('Mail receiver is not a PholioMock!');
	}
	}

	public function getPrivateReplyHandlerEmailAddress(
	PhabricatorObjectHandle $handle) {
	return $this->getDefaultPrivateReplyHandlerEmailAddress($handle, 'M');
	}

	public function getPublicReplyHandlerEmailAddress() {
	return $this->getDefaultPublicReplyHandlerEmailAddress('M');
	}

	public function getReplyHandlerDomain() {
	- return PhabricatorEnv::getEnvConfig(
	+ return $this->getCustomReplyHandlerDomainIfExists(
	'metamta.pholio.reply-handler-domain');
	}

	public function getReplyHandlerInstructions() {
	if ($this->supportsReplies()) {
	// TODO: Implement.
	return null;
	return pht('Reply to comment.');
	} else {
	return null;
	}
	}

	protected function receiveEmail(PhabricatorMetaMTAReceivedMail $mail) {
	// TODO: Implement this.
	return null;
	}

	}
	diff --git a/src/applications/phortune/mail/PhortuneCartReplyHandler.php b/src/applications/phortune/mail/PhortuneCartReplyHandler.php
	index 92e3022d43..c48d1ce264 100644
	--- a/src/applications/phortune/mail/PhortuneCartReplyHandler.php
	+++ b/src/applications/phortune/mail/PhortuneCartReplyHandler.php
	@@ -1,38 +1,34 @@
	<?php

	final class PhortuneCartReplyHandler extends PhabricatorMailReplyHandler {

	public function validateMailReceiver($mail_receiver) {
	if (!($mail_receiver instanceof PhortuneCart)) {
	throw new Exception('Mail receiver is not a PhortuneCart!');
	}
	}

	public function getPrivateReplyHandlerEmailAddress(
	PhabricatorObjectHandle $handle) {
	return $this->getDefaultPrivateReplyHandlerEmailAddress($handle, 'CART');
	}

	public function getPublicReplyHandlerEmailAddress() {
	return $this->getDefaultPublicReplyHandlerEmailAddress('CART');
	}

	- public function getReplyHandlerDomain() {
	- return PhabricatorEnv::getEnvConfig('metamta.reply-handler-domain');
	- }
	-
	public function getReplyHandlerInstructions() {
	if ($this->supportsReplies()) {
	// TODO: Implement.
	return null;
	} else {
	return null;
	}
	}

	protected function receiveEmail(PhabricatorMetaMTAReceivedMail $mail) {
	// TODO: Implement.
	return null;
	}

	}
	diff --git a/src/applications/phriction/mail/PhrictionReplyHandler.php b/src/applications/phriction/mail/PhrictionReplyHandler.php
	index 1f6564dbd7..b458e13dc0 100644
	--- a/src/applications/phriction/mail/PhrictionReplyHandler.php
	+++ b/src/applications/phriction/mail/PhrictionReplyHandler.php
	@@ -1,41 +1,37 @@
	<?php

	final class PhrictionReplyHandler extends PhabricatorMailReplyHandler {

	public function validateMailReceiver($mail_receiver) {
	if (!($mail_receiver instanceof PhrictionDocument)) {
	throw new Exception('Mail receiver is not a PhrictionDocument!');
	}
	}

	public function getPrivateReplyHandlerEmailAddress(
	PhabricatorObjectHandle $handle) {
	return $this->getDefaultPrivateReplyHandlerEmailAddress(
	$handle,
	PhrictionDocumentPHIDType::TYPECONST);
	}

	public function getPublicReplyHandlerEmailAddress() {
	return $this->getDefaultPublicReplyHandlerEmailAddress(
	PhrictionDocumentPHIDType::TYPECONST);
	}

	- public function getReplyHandlerDomain() {
	- return PhabricatorEnv::getEnvConfig('metamta.reply-handler-domain');
	- }
	-
	public function getReplyHandlerInstructions() {
	if ($this->supportsReplies()) {
	// TODO: Implement.
	return null;
	} else {
	return null;
	}
	}

	protected function receiveEmail(PhabricatorMetaMTAReceivedMail $mail) {
	// TODO: Implement.
	return null;
	}

	}
	diff --git a/src/docs/user/configuration/configuring_inbound_email.diviner b/src/docs/user/configuration/configuring_inbound_email.diviner
	index cc6e85120f..c59199e2c0 100644
	--- a/src/docs/user/configuration/configuring_inbound_email.diviner
	+++ b/src/docs/user/configuration/configuring_inbound_email.diviner
	@@ -1,259 +1,256 @@
	@title Configuring Inbound Email
	@group config

	This document contains instructions for configuring inbound email, so users
	-may update Differential and Maniphest by replying to messages and create
	-Maniphest tasks via email.
	+may interact with some Phabricator applications via email.

	= Preamble =

	This can be extremely difficult to configure correctly. This is doubly true if
	you use a local MTA.

	There are a few approaches available:

	\| Receive Mail With \| Setup \| Cost \| Notes \|
	\|--------\|-------\|------\|-------\|
	\| Mailgun \| Easy \| Cheap \| Recommended \|
	\| SendGrid \| Easy \| Cheap \| \|
	\| Local MTA \| Extremely Difficult \| Free \| Strongly discouraged! \|

	The remainder of this document walks through configuring Phabricator to
	receive mail, and then configuring your chosen transport to deliver mail
	to Phabricator.

	= Configuring Phabricator =

	By default, Phabricator uses a `noreply@phabricator.example.com` email address
	as the 'From' (configurable with `metamta.default-address`) and sets
	'Reply-To' to the user generating the email (e.g., by making a comment), if the
	mail was generated by a user action. This means that users can reply (or
	reply-all) to email to discuss changes, but the conversation won't be recorded
	in Phabricator and users will not be able to take actions like claiming tasks or
	requesting changes to revisions.

	To change this behavior so that users can interact with objects in Phabricator
	-over email, set these configuration keys:
	-
	- - ##metamta.differential.reply-handler-domain##: enables email replies for
	- Differential.
	- - ##metamta.maniphest.reply-handler-domain##: enables email replies for
	- Maniphest.
	-
	-Set these keys to some domain which you configure according to the instructions
	-below, e.g. `phabricator.example.com`. You can set these both to the same
	-domain, and will generally want to. Once you set these keys, emails will use a
	-'Reply-To' like `T123+273+af310f9220ad@example.com`, which -- when
	+over email, change the configuration key `metamta.reply-handler-domain` to some
	+domain you configure according to the instructions below, e.g.
	+`phabricator.example.com`. Once you set this key, emails will use a
	+'Reply-To' like `T123+273+af310f9220ad@phabricator.example.com`, which -- when
	configured correctly, according to the instructions below -- will parse incoming
	-email and allow users to interact with Maniphest tasks and Differential
	-revisions over email.
	+email and allow users to interact with Differential revisions, Maniphest tasks,
	+etc. over email.

	If you don't want Phabricator to take up an entire domain (or subdomain) you
	can configure a general prefix so you can use a single mailbox to receive mail
	on. To make use of this set `metamta.single-reply-handler-prefix` to the
	prefix of your choice, and Phabricator will prepend this to the 'Reply-To'
	mail address. This works because everything up to the first (optional) '+'
	character in an email-address is considered the receiver, and everything
	after is essentially ignored.

	-You can also set up a task creation email address, like `bugs@example.com`,
	-which will create a Maniphest task out of any email which is set to it. To do
	-this, set `metamta.maniphest.public-create-email` in your configuration. This
	-has some mild security implications, see below.
	+You can also set up application email addresses to allow users to create
	+application objects via email. For example, you could configure
	+`bugs@phabricator.example.com` to create a Maniphest task out of any email
	+which is sent to it. To do this, see application settings for a given
	+application at
	+
	+{nav icon=home, name=Home >
	+name=Applications >
	+icon=cog, name=Settings}

	= Security =

	The email reply channel is "somewhat" authenticated. Each reply-to address is
	unique to the recipient and includes a hash of user information and a unique
	object ID, so it can only be used to update that object and only be used to act
	on behalf of the recipient.

	However, if an address is leaked (which is fairly easy -- for instance,
	forwarding an email will leak a live reply address, or a user might take a
	screenshot), //anyone// who can send mail to your reply-to domain may interact
	with the object the email relates to as the user who leaked the mail. Because
	the authentication around email has this weakness, some actions (like accepting
	revisions) are not permitted over email.

	This implementation is an attempt to balance utility and security, but makes
	some sacrifices on both sides to achieve it because of the difficulty of
	authenticating senders in the general case (e.g., where you are an open source
	project and need to interact with users whose email accounts you have no control
	over).

	If you leak a bunch of reply-to addresses by accident, you can change
	`phabricator.mail-key` in your configuration to invalidate all the old hashes.

	You can also set `metamta.public-replies`, which will change how Phabricator
	delivers email. Instead of sending each recipient a unique mail with a personal
	reply-to address, it will send a single email to everyone with a public reply-to
	address. This decreases security because anyone who can spoof a "From" address
	can act as another user, but increases convenience if you use mailing lists and,
	practically, is a reasonable setting for many installs. The reply-to address
	will still contain a hash unique to the object it represents, so users who have
	not received an email about an object can not blindly interact with it.

	-If you enable `metamta.maniphest.public-create-email`, that address also uses
	-the weaker "From" authentication mechanism.
	+If you enable application email addresses, those addresses also use the weaker
	+"From" authentication mechanism.

	NOTE: Phabricator does not currently attempt to verify "From" addresses because
	this is technically complex, seems unreasonably difficult in the general case,
	and no installs have had a need for it yet. If you have a specific case where a
	reasonable mechanism exists to provide sender verification (e.g., DKIM
	signatures are sufficient to authenticate the sender under your configuration,
	or you are willing to require all users to sign their email), file a feature
	request.

	= Testing and Debugging Inbound Email =

	You can use the `bin/mail` utility to test and review inbound mail. This can
	help you determine if mail is being delivered to Phabricator or not:

	phabricator/ $ ./bin/mail list-inbound # List inbound messages.
	phabricator/ $ ./bin-mail show-inbound # Show details about a message.

	You can also test receiving mail, but note that this just simulates receiving
	the mail and doesn't send any information over the network. It is
	primarily aimed at developing email handlers: it will still work properly
	if your inbound email configuration is incorrect or even disabled.

	phabricator/ $ ./bin/mail receive-test # Receive test message.

	Run `bin/mail help <command>` for detailed help on using these commands.

	= Mailgun Setup =

	To use Mailgun, you need a Mailgun account. You can sign up at
	<http://www.mailgun.com>. Provided you have such an account, configure it
	like this:

	- Configure a mail domain according to Mailgun's instructions.
	- Add a Mailgun route with a `catch_all()` rule which takes the action
	`forward("https://phabricator.example.com/mail/mailgun/")`. Replace the
	example domain with your actual domain.

	= SendGrid Setup =

	To use SendGrid, you need a SendGrid account with access to the "Parse API" for
	inbound email. Provided you have such an account, configure it like this:

	- Configure an MX record according to SendGrid's instructions, i.e. add
	##phabricator.example.com MX 10 mx.sendgrid.net.## or similar.
	- Go to the "Parse Incoming Emails" page on SendGrid
	(<http://sendgrid.com/developer/reply>) and add the domain as the
	"Hostname".
	- Add the URL ##https://phabricator.example.com/mail/sendgrid/## as the "Url",
	using your domain (and HTTP instead of HTTPS if you are not configured with
	SSL).
	- If you get an error that the hostname "can't be located or verified", it
	means your MX record is either incorrectly configured or hasn't propagated
	yet.
	- Set ##metamta.maniphest.reply-handler-domain## and/or
	##metamta.differential.reply-handler-domain## to
	"##phabricator.example.com##" (whatever you configured the MX record for),
	depending on whether you want to support email replies for Maniphest,
	Differential, or both.

	That's it! If everything is working properly you should be able to send email
	to ##anything@phabricator.example.com## and it should appear in
	`bin/mail list-inbound` within a few seconds.

	= Local MTA: Installing Mailparse =

	If you're going to run your own MTA, you need to install the PECL mailparse
	extension. In theory, you can do that with:

	$ sudo pecl install mailparse

	You may run into an error like "needs mbstring". If so, try:

	$ sudo yum install php-mbstring # or equivalent
	$ sudo pecl install -n mailparse

	If you get a linker error like this:

	COUNTEREXAMPLE
	PHP Warning: PHP Startup: Unable to load dynamic library
	'/usr/lib64/php/modules/mailparse.so' - /usr/lib64/php/modules/mailparse.so:
	undefined symbol: mbfl_name2no_encoding in Unknown on line 0

	...you need to edit your php.ini file so that mbstring.so is loaded before
	mailparse.so. This is not the default if you have individual files in
	`php.d/`.

	= Local MTA: Configuring Sendmail =

	Before you can configure Sendmail, you need to install Mailparse. See the
	section "Installing Mailparse" above.

	Sendmail is very difficult to configure. First, you need to configure it for
	your domain so that mail can be delivered correctly. In broad strokes, this
	probably means something like this:

	- add an MX record;
	- make sendmail listen on external interfaces;
	- open up port 25 if necessary (e.g., in your EC2 security policy);
	- add your host to /etc/mail/local-host-names; and
	- restart sendmail.

	Now, you can actually configure sendmail to deliver to Phabricator. In
	`/etc/aliases`, add an entry like this:

	phabricator: "\| /path/to/phabricator/scripts/mail/mail_handler.php"

	If you use the `PHABRICATOR_ENV` environmental variable to select a
	configuration, you can pass the value to the script as an argument:

	.../path/to/mail_handler.php <ENV>

	This is an advanced feature which is rarely used. Most installs should run
	without an argument.

	After making this change, run `sudo newaliases`. Now you likely need to symlink
	this script into `/etc/smrsh/`:

	sudo ln -s /path/to/phabricator/scripts/mail/mail_handler.php /etc/smrsh/

	Finally, edit ##/etc/mail/virtusertable## and add an entry like this:

	@yourdomain.com phabricator@localhost

	That will forward all mail to @yourdomain.com to the Phabricator processing
	script. Run ##sudo /etc/mail/make## or similar and then restart sendmail with
	`sudo /etc/init.d/sendmail restart`.

	= Local MTA: Configuring Lamson =

	Before you can configure Lamson, you need to install Mailparse. See the section
	"Installing Mailparse" above.

	In contrast to Sendmail, Lamson is relatively easy to configure. It is fairly
	minimal, and is suitable for a development or testing environment. Lamson
	listens for incoming SMTP mails and passes the content directly to Phabricator.

	To get started, follow the provided instructions
	(<http://lamsonproject.org/docs/getting_started.html>) to set up an instance.
	One likely deployment issue is that binding to port 25 requires root
	privileges. Lamson is capable of starting as root then dropping privileges, but
	you must supply ##-uid## and ##-gid## arguments to do so, as demonstrated by
	Step 8 in Lamson's deployment tutorial (located here:
	<http://lamsonproject.org/docs/deploying_oneshotblog.html>).

	The Lamson handler code itself is very concise; it merely needs to pass the
	content of the email to Phabricator:

	import logging, subprocess
	from lamson.routing import route, stateless
	from lamson import view

	PHABRICATOR_ROOT = "/path/to/phabricator"
	PHABRICATOR_ENV = "custom/myconf"
	LOGGING_ENABLED = True

	@route("(address)@(host)", address=".+")
	@stateless
	def START(message, address=None, host=None):
	if LOGGING_ENABLED:
	logging.debug("%s", message.original)
	process = subprocess.Popen([PHABRICATOR_ROOT + "scripts/mail/mail_handler.php",PHABRICATOR_ENV],stdin=subprocess.PIPE)
	process.communicate(message.original)

File Metadata

Mime Type: text/x-diff
Expires: Thu, Jul 24, 2:15 PM (1 d, 1 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 182741
Default Alt Text: (77 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions