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.6.12';
  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 string $version
  92    *   Ex: '5.22' or '5.22.3'
  93    *
  94    * @return CRM_Upgrade_Incremental_Base
  95    *   Ex: CRM_Upgrade_Incremental_php_FiveTwentyTwo
  96    */
  97   public static function &incrementalPhpObject($version) {
  98     static $incrementalPhpObject = [];
  99
 100     $versionParts = explode('.', $version);
 101     $versionName = CRM_Utils_EnglishNumber::toCamelCase($versionParts[0]) . CRM_Utils_EnglishNumber::toCamelCase($versionParts[1]);
 102
 103     if (!array_key_exists($versionName, $incrementalPhpObject)) {
 104       $className = "CRM_Upgrade_Incremental_php_{$versionName}";
 105       $incrementalPhpObject[$versionName] = new $className();
 106     }
 107     return $incrementalPhpObject[$versionName];
 108   }
 109
 110   /**
 111    * @return array
 112    *   ex: ['5.13', '5.14', '5.15']
 113    */
 114   public static function incrementalPhpObjectVersions() {
 115     $versions = [];
 116
 117     $phpDir = implode(DIRECTORY_SEPARATOR, [dirname(__FILE__), 'Incremental', 'php']);
 118     $phpFiles = glob("$phpDir/*.php");
 119     foreach ($phpFiles as $phpFile) {
 120       $phpWord = substr(basename($phpFile), 0, -4);
 121       if (CRM_Utils_EnglishNumber::isNumeric($phpWord)) {
 122         /** @var \CRM_Upgrade_Incremental_Base $instance */
 123         $className = 'CRM_Upgrade_Incremental_php_' . $phpWord;
 124         $instance = new $className();
 125         $versions[] = $instance->getMajorMinor();
 126       }
 127     }
 128
 129     usort($versions, 'version_compare');
 130     return $versions;
 131   }
 132
 133   /**
 134    * @param $version
 135    * @param $release
 136    *
 137    * @return bool
 138    */
 139   public function checkVersionRelease($version, $release) {
 140     $versionParts = explode('.', $version);
 141     return ($versionParts[2] == $release);
 142   }
 143
 144   /**
 145    * @param $constraints
 146    *
 147    * @return array
 148    */
 149   public function checkSQLConstraints(&$constraints) {
 150     $pass = $fail = 0;
 151     foreach ($constraints as $constraint) {
 152       if ($this->checkSQLConstraint($constraint)) {
 153         $pass++;
 154       }
 155       else {
 156         $fail++;
 157       }
 158       return [$pass, $fail];
 159     }
 160   }
 161
 162   /**
 163    * @param $constraint
 164    *
 165    * @return bool
 166    */
 167   public function checkSQLConstraint($constraint) {
 168     // check constraint here
 169     return TRUE;
 170   }
 171
 172   /**
 173    * @param string $fileName
 174    * @param bool $isQueryString
 175    */
 176   public function source($fileName, $isQueryString = FALSE) {
 177     if ($isQueryString) {
 178       CRM_Utils_File::runSqlQuery($this->_config->dsn,
 179         $fileName, NULL
 180       );
 181     }
 182     else {
 183       CRM_Utils_File::sourceSQLFile($this->_config->dsn,
 184         $fileName, NULL
 185       );
 186     }
 187   }
 188
 189   public function preProcess() {
 190     $this->setTitle($this->getTitle());
 191     if (!$this->verifyPreDBState($errorMessage)) {
 192       if (!isset($errorMessage)) {
 193         $errorMessage = 'pre-condition failed for current upgrade step';
 194       }
 195       throw new CRM_Core_Exception($errorMessage);
 196     }
 197     $this->assign('recentlyViewed', FALSE);
 198   }
 199
 200   public function buildQuickForm() {
 201     $this->addDefaultButtons($this->getButtonTitle(),
 202       'next',
 203       NULL,
 204       TRUE
 205     );
 206   }
 207
 208   /**
 209    * Getter function for title. Should be over-ridden by derived class
 210    *
 211    * @return string
 212    */
 213
 214   /**
 215    * @return string
 216    */
 217   public function getTitle() {
 218     return ts('Title not Set');
 219   }
 220
 221   /**
 222    * @return string
 223    */
 224   public function getFieldsetTitle() {
 225     return '';
 226   }
 227
 228   /**
 229    * @return string
 230    */
 231   public function getButtonTitle() {
 232     return ts('Continue');
 233   }
 234
 235   /**
 236    * Use the form name to create the tpl file name.
 237    *
 238    * @return string
 239    */
 240
 241   /**
 242    * @return string
 243    */
 244   public function getTemplateFileName() {
 245     $this->assign('title',
 246       $this->getFieldsetTitle()
 247     );
 248     $this->assign('message',
 249       $this->getTemplateMessage()
 250     );
 251     return 'CRM/Upgrade/Base.tpl';
 252   }
 253
 254   public function postProcess() {
 255     $this->upgrade();
 256
 257     if (!$this->verifyPostDBState($errorMessage)) {
 258       if (!isset($errorMessage)) {
 259         $errorMessage = 'post-condition failed for current upgrade step';
 260       }
 261       throw new CRM_Core_Exception($errorMessage);
 262     }
 263   }
 264
 265   /**
 266    * @param $version
 267    *
 268    * @return Object
 269    */
 270   public function setVersion($version) {
 271     $this->logVersion($version);
 272
 273     $query = "
 274 UPDATE civicrm_domain
 275 SET    version = '$version'
 276 ";
 277     return CRM_Core_DAO::executeQuery($query);
 278   }
 279
 280   /**
 281    * @param $newVersion
 282    *
 283    * @return bool
 284    */
 285   public function logVersion($newVersion) {
 286     if ($newVersion) {
 287       $oldVersion = CRM_Core_BAO_Domain::version();
 288
 289       $session = CRM_Core_Session::singleton();
 290       $logParams = [
 291         'entity_table' => 'civicrm_domain',
 292         'entity_id' => 1,
 293         'data' => "upgrade:{$oldVersion}->{$newVersion}",
 294         // lets skip 'modified_id' for now, as it causes FK issues And
 295         // is not very important for now.
 296         'modified_date' => date('YmdHis'),
 297       ];
 298       CRM_Core_BAO_Log::add($logParams);
 299       return TRUE;
 300     }
 301
 302     return FALSE;
 303   }
 304
 305   /**
 306    * Get a list of all patch-versions that appear in upgrade steps, whether
 307    * as *.mysql.tpl or as *.php.
 308    *
 309    * @return array
 310    * @throws Exception
 311    */
 312   public function getRevisionSequence() {
 313     $revList = [];
 314
 315     foreach (self::incrementalPhpObjectVersions() as $majorMinor) {
 316       $phpUpgrader = self::incrementalPhpObject($majorMinor);
 317       $revList = array_merge($revList, array_values($phpUpgrader->getRevisionSequence()));
 318     }
 319
 320     usort($revList, 'version_compare');
 321     return $revList;
 322   }
 323
 324   /**
 325    * @param $tplFile
 326    * @param $rev
 327    *
 328    * @return bool
 329    */
 330   public function processLocales($tplFile, $rev) {
 331     $smarty = CRM_Core_Smarty::singleton();
 332     $smarty->assign('domainID', CRM_Core_Config::domainID());
 333
 334     $this->source($smarty->fetch($tplFile), TRUE);
 335
 336     if ($this->multilingual) {
 337       CRM_Core_I18n_Schema::rebuildMultilingualSchema($this->locales, $rev);
 338     }
 339     return $this->multilingual;
 340   }
 341
 342   /**
 343    * @param $rev
 344    */
 345   public function setSchemaStructureTables($rev) {
 346     if ($this->multilingual) {
 347       CRM_Core_I18n_Schema::schemaStructureTables($rev, TRUE);
 348     }
 349   }
 350
 351   /**
 352    * @param $rev
 353    *
 354    * @throws Exception
 355    */
 356   public function processSQL($rev) {
 357     $sqlFile = implode(DIRECTORY_SEPARATOR,
 358       [
 359         dirname(__FILE__),
 360         'Incremental',
 361         'sql',
 362         $rev . '.mysql',
 363       ]
 364     );
 365     $tplFile = "$sqlFile.tpl";
 366
 367     if (file_exists($tplFile)) {
 368       $this->processLocales($tplFile, $rev);
 369     }
 370     else {
 371       if (!file_exists($sqlFile)) {
 372         throw new CRM_Core_Exception("sqlfile - $rev.mysql not found.");
 373       }
 374       $this->source($sqlFile);
 375     }
 376   }
 377
 378   /**
 379    * Determine the start and end version of the upgrade process.
 380    *
 381    * @return array(0=>$currentVer, 1=>$latestVer)
 382    */
 383   public function getUpgradeVersions() {
 384     $latestVer = CRM_Utils_System::version();
 385     $currentVer = CRM_Core_BAO_Domain::version(TRUE);
 386     if (!$currentVer) {
 387       throw new CRM_Core_Exception(ts('Version information missing in civicrm database.'));
 388     }
 389     elseif (stripos($currentVer, 'upgrade')) {
 390       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.'));
 391     }
 392     if (!$latestVer) {
 393       throw new CRM_Core_Exception(ts('Version information missing in civicrm codebase.'));
 394     }
 395
 396     return [$currentVer, $latestVer];
 397   }
 398
 399   /**
 400    * Determine if $currentVer can be upgraded to $latestVer
 401    *
 402    * @param $currentVer
 403    * @param $latestVer
 404    *
 405    * @return mixed, a string error message or boolean 'false' if OK
 406    */
 407   public function checkUpgradeableVersion($currentVer, $latestVer) {
 408     $error = FALSE;
 409     // since version is suppose to be in valid format at this point, especially after conversion ($convertVer),
 410     // lets do a pattern check -
 411     if (!CRM_Utils_System::isVersionFormatValid($currentVer)) {
 412       $error = ts('Database is marked with invalid version format. You may want to investigate this before you proceed further.');
 413     }
 414     elseif (version_compare($currentVer, $latestVer) > 0) {
 415       // DB version number is higher than codebase being upgraded to. This is unexpected condition-fatal error.
 416       $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.',
 417         [1 => $currentVer, 2 => $latestVer]
 418       );
 419     }
 420     elseif (version_compare($currentVer, $latestVer) == 0) {
 421       $error = ts('Your database has already been upgraded to CiviCRM %1',
 422         [1 => $latestVer]
 423       );
 424     }
 425     elseif (version_compare($currentVer, self::MINIMUM_UPGRADABLE_VERSION) < 0) {
 426       $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.',
 427         [1 => self::MINIMUM_UPGRADABLE_VERSION, 2 => $latestVer]
 428       );
 429     }
 430
 431     if (version_compare(phpversion(), CRM_Upgrade_Incremental_General::MIN_INSTALL_PHP_VER) < 0) {
 432       $error = ts('CiviCRM %3 requires PHP version %1 (or newer), but the current system uses %2 ',
 433         [
 434           1 => CRM_Upgrade_Incremental_General::MIN_INSTALL_PHP_VER,
 435           2 => phpversion(),
 436           3 => $latestVer,
 437         ]);
 438     }
 439
 440     if (version_compare(CRM_Utils_SQL::getDatabaseVersion(), CRM_Upgrade_Incremental_General::MIN_INSTALL_MYSQL_VER) < 0) {
 441       $error = ts('CiviCRM %4 requires MySQL version v%1 or MariaDB v%3 (or newer), but the current system uses %2 ',
 442         [
 443           1 => CRM_Upgrade_Incremental_General::MIN_INSTALL_MYSQL_VER,
 444           2 => CRM_Utils_SQL::getDatabaseVersion(),
 445           3 => '10.1',
 446           4 => $latestVer,
 447         ]);
 448     }
 449
 450     // check for mysql trigger privileges
 451     if (!\Civi::settings()->get('logging_no_trigger_permission') && !CRM_Core_DAO::checkTriggerViewPermission(FALSE, TRUE)) {
 452       $error = ts('CiviCRM %1 requires MySQL trigger privileges.',
 453         [1 => $latestVer]);
 454     }
 455
 456     if (CRM_Core_DAO::getGlobalSetting('thread_stack', 0) < (1024 * self::MINIMUM_THREAD_STACK)) {
 457       $error = ts('CiviCRM %1 requires MySQL thread stack >= %2k', [
 458         1 => $latestVer,
 459         2 => self::MINIMUM_THREAD_STACK,
 460       ]);
 461     }
 462
 463     return $error;
 464   }
 465
 466   /**
 467    * Determine if $currentver already matches $latestVer
 468    *
 469    * @param $currentVer
 470    * @param $latestVer
 471    *
 472    * @return mixed, a string error message or boolean 'false' if OK
 473    */
 474   public function checkCurrentVersion($currentVer, $latestVer) {
 475     $error = FALSE;
 476
 477     // since version is suppose to be in valid format at this point, especially after conversion ($convertVer),
 478     // lets do a pattern check -
 479     if (!CRM_Utils_System::isVersionFormatValid($currentVer)) {
 480       $error = ts('Database is marked with invalid version format. You may want to investigate this before you proceed further.');
 481     }
 482     elseif (version_compare($currentVer, $latestVer) != 0) {
 483       $error = ts('Your database is not configured for version %1',
 484         [1 => $latestVer]
 485       );
 486     }
 487     return $error;
 488   }
 489
 490   /**
 491    * Fill the queue with upgrade tasks.
 492    *
 493    * The queue is a priority-queue (sorted by tuple weight+id). Here are some common weights:
 494    *
 495    * - `weight=0`: Add a typical upgrade step for revising core schema.
 496    * - `weight=-1`: In the middle of the upgrade, add an extra step for immediate execution.
 497    * - `weight=1000`: Add some general core upgrade-logic that runs after all schema have change.d
 498    * - `weight=2000`: Add some post-upgrade logic. If a task absolutely requires full system services
 499    *    (eg enabling a new extension), then place it here.
 500    *
 501    * @param string $currentVer
 502    *   the original revision.
 503    * @param string $latestVer
 504    *   the target (final) revision.
 505    * @param string $postUpgradeMessageFile
 506    *   path of a modifiable file which lists the post-upgrade messages.
 507    *
 508    * @return CRM_Queue_Service
 509    */
 510   public static function buildQueue($currentVer, $latestVer, $postUpgradeMessageFile) {
 511     $upgrade = new CRM_Upgrade_Form();
 512
 513     // Ensure that queue can be created
 514     if (!CRM_Queue_BAO_QueueItem::findCreateTable()) {
 515       throw new CRM_Core_Exception(ts('Failed to find or create queueing table'));
 516     }
 517     $queue = CRM_Queue_Service::singleton()->create([
 518       'name' => self::QUEUE_NAME,
 519       'type' => 'Sql',
 520       'reset' => TRUE,
 521     ]);
 522
 523     $task = new CRM_Queue_Task(
 524       ['CRM_Upgrade_Form', 'doFileCleanup'],
 525       [$postUpgradeMessageFile],
 526       "Cleanup old files"
 527     );
 528     $queue->createItem($task, ['weight' => 0]);
 529
 530     $task = new CRM_Queue_Task(
 531       ['CRM_Upgrade_Form', 'disableOldExtensions'],
 532       [$postUpgradeMessageFile],
 533       "Checking extensions"
 534     );
 535     $queue->createItem($task, ['weight' => 0]);
 536
 537     $revisions = $upgrade->getRevisionSequence();
 538     $maxRevision = empty($revisions) ? NULL : end($revisions);
 539     reset($revisions);
 540     if (version_compare($latestVer, $maxRevision, '<')) {
 541       throw new CRM_Core_Exception("Malformed upgrade sequence.  The incremental update $maxRevision exceeds target version $latestVer");
 542     }
 543
 544     foreach ($revisions as $rev) {
 545       // proceed only if $currentVer < $rev
 546       if (version_compare($currentVer, $rev) < 0) {
 547         $beginTask = new CRM_Queue_Task(
 548         // callback
 549           ['CRM_Upgrade_Form', 'doIncrementalUpgradeStart'],
 550           // arguments
 551           [$rev],
 552           "Begin Upgrade to $rev"
 553         );
 554         $queue->createItem($beginTask, ['weight' => 0]);
 555
 556         $task = new CRM_Queue_Task(
 557         // callback
 558           ['CRM_Upgrade_Form', 'doIncrementalUpgradeStep'],
 559           // arguments
 560           [$rev, $currentVer, $latestVer, $postUpgradeMessageFile],
 561           "Upgrade DB to $rev"
 562         );
 563         $queue->createItem($task, ['weight' => 0]);
 564
 565         $task = new CRM_Queue_Task(
 566         // callback
 567           ['CRM_Upgrade_Form', 'doIncrementalUpgradeFinish'],
 568           // arguments
 569           [$rev, $currentVer, $latestVer, $postUpgradeMessageFile],
 570           "Finish Upgrade DB to $rev"
 571         );
 572         $queue->createItem($task, ['weight' => 0]);
 573       }
 574     }
 575
 576     // It's possible that xml/version.xml points to a version that doesn't have any concrete revision steps.
 577     if (!in_array($latestVer, $revisions)) {
 578       $task = new CRM_Queue_Task(
 579         ['CRM_Upgrade_Form', 'doIncrementalUpgradeFinish'],
 580         [$rev, $latestVer, $latestVer, $postUpgradeMessageFile],
 581         "Finish Upgrade DB to $latestVer"
 582       );
 583       $queue->createItem($task, ['weight' => 0]);
 584     }
 585
 586     $task = new CRM_Queue_Task(
 587       ['CRM_Upgrade_Form', 'doCoreFinish'],
 588       [$rev, $latestVer, $latestVer, $postUpgradeMessageFile],
 589       "Finish core DB updates $latestVer"
 590     );
 591     $queue->createItem($task, ['weight' => 1000]);
 592
 593     return $queue;
 594   }
 595
 596   /**
 597    * Find any old, orphaned files that should have been deleted.
 598    *
 599    * These files can get left behind, eg, if you use the Joomla
 600    * upgrade procedure.
 601    *
 602    * The earlier we can do this, the better - don't want upgrade logic
 603    * to inadvertently rely on old/relocated files.
 604    *
 605    * @param \CRM_Queue_TaskContext $ctx
 606    * @param string $postUpgradeMessageFile
 607    * @return bool
 608    */
 609   public static function doFileCleanup(CRM_Queue_TaskContext $ctx, $postUpgradeMessageFile) {
 610     $source = new CRM_Utils_Check_Component_Source();
 611     $files = $source->findOrphanedFiles();
 612     $errors = [];
 613     foreach ($files as $file) {
 614       if (is_dir($file['path'])) {
 615         @rmdir($file['path']);
 616       }
 617       else {
 618         @unlink($file['path']);
 619       }
 620
 621       if (file_exists($file['path'])) {
 622         $errors[] = sprintf("<li>%s</li>", htmlentities($file['path']));
 623       }
 624     }
 625
 626     if (!empty($errors)) {
 627       file_put_contents($postUpgradeMessageFile,
 628         '<br/><br/>' . ts('Some old files could not be removed. Please remove them.')
 629         . '<ul>' . implode("\n", $errors) . '</ul>',
 630         FILE_APPEND
 631       );
 632     }
 633
 634     return TRUE;
 635   }
 636
 637   /**
 638    * Disable/uninstall any extensions not compatible with this new version.
 639    *
 640    * @param \CRM_Queue_TaskContext $ctx
 641    * @param string $postUpgradeMessageFile
 642    * @return bool
 643    */
 644   public static function disableOldExtensions(CRM_Queue_TaskContext $ctx, $postUpgradeMessageFile) {
 645     $messages = [];
 646     $manager = CRM_Extension_System::singleton()->getManager();
 647     foreach ($manager->getStatuses() as $key => $status) {
 648       $enableReplacement = CRM_Core_DAO::singleValueQuery('SELECT is_active FROM civicrm_extension WHERE full_name = %1', [1 => [$key, 'String']]);
 649       $obsolete = $manager->isIncompatible($key);
 650       if ($obsolete) {
 651         if (!empty($obsolete['disable']) && in_array($status, [$manager::STATUS_INSTALLED, $manager::STATUS_INSTALLED_MISSING])) {
 652           try {
 653             $manager->disable($key);
 654             // Update the status for the sake of uninstall below.
 655             $status = $status == $manager::STATUS_INSTALLED ? $manager::STATUS_DISABLED : $manager::STATUS_DISABLED_MISSING;
 656             // This message is intentionally overwritten by uninstall below as it would be redundant
 657             $messages[$key] = ts('The extension %1 is now obsolete and has been disabled.', [1 => $key]);
 658           }
 659           catch (CRM_Extension_Exception $e) {
 660             $messages[] = ts('The obsolete extension %1 could not be removed due to an error. It is recommended to remove this extension manually.', [1 => $key]);
 661           }
 662         }
 663         if (!empty($obsolete['uninstall']) && in_array($status, [$manager::STATUS_DISABLED, $manager::STATUS_DISABLED_MISSING])) {
 664           try {
 665             $manager->uninstall($key);
 666             $messages[$key] = ts('The extension %1 is now obsolete and has been uninstalled.', [1 => $key]);
 667             if ($status == $manager::STATUS_DISABLED) {
 668               $messages[$key] .= ' ' . ts('You can remove it from your extensions directory.');
 669             }
 670           }
 671           catch (CRM_Extension_Exception $e) {
 672             $messages[] = ts('The obsolete extension %1 could not be removed due to an error. It is recommended to remove this extension manually.', [1 => $key]);
 673           }
 674         }
 675         if (!empty($obsolete['force-uninstall'])) {
 676           CRM_Core_DAO::executeQuery('UPDATE civicrm_extension SET is_active = 0 WHERE full_name = %1', [
 677             1 => [$key, 'String'],
 678           ]);
 679         }
 680         if (!empty($obsolete['replacement']) && $enableReplacement) {
 681           try {
 682             $manager->enable($manager->install($obsolete['replacement']));
 683             $messages[] = ts('A replacement extension %1 has been installed as you had the obsolete extension %2 installed', [1 => $obsolete['replacement'], 2 => $key]);
 684           }
 685           catch (CRM_Extension_Exception $e) {
 686             $messages[] = ts('The replacement extension %1 could not be installed due to an error. It is recommended to enable this extension manually.', [1 => $obsolete['replacement']]);
 687           }
 688         }
 689       }
 690     }
 691     if ($messages) {
 692       file_put_contents($postUpgradeMessageFile,
 693         '<br/><br/><ul><li>' . implode("</li>\n<li>", $messages) . '</li></ul>',
 694         FILE_APPEND
 695       );
 696     }
 697
 698     return TRUE;
 699   }
 700
 701   /**
 702    * Perform an incremental version update.
 703    *
 704    * @param CRM_Queue_TaskContext $ctx
 705    * @param string $rev
 706    *   the target (intermediate) revision e.g '3.2.alpha1'.
 707    *
 708    * @return bool
 709    */
 710   public static function doIncrementalUpgradeStart(CRM_Queue_TaskContext $ctx, $rev) {
 711     $upgrade = new CRM_Upgrade_Form();
 712
 713     // as soon as we start doing anything we append ".upgrade" to version.
 714     // this also helps detect any partial upgrade issues
 715     $upgrade->setVersion($rev . '.upgrade');
 716
 717     return TRUE;
 718   }
 719
 720   /**
 721    * Perform an incremental version update.
 722    *
 723    * @param CRM_Queue_TaskContext $ctx
 724    * @param string $rev
 725    *   the target (intermediate) revision e.g '3.2.alpha1'.
 726    * @param string $originalVer
 727    *   the original revision.
 728    * @param string $latestVer
 729    *   the target (final) revision.
 730    * @param string $postUpgradeMessageFile
 731    *   path of a modifiable file which lists the post-upgrade messages.
 732    *
 733    * @return bool
 734    */
 735   public static function doIncrementalUpgradeStep(CRM_Queue_TaskContext $ctx, $rev, $originalVer, $latestVer, $postUpgradeMessageFile) {
 736     $upgrade = new CRM_Upgrade_Form();
 737
 738     $phpFunctionName = 'upgrade_' . str_replace('.', '_', $rev);
 739
 740     $versionObject = $upgrade->incrementalPhpObject($rev);
 741
 742     $upgrade->setSchemaStructureTables($rev);
 743
 744     if (is_callable([$versionObject, $phpFunctionName])) {
 745       $versionObject->$phpFunctionName($rev, $originalVer, $latestVer);
 746     }
 747     else {
 748       $ctx->log->info("Upgrade DB to $rev: SQL");
 749       $upgrade->processSQL($rev);
 750     }
 751
 752     // set post-upgrade-message if any
 753     if (is_callable([$versionObject, 'setPostUpgradeMessage'])) {
 754       $postUpgradeMessage = file_get_contents($postUpgradeMessageFile);
 755       $versionObject->setPostUpgradeMessage($postUpgradeMessage, $rev);
 756       file_put_contents($postUpgradeMessageFile, $postUpgradeMessage);
 757     }
 758
 759     return TRUE;
 760   }
 761
 762   /**
 763    * Mark an incremental update as finished.
 764    *
 765    * This method may be called in two cases:
 766    *
 767    * - After performing each incremental update (`X.X.X.mysql.tpl` or `upgrade_X_X_X()`)
 768    * - If needed, one more time at the end of the upgrade for the final version-number.
 769    *
 770    * @param CRM_Queue_TaskContext $ctx
 771    * @param string $rev
 772    *   the target (intermediate) revision e.g '3.2.alpha1'.
 773    * @param string $currentVer
 774    *   the original revision.
 775    * @param string $latestVer
 776    *   the target (final) revision.
 777    * @param string $postUpgradeMessageFile
 778    *   path of a modifiable file which lists the post-upgrade messages.
 779    *
 780    * @return bool
 781    */
 782   public static function doIncrementalUpgradeFinish(CRM_Queue_TaskContext $ctx, $rev, $currentVer, $latestVer, $postUpgradeMessageFile) {
 783     $upgrade = new CRM_Upgrade_Form();
 784     $upgrade->setVersion($rev);
 785     CRM_Utils_System::flushCache();
 786
 787     return TRUE;
 788   }
 789
 790   /**
 791    * Finalize the core upgrade.
 792    *
 793    * @return bool
 794    * @throws \CRM_Core_Exception
 795    */
 796   public static function doCoreFinish(): bool {
 797     Civi::dispatcher()->setDispatchPolicy(\CRM_Upgrade_DispatchPolicy::get('upgrade.finish'));
 798     $restore = \CRM_Utils_AutoClean::with(function() {
 799       Civi::dispatcher()->setDispatchPolicy(\CRM_Upgrade_DispatchPolicy::get('upgrade.main'));
 800     });
 801
 802     $upgrade = new CRM_Upgrade_Form();
 803     list($ignore, $latestVer) = $upgrade->getUpgradeVersions();
 804     // Seems extraneous in context, but we'll preserve old behavior
 805     $upgrade->setVersion($latestVer);
 806
 807     $config = CRM_Core_Config::singleton();
 808     $config->userSystem->flush();
 809
 810     CRM_Core_Invoke::rebuildMenuAndCaches(FALSE, FALSE);
 811     // NOTE: triggerRebuild is FALSE becaues it will run again in a moment (via fixSchemaDifferences).
 812     // sessionReset is FALSE because upgrade status/postUpgradeMessages are needed by the Page. We reset later in doFinish().
 813
 814     $versionCheck = new CRM_Utils_VersionCheck();
 815     $versionCheck->flushCache();
 816
 817     // Rebuild all triggers and re-enable logging if needed
 818     $logging = new CRM_Logging_Schema();
 819     $logging->fixSchemaDifferences();
 820     // Force a rebuild of CiviCRM asset cache in case things have changed.
 821     \Civi::service('asset_builder')->clear(FALSE);
 822
 823     return TRUE;
 824   }
 825
 826   /**
 827    * After finishing the queue, the upgrade-runner calls `doFinish()`.
 828    *
 829    * This is called by all upgrade-runners (inside or outside of `civicrm-core.git`).
 830    * Removing it would be a breaky-annoying process; it would foreclose future use;
 831    * and it would produce no tangible benefits.
 832    *
 833    * @return bool
 834    */
 835   public static function doFinish(): bool {
 836     $session = CRM_Core_Session::singleton();
 837     $session->reset(2);
 838     return TRUE;
 839   }
 840
 841   /**
 842    * Compute any messages which should be displayed before upgrade
 843    * by calling the 'setPreUpgradeMessage' on each incremental upgrade
 844    * object.
 845    *
 846    * @param string $preUpgradeMessage
 847    *   alterable.
 848    * @param $currentVer
 849    * @param $latestVer
 850    */
 851   public function setPreUpgradeMessage(&$preUpgradeMessage, $currentVer, $latestVer) {
 852     // check for changed message templates
 853     CRM_Upgrade_Incremental_General::checkMessageTemplate($preUpgradeMessage, $latestVer, $currentVer);
 854     // set global messages
 855     CRM_Upgrade_Incremental_General::setPreUpgradeMessage($preUpgradeMessage, $currentVer, $latestVer);
 856
 857     // Scan through all php files and see if any file is interested in setting pre-upgrade-message
 858     // based on $currentVer, $latestVer.
 859     // Please note, at this point upgrade hasn't started executing queries.
 860     $revisions = $this->getRevisionSequence();
 861     foreach ($revisions as $rev) {
 862       if (version_compare($currentVer, $rev) < 0) {
 863         $versionObject = $this->incrementalPhpObject($rev);
 864         CRM_Upgrade_Incremental_General::updateMessageTemplate($preUpgradeMessage, $rev);
 865         if (is_callable([$versionObject, 'setPreUpgradeMessage'])) {
 866           $versionObject->setPreUpgradeMessage($preUpgradeMessage, $rev, $currentVer);
 867         }
 868       }
 869     }
 870   }
 871
 872 }