| [ Index ] |
PHP Cross Reference of MediaWiki-1.24.0 |
[Summary view] [Print] [Text view]
1 <?php 2 /** 3 * @defgroup FileRepo File Repository 4 * 5 * @brief This module handles how MediaWiki interacts with filesystems. 6 * 7 * @details 8 */ 9 10 /** 11 * Base code for file repositories. 12 * 13 * This program is free software; you can redistribute it and/or modify 14 * it under the terms of the GNU General Public License as published by 15 * the Free Software Foundation; either version 2 of the License, or 16 * (at your option) any later version. 17 * 18 * This program is distributed in the hope that it will be useful, 19 * but WITHOUT ANY WARRANTY; without even the implied warranty of 20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 21 * GNU General Public License for more details. 22 * 23 * You should have received a copy of the GNU General Public License along 24 * with this program; if not, write to the Free Software Foundation, Inc., 25 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. 26 * http://www.gnu.org/copyleft/gpl.html 27 * 28 * @file 29 * @ingroup FileRepo 30 */ 31 32 /** 33 * Base class for file repositories 34 * 35 * @ingroup FileRepo 36 */ 37 class FileRepo { 38 const DELETE_SOURCE = 1; 39 const OVERWRITE = 2; 40 const OVERWRITE_SAME = 4; 41 const SKIP_LOCKING = 8; 42 43 const NAME_AND_TIME_ONLY = 1; 44 45 /** @var bool Whether to fetch commons image description pages and display 46 * them on the local wiki */ 47 public $fetchDescription; 48 49 /** @var int */ 50 public $descriptionCacheExpiry; 51 52 /** @var FileBackend */ 53 protected $backend; 54 55 /** @var array Map of zones to config */ 56 protected $zones = array(); 57 58 /** @var string URL of thumb.php */ 59 protected $thumbScriptUrl; 60 61 /** @var bool Whether to skip media file transformation on parse and rely 62 * on a 404 handler instead. */ 63 protected $transformVia404; 64 65 /** @var string URL of image description pages, e.g. 66 * http://en.wikipedia.org/wiki/File: 67 */ 68 protected $descBaseUrl; 69 70 /** @var string URL of the MediaWiki installation, equivalent to 71 * $wgScriptPath, e.g. https://en.wikipedia.org/w 72 */ 73 protected $scriptDirUrl; 74 75 /** @var string Script extension of the MediaWiki installation, equivalent 76 * to $wgScriptExtension, e.g. .php5 defaults to .php */ 77 protected $scriptExtension; 78 79 /** @var string Equivalent to $wgArticlePath, e.g. http://en.wikipedia.org/wiki/$1 */ 80 protected $articleUrl; 81 82 /** @var bool Equivalent to $wgCapitalLinks (or $wgCapitalLinkOverrides[NS_FILE], 83 * determines whether filenames implicitly start with a capital letter. 84 * The current implementation may give incorrect description page links 85 * when the local $wgCapitalLinks and initialCapital are mismatched. 86 */ 87 protected $initialCapital; 88 89 /** @var string May be 'paranoid' to remove all parameters from error 90 * messages, 'none' to leave the paths in unchanged, or 'simple' to 91 * replace paths with placeholders. Default for LocalRepo is 92 * 'simple'. 93 */ 94 protected $pathDisclosureProtection = 'simple'; 95 96 /** @var bool Public zone URL. */ 97 protected $url; 98 99 /** @var string The base thumbnail URL. Defaults to "<url>/thumb". */ 100 protected $thumbUrl; 101 102 /** @var int The number of directory levels for hash-based division of files */ 103 protected $hashLevels; 104 105 /** @var int The number of directory levels for hash-based division of deleted files */ 106 protected $deletedHashLevels; 107 108 /** @var int File names over this size will use the short form of thumbnail 109 * names. Short thumbnail names only have the width, parameters, and the 110 * extension. 111 */ 112 protected $abbrvThreshold; 113 114 /** @var string The URL of the repo's favicon, if any */ 115 protected $favicon; 116 117 /** 118 * Factory functions for creating new files 119 * Override these in the base class 120 */ 121 protected $fileFactory = array( 'UnregisteredLocalFile', 'newFromTitle' ); 122 protected $oldFileFactory = false; 123 protected $fileFactoryKey = false; 124 protected $oldFileFactoryKey = false; 125 126 /** 127 * @param array|null $info 128 * @throws MWException 129 */ 130 public function __construct( array $info = null ) { 131 // Verify required settings presence 132 if ( 133 $info === null 134 || !array_key_exists( 'name', $info ) 135 || !array_key_exists( 'backend', $info ) 136 ) { 137 throw new MWException( __CLASS__ . 138 " requires an array of options having both 'name' and 'backend' keys.\n" ); 139 } 140 141 // Required settings 142 $this->name = $info['name']; 143 if ( $info['backend'] instanceof FileBackend ) { 144 $this->backend = $info['backend']; // useful for testing 145 } else { 146 $this->backend = FileBackendGroup::singleton()->get( $info['backend'] ); 147 } 148 149 // Optional settings that can have no value 150 $optionalSettings = array( 151 'descBaseUrl', 'scriptDirUrl', 'articleUrl', 'fetchDescription', 152 'thumbScriptUrl', 'pathDisclosureProtection', 'descriptionCacheExpiry', 153 'scriptExtension', 'favicon' 154 ); 155 foreach ( $optionalSettings as $var ) { 156 if ( isset( $info[$var] ) ) { 157 $this->$var = $info[$var]; 158 } 159 } 160 161 // Optional settings that have a default 162 $this->initialCapital = isset( $info['initialCapital'] ) 163 ? $info['initialCapital'] 164 : MWNamespace::isCapitalized( NS_FILE ); 165 $this->url = isset( $info['url'] ) 166 ? $info['url'] 167 : false; // a subclass may set the URL (e.g. ForeignAPIRepo) 168 if ( isset( $info['thumbUrl'] ) ) { 169 $this->thumbUrl = $info['thumbUrl']; 170 } else { 171 $this->thumbUrl = $this->url ? "{$this->url}/thumb" : false; 172 } 173 $this->hashLevels = isset( $info['hashLevels'] ) 174 ? $info['hashLevels'] 175 : 2; 176 $this->deletedHashLevels = isset( $info['deletedHashLevels'] ) 177 ? $info['deletedHashLevels'] 178 : $this->hashLevels; 179 $this->transformVia404 = !empty( $info['transformVia404'] ); 180 $this->abbrvThreshold = isset( $info['abbrvThreshold'] ) 181 ? $info['abbrvThreshold'] 182 : 255; 183 $this->isPrivate = !empty( $info['isPrivate'] ); 184 // Give defaults for the basic zones... 185 $this->zones = isset( $info['zones'] ) ? $info['zones'] : array(); 186 foreach ( array( 'public', 'thumb', 'transcoded', 'temp', 'deleted' ) as $zone ) { 187 if ( !isset( $this->zones[$zone]['container'] ) ) { 188 $this->zones[$zone]['container'] = "{$this->name}-{$zone}"; 189 } 190 if ( !isset( $this->zones[$zone]['directory'] ) ) { 191 $this->zones[$zone]['directory'] = ''; 192 } 193 if ( !isset( $this->zones[$zone]['urlsByExt'] ) ) { 194 $this->zones[$zone]['urlsByExt'] = array(); 195 } 196 } 197 } 198 199 /** 200 * Get the file backend instance. Use this function wisely. 201 * 202 * @return FileBackend 203 */ 204 public function getBackend() { 205 return $this->backend; 206 } 207 208 /** 209 * Get an explanatory message if this repo is read-only. 210 * This checks if an administrator disabled writes to the backend. 211 * 212 * @return string|bool Returns false if the repo is not read-only 213 */ 214 public function getReadOnlyReason() { 215 return $this->backend->getReadOnlyReason(); 216 } 217 218 /** 219 * Check if a single zone or list of zones is defined for usage 220 * 221 * @param array $doZones Only do a particular zones 222 * @throws MWException 223 * @return Status 224 */ 225 protected function initZones( $doZones = array() ) { 226 $status = $this->newGood(); 227 foreach ( (array)$doZones as $zone ) { 228 $root = $this->getZonePath( $zone ); 229 if ( $root === null ) { 230 throw new MWException( "No '$zone' zone defined in the {$this->name} repo." ); 231 } 232 } 233 234 return $status; 235 } 236 237 /** 238 * Determine if a string is an mwrepo:// URL 239 * 240 * @param string $url 241 * @return bool 242 */ 243 public static function isVirtualUrl( $url ) { 244 return substr( $url, 0, 9 ) == 'mwrepo://'; 245 } 246 247 /** 248 * Get a URL referring to this repository, with the private mwrepo protocol. 249 * The suffix, if supplied, is considered to be unencoded, and will be 250 * URL-encoded before being returned. 251 * 252 * @param string|bool $suffix 253 * @return string 254 */ 255 public function getVirtualUrl( $suffix = false ) { 256 $path = 'mwrepo://' . $this->name; 257 if ( $suffix !== false ) { 258 $path .= '/' . rawurlencode( $suffix ); 259 } 260 261 return $path; 262 } 263 264 /** 265 * Get the URL corresponding to one of the four basic zones 266 * 267 * @param string $zone One of: public, deleted, temp, thumb 268 * @param string|null $ext Optional file extension 269 * @return string|bool 270 */ 271 public function getZoneUrl( $zone, $ext = null ) { 272 if ( in_array( $zone, array( 'public', 'temp', 'thumb', 'transcoded' ) ) ) { 273 // standard public zones 274 if ( $ext !== null && isset( $this->zones[$zone]['urlsByExt'][$ext] ) ) { 275 // custom URL for extension/zone 276 return $this->zones[$zone]['urlsByExt'][$ext]; 277 } elseif ( isset( $this->zones[$zone]['url'] ) ) { 278 // custom URL for zone 279 return $this->zones[$zone]['url']; 280 } 281 } 282 switch ( $zone ) { 283 case 'public': 284 return $this->url; 285 case 'temp': 286 return "{$this->url}/temp"; 287 case 'deleted': 288 return false; // no public URL 289 case 'thumb': 290 return $this->thumbUrl; 291 case 'transcoded': 292 return "{$this->url}/transcoded"; 293 default: 294 return false; 295 } 296 } 297 298 /** 299 * @return bool Whether non-ASCII path characters are allowed 300 */ 301 public function backendSupportsUnicodePaths() { 302 return ( $this->getBackend()->getFeatures() & FileBackend::ATTR_UNICODE_PATHS ); 303 } 304 305 /** 306 * Get the backend storage path corresponding to a virtual URL. 307 * Use this function wisely. 308 * 309 * @param string $url 310 * @throws MWException 311 * @return string 312 */ 313 public function resolveVirtualUrl( $url ) { 314 if ( substr( $url, 0, 9 ) != 'mwrepo://' ) { 315 throw new MWException( __METHOD__ . ': unknown protocol' ); 316 } 317 $bits = explode( '/', substr( $url, 9 ), 3 ); 318 if ( count( $bits ) != 3 ) { 319 throw new MWException( __METHOD__ . ": invalid mwrepo URL: $url" ); 320 } 321 list( $repo, $zone, $rel ) = $bits; 322 if ( $repo !== $this->name ) { 323 throw new MWException( __METHOD__ . ": fetching from a foreign repo is not supported" ); 324 } 325 $base = $this->getZonePath( $zone ); 326 if ( !$base ) { 327 throw new MWException( __METHOD__ . ": invalid zone: $zone" ); 328 } 329 330 return $base . '/' . rawurldecode( $rel ); 331 } 332 333 /** 334 * The the storage container and base path of a zone 335 * 336 * @param string $zone 337 * @return array (container, base path) or (null, null) 338 */ 339 protected function getZoneLocation( $zone ) { 340 if ( !isset( $this->zones[$zone] ) ) { 341 return array( null, null ); // bogus 342 } 343 344 return array( $this->zones[$zone]['container'], $this->zones[$zone]['directory'] ); 345 } 346 347 /** 348 * Get the storage path corresponding to one of the zones 349 * 350 * @param string $zone 351 * @return string|null Returns null if the zone is not defined 352 */ 353 public function getZonePath( $zone ) { 354 list( $container, $base ) = $this->getZoneLocation( $zone ); 355 if ( $container === null || $base === null ) { 356 return null; 357 } 358 $backendName = $this->backend->getName(); 359 if ( $base != '' ) { // may not be set 360 $base = "/{$base}"; 361 } 362 363 return "mwstore://$backendName/{$container}{$base}"; 364 } 365 366 /** 367 * Create a new File object from the local repository 368 * 369 * @param Title|string $title Title object or string 370 * @param bool|string $time Time at which the image was uploaded. If this 371 * is specified, the returned object will be an instance of the 372 * repository's old file class instead of a current file. Repositories 373 * not supporting version control should return false if this parameter 374 * is set. 375 * @return File|null A File, or null if passed an invalid Title 376 */ 377 public function newFile( $title, $time = false ) { 378 $title = File::normalizeTitle( $title ); 379 if ( !$title ) { 380 return null; 381 } 382 if ( $time ) { 383 if ( $this->oldFileFactory ) { 384 return call_user_func( $this->oldFileFactory, $title, $this, $time ); 385 } else { 386 return false; 387 } 388 } else { 389 return call_user_func( $this->fileFactory, $title, $this ); 390 } 391 } 392 393 /** 394 * Find an instance of the named file created at the specified time 395 * Returns false if the file does not exist. Repositories not supporting 396 * version control should return false if the time is specified. 397 * 398 * @param Title|string $title Title object or string 399 * @param array $options Associative array of options: 400 * time: requested time for a specific file version, or false for the 401 * current version. An image object will be returned which was 402 * created at the specified time (which may be archived or current). 403 * ignoreRedirect: If true, do not follow file redirects 404 * private: If true, return restricted (deleted) files if the current 405 * user is allowed to view them. Otherwise, such files will not 406 * be found. If a User object, use that user instead of the current. 407 * @return File|bool False on failure 408 */ 409 public function findFile( $title, $options = array() ) { 410 $title = File::normalizeTitle( $title ); 411 if ( !$title ) { 412 return false; 413 } 414 $time = isset( $options['time'] ) ? $options['time'] : false; 415 # First try the current version of the file to see if it precedes the timestamp 416 $img = $this->newFile( $title ); 417 if ( !$img ) { 418 return false; 419 } 420 if ( $img->exists() && ( !$time || $img->getTimestamp() == $time ) ) { 421 return $img; 422 } 423 # Now try an old version of the file 424 if ( $time !== false ) { 425 $img = $this->newFile( $title, $time ); 426 if ( $img && $img->exists() ) { 427 if ( !$img->isDeleted( File::DELETED_FILE ) ) { 428 return $img; // always OK 429 } elseif ( !empty( $options['private'] ) && 430 $img->userCan( File::DELETED_FILE, 431 $options['private'] instanceof User ? $options['private'] : null 432 ) 433 ) { 434 return $img; 435 } 436 } 437 } 438 439 # Now try redirects 440 if ( !empty( $options['ignoreRedirect'] ) ) { 441 return false; 442 } 443 $redir = $this->checkRedirect( $title ); 444 if ( $redir && $title->getNamespace() == NS_FILE ) { 445 $img = $this->newFile( $redir ); 446 if ( !$img ) { 447 return false; 448 } 449 if ( $img->exists() ) { 450 $img->redirectedFrom( $title->getDBkey() ); 451 452 return $img; 453 } 454 } 455 456 return false; 457 } 458 459 /** 460 * Find many files at once. 461 * 462 * @param array $items An array of titles, or an array of findFile() options with 463 * the "title" option giving the title. Example: 464 * 465 * $findItem = array( 'title' => $title, 'private' => true ); 466 * $findBatch = array( $findItem ); 467 * $repo->findFiles( $findBatch ); 468 * 469 * No title should appear in $items twice, as the result use titles as keys 470 * @param int $flags Supports: 471 * - FileRepo::NAME_AND_TIME_ONLY : return a (search title => (title,timestamp)) map. 472 * The search title uses the input titles; the other is the final post-redirect title. 473 * All titles are returned as string DB keys and the inner array is associative. 474 * @return array Map of (file name => File objects) for matches 475 */ 476 public function findFiles( array $items, $flags = 0 ) { 477 $result = array(); 478 foreach ( $items as $item ) { 479 if ( is_array( $item ) ) { 480 $title = $item['title']; 481 $options = $item; 482 unset( $options['title'] ); 483 } else { 484 $title = $item; 485 $options = array(); 486 } 487 $file = $this->findFile( $title, $options ); 488 if ( $file ) { 489 $searchName = File::normalizeTitle( $title )->getDBkey(); // must be valid 490 if ( $flags & self::NAME_AND_TIME_ONLY ) { 491 $result[$searchName] = array( 492 'title' => $file->getTitle()->getDBkey(), 493 'timestamp' => $file->getTimestamp() 494 ); 495 } else { 496 $result[$searchName] = $file; 497 } 498 } 499 } 500 501 return $result; 502 } 503 504 /** 505 * Find an instance of the file with this key, created at the specified time 506 * Returns false if the file does not exist. Repositories not supporting 507 * version control should return false if the time is specified. 508 * 509 * @param string $sha1 Base 36 SHA-1 hash 510 * @param array $options Option array, same as findFile(). 511 * @return File|bool False on failure 512 */ 513 public function findFileFromKey( $sha1, $options = array() ) { 514 $time = isset( $options['time'] ) ? $options['time'] : false; 515 # First try to find a matching current version of a file... 516 if ( $this->fileFactoryKey ) { 517 $img = call_user_func( $this->fileFactoryKey, $sha1, $this, $time ); 518 } else { 519 return false; // find-by-sha1 not supported 520 } 521 if ( $img && $img->exists() ) { 522 return $img; 523 } 524 # Now try to find a matching old version of a file... 525 if ( $time !== false && $this->oldFileFactoryKey ) { // find-by-sha1 supported? 526 $img = call_user_func( $this->oldFileFactoryKey, $sha1, $this, $time ); 527 if ( $img && $img->exists() ) { 528 if ( !$img->isDeleted( File::DELETED_FILE ) ) { 529 return $img; // always OK 530 } elseif ( !empty( $options['private'] ) && 531 $img->userCan( File::DELETED_FILE, 532 $options['private'] instanceof User ? $options['private'] : null 533 ) 534 ) { 535 return $img; 536 } 537 } 538 } 539 540 return false; 541 } 542 543 /** 544 * Get an array or iterator of file objects for files that have a given 545 * SHA-1 content hash. 546 * 547 * STUB 548 * @param string $hash SHA-1 hash 549 * @return File[] 550 */ 551 public function findBySha1( $hash ) { 552 return array(); 553 } 554 555 /** 556 * Get an array of arrays or iterators of file objects for files that 557 * have the given SHA-1 content hashes. 558 * 559 * @param array $hashes An array of hashes 560 * @return array An Array of arrays or iterators of file objects and the hash as key 561 */ 562 public function findBySha1s( array $hashes ) { 563 $result = array(); 564 foreach ( $hashes as $hash ) { 565 $files = $this->findBySha1( $hash ); 566 if ( count( $files ) ) { 567 $result[$hash] = $files; 568 } 569 } 570 571 return $result; 572 } 573 574 /** 575 * Return an array of files where the name starts with $prefix. 576 * 577 * STUB 578 * @param string $prefix The prefix to search for 579 * @param int $limit The maximum amount of files to return 580 * @return array 581 */ 582 public function findFilesByPrefix( $prefix, $limit ) { 583 return array(); 584 } 585 586 /** 587 * Get the public root URL of the repository 588 * 589 * @deprecated since 1.20 590 * @return string 591 */ 592 public function getRootUrl() { 593 return $this->getZoneUrl( 'public' ); 594 } 595 596 /** 597 * Get the URL of thumb.php 598 * 599 * @return string 600 */ 601 public function getThumbScriptUrl() { 602 return $this->thumbScriptUrl; 603 } 604 605 /** 606 * Returns true if the repository can transform files via a 404 handler 607 * 608 * @return bool 609 */ 610 public function canTransformVia404() { 611 return $this->transformVia404; 612 } 613 614 /** 615 * Get the name of a file from its title object 616 * 617 * @param Title $title 618 * @return string 619 */ 620 public function getNameFromTitle( Title $title ) { 621 global $wgContLang; 622 if ( $this->initialCapital != MWNamespace::isCapitalized( NS_FILE ) ) { 623 $name = $title->getUserCaseDBKey(); 624 if ( $this->initialCapital ) { 625 $name = $wgContLang->ucfirst( $name ); 626 } 627 } else { 628 $name = $title->getDBkey(); 629 } 630 631 return $name; 632 } 633 634 /** 635 * Get the public zone root storage directory of the repository 636 * 637 * @return string 638 */ 639 public function getRootDirectory() { 640 return $this->getZonePath( 'public' ); 641 } 642 643 /** 644 * Get a relative path including trailing slash, e.g. f/fa/ 645 * If the repo is not hashed, returns an empty string 646 * 647 * @param string $name Name of file 648 * @return string 649 */ 650 public function getHashPath( $name ) { 651 return self::getHashPathForLevel( $name, $this->hashLevels ); 652 } 653 654 /** 655 * Get a relative path including trailing slash, e.g. f/fa/ 656 * If the repo is not hashed, returns an empty string 657 * 658 * @param string $suffix Basename of file from FileRepo::storeTemp() 659 * @return string 660 */ 661 public function getTempHashPath( $suffix ) { 662 $parts = explode( '!', $suffix, 2 ); // format is <timestamp>!<name> or just <name> 663 $name = isset( $parts[1] ) ? $parts[1] : $suffix; // hash path is not based on timestamp 664 return self::getHashPathForLevel( $name, $this->hashLevels ); 665 } 666 667 /** 668 * @param string $name 669 * @param int $levels 670 * @return string 671 */ 672 protected static function getHashPathForLevel( $name, $levels ) { 673 if ( $levels == 0 ) { 674 return ''; 675 } else { 676 $hash = md5( $name ); 677 $path = ''; 678 for ( $i = 1; $i <= $levels; $i++ ) { 679 $path .= substr( $hash, 0, $i ) . '/'; 680 } 681 682 return $path; 683 } 684 } 685 686 /** 687 * Get the number of hash directory levels 688 * 689 * @return int 690 */ 691 public function getHashLevels() { 692 return $this->hashLevels; 693 } 694 695 /** 696 * Get the name of this repository, as specified by $info['name]' to the constructor 697 * 698 * @return string 699 */ 700 public function getName() { 701 return $this->name; 702 } 703 704 /** 705 * Make an url to this repo 706 * 707 * @param string $query Query string to append 708 * @param string $entry Entry point; defaults to index 709 * @return string|bool False on failure 710 */ 711 public function makeUrl( $query = '', $entry = 'index' ) { 712 if ( isset( $this->scriptDirUrl ) ) { 713 $ext = isset( $this->scriptExtension ) ? $this->scriptExtension : '.php'; 714 715 return wfAppendQuery( "{$this->scriptDirUrl}/{$entry}{$ext}", $query ); 716 } 717 718 return false; 719 } 720 721 /** 722 * Get the URL of an image description page. May return false if it is 723 * unknown or not applicable. In general this should only be called by the 724 * File class, since it may return invalid results for certain kinds of 725 * repositories. Use File::getDescriptionUrl() in user code. 726 * 727 * In particular, it uses the article paths as specified to the repository 728 * constructor, whereas local repositories use the local Title functions. 729 * 730 * @param string $name 731 * @return string 732 */ 733 public function getDescriptionUrl( $name ) { 734 $encName = wfUrlencode( $name ); 735 if ( !is_null( $this->descBaseUrl ) ) { 736 # "http://example.com/wiki/File:" 737 return $this->descBaseUrl . $encName; 738 } 739 if ( !is_null( $this->articleUrl ) ) { 740 # "http://example.com/wiki/$1" 741 # 742 # We use "Image:" as the canonical namespace for 743 # compatibility across all MediaWiki versions. 744 return str_replace( '$1', 745 "Image:$encName", $this->articleUrl ); 746 } 747 if ( !is_null( $this->scriptDirUrl ) ) { 748 # "http://example.com/w" 749 # 750 # We use "Image:" as the canonical namespace for 751 # compatibility across all MediaWiki versions, 752 # and just sort of hope index.php is right. ;) 753 return $this->makeUrl( "title=Image:$encName" ); 754 } 755 756 return false; 757 } 758 759 /** 760 * Get the URL of the content-only fragment of the description page. For 761 * MediaWiki this means action=render. This should only be called by the 762 * repository's file class, since it may return invalid results. User code 763 * should use File::getDescriptionText(). 764 * 765 * @param string $name Name of image to fetch 766 * @param string $lang Language to fetch it in, if any. 767 * @return string 768 */ 769 public function getDescriptionRenderUrl( $name, $lang = null ) { 770 $query = 'action=render'; 771 if ( !is_null( $lang ) ) { 772 $query .= '&uselang=' . $lang; 773 } 774 if ( isset( $this->scriptDirUrl ) ) { 775 return $this->makeUrl( 776 'title=' . 777 wfUrlencode( 'Image:' . $name ) . 778 "&$query" ); 779 } else { 780 $descUrl = $this->getDescriptionUrl( $name ); 781 if ( $descUrl ) { 782 return wfAppendQuery( $descUrl, $query ); 783 } else { 784 return false; 785 } 786 } 787 } 788 789 /** 790 * Get the URL of the stylesheet to apply to description pages 791 * 792 * @return string|bool False on failure 793 */ 794 public function getDescriptionStylesheetUrl() { 795 if ( isset( $this->scriptDirUrl ) ) { 796 return $this->makeUrl( 'title=MediaWiki:Filepage.css&' . 797 wfArrayToCgi( Skin::getDynamicStylesheetQuery() ) ); 798 } 799 800 return false; 801 } 802 803 /** 804 * Store a file to a given destination. 805 * 806 * @param string $srcPath Source file system path, storage path, or virtual URL 807 * @param string $dstZone Destination zone 808 * @param string $dstRel Destination relative path 809 * @param int $flags Bitwise combination of the following flags: 810 * self::DELETE_SOURCE Delete the source file after upload 811 * self::OVERWRITE Overwrite an existing destination file instead of failing 812 * self::OVERWRITE_SAME Overwrite the file if the destination exists and has the 813 * same contents as the source 814 * self::SKIP_LOCKING Skip any file locking when doing the store 815 * @return FileRepoStatus 816 */ 817 public function store( $srcPath, $dstZone, $dstRel, $flags = 0 ) { 818 $this->assertWritableRepo(); // fail out if read-only 819 820 $status = $this->storeBatch( array( array( $srcPath, $dstZone, $dstRel ) ), $flags ); 821 if ( $status->successCount == 0 ) { 822 $status->ok = false; 823 } 824 825 return $status; 826 } 827 828 /** 829 * Store a batch of files 830 * 831 * @param array $triplets (src, dest zone, dest rel) triplets as per store() 832 * @param int $flags Bitwise combination of the following flags: 833 * self::DELETE_SOURCE Delete the source file after upload 834 * self::OVERWRITE Overwrite an existing destination file instead of failing 835 * self::OVERWRITE_SAME Overwrite the file if the destination exists and has the 836 * same contents as the source 837 * self::SKIP_LOCKING Skip any file locking when doing the store 838 * @throws MWException 839 * @return FileRepoStatus 840 */ 841 public function storeBatch( array $triplets, $flags = 0 ) { 842 $this->assertWritableRepo(); // fail out if read-only 843 844 $status = $this->newGood(); 845 $backend = $this->backend; // convenience 846 847 $operations = array(); 848 $sourceFSFilesToDelete = array(); // cleanup for disk source files 849 // Validate each triplet and get the store operation... 850 foreach ( $triplets as $triplet ) { 851 list( $srcPath, $dstZone, $dstRel ) = $triplet; 852 wfDebug( __METHOD__ 853 . "( \$src='$srcPath', \$dstZone='$dstZone', \$dstRel='$dstRel' )\n" 854 ); 855 856 // Resolve destination path 857 $root = $this->getZonePath( $dstZone ); 858 if ( !$root ) { 859 throw new MWException( "Invalid zone: $dstZone" ); 860 } 861 if ( !$this->validateFilename( $dstRel ) ) { 862 throw new MWException( 'Validation error in $dstRel' ); 863 } 864 $dstPath = "$root/$dstRel"; 865 $dstDir = dirname( $dstPath ); 866 // Create destination directories for this triplet 867 if ( !$this->initDirectory( $dstDir )->isOK() ) { 868 return $this->newFatal( 'directorycreateerror', $dstDir ); 869 } 870 871 // Resolve source to a storage path if virtual 872 $srcPath = $this->resolveToStoragePath( $srcPath ); 873 874 // Get the appropriate file operation 875 if ( FileBackend::isStoragePath( $srcPath ) ) { 876 $opName = ( $flags & self::DELETE_SOURCE ) ? 'move' : 'copy'; 877 } else { 878 $opName = 'store'; 879 if ( $flags & self::DELETE_SOURCE ) { 880 $sourceFSFilesToDelete[] = $srcPath; 881 } 882 } 883 $operations[] = array( 884 'op' => $opName, 885 'src' => $srcPath, 886 'dst' => $dstPath, 887 'overwrite' => $flags & self::OVERWRITE, 888 'overwriteSame' => $flags & self::OVERWRITE_SAME, 889 ); 890 } 891 892 // Execute the store operation for each triplet 893 $opts = array( 'force' => true ); 894 if ( $flags & self::SKIP_LOCKING ) { 895 $opts['nonLocking'] = true; 896 } 897 $status->merge( $backend->doOperations( $operations, $opts ) ); 898 // Cleanup for disk source files... 899 foreach ( $sourceFSFilesToDelete as $file ) { 900 wfSuppressWarnings(); 901 unlink( $file ); // FS cleanup 902 wfRestoreWarnings(); 903 } 904 905 return $status; 906 } 907 908 /** 909 * Deletes a batch of files. 910 * Each file can be a (zone, rel) pair, virtual url, storage path. 911 * It will try to delete each file, but ignores any errors that may occur. 912 * 913 * @param array $files List of files to delete 914 * @param int $flags Bitwise combination of the following flags: 915 * self::SKIP_LOCKING Skip any file locking when doing the deletions 916 * @return FileRepoStatus 917 */ 918 public function cleanupBatch( array $files, $flags = 0 ) { 919 $this->assertWritableRepo(); // fail out if read-only 920 921 $status = $this->newGood(); 922 923 $operations = array(); 924 foreach ( $files as $path ) { 925 if ( is_array( $path ) ) { 926 // This is a pair, extract it 927 list( $zone, $rel ) = $path; 928 $path = $this->getZonePath( $zone ) . "/$rel"; 929 } else { 930 // Resolve source to a storage path if virtual 931 $path = $this->resolveToStoragePath( $path ); 932 } 933 $operations[] = array( 'op' => 'delete', 'src' => $path ); 934 } 935 // Actually delete files from storage... 936 $opts = array( 'force' => true ); 937 if ( $flags & self::SKIP_LOCKING ) { 938 $opts['nonLocking'] = true; 939 } 940 $status->merge( $this->backend->doOperations( $operations, $opts ) ); 941 942 return $status; 943 } 944 945 /** 946 * Import a file from the local file system into the repo. 947 * This does no locking nor journaling and overrides existing files. 948 * This function can be used to write to otherwise read-only foreign repos. 949 * This is intended for copying generated thumbnails into the repo. 950 * 951 * @param string $src Source file system path, storage path, or virtual URL 952 * @param string $dst Virtual URL or storage path 953 * @param array|string|null $options An array consisting of a key named headers 954 * listing extra headers. If a string, taken as content-disposition header. 955 * (Support for array of options new in 1.23) 956 * @return FileRepoStatus 957 */ 958 final public function quickImport( $src, $dst, $options = null ) { 959 return $this->quickImportBatch( array( array( $src, $dst, $options ) ) ); 960 } 961 962 /** 963 * Purge a file from the repo. This does no locking nor journaling. 964 * This function can be used to write to otherwise read-only foreign repos. 965 * This is intended for purging thumbnails. 966 * 967 * @param string $path Virtual URL or storage path 968 * @return FileRepoStatus 969 */ 970 final public function quickPurge( $path ) { 971 return $this->quickPurgeBatch( array( $path ) ); 972 } 973 974 /** 975 * Deletes a directory if empty. 976 * This function can be used to write to otherwise read-only foreign repos. 977 * 978 * @param string $dir Virtual URL (or storage path) of directory to clean 979 * @return Status 980 */ 981 public function quickCleanDir( $dir ) { 982 $status = $this->newGood(); 983 $status->merge( $this->backend->clean( 984 array( 'dir' => $this->resolveToStoragePath( $dir ) ) ) ); 985 986 return $status; 987 } 988 989 /** 990 * Import a batch of files from the local file system into the repo. 991 * This does no locking nor journaling and overrides existing files. 992 * This function can be used to write to otherwise read-only foreign repos. 993 * This is intended for copying generated thumbnails into the repo. 994 * 995 * All path parameters may be a file system path, storage path, or virtual URL. 996 * When "headers" are given they are used as HTTP headers if supported. 997 * 998 * @param array $triples List of (source path, destination path, disposition) 999 * @return FileRepoStatus 1000 */ 1001 public function quickImportBatch( array $triples ) { 1002 $status = $this->newGood(); 1003 $operations = array(); 1004 foreach ( $triples as $triple ) { 1005 list( $src, $dst ) = $triple; 1006 $src = $this->resolveToStoragePath( $src ); 1007 $dst = $this->resolveToStoragePath( $dst ); 1008 1009 if ( !isset( $triple[2] ) ) { 1010 $headers = array(); 1011 } elseif ( is_string( $triple[2] ) ) { 1012 // back-compat 1013 $headers = array( 'Content-Disposition' => $triple[2] ); 1014 } elseif ( is_array( $triple[2] ) && isset( $triple[2]['headers'] ) ) { 1015 $headers = $triple[2]['headers']; 1016 } 1017 // @fixme: $headers might not be defined 1018 $operations[] = array( 1019 'op' => FileBackend::isStoragePath( $src ) ? 'copy' : 'store', 1020 'src' => $src, 1021 'dst' => $dst, 1022 'headers' => $headers 1023 ); 1024 $status->merge( $this->initDirectory( dirname( $dst ) ) ); 1025 } 1026 $status->merge( $this->backend->doQuickOperations( $operations ) ); 1027 1028 return $status; 1029 } 1030 1031 /** 1032 * Purge a batch of files from the repo. 1033 * This function can be used to write to otherwise read-only foreign repos. 1034 * This does no locking nor journaling and is intended for purging thumbnails. 1035 * 1036 * @param array $paths List of virtual URLs or storage paths 1037 * @return FileRepoStatus 1038 */ 1039 public function quickPurgeBatch( array $paths ) { 1040 $status = $this->newGood(); 1041 $operations = array(); 1042 foreach ( $paths as $path ) { 1043 $operations[] = array( 1044 'op' => 'delete', 1045 'src' => $this->resolveToStoragePath( $path ), 1046 'ignoreMissingSource' => true 1047 ); 1048 } 1049 $status->merge( $this->backend->doQuickOperations( $operations ) ); 1050 1051 return $status; 1052 } 1053 1054 /** 1055 * Pick a random name in the temp zone and store a file to it. 1056 * Returns a FileRepoStatus object with the file Virtual URL in the value, 1057 * file can later be disposed using FileRepo::freeTemp(). 1058 * 1059 * @param string $originalName The base name of the file as specified 1060 * by the user. The file extension will be maintained. 1061 * @param string $srcPath The current location of the file. 1062 * @return FileRepoStatus Object with the URL in the value. 1063 */ 1064 public function storeTemp( $originalName, $srcPath ) { 1065 $this->assertWritableRepo(); // fail out if read-only 1066 1067 $date = MWTimestamp::getInstance()->format( 'YmdHis' ); 1068 $hashPath = $this->getHashPath( $originalName ); 1069 $dstUrlRel = $hashPath . $date . '!' . rawurlencode( $originalName ); 1070 $virtualUrl = $this->getVirtualUrl( 'temp' ) . '/' . $dstUrlRel; 1071 1072 $result = $this->quickImport( $srcPath, $virtualUrl ); 1073 $result->value = $virtualUrl; 1074 1075 return $result; 1076 } 1077 1078 /** 1079 * Remove a temporary file or mark it for garbage collection 1080 * 1081 * @param string $virtualUrl The virtual URL returned by FileRepo::storeTemp() 1082 * @return bool True on success, false on failure 1083 */ 1084 public function freeTemp( $virtualUrl ) { 1085 $this->assertWritableRepo(); // fail out if read-only 1086 1087 $temp = $this->getVirtualUrl( 'temp' ); 1088 if ( substr( $virtualUrl, 0, strlen( $temp ) ) != $temp ) { 1089 wfDebug( __METHOD__ . ": Invalid temp virtual URL\n" ); 1090 1091 return false; 1092 } 1093 1094 return $this->quickPurge( $virtualUrl )->isOK(); 1095 } 1096 1097 /** 1098 * Concatenate a list of temporary files into a target file location. 1099 * 1100 * @param array $srcPaths Ordered list of source virtual URLs/storage paths 1101 * @param string $dstPath Target file system path 1102 * @param int $flags Bitwise combination of the following flags: 1103 * self::DELETE_SOURCE Delete the source files 1104 * @return FileRepoStatus 1105 */ 1106 public function concatenate( array $srcPaths, $dstPath, $flags = 0 ) { 1107 $this->assertWritableRepo(); // fail out if read-only 1108 1109 $status = $this->newGood(); 1110 1111 $sources = array(); 1112 foreach ( $srcPaths as $srcPath ) { 1113 // Resolve source to a storage path if virtual 1114 $source = $this->resolveToStoragePath( $srcPath ); 1115 $sources[] = $source; // chunk to merge 1116 } 1117 1118 // Concatenate the chunks into one FS file 1119 $params = array( 'srcs' => $sources, 'dst' => $dstPath ); 1120 $status->merge( $this->backend->concatenate( $params ) ); 1121 if ( !$status->isOK() ) { 1122 return $status; 1123 } 1124 1125 // Delete the sources if required 1126 if ( $flags & self::DELETE_SOURCE ) { 1127 $status->merge( $this->quickPurgeBatch( $srcPaths ) ); 1128 } 1129 1130 // Make sure status is OK, despite any quickPurgeBatch() fatals 1131 $status->setResult( true ); 1132 1133 return $status; 1134 } 1135 1136 /** 1137 * Copy or move a file either from a storage path, virtual URL, 1138 * or file system path, into this repository at the specified destination location. 1139 * 1140 * Returns a FileRepoStatus object. On success, the value contains "new" or 1141 * "archived", to indicate whether the file was new with that name. 1142 * 1143 * Options to $options include: 1144 * - headers : name/value map of HTTP headers to use in response to GET/HEAD requests 1145 * 1146 * @param string $srcPath The source file system path, storage path, or URL 1147 * @param string $dstRel The destination relative path 1148 * @param string $archiveRel The relative path where the existing file is to 1149 * be archived, if there is one. Relative to the public zone root. 1150 * @param int $flags Bitfield, may be FileRepo::DELETE_SOURCE to indicate 1151 * that the source file should be deleted if possible 1152 * @param array $options Optional additional parameters 1153 * @return FileRepoStatus 1154 */ 1155 public function publish( 1156 $srcPath, $dstRel, $archiveRel, $flags = 0, array $options = array() 1157 ) { 1158 $this->assertWritableRepo(); // fail out if read-only 1159 1160 $status = $this->publishBatch( 1161 array( array( $srcPath, $dstRel, $archiveRel, $options ) ), $flags ); 1162 if ( $status->successCount == 0 ) { 1163 $status->ok = false; 1164 } 1165 if ( isset( $status->value[0] ) ) { 1166 $status->value = $status->value[0]; 1167 } else { 1168 $status->value = false; 1169 } 1170 1171 return $status; 1172 } 1173 1174 /** 1175 * Publish a batch of files 1176 * 1177 * @param array $ntuples (source, dest, archive) triplets or 1178 * (source, dest, archive, options) 4-tuples as per publish(). 1179 * @param int $flags Bitfield, may be FileRepo::DELETE_SOURCE to indicate 1180 * that the source files should be deleted if possible 1181 * @throws MWException 1182 * @return FileRepoStatus 1183 */ 1184 public function publishBatch( array $ntuples, $flags = 0 ) { 1185 $this->assertWritableRepo(); // fail out if read-only 1186 1187 $backend = $this->backend; // convenience 1188 // Try creating directories 1189 $status = $this->initZones( 'public' ); 1190 if ( !$status->isOK() ) { 1191 return $status; 1192 } 1193 1194 $status = $this->newGood( array() ); 1195 1196 $operations = array(); 1197 $sourceFSFilesToDelete = array(); // cleanup for disk source files 1198 // Validate each triplet and get the store operation... 1199 foreach ( $ntuples as $ntuple ) { 1200 list( $srcPath, $dstRel, $archiveRel ) = $ntuple; 1201 $options = isset( $ntuple[3] ) ? $ntuple[3] : array(); 1202 // Resolve source to a storage path if virtual 1203 $srcPath = $this->resolveToStoragePath( $srcPath ); 1204 if ( !$this->validateFilename( $dstRel ) ) { 1205 throw new MWException( 'Validation error in $dstRel' ); 1206 } 1207 if ( !$this->validateFilename( $archiveRel ) ) { 1208 throw new MWException( 'Validation error in $archiveRel' ); 1209 } 1210 1211 $publicRoot = $this->getZonePath( 'public' ); 1212 $dstPath = "$publicRoot/$dstRel"; 1213 $archivePath = "$publicRoot/$archiveRel"; 1214 1215 $dstDir = dirname( $dstPath ); 1216 $archiveDir = dirname( $archivePath ); 1217 // Abort immediately on directory creation errors since they're likely to be repetitive 1218 if ( !$this->initDirectory( $dstDir )->isOK() ) { 1219 return $this->newFatal( 'directorycreateerror', $dstDir ); 1220 } 1221 if ( !$this->initDirectory( $archiveDir )->isOK() ) { 1222 return $this->newFatal( 'directorycreateerror', $archiveDir ); 1223 } 1224 1225 // Set any desired headers to be use in GET/HEAD responses 1226 $headers = isset( $options['headers'] ) ? $options['headers'] : array(); 1227 1228 // Archive destination file if it exists. 1229 // This will check if the archive file also exists and fail if does. 1230 // This is a sanity check to avoid data loss. On Windows and Linux, 1231 // copy() will overwrite, so the existence check is vulnerable to 1232 // race conditions unless a functioning LockManager is used. 1233 // LocalFile also uses SELECT FOR UPDATE for synchronization. 1234 $operations[] = array( 1235 'op' => 'copy', 1236 'src' => $dstPath, 1237 'dst' => $archivePath, 1238 'ignoreMissingSource' => true 1239 ); 1240 1241 // Copy (or move) the source file to the destination 1242 if ( FileBackend::isStoragePath( $srcPath ) ) { 1243 if ( $flags & self::DELETE_SOURCE ) { 1244 $operations[] = array( 1245 'op' => 'move', 1246 'src' => $srcPath, 1247 'dst' => $dstPath, 1248 'overwrite' => true, // replace current 1249 'headers' => $headers 1250 ); 1251 } else { 1252 $operations[] = array( 1253 'op' => 'copy', 1254 'src' => $srcPath, 1255 'dst' => $dstPath, 1256 'overwrite' => true, // replace current 1257 'headers' => $headers 1258 ); 1259 } 1260 } else { // FS source path 1261 $operations[] = array( 1262 'op' => 'store', 1263 'src' => $srcPath, 1264 'dst' => $dstPath, 1265 'overwrite' => true, // replace current 1266 'headers' => $headers 1267 ); 1268 if ( $flags & self::DELETE_SOURCE ) { 1269 $sourceFSFilesToDelete[] = $srcPath; 1270 } 1271 } 1272 } 1273 1274 // Execute the operations for each triplet 1275 $status->merge( $backend->doOperations( $operations ) ); 1276 // Find out which files were archived... 1277 foreach ( $ntuples as $i => $ntuple ) { 1278 list( , , $archiveRel ) = $ntuple; 1279 $archivePath = $this->getZonePath( 'public' ) . "/$archiveRel"; 1280 if ( $this->fileExists( $archivePath ) ) { 1281 $status->value[$i] = 'archived'; 1282 } else { 1283 $status->value[$i] = 'new'; 1284 } 1285 } 1286 // Cleanup for disk source files... 1287 foreach ( $sourceFSFilesToDelete as $file ) { 1288 wfSuppressWarnings(); 1289 unlink( $file ); // FS cleanup 1290 wfRestoreWarnings(); 1291 } 1292 1293 return $status; 1294 } 1295 1296 /** 1297 * Creates a directory with the appropriate zone permissions. 1298 * Callers are responsible for doing read-only and "writable repo" checks. 1299 * 1300 * @param string $dir Virtual URL (or storage path) of directory to clean 1301 * @return Status 1302 */ 1303 protected function initDirectory( $dir ) { 1304 $path = $this->resolveToStoragePath( $dir ); 1305 list( , $container, ) = FileBackend::splitStoragePath( $path ); 1306 1307 $params = array( 'dir' => $path ); 1308 if ( $this->isPrivate || $container === $this->zones['deleted']['container'] ) { 1309 # Take all available measures to prevent web accessibility of new deleted 1310 # directories, in case the user has not configured offline storage 1311 $params = array( 'noAccess' => true, 'noListing' => true ) + $params; 1312 } 1313 1314 return $this->backend->prepare( $params ); 1315 } 1316 1317 /** 1318 * Deletes a directory if empty. 1319 * 1320 * @param string $dir Virtual URL (or storage path) of directory to clean 1321 * @return Status 1322 */ 1323 public function cleanDir( $dir ) { 1324 $this->assertWritableRepo(); // fail out if read-only 1325 1326 $status = $this->newGood(); 1327 $status->merge( $this->backend->clean( 1328 array( 'dir' => $this->resolveToStoragePath( $dir ) ) ) ); 1329 1330 return $status; 1331 } 1332 1333 /** 1334 * Checks existence of a a file 1335 * 1336 * @param string $file Virtual URL (or storage path) of file to check 1337 * @return bool 1338 */ 1339 public function fileExists( $file ) { 1340 $result = $this->fileExistsBatch( array( $file ) ); 1341 1342 return $result[0]; 1343 } 1344 1345 /** 1346 * Checks existence of an array of files. 1347 * 1348 * @param array $files Virtual URLs (or storage paths) of files to check 1349 * @return array Map of files and existence flags, or false 1350 */ 1351 public function fileExistsBatch( array $files ) { 1352 $paths = array_map( array( $this, 'resolveToStoragePath' ), $files ); 1353 $this->backend->preloadFileStat( array( 'srcs' => $paths ) ); 1354 1355 $result = array(); 1356 foreach ( $files as $key => $file ) { 1357 $path = $this->resolveToStoragePath( $file ); 1358 $result[$key] = $this->backend->fileExists( array( 'src' => $path ) ); 1359 } 1360 1361 return $result; 1362 } 1363 1364 /** 1365 * Move a file to the deletion archive. 1366 * If no valid deletion archive exists, this may either delete the file 1367 * or throw an exception, depending on the preference of the repository 1368 * 1369 * @param mixed $srcRel Relative path for the file to be deleted 1370 * @param mixed $archiveRel Relative path for the archive location. 1371 * Relative to a private archive directory. 1372 * @return FileRepoStatus 1373 */ 1374 public function delete( $srcRel, $archiveRel ) { 1375 $this->assertWritableRepo(); // fail out if read-only 1376 1377 return $this->deleteBatch( array( array( $srcRel, $archiveRel ) ) ); 1378 } 1379 1380 /** 1381 * Move a group of files to the deletion archive. 1382 * 1383 * If no valid deletion archive is configured, this may either delete the 1384 * file or throw an exception, depending on the preference of the repository. 1385 * 1386 * The overwrite policy is determined by the repository -- currently LocalRepo 1387 * assumes a naming scheme in the deleted zone based on content hash, as 1388 * opposed to the public zone which is assumed to be unique. 1389 * 1390 * @param array $sourceDestPairs Array of source/destination pairs. Each element 1391 * is a two-element array containing the source file path relative to the 1392 * public root in the first element, and the archive file path relative 1393 * to the deleted zone root in the second element. 1394 * @throws MWException 1395 * @return FileRepoStatus 1396 */ 1397 public function deleteBatch( array $sourceDestPairs ) { 1398 $this->assertWritableRepo(); // fail out if read-only 1399 1400 // Try creating directories 1401 $status = $this->initZones( array( 'public', 'deleted' ) ); 1402 if ( !$status->isOK() ) { 1403 return $status; 1404 } 1405 1406 $status = $this->newGood(); 1407 1408 $backend = $this->backend; // convenience 1409 $operations = array(); 1410 // Validate filenames and create archive directories 1411 foreach ( $sourceDestPairs as $pair ) { 1412 list( $srcRel, $archiveRel ) = $pair; 1413 if ( !$this->validateFilename( $srcRel ) ) { 1414 throw new MWException( __METHOD__ . ':Validation error in $srcRel' ); 1415 } elseif ( !$this->validateFilename( $archiveRel ) ) { 1416 throw new MWException( __METHOD__ . ':Validation error in $archiveRel' ); 1417 } 1418 1419 $publicRoot = $this->getZonePath( 'public' ); 1420 $srcPath = "{$publicRoot}/$srcRel"; 1421 1422 $deletedRoot = $this->getZonePath( 'deleted' ); 1423 $archivePath = "{$deletedRoot}/{$archiveRel}"; 1424 $archiveDir = dirname( $archivePath ); // does not touch FS 1425 1426 // Create destination directories 1427 if ( !$this->initDirectory( $archiveDir )->isOK() ) { 1428 return $this->newFatal( 'directorycreateerror', $archiveDir ); 1429 } 1430 1431 $operations[] = array( 1432 'op' => 'move', 1433 'src' => $srcPath, 1434 'dst' => $archivePath, 1435 // We may have 2+ identical files being deleted, 1436 // all of which will map to the same destination file 1437 'overwriteSame' => true // also see bug 31792 1438 ); 1439 } 1440 1441 // Move the files by execute the operations for each pair. 1442 // We're now committed to returning an OK result, which will 1443 // lead to the files being moved in the DB also. 1444 $opts = array( 'force' => true ); 1445 $status->merge( $backend->doOperations( $operations, $opts ) ); 1446 1447 return $status; 1448 } 1449 1450 /** 1451 * Delete files in the deleted directory if they are not referenced in the filearchive table 1452 * 1453 * STUB 1454 * @param array $storageKeys 1455 */ 1456 public function cleanupDeletedBatch( array $storageKeys ) { 1457 $this->assertWritableRepo(); 1458 } 1459 1460 /** 1461 * Get a relative path for a deletion archive key, 1462 * e.g. s/z/a/ for sza251lrxrc1jad41h5mgilp8nysje52.jpg 1463 * 1464 * @param string $key 1465 * @throws MWException 1466 * @return string 1467 */ 1468 public function getDeletedHashPath( $key ) { 1469 if ( strlen( $key ) < 31 ) { 1470 throw new MWException( "Invalid storage key '$key'." ); 1471 } 1472 $path = ''; 1473 for ( $i = 0; $i < $this->deletedHashLevels; $i++ ) { 1474 $path .= $key[$i] . '/'; 1475 } 1476 1477 return $path; 1478 } 1479 1480 /** 1481 * If a path is a virtual URL, resolve it to a storage path. 1482 * Otherwise, just return the path as it is. 1483 * 1484 * @param string $path 1485 * @return string 1486 * @throws MWException 1487 */ 1488 protected function resolveToStoragePath( $path ) { 1489 if ( $this->isVirtualUrl( $path ) ) { 1490 return $this->resolveVirtualUrl( $path ); 1491 } 1492 1493 return $path; 1494 } 1495 1496 /** 1497 * Get a local FS copy of a file with a given virtual URL/storage path. 1498 * Temporary files may be purged when the file object falls out of scope. 1499 * 1500 * @param string $virtualUrl 1501 * @return TempFSFile|null Returns null on failure 1502 */ 1503 public function getLocalCopy( $virtualUrl ) { 1504 $path = $this->resolveToStoragePath( $virtualUrl ); 1505 1506 return $this->backend->getLocalCopy( array( 'src' => $path ) ); 1507 } 1508 1509 /** 1510 * Get a local FS file with a given virtual URL/storage path. 1511 * The file is either an original or a copy. It should not be changed. 1512 * Temporary files may be purged when the file object falls out of scope. 1513 * 1514 * @param string $virtualUrl 1515 * @return FSFile|null Returns null on failure. 1516 */ 1517 public function getLocalReference( $virtualUrl ) { 1518 $path = $this->resolveToStoragePath( $virtualUrl ); 1519 1520 return $this->backend->getLocalReference( array( 'src' => $path ) ); 1521 } 1522 1523 /** 1524 * Get properties of a file with a given virtual URL/storage path. 1525 * Properties should ultimately be obtained via FSFile::getProps(). 1526 * 1527 * @param string $virtualUrl 1528 * @return array 1529 */ 1530 public function getFileProps( $virtualUrl ) { 1531 $path = $this->resolveToStoragePath( $virtualUrl ); 1532 1533 return $this->backend->getFileProps( array( 'src' => $path ) ); 1534 } 1535 1536 /** 1537 * Get the timestamp of a file with a given virtual URL/storage path 1538 * 1539 * @param string $virtualUrl 1540 * @return string|bool False on failure 1541 */ 1542 public function getFileTimestamp( $virtualUrl ) { 1543 $path = $this->resolveToStoragePath( $virtualUrl ); 1544 1545 return $this->backend->getFileTimestamp( array( 'src' => $path ) ); 1546 } 1547 1548 /** 1549 * Get the size of a file with a given virtual URL/storage path 1550 * 1551 * @param string $virtualUrl 1552 * @return int|bool False on failure 1553 */ 1554 public function getFileSize( $virtualUrl ) { 1555 $path = $this->resolveToStoragePath( $virtualUrl ); 1556 1557 return $this->backend->getFileSize( array( 'src' => $path ) ); 1558 } 1559 1560 /** 1561 * Get the sha1 (base 36) of a file with a given virtual URL/storage path 1562 * 1563 * @param string $virtualUrl 1564 * @return string|bool 1565 */ 1566 public function getFileSha1( $virtualUrl ) { 1567 $path = $this->resolveToStoragePath( $virtualUrl ); 1568 1569 return $this->backend->getFileSha1Base36( array( 'src' => $path ) ); 1570 } 1571 1572 /** 1573 * Attempt to stream a file with the given virtual URL/storage path 1574 * 1575 * @param string $virtualUrl 1576 * @param array $headers Additional HTTP headers to send on success 1577 * @return bool Success 1578 */ 1579 public function streamFile( $virtualUrl, $headers = array() ) { 1580 $path = $this->resolveToStoragePath( $virtualUrl ); 1581 $params = array( 'src' => $path, 'headers' => $headers ); 1582 1583 return $this->backend->streamFile( $params )->isOK(); 1584 } 1585 1586 /** 1587 * Call a callback function for every public regular file in the repository. 1588 * This only acts on the current version of files, not any old versions. 1589 * May use either the database or the filesystem. 1590 * 1591 * @param callable $callback 1592 * @return void 1593 */ 1594 public function enumFiles( $callback ) { 1595 $this->enumFilesInStorage( $callback ); 1596 } 1597 1598 /** 1599 * Call a callback function for every public file in the repository. 1600 * May use either the database or the filesystem. 1601 * 1602 * @param callable $callback 1603 * @return void 1604 */ 1605 protected function enumFilesInStorage( $callback ) { 1606 $publicRoot = $this->getZonePath( 'public' ); 1607 $numDirs = 1 << ( $this->hashLevels * 4 ); 1608 // Use a priori assumptions about directory structure 1609 // to reduce the tree height of the scanning process. 1610 for ( $flatIndex = 0; $flatIndex < $numDirs; $flatIndex++ ) { 1611 $hexString = sprintf( "%0{$this->hashLevels}x", $flatIndex ); 1612 $path = $publicRoot; 1613 for ( $hexPos = 0; $hexPos < $this->hashLevels; $hexPos++ ) { 1614 $path .= '/' . substr( $hexString, 0, $hexPos + 1 ); 1615 } 1616 $iterator = $this->backend->getFileList( array( 'dir' => $path ) ); 1617 foreach ( $iterator as $name ) { 1618 // Each item returned is a public file 1619 call_user_func( $callback, "{$path}/{$name}" ); 1620 } 1621 } 1622 } 1623 1624 /** 1625 * Determine if a relative path is valid, i.e. not blank or involving directory traveral 1626 * 1627 * @param string $filename 1628 * @return bool 1629 */ 1630 public function validateFilename( $filename ) { 1631 if ( strval( $filename ) == '' ) { 1632 return false; 1633 } 1634 1635 return FileBackend::isPathTraversalFree( $filename ); 1636 } 1637 1638 /** 1639 * Get a callback function to use for cleaning error message parameters 1640 * 1641 * @return array 1642 */ 1643 function getErrorCleanupFunction() { 1644 switch ( $this->pathDisclosureProtection ) { 1645 case 'none': 1646 case 'simple': // b/c 1647 $callback = array( $this, 'passThrough' ); 1648 break; 1649 default: // 'paranoid' 1650 $callback = array( $this, 'paranoidClean' ); 1651 } 1652 return $callback; 1653 } 1654 1655 /** 1656 * Path disclosure protection function 1657 * 1658 * @param string $param 1659 * @return string 1660 */ 1661 function paranoidClean( $param ) { 1662 return '[hidden]'; 1663 } 1664 1665 /** 1666 * Path disclosure protection function 1667 * 1668 * @param string $param 1669 * @return string 1670 */ 1671 function passThrough( $param ) { 1672 return $param; 1673 } 1674 1675 /** 1676 * Create a new fatal error 1677 * 1678 * @param string $message 1679 * @return FileRepoStatus 1680 */ 1681 public function newFatal( $message /*, parameters...*/ ) { 1682 $params = func_get_args(); 1683 array_unshift( $params, $this ); 1684 1685 return call_user_func_array( array( 'FileRepoStatus', 'newFatal' ), $params ); 1686 } 1687 1688 /** 1689 * Create a new good result 1690 * 1691 * @param null|string $value 1692 * @return FileRepoStatus 1693 */ 1694 public function newGood( $value = null ) { 1695 return FileRepoStatus::newGood( $this, $value ); 1696 } 1697 1698 /** 1699 * Checks if there is a redirect named as $title. If there is, return the 1700 * title object. If not, return false. 1701 * STUB 1702 * 1703 * @param Title $title Title of image 1704 * @return bool 1705 */ 1706 public function checkRedirect( Title $title ) { 1707 return false; 1708 } 1709 1710 /** 1711 * Invalidates image redirect cache related to that image 1712 * Doesn't do anything for repositories that don't support image redirects. 1713 * 1714 * STUB 1715 * @param Title $title Title of image 1716 */ 1717 public function invalidateImageRedirect( Title $title ) { 1718 } 1719 1720 /** 1721 * Get the human-readable name of the repo 1722 * 1723 * @return string 1724 */ 1725 public function getDisplayName() { 1726 global $wgSitename; 1727 1728 if ( $this->isLocal() ) { 1729 return $wgSitename; 1730 } 1731 1732 // 'shared-repo-name-wikimediacommons' is used when $wgUseInstantCommons = true 1733 return wfMessageFallback( 'shared-repo-name-' . $this->name, 'shared-repo' )->text(); 1734 } 1735 1736 /** 1737 * Get the portion of the file that contains the origin file name. 1738 * If that name is too long, then the name "thumbnail.<ext>" will be given. 1739 * 1740 * @param string $name 1741 * @return string 1742 */ 1743 public function nameForThumb( $name ) { 1744 if ( strlen( $name ) > $this->abbrvThreshold ) { 1745 $ext = FileBackend::extensionFromPath( $name ); 1746 $name = ( $ext == '' ) ? 'thumbnail' : "thumbnail.$ext"; 1747 } 1748 1749 return $name; 1750 } 1751 1752 /** 1753 * Returns true if this the local file repository. 1754 * 1755 * @return bool 1756 */ 1757 public function isLocal() { 1758 return $this->getName() == 'local'; 1759 } 1760 1761 /** 1762 * Get a key on the primary cache for this repository. 1763 * Returns false if the repository's cache is not accessible at this site. 1764 * The parameters are the parts of the key, as for wfMemcKey(). 1765 * 1766 * STUB 1767 * @return bool 1768 */ 1769 public function getSharedCacheKey( /*...*/ ) { 1770 return false; 1771 } 1772 1773 /** 1774 * Get a key for this repo in the local cache domain. These cache keys are 1775 * not shared with remote instances of the repo. 1776 * The parameters are the parts of the key, as for wfMemcKey(). 1777 * 1778 * @return string 1779 */ 1780 public function getLocalCacheKey( /*...*/ ) { 1781 $args = func_get_args(); 1782 array_unshift( $args, 'filerepo', $this->getName() ); 1783 1784 return call_user_func_array( 'wfMemcKey', $args ); 1785 } 1786 1787 /** 1788 * Get an temporary FileRepo associated with this repo. 1789 * Files will be created in the temp zone of this repo and 1790 * thumbnails in a /temp subdirectory in thumb zone of this repo. 1791 * It will have the same backend as this repo. 1792 * 1793 * @return TempFileRepo 1794 */ 1795 public function getTempRepo() { 1796 return new TempFileRepo( array( 1797 'name' => "{$this->name}-temp", 1798 'backend' => $this->backend, 1799 'zones' => array( 1800 'public' => array( 1801 'container' => $this->zones['temp']['container'], 1802 'directory' => $this->zones['temp']['directory'] 1803 ), 1804 'thumb' => array( 1805 'container' => $this->zones['thumb']['container'], 1806 'directory' => $this->zones['thumb']['directory'] == '' 1807 ? 'temp' 1808 : $this->zones['thumb']['directory'] . '/temp' 1809 ), 1810 'transcoded' => array( 1811 'container' => $this->zones['transcoded']['container'], 1812 'directory' => $this->zones['transcoded']['directory'] == '' 1813 ? 'temp' 1814 : $this->zones['transcoded']['directory'] . '/temp' 1815 ) 1816 ), 1817 'url' => $this->getZoneUrl( 'temp' ), 1818 'thumbUrl' => $this->getZoneUrl( 'thumb' ) . '/temp', 1819 'transcodedUrl' => $this->getZoneUrl( 'transcoded' ) . '/temp', 1820 'hashLevels' => $this->hashLevels // performance 1821 ) ); 1822 } 1823 1824 /** 1825 * Get an UploadStash associated with this repo. 1826 * 1827 * @param User $user 1828 * @return UploadStash 1829 */ 1830 public function getUploadStash( User $user = null ) { 1831 return new UploadStash( $this, $user ); 1832 } 1833 1834 /** 1835 * Throw an exception if this repo is read-only by design. 1836 * This does not and should not check getReadOnlyReason(). 1837 * 1838 * @return void 1839 * @throws MWException 1840 */ 1841 protected function assertWritableRepo() { 1842 } 1843 1844 /** 1845 * Return information about the repository. 1846 * 1847 * @return array 1848 * @since 1.22 1849 */ 1850 public function getInfo() { 1851 $ret = array( 1852 'name' => $this->getName(), 1853 'displayname' => $this->getDisplayName(), 1854 'rootUrl' => $this->getZoneUrl( 'public' ), 1855 'local' => $this->isLocal(), 1856 ); 1857 1858 $optionalSettings = array( 1859 'url', 'thumbUrl', 'initialCapital', 'descBaseUrl', 'scriptDirUrl', 'articleUrl', 1860 'fetchDescription', 'descriptionCacheExpiry', 'scriptExtension', 'favicon' 1861 ); 1862 foreach ( $optionalSettings as $k ) { 1863 if ( isset( $this->$k ) ) { 1864 $ret[$k] = $this->$k; 1865 } 1866 } 1867 1868 return $ret; 1869 } 1870 } 1871 1872 /** 1873 * FileRepo for temporary files created via FileRepo::getTempRepo() 1874 */ 1875 class TempFileRepo extends FileRepo { 1876 public function getTempRepo() { 1877 throw new MWException( "Cannot get a temp repo from a temp repo." ); 1878 } 1879 }
title
Description
Body
title
Description
Body
title
Description
Body
title
Body
| Generated: Fri Nov 28 14:03:12 2014 | Cross-referenced by PHPXref 0.7.1 |