[Summary view] [Print] [Text view]

   1  <?php //$Id: backup_scheduled.php,v 1.38.2.3 2008/04/13 01:34:06 stronk7 Exp $
   2      //This file contains all the code needed to execute scheduled backups
   3  
   4  //This function is executed via moodle cron
   5  //It prepares all the info and execute backups as necessary
   6  function schedule_backup_cron() {
   7  
   8      global $CFG;
   9  
  10      $status = true;
  11  
  12      $emailpending = false;
  13  
  14      //Check for required functions...
  15      if(!function_exists('utf8_encode')) {
  16          mtrace("        ERROR: You need to add XML support to your PHP installation!");
  17          return true;
  18      }
  19  
  20      //Get now
  21      $now = time();
  22  
  23      //First of all, we have to see if the scheduled is active and detect
  24      //that there isn't another cron running
  25      mtrace("    Checking backup status",'...');
  26      $backup_config = backup_get_config();
  27      if(!isset($backup_config->backup_sche_active) || !$backup_config->backup_sche_active) {
  28          mtrace("INACTIVE");
  29          return true;
  30      } else if (isset($backup_config->backup_sche_running) && $backup_config->backup_sche_running) {
  31          mtrace("RUNNING");
  32          //Now check if it's a really running task or something very old looking
  33          //for info in backup_logs to unlock status as necessary
  34          $timetosee = 1800;   //Half an hour looking for activity
  35          $timeafter = time() - $timetosee;
  36          $numofrec = count_records_select ("backup_log","time > $timeafter");
  37          if (!$numofrec) {
  38              $timetoseemin = $timetosee/60;
  39              mtrace("    No activity in last ".$timetoseemin." minutes. Unlocking status");
  40          } else {
  41              mtrace("    Scheduled backup seems to be running. Execution delayed");
  42              return true;
  43          }
  44      } else {
  45          mtrace("OK");
  46          //Mark backup_sche_running
  47          backup_set_config("backup_sche_running","1");
  48      }
  49  
  50      //Now we get the main admin user (we'll use his timezone, mail...)
  51      mtrace("    Getting admin info");
  52      $admin = get_admin();
  53      if (!$admin) {
  54          $status = false;
  55      }
  56  
  57      //Delete old_entries from backup tables
  58      if ($status) {
  59          mtrace("    Deleting old data");
  60          $status = backup_delete_old_data();
  61      }
  62  
  63      //Now we get a list of courses in the server
  64      if ($status) {
  65          mtrace("    Checking courses");
  66          //First of all, we delete everything from backup tables related to deleted courses
  67          mtrace("        Skipping deleted courses");
  68          $skipped = 0;
  69          if ($bckcourses = get_records('backup_courses')) {
  70              foreach($bckcourses as $bckcourse) {
  71                  //Search if it exists
  72                  if (!$exists = get_record('course', 'id', "$bckcourse->courseid")) {
  73                      //Doesn't exist, so delete from backup tables
  74                      delete_records('backup_courses', 'courseid', "$bckcourse->courseid");
  75                      delete_records('backup_log', 'courseid', "$bckcourse->courseid");
  76                      $skipped++;
  77                  }
  78              }
  79          }
  80          mtrace("            $skipped courses");
  81          //Now process existing courses
  82          $courses = get_records("course");
  83          //For each course, we check (insert, update) the backup_course table
  84          //with needed data
  85          foreach ($courses as $course) {
  86              if ($status) {
  87                  mtrace("        $course->fullname");
  88                  //We check if the course exists in backup_course
  89                  $backup_course = get_record("backup_courses","courseid",$course->id);
  90                  //If it doesn't exist, create
  91                  if (!$backup_course) {
  92                      $temp_backup_course->courseid = $course->id;
  93                      $newid = insert_record("backup_courses",$temp_backup_course);
  94                      //And get it from db
  95                      $backup_course = get_record("backup_courses","id",$newid);
  96                  }
  97                  //If it doesn't exist now, error
  98                  if (!$backup_course) {
  99                      mtrace("            ERROR (in backup_courses detection)");
 100                      $status = false;
 101                      continue;
 102                  }
 103                  // Skip backup of unavailable courses that have remained unmodified in a month
 104                  $skipped = false;
 105                  if (!$course->visible && ($now - $course->timemodified) > 31*24*60*60) {  //Hidden + unmodified last month
 106                      mtrace("            SKIPPING - hidden+unmodified");
 107                      set_field("backup_courses","laststatus","3","courseid",$backup_course->courseid);
 108                      $skipped = true;
 109                  }
 110                  //Now we backup every non skipped course with nextstarttime < now
 111                  if (!$skipped  && $backup_course->nextstarttime > 0 && $backup_course->nextstarttime < $now) {
 112                      //We have to send a email because we have included at least one backup
 113                      $emailpending = true;
 114                      //Only make the backup if laststatus isn't 2-UNFINISHED (uncontrolled error)
 115                      if ($backup_course->laststatus != 2) {
 116                          //Set laststarttime
 117                          $starttime = time();
 118                          set_field("backup_courses","laststarttime",$starttime,"courseid",$backup_course->courseid);
 119                          //Set course status to unfinished, the process will reset it
 120                          set_field("backup_courses","laststatus","2","courseid",$backup_course->courseid);
 121                          //Launch backup
 122                          $course_status = schedule_backup_launch_backup($course,$starttime);
 123                          //Set lastendtime
 124                          set_field("backup_courses","lastendtime",time(),"courseid",$backup_course->courseid);
 125                          //Set laststatus
 126                          if ($course_status) {
 127                              set_field("backup_courses","laststatus","1","courseid",$backup_course->courseid);
 128                          } else {
 129                              set_field("backup_courses","laststatus","0","courseid",$backup_course->courseid);
 130                          }
 131                      }
 132                  }
 133  
 134                  //Now, calculate next execution of the course
 135                  $nextstarttime = schedule_backup_next_execution ($backup_course,$backup_config,$now,$admin->timezone);
 136                  //Save it to db
 137                  set_field("backup_courses","nextstarttime",$nextstarttime,"courseid",$backup_course->courseid);
 138                  //Print it to screen as necessary
 139                  $showtime = "undefined";
 140                  if ($nextstarttime > 0) {
 141                      $showtime = userdate($nextstarttime,"",$admin->timezone);
 142                  }
 143                  mtrace("            Next execution: $showtime");
 144              }
 145          }
 146      }
 147  
 148      //Delete old logs
 149      if (!empty($CFG->loglifetime)) {
 150          mtrace("    Deleting old logs");
 151          $loglifetime = $now - ($CFG->loglifetime * 86400);
 152          delete_records_select("backup_log", "laststarttime < '$loglifetime'");
 153      }
 154  
 155      //Send email to admin if necessary
 156      if ($emailpending) {
 157          mtrace("    Sending email to admin");
 158          $message = "";
 159  
 160          //Get info about the status of courses
 161          $count_all = count_records('backup_courses');
 162          $count_ok = count_records('backup_courses','laststatus','1');
 163          $count_error = count_records('backup_courses','laststatus','0');
 164          $count_unfinished = count_records('backup_courses','laststatus','2');
 165          $count_skipped = count_records('backup_courses','laststatus','3');
 166  
 167          //Build the message text
 168          //Summary
 169          $message .= get_string('summary')."\n";
 170          $message .= "==================================================\n";
 171          $message .= "  ".get_string('courses').": ".$count_all."\n";
 172          $message .= "  ".get_string('ok').": ".$count_ok."\n";
 173          $message .= "  ".get_string('skipped').": ".$count_skipped."\n";
 174          $message .= "  ".get_string('error').": ".$count_error."\n";
 175          $message .= "  ".get_string('unfinished').": ".$count_unfinished."\n\n";
 176  
 177          //Reference
 178          if ($count_error != 0 || $count_unfinished != 0) {
 179              $message .= "  ".get_string('backupfailed')."\n\n";
 180              $dest_url = "$CFG->wwwroot/$CFG->admin/report/backups/index.php";
 181              $message .= "  ".get_string('backuptakealook','',$dest_url)."\n\n";
 182              //Set message priority
 183              $admin->priority = 1;
 184              //Reset unfinished to error
 185              set_field('backup_courses','laststatus','0','laststatus','2');
 186          } else {
 187              $message .= "  ".get_string('backupfinished')."\n";
 188          }
 189  
 190          //Build the message subject
 191          $site = get_site();
 192          $prefix = $site->shortname.": ";
 193          if ($count_error != 0 || $count_unfinished != 0) {
 194              $prefix .= "[".strtoupper(get_string('error'))."] ";
 195          }
 196          $subject = $prefix.get_string("scheduledbackupstatus");
 197  
 198          //Send the message
 199          email_to_user($admin,$admin,$subject,$message);
 200      }
 201  
 202  
 203      //Everything is finished stop backup_sche_running
 204      backup_set_config("backup_sche_running","0");
 205  
 206      return $status;
 207  }
 208  
 209  //This function executes the ENTIRE backup of a course (passed as parameter)
 210  //using all the scheduled backup preferences
 211  function schedule_backup_launch_backup($course,$starttime = 0) {
 212  
 213      $preferences = false;
 214      $status = false;
 215  
 216      mtrace("            Executing backup");
 217      schedule_backup_log($starttime,$course->id,"Start backup course $course->fullname");
 218      schedule_backup_log($starttime,$course->id,"  Phase 1: Checking and counting:");
 219      $preferences = schedule_backup_course_configure($course,$starttime);
 220  
 221      if ($preferences) {
 222          schedule_backup_log($starttime,$course->id,"  Phase 2: Executing and copying:");
 223          $status = schedule_backup_course_execute($preferences,$starttime);
 224      }
 225  
 226      if ($status && $preferences) {
 227          //Only if the backup_sche_keep is set
 228          if ($preferences->backup_keep) {
 229              schedule_backup_log($starttime,$course->id,"  Phase 3: Deleting old backup files:");
 230              $status = schedule_backup_course_delete_old_files($preferences,$starttime);
 231          }
 232      }
 233  
 234      if ($status && $preferences) {
 235          mtrace("            End backup OK");
 236          schedule_backup_log($starttime,$course->id,"End backup course $course->fullname - OK");
 237      } else {
 238          mtrace("            End backup with ERROR");
 239          schedule_backup_log($starttime,$course->id,"End backup course $course->fullname - ERROR!!");
 240      }
 241  
 242      return $status && $preferences;
 243  }
 244  
 245  //This function saves to backup_log all the needed process info
 246  //to use it later.  NOTE: If $starttime = 0 no info in saved
 247  function schedule_backup_log($starttime,$courseid,$message) {
 248  
 249      if ($starttime) {
 250          $log->courseid = $courseid;
 251          $log->time = time();
 252          $log->laststarttime = $starttime;
 253          $log->info = addslashes($message);
 254  
 255          insert_record ("backup_log",$log);
 256      }
 257  
 258  }
 259  
 260  //This function returns the next future GMT time to execute the course based in the
 261  //configuration of the scheduled backups
 262  function schedule_backup_next_execution ($backup_course,$backup_config,$now,$timezone) {
 263  
 264      $result = -1;
 265  
 266      //Get today's midnight GMT
 267      $midnight = usergetmidnight($now,$timezone);
 268  
 269      //Get today's day of week (0=Sunday...6=Saturday)
 270      $date = usergetdate($now,$timezone);
 271      $dayofweek = $date['wday'];
 272  
 273      //Get number of days (from today) to execute backups
 274      $scheduled_days = substr($backup_config->backup_sche_weekdays,$dayofweek).
 275                        $backup_config->backup_sche_weekdays;
 276      $daysfromtoday = strpos($scheduled_days, "1");
 277  
 278      //If some day has been found
 279      if ($daysfromtoday !== false) {
 280          //Calculate distance
 281          $dist = ($daysfromtoday * 86400) +                     //Days distance
 282                  ($backup_config->backup_sche_hour*3600) +      //Hours distance
 283                  ($backup_config->backup_sche_minute*60);       //Minutes distance
 284          $result = $midnight + $dist;
 285      }
 286  
 287      //If that time is past, call the function recursively to obtain the next valid day
 288      if ($result > 0 && $result < time()) {
 289          $result = schedule_backup_next_execution ($backup_course,$backup_config,$now + 86400,$timezone);
 290      }
 291  
 292      return $result;
 293  }
 294  
 295  
 296  
 297  //This function implements all the needed code to prepare a course
 298  //to be in backup (insert temp info into backup temp tables).
 299  function schedule_backup_course_configure($course,$starttime = 0) {
 300  
 301      global $CFG;
 302  
 303      $status = true;
 304  
 305      schedule_backup_log($starttime,$course->id,"    checking parameters");
 306  
 307      //Check the required variable
 308      if (empty($course->id)) {
 309          $status = false;
 310      }
 311      //Get scheduled backup preferences
 312      $backup_config =  backup_get_config();
 313  
 314      //Checks backup_config pairs exist
 315      if ($status) {
 316          if (!isset($backup_config->backup_sche_modules)) {
 317              $backup_config->backup_sche_modules = 1;
 318          }
 319          if (!isset($backup_config->backup_sche_withuserdata)) {
 320              $backup_config->backup_sche_withuserdata = 1;
 321          }
 322          if (!isset($backup_config->backup_sche_metacourse)) {
 323              $backup_config->backup_sche_metacourse = 1;
 324          }
 325          if (!isset($backup_config->backup_sche_users)) {
 326              $backup_config->backup_sche_users = 1;
 327          }
 328          if (!isset($backup_config->backup_sche_logs)) {
 329              $backup_config->backup_sche_logs = 0;
 330          }
 331          if (!isset($backup_config->backup_sche_userfiles)) {
 332              $backup_config->backup_sche_userfiles = 1;
 333          }
 334          if (!isset($backup_config->backup_sche_coursefiles)) {
 335              $backup_config->backup_sche_coursefiles = 1;
 336          }
 337          if (!isset($backup_config->backup_sche_sitefiles)) {
 338              $backup_config->backup_sche_sitefiles = 1;
 339          }
 340          if (!isset($backup_config->backup_sche_messages)) {
 341              $backup_config->backup_sche_messages = 0;
 342          }
 343          if (!isset($backup_config->backup_sche_blogs)) {
 344              $backup_config->backup_sche_blogs = 0;
 345          }
 346          if (!isset($backup_config->backup_sche_active)) {
 347              $backup_config->backup_sche_active = 0;
 348          }
 349          if (!isset($backup_config->backup_sche_weekdays)) {
 350              $backup_config->backup_sche_weekdays = "0000000";
 351          }
 352          if (!isset($backup_config->backup_sche_hour)) {
 353              $backup_config->backup_sche_hour = 00;
 354          }
 355          if (!isset($backup_config->backup_sche_minute)) {
 356              $backup_config->backup_sche_minute = 00;
 357          }
 358          if (!isset($backup_config->backup_sche_destination)) {
 359              $backup_config->backup_sche_destination = "";
 360          }
 361          if (!isset($backup_config->backup_sche_keep)) {
 362              $backup_config->backup_sche_keep = 1;
 363          }
 364      }
 365  
 366      if ($status) {
 367         //Checks for the required files/functions to backup every mod
 368          //And check if there is data about it
 369          $count = 0;
 370          if ($allmods = get_records("modules") ) {
 371              foreach ($allmods as $mod) {
 372                  $modname = $mod->name;
 373                  $modfile = "$CFG->dirroot/mod/$modname/backuplib.php";
 374                  $modbackup = $modname."_backup_mods";
 375                  $modcheckbackup = $modname."_check_backup_mods";
 376                  if (file_exists($modfile)) {
 377                     include_once($modfile);
 378                     if (function_exists($modbackup) and function_exists($modcheckbackup)) {
 379                         $var = "exists_".$modname;
 380                         $$var = true;
 381                         $count++;
 382  
 383                         // PENNY NOTES: I have moved from here to the closing brace inside
 384                         // by two sets of ifs()
 385                         // to avoid the backup failing on a non existant backup.
 386                         // If the file/function/whatever doesn't exist, we don't want to set this
 387                         // this module in backup preferences at all.
 388                         //Check data
 389                         //Check module info
 390                         $var = "backup_".$modname;
 391                         if (!isset($$var)) {
 392                             $$var = $backup_config->backup_sche_modules;
 393                         }
 394                         //Now stores all the mods preferences into an array into preferences
 395                         $preferences->mods[$modname]->backup = $$var;
 396  
 397                         //Check include user info
 398                         $var = "backup_user_info_".$modname;
 399                         if (!isset($$var)) {
 400                             $$var = $backup_config->backup_sche_withuserdata;
 401                         }
 402                         //Now stores all the mods preferences into an array into preferences
 403                         $preferences->mods[$modname]->userinfo = $$var;
 404                         //And the name of the mod
 405                         $preferences->mods[$modname]->name = $modname;
 406                     }
 407                  }
 408              }
 409          }
 410  
 411          // now set instances
 412          if ($coursemods = get_course_mods($course->id)) {
 413              foreach ($coursemods as $mod) {
 414                  if (array_key_exists($mod->modname,$preferences->mods)) { // we are to backup this module
 415                      if (empty($preferences->mods[$mod->modname]->instances)) {
 416                          $preferences->mods[$mod->modname]->instances = array(); // avoid warnings
 417                      }
 418                      $preferences->mods[$mod->modname]->instances[$mod->instance]->backup = $preferences->mods[$mod->modname]->backup;
 419                      $preferences->mods[$mod->modname]->instances[$mod->instance]->userinfo = $preferences->mods[$mod->modname]->userinfo;
 420                      // there isn't really a nice way to do this...
 421                      $preferences->mods[$mod->modname]->instances[$mod->instance]->name = get_field($mod->modname,'name','id',$mod->instance);
 422                  }
 423              }
 424          }
 425  
 426          // finally, clean all the $preferences->mods[] not having instances. Nothing to backup about them
 427          foreach ($preferences->mods as $modname => $mod) {
 428              if (!isset($mod->instances)) {
 429                  unset($preferences->mods[$modname]);
 430              }
 431          }
 432      }
 433  
 434      //Convert other parameters
 435      if ($status) {
 436          $preferences->backup_metacourse = $backup_config->backup_sche_metacourse;
 437          $preferences->backup_users = $backup_config->backup_sche_users;
 438          $preferences->backup_logs = $backup_config->backup_sche_logs;
 439          $preferences->backup_user_files = $backup_config->backup_sche_userfiles;
 440          $preferences->backup_course_files = $backup_config->backup_sche_coursefiles;
 441          $preferences->backup_site_files = $backup_config->backup_sche_sitefiles;
 442          $preferences->backup_messages = $backup_config->backup_sche_messages;
 443          $preferences->backup_blogs = $backup_config->backup_sche_blogs;
 444          $preferences->backup_course = $course->id;
 445          $preferences->backup_destination = $backup_config->backup_sche_destination;
 446          $preferences->backup_keep = $backup_config->backup_sche_keep;
 447      }
 448  
 449      //Calculate various backup preferences
 450      if ($status) {
 451          schedule_backup_log($starttime,$course->id,"    calculating backup name");
 452  
 453          //Calculate the backup file name
 454          $backup_name = backup_get_zipfile_name($course);
 455  
 456          //Calculate the string to match the keep preference
 457          $keep_name = backup_get_keep_name($course);
 458  
 459          //Set them
 460          $preferences->backup_name = $backup_name;
 461          $preferences->keep_name = $keep_name;
 462  
 463          //Roleasignments
 464          $roles = get_records('role', '', '', 'sortorder');
 465          foreach ($roles as $role) {
 466              $preferences->backuproleassignments[$role->id] = $role;
 467          }
 468  
 469          //Another Info
 470          backup_add_static_preferences($preferences);
 471      }
 472  
 473      //Calculate the backup unique code to allow simultaneus backups (to define
 474      //the temp-directory name and records in backup temp tables
 475      if ($status) {
 476          $backup_unique_code = time();
 477          $preferences->backup_unique_code = $backup_unique_code;
 478      }
 479  
 480      //Calculate necesary info to backup modules
 481      if ($status) {
 482          schedule_backup_log($starttime,$course->id,"    calculating modules data");
 483          if ($allmods = get_records("modules") ) {
 484              foreach ($allmods as $mod) {
 485                  $modname = $mod->name;
 486                  $modbackup = $modname."_backup_mods";
 487                  //If exists the lib & function
 488                  $var = "exists_".$modname;
 489                  if (isset($$var) && $$var) {
 490                      //Add hidden fields
 491                      $var = "backup_".$modname;
 492                      //Only if selected
 493                      if ($$var == 1) {
 494                          $var = "backup_user_info_".$modname;
 495                          //Call the check function to show more info
 496                          $modcheckbackup = $modname."_check_backup_mods";
 497                          schedule_backup_log($starttime,$course->id,"      $modname");
 498                          $modcheckbackup($course->id,$$var,$backup_unique_code);
 499                      }
 500                  }
 501              }
 502          }
 503      }
 504  
 505      //Now calculate the users
 506      if ($status) {
 507          schedule_backup_log($starttime,$course->id,"    calculating users");
 508          //Decide about include users with messages, based on SITEID
 509          if ($preferences->backup_messages && $preferences->backup_course == SITEID) {
 510              $include_message_users = true;
 511          } else {
 512              $include_message_users = false;
 513          }
 514          //Decide about include users with blogs, based on SITEID
 515          if ($preferences->backup_blogs && $preferences->backup_course == SITEID) {
 516              $include_blog_users = true;
 517          } else {
 518              $include_blog_users = false;
 519          }
 520          user_check_backup($course->id,$backup_unique_code,$preferences->backup_users,$include_message_users, $include_blog_users);
 521      }
 522  
 523      //Now calculate the logs
 524      if ($status) {
 525          if ($preferences->backup_logs) {
 526              schedule_backup_log($starttime,$course->id,"    calculating logs");
 527              log_check_backup($course->id);
 528          }
 529      }
 530  
 531      //Now calculate the userfiles
 532      if ($status) {
 533          if ($preferences->backup_user_files) {
 534              schedule_backup_log($starttime,$course->id,"    calculating user files");
 535              user_files_check_backup($course->id,$preferences->backup_unique_code);
 536          }
 537      }
 538  
 539      //Now calculate the coursefiles
 540      if ($status) {
 541         if ($preferences->backup_course_files) {
 542              schedule_backup_log($starttime,$course->id,"    calculating course files");
 543              course_files_check_backup($course->id,$preferences->backup_unique_code);
 544          }
 545      }
 546  
 547      //Now calculate the sitefiles
 548      if ($status) {
 549         if ($preferences->backup_site_files) {
 550              schedule_backup_log($starttime,$course->id,"    calculating site files");
 551              site_files_check_backup($course->id,$preferences->backup_unique_code);
 552          }
 553      }
 554  
 555      //If everything is ok, return calculated preferences
 556      if ($status) {
 557          $status = $preferences;
 558      }
 559  
 560      return $status;
 561  }
 562  
 563  //TODO: Unify this function with backup_execute() to have both backups 100% equivalent. Moodle 2.0
 564  
 565  //This function implements all the needed code to backup a course
 566  //copying it to the desired destination (default if not specified)
 567  function schedule_backup_course_execute($preferences,$starttime = 0) {
 568  
 569      global $CFG;
 570  
 571      $status = true;
 572  
 573      //Some parts of the backup doesn't know about $preferences, so we
 574      //put a copy of it inside that CFG (always global) to be able to
 575      //use it. Then, when needed I search for preferences inside CFG
 576      //Used to avoid some problems in full_tag() when preferences isn't
 577      //set globally (i.e. in scheduled backups)
 578      $CFG->backup_preferences = $preferences;
 579  
 580      //Check for temp and backup and backup_unique_code directory
 581      //Create them as needed
 582      schedule_backup_log($starttime,$preferences->backup_course,"    checking temp structures");
 583      $status = check_and_create_backup_dir($preferences->backup_unique_code);
 584      //Empty backup dir
 585      if ($status) {
 586          schedule_backup_log($starttime,$preferences->backup_course,"    cleaning current dir");
 587          $status = clear_backup_dir($preferences->backup_unique_code);
 588      }
 589  
 590      //Create the moodle.xml file
 591      if ($status) {
 592          schedule_backup_log($starttime,$preferences->backup_course,"    creating backup file");
 593          //Obtain the xml file (create and open) and print prolog information
 594          $backup_file = backup_open_xml($preferences->backup_unique_code);
 595          //Prints general info about backup to file
 596          if ($backup_file) {
 597              schedule_backup_log($starttime,$preferences->backup_course,"      general info");
 598              $status = backup_general_info($backup_file,$preferences);
 599          } else {
 600              $status = false;
 601          }
 602  
 603          //Prints course start (tag and general info)
 604          if ($status) {
 605              $status = backup_course_start($backup_file,$preferences);
 606          }
 607  
 608          //Metacourse information
 609          if ($status && $preferences->backup_metacourse) {
 610              schedule_backup_log($starttime,$preferences->backup_course,"      metacourse info");
 611              $status = backup_course_metacourse($backup_file,$preferences);
 612          }
 613  
 614          //Block info
 615          if ($status) {
 616              schedule_backup_log($starttime,$preferences->backup_course,"      blocks info");
 617              $status = backup_course_blocks($backup_file,$preferences);
 618          }
 619  
 620          //Section info
 621          if ($status) {
 622              schedule_backup_log($starttime,$preferences->backup_course,"      sections info");
 623              $status = backup_course_sections($backup_file,$preferences);
 624          }
 625  
 626          //User info
 627          if ($status) {
 628              schedule_backup_log($starttime,$preferences->backup_course,"      user info");
 629              $status = backup_user_info($backup_file,$preferences);
 630          }
 631  
 632          //If we have selected to backup messages and we are
 633          //doing a SITE backup, let's do it
 634          if ($status && $preferences->backup_messages && $preferences->backup_course == SITEID) {
 635              schedule_backup_log($starttime,$preferences->backup_course,"      messages");
 636              $status = backup_messages($backup_file,$preferences);
 637          }
 638  
 639          //If we have selected to backup blogs and we are
 640          //doing a SITE backup, let's do it
 641          if ($status && $preferences->backup_blogs && $preferences->backup_course == SITEID) {
 642              schedule_backup_log($starttime,$preferences->backup_course,"      blogs");
 643              $status = backup_blogs($backup_file,$preferences);
 644          }
 645  
 646          //If we have selected to backup quizzes, backup categories and
 647          //questions structure (step 1). See notes on mod/quiz/backuplib.php
 648          if ($status and $preferences->mods['quiz']->backup) {
 649              schedule_backup_log($starttime,$preferences->backup_course,"      categories & questions");
 650              $status = backup_question_categories($backup_file,$preferences);
 651          }
 652  
 653          //Print logs if selected
 654          if ($status) {
 655              if ($preferences->backup_logs) {
 656                  schedule_backup_log($starttime,$preferences->backup_course,"      logs");
 657                  $status = backup_log_info($backup_file,$preferences);
 658              }
 659          }
 660  
 661          //Print scales info
 662          if ($status) {
 663              schedule_backup_log($starttime,$preferences->backup_course,"      scales");
 664              $status = backup_scales_info($backup_file,$preferences);
 665          }
 666  
 667          //Print groups info
 668          if ($status) {
 669              schedule_backup_log($starttime,$preferences->backup_course,"      groups");
 670              $status = backup_groups_info($backup_file,$preferences);
 671          }
 672  
 673          //Print groupings info
 674          if ($status) {
 675              schedule_backup_log($starttime,$preferences->backup_course,"      groupings");
 676              $status = backup_groupings_info($backup_file,$preferences);
 677          }
 678  
 679          //Print groupings_groups info
 680          if ($status) {
 681              schedule_backup_log($starttime,$preferences->backup_course,"      groupings_groups");
 682              $status = backup_groupings_groups_info($backup_file,$preferences);
 683          }
 684  
 685          //Print events info
 686          if ($status) {
 687              schedule_backup_log($starttime,$preferences->backup_course,"      events");
 688              $status = backup_events_info($backup_file,$preferences);
 689          }
 690  
 691          //Print gradebook info
 692          if ($status) {
 693              schedule_backup_log($starttime,$preferences->backup_course,"      gradebook");
 694              $status = backup_gradebook_info($backup_file,$preferences);
 695          }
 696  
 697          //Module info, this unique function makes all the work!!
 698          //db export and module fileis copy
 699          if ($status) {
 700              $mods_to_backup = false;
 701              //Check if we have any mod to backup
 702              foreach ($preferences->mods as $module) {
 703                  if ($module->backup) {
 704                      $mods_to_backup = true;
 705                  }
 706              }
 707              //If we have to backup some module
 708              if ($mods_to_backup) {
 709                  schedule_backup_log($starttime,$preferences->backup_course,"      modules");
 710                  //Start modules tag
 711                  $status = backup_modules_start ($backup_file,$preferences);
 712                  //Iterate over modules and call backup
 713                  foreach ($preferences->mods as $module) {
 714                      if ($module->backup and $status) {
 715                          schedule_backup_log($starttime,$preferences->backup_course,"        $module->name");
 716                          $status = backup_module($backup_file,$preferences,$module->name);
 717                      }
 718                  }
 719                  //Close modules tag
 720                  $status = backup_modules_end ($backup_file,$preferences);
 721              }
 722          }
 723  
 724          //Backup course format data, if any.
 725          if ($status) {
 726              schedule_backup_log($starttime,$preferences->backup_course,"      course format data");
 727              $status = backup_format_data($backup_file,$preferences);
 728          }
 729  
 730          //Prints course end
 731          if ($status) {
 732              $status = backup_course_end($backup_file,$preferences);
 733          }
 734  
 735          //Close the xml file and xml data
 736          if ($backup_file) {
 737              backup_close_xml($backup_file);
 738          }
 739      }
 740  
 741      //Now, if selected, copy user files
 742      if ($status) {
 743          if ($preferences->backup_user_files) {
 744              schedule_backup_log($starttime,$preferences->backup_course,"    copying user files");
 745              $status = backup_copy_user_files ($preferences);
 746          }
 747      }
 748  
 749      //Now, if selected, copy course files
 750      if ($status) {
 751          if ($preferences->backup_course_files) {
 752              schedule_backup_log($starttime,$preferences->backup_course,"    copying course files");
 753              $status = backup_copy_course_files ($preferences);
 754          }
 755      }
 756  
 757      //Now, if selected, copy site files
 758      if ($status) {
 759          if ($preferences->backup_site_files) {
 760              schedule_backup_log($starttime,$preferences->backup_course,"    copying site files");
 761              $status = backup_copy_site_files ($preferences);
 762          }
 763      }
 764  
 765      //Now, zip all the backup directory contents
 766      if ($status) {
 767          schedule_backup_log($starttime,$preferences->backup_course,"    zipping files");
 768          $status = backup_zip ($preferences);
 769      }
 770  
 771      //Now, copy the zip file to course directory
 772      if ($status) {
 773          schedule_backup_log($starttime,$preferences->backup_course,"    copying backup");
 774          $status = copy_zip_to_course_dir ($preferences);
 775      }
 776  
 777      //Now, clean temporary data (db and filesystem)
 778      if ($status) {
 779          schedule_backup_log($starttime,$preferences->backup_course,"    cleaning temp data");
 780          $status = clean_temp_data ($preferences);
 781      }
 782  
 783      //Unset CFG->backup_preferences only needed in scheduled backups
 784      unset ($CFG->backup_preferences);
 785  
 786      return $status;
 787  }
 788  
 789  //This function deletes old backup files when the "keep" limit has been reached
 790  //in the destination directory.
 791  function schedule_backup_course_delete_old_files($preferences,$starttime=0) {
 792  
 793      global $CFG;
 794  
 795      $status = true;
 796  
 797      //Calculate the directory to check
 798      $dirtocheck = "";
 799      //if $preferences->backup_destination isn't empty, then check that directory
 800      if (!empty($preferences->backup_destination)) {
 801          $dirtocheck = $preferences->backup_destination;
 802      //else calculate standard backup directory location
 803      } else {
 804          $dirtocheck = $CFG->dataroot."/".$preferences->backup_course."/backupdata";
 805      }
 806      schedule_backup_log($starttime,$preferences->backup_course,"    checking $dirtocheck");
 807      if ($CFG->debug > 7) {
 808          mtrace("            Keeping backup files in $dirtocheck");
 809      }
 810  
 811      //Get all the files in $dirtocheck
 812      $files = get_directory_list($dirtocheck,"",false);
 813      //Get all matching files ($preferences->keep_name) from $files
 814      $matchingfiles = array();
 815      foreach ($files as $file) {
 816          if (substr($file, 0, strlen($preferences->keep_name)) == $preferences->keep_name) {
 817              $modifieddate = filemtime($dirtocheck."/".$file);
 818              $matchingfiles[$modifieddate] = $file;
 819          }
 820      }
 821      //Sort by key (modified date) to get the oldest first (instead of doing that by name
 822      //because it could give us problems in some languages with different format names).
 823      ksort($matchingfiles);
 824  
 825      //Count matching files
 826      $countmatching = count($matchingfiles);
 827      schedule_backup_log($starttime,$preferences->backup_course,"        found $countmatching backup files");
 828      mtrace("                found $countmatching backup files");
 829      if ($preferences->backup_keep < $countmatching) {
 830          schedule_backup_log($starttime,$preferences->backup_course,"        keep limit ($preferences->backup_keep) reached. Deleting old files");
 831          mtrace("                keep limit ($preferences->backup_keep) reached. Deleting old files");
 832          $filestodelete = $countmatching - $preferences->backup_keep;
 833          $filesdeleted = 0;
 834          foreach ($matchingfiles as $matchfile) {
 835              if ($filesdeleted < $filestodelete) {
 836                  schedule_backup_log($starttime,$preferences->backup_course,"        $matchfile deleted");
 837                  mtrace("                $matchfile deleted");
 838                  $filetodelete = $dirtocheck."/".$matchfile;
 839                  unlink($filetodelete);
 840                  $filesdeleted++;
 841              }
 842          }
 843      }
 844      return $status;
 845  }
 846  
 847  ?>