/**
  * Store a file or virtual URL source into a media file name.
  *
  * @param $originalName string The title of the image
  * @param $srcPath string The filepath or virtual URL
  * @param $flags integer Flags to pass into repo::store().
  * @return FileRepoStatus
  */
 private function storeit($originalName, $srcPath, $flags)
 {
     $hashPath = $this->repo->getHashPath($originalName);
     $dstRel = "{$hashPath}{$this->date}!{$originalName}";
     $dstUrlRel = $hashPath . $this->date . '!' . rawurlencode($originalName);
     $result = $this->repo->store($srcPath, 'temp', $dstRel, $flags);
     $result->value = $this->repo->getVirtualUrl('temp') . '/' . $dstUrlRel;
     $this->createdFiles[] = $result->value;
     return $result;
 }

 /**
  * Per docs in FileRepo, this needs to return false if we don't support versioned
  * files. Well, we don't.
  */
 function newFile($title, $time = false)
 {
     if ($time) {
         return false;
     }
     return parent::newFile($title, $time);
 }

 /**
  * Create an UnregisteredLocalFile based on a path or a (title,repo) pair.
  * A FileRepo object is not required here, unlike most other File classes.
  *
  * @throws MWException
  * @param Title|bool $title
  * @param FileRepo|bool $repo
  * @param string|bool $path
  * @param string|bool $mime
  */
 function __construct($title = false, $repo = false, $path = false, $mime = false)
 {
     if (!($title && $repo) && !$path) {
         throw new MWException(__METHOD__ . ': not enough parameters, must specify title and repo, or a full path');
     }
     if ($title instanceof Title) {
         $this->title = File::normalizeTitle($title, 'exception');
         $this->name = $repo->getNameFromTitle($title);
     } else {
         $this->name = basename($path);
         $this->title = File::normalizeTitle($this->name, 'exception');
     }
     $this->repo = $repo;
     if ($path) {
         $this->path = $path;
     } else {
         $this->assertRepoDefined();
         $this->path = $repo->getRootDirectory() . '/' . $repo->getHashPath($this->name) . $this->name;
     }
     if ($mime) {
         $this->mime = $mime;
     }
     $this->dims = array();
 }

 function getFileProps($fileName)
 {
     if (FileRepo::isVirtualUrl($fileName)) {
         list($repoName, , ) = $this->splitVirtualUrl($fileName);
         if ($repoName === '') {
             $repoName = 'local';
         }
         $repo = $this->getRepo($repoName);
         return $repo->getFileProps($fileName);
     } else {
         return File::getPropsFromPath($fileName);
     }
 }

 /**
  * Return information about the repository.
  *
  * @return array
  * @since 1.22
  */
 function getInfo()
 {
     return FileRepo::getInfo();
 }

 protected function doOperations(FileRepo $tempRepo, array $ops)
 {
     $status = $tempRepo->getBackend()->doQuickOperations($ops);
     if (!$status->isOK()) {
         $this->error(print_r($status->getErrorsArray(), true));
     }
 }

 /**
  * @param Masthead $masthead
  * @param int $width
  * @param $timestamp
  * @return \Wikia\Vignette\UrlGenerator
  */
 public static function getVignetteUrl(Masthead $masthead, $width, $timestamp)
 {
     $relativePath = $masthead->mUser->getGlobalAttribute(AVATAR_USER_OPTION_NAME);
     if ($relativePath) {
         if (strpos($relativePath, '/') !== false) {
             // custom avatar
             $url = self::vignetteCustomUrl($width, $relativePath, $timestamp);
         } else {
             // wikia-provided avatars
             $hash = FileRepo::getHashPathForLevel($relativePath, 2);
             $bucket = VignetteRequest::parseBucket($masthead->mDefaultPath);
             $relativePath = $hash . $relativePath;
             $url = self::buildVignetteUrl($width, $bucket, $relativePath, $timestamp, false);
         }
     } else {
         // default avatar
         $legacyDefaultUrl = $masthead->getDefaultAvatars('thumb/')[0];
         $bucket = VignetteRequest::parseBucket($legacyDefaultUrl);
         $relativePath = VignetteRequest::parseRelativePath($legacyDefaultUrl);
         $url = self::buildVignetteUrl($width, $bucket, $relativePath, $timestamp, false);
     }
     return $url;
 }

 /**
  * @param string $fileName
  * @return array
  */
 function getFileProps($fileName)
 {
     if (FileRepo::isVirtualUrl($fileName)) {
         list($repoName, , ) = $this->splitVirtualUrl($fileName);
         if ($repoName === '') {
             $repoName = 'local';
         }
         $repo = $this->getRepo($repoName);
         return $repo->getFileProps($fileName);
     } else {
         $mwProps = new MWFileProps(MimeMagic::singleton());
         return $mwProps->getPropsFromPath($fileName, true);
     }
 }

	function __construct( $info ) {
		// We don't call parent::_construct because it requires $this->directory,
		// which doesn't exist in Swift.
		FileRepo::__construct( $info );

		// Required settings
		$this->url = $info['url'];

		// Optional settings
		$this->hashLevels = isset( $info['hashLevels'] ) ? $info['hashLevels'] : 2;
		$this->deletedHashLevels = isset( $info['deletedHashLevels'] ) ?
			$info['deletedHashLevels'] : $this->hashLevels;

		// This relationship is also hard-coded in rewrite.py, another part of this
		// extension. If you want to change this here, you might have to change it
		// there, too.
		$this->thumbUrl = "{$this->url}/thumb";

		// we don't have directories
		$this->deletedDir = false;

		// Required settings
		$this->swiftuser = $info['user'];
		$this->swiftkey = $info['key'];
		$this->authurl = $info['authurl'];
		$this->container = $info['container'];
	}

 /**
  * A LocalFile wrapper around a file that has been temporarily stashed,
  * so we can do things like create thumbnails for it. Arguably
  * UnregisteredLocalFile should be handling its own file repo but that
  * class is a bit retarded currently.
  *
  * @param FileRepo $repo Repository where we should find the path
  * @param string $path Path to file
  * @param string $key Key to store the path and any stashed data under
  * @throws UploadStashBadPathException
  * @throws UploadStashFileNotFoundException
  */
 public function __construct($repo, $path, $key)
 {
     $this->fileKey = $key;
     // resolve mwrepo:// urls
     if ($repo->isVirtualUrl($path)) {
         $path = $repo->resolveVirtualUrl($path);
     } else {
         // check if path appears to be sane, no parent traversals,
         // and is in this repo's temp zone.
         $repoTempPath = $repo->getZonePath('temp');
         if (!$repo->validateFilename($path) || strpos($path, $repoTempPath) !== 0) {
             wfDebug("UploadStash: tried to construct an UploadStashFile " . "from a file that should already exist at '{$path}', but path is not valid\n");
             throw new UploadStashBadPathException('path is not valid');
         }
         // check if path exists! and is a plain file.
         if (!$repo->fileExists($path)) {
             wfDebug("UploadStash: tried to construct an UploadStashFile from " . "a file that should already exist at '{$path}', but path is not found\n");
             throw new UploadStashFileNotFoundException('cannot find path, or not a plain file');
         }
     }
     parent::__construct(false, $repo, $path, false);
     $this->name = basename($this->path);
 }

 /**
  * @param bool|FileRepo $repo
  */
 function __construct($repo = false)
 {
     if ($repo) {
         $this->cleanCallback = $repo->getErrorCleanupFunction();
     }
 }

 static function getHashPath($name)
 {
     return FileRepo::getHashPathForLevel($name, 2);
 }

 /**
  * @brief Gets an array of sample avatars
  *
  * @desc Method based on Masthead::getDefaultAvatars()
  *
  * @param string $thumb a thumb
  *
  * @return array multidimensional array with default avatars defined on messaging.wikia.com
  *
  * @author Andrzej 'nAndy' Łukaszewski
  */
 private function getDefaultAvatars($thumb = '')
 {
     wfProfileIn(__METHOD__);
     // parse message only once per request
     if (empty($thumb) && is_array($this->defaultAvatars) && count($this->defaultAvatars) > 0) {
         wfProfileOut(__METHOD__);
         return $this->defaultAvatars;
     }
     $this->defaultAvatars = array();
     $images = getMessageForContentAsArray('blog-avatar-defaults');
     if (is_array($images)) {
         foreach ($images as $image) {
             $hash = FileRepo::getHashPathForLevel($image, 2);
             $this->defaultAvatars[] = array('name' => $image, 'url' => $this->defaultAvatarPath . $thumb . $hash . $image);
         }
     }
     wfProfileOut(__METHOD__);
     return $this->defaultAvatars;
 }

/**
 * Diese Hook-Funktion aktualisiert die Index-Sektion, sollte es sich um einen FileUpload handeln
 * und ein neuer Inhalt fuer diese Sektion vorbereitet worden sein.
 * In jedem Fall wird die global abgelegte Index-Sektions-Inhalts-Variable wieder geleert.
 *
 * @param $oArticle OBJECT Der Artikel
 * @param $oUser OBJECT Der Benutzer
 * @param $sContent STRING Inhalt des Artikels
 * @param $sSummary STRING Zusammenfassung fuer das Update
 * @param $minor SIEHE WIKIDOKU
 * @param $watch SIEHE WIKIDOKU
 * @param $sectionanchor SIEHE WIKIDOKU
 * @param $flags SIEHE WIKIDOKU
 * @return BOOL TRUE
 */
function wfFiArticleSave(&$oArticle, &$oUser, &$sContent, &$sSummary, $minor, $watch, $sectionanchor, &$flags)
{
    global $wgFiPrefix, $wgFiPostfix, $wgUploadDirectory, $wgHashedUploadDirectory, $wgRequest, $wgFiCreateIndexThisTime;
    // Spezialseite und UploadFormular setzen $wgFiCreateIndexThisTime auf true zur Indexerstellung
    if ($wgFiCreateIndexThisTime === true || !is_null($wgRequest->getVal('wpProcessIndex')) && $wgRequest->getVal('wpProcessIndex') == "true") {
        // Datei holen und Index erstellen
        $sFilepath = $wgUploadDirectory . "/" . FileRepo::getHashPathForLevel($oArticle->mTitle->mDbkeyform, $wgHashedUploadDirectory ? 2 : 0) . $oArticle->mTitle->mDbkeyform;
        $sIndex = wfFiGetIndex($sFilepath);
        if (is_numeric($sIndex)) {
            // kein Index aus Datei erzeugt
            switch ($sIndex) {
                case WC_FI_ERR_MISSING_SYSTEMCOMMAND:
                    $sReason = wfMsg('fileindexer_index_creation_failed_comment_missing_systemcommand');
                    break;
                case WC_FI_ERR_UNKNOWN_FILETYPE:
                    $sReason = wfMsg('fileindexer_index_creation_failed_comment_unknown_filetype');
                    break;
                default:
                    $sReason = wfMsg('fileindexer_index_creation_failed_comment_unknown_reason');
            }
            $sSummary .= (substr($sSummary, strlen($sSummary) - 1, 1) == "\n" ? "" : "\n") . wfMsg('fileindexer_index_creation_failed_comment') . $sReason;
            return true;
        }
        // Index suchen und Text in Fragmente splitten
        $aFragments = wfFiGetIndexFragments($sContent);
        if ($aFragments === false) {
            // kein Index gefunden
            if (substr($sContent, strlen($sContent) - 1, 1) != "\n") {
                $sContent .= "\n";
            }
            $sContent .= $sIndex;
            $sSummary .= (substr($sSummary, strlen($sSummary) - 1, 1) == "\n" ? "" : "\n") . wfMsg('fileindexer_index_creation_complete_comment');
            return true;
        } else {
            // Index gefunden
            $sContent = $aFragments['pre'] . $sIndex . $aFragments['post'];
            $sSummary .= (substr($sSummary, strlen($sSummary) - 1, 1) == "\n" ? "" : "\n") . wfMsg('fileindexer_index_update_complete_comment');
            return true;
        }
    }
    return true;
}

 public function view()
 {
     global $wgShowEXIF;
     $out = $this->getContext()->getOutput();
     $request = $this->getContext()->getRequest();
     $diff = $request->getVal('diff');
     $diffOnly = $request->getBool('diffonly', $this->getContext()->getUser()->getOption('diffonly'));
     if ($this->getTitle()->getNamespace() != NS_FILE || $diff !== null && $diffOnly) {
         parent::view();
         return;
     }
     $this->loadFile();
     if ($this->getTitle()->getNamespace() == NS_FILE && $this->mPage->getFile()->getRedirected()) {
         if ($this->getTitle()->getDBkey() == $this->mPage->getFile()->getName() || $diff !== null) {
             // mTitle is the same as the redirect target so ask Article
             // to perform the redirect for us.
             $request->setVal('diffonly', 'true');
             parent::view();
             return;
         } else {
             // mTitle is not the same as the redirect target so it is
             // probably the redirect page itself. Fake the redirect symbol
             $out->setPageTitle($this->getTitle()->getPrefixedText());
             $out->addHTML($this->viewRedirect(Title::makeTitle(NS_FILE, $this->mPage->getFile()->getName()), true, true));
             $this->mPage->doViewUpdates($this->getContext()->getUser(), $this->getOldID());
             return;
         }
     }
     if ($wgShowEXIF && $this->displayImg->exists()) {
         // @todo FIXME: Bad interface, see note on MediaHandler::formatMetadata().
         $formattedMetadata = $this->displayImg->formatMetadata();
         $showmeta = $formattedMetadata !== false;
     } else {
         $showmeta = false;
     }
     if (!$diff && $this->displayImg->exists()) {
         $out->addHTML($this->showTOC($showmeta));
     }
     if (!$diff) {
         $this->openShowImage();
     }
     # No need to display noarticletext, we use our own message, output in openShowImage()
     if ($this->mPage->getID()) {
         # NS_FILE is in the user language, but this section (the actual wikitext)
         # should be in page content language
         $pageLang = $this->getTitle()->getPageViewLanguage();
         $out->addHTML(Xml::openElement('div', array('id' => 'mw-imagepage-content', 'lang' => $pageLang->getHtmlCode(), 'dir' => $pageLang->getDir(), 'class' => 'mw-content-' . $pageLang->getDir())));
         parent::view();
         $out->addHTML(Xml::closeElement('div'));
     } else {
         # Just need to set the right headers
         $out->setArticleFlag(true);
         $out->setPageTitle($this->getTitle()->getPrefixedText());
         $this->mPage->doViewUpdates($this->getContext()->getUser(), $this->getOldID());
     }
     # Show shared description, if needed
     if ($this->mExtraDescription) {
         $fol = wfMessage('shareddescriptionfollows');
         if (!$fol->isDisabled()) {
             $out->addWikiText($fol->plain());
         }
         $out->addHTML('<div id="shared-image-desc">' . $this->mExtraDescription . "</div>\n");
     }
     $this->closeShowImage();
     $this->imageHistory();
     // TODO: Cleanup the following
     $out->addHTML(Xml::element('h2', array('id' => 'filelinks'), wfMessage('imagelinks')->text()) . "\n");
     $this->imageDupes();
     # @todo FIXME: For some freaky reason, we can't redirect to foreign images.
     # Yet we return metadata about the target. Definitely an issue in the FileRepo
     $this->imageLinks();
     # Allow extensions to add something after the image links
     $html = '';
     wfRunHooks('ImagePageAfterImageLinks', array($this, &$html));
     if ($html) {
         $out->addHTML($html);
     }
     if ($showmeta) {
         $out->addHTML(Xml::element('h2', array('id' => 'metadata'), wfMessage('metadata')->text()) . "\n");
         $out->addWikiText($this->makeMetadataTable($formattedMetadata));
         $out->addModules(array('mediawiki.action.view.metadata'));
     }
     // Add remote Filepage.css
     if (!$this->repo->isLocal()) {
         $css = $this->repo->getDescriptionStylesheetUrl();
         if ($css) {
             $out->addStyle($css);
         }
     }
     // always show the local local Filepage.css, bug 29277
     $out->addModuleStyles('filepage');
 }

 public static function getVidDirPath($filename)
 {
     return FileRepo::getHashPathForLevel($filename, self::NUM_DIR_LEVELS);
 }

 /**
  * @see FileRepo::getZoneUrl()
  */
 function getZoneUrl($zone)
 {
     switch ($zone) {
         case 'public':
             return $this->url;
         case 'thumb':
             return $this->thumbUrl;
         default:
             return parent::getZoneUrl($zone);
     }
 }

 /**
  * getPurgeUrl -- the basic URL (without image server rewriting, cachebuster,
  * etc.) of the avatar.  This can be sent to squid to purge it.
  *
  * @access public
  *
  * @param $thumb String  -- if defined will be added as part of base path
  *      default empty string ""
  *
  * @return String
  */
 public function getPurgeUrl($thumb = "")
 {
     global $wgBlogAvatarPath;
     $url = $this->mUser->getOption(AVATAR_USER_OPTION_NAME);
     if ($url) {
         /**
          * if default avatar we glue with messaging.wikia.com
          * if uploaded avatar we glue with common avatar path
          */
         if (strpos($url, '/') !== false) {
             /**
              * uploaded file, we are adding common/avatars path
              */
             $url = $wgBlogAvatarPath . rtrim($thumb, '/') . $url;
         } else {
             /**
              * default avatar, path from messaging.wikia.com
              */
             $hash = FileRepo::getHashPathForLevel($url, 2);
             $url = $this->mDefaultPath . trim($thumb, '/') . '/' . $hash . $url;
         }
     } else {
         $defaults = $this->getDefaultAvatars(trim($thumb, "/") . "/");
         $url = array_shift($defaults);
     }
     return $url;
 }

 function __construct($info)
 {
     parent::__construct($info);
     $this->mApiBase = $info['apibase'];
     // http://commons.wikimedia.org/w/api.php
     if (!$this->scriptDirUrl) {
         // hack for description fetches
         $this->scriptDirUrl = dirname($this->mApiBase);
     }
 }

 /**
  * @param $info array
  * @throws MWException
  */
 function __construct(array $info)
 {
     if (!isset($info['backend'])) {
         // B/C settings...
         $directory = $info['directory'];
         $deletedDir = isset($info['deletedDir']) ? $info['deletedDir'] : false;
         $thumbDir = isset($info['thumbDir']) ? $info['thumbDir'] : "{$directory}/thumb";
         $fileMode = isset($info['fileMode']) ? $info['fileMode'] : 0644;
         $repoName = $info['name'];
         // Get the FS backend configuration
         $backend = new FSFileBackend(array('name' => $info['name'] . '-backend', 'lockManager' => 'fsLockManager', 'containerPaths' => array("{$repoName}-public" => "{$directory}", "{$repoName}-temp" => "{$directory}/temp", "{$repoName}-thumb" => $thumbDir, "{$repoName}-deleted" => $deletedDir), 'fileMode' => $fileMode));
         // Update repo config to use this backend
         $info['backend'] = $backend;
     }
     parent::__construct($info);
     if (!$this->backend instanceof FSFileBackend) {
         throw new MWException("FSRepo only supports FSFileBackend.");
     }
 }