CRM/Upgrade/Form.php

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