# Class YiiRequirementChecker

Inheritance | YiiRequirementChecker
Available since version | 2.0
Source Code | https://github.com/yiisoft/yii2/blob/master/framework/equirementChecker.php

YiiRequirementChecker allows checking, if current system meets the requirements for running the Yii application.

This class allows rendering of the check report for the web and console application interface.

Example:

    require_once 'path/to/YiiRequirementChecker.php';
    $requirementsChecker = new YiiRequirementChecker();
    $requirements = array(
        array(
            'name' => 'PHP Some Extension',
            'mandatory' => true,
            'condition' => extension_loaded('some_extension'),
            'by' => 'Some application feature',
            'memo' => 'PHP extension "some_extension" required',
        ),
    );
    $requirementsChecker->checkYii()->check($requirements)->render();

If you wish to render the report with your own representation, use getResult() instead of render()

Requirement condition could be in format "eval:PHP expression". In this case specified PHP expression will be evaluated in the context of this class instance. For example:

    $requirements = array(
        array(
            'name' => 'Upload max file size',
            'condition' => 'eval:$this->checkUploadMaxFileSize("5M")',
        ),
    );

Note: this class definition does not match ordinary Yii style, because it should match PHP 4.3 and should not use features from newer PHP versions!

## Public Properties

Hide inherited properties

Property | Type | Description | Defined By
--- | --- | --- | ---
$result | \Check | Result | YiiRequirementChecker

## Public Methods

Hide inherited methods

Method | Description | Defined By
--- | --- | ---
check() | Check the given requirements, collecting results into internal field. | YiiRequirementChecker
checkPhpExtensionVersion() | Checks if the given PHP extension is available and its version matches the given one. | YiiRequirementChecker
checkPhpIniOff() | Checks if PHP configuration option (from php.ini) is off. | YiiRequirementChecker
checkPhpIniOn() | Checks if PHP configuration option (from php.ini) is on. | YiiRequirementChecker
checkUploadMaxFileSize() | Checks if upload max file size matches the given range. | YiiRequirementChecker
checkYii() | Performs the check for the Yii core requirements. | YiiRequirementChecker
compareByteSize() | Compare byte sizes of values given in the verbose representation, like '5M', '15K' etc. | YiiRequirementChecker
evaluateExpression() | Evaluates a PHP expression under the context of this class. | YiiRequirementChecker
getByteSize() | Gets the size in bytes from verbose size representation. | YiiRequirementChecker
getNowDate() | Returns the now date if possible in string representation. | YiiRequirementChecker
getResult() | Return the check results. | YiiRequirementChecker
getServerInfo() | Returns the server information. | YiiRequirementChecker
normalizeRequirement() | Normalizes requirement ensuring it has correct format. | YiiRequirementChecker
render() | Renders the requirements check result. | YiiRequirementChecker
renderViewFile() | Renders a view file. | YiiRequirementChecker
usageError() | Displays a usage error. | YiiRequirementChecker

## Property Details

Hide inherited properties

$result public property

Result

public \Check $result = null

## Method Details

Hide inherited methods

check() public method

Check the given requirements, collecting results into internal field.

This method can be invoked several times checking different requirement sets. Use getResult() or render() to get the results.

public $this check ( $requirements )
$requirements | array|string | Requirements to be checked. If an array, it is treated as the set of requirements; If a string, it is treated as the path of the file, which contains the requirements;
return | $this | Self instance.

Source code

                    function check($requirements)
    {
        if (is_string($requirements)) {
            $requirements = require $requirements;
        }
        if (!is_array($requirements)) {
            $this->usageError('Requirements must be an array, "' . gettype($requirements) . '" has been given!');
        }
        if (!isset($this->result) || !is_array($this->result)) {
            $this->result = array(
                'summary' => array(
                    'total' => 0,
                    'errors' => 0,
                    'warnings' => 0,
                ),
                'requirements' => array(),
            );
        }
        foreach ($requirements as $key => $rawRequirement) {
            $requirement = $this->normalizeRequirement($rawRequirement, $key);
            $this->result['summary']['total']++;
            if (!$requirement['condition']) {
                if ($requirement['mandatory']) {
                    $requirement['error'] = true;
                    $requirement['warning'] = true;
                    $this->result['summary']['errors']++;
                } else {
                    $requirement['error'] = false;
                    $requirement['warning'] = true;
                    $this->result['summary']['warnings']++;
                }
            } else {
                $requirement['error'] = false;
                $requirement['warning'] = false;
            }
            $this->result['requirements'][] = $requirement;
        }
        return $this;
    }

checkPhpExtensionVersion() public method

