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

/**

 * Redis based session handler.

 *

 * @package    core

 * @copyright  2015 Russell Smith <mr-russ@smith2001.net>

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

 */

namespace core\session;

use RedisException;

use RedisClusterException;

use SessionHandlerInterface;

/**

 * Redis based session handler.

 *

 * The default Redis session handler does not handle locking in 2.2.7, so we have written a php session handler

 * that uses locking.  The places where locking is used was modeled from the memcached code that is used in Moodle

 * https://github.com/php-memcached-dev/php-memcached/blob/master/php_memcached_session.c

 *

 * @package    core

 * @copyright  2016 Russell Smith

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

 */

class redis extends handler implements SessionHandlerInterface {

    /**

     * Compressor: none.

     */

    const COMPRESSION_NONE      = 'none';

    /**

     * Compressor: PHP GZip.

     */

    const COMPRESSION_GZIP      = 'gzip';

    /**

     * Compressor: PHP Zstandard.

     */

    const COMPRESSION_ZSTD      = 'zstd';

    /** @var array $host save_path string  */

    protected array $host = [];

    /** @var int $port The port to connect to */

    protected $port = 6379;

    /** @var array $sslopts SSL options, if applicable */

    protected $sslopts = [];

    /** @var string $auth redis password  */

    protected $auth = '';

    /** @var int $database the Redis database to store sesions in */

    protected $database = 0;

    /** @var array $servers list of servers parsed from save_path */

    protected $prefix = '';

    /** @var int $acquiretimeout how long to wait for session lock in seconds */

    protected $acquiretimeout = 120;

    /** @var int $acquirewarn how long before warning when waiting for a lock in seconds */

    protected $acquirewarn = null;

    /** @var int $lockretry how long to wait between session lock attempts in ms */

    protected $lockretry = 100;

    /** @var int $serializer The serializer to use */

    protected $serializer = \Redis::SERIALIZER_PHP;

    /** @var int $compressor The compressor to use */

    protected $compressor = self::COMPRESSION_NONE;

    /** @var string $lasthash hash of the session data content */

    protected $lasthash = null;

    /**

     * @var int $lockexpire how long to wait in seconds before expiring the lock automatically

     * so that other requests may continue execution, ignored if PECL redis is below version 2.2.0.

     */

    protected $lockexpire;

    /** @var Redis|RedisCluster Connection */

    protected $connection = null;

    /** @var array $locks List of currently held locks by this page. */

    protected $locks = array();

    /** @var int $timeout How long sessions live before expiring. */

    protected $timeout;

    /** @var bool $clustermode Redis in cluster mode. */

    protected bool $clustermode = false;

    /** @var int Maximum number of retries for cache store operations. */

    const MAX_RETRIES = 5;

    /**

     * Create new instance of handler.

     */

