PHP Redis : Comment indexer les clés ?

Discussion dans 'Développement d'un site Web ou d'une appli mobile' créé par ortolojf, 1 Août 2020.

  1. ortolojf
    ortolojf WRInaute accro
    Inscrit:
    14 Août 2002
    Messages:
    3 138
    J'aime reçus:
    12
    Bonjour

    Suis en train d'implémenter mes sessions avec PHP Redis.

    Les méthode suivantes n'agissent que sur des string du genre : $key : $value.

    ttl(), expire(), del(), etc...

    Sur mon petit projet, les valeurs $key : $value sont affectées/lues avec : $connId->hSet($id, [key => $value]);

    Comment gérer les delete et expire() ?

    Suis-je obligé de n'enregistrer que des : ($id . $key) : $value ?

    Mes id de session sont des UUID V4.

    Pour lire les enreg de $id je ferais ( à peu près ) :

    PHP:

      $array_keys 
    = array();

      
    $iterator NULL;
      while(
    $iterator != 0)
      {
                    
    $array_keys $this->connId->scan($iterator"[a-z0-9-]+*");

                   
    //   ... etc...
      
    }

    Merci beaucoup de votre aide.
     
  2. ortolojf
    ortolojf WRInaute accro
    Inscrit:
    14 Août 2002
    Messages:
    3 138
    J'aime reçus:
    12
    Pardon

    J'avais trouvé.

    J'ai mis les enregs dans des "hash", un hash par id de session.

    Chaque id de session est strictement aléatoire, et ( dans mon cas ), du type UUID v4.

    Les expire() ne peuvent être affectés que pour la clé de chaque hash.

    Voici mon session_handler.php

    Merci de vos avis et critiques.

    PHP:

    <?php
    require(__DIR__ '/clientID.php');
    define('MAXLIFETIME'ini_get('session.gc_maxlifetime'));
    define('MAX_IDLE_TIME'300);
    define('MIN_LEFT_TIME'30);
    class 
    CustomSessionHandler implements SessionHandlerInterface,
            
    SessionIdInterface,
            
    SessionUpdateTimestampHandlerInterface
    {
            private 
    $redisConn;
            private 
    $lastCreatedId;
            private 
    $fp null;
            public function    
    __construct()
            {
                    
    $this->fp fopen("/var/www/html/php/config/redis.log""w");
                    
    session_set_save_handler(
                            array(
    $this"open"),
                            array(
    $this"close"),
                            array(
    $this"read"), 
                            array(
    $this"write"), 
                            array(
    $this"destroy"), 
                            array(
    $this"gc"), 
                            array(
    $this"create_sid"), 
                            array(
    $this"validateId"), 
                            array(
    $this"updateTimestamp"));
                    
    fwrite($this->fp"Running session_set_save_handler();\n");
                    
    // Set the shutdown function
                    
    register_shutdown_function('session_write_close');
                    
    fwrite($this->fp"Preparing session_write_close();\n");
                    
    // Define and initialise the Session Handler
                    
    session_start();
                    return 
    true;
            }
            
    /**
            * 1ère fonction.
            **/
            
    public function open($savePath$sessionName)
            {
                    
    /**
                    Parameters
                        host: string. can be a host, or the path to a unix domain socket. Starting from version 5.0.0 it is possible to specify schema port: int, optional
                        timeout: float, value in seconds (optional, default is 0 meaning unlimited)
                        reserved: should be NULL if retry_interval is specified
                        retry_interval: int, value in milliseconds (optional)
                        read_timeout: float, value in seconds (optional, default is 0 meaning unlimited)
                    **/
                    
    try
                    {
                            
    $this->redisConn = new Redis();
                            
    fwrite($this->fp"Instanciation class Redis done.\n");
                    } catch(
    Exception $e) {
                            
    fwrite($this->fp"Erreur instanciation classe Redis : " $e->getMessage() . "\n");
                            return 
    false;
                    }   
                    try
                    {
                            
    $this->redisConn->connect('/var/run/redis/redis.sock'); // unix domain socket.
                            
    fwrite($this->fp"Connect to Redis server done.\n");
                    } catch(
    Exception $e) {
                            
    fwrite($this->fp"Erreur connexion serveur Redis : " $e->getMessage() . "\n");
                            return 
    false;
                    }
                    try
                    {
                            
    $this->redisConn->setOption(Redis::OPT_SCANRedis::SCAN_RETRY);
                            
    fwrite($this->fp"Setting Redis client option done.\n");
                            return 
    true;
                    } catch(
    Exception $e) {
                            
    fwrite($this->fp"Erreur setting option client Redis : " $e->getMessage() . "\n");
                            return 
    false;
                    }
                    return 
    false;
                    
    /* With PhpRedis >= 5.3.0 you can specify authentication information on connect */
                    /**
                    if($this->redisConn->connect('/var/run/redis/redis.sock', 1, NULL, 100, 0, ['auth' => ['phpredis', 'phpredis']]) === true)
                    {
                        return true;
                    }
                    **/
                    // return value should be true for success or false for failure
            
    }
            
    /**
            * 2ème fonction.
            * ( si nouvelle session ).
            **/
            
    public function create_sid()
            {
                    try
                    {
                            
    $this->lastCreatedId clientID();
                    } catch(
    Exception $e) {
                            
    fwrite($this->fp"Erreur création Id : " $e->getMessage() . "\n");
                            return 
    false;
                    }
                    
    // invoked internally when a new session id is needed
                    // no parameter is needed and return value should be the new session id created
                    
    $this->affic("Session Id created"$this->lastCreatedId);
                    return 
    $this->lastCreatedId;
            }
            public function 
    validateId($sessionId)
            {
                    
    $this->affic("Session Id checked"$sessionId);
                    if (
    $sessionId !== $this->lastCreatedId) {
                            return 
    false;
                    }
                    
    fwrite($this->fp"session_id() checked : " session_id() . "\n");
                    if(
    preg_match("{^[a-z0-9-]+$}"session_id()))
                    {
                            return 
    true;
                    }
                    return 
    false;
                    
    // return value should be true if the session id is valid otherwise false
                    // if false is returned a new session id will be generated by php internally
                    // checks session existance
            
    }
            
    /**
            * fonction
            * lecture
            * de l'array
            * lue par hGetAll().
            **/
            
    protected function affic($str$tmp_array)
            {
                    if(
    is_array($tmp_array))
                    {
                            foreach(
    $tmp_array as $key => $value)
                            {
                                    
    fwrite($this->fp"\t\t" $str " : " $key " => " $value "\n");
                            }
                    }
                    else
                    {
                            
    fwrite($this->fp"\t\t" $str " : " $tmp_array "\n");
                    }
            }
            
    /**
            * Dernière fonction.
            **/
            
    public function close()
            {
                    if(
    $this->gc(MAXLIFETIME) === false)
                    {
                            
    fwrite($this->fp"\t\tFailed updating session data while closing the session.\n");
                            
    fclose($this->fp);
                            
    fwrite($this->fp"\t\tClosing the session.\n");
                            
    $this->redisConn->close();
                            return 
    false;
                    }
                    
    fwrite($this->fp"\t\tClosing the session.\n");
                    
    fclose($this->fp);
                    return 
    $this->redisConn->close();
                    
    // return value should be true for success or false for failure
            
    }
            
    /**
            * 3ème fonction
            * si nouvelle fonction,
            * ou 2ème fonction.
            **/
            
    public function read($id)
            {
                    
    $array_read        = array();
                    try
                    {
                            
    $array_read $this->redisConn->hGetAll($id);
                    } catch(
    Exception $err) {
                            
    fwrite($this->fp"Erreur read Data : " $e->getMessage() . "\n");
                            return 
    false;
                    }
                    
    $this->affic("Data read"$array_read);
                    if ((
    is_array($array_read))&&
                            (
    count($array_read) > 0))
                    {
                            
    $_SESSION $array_read;
                            return 
    serialize($array_read);
                    }
                    return 
    "";
            }
            
    /**
            * Avant-dernière fonction,
            * ( si session_write_close(); )
            **/
            
    public function write($id$data)
            {
                    
    $array_write = array();
                    if(
    strlen($data) > 0)
                    {
                            
    $array_write unserialize($data);
                            if(
    count($array_write) > 0)
                            {
                                    foreach(
    $array_write as $key => $value)
                                    {
                                            if(
    $this->redisConn->hSet($id$key$value) === false)
                                            {
                                                    
    $this->affic("Failed writing key : " $key$value);
                                                    return 
    false;
                                            }
                                    }
                                    if(
    $this->redisConn->expire($idMAXLIFETIME) === false)
                                    {
                                        
    $this->affic("Succeded setting key TTL : " $id " => " $key$value);
                                        return 
    false;
                                    }
                            }
                    }
                    
    $this->affic("Data written"$array_write);
                    return 
    true;
                    
    //                return file_put_contents("$this->savePath/sess_$id", $data) === false ? false : true;
                    // return value should be true for success or false for failure
            
    }
            
    /**
            * Avant-dernière fonction,
            *         après 
            *    session_regenerate_id(),
            *    session_destroy(),
            *    ou session_decode() === false
            **/
            
    public function destroy($id)
            {
                    
    /**
                    * Seulement
                    * pour la session
                    *     $id.
                    */
                    
    $array_del = array();
                    
    $array_del $this->redisConn->hGetAll($id);
                    
    $this->affic("Data destroyed"$array_del);
                    foreach(
    $array_del as $key => $value)
                    {
                            if(
    $this->redisConn->hDel($id$key) === false)
                            {
                                    
    $this->affic("Failed to destroy the session key : " $id " => " $key$value);
                                    return 
    false;
                            }
                    }
                    if(
    $this->redisConn->del($id) === false)
                    {
                            
    fwrite($this->fp"\t\tFailed to destroy the session.\n");
                            return 
    false;
                    }
                    return 
    true;
                    
    // return value should be true for success or false for failure
            
    }
            
    /**
            * Après session_start(),
            * en fonction de 
            * session.gc_divisor, 
            * session.gc_probability, 
            * session.gc_maxlifetime
            **/
            /**
            * Fonction globale
            */
            
    public function gc($maxlifetime)
            {
                    
    $array_keys = array();
                    
    /**
                    * Lecture $str_key
                    * des id_sessions.
                    **/
                    
    $array_keys $this->redisConn->keys("*");
                    
    $this->affic("\$array_keys"$array_keys);
                    foreach(
    $array_keys as $str_key)
                    {
                        if(
    $str_key == $this->lastCreatedId)
                        {
                            continue;
                        }
    //                    if(preg_match("#^[a-z0-9]{8}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{12}$#", $str_key))
                        
    if(preg_match("#^[a-z0-9-]+$#"$str_key))
                        {
                            unset(
    $ttl);
                            
    $ttl $this->redisConn->ttl($str_key);
    //                        $this->affic("Key TTL : " . $str_key, $ttl);
                            
    if(($ttl 0)&&($ttl != -2))
                            {
    //                            $this->affic("Key TTL : " . $str_key, $ttl);
                                
    $array_del = array();
                                
    $array_del $this->redisConn->hGetAll($str_key);
                                
    $this->affic("Array_keys to delete"$array_del);
                                foreach(
    $array_del as $key => $value)
                                {
                                    
    $this->affic("Key to be deleted = " $str_key$key);
                                    if(
    $this->redisConn->hDel($str_key$key) === false)
                                    {
                                        
    $this->affic("Failed deleting key : " $str_key " => " $key$value);
                                        return 
    false;
                                    }
                                    else
                                    {
                                        
    $this->affic("Succeded deleting key : " $str_key " => " $key$value);
                                    }
                                }
                                if(
    $this->redisConn->del($str_key) === false)
                                {
                                        
    $this->affic("Failed deleting key"$str_key);
                                        return 
    false;
                                }
                                else
                                {
                                    
    $this->affic("Succeded deleting key"$str_key);
                                }
                            }
                        }
                    }
                    return 
    true;
                    
    // return value should be true for success or false for failure
                    /**
                    foreach (glob("$this->savePath/sess_*") as $file) {
                            if (filemtime($file) + $maxlifetime < time() && file_exists($file)) {
                                    unlink($file);
                            }
                    }
                    **/
            
    }
            public function 
    updateTimestamp($id$data)
            {
                    
    $array_updated    = array();
                    
    $array_read        = array();
                    
    $array_read        unserialize($data);
                    
    //    $array_read = $this->redisConn->hGetAll($id);
                    
    foreach($array_read as $key => $value)
                    {
                        
    $this->affic("Attempting to update the session key " $key " TTL = " $this->redisConn->ttl($key), $value);
                        if(
    $this->redisConn->hExists($this->lastCreatedId$key) === true)
                        {
                            if(
    $this->redisConn->expire($keyMAX_IDLE_TIME) === false)
                            {
                                
    $this->affic("Failed while updating the session key TTL" $key$value);
                                return 
    false;
                            }
                            
    $this->affic("Succeded while updating the session key TTL" $key$value);
                        }
                    }
                           
                    return 
    true;
                    
    // return value should be true for success or false for failure
            
    }
    }
    $handler = new CustomSessionHandler();
    // if (session_status() == PHP_SESSION_NONE) {session_start();}
    //    session_set_save_handler ( callable $open , callable $close , callable $read , callable $write , callable $destroy , callable $gc [, callable $create_sid [, callable $validate_sid [, callable $update_timestamp ]]] ) : bool
    ?>

     
  3. ortolojf
    ortolojf WRInaute accro
    Inscrit:
    14 Août 2002
    Messages:
    3 138
    J'aime reçus:
    12
    Rebond.

    La fonction gc() ne se déclenche que si (time() % 6000) < 6).

    J'obtiens environ 180 clés simultanées dans redis.log.

    J'ai mis celà sur mon site.

    Prenez si vous voulez.

    PHP:

    <?php

    /**
      * session_handler.php
     **/
    require(__DIR__ '/clientID.php');
    define('MAXLIFETIME'ini_get('session.gc_maxlifetime'));
    define('MAX_IDLE_TIME'300);
    define('MIN_LEFT_TIME'30);
    define('ID_KEY''x9NNGejdBGrwlZCkBBAqTYZlD82tzj4w');
    define('COUNT_KEY''COUNT_KEY');
    define('GC_PERIOD'6000);
    class 
    CustomSessionHandler implements SessionHandlerInterface,
        
    SessionIdInterface,
        
    SessionUpdateTimestampHandlerInterface
    {
        private 
    $redisConn;
        private 
    $lastCreatedId;
        private 
    $fp;
        public function    
    __construct()
        {
            
    session_set_save_handler(
                array(
    $this"open"),
                array(
    $this"close"),
                array(
    $this"read"), 
                array(
    $this"write"), 
                array(
    $this"destroy"), 
                array(
    $this"gc"), 
                array(
    $this"create_sid"), 
                array(
    $this"validateId"), 
                array(
    $this"updateTimestamp"));
            
    // Set the shutdown function
            
    register_shutdown_function('session_write_close');
            
    // Define and initialise the Session Handler
            
    session_start();
            return 
    true;
        }
        
    /**
        * 1ère fonction.
        **/
        
    public function open($savePath$sessionName)
        {
                    
    /**
                    Parameters
                        host: string. can be a host, or the path to a unix domain socket. Starting from version 5.0.0 it is possible to specify schema port: int, optional
                        timeout: float, value in seconds (optional, default is 0 meaning unlimited)
                        reserved: should be NULL if retry_interval is specified
                        retry_interval: int, value in milliseconds (optional)
                        read_timeout: float, value in seconds (optional, default is 0 meaning unlimited)
                    **/
            
    try
            {
                
    $this->redisConn = new Redis();
            } catch(
    Exception $e) {
                return 
    false;
            }   
            try
            {
                
    $this->redisConn->connect('/var/run/redis/redis.sock'); // unix domain socket.
            
    } catch(Exception $e) {
                
    $this->redisConn->close();
                return 
    false;
            }
            try
            {
                
    $this->redisConn->setOption(Redis::OPT_SCANRedis::SCAN_RETRY);
                return 
    true;
            } catch(
    Exception $e) {
                
    $this->redisConn->close();
                return 
    false;
            }
            return 
    false;
            
    /* With PhpRedis >= 5.3.0 you can specify authentication information on connect */
                    /**
                    if($this->redisConn->connect('/var/run/redis/redis.sock', 1, NULL, 100, 0, ['auth' => ['phpredis', 'phpredis']]) === true)
                    {
                        return true;
                    }
                    **/
            // return value should be true for success or false for failure
        
    }
        
    /**
        * 2ème fonction.
        * ( si nouvelle session ).
        **/
        
    public function create_sid()
        {
            try
            {
                
    $this->lastCreatedId clientID();
            } catch(
    Exception $e) {
                return 
    false;
            }
            
    // invoked internally when a new session id is needed
            // no parameter is needed and return value should be the new session id created
            
    return $this->lastCreatedId;
        }
        public function 
    validateId($sessionId)
        {
            if (
    $sessionId !== $this->lastCreatedId) {
                return 
    false;
            }
            if((
    strlen(session_id()) > 2)&&(preg_match("#^[a-z0-9-]+$#"session_id())))
            {
                return 
    true;
            }
            return 
    false;
            
    // return value should be true if the session id is valid otherwise false
            // if false is returned a new session id will be generated by php internally
            // checks session existance
        
    }
        
    /**
        * Dernière fonction.
        **/
        
    public function close()
        {
            
    /**
            if($this->gc(MAXLIFETIME) === false)
            {
                $this->redisConn->close();
                return false;
            }
            **/
            
    return $this->redisConn->close();
            
    // return value should be true for success or false for failure
        
    }
        
    /**
        * 3ème fonction
        * si nouvelle fonction,
        * ou 2ème fonction.
        **/
        
    public function affic($key$tmp_array)
        {
            if(
    is_array($tmp_array))
            {
                    foreach(
    $tmp_array as $key2 => $value)
                    {
                        
    fwrite($this->fp$key " => " $key2 " => " $value "\n");
                    }
            }
            else
            {
                
    fwrite($this->fp$key " => " $tmp_array "\n");
            }
            return 
    true;
        }
        
    /**
        * 3ème fonction
        * si nouvelle fonction,
        * ou 2ème fonction.
        **/
        
    public function read($id)
        {
            
    $array_read        = array();
            try
            {
                
    $array_read $this->redisConn->hGetAll($id);
            } catch(
    Exception $err) {
                return 
    false;
            }
            if ((
    is_array($array_read))&&
                (
    count($array_read) > 0))
            {
                
    $_SESSION $array_read;
                return 
    serialize($array_read);
            }
            return 
    "";
        }
        
    /**
        * Avant-dernière fonction,
        * ( si session_write_close(); )
        **/
        
    public function run_gc()
        {
            if((
    time() % GC_PERIOD) <= 6)
            {
                if(
    $this->gc(MAXLIFETIME) === false)
                {
                    
    $this->redisConn->close();
                    return 
    false;
                }
            }
            return 
    true;
        }
        
    /**
        * Avant-dernière fonction,
        * ( si session_write_close(); )
        **/
        
    public function write($id$data)
        {
            
    $array_write = array();
            if(
    strlen($data) > 0)
            {
                
    $array_write unserialize($data);
                if(
    count($array_write) > 0)
                {
                    foreach(
    $array_write as $key => $value)
                    {
                        if(
    $this->redisConn->hSet($id$key$value) === false)
                        {
                            
    $this->redisConn->close();
                            return 
    false;
                        }
                        if(
    $this->redisConn->expire($idMAXLIFETIME) === false)
                        {
                            
    $this->redisConn->close();
                            return 
    false;
                        }
                    }
                }
            }
            return 
    $this->run_gc();
            
    //                return file_put_contents("$this->savePath/sess_$id", $data) === false ? false : true;
            // return value should be true for success or false for failure
        
    }
        
    /**
        * Avant-dernière fonction,
        *         après 
        *    session_regenerate_id(),
        *    session_destroy(),
        *    ou session_decode() === false
        **/
        
    public function destroy($id)
        {
            
    /**
            * Seulement
            * pour la session
            *     $id.
            */
            
    $array_del = array();
            
    $array_del $this->redisConn->hGetAll($id);
            foreach(
    $array_del as $key => $value)
            {
                if(
    $this->redisConn->hDel($id$key) === false)
                {
                    return 
    false;
                }
            }
            if(
    $this->redisConn->del($id) === false)
            {
                return 
    false;
            }
            return 
    true;
            
    // return value should be true for success or false for failure
        
    }
        
    /**
        * Après session_start(),
        * en fonction de 
        * session.gc_divisor, 
        * session.gc_probability, 
        * session.gc_maxlifetime
        **/
        /**
        * Fonction globale
        */
        
    public function gc($maxlifetime)
        {
            
    $array_keys = array();
            
    $i 0;
            
    $iterator null;
            while(
    $iterator !== 0)
            {
                
    /**
                * Lecture $str_key
                * des id_sessions.
                **/
                
    $array_keys $this->redisConn->scan($iterator'*');
                   
                
    $array_only_keys preg_filter("{([a-z]+|-)}"$array_keys);
                
    $i += count($array_keys);
                foreach(
    $array_keys as $str_key)
                {
                    if((
    $str_key == $this->lastCreatedId)||
                            (
    $str_key == ID_KEY))
                    {
                            continue;
                    }
                    if((
    strlen($str_key) > 2)&&(preg_match("#^[a-z0-9-]+$#"$str_key)))
                    {
                        unset(
    $ttl);
                        
    $ttl $this->redisConn->ttl($str_key);
                        if((
    $ttl 0)&&($ttl != -2))
                        {
                            
    $array_del = array();
                            
    $array_del $this->redisConn->hGetAll($str_key);
                            foreach(
    $array_del as $key => $value)
                            {
                                if(
    $this->redisConn->hDel($str_key$key) === false)
                                {
                                    return 
    false;
                                }
                            }
                            if(
    $this->redisConn->del($str_key) === false)
                            {
                                return 
    false;
                            }
                        }
                    }
                }
            }
            
    $this->fp fopen(__DIR__ "/redis.log""w");
           
            if(
    $this->redisConn->hSet(ID_KEYCOUNT_KEY$i) === false)
            {
                
    $this->affic("\$this->redisConn->hSet(ID_KEY, COUNT_KEY"$this->redisConn->hGet(ID_KEYCOUNT_KEY) . " Keys failed.");
                return 
    false;
            }
            
    $this->affic("\$this->redisConn->hSet(ID_KEY, COUNT_KEY"$this->redisConn->hGet(ID_KEYCOUNT_KEY) . " Keys succeded.");
            
    fclose($this->fp);
            return 
    true;
            
    // return value should be true for success or false for failure
                    /**
                    foreach (glob("$this->savePath/sess_*") as $file) {
                            if (filemtime($file) + $maxlifetime < time() && file_exists($file)) {
                                    unlink($file);
                            }
                    }
                    **/
        
    }
        public function 
    updateTimestamp($id$data)
        {
            
    $array_updated    = array();
            
    $array_read        = array();
            
    $array_read        unserialize($data);
            
    //    $array_read = $this->redisConn->hGetAll($id);
            
    foreach($array_read as $key => $value)
            {
                if(
    $this->redisConn->hExists($id$key) === true)
                {
                    if(
    $this->redisConn->expire($idMAX_IDLE_TIME) === false)
                    {
                        return 
    false;
                    }
                    return 
    true;
                }
            }
            return 
    true;
            
    // return value should be true for success or false for failure
        
    }
    }
    $handler = new CustomSessionHandler();
    // if (session_status() == PHP_SESSION_NONE) {session_start();}
    //    session_set_save_handler ( callable $open , callable $close , callable $read , callable $write , callable $destroy , callable $gc [, callable $create_sid [, callable $validate_sid [, callable $update_timestamp ]]] ) : bool
    ?>

     
  4. ortolojf
    ortolojf WRInaute accro
    Inscrit:
    14 Août 2002
    Messages:
    3 138
    J'aime reçus:
    12
    Excusez-moi

    J'ai mis le gc.filemtime à 1440 et le gc.divisor à 1000 ( après 100 ).

    Je me suis aperçu que la fonction gc() était lancée sans que j'ais besoin de le faire manuellement.

    Voici le log.

    read Keys c'est le nbre total de clés-enregs

    delete Keys c'est le nbre de clés-enregs à deleter.

    Le blème, c'est que aucune clé semble exister.

    Donc il n'y a pas de delete faits.

    Cependant, le nombre de clés total n'augmente pas.

    Par quel miracle, les clés sont effacées avant que gc() ne soit lancée ?

    Le DELAY c'était quand je faisais moi-même les lancements de gc().

    Merci beaucoup de votre aide.

    Amicalement.

    Code:
    
    *************************************************************************
        DELAY = 600 secondes, Date mesure = 03/08/2020 11:03:35
    *************************************************************************
        $this->redisConn->hSet(ID_KEY, GC_KEY => 128 read Keys succeded.
        $this->redisConn->hSet(ID_KEY, GC_DELETED => 0 delete Keys succeded.
    *************************************************************************
        DELAY = 600 secondes, Date mesure = 03/08/2020 11:05:07
    *************************************************************************
        $this->redisConn->hSet(ID_KEY, GC_KEY => 107 read Keys succeded.
        $this->redisConn->hSet(ID_KEY, GC_DELETED => 0 delete Keys succeded.
    *************************************************************************
        DELAY = 600 secondes, Date mesure = 03/08/2020 11:12:40
    *************************************************************************
        $this->redisConn->hSet(ID_KEY, GC_KEY => 99 read Keys succeded.
        $this->redisConn->hSet(ID_KEY, GC_DELETED => 0 delete Keys succeded.
    *************************************************************************
        DELAY = 600 secondes, Date mesure = 03/08/2020 11:19:28
    *************************************************************************
        $this->redisConn->hSet(ID_KEY, GC_KEY => 89 read Keys succeded.
        $this->redisConn->hSet(ID_KEY, GC_DELETED => 0 delete Keys succeded.
    *************************************************************************
        DELAY = 600 secondes, Date mesure = 03/08/2020 11:19:38
    *************************************************************************
        $this->redisConn->hSet(ID_KEY, GC_KEY => 90 read Keys succeded.
        $this->redisConn->hSet(ID_KEY, GC_DELETED => 0 delete Keys succeded.
    *************************************************************************
        DELAY = 600 secondes, Date mesure = 03/08/2020 11:20:05
    *************************************************************************
        $this->redisConn->hSet(ID_KEY, GC_KEY => 100 read Keys succeded.
        $this->redisConn->hSet(ID_KEY, GC_DELETED => 0 delete Keys succeded.
    *************************************************************************
        DELAY = 600 secondes, Date mesure = 03/08/2020 11:20:18
    *************************************************************************
        $this->redisConn->hSet(ID_KEY, GC_KEY => 98 read Keys succeded.
        $this->redisConn->hSet(ID_KEY, GC_DELETED => 0 delete Keys succeded.
    
    
     
Chargement...
Similar Threads - PHP Redis indexer Forum Date
Quelle doc sur PHPRedis ? Développement d'un site Web ou d'une appli mobile 24 Juillet 2020
[PHP x64] Touts les vendredis 13 pendant 31000 ans Développement d'un site Web ou d'une appli mobile 15 Juillet 2012
réécrire /categorie.php?id=xxx en /categorie/id URL Rewriting et .htaccess 13 Septembre 2020
Rediriger Index.php vers racine URL Rewriting et .htaccess 15 Août 2020
Galère pour supprimer index.php URL Rewriting et .htaccess 12 Août 2020
PHP session perso : session_start() en erreur. Développement d'un site Web ou d'une appli mobile 27 Juillet 2020
Memcached/PHP gestion de sessions Développement d'un site Web ou d'une appli mobile 22 Juillet 2020
PHP empêcher form onsubmit si formulaire invalide Développement d'un site Web ou d'une appli mobile 29 Juin 2020
Parser en php un fichier xml Développement d'un site Web ou d'une appli mobile 12 Juin 2020
UX sur Android (et iOS) : Le $_POST en php qui fait mal Développement d'un site Web ou d'une appli mobile 10 Juin 2020