| [ Index ] |
PHP Cross Reference of Phabricator |
[Source view] [Print] [Project Stats]
Handle request startup, before loading the environment or libraries. This class bootstraps the request state up to the point where we can enter Phabricator code. NOTE: This class MUST NOT have any dependencies. It runs before libraries load.
| File Size: | 856 lines (25 kb) |
| Included or required: | 0 times |
| Referenced: | 2 times |
| Includes or requires: | 0 files |
| getStartTime() X-Ref |
| getMicrosecondsSinceStart() X-Ref |
| setGlobal($key, $value) X-Ref |
| getGlobal($key, $default = null) X-Ref |
| getRawInput() X-Ref |
| didStartup() X-Ref |
| didShutdown() X-Ref |
| loadCoreLibraries() X-Ref |
| No description |
| beginOutputCapture() X-Ref |
| No description |
| endOutputCapture() X-Ref |
| No description |
| setDebugTimeLimit($limit) X-Ref |
| Set a time limit (in seconds) for the current script. After time expires, the script fatals. This works like `max_execution_time`, but prints out a useful stack trace when the time limit expires. This is primarily intended to make it easier to debug pages which hang by allowing extraction of a stack trace: set a short debug limit, then use the trace to figure out what's happening. The limit is implemented with a tick function, so enabling it implies some accounting overhead. param: int Time limit in seconds. return: void |
| onDebugTick() X-Ref |
| Callback tick function used by @{method:setDebugTimeLimit}. Fatals with a useful stack trace after the time limit expires. return: void |
| didEncounterFatalException($note,Exception $ex,$show_trace) X-Ref |
| Fatal the request completely in response to an exception, sending a plain text message to the client. Calls @{method:didFatal} internally. param: string Brief description of the exception context, like param: Exception The exception itself. param: bool True if it's okay to show the exception's stack trace return: exit This method **does not return**. |
| didFatal($message, $log_message = null) X-Ref |
| Fatal the request completely, sending a plain text message to the client. param: string Plain text message to send to the client. param: string Plain text message to send to the error log. If not return: exit This method **does not return**. |
| setupPHP() X-Ref |
| getOldMemoryLimit() X-Ref |
| normalizeInput() X-Ref |
| verifyPHP() X-Ref |
| verifyRewriteRules() X-Ref |
| validateGlobal($key) X-Ref |
| detectPostMaxSizeTriggered() X-Ref |
| Detect if this request has had its POST data stripped by exceeding the 'post_max_size' PHP configuration limit. PHP has a setting called 'post_max_size'. If a POST request arrives with a body larger than the limit, PHP doesn't generate $_POST but processes the request anyway, and provides no formal way to detect that this happened. We can still read the entire body out of `php://input`. However according to the documentation the stream isn't available for "multipart/form-data" (on nginx + php-fpm it appears that it is available, though, at least) so any attempt to generate $_POST would be fragile. |
| setMaximumRate($rate) X-Ref |
| Adjust the permissible rate limit score. By default, the limit is `1000`. You can use this method to set it to a larger or smaller value. If you set it to `2000`, users may make twice as many requests before rate limiting. param: int Maximum score before rate limiting. return: void |
| rateLimitRequest($user_identity) X-Ref |
| Check if the user (identified by `$user_identity`) has issued too many requests recently. If they have, end the request with a 429 error code. The key just needs to identify the user. Phabricator uses both user PHIDs and user IPs as keys, tracking logged-in and logged-out users separately and enforcing different limits. param: string Some key which identifies the user making the request. return: void If the user has exceeded the rate limit, this method |
| addRateLimitScore($user_identity, $score) X-Ref |
| Add points to the rate limit score for some user. If users have earned more than 1000 points per minute across all the buckets they'll be locked out of the application, so awarding 1 point per request roughly corresponds to allowing 1000 requests per second, while awarding 50 points roughly corresponds to allowing 20 requests per second. param: string Some key which identifies the user making the request. param: float The cost for this request; more points pushes them toward return: void |
| canRateLimit() X-Ref |
| Determine if rate limiting is available. Rate limiting depends on APC, and isn't available unless the APC user cache is available. return: bool True if rate limiting is available. |
| getRateLimitBucket() X-Ref |
| Get the current bucket for storing rate limit scores. return: int The current bucket. |
| getRateLimitBucketCount() X-Ref |
| Get the total number of rate limit buckets to retain. return: int Total number of rate limit buckets to retain. |
| getRateLimitBucketKey($bucket) X-Ref |
| Get the APC key for a given bucket. param: int Bucket to get the key for. return: string APC key for the bucket. |
| getRateLimitMinKey() X-Ref |
| Get the APC key for the smallest stored bucket. return: string APC key for the smallest stored bucket. |
| getRateLimitScore($user_identity) X-Ref |
| Get the current rate limit score for a given user. param: string Unique key identifying the user. return: float The user's current score. |
| didRateLimit() X-Ref |
| Emit an HTTP 429 "Too Many Requests" response (indicating that the user has exceeded application rate limits) and exit. return: exit This method **does not return**. |
| Generated: Sun Nov 30 09:20:46 2014 | Cross-referenced by PHPXref 0.7.1 |