Subversion Repositories Applications.framework

<?php
class CacheSqlite {
        /**
         * Options disponibles :
         *
         * ====> (string) stockage_chemin :
         * Chemin vers le fichier contenant la base SQLite.
         * 
         *
         * ====> (int) defragmentation_auto :
         * - Désactive / Régler le processus de défragmentation automatique
         * - Le processus de défragmentation automatiques réduit la taille du fichier contenant la base de données
         *   quand un ajout ou une suppression de cache est réalisée :
         *       0                         => pas de défragmentation automatique
         *       1                         => défragmentation automatique systématique
         *       x (integer) > 1 => défragmentation automatique toutes les 1 fois (au hasard) sur x ajout ou suppression de cache
         *
         * @var array options disponibles
         */
        protected $options = array(
                'stockage_chemin' => null,
                'defragmentation_auto' => 10
        );
        
        /**
         * DB ressource
         *
         * @var mixed $db
         */
        private $bdd = null;

        /**
         * Boolean to store if the structure has benn checked or not
         *
         * @var boolean $structure_ok
         */
        private $structure_ok = false;

        private $Cache = null;
        
        /**
         * Constructor
         *
         * @param  array $options Associative array of options
         * @throws Zend_cache_Exception
         * @return void
         */
        public function __construct(array $options = array(), Cache $cache) {
                $this->Cache = $cache;
                if (extension_loaded('sqlite')) {
                        $this->initialiserOptionsParConfig();
                        $this->setOptions($options);
                } else {
                        $e = "Impossible d'utiliser le cache SQLITE car l'extenssion 'sqlite' n'est pas chargée dans l'environnement PHP courrant.";
                        trigger_error($e, E_USER_ERROR);
                }
        }
        
        private function initialiserOptionsParConfig() {
                while (list($nom, $valeur) = each($this->options)) {
                        if (Config::existe($nom)) {
                                $this->options[$nom] = Config::get($nom);
                        }
                }
        }
        
        /**
         * Destructor
         *
         * @return void
         */
        public function __destruct() {
                @sqlite_close($this->getConnexion());
        }
        
        private function setOptions($options) {
                while (list($nom, $valeur) = each($options)) {
                        if (!is_string($nom)) {
                                trigger_error("Nom d'option incorecte : $nom", E_USER_WARNING);
                        }
                        $nom = strtolower($nom);
                        if (array_key_exists($nom, $this->options)) {
                                $this->options[$nom] = $valeur;
                        }
                }
        }
        
        public function setEmplacement($emplacement) {
                if (extension_loaded('sqlite')) {
                        $this->options['stockage_chemin'] = $emplacement;
                } else {
                        trigger_error("Impossible d'utiliser le mode de sotckage SQLite car l'extenssion 'sqlite' n'est pas chargé dans ".
                                "l'environnement PHP courrant.", E_USER_ERROR);
                }
        }

        /**
         * Test if a cache is available for the given id and (if yes) return it (false else)
         *
         * @param  string  $id                                   Cache id
         * @param  boolean $doNotTestCacheValidity If set to true, the cache validity won't be tested
         * @return string|false Cached datas
         */
        public function charger($id, $ne_pas_tester_validiter_du_cache = false) {
                $this->verifierEtCreerStructureBdd();
                $requete = "SELECT content FROM cache WHERE id = '$id'".
                        (($ne_pas_tester_validiter_du_cache) ? '' : ' AND (expire = 0 OR expire > '.time().')');
                $resultat = $this->requeter($requete);
                $ligne = @sqlite_fetch_array($resultat);
                return ($ligne) ? $ligne['content'] : false;
        }

        /**
         * Test if a cache is available or not (for the given id)
         *
         * @param string $id Cache id
         * @return mixed|false (a cache is not available) or "last modified" timestamp (int) of the available cache record
         */
        public function tester($id) {
                $this->verifierEtCreerStructureBdd();
                $requete = "SELECT lastModified FROM cache WHERE id = '$id' AND (expire = 0 OR expire > ".time().')';
                $resultat = $this->requeter($requete);
                $ligne = @sqlite_fetch_array($resultat);
                return ($ligne) ? ((int) $ligne['lastModified']) : false;
        }

