Merge branch 'MDL-56895-master' of git://github.com/danpoltawski/moodle
[moodle.git] / lib / classes / session / redis.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  * Redis based session handler.
19  *
20  * @package    core
21  * @copyright  2015 Russell Smith <mr-russ@smith2001.net>
22  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
23  */
25 namespace core\session;
27 use RedisException;
29 defined('MOODLE_INTERNAL') || die();
31 /**
32  * Redis based session handler.
33  *
34  * The default Redis session handler does not handle locking in 2.2.7, so we have written a php session handler
35  * that uses locking.  The places where locking is used was modeled from the memcached code that is used in Moodle
36  * https://github.com/php-memcached-dev/php-memcached/blob/master/php_memcached_session.c
37  *
38  * @package    core
39  * @copyright  2016 Russell Smith
40  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
41  */
42 class redis extends handler {
43     /** @var string $host save_path string  */
44     protected $host = '';
45     /** @var int $port The port to connect to */
46     protected $port = 6379;
47     /** @var int $database the Redis database to store sesions in */
48     protected $database = 0;
49     /** @var array $servers list of servers parsed from save_path */
50     protected $prefix = '';
51     /** @var int $acquiretimeout how long to wait for session lock in seconds */
52     protected $acquiretimeout = 120;
53     /**
54      * @var int $lockexpire how long to wait in seconds before expiring the lock automatically
55      * so that other requests may continue execution, ignored if PECL redis is below version 2.2.0.
56      */
57     protected $lockexpire = 7200;
59     /** @var Redis Connection */
60     protected $connection = null;
62     /** @var array $locks List of currently held locks by this page. */
63     protected $locks = array();
65     /**
66      * Create new instance of handler.
67      */
68     public function __construct() {
69         global $CFG;
71         if (isset($CFG->session_redis_host)) {
72             $this->host = $CFG->session_redis_host;
73         }
75         if (isset($CFG->session_redis_port)) {
76             $this->port = (int)$CFG->session_redis_port;
77         }
79         if (isset($CFG->session_redis_database)) {
80             $this->database = (int)$CFG->session_redis_database;
81         }
83         if (isset($CFG->session_redis_prefix)) {
84             $this->prefix = $CFG->session_redis_prefix;
85         }
87         if (isset($CFG->session_redis_acquire_lock_timeout)) {
88             $this->acquiretimeout = (int)$CFG->session_redis_acquire_lock_timeout;
89         }
91         if (isset($CFG->session_redis_lock_expire)) {
92             $this->lockexpire = (int)$CFG->session_redis_lock_expire;
93         }
94     }
96     /**
97      * Start the session.
98      *
99      * @return bool success
100      */
101     public function start() {
102         $result = parent::start();
104         return $result;
105     }
107     /**
108      * Init session handler.
109      */
110     public function init() {
111         if (!extension_loaded('redis')) {
112             throw new exception('sessionhandlerproblem', 'error', '', null, 'redis extension is not loaded');
113         }
115         if (empty($this->host)) {
116             throw new exception('sessionhandlerproblem', 'error', '', null,
117                     '$CFG->session_redis_host must be specified in config.php');
118         }
120         // The session handler requires a version of Redis with the SETEX command (at least 2.0).
121         $version = phpversion('Redis');
122         if (!$version or version_compare($version, '2.0') <= 0) {
123             throw new exception('sessionhandlerproblem', 'error', '', null, 'redis extension version must be at least 2.0');
124         }
126         $this->connection = new \Redis();
128         $result = session_set_save_handler(array($this, 'handler_open'),
129             array($this, 'handler_close'),
130             array($this, 'handler_read'),
131             array($this, 'handler_write'),
132             array($this, 'handler_destroy'),
133             array($this, 'handler_gc'));
134         if (!$result) {
135             throw new exception('redissessionhandlerproblem', 'error');
136         }
138         try {
139             // One second timeout was chosen as it is long for connection, but short enough for a user to be patient.
140             if (!$this->connection->connect($this->host, $this->port, 1)) {
141                 throw new RedisException('Unable to connect to host.');
142             }
143             if (!$this->connection->setOption(\Redis::OPT_SERIALIZER, \Redis::SERIALIZER_PHP)) {
144                 throw new RedisException('Unable to set Redis PHP Serializer option.');
145             }
147             if ($this->prefix !== '') {
148                 // Use custom prefix on sessions.
149                 if (!$this->connection->setOption(\Redis::OPT_PREFIX, $this->prefix)) {
150                     throw new RedisException('Unable to set Redis Prefix option.');
151                 }
152             }
153             if ($this->database !== 0) {
154                 if (!$this->connection->select($this->database)) {
155                     throw new RedisException('Unable to select Redis database '.$this->database.'.');
156                 }
157             }
158             $this->connection->ping();
159             return true;
160         } catch (RedisException $e) {
161             error_log('Failed to connect to redis at '.$this->host.':'.$this->port.', error returned was: '.$e->getMessage());
162             return false;
163         }
164     }
166     /**
167      * Update our session search path to include session name when opened.
168      *
169      * @param string $savepath  unused session save path. (ignored)
170      * @param string $sessionname Session name for this session. (ignored)
171      * @return bool true always as we will succeed.
172      */
173     public function handler_open($savepath, $sessionname) {
174         return true;
175     }
177     /**
178      * Close the session completely. We also remove all locks we may have obtained that aren't expired.
179      *
180      * @return bool true on success.  false on unable to unlock sessions.
181      */
182     public function handler_close() {
183         try {
184             foreach ($this->locks as $id => $expirytime) {
185                 if ($expirytime > $this->time()) {
186                     $this->unlock_session($id);
187                 }
188                 unset($this->locks[$id]);
189             }
190         } catch (RedisException $e) {
191             error_log('Failed talking to redis: '.$e->getMessage());
192             return false;
193         }
195         return true;
196     }
197     /**
198      * Read the session data from storage
199      *
200      * @param string $id The session id to read from storage.
201      * @return string The session data for PHP to process.
202      *
203      * @throws RedisException when we are unable to talk to the Redis server.
204      */
205     public function handler_read($id) {
206         try {
207             $this->lock_session($id);
208             $sessiondata = $this->connection->get($id);
209             if ($sessiondata === false) {
210                 $this->unlock_session($id);
211                 return '';
212             }
213             $this->connection->expire($id, $this->lockexpire);
214         } catch (RedisException $e) {
215             error_log('Failed talking to redis: '.$e->getMessage());
216             throw $e;
217         }
218         return $sessiondata;
219     }
221     /**
222      * Write the serialized session data to our session store.
223      *
224      * @param string $id session id to write.
225      * @param string $data session data
226      * @return bool true on write success, false on failure
227      */
228     public function handler_write($id, $data) {
229         if (is_null($this->connection)) {
230             // The session has already been closed, don't attempt another write.
231             error_log('Tried to write session: '.$id.' before open or after close.');
232             return false;
233         }
235         // We do not do locking here because memcached doesn't.  Also
236         // PHP does open, read, destroy, write, close. When a session doesn't exist.
237         // There can be race conditions on new sessions racing each other but we can
238         // address that in the future.
239         try {
240             $this->connection->setex($id, $this->lockexpire, $data);
241         } catch (RedisException $e) {
242             error_log('Failed talking to redis: '.$e->getMessage());
243             return false;
244         }
245         return true;
246     }
248     /**
249      * Handle destroying a session.
250      *
251      * @param string $id the session id to destroy.
252      * @return bool true if the session was deleted, false otherwise.
253      */
254     public function handler_destroy($id) {
255         try {
256             $this->connection->del($id);
257             $this->unlock_session($id);
258         } catch (RedisException $e) {
259             error_log('Failed talking to redis: '.$e->getMessage());
260             return false;
261         }
263         return true;
264     }
266     /**
267      * Garbage collect sessions.  We don't we any as Redis does it for us.
268      *
269      * @param integer $maxlifetime All sessions older than this should be removed.
270      * @return bool true, as Redis handles expiry for us.
271      */
272     public function handler_gc($maxlifetime) {
273         return true;
274     }
276     /**
277      * Unlock a session.
278      *
279      * @param string $id Session id to be unlocked.
280      */
281     protected function unlock_session($id) {
282         if (isset($this->locks[$id])) {
283             $this->connection->del($id.".lock");
284             unset($this->locks[$id]);
285         }
286     }
288     /**
289      * Obtain a session lock so we are the only one using it at the moent.
290      *
291      * @param string $id The session id to lock.
292      * @return bool true when session was locked, exception otherwise.
293      * @throws exception When we are unable to obtain a session lock.
294      */
295     protected function lock_session($id) {
296         $lockkey = $id.".lock";
298         $haslock = isset($this->locks[$id]) && $this->time() < $this->locks[$id];
299         $startlocktime = $this->time();
301         /* To be able to ensure sessions don't write out of order we must obtain an exclusive lock
302          * on the session for the entire time it is open.  If another AJAX call, or page is using
303          * the session then we just wait until it finishes before we can open the session.
304          */
305         while (!$haslock) {
306             $haslock = $this->connection->setnx($lockkey, '1');
307             if (!$haslock) {
308                 usleep(rand(100000, 1000000));
309                 if ($this->time() > $startlocktime + $this->acquiretimeout) {
310                     // This is a fatal error, better inform users.
311                     // It should not happen very often - all pages that need long time to execute
312                     // should close session immediately after access control checks.
313                     error_log('Cannot obtain session lock for sid: '.$id.' within '.$this->acquiretimeout.
314                             '. It is likely another page has a long session lock, or the session lock was never released.');
315                     throw new exception("Unable to obtain session lock");
316                 }
317             } else {
318                 $this->locks[$id] = $this->time() + $this->lockexpire;
319                 $this->connection->expire($lockkey, $this->lockexpire);
320                 return true;
321             }
322         }
323     }
325     /**
326      * Return the current time.
327      *
328      * @return int the current time as a unixtimestamp.
329      */
330     protected function time() {
331         return time();
332     }
334     /**
335      * Check the backend contains data for this session id.
336      *
337      * Note: this is intended to be called from manager::session_exists() only.
338      *
339      * @param string $sid
340      * @return bool true if session found.
341      */
342     public function session_exists($sid) {
343         if (!$this->connection) {
344             return false;
345         }
347         try {
348             return $this->connection->exists($sid);
349         } catch (RedisException $e) {
350             return false;
351         }
352     }
354     /**
355      * Kill all active sessions, the core sessions table is purged afterwards.
356      */
357     public function kill_all_sessions() {
358         global $DB;
359         if (!$this->connection) {
360             return;
361         }
363         $rs = $DB->get_recordset('sessions', array(), 'id DESC', 'id, sid');
364         foreach ($rs as $record) {
365             $this->handler_destroy($record->sid);
366         }
367         $rs->close();
368     }
370     /**
371      * Kill one session, the session record is removed afterwards.
372      *
373      * @param string $sid
374      */
375     public function kill_session($sid) {
376         if (!$this->connection) {
377             return;
378         }
380         $this->handler_destroy($sid);
381     }