CRM/Upgrade/Form.php

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