src/Replication/ReplicationGui.php

   1 <?php
   2 /**
   3  * Functions for the replication GUI
   4  */
   5
   6 declare(strict_types=1);
   7
   8 namespace PhpMyAdmin\Replication;
   9
  10 use PhpMyAdmin\Config;
  11 use PhpMyAdmin\DatabaseInterface;
  12 use PhpMyAdmin\Dbal\ConnectionType;
  13 use PhpMyAdmin\Message;
  14 use PhpMyAdmin\Query\Utilities;
  15 use PhpMyAdmin\ResponseRenderer;
  16 use PhpMyAdmin\Template;
  17 use PhpMyAdmin\Url;
  18 use PhpMyAdmin\Util;
  19
  20 use function __;
  21 use function htmlspecialchars;
  22 use function in_array;
  23 use function mb_strrpos;
  24 use function mb_strtolower;
  25 use function mb_substr;
  26 use function sprintf;
  27 use function str_replace;
  28 use function strtok;
  29 use function time;
  30
  31 /**
  32  * Functions for the replication GUI
  33  */
  34 class ReplicationGui
  35 {
  36     public function __construct(private Replication $replication, private Template $template)
  37     {
  38     }
  39
  40     /**
  41      * returns HTML for error message
  42      *
  43      * @return string HTML code
  44      */
  45     public function getHtmlForErrorMessage(): string
  46     {
  47         $html = '';
  48         if (isset($_SESSION['replication']['sr_action_status'], $_SESSION['replication']['sr_action_info'])) {
  49             if ($_SESSION['replication']['sr_action_status'] === 'error') {
  50                 $errorMessage = $_SESSION['replication']['sr_action_info'];
  51                 $html .= Message::error($errorMessage)->getDisplay();
  52                 $_SESSION['replication']['sr_action_status'] = 'unknown';
  53             } elseif ($_SESSION['replication']['sr_action_status'] === 'success') {
  54                 $successMessage = $_SESSION['replication']['sr_action_info'];
  55                 $html .= Message::success($successMessage)->getDisplay();
  56                 $_SESSION['replication']['sr_action_status'] = 'unknown';
  57             }
  58         }
  59
  60         return $html;
  61     }
  62
  63     /**
  64      * returns HTML for primary replication
  65      *
  66      * @return string HTML code
  67      */
  68     public function getHtmlForPrimaryReplication(
  69         string|null $connection,
  70         bool $hasReplicaClearScreen,
  71         string|null $primaryAddUser,
  72         string|null $username,
  73         string|null $hostname,
  74     ): string {
  75         if (! $hasReplicaClearScreen) {
  76             $primaryStatusTable = $this->getHtmlForReplicationStatusTable($connection, 'primary', true, false);
  77             $replicas = DatabaseInterface::getInstance()->fetchResult('SHOW SLAVE HOSTS');
  78
  79             $urlParams = $GLOBALS['urlParams'];
  80             $urlParams['primary_add_user'] = true;
  81             $urlParams['replica_clear_screen'] = true;
  82         }
  83
  84         if ($primaryAddUser !== null) {
  85             $primaryAddReplicaUser = $this->getHtmlForReplicationPrimaryAddReplicaUser($username, $hostname);
  86         }
  87
  88         return $this->template->render('server/replication/primary_replication', [
  89             'clear_screen' => $hasReplicaClearScreen,
  90             'primary_status_table' => $primaryStatusTable ?? '',
  91             'replicas' => $replicas ?? [],
  92             'url_params' => $urlParams ?? [],
  93             'primary_add_user' => $primaryAddUser !== null,
  94             'primary_add_replica_user' => $primaryAddReplicaUser ?? '',
  95         ]);
  96     }
  97
  98     /**
  99      * returns HTML for primary replication configuration
 100      *
 101      * @return string HTML code
 102      */
 103     public function getHtmlForPrimaryConfiguration(): string
 104     {
 105         $databaseMultibox = $this->getHtmlForReplicationDbMultibox();
 106
 107         return $this->template->render(
 108             'server/replication/primary_configuration',
 109             ['database_multibox' => $databaseMultibox],
 110         );
 111     }
 112
 113     /**
 114      * returns HTML for replica replication configuration
 115      *
 116      * @param string|null $connection               Primary connection
 117      * @param bool        $serverReplicaStatus      Whether it is Primary or Replica
 118      * @param mixed[]     $serverReplicaReplication Replica replication
 119      * @param bool        $replicaConfigure         Replica configure
 120      *
 121      * @return string HTML code
 122      */
 123     public function getHtmlForReplicaConfiguration(
 124         string|null $connection,
 125         bool $serverReplicaStatus,
 126         array $serverReplicaReplication,
 127         bool $replicaConfigure,
 128     ): string {
 129         $serverReplicaMultiReplication = DatabaseInterface::getInstance()->fetchResult('SHOW ALL SLAVES STATUS');
 130         if ($serverReplicaStatus) {
 131             $urlParams = $GLOBALS['urlParams'];
 132             $urlParams['sr_take_action'] = true;
 133             $urlParams['sr_replica_server_control'] = true;
 134
 135             if ($serverReplicaReplication[0]['Slave_IO_Running'] === 'No') {
 136                 $urlParams['sr_replica_action'] = 'start';
 137             } else {
 138                 $urlParams['sr_replica_action'] = 'stop';
 139             }
 140
 141             $urlParams['sr_replica_control_param'] = 'IO_THREAD';
 142             $replicaControlIoLink = Url::getCommon($urlParams, '', false);
 143
 144             if ($serverReplicaReplication[0]['Slave_SQL_Running'] === 'No') {
 145                 $urlParams['sr_replica_action'] = 'start';
 146             } else {
 147                 $urlParams['sr_replica_action'] = 'stop';
 148             }
 149
 150             $urlParams['sr_replica_control_param'] = 'SQL_THREAD';
 151             $replicaControlSqlLink = Url::getCommon($urlParams, '', false);
 152
 153             if (
 154                 $serverReplicaReplication[0]['Slave_IO_Running'] === 'No'
 155                 || $serverReplicaReplication[0]['Slave_SQL_Running'] === 'No'
 156             ) {
 157                 $urlParams['sr_replica_action'] = 'start';
 158             } else {
 159                 $urlParams['sr_replica_action'] = 'stop';
 160             }
 161
 162             $urlParams['sr_replica_control_param'] = null;
 163             $replicaControlFullLink = Url::getCommon($urlParams, '', false);
 164
 165             $urlParams['sr_replica_action'] = 'reset';
 166             $replicaControlResetLink = Url::getCommon($urlParams, '', false);
 167
 168             $urlParams = $GLOBALS['urlParams'];
 169             $urlParams['sr_take_action'] = true;
 170             $urlParams['sr_replica_skip_error'] = true;
 171             $replicaSkipErrorLink = Url::getCommon($urlParams, '', false);
 172
 173             $urlParams = $GLOBALS['urlParams'];
 174             $urlParams['replica_configure'] = true;
 175             $urlParams['replica_clear_screen'] = true;
 176
 177             $reconfigurePrimaryLink = Url::getCommon($urlParams, '', false);
 178
 179             $replicaStatusTable = $this->getHtmlForReplicationStatusTable($connection, 'replica', true, false);
 180
 181             $replicaIoRunning = $serverReplicaReplication[0]['Slave_IO_Running'] !== 'No';
 182             $replicaSqlRunning = $serverReplicaReplication[0]['Slave_SQL_Running'] !== 'No';
 183         }
 184
 185         return $this->template->render('server/replication/replica_configuration', [
 186             'server_replica_multi_replication' => $serverReplicaMultiReplication,
 187             'url_params' => $GLOBALS['urlParams'],
 188             'primary_connection' => $connection ?? '',
 189             'server_replica_status' => $serverReplicaStatus,
 190             'replica_status_table' => $replicaStatusTable ?? '',
 191             'replica_sql_running' => $replicaSqlRunning ?? false,
 192             'replica_io_running' => $replicaIoRunning ?? false,
 193             'replica_control_full_link' => $replicaControlFullLink ?? '',
 194             'replica_control_reset_link' => $replicaControlResetLink ?? '',
 195             'replica_control_sql_link' => $replicaControlSqlLink ?? '',
 196             'replica_control_io_link' => $replicaControlIoLink ?? '',
 197             'replica_skip_error_link' => $replicaSkipErrorLink ?? '',
 198             'reconfigure_primary_link' => $reconfigurePrimaryLink ?? '',
 199             'has_replica_configure' => $replicaConfigure,
 200         ]);
 201     }
 202
 203     /**
 204      * returns HTML code for selecting databases
 205      *
 206      * @return string HTML code
 207      */
 208     public function getHtmlForReplicationDbMultibox(): string
 209     {
 210         $databases = [];
 211         foreach (DatabaseInterface::getInstance()->getDatabaseList() as $database) {
 212             if (Utilities::isSystemSchema($database)) {
 213                 continue;
 214             }
 215
 216             $databases[] = $database;
 217         }
 218
 219         return $this->template->render('server/replication/database_multibox', ['databases' => $databases]);
 220     }
 221
 222     /**
 223      * returns HTML for changing primary
 224      *
 225      * @param string $submitName submit button name
 226      *
 227      * @return string HTML code
 228      */
 229     public function getHtmlForReplicationChangePrimary(string $submitName): string
 230     {
 231         [$usernameLength, $hostnameLength] = $this->getUsernameHostnameLength();
 232
 233         return $this->template->render('server/replication/change_primary', [
 234             'server_id' => time(),
 235             'username_length' => $usernameLength,
 236             'hostname_length' => $hostnameLength,
 237             'submit_name' => $submitName,
 238         ]);
 239     }
 240
 241     /**
 242      * This function returns html code for table with replication status.
 243      *
 244      * @param string|null $connection primary connection
 245      * @param string      $type       either primary or replica
 246      * @param bool        $isHidden   if true, then default style is set to hidden, default value false
 247      * @param bool        $hasTitle   if true, then title is displayed, default true
 248      *
 249      * @return string HTML code
 250      */
 251     public function getHtmlForReplicationStatusTable(
 252         string|null $connection,
 253         string $type,
 254         bool $isHidden = false,
 255         bool $hasTitle = true,
 256     ): string {
 257         $replicationInfo = new ReplicationInfo(DatabaseInterface::getInstance());
 258         $replicationInfo->load($connection);
 259
 260         $replicationVariables = $replicationInfo->primaryVariables;
 261         $variablesAlerts = null;
 262         $variablesOks = null;
 263         $serverReplication = $replicationInfo->getPrimaryStatus();
 264         if ($type === 'replica') {
 265             $replicationVariables = $replicationInfo->replicaVariables;
 266             $variablesAlerts = ['Slave_IO_Running' => 'No', 'Slave_SQL_Running' => 'No'];
 267             $variablesOks = ['Slave_IO_Running' => 'Yes', 'Slave_SQL_Running' => 'Yes'];
 268             $serverReplication = $replicationInfo->getReplicaStatus();
 269         }
 270
 271         $variables = [];
 272         foreach ($replicationVariables as $variable) {
 273             $serverReplicationVariable = isset($serverReplication[0])
 274                 ? $serverReplication[0][$variable]
 275                 : '';
 276
 277             $variables[$variable] = ['name' => $variable, 'status' => '', 'value' => $serverReplicationVariable];
 278
 279             if (isset($variablesAlerts[$variable]) && $variablesAlerts[$variable] === $serverReplicationVariable) {
 280                 $variables[$variable]['status'] = 'text-danger';
 281             } elseif (isset($variablesOks[$variable]) && $variablesOks[$variable] === $serverReplicationVariable) {
 282                 $variables[$variable]['status'] = 'text-success';
 283             }
 284
 285             $variablesWrap = [
 286                 'Replicate_Do_DB',
 287                 'Replicate_Ignore_DB',
 288                 'Replicate_Do_Table',
 289                 'Replicate_Ignore_Table',
 290                 'Replicate_Wild_Do_Table',
 291                 'Replicate_Wild_Ignore_Table',
 292             ];
 293             if (! in_array($variable, $variablesWrap, true)) {
 294                 continue;
 295             }
 296
 297             $variables[$variable]['value'] = str_replace(',', ', ', $serverReplicationVariable);
 298         }
 299
 300         return $this->template->render('server/replication/status_table', [
 301             'type' => $type,
 302             'is_hidden' => $isHidden,
 303             'has_title' => $hasTitle,
 304             'variables' => $variables,
 305         ]);
 306     }
 307
 308     /**
 309      * get the correct username and hostname lengths for this MySQL server
 310      *
 311      * @return array<int,int> username length, hostname length
 312      */
 313     public function getUsernameHostnameLength(): array
 314     {
 315         $fieldsInfo = DatabaseInterface::getInstance()->getColumns('mysql', 'user');
 316         $usernameLength = 16;
 317         $hostnameLength = 41;
 318         foreach ($fieldsInfo as $val) {
 319             if ($val->field === 'User') {
 320                 strtok($val->type, '()');
 321                 $v = strtok('()');
 322                 if (Util::isInteger($v)) {
 323                     $usernameLength = (int) $v;
 324                 }
 325             } elseif ($val->field === 'Host') {
 326                 strtok($val->type, '()');
 327                 $v = strtok('()');
 328                 if (Util::isInteger($v)) {
 329                     $hostnameLength = (int) $v;
 330                 }
 331             }
 332         }
 333
 334         return [$usernameLength, $hostnameLength];
 335     }
 336
 337     /**
 338      * returns html code to add a replication replica user to the primary
 339      *
 340      * @return string HTML code
 341      */
 342     public function getHtmlForReplicationPrimaryAddReplicaUser(string|null $postUsername, string|null $hostname): string
 343     {
 344         [$usernameLength, $hostnameLength] = $this->getUsernameHostnameLength();
 345
 346         $username = '';
 347         if ($postUsername === '') {
 348             $GLOBALS['pred_username'] = 'any';
 349         } elseif ($postUsername !== null && $postUsername !== '0') {
 350             $username = $GLOBALS['new_username'] ?? $postUsername;
 351         }
 352
 353         $currentUser = DatabaseInterface::getInstance()->fetchValue('SELECT USER();');
 354         if ($currentUser !== '' && $currentUser !== false && $currentUser !== null) {
 355             $userHost = str_replace(
 356                 "'",
 357                 '',
 358                 mb_substr(
 359                     $currentUser,
 360                     mb_strrpos($currentUser, '@') + 1,
 361                 ),
 362             );
 363             if ($userHost !== 'localhost' && $userHost !== '127.0.0.1') {
 364                 $thisHost = $userHost;
 365             }
 366         }
 367
 368         // when we start editing a user, $GLOBALS['pred_hostname'] is not defined
 369         if (! isset($GLOBALS['pred_hostname']) && $hostname !== null) {
 370             $GLOBALS['pred_hostname'] = match (mb_strtolower($hostname)) {
 371                 'localhost', '127.0.0.1' => 'localhost',
 372                 '%' => 'any',
 373                 default => 'userdefined',
 374             };
 375         }
 376
 377         return $this->template->render('server/replication/primary_add_replica_user', [
 378             'username_length' => $usernameLength,
 379             'hostname_length' => $hostnameLength,
 380             'has_username' => $postUsername !== null,
 381             'username' => $username,
 382             'hostname' => $hostname ?? '',
 383             'predefined_username' => $GLOBALS['pred_username'] ?? '',
 384             'predefined_hostname' => $GLOBALS['pred_hostname'] ?? '',
 385             'this_host' => $thisHost ?? null,
 386         ]);
 387     }
 388
 389     /**
 390      * handle control requests
 391      */
 392     public function handleControlRequest(
 393         bool $srTakeAction,
 394         bool $replicaChangePrimary,
 395         bool $srReplicaServerControl,
 396         string|null $srReplicaAction,
 397         bool $srReplicaSkipError,
 398         int $srSkipErrorsCount,
 399         string|null $srReplicaControlParam,
 400         string $username,
 401         string $pmaPassword,
 402         string $hostname,
 403         int $port,
 404     ): void {
 405         if (! $srTakeAction) {
 406             return;
 407         }
 408
 409         $refresh = false;
 410         $result = false;
 411         $messageSuccess = '';
 412         $messageError = '';
 413
 414         if ($replicaChangePrimary && ! Config::getInstance()->settings['AllowArbitraryServer']) {
 415             $_SESSION['replication']['sr_action_status'] = 'error';
 416             $_SESSION['replication']['sr_action_info'] = __(
 417                 'Connection to server is disabled, please enable'
 418                 . ' $cfg[\'AllowArbitraryServer\'] in phpMyAdmin configuration.',
 419             );
 420         } elseif ($replicaChangePrimary) {
 421             $result = $this->handleRequestForReplicaChangePrimary($username, $pmaPassword, $hostname, $port);
 422         } elseif ($srReplicaServerControl) {
 423             $result = $this->handleRequestForReplicaServerControl($srReplicaAction, $srReplicaControlParam);
 424             $refresh = true;
 425
 426             switch ($srReplicaAction) {
 427                 case 'start':
 428                     $messageSuccess = __('Replication started successfully.');
 429                     $messageError = __('Error starting replication.');
 430                     break;
 431                 case 'stop':
 432                     $messageSuccess = __('Replication stopped successfully.');
 433                     $messageError = __('Error stopping replication.');
 434                     break;
 435                 case 'reset':
 436                     $messageSuccess = __('Replication resetting successfully.');
 437                     $messageError = __('Error resetting replication.');
 438                     break;
 439                 default:
 440                     $messageSuccess = __('Success.');
 441                     $messageError = __('Error.');
 442                     break;
 443             }
 444         } elseif ($srReplicaSkipError) {
 445             $result = $this->handleRequestForReplicaSkipError($srSkipErrorsCount);
 446         }
 447
 448         if ($refresh) {
 449             $response = ResponseRenderer::getInstance();
 450             if ($response->isAjax()) {
 451                 $response->setRequestStatus($result);
 452                 $response->addJSON(
 453                     'message',
 454                     $result
 455                     ? Message::success($messageSuccess)
 456                     : Message::error($messageError),
 457                 );
 458             } else {
 459                 $response->redirect(
 460                     './index.php?route=/server/replication' . Url::getCommonRaw($GLOBALS['urlParams'], '&'),
 461                 );
 462             }
 463         }
 464
 465         unset($refresh);
 466     }
 467
 468     public function handleRequestForReplicaChangePrimary(
 469         string $username,
 470         string $pmaPassword,
 471         string $hostname,
 472         int $port,
 473     ): bool {
 474         $_SESSION['replication']['m_username'] = $username;
 475         $_SESSION['replication']['m_password'] = $pmaPassword;
 476         $_SESSION['replication']['m_hostname'] = $hostname;
 477         $_SESSION['replication']['m_port'] = $port;
 478         $_SESSION['replication']['m_correct'] = '';
 479
 480         // Attempt to connect to the new primary server
 481         $connectionToPrimary = $this->replication->connectToPrimary($username, $pmaPassword, $hostname, $port);
 482
 483         if ($connectionToPrimary === null) {
 484             $_SESSION['replication']['sr_action_status'] = 'error';
 485             $_SESSION['replication']['sr_action_info'] = sprintf(
 486                 __('Unable to connect to primary %s.'),
 487                 htmlspecialchars($hostname),
 488             );
 489         } else {
 490             // Read the current primary position
 491             $position = $this->replication->replicaBinLogPrimary(ConnectionType::Auxiliary);
 492
 493             if ($position === []) {
 494                 $_SESSION['replication']['sr_action_status'] = 'error';
 495                 $_SESSION['replication']['sr_action_info'] = __(
 496                     'Unable to read primary log position. Possible privilege problem on primary.',
 497                 );
 498             } else {
 499                 $_SESSION['replication']['m_correct'] = true;
 500
 501                 if (
 502                     ! $this->replication->replicaChangePrimary(
 503                         $username,
 504                         $pmaPassword,
 505                         $hostname,
 506                         $port,
 507                         $position,
 508                         true,
 509                         false,
 510                         ConnectionType::User,
 511                     )
 512                 ) {
 513                     $_SESSION['replication']['sr_action_status'] = 'error';
 514                     $_SESSION['replication']['sr_action_info'] = __('Unable to change primary!');
 515                 } else {
 516                     $_SESSION['replication']['sr_action_status'] = 'success';
 517                     $_SESSION['replication']['sr_action_info'] = sprintf(
 518                         __('Primary server changed successfully to %s.'),
 519                         htmlspecialchars($hostname),
 520                     );
 521                 }
 522             }
 523         }
 524
 525         return $_SESSION['replication']['sr_action_status'] === 'success';
 526     }
 527
 528     public function handleRequestForReplicaServerControl(string|null $srReplicaAction, string|null $control): bool
 529     {
 530         if ($srReplicaAction === 'reset') {
 531             $qStop = $this->replication->replicaControl('STOP', null, ConnectionType::User);
 532             $qReset = DatabaseInterface::getInstance()->tryQuery('RESET SLAVE;');
 533             $qStart = $this->replication->replicaControl('START', null, ConnectionType::User);
 534
 535             return $qStop !== false && $qStop !== -1 && $qReset !== false && $qStart !== false && $qStart !== -1;
 536         }
 537
 538         $qControl = $this->replication->replicaControl($srReplicaAction, $control, ConnectionType::User);
 539
 540         return $qControl !== false && $qControl !== -1;
 541     }
 542
 543     public function handleRequestForReplicaSkipError(int $srSkipErrorsCount): bool
 544     {
 545         $dbi = DatabaseInterface::getInstance();
 546         $qStop = $this->replication->replicaControl('STOP', null, ConnectionType::User);
 547         $qSkip = $dbi->tryQuery('SET GLOBAL SQL_SLAVE_SKIP_COUNTER = ' . $srSkipErrorsCount . ';');
 548         $qStart = $this->replication->replicaControl('START', null, ConnectionType::User);
 549
 550         return $qStop !== false && $qStop !== -1 && $qSkip !== false && $qStart !== false && $qStart !== -1;
 551     }
 552 }