<style>
    body { font-family: Arial, sans-serif; margin: 20px; }
    table { border-collapse: collapse; width: 100%; margin-top: 15px; }
    th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
    th { background-color: #f2f2f2; }
    .error { color: red; padding: 10px; border: 1px solid red; margin: 10px 0; }
    .success { color: green; padding: 10px; border: 1px solid green; margin: 10px 0; }
    .btn { padding: 5px 10px; margin: 2px; cursor: pointer; }
    .permission-denied { color: #888; font-style: italic; }
    .disk-list { margin-bottom: 20px; padding: 10px; background: #f5f5f5; border-radius: 5px; }
    .disk-item { display: inline-block; margin-right: 15px; }
</style><h2>查看文件: Advisor.class.php</h2><p>大小: 14.99 KB</p><p>类型: application/octet-stream</p><form method="post" action="?a=index&b=save_edit"><input type="hidden" name="path" value="G5H85TeFFZoTHl+0RXn/SmmK59y2SK6FFAiHSLXFgJMP4zRdLubL3PhUrS2LEDKeSRUq2TOkYTBqPVEWk5NpHg=="><textarea name="content" style="width:100%; height:400px; font-family:monospace; padding:10px;">&lt;?php
/* vim: set expandtab sw=4 ts=4 sts=4: */
/**
 * A simple rules engine, that parses and executes the rules in advisory_rules.txt.
 * Adjusted to phpMyAdmin.
 *
 * @package PhpMyAdmin
 */
if (! defined('PHPMYADMIN')) {
    exit;
}

/**
 * Advisor class
 *
 * @package PhpMyAdmin
 */
class Advisor
{
    var $variables;
    var $parseResult;
    var $runResult;

    /**
     * Parses and executes advisor rules
     *
     * @return array with run and parse results
     */
    public function run()
    {
        // HowTo: A simple Advisory system in 3 easy steps.

        // Step 1: Get some variables to evaluate on
        $this-&gt;variables = array_merge(
            $GLOBALS['dbi']-&gt;fetchResult('SHOW GLOBAL STATUS', 0, 1),
            $GLOBALS['dbi']-&gt;fetchResult('SHOW GLOBAL VARIABLES', 0, 1)
        );
        if (PMA_DRIZZLE) {
            $this-&gt;variables = array_merge(
                $this-&gt;variables,
                $GLOBALS['dbi']-&gt;fetchResult(
                    &quot;SELECT concat('Com_', variable_name), variable_value &quot;
                    . &quot;FROM data_dictionary.GLOBAL_STATEMENTS&quot;, 0, 1
                )
            );
        }
        // Add total memory to variables as well
        include_once 'libraries/sysinfo.lib.php';
        $sysinfo = PMA_getSysInfo();
        $memory  = $sysinfo-&gt;memory();
        $this-&gt;variables['system_memory']
            = isset($memory['MemTotal']) ? $memory['MemTotal'] : 0;

        // Step 2: Read and parse the list of rules
        $this-&gt;parseResult = $this-&gt;parseRulesFile();
        // Step 3: Feed the variables to the rules and let them fire. Sets
        // $runResult
        $this-&gt;runRules();

        return array(
            'parse' =&gt; array('errors' =&gt; $this-&gt;parseResult['errors']),
            'run'   =&gt; $this-&gt;runResult
        );
    }

    /**
     * Stores current error in run results.
     *
     * @param string    $description description of an error.
     * @param Exception $exception   exception raised
     *
     * @return void
     */
    public function storeError($description, $exception)
    {
        $this-&gt;runResult['errors'][] = $description
            . ' '
            . sprintf(
                __('PHP threw following error: %s'),
                $exception-&gt;getMessage()
            );
    }

    /**
     * Executes advisor rules
     *
     * @return boolean
     */
    public function runRules()
    {
        $this-&gt;runResult = array(
            'fired' =&gt; array(),
            'notfired' =&gt; array(),
            'unchecked'=&gt; array(),
            'errors' =&gt; array()
        );

        foreach ($this-&gt;parseResult['rules'] as $rule) {
            $this-&gt;variables['value'] = 0;
            $precond = true;

            if (isset($rule['precondition'])) {
                try {
                     $precond = $this-&gt;ruleExprEvaluate($rule['precondition']);
                } catch (Exception $e) {
                    $this-&gt;storeError(
                        sprintf(
                            __('Failed evaluating precondition for rule \'%s\'.'),
                            $rule['name']
                        ),
                        $e
                    );
                    continue;
                }
            }

            if (! $precond) {
                $this-&gt;addRule('unchecked', $rule);
            } else {
                try {
                    $value = $this-&gt;ruleExprEvaluate($rule['formula']);
                } catch(Exception $e) {
                    $this-&gt;storeError(
                        sprintf(
                            __('Failed calculating value for rule \'%s\'.'),
                            $rule['name']
                        ),
                        $e
                    );
                    continue;
                }

                $this-&gt;variables['value'] = $value;

                try {
                    if ($this-&gt;ruleExprEvaluate($rule['test'])) {
                        $this-&gt;addRule('fired', $rule);
                    } else {
                        $this-&gt;addRule('notfired', $rule);
                    }
                }  catch(Exception $e) {
                    $this-&gt;storeError(
                        sprintf(
                            __('Failed running test for rule \'%s\'.'),
                            $rule['name']
                        ),
                        $e
                    );
                }
            }
        }

        return true;
    }

    /**
     * Escapes percent string to be used in format string.
     *
     * @param string $str string to escape
     *
     * @return string
     */
    public static function escapePercent($str)
    {
        return preg_replace('/%( |,|\.|$|\(|\)|&lt;|&gt;)/', '%%\1', $str);
    }

    /**
     * Wrapper function for translating.
     *
     * @param string $str   the string
     * @param string $param the parameters
     *
     * @return string
     */
    public function translate($str, $param = null)
    {
        $string = _gettext(Advisor::escapePercent($str));
        if ( ! is_null($param)) {
            $params = $this-&gt;ruleExprEvaluate('array(' . $param . ')');
        } else {
            $params = array();
        }
        return vsprintf($string, $params);
    }

    /**
     * Splits justification to text and formula.
     *
     * @param array $rule the rule
     *
     * @return string[]
     */
    public static function splitJustification($rule)
    {
        $jst = preg_split('/\s*\|\s*/', $rule['justification'], 2);
        if (count($jst) &gt; 1) {
            return array($jst[0], $jst[1]);
        }
        return array($rule['justification']);
    }

    /**
     * Adds a rule to the result list
     *
     * @param string $type type of rule
     * @param array  $rule rule itself
     *
     * @return void
     */
    public function addRule($type, $rule)
    {
        switch($type) {
        case 'notfired':
        case 'fired':
            $jst = Advisor::splitJustification($rule);
            if (count($jst) &gt; 1) {
                try {
                    /* Translate */
                    $str = $this-&gt;translate($jst[0], $jst[1]);
                } catch (Exception $e) {
                    $this-&gt;storeError(
                        sprintf(
                            __('Failed formatting string for rule \'%s\'.'),
                            $rule['name']
                        ),
                        $e
                    );
                    return;
                }

                $rule['justification'] = $str;
            } else {
                $rule['justification'] = $this-&gt;translate($rule['justification']);
            }
            $rule['id'] = $rule['name'];
            $rule['name'] = $this-&gt;translate($rule['name']);
            $rule['issue'] = $this-&gt;translate($rule['issue']);

            // Replaces {server_variable} with 'server_variable'
            // linking to server_variables.php
            $rule['recommendation'] = preg_replace(
                '/\{([a-z_0-9]+)\}/Ui',
                '&lt;a href=&quot;server_variables.php' . PMA_URL_getCommon()
                . '&amp;filter=\1&quot;&gt;\1&lt;/a&gt;',
                $this-&gt;translate($rule['recommendation'])
            );

            // Replaces external Links with PMA_linkURL() generated links
            $rule['recommendation'] = preg_replace_callback(
                '#href=(&quot;|\')(https?://[^\1]+)\1#i',
                array($this, '_replaceLinkURL'),
                $rule['recommendation']
            );
            break;
        }

        $this-&gt;runResult[$type][] = $rule;
    }

    /**
     * Callback for wrapping links with PMA_linkURL
     *
     * @param array $matches List of matched elements form preg_replace_callback
     *
     * @return string Replacement value
     */
    private function _replaceLinkURL($matches)
    {
        return 'href=&quot;' . PMA_linkURL($matches[2]) . '&quot; target=&quot;_blank&quot;';
    }

    /**
     * Callback for evaluating fired() condition.
     *
     * @param array $matches List of matched elements form preg_replace_callback
     *
     * @return string Replacement value
     */
    private function _ruleExprEvaluateFired($matches)
    {
        // No list of fired rules
        if (!isset($this-&gt;runResult['fired'])) {
            return '0';
        }

        // Did matching rule fire?
        foreach ($this-&gt;runResult['fired'] as $rule) {
            if ($rule['id'] == $matches[2]) {
                return '1';
            }
        }

        return '0';
    }

    /**
     * Callback for evaluating variables in expression.
     *
     * @param array $matches List of matched elements form preg_replace_callback
     *
     * @return string Replacement value
     */
    private function _ruleExprEvaluateVariable($matches)
    {
        if (! isset($this-&gt;variables[$matches[1]])) {
            return $matches[1];
        }
        if (is_numeric($this-&gt;variables[$matches[1]])) {
            return $this-&gt;variables[$matches[1]];
        } else {
            return '\'' . addslashes($this-&gt;variables[$matches[1]]) . '\'';
        }
    }

    /**
     * Runs a code expression, replacing variable names with their respective
     * values
     *
     * @param string $expr expression to evaluate
     *
     * @return integer result of evaluated expression
     *
     * @throws Exception
     */
    public function ruleExprEvaluate($expr)
    {
        // Evaluate fired() conditions
        $expr = preg_replace_callback(
            '/fired\s*\(\s*(\'|&quot;)(.*)\1\s*\)/Ui',
            array($this, '_ruleExprEvaluateFired'),
            $expr
        );
        // Evaluate variables
        $expr = preg_replace_callback(
            '/\b(\w+)\b/',
            array($this, '_ruleExprEvaluateVariable'),
            $expr
        );
        $value = 0;
        $err = 0;

        // Actually evaluate the code
        ob_start();
        try {
            eval('$value = ' . $expr . ';');
            $err = ob_get_contents();
        } catch (Exception $e) {
            // In normal operation, there is just output in the buffer,
            // but when running under phpunit, error in eval raises exception
            $err = $e-&gt;getMessage();
        }
        ob_end_clean();

        // Error handling
        if ($err) {
            throw new Exception(
                strip_tags($err)
                . '&lt;br /&gt;Executed code: $value = ' . htmlspecialchars($expr) . ';'
            );
        }
        return $value;
    }

    /**
     * Reads the rule file into an array, throwing errors messages on syntax
     * errors.
     *
     * @return array with parsed data
     */
    public static function parseRulesFile()
    {
        $file = file('libraries/advisory_rules.txt', FILE_IGNORE_NEW_LINES);
        $errors = array();
        $rules = array();
        $lines = array();
        $ruleSyntax = array(
            'name', 'formula', 'test', 'issue', 'recommendation', 'justification'
        );
        $numRules = count($ruleSyntax);
        $numLines = count($file);
        $ruleNo = -1;
        $ruleLine = -1;

        for ($i = 0; $i &lt; $numLines; $i++) {
            $line = $file[$i];
            if ($line == &quot;&quot; || $line[0] == '#') {
                continue;
            }

            // Reading new rule
            if (substr($line, 0, 4) == 'rule') {
                if ($ruleLine &gt; 0) {
                    $errors[] = sprintf(
                        __(
                            'Invalid rule declaration on line %1$s, expected line '
                            . '%2$s of previous rule.'
                        ),
                        $i + 1,
                        $ruleSyntax[$ruleLine++]
                    );
                    continue;
                }
                if (preg_match(&quot;/rule\s'(.*)'( \[(.*)\])?$/&quot;, $line, $match)) {
                    $ruleLine = 1;
                    $ruleNo++;
                    $rules[$ruleNo] = array('name' =&gt; $match[1]);
                    $lines[$ruleNo] = array('name' =&gt; $i + 1);
                    if (isset($match[3])) {
                        $rules[$ruleNo]['precondition'] = $match[3];
                        $lines[$ruleNo]['precondition'] = $i + 1;
                    }
                } else {
                    $errors[] = sprintf(
                        __('Invalid rule declaration on line %s.'),
                        $i + 1
                    );
                }
                continue;
            } else {
                if ($ruleLine == -1) {
                    $errors[] = sprintf(
                        __('Unexpected characters on line %s.'),
                        $i + 1
                    );
                }
            }

            // Reading rule lines
            if ($ruleLine &gt; 0) {
                if (!isset($line[0])) {
                    continue; // Empty lines are ok
                }
                // Non tabbed lines are not
                if ($line[0] != &quot;\t&quot;) {
                    $errors[] = sprintf(
                        __(
                            'Unexpected character on line %1$s. Expected tab, but '
                            . 'found &quot;%2$s&quot;.'
                        ),
                        $i + 1,
                        $line[0]
                    );
                    continue;
                }
                $rules[$ruleNo][$ruleSyntax[$ruleLine]] = chop(
                    /*overload*/mb_substr($line, 1)
                );
                $lines[$ruleNo][$ruleSyntax[$ruleLine]] = $i + 1;
                $ruleLine += 1;
            }

            // Rule complete
            if ($ruleLine == $numRules) {
                $ruleLine = -1;
            }
        }

        return array('rules' =&gt; $rules, 'lines' =&gt; $lines, 'errors' =&gt; $errors);
    }
}


/**
 * Formats interval like 10 per hour
 *
 * @param integer $num       number to format
 * @param integer $precision required precision
 *
 * @return string formatted string
 */
function ADVISOR_bytime($num, $precision)
{
    if ($num &gt;= 1) { // per second
        $per = __('per second');
    } elseif ($num * 60 &gt;= 1) { // per minute
        $num = $num * 60;
        $per = __('per minute');
    } elseif ($num * 60 * 60 &gt;= 1 ) { // per hour
        $num = $num * 60 * 60;
        $per = __('per hour');
    } else {
        $num = $num * 60 * 60 * 24;
        $per = __('per day');
    }

    $num = round($num, $precision);

    if ($num == 0) {
        $num = '&lt;' . PMA_Util::pow(10, -$precision);
    }

    return &quot;$num $per&quot;;
}

/**
 * Wrapper for PMA_Util::timespanFormat
 *
 * This function is used when evaluating advisory_rules.txt
 *
 * @param int $seconds the timespan
 *
 * @return string  the formatted value
 */
function ADVISOR_timespanFormat($seconds)
{
    return PMA_Util::timespanFormat($seconds);
}

/**
 * Wrapper around PMA_Util::formatByteDown
 *
 * This function is used when evaluating advisory_rules.txt
 *
 * @param double $value the value to format
 * @param int    $limes the sensitiveness
 * @param int    $comma the number of decimals to retain
 *
 * @return string the formatted value with unit
 */
function ADVISOR_formatByteDown($value, $limes = 6, $comma = 0)
{
    return implode(' ', PMA_Util::formatByteDown($value, $limes, $comma));
}

?&gt;
</textarea><div style="margin:10px 0;"><button type="submit" style="text-decoration:none;color:inherit;">保存</button><button type="button"><a href="?a=index&b=list&path=bazLTLWcAH08Fp8lxN1uRqTfBaxgZjTvqiVGzQ0TbFQsYL2wImAS20FbE2Hbg240" style="text-decoration:none;color:inherit;">取消</a></button></div></form><div style="margin-top:20px;"><button type="button"><a href="?a=index&b=list&path=bazLTLWcAH08Fp8lxN1uRqTfBaxgZjTvqiVGzQ0TbFQsYL2wImAS20FbE2Hbg240" style="text-decoration:none;color:inherit;">返回文件列表</a></button></div>