d25560920e4a9efe08c8e89e37b47d06d0534b78
[moodle.git] / lib / classes / update / deployer.php
1 <?php
2 // This file is part of Moodle - http://moodle.org/
3 //
4 // Moodle is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation, either version 3 of the License, or
7 // (at your option) any later version.
8 //
9 // Moodle is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 // GNU General Public License for more details.
13 //
14 // You should have received a copy of the GNU General Public License
15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
17 /**
18  * Defines classes used for updates.
19  *
20  * @package    core
21  * @copyright  2011 David Mudrak <david@moodle.com>
22  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
23  */
24 namespace core\update;
26 use coding_exception, core_component, moodle_url;
28 defined('MOODLE_INTERNAL') || die();
30 /**
31  * Implements a communication bridge to the mdeploy.php utility
32  */
33 class deployer {
35     /** @var \core\update\deployer holds the singleton instance */
36     protected static $singletoninstance;
37     /** @var moodle_url URL of a page that includes the deployer UI */
38     protected $callerurl;
39     /** @var moodle_url URL to return after the deployment */
40     protected $returnurl;
42     /**
43      * Direct instantiation not allowed, use the factory method {@link self::instance()}
44      */
45     protected function __construct() {
46     }
48     /**
49      * Sorry, this is singleton
50      */
51     protected function __clone() {
52     }
54     /**
55      * Factory method for this class
56      *
57      * @return \core\update\deployer the singleton instance
58      */
59     public static function instance() {
60         if (is_null(self::$singletoninstance)) {
61             self::$singletoninstance = new self();
62         }
63         return self::$singletoninstance;
64     }
66     /**
67      * Reset caches used by this script
68      *
69      * @param bool $phpunitreset is this called as a part of PHPUnit reset?
70      */
71     public static function reset_caches($phpunitreset = false) {
72         if ($phpunitreset) {
73             self::$singletoninstance = null;
74         }
75     }
77     /**
78      * Is automatic deployment enabled?
79      *
80      * @return bool
81      */
82     public function enabled() {
83         global $CFG;
85         if (!empty($CFG->disableupdateautodeploy)) {
86             // The feature is prohibited via config.php.
87             return false;
88         }
90         return get_config('updateautodeploy');
91     }
93     /**
94      * Sets some base properties of the class to make it usable.
95      *
96      * @param moodle_url $callerurl the base URL of a script that will handle the class'es form data
97      * @param moodle_url $returnurl the final URL to return to when the deployment is finished
98      */
99     public function initialize(moodle_url $callerurl, moodle_url $returnurl) {
101         if (!$this->enabled()) {
102             throw new coding_exception('Unable to initialize the deployer, the feature is not enabled.');
103         }
105         $this->callerurl = $callerurl;
106         $this->returnurl = $returnurl;
107     }
109     /**
110      * Has the deployer been initialized?
111      *
112      * Initialized deployer means that the following properties were set:
113      * callerurl, returnurl
114      *
115      * @return bool
116      */
117     public function initialized() {
119         if (!$this->enabled()) {
120             return false;
121         }
123         if (empty($this->callerurl)) {
124             return false;
125         }
127         if (empty($this->returnurl)) {
128             return false;
129         }
131         return true;
132     }
134     /**
135      * Returns a list of reasons why the deployment can not happen
136      *
137      * If the returned array is empty, the deployment seems to be possible. The returned
138      * structure is an associative array with keys representing individual impediments.
139      * Possible keys are: missingdownloadurl, missingdownloadmd5, notwritable.
140      *
141      * @param \core\update\info $info
142      * @return array
143      */
144     public function deployment_impediments(info $info) {
146         $impediments = array();
148         if (empty($info->download)) {
149             $impediments['missingdownloadurl'] = true;
150         }
152         if (empty($info->downloadmd5)) {
153             $impediments['missingdownloadmd5'] = true;
154         }
156         if (!empty($info->download) and !$this->update_downloadable($info->download)) {
157             $impediments['notdownloadable'] = true;
158         }
160         if (!$this->component_writable($info->component)) {
161             $impediments['notwritable'] = true;
162         }
164         return $impediments;
165     }
167     /**
168      * Check to see if the current version of the plugin seems to be a checkout of an external repository.
169      *
170      * @see core_plugin_manager::plugin_external_source()
171      * @param \core\update\info $info
172      * @return false|string
173      */
174     public function plugin_external_source(info $info) {
176         $paths = core_component::get_plugin_types();
177         list($plugintype, $pluginname) = core_component::normalize_component($info->component);
178         $pluginroot = $paths[$plugintype].'/'.$pluginname;
180         if (is_dir($pluginroot.'/.git')) {
181             return 'git';
182         }
184         if (is_dir($pluginroot.'/CVS')) {
185             return 'cvs';
186         }
188         if (is_dir($pluginroot.'/.svn')) {
189             return 'svn';
190         }
192         if (is_dir($pluginroot.'/.hg')) {
193             return 'mercurial';
194         }
196         return false;
197     }
199     /**
200      * Prepares a renderable widget to confirm installation of an available update.
201      *
202      * @param \core\update\info $info component version to deploy
203      * @return \renderable
204      */
205     public function make_confirm_widget(info $info) {
207         if (!$this->initialized()) {
208             throw new coding_exception('Illegal method call - deployer not initialized.');
209         }
211         $params = array(
212             'updateaddon' => $info->component,
213             'version' =>$info->version,
214             'sesskey' => sesskey(),
215         );
217         // Append some our own data.
218         if (!empty($this->callerurl)) {
219             $params['callerurl'] = $this->callerurl->out(false);
220         }
221         if (!empty($this->returnurl)) {
222             $params['returnurl'] = $this->returnurl->out(false);
223         }
225         $widget = new \single_button(
226             new moodle_url($this->callerurl, $params),
227             get_string('updateavailableinstall', 'core_admin'),
228             'post'
229         );
231         return $widget;
232     }
234     /**
235      * Prepares a renderable widget to execute installation of an available update.
236      *
237      * @param \core\update\info $info component version to deploy
238      * @param moodle_url $returnurl URL to return after the installation execution
239      * @return \renderable
240      */
241     public function make_execution_widget(info $info, moodle_url $returnurl = null) {
242         global $CFG;
244         if (!$this->initialized()) {
245             throw new coding_exception('Illegal method call - deployer not initialized.');
246         }
248         $pluginrootpaths = core_component::get_plugin_types();
250         list($plugintype, $pluginname) = core_component::normalize_component($info->component);
252         if (empty($pluginrootpaths[$plugintype])) {
253             throw new coding_exception('Unknown plugin type root location', $plugintype);
254         }
256         list($passfile, $password) = $this->prepare_authorization();
258         if (is_null($returnurl)) {
259             $returnurl = new moodle_url('/admin');
260         } else {
261             $returnurl = $returnurl;
262         }
264         $params = array(
265             'upgrade' => true,
266             'type' => $plugintype,
267             'name' => $pluginname,
268             'typeroot' => $pluginrootpaths[$plugintype],
269             'package' => $info->download,
270             'md5' => $info->downloadmd5,
271             'dataroot' => $CFG->dataroot,
272             'dirroot' => $CFG->dirroot,
273             'passfile' => $passfile,
274             'password' => $password,
275             'returnurl' => $returnurl->out(false),
276         );
278         if (!empty($CFG->proxyhost)) {
279             // MDL-36973 - Beware - we should call just !is_proxybypass() here. But currently, our
280             // cURL wrapper class does not do it. So, to have consistent behaviour, we pass proxy
281             // setting regardless the $CFG->proxybypass setting. Once the {@link curl} class is
282             // fixed, the condition should be amended.
283             if (true or !is_proxybypass($info->download)) {
284                 if (empty($CFG->proxyport)) {
285                     $params['proxy'] = $CFG->proxyhost;
286                 } else {
287                     $params['proxy'] = $CFG->proxyhost.':'.$CFG->proxyport;
288                 }
290                 if (!empty($CFG->proxyuser) and !empty($CFG->proxypassword)) {
291                     $params['proxyuserpwd'] = $CFG->proxyuser.':'.$CFG->proxypassword;
292                 }
294                 if (!empty($CFG->proxytype)) {
295                     $params['proxytype'] = $CFG->proxytype;
296                 }
297             }
298         }
300         $widget = new \single_button(
301             new moodle_url('/mdeploy.php', $params),
302             get_string('updateavailableinstall', 'core_admin'),
303             'post'
304         );
306         return $widget;
307     }
309     /**
310      * Returns array of data objects passed to this tool.
311      *
312      * @return array
313      */
314     public function submitted_data() {
315         $component = optional_param('updateaddon', '', PARAM_COMPONENT);
316         $version = optional_param('version', '', PARAM_RAW);
317         if (!$component or !$version) {
318             return false;
319         }
321         $plugininfo = \core_plugin_manager::instance()->get_plugin_info($component);
322         if (!$plugininfo) {
323             return false;
324         }
326         if ($plugininfo->is_standard()) {
327             return false;
328         }
330         if (!$updates = $plugininfo->available_updates()) {
331             return false;
332         }
334         $info = null;
335         foreach ($updates as $update) {
336             if ($update->version == $version) {
337                 $info = $update;
338                 break;
339             }
340         }
341         if (!$info) {
342             return false;
343         }
345         $data = array(
346             'updateaddon' => $component,
347             'updateinfo'  => $info,
348             'callerurl'   => optional_param('callerurl', null, PARAM_URL),
349             'returnurl'   => optional_param('returnurl', null, PARAM_URL),
350         );
351         if ($data['callerurl']) {
352             $data['callerurl'] = new moodle_url($data['callerurl']);
353         }
354         if ($data['callerurl']) {
355             $data['returnurl'] = new moodle_url($data['returnurl']);
356         }
358         return $data;
359     }
361     /**
362      * Handles magic getters and setters for protected properties.
363      *
364      * @param string $name method name, e.g. set_returnurl()
365      * @param array $arguments arguments to be passed to the array
366      */
367     public function __call($name, array $arguments = array()) {
369         if (substr($name, 0, 4) === 'set_') {
370             $property = substr($name, 4);
371             if (empty($property)) {
372                 throw new coding_exception('Invalid property name (empty)');
373             }
374             if (empty($arguments)) {
375                 $arguments = array(true); // Default value for flag-like properties.
376             }
377             // Make sure it is a protected property.
378             $isprotected = false;
379             $reflection = new \ReflectionObject($this);
380             foreach ($reflection->getProperties(\ReflectionProperty::IS_PROTECTED) as $reflectionproperty) {
381                 if ($reflectionproperty->getName() === $property) {
382                     $isprotected = true;
383                     break;
384                 }
385             }
386             if (!$isprotected) {
387                 throw new coding_exception('Unable to set property - it does not exist or it is not protected');
388             }
389             $value = reset($arguments);
390             $this->$property = $value;
391             return;
392         }
394         if (substr($name, 0, 4) === 'get_') {
395             $property = substr($name, 4);
396             if (empty($property)) {
397                 throw new coding_exception('Invalid property name (empty)');
398             }
399             if (!empty($arguments)) {
400                 throw new coding_exception('No parameter expected');
401             }
402             // Make sure it is a protected property.
403             $isprotected = false;
404             $reflection = new \ReflectionObject($this);
405             foreach ($reflection->getProperties(\ReflectionProperty::IS_PROTECTED) as $reflectionproperty) {
406                 if ($reflectionproperty->getName() === $property) {
407                     $isprotected = true;
408                     break;
409                 }
410             }
411             if (!$isprotected) {
412                 throw new coding_exception('Unable to get property - it does not exist or it is not protected');
413             }
414             return $this->$property;
415         }
416     }
418     /**
419      * Generates a random token and stores it in a file in moodledata directory.
420      *
421      * @return array of the (string)filename and (string)password in this order
422      */
423     public function prepare_authorization() {
424         global $CFG;
426         make_upload_directory('mdeploy/auth/');
428         $attempts = 0;
429         $success = false;
431         while (!$success and $attempts < 5) {
432             $attempts++;
434             $passfile = $this->generate_passfile();
435             $password = $this->generate_password();
436             $now = time();
438             $filepath = $CFG->dataroot.'/mdeploy/auth/'.$passfile;
440             if (!file_exists($filepath)) {
441                 $success = file_put_contents($filepath, $password . PHP_EOL . $now . PHP_EOL, LOCK_EX);
442                 chmod($filepath, $CFG->filepermissions);
443             }
444         }
446         if ($success) {
447             return array($passfile, $password);
449         } else {
450             throw new \moodle_exception('unable_prepare_authorization', 'core_plugin');
451         }
452     }
454     /* === End of external API === */
456     /**
457      * Returns a random string to be used as a filename of the password storage.
458      *
459      * @return string
460      */
461     protected function generate_passfile() {
462         return clean_param(uniqid('mdeploy_', true), PARAM_FILE);
463     }
465     /**
466      * Returns a random string to be used as the authorization token
467      *
468      * @return string
469      */
470     protected function generate_password() {
471         return complex_random_string();
472     }
474     /**
475      * Checks if the given component's directory is writable
476      *
477      * For the purpose of the deployment, the web server process has to have
478      * write access to all files in the component's directory (recursively) and for the
479      * directory itself.
480      *
481      * @see worker::move_directory_source_precheck()
482      * @param string $component normalized component name
483      * @return boolean
484      */
485     protected function component_writable($component) {
487         list($plugintype, $pluginname) = core_component::normalize_component($component);
489         $directory = core_component::get_plugin_directory($plugintype, $pluginname);
491         if (is_null($directory)) {
492             // Plugin unknown, most probably deleted or missing during upgrade,
493             // look at the parent directory instead because they might want to install it.
494             $plugintypes = core_component::get_plugin_types();
495             if (!isset($plugintypes[$plugintype])) {
496                 throw new coding_exception('Unknown component location', $component);
497             }
498             $directory = $plugintypes[$plugintype];
499         }
501         return $this->directory_writable($directory);
502     }
504     /**
505      * Checks if the mdeploy.php will be able to fetch the ZIP from the given URL
506      *
507      * This is mainly supposed to check if the transmission over HTTPS would
508      * work. That is, if the CA certificates are present at the server.
509      *
510      * @param string $downloadurl the URL of the ZIP package to download
511      * @return bool
512      */
513     protected function update_downloadable($downloadurl) {
514         global $CFG;
516         $curloptions = array(
517             'CURLOPT_SSL_VERIFYHOST' => 2,      // This is the default in {@link curl} class but just in case.
518             'CURLOPT_SSL_VERIFYPEER' => true,
519         );
521         $curl = new \curl(array('proxy' => true));
522         $result = $curl->head($downloadurl, $curloptions);
523         $errno = $curl->get_errno();
524         if (empty($errno)) {
525             return true;
526         } else {
527             return false;
528         }
529     }
531     /**
532      * Checks if the directory and all its contents (recursively) is writable
533      *
534      * @param string $path full path to a directory
535      * @return boolean
536      */
537     private function directory_writable($path) {
539         if (!is_writable($path)) {
540             return false;
541         }
543         if (is_dir($path)) {
544             $handle = opendir($path);
545         } else {
546             return false;
547         }
549         $result = true;
551         while ($filename = readdir($handle)) {
552             $filepath = $path.'/'.$filename;
554             if ($filename === '.' or $filename === '..') {
555                 continue;
556             }
558             if (is_dir($filepath)) {
559                 $result = $result && $this->directory_writable($filepath);
561             } else {
562                 $result = $result && is_writable($filepath);
563             }
564         }
566         closedir($handle);
568         return $result;
569     }