Your IP : 3.142.251.204
<?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/>.
/**
* Backup controller and related exception classes.
*
* @package core_backup
* @subpackage backup-controller
* @copyright 2010 onwards Eloy Lafuente (stronk7) {@link http://stronk7.com}
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
/**
* Class implementing the controller of any backup process
*
* This final class is in charge of controlling all the backup architecture, for any
* type of backup. Based in type, format, interactivity and target, it stores the
* whole execution plan and settings that will be used later by the @backup_worker,
* applies all the defaults, performs all the security contraints and is in charge
* of handling the ui if necessary. Also logging strategy is defined here.
*
* Note the class is 100% neutral and usable for *any* backup. It just stores/requests
* all the needed information from other backup classes in order to have everything well
* structured in order to allow the @backup_worker classes to do their job.
*
* In other words, a mammoth class, but don't worry, practically everything is delegated/
* aggregated!)
*/
class backup_controller extends base_controller {
/** @var string Unique identifier for this backup */
protected $backupid;
/**
* Type of item that is being stored in the backup.
*
* Should be selected from one of the backup::TYPE_ constants
* for example backup::TYPE_1ACTIVITY
*
* @var string
*/
protected $type;
/** @var int Course/section/course_module id to backup */
protected $id;
/** @var false|int The id of the course the backup belongs to, or false if no course. */
protected $courseid;
/**
* Format of backup (moodle, imscc).
*
* Should be one of the backup::FORMAT_ constants.
* for example backup::FORMAT_MOODLE
*
* @var string
*/
protected $format;
/**
* Whether this backup will require user interaction.
*
* Should be one of backup::INTERACTIVE_YES or INTERACTIVE_NO
*
* @var bool
*/
protected $interactive;
/**
* Purpose of the backup (default settings)
*
* Should be one of the the backup::MODE_ constants,
* for example backup::MODE_GENERAL
*
* @var int
*/
protected $mode;
/** @var int The id of the user executing the backup. */
protected $userid;
/**
* Type of operation (backup/restore)
*
* Should be selected from: backup::OPERATION_BACKUP or OPERATION_RESTORE
*
* @var string
*/
protected $operation;
/**
* Current status of the controller (created, planned, configured...)
*
* It should be one of the backup::STATUS_ constants,
* for example backup::STATUS_AWAITING.
*
* @var int
*/
protected $status;
/** @var backup_plan Backup execution plan. */
protected $plan;
/** @var int Whether this backup includes files (1) or not (0). */
protected $includefiles;
/**
* Immediate/delayed execution type.
* @var int
*/
protected $execution;
/** @var int Epoch time when we want the backup to be executed (requires cron to run). */
protected $executiontime;
/** @var null Destination chain object (fs_moodle, fs_os, db, email...). */
protected $destination;
/** @var string Cache {@see \checksumable} results for lighter {@see \backup_controller::is_checksum_correct()} uses. */
protected $checksum;
/**
* The role ids to keep in a copy operation.
* @var array
*/
protected $keptroles = array();
/**
* Constructor for the backup controller class.
*
* @param string $type Type of the backup; One of backup::TYPE_1COURSE, TYPE_1SECTION, TYPE_1ACTIVITY
* @param int $id The ID of the item to backup; e.g the course id
* @param string $format The backup format to use; Most likely backup::FORMAT_MOODLE
* @param bool $interactive Whether this backup will require user interaction; backup::INTERACTIVE_YES or INTERACTIVE_NO
* @param int $mode One of backup::MODE_GENERAL, MODE_IMPORT, MODE_SAMESITE, MODE_HUB, MODE_AUTOMATED
* @param int $userid The id of the user making the backup
* @param bool $releasesession Should release the session? backup::RELEASESESSION_YES or backup::RELEASESESSION_NO
*/
public function __construct($type, $id, $format, $interactive, $mode, $userid, $releasesession = backup::RELEASESESSION_NO) {
$this->type = $type;
$this->id = $id;
$this->courseid = backup_controller_dbops::get_courseid_from_type_id($this->type, $this->id);
$this->format = $format;
$this->interactive = $interactive;
$this->mode = $mode;
$this->userid = $userid;
$this->releasesession = $releasesession;
// Apply some defaults
$this->operation = backup::OPERATION_BACKUP;
$this->executiontime = 0;
$this->checksum = '';
// Set execution based on backup mode.
if ($mode == backup::MODE_ASYNC || $mode == backup::MODE_COPY) {
$this->execution = backup::EXECUTION_DELAYED;
} else {
$this->execution = backup::EXECUTION_INMEDIATE;
}
// Apply current backup version and release if necessary
backup_controller_dbops::apply_version_and_release();
// Check format and type are correct
backup_check::check_format_and_type($this->format, $this->type);
// Check id is correct
backup_check::check_id($this->type, $this->id);
// Check user is correct
backup_check::check_user($this->userid);
// Calculate unique $backupid
$this->calculate_backupid();
// Default logger chain (based on interactive/execution)
$this->logger = backup_factory::get_logger_chain($this->interactive, $this->execution, $this->backupid);
// By default there is no progress reporter. Interfaces that wish to
// display progress must set it.
$this->progress = new \core\progress\none();
// Instantiate the output_controller singleton and active it if interactive and immediate.
$oc = output_controller::get_instance();
if ($this->interactive == backup::INTERACTIVE_YES && $this->execution == backup::EXECUTION_INMEDIATE) {
$oc->set_active(true);
}
$this->log('instantiating backup controller', backup::LOG_INFO, $this->backupid);
// Default destination chain (based on type/mode/execution)
$this->destination = backup_factory::get_destination_chain($this->type, $this->id, $this->mode, $this->execution);
// Set initial status
$this->set_status(backup::STATUS_CREATED);
// Load plan (based on type/format)
$this->load_plan();
// Apply all default settings (based on type/format/mode)
$this->apply_defaults();
// Perform all initial security checks and apply (2nd param) them to settings automatically
backup_check::check_security($this, true);
// Set status based on interactivity
if ($this->interactive == backup::INTERACTIVE_YES) {
$this->set_status(backup::STATUS_SETTING_UI);
} else {
$this->set_status(backup::STATUS_AWAITING);
}
}
/**
* Clean structures used by the backup_controller
*
* This method clean various structures used by the backup_controller,
* destroying them in an ordered way, so their memory will be gc properly
* by PHP (mainly circular references).
*
* Note that, while it's not mandatory to execute this method, it's highly
* recommended to do so, specially in scripts performing multiple operations
* (like the automated backups) or the system will run out of memory after
* a few dozens of backups)
*/
public function destroy() {
// Only need to destroy circulars under the plan. Delegate to it.
$this->plan->destroy();
// Loggers may have also chained references, destroy them. Also closing resources when needed.
$this->logger->destroy();
}
/**
* Declare that all user interaction with the backup controller is complete.
*
* After this the backup controller is waiting for processing.
*/
public function finish_ui() {
if ($this->status != backup::STATUS_SETTING_UI) {
throw new backup_controller_exception('cannot_finish_ui_if_not_setting_ui');
}
$this->set_status(backup::STATUS_AWAITING);
}
/**
* Validates the backup is valid after any user changes.
*
* A backup_controller_exception will be thrown if there is an issue.
*/
public function process_ui_event() {
// Perform security checks throwing exceptions (2nd param) if something is wrong
backup_check::check_security($this, false);
}
/**
* Sets the new status of the backup.
*
* @param int $status
*/
public function set_status($status) {
// Note: never save_controller() with the object info after STATUS_EXECUTING or the whole controller,
// containing all the steps will be sent to DB. 100% (monster) useless.
$this->log('setting controller status to', backup::LOG_DEBUG, $status);
// TODO: Check it's a correct status.
$this->status = $status;
// Ensure that, once set to backup::STATUS_AWAITING, controller is stored in DB.
// Also save if executing so we can better track progress.
if ($status == backup::STATUS_AWAITING || $status == backup::STATUS_EXECUTING) {
$this->save_controller();
$tbc = self::load_controller($this->backupid);
$this->logger = $tbc->logger; // wakeup loggers
$tbc->plan->destroy(); // Clean plan controller structures, keeping logger alive.
} else if ($status == backup::STATUS_FINISHED_OK) {
// If the operation has ended without error (backup::STATUS_FINISHED_OK)
// proceed by cleaning the object from database. MDL-29262.
$this->save_controller(false, true);
} else if ($status == backup::STATUS_FINISHED_ERR) {
// If the operation has ended with an error save the controller
// preserving the object in the database. We may want it for debugging.
$this->save_controller();
}
}
/**
* Sets if the backup will be processed immediately, or later.
*
* @param int $execution Use backup::EXECUTION_INMEDIATE or backup::EXECUTION_DELAYED
* @param int $executiontime The timestamp in the future when the task should be executed, or 0 for immediately.
*/
public function set_execution($execution, $executiontime = 0) {
$this->log('setting controller execution', backup::LOG_DEBUG);
// TODO: Check valid execution mode.
// TODO: Check time in future.
// TODO: Check time = 0 if immediate.
$this->execution = $execution;
$this->executiontime = $executiontime;
// Default destination chain (based on type/mode/execution)
$this->destination = backup_factory::get_destination_chain($this->type, $this->id, $this->mode, $this->execution);
// Default logger chain (based on interactive/execution)
$this->logger = backup_factory::get_logger_chain($this->interactive, $this->execution, $this->backupid);
}
// checksumable interface methods
public function calculate_checksum() {
// Reset current checksum to take it out from calculations!
$this->checksum = '';
// Init checksum
$tempchecksum = md5('backupid-' . $this->backupid .
'type-' . $this->type .
'id-' . $this->id .
'format-' . $this->format .
'interactive-'. $this->interactive .
'mode-' . $this->mode .
'userid-' . $this->userid .
'operation-' . $this->operation .
'status-' . $this->status .
'execution-' . $this->execution .
'plan-' . backup_general_helper::array_checksum_recursive(array($this->plan)) .
'destination-'. backup_general_helper::array_checksum_recursive(array($this->destination)) .
'logger-' . backup_general_helper::array_checksum_recursive(array($this->logger)));
$this->log('calculating controller checksum', backup::LOG_DEBUG, $tempchecksum);
return $tempchecksum;
}
public function is_checksum_correct($checksum) {
return $this->checksum === $checksum;
}
/**
* Gets the unique identifier for this backup controller.
*
* @return string
*/
public function get_backupid() {
return $this->backupid;
}
/**
* Gets the type of backup to be performed.
*
* Use {@see \backup_controller::get_id()} to find the instance being backed up.
*
* @return string
*/
public function get_type() {
return $this->type;
}
/**
* Returns the current value of the include_files setting.
* This setting is intended to ensure that files are not included in
* generated backups.
*
* @return int Indicates whether files should be included in backups.
*/
public function get_include_files() {
return $this->includefiles;
}
/**
* Returns the default value for $this->includefiles before we consider any settings.
*
* @return bool
* @throws dml_exception
*/
protected function get_include_files_default() : bool {
// We normally include files.
$includefiles = true;
// In an import, we don't need to include files.
if ($this->get_mode() === backup::MODE_IMPORT) {
$includefiles = false;
}
// When a backup is intended for the same site, we don't need to include the files.
// Note, this setting is only used for duplication of an entire course.
if ($this->get_mode() === backup::MODE_SAMESITE || $this->get_mode() === backup::MODE_COPY) {
$includefiles = false;
}
// If backup is automated and we have set auto backup config to exclude
// files then set them to be excluded here.
$backupautofiles = (bool) get_config('backup', 'backup_auto_files');
if ($this->get_mode() === backup::MODE_AUTOMATED && !$backupautofiles) {
$includefiles = false;
}
return $includefiles;
}
/**
* Gets if this is a backup or restore.
*
* @return string
*/
public function get_operation() {
return $this->operation;
}
/**
* Gets the instance id of the item being backed up.
*
* It's meaning is related to the type of backup {@see \backup_controller::get_type()}.
*
* @return int
*/
public function get_id() {
return $this->id;
}
/**
* Gets the course that the item being backed up is in.
*
* @return false|int
*/
public function get_courseid() {
return $this->courseid;
}
/**
* Gets the format the backup is stored in.
*
* @return string
*/
public function get_format() {
return $this->format;
}
/**
* Gets if user interaction is expected during the backup.
*
* @return bool
*/
public function get_interactive() {
return $this->interactive;
}
/**
* Gets the mode that the backup will be performed in.
*
* @return int
*/
public function get_mode() {
return $this->mode;
}
/**
* Get the id of the user who started the backup.
*
* @return int
*/
public function get_userid() {
return $this->userid;
}
/**
* Get the current status of the backup.
*
* @return int
*/
public function get_status() {
return $this->status;
}
/**
* Get if the backup will be executed immediately, or later.
*
* @return int
*/
public function get_execution() {
return $this->execution;
}
/**
* Get when the backup will be executed.
*
* @return int 0 means now, otherwise a Unix timestamp
*/
public function get_executiontime() {
return $this->executiontime;
}
/**
* Gets the plan that will be run during the backup.
*
* @return backup_plan
*/
public function get_plan() {
return $this->plan;
}
/**
* For debug only. Get a simple test display of all the settings.
*
* @return string
*/
public function debug_display_all_settings_values(): string {
return $this->get_plan()->debug_display_all_settings_values();
}
/**
* Sets the user roles that should be kept in the destination course
* for a course copy operation.
*
* @param array $roleids
* @throws backup_controller_exception
*/
public function set_kept_roles(array $roleids): void {
// Only allow of keeping user roles when controller is in copy mode.
if ($this->mode != backup::MODE_COPY) {
throw new backup_controller_exception('cannot_set_keep_roles_wrong_mode');
}
$this->keptroles = $roleids;
}
/**
* Executes the backup
* @return void Throws and exception of completes
*/
public function execute_plan() {
// Basic/initial prevention against time/memory limits
core_php_time_limit::raise(1 * 60 * 60); // 1 hour for 1 course initially granted
raise_memory_limit(MEMORY_EXTRA);
// Release the session so other tabs in the same session are not blocked.
if ($this->get_releasesession() === backup::RELEASESESSION_YES) {
\core\session\manager::write_close();
}
// If the controller has decided that we can include files, then check the setting, otherwise do not include files.
if ($this->get_include_files()) {
$this->set_include_files((bool) $this->get_plan()->get_setting('files')->get_value());
}
// If this is not a course backup, or single activity backup (e.g. duplicate) inform the plan we are not
// including all the activities for sure. This will affect any
// task/step executed conditionally to stop including information
// for section and activity backup. MDL-28180.
if ($this->get_type() !== backup::TYPE_1COURSE && $this->get_type() !== backup::TYPE_1ACTIVITY) {
$this->log('notifying plan about excluded activities by type', backup::LOG_DEBUG);
$this->plan->set_excluding_activities();
}
// Handle copy operation specific settings.
if ($this->mode == backup::MODE_COPY) {
$this->plan->set_kept_roles($this->keptroles);
}
return $this->plan->execute();
}
/**
* Gets the results of the plan execution for this backup.
*
* @return array
*/
public function get_results() {
return $this->plan->get_results();
}
/**
* Save controller information
*
* @param bool $includeobj to decide if the object itself must be updated (true) or no (false)
* @param bool $cleanobj to decide if the object itself must be cleaned (true) or no (false)
*/
public function save_controller($includeobj = true, $cleanobj = false) {
// Going to save controller to persistent storage, calculate checksum for later checks and save it.
// TODO: flag the controller as NA. Any operation on it should be forbidden until loaded back.
$this->log('saving controller to db', backup::LOG_DEBUG);
if ($includeobj ) { // Only calculate checksum if we are going to include the object.
$this->checksum = $this->calculate_checksum();
}
backup_controller_dbops::save_controller($this, $this->checksum, $includeobj, $cleanobj);
}
/**
* Loads a backup controller from the database.
*
* @param string $backupid The id of the backup controller.
* @return \backup_controller
*/
public static function load_controller($backupid) {
// Load controller from persistent storage
// TODO: flag the controller as available. Operations on it can continue
$controller = backup_controller_dbops::load_controller($backupid);
$controller->log('loading controller from db', backup::LOG_DEBUG);
return $controller;
}
// Protected API starts here
/**
* Creates a unique id for this backup.
*/
protected function calculate_backupid() {
// Current epoch time + type + id + format + interactive + mode + userid + operation
// should be unique enough. Add one random part at the end
$this->backupid = md5(time() . '-' . $this->type . '-' . $this->id . '-' . $this->format . '-' .
$this->interactive . '-' . $this->mode . '-' . $this->userid . '-' .
$this->operation . '-' . random_string(20));
}
/**
* Builds the plan for this backup job so that it may be executed.
*/
protected function load_plan() {
$this->log('loading controller plan', backup::LOG_DEBUG);
$this->plan = new backup_plan($this);
$this->plan->build(); // Build plan for this controller
$this->set_status(backup::STATUS_PLANNED);
}
/**
* Sets default values for the backup controller.
*/
protected function apply_defaults() {
$this->log('applying plan defaults', backup::LOG_DEBUG);
backup_controller_dbops::apply_config_defaults($this);
$this->set_status(backup::STATUS_CONFIGURED);
$this->set_include_files($this->get_include_files_default());
}
/**
* Set the initial value for the include_files setting.
*
* @param bool $includefiles
* @see backup_controller::get_include_files for further information on the purpose of this setting.
*/
protected function set_include_files(bool $includefiles) {
$this->log("setting file inclusion to {$this->includefiles}", backup::LOG_DEBUG);
$this->includefiles = (int) $includefiles;
}
}
/**
* Exception class used by all the @backup_controller stuff
*/
class backup_controller_exception extends backup_exception {
public function __construct($errorcode, $a=NULL, $debuginfo=null) {
parent::__construct($errorcode, $a, $debuginfo);
}
}