Code Coverage
 
Lines
Functions and Methods
Classes and Traits
Total
11.02% covered (danger)
11.02%
41 / 372
16.13% covered (danger)
16.13%
10 / 62
CRAP
0.00% covered (danger)
0.00%
0 / 1
MediaWikiEntryPoint
11.02% covered (danger)
11.02%
41 / 372
16.13% covered (danger)
16.13%
10 / 62
14346.69
0.00% covered (danger)
0.00%
0 / 1
 __construct
77.78% covered (warning)
77.78%
7 / 9
0.00% covered (danger)
0.00%
0 / 1
3.10
 setup
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 doSetup
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 prepareForOutput
0.00% covered (danger)
0.00%
0 / 4
0.00% covered (danger)
0.00%
0 / 1
6
 doPrepareForOutput
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 run
0.00% covered (danger)
0.00%
0 / 7
0.00% covered (danger)
0.00%
0 / 1
6
 handleTopLevelError
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 execute
n/a
0 / 0
n/a
0 / 0
0
 schedulePostSendJobs
0.00% covered (danger)
0.00%
0 / 22
0.00% covered (danger)
0.00%
0 / 1
110
 commitMainTransaction
0.00% covered (danger)
0.00%
0 / 73
0.00% covered (danger)
0.00%
0 / 1
380
 getUrlDomainDistance
0.00% covered (danger)
0.00%
0 / 6
0.00% covered (danger)
0.00%
0 / 1
12
 getRequestPathSuffix
100.00% covered (success)
100.00%
4 / 4
100.00% covered (success)
100.00%
1 / 1
1
 postOutputShutdown
0.00% covered (danger)
0.00%
0 / 4
0.00% covered (danger)
0.00%
0 / 1
6
 doPostOutputShutdown
0.00% covered (danger)
0.00%
0 / 23
0.00% covered (danger)
0.00%
0 / 1
30
 shouldDoHttpRedirect
0.00% covered (danger)
0.00%
0 / 19
0.00% covered (danger)
0.00%
0 / 1
56
 outputResponsePayload
0.00% covered (danger)
0.00%
0 / 26
0.00% covered (danger)
0.00%
0 / 1
110
 restInPeace
0.00% covered (danger)
0.00%
0 / 21
0.00% covered (danger)
0.00%
0 / 1
6
 emitBufferedStatsdData
0.00% covered (danger)
0.00%
0 / 12
0.00% covered (danger)
0.00%
0 / 1
20
 triggerSyncJobs
0.00% covered (danger)
0.00%
0 / 3
0.00% covered (danger)
0.00%
0 / 1
2
 triggerAsyncJobs
0.00% covered (danger)
0.00%
0 / 47
0.00% covered (danger)
0.00%
0 / 1
72
 getServiceContainer
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 getUrlUtils
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 getReadOnlyMode
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 getJobRunner
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 getDBLoadBalancerFactory
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 getMessageCache
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 getBlockManager
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 getStatsFactory
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 getStatsdDataFactory
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 getJobQueueGroupFactory
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 getSpecialPageFactory
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 getContext
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 getRequest
100.00% covered (success)
100.00%
1 / 1
100.00% covered (success)
100.00%
1 / 1
1
 getResponse
100.00% covered (success)
100.00%
1 / 1
100.00% covered (success)
100.00%
1 / 1
1
 getConfig
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 isCli
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 hasFastCgi
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 getServerInfo
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 print
0.00% covered (danger)
0.00%
0 / 3
0.00% covered (danger)
0.00%
0 / 1
6
 exit
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 startOutputBuffer
100.00% covered (success)
100.00%
1 / 1
100.00% covered (success)
100.00%
1 / 1
1
 drainOutputBuffer
100.00% covered (success)
100.00%
3 / 3
100.00% covered (success)
100.00%
1 / 1
1
 enableOutputCapture
50.00% covered (danger)
50.00%
3 / 6
0.00% covered (danger)
0.00%
0 / 1
2.50
 getOutputBufferLevel
100.00% covered (success)
100.00%
1 / 1
100.00% covered (success)
100.00%
1 / 1
1
 commitOutputBuffer
0.00% covered (danger)
0.00%
0 / 6
0.00% covered (danger)
0.00%
0 / 1
12
 getCapturedOutput
0.00% covered (danger)
0.00%
0 / 6
0.00% covered (danger)
0.00%
0 / 1
6
 flushOutputBuffer
93.75% covered (success)
93.75%
15 / 16
0.00% covered (danger)
0.00%
0 / 1
7.01
 discardAllOutput
0.00% covered (danger)
0.00%
0 / 3
0.00% covered (danger)
0.00%
0 / 1
6
 getOutputBufferLength
100.00% covered (success)
100.00%
1 / 1
100.00% covered (success)
100.00%
1 / 1
1
 getOutputBufferStatus
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 discardOutputBuffer
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 disableModDeflate
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 getStatusCode
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 inPostSendMode
100.00% covered (success)
100.00%
1 / 1
100.00% covered (success)
100.00%
1 / 1
1
 triggerError
