classes/install/Installer.inc.php

<?php

// $Id: Installer.inc.php,v 1.40 2008/07/01 01:16:09 asmecher Exp $


// Database installation files
define('INSTALLER_DATA_DIR', 'dbscripts/xml');
define('INSTALLER_DOCS_DIR', 'docs');

// Installer error codes
define('INSTALLER_ERROR_GENERAL', 1);
define('INSTALLER_ERROR_DB', 2);

// Default data
define('INSTALLER_DEFAULT_LOCALE', 'en_US');

import('db.DBDataXMLParser');
import('site.Version');
import('site.VersionDAO');
import('config.ConfigParser');

require_once('adodb/adodb-xmlschema.inc.php'); // FIXME?

class Installer {

   var $descriptor;

   var $params;

   var $currentVersion;

   var $newVersion;

   var $dbconn;

   var $locale;

   var $installedLocales;

   var $dataXMLParser;

   var $actions;

   var $sql;

   var $notes;

   var $configContents;

   var $wroteConfig;

   var $errorType;

   var $errorMsg;

   var $logger;


   function Installer($descriptor, $params = array()) {
      // Load all plugins. If any of them use installer hooks,
      // they'll need to be loaded here.
      PluginRegistry::loadAllPlugins();

      // Give the HookRegistry the opportunity to override this
      // method or alter its parameters.
      if (!HookRegistry::call('Installer::Installer', array(&$this, &$descriptor, &$params))) {
         $this->descriptor = $descriptor;
         $this->params = $params;
         $this->actions = array();
         $this->sql = array();
         $this->notes = array();
         $this->wroteConfig = true;
      }
   }

   function isUpgrade() {
      die ('ABSTRACT CLASS');
   }

   function destroy() {
      if (isset($this->dataXMLParser)) {
         $this->dataXMLParser->destroy();
      }

      HookRegistry::call('Installer::destroy', array(&$this));
   }

   function preInstall() {
      if (!isset($this->dbconn)) {
         // Connect to the database.
         $conn = &DBConnection::getInstance();
         $this->dbconn = &$conn->getDBConn();

         if (!$conn->isConnected()) {
            $this->setError(INSTALLER_ERROR_DB, $this->dbconn->errorMsg());
            return false;
         }
      }

      if (!isset($this->currentVersion)) {
         // Retrieve the currently installed version
         $versionDao = &DAORegistry::getDAO('VersionDAO');
         $this->currentVersion = &$versionDao->getCurrentVersion();
      }

      if (!isset($this->locale)) {
         $this->locale = Locale::getLocale();
      }

      if (!isset($this->installedLocales)) {
         $this->installedLocales = array_keys(Locale::getAllLocales());
      }

      if (!isset($this->dataXMLParser)) {
         $this->dataXMLParser = &new DBDataXMLParser();
         $this->dataXMLParser->setDBConn($this->dbconn);
      }

      $result = true;
      HookRegistry::call('Installer::preInstall', array(&$this, &$result));

      return $result;
   }

   function execute() {
      // Ensure that the installation will not get interrupted if it takes
      // longer than max_execution_time (php.ini). Note that this does not
      // work under safe mode.
      @set_time_limit (0);

      if (!$this->preInstall()) {
         return false;
      }

      if (!$this->parseInstaller()) {
         return false;
      }

      if (!$this->executeInstaller()) {
         return false;
      }

      if (!$this->postInstall()) {
         return false;
      }

      return $this->updateVersion();
   }

   function postInstall() {
      $result = true;
      HookRegistry::call('Installer::postInstall', array(&$this, &$result));
      return $result;
   }


   function log($message) {
      if (isset($this->logger)) {
         call_user_func(array($this->logger, 'log'), $message);
      }
   }


   //
   // Main actions
   //