        /**
         * Save some string datas into a cache record
         *
         * Note : $data is always "string" (serialization is done by the
         * core not by the backend)
         *
         * @param  string $data                  Datas to cache
         * @param  string $id                      Cache id
         * @param  array  $tags                  Array of strings, the cache record will be tagged by each string entry
         * @param  int  $specificLifetime If != false, set a specific lifetime for this cache record (null => infinite lifetime)
         * @throws Zend_Cache_Exception
         * @return boolean True if no problem
         */
        public function sauver($donnees, $id, $tags = array(), $duree_vie_specifique = false) {
                $this->verifierEtCreerStructureBdd();
                $donnees = @sqlite_escape_string($donnees);
                $timestamp_courrant = time();
                $expiration = $this->Cache->getTimestampExpiration($duree_vie_specifique);

                $this->requeter("DELETE FROM cache WHERE id = '$id'");
                $sql = "INSERT INTO cache (id, content, lastModified, expire) VALUES ('$id', '$donnees', $timestamp_courrant, $expiration)";
                $resultat = $this->requeter($sql);
                if (!$resultat) {
                        // TODO : ajouter un log sauver() : impossible de stocker le cache d'id '$id'
                        Debug::printr("sauver() : impossible de stocker le cache d'id '$id'");
                        $resultat =  false;
                } else {
                        $resultat = true;
                        foreach ($tags as $tag) {
                                $resultat = $this->enregisterTag($id, $tag) && $resultat;
                        }
                }
                return $resultat;
        }

        /**
         * Remove a cache record
         *
         * @param  string $id Cache id
         * @return boolean True if no problem
         */
        public function supprimer($id) {
                $this->verifierEtCreerStructureBdd();
                $resultat = $this->requeter("SELECT COUNT(*) AS nbr FROM cache WHERE id = '$id'");
                $resultat_nbre = @sqlite_fetch_single($resultat);
                $suppression_cache = $this->requeter("DELETE FROM cache WHERE id = '$id'");
                $suppression_tags = $this->requeter("DELETE FROM tag WHERE id = '$id'");
                $this->defragmenterAutomatiquement();
                return ($resultat_nbre && $suppression_cache && $suppression_tags);
        }

        /**
         * Clean some cache records
         *
         * Available modes are :
         * Zend_Cache::CLEANING_MODE_ALL (default)      => remove all cache entries ($tags is not used)
         * Zend_Cache::CLEANING_MODE_OLD                          => remove too old cache entries ($tags is not used)
         * Zend_Cache::CLEANING_MODE_MATCHING_TAG        => remove cache entries matching all given tags
         *                                                                                         ($tags can be an array of strings or a single string)
         * Zend_Cache::CLEANING_MODE_NOT_MATCHING_TAG => remove cache entries not {matching one of the given tags}
         *                                                                                         ($tags can be an array of strings or a single string)
         * Zend_Cache::CLEANING_MODE_MATCHING_ANY_TAG => remove cache entries matching any given tags
         *                                                                                         ($tags can be an array of strings or a single string)
         *
         * @param  string $mode Clean mode
         * @param  array  $tags Array of tags
         * @return boolean True if no problem
         */
        public function nettoyer($mode = Cache::NETTOYAGE_MODE_TOUS, $tags = array()) {
                $this->verifierEtCreerStructureBdd();
                $retour = $this->nettoyerSqlite($mode, $tags);
                $this->defragmenterAutomatiquement();
                return $retour;
        }

        /**
         * Return an array of stored cache ids
         *
         * @return array array of stored cache ids (string)
         */
        public function getIds() {
                $this->verifierEtCreerStructureBdd();
                $resultat = $this->requeter('SELECT id FROM cache WHERE (expire = 0 OR expire > '.time().')');
                $retour = array();
                while ($id = @sqlite_fetch_single($resultat)) {
                        $retour[] = $id;
                }
                return $retour;
        }

        /**
         * Return an array of stored tags
         *
         * @return array array of stored tags (string)
         */
        public function getTags() {
                $this->verifierEtCreerStructureBdd();
                $resultat = $this->requeter('SELECT DISTINCT(name) AS name FROM tag');
                $retour = array();
                while ($id = @sqlite_fetch_single($resultat)) {
                        $retour[] = $id;
                }
                return $retour;
        }

        /**
         * Return an array of stored cache ids which match given tags
         *
         * In case of multiple tags, a logical AND is made between tags
         *
         * @param array $tags array of tags
         * @return array array of matching cache ids (string)
         */
        public function getIdsAvecLesTags($tags = array()) {
                $this->verifierEtCreerStructureBdd();
                $premier = true;
                $ids = array();
                foreach ($tags as $tag) {
                        $resultat = $this->requeter("SELECT DISTINCT(id) AS id FROM tag WHERE name='$tag'");
                        if ($resultat) {
                                $lignes = @sqlite_fetch_all($resultat, SQLITE_ASSOC);
                                $ids_tmp = array();
                                foreach ($lignes as $ligne) {
                                        $ids_tmp[] = $ligne['id'];
                                }
                                if ($premier) {
                                        $ids = $ids_tmp;
                                        $premier = false;
                                } else {
                                        $ids = array_intersect($ids, $ids_tmp);
                                }
                        }
                }
                
                $retour = array();
                if (count($ids) > 0) {
                        foreach ($ids as $id) {
                                $retour[] = $id;
                        }
                }
                return $retour;
        }

