Class yii\redis\Connection

                public function __call($name, $params)
{
    $redisCommand = strtoupper(Inflector::camel2words($name, false));
    if (in_array($redisCommand, $this->redisCommands)) {
        return $this->executeCommand($redisCommand, $params);
    }
    return parent::__call($name, $params);
}

            

                public function __sleep()
{
    $this->close();
    return array_keys(get_object_vars($this));
}

            

                public function close(): void
{
    foreach ($this->_pool as $socket) {
        $connection = $this->connectionString . ', database=' . $this->database;
        \Yii::debug('Closing DB connection: ' . $connection, __METHOD__);
        try {
            $this->executeCommand('QUIT');
        } catch (SocketException $e) {
            // ignore errors when quitting a closed connection
        }
        fclose($socket);
    }
    $this->_pool = [];
}

            

                public function executeCommand($name, $params = [])
{
    $this->open();
    $params = array_merge(explode(' ', $name), $params);
    $command = '*' . count($params) . "\r\n";
    foreach ($params as $arg) {
        $command .= '$' . mb_strlen($arg ?? '', '8bit') . "\r\n" . $arg . "\r\n";
    }
    \Yii::debug("Executing Redis Command: {$name}", __METHOD__);
    if ($this->retries > 0) {
        $tries = $this->retries;
        while ($tries-- > 0) {
            try {
                return $this->sendRawCommand($command, $params);
            } catch (SocketException $e) {
                \Yii::error($e, __METHOD__);
                // backup retries, fail on commands that fail inside here
                $retries = $this->retries;
                $this->retries = 0;
                $this->close();
                if ($this->retryInterval > 0) {
                    usleep($this->retryInterval);
                }
                try {
                    $this->open();
                } catch (SocketException $exception) {
                    // Fail to run initial commands, skip current try
                    \Yii::error($exception, __METHOD__);
                    $this->close();
                } catch (Exception $exception) {
                    $this->close();
                }
                $this->retries = $retries;
            }
        }
    }
    return $this->sendRawCommand($command, $params);
}

            

                public function getConnectionString()
{
    if ($this->unixSocket) {
        return 'unix://' . $this->unixSocket;
    }
    return $this->scheme . '://' . ($this->redirectConnectionString ?: "$this->hostname:$this->port");
}

            

                public function getDriverName()
{
    return 'redis';
}

            

                public function getIsActive(): bool
{
    return ArrayHelper::getValue($this->_pool, $this->connectionString, false) !== false;
}

            

                public function getLuaScriptBuilder()
{
    return new LuaScriptBuilder();
}

            

                public function getSocket()
{
    return ArrayHelper::getValue($this->_pool, $this->connectionString, false);
}

            

                protected function initConnection()
{
    $this->trigger(self::EVENT_AFTER_OPEN);
}

            

                public function open(): void
{
    if ($this->socket !== false) {
        return;
    }
    $connection = $this->connectionString . ', database=' . $this->database;
    \Yii::debug('Opening redis DB connection: ' . $connection, __METHOD__);
    $socket = @stream_socket_client(
        $this->connectionString,
        $errorNumber,
        $errorDescription,
        $this->connectionTimeout ?: ini_get('default_socket_timeout'),
        $this->socketClientFlags,
        stream_context_create($this->contextOptions)
    );
    if ($socket) {
        $this->_pool[ $this->connectionString ] = $socket;
        if ($this->dataTimeout !== null) {
            stream_set_timeout($socket, $timeout = (int) $this->dataTimeout, (int) (($this->dataTimeout - $timeout) * 1000000));
        }
        if ($this->useSSL) {
            stream_socket_enable_crypto($socket, true, STREAM_CRYPTO_METHOD_TLS_CLIENT);
        }
        if ($this->password !== null) {
            $this->executeCommand('AUTH', array_filter([$this->username, $this->password]));
        }
        if ($this->database !== null) {
            $this->executeCommand('SELECT', [$this->database]);
        }
        $this->initConnection();
    } else {
        \Yii::error("Failed to open redis DB connection ($connection): $errorNumber - $errorDescription", __CLASS__);
        $message = YII_DEBUG ? "Failed to open redis DB connection ($connection): $errorNumber - $errorDescription" : 'Failed to open DB connection.';
        throw new Exception($message, $errorDescription, $errorNumber);
    }
}

            

                protected function sendRawCommand($command, $params)
{
    $written = @fwrite($this->socket, $command);
    if ($written === false) {
        throw new SocketException("Failed to write to socket.\nRedis command was: " . $command);
    }
    if ($written !== ($len = mb_strlen($command, '8bit'))) {
        throw new SocketException("Failed to write to socket. $written of $len bytes written.\nRedis command was: " . $command);
    }
    return $this->parseResponse($params, $command);
}