libdir.'/xmlize.php');
/// Define a buch of XML processing errors
define('NO_ERROR', 0);
define('NO_VERSION_DATA_FOUND', 1);
define('NO_DATABASE_SECTION_FOUND', 2);
define('NO_DATABASE_VENDORS_FOUND', 3);
define('NO_DATABASE_VENDOR_MYSQL_FOUND', 4);
define('NO_DATABASE_VENDOR_POSTGRES_FOUND', 5);
define('NO_PHP_SECTION_FOUND', 6);
define('NO_PHP_VERSION_FOUND', 7);
define('NO_PHP_EXTENSIONS_SECTION_FOUND', 8);
define('NO_PHP_EXTENSIONS_NAME_FOUND', 9);
define('NO_DATABASE_VENDOR_VERSION_FOUND', 10);
define('NO_UNICODE_SECTION_FOUND', 11);
define('NO_CUSTOM_CHECK_FOUND', 12);
define('CUSTOM_CHECK_FILE_MISSING', 13);
define('CUSTOM_CHECK_FUNCTION_MISSING', 14);
/**
* This function will perform the whole check, returning
* true or false as final result. Also, he full array of
* environment_result will be returned in the parameter list.
* The function looks for the best version to compare and
* everything. This is the only function that should be called
* ever from the rest of Moodle.
* @param string version version to check.
* @param array results array of results checked.
* @param boolean true/false, whether to print the table or just return results array
* @return boolean true/false, depending of results
*/
function check_moodle_environment($version, &$environment_results, $print_table=true) {
$status = true;
/// This are cached per request
static $result = true;
static $env_results;
static $cache_exists = false;
/// if we have results cached, use them
if ($cache_exists) {
$environment_results = $env_results;
/// No cache exists, calculate everything
} else {
/// Get the more recent version before the requested
if (!$version = get_latest_version_available($version)) {
$status = false;
}
/// Perform all the checks
if (!($environment_results = environment_check($version)) && $status) {
$status = false;
}
/// Iterate over all the results looking for some error in required items
/// or some error_code
if ($status) {
foreach ($environment_results as $environment_result) {
if (!$environment_result->getStatus() && $environment_result->getLevel() == 'required'
&& !$environment_result->getBypassStr()) {
$result = false; // required item that is not bypased
} else if ($environment_result->getStatus() && $environment_result->getLevel() == 'required'
&& $environment_result->getRestrictStr()) {
$result = false; // required item that is restricted
} else if ($environment_result->getErrorCode()) {
$result = false;
}
}
}
/// Going to end, we store environment_results to cache
$env_results = $environment_results;
$cache_exists = true;
} ///End of cache block
/// If we have decided to print all the information, just do it
if ($print_table) {
print_moodle_environment($result && $status, $environment_results);
}
return ($result && $status);
}
/**
* This function will print one beautiful table with all the environmental
* configuration and how it suits Moodle needs.
* @param boolean final result of the check (true/false)
* @param array environment_results array of results gathered
*/
function print_moodle_environment($result, $environment_results) {
/// Get some strings
$strname = get_string('name');
$strinfo = get_string('info');
$strreport = get_string('report');
$strstatus = get_string('status');
$strok = get_string('ok');
$strerror = get_string('error');
$strcheck = get_string('check');
$strbypassed = get_string('bypassed');
$strrestricted = get_string('restricted');
$strenvironmenterrortodo = get_string('environmenterrortodo', 'admin');
/// Table headers
$servertable = new stdClass;//table for server checks
$servertable->head = array ($strname, $strinfo, $strreport, $strstatus);
$servertable->align = array ('center', 'center', 'left', 'center');
$servertable->wrap = array ('nowrap', '', '', 'nowrap');
$servertable->size = array ('10', 10, '100%', '10');
$servertable->width = '90%';
$servertable->class = 'environmenttable generaltable';
$serverdata = array('ok'=>array(), 'warn'=>array(), 'error'=>array());
$othertable = new stdClass;//table for custom checks
$othertable->head = array ($strinfo, $strreport, $strstatus);
$othertable->align = array ('center', 'left', 'center');
$othertable->wrap = array ('', '', 'nowrap');
$othertable->size = array (10, '100%', '10');
$othertable->width = '90%';
$othertable->class = 'environmenttable generaltable';
$otherdata = array('ok'=>array(), 'warn'=>array(), 'error'=>array());
/// Iterate over each environment_result
$continue = true;
foreach ($environment_results as $environment_result) {
$errorline = false;
$warningline = false;
if ($continue) {
$type = $environment_result->getPart();
$info = $environment_result->getInfo();
$status = $environment_result->getStatus();
$error_code = $environment_result->getErrorCode();
/// Process Report field
$rec = new stdClass();
/// Something has gone wrong at parsing time
if ($error_code) {
$stringtouse = 'environmentxmlerror';
$rec->error_code = $error_code;
$status = $strerror;
$errorline = true;
$continue = false;
}
if ($continue) {
/// We are comparing versions
if ($rec->needed = $environment_result->getNeededVersion()) {
$rec->current = $environment_result->getCurrentVersion();
if ($environment_result->getLevel() == 'required') {
$stringtouse = 'environmentrequireversion';
} else {
$stringtouse = 'environmentrecommendversion';
}
/// We are checking installed & enabled things
} else if ($environment_result->getPart() == 'custom_check') {
if ($environment_result->getLevel() == 'required') {
$stringtouse = 'environmentrequirecustomcheck';
} else {
$stringtouse = 'environmentrecommendcustomcheck';
}
} else {
if ($environment_result->getLevel() == 'required') {
$stringtouse = 'environmentrequireinstall';
} else {
$stringtouse = 'environmentrecommendinstall';
}
}
/// Calculate the status value
if ($environment_result->getBypassStr() != '') { //Handle bypassed result (warning)
$status = $strbypassed;
$warningline = true;
} else if ($environment_result->getRestrictStr() != '') { //Handle restricted result (error)
$status = $strrestricted;
$errorline = true;
} else {
if ($status) { //Handle ok result (ok)
$status = $strok;
} else {
if ($environment_result->getLevel() == 'optional') {//Handle check result (warning)
$status = $strcheck;
$warningline = true;
} else { //Handle error result (error)
$status = $strcheck;
$errorline = true;
}
}
}
}
/// Build the text
$linkparts = array();
$linkparts[] = 'admin/environment';
$linkparts[] = $type;
if (!empty($info)){
$linkparts[] = $info;
}
$report = doc_link(join($linkparts, '/'), get_string($stringtouse, 'admin', $rec));
/// Format error or warning line
if ($errorline || $warningline) {
$messagetype = $errorline? 'error':'warn';
} else {
$messagetype = 'ok';
}
$status = ''.$status.'';
/// Here we'll store all the feedback found
$feedbacktext = '';
///Append the feedback if there is some
$feedbacktext .= $environment_result->strToReport($environment_result->getFeedbackStr(), $messagetype);
///Append the bypass if there is some
$feedbacktext .= $environment_result->strToReport($environment_result->getBypassStr(), 'warn');
///Append the restrict if there is some
$feedbacktext .= $environment_result->strToReport($environment_result->getRestrictStr(), 'error');
$report .= $feedbacktext;
/// Add the row to the table
if ($environment_result->getPart() == 'custom_check'){
$otherdata[$messagetype][] = array ($info, $report, $status);
} else {
$serverdata[$messagetype][] = array ($type, $info, $report, $status);
}
}
}
//put errors first in
$servertable->data = array_merge($serverdata['error'], $serverdata['warn'], $serverdata['ok']);
$othertable->data = array_merge($otherdata['error'], $otherdata['warn'], $otherdata['ok']);
/// Print table
print_heading(get_string('serverchecks', 'admin'));
print_table($servertable);
if (count($othertable->data)){
print_heading(get_string('customcheck', 'admin'));
print_table($othertable);
}
/// Finally, if any error has happened, print the summary box
if (!$result) {
print_simple_box($strenvironmenterrortodo, 'center', '', '', '', 'environmentbox errorbox');
}
}
/**
* This function will normalize any version to just a serie of numbers
* separated by dots. Everything else will be removed.
* @param string $version the original version
* @return string the normalized version
*/
function normalize_version($version) {
/// 1.9 Beta 2 should be read 1.9 on enviromental checks, not 1.9.2
/// we can discard everything after the first space
$version = trim($version);
$versionarr = explode(" ",$version);
if (!empty($versionarr)) {
$version = $versionarr[0];
}
/// Replace everything but numbers and dots by dots
$version = preg_replace('/[^\.\d]/', '.', $version);
/// Combine multiple dots in one
$version = preg_replace('/(\.{2,})/', '.', $version);
/// Trim possible leading and trailing dots
$version = trim($version, '.');
return $version;
}
/**
* This function will load the environment.xml file and xmlize it
* @return mixed the xmlized structure or false on error
*/
function load_environment_xml() {
global $CFG;
static $data; //Only load and xmlize once by request
if (!empty($data)) {
return $data;
}
/// First of all, take a look inside $CFG->dataroot/environment/environment.xml
$file = $CFG->dataroot.'/environment/environment.xml';
$internalfile = $CFG->dirroot.'/'.$CFG->admin.'/environment.xml';
if (!is_file($file) || !is_readable($file) || filemtime($file) < filemtime($internalfile) ||
!$contents = file_get_contents($file)) {
/// Fallback to fixed $CFG->admin/environment.xml
if (!is_file($internalfile) || !is_readable($internalfile) || !$contents = file_get_contents($internalfile)) {
return false;
}
}
/// XML the whole file
$data = xmlize($contents);
return $data;
}
/**
* This function will return the list of Moodle versions available
* @return mixed array of versions. False on error.
*/
function get_list_of_environment_versions ($contents) {
static $versions = array();
if (!empty($versions)) {
return $versions;
}
if (isset($contents['COMPATIBILITY_MATRIX']['#']['MOODLE'])) {
foreach ($contents['COMPATIBILITY_MATRIX']['#']['MOODLE'] as $version) {
$versions[] = $version['@']['version'];
}
}
return $versions;
}
/**
* This function will return the most recent version in the environment.xml
* file previous or equal to the version requested
* @param string version top version from which we start to look backwards
* @return string more recent version or false if not found
*/
function get_latest_version_available ($version) {
/// Normalize the version requested
$version = normalize_version($version);
/// Load xml file
if (!$contents = load_environment_xml()) {
return false;
}
/// Detect available versions
if (!$versions = get_list_of_environment_versions($contents)) {
return false;
}
/// First we look for exact version
if (in_array($version, $versions)) {
return $version;
} else {
$found_version = false;
/// Not exact match, so we are going to iterate over the list searching
/// for the latest version before the requested one
foreach ($versions as $arrversion) {
if (version_compare($arrversion, $version, '<')) {
$found_version = $arrversion;
}
}
}
return $found_version;
}
/**
* This function will return the xmlized data belonging to one Moodle version
* @return mixed the xmlized structure or false on error
*/
function get_environment_for_version($version) {
/// Normalize the version requested
$version = normalize_version($version);
/// Load xml file
if (!$contents = load_environment_xml()) {
return false;
}
/// Detect available versions
if (!$versions = get_list_of_environment_versions($contents)) {
return false;
}
/// If the version requested is available
if (!in_array($version, $versions)) {
return false;
}
/// We now we have it. Extract from full contents.
$fl_arr = array_flip($versions);
return $contents['COMPATIBILITY_MATRIX']['#']['MOODLE'][$fl_arr[$version]];
}
/**
* This function will check for everything (DB, PHP and PHP extensions for now)
* returning an array of environment_result objects.
* @param string $version xml version we are going to use to test this server
* @return array array of results encapsulated in one environment_result object
*/
function environment_check($version) {
global $CFG;
/// Normalize the version requested
$version = normalize_version($version);
$results = array(); //To store all the results
/// Only run the moodle versions checker on upgrade, not on install
if (empty($CFG->running_installer)) {
$results[] = environment_check_moodle($version);
}
$results[] = environment_check_unicode($version);
$results[] = environment_check_database($version);
$results[] = environment_check_php($version);
$phpext_results = environment_check_php_extensions($version);
$results = array_merge($results, $phpext_results);
$custom_results = environment_custom_checks($version);
$results = array_merge($results, $custom_results);
return $results;
}
/**
* This function will check if php extensions requirements are satisfied
* @param string $version xml version we are going to use to test this server
* @return array array of results encapsulated in one environment_result object
*/
function environment_check_php_extensions($version) {
$results = array();
/// Get the enviroment version we need
if (!$data = get_environment_for_version($version)) {
/// Error. No version data found
$result = new environment_results('php_extension');
$result->setStatus(false);
$result->setErrorCode(NO_VERSION_DATA_FOUND);
return array($result);
}
/// Extract the php_extension part
if (!isset($data['#']['PHP_EXTENSIONS']['0']['#']['PHP_EXTENSION'])) {
/// Error. No PHP section found
$result = new environment_results('php_extension');
$result->setStatus(false);
$result->setErrorCode(NO_PHP_EXTENSIONS_SECTION_FOUND);
return array($result);
}
/// Iterate over extensions checking them and creating the needed environment_results
foreach($data['#']['PHP_EXTENSIONS']['0']['#']['PHP_EXTENSION'] as $extension) {
$result = new environment_results('php_extension');
/// Check for level
$level = get_level($extension);
/// Check for extension name
if (!isset($extension['@']['name'])) {
$result->setStatus(false);
$result->setErrorCode(NO_PHP_EXTENSIONS_NAME_FOUND);
} else {
$extension_name = $extension['@']['name'];
/// The name exists. Just check if it's an installed extension
if (!extension_loaded($extension_name)) {
$result->setStatus(false);
} else {
$result->setStatus(true);
}
$result->setLevel($level);
$result->setInfo($extension_name);
}
/// Do any actions defined in the XML file.
process_environment_result($extension, $result);
/// Add the result to the array of results
$results[] = $result;
}
return $results;
}
/**
* This function will do the custom checks.
* @param string $version xml version we are going to use to test this server.
* @return array array of results encapsulated in environment_result objects.
*/
function environment_custom_checks($version) {
global $CFG;
$results = array();
/// Get current Moodle version (release) for later compare
$release = isset($CFG->release) ? $CFG->release : $version; /// In case $CFG fails (at install) use $version
$current_version = normalize_version($release);
/// Get the enviroment version we need
if (!$data = get_environment_for_version($version)) {
/// Error. No version data found - but this will already have been reported.
return $results;
}
/// Extract the CUSTOM_CHECKS part
if (!isset($data['#']['CUSTOM_CHECKS']['0']['#']['CUSTOM_CHECK'])) {
/// No custom checks found - not a problem
return $results;
}
/// Iterate over extensions checking them and creating the needed environment_results
foreach($data['#']['CUSTOM_CHECKS']['0']['#']['CUSTOM_CHECK'] as $check) {
$result = new environment_results('custom_check');
/// Check for level
$level = get_level($check);
/// Check for extension name
if (isset($check['@']['file']) && isset($check['@']['function'])) {
$file = $CFG->dirroot . '/' . $check['@']['file'];
$function = $check['@']['function'];
if (is_readable($file)) {
include_once($file);
if (function_exists($function)) {
$result->setLevel($level);
$result->setInfo($function);
$result = $function($result);
} else {
/// Only show error for current version (where function MUST exist)
/// else, we are performing custom checks against future versiosn
/// and function MAY not exist, so it doesn't cause error, just skip
/// custom check by returning null. MDL-15939
if (version_compare($current_version, $version, '>=')) {
$result->setStatus(false);
$result->setInfo($function);
$result->setErrorCode(CUSTOM_CHECK_FUNCTION_MISSING);
} else {
$result = null;
}
}
} else {
/// Only show error for current version (where function MUST exist)
/// else, we are performing custom checks against future versiosn
/// and function MAY not exist, so it doesn't cause error, just skip
/// custom check by returning null. MDL-15939
if (version_compare($current_version, $version, '>=')) {
$result->setStatus(false);
$result->setInfo($function);
$result->setErrorCode(CUSTOM_CHECK_FILE_MISSING);
} else {
$result = null;
}
}
} else {
$result->setStatus(false);
$result->setErrorCode(NO_CUSTOM_CHECK_FOUND);
}
if (!is_null($result)) {
/// Do any actions defined in the XML file.
process_environment_result($check, $result);
/// Add the result to the array of results
$results[] = $result;
}
}
return $results;
}
/**
* This function will check if Moodle requirements are satisfied
* @param string $version xml version we are going to use to test this server
* @return object results encapsulated in one environment_result object
*/
function environment_check_moodle($version) {
$result = new environment_results('moodle');
/// Get the enviroment version we need
if (!$data = get_environment_for_version($version)) {
/// Error. No version data found
$result->setStatus(false);
$result->setErrorCode(NO_VERSION_DATA_FOUND);
return $result;
}
/// Extract the moodle part
if (!isset($data['@']['requires'])) {
$needed_version = '1.0'; /// Default to 1.0 if no moodle requires is found
} else {
/// Extract required moodle version
$needed_version = $data['@']['requires'];
}
/// Now search the version we are using
$current_version = normalize_version(get_config('', 'release'));
/// And finally compare them, saving results
if (version_compare($current_version, $needed_version, '>=')) {
$result->setStatus(true);
} else {
$result->setStatus(false);
}
$result->setLevel('required');
$result->setCurrentVersion($current_version);
$result->setNeededVersion($needed_version);
return $result;
}
/**
* This function will check if php requirements are satisfied
* @param string $version xml version we are going to use to test this server
* @return object results encapsulated in one environment_result object
*/
function environment_check_php($version) {
$result = new environment_results('php');
/// Get the enviroment version we need
if (!$data = get_environment_for_version($version)) {
/// Error. No version data found
$result->setStatus(false);
$result->setErrorCode(NO_VERSION_DATA_FOUND);
return $result;
}
/// Extract the php part
if (!isset($data['#']['PHP'])) {
/// Error. No PHP section found
$result->setStatus(false);
$result->setErrorCode(NO_PHP_SECTION_FOUND);
return $result;
} else {
/// Extract level and version
$level = get_level($data['#']['PHP']['0']);
if (!isset($data['#']['PHP']['0']['@']['version'])) {
$result->setStatus(false);
$result->setErrorCode(NO_PHP_VERSION_FOUND);
return $result;
} else {
$needed_version = $data['#']['PHP']['0']['@']['version'];
}
}
/// Now search the version we are using
$current_version = normalize_version(phpversion());
/// And finally compare them, saving results
if (version_compare($current_version, $needed_version, '>=')) {
$result->setStatus(true);
} else {
$result->setStatus(false);
}
$result->setLevel($level);
$result->setCurrentVersion($current_version);
$result->setNeededVersion($needed_version);
/// Do any actions defined in the XML file.
process_environment_result($data['#']['PHP'][0], $result);
return $result;
}
/**
* This function will check if unicode database requirements are satisfied
* @param string $version xml version we are going to use to test this server
* @return object results encapsulated in one environment_result object
*/
function environment_check_unicode($version) {
global $db;
$result = new environment_results('unicode');
/// Get the enviroment version we need
if (!$data = get_environment_for_version($version)) {
/// Error. No version data found
$result->setStatus(false);
$result->setErrorCode(NO_VERSION_DATA_FOUND);
return $result;
}
/// Extract the unicode part
if (!isset($data['#']['UNICODE'])) {
/// Error. No UNICODE section found
$result->setStatus(false);
$result->setErrorCode(NO_UNICODE_SECTION_FOUND);
return $result;
} else {
/// Extract level
$level = get_level($data['#']['UNICODE']['0']);
}
if (!$unicodedb = setup_is_unicodedb()) {
$result->setStatus(false);
} else {
$result->setStatus(true);
}
$result->setLevel($level);
/// Do any actions defined in the XML file.
process_environment_result($data['#']['UNICODE'][0], $result);
return $result;
}
/**
* This function will check if database requirements are satisfied
* @param string $version xml version we are going to use to test this server
* @return object results encapsulated in one environment_result object
*/
function environment_check_database($version) {
global $db;
$result = new environment_results('database');
$vendors = array(); //Array of vendors in version
/// Get the enviroment version we need
if (!$data = get_environment_for_version($version)) {
/// Error. No version data found
$result->setStatus(false);
$result->setErrorCode(NO_VERSION_DATA_FOUND);
return $result;
}
/// Extract the database part
if (!isset($data['#']['DATABASE'])) {
/// Error. No DATABASE section found
$result->setStatus(false);
$result->setErrorCode(NO_DATABASE_SECTION_FOUND);
return $result;
} else {
/// Extract level
$level = get_level($data['#']['DATABASE']['0']);
}
/// Extract DB vendors. At least 2 are mandatory (mysql & postgres)
if (!isset($data['#']['DATABASE']['0']['#']['VENDOR'])) {
/// Error. No VENDORS found
$result->setStatus(false);
$result->setErrorCode(NO_DATABASE_VENDORS_FOUND);
return $result;
} else {
/// Extract vendors
foreach ($data['#']['DATABASE']['0']['#']['VENDOR'] as $vendor) {
if (isset($vendor['@']['name']) && isset($vendor['@']['version'])) {
$vendors[$vendor['@']['name']] = $vendor['@']['version'];
$vendorsxml[$vendor['@']['name']] = $vendor;
}
}
}
/// Check we have the mysql vendor version
if (empty($vendors['mysql'])) {
$result->setStatus(false);
$result->setErrorCode(NO_DATABASE_VENDOR_MYSQL_FOUND);
return $result;
}
/// Check we have the postgres vendor version
if (empty($vendors['postgres'])) {
$result->setStatus(false);
$result->setErrorCode(NO_DATABASE_VENDOR_POSTGRES_FOUND);
return $result;
}
/// Now search the version we are using (depending of vendor)
$current_vendor = set_dbfamily();
$dbinfo = $db->ServerInfo();
$current_version = normalize_version($dbinfo['version']);
$needed_version = $vendors[$current_vendor];
/// Check we have a needed version
if (!$needed_version) {
$result->setStatus(false);
$result->setErrorCode(NO_DATABASE_VENDOR_VERSION_FOUND);
return $result;
}
/// And finally compare them, saving results
if (version_compare($current_version, $needed_version, '>=')) {
$result->setStatus(true);
} else {
$result->setStatus(false);
}
$result->setLevel($level);
$result->setCurrentVersion($current_version);
$result->setNeededVersion($needed_version);
$result->setInfo($current_vendor);
/// Do any actions defined in the XML file.
process_environment_result($vendorsxml[$current_vendor], $result);
return $result;
}
/**
* This function will post-process the result record by executing the specified
* function, modifying it as necessary, also a custom message will be added
* to the result object to be printed by the display layer.
* Every bypass function must be defined in this file and it'll return
* true/false to decide if the original test is bypassed or no. Also
* such bypass functions are able to directly handling the result object
* although it should be only under exceptional conditions.
*
* @param string xmldata containing the bypass data
* @param object result object to be updated
*/
function process_environment_bypass($xml, &$result) {
/// Only try to bypass if we were in error and it was required
if ($result->getStatus() || $result->getLevel() == 'optional') {
return;
}
/// It there is bypass info (function and message)
if (is_array($xml['#']) && isset($xml['#']['BYPASS'][0]['@']['function']) && isset($xml['#']['BYPASS'][0]['@']['message'])) {
$function = $xml['#']['BYPASS'][0]['@']['function'];
$message = $xml['#']['BYPASS'][0]['@']['message'];
/// Look for the function
if (function_exists($function)) {
/// Call it, and if bypass = true is returned, apply meesage
if ($function($result)) {
/// We only set the bypass message if the function itself hasn't defined it before
if (empty($result->getBypassStr)) {
$result->setBypassStr($message);
}
}
}
}
}
/**
* This function will post-process the result record by executing the specified
* function, modifying it as necessary, also a custom message will be added
* to the result object to be printed by the display layer.
* Every restrict function must be defined in this file and it'll return
* true/false to decide if the original test is restricted or no. Also
* such restrict functions are able to directly handling the result object
* although it should be only under exceptional conditions.
*
* @param string xmldata containing the restrict data
* @param object result object to be updated
*/
function process_environment_restrict($xml, &$result) {
/// Only try to restrict if we were not in error and it was required
if (!$result->getStatus() || $result->getLevel() == 'optional') {
return;
}
/// It there is restrict info (function and message)
if (is_array($xml['#']) && isset($xml['#']['RESTRICT'][0]['@']['function']) && isset($xml['#']['RESTRICT'][0]['@']['message'])) {
$function = $xml['#']['RESTRICT'][0]['@']['function'];
$message = $xml['#']['RESTRICT'][0]['@']['message'];
/// Look for the function
if (function_exists($function)) {
/// Call it, and if restrict = true is returned, apply meesage
if ($function($result)) {
/// We only set the restrict message if the function itself hasn't defined it before
if (empty($result->getRestrictStr)) {
$result->setRestrictStr($message);
}
}
}
}
}
/**
* This function will detect if there is some message available to be added to the
* result in order to clarify enviromental details.
* @param string xmldata containing the feedback data
* @param object reult object to be updated
*/
function process_environment_messages($xml, &$result) {
/// If there is feedback info
if (is_array($xml['#']) && isset($xml['#']['FEEDBACK'][0]['#'])) {
$feedbackxml = $xml['#']['FEEDBACK'][0]['#'];
if (!$result->status and $result->getLevel() == 'required') {
if (isset($feedbackxml['ON_ERROR'][0]['@']['message'])) {
$result->setFeedbackStr($feedbackxml['ON_ERROR'][0]['@']['message']);
}
} else if (!$result->status and $result->getLevel() == 'optional') {
if (isset($feedbackxml['ON_CHECK'][0]['@']['message'])) {
$result->setFeedbackStr($feedbackxml['ON_CHECK'][0]['@']['message']);
}
} else {
if (isset($feedbackxml['ON_OK'][0]['@']['message'])) {
$result->setFeedbackStr($feedbackxml['ON_OK'][0]['@']['message']);
}
}
}
}
//--- Helper Class to return results to caller ---//
/**
* This class is used to return the results of the environment
* main functions (environment_check_xxxx)
*/
class environment_results {
var $part; //which are we checking (database, php, php_extension)
var $status; //true/false
var $error_code; //integer. See constants at the beginning of the file
var $level; //required/optional
var $current_version; //current version detected
var $needed_version; //version needed
var $info; //Aux. info (DB vendor, library...)
var $feedback_str; //String to show on error|on check|on ok
var $bypass_str; //String to show if some bypass has happened
var $restrict_str; //String to show if some restrict has happened
/**
* Constructor of the environment_result class. Just set default values
*/
function environment_results($part) {
$this->part=$part;
$this->status=false;
$this->error_code=NO_ERROR;
$this->level='required';
$this->current_version='';
$this->needed_version='';
$this->info='';
$this->feedback_str='';
$this->bypass_str='';
$this->restrict_str='';
}
/**
* Set the status
* @param boolean the status (true/false)
*/
function setStatus($status) {
$this->status=$status;
if ($status) {
$this->setErrorCode(NO_ERROR);
}
}
/**
* Set the error_code
* @param integer the error code (see constants above)
*/
function setErrorCode($error_code) {
$this->error_code=$error_code;
}
/**
* Set the level
* @param string the level (required, optional)
*/
function setLevel($level) {
$this->level=$level;
}
/**
* Set the current version
* @param string the current version
*/
function setCurrentVersion($current_version) {
$this->current_version=$current_version;
}
/**
* Set the needed version
* @param string the needed version
*/
function setNeededVersion($needed_version) {
$this->needed_version=$needed_version;
}
/**
* Set the auxiliary info
* @param string the auxiliary info
*/
function setInfo($info) {
$this->info=$info;
}
/**
* Set the feedback string
* @param mixed the feedback string that will be fetched from the admin lang file.
* pass just the string or pass an array of params for get_string
* You always should put your string in admin.php but a third param is useful
* to pass an $a object / string to get_string
*/
function setFeedbackStr($str) {
$this->feedback_str=$str;
}
/**
* Set the bypass string
* @param string the bypass string that will be fetched from the admin lang file.
* pass just the string or pass an array of params for get_string
* You always should put your string in admin.php but a third param is useful
* to pass an $a object / string to get_string
*/
function setBypassStr($str) {
$this->bypass_str=$str;
}
/**
* Set the restrict string
* @param string the restrict string that will be fetched from the admin lang file.
* pass just the string or pass an array of params for get_string
* You always should put your string in admin.php but a third param is useful
* to pass an $a object / string to get_string
*/
function setRestrictStr($str) {
$this->restrict_str=$str;
}
/**
* Get the status
* @return boolean result
*/
function getStatus() {
return $this->status;
}
/**
* Get the error code
* @return integer error code
*/
function getErrorCode() {
return $this->error_code;
}
/**
* Get the level
* @return string level
*/
function getLevel() {
return $this->level;
}
/**
* Get the current version
* @return string current version
*/
function getCurrentVersion() {
return $this->current_version;
}
/**
* Get the needed version
* @return string needed version
*/
function getNeededVersion() {
return $this->needed_version;
}
/**
* Get the aux info
* @return string info
*/
function getInfo() {
return $this->info;
}
/**
* Get the part this result belongs to
* @return string part
*/
function getPart() {
return $this->part;
}
/**
* Get the feedback string
* @return mixed feedback string (can be an array of params for get_string or a single string to fetch from
* admin.php lang file).
*/
function getFeedbackStr() {
return $this->feedback_str;
}
/**
* Get the bypass string
* @return mixed bypass string (can be an array of params for get_string or a single string to fetch from
* admin.php lang file).
*/
function getBypassStr() {
return $this->bypass_str;
}
/**
* Get the restrict string
* @return mixed restrict string (can be an array of params for get_string or a single string to fetch from
* admin.php lang file).
*/
function getRestrictStr() {
return $this->restrict_str;
}
/**
* @param mixed $string params for get_string, either a string to fetch from admin.php or an array of
* params for get_string.
* @param string $class css class(es) for message.
* @return string feedback string fetched from lang file wrapped in p tag with class $class or returns
* empty string if $string is empty.
*/
function strToReport($string, $class){
if (!empty($string)){
if (is_array($string)){
$str = call_user_func_array('get_string', $string);
} else {
$str = get_string($string, 'admin');
}
return ''.$str.'
';
} else {
return '';
}
}
}
/// Here all the bypass functions are coded to be used by the environment
/// checker. All those functions will receive the result object and will
/// return it modified as needed (status and bypass string)
/**
* This function will bypass MySQL 4.1.16 reqs if:
* - We are using MySQL > 4.1.12, informing about problems with non latin chars in the future
*
* @param object result object to handle
* @return boolean true/false to determinate if the bypass has to be performed (true) or no (false)
*/
function bypass_mysql416_reqs ($result) {
/// See if we are running MySQL >= 4.1.12
if (version_compare($result->getCurrentVersion(), '4.1.12', '>=')) {
return true;
}
return false;
}
/// Here all the restrict functions are coded to be used by the environment
/// checker. All those functions will receive the result object and will
/// return it modified as needed (status and bypass string)
/**
* This function will restrict PHP reqs if:
* - We are using PHP 5.0.x, informing about the buggy version
*
* @param object result object to handle
* @return boolean true/false to determinate if the restrict has to be performed (true) or no (false)
*/
function restrict_php50_version($result) {
if (version_compare($result->getCurrentVersion(), '5.0.0', '>=')
and version_compare($result->getCurrentVersion(), '5.0.99', '<')) {
return true;
}
return false;
}
/**
* @param array $element the element from the environment.xml file that should have
* either a level="required" or level="optional" attribute.
* @read string "required" or "optional".
*/
function get_level($element) {
$level = 'required';
if (isset($element['@']['level'])) {
$level = $element['@']['level'];
if (!in_array($level, array('required', 'optional'))) {
debugging('The level of a check in the environment.xml file must be "required" or "optional".', DEBUG_DEVELOPER);
$level = 'required';
}
} else {
debugging('Checks in the environment.xml file must have a level="required" or level="optional" attribute.', DEBUG_DEVELOPER);
}
return $level;
}
/**
* Once the result has been determined, look in the XML for any
* messages, or other things that should be done depending on the outcome.
* @param array $element the element from the environment.xml file which
* may have children defining what should be done with the outcome.
* @param object $result the result of the test, which may be modified by
* this function as specified in the XML.
*/
function process_environment_result($element, &$result) {
/// Process messages, modifying the $result if needed.
process_environment_messages($element, $result);
/// Process bypass, modifying $result if needed.
process_environment_bypass($element, $result);
/// Process restrict, modifying $result if needed.
process_environment_restrict($element, $result);
}
?>