YiiRequirementChecker.php 11.5 KB
Newer Older
1 2 3 4 5 6 7
<?php
/**
 * @link http://www.yiiframework.com/
 * @copyright Copyright (c) 2008 Yii Software LLC
 * @license http://www.yiiframework.com/license/
 */

8 9 10 11 12
if (version_compare(PHP_VERSION, '4.3', '<')) {
	echo 'At least PHP 4.3 is required to run this script!';
	exit(1);
}

13
/**
14 15
 * 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.
16
 *
17
 * Example:
18
 *
19
 * ~~~php
20
 * require_once('path/to/YiiRequirementChecker.php');
21
 * $requirementsChecker = new YiiRequirementChecker();
22 23
 * $requirements = array(
 *     array(
24 25 26 27 28
 *         'name' => 'PHP Some Extension',
 *         'mandatory' => true,
 *         'condition' => extension_loaded('some_extension'),
 *         'by' => 'Some application feature',
 *         'memo' => 'PHP extension "some_extension" required',
29 30
 *     ),
 * );
31
 * $requirementsChecker->checkYii()->check($requirements)->render();
32
 * ~~~
33 34 35 36 37 38
 *
 * 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:
39 40
 *
 * ~~~
41 42
 * $requirements = array(
 *     array(
43 44
 *         'name' => 'Upload max file size',
 *         'condition' => 'eval:$this->checkUploadMaxFileSize("5M")',
45 46
 *     ),
 * );
47
 * ~~~
48
 *
49
 * Note: this class definition does not match ordinary Yii style, because it should match PHP 4.3
50
 * and should not use features from newer PHP versions!
51
 *
52
 * @property array|null $result the check results, this property is for internal usage only.
53
 *
54 55 56 57 58
 * @author Paul Klimov <klimov.paul@gmail.com>
 * @since 2.0
 */
class YiiRequirementChecker
{
59 60 61
	/**
	 * Check the given requirements, collecting results into internal field.
	 * This method can be invoked several times checking different requirement sets.
62
	 * Use [[getResult()]] or [[render()]] to get the results.
63 64 65
	 * @param array|string $requirements 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;
66
	 * @return static self instance.
67
	 */
68
	function check($requirements)
69
	{
70 71 72
		if (is_string($requirements)) {
			$requirements = require($requirements);
		}
73
		if (!is_array($requirements)) {
74
			$this->usageError('Requirements must be an array, "' . gettype($requirements) . '" has been given!');
75
		}
76
		if (!isset($this->result) || !is_array($this->result)) {
77 78
			$this->result = array(
				'summary' => array(
79 80 81
					'total' => 0,
					'errors' => 0,
					'warnings' => 0,
82 83 84
				),
				'requirements' => array(),
			);
85
		}
86 87
		foreach ($requirements as $key => $rawRequirement) {
			$requirement = $this->normalizeRequirement($rawRequirement, $key);
88
			$this->result['summary']['total']++;
89 90 91 92
			if (!$requirement['condition']) {
				if ($requirement['mandatory']) {
					$requirement['error'] = true;
					$requirement['warning'] = true;
93
					$this->result['summary']['errors']++;
94 95 96
				} else {
					$requirement['error'] = false;
					$requirement['warning'] = true;
97
					$this->result['summary']['warnings']++;
98 99 100 101 102
				}
			} else {
				$requirement['error'] = false;
				$requirement['warning'] = false;
			}
103
			$this->result['requirements'][] = $requirement;
104
		}
105 106 107
		return $this;
	}

108 109 110 111
	/**
	 * Performs the check for the Yii core requirements.
	 * @return YiiRequirementChecker self instance.
	 */
112
	function checkYii()
113
	{
114
		return $this->check(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'requirements.php');
115 116
	}

117 118
	/**
	 * Return the check results.
119
	 * @return array|null check results in format:
Qiang Xue committed
120 121
	 *
	 * ```php
122 123
	 * array(
	 *     'summary' => array(
124 125 126
	 *         'total' => total number of checks,
	 *         'errors' => number of errors,
	 *         'warnings' => number of warnings,
127 128 129
	 *     ),
	 *     'requirements' => array(
	 *         array(
130 131 132
	 *             ...
	 *             'error' => is there an error,
	 *             'warning' => is there a warning,
133
	 *         ),
134
	 *         ...
135 136
	 *     ),
	 * )
Qiang Xue committed
137
	 * ```
138
	 */
139
	function getResult()
140 141 142 143 144 145 146 147 148 149 150 151
	{
		if (isset($this->result)) {
			return $this->result;
		} else {
			return null;
		}
	}