   function parseInstaller() {
      // Read installation descriptor file
      $this->log(sprintf('load: %s', $this->descriptor));
      $xmlParser = &new XMLParser();
      $installTree = $xmlParser->parse(INSTALLER_DATA_DIR . '/' . $this->descriptor);
      if (!$installTree) {
         // Error reading installation file
         $xmlParser->destroy();
         $this->setError(INSTALLER_ERROR_GENERAL, 'installer.installFileError');
         return false;
      }

      $versionString = $installTree->getAttribute('version');
      if (isset($versionString)) {
         $this->newVersion = &Version::fromString($versionString);
         $this->newVersion->setCurrent(1);
      } else {
         $this->newVersion = $this->currentVersion;
      }  

      // Parse descriptor
      $this->parseInstallNodes($installTree);
      $xmlParser->destroy();

      $result = $this->getErrorType() == 0;

      HookRegistry::call('Installer::parseInstaller', array(&$this, &$result));
      return $result;
   }

   function executeInstaller() {
      $this->log(sprintf('version: %s', $this->newVersion->getVersionString()));
      foreach ($this->actions as $action) {
         if (!$this->executeAction($action)) {
            return false;
         }
      }

      $result = true;
      HookRegistry::call('Installer::executeInstaller', array(&$this, &$result));

      return $result;
   }

   function updateVersion() {
      if ($this->newVersion->compare($this->currentVersion) > 0) {
         if ($this->getParam('manualInstall')) {
            // FIXME Would be better to have a mode where $dbconn->execute() saves the query
            return $this->executeSQL(sprintf('INSERT INTO versions (major, minor, revision, build, date_installed, current) VALUES (%d, %d, %d, %d, NOW(), 1)', $this->newVersion->getMajor(), $this->newVersion->getMinor(), $this->newVersion->getRevision(), $this->newVersion->getBuild()));
         } else {
            $versionDao = &DAORegistry::getDAO('VersionDAO');
            if (!$versionDao->insertVersion($this->newVersion)) {
               return false;
            }
         }
      }

      $result = true;
      HookRegistry::call('Installer::updateVersion', array(&$this, &$result));

      return $result;
   }


   //
   // Installer Parsing
   //

   function parseInstallNodes(&$installTree) {
      foreach ($installTree->getChildren() as $node) {
         switch ($node->getName()) {
            case 'schema':
            case 'data':
            case 'code':
            case 'note':
               $this->addInstallAction($node);
               break;
            case 'upgrade':
               $minVersion = $node->getAttribute('minversion');
               $maxVersion = $node->getAttribute('maxversion');
               if ((!isset($minVersion) || $this->currentVersion->compare($minVersion) >= 0) && (!isset($maxVersion) || $this->currentVersion->compare($maxVersion) <= 0)) {
                  $this->parseInstallNodes($node);
               }
               break;
         }
      }
   }

   function addInstallAction(&$node) {
      $fileName = $node->getAttribute('file');

      if (!isset($fileName)) {
         $this->actions[] = array('type' => $node->getName(), 'file' => null, 'attr' => $node->getAttributes());

      } else if (strstr($fileName, '{$installedLocale}')) {
         // Filename substitution for locales
         foreach ($this->installedLocales as $thisLocale) {
            $newFileName = str_replace('{$installedLocale}', $thisLocale, $fileName);
            $this->actions[] = array('type' => $node->getName(), 'file' => $newFileName, 'attr' => $node->getAttributes());
         }

      } else {
         $newFileName = str_replace('{$locale}', $this->locale, $fileName);
         if (!file_exists(INSTALLER_DATA_DIR . '/'. $newFileName)) {
            // Use version from default locale if data file is not available in the selected locale
            $newFileName = str_replace('{$locale}', INSTALLER_DEFAULT_LOCALE, $fileName);
         }

         $this->actions[] = array('type' => $node->getName(), 'file' => $newFileName, 'attr' => $node->getAttributes());
      }
   }


   //
   // Installer Execution
   //