    public function __construct() {

        global $CFG;

        if (isset($CFG->session_redis_host)) {

            // If there is only one host, use the single Redis connection.

            // If there are multiple hosts (separated by a comma), use the Redis cluster connection.

            $this->host = array_filter(array_map('trim', explode(',', $CFG->session_redis_host)));

            $this->clustermode = count($this->host) > 1;

        }

        if (isset($CFG->session_redis_port)) {

            $this->port = (int)$CFG->session_redis_port;

        }

        if (isset($CFG->session_redis_encrypt) && $CFG->session_redis_encrypt) {

            $this->sslopts = $CFG->session_redis_encrypt;

        }

        if (isset($CFG->session_redis_auth)) {

            $this->auth = $CFG->session_redis_auth;

        }

        if (isset($CFG->session_redis_database)) {

            $this->database = (int)$CFG->session_redis_database;

        }

        if (isset($CFG->session_redis_prefix)) {

            $this->prefix = $CFG->session_redis_prefix;

        }

        if (isset($CFG->session_redis_acquire_lock_timeout)) {

            $this->acquiretimeout = (int)$CFG->session_redis_acquire_lock_timeout;

        }

        if (isset($CFG->session_redis_acquire_lock_warn)) {

            $this->acquirewarn = (int)$CFG->session_redis_acquire_lock_warn;

        }

        if (isset($CFG->session_redis_acquire_lock_retry)) {

            $this->lockretry = (int)$CFG->session_redis_acquire_lock_retry;

        }

        if (!empty($CFG->session_redis_serializer_use_igbinary) && defined('\Redis::SERIALIZER_IGBINARY')) {

            $this->serializer = \Redis::SERIALIZER_IGBINARY; // Set igbinary serializer if phpredis supports it.

        }

        // The following configures the session lifetime in redis to allow some

        // wriggle room in the user noticing they've been booted off and

        // letting them log back in before they lose their session entirely.

        $updatefreq = empty($CFG->session_update_timemodified_frequency) ? 20 : $CFG->session_update_timemodified_frequency;

        $this->timeout = $CFG->sessiontimeout + $updatefreq + MINSECS;

        // This sets the Redis session lock expiry time to whatever is lower, either

        // the PHP execution time `max_execution_time`, if the value was defined in

        // the `php.ini` or the globally configured `sessiontimeout`. Setting it to

        // the lower of the two will not make things worse it if the execution timeout

        // is longer than the session timeout.

        // For the PHP execution time, once the PHP execution time is over, we can be sure

        // that the lock is no longer actively held so that the lock can expire safely.

        // Although at `lib/classes/php_time_limit.php::raise(int)`, Moodle can

        // progressively increase the maximum PHP execution time, this is limited to the

        // `max_execution_time` value defined in the `php.ini`.

        // For the session timeout, we assume it is safe to consider the lock to expire

        // once the session itself expires.

        // If we unnecessarily hold the lock any longer, it blocks other session requests.

        $this->lockexpire = ini_get('max_execution_time');

        if (empty($this->lockexpire) || ($this->lockexpire > (int)$CFG->sessiontimeout)) {

            $this->lockexpire = (int)$CFG->sessiontimeout;

        }

        if (isset($CFG->session_redis_lock_expire)) {

            $this->lockexpire = (int)$CFG->session_redis_lock_expire;

        }

        if (isset($CFG->session_redis_compressor)) {

            $this->compressor = $CFG->session_redis_compressor;

        }

    }

    /**

     * Start the session.

     *

     * @return bool success

     */

    public function start() {

        $result = parent::start();

        return $result;

    }

    /**

     * Init session handler.

     */

