Girando per la rete ho trovato un plugin per Zend Framework che aiuta molto in fase di sviluppo. Il plugin in questione si chiama ZFDebug ed è disponibile con licenza BSD su google code.
L’utilizzo di questo plugin è abbastanza semplice ed immediato e fornisce utili informazioni sull’esecuzione della richiesta corrente. Tra le feature di questo plugin ci sono:
- Informazioni sull’uso della cache (Zend_Cache e APC)
- Informazioni sull’uso del database: dump completo delle query eseguite e tempi di esecuzione
- Informazioni su errori ed eccezioni
- Informazioni sui file inclusi, lista completa dei file, numero e dimensioni dei files inclusi
- Informazioni sui file di stile e sui javascript inclusi
- Informazioni sull’uso della memoria
- Visualizzazione del contenuto di Zend_Registry
- Informazioni sui tempi di esecuzione
- Dump delle variabili della vista e delle variabili $_POST e $_COOKIE
L’installazione ed uso di questo plugin avviene utilizzando il l’application bootstrap per le versioni di ZF superiori alla 1.8, in alternativa è disponibile anche la procedura per l’installazione nelle versioni precedenti. La procedura completa si trova nella pagina di istruzioni del progetto.
Setup per l’uso del plugin come application resource
Dal momento che una delle cose che ho maggiormente apprezzato con l’introduzione di Zend_Application è il meccanismo delle resources ho scritto un’application resource per poter caricarlo a piacimento utilizzando il solo file application.ini senza dover intervenire in nessun modo nel codice del file di bootstrap.
Per creare un’application resource è sufficiente creare una classe che estenda la classe Zend_Application_Resource_ResourceAbstract e definire in tale classe almeno il metodo init. Per la convenzione da utilizzare sui nomi di classe si veda qui. Come al solito ZF offre varie possibilità in modo soddisfare tutte le esigenze; tra le varie opportunità ho scelto la seguente strategia per poter caricare automaticamente le risorse che ho creato.
Nella mia libreria di estensioni a ZF mi sono creato una struttura identica a quella del framework stesso sostituendo il namespace Zend con un mio namespace (nello specifico Zenit) e ho aggiunto all’include path di php la directory radice di tale namespace.
Una volta fatto ciò si deve registrare il namespace per poter essere utilizzato tramite l’autoloader e dire a Zend_Application dove trovare le risorse aggiuntive, questi due passi si risolvono con due righe nel file application.ini:
autoloadernamespaces.zenit = "Zenit_" pluginPaths.Zenit_Application_Resource = "Zenit/Application/Resource"
Con queste due semplici righe si possono referenziare le risorse definite nel namespace Zenit_Application_Resource per nome. L’equivalente in maniera programmatica sarebbe stato:
$app = new Zend_Application(APPLICATION_ENV, array(
'pluginPaths' => array(
'Zenit_Application_Resource' => 'Zenit/Application/Resource/',
)));
$autoloader = Zend_Loader_Autoloader::getInstance();
$autoloader->registerNamespace('Zenit_');
Chiaramente risulta molto più comodo e portabile attraverso vari progetti il primo metodo.
Application resource
Completato il setup per poter caricare le proprie risorse, vediamo il file di risorsa vero e proprio e come sia possibile caricare o meno il plugin utilizzando poche righe nel file application.ini.
Con la configurazione creata in precedenza per definire una nuova risorsa è sufficiente creare il file Zfdebug.php nella directory delle risorse contenente la classe Zenit_Application_Resource_Zfdebug (è importante mantenere il case indicato sia nel nome del file sia nel nome della classe, altrimenti su filesystem case sensitive si avranno problemi).
Per far caricare il plugin ZFDebug è sufficiente inserire questo codice nel file di configurazione dell’applicazione
[development : production] ; enable zfdebug plugin resources.zfdebug.enabled = true resources.zfdebug.params.plugins[] = "Variables" resources.zfdebug.params.plugins.File.base_path = APPLICATION_PATH "/../" resources.zfdebug.params.plugins[] = "Database" resources.zfdebug.params.plugins[] = "Memory" resources.zfdebug.params.plugins[] = "Time" resources.zfdebug.params.plugins[] = "Registry" resources.zfdebug.params.plugins[] = "Exception"
Quando si usano le risorse i parametri passati alle risorse tramite il file di configurazione vengono mappati con i setter della classe risorsa, per cui nella classe risorsa avremo i metodi setParams e setEnabled che verranno richiamati con i parametri passati in application.ini. Il codice di questi due metodi è abbastanza semplice
/**
* @var boolean
*/
protected $_enabled = false;
/**
* @var array
*/
protected $_params = array ();
/**
* Set plugin options
*
* @param array $params
*/
public function setParams(array $params) {
$this->_params = $params;
}
/**
* Return plugin options
*
* @return array
*/
public function getParams() {
return $this->_params;
}
/**
* Activate plugin
*
* @param boolean $enabled
*/
public function setEnabled($enabled) {
$this->_enabled = (boolean) $enabled;
}
/**
* Return true iff plugin should be enabled
*
* @return boolean
*/
public function getEnabled() {
return $this->_enabled;
}
Mentre il caricamento vero e proprio del plugin viene effettuato dal metodo init che, utilizzando i parametri passati, lo registra nel FrontController
/**
* Defined by Zend_Application_Resource_Resource
*/
public function init() {
$this->initDebugPlugin();
}
/**
* Initialize ZFDebug plugin
*/
public function initDebugPlugin() {
if (!$this->_init && $this->getEnabled()) {
// execute once
$this->_init = true;
// plugin options
$options = $this->getParams();
// bootstrap database
if (isset($options['plugins']['Database'])) {
if ($this->getBootstrap()->hasPluginResource('db')) {
$this->getBootstrap()->bootstrap('db');
}
}
// normalize base_path with realpath
if (isset($options['plugins']['File']['base_path'])) {
$options['plugins']['File']['base_path'] = realpath(
$options['plugins']['File']['base_path']);
}
// register namespace
$autoloader = Zend_Loader_Autoloader::getInstance();
$autoloader->registerNamespace('ZFDebug');
// ensure frontcontroller is initializated
$this->getBootstrap()->bootstrap('frontController');
// instantiate plugin
$debug = new ZFDebug_Controller_Plugin_Debug(
$options);
// add plugin to front controller
$frontController = $this->getBootstrap()->getResource(
'frontController');
$frontController->registerPlugin($debug);
}
}
In questo codice si fa l’assunzione che la directory contenente il plugin sia presente nell’include path di php, altrimenti le classi relative al plugin vero e proprio non verranno trovate dall’autoloader.
Conclusioni
Una volta eseguiti i passi descritti in precedenza, aggiungere ed abilitare selettivamente il plugin ZFDebug nei propri progetti si ridurrà a due semplici operazioni: avere le classi necessarie nel proprio include path e abilitarlo o disabilitarlo utilizzando il file application.ini.
Vediamo come questo si possa fare facilmente nell’applicazione di esempio del quickstart disponibile per il download sul sito di Zend Framework. Una volta scaricata l’applicazione di esempio e creato il database con lo script apposito, è sufficiente eseguire i passi riportati per mettere in funzione il plugin.
Nello specifico andiamo a mettere i files nella directory library dell’applicazione (che viene incluso nell’include path dal bootstrap) in modo da avere questa struttura:
Struttura filesystem per usare l'application resource ZFDebug
Da notare che la directory ZFDebug è un link simbolico alla directory zfdebug-dist/library/ZFDebug, questo si rende necessario in quanto la libreria fa uso di immagini che si trovano nella directory web, per cui è necessario che essa sia presente nel path indicato in figura. Per ottenere questo risultato è sufficiente scompattare tutto il contenuto del plugin in library ed eseguire il comando ln -s zfdebug-dist/library/ZFDebug . da shell
Aggiungiamo le righe necessarie al file di configurazione dell’applicazione e carichiamo la home del progetto nel browser, questo è il risultato che si ha navigando tra le pagine dell’applicazione di esempio:
Dump delle variabili con ZFDebug
Tempi di esecuzione dello script con ZFDebug
L’applicazione QuickStart con il plugin ZFDebug installato è disponibile come archivio per il download.
