You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
359 lines
12 KiB
359 lines
12 KiB
<?php
|
|
// This file is part of Moodle - http://moodle.org/
|
|
//
|
|
// Moodle is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// Moodle is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
namespace core\event;
|
|
|
|
defined('MOODLE_INTERNAL') || die();
|
|
|
|
/**
|
|
* New event manager class.
|
|
*
|
|
* @package core
|
|
* @since Moodle 2.6
|
|
* @copyright 2013 Petr Skoda {@link http://skodak.org}
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
|
|
/**
|
|
* Class used for event dispatching.
|
|
*
|
|
* Note: Do NOT use directly in your code, it is intended to be used from
|
|
* base event class only.
|
|
*/
|
|
class manager {
|
|
/** @var array buffer of event for dispatching */
|
|
protected static $buffer = array();
|
|
|
|
/** @var array buffer for events that were not sent to external observers when DB transaction in progress */
|
|
protected static $extbuffer = array();
|
|
|
|
/** @var bool evert dispatching already in progress - prevents nesting */
|
|
protected static $dispatching = false;
|
|
|
|
/** @var array cache of all observers */
|
|
protected static $allobservers = null;
|
|
|
|
/** @var bool should we reload observers after the test? */
|
|
protected static $reloadaftertest = false;
|
|
|
|
/**
|
|
* Trigger new event.
|
|
*
|
|
* @internal to be used only from \core\event\base::trigger() method.
|
|
* @param \core\event\base $event
|
|
*
|
|
* @throws \coding_Exception if used directly.
|
|
*/
|
|
public static function dispatch(\core\event\base $event) {
|
|
if (during_initial_install()) {
|
|
return;
|
|
}
|
|
if (!$event->is_triggered() or $event->is_dispatched()) {
|
|
throw new \coding_exception('Illegal event dispatching attempted.');
|
|
}
|
|
|
|
self::$buffer[] = $event;
|
|
|
|
if (self::$dispatching) {
|
|
return;
|
|
}
|
|
|
|
self::$dispatching = true;
|
|
self::process_buffers();
|
|
self::$dispatching = false;
|
|
}
|
|
|
|
/**
|
|
* Notification from DML layer.
|
|
* @internal to be used from DML layer only.
|
|
*/
|
|
public static function database_transaction_commited() {
|
|
if (self::$dispatching or empty(self::$extbuffer)) {
|
|
return;
|
|
}
|
|
|
|
self::$dispatching = true;
|
|
self::process_buffers();
|
|
self::$dispatching = false;
|
|
}
|
|
|
|
/**
|
|
* Notification from DML layer.
|
|
* @internal to be used from DML layer only.
|
|
*/
|
|
public static function database_transaction_rolledback() {
|
|
self::$extbuffer = array();
|
|
}
|
|
|
|
protected static function process_buffers() {
|
|
global $DB, $CFG;
|
|
self::init_all_observers();
|
|
|
|
while (self::$buffer or self::$extbuffer) {
|
|
|
|
$fromextbuffer = false;
|
|
$addedtoextbuffer = false;
|
|
|
|
if (self::$extbuffer and !$DB->is_transaction_started()) {
|
|
$fromextbuffer = true;
|
|
$event = reset(self::$extbuffer);
|
|
unset(self::$extbuffer[key(self::$extbuffer)]);
|
|
|
|
} else if (self::$buffer) {
|
|
$event = reset(self::$buffer);
|
|
unset(self::$buffer[key(self::$buffer)]);
|
|
|
|
} else {
|
|
return;
|
|
}
|
|
|
|
$observingclasses = self::get_observing_classes($event);
|
|
foreach ($observingclasses as $observingclass) {
|
|
if (!isset(self::$allobservers[$observingclass])) {
|
|
continue;
|
|
}
|
|
foreach (self::$allobservers[$observingclass] as $observer) {
|
|
if ($observer->internal) {
|
|
if ($fromextbuffer) {
|
|
// Do not send buffered external events to internal handlers,
|
|
// they processed them already.
|
|
continue;
|
|
}
|
|
} else {
|
|
if ($DB->is_transaction_started()) {
|
|
if ($fromextbuffer) {
|
|
// Weird!
|
|
continue;
|
|
}
|
|
// Do not notify external observers while in DB transaction.
|
|
if (!$addedtoextbuffer) {
|
|
self::$extbuffer[] = $event;
|
|
$addedtoextbuffer = true;
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (isset($observer->includefile) and file_exists($observer->includefile)) {
|
|
include_once($observer->includefile);
|
|
}
|
|
if (is_callable($observer->callable)) {
|
|
try {
|
|
call_user_func($observer->callable, $event);
|
|
} catch (\Exception $e) {
|
|
// Observers are notified before installation and upgrade, this may throw errors.
|
|
if (empty($CFG->upgraderunning)) {
|
|
// Ignore errors during upgrade, otherwise warn developers.
|
|
debugging("Exception encountered in event observer '$observer->callable': ".$e->getMessage(), DEBUG_DEVELOPER, $e->getTrace());
|
|
}
|
|
}
|
|
} else {
|
|
debugging("Can not execute event observer '$observer->callable'");
|
|
}
|
|
}
|
|
}
|
|
|
|
// TODO: Invent some infinite loop protection in case events cross-trigger one another.
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns list of classes related to this event.
|
|
* @param \core\event\base $event
|
|
* @return array
|
|
*/
|
|
protected static function get_observing_classes(\core\event\base $event) {
|
|
$classname = get_class($event);
|
|
$observers = array('\\'.$classname);
|
|
while ($classname = get_parent_class($classname)) {
|
|
$observers[] = '\\'.$classname;
|
|
}
|
|
$observers = array_reverse($observers, false);
|
|
|
|
return $observers;
|
|
}
|
|
|
|
/**
|
|
* Initialise the list of observers.
|
|
*/
|
|
protected static function init_all_observers() {
|
|
global $CFG;
|
|
|
|
if (is_array(self::$allobservers)) {
|
|
return;
|
|
}
|
|
|
|
if (!PHPUNIT_TEST and !during_initial_install()) {
|
|
$cache = \cache::make('core', 'observers');
|
|
$cached = $cache->get('all');
|
|
$dirroot = $cache->get('dirroot');
|
|
if ($dirroot === $CFG->dirroot and is_array($cached)) {
|
|
self::$allobservers = $cached;
|
|
return;
|
|
}
|
|
}
|
|
|
|
self::$allobservers = array();
|
|
|
|
$plugintypes = \core_component::get_plugin_types();
|
|
$plugintypes = array_merge(array('core' => 'not used'), $plugintypes);
|
|
$systemdone = false;
|
|
foreach ($plugintypes as $plugintype => $ignored) {
|
|
if ($plugintype === 'core') {
|
|
$plugins['core'] = "$CFG->dirroot/lib";
|
|
} else {
|
|
$plugins = \core_component::get_plugin_list($plugintype);
|
|
}
|
|
|
|
foreach ($plugins as $plugin => $fulldir) {
|
|
if (!file_exists("$fulldir/db/events.php")) {
|
|
continue;
|
|
}
|
|
$observers = null;
|
|
include("$fulldir/db/events.php");
|
|
if (!is_array($observers)) {
|
|
continue;
|
|
}
|
|
self::add_observers($observers, "$fulldir/db/events.php", $plugintype, $plugin);
|
|
}
|
|
}
|
|
|
|
self::order_all_observers();
|
|
|
|
if (!PHPUNIT_TEST and !during_initial_install()) {
|
|
$cache->set('all', self::$allobservers);
|
|
$cache->set('dirroot', $CFG->dirroot);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add observers.
|
|
* @param array $observers
|
|
* @param string $file
|
|
* @param string $plugintype Plugin type of the observer.
|
|
* @param string $plugin Plugin of the observer.
|
|
*/
|
|
protected static function add_observers(array $observers, $file, $plugintype = null, $plugin = null) {
|
|
global $CFG;
|
|
|
|
foreach ($observers as $observer) {
|
|
if (empty($observer['eventname']) or !is_string($observer['eventname'])) {
|
|
debugging("Invalid 'eventname' detected in $file observer definition", DEBUG_DEVELOPER);
|
|
continue;
|
|
}
|
|
if ($observer['eventname'] === '*') {
|
|
$observer['eventname'] = '\core\event\base';
|
|
}
|
|
if (strpos($observer['eventname'], '\\') !== 0) {
|
|
$observer['eventname'] = '\\'.$observer['eventname'];
|
|
}
|
|
if (empty($observer['callback'])) {
|
|
debugging("Invalid 'callback' detected in $file observer definition", DEBUG_DEVELOPER);
|
|
continue;
|
|
}
|
|
$o = new \stdClass();
|
|
$o->callable = $observer['callback'];
|
|
if (!isset($observer['priority'])) {
|
|
$o->priority = 0;
|
|
} else {
|
|
$o->priority = (int)$observer['priority'];
|
|
}
|
|
if (!isset($observer['internal'])) {
|
|
$o->internal = true;
|
|
} else {
|
|
$o->internal = (bool)$observer['internal'];
|
|
}
|
|
if (empty($observer['includefile'])) {
|
|
$o->includefile = null;
|
|
} else {
|
|
if ($CFG->admin !== 'admin' and strpos($observer['includefile'], '/admin/') === 0) {
|
|
$observer['includefile'] = preg_replace('|^/admin/|', '/'.$CFG->admin.'/', $observer['includefile']);
|
|
}
|
|
$observer['includefile'] = $CFG->dirroot . '/' . ltrim($observer['includefile'], '/');
|
|
if (!file_exists($observer['includefile'])) {
|
|
debugging("Invalid 'includefile' detected in $file observer definition", DEBUG_DEVELOPER);
|
|
continue;
|
|
}
|
|
$o->includefile = $observer['includefile'];
|
|
}
|
|
$o->plugintype = $plugintype;
|
|
$o->plugin = $plugin;
|
|
self::$allobservers[$observer['eventname']][] = $o;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Reorder observers to allow quick lookup of observer for each event.
|
|
*/
|
|
protected static function order_all_observers() {
|
|
foreach (self::$allobservers as $classname => $observers) {
|
|
\core_collator::asort_objects_by_property($observers, 'priority', \core_collator::SORT_NUMERIC);
|
|
self::$allobservers[$classname] = array_reverse($observers);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns all observers in the system. This is only for use for reporting on the list of observers in the system.
|
|
*
|
|
* @access private
|
|
* @return array An array of stdClass with all core observer details.
|
|
*/
|
|
public static function get_all_observers() {
|
|
self::init_all_observers();
|
|
return self::$allobservers;
|
|
}
|
|
|
|
/**
|
|
* Replace all standard observers.
|
|
* @param array $observers
|
|
* @return array
|
|
*
|
|
* @throws \coding_Exception if used outside of unit tests.
|
|
*/
|
|
public static function phpunit_replace_observers(array $observers) {
|
|
if (!PHPUNIT_TEST) {
|
|
throw new \coding_exception('Cannot override event observers outside of phpunit tests!');
|
|
}
|
|
|
|
self::phpunit_reset();
|
|
self::$allobservers = array();
|
|
self::$reloadaftertest = true;
|
|
|
|
self::add_observers($observers, 'phpunit');
|
|
self::order_all_observers();
|
|
|
|
return self::$allobservers;
|
|
}
|
|
|
|
/**
|
|
* Reset everything if necessary.
|
|
* @private
|
|
*
|
|
* @throws \coding_Exception if used outside of unit tests.
|
|
*/
|
|
public static function phpunit_reset() {
|
|
if (!PHPUNIT_TEST) {
|
|
throw new \coding_exception('Cannot reset event manager outside of phpunit tests!');
|
|
}
|
|
self::$buffer = array();
|
|
self::$extbuffer = array();
|
|
self::$dispatching = false;
|
|
if (!self::$reloadaftertest) {
|
|
self::$allobservers = null;
|
|
}
|
|
self::$reloadaftertest = false;
|
|
}
|
|
}
|
|
|