    public function init() {

        if (!extension_loaded('redis')) {

            throw new exception('sessionhandlerproblem', 'error', '', null, 'redis extension is not loaded');

        }

        if (empty($this->host)) {

            throw new exception('sessionhandlerproblem', 'error', '', null,

                    '$CFG->session_redis_host must be specified in config.php');

        }

        // The session handler requires a version of Redis with the SETEX command (at least 2.0).

        $version = phpversion('Redis');

        if (!$version || version_compare($version, '2.0') <= 0) {

            throw new exception('sessionhandlerproblem', 'error', '', null, 'redis extension version must be at least 2.0');

        }

        $result = session_set_save_handler($this);

        if (!$result) {

            throw new exception('redissessionhandlerproblem', 'error');

        }

        $encrypt = (bool) ($this->sslopts ?? false);

        // Set Redis server(s).

        $trimmedservers = [];

        foreach ($this->host as $host) {

            $server = strtolower(trim($host));

            if (!empty($server)) {

                if ($server[0] === '/' || str_starts_with($server, 'unix://')) {

                    $port = 0;

                    $trimmedservers[] = $server;

                } else {

                    $port = $this->port ?? 6379; // No Unix socket so set default port.

                    if (strpos($server, ':')) { // Check for custom port.

                        list($server, $port) = explode(':', $server);

                    }

                    $trimmedservers[] = $server.':'.$port;

                }

                // We only need the first record for the single redis.

                if (!$this->clustermode) {

                    // Handle the case when the server is not a Unix domain socket.

                    if ($port !== 0) {

                        list($server, ) = explode(':', $trimmedservers[0]);

                    } else {

                        $server = $trimmedservers[0];

                    }

                    break;

                }

            }

        }

        // TLS/SSL Configuration.

        $opts = [];

        if ($encrypt) {

            if ($this->clustermode) {

                $opts = $this->sslopts;

            } else {

                // For a single (non-cluster) Redis, the TLS/SSL config must be added to the 'stream' key.

                $opts['stream'] = $this->sslopts;

            }

        }

        // MDL-59866: Add retries for connections (up to 5 times) to make sure it goes through.

        $counter = 1;

        $exceptionclass = $this->clustermode ? 'RedisClusterException' : 'RedisException';

        while ($counter <= self::MAX_RETRIES) {

            $this->connection = null;

            // Make a connection to Redis server(s).

            try {

                // Create a $redis object of a RedisCluster or Redis class.

                if ($this->clustermode) {

                    $this->connection = new \RedisCluster(null, $trimmedservers, 1, 1, true,

                        $this->auth, !empty($opts) ? $opts : null);

                } else {

                    $delay = rand(100, 500);

                    $this->connection = new \Redis();

                    $this->connection->connect($server, $port, 1, null, $delay, 1, $opts);

                    if ($this->auth !== '' && !$this->connection->auth($this->auth)) {

                        throw new $exceptionclass('Unable to authenticate.');

                    }

                }

                if (!$this->connection->setOption(\Redis::OPT_SERIALIZER, $this->serializer)) {

                    throw new $exceptionclass('Unable to set the Redis PHP Serializer option.');

                }

                if ($this->prefix !== '') {

                    // Use custom prefix on sessions.

                    if (!$this->connection->setOption(\Redis::OPT_PREFIX, $this->prefix)) {

                        throw new $exceptionclass('Unable to set the Redis Prefix option.');

                    }

                }

                if ($this->sslopts && !$this->connection->ping('Ping')) {

                    // In case of a TLS connection,

                    // if phpredis client does not communicate immediately with the server the connection hangs.

                    // See https://github.com/phpredis/phpredis/issues/2332.

                    throw new $exceptionclass("Ping failed");

                }

                if ($this->database !== 0) {

                    if (!$this->connection->select($this->database)) {

                        throw new $exceptionclass('Unable to select the Redis database ' . $this->database . '.');

                    }

                }

                return true;

            } catch (RedisException | RedisClusterException $e) {

                $redishost = $this->clustermode ? implode(',', $this->host) : $server. ':'. $port;

                $logstring = "Failed to connect (try {$counter} out of " . self::MAX_RETRIES . ") to Redis ";

                $logstring .= "at ". $redishost .", the error returned was: {$e->getMessage()}";

                debugging($logstring);

            }

            $counter++;

            // Introduce a random sleep between 100ms and 500ms.

            usleep(rand(100000, 500000));

        }

        if (isset($logstring)) {

            // We have exhausted our retries; it's time to give up.

            throw new $exceptionclass($logstring);

        }

        $result = session_set_save_handler($this);

        if (!$result) {

            throw new exception('redissessionhandlerproblem', 'error');

        }

    }

    /**

     * Update our session search path to include session name when opened.

     *

     * @param string $path  unused session save path. (ignored)

     * @param string $name Session name for this session. (ignored)

     * @return bool true always as we will succeed.

     */

    public function open(string $path, string $name): bool {

        return true;

    }

    /**

     * Close the session completely. We also remove all locks we may have obtained that aren't expired.

     *

     * @return bool true on success.  false on unable to unlock sessions.

     */

    public function close(): bool {

        $this->lasthash = null;

        try {

            foreach ($this->locks as $id => $expirytime) {

                if ($expirytime > $this->time()) {

                    $this->unlock_session($id);

                }

                unset($this->locks[$id]);

            }

        } catch (RedisException | RedisClusterException $e) {

            error_log('Failed talking to redis: '.$e->getMessage());

            return false;

        }

        return true;

    }

    /**

     * Read the session data from storage

     *

     * @param string $id The session id to read from storage.

     * @return string The session data for PHP to process.

     *

     * @throws RedisException when we are unable to talk to the Redis server.

     */

