/**
* Tests the update of event handlers from file.
*/
public function test_events_update_definition__update()
{
global $DB;
// First modify directly existing handler.
$handler = $DB->get_record('events_handlers', array('component' => 'unittest', 'eventname' => 'test_instant'));
$original = $handler->handlerfunction;
// Change handler in db.
$DB->set_field('events_handlers', 'handlerfunction', serialize('some_other_function_handler'), array('id' => $handler->id));
// Update the definition, it should revert the handler back.
events_update_definition('unittest');
$handler = $DB->get_record('events_handlers', array('component' => 'unittest', 'eventname' => 'test_instant'));
$this->assertSame($handler->handlerfunction, $original, 'update should sync db with file definition: %s');
}
function upgrade_blocks_plugins($continueto)
{
global $CFG, $db;
$blocktitles = array();
$invalidblocks = array();
$validblocks = array();
$notices = array();
//Count the number of blocks in db
$blockcount = count_records('block');
//If there isn't records. This is the first install, so I remember it
if ($blockcount == 0) {
$first_install = true;
} else {
$first_install = false;
}
$site = get_site();
if (!($blocks = get_list_of_plugins('blocks', 'db'))) {
error('No blocks installed!');
}
include_once $CFG->dirroot . '/blocks/moodleblock.class.php';
if (!class_exists('block_base')) {
error('Class block_base is not defined or file not found for /blocks/moodleblock.class.php');
}
foreach ($blocks as $blockname) {
if ($blockname == 'NEWBLOCK') {
// Someone has unzipped the template, ignore it
continue;
}
if (!block_is_compatible($blockname)) {
// This is an old-style block
//$notices[] = 'Block '. $blockname .' is not compatible with the current version of Mooodle and needs to be updated by a programmer.';
$invalidblocks[] = $blockname;
continue;
}
$fullblock = $CFG->dirroot . '/blocks/' . $blockname;
if (is_readable($fullblock . '/block_' . $blockname . '.php')) {
include_once $fullblock . '/block_' . $blockname . '.php';
} else {
$notices[] = 'Block ' . $blockname . ': ' . $fullblock . '/block_' . $blockname . '.php was not readable';
continue;
}
$oldupgrade = false;
$newupgrade = false;
if (@is_dir($fullblock . '/db/')) {
if (@is_readable($fullblock . '/db/' . $CFG->dbtype . '.php')) {
include_once $fullblock . '/db/' . $CFG->dbtype . '.php';
// defines old upgrading function
$oldupgrade = true;
}
if (@is_readable($fullblock . '/db/upgrade.php')) {
include_once $fullblock . '/db/upgrade.php';
// defines new upgrading function
$newupgrade = true;
}
}
$classname = 'block_' . $blockname;
if (!class_exists($classname)) {
$notices[] = 'Block ' . $blockname . ': ' . $classname . ' not implemented';
continue;
}
// Here is the place to see if the block implements a constructor (old style),
// an init() function (new style) or nothing at all (error time).
$constructor = get_class_constructor($classname);
if (empty($constructor)) {
// No constructor
$notices[] = 'Block ' . $blockname . ': class does not have a constructor';
$invalidblocks[] = $blockname;
continue;
}
$block = new stdClass();
// This may be used to update the db below
$blockobj = new $classname();
// This is what we 'll be testing
// Inherits from block_base?
if (!is_subclass_of($blockobj, 'block_base')) {
$notices[] = 'Block ' . $blockname . ': class does not inherit from block_base';
continue;
}
// OK, it's as we all hoped. For further tests, the object will do them itself.
if (!$blockobj->_self_test()) {
$notices[] = 'Block ' . $blockname . ': self test failed';
continue;
}
$block->version = $blockobj->get_version();
if (!isset($block->version)) {
$notices[] = 'Block ' . $blockname . ': has no version support. It must be updated by a programmer.';
continue;
}
$block->name = $blockname;
// The name MUST match the directory
$blocktitle = $blockobj->get_title();
if ($currblock = get_record('block', 'name', $block->name)) {
if ($currblock->version == $block->version) {
// do nothing
} else {
if ($currblock->version < $block->version) {
if (empty($updated_blocks)) {
$strblocksetup = get_string('blocksetup');
print_header($strblocksetup, $strblocksetup, build_navigation(array(array('name' => $strblocksetup, 'link' => null, 'type' => 'misc'))), '', upgrade_get_javascript(), false, ' ', ' ');
}
$updated_blocks = true;
upgrade_log_start();
print_heading('New version of ' . $blocktitle . ' (' . $block->name . ') exists');
@set_time_limit(0);
// To allow slow databases to complete the long SQL
/// Run de old and new upgrade functions for the module
$oldupgrade_function = $block->name . '_upgrade';
$newupgrade_function = 'xmldb_block_' . $block->name . '_upgrade';
/// First, the old function if exists
$oldupgrade_status = true;
if ($oldupgrade && function_exists($oldupgrade_function)) {
$db->debug = true;
$oldupgrade_status = $oldupgrade_function($currblock->version, $block);
} else {
if ($oldupgrade) {
notify('Upgrade function ' . $oldupgrade_function . ' was not available in ' . $fullblock . '/db/' . $CFG->dbtype . '.php');
}
}
/// Then, the new function if exists and the old one was ok
$newupgrade_status = true;
if ($newupgrade && function_exists($newupgrade_function) && $oldupgrade_status) {
$db->debug = true;
$newupgrade_status = $newupgrade_function($currblock->version, $block);
} else {
if ($newupgrade) {
notify('Upgrade function ' . $newupgrade_function . ' was not available in ' . $fullblock . '/db/upgrade.php');
}
}
$db->debug = false;
/// Now analyze upgrade results
if ($oldupgrade_status && $newupgrade_status) {
// No upgrading failed
// Set the block cron on upgrade
$block->cron = !empty($blockobj->cron) ? $blockobj->cron : 0;
// OK so far, now update the block record
$block->id = $currblock->id;
if (!update_record('block', $block)) {
error('Could not update block ' . $block->name . ' record in block table!');
}
$component = 'block/' . $block->name;
if (!update_capabilities($component)) {
error('Could not update ' . $block->name . ' capabilities!');
}
events_update_definition($component);
notify(get_string('blocksuccess', '', $blocktitle), 'notifysuccess');
} else {
notify('Upgrading block ' . $block->name . ' from ' . $currblock->version . ' to ' . $block->version . ' FAILED!');
}
echo '<hr />';
} else {
upgrade_log_start();
error('Version mismatch: block ' . $block->name . ' can\'t downgrade ' . $currblock->version . ' -> ' . $block->version . '!');
}
}
} else {
// block not installed yet, so install it
// If it allows multiples, start with it enabled
if ($blockobj->instance_allow_multiple()) {
$block->multiple = 1;
}
// Set the block cron on install
$block->cron = !empty($blockobj->cron) ? $blockobj->cron : 0;
// [pj] Normally this would be inline in the if, but we need to
// check for NULL (necessary for 4.0.5 <= PHP < 4.2.0)
$conflictblock = array_search($blocktitle, $blocktitles);
if ($conflictblock !== false && $conflictblock !== NULL) {
// Duplicate block titles are not allowed, they confuse people
// AND PHP's associative arrays ;)
error('<strong>Naming conflict</strong>: block <strong>' . $block->name . '</strong> has the same title with an existing block, <strong>' . $conflictblock . '</strong>!');
}
if (empty($updated_blocks)) {
$strblocksetup = get_string('blocksetup');
print_header($strblocksetup, $strblocksetup, build_navigation(array(array('name' => $strblocksetup, 'link' => null, 'type' => 'misc'))), '', upgrade_get_javascript(), false, ' ', ' ');
}
$updated_blocks = true;
upgrade_log_start();
print_heading($block->name);
$db->debug = true;
@set_time_limit(0);
// To allow slow databases to complete the long SQL
/// Both old .sql files and new install.xml are supported
/// but we priorize install.xml (XMLDB) if present
$status = false;
if (file_exists($fullblock . '/db/install.xml')) {
$status = install_from_xmldb_file($fullblock . '/db/install.xml');
//New method
} else {
if (file_exists($fullblock . '/db/' . $CFG->dbtype . '.sql')) {
$status = modify_database($fullblock . '/db/' . $CFG->dbtype . '.sql');
//Old method
} else {
$status = true;
}
}
$db->debug = false;
if ($status) {
if ($block->id = insert_record('block', $block)) {
$blockobj->after_install();
$component = 'block/' . $block->name;
if (!update_capabilities($component)) {
notify('Could not set up ' . $block->name . ' capabilities!');
}
events_update_definition($component);
notify(get_string('blocksuccess', '', $blocktitle), 'notifysuccess');
echo '<hr />';
} else {
error($block->name . ' block could not be added to the block list!');
}
} else {
error('Block ' . $block->name . ' tables could NOT be set up successfully!');
}
}
$blocktitles[$block->name] = $blocktitle;
}
if (!empty($notices)) {
upgrade_log_start();
foreach ($notices as $notice) {
notify($notice);
}
}
// Finally, if we are in the first_install of BLOCKS (this means that we are
// upgrading from Moodle < 1.3), put blocks in all existing courses.
if ($first_install) {
upgrade_log_start();
//Iterate over each course
if ($courses = get_records('course')) {
foreach ($courses as $course) {
$page = page_create_object(PAGE_COURSE_VIEW, $course->id);
blocks_repopulate_page($page);
}
}
}
if (!empty($CFG->siteblocksadded)) {
/// This is a once-off hack to make a proper upgrade
upgrade_log_start();
$page = page_create_object(PAGE_COURSE_VIEW, SITEID);
blocks_repopulate_page($page);
delete_records('config', 'name', 'siteblocksadded');
}
upgrade_log_finish();
if (!empty($updated_blocks)) {
print_continue($continueto);
print_footer('none');
die;
}
}
/**
* Upgrade moodle core
* @param float $version target version
* @param bool $verbose
* @return void, may throw exception
*/
function upgrade_core($version, $verbose) {
global $CFG, $SITE, $DB, $COURSE;
raise_memory_limit(MEMORY_EXTRA);
require_once($CFG->libdir.'/db/upgrade.php'); // Defines upgrades
try {
// Reset caches before any output.
cache_helper::purge_all(true);
purge_all_caches();
// Upgrade current language pack if we can
upgrade_language_pack();
print_upgrade_part_start('moodle', false, $verbose);
// Pre-upgrade scripts for local hack workarounds.
$preupgradefile = "$CFG->dirroot/local/preupgrade.php";
if (file_exists($preupgradefile)) {
core_php_time_limit::raise();
require($preupgradefile);
// Reset upgrade timeout to default.
upgrade_set_timeout();
}
$result = xmldb_main_upgrade($CFG->version);
if ($version > $CFG->version) {
// store version if not already there
upgrade_main_savepoint($result, $version, false);
}
// In case structure of 'course' table has been changed and we forgot to update $SITE, re-read it from db.
$SITE = $DB->get_record('course', array('id' => $SITE->id));
$COURSE = clone($SITE);
// perform all other component upgrade routines
update_capabilities('moodle');
log_update_descriptions('moodle');
external_update_descriptions('moodle');
events_update_definition('moodle');
\core\task\manager::reset_scheduled_tasks_for_component('moodle');
message_update_providers('moodle');
\core\message\inbound\manager::update_handlers_for_component('moodle');
// Update core definitions.
cache_helper::update_definitions(true);
// Purge caches again, just to be sure we arn't holding onto old stuff now.
cache_helper::purge_all(true);
purge_all_caches();
// Clean up contexts - more and more stuff depends on existence of paths and contexts
context_helper::cleanup_instances();
context_helper::create_instances(null, false);
context_helper::build_all_paths(false);
$syscontext = context_system::instance();
$syscontext->mark_dirty();
print_upgrade_part_end('moodle', false, $verbose);
} catch (Exception $ex) {
upgrade_handle_exception($ex);
}
}
/**
* This function checks to see whether local database customisations are up-to-date
* by comparing $CFG->local_version to the variable $local_version defined in
* local/version.php. If not, it looks for a function called 'xmldb_local_upgrade'
* in a file called 'local/db/upgrade.php', and if it's there calls it with the
* appropiate $oldversion parameter. Then it updates $CFG->local_version.
* On success it prints a continue link. On failure it prints an error.
*
* @uses $CFG
* @uses $db to do something really evil with the debug setting that should probably be eliminated. TODO!
* @param string $continueto a URL passed to print_continue() if the local upgrades succeed.
*/
function upgrade_local_db($continueto)
{
global $CFG, $db;
// if we don't have code version or a db upgrade file, just return true, we're unneeded
if (!file_exists($CFG->dirroot . '/local/version.php') || !file_exists($CFG->dirroot . '/local/db/upgrade.php')) {
return true;
}
require_once $CFG->dirroot . '/local/version.php';
// Get code versions
if (empty($CFG->local_version)) {
// normally we'd install, but just replay all the upgrades.
$CFG->local_version = 0;
}
if ($local_version > $CFG->local_version) {
// upgrade!
$strdatabaseupgrades = get_string('databaseupgrades');
print_header($strdatabaseupgrades, $strdatabaseupgrades, build_navigation(array(array('name' => $strdatabaseupgrades, 'link' => null, 'type' => 'misc'))), '', upgrade_get_javascript());
upgrade_log_start();
require_once $CFG->dirroot . '/local/db/upgrade.php';
$db->debug = true;
if (xmldb_local_upgrade($CFG->local_version)) {
$db->debug = false;
if (set_config('local_version', $local_version)) {
notify(get_string('databasesuccess'), 'notifysuccess');
notify(get_string('databaseupgradelocal', '', $local_version), 'notifysuccess');
print_continue($continueto);
print_footer('none');
exit;
} else {
error('Upgrade of local database customisations failed! (Could not update version in config table)');
}
} else {
$db->debug = false;
error('Upgrade failed! See local/version.php');
}
} else {
if ($local_version < $CFG->local_version) {
upgrade_log_start();
notify('WARNING!!! The local version you are using is OLDER than the version that made these databases!');
}
}
/// Capabilities
if (!update_capabilities('local')) {
error('Could not set up the capabilities for local!');
}
if (!events_update_definition('local')) {
error('Could not set up the events definitions for local!');
}
upgrade_log_finish();
}
/**
* Find and check all modules and load them up or upgrade them if necessary
*
* @uses $db
* @uses $CFG
* @param string $return The url to prompt the user to continue to
* @todo Finish documenting this function
*/
function upgrade_activity_modules($return)
{
global $CFG, $db;
if (!($mods = get_list_of_plugins('mod'))) {
error('No modules installed!');
}
$updated_modules = false;
$strmodulesetup = get_string('modulesetup');
foreach ($mods as $mod) {
if ($mod == 'NEWMODULE') {
// Someone has unzipped the template, ignore it
continue;
}
$fullmod = $CFG->dirroot . '/mod/' . $mod;
unset($module);
if (is_readable($fullmod . '/version.php')) {
include_once $fullmod . '/version.php';
// defines $module with version etc
} else {
notify('Module ' . $mod . ': ' . $fullmod . '/version.php was not readable');
continue;
}
$oldupgrade = false;
$newupgrade = false;
if (is_readable($fullmod . '/db/' . $CFG->dbtype . '.php')) {
include_once $fullmod . '/db/' . $CFG->dbtype . '.php';
// defines old upgrading function
$oldupgrade = true;
}
if (is_readable($fullmod . '/db/upgrade.php')) {
include_once $fullmod . '/db/upgrade.php';
// defines new upgrading function
$newupgrade = true;
}
if (!isset($module)) {
continue;
}
if (!empty($module->requires)) {
if ($module->requires > $CFG->version) {
$info = new object();
$info->modulename = $mod;
$info->moduleversion = $module->version;
$info->currentmoodle = $CFG->version;
$info->requiremoodle = $module->requires;
if (!$updated_modules) {
print_header($strmodulesetup, $strmodulesetup, build_navigation(array(array('name' => $strmodulesetup, 'link' => null, 'type' => 'misc'))), '', upgrade_get_javascript(), false, ' ', ' ');
}
upgrade_log_start();
notify(get_string('modulerequirementsnotmet', 'error', $info));
$updated_modules = true;
continue;
}
}
$module->name = $mod;
// The name MUST match the directory
include_once $fullmod . '/lib.php';
// defines upgrading and/or installing functions
if ($currmodule = get_record('modules', 'name', $module->name)) {
if ($currmodule->version == $module->version) {
// do nothing
} else {
if ($currmodule->version < $module->version) {
/// If versions say that we need to upgrade but no upgrade files are available, notify and continue
if (!$oldupgrade && !$newupgrade) {
notify('Upgrade files ' . $mod . ': ' . $fullmod . '/db/' . $CFG->dbtype . '.php or ' . $fullmod . '/db/upgrade.php were not readable');
continue;
}
if (!$updated_modules) {
print_header($strmodulesetup, $strmodulesetup, build_navigation(array(array('name' => $strmodulesetup, 'link' => null, 'type' => 'misc'))), '', upgrade_get_javascript(), false, ' ', ' ');
}
upgrade_log_start();
print_heading($module->name . ' module needs upgrading');
/// Run de old and new upgrade functions for the module
$oldupgrade_function = $module->name . '_upgrade';
$newupgrade_function = 'xmldb_' . $module->name . '_upgrade';
/// First, the old function if exists
$oldupgrade_status = true;
if ($oldupgrade && function_exists($oldupgrade_function)) {
$db->debug = true;
$oldupgrade_status = $oldupgrade_function($currmodule->version, $module);
if (!$oldupgrade_status) {
notify('Upgrade function ' . $oldupgrade_function . ' did not complete successfully.');
}
} else {
if ($oldupgrade) {
notify('Upgrade function ' . $oldupgrade_function . ' was not available in ' . $mod . ': ' . $fullmod . '/db/' . $CFG->dbtype . '.php');
}
}
/// Then, the new function if exists and the old one was ok
$newupgrade_status = true;
if ($newupgrade && function_exists($newupgrade_function) && $oldupgrade_status) {
$db->debug = true;
$newupgrade_status = $newupgrade_function($currmodule->version, $module);
} else {
if ($newupgrade && $oldupgrade_status) {
notify('Upgrade function ' . $newupgrade_function . ' was not available in ' . $mod . ': ' . $fullmod . '/db/upgrade.php');
}
}
$db->debug = false;
/// Now analyze upgrade results
if ($oldupgrade_status && $newupgrade_status) {
// No upgrading failed
// OK so far, now update the modules record
$module->id = $currmodule->id;
if (!update_record('modules', $module)) {
error('Could not update ' . $module->name . ' record in modules table!');
}
remove_dir($CFG->dataroot . '/cache', true);
// flush cache
notify(get_string('modulesuccess', '', $module->name), 'notifysuccess');
echo '<hr />';
} else {
notify('Upgrading ' . $module->name . ' from ' . $currmodule->version . ' to ' . $module->version . ' FAILED!');
}
/// Update the capabilities table?
if (!update_capabilities('mod/' . $module->name)) {
error('Could not update ' . $module->name . ' capabilities!');
}
events_update_definition('mod/' . $module->name);
$updated_modules = true;
} else {
upgrade_log_start();
error('Version mismatch: ' . $module->name . ' can\'t downgrade ' . $currmodule->version . ' -> ' . $module->version . ' !');
}
}
} else {
// module not installed yet, so install it
if (!$updated_modules) {
print_header($strmodulesetup, $strmodulesetup, build_navigation(array(array('name' => $strmodulesetup, 'link' => null, 'type' => 'misc'))), '', upgrade_get_javascript(), false, ' ', ' ');
}
upgrade_log_start();
print_heading($module->name);
$updated_modules = true;
$db->debug = true;
@set_time_limit(0);
// To allow slow databases to complete the long SQL
/// Both old .sql files and new install.xml are supported
/// but we priorize install.xml (XMLDB) if present
if (file_exists($fullmod . '/db/install.xml')) {
$status = install_from_xmldb_file($fullmod . '/db/install.xml');
//New method
} else {
$status = modify_database($fullmod . '/db/' . $CFG->dbtype . '.sql');
//Old method
}
$db->debug = false;
/// Continue with the installation, roles and other stuff
if ($status) {
if ($module->id = insert_record('modules', $module)) {
/// Capabilities
if (!update_capabilities('mod/' . $module->name)) {
error('Could not set up the capabilities for ' . $module->name . '!');
}
/// Events
events_update_definition('mod/' . $module->name);
/// Run local install function if there is one
$installfunction = $module->name . '_install';
if (function_exists($installfunction)) {
if (!$installfunction()) {
notify('Encountered a problem running install function for ' . $module->name . '!');
}
}
notify(get_string('modulesuccess', '', $module->name), 'notifysuccess');
echo '<hr />';
} else {
error($module->name . ' module could not be added to the module list!');
}
} else {
error($module->name . ' tables could NOT be set up successfully!');
}
}
/// Check submodules of this module if necessary
$submoduleupgrade = $module->name . '_upgrade_submodules';
if (function_exists($submoduleupgrade)) {
$submoduleupgrade();
}
/// Run any defaults or final code that is necessary for this module
if (is_readable($fullmod . '/defaults.php')) {
// Insert default values for any important configuration variables
unset($defaults);
include $fullmod . '/defaults.php';
// include here means execute, not library include
if (!empty($defaults)) {
foreach ($defaults as $name => $value) {
if (!isset($CFG->{$name})) {
set_config($name, $value);
}
}
}
}
}
upgrade_log_finish();
// finish logging if started
if ($updated_modules) {
print_continue($return);
print_footer('none');
die;
}
}
public function test_legacy()
{
global $DB;
$this->resetAfterTest(true);
$observers = array(array('eventname' => '\\core_tests\\event\\unittest_executed', 'callback' => '\\core_tests\\event\\unittest_observer::observe_one'), array('eventname' => '*', 'callback' => '\\core_tests\\event\\unittest_observer::observe_all', 'includefile' => null, 'internal' => 1, 'priority' => 9999));
$DB->delete_records('log', array());
events_update_definition('unittest');
$DB->delete_records_select('events_handlers', "component <> 'unittest'");
events_get_handlers('reset');
$this->assertEquals(3, $DB->count_records('events_handlers'));
set_config('loglifetime', 60 * 60 * 24 * 5);
\core\event\manager::phpunit_replace_observers($observers);
\core_tests\event\unittest_observer::reset();
$event1 = \core_tests\event\unittest_executed::create(array('courseid' => 1, 'context' => \context_system::instance(), 'other' => array('sample' => 5, 'xx' => 10)));
$event1->trigger();
$event2 = \core_tests\event\unittest_executed::create(array('courseid' => 2, 'context' => \context_system::instance(), 'other' => array('sample' => 6, 'xx' => 11)));
$event2->nest = true;
$event2->trigger();
$this->assertSame(array('observe_all-1', 'observe_one-1', 'legacy_handler-1', 'observe_all-nesting-2', 'legacy_handler-3', 'observe_one-2', 'observe_all-3', 'observe_one-3', 'legacy_handler-2'), \core_tests\event\unittest_observer::$info);
$this->assertSame($event1, \core_tests\event\unittest_observer::$event[0]);
$this->assertSame($event1, \core_tests\event\unittest_observer::$event[1]);
$this->assertSame(array(1, 5), \core_tests\event\unittest_observer::$event[2]);
$logs = $DB->get_records('log', array(), 'id ASC');
$this->assertCount(3, $logs);
$log = array_shift($logs);
$this->assertEquals(1, $log->course);
$this->assertSame('core_unittest', $log->module);
$this->assertSame('view', $log->action);
$log = array_shift($logs);
$this->assertEquals(2, $log->course);
$this->assertSame('core_unittest', $log->module);
$this->assertSame('view', $log->action);
$log = array_shift($logs);
$this->assertEquals(3, $log->course);
$this->assertSame('core_unittest', $log->module);
$this->assertSame('view', $log->action);
}
}
$db->debug = false;
/// If successful, continue upgrading roles and setting everything properly
if ($status) {
if (empty($CFG->rolesactive)) {
/// Groups upgrade is now in core above.
// Upgrade to the roles system.
moodle_install_roles();
set_config('rolesactive', 1);
} else {
if (!update_capabilities()) {
error('Had trouble upgrading the core capabilities for the Roles System');
}
}
// update core events
events_update_definition();
require_once $CFG->libdir . '/statslib.php';
if (!stats_upgrade_for_roles_wrapper()) {
notify('Couldn\'t upgrade the stats tables to use the new roles system');
}
if (set_config("version", $version)) {
remove_dir($CFG->dataroot . '/cache', true);
// flush cache
notify($strdatabasesuccess, "green");
print_continue("upgradesettings.php");
print_footer('none');
exit;
} else {
error('Upgrade failed! (Could not update version in config table)');
}
/// Main upgrade not success
/**
* Upgrade moodle core
* @param float $version target version
* @param bool $verbose
* @return void, may throw exception
*/
function upgrade_core($version, $verbose)
{
global $CFG;
raise_memory_limit(MEMORY_EXTRA);
require_once $CFG->libdir . '/db/upgrade.php';
// Defines upgrades
try {
// Reset caches before any output.
cache_helper::purge_all(true);
purge_all_caches();
// Upgrade current language pack if we can
upgrade_language_pack();
print_upgrade_part_start('moodle', false, $verbose);
// Pre-upgrade scripts for local hack workarounds.
$preupgradefile = "{$CFG->dirroot}/local/preupgrade.php";
if (file_exists($preupgradefile)) {
core_php_time_limit::raise();
require $preupgradefile;
// Reset upgrade timeout to default.
upgrade_set_timeout();
}
$result = xmldb_main_upgrade($CFG->version);
if ($version > $CFG->version) {
// store version if not already there
upgrade_main_savepoint($result, $version, false);
}
// perform all other component upgrade routines
update_capabilities('moodle');
log_update_descriptions('moodle');
external_update_descriptions('moodle');
events_update_definition('moodle');
message_update_providers('moodle');
// Update core definitions.
cache_helper::update_definitions(true);
// Purge caches again, just to be sure we arn't holding onto old stuff now.
cache_helper::purge_all(true);
purge_all_caches();
// Clean up contexts - more and more stuff depends on existence of paths and contexts
context_helper::cleanup_instances();
context_helper::create_instances(null, false);
context_helper::build_all_paths(false);
$syscontext = context_system::instance();
$syscontext->mark_dirty();
print_upgrade_part_end('moodle', false, $verbose);
} catch (Exception $ex) {
upgrade_handle_exception($ex);
}
}
/**
* Tests events_trigger() function.
*/
public function test_events_trigger_debugging()
{
events_update_definition('unittest');
$this->assertDebuggingCalled(self::DEBUGGING_MSG, DEBUG_DEVELOPER);
$this->assertEquals(0, events_trigger('test_instant', 'ok'));
$debugmessages = array('events_trigger() is deprecated, please use new events instead', self::DEBUGGING_MSG);
$this->assertDebuggingCalledCount(2, $debugmessages, array(DEBUG_DEVELOPER, DEBUG_DEVELOPER));
}
/**
* Upgrade moodle core
* @param float $version target version
* @param bool $verbose
* @return void, may throw exception
*/
function upgrade_core($version, $verbose)
{
global $CFG;
require_once $CFG->libdir . '/db/upgrade.php';
// Defines upgrades
try {
// Upgrade current language pack if we can
if (empty($CFG->skiplangupgrade)) {
upgrade_language_pack(false);
}
print_upgrade_part_start('moodle', false, $verbose);
// one time special local migration pre 2.0 upgrade script
if ($version < 2007101600) {
$pre20upgradefile = "{$CFG->dirrot}/local/upgrade_pre20.php";
if (file_exists($pre20upgradefile)) {
set_time_limit(0);
require $pre20upgradefile;
// reset upgrade timeout to default
upgrade_set_timeout();
}
}
$result = xmldb_main_upgrade($CFG->version);
if ($version > $CFG->version) {
// store version if not already there
upgrade_main_savepoint($result, $version, false);
}
// perform all other component upgrade routines
update_capabilities('moodle');
events_update_definition('moodle');
message_update_providers('moodle');
remove_dir($CFG->dataroot . '/cache', true);
// flush cache
print_upgrade_part_end('moodle', false, $verbose);
} catch (Exception $ex) {
upgrade_handle_exception($ex);
}
}
public function test_legacy()
{
global $DB, $CFG;
$this->resetAfterTest(true);
$observers = array(array('eventname' => '\\core_tests\\event\\unittest_executed', 'callback' => '\\core_tests\\event\\unittest_observer::observe_one'), array('eventname' => '*', 'callback' => '\\core_tests\\event\\unittest_observer::observe_all', 'includefile' => null, 'internal' => 1, 'priority' => 9999));
$DB->delete_records('log', array());
events_update_definition('unittest');
$this->assertDebuggingCalled(self::DEBUGGING_MSG, DEBUG_DEVELOPER);
$DB->delete_records_select('events_handlers', "component <> 'unittest'");
events_get_handlers('reset');
$this->assertEquals(3, $DB->count_records('events_handlers'));
set_config('loglifetime', 60 * 60 * 24 * 5);
\core\event\manager::phpunit_replace_observers($observers);
\core_tests\event\unittest_observer::reset();
$event1 = \core_tests\event\unittest_executed::create(array('context' => \context_system::instance(), 'other' => array('sample' => 5, 'xx' => 10)));
$event1->trigger();
$this->assertDebuggingCalled(self::DEBUGGING_MSG, DEBUG_DEVELOPER);
$event2 = \core_tests\event\unittest_executed::create(array('context' => \context_system::instance(), 'other' => array('sample' => 6, 'xx' => 11)));
$event2->nest = true;
$event2->trigger();
$this->assertDebuggingCalledCount(2, array(self::DEBUGGING_MSG, self::DEBUGGING_MSG), array(DEBUG_DEVELOPER, DEBUG_DEVELOPER));
$this->assertSame(array('observe_all-5', 'observe_one-5', 'legacy_handler-0', 'observe_all-nesting-6', 'legacy_handler-0', 'observe_one-6', 'observe_all-666', 'observe_one-666', 'legacy_handler-0'), \core_tests\event\unittest_observer::$info);
$this->assertSame($event1, \core_tests\event\unittest_observer::$event[0]);
$this->assertSame($event1, \core_tests\event\unittest_observer::$event[1]);
$this->assertSame(array(0, 5), \core_tests\event\unittest_observer::$event[2]);
$logs = $DB->get_records('log', array(), 'id ASC');
$this->assertCount(0, $logs);
}
} else {
/// Launch main upgrade
try {
// Upgrade current language pack if we can
if (empty($CFG->skiplangupgrade)) {
upgrade_language_pack(false);
}
print_upgrade_part_start('moodle', false);
$result = xmldb_main_upgrade($CFG->version);
if ($version > $CFG->version) {
// store version if not already there
upgrade_main_savepoint($result, $version, false);
}
// perform all other component upgrade routines
update_capabilities('moodle');
events_update_definition('moodle');
message_update_providers('moodle');
message_update_providers('message');
remove_dir($CFG->dataroot . '/cache', true);
// flush cache
print_upgrade_part_end('moodle', false);
} catch (Exception $ex) {
upgrade_handle_exception($ex);
}
}
}
} else {
if ($version < $CFG->version) {
notify("WARNING!!! The code you are using is OLDER than the version that made these databases!");
}
}
/**
* Find and check all submodules and load them up or upgrade them if necessary
*
* @global object
* @global object
*/
function vmoodle_upgrade_subplugins_modules($startcallback, $endcallback, $verbose = true)
{
global $CFG, $DB;
include $CFG->dirroot . '/local/vmoodle/db/subplugins.php';
foreach ($subplugins as $type => $subpluginpath) {
$plugindirs = glob($CFG->dirroot . '/' . $subpluginpath . '/*');
foreach ($plugindirs as $dir) {
$plug = basename($dir);
$fullplug = $dir;
if ($plug === 'CVS') {
// Someone has unzipped the template, ignore it.
continue;
}
if ($plug === 'NEWMODULE') {
// Someone has unzipped the template, ignore it.
continue;
}
// Reset time so that it works when installing a large number of plugins.
set_time_limit(600);
$component = clean_param($type . '_' . $plug, PARAM_COMPONENT);
// standardised plugin name
// Check plugin dir is valid name.
if (empty($component)) {
throw new plugin_defective_exception($type . '_' . $plug, 'Invalid plugin directory name.');
}
if (!is_readable($fullplug . '/version.php')) {
continue;
}
$plugin = new stdClass();
require $fullplug . '/version.php';
// Defines $plugin with version etc.
// If plugin tells us it's full name we may check the location.
if (isset($plugin->component)) {
if ($plugin->component !== $component) {
throw new plugin_defective_exception($component, 'Plugin installed in wrong folder.');
}
}
if (empty($plugin->version)) {
throw new plugin_defective_exception($component, 'Missing version value in version.php');
}
$plugin->name = $plug;
$plugin->fullname = $component;
if (!empty($plugin->requires)) {
if ($plugin->requires > $CFG->version) {
throw new upgrade_requires_exception($component, $plugin->version, $CFG->version, $plugin->requires);
} else {
if ($plugin->requires < 2010000000) {
throw new plugin_defective_exception($component, 'Plugin is not compatible with Moodle 2.x or later.');
}
}
}
// Try to recover from interrupted install.php if needed.
if (file_exists($fullplug . '/db/install.php')) {
if (get_config($plugin->fullname, 'installrunning')) {
require_once $fullplug . '/db/install.php';
$recover_install_function = 'xmldb_' . $plugin->fullname . '_install_recovery';
if (function_exists($recover_install_function)) {
$startcallback($component, true, $verbose);
$recover_install_function();
unset_config('installrunning', $plugin->fullname);
update_capabilities($component);
log_update_descriptions($component);
external_update_descriptions($component);
events_update_definition($component);
message_update_providers($component);
if ($type === 'message') {
message_update_processors($plug);
}
vmoodle_upgrade_plugin_mnet_functions($component, $fullplug);
// Fix wrongly twicked paths.
if ($rpc_shifted_defines = $DB->get_records_select('mnet_rpc', " xmlrpcpath LIKE 'vmoodleadminset' ", array())) {
foreach ($rpc_shifted_defines as $rpc) {
$rpc->xmlrpcpath = str_replace('vmoocleadminset', 'local/vmoodle/plugins');
$DB->update_record('mnet_rpc', $rpc);
}
}
$endcallback($component, true, $verbose);
}
}
}
$installedversion = get_config($plugin->fullname, 'version');
if (empty($installedversion)) {
// New installation.
$startcallback($component, true, $verbose);
// Install tables if defined.
if (file_exists($fullplug . '/db/install.xml')) {
$DB->get_manager()->install_from_xmldb_file($fullplug . '/db/install.xml');
}
// Store version.
upgrade_plugin_savepoint(true, $plugin->version, $type, $plug, false);
// Execute post install file.
if (file_exists($fullplug . '/db/install.php')) {
require_once $fullplug . '/db/install.php';
set_config('installrunning', 1, $plugin->fullname);
$post_install_function = 'xmldb_' . $plugin->fullname . '_install';
$post_install_function();
unset_config('installrunning', $plugin->fullname);
}
// Install various components.
update_capabilities($component);
log_update_descriptions($component);
external_update_descriptions($component);
events_update_definition($component);
message_update_providers($component);
if ($type === 'message') {
message_update_processors($plug);
}
vmoodle_upgrade_plugin_mnet_functions($component, $fullplug);
// Fix wrongly twicked paths.
if ($rpc_shifted_defines = $DB->get_records_select('mnet_rpc', " xmlrpcpath LIKE 'vmoodleadminset' ", array())) {
foreach ($rpc_shifted_defines as $rpc) {
$rpc->xmlrpcpath = str_replace('vmoocleadminset', 'local/vmoodle/plugins');
$DB->update_record('mnet_rpc', $rpc);
}
}
purge_all_caches();
$endcallback($component, true, $verbose);
} else {
if ($installedversion < $plugin->version) {
// Upgrade
// Run the upgrade function for the plugin.
$startcallback($component, false, $verbose);
if (is_readable($fullplug . '/db/upgrade.php')) {
require_once $fullplug . '/db/upgrade.php';
// Defines upgrading function
$newupgrade_function = 'xmldb_' . $plugin->fullname . '_upgrade';
$result = $newupgrade_function($installedversion);
} else {
$result = true;
}
$installedversion = get_config($plugin->fullname, 'version');
if ($installedversion < $plugin->version) {
// store version if not already there.
upgrade_plugin_savepoint($result, $plugin->version, $type, $plug, false);
}
// Upgrade various components.
update_capabilities($component);
log_update_descriptions($component);
external_update_descriptions($component);
events_update_definition($component);
message_update_providers($component);
if ($type === 'message') {
message_update_processors($plug);
}
vmoodle_upgrade_plugin_mnet_functions($component, $fullplug);
purge_all_caches();
$endcallback($component, false, $verbose);
} else {
if ($installedversion > $plugin->version) {
throw new downgrade_exception($component, $installedversion, $plugin->version);
}
}
}
}
}
}
/**
* This function checks to see whether local database customisations are up-to-date
* by comparing $CFG->local_version to the variable $local_version defined in
* local/version.php. If not, it looks for a function called 'xmldb_local_upgrade'
* in a file called 'local/db/upgrade.php', and if it's there calls it with the
* appropiate $oldversion parameter. Then it updates $CFG->local_version.
*
* @uses $CFG
*/
function upgrade_local_db($startcallback, $endcallback)
{
global $CFG, $DB;
// if we don't have code version, just return false
if (!file_exists($CFG->dirroot . '/local/version.php')) {
return;
}
$local_version = null;
require $CFG->dirroot . '/local/version.php';
// Get code versions
if (empty($CFG->local_version)) {
// install
$startcallback('local', true);
if (file_exists($CFG->dirroot . '/local/db/install.php')) {
require_once $CFG->dirroot . '/local/db/install.php';
xmldb_local_install();
}
set_config('local_version', $local_version);
/// Install various components
events_update_definition('local');
update_capabilities('local');
message_update_providers('local');
$endcallback('local', true);
} else {
if ($local_version > $CFG->local_version) {
// upgrade!
$startcallback('local', false);
if (file_exists($CFG->dirroot . '/local/db/upgrade.php')) {
require_once $CFG->dirroot . '/local/db/upgrade.php';
xmldb_local_upgrade($CFG->local_version);
}
set_config('local_version', $local_version);
/// Upgrade various components
events_update_definition('local');
update_capabilities('local');
message_update_providers('local');
$endcallback('local', false);
} else {
if ($local_version < $CFG->local_version) {
throw new downgrade_exception('local', $CFG->local_version, $local_version);
}
}
}
}
/**
* This function checks to see whether local database customisations are up-to-date
* by comparing $CFG->local_version to the variable $local_version defined in
* local/version.php. If not, it looks for a function called 'xmldb_local_upgrade'
* in a file called 'local/db/upgrade.php', and if it's there calls it with the
* appropiate $oldversion parameter. Then it updates $CFG->local_version.
* On success it prints a continue link. On failure it prints an error.
*
* @uses $CFG
* @uses $db to do something really evil with the debug setting that should probably be eliminated. TODO!
* @param string $continueto a URL passed to print_continue() if the local upgrades succeed.
*/
function upgrade_local_dbs($continueto)
{
global $CFG, $db;
$path = '/local';
$pat = 'local';
$status = true;
$changed = false;
$firstloop = true;
while (is_dir($CFG->dirroot . $path)) {
// if we don't have code version or a db upgrade file, check lower
if (!file_exists($CFG->dirroot . "{$path}/version.php") || !file_exists($CFG->dirroot . "{$path}/db/upgrade.php")) {
$path .= '/local';
$pat .= 'local';
continue;
}
require_once $CFG->dirroot . "{$path}/version.php";
// Get code versions
$cfgvarname = "{$pat}_version";
if (empty($CFG->{$cfgvarname})) {
// normally we'd install, but just replay all the upgrades.
$CFG->{$cfgvarname} = 0;
}
$localversionvar = "{$pat}_version";
// echo "($localversionvar) ".$$localversionvar." > ($cfgvarname) ".$CFG->{$cfgvarname}."<br/>";
if (${$localversionvar} > $CFG->{$cfgvarname}) {
// something upgrades!
upgrade_log_start();
/// Capabilities
/// do this first *instead of* last , so that the installer has the chance to locally assign caps
if (!update_capabilities($pat)) {
error('Could not set up the capabilities for ' . $pat . '!');
}
if ($firstloop) {
$strdatabaseupgrades = get_string('databaseupgrades');
print_header($strdatabaseupgrades, $strdatabaseupgrades, build_navigation(array(array('name' => $strdatabaseupgrades, 'link' => null, 'type' => 'misc'))), '', upgrade_get_javascript());
$firstloop = false;
}
$changed = true;
require_once $CFG->dirroot . "{$path}/db/upgrade.php";
$db->debug = true;
$upgradefunc = "xmldb_{$pat}_upgrade";
if ($upgradefunc($CFG->{$cfgvarname})) {
$db->debug = false;
if (set_config($localversionvar, ${$localversionvar})) {
notify(get_string('databasesuccess'), 'notifysuccess');
notify(get_string('databaseupgradelocal', '', $path . ' >> ' . ${$localversionvar}), 'notifysuccess');
} else {
$status = false;
error('Upgrade of local database customisations failed in $path! (Could not update version in config table)');
}
} else {
$db->debug = false;
error("Upgrade failed! See {$path}/version.php");
}
if (!events_update_definition($pat)) {
error('Could not set up the events definitions for ' . $pat . '!');
}
upgrade_log_finish();
} else {
if (${$localversionvar} < $CFG->{$cfgvarname}) {
notify("WARNING!!! The local version you are using in {$path} is OLDER than the version that made these databases!");
}
}
$path .= '/local';
$pat .= 'local';
}
if ($changed) {
print_continue($continueto);
print_footer('none');
exit;
}
}
/**
* Upgrade moodle core
* @param float $version target version
* @param bool $verbose
* @return void, may throw exception
*/
function upgrade_core($version, $verbose) {
global $CFG;
raise_memory_limit(MEMORY_EXTRA);
require_once($CFG->libdir.'/db/upgrade.php'); // Defines upgrades
try {
// Reset caches before any output
purge_all_caches();
// Upgrade current language pack if we can
upgrade_language_pack();
print_upgrade_part_start('moodle', false, $verbose);
// one time special local migration pre 2.0 upgrade script
if ($CFG->version < 2007101600) {
$pre20upgradefile = "$CFG->dirroot/local/upgrade_pre20.php";
if (file_exists($pre20upgradefile)) {
set_time_limit(0);
require($pre20upgradefile);
// reset upgrade timeout to default
upgrade_set_timeout();
}
}
$result = xmldb_main_upgrade($CFG->version);
if ($version > $CFG->version) {
// store version if not already there
upgrade_main_savepoint($result, $version, false);
}
// perform all other component upgrade routines
update_capabilities('moodle');
log_update_descriptions('moodle');
external_update_descriptions('moodle');
events_update_definition('moodle');
message_update_providers('moodle');
// Reset caches again, just to be sure
purge_all_caches();
// Clean up contexts - more and more stuff depends on existence of paths and contexts
context_helper::cleanup_instances();
context_helper::create_instances(null, false);
context_helper::build_all_paths(false);
$syscontext = context_system::instance();
$syscontext->mark_dirty();
print_upgrade_part_end('moodle', false, $verbose);
} catch (Exception $ex) {
upgrade_handle_exception($ex);
}
}
/**
* Tests the update of event handlers from file
*/
function test__events_update_definition__update()
{
// first modify directly existing handler
$handler = get_record('events_handlers', 'handlermodule', 'unittest', 'eventname', 'test_instant');
$original = $handler->handlerfunction;
// change handler in db
set_field('events_handlers', 'handlerfunction', serialize('some_other_function_handler'), 'id', $handler->id);
// update the definition, it should revert the handler back
events_update_definition('unittest');
$handler = get_record('events_handlers', 'handlermodule', 'unittest', 'eventname', 'test_instant');
$this->assertEqual($handler->handlerfunction, $original, 'update should sync db with file definition: %s');
}
/**
* Upgrade moodle core
* @param float $version target version
* @param bool $verbose
* @return void, may throw exception
*/
function upgrade_core($version, $verbose)
{
global $CFG;
raise_memory_limit(MEMORY_EXTRA);
require_once $CFG->libdir . '/db/upgrade.php';
// Defines upgrades
try {
// Reset caches before any output
purge_all_caches();
// Disable the use of cache stores here. We will reset the factory after we've performed the installation.
// This ensures that we don't permanently cache anything during installation.
cache_factory::disable_stores();
// Upgrade current language pack if we can
upgrade_language_pack();
print_upgrade_part_start('moodle', false, $verbose);
// one time special local migration pre 2.0 upgrade script
if ($CFG->version < 2007101600) {
$pre20upgradefile = "{$CFG->dirroot}/local/upgrade_pre20.php";
if (file_exists($pre20upgradefile)) {
set_time_limit(0);
require $pre20upgradefile;
// reset upgrade timeout to default
upgrade_set_timeout();
}
}
$result = xmldb_main_upgrade($CFG->version);
if ($version > $CFG->version) {
// store version if not already there
upgrade_main_savepoint($result, $version, false);
}
// perform all other component upgrade routines
update_capabilities('moodle');
log_update_descriptions('moodle');
external_update_descriptions('moodle');
events_update_definition('moodle');
message_update_providers('moodle');
// Update core definitions.
cache_helper::update_definitions(true);
// Reset the cache, this returns it to a normal operation state.
cache_factory::reset();
// Purge caches again, just to be sure we arn't holding onto old stuff now.
purge_all_caches();
// Clean up contexts - more and more stuff depends on existence of paths and contexts
context_helper::cleanup_instances();
context_helper::create_instances(null, false);
context_helper::build_all_paths(false);
$syscontext = context_system::instance();
$syscontext->mark_dirty();
print_upgrade_part_end('moodle', false, $verbose);
} catch (Exception $ex) {
upgrade_handle_exception($ex);
}
}