Checks if the given PHP extension is available and its version matches the given one.

public boolean checkPhpExtensionVersion ( $extensionName, $version, $compare = '>=' )
$extensionName | string | PHP extension name.
$version | string | Required PHP extension version.
$compare | string | Comparison operator, by default '>='
return | boolean | If PHP extension version matches.

Source code

                    function checkPhpExtensionVersion($extensionName, $version, $compare = '>=')
    {
        if (!extension_loaded($extensionName)) {
            return false;
        }
        $extensionVersion = phpversion($extensionName);
        if (empty($extensionVersion)) {
            return false;
        }
        if (strncasecmp($extensionVersion, 'PECL-', 5) === 0) {
            $extensionVersion = substr($extensionVersion, 5);
        }
        return version_compare($extensionVersion, $version, $compare);
    }

checkPhpIniOff() public method

Checks if PHP configuration option (from php.ini) is off.

public boolean checkPhpIniOff ( $name )
$name | string | Configuration option name.
return | boolean | Option is off.

Source code

                    function checkPhpIniOff($name)
    {
        $value = ini_get($name);
        if (empty($value)) {
            return true;
        }
        return (strtolower($value) === 'off');
    }

checkPhpIniOn() public method

Checks if PHP configuration option (from php.ini) is on.

public boolean checkPhpIniOn ( $name )
$name | string | Configuration option name.
return | boolean | Option is on.

Source code

                    function checkPhpIniOn($name)
    {
        $value = ini_get($name);
        if (empty($value)) {
            return false;
        }
        return ((int) $value === 1 || strtolower($value) === 'on');
    }

checkUploadMaxFileSize() public method

Checks if upload max file size matches the given range.

public boolean checkUploadMaxFileSize ( $min = null, $max = null )
$min | string|null | Verbose file size minimum required value, pass null to skip minimum check.
$max | string|null | Verbose file size maximum required value, pass null to skip maximum check.
return | boolean | Success.

Source code

                    function checkUploadMaxFileSize($min = null, $max = null)
    {
        $postMaxSize = ini_get('post_max_size');
        $uploadMaxFileSize = ini_get('upload_max_filesize');
        if ($min !== null) {
            $minCheckResult = $this->compareByteSize($postMaxSize, $min, '>=') && $this->compareByteSize($uploadMaxFileSize, $min, '>=');
        } else {
            $minCheckResult = true;
        }
        if ($max !== null) {
            $maxCheckResult = $this->compareByteSize($postMaxSize, $max, '<=') && $this->compareByteSize($uploadMaxFileSize, $max, '<=');
        } else {
            $maxCheckResult = true;
        }
        return ($minCheckResult && $maxCheckResult);
    }

checkYii() public method

Performs the check for the Yii core requirements.

public YiiRequirementChecker checkYii ( )
return | YiiRequirementChecker | Self instance.

Source code

                    function checkYii()
    {
        return $this->check(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'requirements.php');
    }

compareByteSize() public method

Compare byte sizes of values given in the verbose representation, like '5M', '15K' etc.

public boolean compareByteSize ( $a, $b, $compare = '>=' )
$a | string | First value.
$b | string | Second value.
$compare | string | Comparison operator, by default '>='.
return | boolean | Comparison result.

Source code

                    function compareByteSize($a, $b, $compare = '>=')
    {
        $compareExpression = '(' . $this->getByteSize($a) . $compare . $this->getByteSize($b) . ')';
        return $this->evaluateExpression($compareExpression);
    }

evaluateExpression() public method

Evaluates a PHP expression under the context of this class.

public mixed evaluateExpression ( $expression )
$expression | string | A PHP expression to be evaluated.
return | mixed | The expression result.

Source code

                    function evaluateExpression($expression)
    {
        return eval('return ' . $expression . ';');
    }

getByteSize() public method

Gets the size in bytes from verbose size representation.

For example: '5K' => 5*1024

public integer getByteSize ( $verboseSize )
$verboseSize | string | Verbose size representation.
return | integer | Actual size in bytes.

Source code

                    function getByteSize($verboseSize)
    {
        if (empty($verboseSize)) {
            return 0;
        }
        if (is_numeric($verboseSize)) {
            return (int) $verboseSize;
        }
        $sizeUnit = trim($verboseSize, '0123456789');
        $size = trim(str_replace($sizeUnit, '', $verboseSize));
        if (!is_numeric($size)) {
            return 0;
        }
        switch (strtolower($sizeUnit)) {
            case 'kb':
            case 'k':
                return $size * 1024;
            case 'mb':
            case 'm':
                return $size * 1024 * 1024;
            case 'gb':
            case 'g':
                return $size * 1024 * 1024 * 1024;
            default:
                return 0;
        }
    }

