CRM/Upgrade/Form.php

   1 <?php
   2 /*
   3  +--------------------------------------------------------------------+
   4  | CiviCRM version 4.6                                                |
   5  +--------------------------------------------------------------------+
   6  | Copyright CiviCRM LLC (c) 2004-2014                                |
   7  +--------------------------------------------------------------------+
   8  | This file is a part of CiviCRM.                                    |
   9  |                                                                    |
  10  | CiviCRM is free software; you can copy, modify, and distribute it  |
  11  | under the terms of the GNU Affero General Public License           |
  12  | Version 3, 19 November 2007 and the CiviCRM Licensing Exception.   |
  13  |                                                                    |
  14  | CiviCRM is distributed in the hope that it will be useful, but     |
  15  | WITHOUT ANY WARRANTY; without even the implied warranty of         |
  16  | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.               |
  17  | See the GNU Affero General Public License for more details.        |
  18  |                                                                    |
  19  | You should have received a copy of the GNU Affero General Public   |
  20  | License and the CiviCRM Licensing Exception along                  |
  21  | with this program; if not, contact CiviCRM LLC                     |
  22  | at info[AT]civicrm[DOT]org. If you have questions about the        |
  23  | GNU Affero General Public License or the licensing of CiviCRM,     |
  24  | see the CiviCRM license FAQ at http://civicrm.org/licensing        |
  25  +--------------------------------------------------------------------+
  26  */
  27
  28 /**
  29  *
  30  * @package CRM
  31  * @copyright CiviCRM LLC (c) 2004-2014
  32  * $Id$
  33  *
  34  */
  35 class CRM_Upgrade_Form extends CRM_Core_Form {
  36   const QUEUE_NAME = 'CRM_Upgrade';
  37
  38   /**
  39    * Minimum size of MySQL's thread_stack option
  40    *
  41    * @see install/index.php MINIMUM_THREAD_STACK
  42    */
  43   const MINIMUM_THREAD_STACK = 192;
  44
  45   protected $_config;
  46
  47   /**
  48    * Upgrade for multilingual
  49    *
  50    * @var boolean
  51    */
  52   public $multilingual = FALSE;
  53
  54   /**
  55    * Locales available for multilingual upgrade
  56    *
  57    * @var array
  58    */
  59   public $locales;
  60
  61   /**
  62    * Number to string mapper
  63    *
  64    * @var array
  65    */
  66   static $_numberMap = array(
  67     0 => 'Zero',
  68     1 => 'One',
  69     2 => 'Two',
  70     3 => 'Three',
  71     4 => 'Four',
  72     5 => 'Five',
  73     6 => 'Six',
  74     7 => 'Seven',
  75     8 => 'Eight',
  76     9 => 'Nine',
  77   );
  78
  79   /**
  80    * Constructor for the basic form page
  81    *
  82    * We should not use QuickForm directly. This class provides a lot
  83    * of default convenient functions, rules and buttons
  84    *
  85    * @param object $state
  86    *   State associated with this form.
  87    * @param \const|\enum $action The mode the form is operating in (None/Create/View/Update/Delete)
  88    * @param string $method
  89    *   The type of http method used (GET/POST).
  90    * @param string $name
  91    *   The name of the form if different from class name.
  92    *
  93    * @return \CRM_Core_Form
  94    */
  95   /**
  96    * @param null|object $state
  97    * @param const|enum|int $action
  98    * @param string $method
  99    * @param null|string $name
 100    */
 101   public function __construct(
 102     $state = NULL,
 103     $action = CRM_Core_Action::NONE,
 104     $method = 'post',
 105     $name = NULL
 106   ) {
 107     $this->_config = CRM_Core_Config::singleton();
 108
 109     $domain = new CRM_Core_DAO_Domain();
 110     $domain->find(TRUE);
 111
 112     $this->multilingual = (bool) $domain->locales;
 113     $this->locales = explode(CRM_Core_DAO::VALUE_SEPARATOR, $domain->locales);
 114
 115     $smarty = CRM_Core_Smarty::singleton();
 116     $smarty->compile_dir = $this->_config->templateCompileDir;
 117     $smarty->assign('multilingual', $this->multilingual);
 118     $smarty->assign('locales', $this->locales);
 119
 120     // we didn't call CRM_Core_BAO_ConfigSetting::retrieve(), so we need to set $dbLocale by hand
 121     if ($this->multilingual) {
 122       global $dbLocale;
 123       $dbLocale = "_{$this->_config->lcMessages}";
 124     }
 125
 126     parent::__construct($state, $action, $method, $name);
 127   }
 128
 129   /**
 130    * @param $version
 131    *
 132    * @return mixed
 133    */
 134   public static function &incrementalPhpObject($version) {
 135     static $incrementalPhpObject = array();
 136
 137     $versionParts = explode('.', $version);
 138     $versionName = self::$_numberMap[$versionParts[0]] . self::$_numberMap[$versionParts[1]];
 139
 140     if (!array_key_exists($versionName, $incrementalPhpObject)) {
 141       $className = "CRM_Upgrade_Incremental_php_{$versionName}";
 142       $incrementalPhpObject[$versionName] = new $className();
 143     }
 144     return $incrementalPhpObject[$versionName];
 145   }
 146
 147   /**
 148    * @param $version
 149    * @param $release
 150    *
 151    * @return bool
 152    */
 153   public function checkVersionRelease($version, $release) {
 154     $versionParts = explode('.', $version);
 155     if ($versionParts[2] == $release) {
 156       return TRUE;
 157     }
 158     return FALSE;
 159   }
 160
 161   /**
 162    * @param $constraints
 163    *
 164    * @return array
 165    */
 166   public function checkSQLConstraints(&$constraints) {
 167     $pass = $fail = 0;
 168     foreach ($constraints as $constraint) {
 169       if ($this->checkSQLConstraint($constraint)) {
 170         $pass++;
 171       }
 172       else {
 173         $fail++;
 174       }
 175       return array($pass, $fail);
 176     }
 177   }
 178
 179   /**
 180    * @param $constraint
 181    *
 182    * @return bool
 183    */
 184   public function checkSQLConstraint($constraint) {
 185     // check constraint here
 186     return TRUE;
 187   }
 188
 189   /**
 190    * @param string $fileName
 191    * @param bool $isQueryString
 192    */
 193   public function source($fileName, $isQueryString = FALSE) {
 194
 195     CRM_Utils_File::sourceSQLFile($this->_config->dsn,
 196       $fileName, NULL, $isQueryString
 197     );
 198   }
 199
 200   public function preProcess() {
 201     CRM_Utils_System::setTitle($this->getTitle());
 202     if (!$this->verifyPreDBState($errorMessage)) {
 203       if (!isset($errorMessage)) {
 204         $errorMessage = 'pre-condition failed for current upgrade step';
 205       }
 206       CRM_Core_Error::fatal($errorMessage);
 207     }
 208     $this->assign('recentlyViewed', FALSE);
 209   }
 210
 211   public function buildQuickForm() {
 212     $this->addDefaultButtons($this->getButtonTitle(),
 213       'next',
 214       NULL,
 215       TRUE
 216     );
 217   }
 218
 219   /**
 220    * Getter function for title. Should be over-ridden by derived class
 221    *
 222    * @return string
 223    */
 224   /**
 225    * @return string
 226    */
 227   public function getTitle() {
 228     return ts('Title not Set');
 229   }
 230
 231   /**
 232    * @return string
 233    */
 234   public function getFieldsetTitle() {
 235     return ts('');
 236   }
 237
 238   /**
 239    * @return string
 240    */
 241   public function getButtonTitle() {
 242     return ts('Continue');
 243   }
 244
 245   /**
 246    * Use the form name to create the tpl file name
 247    *
 248    * @return string
 249    */
 250   /**
 251    * @return string
 252    */
 253   public function getTemplateFileName() {
 254     $this->assign('title',
 255       $this->getFieldsetTitle()
 256     );
 257     $this->assign('message',
 258       $this->getTemplateMessage()
 259     );
 260     return 'CRM/Upgrade/Base.tpl';
 261   }
 262
 263   public function postProcess() {
 264     $this->upgrade();
 265
 266     if (!$this->verifyPostDBState($errorMessage)) {
 267       if (!isset($errorMessage)) {
 268         $errorMessage = 'post-condition failed for current upgrade step';
 269       }
 270       CRM_Core_Error::fatal($errorMessage);
 271     }
 272   }
 273
 274   /**
 275    * @param $query
 276    *
 277    * @return Object
 278    */
 279   public function runQuery($query) {
 280     return CRM_Core_DAO::executeQuery($query,
 281       CRM_Core_DAO::$_nullArray
 282     );
 283   }
 284
 285   /**
 286    * @param $version
 287    *
 288    * @return Object
 289    */
 290   public function setVersion($version) {
 291     $this->logVersion($version);
 292
 293     $query = "
 294 UPDATE civicrm_domain
 295 SET    version = '$version'
 296 ";
 297     return $this->runQuery($query);
 298   }
 299
 300   /**
 301    * @param $newVersion
 302    *
 303    * @return bool
 304    */
 305   public function logVersion($newVersion) {
 306     if ($newVersion) {
 307       $oldVersion = CRM_Core_BAO_Domain::version();
 308
 309       $session = CRM_Core_Session::singleton();
 310       $logParams = array(
 311         'entity_table' => 'civicrm_domain',
 312         'entity_id' => 1,
 313         'data' => "upgrade:{$oldVersion}->{$newVersion}",
 314         // lets skip 'modified_id' for now, as it causes FK issues And
 315         // is not very important for now.
 316         'modified_date' => date('YmdHis'),
 317       );
 318       CRM_Core_BAO_Log::add($logParams);
 319       return TRUE;
 320     }
 321
 322     return FALSE;
 323   }
 324
 325   /**
 326    * @param $version
 327    *
 328    * @return bool
 329    */
 330   public function checkVersion($version) {
 331     $domainID = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_Domain',
 332       $version, 'id',
 333       'version'
 334     );
 335     return $domainID ? TRUE : FALSE;
 336   }
 337
 338   /**
 339    * @return array
 340    * @throws Exception
 341    */
 342   public function getRevisionSequence() {
 343     $revList = array();
 344     $sqlDir = implode(DIRECTORY_SEPARATOR,
 345       array(dirname(__FILE__), 'Incremental', 'sql')
 346     );
 347     $sqlFiles = scandir($sqlDir);
 348
 349     $sqlFilePattern = '/^((\d{1,2}\.\d{1,2})\.(\d{1,2}\.)?(\d{1,2}|\w{4,7}))\.(my)?sql(\.tpl)?$/i';
 350     foreach ($sqlFiles as $file) {
 351       if (preg_match($sqlFilePattern, $file, $matches)) {
 352         if ($matches[2] == '4.0') {
 353           CRM_Core_Error::fatal(ts("4.0.x upgrade files shouldn't exist. Contact Lobo to discuss this. This is related to the issue CRM-7731."));
 354         }
 355         if (!in_array($matches[1], $revList)) {
 356           $revList[] = $matches[1];
 357         }
 358       }
 359     }
 360
 361     // sample test list
 362     /*         $revList = array(
 363     '2.1.0', '2.2.beta2', '2.2.beta1', '2.2.alpha1', */
 364
 365     /*                          '2.2.alpha3', '2.2.0', '2.2.2', '2.1.alpha1', '2.1.3'); */
 366
 367     usort($revList, 'version_compare');
 368     return $revList;
 369   }
 370
 371   /**
 372    * @param $rev
 373    * @param int $index
 374    *
 375    * @return null
 376    */
 377   public static function getRevisionPart($rev, $index = 1) {
 378     $revPattern = '/^((\d{1,2})\.\d{1,2})\.(\d{1,2}|\w{4,7})?$/i';
 379     preg_match($revPattern, $rev, $matches);
 380
 381     return array_key_exists($index, $matches) ? $matches[$index] : NULL;
 382   }
 383
 384   /**
 385    * @param $tplFile
 386    * @param $rev
 387    *
 388    * @return bool
 389    */
 390   public function processLocales($tplFile, $rev) {
 391     $smarty = CRM_Core_Smarty::singleton();
 392     $smarty->assign('domainID', CRM_Core_Config::domainID());
 393
 394     $this->source($smarty->fetch($tplFile), TRUE);
 395
 396     if ($this->multilingual) {
 397       CRM_Core_I18n_Schema::rebuildMultilingualSchema($this->locales, $rev);
 398     }
 399     return $this->multilingual;
 400   }
 401
 402   /**
 403    * @param $rev
 404    */
 405   public function setSchemaStructureTables($rev) {
 406     if ($this->multilingual) {
 407       CRM_Core_I18n_Schema::schemaStructureTables($rev, TRUE);
 408     }
 409   }
 410
 411   /**
 412    * @param $rev
 413    *
 414    * @throws Exception
 415    */
 416   public function processSQL($rev) {
 417     $sqlFile = implode(DIRECTORY_SEPARATOR,
 418       array(
 419         dirname(__FILE__),
 420         'Incremental',
 421         'sql',
 422         $rev . '.mysql',
 423       )
 424     );
 425     $tplFile = "$sqlFile.tpl";
 426
 427     if (file_exists($tplFile)) {
 428       $this->processLocales($tplFile, $rev);
 429     }
 430     else {
 431       if (!file_exists($sqlFile)) {
 432         CRM_Core_Error::fatal("sqlfile - $rev.mysql not found.");
 433       }
 434       $this->source($sqlFile);
 435     }
 436   }
 437
 438   /**
 439    * Determine the start and end version of the upgrade process
 440    *
 441    * @return array(0=>$currentVer, 1=>$latestVer)
 442    */
 443   public function getUpgradeVersions() {
 444     $latestVer = CRM_Utils_System::version();
 445     $currentVer = CRM_Core_BAO_Domain::version(TRUE);
 446     if (!$currentVer) {
 447       CRM_Core_Error::fatal(ts('Version information missing in civicrm database.'));
 448     }
 449     elseif (stripos($currentVer, 'upgrade')) {
 450       CRM_Core_Error::fatal(ts('Database check failed - the database looks to have been partially upgraded. You may want to reload the database with the backup and try the upgrade process again.'));
 451     }
 452     if (!$latestVer) {
 453       CRM_Core_Error::fatal(ts('Version information missing in civicrm codebase.'));
 454     }
 455
 456     // hack to make past ver compatible /w new incremental upgrade process
 457     $convertVer = array(
 458       '2.1' => '2.1.0',
 459       '2.2' => '2.2.alpha1',
 460       '2.2.alph' => '2.2.alpha3',
 461       // since 3.1.1 had domain.version set as 3.1.0
 462       '3.1.0' => '3.1.1',
 463     );
 464     if (isset($convertVer[$currentVer])) {
 465       $currentVer = $convertVer[$currentVer];
 466     }
 467
 468     return array($currentVer, $latestVer);
 469   }
 470
 471   /**
 472    * Determine if $currentVer can be upgraded to $latestVer
 473    *
 474    * @param $currentVer
 475    * @param $latestVer
 476    *
 477    * @return mixed, a string error message or boolean 'false' if OK
 478    */
 479   public function checkUpgradeableVersion($currentVer, $latestVer) {
 480     $error = FALSE;
 481     // since version is suppose to be in valid format at this point, especially after conversion ($convertVer),
 482     // lets do a pattern check -
 483     if (!CRM_Utils_System::isVersionFormatValid($currentVer)) {
 484       $error = ts('Database is marked with invalid version format. You may want to investigate this before you proceed further.');
 485     }
 486     elseif (version_compare($currentVer, $latestVer) > 0) {
 487       // DB version number is higher than codebase being upgraded to. This is unexpected condition-fatal error.
 488       $error = ts('Your database is marked with an unexpected version number: %1. The automated upgrade to version %2 can not be run - and the %2 codebase may not be compatible with your database state. You will need to determine the correct version corresponding to your current database state. You may want to revert to the codebase you were using prior to beginning this upgrade until you resolve this problem.',
 489         array(1 => $currentVer, 2 => $latestVer, 3 => $dbToolsLink)
 490       );
 491     }
 492     elseif (version_compare($currentVer, $latestVer) == 0) {
 493       $error = ts('Your database has already been upgraded to CiviCRM %1',
 494         array(1 => $latestVer)
 495       );
 496     }
 497
 498     $phpVersion = phpversion();
 499     $minPhpVersion = '5.3.3';
 500     if (version_compare($phpVersion, $minPhpVersion) < 0) {
 501       $error = ts('CiviCRM %3 requires PHP version %1 (or newer), but the current system uses %2 ',
 502         array(
 503           1 => $minPhpVersion,
 504           2 => $phpVersion,
 505           3 => $latestVer,
 506         ));
 507     }
 508
 509     // check for mysql trigger privileges
 510     if (!CRM_Core_DAO::checkTriggerViewPermission(FALSE, TRUE)) {
 511       $error = ts('CiviCRM %1 requires MySQL trigger privileges.',
 512         array(1 => $latestVer));
 513     }
 514
 515     if (CRM_Core_DAO::getGlobalSetting('thread_stack', 0) < (1024 * self::MINIMUM_THREAD_STACK)) {
 516       $error = ts('CiviCRM %1 requires MySQL thread stack >= %2k', array(
 517         1 => $latestVer,
 518         2 => self::MINIMUM_THREAD_STACK,
 519       ));
 520     }
 521
 522     return $error;
 523   }
 524
 525   /**
 526    * Determine if $currentver already matches $latestVer
 527    *
 528    * @param $currentVer
 529    * @param $latestVer
 530    *
 531    * @return mixed, a string error message or boolean 'false' if OK
 532    */
 533   public function checkCurrentVersion($currentVer, $latestVer) {
 534     $error = FALSE;
 535
 536     // since version is suppose to be in valid format at this point, especially after conversion ($convertVer),
 537     // lets do a pattern check -
 538     if (!CRM_Utils_System::isVersionFormatValid($currentVer)) {
 539       $error = ts('Database is marked with invalid version format. You may want to investigate this before you proceed further.');
 540     }
 541     elseif (version_compare($currentVer, $latestVer) != 0) {
 542       $error = ts('Your database is not configured for version %1',
 543         array(1 => $latestVer)
 544       );
 545     }
 546     return $error;
 547   }
 548
 549   /**
 550    * Fill the queue with upgrade tasks
 551    *
 552    * @param string $currentVer
 553    *   the original revision.
 554    * @param string $latestVer
 555    *   the target (final) revision.
 556    * @param string $postUpgradeMessageFile
 557    *   path of a modifiable file which lists the post-upgrade messages.
 558    *
 559    * @return CRM_Queue
 560    */
 561   public static function buildQueue($currentVer, $latestVer, $postUpgradeMessageFile) {
 562     $upgrade = new CRM_Upgrade_Form();
 563
 564     // hack to make 4.0.x (D7,J1.6) codebase go through 3.4.x (d6, J1.5) upgrade files,
 565     // since schema wise they are same
 566     if (CRM_Upgrade_Form::getRevisionPart($currentVer) == '4.0') {
 567       $currentVer = str_replace('4.0.', '3.4.', $currentVer);
 568     }
 569
 570     // Ensure that queue can be created
 571     if (!CRM_Queue_BAO_QueueItem::findCreateTable()) {
 572       CRM_Core_Error::fatal(ts('Failed to find or create queueing table'));
 573     }
 574     $queue = CRM_Queue_Service::singleton()->create(array(
 575       'name' => self::QUEUE_NAME,
 576       'type' => 'Sql',
 577       'reset' => TRUE,
 578     ));
 579
 580     $revisions = $upgrade->getRevisionSequence();
 581     foreach ($revisions as $rev) {
 582       // proceed only if $currentVer < $rev
 583       if (version_compare($currentVer, $rev) < 0) {
 584         $beginTask = new CRM_Queue_Task(
 585         // callback
 586           array('CRM_Upgrade_Form', 'doIncrementalUpgradeStart'),
 587           // arguments
 588           array($rev),
 589           "Begin Upgrade to $rev"
 590         );
 591         $queue->createItem($beginTask);
 592
 593         $task = new CRM_Queue_Task(
 594         // callback
 595           array('CRM_Upgrade_Form', 'doIncrementalUpgradeStep'),
 596           // arguments
 597           array($rev, $currentVer, $latestVer, $postUpgradeMessageFile),
 598           "Upgrade DB to $rev"
 599         );
 600         $queue->createItem($task);
 601
 602         $task = new CRM_Queue_Task(
 603         // callback
 604           array('CRM_Upgrade_Form', 'doIncrementalUpgradeFinish'),
 605           // arguments
 606           array($rev, $currentVer, $latestVer, $postUpgradeMessageFile),
 607           "Finish Upgrade DB to $rev"
 608         );
 609         $queue->createItem($task);
 610       }
 611     }
 612
 613     return $queue;
 614   }
 615
 616   /**
 617    * Perform an incremental version update
 618    *
 619    * @param CRM_Queue_TaskContext $ctx
 620    * @param string $rev
 621    *   the target (intermediate) revision e.g '3.2.alpha1'.
 622    *
 623    * @return bool
 624    */
 625   public static function doIncrementalUpgradeStart(CRM_Queue_TaskContext $ctx, $rev) {
 626     $upgrade = new CRM_Upgrade_Form();
 627
 628     // as soon as we start doing anything we append ".upgrade" to version.
 629     // this also helps detect any partial upgrade issues
 630     $upgrade->setVersion($rev . '.upgrade');
 631
 632     return TRUE;
 633   }
 634
 635   /**
 636    * Perform an incremental version update
 637    *
 638    * @param CRM_Queue_TaskContext $ctx
 639    * @param string $rev
 640    *   the target (intermediate) revision e.g '3.2.alpha1'.
 641    * @param string $originalVer
 642    *   the original revision.
 643    * @param string $latestVer
 644    *   the target (final) revision.
 645    * @param string $postUpgradeMessageFile
 646    *   path of a modifiable file which lists the post-upgrade messages.
 647    *
 648    * @return bool
 649    */
 650   public static function doIncrementalUpgradeStep(CRM_Queue_TaskContext $ctx, $rev, $originalVer, $latestVer, $postUpgradeMessageFile) {
 651     $upgrade = new CRM_Upgrade_Form();
 652
 653     $phpFunctionName = 'upgrade_' . str_replace('.', '_', $rev);
 654
 655     $versionObject = $upgrade->incrementalPhpObject($rev);
 656
 657     // pre-db check for major release.
 658     if ($upgrade->checkVersionRelease($rev, 'alpha1')) {
 659       if (!(is_callable(array(
 660         $versionObject,
 661         'verifyPreDBstate',
 662       )))
 663       ) {
 664         CRM_Core_Error::fatal("verifyPreDBstate method was not found for $rev");
 665       }
 666
 667       $error = NULL;
 668       if (!($versionObject->verifyPreDBstate($error))) {
 669         if (!isset($error)) {
 670           $error = "post-condition failed for current upgrade for $rev";
 671         }
 672         CRM_Core_Error::fatal($error);
 673       }
 674
 675     }
 676
 677     $upgrade->setSchemaStructureTables($rev);
 678
 679     if (is_callable(array(
 680       $versionObject,
 681       $phpFunctionName,
 682     ))) {
 683       $versionObject->$phpFunctionName($rev, $originalVer, $latestVer);
 684     }
 685     else {
 686       $upgrade->processSQL($rev);
 687     }
 688
 689     // set post-upgrade-message if any
 690     if (is_callable(array(
 691       $versionObject,
 692       'setPostUpgradeMessage',
 693     ))) {
 694       $postUpgradeMessage = file_get_contents($postUpgradeMessageFile);
 695       $versionObject->setPostUpgradeMessage($postUpgradeMessage, $rev);
 696       file_put_contents($postUpgradeMessageFile, $postUpgradeMessage);
 697     }
 698     else {
 699       $postUpgradeMessage = file_get_contents($postUpgradeMessageFile);
 700       CRM_Upgrade_Incremental_Legacy::setPostUpgradeMessage($postUpgradeMessage, $rev);
 701       file_put_contents($postUpgradeMessageFile, $postUpgradeMessage);
 702     }
 703
 704     return TRUE;
 705   }
 706
 707   /**
 708    * Perform an incremental version update
 709    *
 710    * @param CRM_Queue_TaskContext $ctx
 711    * @param string $rev
 712    *   the target (intermediate) revision e.g '3.2.alpha1'.
 713    * @param string $currentVer
 714    *   the original revision.
 715    * @param string $latestVer
 716    *   the target (final) revision.
 717    * @param string $postUpgradeMessageFile
 718    *   path of a modifiable file which lists the post-upgrade messages.
 719    *
 720    * @return bool
 721    */
 722   public static function doIncrementalUpgradeFinish(CRM_Queue_TaskContext $ctx, $rev, $currentVer, $latestVer, $postUpgradeMessageFile) {
 723     $upgrade = new CRM_Upgrade_Form();
 724     $upgrade->setVersion($rev);
 725     CRM_Utils_System::flushCache();
 726
 727     $config = CRM_Core_Config::singleton();
 728     $config->userSystem->flush();
 729     return TRUE;
 730   }
 731
 732   public static function doFinish() {
 733     $upgrade = new CRM_Upgrade_Form();
 734     list($ignore, $latestVer) = $upgrade->getUpgradeVersions();
 735     // Seems extraneous in context, but we'll preserve old behavior
 736     $upgrade->setVersion($latestVer);
 737
 738     // lets rebuild the config array in case we've made a few changes in the
 739     // code base
 740     // this also helps us always store the latest version of civi in the DB
 741     $params = array();
 742     CRM_Core_BAO_ConfigSetting::add($params);
 743
 744     // CRM-12804 comment-51411 : add any missing settings
 745     // at the end of upgrade
 746     CRM_Core_BAO_Setting::updateSettingsFromMetaData();
 747
 748     // cleanup caches CRM-8739
 749     $config = CRM_Core_Config::singleton();
 750     $config->cleanupCaches(1);
 751
 752     // Rebuild all triggers and re-enable logging if needed
 753     $logging = new CRM_Logging_Schema();
 754     $logging->fixSchemaDifferences();
 755   }
 756
 757   /**
 758    * Compute any messages which should be displayed before upgrade
 759    * by calling the 'setPreUpgradeMessage' on each incremental upgrade
 760    * object.
 761    *
 762    * @param string $preUpgradeMessage
 763    *   alterable.
 764    * @param $currentVer
 765    * @param $latestVer
 766    */
 767   public function setPreUpgradeMessage(&$preUpgradeMessage, $currentVer, $latestVer) {
 768     CRM_Upgrade_Incremental_Legacy::setPreUpgradeMessage($preUpgradeMessage, $currentVer, $latestVer);
 769
 770     // Scan through all php files and see if any file is interested in setting pre-upgrade-message
 771     // based on $currentVer, $latestVer.
 772     // Please note, at this point upgrade hasn't started executing queries.
 773     $revisions = $this->getRevisionSequence();
 774     foreach ($revisions as $rev) {
 775       if (version_compare($currentVer, $rev) < 0 &&
 776         version_compare($rev, '3.2.alpha1') > 0
 777       ) {
 778         $versionObject = $this->incrementalPhpObject($rev);
 779         if (is_callable(array(
 780           $versionObject,
 781           'setPreUpgradeMessage',
 782         ))) {
 783           $versionObject->setPreUpgradeMessage($preUpgradeMessage, $rev, $currentVer);
 784         }
 785       }
 786     }
 787   }
 788
 789 }