includes/WikiMap.php

   1 <?php
   2 /**
   3  * Tools for dealing with other locally-hosted wikis.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  * http://www.gnu.org/copyleft/gpl.html
  19  *
  20  * @file
  21  */
  22
  23 use MediaWiki\MediaWikiServices;
  24 use Wikimedia\Rdbms\DatabaseDomain;
  25
  26 /**
  27  * Helper tools for dealing with other locally-hosted wikis.
  28  */
  29 class WikiMap {
  30
  31         /**
  32          * Get a WikiReference object for $wikiID
  33          *
  34          * @param string $wikiID Wiki'd id (generally database name)
  35          * @return WikiReference|null WikiReference object or null if the wiki was not found
  36          */
  37         public static function getWiki( $wikiID ) {
  38                 $wikiReference = self::getWikiReferenceFromWgConf( $wikiID );
  39                 if ( $wikiReference ) {
  40                         return $wikiReference;
  41                 }
  42
  43                 // Try sites, if $wgConf failed
  44                 return self::getWikiWikiReferenceFromSites( $wikiID );
  45         }
  46
  47         /**
  48          * @param string $wikiID
  49          * @return WikiReference|null WikiReference object or null if the wiki was not found
  50          */
  51         private static function getWikiReferenceFromWgConf( $wikiID ) {
  52                 global $wgConf;
  53
  54                 $wgConf->loadFullData();
  55
  56                 list( $major, $minor ) = $wgConf->siteFromDB( $wikiID );
  57                 if ( $major === null ) {
  58                         return null;
  59                 }
  60                 $server = $wgConf->get( 'wgServer', $wikiID, $major,
  61                         [ 'lang' => $minor, 'site' => $major ] );
  62
  63                 $canonicalServer = $wgConf->get( 'wgCanonicalServer', $wikiID, $major,
  64                         [ 'lang' => $minor, 'site' => $major ] );
  65                 if ( $canonicalServer === false || $canonicalServer === null ) {
  66                         $canonicalServer = $server;
  67                 }
  68
  69                 $path = $wgConf->get( 'wgArticlePath', $wikiID, $major,
  70                         [ 'lang' => $minor, 'site' => $major ] );
  71
  72                 // If we don't have a canonical server or a path containing $1, the
  73                 // WikiReference isn't going to function properly. Just return null in
  74                 // that case.
  75                 if ( !is_string( $canonicalServer ) || !is_string( $path ) || strpos( $path, '$1' ) === false ) {
  76                         return null;
  77                 }
  78
  79                 return new WikiReference( $canonicalServer, $path, $server );
  80         }
  81
  82         /**
  83          * @param string $wikiID
  84          * @return WikiReference|null WikiReference object or null if the wiki was not found
  85          */
  86         private static function getWikiWikiReferenceFromSites( $wikiID ) {
  87                 $siteLookup = MediaWikiServices::getInstance()->getSiteLookup();
  88                 $site = $siteLookup->getSite( $wikiID );
  89
  90                 if ( !$site instanceof MediaWikiSite ) {
  91                         // Abort if not a MediaWikiSite, as this is about Wikis
  92                         return null;
  93                 }
  94
  95                 $urlParts = wfParseUrl( $site->getPageUrl() );
  96                 if ( $urlParts === false || !isset( $urlParts['path'] ) || !isset( $urlParts['host'] ) ) {
  97                         // We can't create a meaningful WikiReference without URLs
  98                         return null;
  99                 }
 100
 101                 // XXX: Check whether path contains a $1?
 102                 $path = $urlParts['path'];
 103                 if ( isset( $urlParts['query'] ) ) {
 104                         $path .= '?' . $urlParts['query'];
 105                 }
 106
 107                 $canonicalServer = $urlParts['scheme'] ?? 'http';
 108                 $canonicalServer .= '://' . $urlParts['host'];
 109
 110                 return new WikiReference( $canonicalServer, $path );
 111         }
 112
 113         /**
 114          * Convenience to get the wiki's display name
 115          *
 116          * @todo We can give more info than just the wiki id!
 117          * @param string $wikiID Wiki'd id (generally database name)
 118          * @return string|int Wiki's name or $wiki_id if the wiki was not found
 119          */
 120         public static function getWikiName( $wikiID ) {
 121                 $wiki = self::getWiki( $wikiID );
 122
 123                 if ( $wiki ) {
 124                         return $wiki->getDisplayName();
 125                 }
 126                 return $wikiID;
 127         }
 128
 129         /**
 130          * Convenience to get a link to a user page on a foreign wiki
 131          *
 132          * @param string $wikiID Wiki'd id (generally database name)
 133          * @param string $user User name (must be normalised before calling this function!)
 134          * @param string|null $text Link's text; optional, default to "User:$user"
 135          * @return string HTML link or false if the wiki was not found
 136          */
 137         public static function foreignUserLink( $wikiID, $user, $text = null ) {
 138                 return self::makeForeignLink( $wikiID, "User:$user", $text );
 139         }
 140
 141         /**
 142          * Convenience to get a link to a page on a foreign wiki
 143          *
 144          * @param string $wikiID Wiki'd id (generally database name)
 145          * @param string $page Page name (must be normalised before calling this function!)
 146          * @param string|null $text Link's text; optional, default to $page
 147          * @return string|false HTML link or false if the wiki was not found
 148          */
 149         public static function makeForeignLink( $wikiID, $page, $text = null ) {
 150                 if ( !$text ) {
 151                         $text = $page;
 152                 }
 153
 154                 $url = self::getForeignURL( $wikiID, $page );
 155                 if ( $url === false ) {
 156                         return false;
 157                 }
 158
 159                 return Linker::makeExternalLink( $url, $text );
 160         }
 161
 162         /**
 163          * Convenience to get a url to a page on a foreign wiki
 164          *
 165          * @param string $wikiID Wiki'd id (generally database name)
 166          * @param string $page Page name (must be normalised before calling this function!)
 167          * @param string|null $fragmentId
 168          *
 169          * @return string|bool URL or false if the wiki was not found
 170          */
 171         public static function getForeignURL( $wikiID, $page, $fragmentId = null ) {
 172                 $wiki = self::getWiki( $wikiID );
 173
 174                 if ( $wiki ) {
 175                         return $wiki->getFullUrl( $page, $fragmentId );
 176                 }
 177
 178                 return false;
 179         }
 180
 181         /**
 182          * Get canonical server info for all local wikis in the map that have one
 183          *
 184          * @return array Map of (local wiki ID => map of (url,parts))
 185          * @since 1.30
 186          */
 187         public static function getCanonicalServerInfoForAllWikis() {
 188                 $cache = MediaWikiServices::getInstance()->getLocalServerObjectCache();
 189
 190                 return $cache->getWithSetCallback(
 191                         $cache->makeGlobalKey( 'wikimap', 'canonical-urls' ),
 192                         $cache::TTL_DAY,
 193                         function () {
 194                                 global $wgLocalDatabases, $wgCanonicalServer;
 195
 196                                 $infoMap = [];
 197                                 // Make sure at least the current wiki is set, for simple configurations.
 198                                 // This also makes it the first in the map, which is useful for common cases.
 199                                 $wikiId = self::getWikiIdFromDbDomain( self::getCurrentWikiDbDomain() );
 200                                 $infoMap[$wikiId] = [
 201                                         'url' => $wgCanonicalServer,
 202                                         'parts' => wfParseUrl( $wgCanonicalServer )
 203                                 ];
 204
 205                                 foreach ( $wgLocalDatabases as $wikiId ) {
 206                                         $wikiReference = self::getWiki( $wikiId );
 207                                         if ( $wikiReference ) {
 208                                                 $url = $wikiReference->getCanonicalServer();
 209                                                 $infoMap[$wikiId] = [ 'url' => $url, 'parts' => wfParseUrl( $url ) ];
 210                                         }
 211                                 }
 212
 213                                 return $infoMap;
 214                         }
 215                 );
 216         }
 217
 218         /**
 219          * @param string $url
 220          * @return bool|string Wiki ID or false
 221          * @since 1.30
 222          */
 223         public static function getWikiFromUrl( $url ) {
 224                 global $wgCanonicalServer;
 225
 226                 if ( strpos( $url, "$wgCanonicalServer/" ) === 0 ) {
 227                         // Optimisation: Handle the the common case.
 228                         // (Duplicates self::getCanonicalServerInfoForAllWikis)
 229                         return self::getWikiIdFromDbDomain( self::getCurrentWikiDbDomain() );
 230                 }
 231
 232                 $urlPartsCheck = wfParseUrl( $url );
 233                 if ( $urlPartsCheck === false ) {
 234                         return false;
 235                 }
 236
 237                 static $relevantKeys = [ 'host' => 1, 'port' => 1 ];
 238                 $urlPartsCheck = array_intersect_key( $urlPartsCheck, $relevantKeys );
 239
 240                 foreach ( self::getCanonicalServerInfoForAllWikis() as $wikiId => $info ) {
 241                         $urlParts = $info['parts'];
 242                         if ( $urlParts === false ) {
 243                                 continue; // sanity
 244                         }
 245
 246                         $urlParts = array_intersect_key( $urlParts, $relevantKeys );
 247                         if ( $urlParts == $urlPartsCheck ) {
 248                                 return $wikiId;
 249                         }
 250                 }
 251
 252                 return false;
 253         }
 254
 255         /**
 256          * Get the wiki ID of a database domain
 257          *
 258          * This is like DatabaseDomain::getId() without encoding (for legacy reasons) and
 259          * without the schema if it is the generic installer default of "mediawiki"/"dbo"
 260          *
 261          * @see $wgDBmwschema
 262          * @see PostgresInstaller
 263          * @see MssqlInstaller
 264          *
 265          * @param string|DatabaseDomain $domain
 266          * @return string
 267          * @since 1.31
 268          */
 269         public static function getWikiIdFromDbDomain( $domain ) {
 270                 $domain = DatabaseDomain::newFromId( $domain );
 271                 // Since the schema was not always part of the wiki ID, try to maintain backwards
 272                 // compatibility with some common cases. Assume that if the DB domain schema is just
 273                 // the installer default then it is probably the case that the schema is the same for
 274                 // all wikis in the farm. Historically, any wiki farm had to make the database/prefix
 275                 // combination unique per wiki. Ommit the schema if it does not seem wiki specific.
 276                 if ( !in_array( $domain->getSchema(), [ null, 'mediawiki', 'dbo' ], true ) ) {
 277                         // This means a site admin may have specifically taylored the schemas.
 278                         // Domain IDs might use the form <DB>-<project>- or <DB>-<project>-<language>_,
 279                         // meaning that the schema portion must be accounted for to disambiguate wikis.
 280                         return "{$domain->getDatabase()}-{$domain->getSchema()}-{$domain->getTablePrefix()}";
 281                 }
 282                 // Note that if this wiki ID is passed a a domain ID to LoadBalancer, then it can
 283                 // handle the schema by assuming the generic "mediawiki" schema if needed.
 284                 return strlen( $domain->getTablePrefix() )
 285                         ? "{$domain->getDatabase()}-{$domain->getTablePrefix()}"
 286                         : (string)$domain->getDatabase();
 287         }
 288
 289         /**
 290          * @param string $domain
 291          * @return string
 292          * @deprecated Since 1.33; use getWikiIdFromDbDomain()
 293          */
 294         public static function getWikiIdFromDomain( $domain ) {
 295                 return self::getWikiIdFromDbDomain( $domain );
 296         }
 297
 298         /**
 299          * @return DatabaseDomain Database domain of the current wiki
 300          * @since 1.33
 301          */
 302         public static function getCurrentWikiDbDomain() {
 303                 global $wgDBname, $wgDBmwschema, $wgDBprefix;
 304                 // Avoid invoking LBFactory to avoid any chance of recursion
 305                 return new DatabaseDomain( $wgDBname, $wgDBmwschema, (string)$wgDBprefix );
 306         }
 307
 308         /**
 309          * @param DatabaseDomain|string $domain
 310          * @return bool Whether $domain matches the DB domain of the current wiki
 311          * @since 1.33
 312          */
 313         public static function isCurrentWikiDbDomain( $domain ) {
 314                 return self::getCurrentWikiDbDomain()->equals( DatabaseDomain::newFromId( $domain ) );
 315         }
 316
 317         /**
 318          * @param string $wikiId
 319          * @return bool Whether $wikiId matches the wiki ID of the current wiki
 320          * @since 1.33
 321          */
 322         public static function isCurrentWikiId( $wikiId ) {
 323                 return ( self::getWikiIdFromDbDomain( self::getCurrentWikiDbDomain() ) === $wikiId );
 324         }
 325 }