Router.php

Go to the documentation of this file.

<?php
 
namespace MediaWiki\Rest;
 
use AppendIterator;
use BagOStuff;
use MediaWiki\HookContainer\HookContainer;
use MediaWiki\MediaWikiServices;
use MediaWiki\Rest\BasicAccess\BasicAuthorizerInterface;
use MediaWiki\Rest\PathTemplateMatcher\PathMatcher;
use MediaWiki\Rest\Validator\Validator;
use Wikimedia\Message\MessageValue;
use Wikimedia\ObjectFactory;
 
class Router {
    private $routeFiles;
 
    private $extraRoutes;
 
    private $routesFromFiles;
 
    private $routeFileTimestamps;
 
    private $baseUrl;
 
    private $rootPath;
 
    private $cacheBag;
 
    private $matchers;
 
    private $configHash;
 
    private $responseFactory;
 
    private $basicAuth;
 
    private $objectFactory;
 
    private $restValidator;
 
    private $hookContainer;
 
    public function __construct( $routeFiles, $extraRoutes, $baseUrl, $rootPath,
        BagOStuff $cacheBag, ResponseFactory $responseFactory,
        BasicAuthorizerInterface $basicAuth, ObjectFactory $objectFactory,
        Validator $restValidator, HookContainer $hookContainer = null
    ) {
        $this->routeFiles = $routeFiles;
        $this->extraRoutes = $extraRoutes;
        $this->baseUrl = $baseUrl;
        $this->rootPath = $rootPath;
        $this->cacheBag = $cacheBag;
        $this->responseFactory = $responseFactory;
        $this->basicAuth = $basicAuth;
        $this->objectFactory = $objectFactory;
        $this->restValidator = $restValidator;
 
        if ( !$hookContainer ) {
            // b/c for OAuth extension
            $hookContainer = MediaWikiServices::getInstance()->getHookContainer();
        }
        $this->hookContainer = $hookContainer;
    }
 
    private function fetchCacheData() {
        $cacheData = $this->cacheBag->get( $this->getCacheKey() );
        if ( $cacheData && $cacheData['CONFIG-HASH'] === $this->getConfigHash() ) {
            unset( $cacheData['CONFIG-HASH'] );
            return $cacheData;
        } else {
            return false;
        }
    }
 
    private function getCacheKey() {
        return $this->cacheBag->makeKey( __CLASS__, '1' );
    }
 
    private function getConfigHash() {
        if ( $this->configHash === null ) {
            $this->configHash = md5( json_encode( [
                $this->extraRoutes,
                $this->getRouteFileTimestamps()
            ] ) );
        }
        return $this->configHash;
    }
 
    private function getRoutesFromFiles() {
        if ( $this->routesFromFiles === null ) {
            $this->routeFileTimestamps = [];
            foreach ( $this->routeFiles as $fileName ) {
                $this->routeFileTimestamps[$fileName] = filemtime( $fileName );
                $routes = json_decode( file_get_contents( $fileName ), true );
                if ( $this->routesFromFiles === null ) {
                    $this->routesFromFiles = $routes;
                } else {
                    $this->routesFromFiles = array_merge( $this->routesFromFiles, $routes );
                }
            }
        }
        return $this->routesFromFiles;
    }
 
    private function getRouteFileTimestamps() {
        if ( $this->routeFileTimestamps === null ) {
            $this->routeFileTimestamps = [];
            foreach ( $this->routeFiles as $fileName ) {
                $this->routeFileTimestamps[$fileName] = filemtime( $fileName );
            }
        }
        return $this->routeFileTimestamps;
    }
 
    private function getAllRoutes() {
        $iterator = new AppendIterator;
        $iterator->append( new \ArrayIterator( $this->getRoutesFromFiles() ) );
        $iterator->append( new \ArrayIterator( $this->extraRoutes ) );
        return $iterator;
    }
 
    private function getMatchers() {
        if ( $this->matchers === null ) {
            $cacheData = $this->fetchCacheData();
            $matchers = [];
            if ( $cacheData ) {
                foreach ( $cacheData as $method => $data ) {
                    $matchers[$method] = PathMatcher::newFromCache( $data );
                }
            } else {
                foreach ( $this->getAllRoutes() as $spec ) {
                    $methods = $spec['method'] ?? [ 'GET' ];
                    if ( !is_array( $methods ) ) {
                        $methods = [ $methods ];
                    }
                    foreach ( $methods as $method ) {
                        if ( !isset( $matchers[$method] ) ) {
                            $matchers[$method] = new PathMatcher;
                        }
                        $matchers[$method]->add( $spec['path'], $spec );
                    }
                }
 
                $cacheData = [ 'CONFIG-HASH' => $this->getConfigHash() ];
                foreach ( $matchers as $method => $matcher ) {
                    $cacheData[$method] = $matcher->getCacheData();
                }
                $this->cacheBag->set( $this->getCacheKey(), $cacheData );
            }
            $this->matchers = $matchers;
        }
        return $this->matchers;
    }
 
