WebSVN – Applications.framework – Diff – /branches/v0.3-aleaume/framework/GestionnaireException.php


<?php
// declare(encoding='UTF-8');
/**
 * Classe de gestion des exceptions.
 * C'est un Singleton.
 *
 * 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: GestionnaireException.php 161 2010-03-05 09:04:15Z aurelien $$
 * @link	  /doc/framework/
 *
 */
class GestionnaireException {
 
	/**
	 * Liste des exceptions enregistrées
	 */
	private static $exceptions = array();
 
	/**
	 * Détermine si l'on affiche ou non le contexte
	 */
	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 $afficher = false;
 
	/**
	 * Definit si php est lancé en ligne de commande ou en mode serveur
	 */
	private static $mode = null ;
 
	/**
	 * le gestionnaire d'exception est un singleton
	 * et possède donc un "pointeur statique sur lui-même"
	 */
	private static $gestionnaireException;
 
	/**
	 * Constructeur avec paramètres optionnel
	 * @param bool indique si l'on veut afficher ou non le contexte des exceptions (i.e. la trace)
	 */
	public function __construct() {
		self::$exceptions = array();
		self::$contexte = Config::get('fw_debogage_contexte');
		self::$logger = Config::get('fw_log_debogage');
		self::$afficher = Config::get('fw_debogage');
		self::$mode = php_sapi_name();
 
		set_exception_handler(array(get_class($this),'gererException'));
		set_error_handler(array(get_class($this),'gererErreur'));
	}
 
	/**
	 * Renvoie le booleen définissant si l'on affiche le contexte ou non
	 */
	public static function getContexte() {
		return self::$contexte;
	}
 
	/**
	 * Definit si l'on veut afficher le contexte ou non
	 * @param bool true si on veut afficher le contexte, false sinon, par défaut vaut false
	 */
	public static function setContexte($contexte) {
		self::$contexte = $contexte;
	}
 
	 /** Fonction d'accès au singleton
	 * @return GestionnaireErreur le gestionnaire d'exceptions courant
	 */
	public static function getInstance() {
		if (self::$gestionnaireException instanceof GestionnaireException) {
			return self::$gestionnaireException;
		}
		self::$gestionnaireException = new GestionnaireException;
 
		return self::$gestionnaireException;
	}
 
	/**
	 * Fonction de gestion des exceptions, remplace le handler par défaut
	 * @param Exception $e l'exception à traiter
	 */
	public static function gererException(Exception $e) {
		// pour le moment on se contente de l'ajouter au tableau et de les afficher
		self::$exceptions[] = $e;
 
		// si on doit logger on envoie l'exception au loggeur
		if (self::$logger) {
			self::loggerException($e);
		}
	}
 
	/**
	 * 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) {
			return;
		}
 
		// sinon on crée une exception
		$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;
	}
 
	/**
	 * Renvoie les exceptions au format (X)HTML
	 * ou bien au format texte suivant le mode d'utilisation de PHP
	 */
	public static function getExceptions() {
		$retour = '';
		foreach (self::$exceptions as $cle => $e) {
			switch (self::$mode) {
				case 'cli' :
					$retour .= $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";
					}
					break;
				default:
					$retour .= '<pre class="debogage">'."\n";
					$retour .= $e->getMessage()."\n";
					$retour .= '<span class="debogage_fichier">'.'Fichier : '.$e->getFile().'</span>'."\n";
					$retour .= '<span class="debogage_ligne">'.'Ligne : '.$e->getLine().'</span>'."\n";
					$retour .= '</pre>'."\n";
 
					if (self::getContexte()) {
						$retour .= '<pre>'."\n";
						$retour .= '<strong>Contexte : </strong>'."\n".print_r($e->getTraceAsString(), true)."\n";
						$retour .= '</pre>'."\n";
					}
			}
			// Nous vidons le tableau des exceptions au fur et à mesure
			unset(self::$exceptions[$cle]);
		}
		return $retour;
	}
 
	/**
	 * logge une exception donnée sous une forme lisible
	 * @param Exception	$e l'exception à logger
	 */
	private static function loggerException($e) {
		$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);
	}
 
	public function __destruct() {
		// Si des erreurs n'ont pas été affichée nous forçons leur affichage
		if (self::$afficher && count(self::$exceptions) > 0) {
			echo self::getExceptions();
		}
	}
 
}
?>

Subversion Repositories Applications.framework

(root)/branches/v0.3-aleaume/framework/GestionnaireException.php @ 399 – Rev 160 → 161