    public function read(string $id): string|false {

        try {

            if ($this->requires_write_lock()) {

                $this->lock_session($id);

            }

            $sessiondata = $this->uncompress($this->connection->get($id));

            if ($sessiondata === false) {

                if ($this->requires_write_lock()) {

                    $this->unlock_session($id);

                }

                $this->lasthash = sha1('');

                return '';

            }

            $this->connection->expire($id, $this->timeout);

        } catch (RedisException | RedisClusterException $e) {

            error_log('Failed talking to redis: '.$e->getMessage());

            throw $e;

        }

        $this->lasthash = sha1(base64_encode($sessiondata));

        return $sessiondata;

    }

    /**

     * Compresses session data.

     *

     * @param mixed $value

     * @return string

     */

    private function compress($value) {

        switch ($this->compressor) {

            case self::COMPRESSION_NONE:

                return $value;

            case self::COMPRESSION_GZIP:

                return gzencode($value);

            case self::COMPRESSION_ZSTD:

                return zstd_compress($value);

            default:

                debugging("Invalid compressor: {$this->compressor}");

                return $value;

        }

    }

    /**

     * Uncompresses session data.

     *

     * @param string $value

     * @return mixed

     */

    private function uncompress($value) {

        if ($value === false) {

            return false;

        }

        switch ($this->compressor) {

            case self::COMPRESSION_NONE:

                break;

            case self::COMPRESSION_GZIP:

                $value = gzdecode($value);

                break;

            case self::COMPRESSION_ZSTD:

                $value = zstd_uncompress($value);

                break;

            default:

                debugging("Invalid compressor: {$this->compressor}");

        }

        return $value;

    }

    /**

     * Write the serialized session data to our session store.

     *

     * @param string $id session id to write.

     * @param string $data session data

     * @return bool true on write success, false on failure

     */

    public function write(string $id, string $data): bool {

        $hash = sha1(base64_encode($data));

        // If the content has not changed don't bother writing.

        if ($hash === $this->lasthash) {

            return true;

        }

        if (is_null($this->connection)) {

            // The session has already been closed, don't attempt another write.

            error_log('Tried to write session: '.$id.' before open or after close.');

            return false;

        }

        // We do not do locking here because memcached doesn't.  Also

        // PHP does open, read, destroy, write, close. When a session doesn't exist.

        // There can be race conditions on new sessions racing each other but we can

        // address that in the future.

        try {

            $data = $this->compress($data);

            $this->connection->setex($id, $this->timeout, $data);

        } catch (RedisException | RedisClusterException $e) {

            error_log('Failed talking to redis: '.$e->getMessage());

            return false;

        }

        return true;

    }

    /**

     * Handle destroying a session.

     *

     * @param string $id the session id to destroy.

     * @return bool true if the session was deleted, false otherwise.

     */

    public function destroy(string $id): bool {

        $this->lasthash = null;

        try {

            $this->connection->del($id);

            $this->unlock_session($id);

        } catch (RedisException | RedisClusterException $e) {

            error_log('Failed talking to redis: '.$e->getMessage());

            return false;

        }

        return true;

    }

    /**

     * Garbage collect sessions.  We don't we any as Redis does it for us.

     *

     * @param integer $max_lifetime All sessions older than this should be removed.

     * @return bool true, as Redis handles expiry for us.

     */

    // phpcs:ignore moodle.NamingConventions.ValidVariableName.VariableNameUnderscore

    public function gc(int $max_lifetime): int|false {

        return false;

    }

    /**

     * Unlock a session.

     *

     * @param string $id Session id to be unlocked.

     */

    protected function unlock_session($id) {

        if (isset($this->locks[$id])) {

            $this->connection->del($id.".lock");

            unset($this->locks[$id]);

        }

    }

    /**

     * Obtain a session lock so we are the only one using it at the moment.

     *

     * @param string $id The session id to lock.

     * @return bool true when session was locked, exception otherwise.

     * @throws exception When we are unable to obtain a session lock.

     */