    private function getRelativePath( $path ) {
        if ( strlen( $this->rootPath ) > strlen( $path ) ||
            substr_compare( $path, $this->rootPath, 0, strlen( $this->rootPath ) ) !== 0
        ) {
            return false;
        }
        return substr( $path, strlen( $this->rootPath ) );
    }
 
    public function getRouteUrl( $route, $pathParams = [], $queryParams = [] ) {
        foreach ( $pathParams as $param => $value ) {
            // NOTE: we use rawurlencode here, since execute() uses rawurldecode().
            // Spaces in path params must be encoded to %20 (not +).
            $route = str_replace( '{' . $param . '}', rawurlencode( $value ), $route );
        }
 
        $url = $this->baseUrl . $this->rootPath . $route;
        return wfAppendQuery( $url, $queryParams );
    }
 
    public function execute( RequestInterface $request ) {
        $path = $request->getUri()->getPath();
        $relPath = $this->getRelativePath( $path );
        if ( $relPath === false ) {
            return $this->responseFactory->createLocalizedHttpError( 404,
                ( new MessageValue( 'rest-prefix-mismatch' ) )
                    ->plaintextParams( $path, $this->rootPath )
            );
        }
 
        $requestMethod = $request->getMethod();
        $matchers = $this->getMatchers();
        $matcher = $matchers[$requestMethod] ?? null;
        $match = $matcher ? $matcher->match( $relPath ) : null;
 
        // For a HEAD request, execute the GET handler instead if one exists.
        // The webserver will discard the body.
        if ( !$match && $requestMethod === 'HEAD' && isset( $matchers['GET'] ) ) {
            $match = $matchers['GET']->match( $relPath );
        }
 
        if ( !$match ) {
            // Check for 405 wrong method
            $allowed = [];
            foreach ( $matchers as $allowedMethod => $allowedMatcher ) {
                if ( $allowedMethod === $requestMethod ) {
                    continue;
                }
                if ( $allowedMatcher->match( $relPath ) ) {
                    $allowed[] = $allowedMethod;
                }
            }
            if ( $allowed ) {
                $response = $this->responseFactory->createLocalizedHttpError( 405,
                    ( new MessageValue( 'rest-wrong-method' ) )
                        ->textParams( $requestMethod )
                        ->commaListParams( $allowed )
                        ->numParams( count( $allowed ) )
                );
                $response->setHeader( 'Allow', $allowed );
                return $response;
            } else {
                // Did not match with any other method, must be 404
                return $this->responseFactory->createLocalizedHttpError( 404,
                    ( new MessageValue( 'rest-no-match' ) )
                        ->plaintextParams( $relPath )
                );
            }
        }
 
        // Use rawurldecode so a "+" in path params is not interpreted as a space character.
        $request->setPathParams( array_map( 'rawurldecode', $match['params'] ) );
        $handler = $this->createHandler( $request, $match['userData'] );
 
        try {
            return $this->executeHandler( $handler );
        } catch ( HttpException $e ) {
            return $this->responseFactory->createFromException( $e );
        }
    }
 
    private function createHandler( RequestInterface $request, array $spec ): Handler {
        $objectFactorySpec = array_intersect_key( $spec,
            [ 'factory' => true, 'class' => true, 'args' => true, 'services' => true ] );
        $handler = $this->objectFactory->createObject( $objectFactorySpec );
        $handler->init( $this, $request, $spec, $this->responseFactory, $this->hookContainer );
 
        return $handler;
    }
 
    private function executeHandler( $handler ): ResponseInterface {
        // Check for basic authorization, to avoid leaking data from private wikis
        $authResult = $this->basicAuth->authorize( $handler->getRequest(), $handler );
        if ( $authResult ) {
            return $this->responseFactory->createHttpError( 403, [ 'error' => $authResult ] );
        }
 
        // Validate the parameters
        $handler->validate( $this->restValidator );
 
        // Check conditional request headers
        $earlyResponse = $handler->checkPreconditions();
        if ( $earlyResponse ) {
            return $earlyResponse;
        }
 
        // Run the main part of the handler
        $response = $handler->execute();
        if ( !( $response instanceof ResponseInterface ) ) {
            $response = $this->responseFactory->createFromReturnValue( $response );
        }
 
        // Set Last-Modified and ETag headers in the response if available
        $handler->applyConditionalResponseHeaders( $response );
 
        return $response;
    }
}