includes/installer/SqliteInstaller.php

   1 <?php
   2 /**
   3  * Sqlite-specific installer.
   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 Deployment
  22  */
  23
  24 /**
  25  * Class for setting up the MediaWiki database using SQLLite.
  26  *
  27  * @ingroup Deployment
  28  * @since 1.17
  29  */
  30 class SqliteInstaller extends DatabaseInstaller {
  31         const MINIMUM_VERSION = '3.3.7';
  32
  33         /**
  34          * @var DatabaseSqlite
  35          */
  36         public $db;
  37
  38         protected $globalNames = array(
  39                 'wgDBname',
  40                 'wgSQLiteDataDir',
  41         );
  42
  43         public function getName() {
  44                 return 'sqlite';
  45         }
  46
  47         public function isCompiled() {
  48                 return self::checkExtension( 'pdo_sqlite' );
  49         }
  50
  51         /**
  52          *
  53          * @return Status:
  54          */
  55         public function checkPrerequisites() {
  56                 $result = Status::newGood();
  57                 // Bail out if SQLite is too old
  58                 $db = new DatabaseSqliteStandalone( ':memory:' );
  59                 if ( version_compare( $db->getServerVersion(), self::MINIMUM_VERSION, '<' ) ) {
  60                         $result->fatal( 'config-outdated-sqlite', $db->getServerVersion(), self::MINIMUM_VERSION );
  61                 }
  62                 // Check for FTS3 full-text search module
  63                 if( DatabaseSqlite::getFulltextSearchModule() != 'FTS3' ) {
  64                         $result->warning( 'config-no-fts3' );
  65                 }
  66                 return $result;
  67         }
  68
  69         public function getGlobalDefaults() {
  70                 if ( isset( $_SERVER['DOCUMENT_ROOT'] ) ) {
  71                         $path = str_replace(
  72                                 array( '/', '\\' ),
  73                                 DIRECTORY_SEPARATOR,
  74                                 dirname( $_SERVER['DOCUMENT_ROOT'] ) . '/data'
  75                         );
  76                         return array( 'wgSQLiteDataDir' => $path );
  77                 } else {
  78                         return array();
  79                 }
  80         }
  81
  82         public function getConnectForm() {
  83                 return $this->getTextBox( 'wgSQLiteDataDir', 'config-sqlite-dir', array(), $this->parent->getHelpBox( 'config-sqlite-dir-help' ) ) .
  84                         $this->getTextBox( 'wgDBname', 'config-db-name', array(), $this->parent->getHelpBox( 'config-sqlite-name-help' ) );
  85         }
  86
  87         /**
  88          * Safe wrapper for PHP's realpath() that fails gracefully if it's unable to canonicalize the path.
  89          *
  90          * @param $path string
  91          *
  92          * @return string
  93          */
  94         private static function realpath( $path ) {
  95                 $result = realpath( $path );
  96                 if ( !$result ) {
  97                         return $path;
  98                 }
  99                 return $result;
 100         }
 101
 102         /**
 103          * @return Status
 104          */
 105         public function submitConnectForm() {
 106                 $this->setVarsFromRequest( array( 'wgSQLiteDataDir', 'wgDBname' ) );
 107
 108                 # Try realpath() if the directory already exists
 109                 $dir = self::realpath( $this->getVar( 'wgSQLiteDataDir' ) );
 110                 $result = self::dataDirOKmaybeCreate( $dir, true /* create? */ );
 111                 if ( $result->isOK() ) {
 112                         # Try expanding again in case we've just created it
 113                         $dir = self::realpath( $dir );
 114                         $this->setVar( 'wgSQLiteDataDir', $dir );
 115                 }
 116                 return $result;
 117         }
 118
 119         /**
 120          * @param $dir
 121          * @param $create bool
 122          * @return Status
 123          */
 124         private static function dataDirOKmaybeCreate( $dir, $create = false ) {
 125                 if ( !is_dir( $dir ) ) {
 126                         if ( !is_writable( dirname( $dir ) ) ) {
 127                                 $webserverGroup = Installer::maybeGetWebserverPrimaryGroup();
 128                                 if ( $webserverGroup !== null ) {
 129                                         return Status::newFatal( 'config-sqlite-parent-unwritable-group', $dir, dirname( $dir ), basename( $dir ), $webserverGroup );
 130                                 } else {
 131                                         return Status::newFatal( 'config-sqlite-parent-unwritable-nogroup', $dir, dirname( $dir ), basename( $dir ) );
 132                                 }
 133                         }
 134
 135                         # Called early on in the installer, later we just want to sanity check
 136                         # if it's still writable
 137                         if ( $create ) {
 138                                 wfSuppressWarnings();
 139                                 $ok = wfMkdirParents( $dir, 0700, __METHOD__ );
 140                                 wfRestoreWarnings();
 141                                 if ( !$ok ) {
 142                                         return Status::newFatal( 'config-sqlite-mkdir-error', $dir );
 143                                 }
 144                                 # Put a .htaccess file in in case the user didn't take our advice
 145                                 file_put_contents( "$dir/.htaccess", "Deny from all\n" );
 146                         }
 147                 }
 148                 if ( !is_writable( $dir ) ) {
 149                         return Status::newFatal( 'config-sqlite-dir-unwritable', $dir );
 150                 }
 151
 152                 # We haven't blown up yet, fall through
 153                 return Status::newGood();
 154         }
 155
 156         /**
 157          * @return Status
 158          */
 159         public function openConnection() {
 160                 global $wgSQLiteDataDir;
 161
 162                 $status = Status::newGood();
 163                 $dir = $this->getVar( 'wgSQLiteDataDir' );
 164                 $dbName = $this->getVar( 'wgDBname' );
 165                 try {
 166                         # @todo FIXME: Need more sensible constructor parameters, e.g. single associative array
 167                         # Setting globals kind of sucks
 168                         $wgSQLiteDataDir = $dir;
 169                         $db = new DatabaseSqlite( false, false, false, $dbName );
 170                         $status->value = $db;
 171                 } catch ( DBConnectionError $e ) {
 172                         $status->fatal( 'config-sqlite-connection-error', $e->getMessage() );
 173                 }
 174                 return $status;
 175         }
 176
 177         /**
 178          * @return bool
 179          */
 180         public function needsUpgrade() {
 181                 $dir = $this->getVar( 'wgSQLiteDataDir' );
 182                 $dbName = $this->getVar( 'wgDBname' );
 183                 // Don't create the data file yet
 184                 if ( !file_exists( DatabaseSqlite::generateFileName( $dir, $dbName ) ) ) {
 185                         return false;
 186                 }
 187
 188                 // If the data file exists, look inside it
 189                 return parent::needsUpgrade();
 190         }
 191
 192         /**
 193          * @return Status
 194          */
 195         public function setupDatabase() {
 196                 $dir = $this->getVar( 'wgSQLiteDataDir' );
 197
 198                 # Sanity check. We checked this before but maybe someone deleted the
 199                 # data dir between then and now
 200                 $dir_status = self::dataDirOKmaybeCreate( $dir, false /* create? */ );
 201                 if ( !$dir_status->isOK() ) {
 202                         return $dir_status;
 203                 }
 204
 205                 $db = $this->getVar( 'wgDBname' );
 206                 $file = DatabaseSqlite::generateFileName( $dir, $db );
 207                 if ( file_exists( $file ) ) {
 208                         if ( !is_writable( $file ) ) {
 209                                 return Status::newFatal( 'config-sqlite-readonly', $file );
 210                         }
 211                 } else {
 212                         if ( file_put_contents( $file, '' ) === false ) {
 213                                 return Status::newFatal( 'config-sqlite-cant-create-db', $file );
 214                         }
 215                 }
 216                 // nuke the unused settings for clarity
 217                 $this->setVar( 'wgDBserver', '' );
 218                 $this->setVar( 'wgDBuser', '' );
 219                 $this->setVar( 'wgDBpassword', '' );
 220                 $this->setupSchemaVars();
 221                 return $this->getConnection();
 222         }
 223
 224         /**
 225          * @return Status
 226          */
 227         public function createTables() {
 228                 $status = parent::createTables();
 229                 return $this->setupSearchIndex( $status );
 230         }
 231
 232         /**
 233          * @param $status Status
 234          * @return Status
 235          */
 236         public function setupSearchIndex( &$status ) {
 237                 global $IP;
 238
 239                 $module = DatabaseSqlite::getFulltextSearchModule();
 240                 $fts3tTable = $this->db->checkForEnabledSearch();
 241                 if ( $fts3tTable &&  !$module ) {
 242                         $status->warning( 'config-sqlite-fts3-downgrade' );
 243                         $this->db->sourceFile( "$IP/maintenance/sqlite/archives/searchindex-no-fts.sql" );
 244                 } elseif ( !$fts3tTable && $module == 'FTS3' ) {
 245                         $this->db->sourceFile( "$IP/maintenance/sqlite/archives/searchindex-fts3.sql" );
 246                 }
 247                 return $status;
 248         }
 249
 250         /**
 251          * @return string
 252          */
 253         public function getLocalSettings() {
 254                 $dir = LocalSettingsGenerator::escapePhpString( $this->getVar( 'wgSQLiteDataDir' ) );
 255                 return
 256 "# SQLite-specific settings
 257 \$wgSQLiteDataDir    = \"{$dir}\";";
 258         }
 259 }