mirror of
https://github.com/moodle/moodle.git
synced 2025-01-18 14:03:52 +01:00
b874e20b55
Use the full result from download_file_content within the component installer to ensure that spurious debugging is not emitted during operation. Handle validation of the returned data consistently.
841 lines
30 KiB
PHP
841 lines
30 KiB
PHP
<?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/>.
|
|
|
|
/**
|
|
* This library includes all the necessary stuff to use the one-click
|
|
* download and install feature of Moodle, used to keep updated some
|
|
* items like languages, pear, enviroment... i.e, components.
|
|
*
|
|
* It has been developed harcoding some important limits that are
|
|
* explained below:
|
|
* - It only can check, download and install items under moodledata.
|
|
* - Every downloadeable item must be one zip file.
|
|
* - The zip file root content must be 1 directory, i.e, everything
|
|
* is stored under 1 directory.
|
|
* - Zip file name and root directory must have the same name (but
|
|
* the .zip extension, of course).
|
|
* - Every .zip file must be defined in one .md5 file that will be
|
|
* stored in the same remote directory than the .zip file.
|
|
* - The name of such .md5 file is free, although it's recommended
|
|
* to use the same name than the .zip (that's the default
|
|
* assumption if no specified).
|
|
* - Every remote .md5 file will be a comma separated (CVS) file where each
|
|
* line will follow this format:
|
|
* - Field 1: name of the zip file (without extension). Mandatory.
|
|
* - Field 2: md5 of the zip file. Mandatory.
|
|
* - Field 3: whatever you want (or need). Optional.
|
|
* -Every local .md5 file will:
|
|
* - Have the zip file name (without the extension) plus -md5
|
|
* - Will reside inside the expanded zip file dir
|
|
* - Will contain the md5 od the latest installed component
|
|
* With all these details present, the process will perform this tasks:
|
|
* - Perform security checks. Only admins are allowed to use this for now.
|
|
* - Read the .md5 file from source (1).
|
|
* - Extract the correct line for the .zip being requested.
|
|
* - Compare it with the local .md5 file (2).
|
|
* - If different:
|
|
* - Download the newer .zip file from source.
|
|
* - Calculate its md5 (3).
|
|
* - Compare (1) and (3).
|
|
* - If equal:
|
|
* - Delete old directory.
|
|
* - Uunzip the newer .zip file.
|
|
* - Create the new local .md5 file.
|
|
* - Delete the .zip file.
|
|
* - If different:
|
|
* - ERROR. Old package won't be modified. We shouldn't
|
|
* reach here ever.
|
|
* - If component download is not possible, a message text about how to do
|
|
* the process manually (remotedownloaderror) must be displayed to explain it.
|
|
*
|
|
* General Usage:
|
|
*
|
|
* To install one component:
|
|
* <code>
|
|
* require_once($CFG->libdir.'/componentlib.class.php');
|
|
* if ($cd = new component_installer('https://download.moodle.org', 'langpack/2.0',
|
|
* 'es.zip', 'languages.md5', 'lang')) {
|
|
* $status = $cd->install(); //returns COMPONENT_(ERROR | UPTODATE | INSTALLED)
|
|
* switch ($status) {
|
|
* case COMPONENT_ERROR:
|
|
* if ($cd->get_error() == 'remotedownloaderror') {
|
|
* $a = new stdClass();
|
|
* $a->url = 'https://download.moodle.org/langpack/2.0/es.zip';
|
|
* $a->dest= $CFG->dataroot.'/lang';
|
|
* throw new \moodle_exception($cd->get_error(), 'error', '', $a);
|
|
* } else {
|
|
* throw new \moodle_exception($cd->get_error(), 'error');
|
|
* }
|
|
* break;
|
|
* case COMPONENT_UPTODATE:
|
|
* //Print error string or whatever you want to do
|
|
* break;
|
|
* case COMPONENT_INSTALLED:
|
|
* //Print/do whatever you want
|
|
* break;
|
|
* default:
|
|
* //We shouldn't reach this point
|
|
* }
|
|
* } else {
|
|
* //We shouldn't reach this point
|
|
* }
|
|
* </code>
|
|
*
|
|
* To switch of component (maintaining the rest of settings):
|
|
* <code>
|
|
* $status = $cd->change_zip_file('en.zip'); //returns boolean false on error
|
|
* </code>
|
|
*
|
|
* To retrieve all the components in one remote md5 file
|
|
* <code>
|
|
* $components = $cd->get_all_components_md5(); //returns boolean false on error, array instead
|
|
* </code>
|
|
*
|
|
* To check if current component needs to be updated
|
|
* <code>
|
|
* $status = $cd->need_upgrade(); //returns COMPONENT_(ERROR | UPTODATE | NEEDUPDATE)
|
|
* </code>
|
|
*
|
|
* To get the 3rd field of the md5 file (optional)
|
|
* <code>
|
|
* $field = $cd->get_extra_md5_field(); //returns string (empty if not exists)
|
|
* </code>
|
|
*
|
|
* For all the error situations the $cd->get_error() method should return always the key of the
|
|
* error to be retrieved by one standard get_string() call against the error.php lang file.
|
|
*
|
|
* That's all!
|
|
*
|
|
* @package core
|
|
* @copyright (C) 2001-3001 Eloy Lafuente (stronk7) {@link http://contiento.com}
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
|
|
defined('MOODLE_INTERNAL') || die();
|
|
|
|
/**
|
|
* @global object $CFG
|
|
* @name $CFG
|
|
*/
|
|
global $CFG;
|
|
require_once($CFG->libdir.'/filelib.php');
|
|
|
|
// Some needed constants
|
|
define('COMPONENT_ERROR', 0);
|
|
define('COMPONENT_UPTODATE', 1);
|
|
define('COMPONENT_NEEDUPDATE', 2);
|
|
define('COMPONENT_INSTALLED', 3);
|
|
|
|
/**
|
|
* This class is used to check, download and install items from
|
|
* download.moodle.org to the moodledata directory.
|
|
*
|
|
* It always return true/false in all their public methods to say if
|
|
* execution has ended succesfuly or not. If there is any problem
|
|
* its getError() method can be called, returning one error string
|
|
* to be used with the standard get/print_string() functions.
|
|
*
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
* @package moodlecore
|
|
*/
|
|
class component_installer {
|
|
/**
|
|
* @var string
|
|
*/
|
|
var $sourcebase; /// Full http URL, base for downloadable items
|
|
var $zippath; /// Relative path (from sourcebase) where the
|
|
/// downloadeable item resides.
|
|
var $zipfilename; /// Name of the .zip file to be downloaded
|
|
var $md5filename; /// Name of the .md5 file to be read
|
|
var $componentname;/// Name of the component. Must be the zip name without
|
|
/// the extension. And it defines a lot of things:
|
|
/// the md5 line to search for, the default m5 file name
|
|
/// and the name of the root dir stored inside the zip file
|
|
var $destpath; /// Relative path (from moodledata) where the .zip
|
|
/// file will be expanded.
|
|
var $errorstring; /// Latest error produced. It will contain one lang string key.
|
|
var $extramd5info; /// Contents of the optional third field in the .md5 file.
|
|
var $requisitesok; /// Flag to see if requisites check has been passed ok.
|
|
/**
|
|
* @var array
|
|
*/
|
|
var $cachedmd5components; /// Array of cached components to avoid to
|
|
/// download the same md5 file more than once per request.
|
|
|
|
/**
|
|
* Standard constructor of the class. It will initialize all attributes.
|
|
* without performing any check at all.
|
|
*
|
|
* @param string $sourcebase Full http URL, base for downloadeable items
|
|
* @param string $zippath Relative path (from sourcebase) where the
|
|
* downloadeable item resides
|
|
* @param string $zipfilename Name of the .zip file to be downloaded
|
|
* @param string $md5filename Name of the .md5 file to be read (default '' = same
|
|
* than zipfilename)
|
|
* @param string $destpath Relative path (from moodledata) where the .zip file will
|
|
* be expanded (default='' = moodledataitself)
|
|
* @return object
|
|
*/
|
|
public function __construct($sourcebase, $zippath, $zipfilename, $md5filename='', $destpath='') {
|
|
|
|
$this->sourcebase = $sourcebase;
|
|
$this->zippath = $zippath;
|
|
$this->zipfilename = $zipfilename;
|
|
$this->md5filename = $md5filename;
|
|
$this->componentname= '';
|
|
$this->destpath = $destpath;
|
|
$this->errorstring = '';
|
|
$this->extramd5info = '';
|
|
$this->requisitesok = false;
|
|
$this->cachedmd5components = array();
|
|
|
|
$this->check_requisites();
|
|
}
|
|
|
|
/**
|
|
* Old syntax of class constructor. Deprecated in PHP7.
|
|
*
|
|
* @deprecated since Moodle 3.1
|
|
*/
|
|
public function component_installer($sourcebase, $zippath, $zipfilename, $md5filename='', $destpath='') {
|
|
debugging('Use of class name as constructor is deprecated', DEBUG_DEVELOPER);
|
|
self::__construct($sourcebase, $zippath, $zipfilename, $md5filename, $destpath);
|
|
}
|
|
|
|
/**
|
|
* This function will check if everything is properly set to begin
|
|
* one installation. Also, it will check for required settings
|
|
* and will fill everything as needed.
|
|
*
|
|
* @global object
|
|
* @return boolean true/false (plus detailed error in errorstring)
|
|
*/
|
|
function check_requisites() {
|
|
global $CFG;
|
|
|
|
$this->requisitesok = false;
|
|
|
|
/// Check that everything we need is present
|
|
if (empty($this->sourcebase) || empty($this->zipfilename)) {
|
|
$this->errorstring='missingrequiredfield';
|
|
return false;
|
|
}
|
|
/// Check for correct sourcebase (this will be out in the future)
|
|
if (!PHPUNIT_TEST and $this->sourcebase != 'https://download.moodle.org') {
|
|
$this->errorstring='wrongsourcebase';
|
|
return false;
|
|
}
|
|
/// Check the zip file is a correct one (by extension)
|
|
if (stripos($this->zipfilename, '.zip') === false) {
|
|
$this->errorstring='wrongzipfilename';
|
|
return false;
|
|
}
|
|
/// Check that exists under dataroot
|
|
if (!empty($this->destpath)) {
|
|
if (!file_exists($CFG->dataroot.'/'.$this->destpath)) {
|
|
$this->errorstring='wrongdestpath';
|
|
return false;
|
|
}
|
|
}
|
|
/// Calculate the componentname
|
|
$pos = stripos($this->zipfilename, '.zip');
|
|
$this->componentname = substr($this->zipfilename, 0, $pos);
|
|
/// Calculate md5filename if it's empty
|
|
if (empty($this->md5filename)) {
|
|
$this->md5filename = $this->componentname.'.md5';
|
|
}
|
|
/// Set the requisites passed flag
|
|
$this->requisitesok = true;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* This function will perform the full installation if needed, i.e.
|
|
* compare md5 values, download, unzip, install and regenerate
|
|
* local md5 file
|
|
*
|
|
* @uses COMPONENT_ERROR
|
|
* @uses COMPONENT_UPTODATE
|
|
* @uses COMPONENT_ERROR
|
|
* @uses COMPONENT_INSTALLED
|
|
* @return int COMPONENT_(ERROR | UPTODATE | INSTALLED)
|
|
*/
|
|
public function install() {
|
|
global $CFG;
|
|
|
|
/// Check requisites are passed
|
|
if (!$this->requisitesok) {
|
|
return COMPONENT_ERROR;
|
|
}
|
|
/// Confirm we need upgrade
|
|
if ($this->need_upgrade() === COMPONENT_ERROR) {
|
|
return COMPONENT_ERROR;
|
|
} else if ($this->need_upgrade() === COMPONENT_UPTODATE) {
|
|
$this->errorstring='componentisuptodate';
|
|
return COMPONENT_UPTODATE;
|
|
}
|
|
/// Create temp directory if necesary
|
|
if (!make_temp_directory('', false)) {
|
|
$this->errorstring='cannotcreatetempdir';
|
|
return COMPONENT_ERROR;
|
|
}
|
|
/// Download zip file and save it to temp
|
|
if ($this->zippath) {
|
|
$source = $this->sourcebase.'/'.$this->zippath.'/'.$this->zipfilename;
|
|
} else {
|
|
$source = $this->sourcebase.'/'.$this->zipfilename;
|
|
}
|
|
|
|
$zipfile= $CFG->tempdir.'/'.$this->zipfilename;
|
|
|
|
$contents = download_file_content($source, null, null, true);
|
|
if ($contents->results && (int) $contents->status === 200) {
|
|
if ($file = fopen($zipfile, 'w')) {
|
|
if (!fwrite($file, $contents->results)) {
|
|
fclose($file);
|
|
$this->errorstring='cannotsavezipfile';
|
|
return COMPONENT_ERROR;
|
|
}
|
|
} else {
|
|
$this->errorstring='cannotsavezipfile';
|
|
return COMPONENT_ERROR;
|
|
}
|
|
fclose($file);
|
|
} else {
|
|
$this->errorstring='cannotdownloadzipfile';
|
|
return COMPONENT_ERROR;
|
|
}
|
|
/// Calculate its md5
|
|
$new_md5 = md5($contents->results);
|
|
/// Compare it with the remote md5 to check if we have the correct zip file
|
|
if (!$remote_md5 = $this->get_component_md5()) {
|
|
return COMPONENT_ERROR;
|
|
}
|
|
if ($new_md5 != $remote_md5) {
|
|
$this->errorstring='downloadedfilecheckfailed';
|
|
return COMPONENT_ERROR;
|
|
}
|
|
|
|
// Move current revision to a safe place.
|
|
$destinationdir = $CFG->dataroot . '/' . $this->destpath;
|
|
$destinationcomponent = $destinationdir . '/' . $this->componentname;
|
|
$destinationcomponentold = $destinationcomponent . '_old';
|
|
@remove_dir($destinationcomponentold); // Deleting a possible old version.
|
|
|
|
// Moving to a safe place.
|
|
@rename($destinationcomponent, $destinationcomponentold);
|
|
|
|
// Unzip new version.
|
|
$packer = get_file_packer('application/zip');
|
|
$unzipsuccess = $packer->extract_to_pathname($zipfile, $destinationdir, null, null, true);
|
|
if (!$unzipsuccess) {
|
|
@remove_dir($destinationcomponent);
|
|
@rename($destinationcomponentold, $destinationcomponent);
|
|
$this->errorstring = 'cannotunzipfile';
|
|
return COMPONENT_ERROR;
|
|
}
|
|
|
|
// Delete old component version.
|
|
@remove_dir($destinationcomponentold);
|
|
|
|
// Create local md5.
|
|
if ($file = fopen($destinationcomponent.'/'.$this->componentname.'.md5', 'w')) {
|
|
if (!fwrite($file, $new_md5)) {
|
|
fclose($file);
|
|
$this->errorstring='cannotsavemd5file';
|
|
return COMPONENT_ERROR;
|
|
}
|
|
} else {
|
|
$this->errorstring='cannotsavemd5file';
|
|
return COMPONENT_ERROR;
|
|
}
|
|
fclose($file);
|
|
/// Delete temp zip file
|
|
@unlink($zipfile);
|
|
|
|
return COMPONENT_INSTALLED;
|
|
}
|
|
|
|
/**
|
|
* This function will detect if remote component needs to be installed
|
|
* because it's different from the local one
|
|
*
|
|
* @uses COMPONENT_ERROR
|
|
* @uses COMPONENT_UPTODATE
|
|
* @uses COMPONENT_NEEDUPDATE
|
|
* @return int COMPONENT_(ERROR | UPTODATE | NEEDUPDATE)
|
|
*/
|
|
function need_upgrade() {
|
|
|
|
/// Check requisites are passed
|
|
if (!$this->requisitesok) {
|
|
return COMPONENT_ERROR;
|
|
}
|
|
/// Get local md5
|
|
$local_md5 = $this->get_local_md5();
|
|
/// Get remote md5
|
|
if (!$remote_md5 = $this->get_component_md5()) {
|
|
return COMPONENT_ERROR;
|
|
}
|
|
/// Return result
|
|
if ($local_md5 == $remote_md5) {
|
|
return COMPONENT_UPTODATE;
|
|
} else {
|
|
return COMPONENT_NEEDUPDATE;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This function will change the zip file to install on the fly
|
|
* to allow the class to process different components of the
|
|
* same md5 file without intantiating more objects.
|
|
*
|
|
* @param string $newzipfilename New zip filename to process
|
|
* @return boolean true/false
|
|
*/
|
|
function change_zip_file($newzipfilename) {
|
|
|
|
$this->zipfilename = $newzipfilename;
|
|
return $this->check_requisites();
|
|
}
|
|
|
|
/**
|
|
* This function will get the local md5 value of the installed
|
|
* component.
|
|
*
|
|
* @global object
|
|
* @return bool|string md5 of the local component (false on error)
|
|
*/
|
|
function get_local_md5() {
|
|
global $CFG;
|
|
|
|
/// Check requisites are passed
|
|
if (!$this->requisitesok) {
|
|
return false;
|
|
}
|
|
|
|
$return_value = 'needtobeinstalled'; /// Fake value to force new installation
|
|
|
|
/// Calculate source to read
|
|
$source = $CFG->dataroot.'/'.$this->destpath.'/'.$this->componentname.'/'.$this->componentname.'.md5';
|
|
/// Read md5 value stored (if exists)
|
|
if (file_exists($source)) {
|
|
if ($temp = file_get_contents($source)) {
|
|
$return_value = $temp;
|
|
}
|
|
}
|
|
return $return_value;
|
|
}
|
|
|
|
/**
|
|
* This function will download the specified md5 file, looking for the
|
|
* current componentname, returning its md5 field and storing extramd5info
|
|
* if present. Also it caches results to cachedmd5components for better
|
|
* performance in the same request.
|
|
*
|
|
* @return mixed md5 present in server (or false if error)
|
|
*/
|
|
function get_component_md5() {
|
|
|
|
/// Check requisites are passed
|
|
if (!$this->requisitesok) {
|
|
return false;
|
|
}
|
|
/// Get all components of md5 file
|
|
if (!$comp_arr = $this->get_all_components_md5()) {
|
|
if (empty($this->errorstring)) {
|
|
$this->errorstring='cannotdownloadcomponents';
|
|
}
|
|
return false;
|
|
}
|
|
/// Search for the componentname component
|
|
if (empty($comp_arr[$this->componentname]) || !$component = $comp_arr[$this->componentname]) {
|
|
$this->errorstring='cannotfindcomponent';
|
|
return false;
|
|
}
|
|
/// Check we have a valid md5
|
|
if (empty($component[1]) || strlen($component[1]) != 32) {
|
|
$this->errorstring='invalidmd5';
|
|
return false;
|
|
}
|
|
/// Set the extramd5info field
|
|
if (!empty($component[2])) {
|
|
$this->extramd5info = $component[2];
|
|
}
|
|
return $component[1];
|
|
}
|
|
|
|
/**
|
|
* This function allows you to retrieve the complete array of components found in
|
|
* the md5filename
|
|
*
|
|
* @return bool|array array of components in md5 file or false if error
|
|
*/
|
|
function get_all_components_md5() {
|
|
|
|
/// Check requisites are passed
|
|
if (!$this->requisitesok) {
|
|
return false;
|
|
}
|
|
|
|
/// Initialize components array
|
|
$comp_arr = array();
|
|
|
|
/// Define and retrieve the full md5 file
|
|
if ($this->zippath) {
|
|
$source = $this->sourcebase.'/'.$this->zippath.'/'.$this->md5filename;
|
|
} else {
|
|
$source = $this->sourcebase.'/'.$this->md5filename;
|
|
}
|
|
|
|
/// Check if we have downloaded the md5 file before (per request cache)
|
|
if (!empty($this->cachedmd5components[$source])) {
|
|
$comp_arr = $this->cachedmd5components[$source];
|
|
} else {
|
|
/// Not downloaded, let's do it now
|
|
$availablecomponents = array();
|
|
|
|
$contents = download_file_content($source, null, null, true);
|
|
if ($contents->results && (int) $contents->status === 200) {
|
|
/// Split text into lines
|
|
$lines = preg_split('/\r?\n/', $contents->results);
|
|
/// Each line will be one component
|
|
foreach($lines as $line) {
|
|
$availablecomponents[] = explode(',', $line);
|
|
}
|
|
/// If no components have been found, return error
|
|
if (empty($availablecomponents)) {
|
|
$this->errorstring='cannotdownloadcomponents';
|
|
return false;
|
|
}
|
|
/// Build an associative array of components for easily search
|
|
/// applying trim to avoid linefeeds and other...
|
|
$comp_arr = array();
|
|
foreach ($availablecomponents as $component) {
|
|
/// Avoid sometimes empty lines
|
|
if (empty($component[0])) {
|
|
continue;
|
|
}
|
|
$component[0]=trim($component[0]);
|
|
if (!empty($component[1])) {
|
|
$component[1]=trim($component[1]);
|
|
}
|
|
if (!empty($component[2])) {
|
|
$component[2]=trim($component[2]);
|
|
}
|
|
$comp_arr[$component[0]] = $component;
|
|
}
|
|
/// Cache components
|
|
$this->cachedmd5components[$source] = $comp_arr;
|
|
} else {
|
|
/// Return error
|
|
$this->errorstring='remotedownloaderror';
|
|
return false;
|
|
}
|
|
}
|
|
/// If there is no commponents or erros found, error
|
|
if (!empty($this->errorstring)) {
|
|
return false;
|
|
|
|
} else if (empty($comp_arr)) {
|
|
$this->errorstring='cannotdownloadcomponents';
|
|
return false;
|
|
}
|
|
return $comp_arr;
|
|
}
|
|
|
|
/**
|
|
* This function returns the errorstring
|
|
*
|
|
* @return string the error string
|
|
*/
|
|
function get_error() {
|
|
return $this->errorstring;
|
|
}
|
|
|
|
/** This function returns the extramd5 field (optional in md5 file)
|
|
*
|
|
* @return string the extramd5 field
|
|
*/
|
|
function get_extra_md5_field() {
|
|
return $this->extramd5info;
|
|
}
|
|
|
|
} /// End of component_installer class
|
|
|
|
|
|
/**
|
|
* Language packs installer
|
|
*
|
|
* This class wraps the functionality provided by {@link component_installer}
|
|
* and adds support for installing a set of language packs.
|
|
*
|
|
* Given an array of required language packs, this class fetches them all
|
|
* and installs them. It detects eventual dependencies and installs
|
|
* all parent languages, too.
|
|
*
|
|
* @copyright 2011 David Mudrak <david@moodle.com>
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
class lang_installer {
|
|
|
|
/** lang pack was successfully downloaded and deployed */
|
|
const RESULT_INSTALLED = 'installed';
|
|
/** lang pack was up-to-date so no download was needed */
|
|
const RESULT_UPTODATE = 'uptodate';
|
|
/** there was a problem with downloading the lang pack */
|
|
const RESULT_DOWNLOADERROR = 'downloaderror';
|
|
|
|
/** @var array of languages to install */
|
|
protected $queue = array();
|
|
/** @var string the code of language being currently installed */
|
|
protected $current;
|
|
/** @var array of languages already installed by this instance */
|
|
protected $done = array();
|
|
/** @var string this Moodle major version */
|
|
protected $version;
|
|
|
|
/**
|
|
* Prepare the installer
|
|
*
|
|
* @param string|array $langcode a code of the language to install
|
|
*/
|
|
public function __construct($langcode = '') {
|
|
global $CFG;
|
|
|
|
$this->set_queue($langcode);
|
|
$this->version = moodle_major_version(true);
|
|
|
|
if (!empty($CFG->langotherroot) and $CFG->langotherroot !== $CFG->dataroot . '/lang') {
|
|
debugging('The in-built language pack installer does not support alternative location ' .
|
|
'of languages root directory. You are supposed to install and update your language '.
|
|
'packs on your own.');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the queue of language packs to be installed
|
|
*
|
|
* @param string|array $langcodes language code like 'cs' or a list of them
|
|
*/
|
|
public function set_queue($langcodes) {
|
|
if (is_array($langcodes)) {
|
|
$this->queue = $langcodes;
|
|
} else if (!empty($langcodes)) {
|
|
$this->queue = array($langcodes);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Runs the installer
|
|
*
|
|
* This method calls {@link self::install_language_pack} for every language in the
|
|
* queue. If a dependency is detected, the parent language is added to the queue.
|
|
*
|
|
* @return array results, array of self::RESULT_xxx constants indexed by language code
|
|
*/
|
|
public function run() {
|
|
|
|
$results = array();
|
|
|
|
while ($this->current = array_shift($this->queue)) {
|
|
|
|
if ($this->was_processed($this->current)) {
|
|
// do not repeat yourself
|
|
continue;
|
|
}
|
|
|
|
if ($this->current === 'en') {
|
|
$this->mark_processed($this->current);
|
|
continue;
|
|
}
|
|
|
|
$results[$this->current] = $this->install_language_pack($this->current);
|
|
|
|
if (in_array($results[$this->current], array(self::RESULT_INSTALLED, self::RESULT_UPTODATE))) {
|
|
if ($parentlang = $this->get_parent_language($this->current)) {
|
|
if (!$this->is_queued($parentlang) and !$this->was_processed($parentlang)) {
|
|
$this->add_to_queue($parentlang);
|
|
}
|
|
}
|
|
}
|
|
|
|
$this->mark_processed($this->current);
|
|
}
|
|
|
|
return $results;
|
|
}
|
|
|
|
/**
|
|
* Returns the URL where a given language pack can be downloaded
|
|
*
|
|
* Alternatively, if the parameter is empty, returns URL of the page with the
|
|
* list of all available language packs.
|
|
*
|
|
* @param string $langcode language code like 'cs' or empty for unknown
|
|
* @return string URL
|
|
*/
|
|
public function lang_pack_url($langcode = '') {
|
|
|
|
if (empty($langcode)) {
|
|
return 'https://download.moodle.org/langpack/'.$this->version.'/';
|
|
} else {
|
|
return 'https://download.moodle.org/download.php/langpack/'.$this->version.'/'.$langcode.'.zip';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the list of available language packs from download.moodle.org
|
|
*
|
|
* @return array|bool false if can not download
|
|
*/
|
|
public function get_remote_list_of_languages() {
|
|
$source = 'https://download.moodle.org/langpack/' . $this->version . '/languages.md5';
|
|
$availablelangs = array();
|
|
|
|
$contents = download_file_content($source, null, null, true);
|
|
if ($contents->results && (int) $contents->status === 200) {
|
|
$alllines = explode("\n", $contents->results);
|
|
foreach($alllines as $line) {
|
|
if (!empty($line)){
|
|
$availablelangs[] = explode(',', $line);
|
|
}
|
|
}
|
|
return $availablelangs;
|
|
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Internal implementation /////////////////////////////////////////////////
|
|
|
|
/**
|
|
* Adds a language pack (or a list of them) to the queue
|
|
*
|
|
* @param string|array $langcodes code of the language to install or a list of them
|
|
*/
|
|
protected function add_to_queue($langcodes) {
|
|
if (is_array($langcodes)) {
|
|
$this->queue = array_merge($this->queue, $langcodes);
|
|
} else if (!empty($langcodes)) {
|
|
$this->queue[] = $langcodes;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks if the given language is queued or if the queue is empty
|
|
*
|
|
* @example $installer->is_queued('es'); // is Spanish going to be installed?
|
|
* @example $installer->is_queued(); // is there a language queued?
|
|
*
|
|
* @param string $langcode language code or empty string for "any"
|
|
* @return boolean
|
|
*/
|
|
protected function is_queued($langcode = '') {
|
|
|
|
if (empty($langcode)) {
|
|
return !empty($this->queue);
|
|
|
|
} else {
|
|
return in_array($langcode, $this->queue);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks if the given language has already been processed by this instance
|
|
*
|
|
* @see self::mark_processed()
|
|
* @param string $langcode
|
|
* @return boolean
|
|
*/
|
|
protected function was_processed($langcode) {
|
|
return isset($this->done[$langcode]);
|
|
}
|
|
|
|
/**
|
|
* Mark the given language pack as processed
|
|
*
|
|
* @see self::was_processed()
|
|
* @param string $langcode
|
|
*/
|
|
protected function mark_processed($langcode) {
|
|
$this->done[$langcode] = 1;
|
|
}
|
|
|
|
/**
|
|
* Returns a parent language of the given installed language
|
|
*
|
|
* @param string $langcode
|
|
* @return string parent language's code
|
|
*/
|
|
protected function get_parent_language($langcode) {
|
|
return get_parent_language($langcode);
|
|
}
|
|
|
|
/**
|
|
* Perform the actual language pack installation
|
|
*
|
|
* @uses component_installer
|
|
* @param string $langcode
|
|
* @return int return status
|
|
*/
|
|
protected function install_language_pack($langcode) {
|
|
|
|
// initialise new component installer to process this language
|
|
$installer = new component_installer('https://download.moodle.org', 'download.php/direct/langpack/' . $this->version,
|
|
$langcode . '.zip', 'languages.md5', 'lang');
|
|
|
|
if (!$installer->requisitesok) {
|
|
throw new lang_installer_exception('installer_requisites_check_failed');
|
|
}
|
|
|
|
$status = $installer->install();
|
|
|
|
if ($status == COMPONENT_ERROR) {
|
|
if ($installer->get_error() === 'remotedownloaderror') {
|
|
return self::RESULT_DOWNLOADERROR;
|
|
} else {
|
|
throw new lang_installer_exception($installer->get_error(), $langcode);
|
|
}
|
|
|
|
} else if ($status == COMPONENT_UPTODATE) {
|
|
return self::RESULT_UPTODATE;
|
|
|
|
} else if ($status == COMPONENT_INSTALLED) {
|
|
return self::RESULT_INSTALLED;
|
|
|
|
} else {
|
|
throw new lang_installer_exception('unexpected_installer_result', $status);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Exception thrown by {@link lang_installer}
|
|
*
|
|
* @copyright 2011 David Mudrak <david@moodle.com>
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
class lang_installer_exception extends moodle_exception {
|
|
|
|
public function __construct($errorcode, $debuginfo = null) {
|
|
parent::__construct($errorcode, 'error', '', null, $debuginfo);
|
|
}
|
|
}
|