Subversion Repositories Applications.framework

Compare Revisions

Ignore whitespace Rev 268 → Rev 269

/trunk/framework/CacheSqlite.php
New file
0,0 → 1,606
<?php
class CacheSqlite {
/**
* Available options
*
* =====> (string) cache_db_complete_path :
* - the complete path (filename included) of the SQLITE database
*
* ====> (int) automatic_vacuum_factor :
* - Disable / Tune the automatic vacuum process
* - The automatic vacuum process defragment the database file (and make it smaller)
* when a clean() or delete() is called
* 0 => no automatic vacuum
* 1 => systematic vacuum (when delete() or clean() methods are called)
* x (integer) > 1 => automatic vacuum randomly 1 times on x clean() or delete()
*
* @var array Available options
*/
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->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);
}
}
/**
* 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() {
Debug::printr("création de la str");
$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;
}
 
}
?>
/trunk/framework/CacheFichier.php
67,7 → 67,8
*/
protected $metadonnees = array();
 
 
private $Cache = null;
/**
* Constructor
*
75,7 → 76,8
* @throws Zend_Cache_Exception
* @return void
*/
public function __construct(array $options = array()) {
public function __construct(array $options = array(), Cache $cache) {
$this->Cache = $cache;
$this->setOptions($options);
 
if (isset($this->options['prefixe_fichier'])) {
195,7 → 197,7
$metadonnees = array(
'hash' => $cle_secu,
'mtime' => time(),
'expiration' => $this->getTimestampExpiration($duree_vie_specifique),
'expiration' => $this->Cache->getTimestampExpiration($duree_vie_specifique),
'tags' => $tags
);
 
697,19 → 699,6
}
 
/**
* Compute & return the expire time
*
* @return int expire time (unix timestamp)
*/
protected function getTimestampExpiration($duree_de_vie) {
if ($duree_de_vie === false) {
$duree_de_vie = 3600;
}
$timestamp = ($duree_de_vie === null) ? 9999999999 : (time() + $duree_de_vie);
return $timestamp;
}
 
/**
* Make a control key with the string containing datas
*
* @param string $data Data
/trunk/framework/Cache.php
84,12 → 84,12
protected $stockage = null;
public function __construct($options, $options_stockage) {
public function __construct($options, $options_stockage = array()) {
$this->setOptions($options);
if ($this->options['stockage_mode'] == self::STOCKAGE_MODE_FICHIER) {
$this->stockage = new CacheFichier($options_stockage);
$this->stockage = new CacheFichier($options_stockage, $this);
} else if ($this->options['stockage_mode'] == self::STOCKAGE_MODE_SQLITE) {
$this->stockage = new CacheSqlite($options_stockage);
$this->stockage = new CacheSqlite($options_stockage, $this);
}
$this->stockage->setEmplacement($this->options['stockage_chemin']);
}
455,5 → 455,21
reset($tags);
}
/**
* Calcule et retourne le timestamp d'expiration
*
* @return int timestamp d'expiration (unix timestamp)
*/
public function getTimestampExpiration($duree_de_vie) {
if ($duree_de_vie === false) {
if (isset($this->options['duree_de_vie']) && is_int($this->options['duree_de_vie'])) {
$duree_de_vie = (int) $this->options['duree_de_vie'];
} else {
$duree_de_vie = 3600;
}
}
$timestamp = ($duree_de_vie === null) ? 9999999999 : (time() + $duree_de_vie);
return $timestamp;
}
}