Rev 160		Rev 161
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`	7	`* PHP Version 5`
8	`*`	8	`*`
9	`* @category Class`	9	`* @category Class`
10	`* @package Framework`	10	`* @package Framework`
11	`* @author aurelien <aurelien@tela-botanica.org>`	11	`* @author aurelien <aurelien@tela-botanica.org>`
12	`* @copyright 2009 Tela-Botanica`	12	`* @copyright 2009 Tela-Botanica`
13	`* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL`	13	`* @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`	14	`* @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL`
15	`* @version SVN: $$Id: GestionnaireException.php 160 2010-03-05 09:01:39Z aurelien $$`	15	`* @version SVN: $$Id: GestionnaireException.php 161 2010-03-05 09:04:15Z aurelien $$`
16	`* @link /doc/framework/`	16	`* @link /doc/framework/`
17	`*`	17	`*`
18	`*/`	18	`*/`
19	`class GestionnaireException {`	19	`class GestionnaireException {`
20		20
21	`/**`	21	`/**`
22	`* Liste des exceptions enregistrées`	22	`* Liste des exceptions enregistrées`
23	`*/`	23	`*/`
24	`private static $exceptions = array();`	24	`private static $exceptions = array();`
25		25
26	`/**`	26	`/**`
27	`* Détermine si l'on affiche ou non le contexte`	27	`* Détermine si l'on affiche ou non le contexte`
28	`*/`	28	`*/`
29	`private static $contexte = false;`	29	`private static $contexte = false;`
30		30
31	`/**`	31	`/**`
32	`* Détermine si l'on loggue ou non les erreurs`	32	`* Détermine si l'on loggue ou non les erreurs`
33	`*/`	33	`*/`
34	`private static $logger = false;`	34	`private static $logger = false;`
35		35
36	`/**`	36	`/**`
37	`* Détermine si l'on loggue ou non les erreurs`	37	`* Détermine si l'on loggue ou non les erreurs`
38	`*/`	38	`*/`
39	`private static $afficher = false;`	39	`private static $afficher = false;`
40		40
41	`/**`	41	`/**`
42	`* Definit si php est lancé en ligne de commande ou en mode serveur`	42	`* Definit si php est lancé en ligne de commande ou en mode serveur`
43	`*/`	43	`*/`
44	`private static $mode = php_sapi_name ;`	44	`private static $mode = null ;`
45		45
46	`/**`	46	`/**`
47	`* le gestionnaire d'exception est un singleton`	47	`* le gestionnaire d'exception est un singleton`
48	`* et possède donc un "pointeur statique sur lui-même"`	48	`* et possède donc un "pointeur statique sur lui-même"`
49	`*/`	49	`*/`
50	`private static $gestionnaireException;`	50	`private static $gestionnaireException;`
51		51
52	`/**`	52	`/**`
53	`* Constructeur avec paramètres optionnel`	53	`* Constructeur avec paramètres optionnel`
54	`* @param bool indique si l'on veut afficher ou non le contexte des exceptions (i.e. la trace)`	54	`* @param bool indique si l'on veut afficher ou non le contexte des exceptions (i.e. la trace)`
55	`*/`	55	`*/`
56	`public function __construct() {`	56	`public function __construct() {`
57	`self::$exceptions = array();`	57	`self::$exceptions = array();`
58	`self::$contexte = Config::get('fw_debogage_contexte');`	58	`self::$contexte = Config::get('fw_debogage_contexte');`
59	`self::$logger = Config::get('fw_log_debogage');`	59	`self::$logger = Config::get('fw_log_debogage');`
60	`self::$afficher = Config::get('fw_debogage');`	60	`self::$afficher = Config::get('fw_debogage');`
61	`self::$mode = php_sapi_name();`	61	`self::$mode = php_sapi_name();`
62		62
63	`set_exception_handler(array(get_class($this),'gererException'));`	63	`set_exception_handler(array(get_class($this),'gererException'));`
64	`set_error_handler(array(get_class($this),'gererErreur'));`	64	`set_error_handler(array(get_class($this),'gererErreur'));`
65	`}`	65	`}`
66		66
67	`/**`	67	`/**`
68	`* Renvoie le booleen définissant si l'on affiche le contexte ou non`	68	`* Renvoie le booleen définissant si l'on affiche le contexte ou non`
69	`*/`	69	`*/`
70	`public static function getContexte() {`	70	`public static function getContexte() {`
71	`return self::$contexte;`	71	`return self::$contexte;`
72	`}`	72	`}`
73		73
74	`/**`	74	`/**`
75	`* Definit si l'on veut afficher le contexte ou non`	75	`* Definit si l'on veut afficher le contexte ou non`
76	`* @param bool true si on veut afficher le contexte, false sinon, par défaut vaut false`	76	`* @param bool true si on veut afficher le contexte, false sinon, par défaut vaut false`
77	`*/`	77	`*/`
78	`public static function setContexte($contexte) {`	78	`public static function setContexte($contexte) {`
79	`self::$contexte = $contexte;`	79	`self::$contexte = $contexte;`
80	`}`	80	`}`
81		81
82	`/** Fonction d'accès au singleton`	82	`/** Fonction d'accès au singleton`
83	`* @return GestionnaireErreur le gestionnaire d'exceptions courant`	83	`* @return GestionnaireErreur le gestionnaire d'exceptions courant`
84	`*/`	84	`*/`
85	`public static function getInstance() {`	85	`public static function getInstance() {`
86	`if (self::$gestionnaireException instanceof GestionnaireException) {`	86	`if (self::$gestionnaireException instanceof GestionnaireException) {`
87	`return self::$gestionnaireException;`	87	`return self::$gestionnaireException;`
88	`}`	88	`}`
89	`self::$gestionnaireException = new GestionnaireException;`	89	`self::$gestionnaireException = new GestionnaireException;`
90		90
91	`return self::$gestionnaireException;`	91	`return self::$gestionnaireException;`
92	`}`	92	`}`
93		93
94	`/**`	94	`/**`
95	`* Fonction de gestion des exceptions, remplace le handler par défaut`	95	`* Fonction de gestion des exceptions, remplace le handler par défaut`
96	`* @param Exception $e l'exception à traiter`	96	`* @param Exception $e l'exception à traiter`
97	`*/`	97	`*/`
98	`public static function gererException(Exception $e) {`	98	`public static function gererException(Exception $e) {`
99	`// pour le moment on se contente de l'ajouter au tableau et de les afficher`	99	`// pour le moment on se contente de l'ajouter au tableau et de les afficher`
100	`self::$exceptions[] = $e;`	100	`self::$exceptions[] = $e;`
101		101
102	`// si on doit logger on envoie l'exception au loggeur`	102	`// si on doit logger on envoie l'exception au loggeur`
103	`if (self::$logger) {`	103	`if (self::$logger) {`
104	`self::loggerException($e);`	104	`self::loggerException($e);`
105	`}`	105	`}`
106	`}`	106	`}`
107		107
108	`/**`	108	`/**`
109	`* Gère les erreurs en les convertissant en exceptions (remplace la fonction gestion d'erreurs native de php)`	109	`* Gère les erreurs en les convertissant en exceptions (remplace la fonction gestion d'erreurs native de php)`
110	`* @param int $niveau le niveau de l'erreur`	110	`* @param int $niveau le niveau de l'erreur`
111	`* @param string $message le message associé à l'erreur`	111	`* @param string $message le message associé à l'erreur`
112	`* @param string $fichier le nom du fichier où l'erreur s'est produite`	112	`* @param string $fichier le nom du fichier où l'erreur s'est produite`
113	`* @param int $ligne la ligne où l'erreur s'est produite`	113	`* @param int $ligne la ligne où l'erreur s'est produite`
114	`* @param string $contexte le contexte associé à l'erreur`	114	`* @param string $contexte le contexte associé à l'erreur`
115	`*/`	115	`*/`
116	`public static function gererErreur($niveau, $message, $fichier, $ligne, $contexte){`	116	`public static function gererErreur($niveau, $message, $fichier, $ligne, $contexte){`
117	`// si aucun rapport d'erreur, on sort directement`	117	`// si aucun rapport d'erreur, on sort directement`
118	`if (error_reporting() == 0) {`	118	`if (error_reporting() == 0) {`
119	`return;`	119	`return;`
120	`}`	120	`}`
121		121
122	`// sinon on crée une exception`	122	`// sinon on crée une exception`
123	`$e = new ErrorException($message, 0, $niveau, $fichier, $ligne);`	123	`$e = new ErrorException($message, 0, $niveau, $fichier, $ligne);`
124	`// que l'on donne au tableau d'exceptions`	124	`// que l'on donne au tableau d'exceptions`
125	`self::$exceptions[] = $e;`	125	`self::$exceptions[] = $e;`
126	`// on la logge si nécéssaire`	126	`// on la logge si nécéssaire`
127	`if (self::$logger) {`	127	`if (self::$logger) {`
128	`self::loggerException($e);`	128	`self::loggerException($e);`
129	`}`	129	`}`
130	`return;`	130	`return;`
131	`}`	131	`}`
132		132
133	`/**`	133	`/**`
134	`* Renvoie les exceptions au format (X)HTML`	134	`* Renvoie les exceptions au format (X)HTML`
135	`* ou bien au format texte suivant le mode d'utilisation de PHP`	135	`* ou bien au format texte suivant le mode d'utilisation de PHP`
136	`*/`	136	`*/`
137	`public static function getExceptions() {`	137	`public static function getExceptions() {`
138	`$retour = '';`	138	`$retour = '';`
139	`foreach (self::$exceptions as $cle => $e) {`	139	`foreach (self::$exceptions as $cle => $e) {`
140	`switch (self::$mode) {`	140	`switch (self::$mode) {`
141	`case 'cli' :`	141	`case 'cli' :`
142	`$retour .= $e->getMessage()."\n";`	142	`$retour .= $e->getMessage()."\n";`
143	`$retour .= 'Fichier : '.$e->getFile()."\n";`	143	`$retour .= 'Fichier : '.$e->getFile()."\n";`
144	`$retour .= 'Ligne : '.$e->getLine()."\n";`	144	`$retour .= 'Ligne : '.$e->getLine()."\n";`
145	`if (self::getContexte()) {`	145	`if (self::getContexte()) {`
146	`$retour .= 'Contexte : '."\n".print_r($e->getTraceAsString(), true)."\n";`	146	`$retour .= 'Contexte : '."\n".print_r($e->getTraceAsString(), true)."\n";`
147	`}`	147	`}`
148	`break;`	148	`break;`
149	`default:`	149	`default:`
150	`$retour .= '<pre class="debogage">'."\n";`	150	`$retour .= '<pre class="debogage">'."\n";`
151	`$retour .= $e->getMessage()."\n";`	151	`$retour .= $e->getMessage()."\n";`
152	`$retour .= '<span class="debogage_fichier">'.'Fichier : '.$e->getFile().'</span>'."\n";`	152	`$retour .= '<span class="debogage_fichier">'.'Fichier : '.$e->getFile().'</span>'."\n";`
153	`$retour .= '<span class="debogage_ligne">'.'Ligne : '.$e->getLine().'</span>'."\n";`	153	`$retour .= '<span class="debogage_ligne">'.'Ligne : '.$e->getLine().'</span>'."\n";`
154	`$retour .= '</pre>'."\n";`	154	`$retour .= '</pre>'."\n";`
155		155
156	`if (self::getContexte()) {`	156	`if (self::getContexte()) {`
157	`$retour .= '<pre>'."\n";`	157	`$retour .= '<pre>'."\n";`
158	`$retour .= '<strong>Contexte : </strong>'."\n".print_r($e->getTraceAsString(), true)."\n";`	158	`$retour .= '<strong>Contexte : </strong>'."\n".print_r($e->getTraceAsString(), true)."\n";`
159	`$retour .= '</pre>'."\n";`	159	`$retour .= '</pre>'."\n";`
160	`}`	160	`}`
161	`}`	161	`}`
162	`// Nous vidons le tableau des exceptions au fur et à mesure`	162	`// Nous vidons le tableau des exceptions au fur et à mesure`
163	`unset(self::$exceptions[$cle]);`	163	`unset(self::$exceptions[$cle]);`
164	`}`	164	`}`
165	`return $retour;`	165	`return $retour;`
166	`}`	166	`}`
167		167
168	`/**`	168	`/**`
169	`* logge une exception donnée sous une forme lisible`	169	`* logge une exception donnée sous une forme lisible`
170	`* @param Exception $e l'exception à logger`	170	`* @param Exception $e l'exception à logger`
171	`*/`	171	`*/`
172	`private static function loggerException($e) {`	172	`private static function loggerException($e) {`
173	`$erreur = '';`	173	`$erreur = '';`
174	`$erreur .= $e->getMessage()."\n";`	174	`$erreur .= $e->getMessage()."\n";`
175	`$erreur .= 'Fichier : '.$e->getFile()."\n";`	175	`$erreur .= 'Fichier : '.$e->getFile()."\n";`
176	`$erreur .= 'Ligne : '.$e->getLine()."\n";`	176	`$erreur .= 'Ligne : '.$e->getLine()."\n";`
177	`if (self::getContexte()) {`	177	`if (self::getContexte()) {`
178	`$erreur .= 'Contexte : '."\n".print_r($e->getTraceAsString(), true)."\n";`	178	`$erreur .= 'Contexte : '."\n".print_r($e->getTraceAsString(), true)."\n";`
179	`}`	179	`}`
180	`$erreur .= "\n";`	180	`$erreur .= "\n";`
181	`Log::ajouterEntree('erreurs',$erreur);`	181	`Log::ajouterEntree('erreurs',$erreur);`
182	`}`	182	`}`
183		183
184	`public function __destruct() {`	184	`public function __destruct() {`
185	`// Si des erreurs n'ont pas été affichée nous forçons leur affichage`	185	`// Si des erreurs n'ont pas été affichée nous forçons leur affichage`
186	`if (self::$afficher && count(self::$exceptions) > 0) {`	186	`if (self::$afficher && count(self::$exceptions) > 0) {`
187	`echo self::getExceptions();`	187	`echo self::getExceptions();`
188	`}`	188	`}`
189	`}`	189	`}`
190		190
191	`}`	191	`}`
192	`?>`	192	`?>`