        /**
         * Return an array of stored cache ids which don't match given tags
         *
         * In case of multiple tags, a logical OR is made between tags
         *
         * @param array $tags array of tags
         * @return array array of not matching cache ids (string)
         */
        public function getIdsSansLesTags($tags = array()) {
                $this->verifierEtCreerStructureBdd();
                $resultat = $this->requeter('SELECT id FROM cache');
                $lignes = @sqlite_fetch_all($resultat, SQLITE_ASSOC);
                $retour = array();
                foreach ($lignes as $ligne) {
                        $id = $ligne['id'];
                        $correspondance = false;
                        foreach ($tags as $tag) {
                                $resultat = $this->requeter("SELECT COUNT(*) AS nbr FROM tag WHERE name = '$tag' AND id = '$id'");
                                if ($resultat) {
                                        $nbre = (int) @sqlite_fetch_single($resultat);
                                        if ($nbre > 0) {
                                                $correspondance = true;
                                        }
                                }
                        }
                        if (!$correspondance) {
                                $retour[] = $id;
                        }
                }
                return $retour;
        }

        /**
         * Return an array of stored cache ids which match any given tags
         *
         * In case of multiple tags, a logical AND is made between tags
         *
         * @param array $tags array of tags
         * @return array array of any matching cache ids (string)
         */
        public function getIdsAvecUnTag($tags = array()) {
                $this->verifierEtCreerStructureBdd();
                $premier = true;
                $ids = array();
                foreach ($tags as $tag) {
                        $resultat = $this->requeter("SELECT DISTINCT(id) AS id FROM tag WHERE name = '$tag'");
                        if ($resultat) {
                                $lignes = @sqlite_fetch_all($resultat, SQLITE_ASSOC);
                                $ids_tmp = array();
                                foreach ($lignes as $ligne) {
                                        $ids_tmp[] = $ligne['id'];
                                }
                                if ($premier) {
                                        $ids = $ids_tmp;
                                        $premier = false;
                                } else {
                                        $ids = array_merge($ids, $ids_tmp);
                                }
                        }
                }
                
                $retour = array();
                if (count($ids) > 0) {
                        foreach ($ids as $id) {
                                $retour[] = $id;
                        }
                }
                return $retour;
        }

        /**
         * Return the filling percentage of the backend storage
         *
         * @throws Zend_Cache_Exception
         * @return int integer between 0 and 100
         */
        public function getPourcentageRemplissage() {
                $dossier = dirname($this->options['stockage_chemin']);
                $libre = disk_free_space($dossier);
                $total = disk_total_space($dossier);
                
                $pourcentage = 0;
                if ($total == 0) {
                        trigger_error("Impossible d'utiliser la fonction disk_total_space", E_USER_WARNING);
                } else {
                        $pourcentage = ($libre >= $total) ? 100 : ((int) (100. * ($total - $libre) / $total));
                }
                return $pourcentage;
        }

        /**
         * Return an array of metadatas for the given cache id
         *
         * The array must include these keys :
         * - expire : the expire timestamp
         * - tags : a string array of tags
         * - mtime : timestamp of last modification time
         *
         * @param string $id cache id
         * @return array array of metadatas (false if the cache id is not found)
         */
        public function getMetadonnees($id) {
                $this->verifierEtCreerStructureBdd();
                $tags = array();
                $resultat = $this->requeter("SELECT name FROM tag WHERE id = '$id'");
                if ($resultat) {
                        $lignes = @sqlite_fetch_all($resultat, SQLITE_ASSOC);
                        foreach ($lignes as $ligne) {
                                $tags[] = $ligne['name'];
                        }
                }
                $resultat = $this->requeter("SELECT lastModified, expire FROM cache WHERE id = '$id'");
                if ($resultat) {
                        $ligne = @sqlite_fetch_array($resultat, SQLITE_ASSOC);
                        $resultat = array(
                                'tags' => $tags,
                                'mtime' => $ligne['lastModified'],
                                'expiration' => $ligne['expire']);
                } else {
                        $resultat = false;
                }
                return $resultat;
        }

