phpmyadmin working

7 files changed, 1462 insertions, 0 deletions

diff --git a/srcs/phpmyadmin/libraries/classes/Controllers/Server/Status/AbstractController.php b/srcs/phpmyadmin/libraries/classes/Controllers/Server/Status/AbstractController.php
new file mode 100644
index 0000000..8d4b51d
--- /dev/null
+++ b/srcs/phpmyadmin/libraries/classes/Controllers/Server/Status/AbstractController.php
@@ -0,0 +1,42 @@
+<?php
+/* vim: set expandtab sw=4 ts=4 sts=4: */
+/**
+ * Holds the PhpMyAdmin\Controllers\Server\Status\AbstractController
+ *
+ * @package PhpMyAdmin\Controllers
+ */
+declare(strict_types=1);
+
+namespace PhpMyAdmin\Controllers\Server\Status;
+
+use PhpMyAdmin\Controllers\AbstractController as Controller;
+use PhpMyAdmin\DatabaseInterface;
+use PhpMyAdmin\Response;
+use PhpMyAdmin\Server\Status\Data;
+use PhpMyAdmin\Template;
+
+/**
+ * Abstract class Controller
+ * @package PhpMyAdmin\Controllers\Server\Status
+ */
+abstract class AbstractController extends Controller
+{
+    /**
+     * @var Data
+     */
+    protected $data;
+
+    /**
+     * AbstractController constructor.
+     *
+     * @param Response          $response Response object
+     * @param DatabaseInterface $dbi      DatabaseInterface object
+     * @param Template          $template Template object
+     * @param Data              $data     Data object
+     */
+    public function __construct($response, $dbi, Template $template, $data)
+    {
+        parent::__construct($response, $dbi, $template);
+        $this->data = $data;
+    }
+}
diff --git a/srcs/phpmyadmin/libraries/classes/Controllers/Server/Status/AdvisorController.php b/srcs/phpmyadmin/libraries/classes/Controllers/Server/Status/AdvisorController.php
new file mode 100644
index 0000000..5b93b0e
--- /dev/null
+++ b/srcs/phpmyadmin/libraries/classes/Controllers/Server/Status/AdvisorController.php
@@ -0,0 +1,60 @@
+<?php
+/* vim: set expandtab sw=4 ts=4 sts=4: */
+/**
+ * Holds the PhpMyAdmin\Controllers\Server\Status\AdvisorController
+ *
+ * @package PhpMyAdmin\Controllers
+ */
+declare(strict_types=1);
+
+namespace PhpMyAdmin\Controllers\Server\Status;
+
+use PhpMyAdmin\Advisor;
+use PhpMyAdmin\DatabaseInterface;
+use PhpMyAdmin\Response;
+use PhpMyAdmin\Server\Status\Data;
+use PhpMyAdmin\Template;
+use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
+
+/**
+ * Displays the advisor feature
+ *
+ * @package PhpMyAdmin\Controllers
+ */
+class AdvisorController extends AbstractController
+{
+    /**
+     * @var Advisor
+     */
+    private $advisor;
+
+    /**
+     * AdvisorController constructor.
+     *
+     * @param Response          $response Response object
+     * @param DatabaseInterface $dbi      DatabaseInterface object
+     * @param Template          $template Template object
+     * @param Data              $data     Data object
+     * @param Advisor           $advisor  Advisor instance
+     */
+    public function __construct($response, $dbi, Template $template, $data, Advisor $advisor)
+    {
+        parent::__construct($response, $dbi, $template, $data);
+        $this->advisor = $advisor;
+    }
+
+    /**
+     * @return string
+     */
+    public function index(): string
+    {
+        $data = '';
+        if ($this->data->dataLoaded) {
+            $data = json_encode($this->advisor->run());
+        }
+
+        return $this->template->render('server/status/advisor/index', [
+            'data' => $data,
+        ]);
+    }
+}
diff --git a/srcs/phpmyadmin/libraries/classes/Controllers/Server/Status/MonitorController.php b/srcs/phpmyadmin/libraries/classes/Controllers/Server/Status/MonitorController.php
new file mode 100644
index 0000000..1d2cadc
--- /dev/null
+++ b/srcs/phpmyadmin/libraries/classes/Controllers/Server/Status/MonitorController.php
@@ -0,0 +1,146 @@
+<?php
+/* vim: set expandtab sw=4 ts=4 sts=4: */
+/**
+ * Holds the PhpMyAdmin\Controllers\Server\Status\MonitorController
+ *
+ * @package PhpMyAdmin\Controllers
+ */
+declare(strict_types=1);
+
+namespace PhpMyAdmin\Controllers\Server\Status;
+
+use PhpMyAdmin\DatabaseInterface;
+use PhpMyAdmin\Response;
+use PhpMyAdmin\Server\Status\Data;
+use PhpMyAdmin\Server\Status\Monitor;
+use PhpMyAdmin\SysInfo;
+use PhpMyAdmin\Template;
+
+/**
+ * Class MonitorController
+ * @package PhpMyAdmin\Controllers\Server\Status
+ */
+class MonitorController extends AbstractController
+{
+    /**
+     * @var Monitor
+     */
+    private $monitor;
+
+    /**
+     * MonitorController constructor.
+     *
+     * @param Response          $response Response object
+     * @param DatabaseInterface $dbi      DatabaseInterface object
+     * @param Template          $template Template object
+     * @param Data              $data     Data object
+     * @param Monitor           $monitor  Monitor object
+     */
+    public function __construct($response, $dbi, Template $template, $data, $monitor)
+    {
+        parent::__construct($response, $dbi, $template, $data);
+        $this->monitor = $monitor;
+    }
+
+    /**
+     * @return string HTML
+     */
+    public function index(): string
+    {
+        $form = [
+            'server_time' => microtime(true) * 1000,
+            'server_os' => SysInfo::getOs(),
+            'is_superuser' => $this->dbi->isSuperuser(),
+            'server_db_isLocal' => $this->data->db_isLocal,
+        ];
+
+        $javascriptVariableNames = [];
+        foreach ($this->data->status as $name => $value) {
+            if (is_numeric($value)) {
+                $javascriptVariableNames[] = $name;
+            }
+        }
+
+        return $this->template->render('server/status/monitor/index', [
+            'image_path' => $GLOBALS['pmaThemeImage'],
+            'javascript_variable_names' => $javascriptVariableNames,
+            'form' => $form,
+        ]);
+    }
+
+    /**
+     * @param array $params Request parameters
+     * @return array JSON
+     */
+    public function chartingData(array $params): array
+    {
+        $json = [];
+        $json['message'] = $this->monitor->getJsonForChartingData(
+            $params['requiredData'] ?? ''
+        );
+
+        return $json;
+    }
+
+    /**
+     * @param array $params Request parameters
+     * @return array JSON
+     */
+    public function logDataTypeSlow(array $params): array
+    {
+        $json = [];
+        $json['message'] = $this->monitor->getJsonForLogDataTypeSlow(
+            (int) $params['time_start'],
+            (int) $params['time_end']
+        );
+
+        return $json;
+    }
+
+    /**
+     * @param array $params Request parameters
+     * @return array JSON
+     */
+    public function logDataTypeGeneral(array $params): array
+    {
+        $json = [];
+        $json['message'] = $this->monitor->getJsonForLogDataTypeGeneral(
+            (int) $params['time_start'],
+            (int) $params['time_end'],
+            (bool) $params['limitTypes'],
+            (bool) $params['removeVariables']
+        );
+
+        return $json;
+    }
+
+    /**
+     * @param array $params Request parameters
+     * @return array JSON
+     */
+    public function loggingVars(array $params): array
+    {
+        $json = [];
+        $json['message'] = $this->monitor->getJsonForLoggingVars(
+            $params['varName'],
+            $params['varValue']
+        );
+
+        return $json;
+    }
+
+    /**
+     * @param array $params Request parameters
+     * @return array JSON
+     */
+    public function queryAnalyzer(array $params): array
+    {
+        $json = [];
+        $json['message'] = $this->monitor->getJsonForQueryAnalyzer(
+            $params['database'] ?? '',
+            $params['query'] ?? ''
+        );
+
+        return $json;
+    }
+}
diff --git a/srcs/phpmyadmin/libraries/classes/Controllers/Server/Status/ProcessesController.php b/srcs/phpmyadmin/libraries/classes/Controllers/Server/Status/ProcessesController.php
new file mode 100644
index 0000000..9817e1b
--- /dev/null
+++ b/srcs/phpmyadmin/libraries/classes/Controllers/Server/Status/ProcessesController.php
@@ -0,0 +1,240 @@
+<?php
+/* vim: set expandtab sw=4 ts=4 sts=4: */
+/**
+ * Holds the PhpMyAdmin\Controllers\Server\Status\ProcessesController
+ *
+ * @package PhpMyAdmin\Controllers
+ */
+declare(strict_types=1);
+
+namespace PhpMyAdmin\Controllers\Server\Status;
+
+use PhpMyAdmin\Message;
+use PhpMyAdmin\Util;
+
+/**
+ * Class ProcessesController
+ * @package PhpMyAdmin\Controllers\Server\Status
+ */
+class ProcessesController extends AbstractController
+{
+    /**
+     * @param array $params Request parameters
+     * @return string
+     */
+    public function index(array $params): string
+    {
+        $isChecked = false;
+        if (! empty($params['showExecuting'])) {
+            $isChecked = true;
+        }
+
+        $urlParams = [
+            'ajax_request' => true,
+            'full' => $params['full'] ?? '',
+            'column_name' => $params['column_name'] ?? '',
+            'order_by_field' => $params['order_by_field'] ?? '',
+            'sort_order' => $params['sort_order'] ?? '',
+        ];
+
+        $serverProcessList = $this->getList($params);
+
+        return $this->template->render('server/status/processes/index', [
+            'url_params' => $urlParams,
+            'is_checked' => $isChecked,
+            'server_process_list' => $serverProcessList,
+        ]);
+    }
+
+    /**
+     * Only sends the process list table
+     *
+     * @param array $params Request parameters
+     * @return string
+     */
+    public function refresh(array $params): string
+    {
+        return $this->getList($params);
+    }
+
+    /**
+     * @param array $params Request parameters
+     * @return array
+     */
+    public function kill(array $params): array
+    {
+        $kill = (int) $params['kill'];
+        $query = $this->dbi->getKillQuery($kill);
+
+        if ($this->dbi->tryQuery($query)) {
+            $message = Message::success(
+                __('Thread %s was successfully killed.')
+            );
+            $this->response->setRequestStatus(true);
+        } else {
+            $message = Message::error(
+                __(
+                    'phpMyAdmin was unable to kill thread %s.'
+                    . ' It probably has already been closed.'
+                )
+            );
+            $this->response->setRequestStatus(false);
+        }
+        $message->addParam($kill);
+
+        $json = [];
+        $json['message'] = $message;
+
+        return $json;
+    }
+
+    /**
+     * @param array $params Request parameters
+     * @return string
+     */
+    private function getList(array $params): string
+    {
+        $urlParams = [];
+
+        $showFullSql = ! empty($params['full']);
+        if ($showFullSql) {
+            $urlParams['full'] = '';
+        } else {
+            $urlParams['full'] = 1;
+        }
+
+        // This array contains display name and real column name of each
+        // sortable column in the table
+        $sortableColumns = [
+            [
+                'column_name' => __('ID'),
+                'order_by_field' => 'Id',
+            ],
+            [
+                'column_name' => __('User'),
+                'order_by_field' => 'User',
+            ],
+            [
+                'column_name' => __('Host'),
+                'order_by_field' => 'Host',
+            ],
+            [
+                'column_name' => __('Database'),
+                'order_by_field' => 'db',
+            ],
+            [
+                'column_name' => __('Command'),
+                'order_by_field' => 'Command',
+            ],
+            [
+                'column_name' => __('Time'),
+                'order_by_field' => 'Time',
+            ],
+            [
+                'column_name' => __('Status'),
+                'order_by_field' => 'State',
+            ],
+            [
+                'column_name' => __('Progress'),
+                'order_by_field' => 'Progress',
+            ],
+            [
+                'column_name' => __('SQL query'),
+                'order_by_field' => 'Info',
+            ],
+        ];
+        $sortableColCount = count($sortableColumns);
+
+        $sqlQuery = $showFullSql
+            ? 'SHOW FULL PROCESSLIST'
+            : 'SHOW PROCESSLIST';
+        if ((! empty($params['order_by_field'])
+                && ! empty($params['sort_order']))
+            || ! empty($params['showExecuting'])
+        ) {
+            $urlParams['order_by_field'] = $params['order_by_field'];
+            $urlParams['sort_order'] = $params['sort_order'];
+            $urlParams['showExecuting'] = $params['showExecuting'];
+            $sqlQuery = 'SELECT * FROM `INFORMATION_SCHEMA`.`PROCESSLIST` ';
+        }
+        if (! empty($params['showExecuting'])) {
+            $sqlQuery .= ' WHERE state != "" ';
+        }
+        if (! empty($params['order_by_field']) && ! empty($params['sort_order'])) {
+            $sqlQuery .= ' ORDER BY '
+                . Util::backquote($params['order_by_field'])
+                . ' ' . $params['sort_order'];
+        }
+
+        $result = $this->dbi->query($sqlQuery);
+
+        $columns = [];
+        foreach ($sortableColumns as $columnKey => $column) {
+            $is_sorted = ! empty($params['order_by_field'])
+                && ! empty($params['sort_order'])
+                && ($params['order_by_field'] == $column['order_by_field']);
+
+            $column['sort_order'] = 'ASC';
+            if ($is_sorted && $params['sort_order'] === 'ASC') {
+                $column['sort_order'] = 'DESC';
+            }
+            if (isset($params['showExecuting'])) {
+                $column['showExecuting'] = 'on';
+            }
+
+            $columns[$columnKey] = [
+                'name' => $column['column_name'],
+                'params' => $column,
+                'is_sorted' => $is_sorted,
+                'sort_order' => $column['sort_order'],
+                'has_full_query' => false,
+                'is_full' => false,
+            ];
+
+            if (0 === --$sortableColCount) {
+                $columns[$columnKey]['has_full_query'] = true;
+                if ($showFullSql) {
+                    $columns[$columnKey]['is_full'] = true;
+                }
+            }
+        }
+
+        $rows = [];
+        while ($process = $this->dbi->fetchAssoc($result)) {
+            // Array keys need to modify due to the way it has used
+            // to display column values
+            if ((! empty($params['order_by_field']) && ! empty($params['sort_order']))
+                || ! empty($params['showExecuting'])
+            ) {
+                foreach (array_keys($process) as $key) {
+                    $newKey = ucfirst(mb_strtolower($key));
+                    if ($newKey !== $key) {
+                        $process[$newKey] = $process[$key];
+                        unset($process[$key]);
+                    }
+                }
+            }
+
+            $rows[] = [
+                'id' => $process['Id'],
+                'user' => $process['User'],
+                'host' => $process['Host'],
+                'db' => ! isset($process['db']) || strlen($process['db']) === 0 ? '' : $process['db'],
+                'command' => $process['Command'],
+                'time' => $process['Time'],
+                'state' => ! empty($process['State']) ? $process['State'] : '---',
+                'progress' => ! empty($process['Progress']) ? $process['Progress'] : '---',
+                'info' => ! empty($process['Info']) ? Util::formatSql(
+                    $process['Info'],
+                    ! $showFullSql
+                ) : '---',
+            ];
+        }
+
+        return $this->template->render('server/status/processes/list', [
+            'columns' => $columns,
+            'rows' => $rows,
+            'refresh_params' => $urlParams,
+        ]);
+    }
+}
diff --git a/srcs/phpmyadmin/libraries/classes/Controllers/Server/Status/QueriesController.php b/srcs/phpmyadmin/libraries/classes/Controllers/Server/Status/QueriesController.php
new file mode 100644
index 0000000..76430d4
--- /dev/null
+++ b/srcs/phpmyadmin/libraries/classes/Controllers/Server/Status/QueriesController.php
@@ -0,0 +1,75 @@
+<?php
+/* vim: set expandtab sw=4 ts=4 sts=4: */
+/**
+ * Displays query statistics for the server
+ *
+ * @package PhpMyAdmin\Controllers
+ */
+declare(strict_types=1);
+
+namespace PhpMyAdmin\Controllers\Server\Status;
+
+/**
+ * Class QueriesController
+ * @package PhpMyAdmin\Controllers\Server\Status
+ */
+class QueriesController extends AbstractController
+{
+    /**
+     * @return string HTML
+     */
+    public function index(): string
+    {
+        if ($this->data->dataLoaded) {
+            $hourFactor = 3600 / $this->data->status['Uptime'];
+            $usedQueries = $this->data->used_queries;
+            $totalQueries = array_sum($usedQueries);
+
+            $stats = [
+                'total' => $totalQueries,
+                'per_hour' => $totalQueries * $hourFactor,
+                'per_minute' => $totalQueries * 60 / $this->data->status['Uptime'],
+                'per_second' => $totalQueries / $this->data->status['Uptime'],
+            ];
+
+            // reverse sort by value to show most used statements first
+            arsort($usedQueries);
+
+            $chart = [];
+            $querySum = array_sum($usedQueries);
+            $otherSum = 0;
+            $queries = [];
+            foreach ($usedQueries as $key => $value) {
+                // For the percentage column, use Questions - Connections, because
+                // the number of connections is not an item of the Query types
+                // but is included in Questions. Then the total of the percentages is 100.
+                $name = str_replace(['Com_', '_'], ['', ' '], $key);
+                // Group together values that make out less than 2% into "Other", but only
+                // if we have more than 6 fractions already
+                if ($value < $querySum * 0.02 && count($chart) > 6) {
+                    $otherSum += $value;
+                } else {
+                    $chart[$name] = $value;
+                }
+
+                $queries[$key] = [
+                    'name' => $name,
+                    'value' => $value,
+                    'per_hour' => $value * $hourFactor,
+                    'percentage' => $value * 100 / $totalQueries,
+                ];
+            }
+
+            if ($otherSum > 0) {
+                $chart[__('Other')] = $otherSum;
+            }
+        }
+
+        return $this->template->render('server/status/queries/index', [
+            'is_data_loaded' => $this->data->dataLoaded,
+            'stats' => $stats ?? null,
+            'queries' => $queries ?? [],
+            'chart' => $chart ?? [],
+        ]);
+    }
+}
diff --git a/srcs/phpmyadmin/libraries/classes/Controllers/Server/Status/StatusController.php b/srcs/phpmyadmin/libraries/classes/Controllers/Server/Status/StatusController.php
new file mode 100644
index 0000000..53d78a3
--- /dev/null
+++ b/srcs/phpmyadmin/libraries/classes/Controllers/Server/Status/StatusController.php
@@ -0,0 +1,260 @@
+<?php
+/* vim: set expandtab sw=4 ts=4 sts=4: */
+/**
+ * Holds the PhpMyAdmin\Controllers\Server\Status\StatusController
+ *
+ * @package PhpMyAdmin\Controllers
+ */
+declare(strict_types=1);
+
+namespace PhpMyAdmin\Controllers\Server\Status;
+
+use PhpMyAdmin\ReplicationGui;
+use PhpMyAdmin\Util;
+use Throwable;
+use Twig_Error_Loader;
+use Twig_Error_Runtime;
+use Twig_Error_Syntax;
+
+/**
+ * Class StatusController
+ * @package PhpMyAdmin\Controllers\Server\Status
+ */
+class StatusController extends AbstractController
+{
+    /**
+     * @param ReplicationGui $replicationGui ReplicationGui instance
+     *
+     * @return string
+     * @throws Throwable
+     * @throws Twig_Error_Loader
+     * @throws Twig_Error_Runtime
+     * @throws Twig_Error_Syntax
+     */
+    public function index(ReplicationGui $replicationGui): string
+    {
+        global $replication_info;
+
+        $traffic = [];
+        $connections = [];
+        $replication = '';
+        if ($this->data->dataLoaded) {
+            $networkTraffic = implode(
+                ' ',
+                Util::formatByteDown(
+                    $this->data->status['Bytes_received'] + $this->data->status['Bytes_sent'],
+                    3,
+                    1
+                )
+            );
+            $uptime = Util::timespanFormat($this->data->status['Uptime']);
+            $startTime = Util::localisedDate($this->getStartTime());
+
+            $traffic = $this->getTrafficInfo();
+
+            $connections = $this->getConnectionsInfo();
+
+            // display replication information
+            if ($replication_info['master']['status']
+                || $replication_info['slave']['status']
+            ) {
+                $replication = $this->getReplicationInfo($replicationGui);
+            }
+        }
+
+        return $this->template->render('server/status/status/index', [
+            'is_data_loaded' => $this->data->dataLoaded,
+            'network_traffic' => $networkTraffic ?? null,
+            'uptime' => $uptime ?? null,
+            'start_time' => $startTime ?? null,
+            'traffic' => $traffic,
+            'connections' => $connections,
+            'is_master' => $replication_info['master']['status'],
+            'is_slave' => $replication_info['slave']['status'],
+            'replication' => $replication,
+        ]);
+    }
+
+    /**
+     * @return int
+     */
+    private function getStartTime(): int
+    {
+        return (int) $this->dbi->fetchValue(
+            'SELECT UNIX_TIMESTAMP() - ' . $this->data->status['Uptime']
+        );
+    }
+
+    /**
+     * @return array
+     */
+    private function getTrafficInfo(): array
+    {
+        $hourFactor = 3600 / $this->data->status['Uptime'];
+
+        return [
+            [
+                'name' => __('Received'),
+                'number' => implode(
+                    ' ',
+                    Util::formatByteDown(
+                        $this->data->status['Bytes_received'],
+                        3,
+                        1
+                    )
+                ),
+                'per_hour' => implode(
+                    ' ',
+                    Util::formatByteDown(
+                        $this->data->status['Bytes_received'] * $hourFactor,
+                        3,
+                        1
+                    )
+                ),
+            ],
+            [
+                'name' => __('Sent'),
+                'number' => implode(
+                    ' ',
+                    Util::formatByteDown(
+                        $this->data->status['Bytes_sent'],
+                        3,
+                        1
+                    )
+                ),
+                'per_hour' => implode(
+                    ' ',
+                    Util::formatByteDown(
+                        $this->data->status['Bytes_sent'] * $hourFactor,
+                        3,
+                        1
+                    )
+                ),
+            ],
+            [
+                'name' => __('Total'),
+                'number' => implode(
+                    ' ',
+                    Util::formatByteDown(
+                        $this->data->status['Bytes_received'] + $this->data->status['Bytes_sent'],
+                        3,
+                        1
+                    )
+                ),
+                'per_hour' => implode(
+                    ' ',
+                    Util::formatByteDown(
+                        ($this->data->status['Bytes_received'] + $this->data->status['Bytes_sent']) * $hourFactor,
+                        3,
+                        1
+                    )
+                ),
+            ],
+        ];
+    }
+
+    /**
+     * @return array
+     */
+    private function getConnectionsInfo(): array
+    {
+        $hourFactor = 3600 / $this->data->status['Uptime'];
+
+        $failedAttemptsPercentage = '---';
+        $abortedPercentage = '---';
+        if ($this->data->status['Connections'] > 0) {
+            $failedAttemptsPercentage = Util::formatNumber(
+                $this->data->status['Aborted_connects'] * 100 / $this->data->status['Connections'],
+                0,
+                2,
+                true
+            ) . '%';
+
+            $abortedPercentage = Util::formatNumber(
+                $this->data->status['Aborted_clients'] * 100 / $this->data->status['Connections'],
+                0,
+                2,
+                true
+            ) . '%';
+        }
+
+        return [
+            [
+                'name' => __('Max. concurrent connections'),
+                'number' => Util::formatNumber(
+                    $this->data->status['Max_used_connections'],
+                    0
+                ),
+                'per_hour' => '---',
+                'percentage' => '---',
+            ],
+            [
+                'name' => __('Failed attempts'),
+                'number' => Util::formatNumber(
+                    $this->data->status['Aborted_connects'],
+                    4,
+                    1,
+                    true
+                ),
+                'per_hour' => Util::formatNumber(
+                    $this->data->status['Aborted_connects'] * $hourFactor,
+                    4,
+                    2,
+                    true
+                ),
+                'percentage' => $failedAttemptsPercentage,
+            ],
+            [
+                'name' => __('Aborted'),
+                'number' => Util::formatNumber(
+                    $this->data->status['Aborted_clients'],
+                    4,
+                    1,
+                    true
+                ),
+                'per_hour' => Util::formatNumber(
+                    $this->data->status['Aborted_clients'] * $hourFactor,
+                    4,
+                    2,
+                    true
+                ),
+                'percentage' => $abortedPercentage,
+            ],
+            [
+                'name' => __('Total'),
+                'number' => Util::formatNumber(
+                    $this->data->status['Connections'],
+                    4,
+                    0
+                ),
+                'per_hour' => Util::formatNumber(
+                    $this->data->status['Connections'] * $hourFactor,
+                    4,
+                    2
+                ),
+                'percentage' => Util::formatNumber(100, 0, 2) . '%',
+            ],
+        ];
+    }
+
+    /**
+     * @param ReplicationGui $replicationGui ReplicationGui instance
+     *
+     * @return string
+     */
+    private function getReplicationInfo(ReplicationGui $replicationGui): string
+    {
+        global $replication_info, $replication_types;
+
+        $output = '';
+        foreach ($replication_types as $type) {
+            if (isset($replication_info[$type]['status'])
+                && $replication_info[$type]['status']
+            ) {
+                $output .= $replicationGui->getHtmlForReplicationStatusTable($type);
+            }
+        }
+
+        return $output;
+    }
+}
diff --git a/srcs/phpmyadmin/libraries/classes/Controllers/Server/Status/VariablesController.php b/srcs/phpmyadmin/libraries/classes/Controllers/Server/Status/VariablesController.php
new file mode 100644
index 0000000..a17f15f
--- /dev/null
+++ b/srcs/phpmyadmin/libraries/classes/Controllers/Server/Status/VariablesController.php
@@ -0,0 +1,639 @@
+<?php
+/* vim: set expandtab sw=4 ts=4 sts=4: */
+/**
+ * Displays a list of server status variables
+ *
+ * @package PhpMyAdmin\Controllers
+ */
+declare(strict_types=1);
+
+namespace PhpMyAdmin\Controllers\Server\Status;
+
+use PhpMyAdmin\Util;
+
+/**
+ * Class VariablesController
+ * @package PhpMyAdmin\Controllers\Server\Status
+ */
+class VariablesController extends AbstractController
+{
+    /**
+     * @param array $params Request parameters
+     * @return string HTML
+     */
+    public function index(array $params): string
+    {
+        if (isset($params['flush'])) {
+            $this->flush($params['flush']);
+        }
+
+        if ($this->data->dataLoaded) {
+            $categories = [];
+            foreach ($this->data->sections as $sectionId => $sectionName) {
+                if (isset($this->data->sectionUsed[$sectionId])) {
+                    $categories[$sectionId] = [
+                        'id' => $sectionId,
+                        'name' => $sectionName,
+                        'is_selected' => false,
+                    ];
+                    if (! empty($params['filterCategory'])
+                        && $params['filterCategory'] === $sectionId
+                    ) {
+                        $categories[$sectionId]['is_selected'] = true;
+                    }
+                }
+            }
+
+            $links = [];
+            foreach ($this->data->links as $sectionName => $sectionLinks) {
+                $links[$sectionName] = [
+                    'name' => 'status_' . $sectionName,
+                    'links' => $sectionLinks,
+                ];
+            }
+
+            $descriptions = $this->getDescriptions();
+            $alerts = $this->getAlerts();
+
+            $variables = [];
+            foreach ($this->data->status as $name => $value) {
+                $variables[$name] = [
+                    'name' => $name,
+                    'value' => $value,
+                    'is_numeric' => is_numeric($value),
+                    'class' => $this->data->allocationMap[$name] ?? null,
+                    'doc' => '',
+                    'has_alert' => false,
+                    'is_alert' => false,
+                    'description' => $descriptions[$name] ?? '',
+                    'description_doc' => [],
+                ];
+
+                // Fields containing % are calculated,
+                // they can not be described in MySQL documentation
+                if (mb_strpos($name, '%') === false) {
+                    $variables[$name]['doc'] = Util::linkToVarDocumentation(
+                        $name,
+                        $this->dbi->isMariaDB()
+                    );
+                }
+
+                if (isset($alerts[$name])) {
+                    $variables[$name]['has_alert'] = true;
+                    if ($value > $alerts[$name]) {
+                        $variables[$name]['is_alert'] = true;
+                    }
+                }
+
+                if (isset($this->data->links[$name])) {
+                    foreach ($this->data->links[$name] as $linkName => $linkUrl) {
+                        $variables[$name]['description_doc'][] = [
+                            'name' => $linkName,
+                            'url' => $linkUrl,
+                        ];
+                    }
+                }
+            }
+        }
+
+        return $this->template->render('server/status/variables/index', [
+            'is_data_loaded' => $this->data->dataLoaded,
+            'filter_text' => ! empty($params['filterText']) ? $params['filterText'] : '',
+            'is_only_alerts' => ! empty($params['filterAlert']),
+            'is_not_formatted' => ! empty($params['dontFormat']),
+            'categories' => $categories ?? [],
+            'links' => $links ?? [],
+            'variables' => $variables ?? [],
+        ]);
+    }
+
+    /**
+     * Flush status variables if requested
+     *
+     * @param string $flush Variable name
+     * @return void
+     */
+    private function flush(string $flush): void
+    {
+        $flushCommands = [
+            'STATUS',
+            'TABLES',
+            'QUERY CACHE',
+        ];
+
+        if (in_array($flush, $flushCommands)) {
+            $this->dbi->query('FLUSH ' . $flush . ';');
+        }
+    }
+
+    /**
+     * @return array
+     */
+    private function getAlerts(): array
+    {
+        // name => max value before alert
+        return [
+            // lower is better
+            // variable => max value
+            'Aborted_clients' => 0,
+            'Aborted_connects' => 0,
+
+            'Binlog_cache_disk_use' => 0,
+
+            'Created_tmp_disk_tables' => 0,
+
+            'Handler_read_rnd' => 0,
+            'Handler_read_rnd_next' => 0,
+
+            'Innodb_buffer_pool_pages_dirty' => 0,
+            'Innodb_buffer_pool_reads' => 0,
+            'Innodb_buffer_pool_wait_free' => 0,
+            'Innodb_log_waits' => 0,
+            'Innodb_row_lock_time_avg' => 10, // ms
+            'Innodb_row_lock_time_max' => 50, // ms
+            'Innodb_row_lock_waits' => 0,
+
+            'Slow_queries' => 0,
+            'Delayed_errors' => 0,
+            'Select_full_join' => 0,
+            'Select_range_check' => 0,
+            'Sort_merge_passes' => 0,
+            'Opened_tables' => 0,
+            'Table_locks_waited' => 0,
+            'Qcache_lowmem_prunes' => 0,
+
+            'Qcache_free_blocks' =>
+                isset($this->data->status['Qcache_total_blocks'])
+                    ? $this->data->status['Qcache_total_blocks'] / 5
+                    : 0,
+            'Slow_launch_threads' => 0,
+
+            // depends on Key_read_requests
+            // normally lower then 1:0.01
+            'Key_reads' => isset($this->data->status['Key_read_requests'])
+                ? (0.01 * $this->data->status['Key_read_requests']) : 0,
+            // depends on Key_write_requests
+            // normally nearly 1:1
+            'Key_writes' => isset($this->data->status['Key_write_requests'])
+                ? (0.9 * $this->data->status['Key_write_requests']) : 0,
+
+            'Key_buffer_fraction' => 0.5,
+
+            // alert if more than 95% of thread cache is in use
+            'Threads_cached' => isset($this->data->variables['thread_cache_size'])
+                ? 0.95 * $this->data->variables['thread_cache_size'] : 0,
+
+            // higher is better
+            // variable => min value
+            //'Handler read key' => '> ',
+        ];
+    }
+
+    /**
+     * Returns a list of variable descriptions
+     *
+     * @return array
+     */
+    private function getDescriptions(): array
+    {
+        /**
+         * Messages are built using the message name
+         */
+        return [
+            'Aborted_clients' => __(
+                'The number of connections that were aborted because the client died'
+                . ' without closing the connection properly.'
+            ),
+            'Aborted_connects' => __(
+                'The number of failed attempts to connect to the MySQL server.'
+            ),
+            'Binlog_cache_disk_use' => __(
+                'The number of transactions that used the temporary binary log cache'
+                . ' but that exceeded the value of binlog_cache_size and used a'
+                . ' temporary file to store statements from the transaction.'
+            ),
+            'Binlog_cache_use' => __(
+                'The number of transactions that used the temporary binary log cache.'
+            ),
+            'Connections' => __(
+                'The number of connection attempts (successful or not)'
+                . ' to the MySQL server.'
+            ),
+            'Created_tmp_disk_tables' => __(
+                'The number of temporary tables on disk created automatically by'
+                . ' the server while executing statements. If'
+                . ' Created_tmp_disk_tables is big, you may want to increase the'
+                . ' tmp_table_size  value to cause temporary tables to be'
+                . ' memory-based instead of disk-based.'
+            ),
+            'Created_tmp_files' => __(
+                'How many temporary files mysqld has created.'
+            ),
+            'Created_tmp_tables' => __(
+                'The number of in-memory temporary tables created automatically'
+                . ' by the server while executing statements.'
+            ),
+            'Delayed_errors' => __(
+                'The number of rows written with INSERT DELAYED for which some'
+                . ' error occurred (probably duplicate key).'
+            ),
+            'Delayed_insert_threads' => __(
+                'The number of INSERT DELAYED handler threads in use. Every'
+                . ' different table on which one uses INSERT DELAYED gets'
+                . ' its own thread.'
+            ),
+            'Delayed_writes' => __(
+                'The number of INSERT DELAYED rows written.'
+            ),
+            'Flush_commands'  => __(
+                'The number of executed FLUSH statements.'
+            ),
+            'Handler_commit' => __(
+                'The number of internal COMMIT statements.'
+            ),
+            'Handler_delete' => __(
+                'The number of times a row was deleted from a table.'
+            ),
+            'Handler_discover' => __(
+                'The MySQL server can ask the NDB Cluster storage engine if it'
+                . ' knows about a table with a given name. This is called discovery.'
+                . ' Handler_discover indicates the number of time tables have been'
+                . ' discovered.'
+            ),
+            'Handler_read_first' => __(
+                'The number of times the first entry was read from an index. If this'
+                . ' is high, it suggests that the server is doing a lot of full'
+                . ' index scans; for example, SELECT col1 FROM foo, assuming that'
+                . ' col1 is indexed.'
+            ),
+            'Handler_read_key' => __(
+                'The number of requests to read a row based on a key. If this is'
+                . ' high, it is a good indication that your queries and tables'
+                . ' are properly indexed.'
+            ),
+            'Handler_read_next' => __(
+                'The number of requests to read the next row in key order. This is'
+                . ' incremented if you are querying an index column with a range'
+                . ' constraint or if you are doing an index scan.'
+            ),
+            'Handler_read_prev' => __(
+                'The number of requests to read the previous row in key order.'
+                . ' This read method is mainly used to optimize ORDER BY … DESC.'
+            ),
+            'Handler_read_rnd' => __(
+                'The number of requests to read a row based on a fixed position.'
+                . ' This is high if you are doing a lot of queries that require'
+                . ' sorting of the result. You probably have a lot of queries that'
+                . ' require MySQL to scan whole tables or you have joins that'
+                . ' don\'t use keys properly.'
+            ),
+            'Handler_read_rnd_next' => __(
+                'The number of requests to read the next row in the data file.'
+                . ' This is high if you are doing a lot of table scans. Generally'
+                . ' this suggests that your tables are not properly indexed or that'
+                . ' your queries are not written to take advantage of the indexes'
+                . ' you have.'
+            ),
+            'Handler_rollback' => __(
+                'The number of internal ROLLBACK statements.'
+            ),
+            'Handler_update' => __(
+                'The number of requests to update a row in a table.'
+            ),
+            'Handler_write' => __(
+                'The number of requests to insert a row in a table.'
+            ),
+            'Innodb_buffer_pool_pages_data' => __(
+                'The number of pages containing data (dirty or clean).'
+            ),
+            'Innodb_buffer_pool_pages_dirty' => __(
+                'The number of pages currently dirty.'
+            ),
+            'Innodb_buffer_pool_pages_flushed' => __(
+                'The number of buffer pool pages that have been requested'
+                . ' to be flushed.'
+            ),
+            'Innodb_buffer_pool_pages_free' => __(
+                'The number of free pages.'
+            ),
+            'Innodb_buffer_pool_pages_latched' => __(
+                'The number of latched pages in InnoDB buffer pool. These are pages'
+                . ' currently being read or written or that can\'t be flushed or'
+                . ' removed for some other reason.'
+            ),
+            'Innodb_buffer_pool_pages_misc' => __(
+                'The number of pages busy because they have been allocated for'
+                . ' administrative overhead such as row locks or the adaptive'
+                . ' hash index. This value can also be calculated as'
+                . ' Innodb_buffer_pool_pages_total - Innodb_buffer_pool_pages_free'
+                . ' - Innodb_buffer_pool_pages_data.'
+            ),
+            'Innodb_buffer_pool_pages_total' => __(
+                'Total size of buffer pool, in pages.'
+            ),
+            'Innodb_buffer_pool_read_ahead_rnd' => __(
+                'The number of "random" read-aheads InnoDB initiated. This happens'
+                . ' when a query is to scan a large portion of a table but in'
+                . ' random order.'
+            ),
+            'Innodb_buffer_pool_read_ahead_seq' => __(
+                'The number of sequential read-aheads InnoDB initiated. This'
+                . ' happens when InnoDB does a sequential full table scan.'
+            ),
+            'Innodb_buffer_pool_read_requests' => __(
+                'The number of logical read requests InnoDB has done.'
+            ),
+            'Innodb_buffer_pool_reads' => __(
+                'The number of logical reads that InnoDB could not satisfy'
+                . ' from buffer pool and had to do a single-page read.'
+            ),
+            'Innodb_buffer_pool_wait_free' => __(
+                'Normally, writes to the InnoDB buffer pool happen in the'
+                . ' background. However, if it\'s necessary to read or create a page'
+                . ' and no clean pages are available, it\'s necessary to wait for'
+                . ' pages to be flushed first. This counter counts instances of'
+                . ' these waits. If the buffer pool size was set properly, this'
+                . ' value should be small.'
+            ),
+            'Innodb_buffer_pool_write_requests' => __(
+                'The number writes done to the InnoDB buffer pool.'
+            ),
+            'Innodb_data_fsyncs' => __(
+                'The number of fsync() operations so far.'
+            ),
+            'Innodb_data_pending_fsyncs' => __(
+                'The current number of pending fsync() operations.'
+            ),
+            'Innodb_data_pending_reads' => __(
+                'The current number of pending reads.'
+            ),
+            'Innodb_data_pending_writes' => __(
+                'The current number of pending writes.'
+            ),
+            'Innodb_data_read' => __(
+                'The amount of data read so far, in bytes.'
+            ),
+            'Innodb_data_reads' => __(
+                'The total number of data reads.'
+            ),
+            'Innodb_data_writes' => __(
+                'The total number of data writes.'
+            ),
+            'Innodb_data_written' => __(
+                'The amount of data written so far, in bytes.'
+            ),
+            'Innodb_dblwr_pages_written' => __(
+                'The number of pages that have been written for'
+                . ' doublewrite operations.'
+            ),
+            'Innodb_dblwr_writes' => __(
+                'The number of doublewrite operations that have been performed.'
+            ),
+            'Innodb_log_waits' => __(
+                'The number of waits we had because log buffer was too small and'
+                . ' we had to wait for it to be flushed before continuing.'
+            ),
+            'Innodb_log_write_requests' => __(
+                'The number of log write requests.'
+            ),
+            'Innodb_log_writes' => __(
+                'The number of physical writes to the log file.'
+            ),
+            'Innodb_os_log_fsyncs' => __(
+                'The number of fsync() writes done to the log file.'
+            ),
+            'Innodb_os_log_pending_fsyncs' => __(
+                'The number of pending log file fsyncs.'
+            ),
+            'Innodb_os_log_pending_writes' => __(
+                'Pending log file writes.'
+            ),
+            'Innodb_os_log_written' => __(
+                'The number of bytes written to the log file.'
+            ),
+            'Innodb_pages_created' => __(
+                'The number of pages created.'
+            ),
+            'Innodb_page_size' => __(
+                'The compiled-in InnoDB page size (default 16KB). Many values are'
+                . ' counted in pages; the page size allows them to be easily'
+                . ' converted to bytes.'
+            ),
+            'Innodb_pages_read' => __(
+                'The number of pages read.'
+            ),
+            'Innodb_pages_written' => __(
+                'The number of pages written.'
+            ),
+            'Innodb_row_lock_current_waits' => __(
+                'The number of row locks currently being waited for.'
+            ),
+            'Innodb_row_lock_time_avg' => __(
+                'The average time to acquire a row lock, in milliseconds.'
+            ),
+            'Innodb_row_lock_time' => __(
+                'The total time spent in acquiring row locks, in milliseconds.'
+            ),
+            'Innodb_row_lock_time_max' => __(
+                'The maximum time to acquire a row lock, in milliseconds.'
+            ),
+            'Innodb_row_lock_waits' => __(
+                'The number of times a row lock had to be waited for.'
+            ),
+            'Innodb_rows_deleted' => __(
+                'The number of rows deleted from InnoDB tables.'
+            ),
+            'Innodb_rows_inserted' => __(
+                'The number of rows inserted in InnoDB tables.'
+            ),
+            'Innodb_rows_read' => __(
+                'The number of rows read from InnoDB tables.'
+            ),
+            'Innodb_rows_updated' => __(
+                'The number of rows updated in InnoDB tables.'
+            ),
+            'Key_blocks_not_flushed' => __(
+                'The number of key blocks in the key cache that have changed but'
+                . ' haven\'t yet been flushed to disk. It used to be known as'
+                . ' Not_flushed_key_blocks.'
+            ),
+            'Key_blocks_unused' => __(
+                'The number of unused blocks in the key cache. You can use this'
+                . ' value to determine how much of the key cache is in use.'
+            ),
+            'Key_blocks_used' => __(
+                'The number of used blocks in the key cache. This value is a'
+                . ' high-water mark that indicates the maximum number of blocks'
+                . ' that have ever been in use at one time.'
+            ),
+            'Key_buffer_fraction_%' => __(
+                'Percentage of used key cache (calculated value)'
+            ),
+            'Key_read_requests' => __(
+                'The number of requests to read a key block from the cache.'
+            ),
+            'Key_reads' => __(
+                'The number of physical reads of a key block from disk. If Key_reads'
+                . ' is big, then your key_buffer_size value is probably too small.'
+                . ' The cache miss rate can be calculated as'
+                . ' Key_reads/Key_read_requests.'
+            ),
+            'Key_read_ratio_%' => __(
+                'Key cache miss calculated as rate of physical reads compared'
+                . ' to read requests (calculated value)'
+            ),
+            'Key_write_requests' => __(
+                'The number of requests to write a key block to the cache.'
+            ),
+            'Key_writes' => __(
+                'The number of physical writes of a key block to disk.'
+            ),
+            'Key_write_ratio_%' => __(
+                'Percentage of physical writes compared'
+                . ' to write requests (calculated value)'
+            ),
+            'Last_query_cost' => __(
+                'The total cost of the last compiled query as computed by the query'
+                . ' optimizer. Useful for comparing the cost of different query'
+                . ' plans for the same query. The default value of 0 means that'
+                . ' no query has been compiled yet.'
+            ),
+            'Max_used_connections' => __(
+                'The maximum number of connections that have been in use'
+                . ' simultaneously since the server started.'
+            ),
+            'Not_flushed_delayed_rows' => __(
+                'The number of rows waiting to be written in INSERT DELAYED queues.'
+            ),
+            'Opened_tables' => __(
+                'The number of tables that have been opened. If opened tables is'
+                . ' big, your table cache value is probably too small.'
+            ),
+            'Open_files' => __(
+                'The number of files that are open.'
+            ),
+            'Open_streams' => __(
+                'The number of streams that are open (used mainly for logging).'
+            ),
+            'Open_tables' => __(
+                'The number of tables that are open.'
+            ),
+            'Qcache_free_blocks' => __(
+                'The number of free memory blocks in query cache. High numbers can'
+                . ' indicate fragmentation issues, which may be solved by issuing'
+                . ' a FLUSH QUERY CACHE statement.'
+            ),
+            'Qcache_free_memory' => __(
+                'The amount of free memory for query cache.'
+            ),
+            'Qcache_hits' => __(
+                'The number of cache hits.'
+            ),
+            'Qcache_inserts' => __(
+                'The number of queries added to the cache.'
+            ),
+            'Qcache_lowmem_prunes' => __(
+                'The number of queries that have been removed from the cache to'
+                . ' free up memory for caching new queries. This information can'
+                . ' help you tune the query cache size. The query cache uses a'
+                . ' least recently used (LRU) strategy to decide which queries'
+                . ' to remove from the cache.'
+            ),
+            'Qcache_not_cached' => __(
+                'The number of non-cached queries (not cachable, or not cached'
+                . ' due to the query_cache_type setting).'
+            ),
+            'Qcache_queries_in_cache' => __(
+                'The number of queries registered in the cache.'
+            ),
+            'Qcache_total_blocks' => __(
+                'The total number of blocks in the query cache.'
+            ),
+            'Rpl_status' => __(
+                'The status of failsafe replication (not yet implemented).'
+            ),
+            'Select_full_join' => __(
+                'The number of joins that do not use indexes. If this value is'
+                . ' not 0, you should carefully check the indexes of your tables.'
+            ),
+            'Select_full_range_join' => __(
+                'The number of joins that used a range search on a reference table.'
+            ),
+            'Select_range_check' => __(
+                'The number of joins without keys that check for key usage after'
+                . ' each row. (If this is not 0, you should carefully check the'
+                . ' indexes of your tables.)'
+            ),
+            'Select_range' => __(
+                'The number of joins that used ranges on the first table. (It\'s'
+                . ' normally not critical even if this is big.)'
+            ),
+            'Select_scan' => __(
+                'The number of joins that did a full scan of the first table.'
+            ),
+            'Slave_open_temp_tables' => __(
+                'The number of temporary tables currently'
+                . ' open by the slave SQL thread.'
+            ),
+            'Slave_retried_transactions' => __(
+                'Total (since startup) number of times the replication slave SQL'
+                . ' thread has retried transactions.'
+            ),
+            'Slave_running' => __(
+                'This is ON if this server is a slave that is connected to a master.'
+            ),
+            'Slow_launch_threads' => __(
+                'The number of threads that have taken more than slow_launch_time'
+                . ' seconds to create.'
+            ),
+            'Slow_queries' => __(
+                'The number of queries that have taken more than long_query_time'
+                . ' seconds.'
+            ),
+            'Sort_merge_passes' => __(
+                'The number of merge passes the sort algorithm has had to do.'
+                . ' If this value is large, you should consider increasing the'
+                . ' value of the sort_buffer_size system variable.'
+            ),
+            'Sort_range' => __(
+                'The number of sorts that were done with ranges.'
+            ),
+            'Sort_rows' => __(
+                'The number of sorted rows.'
+            ),
+            'Sort_scan' => __(
+                'The number of sorts that were done by scanning the table.'
+            ),
+            'Table_locks_immediate' => __(
+                'The number of times that a table lock was acquired immediately.'
+            ),
+            'Table_locks_waited' => __(
+                'The number of times that a table lock could not be acquired'
+                . ' immediately and a wait was needed. If this is high, and you have'
+                . ' performance problems, you should first optimize your queries,'
+                . ' and then either split your table or tables or use replication.'
+            ),
+            'Threads_cached' => __(
+                'The number of threads in the thread cache. The cache hit rate can'
+                . ' be calculated as Threads_created/Connections. If this value is'
+                . ' red you should raise your thread_cache_size.'
+            ),
+            'Threads_connected' => __(
+                'The number of currently open connections.'
+            ),
+            'Threads_created' => __(
+                'The number of threads created to handle connections. If'
+                . ' Threads_created is big, you may want to increase the'
+                . ' thread_cache_size value. (Normally this doesn\'t give a notable'
+                . ' performance improvement if you have a good thread'
+                . ' implementation.)'
+            ),
+            'Threads_cache_hitrate_%' => __(
+                'Thread cache hit rate (calculated value)'
+            ),
+            'Threads_running' => __(
+                'The number of threads that are not sleeping.'
+            ),
+        ];
+    }
+}