includes/HistoryBlob.php

   1 <?php
   2 /**
   3  *
   4  * @package MediaWiki
   5  */
   6
   7 /**
   8  * Pure virtual parent
   9  * @package MediaWiki
  10  */
  11 class HistoryBlob
  12 {
  13         /**
  14          * setMeta and getMeta currently aren't used for anything, I just thought
  15          * they might be useful in the future.
  16          * @param $meta String: a single string.
  17          */
  18         function setMeta( $meta ) {}
  19
  20         /**
  21          * setMeta and getMeta currently aren't used for anything, I just thought
  22          * they might be useful in the future.
  23          * Gets the meta-value
  24          */
  25         function getMeta() {}
  26
  27         /**
  28          * Adds an item of text, returns a stub object which points to the item.
  29          * You must call setLocation() on the stub object before storing it to the
  30          * database
  31          */
  32         function addItem() {}
  33
  34         /**
  35          * Get item by hash
  36          */
  37         function getItem( $hash ) {}
  38
  39         # Set the "default text"
  40         # This concept is an odd property of the current DB schema, whereby each text item has a revision
  41         # associated with it. The default text is the text of the associated revision. There may, however,
  42         # be other revisions in the same object
  43         function setText() {}
  44
  45         /**
  46          * Get default text. This is called from Revision::getRevisionText()
  47          */
  48         function getText() {}
  49 }
  50
  51 /**
  52  * The real object
  53  * @package MediaWiki
  54  */
  55 class ConcatenatedGzipHistoryBlob extends HistoryBlob
  56 {
  57         /* private */ var $mVersion = 0, $mCompressed = false, $mItems = array(), $mDefaultHash = '';
  58         /* private */ var $mFast = 0, $mSize = 0;
  59
  60         function ConcatenatedGzipHistoryBlob() {
  61                 if ( !function_exists( 'gzdeflate' ) ) {
  62                         throw new MWException( "Need zlib support to read or write this kind of history object (ConcatenatedGzipHistoryBlob)\n" );
  63                 }
  64         }
  65
  66         /** @todo document */
  67         function setMeta( $metaData ) {
  68                 $this->uncompress();
  69                 $this->mItems['meta'] = $metaData;
  70         }
  71
  72         /** @todo document */
  73         function getMeta() {
  74                 $this->uncompress();
  75                 return $this->mItems['meta'];
  76         }
  77
  78         /** @todo document */
  79         function addItem( $text ) {
  80                 $this->uncompress();
  81                 $hash = md5( $text );
  82                 $this->mItems[$hash] = $text;
  83                 $this->mSize += strlen( $text );
  84
  85                 $stub = new HistoryBlobStub( $hash );
  86                 return $stub;
  87         }
  88
  89         /** @todo document */
  90         function getItem( $hash ) {
  91                 $this->uncompress();
  92                 if ( array_key_exists( $hash, $this->mItems ) ) {
  93                         return $this->mItems[$hash];
  94                 } else {
  95                         return false;
  96                 }
  97         }
  98
  99         /** @todo document */
 100         function removeItem( $hash ) {
 101                 $this->mSize -= strlen( $this->mItems[$hash] );
 102                 unset( $this->mItems[$hash] );
 103         }
 104
 105         /** @todo document */
 106         function compress() {
 107                 if ( !$this->mCompressed  ) {
 108                         $this->mItems = gzdeflate( serialize( $this->mItems ) );
 109                         $this->mCompressed = true;
 110                 }
 111         }
 112
 113         /** @todo document */
 114         function uncompress() {
 115                 if ( $this->mCompressed ) {
 116                         $this->mItems = unserialize( gzinflate( $this->mItems ) );
 117                         $this->mCompressed = false;
 118                 }
 119         }
 120
 121         /** @todo document */
 122         function getText() {
 123                 $this->uncompress();
 124                 return $this->getItem( $this->mDefaultHash );
 125         }
 126
 127         /** @todo document */
 128         function setText( $text ) {
 129                 $this->uncompress();
 130                 $stub = $this->addItem( $text );
 131                 $this->mDefaultHash = $stub->mHash;
 132         }
 133
 134         /** @todo document */
 135         function __sleep() {
 136                 $this->compress();
 137                 return array( 'mVersion', 'mCompressed', 'mItems', 'mDefaultHash' );
 138         }
 139
 140         /** @todo document */
 141         function __wakeup() {
 142                 $this->uncompress();
 143         }
 144
 145         /**
 146          * Determines if this object is happy
 147          */
 148         function isHappy( $maxFactor, $factorThreshold ) {
 149                 if ( count( $this->mItems ) == 0 ) {
 150                         return true;
 151                 }
 152                 if ( !$this->mFast ) {
 153                         $this->uncompress();
 154                         $record = serialize( $this->mItems );
 155                         $size = strlen( $record );
 156                         $avgUncompressed = $size / count( $this->mItems );
 157                         $compressed = strlen( gzdeflate( $record ) );
 158
 159                         if ( $compressed < $factorThreshold * 1024 ) {
 160                                 return true;
 161                         } else {
 162                                 return $avgUncompressed * $maxFactor < $compressed;
 163                         }
 164                 } else {
 165                         return count( $this->mItems ) <= 10;
 166                 }
 167         }
 168 }
 169
 170
 171 /**
 172  * One-step cache variable to hold base blobs; operations that
 173  * pull multiple revisions may often pull multiple times from
 174  * the same blob. By keeping the last-used one open, we avoid
 175  * redundant unserialization and decompression overhead.
 176  */
 177 global $wgBlobCache;
 178 $wgBlobCache = array();
 179
 180
 181 /**
 182  * @package MediaWiki
 183  */
 184 class HistoryBlobStub {
 185         var $mOldId, $mHash, $mRef;
 186
 187         /** @todo document */
 188         function HistoryBlobStub( $hash = '', $oldid = 0 ) {
 189                 $this->mHash = $hash;
 190         }
 191
 192         /**
 193          * Sets the location (old_id) of the main object to which this object
 194          * points
 195          */
 196         function setLocation( $id ) {
 197                 $this->mOldId = $id;
 198         }
 199
 200       /**
 201        * Sets the location (old_id) of the referring object
 202        */
 203         function setReferrer( $id ) {
 204                 $this->mRef = $id;
 205         }
 206
 207       /**
 208        * Gets the location of the referring object
 209        */
 210         function getReferrer() {
 211                 return $this->mRef;
 212         }
 213
 214         /** @todo document */
 215         function getText() {
 216                 $fname = 'HistoryBlob::getText';
 217                 global $wgBlobCache;
 218                 if( isset( $wgBlobCache[$this->mOldId] ) ) {
 219                         $obj = $wgBlobCache[$this->mOldId];
 220                 } else {
 221                         $dbr =& wfGetDB( DB_SLAVE );
 222                         $row = $dbr->selectRow( 'text', array( 'old_flags', 'old_text' ), array( 'old_id' => $this->mOldId ) );
 223                         if( !$row ) {
 224                                 return false;
 225                         }
 226                         $flags = explode( ',', $row->old_flags );
 227                         if( in_array( 'external', $flags ) ) {
 228                                 $url=$row->old_text;
 229                                 @list($proto,$path)=explode('://',$url,2);
 230                                 if ($path=="") {
 231                                         wfProfileOut( $fname );
 232                                         return false;
 233                                 }
 234                                 require_once('ExternalStore.php');
 235                                 $row->old_text=ExternalStore::fetchFromUrl($url);
 236
 237                         }
 238                         if( !in_array( 'object', $flags ) ) {
 239                                 return false;
 240                         }
 241
 242                         if( in_array( 'gzip', $flags ) ) {
 243                                 // This shouldn't happen, but a bug in the compress script
 244                                 // may at times gzip-compress a HistoryBlob object row.
 245                                 $obj = unserialize( gzinflate( $row->old_text ) );
 246                         } else {
 247                                 $obj = unserialize( $row->old_text );
 248                         }
 249
 250                         if( !is_object( $obj ) ) {
 251                                 // Correct for old double-serialization bug.
 252                                 $obj = unserialize( $obj );
 253                         }
 254
 255                         // Save this item for reference; if pulling many
 256                         // items in a row we'll likely use it again.
 257                         $obj->uncompress();
 258                         $wgBlobCache = array( $this->mOldId => $obj );
 259                 }
 260                 return $obj->getItem( $this->mHash );
 261         }
 262
 263         /** @todo document */
 264         function getHash() {
 265                 return $this->mHash;
 266         }
 267 }
 268
 269
 270 /**
 271  * To speed up conversion from 1.4 to 1.5 schema, text rows can refer to the
 272  * leftover cur table as the backend. This avoids expensively copying hundreds
 273  * of megabytes of data during the conversion downtime.
 274  *
 275  * Serialized HistoryBlobCurStub objects will be inserted into the text table
 276  * on conversion if $wgFastSchemaUpgrades is set to true.
 277  *
 278  * @package MediaWiki
 279  */
 280 class HistoryBlobCurStub {
 281         var $mCurId;
 282
 283         /** @todo document */
 284         function HistoryBlobCurStub( $curid = 0 ) {
 285                 $this->mCurId = $curid;
 286         }
 287
 288         /**
 289          * Sets the location (cur_id) of the main object to which this object
 290          * points
 291          */
 292         function setLocation( $id ) {
 293                 $this->mCurId = $id;
 294         }
 295
 296         /** @todo document */
 297         function getText() {
 298                 $dbr =& wfGetDB( DB_SLAVE );
 299                 $row = $dbr->selectRow( 'cur', array( 'cur_text' ), array( 'cur_id' => $this->mCurId ) );
 300                 if( !$row ) {
 301                         return false;
 302                 }
 303                 return $row->cur_text;
 304         }
 305 }
 306
 307
 308 ?>