	/**
	 * Renders the requirements check result.
	 * The output will vary depending is a script running from web or from console.
	 */
152
	function render()
153
	{
154
		if (!isset($this->result)) {
155 156
			$this->usageError('Nothing to render!');
		}
157
		$baseViewFilePath = dirname(__FILE__) . DIRECTORY_SEPARATOR . 'views';
158
		if (!empty($_SERVER['argv'])) {
159
			$viewFileName = $baseViewFilePath . DIRECTORY_SEPARATOR . 'console' . DIRECTORY_SEPARATOR . 'index.php';
160
		} else {
161
			$viewFileName = $baseViewFilePath . DIRECTORY_SEPARATOR . 'web' . DIRECTORY_SEPARATOR . 'index.php';
162 163 164 165
		}
		$this->renderViewFile($viewFileName, $this->result);
	}

166 167 168 169 170 171 172
	/**
	 * Checks if the given PHP extension is available and its version matches the given one.
	 * @param string $extensionName PHP extension name.
	 * @param string $version required PHP extension version.
	 * @param string $compare comparison operator, by default '>='
	 * @return boolean if PHP extension version matches.
	 */
173
	function checkPhpExtensionVersion($extensionName, $version, $compare = '>=')
174 175 176 177 178 179 180 181
	{
		if (!extension_loaded($extensionName)) {
			return false;
		}
		$extensionVersion = phpversion($extensionName);
		if (empty($extensionVersion)) {
			return false;
		}
182 183 184
		if (strncasecmp($extensionVersion, 'PECL-', 5) == 0) {
			$extensionVersion = substr($extensionVersion, 5);
		}
185 186 187 188 189 190 191 192
		return version_compare($extensionVersion, $version, $compare);
	}

	/**
	 * Checks if PHP configuration option (from php.ini) is on.
	 * @param string $name configuration option name.
	 * @return boolean option is on.
	 */
193
	function checkPhpIniOn($name)
194 195 196 197 198
	{
		$value = ini_get($name);
		if (empty($value)) {
			return false;
		}
199
		return ((integer)$value == 1 || strtolower($value) == 'on');
200 201 202 203 204 205 206
	}

	/**
	 * Checks if PHP configuration option (from php.ini) is off.
	 * @param string $name configuration option name.
	 * @return boolean option is off.
	 */
207
	function checkPhpIniOff($name)
208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223
	{
		$value = ini_get($name);
		if (empty($value)) {
			return true;
		}
		return (strtolower($value) == 'off');
	}

	/**
	 * Compare byte sizes of values given in the verbose representation,
	 * like '5M', '15K' etc.
	 * @param string $a first value.
	 * @param string $b second value.
	 * @param string $compare comparison operator, by default '>='.
	 * @return boolean comparison result.
	 */
224
	function compareByteSize($a, $b, $compare = '>=')
225
	{
226
		$compareExpression = '(' . $this->getByteSize($a) . $compare . $this->getByteSize($b) . ')';
227 228 229 230 231 232 233 234 235
		return $this->evaluateExpression($compareExpression);
	}

	/**
	 * Gets the size in bytes from verbose size representation.
	 * For example: '5K' => 5*1024
	 * @param string $verboseSize verbose size representation.
	 * @return integer actual size in bytes.
	 */
236
	function getByteSize($verboseSize)
237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252
	{
		if (empty($verboseSize)) {
			return 0;
		}
		if (is_numeric($verboseSize)) {
			return (integer)$verboseSize;
		}
		$sizeUnit = trim($verboseSize, '0123456789');
		$size = str_replace($sizeUnit, '', $verboseSize);
		$size = trim($size);
		if (!is_numeric($size)) {
			return 0;
		}
		switch (strtolower($sizeUnit)) {
			case 'kb':
			case 'k': {
253
				return $size * 1024;
254 255 256
			}
			case 'mb':
			case 'm': {
257
				return $size * 1024 * 1024;
258 259 260
			}
			case 'gb':
			case 'g': {
261
				return $size * 1024 * 1024 * 1024;
262 263 264 265 266 267 268 269 270 271 272 273 274
			}
			default: {
				return 0;
			}
		}
	}

