/trunk/framework/GestionnaireErreur.php |
---|
File deleted |
\ No newline at end of file |
/trunk/framework/config.defaut.ini |
---|
20,9 → 20,12 |
; Indique si oui ou non on veut activer la journalisation des erreurs. |
fw_log_debogage = true |
; Indique si oui ou non on veut activer la journalisation des erreurs. |
; Indique le fuseau horaire pour le datage des logs. |
fw_timezone = Europe/Paris |
; Indique la taille max d'un fichier log (en octets) |
fw_taille_max_logs = 1000000 |
; +------------------------------------------------------------------------------------------------------+ |
; Benchmark |
; Indique si oui ou nom on veut afficher le tableau de chronométrage de l'application. |
/trunk/framework/Chronometre.php |
---|
1,38 → 1,25 |
<?php |
// declare(encoding='UTF-8'); |
/** Fichier de la classe Chronometre |
* |
* PHP Version 5 |
* |
* @category PHP |
* @package Framework |
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
* @copyright 2009 Tela-Botanica |
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
* @version SVN: <svn_id> |
* @link /doc/framework/ |
*/ |
/** Classe Chronometre() - Permet de stocker et d'afficher |
* les temps d'éxécution de script. |
* |
* Cette classe permet de réaliser un ensemble |
* de mesure de temps prises à |
* différents endroits d'un script. |
* Ces mesures peuvent ensuite être affichées au |
* sein d'un tableau XHTML. |
* |
* |
* PHP Version 5 |
* |
* @category PHP |
* @package Framework |
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
* @copyright 2009 Tela-Botanica |
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
* @version Release: <package_version> |
* @link /doc/framework/ |
*/ |
* les temps d'éxécution de script. |
* |
* Cette classe permet de réaliser un ensemble |
* de mesure de temps prises à |
* différents endroits d'un script. |
* Ces mesures peuvent ensuite être affichées au |
* sein d'un tableau XHTML. |
* |
* |
* PHP Version 5 |
* |
* @category PHP |
* @package Framework |
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
* @copyright 2009 Tela-Botanica |
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
* @version Release: <package_version> |
* @link /doc/framework/ |
*/ |
class Chronometre { |
/*** Attributs : ***/ |
private $_temps = array(); |
/trunk/framework/Config.php |
---|
18,9 → 18,19 |
class Config { |
/** |
* instance de la classe pointant sur elle même (pour le pattern singleton) |
*/ |
private static $instance = null; |
/** |
* paramètres de configuration |
*/ |
private static $parametres = array(); |
/** |
* Constructeur vide |
*/ |
private function __construct() { |
// Définition de paramètres avant chargement du config.ini |
self::$parametres = array( |
66,6 → 76,10 |
} |
} |
/** |
* Charge le fichier de config correspondant au contexte |
* @param string $contexte le contexte |
*/ |
private static function chargerFichierContexte($contexte) { |
$chemin_config_appli_contextuel = self::$parametres['chemin_configurations']; |
$chemin_config_appli_contextuel .= sprintf(self::$parametres['fw_fichier_config'], '_'.$contexte); |
72,6 → 86,11 |
self::parserFichierIni($chemin_config_appli_contextuel); |
} |
/** |
* Parse le fichier ini donné en paramètre |
* @param string $fichier_ini nom du fichier ini à parser |
* @return array tableau contenant les paramètres du fichier ini |
*/ |
private static function parserFichierIni($fichier_ini) { |
$retour = false; |
if (file_exists($fichier_ini)) { |
83,10 → 102,20 |
return $retour; |
} |
/** |
* fusionne un tableau de paramètres avec le tableau de paramètres global |
* @param array $ini le tableau à fusionner |
*/ |
private static function fusionner(array $ini) { |
self::$parametres = array_merge(self::$parametres, $ini); |
} |
/** |
* renvoie la valeur demandé grâce une chaine de paramètres |
* @param string $param la chaine de paramètres |
* @param array $config le tableau de paramètre |
* @return string la valeur de la chaine demandée |
*/ |
private static function getValeur($param, $config) { |
if ($param === null) { |
return null; |
109,6 → 138,11 |
} |
} |
/** |
* Teste si param existe dans le tableau config |
* @param string $param nom du paramètre |
* @param array tableau de configuration |
*/ |
private static function existeValeur($param, $config) { |
$retour = false; |
if (self::getValeur($param, $config) !== null) { |
117,6 → 151,9 |
return $retour; |
} |
/** |
* Vérifie si l'instance de classe à été crée, si non la crée |
*/ |
private static function verifierCreationInstance() { |
if (empty(self::$instance)) { |
self::$instance = new Config(); |
123,6 → 160,11 |
} |
} |
/** |
* analyse un tableau de paramètres |
* @param array $config le tableau de paramètres |
* @return array le tableau analysé |
*/ |
private static function analyserTableauIni($config = array()) { |
foreach ($config as $cle => $valeur) { |
if (is_array($valeur)) { |
136,6 → 178,13 |
return $config; |
} |
/** |
* dans le cas des chaine de configuration à sous clé (ex.: cle.souscle) |
* evalue les valeurs correspondantes et crée les sous tableaux associés |
* @param array $config tableau de configuration (par référence) |
* @param string $cle la cle dans le tableau |
* @param string $valeur la valeur à affecter |
*/ |
private static function evaluerCle(&$config, $cle, $valeur) { |
if (strpos($cle, '.') !== false) { |
unset($config[$cle]); |
161,6 → 210,11 |
return $config; |
} |
/** |
* Evalue les valeurs de références à une clé dans le tableau config (cas du ref:cle) |
* @param array $config tableau de configuration |
* @param string $cle la clé dont il faut évaluer les références |
*/ |
private static function evaluerReferences(&$config, $cle) { |
if (preg_match_all('/{ref:([A-Za-z0-9_-]+)}/', $config[$cle], $correspondances, PREG_SET_ORDER)) { |
foreach ($correspondances as $ref) { |
169,6 → 223,11 |
} |
} |
/** |
* Evalue le code php contenu dans un clé tu tableau config |
* @param array $config tableau de configuration (par référence) |
* @param string $cle le clé du tableau dont il faut évaluer la valeur |
*/ |
private static function evaluerPhp(&$config, $cle) { |
if (preg_match('/^php:(.+)$/', $config[$cle], $correspondances)) { |
eval('$config["'.$cle.'"] = '.$correspondances[1].';'); |
175,16 → 234,31 |
} |
} |
/** |
* Charge un fichier ini dans le tableau des paramètres de l'appli |
* @param string $fichier_ini le nom du fichier à charger |
* @return array le fichier ini parsé |
*/ |
public static function charger($fichier_ini) { |
self::verifierCreationInstance(); |
return self::parserFichierIni($fichier_ini); |
} |
/** |
* Acesseur pour la valeur d'un paramètre |
* @param string $param le nom du paramètre |
* @return string la valeur du paramètre |
*/ |
public static function get($param = null) { |
self::verifierCreationInstance(); |
return self::getValeur($param, self::$parametres); |
} |
/** |
* Vérifie si la valeur d'un paramètre existe |
* @param string $param le nom du paramètre |
* @return boolean vrai si le paramètre existe, false sinon |
*/ |
public static function existe($param) { |
self::verifierCreationInstance(); |
return self::existeValeur($param, self::$parametres); |
/trunk/framework/Debug.php |
---|
1,24 → 1,33 |
<?php |
// declare(encoding='UTF-8'); |
/** |
* Classe fournissant des fonctions de débogage équivalante à var_dump et print_r. |
* L'affichage et l'utilisation de ces fonctions sont améliorés via cette classe. |
* Cette classe est inspirée de la classe Zend_Debug. |
* |
* @package Framework |
* @category Debogage |
// Auteur principal : |
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
// Autres auteurs : |
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt> |
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt> |
* @version $$Id$$ |
* @copyright 1999-2009 Tela Botanica (accueil@tela-botanica.org) |
*/ |
* Classe fournissant des fonctions de débogage équivalante à var_dump et print_r. |
* L'affichage et l'utilisation de ces fonctions sont améliorés via cette classe. |
* Cette classe est inspirée de la classe Zend_Debug. |
* |
* PHP version 5 |
* |
* @category Debogage |
* @package Framework |
// Auteur principal : |
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
// Autres auteurs : |
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt> |
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt> |
* @version $$Id$$ |
* @copyright 1999-2009 Tela Botanica (accueil@tela-botanica.org) |
*/ |
class Debug { |
/** |
* mode de php (cli ou sapi) |
*/ |
protected static $mode = null; |
/** |
* Accesseur pour le mode |
* @return string le mode de php |
*/ |
public static function getMode() { |
if (self::$mode === null) { |
self::$mode = PHP_SAPI; |
26,6 → 35,13 |
return self::$mode; |
} |
/** |
* Equivalent de var_dump |
* @param mixed $variable la variable à dumper |
* @param string $mot_cle le mot cle à associer à la variable |
* @param boolean $echo si true on affiche le résultat, si false on ne renvoie que la chaine sans l'afficher |
* @return string la chaine à afficher representant le dump ou null si echo |
*/ |
public static function dump($variable, $mot_cle = null, $echo = true) { |
// var_dump de la variable dans un buffer et récupération de la sortie |
ob_start(); |
39,6 → 55,13 |
return self::traiterDebogage($mot_cle, $sortie, $echo); |
} |
/** |
* Equivalent de print_r |
* @param mixed $variable la variable à afficher |
* @param string $mot_cle le mot cle à associer |
* @param boolean $echo faire un echo ou non |
* @return string la chaine contenant la variable printée ou null si echo |
*/ |
public static function printr($variable, $mot_cle = null, $echo = true) { |
// Récupération de la sortie |
$sortie = print_r($variable, true); |
47,6 → 70,13 |
return self::traiterDebogage($mot_cle, $sortie, $echo); |
} |
/** |
* Traite une chaine de débogage et les mots clés associés |
* @param string $mot_cle le mot à associer à la chaine |
* @param string $sortie le chaine de debogage |
* @param boolean $echo faire un echo du resultat ou non |
* @return string la chaine de debogage formatée ou bien null si echo |
*/ |
private static function traiterDebogage($mot_cle, $sortie, $echo) { |
// Formate le mot-clé |
$mot_cle = self::formaterMotCle($mot_cle); |
63,10 → 93,21 |
} |
} |
/** |
* formate un mot clé donné |
* @param string $mot_cle le mot clé à formaté |
* @return string le mot clé formaté ou bien un chaine vide le mot clé est null ou vide |
*/ |
private static function formaterMotCle($mot_cle) { |
return ($mot_cle === null) ? '' : rtrim($mot_cle).' '; |
} |
/** |
* traite la sortie de la chaine de débogage suivant le mode de php |
* @param string $mot_cle le mot clé associé à la chaine |
* @param string $sortie la chaine de débogage |
* @return string la sortie formatée pour le mode en cours |
*/ |
private static function traiterSortieSuivantMode($mot_cle, $sortie) { |
$corps = $mot_cle.PHP_EOL.$sortie; |
if (self::getMode() == 'cli') { |
/trunk/framework/GestionnaireException.php |
---|
1,20 → 1,20 |
<?php |
// declare(encoding='UTF-8'); |
/** |
* classe de gestion des exceptions. |
* |
* PHP Version 5 |
* |
* @category Class |
* @package Framework |
* @author aurelien <aurelien@tela-botanica.org> |
* @copyright 2009 Tela-Botanica |
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
* @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL |
* @version SVN: $$Id$$ |
* @link /doc/framework/ |
* |
*/ |
* classe de gestion des exceptions. |
* |
* PHP Version 5 |
* |
* @category Class |
* @package Framework |
* @author aurelien <aurelien@tela-botanica.org> |
* @copyright 2009 Tela-Botanica |
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
* @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL |
* @version SVN: $$Id$$ |
* @link /doc/framework/ |
* |
*/ |
class GestionnaireException { |
/** |
27,10 → 27,10 |
*/ |
private static $contexte = false; |
/** |
* Détermine si l'on loggue ou non les erreurs |
*/ |
private static $logger = false; |
/** |
* Détermine si l'on loggue ou non les erreurs |
*/ |
private static $logger = false; |
/** |
* Definit si php est lancé en ligne de commande ou en mode serveur |
49,8 → 49,8 |
*/ |
public function __construct() { |
self::$exceptions = array(); |
self::$mode = Config::get('fw_debogage_contexte'); |
self::$logger = Config::get('fw_log_debogage'); |
self::$contexte = Config::get('fw_debogage_contexte'); |
self::$logger = Config::get('fw_log_debogage'); |
self::$mode = php_sapi_name(); |
set_exception_handler(array(get_class($this),'gererException')); |
61,7 → 61,7 |
* Renvoie le booleen définissant si l'on affiche le contexte ou non |
*/ |
public static function getContexte() { |
return self::$mode; |
return self::$contexte; |
} |
/** |
69,7 → 69,7 |
* @param bool true si on veut afficher le contexte, false sinon, par défaut vaut false |
*/ |
public function setContexte($contexte) { |
self::$mode = $contexte; |
self::$contexte = $contexte; |
} |
/** Fonction d'accès au singleton |
86,6 → 86,7 |
/** |
* Fonction de gestion des exceptions, remplace le handler par défaut |
* @param Exception $e l'exception à traiter |
*/ |
public static function gererException(Exception $e) { |
92,10 → 93,12 |
// pour le moment on se contente de l'ajouter au tableau et de les afficher |
self::$exceptions[] = $e; |
if(self::$logger) { |
self::loggerException($e); |
} |
// si on doit logger on envoie l'exception au loggeur |
if(self::$logger) { |
self::loggerException($e); |
} |
// si l'exception n'est pas permise par error reporting, on affiche les exceptions |
if($e->getCode() != 0 && $e->getCode() <= error_reporting()) { |
echo self::getExceptions(); |
return; |
102,6 → 105,14 |
} |
} |
/** |
* Gère les erreurs en les convertissant en exceptions (remplace la fonction gestion d'erreurs native de php) |
* @param int $niveau le niveau de l'erreur |
* @param string $message le message associé à l'erreur |
* @param string $fichier le nom du fichier où l'erreur s'est produite |
* @param int $ligne la ligne où l'erreur s'est produite |
* @param string $contexte le contexte associé à l'erreur |
*/ |
public static function gererErreur($niveau, $message, $fichier, $ligne, $contexte){ |
// si aucun rapport d'erreur, on sort directement |
if (error_reporting() == 0) |
113,11 → 124,11 |
$e = new ErrorException($message, 0, $niveau, $fichier, $ligne); |
// que l'on donne au tableau d'exceptions |
self::$exceptions[] = $e; |
// on la logge si nécéssaire |
if(self::$logger) { |
self::loggerException($e); |
} |
return; |
// on la logge si nécéssaire |
if(self::$logger) { |
self::loggerException($e); |
} |
return; |
} |
/** |
132,9 → 143,6 |
$retour .= $e->getMessage()."\n"; |
$retour .= 'Fichier : '.$e->getFile()."\n"; |
$retour .= 'Ligne : '.$e->getLine()."\n"; |
$retour .= 'Message : '.$e->getMessage()."\n"; |
$retour .= 'Fichier : '.$e->getFile()."\n"; |
$retour .= 'Ligne : '.$e->getLine()."\n"; |
if (self::getContexte()) { |
$retour .= 'Contexte : '."\n".print_r($e->getTraceAsString(), true)."\n"; |
} |
156,19 → 164,22 |
return $retour; |
} |
private static function loggerException($e) { |
/** |
* logge une exception donnée sous une forme lisible |
* @param Exception $e l'exception à logger |
*/ |
private static function loggerException($e) { |
$erreur = ''; |
$erreur .= 'Fichier : '.$e->getFile()."\n"; |
$erreur .= 'Ligne : '.$e->getLine()."\n"; |
$erreur .= 'Message : '.$e->getMessage()."\n"; |
if (self::getContexte()) { |
$erreur .= 'Contexte : '."\n".print_r($e->getTraceAsString(), true)."\n"; |
} |
$erreur .= "\n"; |
$erreur = ''; |
$erreur .= $e->getMessage()."\n"; |
$erreur .= 'Fichier : '.$e->getFile()."\n"; |
$erreur .= 'Ligne : '.$e->getLine()."\n"; |
if (self::getContexte()) { |
$erreur .= 'Contexte : '."\n".print_r($e->getTraceAsString(), true)."\n"; |
} |
$erreur .= "\n"; |
Log::ajouterEntree('erreurs',$erreur); |
} |
Log::ajouterEntree('erreurs',$erreur); |
} |
} |
?> |
/trunk/framework/Controleur.php |
---|
1,35 → 1,27 |
<?php |
// declare(encoding='UTF-8'); |
/** |
* classe Controlleur, coeur d'une application, c'est normalement la seule classe d'une application |
* qui devrait être appelée de l'extérieur. |
* Elle est abstraite donc doit obligatoirement être étendue |
* |
* PHP Version 5 |
* |
* @category Class |
* @package Framework |
* @author aurelien <aurelien@tela-botanica.org> |
* @copyright 2009 Tela-Botanica |
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
* @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL |
* @version SVN: $$Id$$ |
* @link /doc/framework/ |
* |
*/ |
* classe Controleur, coeur d'une application, c'est normalement la seule classe d'une application |
* qui devrait être appelée de l'extérieur. |
* Elle est abstraite donc doit obligatoirement être étendue |
* |
* PHP Version 5 |
* |
* @category Class |
* @package Framework |
* @author aurelien <aurelien@tela-botanica.org> |
* @copyright 2009 Tela-Botanica |
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
* @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL |
* @version SVN: $$Id$$ |
* @link /doc/framework/ |
* |
*/ |
abstract class Controleur { |
/** |
* Registre global, normalement accessible partout |
*/ |
private $registre; |
/** |
* Gestionnaire d'exceptions php |
*/ |
private $gestionnaire_exception; |
/** |
* Gestionnaire d'erreurs php |
*/ |
private $gestionnaire_erreur; |
/** |
* Constructeur par défaut |
44,8 → 36,6 |
$this->registre->set('base_chemin_squelette', Config::get('chemin_squelettes')); |
$this->registre->set('base_chemin_controleur', Config::get('chemin_controleurs')); |
$this->registre->set('base_url_application', new Url(Config::get('url_base'))); |
$this->gestionnaire_exception = GestionnaireException::getInstance(); |
$this->gestionnaire_erreur = GestionnaireErreur::getInstance(); |
} |
/** |
114,8 → 104,11 |
$this->$nom_squelette = $tampon; |
} |
/** |
* Destructeur de classe, renvoie les exceptions s'il y en a |
*/ |
public function __destruct() { |
$this->gestionnaire_exception->getExceptions(); |
GestionnaireException::getExceptions(); |
} |
} |
?> |
/trunk/framework/autoload.inc.php |
---|
41,6 → 41,8 |
GestionnaireException::getInstance(); |
//instanciation du gestionnaire de logs |
Log::getInstance(); |
// encodage de l'application (défini ici car on peut avoir des sorties d'erreurs dès le début) |
mb_internal_encoding(Config::get('appli_encodage')); |
// Autoload par défaut pour l'application |
function autoloadAppliDefaut($nom_classe) { |
/trunk/framework/Log.php |
---|
1,16 → 1,18 |
<?php |
//declare(encoding='UTF-8'); |
/** |
* PHP Version 5 |
* |
* @category PHP |
* @package framework |
* @author aurelien <aurelien@tela-botanica.org> |
* @copyright 2009 Tela-Botanica |
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
* @version SVN: <svn_id> |
* @link /doc/framework/ |
*/ |
* Classe permettant de logger des messages dans les fichier situés dans le dossier de log |
* |
* PHP Version 5 |
* |
* @category PHP |
* @package framework |
* @author aurelien <aurelien@tela-botanica.org> |
* @copyright 2009 Tela-Botanica |
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
* @version SVN: <svn_id> |
* @link /doc/framework/ |
*/ |
class Log { |
35,11 → 37,21 |
private static $timeZone = ''; |
/** |
* Taille maximum d'un fichier de log avant que celui ne soit archivé (en octets) |
*/ |
private static $tailleMax = 10000; |
/** |
* séparateur de chemin |
*/ |
private static $sd = DIRECTORY_SEPARATOR; |
/** |
* Extension des fichiers de log |
*/ |
private static $ext = '.log'; |
/** |
* La classe registre se contient elle-même, (pour le pattern singleton) |
*/ |
private static $log; |
48,19 → 60,25 |
* Constructeur par défaut, privé, car on accède à la classe par le getInstance |
*/ |
private function __construct() { |
self::$sd = Config::get('ds'); |
self::$cheminLogs = Config::get('chemin_logs'); |
self::$timeZone = Config::get('fw_timezone'); |
self::$sd = Config::get('ds'); |
self::$cheminLogs = Config::get('chemin_logs'); |
self::$timeZone = Config::get('fw_timezone'); |
self::$tailleMax = Config::get('fw_taille_max_logs'); |
// gestion de la timezone pour éviter des erreurs |
if(function_exists("date_default_timezone_set") and function_exists("date_default_timezone_get")) { |
date_default_timezone_set(self::$timeZone); |
} |
// gestion de la timezone pour éviter des erreurs |
if(function_exists("date_default_timezone_set") and function_exists("date_default_timezone_get")) { |
date_default_timezone_set(self::$timeZone); |
} |
if(!is_dir(self::$cheminLogs) || !is_writable(self::$cheminLogs)) { |
self::desactiverEcriture(); |
} |
} |
/** |
* Fonction qui renvoie l'instance de classe en assurant son unicité, c'est l'unique méthode qui doit être |
* utilisée pour récupérer l'objet Registre |
* @return Log le gestionnaire de log en cours |
*/ |
public static function getInstance() { |
if (self::$log instanceof Log) { |
79,24 → 97,14 |
$date = "\n"."\n".date('d m Y H:i')."\n" ; |
// si le fichier est déjà dans le tableau et qu'on peut y écrire |
if(in_array($nomFichier,self::$fichiersLog)) { |
if(is_writable(self::$cheminLogs.$nomFichier)) { |
if(self::verifierOuvrirFichier($nomFichier,$mode)) { |
// on y écrit le message de log |
fwrite(self::$fichiersLog[$nomFichier],$date.$entree); |
} else { |
self::desactiverEcriture($nomFichier); |
} |
// on vérifie si le fichier ne dépasse pas la taille maximale |
self::verifierTailleFichierOuArchiver($nomFichier); |
} else { |
$fp = fopen(self::$cheminLogs.$nomFichier,$mode); |
if($fp) { |
if(is_writable(self::$cheminLogs.$nomFichier)) { |
self::$fichiersLog[$nomFichier] = $fp; |
fwrite(self::$fichiersLog[$nomFichier],$date.$entree); |
} else { |
self::desactiverEcriture($nomFichier); |
} |
} else { |
self::desactiverEcriture($nomFichier); |
} |
// sinon on interdit l'écriture |
self::desactiverEcriture($nomFichier); |
} |
} |
} |
106,31 → 114,61 |
* @param string $nomFichier le nom du fichier à vider |
*/ |
public static function viderLog($nomFichier) { |
if(self::verifierPresenceFichier($nomFichier)) { |
ajouterEntree($nomFichier,'','w'); |
} |
ajouterEntree($nomFichier,'','w'); |
} |
/** |
* Vérifie la présence d'un fichier dans le tableau (et bientot plein |
* d'autres choses). |
* Vérifie la présence d'un fichier dans le tableau, ses droits d'écriture, |
* l'ouvre si nécessaire |
* @param string $nomFichier le nom du fichier dont on doit vérifier la présence |
* @return boolean vrai si le fichier est dans le tableau, faux sinon |
* @return boolean true si le fichier est ouvert ou maintenant accessible, false sinon |
*/ |
public static function verifierPresenceFichier($nomFichier) { |
public static function verifierOuvrirFichier($nomFichier,$mode) { |
// le fichier est il déjà ouvert ? |
if(in_array($nomFichier,self::$fichiersLog)) { |
return true; |
// si oui peut on y écrire ? |
if(is_writable(self::$cheminLogs.$nomFichier.self::$ext)) { |
// si oui on renvoie le descripteur |
return true; |
} |
return false; |
} else { |
// sinon on l'ouvre |
$fp = @fopen(self::$cheminLogs.$nomFichier.self::$ext,$mode); |
// si l'ouverture a réussi et si le fichier a les droits d'écriture |
if($fp && is_writable(self::$cheminLogs.$nomFichier.self::$ext)) { |
// si oui on renvoie le descripteur qu'on ajoute au tableau |
self::$fichiersLog[$nomFichier] = $fp; |
return true; |
} |
return false; |
} |
return false; |
} |
/** |
* Vérifie la taille d'un fichier donné et si celle ci est trop importante |
* archive le fichier de log |
* @param string $nomFichier nom du fichier à vérifier |
*/ |
private static function verifierTailleFichierOuArchiver($nomFichier) { |
if(filesize(self::$cheminLogs.$nomFichier.self::$ext) > self::$tailleMax) { |
rename(self::$cheminLogs.$nomFichier.self::$ext,self::$cheminLogs.$nomFichier.date('d_m_Y_H:i').self::$ext); |
ajouterEntree($nomFichier,''); |
} |
} |
/** |
* Désactive l'écriture du log et envoie un message au gestionnaire d'erreurs |
* @param string $nomFichier le nom du fichier qui a causé l'erreur |
*/ |
private static function desactiverEcriture($nomFichier) { |
private static function desactiverEcriture($nomFichier = '') { |
self::$droitLogger = false; |
$message = 'Ecriture impossible dans le fichier '.$nomFichier.', Assurez-vous des droits du dossier de logs et du fichier'; |
if($nomFichier != '') { |
$fichierDossier = 'fichier '.$nomFichier ; |
} else { |
$fichierDossier = 'dossier des logs'; |
} |
$message = 'Ecriture impossible dans le '.$fichierDossier.', Assurez-vous des droits du dossier et des fichiers'; |
$e = new ErrorException($message,0,E_USER_WARNING,__FILE__,__LINE__); |
GestionnaireException::gererException($e); |
} |
/trunk/framework/Application.php |
---|
1,23 → 1,35 |
<?php |
// declare(encoding='UTF-8'); |
/** |
* Classe fournissant des informations au Framework sur l'application. |
* |
* @package Framework |
* @category Debogage |
// Auteur principal : |
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
// Autres auteurs : |
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt> |
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt> |
* @version $$Id$$ |
* @copyright 1999-2009 Tela Botanica (accueil@tela-botanica.org) |
*/ |
* Classe fournissant des informations au Framework sur l'application. |
* |
* PHP version 5 |
* |
* @category Debogage |
* @package Framework |
// Auteur principal : |
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
// Autres auteurs : |
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt> |
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt> |
* @version $$Id$$ |
* @copyright 1999-2009 Tela Botanica (accueil@tela-botanica.org) |
*/ |
class Application { |
/** |
* tableau d'informations sur l'application |
*/ |
private static $info = null; |
/** |
* chemin de base de l'application |
*/ |
private static $chemin = null; |
/** |
* Modificateur pour le chemin de base |
* @param string $chemin_fichier_principal chemin de base |
*/ |
public static function setChemin($chemin_fichier_principal) { |
if (self::$chemin === null) { |
if (!file_exists($chemin_fichier_principal)) { |
30,6 → 42,10 |
} |
} |
/** |
* accesseur pour le chemin |
* @return string le chemin |
*/ |
public static function getChemin() { |
return self::$chemin; |
} |
50,6 → 66,10 |
} |
} |
/** |
* accesseur pour le tableau d'infos |
* @param string $cle la clé à laquelle on veut accéder |
*/ |
public static function getInfo($cle = null) { |
if ($cle !== null) { |
if (isset(self::$info[$cle])) { |