UNIVERSITÀ DEGLI S TUDI DI MILANO BICOCCA FACOLTÀ DI SCIENZE M ATEMATICHE FISICHE E N ATURALI
Corso di Laurea in Informatica
Progettazione e Sperimentazione di un Framework Estensibile per Applicazioni Web
SUPERVISORE: Chiar.mo Prof. R. Polillo
Relazione della prova finale di: DAVIDE CASALI Matr. n. 041666
Anno Accademico 2004/2005
A Elisa
-2-
S o m ma ri o Sommario ...................................................................................... 3 1. Introduzione ............................................................................. 6 1.1. Obiettivi.............................................................................. 6 1.2. Storia ................................................................................. 6 1.3. Organizzazione del lavoro ................................................... 7 1.4. Struttura dell’elaborato........................................................ 8 2. Analisi .................................................................................... 10 2.1. Definizioni ........................................................................ 10 2.1.1. 2.1.2.
Cos’è un Content Management System (CMS) ................... 10 Cos’è un Framework......................................................... 11
2.2. Tratti comuni: così fan tutti ................................................ 12 2.3. Tratti distintivi: analisi dei vari motori................................. 13 2.3.1. 2.3.2. 2.3.3. 2.3.4. 2.3.5.
PHPNuke ......................................................................... 14 Xoops .............................................................................. 16 Mambo ............................................................................ 18 Drupal.............................................................................. 19 WordPress ....................................................................... 20
3. Requisiti del sistema phpGolem............................................ 22 3.1. Linee guida....................................................................... 22 3.2. Tipologie di utenti ............................................................. 24 3.2.1. 3.2.2. 3.2.3. 3.2.4.
Framework developer ....................................................... 24 Framework user ............................................................... 25 Backoffice user ................................................................ 25 Public site user................................................................. 26
3.3. Requisiti di architettura ..................................................... 26 3.4. Requisiti di usabilità e interfaccia ...................................... 28 3.5. Requisiti tecnici ................................................................ 29 4. Architettura generale del sistema ......................................... 31 4.1. Architettura....................................................................... 31 4.2. Database.......................................................................... 33 -3-
4.2.1. 4.2.2. 4.2.3. 4.2.4. 4.2.5.
Gestore web multisito (web, setup) .................................... 34 Gestore estensioni (ext).................................................... 35 Gestione utenti, gruppi e diritti (user, auth) ........................ 36 Gestione dell’architettura del sito (arch)............................. 39 Gestione della configurazione (config) ............................... 41
4.3. Filesystem ........................................................................ 42 4.4. Framework ....................................................................... 43 4.4.1. 4.4.2. 4.4.3. 4.4.4. 4.4.5. 4.4.6. 4.4.7. 4.4.8. 4.4.9.
Web handler..................................................................... 45 Extensions handler ........................................................... 46 Users handler................................................................... 47 Architecture handler ......................................................... 48 Configuration handler ....................................................... 50 Template handler ............................................................. 50 Interface handler .............................................................. 53 Script di generazione pagina ............................................. 53 Struttura dell’URL ............................................................. 56
4.5. Estensioni ........................................................................ 57 4.6. Come sono perseguite le linee guida ................................. 60 4.6.1. 4.6.2. 4.6.3. 4.6.4. 4.6.5.
Estensibilità ..................................................................... 60 Flessibilità ....................................................................... 61 Semplicità di sviluppo ....................................................... 61 Semplicità di uso .............................................................. 61 Riuso ............................................................................... 62
5. User view ............................................................................... 63 5.1. Installazione ..................................................................... 63 5.2. Estensioni ........................................................................ 66 5.2.1. 5.2.2. 5.2.3. 5.2.4. 5.2.5. 5.2.6. 5.2.7. 5.2.8. 5.2.9.
Extensions ....................................................................... 66 Configuration ................................................................... 67 Architecture ..................................................................... 68 Groups............................................................................. 70 Users............................................................................... 71 Articles ............................................................................ 72 Topics.............................................................................. 74 Comments ....................................................................... 75 Files ................................................................................ 76
6. Sperimentazione .................................................................... 78 6.1. Sito in oggetto .................................................................. 78 6.2. Metodologia di progettazione............................................. 78 -4-
6.3. Definizione requisiti .......................................................... 79 6.3.1. 6.3.2. 6.3.3. 6.3.4. 6.3.5. 6.3.6. 6.3.7. 6.3.8. 6.3.9. 6.3.10.
Analisi della concorrenza .................................................. 79 Obiettivi generali .............................................................. 82 Utenti............................................................................... 83 Requisiti di architettura ..................................................... 85 Requisiti di comunicazione................................................ 86 Requisiti funzionali ........................................................... 86 Requisiti di contenuto ....................................................... 87 Requisiti di gestione ......................................................... 88 Requisiti di accessibilità.................................................... 88 Requisiti di usabilità........................................................ 89
6.4. Web design ...................................................................... 89 6.5. Visual design .................................................................... 91 6.6. Sviluppo del software ........................................................ 93 6.7. Redazione dei contenuti.................................................... 93 6.8. Il risultato ......................................................................... 93 7. Riferimenti e bibliografia ....................................................... 98 7.1. Riferimenti ........................................................................ 98 7.2. Bibliografia ....................................................................... 99
-5-
1 . I n t ro d uzi o n e 1.1. Obiettivi In internet esistono numerosissimi software per la gestione di siti web di piccole, medie o grandi dimensioni. Questi programmi sono denominati, in rapporto al loro approccio al problema, Content Management Systems (CMS) oppure Frameworks. Questo elaborato delinea i vari passi di realizzazione di un sistema di questo tipo, sottostante un sito web, partendo da un’analisi dei suoi requisiti per giungere alla realizzazione del prodotto software pienamente funzionante. Lo scopo è quindi dare una spiegazione esauriente delle fasi iniziali di analisi e di progettazione, fino alla successiva implementazione e sperimentazione in un sito web effettivo. Il progetto software realizzato è una piattaforma aperta per la realizzazione di un sito web interattivo di dimensioni piccole e medie, focalizzato su alcuni aspetti peculiari che verranno delineati nel corso della trattazione.
1.2. Storia Il software qui esposto è denominato phpGolem. Ha preso avvio nel giugno 2003 con scopi molto limitati e centrati ad hoc per un portale web.
-6-
Successivamente (settembre 2003) questo progetto è stato abbandonato, ma si è sentita la necessità di avere una solida base su cui realizzare eventuali altri siti, senza essere vincolati ad un preciso target operativo e visuale. Quando si è giunti alla maturità della versione 0.3 (gennaio 2004) si è notato che, sebbene i requisiti iniziali fossero stati ampiamente soddisfatti, l’idea originale poteva essere estesa per realizzare un sistema completamente modulare e quindi adattabile ad ogni necessità. Quindi giunge la versione 0.4 (prima beta a luglio 2004) è una riscrittura integrale del codice basata su questa logica più astratta ed efficiente, che ha portato a notevoli miglioramenti. La versione di phpGolem 0.4 è quella qui presa come riferimento e ne viene delineato lo sviluppo e la realizzazione.
1.3. Organizzazione del lavoro Il lavoro è stato organizzato in due fasi distinte. La prima è stata quella operativa che è andata ad analizzare phpGolem per verificare, dal punto di vista dell’utente, quanto fosse efficace e come rispondesse alle esigenze, cercando di realizzare una interfaccia semplice ed uniforme. In questa fase si è realizzata una versione navigabile di un sito web (che si trova spiegata nell’ultima parte di questo elaborato), per poter osservare operativamente il comportamento del motore nella gestione delle pagine e della struttura del sito. Nel frattempo, si procedeva alla realizzazione di una interfaccia più intuitiva per la parte di amministrazione e gestione del sito, in modo da verificare come i cambiamenti potessero essere effettuati in modo semplice e, contemporaneamente come questi si riflettessero sul sito pubblico. -7-
Successivamente si è proceduto ad una analisi di tutto il materiale raccolto sino a questo punto, del lavoro svolto e della struttura logica del programma, delineando la struttura complessiva di questo elaborato.
1.4. Struttura dell’elaborato L’elaborato è strutturato in modo da fornire una prospettiva esauriente su phpGolem. Nella prima parte, Analisi (cap 3), verrà quindi esposta la tipologia di programma software che è stata sviluppata, cioè il significato di framework estensibile e di content management system, con i loro contesti applicativi. Verranno quindi analizzati i tratti fondamentali che sono comuni a questi tipi di sistemi in modo da delineare quali siano i punti imprescindibili che bisogna tenere in considerazione. In più verrà fatto un breve passaggio sui vari sistemi opensource attualmente disponibili che rientrano in questa categoria, così da avere una base di implementazioni sulle quali ragionare e valutare i pro e i contro di ciascuna. Nella seconda parte, Requisiti del sistema phpGolem (cap 4), saranno invece definite le linee guida sulle quali il progetto viene fondato, in modo che siano sempre ben chiari le priorità e gli scopi da perseguire. E’ poi importante avere una immagine più concreta e aderente alla realtà su chi siano gli utilizzatori di questo software, in modo da poter focalizzare una utenza precisa. In quest’ambito ci si concentra soprattutto sulla parte tecnica e di amministrazione: la parte pubblica del sito avrà altre utenze che necessiteranno di una valutazione ad hoc in rapporto alle necessità. Quindi si passa alla definizione dei vari requisiti del sistema, come i requisiti di architettura, di usabilità e tecnici.
-8-
La terza parte, Architettura generale del sistema phpGolem (cap 5), approfondisce l’analisi e passa ai dettagli implementativi a livello di struttura e logica. E’ una parte che senza scendere in dettagli troppo implementativi descrive il funzionamento logico delle varie componenti che costituiscono il software phpGolem, partendo da uno schema generico e quindi descrivendo più esaurientemente ogni livello. Viene poi posto un accento sulla prospettiva utente nella parte User View (cap 6), dove vengono descritte le principali funzionalità che il CMS, basato sul framework phpGolem, mette a disposizione. Questo viene fatto tramite un approccio descrittivo non troppo tecnico, che si rivolge ad un utente non esperto, spiegando come svolgere le principali operazioni. Infine c’è la parte di Sperimentazione (cap 7) che prendendo ad esempio il modello di valutazione del libro “Il Check Up dei Siti Web” (v. Bibliografia) lo applica alla progettazione per poter realizzare un sito efficace e completo, basato sempre su phpGolem CMS.
-9-
2 . A n al is i 2.1. Definizioni Prima di delineare come è stato progettato phpGolem, è meglio avere una panoramica sul contesto nel quale si inserisce. Vediamo quindi di entrare nella questione, definendo prima le tipologie dei programmi utilizzabili per questo scopo e in seguito analizzandone alcuni.
2.1.1. Cos’è un Content Management System (CMS) Internet è un luogo dove l’informazione è libera di circolare, di essere condivisa, rielaborata e diffusa globalmente. Date queste premesse, è fondamentale l’esistenza di strumenti software per organizzare questo flusso di informazione, nell’ambito ristretto di un singolo sito web (o di un network di siti). Tradotto da en.wikipedia.org: Nell’informatica, un content management system (CMS) è un sistema utilizzato per organizzare e rendere semplice la creazione collaborativa di documenti e altri contenuti. Un CMS è frequentemente una applicazione web utilizzata per gestire siti e contenuti, anche se in alcuni casi dei CMS richiedono del particolare software client installato su un computer per modificare e realizzare articoli. Un content management system è quindi una struttura software che è adibita a gestire e organizzare, in modo coerente, una quantità di - 10 -
informazioni anche notevole e, spesso, riguardante media differenti, anche se principalmente si considera la componente testuale, data la maggiore facilità con cui può essere veicolata. L’operazione di gestire informazione in modo collaborativo può essere condotta in svariati modi, differenti e specifici allo scopo che ci si prefigge di ottenere. Vi sono ad esempio: • web content management systems per gestire ed organizzare vari aspetti del web • transactional content management systems (T-CMS) per gestire e organizzare transazioni di commercio elettronico • integrated content management systems (I-CMS) per assistere nella gestione di documenti internamente ad una azienda • publications management systems (P-CMS) per aiutare nella gestione di pubblicazioni come manuali, libri, testi, etc • learning management systems (L-CMS) che forniscono un ambiente di supporto nell’apprendimento Come si può vedere l’ambito di utilizzo di questi software può variare molto, sia dal punto di vista dell’informazione veicolata sia dal punto di vista dell’organizzazione della stessa e del modo di interazione.
2.1.2. Cos’è un Framework Un framework software è invece uno strumento sopra il quale si può realizzare il proprio progetto. Può essere considerato come le fondamenta sulle quali viene costruito un edificio. Tradotto da en.wikipedia.org: Nello sviluppo software un framework è una specifica struttura di supporto all’interno della quale un altro software può essere organizzato e sviluppato. Un framework può includere programmi di supporto, librerie di codice, linguaggi di scripting o altri
- 11 -
software per aiutare nello sviluppo e funziona come colla fra i vari componenti di un progetto software. Quindi, fondamentalmente un framework risulta essere un componente invisibile all’utente finale, mentre è di cruciale importanza per lo sviluppatore. Utilizzare un framework piuttosto che iniziare da zero implica avere un punto di partenza migliore e strumenti a disposizione già rifiniti per poter lavorare, ma di contro bisogna anche ricordare che esistono dei framework molto specifici e, quindi, sbagliare in questa scelta iniziale potrebbe essere un problema perché vincola integralmente lo sviluppo futuro. Questo livello software, come è stato specificato può fornire più o meno servizi, ma rimane un ambiente di lavoro all’interno del quale il programma funziona. Il framework si distingue quindi da una libreria in quanto quest’ultima è qualcosa che si aggiunge al corpo di esecuzione del programma principale, mentre nel caso del framework il software gira al suo interno.
2.2. Tratti comuni: così fan tutti Nella maggior parte dei programmi CMS opensource disponibili in rete, si possono riscontrare vari elementi comuni. Un numero notevole di CMS disponibili in rete, persegue un fine specifico e/o si orienta verso una precisa fascia di pubblico. Il target scelto da phpGolem è quindi condiviso da altri motori: si colloca in una fascia di utenza non per forza esperta in questo tipo di tecnologie, orientata ad un facile e veloce deployment (installazione sul server) ed ha una gestione che può non richiedere alcuna conoscenza di programmazione.
- 12 -
Oltre alle caratteristiche che definiscono la tipologia del programma, questa categoria di CMS gestisce la grafica e il layout delle pagine, seppure ciascuno in modo differente. Alcuni seguono un approccio molto minimalista (ovvero solo la pagina principale, mentre le altre vengono generate in modo iterativo) mentre altri forniscono un modo molto flessibile per poter gestire vari layout. Tutti comunque consentono una completa personalizzazione della grafica, anche se a volte limitata per motivi strutturali. In secondo luogo, tutti sembrano aver compreso come sia fondamentale rendere il motore estensibile in qualche modo. L’estensibilità del motore è effettivamente un punto molto importante per soddisfare tutto il possibile ventaglio di esigenze che si possono riscontrare. Nonostante questo, non c’è convenzione sui nomi utilizzati: alcuni utilizzano “module”, altri “blocks”, altri ancora “extensions” o “plugins”. Differenze che delineano anche come notevolmente differiscano le varie implementazioni di questa funzionalità.
2.3. Tratti distintivi: analisi dei vari motori Nell’analisi di questo genere di strumentazioni bisogna sicuramente considerare il target a cui esse si rivolgono. Infatti vi è una differenza sostanziale fra uno strumento in uso presso una singola persona e uno strumento analogo in ambito corporate (aziende di grosse dimensioni, con notevole utilizzo di infrastrutture informatiche). Per questo motivo ho delineato sostanzialmente quattro profili: 1. personale: il software viene usato da una singola persona per uno scopo specifico. Raramente il carico di lavoro che dovrà essere sopportato sarà eccessivo e possono essere usate anche soluzioni a basso costo domestiche (i.e. blog personale, sito personale). 2. piccolo portale: il numero di utenti che interagiscono è limitato e non vi è la necessità di particolari accorgimenti per l’organizzazione delle informazioni. Le interazioni degli utenti
- 13 -
con il sito sono poche o comunque occasionali (i.e. puntoinformatico). 3. medio portale: il numero di utenti che interagiscono diventa sensibile e potrebbero essere necessari accorgimenti tecnici per supportare il traffico sul server, oltre che avere a disposizione banda sufficiente. E’ necessario studiare la struttura con accuratezza per non dare senso di confusione al visitatore (i.e. multiplayer.it). 4. grande portale: il numero di utenti che interagiscono è notevole e lato server è fondamentale una architettura tecnica ben studiata. Il motore deve poter sfruttare a dovere la potenza di calcolo ed essere strutturato per gestire una notevole quantità di interazioni al secondo (i.e. slashdot, deviantart). Ho utilizzato il termine portale invece di sito, più generico, perché nell’uso attuale sottintende il concetto di interazione più o meno ampia con gli utenti, cosa che non è esplicitata dal vocabolo sito. Escludo in questa disamina il profilo per quelli che si possono definire portali enterprise, ovvero sistemi enormi che devono reggere un carico notevole di lavoro, visto che solitamente sono realizzati ad hoc. Considero in questa categoria siti come microsoft.com, ibm.com, etc.
2.3.1. PHPNuke Questo uno dei motori più antichi e diffuso sul web. Si tratta di un progetto nato in modo amatoriale da parte di uno sviluppatore intorno all’anno 2000. E’ stato uno dei pionieri per quanto riguarda i sistemi CMS opensource e per questo risulta avere un’enorme diffusione. Il codice però è stato scritto nel 2000 con le conoscenze del periodo dell’autore, cosa che comporta evidenti idiosincrasie strutturali e un codice sporcato da moltissime pezze e aggiustamenti. Lo stesso sistema a moduli risulta essere di difficile gestione (per quanto sia un notevole passo avanti ai tempi) e facilmente intaccabile da vulnerabilità di vario tipo. Inoltre, dal punto di vista tecnico vi sono moltissime riscritture di codice e la mancanza di un sistema centralizzato di gestione: vi sono numerose tipologie funzionali (index, blocks, admin, moduli, …) ed
- 14 -
ognuna utilizza un differente host per lavorare, sebbene non vi sia una necessità concreta. Estendere questo motore risulta semplice quanto programmare uno script separato se non si fa utilizzo di alcuna funzionalità interna, ma diventa molto intricato quando si cerca di integrare il tutto. Questo motore è fondamentalmente nato per la gestione di siti personali e piccoli portali, ma a volte arriva, grazie a qualche team di sviluppo, anche all’affidabilità necessaria per portali di medie dimensioni, pur non raggiungendo l’idoneità completa a questo scopo. Dal punto di vista dell’interfaccia pubblica il programma non consente grosse variazioni, a partire dalla struttura base costituita da intestazione e tre colonne. Allo stesso modo tutti i moduli creabili per questa piattaforma soffrono di forti limiti e raramente sfoggiano un sistema di interazione con l’utente ben studiato. A parte la divisione su tre colonne e in blocchi, il motore non offre molte altre possibilità integrate per l’organizzazione dei contenuti: la navigazione in profondità e la gerarchia del sito è demandata unicamente al modulo che sta gestendo in quel momento il corpo del sito. Per la parte amministrativa la sensazione generale è di caos, problema che si accentua anche grazie al fatto che i moduli sono sviluppati da persone diverse e spesso utilizzano - 15 -
paradigmi e logiche differenti. Il menu stesso di gestione si riduce ad una mera elencazione di varie funzionalità e moduli. Il target di questo motore è l’uso personale o di piccolo portale: salendo con il numero di utenti la struttura inizia a far sentire le sue debolezze PostNuke rappresenta l’evoluzione di PHPNuke da parte di uno staff differente di sviluppatori, che ha preso il progetto originale portandolo avanti, ma permangono le logiche strutturali risalenti all’originale: questo garantisce che tutti i moduli scritti per il progenitore funzionino ancora, ma inficia il risultato finale nel suo complesso.
2.3.2. Xoops Questo è un programma di gestione per portali di piccole o medie dimensioni, e persegue il fine parallelo di essere un CMS (come loro stessi spiegano nei dettagli del loro progetto). Sfrutta il concetto di modularità, essendo questo un paradigma fondamentale per garantire la crescita e la gestione dei sistemi complessi. L’installazione prepara un sistema vuoto (versione 2.2) che può essere ampliato scaricando dal sito ufficiale altri moduli in modo da avere a propria disposizione solo le parti che si sono scelte per gli scopi specifici del sito. Al contrario la versione 2.0 fornisce un pacchetto già contenente alcuni moduli, in modo da poter partire fin da subito con un set minimo di feature. Il sistema di amministrazione varia leggermente come interfaccia nelle due ultime versioni scaricabili (2.0 e 2.2), passando da un menu
- 16 -
verticale con popup a un menu orizzontale, che mi è sembrato meglio organizzato. In entrambi i casi, il motore e le estensioni native risultano avere una interfaccia piuttosto spartana, con una attenzione probabilmente più all’aspetto della programmazione che non a quello dell’usabilità. Aspetto che comunque potrebbe essere personalizzato in parte tramite un sistema di themes (templates) che ne ridefiniscano la grafica. Dal punto di vista dello sviluppo, i vari moduli sono strutturati piuttosto bene, ma non vi è un sistema trasparente per farli interagire fra di loro. Si possono usare unicamente le classi native (“core”) di Xoops e non vi è un sistema per astrarre e condividere funzioni fra i vari moduli. Utilizza una logica object oriented per molte parti del motore, tenendo un sistema misto per altre parti (funzioni, codice inline), probabilmente a causa di una precisa scelta di architettura unitamente ai limiti imposti da PHP 4. L’utilizzo di Smarty come motore per i template è inoltre una buona scelta, in quanto è un componente di Pear, la libreria pubblica di classi per PHP, forse il migliore in quanto a personalizzazione e velocità. In definitiva Xoops è un sistema più giovane di PHPNuke, si fonda su basi meglio pensate e con un continuo rinnovo (anche guardando la roadmap questo è evidente), con l’idea di mantenere la compatibilità, ma senza sacrificare l’evoluzione del motore stesso.
- 17 -
2.3.3. Mambo Questo sembra un tool orientato ad una fascia di utilizzo più professionale: Mambo si offre infatti come strumento aziendale e quindi presuppongo sia orientato ad un carico di lavoro piuttosto elevato. L’interfaccia è meglio strutturata dei precedenti, con un sistema di amministrazione separato dal sito effettivo, organizzato tramite una barra orizzontale a menu, ognuna per una specifica categoria funzionale del motore. Mambo sembra presentarsi con una struttura a contenitori, caratteristica comune sia a PHPNuke che a Xoops, ma utilizza una nomenclatura specifica differente dagli altri. Ha Modules e, in più strutture chiamate Mambots e Componente, a mio avviso, rischia di rendere troppo complessa l’interazione con l’utente e di rendere la curva di apprendimento piuttosto bassa, in quanto, prima di poterlo utilizzare, bisogna capire tutte le nomenclature che questo motore introduce. Questo è evidente durante la programmazione di una di queste parti per ampliare le funzionalità di Mambo, programmazione che quindi rischia quindi di essere un po’ dispersiva. L’interfaccia è comunque ben strutturata e curata in molti dettagli anche minori, ma probabilmente non è stata realmente pensata con il concetto di usabilità in mente: ad esempio c’è una distinzione fra l’interfaccia di amministrazione generica e
- 18 -
il pannello di gestione di un singolo elemento, ma non è sensibile il passaggio dall’una all’altra, cosa che disorienta l’utente. Questo risulta essere piuttosto problematico, poiché vi è nativo un sistema di lock (se un amministratore sta modificando qualcosa, viene segnalato con un lucchetto). E’ in definitva un CMS molto completo e abbastanza efficace, poiché risulta piuttosto solido ed estensibile in molti modi.
2.3.4. Drupal Questo è un framework più che un CMS, piuttosto recente, che sembra essere una sorta di versione più complessa di un motore per blog. Appena installato appare piuttosto spartano nelle funzionalità, con una interfaccia pulita ed essenziale. Questo ha come risultato che si riesce ad usare in un tempo molto ridotto il motore e le sue funzionalità. Inoltre non vi è una reale separazione fra la parte di amministrazione e quella pubblica: l’interfaccia è la medesima e le opzioni gestionali appaiono all’utente loggato con i diritti corretti tramite un menu. Come accennato, risulta essere qualcosa più di un motore per blog: di base offre tutta una serie di funzionalità che servono per ottenere questo scopo, ma il motore è ampliabile tramite dei moduli scaricabili in modo da poter personalizzare tutto - 19 -
secondo le proprie necessità. In effetti Drupal è la base sulla quale Tipic ha sviluppato il suo servizio di blog: splinder.com. Fra tutti Drupal grazie anche ad un inizio piuttosto essenziale ed ad una interfaccia piuttosto ben strutturata, risulta essere forse il più veloce in assoluto da imparare ad usare. Un difetto che presenta Drupal è forse proprio il suo maggiore pregio: il motore è piuttosto immediato da usare e gestire a discapito della complessità strutturale: i template e i moduli sono piuttosto semplici e non forniscono molti servizi e componenti per integrare il codice. E’ forse la scelta migliore con poco tempo da dedicare all’aspetto tecnico per siti di piccole e medie dimensioni, grazie alla sua semplicità.
2.3.5. WordPress Pur non essendo un CMS o un Framework in senso stretto, WordPress è un motore piuttosto interessante. La sua funzione primaria è quella di gestire blog, ma essendo un motore estensibile risulta essere facilmente ampliabile per coprire una vasta gamma di funzionalità. E’ interessante perché, seppure orientato ad un fine preciso (ovvero il blog), riesce ad essere sufficientemente flessibile in modo da adattarsi senza problemi ad una notevole varietà di utilizzi. Inoltre, poiché è primariamente un motore per blog è stato accuratamente studiato per essere molto efficace in questo senso avendo una interfaccia semplice e immediata, che lo rende facilmente usabile. Il sistema di plugins peraltro non è strutturato in modo tradizionale: invece di essere un blocco funzionale separato, usa un corpo di codice che tramite degli hook si aggancia al motore WordPress
- 20 -
ampliandone le funzionalità in modo uniforme, nel modo e luogo dove serve. Dal punto di vista della presentazione, del layout e della gerarchia, tutto è semplificato in modo da essere gestito tramite il template e, modificando questo, si personalizzano le pagine che l’utente vedrà. L’approccio è piuttosto semplicistico e necessita la conoscenza dei linguaggi per il web come HTML e CSS, più qualche tag PHP, ma risulta essere piuttosto veloce e immediato per chi ha un minimo di conoscenza nel campo, mentre utenti generici possono comunque utilizzare WordPress senza però andare a cambiare queste componenti.
- 21 -
3 . R e q u i s i ti d e l s i s t e m a p h pG ol e m Il motore che è stato realizzato è stato progettato partendo da alcuni principi fondamentali che ne definiscono gli scopi. Possiamo quindi considerare phpGolem come un framework estensibile per applicazioni web, orientato verso la realizzazione di content management system.
3.1. Linee guida Possiamo sintetizzare i principi che caratterizzano i cardini intorno ai quali è stato progettato il sistema e gli obiettivi che sono stati perseguiti: 1. Estensibilità Le funzionalità raramente sono fisse e comuni a tutti gli scopi da raggiungere data l’immensa varietà di usi e applicazioni che può avere il prodotto destinato al web. Per questo motivo è stata scelta una via che minimizzi un nucleo centrale di operazioni e che fornisca contemporaneamente una solida base su cui costruire e aggiungere funzioni in modo semplice ed intuitivo. Questa idea di base, fulcro del motore, garantisce anche che il programma scali bene, in proporzione alle necessità: un sito semplice caricherà poche estensioni risultando quindi molto snello e leggero. Al crescere delle necessità aumenterà anche il numero di componenti utilizzate: il carico di lavoro risulta quindi essere proporzionale alle necessità. 2. Flessibilità Tanti sono i software per il web che forniscono una mole molto valida di funzionalità, ma peccano di un requisito spesso fondamentale, ovvero la flessibilità. - 22 -
In questo caso la flessibilità è garantita dal perseguimento dell’obbiettivo della separazione della logica dalla presentazione. In questo modo il motore si adatta perfettamente a qualunque layout grafico venga utilizzato, senza doversi limitare ad un preciso stile. Questo significa lasciare liberi i designer di scegliere la migliore architettura per il sito ed il migliore layout visuale senza per questo dover sacrificare funzionalità, o viceversa. 3. Semplicità di sviluppo Dato che il punto chiave è fornire un sistema semplice e immediato, facile da gestire e da potenziare, è cruciale che sia il più possibile agevole per uno sviluppatore aggiungere parti assecondando le necessità dell’applicazione che si va a creare. Quindi ogni estensione del motore è ben separata da ogni altra: questo consente ad ogni sviluppatore di utilizzare il proprio stile di programmazione senza dover pensare a come è stato realizzato il resto. Garantire strumenti per creare una estensione ben integrata, semplificando operazioni ripetitive e lasciando libertà al programmatore di scegliere lo stile di sviluppo che più gli è consono risulta quindi rilevante. 4. Semplicità di uso Bisogna però sempre tenere il riferimento costante all’utente finale. Rendere un software strutturato facile ad usarsi non è una impresa così semplice, soprattutto tenendo in considerazioni le limitazioni del web stesso. Quindi è importante tenere sempre come riferimento linee guida di utilizzo, soprattutto nel backend gestionale (backoffice) in modo che mantenere un sito operativo non richieda personale specializzato (al più, solo per le operazioni più critiche o radicali). 5. Riuso Il motore deve essere strutturato il più possibile per garantire che le estensioni al suo interno possano comunicare e utilizzare vicendevolmente le operazioni che ciascuna di esse fornisce.
- 23 -
Di conseguenza, pur lasciando motore è strutturato per favorire modo che ogni estensione possa classi così che siano disponibili in
libertà allo sviluppatore, il questo processo, facendo in esportare le proprie librerie e caso di necessità.
Per queste motivazioni è stato scelto il nome “golem”, con il prefisso “php” di uso comune a tutti gli applicativi che si basano su questo linguaggio: phpGolem. Il golem è una creatura realizzata per mano dell’uomo, creato assemblando più parti distinte e con lo scopo di aiutare il proprio padrone: esattamente quello che fa questo motore, utilizzando differenti estensioni per poter fornire un servizio preciso. Il motore è sviluppato integralmente in lingua inglese per garantirne la più ampia diffusione, ma dispone di una struttura tale da garantire la possibilità di localizzazioni.
3.2. Tipologie di utenti La progettazione del motore dal punto di vista dell’interazione e dell’interfaccia tiene conto delle seguenti figure: 1. Framework developer 2. Framework user, o web builder 3. Backoffice user 4. Public site user Queste sono state delineate in modo da avere sempre come riferimento il tipo di utilizzo che verrà fatto dalle varie tipologie di utente.
3.2.1. Framework developer Il framework developer è una persona che si trova a dover sviluppare su questo motore. E’ una persona che conosce PHP ad un livello intermedio (almeno fino all’uso e all’instanziazione di classi). Egli avrà la necessità di creare rapidamente una nuova estensione.
- 24 -
Ha bisogno quindi delle conoscenze base su come realizzare l’extension ed eventuali spiegazioni su come funziona la struttura stessa del motore, nel caso debba integrare il suo programma con altre componenti. Dato che conosce già il linguaggio che intende utilizzare, va sul sito ufficiale per trovare le informazioni necessarie per poter iniziare e portare avanti il proprio lavoro. Vuole mettersi al lavoro nel minor tempo possibile senza dover imparare sintassi nuove, anche se probabilmente in futuro potrà aver bisogno di alcune librerie interne di phpGolem.
3.2.2. Framework user Il framework user è la persona che utilizza phpGolem e tutte le estensioni necessarie per poter realizzare un sito web. In questa figura rientrano web administrator, web master ed eventualmente il web designer. Questa figura necessita di conoscere le modalità di configurazione e uso delle estensioni che verranno inserite nel sito web che deve creare o gestire, non è quindi richiesta alcuna conoscenza programmativa. Cerca quindi nella documentazione la spiegazione di come è strutturato il motore dal punto di vista operativo per poterlo organizzare secondo le sue necessità. Tutte le operazioni sono svolte nella parte di amministrazione, mentre viene a tratti aperta l’interfaccia pubblica per controllare il risultato del proprio lavoro.
3.2.3. Backoffice user Questo utente utilizza giornalmente alcune funzioni specifiche. E’ ad esempio un editor dei contenuti che riporterà tutte le notizie sul sito stesso. Questa persona non ha alcuna conoscenza tecnica e non ha intenzione di imparare nulla di nuovo per poter lavorare. I suoi strumenti sono semplici ed intuitivi e focalizzati sull’operazione che deve svolgere. Nella parte di backoffice (amministrazione) vede solamente le parti specifiche al proprio ruolo e nient’altro che lo possa confondere. - 25 -
Potenzialmente, l’orientamento di questa parte del lavoro è di tipo semantico: l’organizzazione di eventuali articoli è in base al loro significato e questo è indipendente dalla posizione gerarchica nel sito finale.
3.2.4. Public site user L’utente generico giunge sul sito volendo trovare informazioni nel minor tempo possibile. Egli non è interessato a tecnicismi, quindi il motore deve essergli nascosto. La grafica e il layout sono studiati ad hoc nel progetto del sito per uno scopo specifico e deve essere quindi garantita la massima flessibilità in questo senso. Tutte queste tipologie di utenti sono tenute in considerazione nella realizzazione del progetto con pari priorità, rappresentando ciascuna i diversi livelli operativi ai quali è destinato il prodotto.
3.3. Requisiti di architettura Le fondamenta di phpGolem poggiano su un sistema che deve basarsi sul concetto di estensibilità. E’ quindi fondamentale fornire un sistema che sia verticalmente efficiente per la singola funzionalità operativa e contemporaneamente consenta una comunicazione orizzontale fra le varie altre componenti del software. Il nome phpGolem definisce propriamente il framework e quindi un nucleo di classi e oggetti che gestiscono l’intera struttura. Il framework stesso deve quindi fornire un sistema per inserire e coordinare funzionalità aggiuntive, fornendo contemporaneamente alcuni classi e oggetti per gestire le funzionalità base che un sito web dinamico potrebbe richiedere. Queste funzionalità base sono: • Gestione del database • Gestione delle estensioni • Gestione degli utenti e delle autorizzazioni • Gestione dell’architettura del sito - 26 -
• Gestione della grafica del sito (tramite templates) • Gestione dei files e delle cartelle Queste funzionalità sono quindi fornite come classi contenenti solamente logica (nessuna interfaccia trattandosi di un framework) più un elemento che gestisce il flusso di esecuzione delle componenti per la generazione della pagina finale. Nel caso di phpGolem si è pensato al concetto di estensione come di un elemento che va ad inserirsi su una struttura base. Il vocabolo è stato scelto per essere il più possibile di facile comprensione: “estensione” (extension) è infatti lo stesso termine che usa il noto browser web Mozilla Firefox e quindi dovrebbe essere un termine di vasta diffusione. Si è preferito questo vocabolo al posto di un forse più chiaro “plugin” perché mentre il plugin è concepito come un elemento esterno che aggiunge una funzionalità, al contrario l’estensione è qualcosa di perfettamente integrato nel sistema. L’estensione inoltre è pacchettizzata, questo significa che tutte le parti che convergono a svolgere un preciso compito siano concentrate e ben separate dal resto del sistema. Un altro vantaggio che si ottiene è garantire una separazione dal punto di vista dello sviluppo. In questo modo è possibile lavorare separatamente su diverse estensioni senza per questo inficiare l’intero sistema o impedire la programmazione di altre parti. Infine la pacchettizzazione consente al sistema di gestire l’estensione come un singolo elemento, e rende più semplice la distribuzione e l’installazione. Inoltre le estensioni devono essere abbastanza flessibili al loro interno per consentire varie tipologie di programmazione, in modo da adattarsi meglio allo scopo per cui vengono sviluppate. Per questo è possibile inserire nell’estensione non solo il componente base per la gestione dell’interfaccia, ma anche classi e oggetti per gestire la logica o files contenenti la presentazione e la grafica. - 27 -
Sono cioè fondamentali per perseguire i fini di flessibilità, la separazione della logica dalla presentazione e contemporaneamente il fornire un livello ottimale di interazione fra i vari componenti.
3.4. Requisiti di usabilità e interfaccia Il livello utente è costituito da due interfacce separate e chiaramente distinte. Una interfaccia è pubblica, accessibile a tutti e realizzata dal web designer per soddisfare i fini del sito che verrà progettato. Una seconda interfaccia è invece privata e costituisce la parte gestionale del sito stesso, ovvero le pagine di amministrazione. La parte pubblica varia quindi da sito a sito e non è nostro interesse ora valutarla (verrà fatto nella parte di sperimentazione), mentre quella privata deve essere disegnata durante la realizzazione del motore CMS e quindi va pensata in sede di progettazione. Dopo una prima pagina dove si effettua il login per l’identificazione, la parte di amministrazione dovrà essere quindi in grado di indirizzare in modo rapido l’utente (se ha diritti di accesso) alle funzionalità di cui ha bisogno. La pagina è quindi strutturata in modo da separare visivamente la parte di navigazione (in nero) dalla pagina sulla quale si sta operando (in bianco). La parte di navigazione dispone quindi di due livelli di navigazione: il primo è un menu verticale posizionato sul lato sinistro, sintetizzante ciascuna voce con un vocabolo che chiarifica la parte della gestione alla quale si può avere accesso. In particolare, il raggruppamento delle varie opzioni del menu è realizzato in modo da unire assieme varie funzionalità che assolvono a compiti comuni. Il secondo livello è espresso tramite una barra orizzontale opzionale che varia contestualmente alla pagina visualizzata (ovvero alla voce di primo livello selezionata). Per garantire una certa uniformità di - 28 -
navigazione il primo pulsante su tale barra è costituito dal link “Back” (indietro) per fornire all’utente un elemento fisso per tornare alla pagina precedente indipendentemente dall’operazione che si sta conducendo. Ogni voce del menu di primo livello accede a parti del motore che non sono necessariamente state scritte coordinatamente a phpGolem stesso (estensioni, vedi più avanti), quindi è importante rifarsi a una guideline coerente. La prima pagina di ciascuna voce del menu deve fornire un riassunto visivo dello stato attuale del sistema per quanto riguarda quella specifica funzionalità. Nella barra orizzontale di navigazione andranno definiti i vari pulsanti per eseguire varie operazioni riguardanti la pagina su cui siamo. Se fosse necessario poter effettuare ricerche o selezioni di vario genere sugli eventuali elementi gestiti è consigliabile inserire in cima alla pagina un campo per poter effettuare queste operazioni. Una funzionalità di questo tipo è sempre consigliata nel caso di elementi che si pensa potrebbero venire gestiti in grande numero. L’inserimento e la modifica degli elementi andrebbero fatti in modo coerente con una stessa interfaccia sia per l’inserimento che per la modifica, in modo da mantenere l’uniformità e ridurre la possibilità che l’utente possa venire spaesato. Nel caso di liste contenenti svariate voci, uniformi o comunque facilmente confondibili, è anche consigliabile l’utilizzo di una leggera zebratura sulle righe dell’elenco.
3.5. Requisiti tecnici Per la realizzazione del motore sono stati scelti i due componenti opensource più diffusi ad oggi nella rete: - PHP 4.3 o superiore - MySQL 4.0 o superiore - 29 -
Questa scelta è dovuta al fatto che PHP 4 risulta tuttora la versione più diffusa di questo linguaggio di scripting. Al contrario PHP 5, seppure portatore di notevoli innovazioni, è ancora un linguaggio giovane. Vi è inoltre un motivo non essenziale, ma comunque da tenere in considerazione: PHP 4 supporta nativamente MySQL, mentre nel caso di PHP 5 è un modulo che deve essere attivato. La versione attualmente in sviluppo è quindi PHP 4.3.11. Data la compatibilità di PHP 5, passare a questa versione del linguaggio di scripting non comporta praticamente alcun ostacolo né differenza di utilizzo. MySQL è storicamente l’accoppiata ideale per PHP 4 e quindi raramente si vedono questi due programmi disaccoppiati. Inoltre, questi due componenti sono installabili su qualunque piattaforma in modo semplice: su Microsoft Windows, GNU/Linux, Apple OS X, etc, sia su server Apache che IIS, garantendo una notevole diffusione.
- 30 -
4 . A r ch i t e t t u r a g e n e r a l e d e l s is t e m a In ogni progetto di una certa dimensione è fondamentale progettare la logica e l’architettura del sistema in astratto, prima ancora di passare a qualunque dettaglio implementativo. Vediamo quindi in questo capitolo come è stato progettato phpGolem, sulla base delle riflessioni e dei requisiti definiti nei capitoli precedenti.
4.1. Architettura Il sistema come abbiamo detto è un framework: questo significa che fornisce un livello astratto e separato sul quale le applicazioni web possono essere costruite. Questo livello contiene una serie di classi per la gestione semplificata di molti degli aspetti che si ritrovano nella maggior parte degli applicativi web, come la gestione degli utenti, del database o della grafica. Oltre a fornire questi elementi primari, il framework incorpora nativamente un sistema per la gestione di pacchetti software, denominati estensioni. Queste costituiscono il modo più efficiente di sviluppare applicazioni web su phpGolem e forniscono contemporaneamente, un sistema logico per raggruppare funzionalità omogenee. Quindi questa struttura si va a definire su tre livelli fondamentali, che si orientano da un livello di astrazione maggiore ad uno minore: 1. Estensioni, ovvero gli elementi che realizzano le applicazioni sul motore e implementano l’interfaccia. - 31 -
2. Framework, il livello dove viene gestito il caricamento e l’interazione delle estensioni, fornendo contemporaneamente una serie di funzioni utili. 3. Filesystem e Database, ovvero la struttura fisica sulla quale poggia il framework. Da questo livello vengono prelevati i dati grezzi per essere elaborati o trattati dal programma.
- 32 -
Questo schema delinea la struttura del motore in modo generale, andando a disporre i vari blocchi logici come una struttura ordinata di elementi che si basano l’uno sull’altro. Il filesystem e il database sono ovviamente il più basso livello possibile su cui lavorare: il framework si pone al di sopra di questo, semplificando operazioni su queste due fonti dati grezze ed astraendo in classi ed oggetti le funzionalità. Sul framework si appoggiano tutte le estensioni, che vengono create sul livello sottostante e vengono fatte interagire e funzionare nel modo corretto. Dopo questa visione generale della struttura, andiamo ad osservare i vari livelli secondo un approccio bottom-up.
4.2. Database Separiamo per una disamina più dettagliata il livello più basso nelle sue due componenti principali: Files e Database.
Lo schema del database necessario al framework per funzionare è costituito da un gruppo di tabelle, con nomi prefissi dalla stringa “g_” (completamente personalizzabili), che vengono utilizzate dalle varie classi del core per memorizzare informazioni e impostazioni. Visto che ogni tabella o gruppo di tabelle è connessa ad una funzione specifica, le analizzerò in base a questo tipo di logica.
- 33 -
4.2.1. Gestore web multisito (web, setup) Una parte del motore che funziona automaticamente è quella che gestisce l’installazione e l’inizializzazione di un sito web. Il motore phpGolem è infatti stato creato tenendo a mente la possibilità che più siti possano essere installati su un server utilizzando lo stesso database. Per questo motivo esiste una classe nel framework che associa il nome identificativo del sito (impostato nel file di configurazione) ad un ID memorizzato in una tabella, che viene utilizzato da tutte le estensioni per tenere separati i dati specifici per i diversi siti web. Lo schema della tabella web è il seguente: web wid idname Name URL Enabled Description Date Time IP
int (key) varchar(50) varchar(255) varchar(255) int varchar(255) date time varchar(15)
Questa tabella è stata progettata in modo da tenere traccia dell’associazione nome e id corrispondente (wid), aggiungendo dei dati facoltativi in modo da poter identificare più facilmente un sito web. Inoltre viene anche registrata la data di attivazione. Il campo wid è utilizzato in modo uniforme su tutto il database in modo da identificare univocamente uno specifico sito web. La funzione di questa tabella è naturalmente molto più rilevante nel caso della gestione di più siti con una unica base dati. Inoltre utilizzando un indice numerico al posto di una stringa all’interno delle
- 34 -
tabelle è consentito un notevole risparmio di spazio e una migliore velocità di ricerca durante le query. E’ da sottolineare che questa funzionalità di gestione separata è studiata in modo da consentire una struttura centralizzata parziale: l’utilizzo del parametro wid ($WEB_ID nel codice) è facoltativo per le estensioni e questo consente la creazione di siti contenenti sia componenti strettamente separate sia parti comuni gestite in simultanea su tutti i siti. Ad esempio è possibile creare un motore di ricerca che effettui la scansione sull’intero database, sapendo poi distinguere la fonte da cui una singola voce è stata prelevata. Oppure è possibile registrare gli utenti globalmente, mentre i diritti di questi son assegnati localmente. Inoltre, quando la tabella in questione non viene rilevata, il gestore web carica in memoria un oggetto che compie il setup del sito, inizializzando le tabelle e configurando il primo avvio.
4.2.2. Gestore estensioni (ext) La gestione delle estensioni viene realizzata da un oggetto che fa uso della seguente tabella ext extid wid Extension Name FileName Path Mode Sort
int (key) int varchar(20) varchar(20) varchar(50) varchar(255) smallint int
Questa contiene tutti i dati necessari alla gestione delle estensioni che sono state attivate e che quindi sono operative sul sito web. - 35 -
E’ importante notare che questa tabella non memorizza le estensioni nel senso risretto del termine, ma dispone una tupla per ogni classe PHP che l’estensione possiede e istanzia, in modo da avviarle dinamicamente in fase di runtime. Questo comportamento verrà comunque spiegato nella parte riguardante l’architettura delle estensioni. Inoltre per garantire flessibilità al codice e al motore stesso vengono memorizzati i files in modo da tenere traccia del path relativo rispetto alla root del sito: sebbene quindi le estensioni siano progettate per essere poste in una precisa locazione, queste possono essere in realtà eseguite da qualunque directory. Oltre ai dati essenziali è rapidamente riconoscibile la chiave wid riguardante l’identificativo del sito web in esecuzione: siti differenti che si appoggiano alla stessa base dati possono quindi caricare e gestire in modo indipendente le estensioni. Il campo sort infine è una colonna che si può utilizzare se una estensione ha deve essere avviata prima di un’altra dal motore, in modo da garantire la priorità di esecuzione.
4.2.3. Gestione utenti, gruppi e diritti (user, auth) La parte di gestione degli utenti risulta essere quella più complessa da un punto di vista del database, in quanto ogni utente è relazionato sia ai gruppi a cui appartiene sia ai diritti che possiede. Per questo motivo sono necessarie ben cinque tabelle: users, rights, groups, r2ug, u2g, che definiscono al loro interno gruppi, utenti, diritti e le interconnessioni fra gli stessi.
- 36 -
users uid User Pass Nick EMail Note SessionHash LastLogin
int (key) varchar(32) varchar(32) varchar(50) varchar(60) varchar(80) varchar(32) datetime
La tabella users (utenti del sito) memorizza tutti i dati di registrazione dell’utente, in forma minimale: questo perché si è preferito progettare una base dati ridotta sotto questo aspetto, eventualmente ampliabile tramite una estensione che a questo punto può costruire una JOIN fra le due (o più) tabelle. Inoltre vi è distinzione fra i dati di login (user/pass) ed il nome utilizzato dal motore pubblicamente, che invece è memorizzato nella cella Nick. Questo garantisce la possibilità da parte degli utenti di cambiare il proprio nick visualizzato senza dover mutare i dati di registrazione. L’e-mail è memorizzata per realizzare possibili controlli durante la creazione dell’account, oppure per mandare successivamente segnalazioni. Gli ultimi due campi sono utilizzati dal motore e non sono modificabili direttamente: SessionHash memorizza un hash MD5 variabile che viene utilizzato per l’identificazione univoca dell’utente, in modo da aumentare la sicurezza. LastLogin invece è un semplice campo che viene aggiornato all’ultima data ed ora di visita di quel preciso utente.
- 37 -
groups gid wid Name Description
int (key) int varchar(30) varchar(128)
La tabella dei gruppi non richiede molti dati, è sufficiente il nome ed una eventuale descrizione. Ma è importante sottolineare che mentre gli utenti sono globalmente disponibili a tutti i siti che usano lo stesso db, i gruppi sono indipendenti (è utilizzato il campo wid). rights rightid wid Extension Key Values Description
int (key) int varchar(20) varchar(20) tinyint varchar(30)
La tabella dei diritti viene gestita in modo consistente con le estensioni: ogni diritto appartiene infatti ad una specifica estensione, per questo motivo ne è esplicitato il nome. Il campo Key è quindi una stringa che definisce il tipo di diritto che quella estensione utilizza. E’ importante notare che al momento dell’attivazione di una nuova estensione viene creato un diritto base con campo Key vuoto, che rappresenta il minimo livello di autenticazione per l’accesso al componente appena inserito. Il campo Values è infine utilizzato per impostare che tipologia di diritti è possibile assegnare. Si tratta infatti di una flag che definisce che tipo di selezione mostrare: il default è 2, ovvero due valori fra cui scegliere che saranno quindi “consentito” e “vietato”. Infine vi sono le tabelle che gestiscono le relazioni: la prima fra utenti e gruppi (u2g) mentre la seconda fra diritti e utenti o gruppi (r2ug).
- 38 -
u2g ugid uid gid
int (key) int int
Questa tabella è di comprensione piuttosto immediata: associa utenti con gruppi, in un rapporto di molti a molti. r2ug rugid int (key) rightid int uid int gid int Level tinyint Questa tabella associa un utente o un gruppo con un diritto. Si è realizzata una tabella unica per entrambi in modo da non disperdere troppo i dati per una operazione semplice come questa: nel caso di un gruppo, il campo uid sarà zero, il contrario nel caso di un utente. E’ importante notare come r2ug memorizza anche un livello di accesso per uno specifico diritto (Level). E’ infatti possibile specificare una scala numerica quando una estensione utilizza un diritto, in modo da realizzare una maggiore granularità.
4.2.4. Gestione dell’architettura del sito (arch) La gestione dell’architettura del sito è affidata ad un componente del framework piuttosto complesso che genera una struttura gerarchica di layouts all’interno dei quali vengono effettuati dei collegamenti con dei moduli pubblici delle estensioni (vedremo poi meglio più avanti il funzionamento). I primi sono gestiti dalla tabella arch, i collegamenti da arch_binds.
- 39 -
arch archid parentarchid wid Ref Template SubTemplate Type
int (key) int int varchar(30) varchar(255) varchar(255) tinyint
Qui si nota un campo autoreferenziale che è parentarchid, in modo da poter costruire una gerarchia su n livelli di tuple, che corrispondono ai layout possibili. Il campo Ref è invece utilizzato per richiamare lo specifico layout e renderlo operativo: va infatti a corrispondere con il campo l (L minuscola) nella querystring dell’URL. I due campi Template e SubTemplate definiscono quale grafica deve essere utilizzata sulla pagina, mentre il campo Type specifica se si tratta di un layout normale o di quello di default (esisterà quindi una sola chiave con valore 1), ma è stato denominato in questo modo per rendere possibili anche future evoluzioni. arch_binds archbindid archid Tag x fx Param Access
int (key) int varchar(64) varchar(20) varchar(64) varchar(128) tinyint
La tabella collega ogni archid a molte tuple, ognuna contenente un riferimento ad un Tag specifico esistente nel layout specificato in arch. Questo viene quindi posto in relazione con un modulo pubblico di una estensione (x, fx, rappresentano estensione e funzione): questa parte verrà spiegata più avanti quando si delineerà la parte di architettura. - 40 -
Il campo Param è utile per aggiungere delle variabili di configurazione aggiuntive al modulo che si dovrà poi chiamare a runtime. E’ indicato anche un campo Access per specificare il grado di visibilità che il modulo in questione avrà: ad esempio potrà essere reso visibile solamente agli utenti registrati, per visualizzare una scritta con i messaggi ricevuti.
4.2.5. Gestione della configurazione (config) Un’altra parte del framework è dedicata alla gestione di un sistema globale di configurazione, in modo da disporre di un luogo condiviso da tutte le estensioni per salvare singole variabili. config keyid wid x Key Value DefValue OptValue Description
int (key) int varchar(20) varchar(64) varchar(128) varchar(128) varchar(128) varchar(128)
La tabella memorizza il sito a cui corrispondono queste variabili (wid): essendo le estensioni dipendenti dal sito in cui girano, anche le variabili corrispondenti devono esserlo. Il campo x costituisce il nome interno dell’estensione alla quale è associata una Key, in modo analogo ai diritti, contenente il nome del valore di configurazione. I tre campi successivi servono all’assegnazione del valore: il primo, Value, definisce il valore attuale della variabile di configurazione, DefValue il suo valore di default, mentre OptValue contiene una stringa speciale utilizzata per realizzare un elenco di possibilità alternative fra cui scegliere. - 41 -
E’ autoesplicativo il campo Description, che spiega lo scopo della variabile di configurazione a cui appartiene.
4.3. Filesystem Questo livello include sia la strutturazione del framework sul sito web, sia i files che questo utilizzerà durante il suo funzionamento.
La struttura rispecchia, con alcune aggiunte, gli insiemi definiti nell’architettura generale. Abbiamo infatti tre directory che contengono i tre livelli sopra esposti. 1. ext, contenente tutte le estensioni 2. golem, contenente tutti i files di funzionamento del framework 3. files, contenente tutti i files che potranno essere utilizzati durante il funzionamento In aggiunta a queste parti fondamentali è necessario organizzare anche altri elementi, per motivi tecnici e di semplificazione della gestione. Ad esempio, è necessaria la presenza di un file indice (index.php) che avvii il file default per la gestione (golem.paginator.php) e che quindi si occupi di avviare tutta la procedura di generazione della pagina. E’ anche necessario un modo per accedere alla pagina di amministrazione che, per motivi di semplicità, in questo caso è una sottocartella denominata admin: questo per semplificare la digitazione dell’URL da parte di un utente. - 42 -
Sono anche state separate due funzionalità che a rigor di logica potrebbero essere incluse nella sottocartella files. Il motivo è fornire una maggiore prominenza a queste parti che sono di maggiore importanza per l’utente che deve gestirle. La prima è la cartella templates che contiene, separatamente, tutti i layout e le grafiche utilizzabili a runtime dal motore, in modo da averle a disposizione con immediatezza e facilità. La seconda è la cartella pages, che fornisce un modo semplice per realizzare pagine statiche e renderle disponibili all’interno del motore. E’ importante notare che queste ultime due cartelle sono spostabili e modificabili, assieme ad altri dati, da parte del file di configurazione (_globals.php), il quale, fra le varie cose, contiene il nome del sito e i fondamentali dati di connessione al database. E’ quindi essere possibile unificarle spostandole sotto la directory dei files.
4.4. Framework Il framework è l’aspetto più importante di tutto il sistema. In questo caso si tratta di un insieme di classi che collaborano fra di loro e offrono una serie di funzionalità, solo dal punto di vista logico. Infatti nessun componente ha mai la possibilità di un output diretto verso l’utente, che viene invece gestito, come vedremo più avanti, tramite le estensioni.
- 43 -
Unica eccezione è lo script di generazione pagina, che dato il suo scopo molto particolare esula dalla struttura a classi. Ogni classe del framework è quindi dedicata ad un preciso scopo, in modo da avere una separazione logica dei vari compiti.
Operativamente il framework è disponibile nell’istante in cui viene incluso il file golem.php, contenuto nella cartella golem: questo - 44 -
passaggio molto semplice rende disponibile tutto il livello, pronto all’uso. Per rendere completamente operative tutte le funzionalità è ovviamente necessario procedere all’inizializzazione della classe di gestione del database e all’avvio del metodo di aggancio del sito con la propria web ID.
4.4.1. Web handler Il gestore, o handler, web (golem.web.php) è la classe che sincronizza il nome identificativo del sito specificato nel file di configurazione con l’id web (wid) che verrà utilizzata all’interno del motore. In questo caso web va inteso come rete nel senso originale del termine: infatti non fa altro che organizzare una rete di più siti collegati allo stesso database. Vi è quindi una separazione che consente di avere accesso ad un solo database tramite siti distinti, con la possibilità di mantenere la divisione per tutti i dati memorizzati che riguardano uno solo dei web connessi. In questo modo è possibile realizzare strutture anche piuttosto complesse: un database unico per ricercare le informazioni, per registrare gli utenti e operazioni simili, e un network che si diversifica su siti dedicati ad attività differenti. Inoltre questa classe funziona da primer per l’eventuale setup: se all’avvio non viene rilevata la struttura di tabelle nel database, viene caricata dinamicamente la classe setup (in modo che occupi memoria e potenza di calcolo solo nello specifico caso) e avviata. La classe quindi crea il database vuoto secondo lo schema prima spiegato e genera tutti i parametri di configurazione iniziali, aggiungendo anche l’utente di amministratore (unico utente disponibile al setup).
- 45 -
La classe setup, inoltre, svolge la funzione di aggiornare il database e gli eventuali parametri di configurazione nel caso venga updatato il motore phpGolem sul server web su cui gira.
4.4.2. Extensions handler Questo gestore è forse l’elemento più importante di tutto il framework perché svolge il compito cruciale di gestire il funzionamento delle estensioni. Come è già stato accennato, le estensioni sono dei programmi a tutti gli effetti, contenuti in pacchetti che si appoggiano sul livello framework per funzionare. Il gestore (golem.ext.php) non fa altro che inizializzare le estensioni a runtime, fornendo anche una serie di funzioni per poterle manipolare come unità: aggiunta, installazione, eliminazione. E’ quindi il componente che fornisce il punto di aggancio ed è quindi il fulcro dell’esecuzione delle estensioni, stabilendo e organizzando tutta la struttura logico-funzionale. La parte di aggiunta è piuttosto complessa ma sequenziale: per aggiungere una estensione è sufficiente infatti specificarne la posizione nel filesystem e il suo nome: 1. Viene istanziato l’oggetto di interfaccia, in modo da potere accedere a tutti i suoi metodi e alle sue variabili di configurazione. 2. Questo permette l’accesso ad alcune variabili interne di configurazione, fra cui fondamentale l’elenco delle altre eventuali classi a cui fa riferimento (XClasses). 3. Sia l’estensione, ovvero la sua interfaccia, che le classi così reperite vengono quindi inserite nel database. E’ un passaggio essenziale perché consente successivamente di istanziare sia l’interfaccia che le classi di logica in seguito ad una semplice query sul database. 4. Quindi vengono inseriti i diritti di default, richiamando la specifica classe del framework che procederà all’aggiunta. - 46 -
5. L’ultimo passaggio consiste nel richiamare una possibile funzione all’interno dell’oggetto di interfaccia per consentire all’estensione stessa di eseguire uno script al momento dell’inserimento. A runtime poi, per ogni caricamento della pagina, vengono estratte le estensioni attive (e relative classi di logica) dal database, per poterle inizializzare. 1. Il processo non fa altro che istanziare tutti gli oggetti relativi a ciascuna delle estensioni. 2. Aggancia ad esse il file di lingua specificato nel file di configurazione del sito. 3. La funzione di inizializzazione utilizza le funzionalità di PHP per consentire alle classi di logica di funzionare fra di loro: vengono infatti resi globali tutti gli oggetti qui creati, tranne l’interfaccia (che deve rimanere specifica per l’estensione). Vedremo più avanti nel capitolo come sono strutturate e come funzionano le estensioni. Il gestore è peraltro strutturato in modo da caricare dinamicamente le estensioni la prima volta che ne viene fatta richiesta: in questo modo se il framework viene caricato ma utilizzato solo nelle sue funzionalità base, non vengono dedicate risorse di calcolo e di memoria per caricare anche tutte le estensioni.
4.4.3. Users handler Il gestore degli utenti è in realtà diviso per questioni organizzative in due oggetti distinti: il primo è il gestore utenti propriamente detto (golem.user.php) mentre il secondo è il gestore delle autenticazioni e dei diritti (golem.auth.php). Il primo gestisce l’utente correntemente loggato nel sistema, associando ad esso sia i dati inseriti nel database, sia rendendo disponibili una serie di dati volatili che vengono memorizzati nel cookie. Questo è molto utile per gestire impostazioni di configurazione - 47 -
marginali ed eventuali variabili per la realizzazione di interfacce più intelligenti, senza per questo appesantire il database. Inoltre la gestione di questi valori è condotta in modo omogeneo con il gestore di configurazione (vedi più avanti): questo comporta che se un valore non è memorizzato in modo unico per l’utente, viene ricercato il default nelle impostazioni globali del sistema. Il secondo invece è di maggiore importanza perché effettua tutti i controlli di sicurezza. Durante la login, se i dati inseriti sono corretti, genera un hash MD5 che viene memorizzato sia nel database sia nel cookie. Questo procedimento rende molto più sicura l’identificazione dell’utente ed elude molti tipi di attacco che potrebbero essere diretti verso il sistema. Risponde, inoltre, direttamente a tutte le richieste di verifica dei diritti di accesso, controllando se sono stati forniti sia a livello di utente che a livello di gruppo. L’ultima funzione che assolve è quella di inserire nel sistema altri diritti in modo che siano resi disponibili.
4.4.4. Architecture handler Il sistema dell’architettura (golem.arch.php) è gestito in modo particolare su phpGolem: è un approccio sistematico ma flessibile per la generazione di sistemi strutturati di pagine web, il tutto configurabile a runtime. L’architettura è organizzata in modo gerarchico. Vi sono una serie di layout, ciascuno corrispondente ad un preciso design e all’organizzazione della pagina mostrata agli utenti. I layout sono organizzati tramite una struttura gerarchica in modo che un sottoalbero erediti dalla sua radice tutte le caratteristiche che questa possiede.
- 48 -
Ad esempio è possibile avere tre pagine dipendenti dalla home (la pagina principale del sito), che utilizzano la stessa grafica (il campo Template della tabella) ma un differente layout di pagina (SubTemplate). In questo modo si minimizza la duplicazione di tutti i files accessori alla pagina HTML (grafica, CSS, javascript, …), mantenendo comunque la possibilità di gestire differenti strutture. Ogni layout definisce quindi al suo interno, oltre al template da utilizzare, anche il riferimento alle parti del motore che dovranno essere attivate e a come saranno posizionate. Infatti il gestore dell’architettura estrae dal file della struttura del template (SubTemplate) tutti i tag relativi al layout (#LAYOUT.*#) e consente di associare a ciascuno di questi uno dei possibili moduli pubblici delle estensioni.
- 49 -
La parte operativa dell’associazione è poi eseguita dal gestore del template che, una volta ricevute le associazioni dal componente dell’architettura, esegue i moduli pubblici delle estensioni e li sostituisce, come vedremo, all’interno del template. Questo tipo di organizzazione consente quindi di gestire l’architettura del sito in modo intuitivo e completamente dinamico, strutturando a runtime tutta una possibile gerarchia di layout e grafiche differenti. Inoltre, gestisce in modo altrettanto flessibile i contenuti dinamici forniti dalle estensioni: è possibile sostituire rapidamente una funzionalità con un’altra, senza dover minimamente toccare il template grafico o senza dover mettere mano al codice sorgente. Un altro vantaggio è l’ereditarietà che questo sistema comporta: un figlio può condividere con il padre grafica, design e moduli, e può sostituirne a piacere alcuni secondo le necessità del layout che si sta costruendo.
4.4.5. Configuration handler Questa classe (golem.cfg.php) svolge una funzione piuttosto semplice: mette a disposizione uno spazio condiviso in cui salvare variabili di configurazione, rendendole eventualmente modificabili tramite un’estensione. Le variabili sono associate alle estensioni, quindi per richiedere un valore preciso si specifica l’estensione a cui appartiene e il suo nome. Questo semplifica la gestione e contemporaneamente si uniforma alla gestione dei diritti, che è anch’essa centrata sulle estensioni. E’ quindi possibile creare nuove variabili di configurazione, salvare e leggere i valori.
4.4.6. Template handler Il gestore del template (golem.template.php) è un elemento molto importante per il design del sito web. Esso gestisce la separazione
- 50 -
fra codice e presentazione, fornendo una serie di metodi per poter utilizzare dei template testuali separati. Sebbene l’utilizzo primario sia la generazione di pagine HTML o XHTML, questo oggetto gestisce in modo indipendente dal contenuto il file con cui lavora, in modo che si possano generare, secondo eventuali necessità, pagine XML, testuali, RTF, o in generale qualunque formato file testuale. Il meccanismo di funzionamento è piuttosto semplice: il gestore non struttura un vero e proprio sistema di scripting, ma effettua semplici sostituzioni e separazioni di codice. Questa opzione è stata preferita in quanto è più semplice per un grafico o un designer realizzare template corretti, senza la necessità di possedere conoscenze di programmazione o imparare un ulteriore linguaggio di script. Il template handler quindi carica uno specifico template e automatizza alcuni processi su questo, in modo che possa essere utilizzato dal motore. Vi sono tre strutture che il gestore riconosce all’interno dei template e su cui può operare: 1. tag 2. sezioni 3. inclusioni I tag sono delle stringhe di testo delimitate da cancelletti (#stringa#) che vengono gestiti tramite sostituzione diretta. Quindi si può richiedere di sostituire il tag “content” (#CONTENT#) con la variabile PHP $output. Es.
#NAME#
- 51 -
Le sezioni sono invece un modo di separare, all’interno di uno stesso file template, diverse parti così che possano essere richiamate in modo indipendente l’una dall’altra. Sono delimitate da una coppia di stringhe che aprono e chiudono la sezione, pensate in modo che siano nascoste secondo la normale sintassi HTML/XHTML: e . E’ quindi possibile richiamare una sezione dal template e sostituire al suo interno tutti i tag richiesti, per poi mostrare la pagina così generata all’utente finale. Es.
#ICON#
#TITLE#
#NICK# - #DATE# - #TIME#
#TEXT#
Le inclusioni sono invece un modo di inserire all’interno di uno stesso template sezioni prelevate da più files differenti. Essenzialmente funzionano incorporando il file incluso dentro quello chiamante, da un punto di vista logico, creando un unico corpo. La sintassi utilizzata è una riduzione delle Server Side Includes secondo lo standard del server web Apache: . Vi è un’unica limitazione: al momento il motore gestisce un solo livello di inclusioni. Quindi non è possibile creare strutture nelle quali un file ne chiama un secondo e questo ne richiama un terzo: quest’ultimo non verrebbe letto. - 52 -
Es. Queste strutture offrono sicuramente un livello di flessibilità inferiore rispetto ad un linguaggio di scripting ad hoc (come può essere ad esempio Smarty, o la scrittura diretta di PHP nell’HTML) ma possiede il vantaggio di essere piuttosto semplice da apprendere e da utilizzare.
4.4.7. Interface handler Questo componente (golem.int.php) raggruppa tutto un insieme di funzioni, a volte anche piuttosto eterogenee, ma che contribuiscono a gestire a vari livelli l’interfaccia utente comune di phpGolem. Vengono infatti semplificate al suo interno tramite funzioni una serie di chiamate ripetitive e di operazioni che semplificano la vita di uno sviluppatore, fornendo strutture già pronte e uniformi per la gestione. Ad esempio tutti i tag dei form HTML (