Proyectos de Subversion Moodle

<?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/>.

/**

 * Cache display administration helper.

 *

 * This file is part of Moodle's cache API, affectionately called MUC.

 * It contains the components that are requried in order to use caching.

 *

 * @package    core_cache

 * @category   cache

 * @author     Peter Burnett <peterburnett@catalyst-au.net>

 * @copyright  2020 Catalyst IT

 * @copyright  2012 Sam Hemelryk

 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

namespace core_cache\local;

use core_cache\cache;

use core_cache\config;

use core_cache\config_writer;

use core_cache\configurable_cache_interface;

use core_cache\exception\cache_exception;

use core_cache\factory;

use core_cache\form\cache_lock_form;

use core_cache\form\cache_mode_mappings_form;

use core_cache\form\cache_definition_sharing_form;

use core_cache\form\cache_definition_mappings_form;

use core_cache\form\cachestore_addinstance_form;

use core_cache\helper as cache_helper;

use core_cache\lockable_cache_interface;

use core_cache\store;

use core_component;

use core\context;

use core\context\system as context_system;

use core\exception\coding_exception;

use core\exception\moodle_exception;

use core\output\notification;

use core\output\single_button;

use core\url;

use html_writer;

use stdClass;

/**

 * A cache helper for administration tasks

 *

 * @package    core

 * @category   cache

 * @copyright  2020 Peter Burnett <peterburnett@catalyst-au.net>

 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

class administration_display_helper extends \core_cache\administration_helper {

    /**

     * Please do not call constructor directly. Use factory::get_administration_display_helper() instead.

     */

    public function __construct() {

        // Nothing to do here.

    }

    /**

     * Returns all of the actions that can be performed on a definition.

     *

     * @param context $context the system context.

     * @param array $definitionsummary information about this cache, from the array returned by

     *      core_cache\administration_helper::get_definition_summaries(). Currently only 'sharingoptions'

     *      element is used.

     * @return array of actions. Each action is an action_url.

     */

    public function get_definition_actions(context $context, array $definitionsummary): array {

        global $OUTPUT;

        if (has_capability('moodle/site:config', $context)) {

            $actions = [];

            // Edit mappings.

            $actions[] = $OUTPUT->action_link(

                new url('/cache/admin.php', ['action' => 'editdefinitionmapping',

                    'definition' => $definitionsummary['id'], ]),

                get_string('editmappings', 'cache')

            );

            // Edit sharing.

            if (count($definitionsummary['sharingoptions']) > 1) {

                $actions[] = $OUTPUT->action_link(

                    new url('/cache/admin.php', ['action' => 'editdefinitionsharing',

                        'definition' => $definitionsummary['id'], ]),

                    get_string('editsharing', 'cache')

                );

            }

            // Purge.

            $actions[] = $OUTPUT->action_link(

                new url('/cache/admin.php', ['action' => 'purgedefinition',

                    'definition' => $definitionsummary['id'], 'sesskey' => sesskey(), ]),

                get_string('purge', 'cache')

            );

            return $actions;

        }

        return [];

    }

    /**

     * Returns all of the actions that can be performed on a store.

     *

     * @param string $name The name of the store

     * @param array $storedetails information about this store, from the array returned by

     *      core_cache\administration_helper::get_store_instance_summaries().

     * @return array of actions. Each action is an action_url.

     */

    public function get_store_instance_actions(string $name, array $storedetails): array {

        global $OUTPUT;

        $actions = [];

        if (has_capability('moodle/site:config', context_system::instance())) {

            $baseurl = new url('/cache/admin.php', ['store' => $name]);

            if (empty($storedetails['default'])) {

                // Edit store.

                $actions[] = $OUTPUT->action_link(

                    new url($baseurl, ['action' => 'editstore', 'plugin' => $storedetails['plugin']]),

                    get_string('editstore', 'cache')

                );

                // Delete store.

                $actions[] = $OUTPUT->action_link(

                    new url($baseurl, ['action' => 'deletestore']),

                    get_string('deletestore', 'cache')

                );

            }

            // Purge store.

            $actions[] = $OUTPUT->action_link(

                new url($baseurl, ['action' => 'purgestore', 'sesskey' => sesskey()]),

                get_string('purge', 'cache')

            );

        }

        return $actions;

    }

    /**

     * Returns all of the actions that can be performed on a plugin.

     *

     * @param string $name The name of the plugin

     * @param array $plugindetails information about this store, from the array returned by

     *      core_cache\administration_helper::get_store_plugin_summaries().

     * @return array of actions. Each action is an action_url.

     */

    public function get_store_plugin_actions(string $name, array $plugindetails): array {

        global $OUTPUT;

        $actions = [];

        if (has_capability('moodle/site:config', context_system::instance())) {

            if (!empty($plugindetails['canaddinstance'])) {

                $url = new url(

                    '/cache/admin.php',

                    ['action' => 'addstore', 'plugin' => $name]

                );

                $actions[] = $OUTPUT->action_link(

                    $url,

                    get_string('addinstance', 'cache')

                );

            }

        }

        return $actions;

    }

    /**

     * Returns a form that can be used to add a store instance.

     *

     * @param string $plugin The plugin to add an instance of

     * @return cachestore_addinstance_form

     * @throws coding_exception

     */

    public function get_add_store_form(string $plugin): cachestore_addinstance_form {

        global $CFG; // Needed for includes.

        $plugins = core_component::get_plugin_list('cachestore');

        if (!array_key_exists($plugin, $plugins)) {

            throw new coding_exception('Invalid cache plugin used when trying to create an edit form.');

        }

        $plugindir = $plugins[$plugin];

        $class = 'cachestore_addinstance_form';

        if (file_exists($plugindir . '/addinstanceform.php')) {

            require_once($plugindir . '/addinstanceform.php');

            if (class_exists('cachestore_' . $plugin . '_addinstance_form')) {

                $class = 'cachestore_' . $plugin . '_addinstance_form';

                if (!array_key_exists(cachestore_addinstance_form::class, class_parents($class))) {

                    throw new coding_exception('Cache plugin add instance forms must extend cachestore_addinstance_form');

                }

            }

        }

        $locks = $this->get_possible_locks_for_stores($plugindir, $plugin);

        $url = new url('/cache/admin.php', ['action' => 'addstore']);

        return new $class($url, ['plugin' => $plugin, 'store' => null, 'locks' => $locks]);

    }

    /**

     * Returns a form that can be used to edit a store instance.

     *

     * @param string $plugin

     * @param string $store

     * @return cachestore_addinstance_form

     * @throws coding_exception

     */

    public function get_edit_store_form(string $plugin, string $store): cachestore_addinstance_form {

        global $CFG; // Needed for includes.

        $plugins = core_component::get_plugin_list('cachestore');

        if (!array_key_exists($plugin, $plugins)) {

            throw new coding_exception('Invalid cache plugin used when trying to create an edit form.');

        }

        $factory = factory::instance();

        $config = $factory->create_config_instance();

        $stores = $config->get_all_stores();

        if (!array_key_exists($store, $stores)) {

            throw new coding_exception('Invalid store name given when trying to create an edit form.');

        }

        $plugindir = $plugins[$plugin];

        $class = 'cachestore_addinstance_form';

        if (file_exists($plugindir . '/addinstanceform.php')) {

            require_once($plugindir . '/addinstanceform.php');

            if (class_exists('cachestore_' . $plugin . '_addinstance_form')) {

                $class = 'cachestore_' . $plugin . '_addinstance_form';

                if (!array_key_exists(cachestore_addinstance_form::class, class_parents($class))) {

                    throw new coding_exception('Cache plugin add instance forms must extend cachestore_addinstance_form');

                }

            }

        }

        $locks = $this->get_possible_locks_for_stores($plugindir, $plugin);

        $url = new url('/cache/admin.php', ['action' => 'editstore', 'plugin' => $plugin, 'store' => $store]);

        $editform = new $class($url, ['plugin' => $plugin, 'store' => $store, 'locks' => $locks]);

        if (isset($stores[$store]['lock'])) {

            $editform->set_data(['lock' => $stores[$store]['lock']]);

        }

        // See if the cachestore is going to want to load data for the form.

        // If it has a customised add instance form then it is going to want to.

        $storeclass = 'cachestore_' . $plugin;

        $storedata = $stores[$store];

        if (

            array_key_exists('configuration', $storedata) &&

            array_key_exists(configurable_cache_interface::class, class_implements($storeclass))

        ) {

            $storeclass::config_set_edit_form_data($editform, $storedata['configuration']);

        }

        return $editform;

    }

    /**

     * Returns an array of suitable lock instances for use with this plugin, or false if the plugin handles locking itself.

     *

     * @param string $plugindir

     * @param string $plugin

     * @return array|false

     */

    protected function get_possible_locks_for_stores(string $plugindir, string $plugin) {

        global $CFG; // Needed for includes.

        $supportsnativelocking = false;

        if (file_exists($plugindir . '/lib.php')) {

            require_once($plugindir . '/lib.php');

            $pluginclass = 'cachestore_' . $plugin;

            if (class_exists($pluginclass)) {

                $supportsnativelocking = array_key_exists(lockable_cache_interface::class, class_implements($pluginclass));

            }

        }

        if (!$supportsnativelocking) {

            $config = config::instance();

            $locks = [];

            foreach ($config->get_locks() as $lock => $conf) {

                if (!empty($conf['default'])) {

                    $name = get_string($lock, 'cache');

                } else {

                    $name = $lock;

                }

                $locks[$lock] = $name;

            }

        } else {

            $locks = false;

        }

        return $locks;

    }

    /**

     * Processes the results of the add/edit instance form data for a plugin returning an array of config information suitable to

     * store in configuration.

     *

     * @param stdClass $data The mform data.

     * @return array

     * @throws coding_exception

     */

    public function get_store_configuration_from_data(stdClass $data): array {

        global $CFG;

        $file = $CFG->dirroot . '/cache/stores/' . $data->plugin . '/lib.php';

        if (!file_exists($file)) {

            throw new coding_exception('Invalid cache plugin provided. ' . $file);

        }

        require_once($file);

        $class = 'cachestore_' . $data->plugin;

        if (!class_exists($class)) {

            throw new coding_exception('Invalid cache plugin provided.');

        }

        if (array_key_exists(configurable_cache_interface::class, class_implements($class))) {

            return $class::config_get_configuration_array($data);

        }

        return [];

    }

    /**

     * Returns an array of lock plugins for which we can add an instance.

     *

     * Suitable for use within an mform select element.

     *

     * @return array

     */

    public function get_addable_lock_options(): array {

        $plugins = core_component::get_plugin_list_with_class('cachelock', '', 'lib.php');

        $options = [];

        $len = strlen('cachelock_');

        foreach ($plugins as $plugin => $class) {

            $method = "$class::can_add_instance";

            if (is_callable($method) && !call_user_func($method)) {

                // Can't add an instance of this plugin.

                continue;

            }

            $options[substr($plugin, $len)] = get_string('pluginname', $plugin);

        }

        return $options;

    }

    /**

     * Gets the form to use when adding a lock instance.

     *

     * @param string $plugin

     * @param array|null $lockplugin

     * @return cache_lock_form

     * @throws coding_exception

     */

    public function get_add_lock_form(string $plugin, ?array $lockplugin = null): cache_lock_form {

        global $CFG; // Needed for includes.

        $plugins = core_component::get_plugin_list('cachelock');

        if (!array_key_exists($plugin, $plugins)) {

            throw new coding_exception('Invalid cache lock plugin requested when trying to create a form.');

        }

        $plugindir = $plugins[$plugin];

        $class = cache_lock_form::class;

        $hasaddinstanceform = file_exists($plugindir . '/addinstanceform.php');

        $hasaddinstanceform = $hasaddinstanceform && in_array(configurable_cache_interface::class, class_implements($class));

        if ($hasaddinstanceform) {

            require_once($plugindir . '/addinstanceform.php');

            if (class_exists('cachelock_' . $plugin . '_addinstance_form')) {

                $class = 'cachelock_' . $plugin . '_addinstance_form';

                if (!is_a($class, cache_lock_form::class, true)) {

                    throw new coding_exception('Cache lock plugin add instance forms must extend cache_lock_form');

                }

            }

        }

        return new $class(null, ['lock' => $plugin]);

    }

    /**

     * Gets configuration data from a new lock instance form.

     *

     * @param string $plugin

     * @param stdClass $data

     * @return array

     * @throws coding_exception

     */

    public function get_lock_configuration_from_data(string $plugin, stdClass $data): array {

        global $CFG;

        $file = $CFG->dirroot . '/cache/locks/' . $plugin . '/lib.php';

        if (!file_exists($file)) {

            throw new coding_exception('Invalid cache plugin provided. ' . $file);

        }

        require_once($file);

        $class = 'cachelock_' . $plugin;

        if (!class_exists($class)) {

            throw new coding_exception('Invalid cache plugin provided.');

        }

        if (array_key_exists(configurable_cache_interface::class, class_implements($class))) {

            return $class::config_get_configuration_array($data);

        }

        return [];

    }

    /**

     * Handles the page actions, based on the parameter.

     *

     * @param string $action the action to handle.

     * @param array $forminfo an empty array to be overridden and set.

     * @return array the empty or overridden forminfo array.

     */

    public function perform_cache_actions(string $action, array $forminfo): array {

        switch ($action) {

            case 'rescandefinitions': // Rescan definitions.

                $this->action_rescan_definition();

                break;

            case 'addstore': // Add the requested store.

                $forminfo = $this->action_addstore();

                break;

            case 'editstore': // Edit the requested store.

                $forminfo = $this->action_editstore();

                break;

            case 'deletestore': // Delete a given store.

                $this->action_deletestore($action);

                break;

            case 'editdefinitionmapping': // Edit definition mappings.

                $forminfo = $this->action_editdefinitionmapping();

                break;

            case 'editdefinitionsharing': // Edit definition sharing.

                $forminfo = $this->action_editdefinitionsharing();

                break;

            case 'editmodemappings': // Edit default mode mappings.

                $forminfo = $this->action_editmodemappings();

                break;

            case 'purgedefinition': // Purge a specific definition.

                $this->action_purgedefinition();

                break;

            case 'purgestore':

            case 'purge': // Purge a store cache.

                $this->action_purge();

                break;

            case 'newlockinstance':

                $forminfo = $this->action_newlockinstance();

                break;

            case 'deletelock':

                // Deletes a lock instance.

                $this->action_deletelock($action);

                break;

        }

        return $forminfo;

    }

    /**

     * Performs the rescan definition action.

     *

     * @return void

     */

    public function action_rescan_definition() {

        global $PAGE;

        require_sesskey();

        config_writer::update_definitions();

        redirect($PAGE->url);

    }

    /**

     * Performs the add store action.

     *

     * @return array an array of the form to display to the user, and the page title.

     */

    public function action_addstore(): array {

        global $PAGE;

        $storepluginsummaries = $this->get_store_plugin_summaries();

        $plugin = required_param('plugin', PARAM_PLUGIN);

        if (!$storepluginsummaries[$plugin]['canaddinstance']) {

            throw new moodle_exception('ex_unmetstorerequirements', 'cache');

        }

        $mform = $this->get_add_store_form($plugin);

        $title = get_string('addstore', 'cache', $storepluginsummaries[$plugin]['name']);

        if ($mform->is_cancelled()) {

            redirect($PAGE->url);

        } else if ($data = $mform->get_data()) {

            $config = $this->get_store_configuration_from_data($data);

            $writer = config_writer::instance();

            unset($config['lock']);

            foreach ($writer->get_locks() as $lock => $lockconfig) {

                if ($lock == $data->lock) {

                    $config['lock'] = $data->lock;

                }

            }

            $writer->add_store_instance($data->name, $data->plugin, $config);

            redirect($PAGE->url, get_string('addstoresuccess', 'cache', $storepluginsummaries[$plugin]['name']), 5);

        }

        $PAGE->navbar->add(get_string('addstore', 'cache', 'cache'), $PAGE->url);

        return ['form' => $mform, 'title' => $title];

    }

    /**

     * Performs the edit store action.

     *

     * @return array an array of the form to display, and the page title.

     */

    public function action_editstore(): array {

        global $PAGE;

        $storepluginsummaries = $this->get_store_plugin_summaries();

        $plugin = required_param('plugin', PARAM_PLUGIN);

        $store = required_param('store', PARAM_TEXT);

        $mform = $this->get_edit_store_form($plugin, $store);

        $title = get_string('addstore', 'cache', $storepluginsummaries[$plugin]['name']);

        if ($mform->is_cancelled()) {

            redirect($PAGE->url);

        } else if ($data = $mform->get_data()) {

            $config = $this->get_store_configuration_from_data($data);

            $writer = config_writer::instance();

            unset($config['lock']);

            foreach ($writer->get_locks() as $lock => $lockconfig) {

                if ($lock == $data->lock) {

                    $config['lock'] = $data->lock;

                }

            }

            $writer->edit_store_instance($data->name, $data->plugin, $config);

            redirect($PAGE->url, get_string('editstoresuccess', 'cache', $storepluginsummaries[$plugin]['name']), 5);

        }

        return ['form' => $mform, 'title' => $title];

    }

    /**

     * Performs the deletestore action.

     *

     * @param string $action the action calling to this function.

     */

    public function action_deletestore(string $action): void {

        global $OUTPUT, $PAGE, $SITE;

        $notifysuccess = true;

        $storeinstancesummaries = $this->get_store_instance_summaries();

        $store = required_param('store', PARAM_TEXT);

        $confirm = optional_param('confirm', false, PARAM_BOOL);

        if (!array_key_exists($store, $storeinstancesummaries)) {

            $notifysuccess = false;

            $notification = get_string('invalidstore', 'cache');

        } else if ($storeinstancesummaries[$store]['mappings'] > 0) {

            $notifysuccess = false;

            $notification = get_string('deletestorehasmappings', 'cache');

        }

        if ($notifysuccess) {

            if (!$confirm) {

                $title = get_string('confirmstoredeletion', 'cache');

                $params = ['store' => $store, 'confirm' => 1, 'action' => $action, 'sesskey' => sesskey()];

                $url = new url($PAGE->url, $params);

                $button = new single_button($url, get_string('deletestore', 'cache'));

                $PAGE->set_title($title);

                $PAGE->set_heading($SITE->fullname);

                echo $OUTPUT->header();

                echo $OUTPUT->heading($title);

                $confirmation = get_string('deletestoreconfirmation', 'cache', $storeinstancesummaries[$store]['name']);

                echo $OUTPUT->confirm($confirmation, $button, $PAGE->url);

                echo $OUTPUT->footer();

                exit;

            } else {

                require_sesskey();

                $writer = config_writer::instance();

                $writer->delete_store_instance($store);

                redirect($PAGE->url, get_string('deletestoresuccess', 'cache'), 5);

            }

        } else {

            redirect($PAGE->url, $notification, null, notification::NOTIFY_ERROR);

        }

    }

    /**

     * Performs the edit definition mapping action.

     *

     * @return array an array of the form to display, and the page title.

     * @throws cache_exception

     */

    public function action_editdefinitionmapping(): array {

        global $PAGE;

        $definitionsummaries = $this->get_definition_summaries();

        $definition = required_param('definition', PARAM_SAFEPATH);

        if (!array_key_exists($definition, $definitionsummaries)) {

            throw new cache_exception('Invalid cache definition requested');

        }

        $title = get_string('editdefinitionmappings', 'cache', $definition);

        $mform = new cache_definition_mappings_form($PAGE->url, ['definition' => $definition]);

        if ($mform->is_cancelled()) {

            redirect($PAGE->url);

        } else if ($data = $mform->get_data()) {

            $writer = config_writer::instance();

            $mappings = [];

            foreach ($data->mappings as $mapping) {

                if (!empty($mapping)) {

                    $mappings[] = $mapping;

                }

            }

            $writer->set_definition_mappings($definition, $mappings);

            redirect($PAGE->url);

        }

        $PAGE->navbar->add(get_string('updatedefinitionmapping', 'cache'), $PAGE->url);

        return ['form' => $mform, 'title' => $title];

    }

    /**

     * Performs the edit definition sharing action.

     *

     * @return array an array of the edit definition sharing form, and the page title.

     */

    public function action_editdefinitionsharing(): array {

        global $PAGE;

        $definitionsummaries = $this->get_definition_summaries();

        $definition = required_param('definition', PARAM_SAFEPATH);

        if (!array_key_exists($definition, $definitionsummaries)) {

            throw new cache_exception('Invalid cache definition requested');

        }

        $title = get_string('editdefinitionsharing', 'cache', $definition);

        $sharingoptions = $definitionsummaries[$definition]['sharingoptions'];

        $customdata = ['definition' => $definition, 'sharingoptions' => $sharingoptions];

        $mform = new cache_definition_sharing_form($PAGE->url, $customdata);

        $mform->set_data([

            'sharing' => $definitionsummaries[$definition]['selectedsharingoption'],

            'userinputsharingkey' => $definitionsummaries[$definition]['userinputsharingkey'],

        ]);

        if ($mform->is_cancelled()) {

            redirect($PAGE->url);

        } else if ($data = $mform->get_data()) {

            $component = $definitionsummaries[$definition]['component'];

            $area = $definitionsummaries[$definition]['area'];

            // Purge the stores removing stale data before we alter the sharing option.

            cache_helper::purge_stores_used_by_definition($component, $area);

            $writer = config_writer::instance();

            $sharing = array_sum(array_keys($data->sharing));

            $userinputsharingkey = $data->userinputsharingkey;

            $writer->set_definition_sharing($definition, $sharing, $userinputsharingkey);

            redirect($PAGE->url);

        }

        $PAGE->navbar->add(get_string('updatedefinitionsharing', 'cache'), $PAGE->url);

        return ['form' => $mform, 'title' => $title];

    }

    /**

     * Performs the edit mode mappings action.

     *

     * @return array an array of the edit mode mappings form.

     */

    public function action_editmodemappings(): array {

        global $PAGE;

        $storeinstancesummaries = $this->get_store_instance_summaries();

        $defaultmodestores = $this->get_default_mode_stores();

        $mform = new cache_mode_mappings_form(null, $storeinstancesummaries);

        $mform->set_data([

            'mode_' . store::MODE_APPLICATION => key($defaultmodestores[store::MODE_APPLICATION]),

            'mode_' . store::MODE_SESSION => key($defaultmodestores[store::MODE_SESSION]),

            'mode_' . store::MODE_REQUEST => key($defaultmodestores[store::MODE_REQUEST]),

        ]);

        if ($mform->is_cancelled()) {

            redirect($PAGE->url);

        } else if ($data = $mform->get_data()) {

            $mappings = [

                store::MODE_APPLICATION => [$data->{'mode_' . store::MODE_APPLICATION}],

                store::MODE_SESSION => [$data->{'mode_' . store::MODE_SESSION}],

                store::MODE_REQUEST => [$data->{'mode_' . store::MODE_REQUEST}],

            ];

            $writer = config_writer::instance();

            $writer->set_mode_mappings($mappings);

            redirect($PAGE->url);

        }

        return ['form' => $mform];

    }

    /**

     * Performs the purge definition action.

     *

     * @return void

     */

    public function action_purgedefinition() {

        global $PAGE;

        require_sesskey();

        $id = required_param('definition', PARAM_SAFEPATH);

        [$component, $area] = explode('/', $id, 2);

        $factory = factory::instance();

        $definition = $factory->create_definition($component, $area);

        if ($definition->has_required_identifiers()) {

            // We will have to purge the stores used by this definition.

            cache_helper::purge_stores_used_by_definition($component, $area);

        } else {

            // Alrighty we can purge just the data belonging to this definition.

            cache_helper::purge_by_definition($component, $area);

        }

        $message = get_string('purgexdefinitionsuccess', 'cache', [

                    'name' => $definition->get_name(),

                    'component' => $component,

                    'area' => $area,

                ]);

        $purgeagainlink = html_writer::link(

            new url('/cache/admin.php', [

                'action' => 'purgedefinition', 'sesskey' => sesskey(), 'definition' => $id, ]),

            get_string('purgeagain', 'cache')

        );

        redirect($PAGE->url, $message . ' ' . $purgeagainlink, 5);

    }

    /**

     * Performs the purge action.

     *

     * @return void

     */

    public function action_purge() {

        global $PAGE;

        require_sesskey();

        $store = required_param('store', PARAM_TEXT);

        cache_helper::purge_store($store);

        $message = get_string('purgexstoresuccess', 'cache', ['store' => $store]);

        $purgeagainlink = html_writer::link(

            new url('/cache/admin.php', [

                'action' => 'purgestore', 'sesskey' => sesskey(), 'store' => $store, ]),

            get_string('purgeagain', 'cache')

        );

        redirect($PAGE->url, $message . ' ' . $purgeagainlink, 5);

    }

    /**

     * Performs the new lock instance action.

     *

     * @return array An array containing the new lock instance form.

     */

    public function action_newlockinstance(): array {

        global $PAGE;

        // Adds a new lock instance.

        $lock = required_param('lock', PARAM_ALPHANUMEXT);

        $mform = $this->get_add_lock_form($lock);

        if ($mform->is_cancelled()) {

            redirect($PAGE->url);

        } else if ($data = $mform->get_data()) {

            $factory = factory::instance();

            $config = $factory->create_config_instance(true);

            $name = $data->name;

            $data = $this->get_lock_configuration_from_data($lock, $data);

            $config->add_lock_instance($name, $lock, $data);

            redirect($PAGE->url, get_string('addlocksuccess', 'cache', $name), 5);

        }

        return ['form' => $mform];

    }

    /**

     * Performs the delete lock action.

     *

     * @param string $action the action calling this function.

     */

    public function action_deletelock(string $action): void {

        global $OUTPUT, $PAGE, $SITE;

        $notifysuccess = true;

        $locks = $this->get_lock_summaries();

        $lock = required_param('lock', PARAM_ALPHANUMEXT);

        $confirm = optional_param('confirm', false, PARAM_BOOL);

        if (!array_key_exists($lock, $locks)) {

            $notifysuccess = false;

            $notification = get_string('invalidlock', 'cache');

        } else if ($locks[$lock]['uses'] > 0) {

            $notifysuccess = false;

            $notification = get_string('deletelockhasuses', 'cache');

        }

        if ($notifysuccess) {

            if (!$confirm) {

                $title = get_string('confirmlockdeletion', 'cache');

                $params = ['lock' => $lock, 'confirm' => 1, 'action' => $action, 'sesskey' => sesskey()];

                $url = new url($PAGE->url, $params);

                $button = new single_button($url, get_string('deletelock', 'cache'));

                $PAGE->set_title($title);

                $PAGE->set_heading($SITE->fullname);

                echo $OUTPUT->header();

                echo $OUTPUT->heading($title);

                $confirmation = get_string('deletelockconfirmation', 'cache', $lock);

                echo $OUTPUT->confirm($confirmation, $button, $PAGE->url);

                echo $OUTPUT->footer();

                exit;

            } else {

                require_sesskey();

                $writer = config_writer::instance();

                $writer->delete_lock_instance($lock);

                redirect($PAGE->url, get_string('deletelocksuccess', 'cache'), 5);

            }

        } else {

            redirect($PAGE->url, $notification, null, notification::NOTIFY_ERROR);

        }

    }

    /**

     * Outputs the main admin page by generating it through the renderer.

     *

     * @param \core_cache\output\renderer $renderer the renderer to use to generate the page.

     * @return string the HTML for the admin page.

     */

    public function generate_admin_page(\core_cache\output\renderer $renderer): string {

        $context = context_system::instance();

        $html = '';

        $storepluginsummaries = $this->get_store_plugin_summaries();

        $storeinstancesummaries = $this->get_store_instance_summaries();

        $definitionsummaries = $this->get_definition_summaries();

        $defaultmodestores = $this->get_default_mode_stores();

        $locks = $this->get_lock_summaries();

        $html .= $renderer->store_plugin_summaries($storepluginsummaries);

        $html .= $renderer->store_instance_summariers($storeinstancesummaries, $storepluginsummaries);

        $html .= $renderer->definition_summaries($definitionsummaries, $context);

        $html .= $renderer->lock_summaries($locks);

        $html .= $renderer->additional_lock_actions();

        $applicationstore = join(', ', $defaultmodestores[store::MODE_APPLICATION]);

        $sessionstore = join(', ', $defaultmodestores[store::MODE_SESSION]);

        $requeststore = join(', ', $defaultmodestores[store::MODE_REQUEST]);

        $editurl = new url('/cache/admin.php', ['action' => 'editmodemappings']);

        $html .= $renderer->mode_mappings($applicationstore, $sessionstore, $requeststore, $editurl);

        return $html;

    }

    /**

     * Gets usage information about the whole cache system.

     *

     * This is a slow function and should only be used on an admin information page.

     *

     * The returned array lists all cache definitions with fields 'cacheid' and 'stores'. For

     * each store, the following fields are available:

     *

     * - name (store name)

     * - class (e.g. cachestore_redis)

     * - supported (true if we have any information)

     * - items (number of items stored)

     * - mean (mean size of item)

     * - sd (standard deviation for item sizes)

     * - margin (margin of error for mean at 95% confidence)

     * - storetotal (total usage for store if known, otherwise null)

     *

     * The storetotal field will be the same for every cache that uses the same store.

     *

     * @param int $samplekeys Number of keys to sample when checking size of large caches

     * @return array Details of cache usage

     */

    public function get_usage(int $samplekeys): array {

        $results = [];

        $factory = factory::instance();

        // Check the caches we already have an instance of, so we don't make another one...

        $got = $factory->get_caches_in_use();

        $gotid = [];

        foreach ($got as $longid => $unused) {

            // The IDs here can be of the form cacheid/morestuff if there are parameters in the

            // cache. Any entry for a cacheid is good enough to consider that we don't need to make

            // another entry ourselves, so we remove the extra bits and track the basic cache id.

            $gotid[preg_replace('~^([^/]+/[^/]+)/.*$~', '$1', $longid)] = true;

        }

        $storetotals = [];

        $config = $factory->create_config_instance();

        foreach ($config->get_definitions() as $configdetails) {

            if (!array_key_exists($configdetails['component'] . '/' .  $configdetails['area'], $gotid)) {

                // Where possible (if it doesn't need identifiers), make an instance of the cache, otherwise

                // we can't get the store instances for it (and it won't show up in the list).

                if (empty($configdetails['requireidentifiers'])) {

                    cache::make($configdetails['component'], $configdetails['area']);

                }

            }

            $definition = $factory->create_definition($configdetails['component'], $configdetails['area']);

            $stores = $factory->get_store_instances_in_use($definition);

            // Create object for results about this cache definition.

            $currentresult = (object)['cacheid' => $definition->get_id(), 'stores' => []];

            $results[$currentresult->cacheid] = $currentresult;

            /** @var store $store */

            foreach ($stores as $store) {

                // Skip static cache.

                if ($store instanceof \cachestore_static) {

                    continue;

                }

                // Get cache size details from store.

                $currentstore = $store->cache_size_details($samplekeys);

                // Add in basic information about store.

                $currentstore->name = $store->my_name();

                $currentstore->class = get_class($store);

                // Add in store total.

                if (!array_key_exists($currentstore->name, $storetotals)) {

                    $storetotals[$currentstore->name] = $store->store_total_size();

                }

                $currentstore->storetotal = $storetotals[$currentstore->name];

                $currentresult->stores[] = $currentstore;

            }

        }

        ksort($results);

        return $results;

    }

}