CRM/Upgrade/Form.php

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