Subversion Repositories Applications.framework

Rev

Rev 216 | Rev 241 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 216 Rev 232
1 
<?php
 1 
<?php
2 
// declare(encoding='UTF-8');
 2 
// declare(encoding='UTF-8');
3 
/**
 3 
/**
4 
 * Classe de gestion des exceptions.
 4 
 * Classe de gestion des exceptions.
5 
 * C'est un Singleton.
 5 
 * C'est un Singleton.
6 
 *
 6 
 *
7 
 * PHP Version 5
 - 
 
8 
 *
 - 
 
9 
 * @category  Class
 7 
 * @category	PHP 5.2
10 
 * @package   Framework
 8 
 * @package	Framework
11 
 * @author	aurelien <aurelien@tela-botanica.org>
 9 
 * @author		Aurélien PERONNET <aurelien@tela-botanica.org>
12 
 * @copyright 2009 Tela-Botanica
 10 
 * @copyright	Copyright (c) 2009, Tela Botanica (accueil@tela-botanica.org)
13 
 * @license   http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
 11 
 * @license	http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
14 
 * @license   http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
 12 
 * @license	http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
15 
 * @version   SVN: $$Id: GestionnaireException.php 216 2010-11-10 11:29:59Z jpm $$
 13 
 * @version	$Id: GestionnaireException.php 232 2010-11-19 17:12:58Z jpm $$
16 
 * @link	  /doc/framework/
 14 
 * @link		/doc/framework/
17 
 *
 15 
 *
18 
 */
 16 
 */
19 
class GestionnaireException {
 17 
class GestionnaireException {
20
18
21 
	const MODE_CLI = 'cli';
 19 
	const MODE_CLI = 'cli';
22
20
23 
	/** Liste des exceptions enregistrées */
 21 
	/** Liste des exceptions enregistrées */
24 
	private static $exceptions = array();
 22 
	private static $exceptions = array();
25 
 
 23 
 
26 
	/** Détermine si l'on affiche ou non le contexte */
 24 
	/** Détermine si l'on affiche ou non le contexte */
27 
	private static $contexte = false;
 25 
	private static $contexte = false;
28 
 
 26 
 
29 
	 /** Détermine si l'on loggue ou non les erreurs */
 27 
	 /** Détermine si l'on loggue ou non les erreurs */
30 
	private static $logger = false;
 28 
	private static $logger = false;
31 
 
 29 
 
32 
	/** Détermine si l'affichage des erreurs est forcé (true) ou pas (false) à la destruction de la classe */
 30 
	/** Détermine si l'affichage des erreurs est forcé (true) ou pas (false) à la destruction de la classe */
33 
	private static $afficher = false;
 31 
	private static $afficher = false;
34 
 
 32 
 
35 
	/** Definit si php est lancé en ligne de commande ou en mode serveur */
 33 
	/** Definit si php est lancé en ligne de commande ou en mode serveur */
36 
	private static $mode = null ;
 34 
	private static $mode = null ;
37 
 
 35 
 
38 
	/** Initialise le Gestionnaire d'exceptions et d'erreur sans tenir comptes des paramêtres de config. */
 36 
	/** Initialise le Gestionnaire d'exceptions et d'erreur sans tenir comptes des paramêtres de config. */
39 
	public static function initialiser() {
 37 
	public static function initialiser() {
40 
		self::$mode = php_sapi_name();
 38 
		self::$mode = php_sapi_name();
41 
		// Désactivation des balises HTML dans les messages d'erreur de PHP en mode ligne de commande
 39 
		// Désactivation des balises HTML dans les messages d'erreur de PHP en mode ligne de commande
42 
		if (self::$mode == self::MODE_CLI) {
 40 
		if (self::$mode == self::MODE_CLI) {
43 
			ini_set('html_errors', 0);
 41 
			ini_set('html_errors', 0);
44 
		}
42 
		}
45
43
46 
		set_exception_handler(array(get_class(),'gererException'));
 44 
		set_exception_handler(array(get_class(),'gererException'));
47 
		set_error_handler(array(get_class(),'gererErreur'));
 45 
		set_error_handler(array(get_class(),'gererErreur'));
48 
	}
 46 
	}
49
47
50 
	/** Configure le Gestionnaire d'exceptions et d'erreur à partir des paramêtres de config. */
 48 
	/** Configure le Gestionnaire d'exceptions et d'erreur à partir des paramêtres de config. */
51 
	public static function configurer() {
 49 
	public static function configurer() {
52 
		self::$contexte = Config::get('fw_debogage_contexte');
 50 
		self::$contexte = Config::get('fw_debogage_contexte');
53 
		self::$logger = Config::get('fw_log_debogage');
 51 
		self::$logger = Config::get('fw_log_debogage');
54 
		self::$afficher = Config::get('fw_debogage');
 52 
		self::$afficher = Config::get('fw_debogage');
55 
	}
 53 
	}
- 
 