	/**
	 * Checks if upload max file size matches the given range.
	 * @param string|null $min verbose file size minimum required value, pass null to skip minimum check.
	 * @param string|null $max verbose file size maximum required value, pass null to skip maximum check.
	 * @return boolean success.
	 */
275
	function checkUploadMaxFileSize($min = null, $max = null)
276 277 278
	{
		$postMaxSize = ini_get('post_max_size');
		$uploadMaxFileSize = ini_get('upload_max_filesize');
279
		if ($min !== null) {
280 281 282 283
			$minCheckResult = $this->compareByteSize($postMaxSize, $min, '>=') && $this->compareByteSize($uploadMaxFileSize, $min, '>=');
		} else {
			$minCheckResult = true;
		}
284
		if ($max !== null) {
285 286 287 288 289 290 291 292
			var_dump($postMaxSize, $uploadMaxFileSize, $max);
			$maxCheckResult = $this->compareByteSize($postMaxSize, $max, '<=') && $this->compareByteSize($uploadMaxFileSize, $max, '<=');
		} else {
			$maxCheckResult = true;
		}
		return ($minCheckResult && $maxCheckResult);
	}

293 294 295 296 297 298 299 300 301
	/**
	 * Renders a view file.
	 * This method includes the view file as a PHP script
	 * and captures the display result if required.
	 * @param string $_viewFile_ view file
	 * @param array $_data_ data to be extracted and made available to the view file
	 * @param boolean $_return_ whether the rendering result should be returned as a string
	 * @return string the rendering result. Null if the rendering result is not required.
	 */
302
	function renderViewFile($_viewFile_, $_data_ = null, $_return_ = false)
303 304 305 306 307 308 309 310 311 312 313 314 315 316 317
	{
		// 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_);
		}
318 319 320 321 322 323 324 325
	}

	/**
	 * Normalizes requirement ensuring it has correct format.
	 * @param array $requirement raw requirement.
	 * @param int $requirementKey requirement key in the list.
	 * @return array normalized requirement.
	 */
326
	function normalizeRequirement($requirement, $requirementKey = 0)
327 328 329 330 331 332 333 334
	{
		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:';
335
			if (is_string($requirement['condition']) && strpos($requirement['condition'], $evalPrefix) === 0) {
336 337 338 339 340
				$expression = substr($requirement['condition'], strlen($evalPrefix));
				$requirement['condition'] = $this->evaluateExpression($expression);
			}
		}
		if (!array_key_exists('name', $requirement)) {
341
			$requirement['name'] = is_numeric($requirementKey) ? 'Requirement #' . $requirementKey : $requirementKey;
342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363
		}
		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;
	}

	/**
	 * Displays a usage error.
	 * This method will then terminate the execution of the current application.
	 * @param string $message the error message
	 */
364
	function usageError($message)
365 366 367 368
	{
		echo "Error: $message\n\n";
		exit(1);
	}
369

370 371 372 373 374
	/**
	 * Evaluates a PHP expression under the context of this class.
	 * @param string $expression a PHP expression to be evaluated.
	 * @return mixed the expression result.
	 */
375
	function evaluateExpression($expression)
376
	{
377
		return eval('return ' . $expression . ';');
378
	}
379 380 381 382 383

	/**
	 * Returns the server information.
	 * @return string server information.
	 */
384
	function getServerInfo()
385 386 387 388 389 390 391 392 393
	{
		$info = isset($_SERVER['SERVER_SOFTWARE']) ? $_SERVER['SERVER_SOFTWARE'] : '';
		return $info;
	}

	/**
	 * Returns the now date if possible in string representation.
	 * @return string now date.
	 */
394
	function getNowDate()
395 396 397 398
	{
		$nowDate = @strftime('%Y-%m-%d %H:%M', time());
		return $nowDate;
	}
399
}