   function executeAction($action) {
      switch ($action['type']) {
         case 'schema':
            $fileName = INSTALLER_DATA_DIR . '/'. $action['file'];
            $this->log(sprintf('schema: %s', $action['file']));

            require_once('adodb/adodb-xmlschema.inc.php');
            $schemaXMLParser = &new adoSchema($this->dbconn, $this->dbconn->charSet);
            $sql = $schemaXMLParser->parseSchema($fileName);
            $schemaXMLParser->destroy();

            if ($sql) {
               return $this->executeSQL($sql);
            } else {
               $this->setError(INSTALLER_ERROR_DB, str_replace('{$file}', $fileName, Locale::translate('installer.installParseDBFileError')));
               return false;
            }
            break;
         case 'data':
            $fileName = INSTALLER_DATA_DIR . '/'. $action['file'];
            $this->log(sprintf('data: %s', $action['file']));
            $sql = $this->dataXMLParser->parseData($fileName);
            if ($sql) {
               return $this->executeSQL($sql);
            } else {
               $this->setError(INSTALLER_ERROR_DB, str_replace('{$file}', $fileName, Locale::translate('installer.installParseDBFileError')));
               return false;
            }
            break;
         case 'code':
            $this->log(sprintf('code: %s %s::%s', isset($action['file']) ? $action['file'] : 'Installer', isset($action['attr']['class']) ? $action['attr']['class'] : 'Installer', $action['attr']['function']));
            // FIXME Don't execute code with "manual install" ???
            if (isset($action['file'])) {
               require_once($action['file']);
            }
            if (isset($action['attr']['class'])) {
               return call_user_func(array($action['attr']['class'], $action['attr']['function']), $this);
            } else {
               return call_user_func(array(&$this, $action['attr']['function']));
            }
            break;
         case 'note':
            $this->log(sprintf('note: %s', $action['file']));
            $this->notes[] = join('', file(INSTALLER_DOCS_DIR . '/' . $action['file']));
            break;
      }

      return true;
   }

   function executeSQL($sql) {
      if (is_array($sql)) {
         foreach($sql as $stmt) {
            if (!$this->executeSQL($stmt)) {
               return false;
            }
         }
      } else {
         if ($this->getParam('manualInstall')) {
            $this->sql[] = $sql;

         } else {
            $this->dbconn->execute($sql);
            if ($this->dbconn->errorNo() != 0) {
               $this->setError(INSTALLER_ERROR_DB, $this->dbconn->errorMsg());
               return false;
            }
         }
      }

      return true;
   }

   function updateConfig($configParams) {
      // Update config file
      $configParser = &new ConfigParser();
      if (!$configParser->updateConfig(Config::getConfigFileName(), $configParams)) {
         // Error reading config file
         $this->setError(INSTALLER_ERROR_GENERAL, 'installer.configFileError');
         return false;
      }

      $this->configContents = $configParser->getFileContents();
      if (!$configParser->writeConfig(Config::getConfigFileName())) {
         $this->wroteConfig = false;
      }

      return true;
   }


   //
   // Accessors
   //

   function getParam($name) {
      return isset($this->params[$name]) ? $this->params[$name] : null;
   }

   function &getCurrentVersion() {
      return $this->currentVersion;
   }

   function &getNewVersion() {
      return $this->newVersion;
   }

   function getSQL() {
      return $this->sql;
   }

   function getNotes() {
      return $this->notes;
   }

   function getConfigContents() {
      return $this->configContents;
   }

   function wroteConfig() {
      return $this->wroteConfig;
   }

   function getErrorType() {
      return isset($this->errorType) ? $this->errorType : 0;
   }

   function getErrorMsg() {
      return $this->errorMsg;
   }

   function getErrorString() {
      switch ($this->getErrorType()) {
         case INSTALLER_ERROR_DB:
            return 'DB: ' . $this->getErrorMsg();
         default:
            return Locale::translate($this->getErrorMsg());
      }
   }

   function setError($type, $msg) {
      $this->errorType = $type;
      $this->errorMsg = $msg;
   }

   function setLogger(&$logger) {
      $this->logger = $logger;
   }

}

?>

---