        /**
         * Give (if possible) an extra lifetime to the given cache id
         *
         * @param string $id cache id
         * @param int $extraLifetime
         * @return boolean true if ok
         */
        public function ajouterSupplementDureeDeVie($id, $supplement_duree_de_vie) {
                $this->verifierEtCreerStructureBdd();
                $augmentation = false;
                $requete = "SELECT expire FROM cache WHERE id = '$id' AND (expire = 0 OR expire > ".time().')';
                $resultat = $this->requeter($requete);
                if ($resultat) {
                        $expiration = @sqlite_fetch_single($resultat);
                        $nouvelle_expiration = $expiration + $supplement_duree_de_vie;
                        $resultat = $this->requeter('UPDATE cache SET lastModified = '.time().", expire = $nouvelle_expiration WHERE id = '$id'");
                        $augmentation = ($resultat) ? true : false;
                }
                return $augmentation;
        }

        /**
         * Return the connection resource
         *
         * If we are not connected, the connection is made
         *
         * @throws Zend_Cache_Exception
         * @return resource Connection resource
         */
        private function getConnexion() {
                if (!is_resource($this->bdd)) {
                        if ($this->options['stockage_chemin'] === null) {
                                $e = "L'emplacement du chemin vers le fichier de la base de données SQLite n'a pas été défini";
                                trigger_error($e, E_USER_ERROR);
                        } else {
                                $this->bdd = sqlite_open($this->options['stockage_chemin']);
                                if (!(is_resource($this->bdd))) {
                                        $e = "Impossible d'ouvrir le fichier '".$this->options['stockage_chemin']."' de la base de données SQLite.";
                                        trigger_error($e, E_USER_ERROR);
                                        $this->bdd = null;
                                }
                        }
                }
                return $this->bdd;
        }

        /**
         * Execute une requête SQL sans afficher de messages d'erreur.
         *
         * @param string $requete requête SQL
         * @return mixed|false resultats de la requête
         */
        private function requeter($requete) {
                $bdd = $this->getConnexion();
                //Debug::printr($requete);
                $resultat = (is_resource($bdd)) ? @sqlite_query($bdd, $requete, SQLITE_ASSOC, $e_sqlite) : false;
                if (is_resource($bdd) && ! $resultat) {
                        Debug::printr("Erreur SQLITE :\n$e_sqlite\nPour la requête :\n$requete\nRessource : $bdd");
                }
                return $resultat;
        }

        /**
         * Deal with the automatic vacuum process
         *
         * @return void
         */
        private function defragmenterAutomatiquement() {
                if ($this->options['defragmentation_auto'] > 0) {
                        $rand = rand(1, $this->options['defragmentation_auto']);
                        if ($rand == 1) {
                                $this->requeter('VACUUM');
                                @sqlite_close($this->getConnexion());
                        }
                }
        }

        /**
         * Register a cache id with the given tag
         *
         * @param  string $id  Cache id
         * @param  string $tag Tag
         * @return boolean True if no problem
         */
        private function enregisterTag($id, $tag) {
                $requete_suppression = "DELETE FROM tag WHERE name = '$tag' AND id = '$id'";
                $resultat = $this->requeter($requete_suppression);
                $requete_insertion = "INSERT INTO tag(name,id) VALUES ('$tag','$id')";
                $resultat = $this->requeter($requete_insertion);
                if (!$resultat) {
                        // TODO : ajouter un log -> impossible d'enregistrer le tag=$tag pour le cache id=$id");
                        Debug::printr("Impossible d'enregistrer le tag=$tag pour le cache id=$id");
                }
                return ($resultat) ? true : false;
        }

        /**
         * Build the database structure
         *
         * @return false
         */
        private function creerStructure() {
                $this->requeter('DROP INDEX IF EXISTS tag_id_index');
                $this->requeter('DROP INDEX IF EXISTS tag_name_index');
                $this->requeter('DROP INDEX IF EXISTS cache_id_expire_index');
                $this->requeter('DROP TABLE IF EXISTS version');
                $this->requeter('DROP TABLE IF EXISTS cache');
                $this->requeter('DROP TABLE IF EXISTS tag');
                $this->requeter('CREATE TABLE version (num INTEGER PRIMARY KEY)');
                $this->requeter('CREATE TABLE cache(id TEXT PRIMARY KEY, content BLOB, lastModified INTEGER, expire INTEGER)');
                $this->requeter('CREATE TABLE tag (name TEXT, id TEXT)');
                $this->requeter('CREATE INDEX tag_id_index ON tag(id)');
                $this->requeter('CREATE INDEX tag_name_index ON tag(name)');
                $this->requeter('CREATE INDEX cache_id_expire_index ON cache(id, expire)');
                $this->requeter('INSERT INTO version (num) VALUES (1)');
        }