 54
- 
 
 55 
	/**
- 
 
 56 
	 * Renvoie le nombre d'exceptions et d'erreurs levées.
- 
 
 57 
	 * @see getExceptions() pour obtenir les exceptions formatées.
- 
 
 58 
	 * @since 0.3
- 
 
 59 
	 * @return int le nombre d'exception actuellement levées
- 
 
 60 
	 */
- 
 
 61 
	public static function getExceptionsNbre() {
- 
 
 62 
		return count(self::$exceptions);
- 
 
 63 
	}
- 
 
 64
56
65 
	/**
- 
 
 66 
	 * Renvoie le booleen définissant si l'on affiche le contexte ou non
- 
 
 67 
	 * @return bool true si on affiche le contexte sinon false.
57 
	/** Renvoie le booleen définissant si l'on affiche le contexte ou non */
 68 
	 */
58 
	public static function getContexte() {
 69 
	public static function getContexte() {
59 
		return self::$contexte;
 70 
		return self::$contexte;
60 
	}
 71 
	}
61 
 
 72 
 
62 
	/**
 73 
	/**
63 
	 * Definit si l'on veut afficher le contexte ou non
 74 
	 * Definit si l'on veut afficher le contexte ou non
64 
	 * @param bool true si on veut afficher le contexte, false sinon, par défaut vaut false
 75 
	 * @param bool true si on veut afficher le contexte, false sinon, par défaut vaut false
65 
	 */
 76 
	 */
66 
	public static function setContexte($contexte) {
 77 
	public static function setContexte($contexte) {
67 
		self::$contexte = $contexte;
 78 
		self::$contexte = $contexte;
68 
	}
 79 
	}
69 
 
 80 
 
70 
	/**
 81 
	/**
71 
	 * Fonction de gestion des exceptions, remplace le handler par défaut.
 82 
	 * Fonction de gestion des exceptions, remplace le handler par défaut.
72 
	 * Si une boucle génère de multiple exception (ou erreur) identique une seule sera stockée.
 83 
	 * Si une boucle génère de multiple exception (ou erreur) identique une seule sera stockée.
73 
	 * @param Exception $e l'exception à traiter
 84 
	 * @param Exception $e l'exception à traiter
74 
	 */
 85 
	 */
75 
	public static function gererException(Exception $e) {
 86 
	public static function gererException(Exception $e) {
76 
		$cle = hash('md5', $e->getMessage().'-'.$e->getFile().'-'.$e->getLine());
 87 
		$cle = hash('md5', $e->getMessage().'-'.$e->getFile().'-'.$e->getLine());
77 
		if (!isset(self::$exceptions[$cle])) {
 88 
		if (!isset(self::$exceptions[$cle])) {
78 
			self::$exceptions[$cle] = $e;
 89 
			self::$exceptions[$cle] = $e;
79 
			self::loggerException($e);
 90 
			self::loggerException($e);
80 
		}
 91 
		}
81 
	}
 92 
	}
82 
 
 93 
 
83 
	/**
 94 
	/**
84 
	 * Gère les erreurs en les convertissant en exceptions (remplace la fonction gestion d'erreurs native de php)
 95 
	 * Gère les erreurs en les convertissant en exceptions (remplace la fonction gestion d'erreurs native de php)
85 
	 * @param int $niveau le niveau de l'erreur
 96 
	 * @param int $niveau le niveau de l'erreur
86 
	 * @param string $message le message associé à l'erreur
 97 
	 * @param string $message le message associé à l'erreur
87 
	 * @param string $fichier le nom du fichier où l'erreur s'est produite
 98 
	 * @param string $fichier le nom du fichier où l'erreur s'est produite
88 
	 * @param int $ligne la ligne où l'erreur s'est produite
 99 
	 * @param int $ligne la ligne où l'erreur s'est produite
89 
	 * @param string $contexte le contexte associé à l'erreur
 100 
	 * @param string $contexte le contexte associé à l'erreur
90 
	 */
 101 
	 */
91 
	public static function gererErreur($niveau,  $message,  $fichier,  $ligne,  $contexte){
 102 
	public static function gererErreur($niveau,  $message,  $fichier,  $ligne,  $contexte){
92 
		// Si un rapport d'erreur existe, création d'une exception
 103 
		// Si un rapport d'erreur existe, création d'une exception
93 
		if (error_reporting() != 0) {
 104 
		if (error_reporting() != 0) {
94 
			$e = new ErrorException($message, 0, $niveau, $fichier, $ligne);
 105 
			$e = new ErrorException($message, 0, $niveau, $fichier, $ligne);
95 
			self::gererException($e);
 106 
			self::gererException($e);
96 
		}
 107 
		}
97 
		return null;
 108 
		return null;
98 
	}
 109 
	}
99 
 
