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.
311 lines
10 KiB
311 lines
10 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/>.
|
|
|
|
/**
|
|
* Test plan generator.
|
|
*
|
|
* @package tool_generator
|
|
* @copyright 2013 David Monllaó
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
|
|
defined('MOODLE_INTERNAL') || die();
|
|
|
|
/**
|
|
* Generates the files required by JMeter.
|
|
*
|
|
* @package tool_generator
|
|
* @copyright 2013 David Monllaó
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
class tool_generator_testplan_backend extends tool_generator_backend {
|
|
|
|
/**
|
|
* @var The URL to the repository of the external project.
|
|
*/
|
|
protected static $repourl = 'https://github.com/moodlehq/moodle-performance-comparison';
|
|
|
|
/**
|
|
* @var Number of users depending on the selected size.
|
|
*/
|
|
protected static $users = array(1, 30, 100, 1000, 5000, 10000);
|
|
|
|
/**
|
|
* @var Number of loops depending on the selected size.
|
|
*/
|
|
protected static $loops = array(5, 5, 5, 6, 6, 7);
|
|
|
|
/**
|
|
* @var Rampup period depending on the selected size.
|
|
*/
|
|
protected static $rampups = array(1, 6, 40, 100, 500, 800);
|
|
|
|
/**
|
|
* Gets a list of size choices supported by this backend.
|
|
*
|
|
* @return array List of size (int) => text description for display
|
|
*/
|
|
public static function get_size_choices() {
|
|
|
|
$options = array();
|
|
for ($size = self::MIN_SIZE; $size <= self::MAX_SIZE; $size++) {
|
|
$a = new stdClass();
|
|
$a->users = self::$users[$size];
|
|
$a->loops = self::$loops[$size];
|
|
$a->rampup = self::$rampups[$size];
|
|
$options[$size] = get_string('testplansize_' . $size, 'tool_generator', $a);
|
|
}
|
|
return $options;
|
|
}
|
|
|
|
/**
|
|
* Getter for moodle-performance-comparison project URL.
|
|
*
|
|
* @return string
|
|
*/
|
|
public static function get_repourl() {
|
|
return self::$repourl;
|
|
}
|
|
|
|
/**
|
|
* Creates the test plan file.
|
|
*
|
|
* @param int $courseid The target course id
|
|
* @param int $size The test plan size
|
|
* @return stored_file
|
|
*/
|
|
public static function create_testplan_file($courseid, $size) {
|
|
$jmxcontents = self::generate_test_plan($courseid, $size);
|
|
|
|
$fs = get_file_storage();
|
|
$filerecord = self::get_file_record('testplan', 'jmx');
|
|
return $fs->create_file_from_string($filerecord, $jmxcontents);
|
|
}
|
|
|
|
/**
|
|
* Creates the users data file.
|
|
*
|
|
* @param int $courseid The target course id
|
|
* @param bool $updateuserspassword Updates the course users password to $CFG->tool_generator_users_password
|
|
* @return stored_file
|
|
*/
|
|
public static function create_users_file($courseid, $updateuserspassword) {
|
|
$csvcontents = self::generate_users_file($courseid, $updateuserspassword);
|
|
|
|
$fs = get_file_storage();
|
|
$filerecord = self::get_file_record('users', 'csv');
|
|
return $fs->create_file_from_string($filerecord, $csvcontents);
|
|
}
|
|
|
|
/**
|
|
* Generates the test plan according to the target course contents.
|
|
*
|
|
* @param int $targetcourseid The target course id
|
|
* @param int $size The test plan size
|
|
* @return string The test plan as a string
|
|
*/
|
|
protected static function generate_test_plan($targetcourseid, $size) {
|
|
global $CFG;
|
|
|
|
// Getting the template.
|
|
$template = file_get_contents(__DIR__ . '/../testplan.template.jmx');
|
|
|
|
// Getting the course modules data.
|
|
$coursedata = self::get_course_test_data($targetcourseid);
|
|
|
|
// Host and path to the site.
|
|
$urlcomponents = parse_url($CFG->wwwroot);
|
|
if (empty($urlcomponents['path'])) {
|
|
$urlcomponents['path'] = '';
|
|
}
|
|
|
|
$replacements = array(
|
|
$CFG->version,
|
|
self::$users[$size],
|
|
self::$loops[$size],
|
|
self::$rampups[$size],
|
|
$urlcomponents['host'],
|
|
$urlcomponents['path'],
|
|
get_string('shortsize_' . $size, 'tool_generator'),
|
|
$targetcourseid,
|
|
$coursedata->pageid,
|
|
$coursedata->forumid,
|
|
$coursedata->forumdiscussionid,
|
|
$coursedata->forumreplyid
|
|
);
|
|
|
|
$placeholders = array(
|
|
'{{MOODLEVERSION_PLACEHOLDER}}',
|
|
'{{USERS_PLACEHOLDER}}',
|
|
'{{LOOPS_PLACEHOLDER}}',
|
|
'{{RAMPUP_PLACEHOLDER}}',
|
|
'{{HOST_PLACEHOLDER}}',
|
|
'{{SITEPATH_PLACEHOLDER}}',
|
|
'{{SIZE_PLACEHOLDER}}',
|
|
'{{COURSEID_PLACEHOLDER}}',
|
|
'{{PAGEACTIVITYID_PLACEHOLDER}}',
|
|
'{{FORUMACTIVITYID_PLACEHOLDER}}',
|
|
'{{FORUMDISCUSSIONID_PLACEHOLDER}}',
|
|
'{{FORUMREPLYID_PLACEHOLDER}}'
|
|
);
|
|
|
|
// Fill the template with the target course values.
|
|
return str_replace($placeholders, $replacements, $template);
|
|
}
|
|
|
|
/**
|
|
* Generates the user's credentials file with all the course's users
|
|
*
|
|
* @param int $targetcourseid
|
|
* @param bool $updateuserspassword Updates the course users password to $CFG->tool_generator_users_password
|
|
* @return string The users csv file contents.
|
|
*/
|
|
protected static function generate_users_file($targetcourseid, $updateuserspassword) {
|
|
global $CFG;
|
|
|
|
$coursecontext = context_course::instance($targetcourseid);
|
|
|
|
$users = get_enrolled_users($coursecontext, '', 0, 'u.id, u.username, u.auth', 'u.username ASC');
|
|
if (!$users) {
|
|
print_error('coursewithoutusers', 'tool_generator');
|
|
}
|
|
|
|
$lines = array();
|
|
foreach ($users as $user) {
|
|
|
|
// Updating password to the one set in config.php.
|
|
if ($updateuserspassword) {
|
|
$userauth = get_auth_plugin($user->auth);
|
|
if (!$userauth->user_update_password($user, $CFG->tool_generator_users_password)) {
|
|
print_error('errorpasswordupdate', 'auth');
|
|
}
|
|
}
|
|
|
|
// Here we already checked that $CFG->tool_generator_users_password is not null.
|
|
$lines[] = $user->username . ',' . $CFG->tool_generator_users_password;
|
|
}
|
|
|
|
return implode(PHP_EOL, $lines);
|
|
}
|
|
|
|
/**
|
|
* Returns a tool_generator file record
|
|
*
|
|
* @param string $filearea testplan or users
|
|
* @param string $filetype The file extension jmx or csv
|
|
* @return stdClass The file record to use when creating tool_generator files
|
|
*/
|
|
protected static function get_file_record($filearea, $filetype) {
|
|
|
|
$systemcontext = context_system::instance();
|
|
|
|
$filerecord = new stdClass();
|
|
$filerecord->contextid = $systemcontext->id;
|
|
$filerecord->component = 'tool_generator';
|
|
$filerecord->filearea = $filearea;
|
|
$filerecord->itemid = 0;
|
|
$filerecord->filepath = '/';
|
|
|
|
// Random generated number to avoid concurrent execution problems.
|
|
$filerecord->filename = $filearea . '_' . date('YmdHi', time()) . '_' . rand(1000, 9999) . '.' . $filetype;
|
|
|
|
return $filerecord;
|
|
}
|
|
|
|
/**
|
|
* Gets the data required to fill the test plan template with the database contents.
|
|
*
|
|
* @param int $targetcourseid The target course id
|
|
* @return stdClass The ids required by the test plan
|
|
*/
|
|
protected static function get_course_test_data($targetcourseid) {
|
|
global $DB, $USER;
|
|
|
|
$data = new stdClass();
|
|
|
|
// Getting course contents info as the current user (will be an admin).
|
|
$course = new stdClass();
|
|
$course->id = $targetcourseid;
|
|
$courseinfo = new course_modinfo($course, $USER->id);
|
|
|
|
// Getting the first page module instance.
|
|
if (!$pages = $courseinfo->get_instances_of('page')) {
|
|
print_error('error_nopageinstances', 'tool_generator');
|
|
}
|
|
$data->pageid = reset($pages)->id;
|
|
|
|
// Getting the first forum module instance and it's first discussion and reply as well.
|
|
if (!$forums = $courseinfo->get_instances_of('forum')) {
|
|
print_error('error_noforuminstances', 'tool_generator');
|
|
}
|
|
$forum = reset($forums);
|
|
|
|
// Getting the first discussion (and reply).
|
|
if (!$discussions = forum_get_discussions($forum, 'd.timemodified ASC', false, -1, 1)) {
|
|
print_error('error_noforumdiscussions', 'tool_generator');
|
|
}
|
|
$discussion = reset($discussions);
|
|
|
|
$data->forumid = $forum->id;
|
|
$data->forumdiscussionid = $discussion->discussion;
|
|
$data->forumreplyid = $discussion->id;
|
|
|
|
// According to the current test plan.
|
|
return $data;
|
|
}
|
|
|
|
/**
|
|
* Checks if the selected target course is ok.
|
|
*
|
|
* @param int|string $course
|
|
* @param int $size
|
|
* @return array Errors array or false if everything is ok
|
|
*/
|
|
public static function has_selected_course_any_problem($course, $size) {
|
|
global $DB;
|
|
|
|
$errors = array();
|
|
|
|
if (!is_numeric($course)) {
|
|
if (!$course = $DB->get_field('course', 'id', array('shortname' => $course))) {
|
|
$errors['courseid'] = get_string('error_nonexistingcourse', 'tool_generator');
|
|
return $errors;
|
|
}
|
|
}
|
|
|
|
$coursecontext = context_course::instance($course, IGNORE_MISSING);
|
|
if (!$coursecontext) {
|
|
$errors['courseid'] = get_string('error_nonexistingcourse', 'tool_generator');
|
|
return $errors;
|
|
}
|
|
|
|
if (!$users = get_enrolled_users($coursecontext, '', 0, 'u.id')) {
|
|
$errors['courseid'] = get_string('coursewithoutusers', 'tool_generator');
|
|
}
|
|
|
|
// Checks that the selected course has enough users.
|
|
$coursesizes = tool_generator_course_backend::get_users_per_size();
|
|
if (count($users) < self::$users[$size]) {
|
|
$errors['size'] = get_string('notenoughusers', 'tool_generator');
|
|
}
|
|
|
|
if (empty($errors)) {
|
|
return false;
|
|
}
|
|
|
|
return $errors;
|
|
}
|
|
}
|
|
|