        /**
         * Check if the database structure is ok (with the good version)
         *
         * @return boolean True if ok
         */
        private function verifierBddStructureVersion() {
                $version_ok = false;
                $resultat = $this->requeter('SELECT num FROM version');
                if ($resultat) {
                        $ligne = @sqlite_fetch_array($resultat);
                        if ($ligne) {
                                if (((int) $ligne['num']) == 1) {
                                        $version_ok = true;
                                } else {
                                        // TODO : ajouter un log CacheSqlite::verifierBddStructureVersion() : vielle version de la structure de la base de données de cache détectée => le cache est entrain d'être supprimé
                                }
                        }
                }
                return $version_ok;
        }

        /**
         * Clean some cache records
         *
         * Available modes are :
         * Zend_Cache::CLEANING_MODE_ALL (default)      => remove all cache entries ($tags is not used)
         * Zend_Cache::CLEANING_MODE_OLD                          => remove too old cache entries ($tags is not used)
         * Zend_Cache::CLEANING_MODE_MATCHING_TAG        => remove cache entries matching all given tags
         *                                                                                         ($tags can be an array of strings or a single string)
         * Zend_Cache::CLEANING_MODE_NOT_MATCHING_TAG => remove cache entries not {matching one of the given tags}
         *                                                                                         ($tags can be an array of strings or a single string)
         * Zend_Cache::CLEANING_MODE_MATCHING_ANY_TAG => remove cache entries matching any given tags
         *                                                                                         ($tags can be an array of strings or a single string)
         *
         * @param  string $mode Clean mode
         * @param  array  $tags Array of tags
         * @return boolean True if no problem
         */
        private function nettoyerSqlite($mode = Cache::NETTOYAGE_MODE_TOUS, $tags = array()) {
                $nettoyage_ok = false;
                switch ($mode) {
                        case Cache::NETTOYAGE_MODE_TOUS:
                                $suppression_cache = $this->requeter('DELETE FROM cache');
                                $suppression_tag = $this->requeter('DELETE FROM tag');
                                $nettoyage_ok = $suppression_cache && $suppression_tag;
                                break;
                        case Cache::NETTOYAGE_MODE_EXPIRATION:
                                $mktime = time();
                                $suppression_tag = $this->requeter("DELETE FROM tag WHERE id IN (SELECT id FROM cache WHERE expire > 0 AND expire <= $mktime)");
                                $suppression_cache = $this->requeter("DELETE FROM cache WHERE expire > 0 AND expire <= $mktime");
                                return $suppression_tag && $suppression_cache;
                                break;
                        case Cache::NETTOYAGE_MODE_AVEC_LES_TAGS:
                                $ids = $this->getIdsAvecLesTags($tags);
                                $resultat = true;
                                foreach ($ids as $id) {
                                        $resultat = $this->supprimer($id) && $resultat;
                                }
                                return $resultat;
                                break;
                        case Cache::NETTOYAGE_MODE_SANS_LES_TAGS:
                                $ids = $this->getIdsSansLesTags($tags);
                                $resultat = true;
                                foreach ($ids as $id) {
                                        $resultat = $this->supprimer($id) && $resultat;
                                }
                                return $resultat;
                                break;
                        case Cache::NETTOYAGE_MODE_AVEC_UN_TAG:
                                $ids = $this->getIdsAvecUnTag($tags);
                                $resultat = true;
                                foreach ($ids as $id) {
                                        $resultat = $this->supprimer($id) && $resultat;
                                }
                                return $resultat;
                                break;
                        default:
                                break;
                }
                return $nettoyage_ok;
        }

        /**
         * Check if the database structure is ok (with the good version), if no : build it
         *
         * @throws Zend_Cache_Exception
         * @return boolean True if ok
         */
        private function verifierEtCreerStructureBdd() {
                if (! $this->structure_ok) {
                        if (! $this->verifierBddStructureVersion()) {
                                $this->creerStructure();
                                if (! $this->verifierBddStructureVersion()) {
                                        $e = "Impossible de construire la base de données de cache dans ".$this->options['stockage_chemin'];
                                        trigger_error($e, E_USER_WARNING);
                                        $this->structure_ok = false;
                                }
                        }
                        $this->structure_ok = true;
                }
                return $this->structure_ok;
        }

}
?>