100.00% covered (success)
100.00%
1 / 1
100.00% covered (success)
100.00%
1 / 1
1
 getEnv
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 getIni
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 setIniOption
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 header
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 status
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 fastCgiFinishRequest
0.00% covered (danger)
0.00%
0 / 9
0.00% covered (danger)
0.00%
0 / 1
30
 getRequestURL
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 enterPostSendMode
100.00% covered (success)
100.00%
2 / 2
100.00% covered (success)
100.00%
1 / 1
1
1<?php
2/**
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License as published by
5 * the Free Software Foundation; either version 2 of the License, or
6 * (at your option) any later version.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License along
14 * with this program; if not, write to the Free Software Foundation, Inc.,
15 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
16 * http://www.gnu.org/copyleft/gpl.html
17 *
18 * @file
19 */
20
21namespace MediaWiki;
22
23use Exception;
24use HttpStatus;
25use IBufferingStatsdDataFactory;
26use JobQueueGroup;
27use JobRunner;
28use Liuggio\StatsdClient\Sender\SocketSender;
29use LogicException;
30use MediaWiki\Block\BlockManager;
31use MediaWiki\Config\Config;
32use MediaWiki\Config\ConfigException;
33use MediaWiki\Context\IContextSource;
34use MediaWiki\Deferred\DeferredUpdates;
35use MediaWiki\Deferred\TransactionRoundDefiningUpdate;
36use MediaWiki\HookContainer\ProtectedHookAccessorTrait;
37use MediaWiki\JobQueue\JobQueueGroupFactory;
38use MediaWiki\Logger\LoggerFactory;
39use MediaWiki\Request\WebRequest;
40use MediaWiki\Request\WebResponse;
41use MediaWiki\SpecialPage\SpecialPageFactory;
42use MediaWiki\Specials\SpecialRunJobs;
43use MediaWiki\Utils\UrlUtils;
44use MediaWiki\WikiMap\WikiMap;
45use MessageCache;
46use MWExceptionHandler;
47use Profiler;
48use Psr\Log\LoggerInterface;
49use RuntimeException;
50use SamplingStatsdClient;
51use Throwable;
52use Wikimedia\AtEase\AtEase;
53use Wikimedia\Rdbms\ChronologyProtector;
54use Wikimedia\Rdbms\LBFactory;
55use Wikimedia\Rdbms\ReadOnlyMode;
56use Wikimedia\ScopedCallback;
57use Wikimedia\Stats\StatsFactory;
58
59/**
60 * @defgroup entrypoint Entry points
61 *
62 * Web entry points reside in top-level MediaWiki directory (i.e. installation path).
63 * These entry points handle web requests to interact with the wiki. Other PHP files
64 * in the repository are not accessed directly from the web, but instead included by
65 * an entry point.
66 */
67
68/**
69 * Base class for entry point handlers.
70 *
71 * @note: This is not stable to extend by extensions, because MediaWiki does not
72 * allow extensions to define new entry points.
73 *
74 * @ingroup entrypoint
75 * @since 1.42, factored out of the previously existing MediaWiki class.
76 */
77abstract class MediaWikiEntryPoint {
78    use ProtectedHookAccessorTrait;
79
80    private IContextSource $context;
81    private Config $config;
82    private ?int $outputCaptureLevel = null;
83
84    private bool $postSendMode = false;
85
86    /** @var int Class DEFER_* constant; how non-blocking post-response tasks should run */
87    private int $postSendStrategy;
88
89    /** Call fastcgi_finish_request() to make post-send updates async */
90    private const DEFER_FASTCGI_FINISH_REQUEST = 1;
91
92    /** Set Content-Length and call ob_end_flush()/flush() to make post-send updates async */
93    private const DEFER_SET_LENGTH_AND_FLUSH = 2;
94
95    /** Do not try to make post-send updates async (e.g. for CLI mode) */
96    private const DEFER_CLI_MODE = 3;
97
98    private bool $preparedForOutput = false;
99
100    protected EntryPointEnvironment $environment;
101
102    private MediaWikiServices $mediaWikiServices;
103
104    /**
105     * @param IContextSource $context
106     * @param EntryPointEnvironment $environment
107     * @param MediaWikiServices $mediaWikiServices
108     */
109    public function __construct(
110        IContextSource $context,
111        EntryPointEnvironment $environment,
112        MediaWikiServices $mediaWikiServices
113    ) {
114        $this->context = $context;
115        $this->config = $this->context->getConfig();
116        $this->environment = $environment;
117        $this->mediaWikiServices = $mediaWikiServices;
118
119        if ( $environment->isCli() ) {
120            $this->postSendStrategy = self::DEFER_CLI_MODE;
121        } elseif ( $environment->hasFastCgi() ) {
122            $this->postSendStrategy = self::DEFER_FASTCGI_FINISH_REQUEST;
123        } else {
124            $this->postSendStrategy = self::DEFER_SET_LENGTH_AND_FLUSH;
125        }
126    }
127
128    /**
129     * Perform any setup needed before execute() is called.
130     * Final wrapper function for setup().
131     * Will be called by doRun().
132     */
133    final protected function setup() {
134        // Much of the functionality in WebStart.php and Setup.php should be moved here eventually.
135        // As of MW 1.41, a lot of it still wants to run in file scope.
136
137        // TODO: move define( 'MW_ENTRY_POINT' here )
138        // TODO: move ProfilingContext::singleton()->init( ... ) here.
139
140        $this->doSetup();
141    }
142
143    /**
144     * Perform any setup needed before execute() is called.
145     * Called by doRun() via doSetup().
146     */
147    protected function doSetup() {
148        // no-op
149        // TODO: move ob_start( [ MediaWiki\Output\OutputHandler::class, 'handle' ] ) here
150        // TODO: move MW_NO_OUTPUT_COMPRESSION handling here.
151        // TODO: move HeaderCallback::register() here
152        // TODO: move SessionManager::getGlobalSession() here (from Setup.php)
153        // TODO: move AuthManager::autoCreateUser here (from Setup.php)
154        // TODO: move pingback here (from Setup.php)
155    }
156
157    /**
158     * Prepare for sending the output. Should be called by entry points before
159     * sending the response.
160     * Final wrapper function for doPrepareForOutput().
161     * Will be called automatically at the end of doRun(), but will do nothing if it was
162     * already called from execute().
163     */
164    final protected function prepareForOutput() {
165        if ( $this->preparedForOutput ) {
166            // only do this once.
167            return;
168        }
169
170        $this->preparedForOutput = true;
171
172        $this->doPrepareForOutput();
173    }
174
175    /**
176     * Prepare for sending the output. Should be called by entry points before
177     * sending the response.
178     * Will be called automatically by run() via prepareForOutput().
179     * Subclasses may override this method, but should not call it directly.
180     *
181     * @note arc-lamp profiling relies on the name of this method,
182     *        it's hard coded in the arclamp-generate-svgs script!
183     */
184    protected function doPrepareForOutput() {
185        // Commit any changes in the current transaction round so that:
186        // a) the transaction is not rolled back after success output was already sent
187        // b) error output is not jumbled together with success output in the response
188        // TODO: split this up and pull out stuff like spreading cookie blocks
189        $this->commitMainTransaction();
190    }
191
192    /**
193     * Main app life cycle: Calls doSetup(), execute(),
194     * prepareForOutput(), and postOutputShutdown().
195     */
196    final public function run() {
197        $this->setup();
198
199        try {
200            $this->execute();
201
202            // Prepare for flushing the output. Will do nothing if it was already called by execute().
203            $this->prepareForOutput();
204        } catch ( Throwable $e ) {
205            $this->status( 500 );
206            $this->handleTopLevelError( $e );
207        }
208
209        $this->postOutputShutdown();
210    }
211
212    /**
213     * Report a top level error.
214     * Subclasses in core may override this to handle errors according
215     * to the expected output format.
216     * This method is not safe to override for extensions.
217     *
218     * @param Throwable $e
219     */
220    protected function handleTopLevelError( Throwable $e ) {
221        // Type errors and such: at least handle it now and clean up the LBFactory state
222        MWExceptionHandler::handleException( $e, MWExceptionHandler::CAUGHT_BY_ENTRYPOINT );
223    }
224
225    /**
226     * Subclasses implement the entry point's functionality by overriding this method.
227     * This method is not safe to override for extensions.
228     */
229    abstract protected function execute();
230
231    /**
232     * If enabled, after everything specific to this request is done, occasionally run jobs
233     */
234    protected function schedulePostSendJobs() {
235        $jobRunRate = $this->config->get( MainConfigNames::JobRunRate );
236        if (
237            // Post-send job running disabled
238            $jobRunRate <= 0 ||
239            // Jobs cannot run due to site read-only mode
240            $this->getReadOnlyMode()->isReadOnly() ||
241            // HTTP response body and Content-Length headers likely to not match,
242            // causing post-send updates to block the client when using mod_php
243            $this->context->getRequest()->getMethod() === 'HEAD' ||
244            $this->context->getRequest()->getHeader( 'If-Modified-Since' ) ||
245            $this->context->getRequest()->getHeader( 'If-None-Match' )
246        ) {
247            return;
248        }
249
250        if ( $jobRunRate < 1 ) {
251            $max = mt_getrandmax();
252            if ( mt_rand( 0, $max ) > $max * $jobRunRate ) {
253                return; // the higher the job run rate, the less likely we return here
254            }
255            $n = 1;
256        } else {
257            $n = intval( $jobRunRate );
258        }
259
260        // Note that DeferredUpdates will catch and log any errors (T88312)
261        DeferredUpdates::addUpdate( new TransactionRoundDefiningUpdate( function () use ( $n ) {
262            $logger = LoggerFactory::getInstance( 'runJobs' );
263            if ( $this->config->get( MainConfigNames::RunJobsAsync ) ) {
264                // Send an HTTP request to the job RPC entry point if possible
265                $invokedWithSuccess = $this->triggerAsyncJobs( $n, $logger );
266                if ( !$invokedWithSuccess ) {
267                    // Fall back to blocking on running the job(s)
268                    $logger->warning( "Jobs switched to blocking; Special:RunJobs disabled" );
269                    $this->triggerSyncJobs( $n );
270                }
271            } else {
272                $this->triggerSyncJobs( $n );
273            }
274        }, __METHOD__ ) );
275    }
276
277    /**
278     * This function commits all DB and session changes as needed *before* the
279     * client can receive a response (in case DB commit fails) and thus also before
280     * the response can trigger a subsequent related request by the client
281     */
282    protected function commitMainTransaction() {
283        $context = $this->context;
284
285        $config = $context->getConfig();
286        $request = $context->getRequest();
287        $output = $context->getOutput();
288
289        // Try to make sure that all RDBMs, session, and other storage updates complete
290        ignore_user_abort( true );
291
292        $lbFactory = $this->getDBLoadBalancerFactory();
293
294        // Commit all RDBMs changes from the main transaction round
295        $lbFactory->commitPrimaryChanges(
296            __METHOD__,
297            // Abort if any transaction was too big
298            $config->get( MainConfigNames::MaxUserDBWriteDuration )
299        );
300        wfDebug( __METHOD__ . ': primary transaction round committed' );
301
302        // Run updates that need to block the client or affect output (this is the last chance)
303        DeferredUpdates::doUpdates(
304            $config->get( MainConfigNames::ForceDeferredUpdatesPreSend )
305                ? DeferredUpdates::ALL
306                : DeferredUpdates::PRESEND
307        );
308
309        wfDebug( __METHOD__ . ': pre-send deferred updates completed' );
310
311        if ( !defined( 'MW_NO_SESSION' ) ) {
312            // Persist the session to avoid race conditions on subsequent requests by the client
313            $request->getSession()->save(); // T214471
314            wfDebug( __METHOD__ . ': session changes committed' );
315        }
316
317        // Subsequent requests by the client should see the DB replication positions, as written
318        // to ChronologyProtector during the shutdown() call below.
319        // Setting the cpPosIndex cookie is normally enough. However, this will not work for
320        // cross-wiki redirects within the same wiki farm, so set the ?cpPoxIndex in that case.
321        $isCrossWikiRedirect = (
322            $output->getRedirect() &&
323            $lbFactory->hasOrMadeRecentPrimaryChanges( INF ) &&
324            self::getUrlDomainDistance( $output->getRedirect() ) === 'remote'
325        );
326
327        // Persist replication positions for DBs modified by this request (at this point).
328        // These help provide "session consistency" for the client on their next requests.
329        $cpIndex = null;
330        $cpClientId = null;
331        $lbFactory->shutdown(
332            $lbFactory::SHUTDOWN_NORMAL,
333            null,
334            $cpIndex,
335            $cpClientId
336        );
337        $now = time();
338
339        $allowHeaders = !( $output->isDisabled() || $this->getResponse()->headersSent() );
340
341        if ( $cpIndex > 0 ) {
342            if ( $allowHeaders ) {
343                $expires = $now + ChronologyProtector::POSITION_COOKIE_TTL;
344                $options = [ 'prefix' => '' ];
345                $value = ChronologyProtector::makeCookieValueFromCPIndex( $cpIndex, $now, $cpClientId );
346                $request->response()->setCookie( 'cpPosIndex', $value, $expires, $options );
347            }
348
349            if ( $isCrossWikiRedirect ) {
350                if ( $output->getRedirect() ) {
351                    $url = $output->getRedirect();
352                    if ( $lbFactory->hasStreamingReplicaServers() ) {
353                        $url = strpos( $url, '?' ) === false
354                            ? "$url?cpPosIndex=$cpIndex" : "$url&cpPosIndex=$cpIndex";
355                    }
356                    $output->redirect( $url );
357                } else {
358                    MWExceptionHandler::logException(
359                        new LogicException( "No redirect; cannot append cpPosIndex parameter." ),
360                        MWExceptionHandler::CAUGHT_BY_ENTRYPOINT
361                    );
362                }
363            }
364        }
365
366        if ( $allowHeaders ) {
367            // Set a cookie to tell all CDN edge nodes to "stick" the user to the DC that
368            // handles this POST request (e.g. the "primary" data center). Also have the user
369            // briefly bypass CDN so ChronologyProtector works for cacheable URLs.
370            if ( $request->wasPosted() && $lbFactory->hasOrMadeRecentPrimaryChanges() ) {
371                $expires = $now + max(
372                        ChronologyProtector::POSITION_COOKIE_TTL,
373                        $config->get( MainConfigNames::DataCenterUpdateStickTTL )
374                    );
375                $options = [ 'prefix' => '' ];
376                $request->response()->setCookie( 'UseDC', 'master', $expires, $options );
377            }
378
379            // Avoid letting a few seconds of replica DB lag cause a month of stale data.
380            // This logic is also intimately related to the value of $wgCdnReboundPurgeDelay.
381            if ( $lbFactory->laggedReplicaUsed() ) {
382                $maxAge = $config->get( MainConfigNames::CdnMaxageLagged );
383                $output->lowerCdnMaxage( $maxAge );
384                $request->response()->header( "X-Database-Lagged: true" );
385                wfDebugLog( 'replication',
386                    "Lagged DB used; CDN cache TTL limited to $maxAge seconds" );
387            }
388
389            // Avoid long-term cache pollution due to message cache rebuild timeouts (T133069)
390            if ( $this->getMessageCache()->isDisabled() ) {
391                $maxAge = $config->get( MainConfigNames::CdnMaxageSubstitute );
392                $output->lowerCdnMaxage( $maxAge );
393                $request->response()->header( "X-Response-Substitute: true" );
394            }
395
396            if ( !$output->couldBePublicCached() || $output->haveCacheVaryCookies() ) {
397                // Autoblocks: If this user is autoblocked (and the cookie block feature is enabled
398                // for autoblocks), then set a cookie to track this block.
399                // This has to be done on all logged-in page loads (not just upon saving edits),
400                // because an autoblocked editor might not edit again from the same IP address.
401                //
402                // IP blocks: For anons, if their IP is blocked (and cookie block feature is enabled
403                // for IP blocks), we also want to set the cookie whenever it is safe to do.
404                // Basically from any url that are definitely not publicly cacheable (like viewing
405                // EditPage), or when the HTTP response is personalised for other reasons (e.g. viewing
406                // articles within the same browsing session after making an edit).
407                $user = $context->getUser();
408                $this->getBlockManager()->trackBlockWithCookie( $user, $request->response() );
409            }
410        }
411    }
412
413    /**
414     * @param string $url
415     * @return string Either "local", "remote" if in the farm, "external" otherwise
416     */
417    private static function getUrlDomainDistance( $url ) {
418        $clusterWiki = WikiMap::getWikiFromUrl( $url );
419        if ( WikiMap::isCurrentWikiId( $clusterWiki ) ) {
420            return 'local'; // the current wiki
421        }
422        if ( $clusterWiki !== false ) {
423            return 'remote'; // another wiki in this cluster/farm
424        }
425
426        return 'external';
427    }
428
429    /**
430     * If the request URL matches a given base path, extract the path part of
431     * the request URL after that base, and decode escape sequences in it.
432     *
433     * If the request URL does not match, false is returned.
434     *
435     * @internal Should be protected, made public for backwards
436     *           compatibility code in WebRequest.
437     * @param string $basePath
438     *
439     * @return false|string
440     */
441    public function getRequestPathSuffix( $basePath ) {
442        return WebRequest::getRequestPathSuffix(
443            $basePath,
444            $this->getRequestURL()
445        );
446    }
447
448    /**
449     * Forces the response to be sent to the client and then
450     * does work that can be done *after* the
451     * user gets the HTTP response, so they don't block on it.
452     */
453    final protected function postOutputShutdown() {
454        $this->doPostOutputShutdown();
455
456        // Just in case doPostOutputShutdown() was overwritten...
457        if ( !$this->inPostSendMode() ) {
458            $this->flushOutputBuffer();
459            $this->enterPostSendMode();
460        }
461    }
462
463    /**
464     * Forces the response to be sent to the client and then
465     * does work that can be done *after* the
466     * user gets the HTTP response, so they don't block on it.
467     *
468     * @since 1.26 (formerly on the MediaWiki class)
469     *
470     * @note arc-lamp profiling relies on the name of this method,
471     *        it's hard coded in the arclamp-generate-svgs script!
472     */
473    protected function doPostOutputShutdown() {
474        // Record backend request timing
475        $timing = $this->context->getTiming();
476        $timing->mark( 'requestShutdown' );
477
478        // Defer everything else if possible...
479        if ( $this->postSendStrategy === self::DEFER_FASTCGI_FINISH_REQUEST ) {
480            // Flush the output to the client, continue processing, and avoid further output
481            $this->fastCgiFinishRequest();
482        } elseif ( $this->postSendStrategy === self::DEFER_SET_LENGTH_AND_FLUSH ) {
483            // Flush the output to the client, continue processing, and avoid further output
484            $this->flushOutputBuffer();
485        }
486
487        // Since the headers and output where already flushed, disable WebResponse setters
488        // during post-send processing to warnings and unexpected behavior (T191537)
489        $this->enterPostSendMode();
490
491        // Run post-send updates while preventing further output...
492        $this->startOutputBuffer( static function () {
493            return ''; // do not output uncaught exceptions
494        } );
495        try {
496            $this->restInPeace();
497        } catch ( Throwable $e ) {
498            MWExceptionHandler::rollbackPrimaryChangesAndLog(
499                $e,
500                MWExceptionHandler::CAUGHT_BY_ENTRYPOINT
501            );
502        }
503        $length = $this->getOutputBufferLength();
504        if ( $length > 0 ) {
505            $this->triggerError(
506                __METHOD__ . ": suppressed $length byte(s)",
507                E_USER_NOTICE
508            );
509        }
510        $this->discardOutputBuffer();
511    }
512
513    /**
514     * Check if an HTTP->HTTPS redirect should be done. It may still be aborted
515     * by a hook, so this is not the final word.
516     *
517     * @return bool
518     */
519    protected function shouldDoHttpRedirect() {
520        $request = $this->context->getRequest();
521
522        // Don't redirect if we're already on HTTPS
523        if ( $request->getProtocol() !== 'http' ) {
524            return false;
525        }
526
527        $force = $this->config->get( MainConfigNames::ForceHTTPS );
528
529        // Don't redirect if $wgServer is explicitly HTTP. We test for this here
530        // by checking whether UrlUtils::expand() is able to force HTTPS.
531        if (
532            !preg_match(
533                '#^https://#',
534                (string)$this->getUrlUtils()->expand(
535                    $request->getRequestURL(),
536                    PROTO_HTTPS
537                )
538            )
539        ) {
540            if ( $force ) {
541                throw new RuntimeException( '$wgForceHTTPS is true but the server is not HTTPS' );
542            }
543            return false;
544        }
545
546        // Configured $wgForceHTTPS overrides the remaining conditions
547        if ( $force ) {
548            return true;
549        }
550
551        // Check if HTTPS is required by the session or user preferences
552        return $request->getSession()->shouldForceHTTPS() ||
553            // Check the cookie manually, for paranoia
554            $request->getCookie( 'forceHTTPS', '' ) ||
555            $this->context->getUser()->requiresHTTPS();
556    }
557
558    /**
559     * Print a response body to the current buffer (if there is one) or the server (otherwise)
560     *
561     * This method should be called after commitMainTransaction() and before doPostOutputShutdown()
562     *
563     * Any accompanying Content-Type header is assumed to have already been set
564     *
565     * @param string $content Response content, usually from OutputPage::output()
566     */
567    protected function outputResponsePayload( $content ) {
568        // Append any visible profiling data in a manner appropriate for the Content-Type
569        $this->startOutputBuffer();
570        try {
571            Profiler::instance()->logDataPageOutputOnly();
572        } finally {
573            $content .= $this->drainOutputBuffer();
574        }
575
576        // By default, usually one output buffer is active now, either the internal PHP buffer
577        // started by "output_buffering" in php.ini or the buffer started by MW_SETUP_CALLBACK.
578        // The MW_SETUP_CALLBACK buffer has an unlimited chunk size, while the internal PHP
579        // buffer only has an unlimited chunk size if output_buffering="On". If the buffer was
580        // filled up to the chunk size with printed data, then HTTP headers will have already
581        // been sent. Also, if the entry point had to stream content to the client, then HTTP
582        // headers will have already been sent as well, regardless of chunk size.
583
584        // Disable mod_deflate compression since it interferes with the output buffer set
585        // by MW_SETUP_CALLBACK and can also cause the client to wait on deferred updates
586        $this->disableModDeflate();
587
588        if ( $this->inPostSendMode() ) {
589            // Output already sent. This may happen for actions or special pages
590            // that generate raw output and disable OutputPage. In that case,
591            // we should just exit, but we should log an error if $content
592            // was not empty.
593            if ( $content !== '' ) {
594                $length = strlen( $content );
595                $this->triggerError(
596                    __METHOD__ . ": discarded $length byte(s) of output",
597                    E_USER_NOTICE
598                );
599            }
600            return;
601        }
602
603        if (
604            // "Content-Length" is used to prevent clients from waiting on deferred updates
605            $this->postSendStrategy === self::DEFER_SET_LENGTH_AND_FLUSH &&
606            // The HTTP response code clearly allows for a meaningful body
607            in_array( $this->getStatusCode(), [ 200, 404 ], true ) &&
608            // The queue of (post-send) deferred updates is non-empty
609            DeferredUpdates::pendingUpdatesCount() &&
610            // Any buffered output is not spread out across multiple output buffers
611            $this->getOutputBufferLevel() <= 1
612        ) {
613            $response = $this->context->getRequest()->response();
614
615            $obStatus = $this->getOutputBufferStatus();
616            if ( !isset( $obStatus['name'] ) ) {
617                // No output buffer is active
618                $response->header( 'Content-Length: ' . strlen( $content ) );
619            } elseif ( $obStatus['name'] === 'default output handler' ) {
620                // Internal PHP "output_buffering" output buffer (note that the internal PHP
621                // "zlib.output_compression" output buffer is named "zlib output compression")
622                $response->header( 'Content-Length: ' .
623                    ( $this->getOutputBufferLength() + strlen( $content ) ) );
624            }
625
626            // The MW_SETUP_CALLBACK output buffer ("MediaWiki\OutputHandler::handle") sets
627            // "Content-Length" where applicable. Other output buffer types might not set this
628            // header, and since they might mangle or compress the payload, it is not possible
629            // to determine the final payload size here.
630
631            // Tell the client to immediately end the connection as soon as the response payload
632            // has been read (informed by any "Content-Length" header). This prevents the client
633            // from waiting on deferred updates.
634            // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Connection
635            if ( $this->getServerInfo( 'SERVER_PROTOCOL' ) === 'HTTP/1.1' ) {
636                $response->header( 'Connection: close' );
637            }
638        }
639
640        // Print the content *after* adjusting HTTP headers and disabling mod_deflate since
641        // calling "print" will send the output to the client if there is no output buffer or
642        // if the output buffer chunk size is reached
643        $this->print( $content );
644    }
645
646    /**
647     * Ends this task peacefully.
648     * Called after the response has been sent to the client.
649     * Subclasses in core may override this to add end-of-request code,
650     * but should always call the parent method.
651     * This method is not safe to override by extensions.
652     */
653    protected function restInPeace() {
654        // Either all DB and deferred updates should happen or none.
655        // The latter should not be cancelled due to client disconnect.
656        ignore_user_abort( true );
657
658        // Assure deferred updates are not in the main transaction
659        $lbFactory = $this->getDBLoadBalancerFactory();
660        $lbFactory->commitPrimaryChanges( __METHOD__ );
661
662        // Loosen DB query expectations since the HTTP client is unblocked
663        $profiler = Profiler::instance();
664        $trxProfiler = $profiler->getTransactionProfiler();
665        $trxProfiler->redefineExpectations(
666            $this->context->getRequest()->hasSafeMethod()
667                ? $this->config->get( MainConfigNames::TrxProfilerLimits )['PostSend-GET']
668                : $this->config->get( MainConfigNames::TrxProfilerLimits )['PostSend-POST'],
669            __METHOD__
670        );
671
672        // Do any deferred jobs; preferring to run them now if a client will not wait on them
673        DeferredUpdates::doUpdates();
674
675        // Handle external profiler outputs.
676        // Any embedded profiler outputs were already processed in outputResponsePayload().
677        $profiler->logData();
678
679        // Send metrics gathered by StatsFactory
680        $this->getStatsFactory()->flush();
681
682        self::emitBufferedStatsdData(
683            $this->getStatsdDataFactory(),
684            $this->config
685        );
686
687        // Commit and close up!
688        $lbFactory->commitPrimaryChanges( __METHOD__ );
689        $lbFactory->shutdown( $lbFactory::SHUTDOWN_NO_CHRONPROT );
690
691        wfDebug( "Request ended normally" );
692    }
693
694    /**
695     * Send out any buffered statsd data according to sampling rules
696     *
697     * For web requests, this is called once by MediaWiki::restInPeace(),
698     * which is post-send (after the response is sent to the client).
699     *
700     * For maintenance scripts, especially long-running CLI scripts, it is called
701     * more often, to avoid OOM, since we buffer stats (T181385), based on the
702     * following heuristics:
703     *
704     * - Long-running scripts that involve database writes often use transactions
705     *   to commit chunks of work. We flush from IDatabase::setTransactionListener,
706     *   as wired up by MWLBFactory::applyGlobalState.
707     *
708     * - Long-running scripts that involve database writes but don't need any
709     *   transactions will still periodically wait for replication to be
710     *   graceful to the databases. We flush from ILBFactory::setWaitForReplicationListener
711     *   as wired up by MWLBFactory::applyGlobalState.
712     *
713     * - Any other long-running scripts will probably report progress to stdout
714     *   in some way. We also flush from Maintenance::output().
715     *
716     * @param IBufferingStatsdDataFactory $stats
717     * @param Config $config
718     * @throws ConfigException
719     * @since 1.31 (formerly one the MediaWiki class)
720     */
721    public static function emitBufferedStatsdData(
722        IBufferingStatsdDataFactory $stats, Config $config
723    ) {
724        if ( $config->get( MainConfigNames::StatsdServer ) && $stats->hasData() ) {
725            try {
726                $stats->updateCount( 'stats.statsdclient.buffered', $stats->getDataCount() );
727                $statsdServer = explode( ':', $config->get( MainConfigNames::StatsdServer ), 2 );
728                $statsdHost = $statsdServer[0];
729                $statsdPort = $statsdServer[1] ?? 8125;
730                $statsdSender = new SocketSender( $statsdHost, $statsdPort );
731                $statsdClient = new SamplingStatsdClient( $statsdSender, true, false );
732                $statsdClient->setSamplingRates( $config->get( MainConfigNames::StatsdSamplingRates ) );
733                $statsdClient->send( $stats->getData() );
734            } catch ( Exception $e ) {
735                MWExceptionHandler::logException( $e, MWExceptionHandler::CAUGHT_BY_ENTRYPOINT );
736            }
737        }
738        // empty buffer for the next round
739        $stats->clearData();
740    }
741
742    /**
743     * @param int $n Number of jobs to try to run
744     */
745    protected function triggerSyncJobs( $n ) {
746        $scope = Profiler::instance()->getTransactionProfiler()->silenceForScope();
747        $this->getJobRunner()->run( [ 'maxJobs' => $n ] );
748        ScopedCallback::consume( $scope );
749    }
750
751    /**
752     * @param int $n Number of jobs to try to run
753     * @param LoggerInterface $runJobsLogger
754     * @return bool Success
755     */
756    protected function triggerAsyncJobs( $n, LoggerInterface $runJobsLogger ) {
757        // Do not send request if there are probably no jobs
758        $group = $this->getJobQueueGroupFactory()->makeJobQueueGroup();
759        if ( !$group->queuesHaveJobs( JobQueueGroup::TYPE_DEFAULT ) ) {
760            return true;
761        }
762
763        $query = [ 'title' => 'Special:RunJobs',
764            'tasks' => 'jobs', 'maxjobs' => $n, 'sigexpiry' => time() + 5 ];
765        $query['signature'] = SpecialRunJobs::getQuerySignature(
766            $query, $this->config->get( MainConfigNames::SecretKey ) );
767
768        $errno = $errstr = null;
769        $info = $this->getUrlUtils()->parse( $this->config->get( MainConfigNames::CanonicalServer ) ) ?? [];
770        $https = ( $info['scheme'] ?? null ) === 'https';
771        $host = $info['host'] ?? null;
772        $port = $info['port'] ?? ( $https ? 443 : 80 );
773
774        AtEase::suppressWarnings();
775        $sock = $host ? fsockopen(
776            $https ? 'tls://' . $host : $host,
777            $port,
778            $errno,
779            $errstr,
780            // If it takes more than 100ms to connect to ourselves there is a problem...
781            0.100
782        ) : false;
783        AtEase::restoreWarnings();
784
785        $invokedWithSuccess = true;
786        if ( $sock ) {
787            $special = $this->getSpecialPageFactory()->getPage( 'RunJobs' );
788            $url = $special->getPageTitle()->getCanonicalURL( $query );
789            $req = (
790                "POST $url HTTP/1.1\r\n" .
791                "Host: $host\r\n" .
792                "Connection: Close\r\n" .
793                "Content-Length: 0\r\n\r\n"
794            );
795
796            $runJobsLogger->info( "Running $n job(s) via '$url'" );
797            // Send a cron API request to be performed in the background.
798            // Give up if this takes too long to send (which should be rare).
799            stream_set_timeout( $sock, 2 );
800            $bytes = fwrite( $sock, $req );
801            if ( $bytes !== strlen( $req ) ) {
802                $invokedWithSuccess = false;
803                $runJobsLogger->error( "Failed to start cron API (socket write error)" );
804            } else {
805                // Do not wait for the response (the script should handle client aborts).
806                // Make sure that we don't close before that script reaches ignore_user_abort().
807                $start = microtime( true );
808                $status = fgets( $sock );
809                $sec = microtime( true ) - $start;
810                if ( !preg_match( '#^HTTP/\d\.\d 202 #', $status ) ) {
811                    $invokedWithSuccess = false;
812                    $runJobsLogger->error( "Failed to start cron API: received '$status' ($sec)" );
813                }
814            }
815            fclose( $sock );
816        } else {
817            $invokedWithSuccess = false;
818            $runJobsLogger->error( "Failed to start cron API (socket error $errno): $errstr" );
819        }
820
821        return $invokedWithSuccess;
822    }
823
824    /**
825     * Returns the main service container.
826     *
827     * This is intended as a stepping stone for migration.
828     * Ideally, individual service objects should be injected
829     * via the constructor.
830     *
831     * @return MediaWikiServices
832     */
833    protected function getServiceContainer(): MediaWikiServices {
834        return $this->mediaWikiServices;
835    }
836
837    protected function getUrlUtils(): UrlUtils {
838        return $this->mediaWikiServices->getUrlUtils();
839    }
840
841    protected function getReadOnlyMode(): ReadOnlyMode {
842        return $this->mediaWikiServices->getReadOnlyMode();
843    }
844
845    protected function getJobRunner(): JobRunner {
846        return $this->mediaWikiServices->getJobRunner();
847    }
848
849    protected function getDBLoadBalancerFactory(): LBFactory {
850        return $this->mediaWikiServices->getDBLoadBalancerFactory();
851    }
852
853    protected function getMessageCache(): MessageCache {
854        return $this->mediaWikiServices->getMessageCache();
855    }
856
857    protected function getBlockManager(): BlockManager {
858        return $this->mediaWikiServices->getBlockManager();
859    }
860
861    protected function getStatsFactory(): StatsFactory {
862        return $this->mediaWikiServices->getStatsFactory();
863    }
864
865    protected function getStatsdDataFactory(): IBufferingStatsdDataFactory {
866        return $this->mediaWikiServices->getStatsdDataFactory();
867    }
868
869    protected function getJobQueueGroupFactory(): JobQueueGroupFactory {
870        return $this->mediaWikiServices->getJobQueueGroupFactory();
871    }
872
873    protected function getSpecialPageFactory(): SpecialPageFactory {
874        return $this->mediaWikiServices->getSpecialPageFactory();
875    }
876
877    protected function getContext(): IContextSource {
878        return $this->context;
879    }
880
881    protected function getRequest(): WebRequest {
882        return $this->context->getRequest();
883    }
884
885    protected function getResponse(): WebResponse {
886        return $this->getRequest()->response();
887    }
888
889    protected function getConfig( string $key ) {
890        return $this->config->get( $key );
891    }
892
893    protected function isCli(): bool {
894        return $this->environment->isCli();
895    }
896
897    protected function hasFastCgi(): bool {
898        return $this->environment->hasFastCgi();
899    }
900
901    protected function getServerInfo( string $key, $default = null ) {
902        return $this->environment->getServerInfo( $key, $default );
903    }
904
905    protected function print( $data ) {
906        if ( $this->inPostSendMode() ) {
907            throw new RuntimeException( 'Output already sent!' );
908        }
909
910        print $data;
911    }
912
913    /**
914     * @param int $code
915     *
916     * @return never
917     */
918    protected function exit( int $code = 0 ) {
919        $this->environment->exit( $code );
920    }
921
922    /**
923     * Adds a new output buffer level.
924     *
925     * @param ?callable $callback
926     *
927     * @see ob_start
928     */
929    protected function startOutputBuffer( ?callable $callback = null ): void {
930        ob_start( $callback );
931    }
932
933    /**
934     * Returns the content of the current output buffer and clears it.
935     *
936     * @see ob_get_clean
937     * @return false|string
938     */
939    protected function drainOutputBuffer() {
940        // NOTE: The ob_get_clean() would *disable* the current buffer,
941        // we don't want that!
942
943        $contents = ob_get_contents();
944        ob_clean();
945        return $contents;
946    }
947
948    /**
949     * Enable capturing of the current output buffer.
950     *
951     * There may be mutiple levels of output buffering. The level
952     * we are currently at, at the time of calling this method,
953     * is the level that will be captured to later retrieve via
954     * getCapturedOutput().
955     *
956     * When capturing is active, flushOutputBuffer() will not actually
957     * write to the real STDOUT, but instead write only to the capture.
958     *
959     * This exists to ease testing.
960     *
961     * @internal For use in PHPUnit tests
962     * @see ob_start()
963     * @see getCapturedOutput();
964     */
965    public function enableOutputCapture(): void {
966        $level = ob_get_level();
967
968        if ( $level <= 0 ) {
969            throw new RuntimeException(
970                'No capture buffer available, call ob_start first.'
971            );
972        }
973
974        $this->outputCaptureLevel = $level;
975    }
976
977    /**
978     * Returns the output buffer level.
979     *
980     * If enableOutputCapture() has been called, the capture buffer
981     * level is taking into account by subtracting it from the actual buffer
982     * level.
983     *
984     * @see ob_get_level
985     */
986    protected function getOutputBufferLevel(): int {
987        return max( 0, ob_get_level() - ( $this->outputCaptureLevel ?? 0 ) );
988    }
989
990    /**
991     * Ends the current output buffer, appending its content to the parent
992     * buffer.
993     * @see ob_end_flush
994     */
995    protected function commitOutputBuffer(): bool {
996        if ( $this->inPostSendMode() ) {
997            throw new RuntimeException( 'Output already sent!' );
998        }
999
1000        $level = $this->getOutputBufferLevel();
1001        if ( $level === 0 ) {
1002            return false;
1003        } else {
1004            //phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged
1005            return @ob_end_flush();
1006        }
1007    }
1008
1009    /**
1010     * Stop capturing and return all output
1011     *
1012     * It flushes and drains all output buffers, but lets it go
1013     * to a return value instead of the real STDOUT.
1014     *
1015     * You must call enableOutputCapture() and run() before getCapturedOutput().
1016     *
1017     * @internal For use in PHPUnit tests
1018     * @see enableOutputCapture();
1019     * @see ob_end_clean
1020     * @return string HTTP response body
1021     */
1022    public function getCapturedOutput(): string {
1023        if ( $this->outputCaptureLevel === null ) {
1024            throw new LogicException(
1025                'getCapturedOutput() requires enableOutputCapture() to be called first'
1026            );
1027        }
1028
1029        $this->flushOutputBuffer();
1030        return $this->drainOutputBuffer();
1031    }
1032
1033    /**
1034     * Flush buffered output to the client.
1035     *
1036     * If enableOutputCapture() was called, buffered output is committed to
1037     * the capture buffer instead.
1038     *
1039     * If enterPostSendMode() was called before this method, a warning is
1040     * triggered and any buffered output is discarded.
1041     *
1042     * @see ob_end_flush
1043     * @see flush
1044     */
1045    protected function flushOutputBuffer(): void {
1046        // NOTE: Use a for-loop, so we don't loop indefinitely in case
1047        // we fail to delete a buffer. This will routinely happen for
1048        // PHP's zlib.compression buffer.
1049        // See https://www.php.net/manual/en/function.ob-end-flush.php#103387
1050        $levels = $this->getOutputBufferLevel();
1051
1052        // If we are in post-send mode, throw away any buffered output.
1053        // Only complain if there actually is buffered output.
1054        if ( $this->inPostSendMode() ) {
1055            for ( $i = 0; $i < $levels; $i++ ) {
1056                $length = $this->getOutputBufferLength();
1057
1058                // phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged
1059                @ob_end_clean();
1060
1061                if ( $length > 0 ) {
1062                    $this->triggerError(
1063                        __METHOD__ . ": suppressed $length byte(s)",
1064                        E_USER_NOTICE
1065                    );
1066                }
1067            }
1068            return;
1069        }
1070
1071        for ( $i = 0; $i < $levels; $i++ ) {
1072            // Note that ob_end_flush() will fail for buffers created without
1073            // the PHP_OUTPUT_HANDLER_FLUSHABLE flag. So we use a for-loop
1074            // to avoid looping forever when ob_get_level() won't go down.
1075
1076            // phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged
1077            @ob_end_flush();
1078        }
1079
1080        // Flush the system buffer so the response is actually sent to the client,
1081        // unless we intend to capture the output, for testing or otherwise.
1082        // Capturing would be enabled by $this->outputCaptureLevel being set.
1083        // Note that, when not capturing the output, we want to flush response
1084        // to the client even if the loop above did not result in ob_get_level()
1085        // to return 0. This would be the case e.g. when zlib.compression
1086        // is enabled.
1087        // See https://www.php.net/manual/en/function.ob-end-flush.php#103387
1088        if ( $this->outputCaptureLevel === null || ob_get_level() === 0 ) {
1089            // phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged
1090            @flush();
1091        }
1092        wfDebug( "Output buffer flushed" );
1093    }
1094
1095    /**
1096     * Discards all buffered output, down to the capture buffer level.
1097     */
1098    protected function discardAllOutput() {
1099        // NOTE: use a for-loop, in case one of the buffers is non-removable.
1100        // In that case, getOutputBufferLevel() will never return 0.
1101        $levels = $this->getOutputBufferLevel();
1102        for ( $i = 0; $i < $levels; $i++ ) {
1103            // phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged
1104            @ob_end_clean();
1105        }
1106    }
1107
1108    /**
1109     * @see ob_get_length
1110     * @return false|int
1111     */
1112    protected function getOutputBufferLength() {
1113        return ob_get_length();
1114    }
1115
1116    /**
1117     * @see ob_get_status
1118     */
1119    protected function getOutputBufferStatus(): array {
1120        return ob_get_status();
1121    }
1122
1123    /**
1124     * @see ob_end_clean
1125     */
1126    protected function discardOutputBuffer(): bool {
1127        return ob_end_clean();
1128    }
1129
1130    protected function disableModDeflate(): void {
1131        $this->environment->disableModDeflate();
1132    }
1133
1134    /**
1135     * @see http_response_code
1136     * @return int|bool
1137     */
1138    protected function getStatusCode() {
1139        return $this->getResponse()->getStatusCode();
1140    }
1141
1142    /**
1143     * Whether enterPostSendMode() has been called.
1144     * Indicates whether more data can be sent to the client.
1145     * To determine whether more headers can be sent, use
1146     * $this->getResponse()->headersSent().
1147     */
1148    protected function inPostSendMode(): bool {
1149        return $this->postSendMode;
1150    }
1151
1152    /**
1153     * Triggers a PHP runtime error
1154     *
1155     * @see trigger_error
1156     */
1157    protected function triggerError( string $message, int $level = E_USER_NOTICE ): bool {
1158        return $this->environment->triggerError( $message, $level );
1159    }
1160
1161    /**
1162     * Returns the value of an environment variable.
1163     *
1164     * @see getenv
1165     *
1166     * @param string $name
1167     *
1168     * @return array|false|string
1169     */
1170    protected function getEnv( string $name ) {
1171        return $this->environment->getEnv( $name );
1172    }
1173
1174    /**
1175     * Returns the value of an ini option.
1176     *
1177     * @see ini_get
1178     *
1179     * @param string $name
1180     *
1181     * @return false|string
1182     */
1183    protected function getIni( string $name ) {
1184        return $this->environment->getIni( $name );
1185    }
1186
1187    /**
1188     * @param string $name
1189     * @param mixed $value
1190     *
1191     * @return false|string
1192     */
1193    protected function setIniOption( string $name, $value ) {
1194        return $this->environment->setIniOption( $name, $value );
1195    }
1196
1197    /**
1198     * @see header() function
1199     */
1200    protected function header( string $header, bool $replace = true, int $status = 0 ): void {
1201        $this->getResponse()->header( $header, $replace, $status );
1202    }
1203
1204    /**
1205     * @see HttpStatus
1206     */
1207    protected function status( int $code ): void {
1208        $this->header( HttpStatus::getHeader( $code ), true, $code );
1209    }
1210
1211    /**
1212     * Calls fastcgi_finish_request if possible. Reasons for not calling
1213     * fastcgi_finish_request include the fastcgi extension not being loaded
1214     * and the capture buffer level being different from 0.
1215     *
1216     * @see fastcgi_finish_request
1217     * @return bool true if fastcgi_finish_request was called and successful.
1218     */
1219    protected function fastCgiFinishRequest(): bool {
1220        if ( !$this->inPostSendMode() ) {
1221            $this->flushOutputBuffer();
1222        }
1223
1224        // Don't mess with fastcgi on CLI mode.
1225        if ( $this->isCli() ) {
1226            return false;
1227        }
1228
1229        // Only mess with fastcgi if we really have no buffers left.
1230        if ( ob_get_level() > 0 ) {
1231            return false;
1232        }
1233
1234        $success = $this->environment->fastCgiFinishRequest();
1235        wfDebug( $success ? 'FastCGI request finished' : 'FastCGI request finish failed' );
1236        return $success;
1237    }
1238
1239    /**
1240     * Returns the current request's path and query string (not a full URL),
1241     * like PHP's built-in $_SERVER['REQUEST_URI'].
1242     *
1243     * @see WebRequest::getRequestURL()
1244     * @see WebRequest::getGlobalRequestURL()
1245     */
1246    protected function getRequestURL(): string {
1247        // Despite the name, this just returns the path and query string
1248        return $this->getRequest()->getRequestURL();
1249    }
1250
1251    /**
1252     * Disables all output to the client.
1253     * After this, calling any output methods on this object will fail.
1254     */
1255    protected function enterPostSendMode() {
1256        $this->postSendMode = true;
1257
1258        $this->getResponse()->disableForPostSend();
1259    }
1260
1261}