includes/ResourceLoader/Module.php
<?php
/**
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
* http://www.gnu.org/copyleft/gpl.html
*
* @file
* @author Trevor Parscal
* @author Roan Kattouw
*/
namespace MediaWiki\ResourceLoader;
use Exception;
use FileContentsHasher;
use LogicException;
use MediaWiki\Config\Config;
use MediaWiki\HookContainer\HookContainer;
use MediaWiki\MainConfigNames;
use MediaWiki\MediaWikiServices;
use Peast\Peast;
use Peast\Syntax\Exception as PeastSyntaxException;
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;
use RuntimeException;
use Wikimedia\RelPath;
use Wikimedia\RequestTimeout\TimeoutException;
/**
* Abstraction for ResourceLoader modules, with name registration and maxage functionality.
*
* @see $wgResourceModules for the available options when registering a module.
* @stable to extend
* @ingroup ResourceLoader
* @since 1.17
*/
abstract class Module implements LoggerAwareInterface {
/** @var Config */
protected $config;
/** @var LoggerInterface */
protected $logger;
/**
* Script and style modules form a hierarchy of trustworthiness, with core modules
* like skins and jQuery as most trustworthy, and user scripts as least trustworthy. We can
* limit the types of scripts and styles we allow to load on, say, sensitive special
* pages like Special:UserLogin and Special:Preferences
* @var int
*/
protected $origin = self::ORIGIN_CORE_SITEWIDE;
/** @var string|null Module name */
protected $name = null;
/** @var string[]|null Skin names */
protected $skins = null;
/** @var array Map of (variant => indirect file dependencies) */
protected $fileDeps = [];
/** @var array Map of (language => in-object cache for message blob) */
protected $msgBlobs = [];
/** @var array Map of (context hash => cached module version hash) */
protected $versionHash = [];
/** @var array Map of (context hash => cached module content) */
protected $contents = [];
/** @var HookRunner|null */
private $hookRunner;
/** @var callback Function of (module name, variant) to get indirect file dependencies */
private $depLoadCallback;
/** @var callback Function of (module name, variant) to get indirect file dependencies */
private $depSaveCallback;
/** @var string|bool Deprecation string or true if deprecated; false otherwise */
protected $deprecated = false;
/** @var string Scripts only */
public const TYPE_SCRIPTS = 'scripts';
/** @var string Styles only */
public const TYPE_STYLES = 'styles';
/** @var string Scripts and styles */
public const TYPE_COMBINED = 'combined';
/** @var string */
public const GROUP_SITE = 'site';
/** @var string */
public const GROUP_USER = 'user';
/** @var string */
public const GROUP_PRIVATE = 'private';
/** @var string */
public const GROUP_NOSCRIPT = 'noscript';
/** @var string Module only has styles (loaded via <style> or <link rel=stylesheet>) */
public const LOAD_STYLES = 'styles';
/** @var string Module may have other resources (loaded via mw.loader from a script) */
public const LOAD_GENERAL = 'general';
/** @var int Sitewide core module like a skin file or jQuery component */
public const ORIGIN_CORE_SITEWIDE = 1;
/** @var int Per-user module generated by the software */
public const ORIGIN_CORE_INDIVIDUAL = 2;
/**
* Sitewide module generated from user-editable files, like MediaWiki:Common.js,
* or modules accessible to multiple users, such as those generated by the Gadgets extension.
* @var int
*/
public const ORIGIN_USER_SITEWIDE = 3;
/** @var int Per-user module generated from user-editable files, like User:Me/vector.js */
public const ORIGIN_USER_INDIVIDUAL = 4;
/** @var int An access constant; make sure this is kept as the largest number in this group */
public const ORIGIN_ALL = 10;
/** @var int Cache version for user-script JS validation errors from validateScriptFile(). */
private const USERJSPARSE_CACHE_VERSION = 3;
/**
* Get this module's name. This is set when the module is registered
* with ResourceLoader::register()
*
* @return string|null Name (string) or null if no name was set
*/
public function getName() {
return $this->name;
}
/**
* Set this module's name. This is called by ResourceLoader::register()
* when registering the module. Other code should not call this.
*
* @param string $name
*/
public function setName( $name ) {
$this->name = $name;
}
/**
* Provide overrides for skinStyles to modules that support that.
*
* This MUST be called after self::setName().
*
* @since 1.37
* @see $wgResourceModuleSkinStyles
* @param array $moduleSkinStyles
*/
public function setSkinStylesOverride( array $moduleSkinStyles ): void {
// Stub, only supported by FileModule currently.
}
/**
* Inject the functions that load/save the indirect file path dependency list from storage
*
* @param callable $loadCallback Function of (module name, variant)
* @param callable $saveCallback Function of (module name, variant, current paths, stored paths)
* @since 1.35
*/
public function setDependencyAccessCallbacks( callable $loadCallback, callable $saveCallback ) {
$this->depLoadCallback = $loadCallback;
$this->depSaveCallback = $saveCallback;
}
/**
* Get this module's origin. This is set when the module is registered
* with ResourceLoader::register()
*
* @return int Module class constant, the subclass default if not set manually
*/
public function getOrigin() {
return $this->origin;
}
/**
* @param Context $context
* @return bool
*/
public function getFlip( Context $context ) {
return MediaWikiServices::getInstance()->getContentLanguage()->getDir() !==
$context->getDirection();
}
/**
* Get JS representing deprecation information for the current module if available
*
* @deprecated since 1.41 use getDeprecationWarning()
*
* @param Context $context
* @return string JavaScript code
*/
public function getDeprecationInformation( Context $context ) {
wfDeprecated( __METHOD__, '1.41' );
$warning = $this->getDeprecationWarning();
if ( $warning === null ) {
return '';
}
return 'mw.log.warn(' . $context->encodeJson( $warning ) . ');';
}
/**
* Get the deprecation warning, if any
*
* @since 1.41
* @return string|null
*/
public function getDeprecationWarning() {
if ( !$this->deprecated ) {
return null;
}
$name = $this->getName();
$warning = 'This page is using the deprecated ResourceLoader module "' . $name . '".';
if ( is_string( $this->deprecated ) ) {
$warning .= "\n" . $this->deprecated;
}
return $warning;
}
/**
* Get all JS for this module for a given language and skin.
* Includes all relevant JS except loader scripts.
*
* For multi-file modules where require() is used to load one file from
* another file, this should return an array structured as follows:
* [
* 'files' => [
* 'file1.js' => [ 'type' => 'script', 'content' => 'JS code' ],
* 'file2.js' => [ 'type' => 'script', 'content' => 'JS code' ],
* 'data.json' => [ 'type' => 'data', 'content' => array ]
* ],
* 'main' => 'file1.js'
* ]
*
* For plain concatenated scripts, this can either return a string, or an
* associative array similar to the one used for package files:
* [
* 'plainScripts' => [
* [ 'content' => 'JS code' ],
* [ 'content' => 'JS code' ],
* ],
* ]
*
* @stable to override
* @param Context $context
* @return string|array JavaScript code (string), or multi-file array with the
* following keys:
* - files: An associative array mapping file name to file info structure
* - main: The name of the main script, a key in the files array
* - plainScripts: An array of file info structures to be concatenated and
* executed when the module is loaded.
* Each file info structure has the following keys:
* - type: May be "script", "script-vue" or "data". Optional, default "script".
* - content: The string content of the file
* - filePath: A FilePath object describing the location of the source file.
* This will be used to construct the source map during minification.
*/
public function getScript( Context $context ) {
// Stub, override expected
return '';
}
/**
* Takes named templates by the module and returns an array mapping.
*
* @stable to override
* @return string[] Array of templates mapping template alias to content
*/
public function getTemplates() {
// Stub, override expected.
return [];
}
/**
* @return Config
* @since 1.24
*/
public function getConfig() {
if ( $this->config === null ) {
throw new RuntimeException( 'Config accessed before it is set' );
}
return $this->config;
}
/**
* @param Config $config
* @since 1.24
*/
public function setConfig( Config $config ) {
$this->config = $config;
}
/**
* @since 1.27
* @param LoggerInterface $logger
*/
public function setLogger( LoggerInterface $logger ) {
$this->logger = $logger;
}
/**
* @since 1.27
* @return LoggerInterface
*/
protected function getLogger() {
if ( !$this->logger ) {
$this->logger = new NullLogger();
}
return $this->logger;
}
/**
* @internal For use only by ResourceLoader::getModule
* @param HookContainer $hookContainer
*/
public function setHookContainer( HookContainer $hookContainer ): void {
$this->hookRunner = new HookRunner( $hookContainer );
}
/**
* Get a HookRunner for running core hooks.
*
* @internal For use only within core Module subclasses. Hook interfaces may be removed
* without notice.
* @return HookRunner
*/
protected function getHookRunner(): HookRunner {
return $this->hookRunner;
}
/**
* Get alternative script URLs for legacy debug mode.
*
* The default behavior is to return a `load.php?only=scripts&module=<name>` URL.
*
* Module classes that merely wrap one or more other script files in production mode, may
* override this method to return an array of raw URLs for those underlying scripts,
* if those are individually web-accessible.
*
* The mw.loader client will load and execute each URL consecutively. This has the caveat of
* executing legacy debug scripts in the global scope, which is why non-package file modules
* tend to use file closures (T50886).
*
* This function MUST NOT be called, unless all the following are true:
*
* 1. We're in debug mode,
* 2. There is no `only=` parameter in the context,
* 3. self::supportsURLLoading() has returned true.
*
* Point 2 prevents an infinite loop since we use the `only=` mechanism in the return value.
* Overrides must similarly return with `only`, or return or a non-load.php URL.
*
* @stable to override
* @param Context $context
* @return string[]
*/
public function getScriptURLsForDebug( Context $context ) {
$rl = $context->getResourceLoader();
$derivative = new DerivativeContext( $context );
$derivative->setModules( [ $this->getName() ] );
$derivative->setOnly( 'scripts' );
$url = $rl->createLoaderURL(
$this->getSource(),
$derivative
);
// Expand debug URL in case we are another wiki's module source (T255367)
$url = $rl->expandUrl( $this->getConfig()->get( MainConfigNames::Server ), $url );
return [ $url ];
}
/**
* Whether this module supports URL loading. If this function returns false,
* getScript() will be used even in cases (debug mode, no only param) where
* getScriptURLsForDebug() would normally be used instead.
*
* @stable to override
* @return bool
*/
public function supportsURLLoading() {
return true;
}
/**
* Get all CSS for this module for a given skin.
*
* @stable to override
* @param Context $context
* @return array List of CSS strings or array of CSS strings keyed by media type.
* like [ 'screen' => '.foo { width: 0 }' ];
* or [ 'screen' => [ '.foo { width: 0 }' ] ];
*/
public function getStyles( Context $context ) {
// Stub, override expected
return [];
}
/**
* Get the URL or URLs to load for this module's CSS in debug mode.
* The default behavior is to return a load.php?only=styles URL for
* the module, but file-based modules will want to override this to
* load the files directly
*
* This function must only be called when:
*
* 1. We're in debug mode,
* 2. There is no `only=` parameter and,
* 3. self::supportsURLLoading() returns true.
*
* See also getScriptURLsForDebug().
*
* @stable to override
* @param Context $context
* @return array [ mediaType => [ URL1, URL2, ... ], ... ]
*/
public function getStyleURLsForDebug( Context $context ) {
$resourceLoader = $context->getResourceLoader();
$derivative = new DerivativeContext( $context );
$derivative->setModules( [ $this->getName() ] );
$derivative->setOnly( 'styles' );
$url = $resourceLoader->createLoaderURL(
$this->getSource(),
$derivative
);
return [ 'all' => [ $url ] ];
}
/**
* Get the messages needed for this module.
*
* To get a JSON blob with messages, use MessageBlobStore::get()
*
* @stable to override
* @return string[] List of message keys. Keys may occur more than once
*/
public function getMessages() {
// Stub, override expected
return [];
}
/**
* Get the group this module is in.
*
* @stable to override
* @return string|null Group name
*/
public function getGroup() {
// Stub, override expected
return null;
}
/**
* Get the source of this module. Should only be overridden for foreign modules.
*
* @stable to override
* @return string Source name, 'local' for local modules
*/
public function getSource() {
// Stub, override expected
return 'local';
}
/**
* Get a list of modules this module depends on.
*
* Dependency information is taken into account when loading a module
* on the client side.
*
* Note: It is expected that $context will be made non-optional in the near
* future.
*
* @stable to override
* @param Context|null $context
* @return string[] List of module names as strings
*/
public function getDependencies( Context $context = null ) {
// Stub, override expected
return [];
}
/**
* Get list of skins for which this module must be available to load.
*
* By default, modules are available to all skins.
*
* This information may be used by the startup module to optimise registrations
* based on the current skin.
*
* @stable to override
* @since 1.39
* @return string[]|null
*/
public function getSkins(): ?array {
return $this->skins;
}
/**
* Get the module's load type.
*
* @stable to override
* @since 1.28
* @return string Module LOAD_* constant
*/
public function getType() {
return self::LOAD_GENERAL;
}
/**
* Get the skip function.
*
* Modules that provide fallback functionality can provide a "skip function". This
* function, if provided, will be passed along to the module registry on the client.
* When this module is loaded (either directly or as a dependency of another module),
* then this function is executed first. If the function returns true, the module will
* instantly be considered "ready" without requesting the associated module resources.
*
* The value returned here must be valid javascript for execution in a private function.
* It must not contain the "function () {" and "}" wrapper though.
*
* @stable to override
* @return string|null A JavaScript function body returning a boolean value, or null
*/
public function getSkipFunction() {
return null;
}
/**
* Whether the module requires ES6 support in the client.
*
* If the client does not support ES6, attempting to load a module that requires ES6 will
* result in an error.
*
* @deprecated since 1.41, ignored by ResourceLoader
* @since 1.36
* @return bool
*/
public function requiresES6() {
return true;
}
/**
* Get the indirect dependencies for this module pursuant to the skin/language context
*
* These are only image files referenced by the module's stylesheet
*
* If neither setFileDependencies() nor setDependencyAccessCallbacks() was called,
* this will simply return a placeholder with an empty file list
*
* @see Module::setFileDependencies()
* @see Module::saveFileDependencies()
* @param Context $context
* @return string[] List of absolute file paths
*/
protected function getFileDependencies( Context $context ) {
$variant = self::getVary( $context );
if ( !isset( $this->fileDeps[$variant] ) ) {
if ( $this->depLoadCallback ) {
$this->fileDeps[$variant] =
call_user_func( $this->depLoadCallback, $this->getName(), $variant );
} else {
$this->getLogger()->info( __METHOD__ . ": no callback registered" );
$this->fileDeps[$variant] = [];
}
}
return $this->fileDeps[$variant];
}
/**
* Set the indirect dependencies for this module pursuant to the skin/language context
*
* These are only image files referenced by the module's stylesheet
*
* @see Module::getFileDependencies()
* @see Module::saveFileDependencies()
* @param Context $context
* @param string[] $paths List of absolute file paths
*/
public function setFileDependencies( Context $context, array $paths ) {
$variant = self::getVary( $context );
$this->fileDeps[$variant] = $paths;
}
/**
* Save the indirect dependencies for this module pursuant to the skin/language context
*
* @param Context $context
* @param string[] $curFileRefs List of newly computed indirect file dependencies
* @since 1.27
*/
protected function saveFileDependencies( Context $context, array $curFileRefs ) {
if ( !$this->depSaveCallback ) {
$this->getLogger()->info( __METHOD__ . ": no callback registered" );
return;
}
try {
// Pitfalls and performance considerations:
// 1. Don't keep updating the tracked paths due to duplicates or sorting.
// 2. Use relative paths to avoid ghost entries when $IP changes. (T111481)
// 3. Don't needlessly replace tracked paths with the same value
// just because $IP changed (e.g. when upgrading a wiki).
// 4. Don't create an endless replace loop on every request for this
// module when '../' is used anywhere. Even though both are expanded
// (one expanded by getFileDependencies from the DB, the other is
// still raw as originally read by RL), the latter has not
// been normalized yet.
call_user_func(
$this->depSaveCallback,
$this->getName(),
self::getVary( $context ),
self::getRelativePaths( $curFileRefs ),
self::getRelativePaths( $this->getFileDependencies( $context ) )
);
} catch ( TimeoutException $e ) {
throw $e;
} catch ( Exception $e ) {
$this->getLogger()->warning(
__METHOD__ . ": failed to update dependencies: {$e->getMessage()}",
[ 'exception' => $e ]
);
}
}
/**
* Make file paths relative to MediaWiki directory.
*
* This is used to make file paths safe for storing in a database without the paths
* becoming stale or incorrect when MediaWiki is moved or upgraded (T111481).
*
* @since 1.27
* @param array $filePaths
* @return array
*/
public static function getRelativePaths( array $filePaths ) {
global $IP;
return array_map( static function ( $path ) use ( $IP ) {
return RelPath::getRelativePath( $path, $IP );
}, $filePaths );
}
/**
* Expand directories relative to $IP.
*
* @since 1.27
* @param array $filePaths
* @return array
*/
public static function expandRelativePaths( array $filePaths ) {
global $IP;
return array_map( static function ( $path ) use ( $IP ) {
return RelPath::joinPath( $IP, $path );
}, $filePaths );
}
/**
* Get the hash of the message blob.
*
* @stable to override
* @since 1.27
* @param Context $context
* @return string|null JSON blob or null if module has no messages
* @return-taint none -- do not propagate taint from $context->getLanguage()
*/
protected function getMessageBlob( Context $context ) {
if ( !$this->getMessages() ) {
// Don't bother consulting MessageBlobStore
return null;
}
// Message blobs may only vary language, not by context keys
$lang = $context->getLanguage();
if ( !isset( $this->msgBlobs[$lang] ) ) {
$this->getLogger()->warning( 'Message blob for {module} should have been preloaded', [
'module' => $this->getName(),
] );
$store = $context->getResourceLoader()->getMessageBlobStore();
$this->msgBlobs[$lang] = $store->getBlob( $this, $lang );
}
return $this->msgBlobs[$lang];
}
/**
* Set in-object cache for message blobs.
*
* Used to allow fetching of message blobs in batches. See ResourceLoader::preloadModuleInfo().
*
* @since 1.27
* @param string|null $blob JSON blob or null
* @param string $lang Language code
*/
public function setMessageBlob( $blob, $lang ) {
$this->msgBlobs[$lang] = $blob;
}
/**
* Get headers to send as part of a module web response.
*
* It is not supported to send headers through this method that are
* required to be unique or otherwise sent once in an HTTP response
* because clients may make batch requests for multiple modules (as
* is the default behaviour for ResourceLoader clients).
*
* For exclusive or aggregated headers, see ResourceLoader::sendResponseHeaders().
*
* @since 1.30
* @param Context $context
* @return string[] Array of HTTP response headers
*/
final public function getHeaders( Context $context ) {
$formattedLinks = [];
foreach ( $this->getPreloadLinks( $context ) as $url => $attribs ) {
$link = "<{$url}>;rel=preload";
foreach ( $attribs as $key => $val ) {
$link .= ";{$key}={$val}";
}
$formattedLinks[] = $link;
}
if ( $formattedLinks ) {
return [ 'Link: ' . implode( ',', $formattedLinks ) ];
}
return [];
}
/**
* Get a list of resources that web browsers may preload.
*
* Behaviour of rel=preload link is specified at <https://www.w3.org/TR/preload/>.
*
* Use case for ResourceLoader originally part of T164299.
*
* @par Example
* @code
* protected function getPreloadLinks() {
* return [
* 'https://example.org/script.js' => [ 'as' => 'script' ],
* 'https://example.org/image.png' => [ 'as' => 'image' ],
* ];
* }
* @endcode
*
* @par Example using HiDPI image variants
* @code
* protected function getPreloadLinks() {
* return [
* 'https://example.org/logo.png' => [
* 'as' => 'image',
* 'media' => 'not all and (min-resolution: 2dppx)',
* ],
* 'https://example.org/logo@2x.png' => [
* 'as' => 'image',
* 'media' => '(min-resolution: 2dppx)',
* ],
* ];
* }
* @endcode
*
* @see Module::getHeaders
*
* @stable to override
* @since 1.30
* @param Context $context
* @return array Keyed by url, values must be an array containing
* at least an 'as' key. Optionally a 'media' key as well.
*
*/
protected function getPreloadLinks( Context $context ) {
return [];
}
/**
* Get module-specific LESS variables, if any.
*
* @stable to override
* @since 1.27
* @param Context $context
* @return array Module-specific LESS variables.
*/
protected function getLessVars( Context $context ) {
return [];
}
/**
* Get an array of this module's resources. Ready for serving to the web.
*
* @since 1.26
* @param Context $context
* @return array
*/
public function getModuleContent( Context $context ) {
$contextHash = $context->getHash();
// Cache this expensive operation. This calls builds the scripts, styles, and messages
// content which typically involves filesystem and/or database access.
if ( !array_key_exists( $contextHash, $this->contents ) ) {
$this->contents[$contextHash] = $this->buildContent( $context );
}
return $this->contents[$contextHash];
}
/**
* Bundle all resources attached to this module into an array.
*
* @since 1.26
* @param Context $context
* @return array
*/
final protected function buildContent( Context $context ) {
$statsFactory = MediaWikiServices::getInstance()->getStatsFactory();
$statStart = microtime( true );
// This MUST build both scripts and styles, regardless of whether $context->getOnly()
// is 'scripts' or 'styles' because the result is used by getVersionHash which
// must be consistent regardless of the 'only' filter on the current request.
// Also, when introducing new module content resources (e.g. templates, headers),
// these should only be included in the array when they are non-empty so that
// existing modules not using them do not get their cache invalidated.
$content = [];
// Scripts
if ( $context->getDebug() === $context::DEBUG_LEGACY && !$context->getOnly() && $this->supportsURLLoading() ) {
// In legacy debug mode, let supporting modules like FileModule replace the bundled
// script closure with an array of alternative script URLs to consecutively load instead.
// See self::getScriptURLsForDebug() more details.
$scripts = $this->getScriptURLsForDebug( $context );
} else {
$scripts = $this->getScript( $context );
if ( is_string( $scripts ) ) {
$scripts = [ 'plainScripts' => [ [ 'content' => $scripts ] ] ];
}
}
$content['scripts'] = $scripts;
$styles = [];
// Don't create empty stylesheets like [ '' => '' ] for modules
// that don't *have* any stylesheets (T40024).
$stylePairs = $this->getStyles( $context );
if ( count( $stylePairs ) ) {
// If we are in debug mode without &only= set, we'll want to return an array of URLs
// See comment near shouldIncludeScripts() for more details
if ( $context->getDebug() && !$context->getOnly() && $this->supportsURLLoading() ) {
$styles = [
'url' => $this->getStyleURLsForDebug( $context )
];
} else {
// Minify CSS before embedding in mw.loader.impl call
// (unless in debug mode)
if ( !$context->getDebug() ) {
foreach ( $stylePairs as $media => $style ) {
// Can be either a string or an array of strings.
if ( is_array( $style ) ) {
$stylePairs[$media] = [];
foreach ( $style as $cssText ) {
if ( is_string( $cssText ) ) {
$stylePairs[$media][] =
ResourceLoader::filter( 'minify-css', $cssText );
}
}
} elseif ( is_string( $style ) ) {
$stylePairs[$media] = ResourceLoader::filter( 'minify-css', $style );
}
}
}
// Wrap styles into @media groups as needed and flatten into a numerical array
$styles = [
'css' => ResourceLoader::makeCombinedStyles( $stylePairs )
];
}
}
$content['styles'] = $styles;
// Messages
$blob = $this->getMessageBlob( $context );
if ( $blob ) {
$content['messagesBlob'] = $blob;
}
$templates = $this->getTemplates();
if ( $templates ) {
$content['templates'] = $templates;
}
$headers = $this->getHeaders( $context );
if ( $headers ) {
$content['headers'] = $headers;
}
$deprecationWarning = $this->getDeprecationWarning();
if ( $deprecationWarning !== null ) {
$content['deprecationWarning'] = $deprecationWarning;
}
$statTiming = microtime( true ) - $statStart;
$statName = strtr( $this->getName(), '.', '_' );
$statsFactory->getTiming( 'resourceloader_build_seconds' )
->setLabel( 'name', $statName )
->copyToStatsdAt( [
'resourceloader_build.all',
"resourceloader_build.$statName",
] )
->observe( 1000 * $statTiming );
return $content;
}
/**
* Get a string identifying the current version of this module in a given context.
*
* Whenever anything happens that changes the module's response (e.g. scripts, styles, and
* messages) this value must change. This value is used to store module responses in caches,
* both server-side (by a CDN, or other HTTP cache), and client-side (in `mw.loader.store`,
* and in the browser's own HTTP cache).
*
* The underlying methods called here for any given module should be quick because this
* is called for potentially thousands of module bundles in the same request as part of the
* StartUpModule, which is how we invalidate caches and propagate changes to clients.
*
* @since 1.26
* @see self::getDefinitionSummary for how to customize version computation.
* @param Context $context
* @return string Hash formatted by ResourceLoader::makeHash
*/
final public function getVersionHash( Context $context ) {
if ( $context->getDebug() ) {
// In debug mode, make uncached startup module extra fast by not computing any hashes.
// Server responses from load.php for individual modules already have no-cache so
// we don't need them. This also makes breakpoint debugging easier, as each module
// gets its own consistent URL. (T235672)
return '';
}
// Cache this somewhat expensive operation. Especially because some classes
// (e.g. startup module) iterate more than once over all modules to get versions.
$contextHash = $context->getHash();
if ( !array_key_exists( $contextHash, $this->versionHash ) ) {
if ( $this->enableModuleContentVersion() ) {
// Detect changes directly by hashing the module contents.
$str = json_encode( $this->getModuleContent( $context ) );
} else {
// Infer changes based on definition and other metrics
$summary = $this->getDefinitionSummary( $context );
if ( !isset( $summary['_class'] ) ) {
throw new LogicException( 'getDefinitionSummary must call parent method' );
}
$str = json_encode( $summary );
}
$this->versionHash[$contextHash] = ResourceLoader::makeHash( $str );
}
return $this->versionHash[$contextHash];
}
/**
* Whether to generate version hash based on module content.
*
* If a module requires database or file system access to build the module
* content, consider disabling this in favour of manually tracking relevant
* aspects in getDefinitionSummary(). See getVersionHash() for how this is used.
*
* @stable to override
* @return bool
*/
public function enableModuleContentVersion() {
return false;
}
/**
* Get the definition summary for this module.
*
* This is the method subclasses are recommended to use to track data that
* should influence the module's version hash.
*
* Subclasses must call the parent getDefinitionSummary() and add to the
* returned array. It is recommended that each subclass appends its own array,
* to prevent clashes or accidental overwrites of array keys from the parent
* class. This gives each subclass a clean scope.
*
* @code
* $summary = parent::getDefinitionSummary( $context );
* $summary[] = [
* 'foo' => 123,
* 'bar' => 'quux',
* ];
* return $summary;
* @endcode
*
* Return an array that contains all significant properties that define the
* module. The returned data should be deterministic and only change when
* the generated module response would change. Prefer content hashes over
* modified timestamps because timestamps may change for unrelated reasons
* and are not deterministic (T102578). For example, because timestamps are
* not stored in Git, each branch checkout would cause all files to appear as
* new. Timestamps also tend to not match between servers causing additional
* ever-lasting churning of the version hash.
*
* Be careful not to normalise the data too much in an effort to be deterministic.
* For example, if a module concatenates files together (order is significant),
* then the definition summary could be a list of file names, and a list of
* file hashes. These lists should not be sorted as that would mean the cache
* is not invalidated when the order changes (T39812).
*
* This data structure must exclusively contain primitive "scalar" values,
* as it will be serialised using `json_encode`.
*
* @stable to override
* @since 1.23
* @param Context $context
* @return array|null
*/
public function getDefinitionSummary( Context $context ) {
return [
'_class' => static::class,
// Make sure that when filter cache for minification is invalidated,
// we also change the HTTP urls and mw.loader.store keys (T176884).
'_cacheVersion' => ResourceLoader::CACHE_VERSION,
];
}
/**
* Check whether this module is known to be empty. If a child class
* has an easy and cheap way to determine that this module is
* definitely going to be empty, it should override this method to
* return true in that case. Callers may optimize the request for this
* module away if this function returns true.
*
* @stable to override
* @param Context $context
* @return bool
*/
public function isKnownEmpty( Context $context ) {
return false;
}
/**
* Check whether this module should be embedded rather than linked
*
* Modules returning true here will be embedded rather than loaded by
* ClientHtml.
*
* @since 1.30
* @stable to override
* @param Context $context
* @return bool
*/
public function shouldEmbedModule( Context $context ) {
return $this->getGroup() === self::GROUP_PRIVATE;
}
/**
* Whether to skip the structure test ResourcesTest::testRespond() for this
* module.
*
* @since 1.42
* @stable to override
* @return bool
*/
public function shouldSkipStructureTest() {
return $this->getGroup() === self::GROUP_PRIVATE;
}
/**
* Validate a user-provided JavaScript blob.
*
* @param string $fileName
* @param string $contents JavaScript code
* @return string JavaScript code, either the original content or a replacement
* that uses `mw.log.error()` to communicate a syntax error.
*/
protected function validateScriptFile( $fileName, $contents ) {
if ( !$this->getConfig()->get( MainConfigNames::ResourceLoaderValidateJS ) ) {
return $contents;
}
$cache = MediaWikiServices::getInstance()->getMainWANObjectCache();
// Cache potentially slow parsing of JavaScript code during the
// critical path. This happens lazily when responding to requests
// for modules=site, modules=user, and Gadgets.
$error = $cache->getWithSetCallback(
$cache->makeKey(
'resourceloader-userjsparse',
self::USERJSPARSE_CACHE_VERSION,
md5( $contents ),
$fileName
),
$cache::TTL_WEEK,
static function () use ( $contents, $fileName ) {
try {
Peast::ES2016( $contents )->parse();
} catch ( PeastSyntaxException $e ) {
return $e->getMessage() . " on line " . $e->getPosition()->getLine();
}
// Cache success as null
return null;
}
);
if ( $error ) {
// Send the error to the browser console client-side.
// By returning this as replacement for the actual script,
// we ensure user-provided scripts are safe to include in a batch
// request, without risk of a syntax error in this blob breaking
// the response itself.
return 'mw.log.error(' .
json_encode(
'Parse error: ' . $error
) .
');';
}
return $contents;
}
/**
* Compute a non-cryptographic string hash of a file's contents.
* If the file does not exist or cannot be read, returns an empty string.
*
* @since 1.26 Uses MD4 instead of SHA1.
* @param string $filePath
* @return string Hash
*/
protected static function safeFileHash( $filePath ) {
return FileContentsHasher::getFileContentsHash( $filePath );
}
/**
* Get vary string.
*
* @internal For internal use only.
* @param Context $context
* @return string
*/
public static function getVary( Context $context ) {
return implode( '|', [
$context->getSkin(),
$context->getLanguage(),
] );
}
}