No OneTemporary
Actions

Size

111 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/conf/default.conf.php b/conf/default.conf.php
	index e7e64829ac..8b31f89792 100644
	--- a/conf/default.conf.php
	+++ b/conf/default.conf.php
	@@ -1,1145 +1,1138 @@
	<?php

	// IMPORTANT: DO NOT EDIT THIS FILE.
	// This file is no longer read by default, and your efforts will have no effect.
	// Follow the instructions in the documentation to configure Phabricator.

	return array(

	// The root URI which Phabricator is installed on.
	// Example: "http://phabricator.example.com/"
	'phabricator.base-uri' => null,

	// If you have multiple environments, provide the production environment URI
	// here so that emails, etc., generated in development/sandbox environments
	// contain the right links.
	'phabricator.production-uri' => null,

	// -- IMPORTANT! Security! -------------------------------------------------- //

	// IMPORTANT: By default, Phabricator serves files from the same domain the
	// application lives on. This is convenient but not secure: it creates a large
	// class of vulnerabilities which can not be generally mitigated.
	//
	// To avoid this, you should configure a second domain in the same way you
	// have the primary domain configured (e.g., point it at the same machine and
	// set up the same vhost rules) and provide it here. For instance, if your
	// primary install is on "http://www.phabricator-example.com/", you could
	// configure "http://www.phabricator-files.com/" and specify the entire
	// domain (with protocol) here. This will enforce that files are
	// served only from the alternate domain. Ideally, you should use a
	// completely separate domain name rather than just a different subdomain.
	//
	// It is STRONGLY RECOMMENDED that you configure this. Your install is NOT
	// SECURE unless you do so.
	'security.alternate-file-domain' => null,

	// Default key for HMAC digests where the key is not important (i.e., the
	// hash itself is secret). You can change this if you want (to any other
	// string), but doing so will break existing sessions and CSRF tokens.
	'security.hmac-key' => '[D\t~Y7eNmnQGJ;rnH6aF;m2!vJ8@v8C=Cs:aQS\.Qw',

	// If the web server responds to both HTTP and HTTPS requests but you want
	// users to connect with only HTTPS, you can set this to true to make
	// Phabricator redirect HTTP requests to HTTPS.
	//
	// Normally, you should just configure your server not to accept HTTP traffic,
	// but this setting may be useful if you originally used HTTP and have now
	// switched to HTTPS but don't want to break old links, or if your webserver
	// sits behind a load balancer which terminates HTTPS connections and you
	// can not reasonably configure more granular behavior there.
	//
	// NOTE: Phabricator determines if a request is HTTPS or not by examining the
	// PHP $_SERVER['HTTPS'] variable. If you run Apache/mod_php this will
	// probably be set correctly for you automatically, but if you run Phabricator
	// as CGI/FCGI (e.g., through nginx or lighttpd), you need to configure your
	// web server so that it passes the value correctly based on the connection
	// type. Alternatively, you can add a PHP snippet to the top of this
	// configuration file to directly set $_SERVER['HTTPS'] to the correct value.
	'security.require-https' => false,

	// Is Phabricator permitted to make outbound HTTP requests?
	'security.allow-outbound-http' => true,


	// -- Internationalization -------------------------------------------------- //

	// This allows customizing texts used in Phabricator. The class must extend
	// PhabricatorTranslation.
	'translation.provider' => 'PhabricatorEnglishTranslation',

	// You can use 'translation.override' if you don't want to create a full
	// translation to give users an option for switching to it and you just want
	// to override some strings in the default translation.
	'translation.override' => array(),


	// -- Access Policies ------------------------------------------------------- //

	// Phabricator allows you to set the visibility of objects (like repositories
	// and source code) to "Public", which means anyone on the internet can see
	// them, even without being logged in. This is great for open source, but
	// some installs may never want to make anything public, so this policy is
	// disabled by default. You can enable it here, which will let you set the
	// policy for objects to "Public". With this option disabled, the most open
	// policy is "All Users", which means users must be logged in to view things.
	'policy.allow-public' => false,


	// -- Logging --------------------------------------------------------------- //

	// To enable the Phabricator access log, specify a path here. The Phabricator
	// access log can provide more detailed information about Phabricator access
	// than normal HTTP access logs (for instance, it can show logged-in users,
	// controllers, and other application data). If not set, no log will be
	// written.
	//
	// Make sure the PHP process can write to the log!
	'log.access.path' => null,

	// Format for the access log. If not set, the default format will be used:
	//
	// "[%D]\t%h\t%u\t%M\t%C\t%m\t%U\t%c\t%T"
	//
	// Available variables are:
	//
	// - %c The HTTP response code.
	// - %C The controller which handled the request.
	// - %D The request date.
	// - %e Epoch timestamp.
	// - %h The webserver's host name.
	// - %p The PID of the server process.
	// - %R The HTTP referrer.
	// - %r The remote IP.
	// - %T The request duration, in microseconds.
	// - %U The request path.
	// - %u The logged-in username, if one is logged in.
	// - %P The logged-in user PHID, if one is logged in.
	// - %M The HTTP method.
	// - %m For conduit, the Conduit method which was invoked.
	//
	// If a variable isn't available (for example, %m appears in the file format
	// but the request is not a Conduit request), it will be rendered as "-".
	//
	// Note that the default format is subject to change in the future, so if you
	// rely on the log's format, specify it explicitly.
	'log.access.format' => null,


	// -- DarkConsole ----------------------------------------------------------- //

	// DarkConsole is a administrative debugging/profiling tool built into
	// Phabricator. You can leave it disabled unless you're developing against
	// Phabricator.

	// Determines whether or not DarkConsole is available. DarkConsole exposes
	// some data like queries and stack traces, so you should be careful about
	// turning it on in production (although users can not normally see it, even
	// if the deployment configuration enables it).
	'darkconsole.enabled' => false,

	// Always enable DarkConsole, even for logged out users. This potentially
	// exposes sensitive information to users, so make sure untrusted users can
	// not access an install running in this mode. You should definitely leave
	// this off in production. It is only really useful for using DarkConsole
	// utilities to debug or profile logged-out pages. You must set
	// 'darkconsole.enabled' to use this option.
	'darkconsole.always-on' => false,

	// Map of additional configuration values to lock.
	'config.lock' => array(),

	// Map of additional configuration values to hide.
	'config.hide' => array(),

	// Map of additional configuration values to mask.
	'config.mask' => array(),

	// Ignore setup warnings of the following issues.
	'config.ignore-issues' => array(),

	// -- MySQL --------------------------------------------------------------- //

	// Class providing database configuration. It must implement
	// DatabaseConfigurationProvider.
	'mysql.configuration-provider' => 'DefaultDatabaseConfigurationProvider',

	// The username to use when connecting to MySQL.
	'mysql.user' => 'root',

	// The password to use when connecting to MySQL.
	'mysql.pass' => '',

	// The MySQL server to connect to.
	'mysql.host' => 'localhost',

	// If you want to connect to a different port than the default (which is 3306)
	'mysql.port' => null,

	// Phabricator supports PHP extensions MySQL and MySQLi. It is possible to
	// implement also other access mechanism (e.g. PDO_MySQL). The class must
	// extend AphrontMySQLDatabaseConnectionBase.
	'mysql.implementation' => (extension_loaded('mysqli')
	? 'AphrontMySQLiDatabaseConnection'
	: 'AphrontMySQLDatabaseConnection'),


	// -- Notifications --------------------------------------------------------- //

	// Set this to true to enable real-time notifications. You must also run a
	// notification server for this to work. Consult the documentation in
	// "Notifications User Guide: Setup and Configuration" for instructions.
	'notification.enabled' => false,

	// Client port for the realtime server to listen on, and for realtime clients
	// to connect to. Use "localhost" if you are running the notification server
	// on the same host as the web server.
	'notification.client-uri' => 'http://localhost:22280/',

	// URI and port for the notification root server.
	'notification.server-uri' => 'http://localhost:22281/',

	// The server must be started as root so it can bind to privileged ports, but
	// if you specify a user here it will drop permissions after binding.
	'notification.user' => null,

	// Location where the server should log to.
	'notification.log' => '/var/log/aphlict.log',

	// PID file to use.
	'notification.pidfile' => '/var/run/aphlict.pid',

	// Enable this option to get additional debug output in the browser.
	'notification.debug' => false,


	// -- Email ----------------------------------------------------------------- //

	// Some Phabricator tools send email notifications, e.g. when Differential
	// revisions are updated or Maniphest tasks are changed. These options allow
	// you to configure how email is delivered.

	// You can test your mail setup by going to "MetaMTA" in the web interface,
	// clicking "Send New Message", and then composing a message.

	// Default address to send mail "From".
	'metamta.default-address' => 'noreply@example.com',

	// Domain used to generate Message-IDs.
	'metamta.domain' => 'example.com',

	// 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".
	'metamta.one-mail-per-recipient' => true,

	// 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.
	'metamta.placeholder-to-recipient' => null,

	// 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 MUST NOT enable this or virtually all of your outgoing
	// email will vanish into SFP blackholes.
	// - If your install is anything else, you're much safer leaving this
	// off since the risk in turning it on is that your outgoing mail will
	// mostly never arrive.
	'metamta.can-send-as-user' => false,

	// Limit the maximum size of the body of an email generated for a diff
	// (in bytes).
	'metamta.email-body-limit' => 524288,

	// 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.
	'metamta.mail-adapter' =>
	'PhabricatorMailImplementationPHPMailerLiteAdapter',

	- // When email is sent, try to hand it off to the MTA immediately instead of
	- // queueing it for delivery by the daemons. If you are running the Phabricator
	- // daemons with "phd start", you should disable this to provide a (sometimes
	- // substantial) performance boost. It's on by default to make setup and
	- // configuration a little easier.
	- 'metamta.send-immediately' => true,
	-
	// 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'.
	'metamta.user-address-format' => 'full',

	// If you're using PHPMailer to send email, provide the mailer and options
	// here. PHPMailer is much more enormous than PHPMailerLite, and provides more
	// mailers and greater enormity. You need it when you want to use SMTP
	// instead of sendmail as the mailer.
	'phpmailer.mailer' => 'smtp',
	'phpmailer.smtp-host' => '',
	'phpmailer.smtp-port' => 25,

	// When using PHPMailer with SMTP, you can set this to one of "tls" or "ssl"
	// to use TLS or SSL. Leave it blank for vanilla SMTP. If you're sending
	// via Gmail, set it to "ssl".
	'phpmailer.smtp-protocol' => '',

	// Set following if your smtp server requires authentication.
	'phpmailer.smtp-user' => null,
	'phpmailer.smtp-password' => null,

	// If you're using Amazon SES to send email, provide your AWS access key
	// and AWS secret key here. To set up Amazon SES with Phabricator, you need
	// to:
	// - Make sure 'metamta.mail-adapter' is set to:
	// "PhabricatorMailImplementationAmazonSESAdapter"
	// - Make sure 'metamta.can-send-as-user' is false.
	// - Make sure 'metamta.default-address' is configured to something sensible.
	// - Make sure 'metamta.default-address' is a validated SES "From" address.
	'amazon-ses.access-key' => null,
	'amazon-ses.secret-key' => null,

	// If you're using Sendgrid to send email, provide your access credentials
	// here. This will use the REST API. You can also use Sendgrid as a normal
	// SMTP service.
	'sendgrid.api-user' => null,
	'sendgrid.api-key' => null,

	// You can configure a reply handler domain so that email sent from Maniphest
	// will have a special "Reply To" address like "T123+82+af19f@example.com"
	// that allows recipients to reply by email and interact with tasks. For
	// instructions on configurating reply handlers, see the article
	// "Configuring Inbound Email" in the Phabricator documentation. By default,
	// this is set to 'null' and Phabricator will use a generic 'noreply@' address
	// or the address of the acting user instead of a special reply handler
	// address (see 'metamta.default-address'). If you set a domain here,
	// Phabricator will begin generating private reply handler addresses. See
	// also 'metamta.maniphest.reply-handler' to further configure behavior.
	// This key should be set to the domain part after the @, like "example.com".
	'metamta.maniphest.reply-handler-domain' => null,

	// You can follow the instructions in "Configuring Inbound Email" in the
	// Phabricator documentation and set 'metamta.maniphest.reply-handler-domain'
	// to support updating Maniphest tasks by email. If you want more advanced
	// customization than this provides, you can override the reply handler
	// class with an implementation of your own. This will allow you to do things
	// like have a single public reply handler or change how private reply
	// handlers are generated and validated.
	//
	// This key should be set to a loadable subclass of
	// PhabricatorMailReplyHandler.
	'metamta.maniphest.reply-handler' => 'ManiphestReplyHandler',

	// If you don't want phabricator to take up an entire domain
	// (or subdomain for that matter), you can use this and set a common
	// prefix for mail sent 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 users mailbox.
	// Set this to the left part of the email address and it well get
	// prepended to all outgoing mail. If you want to use e.g.
	// 'phabricator@example.com' this should be set to 'phabricator'.
	'metamta.single-reply-handler-prefix' => null,

	// Prefix prepended to mail sent by Maniphest. You can change this to
	// distinguish between testing and development installs, for example.
	'metamta.maniphest.subject-prefix' => '[Maniphest]',

	// See 'metamta.maniphest.reply-handler-domain'. This does the same thing, but
	// affects Pholio.
	'metamta.pholio.reply-handler-domain' => null,

	// Prefix prepended to mail sent by Pholio.
	'metamta.pholio.subject-prefix' => '[Pholio]',

	// See 'metamta.maniphest.reply-handler-domain'. This does the same thing, but
	// affects Macro.
	'metamta.macro.reply-handler-domain' => null,

	// Prefix prepended to mail sent by Macro.
	'metamta.macro.subject-prefix' => '[Macro]',

	// See 'metamta.maniphest.reply-handler-domain'. This does the same thing,
	// but allows email replies via Differential.
	'metamta.differential.reply-handler-domain' => null,

	// See 'metamta.maniphest.reply-handler'. This does the same thing, but
	// affects Differential.
	'metamta.differential.reply-handler' => 'DifferentialReplyHandler',

	// Prefix prepended to mail sent by Differential.
	'metamta.differential.subject-prefix' => '[Differential]',

	// Set this to true if you want patches to be attached to mail from
	// Differential. This won't work if you are using SendGrid as your mail
	// adapter.
	'metamta.differential.attach-patches' => false,

	// To include patches in email bodies, set this to a positive integer. Patches
	// will be inlined if they are at most that many lines. For instance, a value
	// of 100 means "inline patches if they are no longer than 100 lines". By
	// default, patches are not inlined.
	'metamta.differential.inline-patches' => 0,

	// If you enable either of the options above, you can choose what format
	// patches are sent in. Valid options are 'unified' (like diff -u) or 'git'.
	'metamta.differential.patch-format' => 'unified',

	// Enables a different format for comments in differential emails.
	// Differential will create unified diffs around the comment, which
	// will give enough context for people who are only viewing the
	// reviews in email to understand what is going on. The context will
	// be created based on the range of the comment.
	'metamta.differential.unified-comment-context' => false,

	// Prefix prepended to mail sent by Diffusion.
	'metamta.diffusion.subject-prefix' => '[Diffusion]',

	// See 'metamta.maniphest.reply-handler-domain'. This does the same thing,
	// but allows email replies via Diffusion.
	'metamta.diffusion.reply-handler-domain' => null,

	// See 'metamta.maniphest.reply-handler'. This does the same thing, but
	// affects Diffusion.
	'metamta.diffusion.reply-handler' => 'PhabricatorAuditReplyHandler',

	// Set this to true if you want patches to be attached to commit notifications
	// from Diffusion. This won't work with SendGrid.
	'metamta.diffusion.attach-patches' => false,

	// To include patches in Diffusion email bodies, set this to a positive
	// integer. Patches will be inlined if they are at most that many lines.
	// By default, patches are not inlined.
	'metamta.diffusion.inline-patches' => 0,

	// If you've enabled attached patches or inline patches for commit emails, you
	// can establish a hard byte limit on their size. You should generally set
	// reasonable byte and time limits (defaults are 1MB and 60 seconds) to avoid
	// sending ridiculously enormous email for changes like "importing an external
	// library" or "accidentally committed this full-length movie as text".
	'metamta.diffusion.byte-limit' => 1024 * 1024,

	// If you've enabled attached patches or inline patches for commit emails, you
	// can establish a hard time limit on generating them.
	'metamta.diffusion.time-limit' => 60,

	// Prefix prepended to mail sent by Package.
	'metamta.package.subject-prefix' => '[Package]',

	// See 'metamta.maniphest.reply-handler'. This does similar thing for package
	// except that it only supports sending out mail and doesn't handle incoming
	// email.
	'metamta.package.reply-handler' => 'OwnersPackageReplyHandler',

	// 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.
	'metamta.public-replies' => false,

	// You can configure an email address like "bugs@phabricator.example.com"
	// which will automatically create Maniphest tasks when users send email
	// to it. This relies on the "From" address to authenticate users, so it is
	// is not completely secure. To set this up, enter a complete email
	// address like "bugs@phabricator.example.com" and then configure mail to
	// that address so it routed to Phabricator (if you've already configured
	// reply handlers, you're probably already done). See "Configuring Inbound
	// Email" in the documentation for more information.
	'metamta.maniphest.public-create-email' => null,

	// 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, you know, this is
	// still COMPLETELY INSECURE.
	'metamta.insecure-auth-with-reply-to' => false,

	// If you enable 'metamta.maniphest.public-create-email' and create an
	// email address like "bugs@phabricator.example.com", it will default to
	// rejecting mail which doesn't come from a known user. However, you might
	// want to let anyone send email to this address; to do so, set a default
	// author here (a Phabricator username). A typical use of this might be to
	// create a "System Agent" user called "bugs" and use that name here. If you
	// specify a valid username, mail will always be accepted and used to create
	// a task, even if the sender is not a system user. The original email
	// address will be stored in an 'From Email' field on the task.
	'metamta.maniphest.default-public-author' => null,

	'metamta.herald.show-hints' => true,

	// You can disable the hints under "REPLY HANDLER ACTIONS" if users prefer
	// smaller messages. The actions themselves will still work properly.
	'metamta.reply.show-hints' => true,

	// You can disable the "To:" and "Cc:" footers in mail if users prefer
	// smaller messages.
	'metamta.recipients.show-hints' => true,

	// 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.
	'metamta.precedence-bulk' => false,

	// 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.
	'metamta.re-prefix' => false,

	// 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.
	'metamta.vary-subjects' => true,

	// -- Auth ------------------------------------------------------------------ //

	// Maximum number of simultaneous web sessions each user is permitted to have.
	// Setting this to "1" will prevent a user from logging in on more than one
	// browser at the same time.
	'auth.sessions.web' => 5,

	// Maximum number of simultaneous Conduit sessions each user is permitted
	// to have.
	'auth.sessions.conduit' => 5,

	// If true, email addresses must be verified (by clicking a link in an
	// email) before a user can login. By default, verification is optional
	// unless 'auth.email-domains' is nonempty (see below).
	'auth.require-email-verification' => false,

	// You can restrict allowed email addresses to certain domains (like
	// "yourcompany.com") by setting a list of allowed domains here. Users will
	// only be allowed to register using email addresses at one of the domains,
	// and will only be able to add new email addresses for these domains. If
	// you configure this, it implies 'auth.require-email-verification'.
	//
	// To configure email domains, set a list of domains like this:
	//
	// array(
	// 'yourcompany.com',
	// 'yourcompany.co.uk',
	// )
	//
	// You should omit the "@" from domains. Note that the domain must match
	// exactly. If you allow "yourcompany.com", that permits "joe@yourcompany.com"
	// but rejects "joe@mail.yourcompany.com".
	'auth.email-domains' => array(),

	// You can provide an arbitrary block of HTML here, which will appear on the
	// login screen. Normally, you'd use this to provide login or registration
	// instructions to users.
	'auth.login-message' => null,


	// -- Accounts -------------------------------------------------------------- //

	// Is basic account information (email, real name, profile picture) editable?
	// If you set up Phabricator to automatically synchronize account information
	// from some other authoritative system, you can disable this to ensure
	// information remains consistent across both systems.
	'account.editable' => true,

	// When users set or reset a password, it must have at least this many
	// characters.
	'account.minimum-password-length' => 8,


	// -- Recaptcha ------------------------------------------------------------- //

	// Is Recaptcha enabled? If disabled, captchas will not appear. You should
	// enable Recaptcha if your install is public-facing, as it hinders
	// brute-force attacks.
	'recaptcha.enabled' => false,

	// Your Recaptcha public key, obtained from Recaptcha.
	'recaptcha.public-key' => null,

	// Your Recaptcha private key, obtained from Recaptcha.
	'recaptcha.private-key' => null,


	// -- Misc ------------------------------------------------------------------ //

	// This is hashed with other inputs to generate CSRF tokens. If you want, you
	// can change it to some other string which is unique to your install. This
	// will make your install more secure in a vague, mostly theoretical way. But
	// it will take you like 3 seconds of mashing on your keyboard to set it up so
	// you might as well.
	'phabricator.csrf-key' => '0b7ec0592e0a2829d8b71df2fa269b2c6172eca3',

	// This is hashed with other inputs to generate mail tokens. If you want, you
	// can change it to some other string which is unique to your install. In
	// particular, you will want to do this if you accidentally send a bunch of
	// mail somewhere you shouldn't have, to invalidate all old reply-to
	// addresses.
	'phabricator.mail-key' => '5ce3e7e8787f6e40dfae861da315a5cdf1018f12',


	// PHP requires that you set a timezone in your php.ini before using date
	// functions, or it will emit a warning. If this isn't possible (for instance,
	// because you are using HPHP) you can set some valid constant for
	// date_default_timezone_set() here and Phabricator will set it on your
	// behalf, silencing the warning.
	'phabricator.timezone' => null,

	// Show stack traces when unhandled exceptions occur, force reloading of
	// static resources (skipping the cache), show an error callout if a page
	// generated PHP errors, warnings, or notices, force disk reads when
	// reloading, and generally make development easier. This option should not
	// be enabled in production.
	'phabricator.developer-mode' => false,

	// When users write comments which have URIs, they'll be automatically linked
	// if the protocol appears in this set. This whitelist is primarily to prevent
	// security issues like javascript:// URIs.
	'uri.allowed-protocols' => array(
	'http' => true,
	'https' => true,
	),

	// Tokenizers are UI controls which let the user select other users, email
	// addresses, project names, etc., by typing the first few letters and having
	// the control autocomplete from a list. They can load their data in two ways:
	// either in a big chunk up front, or as the user types. By default, the data
	// is loaded in a big chunk. This is simpler and performs better for small
	// datasets. However, if you have a very large number of users or projects,
	// (in the ballpark of more than a thousand), loading all that data may become
	// slow enough that it's worthwhile to query on demand instead. This makes
	// the typeahead slightly less responsive but overall performance will be much
	// better if you have a ton of stuff. You can figure out which setting is
	// best for your install by changing this setting and then playing with a
	// user tokenizer (like the user selectors in Maniphest or Differential) and
	// seeing which setting loads faster and feels better.
	'tokenizer.ondemand' => false,

	// By default, Phabricator includes some silly nonsense in the UI, such as
	// a submit button called "Clowncopterize" in Differential and a call to
	// "Leap Into Action". If you'd prefer more traditional UI strings like
	// "Submit", you can set this flag to disable most of the jokes and easter
	// eggs.
	'phabricator.serious-business' => false,

	// Should Phabricator show beta applications on the homepage
	'phabricator.show-beta-applications' => false,

	// Contains a list of uninstalled applications
	'phabricator.uninstalled-applications' => array(),

	// Allowing non-members to interact with tasks over email.
	'phabricator.allow-email-users' => false,

	// -- Welcome Screen -------------------------------------------------------- //

	// The custom HTML content for the Phabricator welcome screen.
	'welcome.html' => null,

	// -- Files ----------------------------------------------------------------- //

	// Lists which uploaded file types may be viewed in the browser. If a file
	// has a mime type which does not appear in this list, it will always be
	// downloaded instead of displayed. This is mainly a usability
	// consideration, since browsers tend to freak out when viewing enormous
	// binary files.
	//
	// The keys in this array are viewable mime types; the values are the mime
	// types they will be delivered as when they are viewed in the browser.
	//
	// IMPORTANT: Configure 'security.alternate-file-domain' above! Your install
	// is NOT safe if it is left unconfigured.
	'files.viewable-mime-types' => array(
	'image/jpeg' => 'image/jpeg',
	'image/jpg' => 'image/jpg',
	'image/png' => 'image/png',
	'image/gif' => 'image/gif',
	'text/plain' => 'text/plain; charset=utf-8',
	'text/x-diff' => 'text/plain; charset=utf-8',

	// ".ico" favicon files, which have mime type diversity. See:
	// http://en.wikipedia.org/wiki/ICO_(file_format)#MIME_type
	'image/x-ico' => 'image/x-icon',
	'image/x-icon' => 'image/x-icon',
	'image/vnd.microsoft.icon' => 'image/x-icon',
	),

	// List of mime types which can be used as the source for an <img /> tag.
	// This should be a subset of 'files.viewable-mime-types' and exclude files
	// like text.
	'files.image-mime-types' => array(
	'image/jpeg' => true,
	'image/jpg' => true,
	'image/png' => true,
	'image/gif' => true,
	'image/x-ico' => true,
	'image/x-icon' => true,
	'image/vnd.microsoft.icon' => true,
	),

	// Configuration option for enabling imagemagick
	// to resize animated profile pictures (gif)
	'files.enable-imagemagick' => false,

	// -- Storage --------------------------------------------------------------- //

	// Phabricator allows users to upload files, and can keep them in various
	// storage engines. This section allows you to configure which engines
	// Phabricator will use, and how it will use them.

	// The largest filesize Phabricator will store in the MySQL BLOB storage
	// engine, which just uses a database table to store files. While this isn't a
	// best practice, it's really easy to set up. Set this to 0 to disable use of
	// the MySQL blob engine.
	'storage.mysql-engine.max-size' => 1000000,

	// Phabricator provides a local disk storage engine, which just writes files
	// to some directory on local disk. The webserver must have read/write
	// permissions on this directory. This is straightforward and suitable for
	// most installs, but will not scale past one web frontend unless the path
	// is actually an NFS mount, since you'll end up with some of the files
	// written to each web frontend and no way for them to share. To use the
	// local disk storage engine, specify the path to a directory here. To
	// disable it, specify null.
	'storage.local-disk.path' => null,

	// If you want to store files in Amazon S3, specify an AWS access and secret
	// key here and a bucket name below.
	'amazon-s3.access-key' => null,
	'amazon-s3.secret-key' => null,

	// To use a custom endpoint, specify it here. Normally, you do not need to
	// configure this.
	'amazon-s3.endpoint' => null,

	// Set this to a valid Amazon S3 bucket to store files there. You must also
	// configure S3 access keys above.
	'storage.s3.bucket' => null,

	// Phabricator uses a storage engine selector to choose which storage engine
	// to use when writing file data. If you add new storage engines or want to
	// provide very custom rules (e.g., write images to one storage engine and
	// other files to a different one), you can provide an alternate
	// implementation here. The default engine will use choose MySQL, Local Disk,
	// and S3, in that order, if they have valid configurations above and a file
	// fits within configured limits.
	'storage.engine-selector' => 'PhabricatorDefaultFileStorageEngineSelector',

	// Set the size of the largest file a user may upload. This is used to render
	// text like "Maximum file size: 10MB" on interfaces where users can upload
	// files, and files larger than this size will be rejected.
	//
	// Specify this limit in bytes, or using a "K", "M", or "G" suffix.
	//
	// NOTE: Setting this to a large size is NOT sufficient to allow users to
	// upload large files. You must also configure a number of other settings. To
	// configure file upload limits, consult the article "Configuring File Upload
	// Limits" in the documentation. Once you've configured some limit across all
	// levels of the server, you can set this limit to an appropriate value and
	// the UI will then reflect the actual configured limit.
	'storage.upload-size-limit' => null,

	// Phabricator puts databases in a namespace, which defualts to "phabricator"
	// -- for instance, the Differential database is named
	// "phabricator_differential" by default. You can change this namespace if you
	// want. Normally, you should not do this unless you are developing
	// Phabricator and using namespaces to separate multiple sandbox datasets.
	'storage.default-namespace' => 'phabricator',


	// -- Search ---------------------------------------------------------------- //

	// Phabricator supports Elastic Search; to use it, specify a host like
	// 'http://elastic.example.com:9200/' here.
	'search.elastic.host' => null,

	// Phabricator uses a search engine selector to choose which search engine
	// to use when indexing and reconstructing documents, and when executing
	// queries. You can override the engine selector to provide a new selector
	// class which can select some custom engine you implement, if you want to
	// store your documents in some search engine which does not have default
	// support.
	'search.engine-selector' => 'PhabricatorDefaultSearchEngineSelector',


	// -- Differential ---------------------------------------------------------- //

	'differential.revision-custom-detail-renderer' => null,

	// List of file regexps where whitespace is meaningful and should not
	// use 'ignore-all' by default
	'differential.whitespace-matters' => array(
	'/\.py$/',
	'/\.l?hs$/',
	),

	'differential.field-selector' => 'DifferentialDefaultFieldSelector',

	// Differential can show "Host" and "Path" fields on revisions, with
	// information about the machine and working directory where the
	// change came from. These fields are disabled by default because they may
	// occasionally have sensitive information; you can set this to true to
	// enable them.
	'differential.show-host-field' => false,

	// Differential has a required "Test Plan" field by default, which requires
	// authors to fill out information about how they verified the correctness of
	// their changes when sending code for review. If you'd prefer not to use
	// this field, you can disable it here. You can also make it optional
	// (instead of required) below.
	'differential.show-test-plan-field' => true,

	// Differential has a required "Test Plan" field by default. You can make it
	// optional by setting this to false. You can also completely remove it above,
	// if you prefer.
	'differential.require-test-plan-field' => true,

	// If you set this to true, users can "!accept" revisions via email (normally,
	// they can take other actions but can not "!accept"). This action is disabled
	// by default because email authentication can be configured to be very weak,
	// and, socially, email "!accept" is kind of sketchy and implies revisions may
	// not actually be receiving thorough review.
	'differential.enable-email-accept' => false,

	// List of file regexps that should be treated as if they are generated by
	// an automatic process, and thus get hidden by default in differential.
	'differential.generated-paths' => array(
	// '/config\.h$/',
	// '#/autobuilt/#',
	),

	// If you set this to true, users can accept their own revisions. This action
	// is disabled by default because it's most likely not a behavior you want,
	// but it proves useful if you are working alone on a project and want to make
	// use of all of differential's features.
	'differential.allow-self-accept' => false,

	// If you set this to true, any user can close any revision so long as it has
	// been accepted. This can be useful depending on your development model. For
	// example, github-style pull requests where the reviewer is often the
	// actual committer can benefit from turning this option to true. If false,
	// only the submitter can close a revision.
	'differential.always-allow-close' => false,

	// If you set this to true, any user can reopen a revision so long as it has
	// been closed. This can be useful if a revision is accidentally closed or
	// if a developer changes his or her mind after closing a revision. If it is
	// false, reopening is not allowed.
	'differential.allow-reopen' => false,

	// Revisions newer than this number of days are marked as fresh in Action
	// Required and Revisions Waiting on You views. Only work days (not weekends
	// and holidays) are included. Set to 0 to disable this feature.
	'differential.days-fresh' => 1,

	// Similar to 'differential.days-fresh' but marks stale revisions. If the
	// revision is even older than it is marked as old.
	'differential.days-stale' => 3,

	// -- Repositories ---------------------------------------------------------- //

	// The default location in which to store local copies of repositories.
	// Anything stored in this directory will be assumed to be under the
	// control of phabricator, which means that Phabricator will try to do some
	// maintenance on working copies if there are problems (such as a change
	// to the remote origin url). This maintenance may include completely
	// removing (and recloning) anything in this directory.
	//
	// When set to null, this option is ignored (i.e. Phabricator will not fully
	// control any working copies).
	'repository.default-local-path' => null,

	// -- Maniphest ------------------------------------------------------------- //

	// What should the default task priority be in create flows?
	// See the constants in @{class:ManiphestTaskPriority} for valid values.
	// Defaults to "needs triage".
	'maniphest.default-priority' => 90,

	// -- Phame ----------------------------------------------------------------- //

	// Should Phame users have Disqus comment widget, and if so what's the
	// website shortname to use? For example, secure.phabricator.org uses
	// "phabricator", which we registered with Disqus. If you aren't familiar
	// with Disqus, see:
	// Disqus quick start guide - http://docs.disqus.com/help/4/
	// Information on shortnames - http://docs.disqus.com/help/68/
	'disqus.shortname' => null,

	// Directories to look for Phame skins inside of.
	'phame.skins' => array(
	'externals/skins/',
	),

	// -- Remarkup -------------------------------------------------------------- //

	// If you enable this, linked YouTube videos will be embeded inline. This has
	// mild security implications (you'll leak referrers to YouTube) and is pretty
	// silly (but sort of awesome).
	'remarkup.enable-embedded-youtube' => false,


	// -- Cache ----------------------------------------------------------------- //

	// Set this to false to disable the use of gzdeflate()-based compression in
	// some caches. This may give you less performant (but more debuggable)
	// caching.
	'cache.enable-deflate' => true,

	// -- Garbage Collection ---------------------------------------------------- //

	// Phabricator generates various logs and caches in the database which can
	// be garbage collected after a while to make the total data size more
	// manageable. To run garbage collection, launch a
	// PhabricatorGarbageCollector daemon.

	// These 'ttl' keys configure how much old data the GC daemon keeps around.
	// Objects older than the ttl will be collected. Set any value to 0 to store
	// data indefinitely.

	'gcdaemon.ttl.herald-transcripts' => 30 * (24 * 60 * 60),
	'gcdaemon.ttl.daemon-logs' => 7 * (24 * 60 * 60),
	'gcdaemon.ttl.differential-parse-cache' => 14 * (24 * 60 * 60),
	'gcdaemon.ttl.markup-cache' => 30 * (24 * 60 * 60),
	'gcdaemon.ttl.task-archive' => 14 * (24 * 60 * 60),
	'gcdaemon.ttl.general-cache' => 30 * (24 * 60 * 60),


	// -- Feed ------------------------------------------------------------------ //

	// If you set this to true, you can embed Phabricator activity feeds in other
	// pages using iframes. These feeds are completely public, and a login is not
	// required to view them! This is intended for things like open source
	// projects that want to expose an activity feed on the project homepage.
	//
	// NOTE: You must also set `policy.allow-public` to true for this setting
	// to work properly.
	'feed.public' => false,

	// If you set this to a list of http URIs, when a feed story is published a
	// task will be created for each uri that posts the story data to the uri.
	// Daemons automagically retry failures 100 times, waiting $fail_count * 60s
	// between each subsequent failure. Be sure to keep the daemon console
	// (/daemon/) open while developing and testing your end points.
	//
	// NOTE: URIs are not validated, the URI must return http status 200 within
	// 30 seconds, and no permission checks are performed.
	'feed.http-hooks' => array(),

	// -- Drydock --------------------------------------------------------------- //

	// If you want to use Drydock's builtin EC2 Blueprints, configure your AWS
	// EC2 credentials here.
	'amazon-ec2.access-key' => null,
	'amazon-ec2.secret-key' => null,


	// -- Customization --------------------------------------------------------- //

	// Paths to additional phutil libraries to load.
	'load-libraries' => array(),

	'aphront.default-application-configuration-class' =>
	'AphrontDefaultApplicationConfiguration',

	// Directory that phd (the Phabricator daemon control script) should use to
	// track running daemons.
	'phd.pid-directory' => '/var/tmp/phd/pid',

	// Directory that the Phabricator daemons should use to store the log file
	'phd.log-directory' => '/var/tmp/phd/log',

	// Number of "TaskMaster" daemons that "phd start" should start. You can
	// raise this if you have a task backlog, or explicitly launch more with
	// "phd launch <N> taskmaster".
	'phd.start-taskmasters' => 4,

	// Launch daemons in "verbose" mode by default. This creates a lot of output,
	// but can help debug issues. Daemons launched in debug mode with "phd debug"
	// are always launched in verbose mode. See also 'phd.trace'.
	'phd.verbose' => false,

	// Launch daemons in "trace" mode by default. This creates an ENORMOUS amount
	// of output, but can help debug issues. Daemons launched in debug mode with
	// "phd debug" are always launched in trace mdoe. See also 'phd.verbose'.
	'phd.trace' => false,

	// This value is an input to the hash function when building resource hashes.
	// It has no security value, but if you accidentally poison user caches (by
	// pushing a bad patch or having something go wrong with a CDN, e.g.) you can
	// change this to something else and rebuild the Celerity map to break user
	// caches. Unless you are doing Celerity development, it is exceptionally
	// unlikely that you need to modify this.
	'celerity.resource-hash' => 'd9455ea150622ee044f7931dabfa52aa',

	// Minify static resources by removing whitespace and comments. You should
	// enable this in production, but disable it in development.
	'celerity.minify' => false,

	// You can respond to various application events by installing listeners,
	// which will receive callbacks when interesting things occur. Specify a list
	// of classes which extend PhabricatorEventListener here.
	'events.listeners' => array(),

	// -- Syntax Highlighting --------------------------------------------------- //

	// Phabricator can highlight PHP by default and use Pygments for other
	// languages if enabled. You can provide a custom highlighter engine by
	// extending class PhutilSyntaxHighlighterEngine.
	'syntax-highlighter.engine' => 'PhutilDefaultSyntaxHighlighterEngine',

	// If you want syntax highlighting for other languages than PHP then you can
	// install the python package 'Pygments', make sure the 'pygmentize' script is
	// available in the $PATH of the webserver, and then enable this.
	'pygments.enabled' => false,

	// In places that we display a dropdown to syntax-highlight code,
	// this is where that list is defined.
	// Syntax is 'lexer-name' => 'Display Name',
	'pygments.dropdown-choices' => array(
	'apacheconf' => 'Apache Configuration',
	'bash' => 'Bash Scripting',
	'brainfuck' => 'Brainf*ck',
	'c' => 'C',
	'cpp' => 'C++',
	'css' => 'CSS',
	'd' => 'D',
	'diff' => 'Diff',
	'django' => 'Django Templating',
	'erb' => 'Embedded Ruby/ERB',
	'erlang' => 'Erlang',
	'haskell' => 'Haskell',
	'html' => 'HTML',
	'java' => 'Java',
	'js' => 'Javascript',
	'mysql' => 'MySQL',
	'objc' => 'Objective-C',
	'perl' => 'Perl',
	'php' => 'PHP',
	'rest' => 'reStructuredText',
	'text' => 'Plain Text',
	'python' => 'Python',
	'rainbow' => 'Rainbow',
	'remarkup' => 'Remarkup',
	'ruby' => 'Ruby',
	'xml' => 'XML',
	),

	// This is an override list of regular expressions which allows you to choose
	// what language files are highlighted as. If your projects have certain rules
	// about filenames or use unusual or ambiguous language extensions, you can
	// create a mapping here. This is an ordered dictionary of regular expressions
	// which will be tested against the filename. They should map to either an
	// explicit language as a string value, or a numeric index into the captured
	// groups as an integer.
	'syntax.filemap' => array(
	// Example: Treat all '*.xyz' files as PHP.
	// '@\\.xyz$@' => 'php',

	// Example: Treat 'httpd.conf' as 'apacheconf'.
	// '@/httpd\\.conf$@' => 'apacheconf',

	// Example: Treat all '*.x.bak' file as '.x'. NOTE: we map to capturing
	// group 1 by specifying the mapping as "1".
	// '@\\.([^.]+)\\.bak$@' => 1,

	'@\.arcconfig$@' => 'js',
	'@\.divinerconfig$@' => 'js',
	),

	// Set the default monospaced font style for users who haven't set a custom
	// style.
	'style.monospace' => '10px "Menlo", "Consolas", "Monaco", monospace',
	'style.monospace.windows' => '11px "Menlo", "Consolas", "Monaco", monospace',


	// -- Debugging ------------------------------------------------------------- //

	// Enable this to change HTTP redirects into normal pages with a link to the
	// redirection target. For example, after you submit a form you'll get a page
	// saying "normally, you'd be redirected...". This is useful to examine
	// service or profiler information on write pathways, or debug redirects. It
	// also makes the UX horrible for normal use, so you should enable it only
	// when debugging.
	//
	// NOTE: This does not currently work for forms with Javascript "workflow",
	// since the redirect happens in Javascript.
	'debug.stop-on-redirect' => false,

	// Set the rate for how often to do sampled profiling. On average, one
	// request for every number of requests specified here will be sampled.
	// Set this value to 0 to completely disable profiling. In a production
	// environment, this value should either be set to 0 (to disable) or to
	// a large number (to sample only a few requests).
	'debug.profile-rate' => 0,

	// -- Environment ---------------------------------------------------------- //

	// Phabricator occasionally shells out to other binaries on the server.
	// An example of this is the "pygmentize" command, used to syntax-highlight
	// code written in languages other than PHP. By default, it is assumed that
	// these binaries are in the $PATH of the user running Phabricator (normally
	// 'apache', 'httpd', or 'nobody'). Here you can add extra directories to
	// the $PATH environment variable, for when these binaries are in non-standard
	// locations.
	'environment.append-paths' => array(),

	// -- Audit ---------------------------------------------------------- //

	// Controls whether or not task creator can Close Audits
	'audit.can-author-close-audit' => false,
	);
	diff --git a/src/applications/config/check/PhabricatorSetupCheckExtraConfig.php b/src/applications/config/check/PhabricatorSetupCheckExtraConfig.php
	index 5e135c080f..eb1cfc0027 100644
	--- a/src/applications/config/check/PhabricatorSetupCheckExtraConfig.php
	+++ b/src/applications/config/check/PhabricatorSetupCheckExtraConfig.php
	@@ -1,177 +1,179 @@
	<?php

	final class PhabricatorSetupCheckExtraConfig extends PhabricatorSetupCheck {

	protected function executeChecks() {
	$ancient_config = self::getAncientConfig();

	$all_keys = PhabricatorEnv::getAllConfigKeys();
	$all_keys = array_keys($all_keys);
	sort($all_keys);

	$defined_keys = PhabricatorApplicationConfigOptions::loadAllOptions();

	foreach ($all_keys as $key) {
	if (isset($defined_keys[$key])) {
	continue;
	}

	if (isset($ancient_config[$key])) {
	$summary = pht(
	'This option has been removed. You may delete it at your '.
	'convenience.');
	$message = pht(
	"The configuration option '%s' has been removed. You may delete ".
	"it at your convenience.".
	"\n\n%s",
	$key,
	$ancient_config[$key]);
	$short = pht('Obsolete Config');
	$name = pht('Obsolete Configuration Option "%s"', $key);
	} else {
	$summary = pht("This option is not recognized. It may be misspelled.");
	$message = pht(
	"The configuration option '%s' is not recognized. It may be ".
	"misspelled, or it might have existed in an older version of ".
	"Phabricator. It has no effect, and should be corrected or deleted.",
	$key);
	$short = pht('Unknown Config');
	$name = pht('Unknown Configuration Option "%s"', $key);
	}

	$issue = $this->newIssue('config.unknown.'.$key)
	->setShortName($short)
	->setName($name)
	->setSummary($summary);

	$stack = PhabricatorEnv::getConfigSourceStack();
	$stack = $stack->getStack();

	$found = array();
	$found_local = false;
	$found_database = false;

	foreach ($stack as $source_key => $source) {
	$value = $source->getKeys(array($key));
	if ($value) {
	$found[] = $source->getName();
	if ($source instanceof PhabricatorConfigDatabaseSource) {
	$found_database = true;
	}
	if ($source instanceof PhabricatorConfigLocalSource) {
	$found_local = true;
	}
	}
	}

	$message = $message."\n\n".pht(
	"This configuration value is defined in these %d ".
	"configuration source(s): %s.",
	count($found),
	implode(', ', $found));
	$issue->setMessage($message);

	if ($found_local) {
	$command = csprintf('phabricator/ $ ./bin/config delete %s', $key);
	$issue->addCommand($command);
	}

	if ($found_database) {
	$issue->addPhabricatorConfig($key);
	}
	}
	}

	/**
	* Return a map of deleted config options. Keys are option keys; values are
	* explanations of what happened to the option.
	*/
	public static function getAncientConfig() {
	$reason_auth = pht(
	'This option has been migrated to the "Auth" application. Your old '.
	'configuration is still in effect, but now stored in "Auth" instead of '.
	'configuration. Going forward, you can manage authentication from '.
	'the web UI.');

	$auth_config = array(
	'controller.oauth-registration',
	'auth.password-auth-enabled',
	'facebook.auth-enabled',
	'facebook.registration-enabled',
	'facebook.auth-permanent',
	'facebook.application-id',
	'facebook.application-secret',
	'facebook.require-https-auth',
	'github.auth-enabled',
	'github.registration-enabled',
	'github.auth-permanent',
	'github.application-id',
	'github.application-secret',
	'google.auth-enabled',
	'google.registration-enabled',
	'google.auth-permanent',
	'google.application-id',
	'google.application-secret',
	'ldap.auth-enabled',
	'ldap.hostname',
	'ldap.port',
	'ldap.base_dn',
	'ldap.search_attribute',
	'ldap.search-first',
	'ldap.username-attribute',
	'ldap.real_name_attributes',
	'ldap.activedirectory_domain',
	'ldap.version',
	'ldap.referrals',
	'ldap.anonymous-user-name',
	'ldap.anonymous-user-password',
	'ldap.start-tls',
	'disqus.auth-enabled',
	'disqus.registration-enabled',
	'disqus.auth-permanent',
	'disqus.application-id',
	'disqus.application-secret',
	'phabricator.oauth-uri',
	'phabricator.auth-enabled',
	'phabricator.registration-enabled',
	'phabricator.auth-permanent',
	'phabricator.application-id',
	'phabricator.application-secret',
	);

	$ancient_config = array_fill_keys($auth_config, $reason_auth);

	$markup_reason = pht(
	'Custom remarkup rules are now added by subclassing '.
	'PhabricatorRemarkupCustomInlineRule or '.
	'PhabricatorRemarkupCustomBlockRule.');

	$ancient_config += array(
	'phid.external-loaders' =>
	pht(
	'External loaders have been replaced. Extend `PhabricatorPHIDType` '.
	'to implement new PHID and handle types.'),
	'maniphest.custom-task-extensions-class' =>
	pht(
	'Maniphest fields are now loaded automatically. You can configure '.
	'them with `maniphest.fields`.'),
	'maniphest.custom-fields' =>
	pht(
	'Maniphest fields are now defined in '.
	'`maniphest.custom-field-definitions`. Existing definitions have '.
	'been migrated.'),
	'differential.custom-remarkup-rules' => $markup_reason,
	'differential.custom-remarkup-block-rules' => $markup_reason,
	'auth.sshkeys.enabled' => pht(
	'SSH keys are now actually useful, so they are always enabled.'),
	'differential.anonymous-access' => pht(
	'Phabricator now has meaningful global access controls. See '.
	'`policy.allow-public`.'),
	'celerity.resource-path' => pht(
	'An alternate resource map is no longer supported. Instead, use '.
	'multiple maps. See T4222.'),
	+ 'metamta.send-immediately' => pht(
	+ 'Mail is now always delivered by the daemons.'),
	);

	return $ancient_config;
	}
	}
	diff --git a/src/applications/config/option/PhabricatorMetaMTAConfigOptions.php b/src/applications/config/option/PhabricatorMetaMTAConfigOptions.php
	index afd7738e27..18ae3d27c5 100644
	--- a/src/applications/config/option/PhabricatorMetaMTAConfigOptions.php
	+++ b/src/applications/config/option/PhabricatorMetaMTAConfigOptions.php
	@@ -1,355 +1,338 @@
	<?php

	final class PhabricatorMetaMTAConfigOptions
	extends PhabricatorApplicationConfigOptions {

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

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

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

	$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
	-));
	-
	- $immediately_description = $this->deformat(pht(<<<EODOC
	-When email is sent, try to hand it off to the MTA immediately instead of
	-queueing it for delivery by the daemons. If you are running the Phabricator
	-daemons with "phd start", you should disable this to provide a (sometimes
	-substantial) performance boost. It's on by default to make setup and
	-configuration a little easier.
	-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')
	->setDescription(pht(
	'Domain used for reply email addresses. Some applications can '.
	'configure this domain.')),
	$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.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.send-immediately', 'bool', true)
	- ->setBoolOptions(
	- array(
	- pht('Send Immediately (Slow)'),
	- pht('Send Via Daemons (Must Run Daemons)'),
	- ))
	- ->setSummary(pht('Improve performance by sending email via daemons.'))
	- ->setDescription($immediately_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/metamta/storage/PhabricatorMetaMTAMail.php b/src/applications/metamta/storage/PhabricatorMetaMTAMail.php
	index a6c2e1e08f..ec01faf9a2 100644
	--- a/src/applications/metamta/storage/PhabricatorMetaMTAMail.php
	+++ b/src/applications/metamta/storage/PhabricatorMetaMTAMail.php
	@@ -1,839 +1,827 @@
	<?php

	/**
	* See #394445 for an explanation of why this thing even exists.
	*
	* @task recipients Managing Recipients
	*/
	final class PhabricatorMetaMTAMail extends PhabricatorMetaMTADAO {

	const STATUS_QUEUE = 'queued';
	const STATUS_SENT = 'sent';
	const STATUS_FAIL = 'fail';
	const STATUS_VOID = 'void';

	const MAX_RETRIES = 250;
	const RETRY_DELAY = 5;

	protected $parameters;
	protected $status;
	protected $message;
	protected $retryCount;
	protected $nextRetry;
	protected $relatedPHID;

	private $excludePHIDs = array();
	private $overrideNoSelfMail = false;

	public function __construct() {

	$this->status = self::STATUS_QUEUE;
	$this->retryCount = 0;
	$this->nextRetry = time();
	$this->parameters = array();

	parent::__construct();
	}

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

	protected function setParam($param, $value) {
	$this->parameters[$param] = $value;
	return $this;
	}

	protected function getParam($param, $default = null) {
	return idx($this->parameters, $param, $default);
	}

	/**
	* Set tags (@{class:MetaMTANotificationType} constants) which identify the
	* content of this mail in a general way. These tags are used to allow users
	* to opt out of receiving certain types of mail, like updates when a task's
	* projects change.
	*
	* @param list<const> List of @{class:MetaMTANotificationType} constants.
	* @return this
	*/
	public function setMailTags(array $tags) {
	$this->setParam('mailtags', array_unique($tags));
	return $this;
	}

	public function getMailTags() {
	return $this->getParam('mailtags', array());
	}

	/**
	* In Gmail, conversations will be broken if you reply to a thread and the
	* server sends back a response without referencing your Message-ID, even if
	* it references a Message-ID earlier in the thread. To avoid this, use the
	* parent email's message ID explicitly if it's available. This overwrites the
	* "In-Reply-To" and "References" headers we would otherwise generate. This
	* needs to be set whenever an action is triggered by an email message. See
	* T251 for more details.
	*
	* @param string The "Message-ID" of the email which precedes this one.
	* @return this
	*/
	public function setParentMessageID($id) {
	$this->setParam('parent-message-id', $id);
	return $this;
	}

	public function getParentMessageID() {
	return $this->getParam('parent-message-id');
	}

	public function getSubject() {
	return $this->getParam('subject');
	}

	public function addTos(array $phids) {
	$phids = array_unique($phids);
	$this->setParam('to', $phids);
	return $this;
	}

	public function addRawTos(array $raw_email) {
	$this->setParam('raw-to', $raw_email);
	return $this;
	}

	public function addCCs(array $phids) {
	$phids = array_unique($phids);
	$this->setParam('cc', $phids);
	return $this;
	}

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

	public function getOverrideNoSelfMailPreference() {
	return $this->overrideNoSelfMail;
	}

	public function setOverrideNoSelfMailPreference($override) {
	$this->overrideNoSelfMail = $override;
	return $this;
	}

	public function getTranslation(array $objects) {
	$default_translation = PhabricatorEnv::getEnvConfig('translation.provider');
	$return = null;
	$recipients = array_merge(
	idx($this->parameters, 'to', array()),
	idx($this->parameters, 'cc', array()));
	foreach (array_select_keys($objects, $recipients) as $object) {
	$translation = null;
	if ($object instanceof PhabricatorUser) {
	$translation = $object->getTranslation();
	}
	if (!$translation) {
	$translation = $default_translation;
	}
	if ($return && $translation != $return) {
	return $default_translation;
	}
	$return = $translation;
	}

	if (!$return) {
	$return = $default_translation;
	}

	return $return;
	}

	public function addPHIDHeaders($name, array $phids) {
	foreach ($phids as $phid) {
	$this->addHeader($name, '<'.$phid.'>');
	}
	return $this;
	}

	public function addHeader($name, $value) {
	$this->parameters['headers'][] = array($name, $value);
	return $this;
	}

	public function addAttachment(PhabricatorMetaMTAAttachment $attachment) {
	$this->parameters['attachments'][] = $attachment->toDictionary();
	return $this;
	}

	public function getAttachments() {
	$dicts = $this->getParam('attachments');

	$result = array();
	foreach ($dicts as $dict) {
	$result[] = PhabricatorMetaMTAAttachment::newFromDictionary($dict);
	}
	return $result;
	}

	public function setAttachments(array $attachments) {
	assert_instances_of($attachments, 'PhabricatorMetaMTAAttachment');
	$this->setParam('attachments', mpull($attachments, 'toDictionary'));
	return $this;
	}

	public function setFrom($from) {
	$this->setParam('from', $from);
	return $this;
	}

	public function setReplyTo($reply_to) {
	$this->setParam('reply-to', $reply_to);
	return $this;
	}

	public function setSubject($subject) {
	$this->setParam('subject', $subject);
	return $this;
	}

	public function setSubjectPrefix($prefix) {
	$this->setParam('subject-prefix', $prefix);
	return $this;
	}

	public function setVarySubjectPrefix($prefix) {
	$this->setParam('vary-subject-prefix', $prefix);
	return $this;
	}

	public function setBody($body) {
	$this->setParam('body', $body);
	return $this;
	}

	public function getBody() {
	return $this->getParam('body');
	}

	public function setIsHTML($html) {
	$this->setParam('is-html', $html);
	return $this;
	}

	public function getSimulatedFailureCount() {
	return nonempty($this->getParam('simulated-failures'), 0);
	}

	public function setSimulatedFailureCount($count) {
	$this->setParam('simulated-failures', $count);
	return $this;
	}

	public function getWorkerTaskID() {
	return $this->getParam('worker-task');
	}

	public function setWorkerTaskID($id) {
	$this->setParam('worker-task', $id);
	return $this;
	}

	public function getToPHIDs() {
	return $this->getParam('to', array());
	}

	public function getRawToAddresses() {
	return $this->getParam('raw-to', array());
	}

	public function getCcPHIDs() {
	return $this->getParam('cc', array());
	}

	/**
	* Flag that this is an auto-generated bulk message and should have bulk
	* headers added to it if appropriate. Broadly, this means some flavor of
	* "Precedence: bulk" or similar, but is implementation and configuration
	* dependent.
	*
	* @param bool True if the mail is automated bulk mail.
	* @return this
	*/
	public function setIsBulk($is_bulk) {
	$this->setParam('is-bulk', $is_bulk);
	return $this;
	}

	/**
	* Use this method to set an ID used for message threading. MetaMTA will
	* set appropriate headers (Message-ID, In-Reply-To, References and
	* Thread-Index) based on the capabilities of the underlying mailer.
	*
	* @param string Unique identifier, appropriate for use in a Message-ID,
	* In-Reply-To or References headers.
	* @param bool If true, indicates this is the first message in the thread.
	* @return this
	*/
	public function setThreadID($thread_id, $is_first_message = false) {
	$this->setParam('thread-id', $thread_id);
	$this->setParam('is-first-message', $is_first_message);
	return $this;
	}

	/**
	- * Save a newly created mail to the database and attempt to send it
	- * immediately if the server is configured for immediate sends. When
	- * applications generate new mail they should generally use this method to
	- * deliver it. If the server doesn't use immediate sends, this has the same
	- * effect as calling save(): the mail will eventually be delivered by the
	- * MetaMTA daemon.
	+ * Save a newly created mail to the database. The mail will eventually be
	+ * delivered by the MetaMTA daemon.
	*
	* @return this
	*/
	public function saveAndSend() {
	- $ret = null;
	-
	- if (PhabricatorEnv::getEnvConfig('metamta.send-immediately')) {
	- $ret = $this->sendNow();
	- } else {
	- $ret = $this->save();
	- }
	-
	- return $ret;
	+ return $this->save();
	}

	protected function didWriteData() {
	parent::didWriteData();

	if (!$this->getWorkerTaskID()) {
	$mailer_task = PhabricatorWorker::scheduleTask(
	'PhabricatorMetaMTAWorker',
	$this->getID());

	$this->setWorkerTaskID($mailer_task->getID());
	$this->save();
	}
	}


	public function buildDefaultMailer() {
	return PhabricatorEnv::newObjectFromConfig('metamta.mail-adapter');
	}


	/**
	* Attempt to deliver an email immediately, in this process.
	*
	* @param bool Try to deliver this email even if it has already been
	* delivered or is in backoff after a failed delivery attempt.
	* @param PhabricatorMailImplementationAdapter Use a specific mail adapter,
	* instead of the default.
	*
	* @return void
	*/
	public function sendNow(
	$force_send = false,
	PhabricatorMailImplementationAdapter $mailer = null) {

	if ($mailer === null) {
	$mailer = $this->buildDefaultMailer();
	}

	if (!$force_send) {
	if ($this->getStatus() != self::STATUS_QUEUE) {
	throw new Exception("Trying to send an already-sent mail!");
	}

	if (time() < $this->getNextRetry()) {
	throw new Exception("Trying to send an email before next retry!");
	}
	}

	try {
	$params = $this->parameters;

	$actors = $this->loadAllActors();
	$deliverable_actors = $this->filterDeliverableActors($actors);

	$default_from = PhabricatorEnv::getEnvConfig('metamta.default-address');
	if (empty($params['from'])) {
	$mailer->setFrom($default_from);
	}

	$is_first = idx($params, 'is-first-message');
	unset($params['is-first-message']);

	$is_threaded = (bool)idx($params, 'thread-id');

	$reply_to_name = idx($params, 'reply-to-name', '');
	unset($params['reply-to-name']);

	$add_cc = array();
	$add_to = array();

	foreach ($params as $key => $value) {
	switch ($key) {
	case 'from':
	$from = $value;
	$actor_email = null;
	$actor_name = null;
	$actor = idx($actors, $from);
	if ($actor) {
	$actor_email = $actor->getEmailAddress();
	$actor_name = $actor->getName();
	}
	$can_send_as_user = $actor_email &&
	PhabricatorEnv::getEnvConfig('metamta.can-send-as-user');

	if ($can_send_as_user) {
	$mailer->setFrom($actor_email);
	} else {
	$from_email = coalesce($actor_email, $default_from);
	$from_name = coalesce($actor_name, pht('Phabricator'));

	if (empty($params['reply-to'])) {
	$params['reply-to'] = $from_email;
	$params['reply-to-name'] = $from_name;
	}

	$mailer->setFrom($default_from, $from_name);
	}
	break;
	case 'reply-to':
	$mailer->addReplyTo($value, $reply_to_name);
	break;
	case 'to':
	$to_actors = array_select_keys($deliverable_actors, $value);
	$add_to = array_merge(
	$add_to,
	mpull($to_actors, 'getEmailAddress'));
	break;
	case 'raw-to':
	$add_to = array_merge($add_to, $value);
	break;
	case 'cc':
	$cc_actors = array_select_keys($deliverable_actors, $value);
	$add_cc = array_merge(
	$add_cc,
	mpull($cc_actors, 'getEmailAddress'));
	break;
	case 'headers':
	foreach ($value as $pair) {
	list($header_key, $header_value) = $pair;

	// NOTE: If we have \n in a header, SES rejects the email.
	$header_value = str_replace("\n", " ", $header_value);

	$mailer->addHeader($header_key, $header_value);
	}
	break;
	case 'attachments':
	$value = $this->getAttachments();
	foreach ($value as $attachment) {
	$mailer->addAttachment(
	$attachment->getData(),
	$attachment->getFilename(),
	$attachment->getMimeType());
	}
	break;
	case 'body':
	$max = PhabricatorEnv::getEnvConfig('metamta.email-body-limit');
	if (strlen($value) > $max) {
	$value = phutil_utf8_shorten($value, $max);
	$value .= "\n";
	$value .= pht('(This email was truncated at %d bytes.)', $max);
	}
	$mailer->setBody($value);
	break;
	case 'subject':
	// Only try to use preferences if everything is multiplexed, so we
	// get consistent behavior.
	$use_prefs = self::shouldMultiplexAllMail();

	$prefs = null;
	if ($use_prefs) {

	// If multiplexing is enabled, some recipients will be in "Cc"
	// rather than "To". We'll move them to "To" later (or supply a
	// dummy "To") but need to look for the recipient in either the
	// "To" or "Cc" fields here.
	$target_phid = head(idx($params, 'to', array()));
	if (!$target_phid) {
	$target_phid = head(idx($params, 'cc', array()));
	}

	if ($target_phid) {
	$user = id(new PhabricatorUser())->loadOneWhere(
	'phid = %s',
	$target_phid);
	if ($user) {
	$prefs = $user->loadPreferences();
	}
	}
	}

	$subject = array();

	if ($is_threaded) {
	$add_re = PhabricatorEnv::getEnvConfig('metamta.re-prefix');

	if ($prefs) {
	$add_re = $prefs->getPreference(
	PhabricatorUserPreferences::PREFERENCE_RE_PREFIX,
	$add_re);
	}

	if ($add_re) {
	$subject[] = 'Re:';
	}
	}

	$subject[] = trim(idx($params, 'subject-prefix'));

	$vary_prefix = idx($params, 'vary-subject-prefix');
	if ($vary_prefix != '') {
	$use_subject = PhabricatorEnv::getEnvConfig(
	'metamta.vary-subjects');

	if ($prefs) {
	$use_subject = $prefs->getPreference(
	PhabricatorUserPreferences::PREFERENCE_VARY_SUBJECT,
	$use_subject);
	}

	if ($use_subject) {
	$subject[] = $vary_prefix;
	}
	}

	$subject[] = $value;

	$mailer->setSubject(implode(' ', array_filter($subject)));
	break;
	case 'is-html':
	if ($value) {
	$mailer->setIsHTML(true);
	}
	break;
	case 'is-bulk':
	if ($value) {
	if (PhabricatorEnv::getEnvConfig('metamta.precedence-bulk')) {
	$mailer->addHeader('Precedence', 'bulk');
	}
	}
	break;
	case 'thread-id':

	// NOTE: Gmail freaks out about In-Reply-To and References which
	// aren't in the form "<string@domain.tld>"; this is also required
	// by RFC 2822, although some clients are more liberal in what they
	// accept.
	$domain = PhabricatorEnv::getEnvConfig('metamta.domain');
	$value = '<'.$value.'@'.$domain.'>';

	if ($is_first && $mailer->supportsMessageIDHeader()) {
	$mailer->addHeader('Message-ID', $value);
	} else {
	$in_reply_to = $value;
	$references = array($value);
	$parent_id = $this->getParentMessageID();
	if ($parent_id) {
	$in_reply_to = $parent_id;
	// By RFC 2822, the most immediate parent should appear last
	// in the "References" header, so this order is intentional.
	$references[] = $parent_id;
	}
	$references = implode(' ', $references);
	$mailer->addHeader('In-Reply-To', $in_reply_to);
	$mailer->addHeader('References', $references);
	}
	$thread_index = $this->generateThreadIndex($value, $is_first);
	$mailer->addHeader('Thread-Index', $thread_index);
	break;
	case 'mailtags':
	// Handled below.
	break;
	case 'subject-prefix':
	case 'vary-subject-prefix':
	// Handled above.
	break;
	default:
	// Just discard.
	}
	}

	if (!$add_to && !$add_cc) {
	$this->setStatus(self::STATUS_VOID);
	$this->setMessage(
	"Message has no valid recipients: all To/Cc are disabled, invalid, ".
	"or configured not to receive this mail.");
	return $this->save();
	}

	$mailer->addHeader('X-Phabricator-Sent-This-Message', 'Yes');
	$mailer->addHeader('X-Mail-Transport-Agent', 'MetaMTA');

	// Some clients respect this to suppress OOF and other auto-responses.
	$mailer->addHeader('X-Auto-Response-Suppress', 'All');

	// If the message has mailtags, filter out any recipients who don't want
	// to receive this type of mail.
	$mailtags = $this->getParam('mailtags');
	if ($mailtags) {
	$tag_header = array();
	foreach ($mailtags as $mailtag) {
	$tag_header[] = '<'.$mailtag.'>';
	}
	$tag_header = implode(', ', $tag_header);
	$mailer->addHeader('X-Phabricator-Mail-Tags', $tag_header);
	}

	// Some mailers require a valid "To:" in order to deliver mail. If we
	// don't have any "To:", try to fill it in with a placeholder "To:".
	// If that also fails, move the "Cc:" line to "To:".
	if (!$add_to) {
	$placeholder_key = 'metamta.placeholder-to-recipient';
	$placeholder = PhabricatorEnv::getEnvConfig($placeholder_key);
	if ($placeholder !== null) {
	$add_to = array($placeholder);
	} else {
	$add_to = $add_cc;
	$add_cc = array();
	}
	}

	$add_to = array_unique($add_to);
	$add_cc = array_unique($add_cc);

	$mailer->addTos($add_to);
	if ($add_cc) {
	$mailer->addCCs($add_cc);
	}
	} catch (Exception $ex) {
	$this->setStatus(self::STATUS_FAIL);
	$this->setMessage($ex->getMessage());
	return $this->save();
	}

	if ($this->getRetryCount() < $this->getSimulatedFailureCount()) {
	$ok = false;
	$error = 'Simulated failure.';
	} else {
	try {
	$ok = $mailer->send();
	$error = null;
	} catch (PhabricatorMetaMTAPermanentFailureException $ex) {
	$this->setStatus(self::STATUS_FAIL);
	$this->setMessage($ex->getMessage());
	return $this->save();
	} catch (Exception $ex) {
	$ok = false;
	$error = $ex->getMessage()."\n".$ex->getTraceAsString();
	}
	}

	if (!$ok) {
	$this->setMessage($error);
	if ($this->getRetryCount() > self::MAX_RETRIES) {
	$this->setStatus(self::STATUS_FAIL);
	} else {
	$this->setRetryCount($this->getRetryCount() + 1);
	$next_retry = time() + ($this->getRetryCount() * self::RETRY_DELAY);
	$this->setNextRetry($next_retry);
	}
	} else {
	$this->setStatus(self::STATUS_SENT);
	}

	return $this->save();
	}

	public static function getReadableStatus($status_code) {
	static $readable = array(
	self::STATUS_QUEUE => "Queued for Delivery",
	self::STATUS_FAIL => "Delivery Failed",
	self::STATUS_SENT => "Sent",
	self::STATUS_VOID => "Void",
	);
	$status_code = coalesce($status_code, '?');
	return idx($readable, $status_code, $status_code);
	}

	private function generateThreadIndex($seed, $is_first_mail) {
	// When threading, Outlook ignores the 'References' and 'In-Reply-To'
	// headers that most clients use. Instead, it uses a custom 'Thread-Index'
	// header. The format of this header is something like this (from
	// camel-exchange-folder.c in Evolution Exchange):

	/* A new post to a folder gets a 27-byte-long thread index. (The value
	* is apparently unique but meaningless.) Each reply to a post gets a
	* 32-byte-long thread index whose first 27 bytes are the same as the
	* parent's thread index. Each reply to any of those gets a
	* 37-byte-long thread index, etc. The Thread-Index header contains a
	* base64 representation of this value.
	*/

	// The specific implementation uses a 27-byte header for the first email
	// a recipient receives, and a random 5-byte suffix (32 bytes total)
	// thereafter. This means that all the replies are (incorrectly) siblings,
	// but it would be very difficult to keep track of the entire tree and this
	// gets us reasonable client behavior.

	$base = substr(md5($seed), 0, 27);
	if (!$is_first_mail) {
	// Not totally sure, but it seems like outlook orders replies by
	// thread-index rather than timestamp, so to get these to show up in the
	// right order we use the time as the last 4 bytes.
	$base .= ' '.pack('N', time());
	}

	return base64_encode($base);
	}

	public static function shouldMultiplexAllMail() {
	return PhabricatorEnv::getEnvConfig('metamta.one-mail-per-recipient');
	}


	/* -( Managing Recipients )------------------------------------------------ */


	/**
	* Get all of the recipients for this mail, after preference filters are
	* applied. This list has all objects to whom delivery will be attempted.
	*
	* @return list<phid> A list of all recipients to whom delivery will be
	* attempted.
	* @task recipients
	*/
	public function buildRecipientList() {
	$actors = $this->loadActors(
	array_merge(
	$this->getToPHIDs(),
	$this->getCcPHIDs()));
	$actors = $this->filterDeliverableActors($actors);
	return mpull($actors, 'getPHID');
	}

	public function loadAllActors() {
	$actor_phids = array_merge(
	array($this->getParam('from')),
	$this->getToPHIDs(),
	$this->getCcPHIDs());

	return $this->loadActors($actor_phids);
	}

	private function filterDeliverableActors(array $actors) {
	assert_instances_of($actors, 'PhabricatorMetaMTAActor');
	$deliverable_actors = array();
	foreach ($actors as $phid => $actor) {
	if ($actor->isDeliverable()) {
	$deliverable_actors[$phid] = $actor;
	}
	}
	return $deliverable_actors;
	}

	private function loadActors(array $actor_phids) {
	$actor_phids = array_filter($actor_phids);
	$viewer = PhabricatorUser::getOmnipotentUser();

	$actors = id(new PhabricatorMetaMTAActorQuery())
	->setViewer($viewer)
	->withPHIDs($actor_phids)
	->execute();

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

	// Exclude explicit recipients.
	foreach ($this->getExcludeMailRecipientPHIDs() as $phid) {
	$actor = idx($actors, $phid);
	if (!$actor) {
	continue;
	}
	$actor->setUndeliverable(
	pht(
	'This message is a response to another email message, and this '.
	'recipient received the original email message, so we are not '.
	'sending them this substantially similar message (for example, '.
	'the sender used "Reply All" instead of "Reply" in response to '.
	'mail from Phabricator).'));
	}

	// Exclude the actor if their preferences are set.
	$from_phid = $this->getParam('from');
	$from_actor = idx($actors, $from_phid);
	if ($from_actor) {
	$from_user = id(new PhabricatorPeopleQuery())
	->setViewer($viewer)
	->withPHIDs(array($from_phid))
	->execute();
	$from_user = head($from_user);
	if ($from_user && !$this->getOverrideNoSelfMailPreference()) {
	$pref_key = PhabricatorUserPreferences::PREFERENCE_NO_SELF_MAIL;
	$exclude_self = $from_user
	->loadPreferences()
	->getPreference($pref_key);
	if ($exclude_self) {
	$from_actor->setUndeliverable(
	pht(
	'This recipient is the user whose actions caused delivery of '.
	'this message, but they have set preferences so they do not '.
	'receive mail about their own actions (Settings > Email '.
	'Preferences > Self Actions).'));
	}
	}
	}


	// Exclude all recipients who have set preferences to not receive this type
	// of email (for example, a user who says they don't want emails about task
	// CC changes).
	$tags = $this->getParam('mailtags');
	if ($tags) {
	$all_prefs = id(new PhabricatorUserPreferences())->loadAllWhere(
	'userPHID in (%Ls)',
	$actor_phids);
	$all_prefs = mpull($all_prefs, null, 'getUserPHID');

	foreach ($all_prefs as $phid => $prefs) {
	$user_mailtags = $prefs->getPreference(
	PhabricatorUserPreferences::PREFERENCE_MAILTAGS,
	array());

	// The user must have elected to receive mail for at least one
	// of the mailtags.
	$send = false;
	foreach ($tags as $tag) {
	if (idx($user_mailtags, $tag, true)) {
	$send = true;
	break;
	}
	}

	if (!$send) {
	$actors[$phid]->setUndeliverable(
	pht(
	'This mail has tags which control which users receive it, and '.
	'this recipient has not elected to receive mail with any of '.
	'the tags on this message (Settings > Email Preferences).'));
	}
	}
	}

	return $actors;
	}


	}
	diff --git a/src/docs/user/configuration/configuring_outbound_email.diviner b/src/docs/user/configuration/configuring_outbound_email.diviner
	index 56a08eb006..7489ef645e 100644
	--- a/src/docs/user/configuration/configuring_outbound_email.diviner
	+++ b/src/docs/user/configuration/configuring_outbound_email.diviner
	@@ -1,187 +1,176 @@
	@title Configuring Outbound Email
	@group config

	Instructions for configuring Phabricator to send mail.

	= Overview =

	Phabricator can send outbound email via several different adapters:

	- by running ##sendmail## on the local host with SMTP; or
	- by running postfix on the local host with SMTP; or
	- by using Amazon SES (Simple Email Service); or
	- by using SendGrid's REST API; or
	- via a custom adapter you write; or
	- by dropping email into a hole and not delivering it.

	Of these, ##sendmail## is the default but requires some configuration. SES and
	SendGrid are easier, but cost money and have some limitations. Writing a custom
	solution requires digging into the code. See below for details on how to set up
	each method.

	Phabricator can also send outbound email in two ways:

	- immediately, when messages are generated (default); or
	- in the background, via a daemon.

	Sending mail in the background requires that you be running the Phabricator
	daemons, but can greatly improve the performance of the application if your mail
	handler is slow. For more information on using daemons, see
	@{article:Managing Daemons with phd}.

	= Basics =

	Regardless of how outbound email is delivered, you should configure these keys
	in your configuration file:

	- metamta.default-address determines where mail is sent "From" by
	default. If your domain is ##example.org##, set this to something like
	"##noreply@example.org##".
	- metamta.domain should be set to your domain, e.g. "##example.org##".
	- metamta.can-send-as-user should be left as ##false## in most cases,
	but see the documentation in ##default.conf.php## for details.

	= Configuring Mail Adapters =

	To choose how mail will be sent, change the metamta.mail-adapter key in
	your configuration. Possible values are:

	- ##PhabricatorMailImplementationPHPMailerLiteAdapter##: default, uses
	"sendmail", see "Adapter: Sendmail".
	- ##PhabricatorMailImplementationPHPMailerAdapter##: uses SMTP, see
	"Adapter: SMTP".
	- ##PhabricatorMailImplementationAmazonSESAdapter##: use Amazon SES, see
	"Adapter: Amazon SES".
	- ##PhabricatorMailImplementationSendGridAdapter##: use SendGrid, see
	"Adapter: SendGrid".
	- ##Some Custom Class You Write##: use a custom adapter you write, see
	"Adapter: Custom".
	- ##PhabricatorMailImplementationTestAdapter##: this will
	completely disable outbound mail. You can use this if you don't want to
	send outbound mail, or want to skip this step for now and configure it
	later.

	= Adapter: Sendmail =

	This is the default, and selected by choosing
	##PhabricatorMailImplementationPHPMailerLiteAdapter## as the value for
	metamta.mail-adapter. This requires a 'sendmail' binary to be installed on
	the system. Most MTAs (e.g., sendmail, qmail, postfix) should do this, but your
	machine may not have one installed by default. For install instructions, consult
	the documentation for your favorite MTA.

	Since you'll be sending the mail yourself, you are subject to things like SPF
	rules, blackholes, and MTA configuration which are beyond the scope of this
	document. If you can already send outbound email from the command line or know
	how to configure it, this option is straightforward. If you have no idea how to
	do any of this, consider using Amazon SES.

	= Adapter: SMTP =

	For most situations of using SMTP to send email, you could actually use
	'sendmail' or 'postfix' to do it. But some SMTP server requires authentication
	and the 'sendmail' mailer doesn't work. If you want to try with postfix, for
	install instructions, consult the documentation for postfix as MTA and you
	could configure to use SMTP then.

	To configure Phabricator to use SMTP, set these configuration keys:

	- metamta.mail-adapter: set to
	"PhabricatorMailImplementationPHPMailerAdapter".
	- phpmailer.mailer: set to "smtp".
	- phpmailer.smtp-host: set to hostname of your smtp server.
	- phpmailer.smtp-port: set to port of your smtp server.
	- phpmailer.smtp-user: set to your username used for authentication.
	- phpmailer.smtp-password: set to your password used for authentication.

	= Adapter: Amazon SES =

	Amazon SES is Amazon's cloud email service. It is not free, but is easier to
	configure than sendmail and can simplify outbound email configuration. To use
	Amazon SES, you need to sign up for an account with Amazon at
	<http://aws.amazon.com/ses/>.

	To configure Phabricator to use Amazon SES, set these configuration keys:

	- metamta.mail-adapter: set to
	"PhabricatorMailImplementationAmazonSESAdapter".
	- amazon-ses.access-key: set to your Amazon SES access key.
	- amazon-ses.secret-key: set to your Amazon SES secret key.

	NOTE: Amazon SES requires you to verify your "From" address. Configure which
	"From" address to use by setting "##metamta.default-address##" in your config,
	then follow the Amazon SES verification process to verify it. You won't be able
	to send email until you do this!

	NOTE: Amazon SES is slow to accept mail (often 1-2 seconds) and application
	performance will improve greatly if you configure outbound email to send in
	the background.

	= Adapter: SendGrid =

	SendGrid is an email delivery service like Amazon SES. You can learn more at
	<http://sendgrid.com/>. It is easy to configure, but not free.

	You can configure SendGrid in two ways: you can send via SMTP or via the REST
	API. To use SMTP, just configure ##sendmail## and leave Phabricator's setup
	with defaults. To use the REST API, follow the instructions in this section.

	To configure Phabricator to use SendGrid, set these configuration keys:

	- metamta.mail-adapter: set to
	"PhabricatorMailImplementationSendGridAdapter".
	- sendgrid.api-user: set to your SendGrid login name.
	- sendgrid.api-key: set to your SendGrid password.

	If you're logged into your SendGrid account, you may be able to find this
	information easily by visiting <http://sendgrid.com/developer>.

	= Adapter: Custom =

	You can provide a custom adapter by writing a concrete subclass of
	@{class:PhabricatorMailImplementationAdapter} and setting it as the
	metamta.mail-adapter.

	TODO: This needs to be better documented once extending Phabricator is better
	documented.

	= Adapter: Disable Outbound Mail =

	You can use the @{class:PhabricatorMailImplementationTestAdapter} to completely
	disable outbound mail, if you don't want to send mail or don't want to configure
	it yet. Just set metamta.mail-adapter to
	"PhabricatorMailImplementationTestAdapter".

	-= Configuring MetaMTA to Send Mail Using a Daemon =
	-
	-Regardless of how you are sending outbound email, you can move the handoff to
	-the MTA out of the main process and into a daemon. This will greatly improve
	-application performance if your mailer is slow, like Amazon SES. In particular,
	-commenting on Differential Revisions and Maniphest Tasks sends outbound email.
	-
	-If you set metamta.send-immediately to ##false## in your configuration,
	-MetaMTA will queue mail to be send by a PhabricatorTaskmasterDaemon.
	-For more information on using daemons, see @{article:Managing Daemons with phd}.
	-
	= Testing and Debugging Outbound Email =

	You can use the `bin/mail` utility to test, debug, and examine outbound mail. In
	particular:

	phabricator/ $ ./bin/mail list-outbound # List outbound mail.
	phabricator/ $ ./bin/mail show-outbound # Show details about messages.
	phabricator/ $ ./bin/mail send-test # Send test messages.

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

	You can monitor daemons using the Daemon Console (##/daemon/##, or click
	Daemon Console from the homepage).

	= Next Steps =

	Continue by:

	- @{article:Configuring Inbound Email} so users can reply to email they
	receive about revisions and tasks to interact with them; or
	- learning about daemons with @{article:Managing Daemons with phd}; or
	- returning to the @{article:Configuration Guide}.

File Metadata

Mime Type: text/x-diff
Expires: Mon, Jul 28, 2:04 AM (1 w, 19 h ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 186348
Default Alt Text: (111 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions