includes/filebackend/MemoryFileBackend.php

   1 <?php
   2 /**
   3  * Simulation of a backend storage in memory.
   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  * @ingroup FileBackend
  22  * @author Aaron Schulz
  23  */
  24
  25 /**
  26  * Simulation of a backend storage in memory.
  27  *
  28  * All data in the backend is automatically deleted at the end of PHP execution.
  29  * Since the data stored here is volatile, this is only useful for staging or testing.
  30  *
  31  * @ingroup FileBackend
  32  * @since 1.23
  33  */
  34 class MemoryFileBackend extends FileBackendStore {
  35         /** @var array Map of (file path => (data,mtime) */
  36         protected $files = array();
  37
  38         public function isPathUsableInternal( $storagePath ) {
  39                 return true;
  40         }
  41
  42         protected function doCreateInternal( array $params ) {
  43                 $status = Status::newGood();
  44
  45                 $dst = $this->resolveHashKey( $params['dst'] );
  46                 if ( $dst === null ) {
  47                         $status->fatal( 'backend-fail-invalidpath', $params['dst'] );
  48
  49                         return $status;
  50                 }
  51
  52                 $this->files[$dst] = array(
  53                         'data' => $params['content'],
  54                         'mtime' => wfTimestamp( TS_MW, time() )
  55                 );
  56
  57                 return $status;
  58         }
  59
  60         protected function doStoreInternal( array $params ) {
  61                 $status = Status::newGood();
  62
  63                 $dst = $this->resolveHashKey( $params['dst'] );
  64                 if ( $dst === null ) {
  65                         $status->fatal( 'backend-fail-invalidpath', $params['dst'] );
  66
  67                         return $status;
  68                 }
  69
  70                 wfSuppressWarnings();
  71                 $data = file_get_contents( $params['src'] );
  72                 wfRestoreWarnings();
  73                 if ( $data === false ) { // source doesn't exist?
  74                         $status->fatal( 'backend-fail-store', $params['src'], $params['dst'] );
  75
  76                         return $status;
  77                 }
  78
  79                 $this->files[$dst] = array(
  80                         'data' => $data,
  81                         'mtime' => wfTimestamp( TS_MW, time() )
  82                 );
  83
  84                 return $status;
  85         }
  86
  87         protected function doCopyInternal( array $params ) {
  88                 $status = Status::newGood();
  89
  90                 $src = $this->resolveHashKey( $params['src'] );
  91                 if ( $src === null ) {
  92                         $status->fatal( 'backend-fail-invalidpath', $params['src'] );
  93
  94                         return $status;
  95                 }
  96
  97                 $dst = $this->resolveHashKey( $params['dst'] );
  98                 if ( $dst === null ) {
  99                         $status->fatal( 'backend-fail-invalidpath', $params['dst'] );
 100
 101                         return $status;
 102                 }
 103
 104                 if ( !isset( $this->files[$src] ) ) {
 105                         if ( empty( $params['ignoreMissingSource'] ) ) {
 106                                 $status->fatal( 'backend-fail-copy', $params['src'], $params['dst'] );
 107                         }
 108
 109                         return $status;
 110                 }
 111
 112                 $this->files[$dst] = array(
 113                         'data' => $this->files[$src]['data'],
 114                         'mtime' => wfTimestamp( TS_MW, time() )
 115                 );
 116
 117                 return $status;
 118         }
 119
 120         protected function doDeleteInternal( array $params ) {
 121                 $status = Status::newGood();
 122
 123                 $src = $this->resolveHashKey( $params['src'] );
 124                 if ( $src === null ) {
 125                         $status->fatal( 'backend-fail-invalidpath', $params['src'] );
 126
 127                         return $status;
 128                 }
 129
 130                 if ( !isset( $this->files[$src] ) ) {
 131                         if ( empty( $params['ignoreMissingSource'] ) ) {
 132                                 $status->fatal( 'backend-fail-delete', $params['src'] );
 133                         }
 134
 135                         return $status;
 136                 }
 137
 138                 unset( $this->files[$src] );
 139
 140                 return $status;
 141         }
 142
 143         protected function doGetFileStat( array $params ) {
 144                 $src = $this->resolveHashKey( $params['src'] );
 145                 if ( $src === null ) {
 146                         return null;
 147                 }
 148
 149                 if ( isset( $this->files[$src] ) ) {
 150                         return array(
 151                                 'mtime' => $this->files[$src]['mtime'],
 152                                 'size' => strlen( $this->files[$src]['data'] ),
 153                         );
 154                 }
 155
 156                 return false;
 157         }
 158
 159         protected function doGetLocalCopyMulti( array $params ) {
 160                 $tmpFiles = array(); // (path => TempFSFile)
 161                 foreach ( $params['srcs'] as $srcPath ) {
 162                         $src = $this->resolveHashKey( $srcPath );
 163                         if ( $src === null || !isset( $this->files[$src] ) ) {
 164                                 $fsFile = null;
 165                         } else {
 166                                 // Create a new temporary file with the same extension...
 167                                 $ext = FileBackend::extensionFromPath( $src );
 168                                 $fsFile = TempFSFile::factory( 'localcopy_', $ext );
 169                                 if ( $fsFile ) {
 170                                         $bytes = file_put_contents( $fsFile->getPath(), $this->files[$src]['data'] );
 171                                         if ( $bytes !== strlen( $this->files[$src]['data'] ) ) {
 172                                                 $fsFile = null;
 173                                         }
 174                                 }
 175                         }
 176                         $tmpFiles[$srcPath] = $fsFile;
 177                 }
 178
 179                 return $tmpFiles;
 180         }
 181
 182         protected function doStreamFile( array $params ) {
 183                 $status = Status::newGood();
 184
 185                 $src = $this->resolveHashKey( $params['src'] );
 186                 if ( $src === null || !isset( $this->files[$src] ) ) {
 187                         $status->fatal( 'backend-fail-stream', $params['src'] );
 188
 189                         return $status;
 190                 }
 191
 192                 print $this->files[$src]['data'];
 193
 194                 return $status;
 195         }
 196
 197         protected function doDirectoryExists( $container, $dir, array $params ) {
 198                 $prefix = rtrim( "$container/$dir", '/' ) . '/';
 199                 foreach ( $this->files as $path => $data ) {
 200                         if ( strpos( $path, $prefix ) === 0 ) {
 201                                 return true;
 202                         }
 203                 }
 204
 205                 return false;
 206         }
 207
 208         public function getDirectoryListInternal( $container, $dir, array $params ) {
 209                 $dirs = array();
 210                 $prefix = rtrim( "$container/$dir", '/' ) . '/';
 211                 $prefixLen = strlen( $prefix );
 212                 foreach ( $this->files as $path => $data ) {
 213                         if ( strpos( $path, $prefix ) === 0 ) {
 214                                 $relPath = substr( $path, $prefixLen );
 215                                 if ( $relPath === false ) {
 216                                         continue;
 217                                 } elseif ( strpos( $relPath, '/' ) === false ) {
 218                                         continue; // just a file
 219                                 }
 220                                 $parts = array_slice( explode( '/', $relPath ), 0, -1 ); // last part is file name
 221                                 if ( !empty( $params['topOnly'] ) ) {
 222                                         $dirs[$parts[0]] = 1; // top directory
 223                                 } else {
 224                                         $current = '';
 225                                         foreach ( $parts as $part ) { // all directories
 226                                                 $dir = ( $current === '' ) ? $part : "$current/$part";
 227                                                 $dirs[$dir] = 1;
 228                                                 $current = $dir;
 229                                         }
 230                                 }
 231                         }
 232                 }
 233
 234                 return array_keys( $dirs );
 235         }
 236
 237         public function getFileListInternal( $container, $dir, array $params ) {
 238                 $files = array();
 239                 $prefix = rtrim( "$container/$dir", '/' ) . '/';
 240                 $prefixLen = strlen( $prefix );
 241                 foreach ( $this->files as $path => $data ) {
 242                         if ( strpos( $path, $prefix ) === 0 ) {
 243                                 $relPath = substr( $path, $prefixLen );
 244                                 if ( $relPath === false ) {
 245                                         continue;
 246                                 } elseif ( !empty( $params['topOnly'] ) && strpos( $relPath, '/' ) !== false ) {
 247                                         continue;
 248                                 }
 249                                 $files[] = $relPath;
 250                         }
 251                 }
 252
 253                 return $files;
 254         }
 255
 256         protected function directoriesAreVirtual() {
 257                 return true;
 258         }
 259
 260         /**
 261          * Get the absolute file system path for a storage path
 262          *
 263          * @param string $storagePath Storage path
 264          * @return string|null
 265          */
 266         protected function resolveHashKey( $storagePath ) {
 267                 list( $fullCont, $relPath ) = $this->resolveStoragePathReal( $storagePath );
 268                 if ( $relPath === null ) {
 269                         return null; // invalid
 270                 }
 271
 272                 return ( $relPath !== '' ) ? "$fullCont/$relPath" : $fullCont;
 273         }
 274 }