MDL-10888: groupings - make get_all_instances_in_course respect groupmembersonly
[moodle.git] / lib / environmentlib.php
CommitLineData
f58b518f 1<?php //$Id$
2
3///////////////////////////////////////////////////////////////////////////
4// //
5// NOTICE OF COPYRIGHT //
6// //
7// Moodle - Modular Object-Oriented Dynamic Learning Environment //
8// http://moodle.com //
9// //
10// Copyright (C) 2001-3001 Martin Dougiamas http://dougiamas.com //
11// (C) 2001-3001 Eloy Lafuente (stronk7) http://contiento.com //
12// //
13// This program is free software; you can redistribute it and/or modify //
14// it under the terms of the GNU General Public License as published by //
15// the Free Software Foundation; either version 2 of the License, or //
16// (at your option) any later version. //
17// //
18// This program is distributed in the hope that it will be useful, //
19// but WITHOUT ANY WARRANTY; without even the implied warranty of //
20// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
21// GNU General Public License for more details: //
22// //
23// http://www.gnu.org/copyleft/gpl.html //
24// //
25///////////////////////////////////////////////////////////////////////////
26
27// This library includes all the necessary stuff to execute some standard
28// tests of required versions and libraries to run Moodle. It can be
29// used from the admin interface, and both at install and upgrade.
30//
31// All the info is stored in the admin/environment.xml file,
00d3a0fd 32// supporting to have an updated version in dataroot/environment
f58b518f 33
049c0f4a 34/// Add required files
35 require_once($CFG->libdir.'/xmlize.php');
36
37/// Define a buch of XML processing errors
00d3a0fd 38 define('NO_ERROR', 0);
39 define('NO_VERSION_DATA_FOUND', 1);
40 define('NO_DATABASE_SECTION_FOUND', 2);
41 define('NO_DATABASE_VENDORS_FOUND', 3);
42 define('NO_DATABASE_VENDOR_MYSQL_FOUND', 4);
43 define('NO_DATABASE_VENDOR_POSTGRES_FOUND', 5);
44 define('NO_PHP_SECTION_FOUND', 6);
45 define('NO_PHP_VERSION_FOUND', 7);
46 define('NO_PHP_EXTENSIONS_SECTION_FOUND', 8);
47 define('NO_PHP_EXTENSIONS_NAME_FOUND', 9);
48 define('NO_DATABASE_VENDOR_VERSION_FOUND', 10);
a392be33 49 define('NO_UNICODE_SECTION_FOUND', 11);
bac40536 50 define('NO_CUSTOM_CHECK_FOUND', 12);
51 define('CUSTOM_CHECK_FILE_MISSING', 13);
52 define('CUSTOM_CHECK_FUNCTION_MISSING', 14);
f58b518f 53
54/**
55 * This function will perform the whole check, returning
56 * true or false as final result. Also, he full array of
57 * environment_result will be returned in the parameter list.
58 * The function looks for the best version to compare and
59 * everything. This is the only function that should be called
60 * ever from the rest of Moodle.
770fef0a 61 * @param string version version to check.
f58b518f 62 * @param array results array of results checked.
770fef0a 63 * @param boolean true/false, whether to print the table or just return results array
f58b518f 64 * @return boolean true/false, depending of results
65 */
049c0f4a 66function check_moodle_environment($version, &$environment_results, $print_table=true) {
67
68 $status = true;
f58b518f 69
878d309c 70/// This are cached per request
71 static $result = true;
72 static $env_results;
73 static $cache_exists = false;
74
75/// if we have results cached, use them
76 if ($cache_exists) {
77 $environment_results = $env_results;
78/// No cache exists, calculate everything
79 } else {
80 /// Get the more recent version before the requested
81 if (!$version = get_latest_version_available($version)) {
82 $status = false;
83 }
f58b518f 84
878d309c 85 /// Perform all the checks
86 if (!($environment_results = environment_check($version)) && $status) {
87 $status = false;
88 }
f58b518f 89
878d309c 90 /// Iterate over all the results looking for some error in required items
91 /// or some error_code
92 if ($status) {
93 foreach ($environment_results as $environment_result) {
95a39282 94 if (!$environment_result->getStatus() && $environment_result->getLevel() == 'required'
95 && !$environment_result->getBypassStr()) {
96 $result = false; // required item that is not bypased
97 } else if ($environment_result->getStatus() && $environment_result->getLevel() == 'required'
98 && $environment_result->getRestrictStr()) {
99 $result = false; // required item that is restricted
100 } else if ($environment_result->getErrorCode()) {
878d309c 101 $result = false;
102 }
049c0f4a 103 }
f58b518f 104 }
878d309c 105 /// Going to end, we store environment_results to cache
106 $env_results = $environment_results;
107 $cache_exists = true;
108 } ///End of cache block
f58b518f 109
049c0f4a 110/// If we have decided to print all the information, just do it
111 if ($print_table) {
e909788d 112 print_moodle_environment($result && $status, $environment_results);
049c0f4a 113 }
114
115 return ($result && $status);
116}
117
770fef0a 118/**
049c0f4a 119 * This function will print one beautiful table with all the environmental
120 * configuration and how it suits Moodle needs.
121 * @param boolean final result of the check (true/false)
122 * @param array environment_results array of results gathered
123 */
124function print_moodle_environment($result, $environment_results) {
049c0f4a 125/// Get some strings
126 $strname = get_string('name');
127 $strinfo = get_string('info');
128 $strreport = get_string('report');
129 $strstatus = get_string('status');
130 $strok = get_string('ok');
131 $strerror = get_string('error');
132 $strcheck = get_string('check');
b0e2a189 133 $strbypassed = get_string('bypassed');
95a39282 134 $strrestricted = get_string('restricted');
e909788d 135 $strenvironmenterrortodo = get_string('environmenterrortodo', 'admin');
770fef0a 136/// Table headers
137 $servertable = new stdClass;//table for server checks
138 $servertable->head = array ($strname, $strinfo, $strreport, $strstatus);
139 $servertable->align = array ('center', 'center', 'left', 'center');
140 $servertable->wrap = array ('nowrap', '', '', 'nowrap');
141 $servertable->size = array ('10', 10, '100%', '10');
142 $servertable->width = '90%';
143 $servertable->class = 'environmenttable generaltable';
144
145 $serverdata = array('ok'=>array(), 'warn'=>array(), 'error'=>array());
146
147 $othertable = new stdClass;//table for custom checks
148 $othertable->head = array ($strinfo, $strreport, $strstatus);
149 $othertable->align = array ('center', 'left', 'center');
150 $othertable->wrap = array ('', '', 'nowrap');
151 $othertable->size = array (10, '100%', '10');
152 $othertable->width = '90%';
153 $othertable->class = 'environmenttable generaltable';
154
155 $otherdata = array('ok'=>array(), 'warn'=>array(), 'error'=>array());
049c0f4a 156
157/// Iterate over each environment_result
158 $continue = true;
159 foreach ($environment_results as $environment_result) {
95a39282 160 $errorline = false;
161 $warningline = false;
049c0f4a 162 if ($continue) {
163 $type = $environment_result->getPart();
164 $info = $environment_result->getInfo();
165 $status = $environment_result->getStatus();
166 $error_code = $environment_result->getErrorCode();
167 /// Process Report field
878d309c 168 $rec = new stdClass();
049c0f4a 169 /// Something has gone wrong at parsing time
170 if ($error_code) {
171 $stringtouse = 'environmentxmlerror';
172 $rec->error_code = $error_code;
173 $status = $strerror;
174 $errorline = true;
175 $continue = false;
176 }
177
178 if ($continue) {
179 /// We are comparing versions
180 if ($rec->needed = $environment_result->getNeededVersion()) {
181 $rec->current = $environment_result->getCurrentVersion();
182 if ($environment_result->getLevel() == 'required') {
183 $stringtouse = 'environmentrequireversion';
184 } else {
185 $stringtouse = 'environmentrecommendversion';
186 }
187 /// We are checking installed & enabled things
ce5f4578 188 } else if ($environment_result->getPart() == 'custom_check') {
189 if ($environment_result->getLevel() == 'required') {
190 $stringtouse = 'environmentrequirecustomcheck';
191 } else {
192 $stringtouse = 'environmentrecommendcustomcheck';
193 }
049c0f4a 194 } else {
195 if ($environment_result->getLevel() == 'required') {
196 $stringtouse = 'environmentrequireinstall';
197 } else {
198 $stringtouse = 'environmentrecommendinstall';
199 }
200 }
201 /// Calculate the status value
95a39282 202 if ($environment_result->getBypassStr() != '') { //Handle bypassed result (warning)
b0e2a189 203 $status = $strbypassed;
95a39282 204 $warningline = true;
205 } else if ($environment_result->getRestrictStr() != '') { //Handle restricted result (error)
206 $status = $strrestricted;
b0e2a189 207 $errorline = true;
95a39282 208 } else {
209 if ($status) { //Handle ok result (ok)
210 $status = $strok;
211 } else {
212 if ($environment_result->getLevel() == 'optional') {//Handle check result (warning)
213 $status = $strcheck;
214 $warningline = true;
215 } else { //Handle error result (error)
770fef0a 216 $status = $strcheck;
95a39282 217 $errorline = true;
218 }
219 }
049c0f4a 220 }
221 }
770fef0a 222
049c0f4a 223 /// Build the text
770fef0a 224 $linkparts = array();
225 $linkparts[] = 'admin/environment';
226 $linkparts[] = $type;
227 if (!empty($info)){
228 $linkparts[] = $info;
229 }
230 $report = doc_link(join($linkparts, '/'), get_string($stringtouse, 'admin', $rec));
231
232
95a39282 233 /// Format error or warning line
234 if ($errorline || $warningline) {
770fef0a 235 $messagetype = $errorline? 'error':'warn';
236 } else {
237 $messagetype = 'ok';
049c0f4a 238 }
770fef0a 239 $status = '<span class="'.$messagetype.'">'.$status.'</span>';
240 /// Here we'll store all the feedback found
241 $feedbacktext = '';
242 ///Process the feedback if necessary
9e2d15e5 243 if ($feedbackstr = $environment_result->getFeedbackStr()) {
770fef0a 244 $feedbacktext .= '<p class="'.$messagetype.'">'.get_string($feedbackstr, 'admin').'</p>';
9e2d15e5 245 }
b0e2a189 246 ///Process the bypass if necessary
247 if ($bypassstr = $environment_result->getBypassStr()) {
770fef0a 248 $feedbacktext .= '<p class="warn">'.get_string($bypassstr, 'admin').'</p>';
b0e2a189 249 }
95a39282 250 ///Process the restrict if necessary
251 if ($restrictstr = $environment_result->getRestrictStr()) {
770fef0a 252 $feedbacktext .= '<p class="error">'.get_string($restrictstr, 'admin').'</p>';
253 }
254 if ($feedbacktext) {
255 $report = $report .$feedbacktext;
256 }
257 /// Add the row to the table
258
259 if ($environment_result->getPart() == 'custom_check'){
260 $otherdata[$messagetype][] = array ($info, $report, $status);
261
262 } else {
263 $serverdata[$messagetype][] = array ($type, $info, $report, $status);
95a39282 264 }
049c0f4a 265 }
266 }
770fef0a 267 //put errors first in
268 $servertable->data = array_merge($serverdata['error'], $serverdata['warn'], $serverdata['ok']);
269 $othertable->data = array_merge($otherdata['error'], $otherdata['warn'], $otherdata['ok']);
e909788d 270
770fef0a 271/// Print table
272 print_heading(get_string('serverchecks', 'admin'));
273 print_table($servertable);
274 if (count($othertable->data)){
275 print_heading(get_string('customcheck', 'admin'));
276 print_table($othertable);
9e2d15e5 277 }
278
e909788d 279/// Finally, if any error has happened, print the summary box
280 if (!$result) {
cc60cd9b 281 print_simple_box($strenvironmenterrortodo, 'center', '', '', '', 'environmentbox errorbox');
e909788d 282 }
f58b518f 283}
284
285
286/**
287 * This function will normalize any version to just a serie of numbers
288 * separated by dots. Everything else will be removed.
289 * @param string $version the original version
290 * @return string the normalized version
291 */
292function normalize_version($version) {
293/// Replace everything but numbers and dots by dots
294 $version = preg_replace('/[^\.\d]/', '.', $version);
295/// Combine multiple dots in one
296 $version = preg_replace('/(\.{2,})/', '.', $version);
297/// Trim possible leading and trailing dots
298 $version = trim($version, '.');
299
300 return $version;
301}
302
303
304/**
305 * This function will load the environment.xml file and xmlize it
306 * @return mixed the xmlized structure or false on error
307 */
308function load_environment_xml() {
770fef0a 309
f58b518f 310 global $CFG;
311
312 static $data; //Only load and xmlize once by request
313
314 if (!empty($data)) {
315 return $data;
316 }
317
00d3a0fd 318/// First of all, take a look inside $CFG->dataroot/environment/environment.xml
319 $file = $CFG->dataroot.'/environment/environment.xml';
38fca5d7 320 $internalfile = $CFG->dirroot.'/'.$CFG->admin.'/environment.xml';
770fef0a 321 if (!is_file($file) || !is_readable($file) || filemtime($file) < filemtime($internalfile) ||
38fca5d7 322 !$contents = file_get_contents($file)) {
d83f8373 323 /// Fallback to fixed $CFG->admin/environment.xml
38fca5d7 324 if (!is_file($internalfile) || !is_readable($internalfile) || !$contents = file_get_contents($internalfile)) {
f58b518f 325 return false;
326 }
327 }
328/// XML the whole file
329 $data = xmlize($contents);
330
331 return $data;
332}
333
334
335/**
336 * This function will return the list of Moodle versions available
337 * @return mixed array of versions. False on error.
338 */
339function get_list_of_environment_versions ($contents) {
340
341 static $versions = array();
342
343 if (!empty($versions)) {
344 return $versions;
345 }
346
347 if (isset($contents['COMPATIBILITY_MATRIX']['#']['MOODLE'])) {
348 foreach ($contents['COMPATIBILITY_MATRIX']['#']['MOODLE'] as $version) {
349 $versions[] = $version['@']['version'];
350 }
351 }
352
353 return $versions;
354}
355
356
357/**
358 * This function will return the most recent version in the environment.xml
359 * file previous or equal to the version requested
360 * @param string version top version from which we start to look backwards
361 * @return string more recent version or false if not found
362 */
363function get_latest_version_available ($version) {
364
365/// Normalize the version requested
366 $version = normalize_version($version);
367
368/// Load xml file
369 if (!$contents = load_environment_xml()) {
370 return false;
371 }
372
373/// Detect available versions
374 if (!$versions = get_list_of_environment_versions($contents)) {
375 return false;
376 }
377/// First we look for exact version
378 if (in_array($version, $versions)) {
379 return $version;
380 } else {
381 $found_version = false;
382 /// Not exact match, so we are going to iterate over the list searching
383 /// for the latest version before the requested one
384 foreach ($versions as $arrversion) {
385 if (version_compare($arrversion, $version, '<')) {
386 $found_version = $arrversion;
387 }
388 }
389 }
390
391 return $found_version;
392}
393
394
770fef0a 395/**
f58b518f 396 * This function will return the xmlized data belonging to one Moodle version
397 * @return mixed the xmlized structure or false on error
398 */
399function get_environment_for_version($version) {
770fef0a 400
f58b518f 401/// Normalize the version requested
402 $version = normalize_version($version);
403
404/// Load xml file
405 if (!$contents = load_environment_xml()) {
406 return false;
407 }
408
409/// Detect available versions
410 if (!$versions = get_list_of_environment_versions($contents)) {
411 return false;
412 }
413
414/// If the version requested is available
415 if (!in_array($version, $versions)) {
416 return false;
417 }
418
419/// We now we have it. Extract from full contents.
420 $fl_arr = array_flip($versions);
770fef0a 421
f58b518f 422 return $contents['COMPATIBILITY_MATRIX']['#']['MOODLE'][$fl_arr[$version]];
423}
424
425
770fef0a 426/**
f58b518f 427 * This function will check for everything (DB, PHP and PHP extensions for now)
428 * returning an array of environment_result objects.
429 * @param string $version xml version we are going to use to test this server
430 * @return array array of results encapsulated in one environment_result object
431 */
432function environment_check($version) {
433
7f2d3ec0 434 global $CFG;
435
f58b518f 436/// Normalize the version requested
437 $version = normalize_version($version);
438
439 $results = array(); //To store all the results
440
7f2d3ec0 441/// Only run the moodle versions checker on upgrade, not on install
442 if (empty($CFG->running_installer)) {
443 $results[] = environment_check_moodle($version);
444 }
a392be33 445 $results[] = environment_check_unicode($version);
f58b518f 446 $results[] = environment_check_database($version);
447 $results[] = environment_check_php($version);
448
449 $phpext_results = environment_check_php_extensions($version);
bac40536 450 $results = array_merge($results, $phpext_results);
f58b518f 451
bac40536 452 $custom_results = environment_custom_checks($version);
453 $results = array_merge($results, $custom_results);
f58b518f 454
455 return $results;
456}
457
458
459/**
460 * This function will check if php extensions requirements are satisfied
461 * @param string $version xml version we are going to use to test this server
462 * @return array array of results encapsulated in one environment_result object
463 */
464function environment_check_php_extensions($version) {
465
466 $results = array();
467
468/// Get the enviroment version we need
469 if (!$data = get_environment_for_version($version)) {
470 /// Error. No version data found
049c0f4a 471 $result = new environment_results('php_extension');
f58b518f 472 $result->setStatus(false);
473 $result->setErrorCode(NO_VERSION_DATA_FOUND);
474 return $result;
475 }
476
477/// Extract the php_extension part
478 if (!isset($data['#']['PHP_EXTENSIONS']['0']['#']['PHP_EXTENSION'])) {
479 /// Error. No PHP section found
049c0f4a 480 $result = new environment_results('php_extension');
f58b518f 481 $result->setStatus(false);
482 $result->setErrorCode(NO_PHP_EXTENSIONS_SECTION_FOUND);
483 return $result;
9e2d15e5 484 }
485/// Iterate over extensions checking them and creating the needed environment_results
486 foreach($data['#']['PHP_EXTENSIONS']['0']['#']['PHP_EXTENSION'] as $extension) {
487 $result = new environment_results('php_extension');
488 /// Check for level
bac40536 489 $level = get_level($extension);
9e2d15e5 490 /// Check for extension name
491 if (!isset($extension['@']['name'])) {
492 $result->setStatus(false);
493 $result->setErrorCode(NO_PHP_EXTENSIONS_NAME_FOUND);
494 } else {
495 $extension_name = $extension['@']['name'];
496 /// The name exists. Just check if it's an installed extension
497 if (!extension_loaded($extension_name)) {
f58b518f 498 $result->setStatus(false);
f58b518f 499 } else {
9e2d15e5 500 $result->setStatus(true);
f58b518f 501 }
9e2d15e5 502 $result->setLevel($level);
503 $result->setInfo($extension_name);
f58b518f 504 }
bac40536 505
506 /// Do any actions defined in the XML file.
507 process_environment_result($extension, $result);
b0e2a189 508
9e2d15e5 509 /// Add the result to the array of results
510 $results[] = $result;
f58b518f 511 }
512
9e2d15e5 513
f58b518f 514 return $results;
515}
516
bac40536 517/**
518 * This function will do the custom checks.
519 * @param string $version xml version we are going to use to test this server.
520 * @return array array of results encapsulated in environment_result objects.
521 */
522function environment_custom_checks($version) {
523 global $CFG;
524
525 $results = array();
526
527/// Get the enviroment version we need
528 if (!$data = get_environment_for_version($version)) {
529 /// Error. No version data found - but this will already have been reported.
530 return $results;
531 }
532
533/// Extract the CUSTOM_CHECKS part
534 if (!isset($data['#']['CUSTOM_CHECKS']['0']['#']['CUSTOM_CHECK'])) {
535 /// No custom checks found - not a problem
536 return $results;
537 }
538
539/// Iterate over extensions checking them and creating the needed environment_results
540 foreach($data['#']['CUSTOM_CHECKS']['0']['#']['CUSTOM_CHECK'] as $check) {
541 $result = new environment_results('custom_check');
542
543 /// Check for level
544 $level = get_level($check);
545
546 /// Check for extension name
547 if (isset($check['@']['file']) && isset($check['@']['function'])) {
548 $file = $CFG->dirroot . '/' . $check['@']['file'];
bac40536 549 $function = $check['@']['function'];
550 if (is_readable($file)) {
551 include_once($file);
552 if (function_exists($function)) {
553 $result->setLevel($level);
554 $result->setInfo($function);
555 $result = $function($result);
556 } else {
557 $result->setStatus(false);
558 $result->setErrorCode(CUSTOM_CHECK_FUNCTION_MISSING);
559 }
560 } else {
561 $result->setStatus(false);
562 $result->setErrorCode(CUSTOM_CHECK_FILE_MISSING);
563 }
564 } else {
565 $result->setStatus(false);
566 $result->setErrorCode(NO_CUSTOM_CHECK_FOUND);
567 }
568
569 if (!is_null($result)) {
570 /// Do any actions defined in the XML file.
571 process_environment_result($check, $result);
770fef0a 572
bac40536 573 /// Add the result to the array of results
574 $results[] = $result;
575 }
576 }
577
578 return $results;
579}
f58b518f 580
7f2d3ec0 581/**
582 * This function will check if Moodle requirements are satisfied
583 * @param string $version xml version we are going to use to test this server
584 * @return object results encapsulated in one environment_result object
585 */
586function environment_check_moodle($version) {
587
588 $result = new environment_results('moodle');
589
590/// Get the enviroment version we need
591 if (!$data = get_environment_for_version($version)) {
592 /// Error. No version data found
593 $result->setStatus(false);
594 $result->setErrorCode(NO_VERSION_DATA_FOUND);
595 return $result;
596 }
597
598/// Extract the moodle part
599 if (!isset($data['@']['requires'])) {
600 $needed_version = '1.0'; /// Default to 1.0 if no moodle requires is found
601 } else {
602 /// Extract required moodle version
603 $needed_version = $data['@']['requires'];
604 }
605
606/// Now search the version we are using
607 $current_version = normalize_version(get_config('', 'release'));
608
609/// And finally compare them, saving results
610 if (version_compare($current_version, $needed_version, '>=')) {
611 $result->setStatus(true);
612 } else {
613 $result->setStatus(false);
614 }
615 $result->setLevel('required');
616 $result->setCurrentVersion($current_version);
617 $result->setNeededVersion($needed_version);
618
619 return $result;
620}
621
f58b518f 622/**
623 * This function will check if php requirements are satisfied
624 * @param string $version xml version we are going to use to test this server
625 * @return object results encapsulated in one environment_result object
626 */
627function environment_check_php($version) {
628
629 $result = new environment_results('php');
630
631/// Get the enviroment version we need
632 if (!$data = get_environment_for_version($version)) {
633 /// Error. No version data found
634 $result->setStatus(false);
635 $result->setErrorCode(NO_VERSION_DATA_FOUND);
636 return $result;
637 }
638
639/// Extract the php part
640 if (!isset($data['#']['PHP'])) {
641 /// Error. No PHP section found
642 $result->setStatus(false);
643 $result->setErrorCode(NO_PHP_SECTION_FOUND);
644 return $result;
645 } else {
646 /// Extract level and version
bac40536 647 $level = get_level($data['#']['PHP']['0']);
f58b518f 648 if (!isset($data['#']['PHP']['0']['@']['version'])) {
649 $result->setStatus(false);
650 $result->setErrorCode(NO_PHP_VERSION_FOUND);
651 return $result;
652 } else {
653 $needed_version = $data['#']['PHP']['0']['@']['version'];
654 }
655 }
656
657/// Now search the version we are using
658 $current_version = normalize_version(phpversion());
659
660/// And finally compare them, saving results
661 if (version_compare($current_version, $needed_version, '>=')) {
662 $result->setStatus(true);
663 } else {
664 $result->setStatus(false);
f58b518f 665 }
770fef0a 666 $result->setLevel($level);
f58b518f 667 $result->setCurrentVersion($current_version);
668 $result->setNeededVersion($needed_version);
bac40536 669
670/// Do any actions defined in the XML file.
671 process_environment_result($data['#']['PHP'][0], $result);
f58b518f 672
673 return $result;
674}
675
676
a392be33 677/**
678 * This function will check if unicode database requirements are satisfied
679 * @param string $version xml version we are going to use to test this server
680 * @return object results encapsulated in one environment_result object
681 */
682function environment_check_unicode($version) {
683 global $db;
684
685 $result = new environment_results('unicode');
686
687 /// Get the enviroment version we need
688 if (!$data = get_environment_for_version($version)) {
689 /// Error. No version data found
690 $result->setStatus(false);
691 $result->setErrorCode(NO_VERSION_DATA_FOUND);
692 return $result;
693 }
694
695 /// Extract the unicode part
696
697 if (!isset($data['#']['UNICODE'])) {
7f2d3ec0 698 /// Error. No UNICODE section found
a392be33 699 $result->setStatus(false);
700 $result->setErrorCode(NO_UNICODE_SECTION_FOUND);
701 return $result;
702 } else {
703 /// Extract level
bac40536 704 $level = get_level($data['#']['UNICODE']['0']);
a392be33 705 }
706
707 if (!$unicodedb = setup_is_unicodedb()) {
708 $result->setStatus(false);
709 } else {
710 $result->setStatus(true);
711 }
712
713 $result->setLevel($level);
714
bac40536 715/// Do any actions defined in the XML file.
716 process_environment_result($data['#']['UNICODE'][0], $result);
a392be33 717
718 return $result;
719}
720
f58b518f 721/**
722 * This function will check if database requirements are satisfied
723 * @param string $version xml version we are going to use to test this server
724 * @return object results encapsulated in one environment_result object
725 */
726function environment_check_database($version) {
727
728 global $db;
729
730 $result = new environment_results('database');
731
732 $vendors = array(); //Array of vendors in version
733
734/// Get the enviroment version we need
735 if (!$data = get_environment_for_version($version)) {
736 /// Error. No version data found
737 $result->setStatus(false);
738 $result->setErrorCode(NO_VERSION_DATA_FOUND);
739 return $result;
740 }
741
742/// Extract the database part
743 if (!isset($data['#']['DATABASE'])) {
744 /// Error. No DATABASE section found
745 $result->setStatus(false);
746 $result->setErrorCode(NO_DATABASE_SECTION_FOUND);
747 return $result;
748 } else {
749 /// Extract level
bac40536 750 $level = get_level($data['#']['DATABASE']['0']);
f58b518f 751 }
752
753/// Extract DB vendors. At least 2 are mandatory (mysql & postgres)
754 if (!isset($data['#']['DATABASE']['0']['#']['VENDOR'])) {
755 /// Error. No VENDORS found
756 $result->setStatus(false);
757 $result->setErrorCode(NO_DATABASE_VENDORS_FOUND);
758 return $result;
759 } else {
760 /// Extract vendors
761 foreach ($data['#']['DATABASE']['0']['#']['VENDOR'] as $vendor) {
762 if (isset($vendor['@']['name']) && isset($vendor['@']['version'])) {
763 $vendors[$vendor['@']['name']] = $vendor['@']['version'];
9e2d15e5 764 $vendorsxml[$vendor['@']['name']] = $vendor;
f58b518f 765 }
766 }
767 }
768/// Check we have the mysql vendor version
769 if (empty($vendors['mysql'])) {
770 $result->setStatus(false);
771 $result->setErrorCode(NO_DATABASE_VENDOR_MYSQL_FOUND);
772 return $result;
773 }
774/// Check we have the postgres vendor version
775 if (empty($vendors['postgres'])) {
776 $result->setStatus(false);
777 $result->setErrorCode(NO_DATABASE_VENDOR_POSTGRES_FOUND);
778 return $result;
779 }
780
781/// Now search the version we are using (depending of vendor)
ed7656bf 782 $current_vendor = set_dbfamily();
783
f58b518f 784 $dbinfo = $db->ServerInfo();
785 $current_version = normalize_version($dbinfo['version']);
786 $needed_version = $vendors[$current_vendor];
787
e3058eb3 788/// Check we have a needed version
789 if (!$needed_version) {
790 $result->setStatus(false);
791 $result->setErrorCode(NO_DATABASE_VENDOR_VERSION_FOUND);
792 return $result;
793 }
794
f58b518f 795/// And finally compare them, saving results
796 if (version_compare($current_version, $needed_version, '>=')) {
797 $result->setStatus(true);
798 } else {
799 $result->setStatus(false);
f58b518f 800 }
770fef0a 801 $result->setLevel($level);
f58b518f 802 $result->setCurrentVersion($current_version);
803 $result->setNeededVersion($needed_version);
804 $result->setInfo($current_vendor);
805
bac40536 806/// Do any actions defined in the XML file.
807 process_environment_result($vendorsxml[$current_vendor], $result);
9e2d15e5 808
f58b518f 809 return $result;
810
811}
812
b0e2a189 813/**
814 * This function will post-process the result record by executing the specified
815 * function, modifying it as necessary, also a custom message will be added
816 * to the result object to be printed by the display layer.
817 * Every bypass function must be defined in this file and it'll return
818 * true/false to decide if the original test is bypassed or no. Also
819 * such bypass functions are able to directly handling the result object
820 * although it should be only under exceptional conditions.
821 *
822 * @param string xmldata containing the bypass data
95a39282 823 * @param object result object to be updated
b0e2a189 824 */
825function process_environment_bypass($xml, &$result) {
826
76bb0d20 827/// Only try to bypass if we were in error and it was required
828 if ($result->getStatus() || $result->getLevel() == 'optional') {
b0e2a189 829 return;
830 }
831
832/// It there is bypass info (function and message)
74506a51 833 if (is_array($xml['#']) && isset($xml['#']['BYPASS'][0]['@']['function']) && isset($xml['#']['BYPASS'][0]['@']['message'])) {
b0e2a189 834 $function = $xml['#']['BYPASS'][0]['@']['function'];
835 $message = $xml['#']['BYPASS'][0]['@']['message'];
836 /// Look for the function
837 if (function_exists($function)) {
838 /// Call it, and if bypass = true is returned, apply meesage
839 if ($function($result)) {
840 /// We only set the bypass message if the function itself hasn't defined it before
841 if (empty($result->getBypassStr)) {
842 $result->setBypassStr($message);
843 }
844 }
845 }
846 }
847}
848
95a39282 849/**
850 * This function will post-process the result record by executing the specified
851 * function, modifying it as necessary, also a custom message will be added
852 * to the result object to be printed by the display layer.
853 * Every restrict function must be defined in this file and it'll return
854 * true/false to decide if the original test is restricted or no. Also
855 * such restrict functions are able to directly handling the result object
856 * although it should be only under exceptional conditions.
857 *
858 * @param string xmldata containing the restrict data
859 * @param object result object to be updated
860 */
861function process_environment_restrict($xml, &$result) {
862
863/// Only try to restrict if we were not in error and it was required
864 if (!$result->getStatus() || $result->getLevel() == 'optional') {
865 return;
866 }
867/// It there is restrict info (function and message)
868 if (is_array($xml['#']) && isset($xml['#']['RESTRICT'][0]['@']['function']) && isset($xml['#']['RESTRICT'][0]['@']['message'])) {
869 $function = $xml['#']['RESTRICT'][0]['@']['function'];
870 $message = $xml['#']['RESTRICT'][0]['@']['message'];
871 /// Look for the function
872 if (function_exists($function)) {
873 /// Call it, and if restrict = true is returned, apply meesage
874 if ($function($result)) {
875 /// We only set the restrict message if the function itself hasn't defined it before
876 if (empty($result->getRestrictStr)) {
877 $result->setRestrictStr($message);
878 }
879 }
880 }
881 }
882}
883
9e2d15e5 884/**
885 * This function will detect if there is some message available to be added to the
886 * result in order to clarify enviromental details.
b0e2a189 887 * @param string xmldata containing the feedback data
9e2d15e5 888 * @param object reult object to be updated
889 */
890function process_environment_messages($xml, &$result) {
891
892/// If there is feedback info
74506a51 893 if (is_array($xml['#']) && isset($xml['#']['FEEDBACK'][0]['#'])) {
9e2d15e5 894 $feedbackxml = $xml['#']['FEEDBACK'][0]['#'];
895
896 if (!$result->status and $result->getLevel() == 'required') {
897 if (isset($feedbackxml['ON_ERROR'][0]['@']['message'])) {
898 $result->setFeedbackStr($feedbackxml['ON_ERROR'][0]['@']['message']);
899 }
900 } else if (!$result->status and $result->getLevel() == 'optional') {
901 if (isset($feedbackxml['ON_CHECK'][0]['@']['message'])) {
902 $result->setFeedbackStr($feedbackxml['ON_CHECK'][0]['@']['message']);
903 }
904 } else {
905 if (isset($feedbackxml['ON_OK'][0]['@']['message'])) {
906 $result->setFeedbackStr($feedbackxml['ON_OK'][0]['@']['message']);
907 }
908 }
909 }
910}
911
f58b518f 912
913//--- Helper Class to return results to caller ---//
914
915
770fef0a 916/**
f58b518f 917 * This class is used to return the results of the environment
918 * main functions (environment_check_xxxx)
919 */
920class environment_results {
921
049c0f4a 922 var $part; //which are we checking (database, php, php_extension)
f58b518f 923 var $status; //true/false
924 var $error_code; //integer. See constants at the beginning of the file
925 var $level; //required/optional
926 var $current_version; //current version detected
927 var $needed_version; //version needed
928 var $info; //Aux. info (DB vendor, library...)
9e2d15e5 929 var $feedback_str; //String to show on error|on check|on ok
930 var $bypass_str; //String to show if some bypass has happened
95a39282 931 var $restrict_str; //String to show if some restrict has happened
f58b518f 932
933 /**
934 * Constructor of the environment_result class. Just set default values
935 */
936 function environment_results($part) {
937 $this->part=$part;
938 $this->status=false;
049c0f4a 939 $this->error_code=NO_ERROR;
f58b518f 940 $this->level='required';
941 $this->current_version='';
942 $this->needed_version='';
943 $this->info='';
9e2d15e5 944 $this->feedback_str='';
945 $this->bypass_str='';
95a39282 946 $this->restrict_str='';
f58b518f 947 }
948
949 /**
950 * Set the status
951 * @param boolean the status (true/false)
952 */
953 function setStatus($status) {
954 $this->status=$status;
955 if ($status) {
956 $this->setErrorCode(NO_ERROR);
957 }
958 }
959
960 /**
961 * Set the error_code
962 * @param integer the error code (see constants above)
963 */
964 function setErrorCode($error_code) {
965 $this->error_code=$error_code;
966 }
967
968 /**
969 * Set the level
970 * @param string the level (required, optional)
971 */
972 function setLevel($level) {
973 $this->level=$level;
974 }
975
976 /**
977 * Set the current version
978 * @param string the current version
979 */
980 function setCurrentVersion($current_version) {
981 $this->current_version=$current_version;
982 }
983
984 /**
985 * Set the needed version
986 * @param string the needed version
987 */
988 function setNeededVersion($needed_version) {
989 $this->needed_version=$needed_version;
990 }
991
992 /**
993 * Set the auxiliary info
994 * @param string the auxiliary info
995 */
9e2d15e5 996 function setInfo($info) {
997 $this->info=$info;
998 }
770fef0a 999
9e2d15e5 1000 /**
1001 * Set the feedback string
1002 * @param string the feedback string
1003 */
1004 function setFeedbackStr($str) {
1005 $this->feedback_str=$str;
1006 }
f58b518f 1007
b0e2a189 1008 /**
1009 * Set the bypass string
1010 * @param string the bypass string
1011 */
1012 function setBypassStr($str) {
1013 $this->bypass_str=$str;
1014 }
1015
95a39282 1016 /**
1017 * Set the restrict string
1018 * @param string the restrict string
1019 */
1020 function setRestrictStr($str) {
1021 $this->restrict_str=$str;
1022 }
1023
f58b518f 1024 /**
1025 * Get the status
1026 * @return boolean result
1027 */
1028 function getStatus() {
1029 return $this->status;
1030 }
1031
1032 /**
1033 * Get the error code
1034 * @return integer error code
1035 */
1036 function getErrorCode() {
1037 return $this->error_code;
1038 }
1039
1040 /**
1041 * Get the level
1042 * @return string level
1043 */
1044 function getLevel() {
1045 return $this->level;
1046 }
1047
1048 /**
770fef0a 1049 * Get the current version
f58b518f 1050 * @return string current version
1051 */
1052 function getCurrentVersion() {
1053 return $this->current_version;
1054 }
1055
1056 /**
1057 * Get the needed version
1058 * @return string needed version
1059 */
1060 function getNeededVersion() {
1061 return $this->needed_version;
1062 }
1063
1064 /**
1065 * Get the aux info
1066 * @return string info
1067 */
1068 function getInfo() {
1069 return $this->info;
1070 }
1071
1072 /**
1073 * Get the part this result belongs to
1074 * @return string part
1075 */
1076 function getPart() {
1077 return $this->part;
1078 }
9e2d15e5 1079
1080 /**
1081 * Get the feedback string
1082 * @return string feedback string
1083 */
1084 function getFeedbackStr() {
1085 return $this->feedback_str;
1086 }
b0e2a189 1087
1088 /**
1089 * Get the bypass string
1090 * @return string bypass string
1091 */
1092 function getBypassStr() {
1093 return $this->bypass_str;
1094 }
95a39282 1095
1096 /**
1097 * Get the restrict string
1098 * @return string restrict string
1099 */
1100 function getRestrictStr() {
1101 return $this->restrict_str;
1102 }
f58b518f 1103}
1104
9e2d15e5 1105/// Here all the bypass functions are coded to be used by the environment
1106/// checker. All those functions will receive the result object and will
1107/// return it modified as needed (status and bypass string)
1108
b0e2a189 1109/**
1110 * This function will bypass MySQL 4.1.16 reqs if:
1111 * - We are using MySQL > 4.1.12, informing about problems with non latin chars in the future
1112 *
1113 * @param object result object to handle
95a39282 1114 * @return boolean true/false to determinate if the bypass has to be performed (true) or no (false)
b0e2a189 1115 */
1116function bypass_mysql416_reqs ($result) {
1117/// See if we are running MySQL >= 4.1.12
1118 if (version_compare($result->getCurrentVersion(), '4.1.12', '>=')) {
1119 return true;
1120 }
1121
1122 return false;
1123}
1124
95a39282 1125/// Here all the restrict functions are coded to be used by the environment
1126/// checker. All those functions will receive the result object and will
1127/// return it modified as needed (status and bypass string)
1128
770fef0a 1129/**
95a39282 1130 * This function will restrict PHP reqs if:
1131 * - We are using PHP 5.0.x, informing about the buggy version
1132 *
1133 * @param object result object to handle
1134 * @return boolean true/false to determinate if the restrict has to be performed (true) or no (false)
1135 */
1136function restrict_php50_version($result) {
1137 if (version_compare($result->getCurrentVersion(), '5.0.0', '>=')
1138 and version_compare($result->getCurrentVersion(), '5.0.99', '<')) {
1139 return true;
1140 }
1141 return false;
1142}
bac40536 1143
1144/**
1145 * @param array $element the element from the environment.xml file that should have
1146 * either a level="required" or level="optional" attribute.
1147 * @read string "required" or "optional".
1148 */
1149function get_level($element) {
1150 $level = 'required';
1151 if (isset($element['@']['level'])) {
1152 $level = $element['@']['level'];
1153 if (!in_array($level, array('required', 'optional'))) {
7f2d3ec0 1154 debugging('The level of a check in the environment.xml file must be "required" or "optional".', DEBUG_DEVELOPER);
bac40536 1155 $level = 'required';
1156 }
1157 } else {
1158 debugging('Checks in the environment.xml file must have a level="required" or level="optional" attribute.', DEBUG_DEVELOPER);
1159 }
1160 return $level;
1161}
1162
1163/**
1164 * Once the result has been determined, look in the XML for any
1165 * messages, or other things that should be done depending on the outcome.
1166 * @param array $element the element from the environment.xml file which
1167 * may have children defining what should be done with the outcome.
1168 * @param object $result the result of the test, which may be modified by
1169 * this function as specified in the XML.
1170 */
1171function process_environment_result($element, &$result) {
1172/// Process messages, modifying the $result if needed.
1173 process_environment_messages($element, $result);
1174/// Process bypass, modifying $result if needed.
1175 process_environment_bypass($element, $result);
1176/// Process restrict, modifying $result if needed.
1177 process_environment_restrict($element, $result);
1178}
f58b518f 1179?>