    protected function lock_session($id) {

        $lockkey = $id.".lock";

        $haslock = isset($this->locks[$id]) && $this->time() < $this->locks[$id];

        $startlocktime = $this->time();

        /* To be able to ensure sessions don't write out of order we must obtain an exclusive lock

         * on the session for the entire time it is open.  If another AJAX call, or page is using

         * the session then we just wait until it finishes before we can open the session.

         */

        // Store the current host, process id and the request URI so it's easy to track who has the lock.

        $hostname = gethostname();

        if ($hostname === false) {

            $hostname = 'UNKNOWN HOST';

        }

        $pid = getmypid();

        if ($pid === false) {

            $pid = 'UNKNOWN';

        }

        $uri = isset($_SERVER['REQUEST_URI']) ? $_SERVER['REQUEST_URI'] : 'unknown uri';

        $whoami = "[pid {$pid}] {$hostname}:$uri";

        $haswarned = false; // Have we logged a lock warning?

        while (!$haslock) {

            $haslock = $this->connection->setnx($lockkey, $whoami);

            if ($haslock) {

                $this->locks[$id] = $this->time() + $this->lockexpire;

                $this->connection->expire($lockkey, $this->lockexpire);

                return true;

            }

            if (!empty($this->acquirewarn) && !$haswarned && $this->time() > $startlocktime + $this->acquirewarn) {

                // This is a warning to better inform users.

                $whohaslock = $this->connection->get($lockkey);

                // phpcs:ignore

                error_log("Warning: Cannot obtain session lock for sid: $id within $this->acquirewarn seconds but will keep trying. " .

                    "It is likely another page ($whohaslock) has a long session lock, or the session lock was never released.");

                $haswarned = true;

            }

            if ($this->time() > $startlocktime + $this->acquiretimeout) {

                // This is a fatal error, better inform users.

                // It should not happen very often - all pages that need long time to execute

                // should close session immediately after access control checks.

                $whohaslock = $this->connection->get($lockkey);

                // phpcs:ignore

                error_log("Error: Cannot obtain session lock for sid: $id within $this->acquiretimeout seconds. " .

                    "It is likely another page ($whohaslock) has a long session lock, or the session lock was never released.");

                $acquiretimeout = format_time($this->acquiretimeout);

                $lockexpire = format_time($this->lockexpire);

                $a = (object)[

                    'id' => substr($id, 0, 10),

                    'acquiretimeout' => $acquiretimeout,

                    'whohaslock' => $whohaslock,

                    'lockexpire' => $lockexpire];

                throw new exception("sessioncannotobtainlock", 'error', '', $a);

            }

            if ($this->time() < $startlocktime + 5) {

                // We want a random delay to stagger the polling load. Ideally

                // this delay should be a fraction of the average response

                // time. If it is too small we will poll too much and if it is

                // too large we will waste time waiting for no reason. 100ms is

                // the default starting point.

                $delay = rand($this->lockretry, (int)($this->lockretry * 1.1));

            } else {

                // If we don't get a lock within 5 seconds then there must be a

                // very long lived process holding the lock so throttle back to

                // just polling roughly once a second.

                $delay = rand(1000, 1100);

            }

            usleep($delay * 1000);

        }

    }

    /**

     * Return the current time.

     *

     * @return int the current time as a unixtimestamp.

     */

    protected function time() {

        return time();

    }

    /**

     * Check the backend contains data for this session id.

     *

     * Note: this is intended to be called from manager::session_exists() only.

     *

     * @param string $sid

     * @return bool true if session found.

     */

    public function session_exists($sid) {

        if (!$this->connection) {

            return false;

        }

        try {

            return !empty($this->connection->exists($sid));

        } catch (RedisException | RedisClusterException $e) {

            return false;

        }

    }

    /**

     * Kill all active sessions, the core sessions table is purged afterwards.

     */

    public function kill_all_sessions() {

        global $DB;

        if (!$this->connection) {

            return;

        }

        $rs = $DB->get_recordset('sessions', array(), 'id DESC', 'id, sid');

        foreach ($rs as $record) {

            $this->destroy($record->sid);

        }

        $rs->close();

    }

    /**

     * Kill one session, the session record is removed afterwards.

     *

     * @param string $sid

     */

    public function kill_session($sid) {

        if (!$this->connection) {

            return;

        }

        $this->destroy($sid);

    }

}