 110 
 
100 
	/**
 111 
	/**
- 
 
 112 
	 * Renvoie les exceptions au format (X)HTML ou bien au format texte suivant le mode d'utilisation de PHP.
- 
 
 113 
	 * @since 0.3
- 
 
 114 
	 * @deprecated
101 
	 * Renvoie les exceptions au format (X)HTML
 115 
	 * @see getExceptionsFormatees()
102 
	 * ou bien au format texte suivant le mode d'utilisation de PHP
 116 
	 * @return string les exceptions formatées en texte ou (X)HTML.
103 
	 */
 117 
	 */
104 
	public static function getExceptions() {
 118 
	public static function getExceptions() {
- 
 
 119 
		return self::getExceptionsFormatees();
- 
 
 120 
	}
- 
 
 121
- 
 
 122 
	/**
- 
 
 123 
	 * Renvoie les exceptions au format (X)HTML ou bien au format texte suivant le mode d'utilisation de PHP.
- 
 
 124 
	 * @since 0.3
- 
 
 125 
	 * @return string les exceptions formatées en texte ou (X)HTML.
- 
 
 126 
	 */
- 
 
 127 
	public static function getExceptionsFormatees() {
105 
		$retour = '';
 128 
		$retour = '';
- 
 
 129 
		if (self::getExceptionsNbre() > 0) {
106 
		foreach (self::$exceptions as $cle => $e) {
 130 
			foreach (self::$exceptions as $cle => $e) {
107 
			switch (self::$mode) {
 131 
				switch (self::$mode) {
108 
				case self::MODE_CLI :
 132 
					case self::MODE_CLI :
109 
					$retour .= $e->getMessage()."\n";
 133 
						$retour .= self::formaterExceptionTxt($e);
- 
 
 134 
						break;
- 
 
 135 
					default:
110 
					$retour .= 'Fichier : '.$e->getFile()."\n";
 136 
						$retour .= self::formaterExceptionXhtml($e);
- 
 
 137 
				}
111 
					$retour .= 'Ligne : '.$e->getLine()."\n";
 138 
				// Nous vidons le tableau des exceptions au fur et à mesure pour éviter le réaffichage avec le destructeur.
112 
					if (self::getContexte()) {
 139 
				unset(self::$exceptions[$cle]);
113 
						$retour .= 'Contexte : '."\n".print_r($e->getTraceAsString(), true)."\n";
 - 
 
114 
					}
 140 
			}
115 
					break;
 141 
		}
116 
				default:
 142 
		return $retour;
- 
 
 143 
	}
- 
 
 144
- 
 
 145 
	/**
117 
					$retour .= '<div class="debogage">'."\n";
 146 
	 * Renvoie le tableau d'objets Exception générées par le script PHP triées du niveau de sévérité le plus élevé au moins élevé.
118 
					$retour .= $e->getMessage()."\n";
 147 
	 * Format du tableau :
- 
 
 148 
	 * array{sévérité_1 = array{Exception1, Exception2, Exception3,...}, sévérité_1 =  array{Exception1, Exception2, ...}, ...};
119 
					$retour .= '<span class="debogage_fichier">'.'Fichier : '.$e->getFile().'</span>'."\n";
 149 
	 * ATTENTION : si vous utilisez cette méthode, c'est à vous de gérer l'affichage des Exceptions. Le gestionnaire d'exception
- 
 
 150 
	 * n'enverra plus rien au navigateur ou à la console.
- 
 
 151 
	 * @since 0.3
120 
					$retour .= '<span class="debogage_ligne">'.'Ligne : '.$e->getLine().'</span>'."\n";
 152 
	 * @return array le tableau trié d'objet Exception.
- 
 
 153 
	 */
121 
					if (self::getContexte()) {
 154 
	public static function getExceptionsTriees() {
122 
						$retour .= '<pre>'."\n";
 155 
		$retour = array();
- 
 
 156 
		if (self::getExceptionsNbre() > 0) {
123 
						$retour .= '<strong>Contexte : </strong>'."\n".print_r($e->getTraceAsString(), true)."\n";
 157 
			foreach (self::$exceptions as $cle => $e) {
124 
						$retour .= '</pre>'."\n";
 158 
				$retour[$e->getSeverity()][] = $e;
125 
					}
 - 
 
- 
 
 159 
				// Nous vidons le tableau des exceptions au fur et à mesure pour éviter le réaffichage avec le destructeur.
126 
					$retour .= '</div>'."\n";
 160 
				unset(self::$exceptions[$cle]);
127 
			}
 161 
			}
128 
			// Nous vidons le tableau des exceptions au fur et à mesure
 - 
 
129 
			unset(self::$exceptions[$cle]);
 162 
			ksort($retour);
130 
		}
 163 
		}
131 
		return $retour;
 164 
		return $retour;
132 
	}
 165 
	}
133 
 
