Merge branch 'wip-mdl-58068' of https://github.com/rajeshtaneja/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     /** @var int $serializer The serializer to use */
54     protected $serializer = \Redis::SERIALIZER_PHP;
55     /**
56      * @var int $lockexpire how long to wait in seconds before expiring the lock automatically
57      * so that other requests may continue execution, ignored if PECL redis is below version 2.2.0.
58      */
59     protected $lockexpire;
61     /** @var Redis Connection */
62     protected $connection = null;
64     /** @var array $locks List of currently held locks by this page. */
65     protected $locks = array();
67     /** @var int $timeout How long sessions live before expiring. */
68     protected $timeout;
70     /**
71      * Create new instance of handler.
72      */
73     public function __construct() {
74         global $CFG;
76         if (isset($CFG->session_redis_host)) {
77             $this->host = $CFG->session_redis_host;
78         }
80         if (isset($CFG->session_redis_port)) {
81             $this->port = (int)$CFG->session_redis_port;
82         }
84         if (isset($CFG->session_redis_database)) {
85             $this->database = (int)$CFG->session_redis_database;
86         }
88         if (isset($CFG->session_redis_prefix)) {
89             $this->prefix = $CFG->session_redis_prefix;
90         }
92         if (isset($CFG->session_redis_acquire_lock_timeout)) {
93             $this->acquiretimeout = (int)$CFG->session_redis_acquire_lock_timeout;
94         }
96         if (!empty($CFG->session_redis_serializer_use_igbinary) && defined('\Redis::SERIALIZER_IGBINARY')) {
97             $this->serializer = \Redis::SERIALIZER_IGBINARY; // Set igbinary serializer if phpredis supports it.
98         }
100         // The following configures the session lifetime in redis to allow some
101         // wriggle room in the user noticing they've been booted off and
102         // letting them log back in before they lose their session entirely.
103         $updatefreq = empty($CFG->session_update_timemodified_frequency) ? 20 : $CFG->session_update_timemodified_frequency;
104         $this->timeout = $CFG->sessiontimeout + $updatefreq + MINSECS;
106         $this->lockexpire = $CFG->sessiontimeout;
107         if (isset($CFG->session_redis_lock_expire)) {
108             $this->lockexpire = (int)$CFG->session_redis_lock_expire;
109         }
110     }
112     /**
113      * Start the session.
114      *
115      * @return bool success
116      */
117     public function start() {
118         $result = parent::start();
120         return $result;
121     }
123     /**
124      * Init session handler.
125      */
126     public function init() {
127         if (!extension_loaded('redis')) {
128             throw new exception('sessionhandlerproblem', 'error', '', null, 'redis extension is not loaded');
129         }
131         if (empty($this->host)) {
132             throw new exception('sessionhandlerproblem', 'error', '', null,
133                     '$CFG->session_redis_host must be specified in config.php');
134         }
136         // The session handler requires a version of Redis with the SETEX command (at least 2.0).
137         $version = phpversion('Redis');
138         if (!$version or version_compare($version, '2.0') <= 0) {
139             throw new exception('sessionhandlerproblem', 'error', '', null, 'redis extension version must be at least 2.0');
140         }
142         $this->connection = new \Redis();
144         $result = session_set_save_handler(array($this, 'handler_open'),
145             array($this, 'handler_close'),
146             array($this, 'handler_read'),
147             array($this, 'handler_write'),
148             array($this, 'handler_destroy'),
149             array($this, 'handler_gc'));
150         if (!$result) {
151             throw new exception('redissessionhandlerproblem', 'error');
152         }
154         try {
155             // One second timeout was chosen as it is long for connection, but short enough for a user to be patient.
156             if (!$this->connection->connect($this->host, $this->port, 1)) {
157                 throw new RedisException('Unable to connect to host.');
158             }
159             if (!$this->connection->setOption(\Redis::OPT_SERIALIZER, $this->serializer)) {
160                 throw new RedisException('Unable to set Redis PHP Serializer option.');
161             }
163             if ($this->prefix !== '') {
164                 // Use custom prefix on sessions.
165                 if (!$this->connection->setOption(\Redis::OPT_PREFIX, $this->prefix)) {
166                     throw new RedisException('Unable to set Redis Prefix option.');
167                 }
168             }
169             if ($this->database !== 0) {
170                 if (!$this->connection->select($this->database)) {
171                     throw new RedisException('Unable to select Redis database '.$this->database.'.');
172                 }
173             }
174             $this->connection->ping();
175             return true;
176         } catch (RedisException $e) {
177             error_log('Failed to connect to redis at '.$this->host.':'.$this->port.', error returned was: '.$e->getMessage());
178             return false;
179         }
180     }
182     /**
183      * Update our session search path to include session name when opened.
184      *
185      * @param string $savepath  unused session save path. (ignored)
186      * @param string $sessionname Session name for this session. (ignored)
187      * @return bool true always as we will succeed.
188      */
189     public function handler_open($savepath, $sessionname) {
190         return true;
191     }
193     /**
194      * Close the session completely. We also remove all locks we may have obtained that aren't expired.
195      *
196      * @return bool true on success.  false on unable to unlock sessions.
197      */
198     public function handler_close() {
199         try {
200             foreach ($this->locks as $id => $expirytime) {
201                 if ($expirytime > $this->time()) {
202                     $this->unlock_session($id);
203                 }
204                 unset($this->locks[$id]);
205             }
206         } catch (RedisException $e) {
207             error_log('Failed talking to redis: '.$e->getMessage());
208             return false;
209         }
211         return true;
212     }
213     /**
214      * Read the session data from storage
215      *
216      * @param string $id The session id to read from storage.
217      * @return string The session data for PHP to process.
218      *
219      * @throws RedisException when we are unable to talk to the Redis server.
220      */
221     public function handler_read($id) {
222         try {
223             $this->lock_session($id);
224             $sessiondata = $this->connection->get($id);
225             if ($sessiondata === false) {
226                 $this->unlock_session($id);
227                 return '';
228             }
229             $this->connection->expire($id, $this->timeout);
230         } catch (RedisException $e) {
231             error_log('Failed talking to redis: '.$e->getMessage());
232             throw $e;
233         }
234         return $sessiondata;
235     }
237     /**
238      * Write the serialized session data to our session store.
239      *
240      * @param string $id session id to write.
241      * @param string $data session data
242      * @return bool true on write success, false on failure
243      */
244     public function handler_write($id, $data) {
245         if (is_null($this->connection)) {
246             // The session has already been closed, don't attempt another write.
247             error_log('Tried to write session: '.$id.' before open or after close.');
248             return false;
249         }
251         // We do not do locking here because memcached doesn't.  Also
252         // PHP does open, read, destroy, write, close. When a session doesn't exist.
253         // There can be race conditions on new sessions racing each other but we can
254         // address that in the future.
255         try {
256             $this->connection->setex($id, $this->timeout, $data);
257         } catch (RedisException $e) {
258             error_log('Failed talking to redis: '.$e->getMessage());
259             return false;
260         }
261         return true;
262     }
264     /**
265      * Handle destroying a session.
266      *
267      * @param string $id the session id to destroy.
268      * @return bool true if the session was deleted, false otherwise.
269      */
270     public function handler_destroy($id) {
271         try {
272             $this->connection->del($id);
273             $this->unlock_session($id);
274         } catch (RedisException $e) {
275             error_log('Failed talking to redis: '.$e->getMessage());
276             return false;
277         }
279         return true;
280     }
282     /**
283      * Garbage collect sessions.  We don't we any as Redis does it for us.
284      *
285      * @param integer $maxlifetime All sessions older than this should be removed.
286      * @return bool true, as Redis handles expiry for us.
287      */
288     public function handler_gc($maxlifetime) {
289         return true;
290     }
292     /**
293      * Unlock a session.
294      *
295      * @param string $id Session id to be unlocked.
296      */
297     protected function unlock_session($id) {
298         if (isset($this->locks[$id])) {
299             $this->connection->del($id.".lock");
300             unset($this->locks[$id]);
301         }
302     }
304     /**
305      * Obtain a session lock so we are the only one using it at the moent.
306      *
307      * @param string $id The session id to lock.
308      * @return bool true when session was locked, exception otherwise.
309      * @throws exception When we are unable to obtain a session lock.
310      */
311     protected function lock_session($id) {
312         $lockkey = $id.".lock";
314         $haslock = isset($this->locks[$id]) && $this->time() < $this->locks[$id];
315         $startlocktime = $this->time();
317         /* To be able to ensure sessions don't write out of order we must obtain an exclusive lock
318          * on the session for the entire time it is open.  If another AJAX call, or page is using
319          * the session then we just wait until it finishes before we can open the session.
320          */
321         while (!$haslock) {
322             $haslock = $this->connection->setnx($lockkey, '1');
323             if (!$haslock) {
324                 usleep(rand(100000, 1000000));
325                 if ($this->time() > $startlocktime + $this->acquiretimeout) {
326                     // This is a fatal error, better inform users.
327                     // It should not happen very often - all pages that need long time to execute
328                     // should close session immediately after access control checks.
329                     error_log('Cannot obtain session lock for sid: '.$id.' within '.$this->acquiretimeout.
330                             '. It is likely another page has a long session lock, or the session lock was never released.');
331                     throw new exception("Unable to obtain session lock");
332                 }
333             } else {
334                 $this->locks[$id] = $this->time() + $this->lockexpire;
335                 $this->connection->expire($lockkey, $this->lockexpire);
336                 return true;
337             }
338         }
339     }
341     /**
342      * Return the current time.
343      *
344      * @return int the current time as a unixtimestamp.
345      */
346     protected function time() {
347         return time();
348     }
350     /**
351      * Check the backend contains data for this session id.
352      *
353      * Note: this is intended to be called from manager::session_exists() only.
354      *
355      * @param string $sid
356      * @return bool true if session found.
357      */
358     public function session_exists($sid) {
359         if (!$this->connection) {
360             return false;
361         }
363         try {
364             return $this->connection->exists($sid);
365         } catch (RedisException $e) {
366             return false;
367         }
368     }
370     /**
371      * Kill all active sessions, the core sessions table is purged afterwards.
372      */
373     public function kill_all_sessions() {
374         global $DB;
375         if (!$this->connection) {
376             return;
377         }
379         $rs = $DB->get_recordset('sessions', array(), 'id DESC', 'id, sid');
380         foreach ($rs as $record) {
381             $this->handler_destroy($record->sid);
382         }
383         $rs->close();
384     }
386     /**
387      * Kill one session, the session record is removed afterwards.
388      *
389      * @param string $sid
390      */
391     public function kill_session($sid) {
392         if (!$this->connection) {
393             return;
394         }
396         $this->handler_destroy($sid);
397     }