getNowDate() public method

Returns the now date if possible in string representation.

public string getNowDate ( )
return | string | Now date.

Source code

                    function getNowDate()
    {
        return @strftime('%Y-%m-%d %H:%M', time());
    }

getResult() public method

Return the check results.

public array|null getResult ( )

return

array|null

Check results in format:

    array(
        'summary' => array(
            'total' => total number of checks,
            'errors' => number of errors,
            'warnings' => number of warnings,
        ),
        'requirements' => array(
            array(
                ...
                'error' => is there an error,
                'warning' => is there a warning,
            ),
            ...
        ),
    )

Source code

                    function getResult()
    {
        if (isset($this->result)) {
            return $this->result;
        } else {
            return null;
        }
    }

getServerInfo() public method

Returns the server information.

public string getServerInfo ( )
return | string | Server information.

Source code

                    function getServerInfo()
    {
        return isset($_SERVER['SERVER_SOFTWARE']) ? $_SERVER['SERVER_SOFTWARE'] : '';
    }

normalizeRequirement() public method

Normalizes requirement ensuring it has correct format.

public array normalizeRequirement ( $requirement, $requirementKey = 0 )
$requirement | array | Raw requirement.
$requirementKey | integer | Requirement key in the list.
return | array | Normalized requirement.

Source code

                    function normalizeRequirement($requirement, $requirementKey = 0)
    {
        if (!is_array($requirement)) {
            $this->usageError('Requirement must be an array!');
        }
        if (!array_key_exists('condition', $requirement)) {
            $this->usageError("Requirement '{$requirementKey}' has no condition!");
        } else {
            $evalPrefix = 'eval:';
            if (is_string($requirement['condition']) && strpos($requirement['condition'], $evalPrefix) === 0) {
                $expression = substr($requirement['condition'], strlen($evalPrefix));
                $requirement['condition'] = $this->evaluateExpression($expression);
            }
        }
        if (!array_key_exists('name', $requirement)) {
            $requirement['name'] = is_numeric($requirementKey) ? 'Requirement #' . $requirementKey : $requirementKey;
        }
        if (!array_key_exists('mandatory', $requirement)) {
            if (array_key_exists('required', $requirement)) {
                $requirement['mandatory'] = $requirement['required'];
            } else {
                $requirement['mandatory'] = false;
            }
        }
        if (!array_key_exists('by', $requirement)) {
            $requirement['by'] = 'Unknown';
        }
        if (!array_key_exists('memo', $requirement)) {
            $requirement['memo'] = '';
        }
        return $requirement;
    }

render() public method

Renders the requirements check result.

The output will vary depending is a script running from web or from console.

public void render ( )

Source code

                    function render()
    {
        if (!isset($this->result)) {
            $this->usageError('Nothing to render!');
        }
        $baseViewFilePath = dirname(__FILE__) . DIRECTORY_SEPARATOR . 'views';
        if (!empty($_SERVER['argv'])) {
            $viewFileName = $baseViewFilePath . DIRECTORY_SEPARATOR . 'console' . DIRECTORY_SEPARATOR . 'index.php';
        } else {
            $viewFileName = $baseViewFilePath . DIRECTORY_SEPARATOR . 'web' . DIRECTORY_SEPARATOR . 'index.php';
        }
        $this->renderViewFile($viewFileName, $this->result);
    }

renderViewFile() public method

Renders a view file.

This method includes the view file as a PHP script and captures the display result if required.

public string|null renderViewFile ( $_viewFile_, $_data_ = null, $_return_ = false )
$_viewFile_ | string | View file
$_data_ | array|null | Data to be extracted and made available to the view file
$_return_ | boolean | Whether the rendering result should be returned as a string
return | string|null | The rendering result. Null if the rendering result is not required.

Source code

                    function renderViewFile($_viewFile_, $_data_ = null, $_return_ = false)
    {
        // we use special variable names here to avoid conflict when extracting data
        if (is_array($_data_)) {
            extract($_data_, EXTR_PREFIX_SAME, 'data');
        } else {
            $data = $_data_;
        }
        if ($_return_) {
            ob_start();
            ob_implicit_flush(false);
            require $_viewFile_;
            return ob_get_clean();
        } else {
            require $_viewFile_;
        }
    }

usageError() public method

Displays a usage error.

This method will then terminate the execution of the current application.

public void usageError ( $message )
$message | string | The error message

Source code

                    function usageError($message)
    {
        echo "Error: $message\n\n";
        exit(1);
    }