 166 
 
134 
	/**
 167 
	/**
135 
	 * Logue une exception donnée sous une forme lisible si self::logger vaut true.
 168 
	 * Logue une exception donnée sous une forme lisible si self::logger vaut true.
136 
	 * @param Exception	$e l'exception à logger
 169 
	 * @param Exception	$e l'exception à logger
137 
	 */
 170 
	 */
138 
	private static function loggerException($e) {
 171 
	private static function loggerException(Exception $e) {
139 
		if (self::$logger) {
 172 
		if (self::$logger) {
140 
			$erreur = '';
 - 
 
141 
			$erreur .= $e->getMessage()."\n";
 - 
 
142 
			$erreur .= 'Fichier : '.$e->getFile()."\n";
 - 
 
143 
			$erreur .= 'Ligne : '.$e->getLine()."\n";
 173 
			$message = self::formaterExceptionTxt($e);
144 
			if (self::getContexte()) {
 - 
 
145 
				$erreur .= 'Contexte : '."\n".print_r($e->getTraceAsString(), true)."\n";
 - 
 
146 
			}
 - 
 
147 
			$erreur .= "\n";
 - 
 
148 
			Log::ajouterEntree('erreurs', $erreur);
 174 
			Log::ajouterEntree('erreurs', $message);
149 
		}
 175 
		}
150 
	}
 176 
	}
- 
 
 177
- 
 
 178 
	/**
- 
 
 179 
	 * Formate en texte une exception passée en paramètre.
- 
 
 180 
	 * @since 0.3
- 
 
 181 
	 * @param Exception l'exception à formater.
- 
 
 182 
	 */
- 
 
 183 
	public static function formaterExceptionTxt(Exception $e) {
- 
 
 184 
		$message = '';
- 
 
 185 
		$message .= $e->getMessage()."\n";
- 
 
 186 
		$message .= 'Fichier : '.$e->getFile()."\n";
- 
 
 187 
		$message .= 'Ligne : '.$e->getLine()."\n";
- 
 
 188 
		if (self::getContexte()) {
- 
 
 189 
			$message .= 'Contexte : '."\n".print_r($e->getTraceAsString(), true)."\n";
- 
 
 190 
		}
- 
 
 191 
		$message .= "\n";
- 
 
 192 
		return $message;
- 
 
 193 
	}
- 
 
 194
- 
 
 195 
	/**
- 
 
 196 
	 * Formate en (X)HTML une exception passée en paramètre.
- 
 
 197 
	 * @since 0.3
- 
 
 198 
	 * @param Exception l'exception à formater.
- 
 
 199 
	 */
- 
 
 200 
	public static function formaterExceptionXhtml(Exception $e) {
- 
 
 201 
		$message = '';
- 
 
 202 
		$message .= '<div class="debogage">'."\n";
- 
 
 203 
		$message .= $e->getMessage()."\n";
- 
 
 204 
		$message .= '<span class="debogage_fichier">'.'Fichier : '.$e->getFile().'</span>'."\n";
- 
 
 205 
		$message .= '<span class="debogage_ligne">'.'Ligne : '.$e->getLine().'</span>'."\n";
- 
 
 206 
		if (self::getContexte()) {
- 
 
 207 
			$message .= '<pre>'."\n";
- 
 
 208 
			$message .= '<strong>Contexte : </strong>'."\n".print_r($e->getTraceAsString(), true)."\n";
- 
 
 209 
			$message .= '</pre>'."\n";
- 
 
 210 
		}
- 
 
 211 
		$message .= '</div>'."\n";
- 
 
 212 
		return $message;
- 
 
 213 
	}
151 
 
 214
- 
 
 215 
	/**
- 
 
 216 
	 * Lors de la destruction de la classe si des exceptions n'ont pas été affichées, et si le débogage est à true, elles sont
- 
 
 217 
	 * affichées.
- 
 
 218 
	 */
152 
	public function __destruct() {
 219 
	public function __destruct() {
153 
		// Si des erreurs n'ont pas été affichée nous forçons leur affichage
 220 
		// Si des erreurs n'ont pas été affichée nous forçons leur affichage
154 
		if (self::$afficher && count(self::$exceptions) > 0) {
 221 
		if (self::$afficher && self::getExceptionsNbre() > 0) {
155 
			echo self::getExceptions();
 222 
			echo self::getExceptionsFormatees();
156 
		}
 223 
		}
157 
	}
 224 
	}
158 
 
 225 
 
159 
}
 226 
}
160 
?>
 227 
?>