mirror of
https://github.com/moodle/moodle.git
synced 2025-02-08 17:11:49 +01:00
3b120e464f
This new messaging system replaces all the various email_to_user() calls. They are now replaced by events triggers, and the messages are then processed centrally according to user preferences and sent to one or more processors (email, popup, jabber etc...) This code is not finished yet, a lot of work still has to be done on the interface. However, the basic structure is there and should be working. Luis and I will be reviewing and polishing this heavily in the next few weeks.
863 lines
35 KiB
PHP
863 lines
35 KiB
PHP
<?php //$Id$
|
|
//This file contains all the code needed to execute scheduled backups
|
|
|
|
require_once($CFG->libdir.'/eventslib.php');
|
|
|
|
//This function is executed via moodle cron
|
|
//It prepares all the info and execute backups as necessary
|
|
function schedule_backup_cron() {
|
|
global $CFG, $DB;
|
|
|
|
$status = true;
|
|
|
|
$emailpending = false;
|
|
|
|
//Check for required functions...
|
|
if(!function_exists('utf8_encode')) {
|
|
mtrace(" ERROR: You need to add XML support to your PHP installation!");
|
|
return true;
|
|
}
|
|
|
|
//Get now
|
|
$now = time();
|
|
|
|
//First of all, we have to see if the scheduled is active and detect
|
|
//that there isn't another cron running
|
|
mtrace(" Checking backup status",'...');
|
|
$backup_config = backup_get_config();
|
|
if(!isset($backup_config->backup_sche_active) || !$backup_config->backup_sche_active) {
|
|
mtrace("INACTIVE");
|
|
return true;
|
|
} else if (isset($backup_config->backup_sche_running) && $backup_config->backup_sche_running) {
|
|
mtrace("RUNNING");
|
|
//Now check if it's a really running task or something very old looking
|
|
//for info in backup_logs to unlock status as necessary
|
|
$timetosee = 1800; //Half an hour looking for activity
|
|
$timeafter = time() - $timetosee;
|
|
$numofrec = $DB->count_records_select ("backup_log","time > ?", array($timeafter));
|
|
if (!$numofrec) {
|
|
$timetoseemin = $timetosee/60;
|
|
mtrace(" No activity in last ".$timetoseemin." minutes. Unlocking status");
|
|
} else {
|
|
mtrace(" Scheduled backup seems to be running. Execution delayed");
|
|
return true;
|
|
}
|
|
} else {
|
|
mtrace("OK");
|
|
//Mark backup_sche_running
|
|
backup_set_config("backup_sche_running","1");
|
|
}
|
|
|
|
//Now we get the main admin user (we'll use his timezone, mail...)
|
|
mtrace(" Getting admin info");
|
|
$admin = get_admin();
|
|
if (!$admin) {
|
|
$status = false;
|
|
}
|
|
|
|
//Delete old_entries from backup tables
|
|
if ($status) {
|
|
mtrace(" Deleting old data");
|
|
$status = backup_delete_old_data();
|
|
}
|
|
|
|
//Now we get a list of courses in the server
|
|
if ($status) {
|
|
mtrace(" Checking courses");
|
|
//First of all, we delete everything from backup tables related to deleted courses
|
|
mtrace(" Skipping deleted courses");
|
|
$skipped = 0;
|
|
if ($bckcourses = $DB->get_records('backup_courses')) {
|
|
foreach($bckcourses as $bckcourse) {
|
|
//Search if it exists
|
|
if (!$exists = $DB->get_record('course', array('id'=>$bckcourse->courseid))) {
|
|
//Doesn't exist, so delete from backup tables
|
|
$DB->delete_records('backup_courses', array('courseid'=>$bckcourse->courseid));
|
|
$DB->delete_records('backup_log', array('courseid'=>$bckcourse->courseid));
|
|
$skipped++;
|
|
}
|
|
}
|
|
}
|
|
mtrace(" $skipped courses");
|
|
//Now process existing courses
|
|
$courses = $DB->get_records("course");
|
|
//For each course, we check (insert, update) the backup_course table
|
|
//with needed data
|
|
foreach ($courses as $course) {
|
|
if ($status) {
|
|
mtrace(" $course->fullname");
|
|
//We check if the course exists in backup_course
|
|
$backup_course = $DB->get_record("backup_courses", array("courseid"=>$course->id));
|
|
//If it doesn't exist, create
|
|
if (!$backup_course) {
|
|
$temp_backup_course->courseid = $course->id;
|
|
$newid = $DB->insert_record("backup_courses",$temp_backup_course);
|
|
//And get it from db
|
|
$backup_course = $DB->get_record("backup_courses", array("id"=>$newid));
|
|
}
|
|
//If it doesn't exist now, error
|
|
if (!$backup_course) {
|
|
mtrace(" ERROR (in backup_courses detection)");
|
|
$status = false;
|
|
continue;
|
|
}
|
|
// Skip backup of unavailable courses that have remained unmodified in a month
|
|
$skipped = false;
|
|
if (!$course->visible && ($now - $course->timemodified) > 31*24*60*60) { //Hidden + unmodified last month
|
|
mtrace(" SKIPPING - hidden+unmodified");
|
|
$DB->set_field("backup_courses","laststatus","3", array("courseid"=>$backup_course->courseid));
|
|
$skipped = true;
|
|
}
|
|
//Now we backup every non skipped course with nextstarttime < now
|
|
if (!$skipped && $backup_course->nextstarttime > 0 && $backup_course->nextstarttime < $now) {
|
|
//We have to send a email because we have included at least one backup
|
|
$emailpending = true;
|
|
//Only make the backup if laststatus isn't 2-UNFINISHED (uncontrolled error)
|
|
if ($backup_course->laststatus != 2) {
|
|
//Set laststarttime
|
|
$starttime = time();
|
|
$DB->set_field("backup_courses","laststarttime",$starttime, array("courseid"=>$backup_course->courseid));
|
|
//Set course status to unfinished, the process will reset it
|
|
$DB->set_field("backup_courses","laststatus","2", array("courseid"=>$backup_course->courseid));
|
|
//Launch backup
|
|
$course_status = schedule_backup_launch_backup($course,$starttime);
|
|
//Set lastendtime
|
|
$DB->set_field("backup_courses","lastendtime",time(), array("courseid"=>$backup_course->courseid));
|
|
//Set laststatus
|
|
if ($course_status) {
|
|
$DB->set_field("backup_courses","laststatus","1", array("courseid"=>$backup_course->courseid));
|
|
} else {
|
|
$DB->set_field("backup_courses","laststatus","0", array("courseid"=>$backup_course->courseid));
|
|
}
|
|
}
|
|
}
|
|
|
|
//Now, calculate next execution of the course
|
|
$nextstarttime = schedule_backup_next_execution ($backup_course,$backup_config,$now,$admin->timezone);
|
|
//Save it to db
|
|
$DB->set_field("backup_courses","nextstarttime",$nextstarttime, array("courseid"=>$backup_course->courseid));
|
|
//Print it to screen as necessary
|
|
$showtime = "undefined";
|
|
if ($nextstarttime > 0) {
|
|
$showtime = userdate($nextstarttime,"",$admin->timezone);
|
|
}
|
|
mtrace(" Next execution: $showtime");
|
|
}
|
|
}
|
|
}
|
|
|
|
//Delete old logs
|
|
if (!empty($CFG->loglifetime)) {
|
|
mtrace(" Deleting old logs");
|
|
$loglifetime = $now - ($CFG->loglifetime * 86400);
|
|
$DB->delete_records_select("backup_log", "laststarttime < ?", array($loglifetime));
|
|
}
|
|
|
|
//Send email to admin if necessary
|
|
if ($emailpending) {
|
|
mtrace(" Sending email to admin");
|
|
$message = "";
|
|
|
|
//Get info about the status of courses
|
|
$count_all = $DB->count_records('backup_courses');
|
|
$count_ok = $DB->count_records('backup_courses', array('laststatus'=>'1'));
|
|
$count_error = $DB->count_records('backup_courses', array('laststatus'=>'0'));
|
|
$count_unfinished = $DB->count_records('backup_courses', array('laststatus'=>'2'));
|
|
$count_skipped = $DB->count_records('backup_courses', array('laststatus'=>'3'));
|
|
|
|
//Build the message text
|
|
//Summary
|
|
$message .= get_string('summary')."\n";
|
|
$message .= "==================================================\n";
|
|
$message .= " ".get_string('courses').": ".$count_all."\n";
|
|
$message .= " ".get_string('ok').": ".$count_ok."\n";
|
|
$message .= " ".get_string('skipped').": ".$count_skipped."\n";
|
|
$message .= " ".get_string('error').": ".$count_error."\n";
|
|
$message .= " ".get_string('unfinished').": ".$count_unfinished."\n\n";
|
|
|
|
//Reference
|
|
if ($count_error != 0 || $count_unfinished != 0) {
|
|
$message .= " ".get_string('backupfailed')."\n\n";
|
|
$dest_url = "$CFG->wwwroot/$CFG->admin/report/backups/index.php";
|
|
$message .= " ".get_string('backuptakealook','',$dest_url)."\n\n";
|
|
//Set message priority
|
|
$admin->priority = 1;
|
|
//Reset unfinished to error
|
|
$DB->set_field('backup_courses','laststatus','0', array('laststatus'=>'2'));
|
|
} else {
|
|
$message .= " ".get_string('backupfinished')."\n";
|
|
}
|
|
|
|
//Build the message subject
|
|
$site = get_site();
|
|
$prefix = $site->shortname.": ";
|
|
if ($count_error != 0 || $count_unfinished != 0) {
|
|
$prefix .= "[".strtoupper(get_string('error'))."] ";
|
|
}
|
|
$subject = $prefix.get_string("scheduledbackupstatus");
|
|
|
|
//Send the message
|
|
$eventdata = new object();
|
|
$eventdata->modulename = 'moodle';
|
|
$eventdata->userfrom = $admin;
|
|
$eventdata->userto = $admin;
|
|
$eventdata->subject = $subject;
|
|
$eventdata->fullmessage = $message;
|
|
$eventdata->fullmessageformat = FORMAT_PLAIN;
|
|
$eventdata->fullmessagehtml = '';
|
|
$eventdata->smallmessage = '';
|
|
events_trigger('message_send', $eventdata);
|
|
|
|
/*
|
|
email_to_user($admin,$admin,$subject,$message);
|
|
*/
|
|
}
|
|
|
|
|
|
//Everything is finished stop backup_sche_running
|
|
backup_set_config("backup_sche_running","0");
|
|
|
|
return $status;
|
|
}
|
|
|
|
//This function executes the ENTIRE backup of a course (passed as parameter)
|
|
//using all the scheduled backup preferences
|
|
function schedule_backup_launch_backup($course,$starttime = 0) {
|
|
|
|
$preferences = false;
|
|
$status = false;
|
|
|
|
mtrace(" Executing backup");
|
|
schedule_backup_log($starttime,$course->id,"Start backup course $course->fullname");
|
|
schedule_backup_log($starttime,$course->id," Phase 1: Checking and counting:");
|
|
$preferences = schedule_backup_course_configure($course,$starttime);
|
|
|
|
if ($preferences) {
|
|
schedule_backup_log($starttime,$course->id," Phase 2: Executing and copying:");
|
|
$status = schedule_backup_course_execute($preferences,$starttime);
|
|
}
|
|
|
|
if ($status && $preferences) {
|
|
//Only if the backup_sche_keep is set
|
|
if ($preferences->backup_keep) {
|
|
schedule_backup_log($starttime,$course->id," Phase 3: Deleting old backup files:");
|
|
$status = schedule_backup_course_delete_old_files($preferences,$starttime);
|
|
}
|
|
}
|
|
|
|
if ($status && $preferences) {
|
|
mtrace(" End backup OK");
|
|
schedule_backup_log($starttime,$course->id,"End backup course $course->fullname - OK");
|
|
} else {
|
|
mtrace(" End backup with ERROR");
|
|
schedule_backup_log($starttime,$course->id,"End backup course $course->fullname - ERROR!!");
|
|
}
|
|
|
|
return $status && $preferences;
|
|
}
|
|
|
|
//This function saves to backup_log all the needed process info
|
|
//to use it later. NOTE: If $starttime = 0 no info in saved
|
|
function schedule_backup_log($starttime,$courseid,$message) {
|
|
global $DB;
|
|
|
|
if ($starttime) {
|
|
$log = new object();
|
|
$log->courseid = $courseid;
|
|
$log->time = time();
|
|
$log->laststarttime = $starttime;
|
|
$log->info = $message;
|
|
|
|
$DB->insert_record("backup_log", $log);
|
|
}
|
|
|
|
}
|
|
|
|
//This function returns the next future GMT time to execute the course based in the
|
|
//configuration of the scheduled backups
|
|
function schedule_backup_next_execution ($backup_course,$backup_config,$now,$timezone) {
|
|
|
|
$result = -1;
|
|
|
|
//Get today's midnight GMT
|
|
$midnight = usergetmidnight($now,$timezone);
|
|
|
|
//Get today's day of week (0=Sunday...6=Saturday)
|
|
$date = usergetdate($now,$timezone);
|
|
$dayofweek = $date['wday'];
|
|
|
|
//Get number of days (from today) to execute backups
|
|
$scheduled_days = substr($backup_config->backup_sche_weekdays,$dayofweek).
|
|
$backup_config->backup_sche_weekdays;
|
|
$daysfromtoday = strpos($scheduled_days, "1");
|
|
|
|
//If some day has been found
|
|
if ($daysfromtoday !== false) {
|
|
//Calculate distance
|
|
$dist = ($daysfromtoday * 86400) + //Days distance
|
|
($backup_config->backup_sche_hour*3600) + //Hours distance
|
|
($backup_config->backup_sche_minute*60); //Minutes distance
|
|
$result = $midnight + $dist;
|
|
}
|
|
|
|
//If that time is past, call the function recursively to obtain the next valid day
|
|
if ($result > 0 && $result < time()) {
|
|
$result = schedule_backup_next_execution ($backup_course,$backup_config,$now + 86400,$timezone);
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
|
|
|
|
//This function implements all the needed code to prepare a course
|
|
//to be in backup (insert temp info into backup temp tables).
|
|
function schedule_backup_course_configure($course,$starttime = 0) {
|
|
global $CFG, $DB;
|
|
|
|
$status = true;
|
|
|
|
schedule_backup_log($starttime,$course->id," checking parameters");
|
|
|
|
//Check the required variable
|
|
if (empty($course->id)) {
|
|
$status = false;
|
|
}
|
|
//Get scheduled backup preferences
|
|
$backup_config = backup_get_config();
|
|
|
|
//Checks backup_config pairs exist
|
|
if ($status) {
|
|
if (!isset($backup_config->backup_sche_modules)) {
|
|
$backup_config->backup_sche_modules = 1;
|
|
}
|
|
if (!isset($backup_config->backup_sche_withuserdata)) {
|
|
$backup_config->backup_sche_withuserdata = 1;
|
|
}
|
|
if (!isset($backup_config->backup_sche_metacourse)) {
|
|
$backup_config->backup_sche_metacourse = 1;
|
|
}
|
|
if (!isset($backup_config->backup_sche_users)) {
|
|
$backup_config->backup_sche_users = 1;
|
|
}
|
|
if (!isset($backup_config->backup_sche_logs)) {
|
|
$backup_config->backup_sche_logs = 0;
|
|
}
|
|
if (!isset($backup_config->backup_sche_userfiles)) {
|
|
$backup_config->backup_sche_userfiles = 1;
|
|
}
|
|
if (!isset($backup_config->backup_sche_coursefiles)) {
|
|
$backup_config->backup_sche_coursefiles = 1;
|
|
}
|
|
if (!isset($backup_config->backup_sche_sitefiles)) {
|
|
$backup_config->backup_sche_sitefiles = 1;
|
|
}
|
|
if (!isset($backup_config->backup_sche_messages)) {
|
|
$backup_config->backup_sche_messages = 0;
|
|
}
|
|
if (!isset($backup_config->backup_sche_blogs)) {
|
|
$backup_config->backup_sche_blogs = 0;
|
|
}
|
|
if (!isset($backup_config->backup_sche_active)) {
|
|
$backup_config->backup_sche_active = 0;
|
|
}
|
|
if (!isset($backup_config->backup_sche_weekdays)) {
|
|
$backup_config->backup_sche_weekdays = "0000000";
|
|
}
|
|
if (!isset($backup_config->backup_sche_hour)) {
|
|
$backup_config->backup_sche_hour = 00;
|
|
}
|
|
if (!isset($backup_config->backup_sche_minute)) {
|
|
$backup_config->backup_sche_minute = 00;
|
|
}
|
|
if (!isset($backup_config->backup_sche_destination)) {
|
|
$backup_config->backup_sche_destination = "";
|
|
}
|
|
if (!isset($backup_config->backup_sche_keep)) {
|
|
$backup_config->backup_sche_keep = 1;
|
|
}
|
|
}
|
|
|
|
if ($status) {
|
|
//Checks for the required files/functions to backup every mod
|
|
//And check if there is data about it
|
|
$count = 0;
|
|
if ($allmods = $DB->get_records("modules") ) {
|
|
foreach ($allmods as $mod) {
|
|
$modname = $mod->name;
|
|
$modfile = "$CFG->dirroot/mod/$modname/backuplib.php";
|
|
$modbackup = $modname."_backup_mods";
|
|
$modcheckbackup = $modname."_check_backup_mods";
|
|
if (file_exists($modfile)) {
|
|
include_once($modfile);
|
|
if (function_exists($modbackup) and function_exists($modcheckbackup)) {
|
|
$var = "exists_".$modname;
|
|
$$var = true;
|
|
$count++;
|
|
|
|
// PENNY NOTES: I have moved from here to the closing brace inside
|
|
// by two sets of ifs()
|
|
// to avoid the backup failing on a non existant backup.
|
|
// If the file/function/whatever doesn't exist, we don't want to set this
|
|
// this module in backup preferences at all.
|
|
//Check data
|
|
//Check module info
|
|
$var = "backup_".$modname;
|
|
if (!isset($$var)) {
|
|
$$var = $backup_config->backup_sche_modules;
|
|
}
|
|
//Now stores all the mods preferences into an array into preferences
|
|
$preferences->mods[$modname]->backup = $$var;
|
|
|
|
//Check include user info
|
|
$var = "backup_user_info_".$modname;
|
|
if (!isset($$var)) {
|
|
$$var = $backup_config->backup_sche_withuserdata;
|
|
}
|
|
//Now stores all the mods preferences into an array into preferences
|
|
$preferences->mods[$modname]->userinfo = $$var;
|
|
//And the name of the mod
|
|
$preferences->mods[$modname]->name = $modname;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// now set instances
|
|
if ($coursemods = get_course_mods($course->id)) {
|
|
foreach ($coursemods as $mod) {
|
|
if (array_key_exists($mod->modname,$preferences->mods)) { // we are to backup this module
|
|
if (empty($preferences->mods[$mod->modname]->instances)) {
|
|
$preferences->mods[$mod->modname]->instances = array(); // avoid warnings
|
|
}
|
|
$preferences->mods[$mod->modname]->instances[$mod->instance]->backup = $preferences->mods[$mod->modname]->backup;
|
|
$preferences->mods[$mod->modname]->instances[$mod->instance]->userinfo = $preferences->mods[$mod->modname]->userinfo;
|
|
// there isn't really a nice way to do this...
|
|
$preferences->mods[$mod->modname]->instances[$mod->instance]->name = $DB->get_field($mod->modname,'name', array('id'=>$mod->instance));
|
|
}
|
|
}
|
|
}
|
|
|
|
// finally, clean all the $preferences->mods[] not having instances. Nothing to backup about them
|
|
foreach ($preferences->mods as $modname => $mod) {
|
|
if (!isset($mod->instances)) {
|
|
unset($preferences->mods[$modname]);
|
|
}
|
|
}
|
|
}
|
|
|
|
//Convert other parameters
|
|
if ($status) {
|
|
$preferences->backup_metacourse = $backup_config->backup_sche_metacourse;
|
|
$preferences->backup_users = $backup_config->backup_sche_users;
|
|
$preferences->backup_logs = $backup_config->backup_sche_logs;
|
|
$preferences->backup_user_files = $backup_config->backup_sche_userfiles;
|
|
$preferences->backup_course_files = $backup_config->backup_sche_coursefiles;
|
|
$preferences->backup_site_files = $backup_config->backup_sche_sitefiles;
|
|
$preferences->backup_messages = $backup_config->backup_sche_messages;
|
|
$preferences->backup_blogs = $backup_config->backup_sche_blogs;
|
|
$preferences->backup_course = $course->id;
|
|
$preferences->backup_destination = $backup_config->backup_sche_destination;
|
|
$preferences->backup_keep = $backup_config->backup_sche_keep;
|
|
}
|
|
|
|
//Calculate various backup preferences
|
|
if ($status) {
|
|
schedule_backup_log($starttime,$course->id," calculating backup name");
|
|
|
|
//Calculate the backup file name
|
|
$backup_name = backup_get_zipfile_name($course);
|
|
|
|
//Calculate the string to match the keep preference
|
|
$keep_name = backup_get_keep_name($course);
|
|
|
|
//Set them
|
|
$preferences->backup_name = $backup_name;
|
|
$preferences->keep_name = $keep_name;
|
|
|
|
//Roleasignments
|
|
$roles = $DB->get_records('role', null, 'sortorder');
|
|
foreach ($roles as $role) {
|
|
$preferences->backuproleassignments[$role->id] = $role;
|
|
}
|
|
|
|
//Another Info
|
|
backup_add_static_preferences($preferences);
|
|
}
|
|
|
|
//Calculate the backup unique code to allow simultaneus backups (to define
|
|
//the temp-directory name and records in backup temp tables
|
|
if ($status) {
|
|
$backup_unique_code = time();
|
|
$preferences->backup_unique_code = $backup_unique_code;
|
|
}
|
|
|
|
//Calculate necesary info to backup modules
|
|
if ($status) {
|
|
schedule_backup_log($starttime,$course->id," calculating modules data");
|
|
if ($allmods = $DB->get_records("modules") ) {
|
|
foreach ($allmods as $mod) {
|
|
$modname = $mod->name;
|
|
$modbackup = $modname."_backup_mods";
|
|
//If exists the lib & function
|
|
$var = "exists_".$modname;
|
|
if (isset($$var) && $$var) {
|
|
//Add hidden fields
|
|
$var = "backup_".$modname;
|
|
//Only if selected
|
|
if ($$var == 1) {
|
|
$var = "backup_user_info_".$modname;
|
|
//Call the check function to show more info
|
|
$modcheckbackup = $modname."_check_backup_mods";
|
|
schedule_backup_log($starttime,$course->id," $modname");
|
|
$modcheckbackup($course->id,$$var,$backup_unique_code);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//Now calculate the users
|
|
if ($status) {
|
|
schedule_backup_log($starttime,$course->id," calculating users");
|
|
//Decide about include users with messages, based on SITEID
|
|
if ($preferences->backup_messages && $preferences->backup_course == SITEID) {
|
|
$include_message_users = true;
|
|
} else {
|
|
$include_message_users = false;
|
|
}
|
|
//Decide about include users with blogs, based on SITEID
|
|
if ($preferences->backup_blogs && $preferences->backup_course == SITEID) {
|
|
$include_blog_users = true;
|
|
} else {
|
|
$include_blog_users = false;
|
|
}
|
|
user_check_backup($course->id,$backup_unique_code,$preferences->backup_users,$include_message_users, $include_blog_users);
|
|
}
|
|
|
|
//Now calculate the logs
|
|
if ($status) {
|
|
if ($preferences->backup_logs) {
|
|
schedule_backup_log($starttime,$course->id," calculating logs");
|
|
log_check_backup($course->id);
|
|
}
|
|
}
|
|
|
|
//Now calculate the userfiles
|
|
if ($status) {
|
|
if ($preferences->backup_user_files) {
|
|
schedule_backup_log($starttime,$course->id," calculating user files");
|
|
user_files_check_backup($course->id,$preferences->backup_unique_code);
|
|
}
|
|
}
|
|
|
|
//Now calculate the coursefiles
|
|
if ($status) {
|
|
if ($preferences->backup_course_files) {
|
|
schedule_backup_log($starttime,$course->id," calculating course files");
|
|
course_files_check_backup($course->id,$preferences->backup_unique_code);
|
|
}
|
|
}
|
|
|
|
//Now calculate the sitefiles
|
|
if ($status) {
|
|
if ($preferences->backup_site_files) {
|
|
schedule_backup_log($starttime,$course->id," calculating site files");
|
|
site_files_check_backup($course->id,$preferences->backup_unique_code);
|
|
}
|
|
}
|
|
|
|
//If everything is ok, return calculated preferences
|
|
if ($status) {
|
|
$status = $preferences;
|
|
}
|
|
|
|
return $status;
|
|
}
|
|
|
|
//TODO: Unify this function with backup_execute() to have both backups 100% equivalent. Moodle 2.0
|
|
|
|
//This function implements all the needed code to backup a course
|
|
//copying it to the desired destination (default if not specified)
|
|
function schedule_backup_course_execute($preferences,$starttime = 0) {
|
|
|
|
global $CFG;
|
|
|
|
$status = true;
|
|
|
|
//Some parts of the backup doesn't know about $preferences, so we
|
|
//put a copy of it inside that CFG (always global) to be able to
|
|
//use it. Then, when needed I search for preferences inside CFG
|
|
//Used to avoid some problems in full_tag() when preferences isn't
|
|
//set globally (i.e. in scheduled backups)
|
|
$CFG->backup_preferences = $preferences;
|
|
|
|
//Check for temp and backup and backup_unique_code directory
|
|
//Create them as needed
|
|
schedule_backup_log($starttime,$preferences->backup_course," checking temp structures");
|
|
$status = check_and_create_backup_dir($preferences->backup_unique_code);
|
|
//Empty backup dir
|
|
if ($status) {
|
|
schedule_backup_log($starttime,$preferences->backup_course," cleaning current dir");
|
|
$status = clear_backup_dir($preferences->backup_unique_code);
|
|
}
|
|
|
|
//Create the moodle.xml file
|
|
if ($status) {
|
|
schedule_backup_log($starttime,$preferences->backup_course," creating backup file");
|
|
//Obtain the xml file (create and open) and print prolog information
|
|
$backup_file = backup_open_xml($preferences->backup_unique_code);
|
|
//Prints general info about backup to file
|
|
if ($backup_file) {
|
|
schedule_backup_log($starttime,$preferences->backup_course," general info");
|
|
$status = backup_general_info($backup_file,$preferences);
|
|
} else {
|
|
$status = false;
|
|
}
|
|
|
|
//Prints course start (tag and general info)
|
|
if ($status) {
|
|
$status = backup_course_start($backup_file,$preferences);
|
|
}
|
|
|
|
//Metacourse information
|
|
if ($status && $preferences->backup_metacourse) {
|
|
schedule_backup_log($starttime,$preferences->backup_course," metacourse info");
|
|
$status = backup_course_metacourse($backup_file,$preferences);
|
|
}
|
|
|
|
//Block info
|
|
if ($status) {
|
|
schedule_backup_log($starttime,$preferences->backup_course," blocks info");
|
|
$status = backup_course_blocks($backup_file,$preferences);
|
|
}
|
|
|
|
//Section info
|
|
if ($status) {
|
|
schedule_backup_log($starttime,$preferences->backup_course," sections info");
|
|
$status = backup_course_sections($backup_file,$preferences);
|
|
}
|
|
|
|
//User info
|
|
if ($status) {
|
|
schedule_backup_log($starttime,$preferences->backup_course," user info");
|
|
$status = backup_user_info($backup_file,$preferences);
|
|
}
|
|
|
|
//If we have selected to backup messages and we are
|
|
//doing a SITE backup, let's do it
|
|
if ($status && $preferences->backup_messages && $preferences->backup_course == SITEID) {
|
|
schedule_backup_log($starttime,$preferences->backup_course," messages");
|
|
$status = backup_messages($backup_file,$preferences);
|
|
}
|
|
|
|
//If we have selected to backup blogs and we are
|
|
//doing a SITE backup, let's do it
|
|
if ($status && $preferences->backup_blogs && $preferences->backup_course == SITEID) {
|
|
schedule_backup_log($starttime,$preferences->backup_course," blogs");
|
|
$status = backup_blogs($backup_file,$preferences);
|
|
}
|
|
|
|
//If we have selected to backup quizzes, backup categories and
|
|
//questions structure (step 1). See notes on mod/quiz/backuplib.php
|
|
if ($status and $preferences->mods['quiz']->backup) {
|
|
schedule_backup_log($starttime,$preferences->backup_course," categories & questions");
|
|
$status = backup_question_categories($backup_file,$preferences);
|
|
}
|
|
|
|
//Print logs if selected
|
|
if ($status) {
|
|
if ($preferences->backup_logs) {
|
|
schedule_backup_log($starttime,$preferences->backup_course," logs");
|
|
$status = backup_log_info($backup_file,$preferences);
|
|
}
|
|
}
|
|
|
|
//Print scales info
|
|
if ($status) {
|
|
schedule_backup_log($starttime,$preferences->backup_course," scales");
|
|
$status = backup_scales_info($backup_file,$preferences);
|
|
}
|
|
|
|
//Print groups info
|
|
if ($status) {
|
|
schedule_backup_log($starttime,$preferences->backup_course," groups");
|
|
$status = backup_groups_info($backup_file,$preferences);
|
|
}
|
|
|
|
//Print groupings info
|
|
if ($status) {
|
|
schedule_backup_log($starttime,$preferences->backup_course," groupings");
|
|
$status = backup_groupings_info($backup_file,$preferences);
|
|
}
|
|
|
|
//Print groupings_groups info
|
|
if ($status) {
|
|
schedule_backup_log($starttime,$preferences->backup_course," groupings_groups");
|
|
$status = backup_groupings_groups_info($backup_file,$preferences);
|
|
}
|
|
|
|
//Print events info
|
|
if ($status) {
|
|
schedule_backup_log($starttime,$preferences->backup_course," events");
|
|
$status = backup_events_info($backup_file,$preferences);
|
|
}
|
|
|
|
//Print gradebook info
|
|
if ($status) {
|
|
schedule_backup_log($starttime,$preferences->backup_course," gradebook");
|
|
$status = backup_gradebook_info($backup_file,$preferences);
|
|
}
|
|
|
|
//Module info, this unique function makes all the work!!
|
|
//db export and module fileis copy
|
|
if ($status) {
|
|
$mods_to_backup = false;
|
|
//Check if we have any mod to backup
|
|
foreach ($preferences->mods as $module) {
|
|
if ($module->backup) {
|
|
$mods_to_backup = true;
|
|
}
|
|
}
|
|
//If we have to backup some module
|
|
if ($mods_to_backup) {
|
|
schedule_backup_log($starttime,$preferences->backup_course," modules");
|
|
//Start modules tag
|
|
$status = backup_modules_start ($backup_file,$preferences);
|
|
//Iterate over modules and call backup
|
|
foreach ($preferences->mods as $module) {
|
|
if ($module->backup and $status) {
|
|
schedule_backup_log($starttime,$preferences->backup_course," $module->name");
|
|
$status = backup_module($backup_file,$preferences,$module->name);
|
|
}
|
|
}
|
|
//Close modules tag
|
|
$status = backup_modules_end ($backup_file,$preferences);
|
|
}
|
|
}
|
|
|
|
//Backup course format data, if any.
|
|
if ($status) {
|
|
schedule_backup_log($starttime,$preferences->backup_course," course format data");
|
|
$status = backup_format_data($backup_file,$preferences);
|
|
}
|
|
|
|
//Prints course end
|
|
if ($status) {
|
|
$status = backup_course_end($backup_file,$preferences);
|
|
}
|
|
|
|
//Close the xml file and xml data
|
|
if ($backup_file) {
|
|
backup_close_xml($backup_file);
|
|
}
|
|
}
|
|
|
|
//Now, if selected, copy user files
|
|
if ($status) {
|
|
if ($preferences->backup_user_files) {
|
|
schedule_backup_log($starttime,$preferences->backup_course," copying user files");
|
|
$status = backup_copy_user_files ($preferences);
|
|
}
|
|
}
|
|
|
|
//Now, if selected, copy course files
|
|
if ($status) {
|
|
if ($preferences->backup_course_files) {
|
|
schedule_backup_log($starttime,$preferences->backup_course," copying course files");
|
|
$status = backup_copy_course_files ($preferences);
|
|
}
|
|
}
|
|
|
|
//Now, if selected, copy site files
|
|
if ($status) {
|
|
if ($preferences->backup_site_files) {
|
|
schedule_backup_log($starttime,$preferences->backup_course," copying site files");
|
|
$status = backup_copy_site_files ($preferences);
|
|
}
|
|
}
|
|
|
|
//Now, zip all the backup directory contents
|
|
if ($status) {
|
|
schedule_backup_log($starttime,$preferences->backup_course," zipping files");
|
|
$status = backup_zip ($preferences);
|
|
}
|
|
|
|
//Now, copy the zip file to course directory
|
|
if ($status) {
|
|
schedule_backup_log($starttime,$preferences->backup_course," copying backup");
|
|
$status = copy_zip_to_course_dir ($preferences);
|
|
}
|
|
|
|
//Now, clean temporary data (db and filesystem)
|
|
if ($status) {
|
|
schedule_backup_log($starttime,$preferences->backup_course," cleaning temp data");
|
|
$status = clean_temp_data ($preferences);
|
|
}
|
|
|
|
//Unset CFG->backup_preferences only needed in scheduled backups
|
|
unset ($CFG->backup_preferences);
|
|
|
|
return $status;
|
|
}
|
|
|
|
//This function deletes old backup files when the "keep" limit has been reached
|
|
//in the destination directory.
|
|
function schedule_backup_course_delete_old_files($preferences,$starttime=0) {
|
|
|
|
global $CFG;
|
|
|
|
$status = true;
|
|
|
|
//Calculate the directory to check
|
|
$dirtocheck = "";
|
|
//if $preferences->backup_destination isn't empty, then check that directory
|
|
if (!empty($preferences->backup_destination)) {
|
|
$dirtocheck = $preferences->backup_destination;
|
|
//else calculate standard backup directory location
|
|
} else {
|
|
$dirtocheck = $CFG->dataroot."/".$preferences->backup_course."/backupdata";
|
|
}
|
|
schedule_backup_log($starttime,$preferences->backup_course," checking $dirtocheck");
|
|
if ($CFG->debug > 7) {
|
|
mtrace(" Keeping backup files in $dirtocheck");
|
|
}
|
|
|
|
//Get all the files in $dirtocheck
|
|
$files = get_directory_list($dirtocheck,"",false);
|
|
//Get all matching files ($preferences->keep_name) from $files
|
|
$matchingfiles = array();
|
|
foreach ($files as $file) {
|
|
if (substr($file, 0, strlen($preferences->keep_name)) == $preferences->keep_name) {
|
|
$modifieddate = filemtime($dirtocheck."/".$file);
|
|
$matchingfiles[$modifieddate] = $file;
|
|
}
|
|
}
|
|
//Sort by key (modified date) to get the oldest first (instead of doing that by name
|
|
//because it could give us problems in some languages with different format names).
|
|
ksort($matchingfiles);
|
|
|
|
//Count matching files
|
|
$countmatching = count($matchingfiles);
|
|
schedule_backup_log($starttime,$preferences->backup_course," found $countmatching backup files");
|
|
mtrace(" found $countmatching backup files");
|
|
if ($preferences->backup_keep < $countmatching) {
|
|
schedule_backup_log($starttime,$preferences->backup_course," keep limit ($preferences->backup_keep) reached. Deleting old files");
|
|
mtrace(" keep limit ($preferences->backup_keep) reached. Deleting old files");
|
|
$filestodelete = $countmatching - $preferences->backup_keep;
|
|
$filesdeleted = 0;
|
|
foreach ($matchingfiles as $matchfile) {
|
|
if ($filesdeleted < $filestodelete) {
|
|
schedule_backup_log($starttime,$preferences->backup_course," $matchfile deleted");
|
|
mtrace(" $matchfile deleted");
|
|
$filetodelete = $dirtocheck."/".$matchfile;
|
|
unlink($filetodelete);
|
|
$filesdeleted++;
|
|
}
|
|
}
|
|
}
|
|
return $status;
|
|
}
|
|
|
|
?>
|