Università degli Studi di Napoli Federico II
Facoltà di Scienze MM.FF.NN.
Corso di Laurea in Informatica
Tesi Sperimentale di Laurea Triennale
Realizzazione di un sistema per la storicizzazione dei dati di
un database Round-Robin
Relatori
Candidato
Prof. Guido Russo
Dr. Domenico Del Prete
Pasquale Catalano
Matricola: 566/2323
Anno accademico 2009/2010
Desidero ringraziare...
il Prof Guido Russo per avermi consentito
di svolgere questo lavoro di tesi, e per la sua piena disponibilità,
tutti i miei colleghi che ho conosciuto
durante il percorso di studio
e tutte le persone a me care,
che hanno creduto in me.
Indice generale
Introduzione....................................................................................................................................1
1 Data Center Atlas.........................................................................................................................3
1.1 Struttura Del Data Center..........................................................................................................3
1.2 Il Tier2-Napoli...........................................................................................................................6
1.2.1 Apparati del Data Center............................................................................................6
2 Studio, Esempio, Critica sui sistemi esistenti............................................................................8
2.1 SSB Site Status Board................................................................................................................8
2.2 Critica Portale SSB..................................................................................................................10
2.3 Job Monitoring.........................................................................................................................13
2.4 Analisi Interfaccia Web Job Monitoring..................................................................................14
3 Portale di monitoraggio utilizzato dal Tier2............................................................................18
3.1 Organizzazione Dei Contenuti E Dei Servizi..........................................................................19
3.2 La Struttura A Componenti......................................................................................................20
3.3 Enterprise Information Portal: Liferay....................................................................................23
3.4 Portlet WebContent E Iframe...................................................................................................26
3.5 Il Portale Del Tier2-Napoli......................................................................................................29
4 Software di Monitoraggio utilizzati dal Data Center...............................................................34
4.1 Analisi Dello Strumento Per Il Monitoraggio Della Rete........................................................34
4.1.1 Il Collezionamento dei dati.......................................................................................37
4.2 Il Modello Di Storicizzazione Dei Dati...................................................................................40
4.2.1 RRD: Round Robin Database...................................................................................40
4.2.2 RRDTool....................................................................................................................40
4.2.3 Le Caratteristiche di utilizzo di RRD.......................................................................45
4.2.3.1 Create .....................................................................................................................45
4.3.2.2 Fetch.......................................................................................................................46
4.2.2.3 Graph......................................................................................................................47
4.3 Analisi Applicazione Nagios....................................................................................................52
4.3.1 Interfaccia Web utilizzata........................................................................................53
5 Sviluppo del Sistema................................................................................................................54
5.1 Strumenti Utilizzati..................................................................................................................54
5.1.1 Strumento per la gestione e visualizzazione dei grafici..........................................54
5.1.2 Interfaccia di supporto della Connessione al Database...........................................58
5.1.3 Storicizzazione dei Dati: MySql...............................................................................60
5.2 Progettazione Database............................................................................................................63
5.2.1 Gestione dei dati del Database.................................................................................68
5.3 Diagrammi UML.....................................................................................................................69
5.3.1 Fase di Analisi...........................................................................................................69
5.3.2 Fase di Design ..........................................................................................................75
5.3 Funzionalità Offerte Dal Sistema.............................................................................................81
5.3.1 L'operazione di popolamento del Database.............................................................82
5.3.1.1 File di Configurazione dell'applicazione................................................................83
5.3.1.2 File di supporto per le relazioni del Database........................................................84
5.3.1.3 Il Parser sviluppato.................................................................................................86
5.4.2 L'interfaccia Utente...................................................................................................88
6 Risultati Ottenuti.......................................................................................................................91
7 Conclusioni................................................................................................................................95
Appendice A.................................................................................................................................97
Appendice B...............................................................................................................................112
Appendice C...............................................................................................................................117
Sitografia.....................................................................................................................................118
Bibliografia.................................................................................................................................120
Introduzione
Il lavoro di tesi in esame mostra una soluzione su come poter manipolare e
rappresentare le informazioni provenienti da sistemi di monitoraggio già esistenti,
integrandole in un portale web.
L'informazione analizzata nel progetto sviluppato, proviene dagli apparati che vanno a
costituire un Data Center, in particolare il Data Center ATLAS. Nello specifico saranno
esaminati dati che fanno riferimento a valori di controllo dei servizi di determinati
dispositivi, quali: Worker Node, Storage Element, Router e Switch.
Per valutare correttamente lo stato di un sistema, è necessario dunque considerare i
seguenti fattori: gestione, manutenzione ed evoluzione del sistema stesso. Il
monitoraggio consente di controllare diversi aspetti del
funzionamento di un
dispositivo, svolgendo un ruolo di primaria importanza per la vita e sviluppo del sistema
stesso.
Un sistema di monitoraggio è un apparato che permette di controllare computer e
risorse di rete, fornendo delle misure a intervalli di tempo regolari con il fine di
attribuire uno stato ad un servizio monitorato.
Con l'accrescere della complessità delle reti, determinate da un aumento delle macchine
e degli apparati che le compongono, sono stati prodotti negli anni sistemi che concedono
di monitorare ad hoc servizi di tali reti. Questi sistemi sono costituiti in maniera tale da
mantenere le informazioni monitorate, permettendo all'utente che si va ad interfacciare
una rappresentazione grafica dei dati. Il limite di questi framework già esistenti è quello
di non poter usufruire a pieno delle misure che vengono immagazzinate durante il
monitoraggio, perché non possono essere trattate in modo tale da fornire al consumatore
indicazioni che sarebbero più appropriate al suo fabbisogno. Infatti prima della mia
attività di tirocinio, le informazioni non erano gestite in modo tale da poter avere delle
relazioni e inoltre non si potevano eseguire operazioni di personalizzazione sui dati
collezionati dettate dalle esigenze del fruitore dei servizi.
Pasquale Catalano 566/2323
Pagina 1 di 121
Nella tesi in esame proponiamo una soluzione a tale problema avvalendoci di un
approccio costituito dalle seguenti fasi:
•
prelevare i dati dai framework ogni quanto di tempo
•
immagazzinare le informazioni in una base di dati, in modo tale da avere uno
storico di tutti i dati riguardante lo stato dei servizi monitorati
•
interrogare la base di dati in funzione delle esigenze del consumatore
•
integrare i risultati ottenuti in un portale web
L'obiettivo di questo approccio è quello di fornire un feedback immediato all'utente, che
gli consenta di avere risultati finalizzati ad essere chiari, di rapida comprensione e di
caratterizzarli in base ai propri utilizzi.
Infine, si fa impiego di una tecnica di presentazione delle informazioni acquisite
mediante una rappresentazione grafica, con l'obiettivo di agevolare la ricerca e il
ragionamento, comunicando all'utente indicazioni che non sarebbero altrettanto offerte
se si facesse utilizzo di una descrizione tabellare o testuale.
Pasquale Catalano 566/2323
Pagina 2 di 121
1 Data Center Atlas
1.1 Struttura del Data Center
Il modello generale di calcolo per l’analisi dei dati provenienti dagli esperimenti
che adottano l'acceleratore
di particelle LHC è basato sul paradigma di GRID
Computing, attraverso un modello gerarchico organizzato in livelli detti Tier che
permettono una forte decentralizzazione ed una condivisione a livello mondiale delle
risorse computazionali. I dati grezzi in uscita dall'esperimento sono messi insieme,
grazie ad una Event Filter Farm risiedente al CERN, in uno stream per poi essere inviati
al Tier0.
Il Tier0 è collocato al CERN; a questo livello si effettua la produzione dei dati da essere
mandati ai Tier di livello inferiore. La composizione dei dati avviene nel seguente modo:
una prima fase di calibrazione e allineamento dei dati provenienti dall'acceleratore
effettuando, quindi, una prima ricostruzione per poi essere inviati al Tier1.
Il Tier1 è
situato in regione, dove per regione si intende un agglomerato di
organizzazioni disposte su più nazioni. Ad ogni Tier1 sono associati alcuni Tier2, spesso
in base a esigenze di carattere geografico, ai quali vengono trasferiti sottoinsiemi dei
dati rielaborati, per renderli disponibili all'analisi da parte dell'utente. Questo livello ha il
compito di immagazzinare a tempo indeterminato una porzione dei dati grezzi, sui quali
si effettuano procedimenti di allineamento, calibrazione e
ricostruzione delle
informazioni avvalendosi di algoritmi più efficienti rispetto al Tier superiore. Dopodiché
inoltra i risultati distribuendoli ai Tier2.
Il Tier2 è disposto a livello nazionale, infatti raduna organizzazioni all'interno della
stessa nazione. Il loro compito è quello eseguire job di analisi e simulazione sui dati,
trasferendo il risultato in uscita ai Tier3 se richiesto.
Ogni Tier1 con i rispettivi Tier2 vanno a creare una Federazione denominata Cloud;
quella italiana ha nel CNAF (Centro Nazionale per la Ricerca e Sviluppo nelle
Tecnologie Informatiche e Telematiche) di Bologna il suo Tier1, mentre nelle sedi
Pasquale Catalano 566/2323
Pagina 3 di 121
dell'Istituto Nazionale di Fisica Nucleare di Milano, Roma, Napoli e Frascati i suoi
Tier2.
Il Tier3 dislocato a carattere locale, risulta essere il livello più basso della gerarchia,
composto dai singoli istituti o dipartimenti. Risulta essere il luogo dove avviene
fisicamente l'analisi dei dati.
È importante dire che ciascun Tier mantiene una copia dei dati che ha trattato in modo
tale da utilizzarli come esempio per le successive elaborazioni o consente di recuperarli
al livello successivo se necessario.
Figura 1: Struttura a Tier di ATLAS
Le informazioni utilizzate da i vari Tier sono organizzati mediante una gerarchia, che
segue il cosiddetto Event Data Model: parte dai dati grezzi in output dall'acceleratore
LHC, arriva ai dati da elaborare nei singoli siti. Vengono elencati i nomi con relativa
descrizione, del tipo di dato che un'informazione può assumere durante il trasferimento
ai vari Tier:
Pasquale Catalano 566/2323
Pagina 4 di 121
•
Raw Data: sono le misure grezze in uscita dal Trigger; esse sono trasferite dal
Tier0 al Tier1.
•
EDS (Event Summary Data): misure in uscita dalla ricostruzione. Essi vanno a
rappresentare i percorsi delle particelle, le collisioni e tutto ciò che riguarda
l'interazione tra le particelle nell'acceleratore.
•
AOD (Analisys Object Data): sono un tipo ridotto degli ESD, è il formato
pubblico dei dati da elaborare. Descrivono le singole particelle.
•
DPD (Derived Physicl Data): rappresentano il tipo di dato privato utilizzato
esplicitamente nei centri di calcolo. Risultano essere un formato ridotto degli
AOD.
Figura 2: Gerarchia dei dati con le relative dimensioni
Attraverso l'impiego di determinati insiemi di software e middleware viene gestita la
comunicazione ai dati, con la finalità di consentire ai membri dell'organizzazione l'uso e
l'analisi delle informazioni indipendentemente dal luogo geografico in cui si trovano. Al
termine, quindi per fare sì che l'acceleratore funzioni in modo esatto, oltre a tutte le
apparecchiature coinvolte c'è la necessità di una collettività che lavori sia fisicamente al
Cern, sia in altre nazioni che contribuiscono ai vari esperimenti distribuiti attraverso il
modello gerarchico a Tier.
Pasquale Catalano 566/2323
Pagina 5 di 121
1.2 Il Tier2-Napoli
In generale i Tier2 forniscono capacità di analisi per gruppi e sottogruppi, questo
vuol dire che devono garantire un'infrastruttura di calcolo che sia in grado di sostenere
un'attività multiutente, in cui molti utenti eseguono operazioni computazionalmente
impegnative, che richiedono una risposta in tempi flessibili.
Oltre alla potenza di calcolo, un centro Tier2 dovrà fornire anche risorse per lo storage
in grado di ospitare le informazioni assegnate, che si propongono in file di formati
differenti, in funzione alla tipologia e alla quantità d'informazione racchiusa.
I Tier2, inoltre, devono farsi carico di tutta la capacità di simulazione essenziale
all'esperimento e i dati prodotti sono generalmente mandati ai Tier1 di riferimento, dove
saranno resi disponibili per tutti gli altri siti che ad esso fanno capo.
Per poter compiere tutti questi compiti è di fondamentale necessità che la struttura del
Tier2 sia completamente accessibile attraverso gli strumenti Grid standard e che inoltre
il centro dovrà essere operativo con la maggior durata possibile, andando a minimizzare
i periodi di non operatività dovuti a problemi di guasti o manutenzione.
A Napoli all'interno del complesso universitario di Monte S. Angelo della Federico II e'
situato il Tier2-Napoli posizionato in due sale quali: il capannone realizzato per il
progetto S.C.o.P.E e una sala della sezione del INFN.
1.2.1 Apparati del Data Center
Al fine di comprendere meglio le attività previste dal Tier2, risulta essere
vantaggioso andare ad illustrare i servizi e gli apparati fondamentali.
Ogni Virtual Organizzation1 fornisce delle Grid, un'insieme di risorse interconnesse
1 Insieme dinamico di individui o istituzioni che rispettano regole e condizioni per la condivisione di risorse a
prescindere dalla locazione geografica
Pasquale Catalano 566/2323
Pagina 6 di 121
attraverso la rete internet. In ogni sito appartenete al Tier2 sono sistemate delle farm2
costituite da macchine che risultano essere differenti in merito alle loro funzionalità;
alcune sostanzialmente concedono capacità di calcolo altre di storage.
– User Interface (UI): Costituiscono il punto di accesso alla Grid. È rappresentata
da un calcolatore dove tutti gli utenti posseggono un account personale, in cui
risiede il proprio certificato che consente l'interazione con le funzionalità della
Grid. Grazie all'UI un utente può essere autenticato e abilitato all'uso di risorse,
permettendolo di far sottomettere le proprie applicazioni(job), gestendo
l'esecuzione, ricavandone i risultati
– Computing Element (CE): Rappresentano l'interfaccia Grid verso una farm,
realizzata attraverso dei nodi di calcolo denominati Worker Node. Gestiscono i
job di calcolo mediante il batch-queue system. I Worker Node sono nodi di una
farm, chiamati computer off-the-shell, i quali offrono soltanto CPU e connettività
senza periferiche di I/O né di memoria di massa(garantita dall'uso dello Storage
Element )
– HRL: servizio per l'accounting per l'utilizzo delle risorse risorse di calcolo da
parte delle Virtual Organizzation
– Risorse di Storage: Sono dispositivi con il compito di conservare i dati da
elaborare. Essi sono collegati agli altri mediante dei canali di fibra ottica dedicata
e sono gestiti attraverso vari server denominati Storage Element. Uno Storage
Element è un servizio che consente ad utenti o applicazioni di immagazzinare
dati per usi futuri. Le informazioni di un SE sono read-only; non possono essere
modificati, ma solo cancellati o sovrascritti. Il tipo di Storage utilizzato dal Tier2
di Napoli è SRM (Storage Resource Manager), un'interfaccia verso diverse
risorse di storage gestite da più server.
2 Intendiamo una serie di dispositivi distinti, che forniscono particolari servizi alla grid, ed hanno delle
particolari caratteristiche hardware e software.
Pasquale Catalano 566/2323
Pagina 7 di 121
Figura 3: Schema Tipico di un sito Grid
2 Studio, Esempio, Critica sui sistemi esistenti
Nel presente capitolo sono presentati diversi sistemi impiegati dai vari Tier per il
monitoraggio e presentati alla conferenza di luglio 2010 tenuta al Cern di Ginevra. Sono
stati oggetti di studio i seguenti: SSB Site Status Board, Job Monitoring.
2.1 SSB Site Status Board
Il Site Status Board è un sistema che fornisce una visione dello stato secondo le
attività previste, come il trasferimento di dati di produzione e analisi. Il suo obiettivo
principale e' quello di avvalersi di un monitoraggio ad alto livello e che permetta di
osservare, quando si presentano problematiche del sistema, in una sola pagina piuttosto
che muoversi tra monitoraggi di differenti attività ADC quali: Dataprocessing,
trasferimento dati, …, collocati in diverse pagine.
Tale sistema è costituito da due attributi fondamentali: Viste e Metriche.
La vista è una raccolta di metriche; la metrica riporta lo stato di ciascun sito con
l'impiego di determinati sensori. Inoltre la metrica è definita da fonti di dati ricevuti dal
Pasquale Catalano 566/2323
Pagina 8 di 121
sensore.
Figura 4: Attributi SSB
Viene riportato un esempio di vista utilizzata dal sistema caratterizzata dalle seguenti
metriche:
•
DDM 4h - Descrive l'attività di trasferimento dei dati durante le ultime 4 ore. Il
valore del sensore è la percentuale di file trasferiti correttamente, tenendo conto
solo dello spazio MCDISK, DATADISK e DATATAPE per l'invio e il
trasferimento ricevuto.
•
SRM SAM 12h - Descrive il SRM SAM test di risultati per le ultime 12 ore.
•
DataProc - Descrive lo stato dei siti in materia di trattamento dei dati. Il valore
rappresenta l'efficienza del sito.
•
Panda exclusion - Sito code stato panda. I valori possibili sono "online",
"test","Offline" e "brokeroff".
•
DDM status - i siti inclusi/esclusi dai servizi del sito. I valori possibili sono
"online" "Lista nera".
•
Downtime - indica se il sito è schedulato, i tempi di inattività più o meno.
Pasquale Catalano 566/2323
Pagina 9 di 121
Nell'esempio sopra citato, uno specifico sito può assumere uno stato il cui valore
dipende dalle dimensioni assunte dalle metriche coinvolte.
La lista dei valori che ad un sito viene attribuito sono:
•
Stato Ok
•
Stato Allarme: dovuto dal fatto che una delle metriche è in allarme
•
Stato Guasto: dovuto dal fatto che una delle metriche è guasta. La misura
rappresenterà il numero di ore in cui il sito è in errore assumendo tre possibili
valori (meno di 12 ore, tra 12 e 72, più di 72 ore)
•
Stato Manutenzione
•
Stato Investigazione
Dopo aver descritto l'elenco delle metriche che vengono utilizzate, tali da comporre una
particolare vista del sistema e degli stati possibili in cui si possa ritrovare un sito
monitorato dal SSB, viene presentato uno studio di analisi del portale di riferimento.
2.2 Critica Portale SSB
Il portale del Site Status Board si presenta con una homepage strutturata in modo
da mettere in evidenza una netta suddivisione della pagina in due grosse aree.
Figura 5: Menù principale portale SSB
La prima riguardante il menù principale costituito dalle voci Index, Expanded Table,
GridMap, Alternative views, Admin, Atlas Ssb Instruction, Ask the Atlas SSB people.
Esso si sviluppa orizzontalmente consentendo di raggiungere la maggior parte delle
pagine, fornendo all'utilizzatore finale una buona e immediata navigabilità.
Pasquale Catalano 566/2323
Pagina 10 di 121
Figura 6: Porzione della mappa riguardante i siti italiani con legenda annessa
La seconda area fa riferimento ad una mappa contenete gli stati che assumono i vari siti
disposti nelle rispettive sezioni del Tier 0/1 e Tier 2, raggruppati per nazionalità di
appartenenza. Questo comporta un disorientamento all'utente che accederà per la prima
volta al portale. La mappa è costituita da una barra superiore che consente di far
espandere o di ridurre il suo contenuto informativo, composto da un elenco di coppie
(stato, sito). Si nota che il valore assunto dallo stato è rappresentato mediante un'
immagine, di conseguenza nella homepage è presente nella parte inferiore una legenda
molto dettagliata, con lo scopo di dare informazioni precise sul significato delle icone
raffiguranti lo stato di un sito. Avvalendosi la legenda di determinati colori e di accurate
immagini fa sì che il portale risulti comprensibile e coerente al consumatore che si
andrà ad interfacciare.
Trattiamo con particolare attenzione le seguenti pagine: Alternative view, Expanded
Table.
Facendo accesso alla sezione Alternative view appare una schermata contente: una
tabella riportando la lista completa delle viste esistenti con informazioni relative alle
metriche che le compongono e un'altra contenete tutte le metriche definite all'interno del
sistema. Da notare che nel portale le metriche vengono definite con il nome di colonne
critiche. Questo permette ad un' utente più esperto e qualificato di scegliersi quale vista
Pasquale Catalano 566/2323
Pagina 11 di 121
andare ad osservare e cliccando sul link si viene indirizzati ad una pagina che
racchiude
informazioni sulle metriche, presentate mediante una rappresentazione
grafica. Tale rappresentazione presenta contenuti che fanno riferimento a tutti i siti
coinvolti nel monitoraggio, cliccando su quello interessato si accede ad una pagina che
racchiude informazioni ben dettagliate.
Figura 7: Rappresentazione grafica per la metrica DDM 12h
Esempio: supponiamo di aver scelto la metrica DDM 12h, cliccando l'area relativa al
sito interessato, accediamo
ad una pagina contente dati del tipo: dati trasferiti,
trasferimento completo di file e numero totale di errori nel trasferimento.
Ritornando al grafico, il periodo temporale a cui si riferisce può essere modificato
attraverso un menù a tendina consentendo una personalizzazione in funzione
dell'esigenza del consumatore: 24h, 48h, ultima settimana, ultimo mese. In più per dare
una maggiore chiarezza, le informazioni del grafico possono essere filtrate in base alla
categoria di appartenenza del sito quale: Tier 0, Tier 1, Tier 2.
Pasquale Catalano 566/2323
Pagina 12 di 121
Dal menù principale del portale cliccando su Expanded Table si accede alla rispettiva
schermata che presenta: una lista che include, per ciascun sito osservato, misure delle
seguenti metriche: SRM SAM 12, DataProc, panda exclusion, DDM status, DDM 4h,
Scheduled Downtime. Il valore della metrica presente all'interno della lista, viene
evidenziato grazie all'uso di colori, verde e rosso, assicurando al consumatore una buona
interpretazione iniziale della misura. Cliccando sul nome del sito si raggiunge una
pagina con informazioni riguardanti solo le colonne critiche attraverso un diagramma.
Come già citato nella sezione descritta precedentemente, si può scendere a un livello di
maggior dettaglio sulle informazioni e inoltre andare a personalizzare i dati ottenuti in
funzione delle proprie esigenze attraverso delle ricerche che fanno ausilio di filtri.
In conclusione nel complesso si può affermare che il portale presenta una struttura,
consentendo all'utente di muoversi con estrema facilità e presentando i contenuti con
rappresentazioni chiare e comprensibili.
2.3 Job Monitoring
Il Job Monitoring è un sistema di monitoraggio di job per analisi utenti. Il suo
obiettivo è quello di avere un quadro completo dei job ATLAS indipendentemente dalla
presentazione di strumenti e backend in esecuzione; fornisce una visione chiara e precisa
dello stato delle attività, compresa la distribuzione dei job da siti e utilizzo di trame
grafiche avanzate dando un' interfaccia più usabile e interessante per l'analisi degli
utenti. Avvalersi di tale sistema consente di: monitorare facilmente le attività di analisi
utilizzando un'interfaccia web semplice da usare e da navigare, ricevere aggiornamenti
in tempo reale, velocità di latenza molto bassa e avere uno sviluppo guidato e
focalizzato sulla prospettiva dell'utente. In più offre una vista storica ossia una
evoluzione delle metriche di elaborazione dei processi in funzione del tempo (numero
dei job, tasso di successo, codici di errore, ecc...). Con questa vista vengono visualizzate
informazioni riguardanti:
•
Distribuzione dei job in funzione dello stato (esecuzione, attesa, terminato), del
tempo , dell'attività.
Pasquale Catalano 566/2323
Pagina 13 di 121
•
Distribuzione della CPU in funzione del tempo, del sito, delle attività.
•
Distribuzione di eventi trattati in funzione del tempo, del sito, delle attività.
In sintesi il sistema acconsente di unire le informazione di tutti i job fornendo un
punto unico di entrata per il monitoraggio di tutti i job ATLAS indipendente dal metodo
di sottomissione dei job o presentazione della piattaforma middleware. La
visualizzazione Web permette una navigazione intuitiva partendo da una visione globale
per arrivare ad una dettagliata, che terrà conto delle esigenze delle diverse categorie di
utenti. È un'attività di monitoraggio che concede la possibilità di una visione specifica
dei compiti dell'utente, compresi gli strumenti diagnostici di fallimento.
Ora viene riportato un lavoro di analisi effettuato sull'interfaccia web che presenta tale
sistema di monitoraggio.
2.4 Analisi interfaccia web Job Monitoring
L'interfaccia web si presenta con una pagina iniziale ricca di informazioni
suddivisa in più sezioni. In alto un menù a barra contenente le seguenti voci:
•
Waiting time: Tempi medi di attesa per i job. Calcolati tra la sottomissione e il
tempo di inzio esecuzione.
•
Running time: Tempi medi di esecuzione dei job. Calcolati tra il tempo di inizio
esecuzione e tempo di fine. In caso di multiple resottomissioni, solo l'ultima
prova è presa in considerazione.
•
Overall time: Tempi di media totale per i job. Calcolati tra la sottomissione e i
tempi di fine. In caso di multiple resottomissioni, solo l'ultima prova è presa in
considerazione.
•
CPU time: Tempi di media di CPU per i job come riportato dai job wrapper. Al
momento solo i job sottomessi viene riportato questo valore.
•
Job Wrapper: Tempi di media di un job in riferimento al job wrapper.
Pasquale Catalano 566/2323
Pagina 14 di 121
•
Efficiency: Media efficienza dei job. Calcolata come rapporto tra tempo CPU e
tempo Job Wrapper.
Nella sezione centrale la schermata mostra sulla sinistra un menù che consente di dare
opzioni di scelta su cui andare a fare la ricerca, apportando all'utilizzatore finale una
caratterizzazione delle informazioni da recuperare in funzione delle proprie esigenze.
Inoltre è presente una rappresentazione grafica tale da comunicare al consumatore
informazioni riguardante i job per ciascuna attività. Per rendere la rappresentazione di
facile comprensione con contenuti chiari è presente anche una legenda dettagliata.
Figura 8: Pagina iniziale dell'interfaccia web
Accedendo alla sezione Task Monitoring
si presenta una schermata contenete
informazioni circa sui task sottomessi da un determinato utente. Nella pagina appaiono
una lista di menù a tendina riguardante l'utente, l'intervallo di tempo e il tempo di
aggiornamento dei risultati in modo da far filtro alle ricerche da eseguire. Stabiliti gli
attributi della ricerca se essi sono compatibili tra di loro allora forniranno informazioni
altrimenti daranno un messaggio di errore. I dati ricavati saranno visualizzati mediante
le seguenti caratteristiche: Id del task, numero di job, job in attesa, job in esecuzione, job
falliti, job completati con successo. Per rendere leggibile e chiara l'interpretazione dei
Pasquale Catalano 566/2323
Pagina 15 di 121
dati ottenuti viene adottata una rappresentazione grafica. In più c'è la possibilità di
scegliere tra diverse viste del grafico:
•
In funzione del sito
•
In funzione dei job terminati
finalizzate ad
apportare
una visione dei contenuti inerente al fabbisogno
dell'utilizzatore. In più per ciascun task monitorato si possono ottenere contenuti
Figura 9: Schermata principale Task Monitoring
riguardanti i metadati ( input dataset, tempo di creazione del task , ecc ) o essere rediretti
verso un'interfaccia interattiva del task scelto da
analizzare. Queste operazioni si
possono compiere attraverso la pressione di due icone che sono poste immediatamente
dopo il TaskMonitorId.
Vengono proposte alcune illustrazioni di immagini tratte dal contenuto informativo
della vista storica che offre il Job Monitoring. Ci soffermeremo in particolare sul
contenuto riguardante la distribuzione dell'analisi dei job falliti e terminati del sito di
Pasquale Catalano 566/2323
Pagina 16 di 121
Nebraska, servendosi per i job terminati di un diagramma a barra mentre per i job falliti
di una doppia rappresentazione: diagramma a barra e a torta.
Figura 10: Rappresentazione grafica dei job terminati e job falliti
In ultima analisi possiamo riassumere affermando che l'interfaccia web proposta dal Job
Monitoring risulta essere per alcune caratteristiche UserFriendly, mettendo l'utente in
condizione di usare in modo semplice il sistema, senza la richiesta di un livello elevato
di alcune conoscenze ma il suo punto di forza risiede nella qualità di fornire contenuti
accessibili tali da non ostacolare l'utilizzatore.
Pasquale Catalano 566/2323
Pagina 17 di 121
3 Portale di monitoraggio utilizzato dal Tier2
Con il termine portale, per quanto relativamente recente, è uno dei più diffusi e
utilizzati. Quindi non è possibile ottenere un'unica e comune definizione di “portale
web”. Ma andando a confrontare più fonti si è acquisito di poterlo identificare come un
servizio
che opera da mediatore di informazione a favore degli utenti della rete,
consentendo a quest'ultimi di raggiungere mediante un particolare punto d'ingresso nella
rete una grande quantità delle risorse esistenti.
Il portale è una porta di accesso unica ad un insieme di applicazioni, dati e servizi; è un
aggregatore di informazioni che mette a disposizione un servizio di navigazione sulla
rete facilitando il lavoro di ricerca. Ma andando ad analizzare meglio un portale non è
solo questo. Dal punto di vista funzionale possiamo dire che un portale copre le esigenze
in tre grandi aree:
•
aggregazione applicazioni
•
gestione contenuti
•
collaborazione
Quindi un portale è molto di più di quanto
abbiamo detto fino ad ora e ci
fa
comprendere come le potenzialità di uno strumento simile sono enormi. Dal punto di
vista più strettamente applicativo, il ruolo di integrazione che può svolgere un portale è
quello più interessante e promettente. Indipendentemente dalla soluzione di integrazione
scelta, un portale può svolgere il ruolo fondamentale dell'integrazione lato interfaccia
utente delle sorgenti dati, delle applicazioni o dei servizi con i quali un sistema
informativo è costituito. Ciò consentirà all'utente di accedere alla medesima interfaccia
in modo coerente e personalizzabile a molteplici sorgenti informative. Un portale è
però anche un gestore di contenuti. Tutti noi usufruiamo ogni giorno sul web di
contenuti più svariati. Basti pensare ad una pagina web nelle quali troviamo un articolo
Pasquale Catalano 566/2323
Pagina 18 di 121
su un argomento di nostro interesse, con una bella foto, la versione pdf dell'articolo da
scaricare; una singola pagina in cui tutti questi contenuti sono pubblicati in una forma
aggregata e organizzati per un utilizzo da parte dell'utente omogeneo e efficace. In
questo caso entra in gioco l'esigenza di gestire una
molteplicità di contenuti da
pubblicare grazie alle funzionalità del portale che consentono un simile risultato
mediante l'utilizzo di un CMS, Content Management System. Con il passar del tempo il
web è sempre più interattivo e consente a ciascuno di creare e condividere i propri spazi
e i propri contenuti. È bene però mettere in evidenza che una valida piattaforma per la
realizzazione di portali deve fornire i tipici strumenti di collaborazione quali blog, wiki,
message board, instant messaging, mail, shared calendar e così via. Il portale quindi può
essere utilizzato come uno strumento per la collaborazione di team di lavoro in una
intranet aziendale.
3.1 Organizzazione dei contenuti e dei servizi
Uno degli aspetti più importanti nella creazione di un portale risulta essere la sua
struttura di navigazione. Un portale deve al tempo stesso incoraggiare l'esplorazione e
la ricerca. Dunque, la struttura di un portale deve fornire continui interessi e una guida
chiara ed evidente al consumatore che va alla ricerca di specifiche informazioni. Esso
deve presentare un'organizzazione della struttura interna delle informazioni secondo dei
criteri facilmente comprensibili al pubblico ma che allo stesso tempo ne incoraggino
l'esplorazione. Tipicamente, l'organizzazione della navigazione di un portale andrà a
riflettere in maniera più o meno stretta la divisione in sottoargomenti del contenuto
principale del portale, fornendo sezioni
diverse ma collegate per ciascun
sottoargomento. Abbiamo una struttura del portale suddivisa nel seguente modo:
La homepage generale che andrà a rappresentare il punto cardine di accesso al sito,
raccogliendo informazioni e titoli provenienti da tutte le sezioni; contenendo una
selezione delle notizie più importanti. Alla homepage possono essere associate ulteriori
Pasquale Catalano 566/2323
Pagina 19 di 121
pagine di navigazione che risultano indipendenti dalle varie sezioni. Quando andiamo a
definire le diverse sezioni ci ritroviamo in una struttura già vista se pur in una forma
più piccola; costituita a sua volta da una homepage e in merito alla complessità della
sezione, zero o più pagine di navigazione. Queste pagine danno accesso alle
informazioni vere e proprie , che possono essere anche condivise tra più sezioni. Inoltre
insieme a questa struttura che può definirsi gerarchica esiste un'organizzazione di
collegamenti ipertestuali, che connettono in maniera libera homepage, homepage
sezioni, pagine di navigazione, documenti e ogni altro tipo di informazione che si
ritenga essere utile presentare.
3.2 La struttura a componenti
Le Portlet sono dei moduli web usabili all'interno di un portale web. Quindi
servono a gestire una porzione del portale che risulta essere normalmente rappresentata
da un box rettangolare. I vari box o finestre sono organizzati in modo tale da comporre
la pagina del portale nel suo complesso definita come portal-page. Ciascuna portlet è
finalizzata ad una semplice applicazione; esse possono essere chiuse, ridotte o spostate
ed essere personalizzate in merito alle esigenze dell'utente.
Figura 11: Terminologia relativa alle componenti di un portale
La tecnologia delle portlet e dei portali utilizzano un'insieme di standard al fine di
Pasquale Catalano 566/2323
Pagina 20 di 121
consentire lo sviluppo di portlet portabili, ovvero che possono usati nel contesto di
portali sviluppati con tecnologie diverse.
La comunicazione tra le portlet avviene mediante l'accesso a contenuti e dati remoti
attraverso il Portlet Container.
Il Portlet Container fornisce alle portlet il necessario ambiente di esecuzione,il contesto
gestendo il loro ciclo di vita e il comportamento; è suo compito istanziare le portlet
prima che vengano richieste e lanciare eccezioni se qualcosa va male.
Le portlet sono elementi molto simili alle servlet ideati per essere inseriti facilmente in
un portal server ed essere eseguiti. Il portal server esegue il lavoro finale di
aggregazione delle portlet applications e delle singole portlet. In particolare il portal
server esegue la spedizione delle request a tutte le portlet contenute in una singola
pagina svolgendo quindi il lavoro di orchestrazione e coordinamento.
Di seguito andiamo ad elencare le principali differenze di una portlet rispetto ad una
servlet:
•
non posseggono la comunicazione con il browser, quindi non permettono di
inviare redirect o errori;
•
sono componenti più semplici e quindi più leggeri, ciò consente una maggior
facilità di gestione;
•
non possono rappresentare pagine web complete, ma solo singoli componenti;
•
non possono essere raggiunte da un url specifico, in quanto è il portale intero ad
avere associato l'indirizzo.
In conclusione si può affermare che le portlet sono dei mattoni primitivi di un portale
che concedono la possibilità di creare un ambiente di componenti web i quali possano
cooperare nella realizzazione di contenuti web in maniera ottimizzata.
Pasquale Catalano 566/2323
Pagina 21 di 121
Figura 12: Organizzazione logica di una architettura basata su porlet
Generazione di una pagina di un portale
Nella presente sezione descriveremo i passi fondamentali che occorrono
per la creazione di una pagina all'interno di un portale.
1. Ogni portlet genera contenuti per l'utente. Il contenuto può essere statico o
generato dinamicamente, dipende dalla logica dell'applicazione della portlet
2. Il contenitore riceve i dati generati dal several portlet
3. Il contenitore manipola le informazioni per il server portal
4. Il server portal crea la pagina del portale, la quale è essenzialmente una sequenza
di codice HTML che il browser utilizza. Durante la creazione della pagina, il
server portal applica il layout di pagina designato per ciascuna portlet nel luogo
appropriato
5. Il server invia la pagina creata al browser
6. Il browser visualizza il contenuto all'utente
Dopo queste fase, il portale è pronto per avere interazione con l'utente.
Pasquale Catalano 566/2323
Pagina 22 di 121
3.3 Enterprise Information Portal: Liferay
Un Enterprise Information Portal noto come un portale d'informazione aziendale
è una struttura che consente di integrare informazioni, persone e processi attraverso
spazi organizzativi. Esso offre un punto di accesso unificato e sicuro, spesso nella forma
di un'interfaccia utente basata sul web, disegnato per aggregare e personalizzare
informazioni attraverso portlet.
Liferay è un enterprise portal nato nel 2001, candidato ad aiutare le organizzazioni a
collaborare in un modo più efficiente mettendo a disposizione una serie consolidata di
applicazioni pronte all'uso. È adoperato da piccole, medie e grandi aziende in tutto il
mondo e inoltre presenta un elenco di funzionalità tali da metterlo a confronto con altri
portali commerciali, con il privilegio di essere open source. Esso svolge la funzione di
Web Container, permettendo di considerare una pagina come un'aggregazione di moduli
web, destinati a contenere applicazioni. Totalmente basato su J2EE , quindi su java,
consente di impiegarlo insieme a differenti application server, database e sistemi
operativi. Tra le proprietà basilari ci sono:
•
Portlet specification e JSR 168
•
Java Server Face con l'utilizzo di JSR 252
•
WSRP 2.0
•
Full J2EE se associato a Jboss Application Server
Il portale inoltre concede agli utenti di:
•
Elevata dinamicità, permettendo di creare, modificare ed eliminare portlet, di
personalizzarle, impostare livelli di sicurezza.
•
Gestire le portlet mediante un'organizzazione gerarchica detta Interportlet
Comunication (IPC).
•
Personalizzare temi e layout.
Pasquale Catalano 566/2323
Pagina 23 di 121
Liferay si basa su un'architettura orientata ai servizi denominata (SOA). Con SOA
(Service Oriented Architecture) si va ad indicare un'architettura software usata per
supportare l'utilizzo di Web Service e per assicurare l'interoperabilità tra diversi sistemi,
in modo tale da consentire l'uso delle singole applicazioni come parte dell'intero
processo gestionale. In questo modo le applicazioni sono frutto dell'unione di più
servizi,
che tra di loro risultano essere indipendenti garantendo il massimo della
riusabilità. La scelta ricade su Liferay in quanto offre una grande quantità di servizi
integrati di qualità ed un'ottima flessibilità. Tutto questo si va ad includere con una
grande capacità di organizzare e il supporto alla collaborazione.
Figura 13: Homepage Liferay
Dalla figura sovrastante si denota che il portale presenta un'interfaccia utente molto
semplice e chiara organizzata in modo tale da aiutare lo sviluppatore alla finalizzazione
del compito da effettuare. Dopo la fase di autenticazione con l'immissione delle proprie
Pasquale Catalano 566/2323
Pagina 24 di 121
credenziali il sistema passa ad uno stato che consente la creazione delle pagine, in cui
verranno inserite le portlet che s'intendono adoperare. In particolare compare un bottone
“AddPage” che provvederà alla creazione e all'inserimento della pagina nel portale.
In alto a destra, sotto il login sarà disponibile un menù per le opzioni. Tale menù è
composto da una collezione di sezioni dove è possibile fare operazione del tipo:
•
Gestione Pannello di Controllo
•
Gestione Account
•
Aggiunta di un'applicazione
•
Scelta del layout del template
•
Gestione della pagina
Figura 14:Visualizzazione del Menù
Cliccando sulla sezione riguardante “Aggiunta di un'applicazione” concede allo
sviluppatore l'inserimento di una portlet all'interno della pagina. All'utente comparirà un
menù costituito da una lista di tutte le tipologie di portlet presenti nel portale. Inoltre c'è
la possibilità di aggiungere nuove portlet all'interno del portale attraverso o una ricerca
della nuova portlet da integrare o l'inserimento del file.war.
Pasquale Catalano 566/2323
Pagina 25 di 121
Nel successivo paragrafo andiamo a soffermarci più in dettaglio su alcune portlet quali
la Portlet WebContent Display e la Portlet Iframe.
3.4 Portlet WebContent e Iframe
Liferay mette a disposizione per lo sviluppatore una lista di portlet organizzate
per ciascuna categoria interessata.
Per lo sviluppo dell'applicazione sono state oggetto di studio le seguenti portlet:
WebContent Display e Iframe. In seguito vengono presentati il loro utilizzo e le loro
caratteristiche.
La WebContent Display è una portlet che appartiene alla sezione Content Management.
Essa svolge la funzione di contenitore di informazioni, infatti può comprendere sia testo
che immagini. Una volta selezionata, facendo click su “Add” appare una finestra
nell'area di lavoro suddivisa in due settori. Nel primo sono disposti i pulsanti per
ingrandire, ridurre e eliminare la finestra della portlet. Inoltre compare un pulsante che
consente attraverso un menù a tendina di eseguire operazioni del tipo: configurazione,
importare/esportare e imposta layout. Se la scelta ricade su:
•
configurazione: si presenta una schermata suddivisa in più schede che concede di
inserire WebContent già esistenti, impostare i permessi agli utenti e condividere
la portlet.
•
importare/esportare: consente di esportare la portlet creata in un formato .lar o di
importare altre portlet sempre con un'estensione .lar.
•
imposta layout: permette allo sviluppatore di settare lo stile del testo (con
informazione su tipo font, dimensione carattere,...), il colore di sfondo, i margini
e bordi della portlet e inoltre concede di inserire in un'apposita sezione regole
CSS da far assumere alla portlet.
Nel secondo settore posto in basso alla finestra viene mostrato il bottone che permette
Pasquale Catalano 566/2323
Pagina 26 di 121
di aggiungere un Web Content. Quindi compare una schermata in cui è possibile
eseguire le seguenti operazioni:
•
Inserimento del testo
•
Inserimento di un'immagine
•
Inserimento del codice HTML relativo al testo o all'immagine
Questo rende l'utilizzo della portlet adatto a qualsiasi tipo di utente, esperto o non
esperto.
Figura 15: WebContent Display
Dopo la fase di scelta dell'informazione e di salvataggio dei contenuti aggiunti, appare
un pulsante nella finestra che permette di editare le informazioni inserite.
La portlet Iframe fa parte della sezione Sample del menù generale di classificazione
delle portlet. Essa consente di incorporare una pagina HTML all'interno della pagina
corrente. Inoltre l'utente può navigare attraverso la pagina senza perdere il contesto della
pagina del portale. La portlet Iframe utilizza il tag iframe di HTML, che fa parte di
HTML 4, supportandola in tutti i principali browser. Inoltre adeguerà le dimensioni della
pagina HTML, se la pagina è presente nel server stesso. Il browser aggiungerà le barre
di scorrimento se la pagina non rientra nella dimensione del frame. Dopo averla
selezionata, appare una finestra contenete le seguenti macro aree:
Pasquale Catalano 566/2323
Pagina 27 di 121
– General: consente mediante il campo source di andare ad inserire l'URL di una
risorsa internet, come immagini documenti o siti web.
– Autentication: Se la pagina Web incorporata richiede l'autenticazione, la portlet
Iframe può essere configurata per fornire informazioni di autenticazione. Questa
sezione descrive le diverse opzioni offerte all'utente. Se selezionata compare una
box in cui si può scegliere il tipo di autenticazione. Ci sono diverse maniere di
fornire le informazioni di autenticazione per la pagina. La portlet supporta due
categorie:
Autenticazione Basic: Questo metodo è descritto nelle specifiche HTTP. Il nome
utente e password di solito sono forniti come intestazioni HTTP, ma è anche
possibile inserirli nella URL con la sintassi.
Autenticazione Form: È il nome dato ai siti web che autentica l'utente facendogli
compilare un modulo con il suo nome utente e password. Si tratta di quello
utilizzato dalla maggior parte dei siti web. Ci sono due varianti di questo: GET e
POST. La prima imposta il nome utente e password nella URL e il secondo nel
corpo della richiesta. Di solito fanno poca differenza ed entrambi probabilmente
funzionano con qualsiasi sito web.
Quindi nella portlet compariranno una lista di campi tali da poter personalizzare
i tipi di autenticazione. Inoltre la portlet consente, quando si utilizza
l'autenticazione basata sul form, all'amministratore di configurare un insieme di
parametri aggiuntivi che saranno inviate con il modulo. Questi parametri devono
essere impostati nel campo 'Hidden Variable'.
– Advanced: permette allo sviluppatore di inserire valori di attributi HTLM.
Non dimentichiamo che anche con la portlet Iframe è possibile caratterizzarla come la
WebContent attraverso la scelta delle voci look and feel, import/export e configuration
del menu a tendina, che si presenta dopo aver selezionato il rispettivo bottone che
appare in alto alla finestra.
Pasquale Catalano 566/2323
Pagina 28 di 121
Figura 16: Esempio di portlet Iframe con l'URL http://www.google.it
3.5 Il portale del Tier2-Napoli
L'infrastruttura del Tier2-Napoli utilizza un sistema di monitoraggio completo ed
interattivo, che permette di soddisfare molti aspetti, quali:
•
Gestione del profilo degli utenti con relativa caratterizzazione dell'attività. Vale a
dire che ai consumatori generici è permesso analizzare la rete fino a giungere allo
stato dei servizi su ciascun apparato, escludendo la possibilità di
modificare i servizi. Viceversa
poter
agli utenti amministratori viene concessa la
completa gestione, intesa come visualizzazione , sospensione, ravvio di qualsiasi
apparato o servizio
•
Buona scalabilità, ossia facilmente da espandere e da modificare. In realtà un
attributo importante di ogni rete di calcolo ed in particolare quella del Tier2Napoli è quella di non avere un'architettura fissata, concedendo così che nel
tempo sia sempre possibile cambiarne la topologia con l'inserimento di nuove
Pasquale Catalano 566/2323
Pagina 29 di 121
apparecchiature
•
Buona gestione delle apparecchiature da remoto con particolare attenzione
sull'aspetto della sicurezza, dovuta dal fatto che è possibile coordinare tutta
l'intera infrastruttura
Il portale si presenta con una pagina che consente di visualizzare all'intero di un frame
una mappa generale, nella quale sono rappresentati tutte le tipologie di apparati: Storage
Elements, Worker Nodes, Service Nodes, CMC, Switch, Router e UPS. Per alcuni di essi
c'è la distinzione (L1 e L2) tra la locazione nel Data Center, come spiega la legenda in
basso alla mappa. Per ogni tipologia c'è una icona che si riferisce al gruppo, ai suoi host
e ai servizi attivi su essi
Figura 17: Portale del Tier2-Napoli
L'obiettivo è quello di visualizzare, da questa mappa, la stato generale dei servizi per
Pasquale Catalano 566/2323
Pagina 30 di 121
ogni tipologia di apparato, in modo da inquadrare più velocemente il problema che si
presenta. L'icona verde indica che tutti i servizi relativi a quella tipologia restituiscono
uno stato di OK. L'icona gialla indica che almeno un servizio di quella tipologia
restituisce un warning. L'icona rossa indica che almeno un servizio di quella tipologia
restituisce lo stato critical. L'icona grigia invece indica che almeno un servizio
restituisce lo stato unknown.
Posizionando il puntatore del mouse su una di queste icone, si visualizza una lista
(ridotta) degli apparati che fanno parte di quella tipologia, con il rispettivo stato del host,
stato del servizio e numero dei servizi che sono in quello stato, come mostra la seguente
figura.
Figura 18: Sommario servizi Storage Element
Mentre in un altro frame vengono visualizzate notizie riguardanti l'utilizzo di CPU, dello
Storage e di una panoramica dei sistemi di monitoraggio. La mappa essendo navigabile
consente al consumatore di cliccare sull'icona, che indica lo stato di un determinato
apparato, accedendo ad una sezione del portale dove vengono mostrati in dettaglio tutti
gli armadi rack in cui risiede l'apparato selezionato. Nella mappa visualizzata l'utente
riceve informazioni sullo stato di tutti i servizi attivi
Pasquale Catalano 566/2323
Pagina 31 di 121
su quel host e in più altre informazioni generali sullo stato del host.
Figura 19: Mappa con dettaglio di un Worker Node
Le mappe concedono di scendere sempre più nel dettaglio selezionando il singolo host.
In questo caso si accede direttamente alla Web Management dell'apparato. Si apre in una
nuova pagina la home della web management con la schermata di autenticazione.
Dal portale accedendo alla sezione Network Monitoring viene mostrata una mappa che
descrive il monitoraggio del traffico e dei dispositivi della rete mediante il plugin
Weathermap. In questa sezione è possibile navigare tra tutte le mappe, scorgendo ogni
minimo particolare dei dispositivi attivi e della rete.
Dalle mappe, selezionando un qualsiasi link di collegamento dei nodi, è possibile
accedere ad una serie di grafici sia del traffico, che dei pacchetti persi o danneggiati, in
Pasquale Catalano 566/2323
Pagina 32 di 121
Figura 20: Mappa del traffico del Tier2-Napoli
modo da avere una visione completa della situazione della rete. Inoltre, questi grafici
riportano le informazioni secondo una certa scale temporale: giorno, settimana, mese,
anno. Questo schema di consolidamento consente di mantenere importanti informazioni
di carattere storico.
Dunque si può affermare che il portale risulta essere di facile uso al consumatore, anche
con l'introduzione di mappe interattive, fornendogli buone informazioni sullo stato dei
servizi degli apparati della rete e del traffico dell'intera rete. Una mancanza del portale
è quello di esaltare solo il monitoraggio dell'infrastruttura del Tier2 di Napoli senza
poter avere nessuna informazione su i vari esperimenti in cui è coinvolto, rendendolo
utilizzabile solo all'utenza del Tier2 di Napoli.
Pasquale Catalano 566/2323
Pagina 33 di 121
4 Software di Monitoraggio utilizzati dal Data Center
4.1 Analisi dello strumento per il monitoraggio della rete
L'applicazione impiegata per la raccolta dei dati di esercizio degli apparti della
rete del Tier2-Napoli è il software open source Cacti.
La preferenza nell'utilizzare Cacti come uno strumento di raccolta delle informazioni
nasce soprattutto dalle sue caratteristiche, di seguito analizzate, che consentono di tenere
sotto controllo lo stato degli apparati o dei sistemi raggiungibili da una rete.
Il software è costituito in modo tale da integrare una serie di tool, sempre open source, al
fine di fornire un sistema semplice e completo per il monitoraggio di reti informatiche.
Figura 21: Homepage Cacti
Più dettagliatamente Cacti si fonda sui seguenti strumenti:
•
Net-SNMP, Per le interrogazioni SNMP
•
RRDTool, per la persistenza dei dati ricavati dal monitoraggio e la loro
presentazione attraverso grafici
•
piattaforma LAMP ( Linux Apache MySql Php), in particolare:
Pasquale Catalano 566/2323
Pagina 34 di 121
- PHP ed Apache, per la presentazione dei dati e per le interfacce utente
- MySql, per la persistenza dei dati di configurazione
Una schematizzazione modulare, esplicativa, è la seguente:
Figura 22: Struttura modulare Cacti
Cacti mette a disposizione sul proprio portale una serie di script e template già scritti e
funzionanti importabili nel sistema, in modo da espandere le tipologie di dati da
monitorare.
Un'importante caratteristica di Cacti, tale da assegnargli ampi margini di espandibilità, è
quella di un'architettura a plugin.
Tra i plugin più rilevanti ci sono:
•
Discovery ̶ auto rilevamento di dispositivi di una subnet non monitorati da
Cacti
•
Host Info ̶ consente di visualizzare informazione sugli host
•
Monitor ̶ mostra gli stati degli host monitorati generando segnali acustici in
caso di “cadute”
•
UpTime ̶ consente di conoscere gli uptime dei dispositivi monitorati
Pasquale Catalano 566/2323
Pagina 35 di 121
•
Weathermap ̶ permette di definire mappe delle reti arricchite attraverso i dati di
monitoraggio
•
NPC ̶ plugin per integrare il sistema di monitoraggio Nagios all'interno di Cacti
In riferimento alla definizione dei monitoraggi, le chiamate a Net-SMNP possono essere
definite per mezzo di:
– Script di shell bash
– Script Perl
– Definizione di template in XML ( eXtensible Markup Language)
Una volta stabilite le interrogazioni SNMP desiderate, in seguito a un processo di
domande cicliche (polling), Cacti provvede di eseguirle a intervalli di tempo regolari,
trasferendone i risultati finali a RRDTool.
In prima istanza, RRDTool può essere valutato come un vero e proprio database
ottimizzato per gli ambienti di monitoraggio. Nel prossimo paragrafo viene descritto in
maniera esaustiva tale software, assegnando a Cacti un'interfaccia user friendly,
consentendolo di interagire a livello datalayer. Uno dei punti di forza di Cacti è la
facilità di configurazione garantendo ugualmente un'elevata flessibilità.
L'applicativo è dotato di un front-end con interfaccia web scritta in PHP, inoltre permette
di gestire più utenti con viste personalizzate e diversi livelli di permesso per le
modifiche.
Inoltre consente una vasta gamma di personalizzazioni, che vanno dall'aggiunta di
macchine da monitorare, alla definizione di nuove sorgenti di dati, ottenibili tramite
SNMP o script ad hoc.
Per descrivere in una forma chiara e comprensibile il lavoro legato alla raccolta dati di
Cacti, si riporta la seguente figura:
Pasquale Catalano 566/2323
Pagina 36 di 121
Figura 23: Processo di raccolta e persistenza dati di Cacti
Dal modello sopra presentato è possibile osservare come Cacti, mediante l'utilizzo di
Net-SMNP, è in grado di raccogliere informazioni da un'apparecchiatura di rete. È da
notare che le interrogazioni SNMP vengono effettuate unicamente sui WDS in quanto,
quest'ultimi,
mantengono
le
quantità
d'informazione
di
tutti
gli
apparati
dell'infrastruttura a loro carico. Ad ogni interrogazione i dati vengono trasferiti a
RRTool che procede alla storicizzazione.
4.1.1 Il Collezionamento dei dati
Cacti come altri software per il monitoraggio di dispositivi di rete fanno
uso del protocollo SNMP (Simple Network Management Protocol), in quanto ha
l'obiettivo di distribuire all'utente
informazioni e allarmi sugli apparati presenti
all'interno di una rete. Il vantaggio di adoperare tale protocollo è quello di non aver
bisogno di meccanismi esterni di cattura o sonde software da installare.
Dalla natura del dispositivo deriva il grado e il numero delle informazioni, ad esempio
Pasquale Catalano 566/2323
Pagina 37 di 121
uno switch fornirà informazioni differenti da una stampante o da un server.
Bisogna premettere che, prima di effettuare il monitoraggio su un dispositivo è
necessario che si verificano determinate condizioni: gli apparati devono essere dotati di
un Agent SNMP e inoltre possedere la capacità di comunicazione dei dati all'interno
delle rete locale.
Per avere un corretto funzionamento, l'apparato oltre all'Agente SNMP ha bisogno
dell'ausilio di un sistema centrale, con il compito di raccogliere i dati e visualizzarli in
un formato chiaro all'utente denominato Network Management Station, altrimenti la
convenienza nell'utilizzare il protocollo SNMP è del tutto vana.
In una realtà di mercato esistono parecchi ambienti di lavoro che nonostante dispongano
di periferiche SNMP , non prevedono un sistema centrale in grado di consentire la
raccolta dei dati.
Il protocollo SNMP risulta essere di tipo client-server, in cui gli agenti sulle periferiche
lavorano come server mentre il sistema centrale di raccolta come client. Gli agenti
presenti sulle periferiche vengono innescati all'accensione dell'apparato, mettendosi in
attesa di richieste dal sistema centrale. L'utente avrà il compito di decidere quale
particolare informazione del dispositivo andare a controllare, andando a configurare il
software di monitoraggio. Ciò permetterà di interrogare a intervalli di tempo regolare
gli agenti per poter avere informazione sui dati richiesti dall'utente.
L'elenco delle informazioni, variabili, che un dispositivo può fornire è collocata
all'interno di una struttura dati chiamata MIB (Management Information Base) che
risulta essere condivisa tra gli agenti e il sistema di controllo. Questo farà in modo che
l'applicazione di controllo funzionerà subito dopo che sia stata installata. Infine basterà
inserire l'indirizzo IP dell'apparato, una stringa di accesso e le variabili da monitorare.
La MIB è una base di dati che conterrà oggetti, suddivisi nelle seguenti categorie:
•
System: raccoglie informazioni di carattere generale sul dispositivo di rete
•
Interface: accoglie dati relativi alle interfacce di rete
Pasquale Catalano 566/2323
Pagina 38 di 121
•
Address Translation: racchiude informazioni specifiche sulla conversione dei
indirizzi (logico-fisico)
•
Ip: contiene notizie relative al protocollo Ip
•
Icmp: contiene notizie relative al protocollo Icmp
•
Tcp: racchiude dati del protocollo Tcp
•
Udp: comprende informazioni del protocollo Udp
•
Egp: include dati del protocollo Egp
•
Transmission: ospita dati sui mezzi di trasmissione utilizzati da ogni interfaccia
di rete
•
Snmp: racchiude dati del protocollo Snmp
Figura 24: Architettura SNMP
Pasquale Catalano 566/2323
Pagina 39 di 121
4.2 Il Modello di storicizzazione dei dati
4.2.1 RRD: Round Robin Database
Con la sigla RRD indichiamo un Database Round Robin, il quale ci
consente di gestire un numero fisso di voci al suo interno nel seguente modo: la voce più
vecchia viene continuamente sostituita da dati più recenti. Quando nella base di dati
viene scritto l'ultimo record disponibile, il prossimo record da scrivere verrà sovrascritto
al primo in modo tale da mantenere la dimensione del database sotto controllo. Tale
tipologia di database risulta essere adeguata per sistemi che
memorizzano e
visualizzano dei dati di serie temporali (quali banda di rete, temperature, carico CPU)
immagazzinandoli in modo compatto tale da non espandersi nel tempo. Quindi il loro
utilizzo è adatto quando si lavora in un contesto in cui occorre una ripetizione ciclica dei
valori delle misure, che dipendono dal tempo di osservazione.
Figura 25: Funzionamento di un RRD
4.2.2 RRDTool
RRDTool (acronimo di Roundi Robin Database Tool) è un'applicazione
open source strutturato interamente in C da Tobias Oetiker ed è uno degli strumenti
maggiormente utilizzati in generale nell'ambito dei sistemi di monitoraggio. Il suo
Pasquale Catalano 566/2323
Pagina 40 di 121
compito principale, in
un sistema di monitoraggio, è quello di archiviare serie
temporali.
Le caratteristiche fondamentali sono:
•
grandezza degli archivi (file RRD) a regime costante
•
dump degli archivi in file XML
•
prelievo di parziali serie temporali dagli archivi
•
rappresentazione dei dati mediante grafici
Figura 26: Principali caratteristiche di RRDTool
Il software può essere adoperato per osservare qualunque tipo di dato sia possibile
radunare con il supporto del protocollo SNMP. Si fonda principalmente sul criterio del
round robin database. Il vantaggio di utilizzare tale criterio sta nel fatto che le
dimensione degli archivi sono fisse, sgravando l'amministratore da tutti i problemi di
manutenzione relativi alla crescita del database.
Una caratteristica importante da sottolineare dell'applicazione è che le misure rilevate
sono immagazzinate a determinati intervalli di tempo. Nelle misurazioni il tempo
attribuito è espresso nel formato Timestamp, ovvero dal numero di secondi trascorsi
Pasquale Catalano 566/2323
Pagina 41 di 121
dall'epoca (1970/01/01). Inoltre se durante la fase di raccolta accade che la misura non è
disponibile per un fissato intervallo di tempo, allora le viene attribuito il valore di
unknown (nan).
In seguito viene mostrata un'immagine che riporta una dettagliata descrizione degli
oggetti che occorrono per creare un database RRD:
Figura 27: Logica di un RRD
Quindi si giunge alla conclusione che per poter comporre un RRD ci occorrono una o
più fonti dati (DS) e uno o più archivi round robin (RRA)
Le caratteristiche assegnate ad un RRD sono :
•
version: una stringa che concede informazioni sul numero di versione del RRD
•
step: intero che rappresenta il valore della frequenza, espresso in secondi, con cui
un RRD viene aggiornato
Pasquale Catalano 566/2323
Pagina 42 di 121
•
lastupdate: valore numerico che descrive la data dell'ultimo aggiornamento del
RRD , espresso nel formato Timestamp
Ciascun Data Source è costituito dalle seguenti proprietà:
•
name: rappresenta il nome del Data Source, distinguendolo in maniera univoca
all'interno dell' RRD
•
heartbeat: intero che descrive il numero massimo di secondi che possono
trascorrere tra l'inserimento di due dati consecutivi relativi allo stesso DS. Se al
termine del heartbeat non viene un nuovo valore allora RRDTool provvederà a
memorizzare il valore unknown(nan)
•
min, max: rappresentano gli estremi dell' intervallo [min, max] in cui devono
appartenere i dati relativi al Data Source
Come già menzionato ciascun RRD è costituito da uno o più RRA (Round Robin
Archive), aventi il compito di immagazzinare tutte le serie storiche dei DS. Ad ogni
archivio è associata una o più funzioni di consolidamento CF con il fine di consolidare i
dati prima di memorizzarli.
Le funzioni di consolidamento disponibili sono le seguenti:
– AVERAGE
– MIN
– MAX
– LAST
Per quanto riguarda la base di dati, presente in ciascun RRA, è formata dai risultati della
funzione di consolidamento. In linea di massima il numero di righe nel database sarà
costante rispetto all'attributo rows di CF.
Pasquale Catalano 566/2323
Pagina 43 di 121
Figura 28: Flusso dei dati durante il processo di memorizzazione
Dalla figura si deduce come il software RRDTool
effettua il processo di
memorizzazione dei dati su un dispositivo monitorato. Esso è composto dalle seguenti
azioni:
•
Acquisizione del dato e inserimento nel DS (DataSource)
•
Consolidamento dei dati attraverso le CF
•
Archiviazione dei dati
Nel successivo paragrafo si descrivono più in dettaglio alcune funzioni messe a
disposizione da RRDTool.
Pasquale Catalano 566/2323
Pagina 44 di 121
4.2.3 Le Caratteristiche di utilizzo di RRD
RRDTool mette a disposizione per il consumatore una lista di funzioni
che permettono la gestione degli RRD e la visualizzazione delle informazioni. Per lo
sviluppo dell'applicazione sono state oggetto di studio e successivamente di utilizzo le
seguenti funzioni: Create, Fetch, Graph.
4.2.3.1 Create
La funzione di Create di RRDtool permette di impostare un nuovo
Round Robin Database (RRD) file. Il file generato conterrà inizialmente valori nan. Gli
argomenti che riceve sono:
•
[filename]: Specifica il nome dell'RRD che si desidera creare. Il file deve
terminare con l'estensione.RRD
•
[--start|-b start time]: Specifica il tempo in secondi dal 1970/01/01 UTC, quando
il primo valore deve essere aggiunto al file RRD. Non accetterà alcun dato a cui è
associato una serie temporale precedente al tempo specificato
•
[--step|-s step]: Specifica l'intervallo di base in secondi con il quale i dati saranno
inseriti nell'RRD
•
[DS:ds-name:DST:dst arguments]: Ds-name è il nome che verrà utilizzato per
fare riferimento a una particolare fonte di dati di un RRD. DST definisce il tipo di
origine dei dati. I restanti argomenti dipendono dal tipo di sorgente di dati
•
[RRA:CF:cf arguments]: Definizione delle funzioni di consolidamento per la
memorizzazioni dei dati nell'archivio
Figura 29: Esempio d'uso della funzione
Pasquale Catalano 566/2323
Pagina 45 di 121
4.3.2.2 Fetch
La funzione fetch è adoperato per il recupero di informazioni
dall'RRD. Viene normalmente utilizzata internamente dalla funzione graph per ottenere
dati dall'RRD. Fetch analizza l'RRD e cerca di recuperare i dati nella risoluzione
richiesta.
I dati recuperati vengono stampati su stdout. Particolare attenzione ai valori unknown,
spesso rappresentati dalla stringa "nan" a seconda della funzione printf del sistema
operativo.
La lista dei parametri che accetta sono:
•
[filename]: il nome dell'RRD da cui si desiderar recuperare i dati
•
[CF]: la funzione di consolidamento che viene applicata ai dati che si desiderano
scaricare (MEDIA, MIN, MAX, LAST)
•
[--resolution|-r resolution]: indica l'intervallo dei valori che si desidera ricevere.
Anche se la corrispondenza non è soddisfatta la funzione ritornerà i dati
•
[--start|-s start]: limite inferiore della serie temporale per la raccolta dei dati.
Espresso sempre in numero di secondi trascorsi dalla data (1970/01/01)
•
[--end|-e end]: limite superiore della serie temporale per la raccolta dei dati.
Espresso nel formato Timestamp
•
[--daemon address] : indirizzo del demone rrdcached. Se specificato, un
comando viene inviato al server prima di leggere il file RRD
Figura 30: Esempio d'uso funzione fetch
Pasquale Catalano 566/2323
Pagina 46 di 121
Figura 31: Risultato di una fetch di un
file Rrd avente DS total_user
4.2.2.3 Graph
È la funzione cardine di RRDTool, essa viene utilizzata
principalmente per rappresentare i dati da un file RRD verso l'utenza. Il suo obiettivo è
sia quello di creare rappresentazione grafica comprensibile, sia di generare un rapporto
numerico. Tale funzione ha bisogno di dati con cui lavorare, quindi è necessario
utilizzare delle istruzioni che ci consentono la raccolta delle informazioni. RRDTool
fornisce tre tipi di istruzioni:
– DEF:<vname>=<rrdfile>:<ds-name>:<CF>[:step=<step>][:start=<time>]
[:end=<time>][:reduce=<CF>]
Pasquale Catalano 566/2323
Pagina 47 di 121
Questo comando si utilizza quando ci occorre recuperare dati da un file RRD.
Il vname nome virtuale può quindi essere utilizzato in tutto il resto dello script.
Per default, un RRA che contiene i dati consolidati corretti sarà scelto.
– VDEF:vname=RPN expression
Questo comando restituisce un valore e/o un tempo secondo le dichiarazioni
RPN utilizzato. Il vname risultante, a seconda delle funzioni utilizzate, hanno
un valore e una componente tempo. Quando si utilizza questa vname in un'altra
espressione RPN, si sta inserendo il suo valore proprio come se si fosse messo
un numero.
Esempio: VDEF:avg=mydata,AVERAGE
– CDEF:vname=RPN expression
Questo comando crea una nuova serie di punti di dati (in memoria solo, non nel
file RRD) su una o più serie di dati. Le istruzioni RPN sono utilizzate per
valutare una funzione matematica su ogni punto dei dati. Il vname risultante
può quindi essere utilizzato più avanti nello script, proprio come se fosse
generato da una istruzione DEF.
Esempio: CDEF:mydatabits=mydata,8,*
Le principali opzioni passate alla funzione graph sono:
•
[filename]: il nome e il percorso del file da generare. Si raccomanda di inserire a
fine la scelta del formato: .png o .svg o eps
•
[-s|--start time] [-e|--end time]: l'inizio e la fine della serie temporale che si
desiderano visualizzare
•
[-t|--title string] [-v|--vertical-label string]: Stringa orizzontale nella parte
superiore del grafico e/o una stringa disposta verticalmente sul lato sinistro del
grafico.
•
[-w|--width pixels] [-h|--height pixels] dimensioni dell'area che il grafico occupa
Pasquale Catalano 566/2323
Pagina 48 di 121
•
[-g|--no-legend]: Sopprime la generazione della leggenda e visualizza solo l'area
del grafico.
Inoltre fa impiego di istruzioni che consentono di generare le immagini o il report. Se
non si utilizzano elementi grafici, di conseguenza il grafico non viene generato. Allo
stesso modo, nessun report viene generato se non si utilizzano opzioni di stampa.
Per stampare il valore di una variabile definita in una espressione VDEF si adopera la
seguente istruzione: PRINT.
PRINT:vname:format[:strftime]
A seconda del contesto, sia la componente di valore o la componente temporale di un
VDEF viene stampato utilizzando il formato. Si tratta di un errore di specificare un
vname generato da una o DEF CDEF.
Se si volesse inserire del testo all'interno dell'area del grafico s'impiega GPRINT,
altrimenti per introdurre nella medesima area del testo libero si utilizza COMMENT.
GPRINT:dname:CF:testo
COMMENT:testo
La possibiltà di mostrare graficamente l'andamento di una variabile temporale, definita
con una variabile DEF o CDEF è data dal comando LINE
LINE:variabile:colore:legenda
Per ciascun comando LINE si può opzionalmente inserire il comando STACK al termine
della definizione per far sì che la nuova linea si 'appoggi' sulla linea precedente.
Alternativa al metodo LINE esiste il metodo AREA che concede di colorare tutta l'area
compresa l'asse temporale, l'ascissa e la linea di andamento.
AREA: variabile:colore:legenda
Per confrontare dati di tempi diversi è indispensabile 'attualizzare' la posizione
temporale dei dati: ad esempio per paragonare i dati di un indice di borsa odierni con
quelli del giorno precedente, bisogna che i dati del giorno precedente siano spostati di
24h ovvero di 86400 secondi. Questo è possibile con il comando SHIFT
Pasquale Catalano 566/2323
Pagina 49 di 121
SHIFT:datidiieri:86400
Illustriamo in seguito degli esempi d'uso della funzione graph con relativi risultati:
Figura 32: Esempio d'uso con risultato
Pasquale Catalano 566/2323
Pagina 50 di 121
Figura 33: Esempio d'uso con risultato
Figura 34: Esempio d'uso con risultato
Pasquale Catalano 566/2323
Pagina 51 di 121
4.3 Analisi applicazione Nagios
Nagios è un software che si propone come una soluzione per il monitoraggio di
rete aziendali e degli apparati.
Fornisce un sistema di controllo centralizzato dell'intera infrastruttura, includendo
applicazioni software, database, server e apparati di networking, il tutto senza costi di
licenze software e con codice aperto (open source).
Il sistema permette di avere un controllo completo dell'intera rete e quindi di intervenire
tempestivamente in caso di problemi o guasti. La compatibilità è garantita con un
numero elevato di tipologie di server, di sistemi operativi, di router, di switch etc. Il
modello di sviluppo del software in esame garantisce inoltre la possibilità di espandere il
sistema a fronte di esigenze molto particolari poiché la soluzione risulta essere modulare
e a codice aperto.
Il modulo base del sistema è costituito dall'applicazione Nagios per il monitoring
dell'infrastruttura, molto diffusa ed apprezzata, ritenuta ormai una soluzione matura ed
utilizzata da moltissime aziende ed enti pubblici in tutto il mondo.
La configurazione degli host e dei servizi da monitorare viene effettuata tramite una
comoda interfaccia web ed è possibile creare dei template, sia per gli host che per i
servizi, con valori opportuni dei parametri in funzione della tipologia a questo punto il
completamento della configurazione risulta molto semplice, occorre associare i vari
template con le definizioni personalizzate sia degli host da monitorare che dei servizi
che occorre tenere sotto controllo. Il tutto è corredato da un sistema di notifiche di
malfunzionamenti, utilizzabile via posta elettronica o SMS.
I componenti principali di Nagios sono:
•
Monitoring daemon: è un processo lato server che implementa le funzionalità di
monitoraggio e di notifica degli allarmi
•
Web interface: è un’applicazione Web, installabile su un qualsiasi Web Server che
supporti lo standard CGI (usualmente viene utilizzato il programma Apache), che
consente di visualizzare lo stato degli oggetti monitorati anche da postazioni
Pasquale Catalano 566/2323
Pagina 52 di 121
diverse dal server Nagios
4.3.1 Interfaccia Web utilizzata
L’interfaccia Web di Nagios mostra
lo stato degli oggetti monitorati
secondo diversi livelli di dettaglio.
Le viste disponibili principali sono:
•
Status Map, che visualizza la tipologia e lo stato della rete
•
Status Detail, che mostra invece lo stato di ciascun servizio monitorato
•
Tactical Overview, che sintetizza in un’unica schermata lo stato della rete e dei
servizi
•
Status Overview; che mostra lo stato dei servizi raggruppati secondo un criterio
stabilito (tipologia, ubicazione, ecc.)
•
Alert History, che mostra lo storico dei problemi rilevati con possibilità di
applicare filtri
•
Trends, che mostra l’andamento nel tempo dello stato di un servizio
•
Nagios consente di rendere sicuro l’accesso all’interfaccia Web, definendo utenti
con differenti permessi di visualizzazione sugli oggetti monitorati
Figura 35: Interfaccia Web di Nagios
Pasquale Catalano 566/2323
Pagina 53 di 121
5 Sviluppo del Sistema
5.1 Strumenti Utilizzati
5.1.1 Strumento per la gestione e visualizzazione dei grafici
JFreeChart è una libreria gratuita per la creazione di grafici sulla
piattaforma Java. È stato progettato per l'impiego in applicazioni, applet, servlet e JSP.
JFreeChart è distribuito completo di codice sorgente soggetto ai termini della GNU
Lesser General Public Licence.
La libreria è in grado di generare grafici a torta, a barre (regolari e sovrapposti, con un
opzionale effetto 3D), grafici a linee, grafici a dispersione, diagrammi serie storiche,
diagrammi di Gantt, grafici meteo, simbolo grafici, grafici combinazione e altro ancora.
Ulteriori caratteristiche che include sono:
•
Accesso ai dati da qualsiasi implementazione delle interfacce definite
•
Esportazione diretta dei grafici nei formati immagine PNG (Portable Network
Graphic) e JPEG (Joint Photografic Experts Group)
•
Esportazione in qualsiasi formato con una implementazione Graphics2D tra cui:
- PDF con iText
- via Batik SVG
•
Possibilità di aggiungere tooltip ai grafici
•
Possibilità di implementare uno zoom interattivo sui grafici
•
Gestione degli eventi del mouse sui grafici
•
Annotazioni
JFreeChart è scritto interamente in Java e funziona su qualsiasi applicazione sviluppata
sulla piattaforma Java 2 (JDK 1.2.2 o successiva). Ha bisogno anche di Jcommon, un
insieme di utility già incluse comunque nell'archivio scaricabile dal sito ufficiale di
JFreeChart.
Pasquale Catalano 566/2323
Pagina 54 di 121
Figura 36: Esempio di grafico con la libreria JFreeChart
A prescindere dal tipo, la generazione di un grafico tramite JFreeChart prevede sempre
le seguenti azioni:
• Creazione e popolamento di un Dataset;
• Creazione di un oggetto di tipo JFreeChart tramite il corrispondente metodo della
classe org.jfree.chart.ChartFactory;
• Impostazione degli attributi del diagramma tramite una delle classi plot del
package org.jfree.chart.plot;
• Rendering del grafico tramite una delle classi del package
org.jfree.chart.renderer;
• Definizione dell'asse delle ascisse tramite una delle classi del package
org.jfree.chart.axis.
Di seguito viene presentata una descrizione dettagliata di ciascun azione inclusa nella
creazione di un grafico con riferimento al lavoro sviluppato.
Pasquale Catalano 566/2323
Pagina 55 di 121
Quando si definisce un grafico, c'è bisogno di un'insieme di informazioni che permette
di mettere in relazione i dati da voler rappresentare. Di solito questa collezione di dati si
presenta sotto forma di una tabella. In JFreeChart quest'insieme di informazioni è
indicato con un Dataset, dove ogni colonna è una categoria e ogni riga è una serie. La
natura dei dati può essere statica (impostata di default al momento della creazione del
codice) o dinamica (attraverso dati provenienti da query su un database). La libreria
mette a disposizione diversi tipologie di Dataset, ma quello utilizzato nello sviluppo del
l'applicazione è stato il DefaultCategoryDataset.
I principali metodi adottati per la creazione e il riempimento del Dataset sono i seguenti:
•
public DefaultCategoryDataset(), genera un nuovo Dataset (vuoto)
•
public void addValue(double
value,
java.lang.Comparable rowKey,
java.lang.Comparable columnKey),
aggiunge il valore al
Dataset, precedentemente creato
Successivamente si passa alla fase della scelta del tipo di grafico da visualizzare. Per tale
azione la libreria mette a disposizione numerose categorie di grafico. La scelta è ricaduta
sul diagramma a barre.
Nella libreria la preferenza di uno specifico grafico avviene mediante l'impiego del
seguente metodo:
•
public static JFreeChart createBarChart(
String title,
String categoryAxisLabel,
String valueAxisLabel,
CategoryDataset dataset,
PlotOrientation orientation,
boolean legend,
boolean tooltips,
boolean urls
), crea un BarChart
con le seguenti caratteristiche: il titolo del grafico, etichetta asse delle
categorie, etichetta asse dei valori, il Dataset, orientamento del grafico
Pasquale Catalano 566/2323
Pagina 56 di 121
(verticale, orizzontale), flag che indica la presenza della legenda, generazione
tooltips, generazione URL grafico.
Per caratterizzare il grafico in funzione delle proprie esigenze la libreria fornisce una
lista di metodi presenti nella classe CategoryPlot. Per il progetto sono stati utilizzati i
seguenti:
•
public void setBackgroundPaint( Paint
paint
), imposta il colore di sfondo al
grafico
•
public void setDomainGridlinesVisible( boolean
visible
), flag che imposta se
le linee della griglia sono sono tracciate
•
public void setDomainGridlinePaint(
Paint paint
), imposta il colore scelto
alla griglia del grafico
Il processo di generazione di un'immagine, o render della figura, rappresentante il
grafico avviene con l'utilizzo del metodo:
•
public CategoryItemRender getRenderer(), restituisce un render al plot
Inoltre per poter impostare determinati colori alle barre presenti nella figura si è
adoperata la funzione:
•
public void setSeriesPaint( int
series, java.awt.Paint paint
), imposta il
colore scelto per una determinata serie
Quindi dopo la fase di personalizzazione del grafico si giunge a salvare la figura in uno
dei formati offerti dalla libreria nel seguente modo:
•
public static void saveChartAsPNG(
java.io.File file,
JFreeChart chart,
int width,
int height
), salva il grafico per il file
specificato nel formato PNG
Pasquale Catalano 566/2323
Pagina 57 di 121
5.1.2 Interfaccia di supporto della Connessione al Database
La JDBC (Java DataBase Connectivity) è un'interfaccia che consente
l'accesso alle basi di dati da qualsiasi programma scritto con il linguaggio di
programmazione Java, indipendentemente dal tipo di DBMS utilizzato. È formata da
API, completamente scritta nel linguaggio Java, che concede ai client di connettersi e
interrogare il database. In pratica JDBC costituisce una sorta di layer che si interpone
tra applicazione e database vero e proprio. Le applicazioni che utilizzano JDBC nella
maggior parte dei casi sono utilizzabili con differenti tipi di database senza la
necessità di particolari modifiche al codice. Con l'impiego di questa libreria si ha
un'elevata portabilità e quindi riutilizzo del codice. JDBC svolge il suo lavoro
mediante alcune
interfacce,
le quali vengono
implementate da un set di classi
specifico per ogni differente tipo di database andando così a costituire il cosiddetto
driver JDBC. Le API sono collocate nel pacchetto java.sql contenenti solo poche classi
concrete, per la maggior parte si tratta di interfacce indipendenti dalla base di dati che
specificano il comportamento senza però dare alcuna implementazione.
Figura 37: Funzionamento della JDBC
Una volta configurato il driver e collocato all'interno dell'applicazione, possiamo entrare
nel vivo dell'argomento. Come già precedentemente menzionato, la JDBC fornisce dei
metodi che consentono l'accesso ad un qualsiasi DBMS.
Pasquale Catalano 566/2323
Pagina 58 di 121
Sostanzialmente un driver JDBC consente di effettuare le seguenti operazioni:
1. Aprire una connessione al database
2. Esecuzione istruzione
3. Elaborazione del risultato
4. Chiusura della connessione
La fase di connessione al database avviene con l'uso dei seguenti metodi:
•
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"), caricare la classe
corrispondente allo specifico driver. Quando il driver viene caricato in memoria,
si registra con la classe java.sql.DriveManager come un driver per base di dati
disponibile.
•
DriverManager.getConnection("jdbc:odbc:somedb","user","passwd"),
stabilisce una connessione al database di url, user e password specificato. Il
DriverManager seleziona il driver appropriato dal set di driver JDBC registrato.
Dopo aver stabilito la connessione al database, passiamo alla fase in cui è possibile
mandare in esecuzione istruzioni SQL attraverso i metodi:
•
createStatement(), crea un'oggetto Statement per l'invio di istruzioni SQL
•
executeQuery( String sql ), esegue l'istruzione SQL, che restituisce un singolo
oggetto ResultSet. Da notare che l'istruzione SQL eseguita deve essere una
SELECT
•
executeUpdate( String sql ), esegue l'istruzione SQL, di tipo INSERT, UPDATE
o DELETE
Successivamente bisogna gestire i dati provenienti dalle istruzioni SQL mandate in
esecuzione. In ausilio per tale problema c'è la classe ResultSet.
Il ResultSet è una tabella contenente dati che vanno a rappresentare un'insieme di
informazioni provenienti dal database. Un oggetto ResultSet mantiene un cursore che
punta alla riga corrente di dati. Inizialmente il cursore è posizionato prima della prima
Pasquale Catalano 566/2323
Pagina 59 di 121
riga, poi da quando si invoca un metodo su ResultSet, si sposta il cursore sulla riga
successiva.
I metodi adoperati sono stati:
•
public Object getObject( String columnName ), ottiene il valore della colonna
indicata nella riga corrente del ResultSet. Il tipo di oggetto ritornato sarà quello
corrispondente al tipo SQL della colonna. Se il valore è un NULL di SQL, allora
restituisce un null Java
•
public boolean next(), sposta il cursore in basso di una riga dalla sua posizione
attuale
Dopo aver eseguito le operazioni desiderate (prelievo, inserimento, modifica,
cancellazione) sulla base di dati, occorre rilasciare le risorse allocate, in particolare
l'oggetto connection, in quanto il numero totale delle connessioni disponibili è limitato
e normalmente la connessione al database non viene rilasciata automaticamente quando
non è più utilizzata. Quindi per poter liberare la connessione è necessario l'invocazione
del seguente metodo:
•
public void close(), rilascia la connessione precedentemente avuta
5.1.3 Storicizzazione dei Dati: MySql
Un database è un insieme di archivi strutturati che contengono dati che
riguardano un unico ambito lavorativo e
che concedono la gestione di una notevole
quantità di dati. Quindi esso è una banca dati che concede la gestione di grosse moli di
dati con il controllo dell'accesso all'informazione. Per usare le informazioni contenute in
un database, occorre un sistema di gestione di basi di dati (DBMS, Database
Management System). Si tratta di un insieme di programmi che permettono agli utenti di
creare e mantenere una base di dati. Il DBMS è perciò un sistema software che facilita il
processo di definire, costruire, manipolare e condividere basi di dati.
Il modello relazionale è un modello logico di rappresentazione dei dati implementato sui
Pasquale Catalano 566/2323
Pagina 60 di 121
DBMS. Le caratteristiche principali sono:
•
Capacità di gestire grandi moli di dati
•
Condivisione dei dati fra più utenti e applicazioni
•
Utilizzo di sistemi di protezione e autorizzazione per l'accesso ai dati stessi
I DBMS più diffusi sono i Relational Database Management System (RDBMS). I
database appartenenti a questa categoria si basano su una struttura cardine detta
relazione, che concede di rappresentare i dati e di manipolarli attraverso operatori
dell'algebra relazionale. La relazione è presentata mediante una tabella bidimensionale
composta da righe e colonne. Ciascuna riga, che in terminologia relazionale viene
chiamata tupla, rappresenta un'entità che noi vogliamo memorizzare nel database. Le
caratteristiche di ciascuna entità sono definite invece dalle colonne delle relazioni, che
vengono chiamate attributi.
MySql è un database management system (DBMS) relazionale, permette la
conservazione dei dati in tabelle separate piuttosto che in una unica grande entità.
Possiede tutte le funzionalità di un DBMS, è un server di database infatti viene
impiegato in ambienti client-server, nei quali la maggior parte delle operazioni di
elaborazioni e archiviazione hanno luogo nel server, mentre il client è poco più di un
terminale, il tutto attraverso un'interfaccia a caratteri disponibili sia per sistemi Unix che
per Windows, anche se prevale un suo utilizzo in ambito Unix.
MySql possiede un sistema di autorizzazione attraverso il quale gestisce l'accesso da
parte degli utenti ai vari database. Inoltre offre flessibilità e velocità nell'accesso ai dati,
consentendo una più efficace modellazione delle basi di dati. Il fatto di essere Open
Source ha inoltre favorito lo sviluppo di interfacce, rilasciate ovviamente sotto GPL, in
quasi tutti i linguaggi maggiormente utilizzati, soprattutto nello sviluppo di applicazioni
web. L'accesso ai dati è reso possibile dall'utilizzo di SQL (Structured Query Language),
in particolare viene garantito il supporto alla versione corrente dello standard definito
nel ANSI/ISO SQL Standard.
Pasquale Catalano 566/2323
Pagina 61 di 121
In seguito viene mostrato un riepilogo dettagliato delle caratteristiche offerte da MySql:
•
Velocità: risulta essere uno dei più veloci database offerti dal mercato
•
Usabilità: concede con estrema facilità l'installazione, la gestione e
l'amministrazione rispetto a sistemi di maggiori dimensioni presenti sul mercato
•
Supporto di Sql: permette attraverso il linguaggio Sql di operare sulla base di
dati, come tutti i moderni database
•
Capacità: il Server è in grado di amministrare nello stesso tempo connessioni da
più Client ed è possibile accedervi adoperando diverse interfacce in grado di
eseguire query e fornire i risultati. Inoltre esistono una grande quantità di
interfacce di programmazione per differenti linguaggi quali C, Perl, Java, Php
•
Connettività e sicurezza: è autorizzato all'utilizzo della rete e i database sono
accessibili in internet in modo da poter condividere i dati ovunque. Il Server gode
di un meccanismo di controllo degli accessi in modo che chi non ha diritto ad
accedere ai dati non può farlo e supporta connessioni criptate attraverso il
protocollo SSL(Secure Socket Layer)
•
Portabilità: funziona su una varietà di piattaforme come Unix, Windows e OS/2
ed anche su diversi hardware
•
Dimensioni Ridotte: confrontandolo con i software commerciali offerti dal
mercato, occupa meno spazio
•
Disponibilità e costi: è un progetto Open Source liberamente disponibile ed
inoltre possiede una grande comunità di sviluppatori e utilizzatori in rete
Inoltre, la distribuzione di MySQl fornisce i seguenti strumenti:
•
Programmi Client per l'accesso al Server: programma interattivo che consente di
inserire delle query e visualizzarne i risultati, più una serie di utility per gestire la
propria applicazione web
•
Una libreria Client in C per scrivere i propri programmi
Pasquale Catalano 566/2323
Pagina 62 di 121
5.2 Progettazione Database
In questa sezione andiamo ad esporre le fasi di studio, analisi e implementazione
necessarie per la realizzazione della base di dati d'appoggio all'applicazione sviluppata.
La progettazione di un database si divide in due sezioni: la progettazione concettuale e
la progettazione logica. Quella concettuale ha il compito di rappresentare le
informazioni che abbiamo ottenuto dalla raccolta dei requisiti con uno schema formale o
più precisamente detto schema concettuale, realizzato con strumenti indipendenti
dall’ambiente e dal sistema di dati che si andrà ad utilizzare durante lo sviluppo. Questo
schema in pratica ci consente di organizzare i dati ad un alto livello di astrazione perché
la finalità di questa fase è quella di rappresentare il contenuto informativo della base
dati. La progettazione logica, invece, ci consentirà di tradurre lo schema concettuale in
un preciso modello di rappresentazione dati legato al DBMS(database management
system) che abbiamo a disposizione.
La base di dati da realizzare dovrà occuparsi della gestione delle diverse categorie di
apparato che un Data Center può presentare e delle corrispondenti misure rilevate dal
monitoraggio dei servizi attivati sull'apparato.
Nello specifico il database da realizzare deve concedere la memorizzazione delle
informazioni riguardanti:
•
dati sulle categorie degli apparati monitorati
•
dati sui servizi attivati
•
informazioni sulle misure relative al monitoraggio dei servizi
In una base di dati, le entità giocano un ruolo fondamentale poiché mettono in risalto le
informazioni che si andranno a immagazzinare. Senza un'efficace individuazione delle
stesse si avrà una cattiva progettazione di un database perché causano la perdita dei
dati.
Con i requisiti sopra descritti, per la nostra base di dati si evidenziano le seguenti entità:
Pasquale Catalano 566/2323
Pagina 63 di 121
categoria di appartenenza di un apparato, servizio, misura.
Per dare una maggiore comprensione a quanto detto sull'entità e di come esse possono
essere messe in relazione, presentiamo lo schema concettuale della base di dati.
Figura 38: Schema Concettuale database
Dallo schema si evidenzia che Misura risulta essere una entità dell'associazione tra
Categoria e Servizio. Infatti solo quando si è attivato il monitoraggio di un servizio
associato ad una categoria è logico definire una misurazione.
Generato il modello concettuale bisogna procedere verso la progettazione logica. Quindi
si traduce lo schema concettuale prodotto nella fase di progettazione concettuale, nel
modello di rappresentazione dei dati adottato dall’ambiente database scelto per la
programmazione. In questa fase andiamo a definire una lista di caratteristiche tali da
rendere il risultato finale il modello di rappresentazione della nostra base di dati.
Il processo di passaggio dal modello concettuale in logico avviene con una
trasformazione di entità e associazioni in un insieme di schemi, garantendo le proprietà
di un DBMS relazionale.
Pasquale Catalano 566/2323
Pagina 64 di 121
Prima di passare allo schema logico, è necessario ristrutturare lo schema concettuale
ottenuto nella fase precedente.
Bisogna quindi adottare dei criteri che ci permettono di effettuare la traduzione del
modello concettuale
in uno schema ristrutturato per poi passare ad un modello
relazionale equivalente, che tenga anche conto di aspetti legati alle prestazioni delle
operazioni che verranno eseguite sulla base di dati .
Il modello semplificato (schema ristrutturato), equivalente a quello di partenza, al fine di
semplificarne la traduzione successiva, elimina dallo schema concettuale di tutti quei
costrutti non direttamente rappresentabili nel modello relazionale:
•
Attributi composti
•
Attributi Multi-valore
•
Gerarchie di generalizzazioni
•
Scelta degli identificatori primari
Dal modello concettuale mostrato in figura 38, non si evidenziano né la presenza di
attributi composti né Multi-valore, ma presenta una generalizzazione. Per questo tipo di
associazione, si deve intraprendere una scelta, in quanto il modello relazionale non
supporta tale tipo di associazione.
Esistono in letteratura differenti scelte che lo sviluppatore può adottare in funzione delle
proprie esigenze. La prima è quella dell'accorpamento del genitore nei figli: attributi e
associazioni del genitore vanno aggiunti a tutti i figli. Possibile solo se la
generalizzazione è totale ed esclusiva. La seconda risulta quella di accorpare i figli nel
genitore: si aggiunge al genitore un attributo che indichi il “tipo” dell’entità (a quale
entità figlia eventualmente appartiene). Si aggiungono al padre gli attributi e le
associazioni dei figli, che diventano opzionali. Infine la sostituzione della
generalizzazione con le associazioni: si aggiungono nuove associazioni che
rappresentano
la
generalizzazione.
I
figli
partecipano
obbligatoriamente
all’associazione, il genitore opzionalmente.
Pasquale Catalano 566/2323
Pagina 65 di 121
Per il database da realizzare si sceglie quella di trasferire le informazione del padre nelle
entità di specializzazione, consentendo di avere una netta separazione della
storicizzazione dei dati in funzione della categoria dell'apparecchiatura quali Worker
Node, Storage Element, Rete e una migliore gestione e organizzazione dei dati
immagazzinati.
Successivamente si prosegue con la fase in cui si scelgono su ciascuna entità presente
nello schema gli identificatori primari, adottando i seguenti criteri:
•
Gli attributi con valori nulli non possono essere identificatori principali
•
Identificatori composti da pochi attributi sono da preferire a quelli con molti
attributi
•
Un identificatore che viene utilizzato da molte operazioni per accedere alle
occorrenze di una entità è da preferire agli altri
Dopo aver realizzato la ristrutturazione del modello concettuale non resta che passare
alla fase di traduzione nel modello logico. Quindi si procedere con la traduzione che il
modello relazionale adopera per descrive le entità e associazioni presenti nel modello
ristrutturato.
Le entità vengono interpretate con una relazione che comprende gli attributi, in cui la
chiave primaria che corrisponde all’identificatore dell’entità.
Per le associazioni la soluzione da prendere dipende dalla loro cardinalità. Le
associazioni binarie 1:N tra due entità A, B solitamente sono tradotte in due relazioni:
relazione Ra che ha gli attributi di A; relazione Rb che ha gli attributi di B e gli attributi
chiave di A (anche detti chiave esterna).
Le associazioni binarie N:N tra due entità A, B vengono interpretate nel seguente modo:
relazione Ra che ha gli attributi di A; relazione Rb che ha gli attributi di B; una terza
relazione Rs con gli attributi chiave di A e gli attributi chiave B e inoltre tutti gli attributi
dell'entità dell'associazione, sempre se essa è presente nello schema.
Per avere una migliore comprensione su quanto detto fino ad ora, riportiamo un elenco
Pasquale Catalano 566/2323
Pagina 66 di 121
dello schema relazionali, che si vengono a creare con le scelte effettuate.
workernode(idc,nome,nomerack)
storageelement(idc,nome,nomerack)
rete(idc,nome,nomerack)
misura_wn(idm,id,ids,data,valore)
misura_se(idm,id,ids,data,valore)
misura_re(idm,id,idservizio,data,valore)
servizio(ids,nomeservizio,descrizione)
Dal modello sopra illustrato si denota che adoperiamo per ciascun schema
rappresentante la categoria dell'apparato gli stessi attributi. La scelta di utilizzare tale
approccio è dettata dal fatto che concede:
•
maggior riusabilità delle query create e mandate in esecuzione dall'applicazione
sviluppata, modificando solo il nome della tabella interessata da cui prelevare i
dati
•
minor numero di condizioni da inserire nella clausola WHERE della query, in
modo da
poter effettuare l'unione delle tabelle interessate attraverso l'uso
dell'operazione NATURAL JOIN
Creato il modello logico della base di dati, non resta che avviare la fase di progettazione
e creazione dello schema fisico costituito dall'implementazione mediante il linguaggio
Sql delle relazioni sul DBMS scelto, generando le corrispondenti tabelle che andranno a
costituire il database.
Pasquale Catalano 566/2323
Pagina 67 di 121
5.2.1 Gestione dei dati del Database
Le informazioni memorizzate all'interno della base di dati godono di
vincoli assegnati durante la fase di creazione delle tabelle. Tali condizioni sono quelle
riguardanti la chiave primaria, permettendo di identificare univocamente le righe
all'interno della tabella e di integrità referenziale, in modo da gestire con coerenza la
correlazione di dati presenti in tabelle diverse legati attraverso la chiave esterna.
Durante la fase fisica di costruzione del database, quando si genera una tabella, bisogna
gestire con opportune clausole l'operazione da eseguire quando si tenta di eliminare o
aggiornare una chiave alla quale fa riferimento una chiave esterna. Si è giunti ad
adoperare la scelta del valore No Action sia per l'eliminazione che per l'aggiornamento
in modo tale da generare un errore e in eseguito il rollback dell'istruzione di DELETE o
UPDATE. La scelta effettuata è motivata dal fatto che: la base di dati realizzata è
utilizzata solo per avere uno storico di misure di apparati e servizi, quindi non è
necessario fare eliminazioni o aggiornamenti in cascata o settare con valore ”null”.
Inoltre le informazioni da immagazzinare fisicamente nel database, sono state decise in
modo tale da avere una coerenza con quelle memorizzate dagli archivi utilizzati dai
sistemi di monitoraggio con l'aggiunta di altri dati quale la tipologia del servizio attivato
su quell'apparato che fornisce una maggiore completezza sulle informazioni salvate.
In alcuni casi non è stato adoperato lo stesso tipo di dato per la rappresentazione
dell'informazione. Infatti si è scelto di utilizzare un diverso tipo in grado di
rappresentare la stessa informazione. Esempio per il campo data si è deciso di adoperare
il tipo “Human Date1” piuttosto del tipo “Timestamp2” concedendo maggior usabilità
dell'informazione.
In più su ciascuna tabella vengono creati automaticamente degli indici sulla chiave
primaria per poter migliorare i tempi di ricerca dei dati, ma essi non saranno più
utilizzabili quando si effettuano giunzioni tra le tabelle.
1 Intendiamo il formato della data AAAA-MM-GG
2 Rappresenta il numero di secondi trascorsi dalla mezzanotte (UTC) del 1° gennaio 1970 (epoca)
Pasquale Catalano 566/2323
Pagina 68 di 121
5.3 Diagrammi UML
UML è un linguaggio di modellazione in grado di specificare la struttura e il
comportamento di un sistema software. Ė uno strumento di comunicazione tra i diversi
ruoli coinvolti nello sviluppo e nell'evoluzione dei sistemi.
Mette a disposizione per lo sviluppatore una vasta gamma di diagrammi che sono
classificati in: strutturali, comportamentali, comportamentali d'interazione.
Sono stati adoperati per la descrizione dell'applicazione sviluppata i seguenti diagrammi:
UseCase Diagram, Class Diagram, Sequence Diagram, Activity Diagram.
In seguito introdurremo diagrammi UML che apparterranno a due diverse fasi del ciclo
di vita dello sviluppo di un software: la fase di Analisi e la fase di Design.
5.3.1 Fase di Analisi
La fase di analisi è costituita da un'indagine preliminare sul contesto in
cui il prodotto software deve inserirsi e sulle caratteristiche che deve esibire. Consente
di costruire un modello ( schema concettuale ) dell’applicazione completo, preciso e
leggibile, indipendente da linguaggi di programmazione.
Diagramma dei Casi d'uso
Il diagramma dei casi d'uso descrive le funzionalità fondamentali
che il sistema deve esprimere, in termini di scenari di utilizzo del sistema. Un caso d'uso
rappresenta una tipica interazione tra un utente ed l'applicazione da realizzare. In altre
parole, definisce un particolare modo di utilizzare il sistema, il quale offre servizi e
funzionalità in risposta a eventi prodotti dagli attori. Si tratta, essenzialmente, di una
rappresentazione per scoprire, chiarificare e concordare i requisiti di un sistema. Usare i
casi d'uso significa:
1. Individuare chi (persone, o altri sistemi "esterni") dovrà usare il sistema
2. Chiedersi quali sono gli obiettivi che intendono conseguire usando il sistema
(all'incirca, un caso d'uso per ogni obiettivo)
Pasquale Catalano 566/2323
Pagina 69 di 121
Figura 39: Diagramma Caso d'uso
Si approfondiscono, in termini di descrizione di ciascuna modalità d'uso, chiarendo il
modo in cui inizia, le risposte che l'utilizzatore si attende dal sistema, la sequenza di
passi con cui l'interazione si svolge, attraverso il formalismo di Cockburn.
USE CASE #1 Popolamento Database
Goal in
Inserimento dei dati
Contex
Preconditions Esistenza del file contenente le corrispondenze tra gli apparati e
nome rrd
Success End Inserimento delle informazioni nel database avvenuto con successo
Condition
Failed End
Condition
Primary
Utente
Actor
Trigger
Invocazione dello script Manager.sh
STEP
Description
Utente
Sistema
1 Invocazione dello script
Manager.sh
2
Interrogazione sul file.rrd da
esaminare
Pasquale Catalano 566/2323
Pagina 70 di 121
3
4
5
Generazione file contenente il
risultato prodotto dalla query
Lettura del file
Inserimento dei dati nella
tabella del database MySql
USE CASE #2 Visualizza Grafico
Goal in
Il sistema mostra a video la visualizzazione del grafico
Contex
Preconditions Nessuna
Success End Presentazione dell'immagine relativa al grafico da visualizzare
Condition
Failed End
Condition
Primary
Utente
Actor
Trigger
Invocazione pagina HTML
STEP
Description
Utente
Sistema
1 Invocazione pagina HTML
2
Prelievo dal database le
informazioni necessarie
3
Popolamento del Dataset del
grafico
4
Creazione del grafico
5
Generazione del file.PNG
6
Visualizzazione a schermo del
grafico
Pasquale Catalano 566/2323
Pagina 71 di 121
Diagramma delle Classi
Il Diagramma delle Classi definisce una rappresentazione statica
del sistema in termini di classi e relazioni tra classi. È il modello fondamentale fornito
da UML poichè ha la caratteristica di stabilire gli elementi base del sistema software da
sviluppare.
Figura 40: Diagramma delle classi di analisi
Pasquale Catalano 566/2323
Pagina 72 di 121
Dalla figura sopra illustrata si evidenziano le entità necessarie che permettono il
funzionamento dell'applicazione sviluppata. Si fa ausilio dell'euristica three-object-type
per identificare i tipi di oggetti associati a ciascuna classe.
Elenco delle classi presenti:
•
Controller: Appartenete alla categoria Control, descrive l'entità che guida tutta
l'applicazione sviluppata, nello specifico raffigura il funzionamento dello script
shell/bash Manager.sh
•
File: Di tipo Entity, rappresenta i dati prelevati dall'interrogazione eseguita sul
dispositivo monitorato
•
Database: Appartenente alla categoria Entity, descrive l'archivio dei dati di
supporto all'applicazione
•
Grafico: Di tipo control, raffigura la classe che gestisce il modulo della
generazione del grafico
•
RRD: Appartenente alla categoria Entity, rappresenta l'archivio dei dati associato
ai dispositivi monitorati
•
Schermo: Di tipo Boundary, descrive l'entità che permette l'interazione tra il
sistema e l'utente finale
•
Html: Appartenete alla categoria Entity, raffigura l'entità che gestisce i dati
persistenti riguardante la pagina html
Pasquale Catalano 566/2323
Pagina 73 di 121
Diagramma di Sequenza
Attraverso il diagramma di sequenza è possibile presentare la serie
temporale dei messaggi che gli oggetti si scambiano in modo tale da portare a termine
una funzionalità. Essi possono corrispondere a uno scenario specifico o a un intero caso
d’uso.
L'immagine seguente mostra lo scambio dei messaggi che compiono gli oggetti
per effettuare l'inserimento delle informazioni nel database.
Figura 41: Diagramma di sequenza
Nella prossima figura si rappresenta lo scambio dei messaggi che compiono gli oggetti
per la visualizzazione a video delle informazioni attraverso una rappresentazione
grafica.
Pasquale Catalano 566/2323
Pagina 74 di 121
Figura 42: Diagramma di sequenza
5.3.2 Fase di Design
In questa fase si stabiliscono le linee essenziali della struttura del sistema
da realizzare, in funzione dei requisiti evidenziati dalla fase di analisi attraverso i
diagrammi UML generati. Si può dire che tale fase ha lo scopo di definire con un certo
livello di dettaglio la soluzione del problema. In questa fase saranno sviluppati
diagrammi UML che permetteranno di avere una definizione specifica della struttura e
delle caratteristiche dei singoli componenti.
Pasquale Catalano 566/2323
Pagina 75 di 121
Diagramma delle Classi
Figura 43: Diagramma delle Classi di Design
Pasquale Catalano 566/2323
Pagina 76 di 121
Diagramma di Sequenza
L'immagine seguente mostra lo scambio dei messaggi che
compiono gli oggetti per effettuare l'inserimento delle informazioni nel database.
Figura 44: Diagramma Sequenza di Design
Pasquale Catalano 566/2323
Pagina 77 di 121
Nella prossima figura si rappresenta lo scambio dei messaggi che compiono gli oggetti
per la visualizzazione a video delle informazioni attraverso una rappresentazione
grafica.
Figura 45: Diagramma di sequenza di design
Pasquale Catalano 566/2323
Pagina 78 di 121
Diagramma di Attività
I diagrammi di attività, mostrano l'evoluzione del flusso di
un'attività, ognuna delle quali è definita come un'esecuzione continua non atomica
all'interno di uno stato. Esso stabilisce le attività da eseguire per compiere una
determinata funzionalità. Inoltre può essere adoperato per dettagliare uno specifico
algoritmo. È utile per mostrare cosa accade in un processo o in un'operazione ed è
considerato come parte integrante dell'analisi di sistema.
In seguito viene presentato un diagramma che descrive le fasi che vanno a costituire la
procedura di generazione del grafico.
Figura 46: Activity Diagram
Pasquale Catalano 566/2323
Pagina 79 di 121
Nella successiva rappresentazione viene illustrata la soluzione intrapresa volta a
eseguire l'inserimento dell'informazione nella base di dati. Essa sarà composta dalle
attività di lettura del file di testo con l'acquisizione di ciascuna riga e inserimento dei
dati nel database.
Figura 47: Activity Diagram
Pasquale Catalano 566/2323
Pagina 80 di 121
5.3 Funzionalità offerte dal sistema
L'applicazione sviluppata permette di realizzare l'operazione di popolamento di
una base di dati e di eseguire interrogazioni mirate sul database, mostrando il risultato
attraverso una rappresentazione grafica.
Quindi concede la storicizzazione dei dati provenienti da informazioni immagazzinate
dai sistemi di monitoraggio quali Cacti e Nagios, dei servizi osservati degli apparati di
un Data Center come Worker Node, Storage Elemet, Router, Switch. Inoltre, il sistema
consente di mostrare mediante un portale web la visualizzazione di determinati contenuti
che rispondono alle esigenze richieste dall'utente; il tutto presentato con dei grafici.
Sebbene il sistema sia rivolto a persone che lavorano nel campo del monitoraggio,
l'interazione non deve presentare un elevato grado di complessità. Deve essere,
piuttosto, fruibile da un pubblico quanto più eterogeneo possibile. Gli utenti che
interagiscono con il sistema devono essere in grado di reperire l'informazione con
facilità. Per questi motivi si sono adottate determinate rappresentazioni di grafico quali:
a barre e a linea con area sovrapposta.
Il sistema è basato sul web e su un server di database relazionale. Dunque, ha il compito
di essere affidabile e poter mantenere i propri dati anche in caso di guasti (problemi di
fornitura elettrica, usura dell'hardware del server, attacchi informatici). Quindi sono state
pianificate delle operazioni in grado di effettuare il recupero delle informazioni perdute
attraverso dei backup periodici dei dati.
L'applicazione è stata sviluppata in modo tale da garantire buone prestazione, legate al
tempo di risposta, nello specifico alla generazione delle immagini dei grafici da
visualizzare nella pagina web del portale.
Un'altra caratteristica che il sistema rispetta è la scalabilità, cioè la capacità di avere
buone prestazioni se vengono fornite nuove risorse, quindi garantisce una struttura
modulare, in modo che il sistema sia costituito da varie sezioni (moduli) che operano in
Pasquale Catalano 566/2323
Pagina 81 di 121
maniera indipendente uno dall'altro concedendo all'applicazione di essere facilmente
espandibile e modificabile.
Il sistema, sviluppato con il linguaggio di programmazione orientato agli oggetti, Java,
permette di poter gestire in modo efficiente le singole sezioni che vanno a costituire
l'intero sistema e inoltre la portabilità, volta a consentirne l'uso di ciascun modulo in un
ambiente di esecuzione diverso da quello originale, in modo semplice (poco costoso)
rendendolo riusabile.
In più si fa utilizzo del DBMS relazionale MySql, in quanto già presente nei sistemi di
monitoraggio adottati dal Data Center per archiviare determinate informazioni,
permettendo così di integrare l'applicazione sviluppata direttamente sulle macchine che
ospitano i sistemi di monitoraggio.
In ultima analisi, per fare in modo che
il software sviluppato venga eseguito
correttamente c'è bisogno delle seguenti caratteristiche:
•
jdk
•
libreria JDBC
•
libreria JFreeChart
•
database relazionale MySql
Nelle sezioni successive andiamo a fornire un
maggior livello di dettaglio delle
funzionalità offerte dal software.
5.3.1 L'operazione di popolamento del Database
L'attività del popolamento della base di dati è costituita: dal prelievo delle
informazioni dagli archivi dei sistemi di monitoraggio, salvarle in un file di testo, inviare
il file all'applicazione, processare i dati del file e infine inserirli nella base di dati.
Quindi bisogna andare a fare un'interrogazione sul file RRD corrispondente al servizio
Pasquale Catalano 566/2323
Pagina 82 di 121
dell'apparato monitorato di un determinato periodo temporale (nel nostro caso 1h).
Il risultato verrà rediretto in un file di testo nominato nel seguente modo:
nomeapparato:nomeservizio, in una apposita cartella chiamata nomeapparato. Questo
permette di andare a raggruppare tutti i file in funzione della categoria di appartenenza
dell'apparato, garantendo maggior organizzazione della distribuzione dell'informazione.
Successivamente si richiama l'applicazione Applicazione.jar fornendo come input il file
di testo precedentemente generato.
All'interno dell'applicazione si esegue la lettura del file, si elaborano i dati del file
gestendone il tipo in modo tale da non avere problemi con l'inserimento. L'ultima
operazione che resta da eseguire è quella di aggiungere i dati in una specifica tabella
della base di dati.
Tutte le azioni sopra descritte sono inserite in un determinato script di shell/bash
Manager.sh. Per effettuare l'aggiornamento delle tabelle del database con prefissata
frequenza temporale, si fa utilizzo del comando crontab.
Crontab1 è un procedura del sistema operativo Unix che consente la pianificazione di
comandi, ovvero consente di registrarli presso il sistema per essere poi mandati in
esecuzione periodicamente. Sarà sufficiente andare ad inserire nel file crontab una linea
composta da una serie di campi quali minuti, ore giorno, ecc., che specificano con che
frequenza e quando eseguire un comando, nel nostro caso il file Manager.sh.
5.3.1.1 File di Configurazione dell'applicazione
Facendo una dettagliata analisi sui sistemi di monitoraggio
utilizzati dal Data Center è stata evidenziata la seguente problematica.
Quando sono stati inseriti gli apparati nei sistemi di monitoraggio gli sono stati assegnati
dei nomi. Nel momento in cui si va ad attivare il monitoraggio di un servizio di
un'apparecchiatura, viene generato un file RRD corrispondente. Il problema rilevato è
stato quello che il nome del file RRD non corrisponde con il nome dell'apparato presente
1 Per osservare il contenuto, accedere alla sezione Allegato C
Pasquale Catalano 566/2323
Pagina 83 di 121
nel sistema, perchè gli è stato assegnato un identificativo numerico.
Quindi visto che per lo sviluppo dell'applicazione occorreva dire il vero nome
dell'apparato e non l'identificativo numerico, si è proceduto nel seguente modo: grazie
all'ausilio di Centreon, attraverso la sua interfaccia web, si è potuti andare scrivere le
vere relazioni
tra il nome apparato e il
nome del file RRD. Con tale lista di
informazioni si è generato un file di input che sarà il parametro d'ingresso dello script
Manager.sh.
Il file di testo è costituto dai seguenti campi:
•
nomedns dell'apparato
•
nome servizio monitorato
•
nome file RRD
In particolare se ad un apparato sono stati assegnati più servizi da monitorare allora nel
file compariranno tante righe quanti sono i servizi.
Figura 48: File di input dei WorkerNode
5.3.1.2 File di supporto per le relazioni del Database
In aiuto allo sviluppo dell'applicazione è stato utile generare un file
di testo che riporta le corrispondenze tra le categorie di classificazione degli apparati
monitorati e il nome delle loro relative tabelle nella basi di dati. Questo fa si che una una
volta invocata l'applicazione Applicazione.jar con il nome del file di testo contente il
risultato dell'interrogazione dal RRD, dà la possibilità di conoscere già quali tabelle del
Pasquale Catalano 566/2323
Pagina 84 di 121
database adoperare per quel determinato file di testo passato in input.
Quindi si crea un file di testo che avrà tante righe quante sono le categorie degli apparati
di cui si vuole fare uno storico. Inoltre ciascuna riga sarà costituita da campi che
rappresenteranno il nome delle tabelle in relazione con quella classe di apparato,
utilizzando come separatore il carattere ”:”.
Una volta generato il file con le caratteristiche sopra citate, sarà adoperato
dall'applicazione nel seguente modo.
Dopo l'operazione di apertura del file, nell'applicazione sarà creata la seguente struttura
dati:
TreeMap<String,LinkedList<String>>
La TreeMap è una struttura dati che implementa tabelle attraverso un tipo particolare di
alberi binari di ricerca. La tecnica di memorizzazione è caratterizzata dal fatto che le
chiavi devono essere ordinabili; il costo dell'inserimento, della ricerca e della
cancellazione è nell'ordine del logaritmo del numero di chiavi presenti; non ci si deve
preoccupare del numero degli elementi presenti nell'albero in quanto la struttura cresce
in modo naturale ed efficiente.
Figura 49: Esempio Della Struttura Dati
Pasquale Catalano 566/2323
Pagina 85 di 121
Nel nostro caso le chiavi della struttura saranno le categorie degli apparati mentre la
linkedlist sarà costituita dai nomi delle tabelle in relazione con la classe delle
apparecchiature. Con questa metodologia adottata ci permette di rendere il lavoro
modulare in grado di non stravolgerlo quando si presentano modifiche da fare.
Ad esempio nel nostro caso quando si aggiunge una nuova categoria di un apparato
di
cui storicizzare i dati, basta aggiungere nel file una nuova riga contenenti il nome della
categoria e i nomi delle tabelle in relazione con essa.
5.3.1.3 Il Parser sviluppato
Il parser è un modulo dell'applicazione sviluppata che ciclicamente
esamina un file di testo, il quale viene creato dall'interrogazione eseguita sugli archivi
RRD, contenete informazioni sulle misure assunte da un servizio monitorato e le
trasferisce all'interno di un database.
Dal momento che i dati inseriti nella base di dati devono garantire gli aggiornamenti che
assumono i valori dei servizi monitorati nel tempo, occorre che il parser venga eseguito
periodicamente attraverso un'azione automatizzata. Infatti si adopera il comando delle
macchine unix crontab, che consente di effettuare ad intervalli di tempo
stabiliti
l'esecuzione di comandi.
Il principale elemento di cui necessita il modulo del parser è il file di testo che deve
andare ad analizzare. Tale documento viene aggiornato con un intervallo temporale della
durata di un'ora per ciascuna apparecchiatura monitorata, occupando dimensioni sul
disco di pochi KB in quanto il file contiene misure osservate ogni 5min. Esso ha una
specifica formattazione: la prima riga contiene i nomi dei data source associati al RRD,
dalla terza riga in poi comprende informazioni riguardanti la data e ora
dell'osservazione, con le relative misure associate. I campi su ciascuna riga sono separati
mediante il carattere “:”.
Quindi la prima operazione che il parser deve eseguire è quella di aprire lo stream al file
di testo da esaminare. Dopo essersi posizionati sulla terza riga del file, si esplode la riga
Pasquale Catalano 566/2323
Pagina 86 di 121
rispetto al carattere “:” ottenendo un struttura dati composta dallo stesso numero di
campi presenti sulla riga. Si procede andando a gestire ciascun campo nel seguente
modo:
•
il campo contenente la data lo si converte dal formato Timestamp in formato
Date(AAAA-MM-GG), agevolando le operazioni successive da eseguire sul
database
epoch=Long.parseLong(dato[0]);
data=new java.text.SimpleDateFormat("yyyy/MM/dd").format(new java.util.Date (epoch*1000));
•
il campo contenente la misura assunta dal servizio lo si converte in un formato
Float in quanto dal file si presenta come Stinga. Da notare, siccome tale attributo
assume anche la stringa “nan” si associa valore 0.0 .
Terminato con la gestione dei campi, siamo pronti per inserire la riga del file corrente
nella specifica tabella del database. Prima di effettuare tale operazione andiamo a
ricavare :
•
id della riga della tabella da inserire
SELECT count(idm)+1
from tabella
•
id associato al servizio attivato sull'apparato monitorato
•
id associato all'apparato osservato
Dopo il recupero di tali informazioni si possono andare ad inserire i dati nelle tabelle del
database, attraverso il seguente comando Sql
Pasquale Catalano 566/2323
Pagina 87 di 121
INSERT INTO tabella
VALUES(id,id_entita,id_servizio,data,valore)
Tutto questo procedimento bisogna eseguirlo affinché non si esegue la completa
scansione del file di testo.
5.4.2 L'interfaccia Utente
La funzionalità riguardante la visualizzazione dell'informazione consente
di effettuare le seguenti azioni: prelevare dati dal database con delle specifiche query e
mostrare a video il risultato attraverso dei grafici.
Tali azioni verranno eseguite in modi differenti in funzione dei dati che devono essere
mostrati a video. Per la categoria degli apparati di rete ( Router, Switch ) procederemo
utilizzando direttamente la funzione graph di RRDTool per plottare a video i dati con un
grafico composto da linea e area sovrapposte, di cui una raffigura il traffico in ingresso e
l'altra il traffico in uscita, favorendo all'utente una maggior usabilità dell'informazione in
quanto permette la visualizzazione contemporanea delle misure assunte dai due traffici.
La scelta di adoperare questo approccio è dettata dal fatto che ai dati appartenenti agli
apparati di rete non c'è la necessità di gestirli attraverso funzioni matematiche (es:
media).
Mentre per le restanti categorie bisogna procedere con un'interrogazione su ciascuna
tabella rappresentante la classe dell'apparato (Worker Node, Storage Element, …)
presente all'interno del database. Una caratteristica che l'interrogazione deve presentare
è quella di andare a selezionare informazioni in modo tale da soddisfare le necessità
dell'utente.
L'estrazione dell'informazione dalla base di dati è fatta in funzione ad un indicatore che
Pasquale Catalano 566/2323
Pagina 88 di 121
ci permette di fornire una percentuale della media di consumo del servizio dell'apparato
monitorato. In particolare le misure estratte faranno riferimento ad uno specifico arco
temporale (giorno attuale, giorno precedente).
Esempio chiarificatore di come sono strutturate le query:
select nome, avg(valore) as media, data
from (tabella apparato)
where (data=datacorrente)
group by nome
select nome, avg(valore) as media, data
from (tabella apparato)
where (data=datacorrente -1day)
group by nome
Dopo questa fase, si introducono i risultati dell'interrogazione effettuata all'interno di
una struttura dati di supporto al grafico. Successivamente si compiono azioni che
concedono la personalizzazione del grafico da mostrare come: etichette assi cartesiani,
legenda, unità di misura, colori.
La fase successiva sarà quella di generare il grafico e di creare la corrispondente
immagine con estensione .PNG, intitolata con il nome della categoria di appartenenza
dell'apparato. Il grafico utilizzato per tale rappresentazione sarà costituito da una lista
di barre(giorno attuale, giorno precedente) raggruppate per serie(nome dell'apparato).
Tutte le attività sopra descritte sono contenute nell'applicazione sviluppata
Applicazione.jar. Inoltre per essere mandata in esecuzione, bisogna invocare
l'applicazione con il nome della cartella a cui fa riferimento la categoria dell'apparato.
Anche per questa funzionalità è di fondamentale aiuto la struttura dati che viene
generata con la lettura del file delle corrispondenze, dando informazione sulle relazioni
Pasquale Catalano 566/2323
Pagina 89 di 121
delle tabelle del database.
Generati i file.PNG, è necessario farli visualizzare all'utente. Il lavoro di visualizzazione
viene affidato alle pagine HTML Index.html, Index1.html dove verranno richiamate le
immagini. Attraverso le regole di un CSS andremo a settare alcune proprietà che le
figure devono assumere. Richiamando l'url della pagina HTML in una portlet Iframe,
vengono introdotte le immagini nel portale e quindi osservabili dall'utente.
Figura 50: Funzionamento del sistema
Pasquale Catalano 566/2323
Pagina 90 di 121
6 Risultati Ottenuti
In questo capitolo andiamo a descrivere i risultati del sistema sviluppato, prodotti
dopo aver portato a termine l'operazione di popolamento della base di dati, presentati
attraverso la consultazione di un portale web.
In particolare, all'utente autorizzato del Data Center attraverso il portale deve avere
informazioni circa sui servizi delle macchine monitorate in modo tale da trarre delle
conclusioni immediate.
Dunque nel portale di riferimento del Data Center sono state introdotte due portlet
Iframe in cui il valore di ciascuna url è settato alla rispettiva pagina: Index.html e
Index1.html, ognuna contenente file.PNG rappresentanti i grafici. Si è deciso di
procedere con l'ausilio di due portlet sia per una scelta riguardante la logica di
visualizzazione dei dati all'interno del sito web, quindi per poter mostrare le
informazioni nel modo più chiaro possibile, sia per differenziare il contenuto
rappresentato in ciascuna pagina web. Infatti nella prima pagina web andiamo ad
inserire i file che vanno a costituire l'andamento delle misure assunte dai servizi
monitorati sulle apparecchiature, quali: Worker Node e Storage Element; nella seconda
invece vengono raccolti i file che raffigurano informazioni attribuite ai dispositivi di
rete.
I servizi attivati sui dispositivi monitorati e di seguito visualizzati dai grafici, sono quelli
riguardanti:
•
il check_load per i Worker Node
•
il check_disk per gli Storage Element
•
traffico_in/traffico_out per le apparecchiature di rete.
Come già precedentemente detto si è adottata una diversa rappresentazione
dell'informazione in funzione del tipo di dato da trattare, per garantire una maggiore
leggibilità dei dati.
Pasquale Catalano 566/2323
Pagina 91 di 121
Inoltre il contenuto all'interno delle portlet sarà aggiornato di ogni ora, in modo da
garantire una coerenza con gli aggiornamenti effettuati sulla base di dati.
Di seguito si illustra il contenuto informativo di ciascuna portlet.
Figura 51: Portlet con grafici degli apparati Worker Node, Storage Element
Da notare che in ciascun grafico ogni serie rappresentata, fa riferimento al periodo
temporale (giorno corrente, giorno precedente). Inoltre i valori assunti dalle etichette
Pasquale Catalano 566/2323
Pagina 92 di 121
sull'asse delle ascisse sono quelli riguardanti al nome_dns delle apparecchiature, mentre
sull'asse delle ordinate ci sono i valori assunti dai servizi monitorati. Per quanto riguarda
il servizio check_load abbiamo un valore che corrisponde alla percentuale di utilizzo,
mentre per il servizio check_disk si ha il numero di byte usufruiti.
I diagrammi visualizzati rispettano le caratteristiche fornite dalla libreria JFreeChart di
supporto all'applicazione.
Figura 52: Portlet con grafici degli apparati di rete
I due grafici sopra raffigurati rappresentano:
•
il primo la quantità di banda ,di input e di output, fornita dall'ente GARR al Data
Center
Pasquale Catalano 566/2323
Pagina 93 di 121
•
il secondo la quantità reale di banda che arriva al Data Center dopo aver
attraversato diversi dispositivi che vanno a costituire la rete di comunicazione
dell'informazione
Da notare che i dati rappresentati sono presi direttamente dalle interrogazioni effettuate
sugli archivi RRD associati ai dispositivi e inoltre la generazione e personalizzazione del
grafico avviene attraverso la funzione graph di RRDTool.
Nella visualizzazione dell'informazione si è deciso di mostrare il contenuto di un'intera
giornata, ma nonostante ciò, le immagini del grafico vengono aggiornate lo stesso a
specifici periodi temporali di un'ora.
In entrambi i grafici si denota che il traffico in input viene rappresentato mediante delle
aree colorate di verde, mentre per il traffico di output si adotta una semplice linea di
colore blu.
In conclusione si può asserire che i grafici ottenuti sono di aiuto all'utilizzatore del Data
Center, in quanto si presentano in modo tale da far capire con estrema chiarezza e
leggibilità le informazioni al consumatore.
Pasquale Catalano 566/2323
Pagina 94 di 121
7 Conclusioni
Il lavoro di tesi svolto presso il centro S.Co.P.E. mi ha permesso di raggiungere
determinate competenze sia nel campo dei sistemi di monitoraggio di reti, sia
nell'ambito dei portali e soprattutto degli Enterprise Open Portal.
Grazie al progetto sviluppato, è stato possibile realizzare un'applicazione che consente
di storicizzare i dati da un sistema di archiviazione, basato sulla strategia roun-robin, in
una base di dati che adopera il DBMS MySql, per gestire i dati in modo avanzato,
sottoponendoli ad operazioni orientate a rispecchiare in modo molto più specifico le
esigenze dell'utente.
Inoltre, è stato possibile integrare la rappresentazione di alcuni servizi attivi sulle
apparecchiature monitorate mediante una visualizzazione grafica, adoperando delle
portlet Iframe inserite opportunamente all'interno del portale del Data Center.
L'approccio adottato per la risoluzione dello sviluppo del lavoro, ha consentito ai
framework adoperati dal centro di ricerca, una maggiore usabilità e personalizzazione
dei dati monitorati, fornendogli delle funzionalità aggiuntive.
La visualizzazione dei grafici all'interno del portale ha permesso, inoltre, di ampliare le
caratteristiche del sistema consentendo una navigazione semplice e intuitiva tra i vari
apparati monitorati con la possibilità di visualizzare le informazioni circa su l'andamento
dello stato di un particolare dispositivo, garantendo al consumatore dei feedback sempre
in aggiornamento, grazie alle continue interrogazioni effettuate ai dispositivi per la
generazione del grafico a intervalli temporali di un'ora.
Da un'analisi fatta attentamente è sorto un aspetto da tenere in considerazione; quello
dovuto al fatto che, in caso di modifiche o aggiunte al gruppo di apparati monitorati, i
file di configurazione dovranno essere aggiornati o creati direttamente dall'utente.
Quindi per i successivi sviluppi sarebbe meglio ridurre il numero di operazioni da far
Pasquale Catalano 566/2323
Pagina 95 di 121
eseguire all'utente per garantire il corretto funzionamento dell'applicazione.
Facendo riferimento sempre ad una futura versione, un miglioramento potrebbe
riguardare una più accurata gestione dei grafici, consentendo di avere
maggiore
personalizzazione sulle informazioni da voler visualizzare, introducendo all'interno
dell'applicazione una interfaccia costituita da una form che andrà a contenere dati che
avranno il compito di filtro per il recupero delle informazioni dalla base di dati e per poi
essere visualizzate.
Pasquale Catalano 566/2323
Pagina 96 di 121
Appendice A
Di seguito andiamo a mostrare il codice relativo allo sviluppo del progetto
Applicazione.jar costituito dalle classi java: Database.java, Parse.java, Grafici.java,
Main.java.
Database.java:
package media;
import
import
import
import
import
com.mysql.jdbc.Connection;
com.mysql.jdbc.Statement;
java.sql.DriverManager;
java.sql.ResultSet;
java.sql.SQLException;
/*
*
* @author Pasquale Catalano
*/
/*
* Classe che gestisce la connessione al database MySql
* mediante il driver JDBC fornito da Java
*/
public class Database {
//Variabili per la connessione al database
static public String host="pc38.scope.unina.it";
static public String test="pc38";
static public String porta="3306";
static public String user="root";
static public String password="scope01";
static private Connection defaultConnection;
/*
* Restituisce la connessione di default al DB.
*/
Pasquale Catalano 566/2323
Pagina 97 di 121
static public Connection getDefaultConnection() throws
SQLException
{
//Se non è già presente una connessione, ristabilisce quella
di default.
if (defaultConnection==null || defaultConnection.isClosed())
defaultConnection=(Connection)
DriverManager.getConnection("jdbc:mysql://"+host+":"+porta+"/
"+test+"?user="+user+"&password="+password);
return defaultConnection;
}
/*
* Effettua una query e restituisce il primo valore
*/
static public int EseguiComandiModificaSQL(String query)
{
//Dichiarazione variabili
Connection con;
Statement st;
int risultato=0;
try
{
con=getDefaultConnection();
st=(Statement) con.createStatement();
risultato=st.executeUpdate(query);
}
catch (SQLException e)
{
System.out.println(e.getMessage());
}
return risultato;
}
//Effettura una query e restituisce il ResultSet
static public ResultSet EseguiComandoSelect(String query) {
Connection con;
Statement st;
ResultSet rs = null;
try {
con=getDefaultConnection();
Pasquale Catalano 566/2323
Pagina 98 di 121
st=(Statement) con.createStatement();
rs=st.executeQuery(query);
}
catch (SQLException e)
{
System.out.println(e.getMessage());
}
return rs;
}
/*
* Carica il driver JDBC.
*/
static
{
try
{
Class.forName("com.mysql.jdbc.Driver");
}
catch (Exception e)
{
System.out.println(e.getMessage());
}
}
}
Parse.java:
package media;
import
import
import
import
import
import
import
import
java.io.BufferedReader;
java.io.FileNotFoundException;
java.io.FileReader;
java.io.IOException;
java.sql.ResultSet;
java.sql.SQLException;
java.util.LinkedList;
java.util.TreeMap;
Pasquale Catalano 566/2323
Pagina 99 di 121
/*
*
* @author Pasquale Catalano
*/
/*
* Classe che gestisce il Parser dei file di testo
* ricevuti come input e inoltre carica in una struttura,
* le corrispondenze tra le tabelle del database
*/
public class Parse {
/*
* Metodo statico che riceve in input il nome del file di
* testo contenente le relazioni
* tra le tabelle del database, ne effettua la scansione e
* costruisce una struttura dati
* TreeMap costituita la LinkedList di stringhe
* Input: nome del file
* Output: Riferimento alla TreeMap
*/
public static TreeMap CaricaFile(String nomefile) throws
FileNotFoundException, IOException
{
//Dichiarazione variabili
FileReader r;
BufferedReader buf;
String riga=null;
String[] valori;
LinkedList<String> lista;
//Creazione di una TreeMap con chiave di tipo stringa a
cui viene associata una LinkedList di stringhe
TreeMap<String,LinkedList<String>> elenco= new
TreeMap<String,LinkedList<String>>();
//Apertura file di testo
r=new FileReader(nomefile);
buf = new BufferedReader(r);
//Lettura della prima riga
riga=buf.readLine();
// Affinchè il file contenga una riga
Pasquale Catalano 566/2323
Pagina 100 di 121
while( riga != null)
{
//Si esplode la riga rispetto al carattere":"
valori=riga.split(":");
//Si crea la LinkedList
lista=new LinkedList<String>();
//Si aggiungono i valori alla LinkedList
lista.add(valori[1]);
lista.add(valori[2]);
//Si aggiunge la LinkedList alla TreeMap con chiave
valori[0]
elenco.put(valori[0], lista);
riga=buf.readLine();
}
//Chiusura Stream file
r.close();
return elenco;
}
/*
* Metodo che esegue il Parser sul file dei dati contenente
* l'interrogzione dei file RRD,ne gestisce i valori letti,
* li coverte e l'inserisce nella specifica tabella del
* database
* Input: nome del file da esaminare, struttura delle
*
relazione tra le tabelle del database
* Output: Poplamento tabella del database
*/
public void InsertValori(String nomefile,TreeMap struttura)
throws FileNotFoundException, IOException, SQLException
{
//Dichiarazione variabili
FileReader r;
BufferedReader buf;
ResultSet rs;
String[] dato;
String inputLine,data,query;
long epoch;
double valore;
int id,id_entita,id_servizio;
LinkedList<String>tabelle = null;
Pasquale Catalano 566/2323
Pagina 101 di 121
//Apertura file di testo
r=new FileReader(nomefile);
buf = new BufferedReader(r);
//Si esplode il nome del file in modo tale da prelevare
il nome dell'apparcchiatura e del servizio monitorato
String[] elemento = nomefile.split(":");
//Se l'apparato è un Workernode
if (elemento[0].contains("workernode"))
//Si prendono le tabelle del database in relazione a
tale apparato
tabelle=(LinkedList<String>) struttura.get("wn");
//Se l'apparato è un StorageElement
else if (elemento[0].contains("storageelement"))
//Si prendono le tabelle del database in relazione a
tale apparato
tabelle=(LinkedList<String>) struttura.get("se");
//Se l'apparato è di Rete
else
//Si prendono le tabelle del database in relazione a
tale apparato
tabelle=(LinkedList<String>) struttura.get("re");
//Si esclude dalla lettura le prime due righe del file di
cui una vuota e una contente il nome del servizio
for(int i=0;i<=1;i++)
inputLine=buf.readLine();
inputLine=buf.readLine();
//Affinchè il file contenga una riga
while( inputLine != null)
{
//Si esplode la riga letta dal file rispetto al
carattere":"
dato=inputLine.split(":");
//Si converte la data dal formato UnixEpoch in un formato
Date
epoch=Long.parseLong(dato[0]);
data = new
java.text.SimpleDateFormat("yyyy/MM/dd").format(new
java.util.Date (epoch*1000));
Pasquale Catalano 566/2323
Pagina 102 di 121
dato[1]= dato[1].trim();
//Gestione dei valori che può assumere l'array dato[]
fatta eccezione del primo valore
//Se contiene stringhe tali da poter eseguire la
conversione in un double
if (!dato[1].matches("nan"))
{
//Conversione del valore da stringa a double
dato[1]=dato[1].replace(',','.');
valore=Double.parseDouble(dato[1]);
}
//Altrimenti se contiene la stringa nan assegno alla
variabile valore 0
else
valore=0.0;
//Si prepara la query per prelevare l'ultimo id inserito
nella tabella in modo rale da fare l'autoicremento
query="SELECT count(idm)+1 from "+tabelle.get(1);
//Si manda in esecuzione la query
rs=Database.EseguiComandoSelect(query);
rs.next();
//Si converte il risultato ottenuto dalla query in un
intero
id=Integer.parseInt(rs.getObject(1).toString());
//Si prepara la query per conoscere l'id associato
all'apparato
query="SELECT id from "+tabelle.get(0)+" where
nome='"+elemento[0]+"'";
//Si manda in esecuzione la query
rs=Database.EseguiComandoSelect(query);
rs.next();
//Si converte il risultato ottenuto dalla query in un
intero
id_entita=Integer.parseInt(rs.getObject(1).toString());
//Si prepara la query per conoscere l'id associato al
servizio
query="SELECT ids from servizio where
Pasquale Catalano 566/2323
Pagina 103 di 121
nomeservizio='"+elemento[1]+"'";
//Si manda in esecuzione la query
rs=Database.EseguiComandoSelect(query);
rs.next();
//Si converte il risultato ottenuto dalla query in un
intero
id_servizio=Integer.parseInt(rs.getObject(1).toString());
//Si prepara il comando Sql per inserire le informazioni
nel database
query="INSERT INTO "+tabelle.get(1)+" VALUES
("+id+","+id_entita+","+id_servizio+"
,'"+data+"',"+valore+")";
//Si manda in esecuzione il comando
Database.EseguiComandiModificaSQL(query);
//Si procede alla riga successiva del file
inputLine=buf.readLine();
}
//Chiusura Stream file
r.close();
}
}
Grafico.java:
package media;
import
import
import
import
import
import
import
import
import
import
import
import
java.awt.Color;
java.awt.GradientPaint;
java.io.File;
java.io.IOException;
java.sql.ResultSet;
java.sql.SQLException;
java.util.LinkedList;
java.util.TreeMap;
org.jfree.chart.ChartFactory;
org.jfree.chart.ChartUtilities;
org.jfree.chart.JFreeChart;
org.jfree.chart.axis.CategoryAxis;
Pasquale Catalano 566/2323
Pagina 104 di 121
import
import
import
import
import
import
org.jfree.chart.axis.CategoryLabelPositions;
org.jfree.chart.axis.NumberAxis;
org.jfree.chart.plot.CategoryPlot;
org.jfree.chart.plot.PlotOrientation;
org.jfree.chart.renderer.category.BarRenderer;
org.jfree.data.category.DefaultCategoryDataset;
/*
*
* @author Pasquale Catalano
*/
/*
* Classe che gestisce il prelievo dei dati dal database, li
* inseririsce nel Dataset del del grafico, inoltre genera
* l'immagine.PNG rappresentante l'andamento delle misure
* dei dispositivi monitorati
*/
public class Grafico {
/* Metodo che consente di popolare una struttura dati
* "Dataset" di appoggio al grafico.
* Input: nome apparecchiatura monitorata, struttura
*
contenente le corrispondenze delle tabelle del
*
database
* Output: Riferimento alla struttura dati del grafico
*/
public DefaultCategoryDataset createDataset(String nome,
TreeMap struttura) throws SQLException
{
//Dichiarazione delle variabili
DefaultCategoryDataset dataset=new
DefaultCategoryDataset();
String nservizio=null;
ResultSet rs = null;
LinkedList<String> tabelle = null;
SimpleDateFormat f;
String Datacorrente;
String[] valore;
int giorno;
String Dataprecedente;
Pasquale Catalano 566/2323
Pagina 105 di 121
//Se l'apparato è un WorkerNode
if ( nome.matches("workernode"))
//Si prendono le tabelle del database in relazione a
tale apparato
tabelle=(LinkedList<String>) struttura.get("wn");
//Se l'apparato è un StorageElement
else if (nome.matches("storageelement"))
//Si prendono le tabelle del database in relazione a
tale apparato
tabelle=(LinkedList<String>) struttura.get("se");
//Se l'apparato è di Rete
else
//Si prendono le tabelle del database in relazione a
tale apparato
tabelle=(LinkedList<String>) struttura.get("re");
//Si prepara e si manda in esecuzione la query per
conoscesere quali sono i servizi attivivati
sull'apparato
rs=Database.EseguiComandoSelect("select distinct
nomeservizio from"+tabelle.get(1)+" natural
join servizio");
rs.next();
//Si converte il risultato ottenuto dalla query in un
intero
nservizio=rs.getObject(1).toString();
//Gestione della data corrente
f = new SimpleDateFormat("yyyy/MM/dd");
Datacorrente=f.format(new Date());
//Gestione della data precedente a quella corrente
valore=Datacorrente.split("/");
giorno=Integer.parseInt(valore[2]);
giorno=giorno-1;
Dataprecedente=valore[0]+"/"+valore[1]+"/"+giorno.toString;
//Si prelevano dal database le informazioni riguardanti
il nome dell'apparato e media delle misura assunte dal
//servizo dell'apparato monitorato nel giorno corrente
Pasquale Catalano 566/2323
Pagina 106 di 121
rs=Database.EseguiComandoSelect("select nome, avg(valore)
as media, data from "+tabelle.get(0)+" w
natural join "+tabelle.get(1)+" natural join
servizio s where
s.nomeservizio='"+nservizio+"' and
data='"+Datacorrente+"' group by (w.nome)");
//Si scandisce il risultato dell'interrogazione
while (rs.next())
{
//Si inseriscono le informazioni del database nella
struttura del grafico
dataset.addValue(Double.parseDouble(rs.getObject(2).toSt
ring()),rs.getObject(3).toString(),
rs.getObject(1).toString());
}
//Si prelevano dal database le informazioni riguardanti
il nome dell'apparato e media delle misura assunte dal
//servizo dell'apparato monitorato nel precedente al
giorno corrente
rs=Database.EseguiComandoSelect("select nome, avg(valore)
as media, data from "+tabelle.get(0)+" w
natural join "+tabelle.get(1)+" natural join
servizio s where
s.nomeservizio='"+nservizio+"' and
data='"+Dataprecedente+"'group by (w.nome)");
//Si scandisce il risultato dell'interogazione
while (rs.next())
{
//Si inseriscono le informazioni del database nella
struttura del grafico
dataset.addValue(Double.parseDouble(rs.getObject(2).to
String()),rs.getObject(3).toString(),
rs.getObject(1).toString());
}
return dataset;
}
/* Metodo che consente di creare il grafico a barre e di
* visualizzarlo attraverso la generazione
Pasquale Catalano 566/2323
Pagina 107 di 121
* di un'immagine PNG.
* Input: nome apparecchiatura monitorata, struttura
*
contenente le corrispondenze delle tabelle del
*
database
* Output: Immagine.PNG
*/
public Grafico(String nome, TreeMap struttura) throws
IOException, SQLException
{
//Dichiarazioni delle variabili
String titolo = null,nomefile = null, legenda=null;
GradientPaint gp1 = null,gp0 = null;
DefaultCategoryDataset dataset=createDataset(nome,
struttura);
//Se l'apparato è un WorkerNode
if (nome.matches("workernode"))
{
//Si gestiscono le informazioni da plottare sul grafico
tipo: nome , legenda asse y, colori
titolo="Monitoragio Workernode";
nomefile="workernode" ;
legenda="Consumo (%)";
gp0 = new GradientPaint(
0.0f, 0.0f, Color.blue,
0.0f, 0.0f, new Color(0, 0, 64)
);
gp1 = new GradientPaint(
0.0f, 0.0f, Color.red,
0.0f, 0.0f, new Color(64, 0, 0)
);
}
//Se l'apparato è un WorkerNode
else
{
//Si gestiscono le informazioni da plottare sul grafico
tipo: nome , legenda asse y, colori
titolo="Monitoragio StorageElement";
nomefile="storageelement" ;
legenda="Consumo (Byte)";
gp0 = new GradientPaint(
Pasquale Catalano 566/2323
Pagina 108 di 121
0.0f, 0.0f, Color.orange,
0.0f, 0.0f, new
Color(Color.orange.getRed(),Color.orange.getGreen(),Color.oran
ge.getBlue())
);
gp1 = new GradientPaint(
0.0f, 0.0f, Color.blue,
0.0f, 0.0f, new
Color(Color.blue.getRed(),Color.blue.getGreen(),Color.blue.get
Blue())
);
}
//Creazione del Diagramma a Barre
JFreeChart chart = ChartFactory.createBarChart(
// Titolo del grafico
titolo,
// Etichetta asse ascisse
"",
// Etichetta asse ordinate
legenda,
// Dati del grfico
dataset,
//Orienntamento del grafico
PlotOrientation.VERTICAL,
true,
false,
false
);
//Si crea oggetto plot per effettuare la
personalizzazione el grafico
CategoryPlot plot = (CategoryPlot) chart.getPlot();
//Impostazioni caratteristiche del grafico
plot.setBackgroundPaint(Color.lightGray);
plot.setDomainGridlinePaint(Color.white);
plot.setDomainGridlinesVisible(true);
plot.setRangeGridlinePaint(Color.white);
Pasquale Catalano 566/2323
Pagina 109 di 121
final NumberAxis rangeAxis = (NumberAxis)
plot.getRangeAxis();
rangeAxis.setStandardTickUnits(NumberAxis.createIntege
rTickUnits());
// si disabilitano le bar outlines
BarRenderer renderer = (BarRenderer)
plot.getRenderer();
renderer.setDrawBarOutline(false);
// Impostazioni colori per le barre del grafico
renderer.setSeriesPaint(0, gp0);
renderer.setSeriesPaint(1, gp1);
//Gestione posizione etichette grafico
CategoryAxis domainAxis = plot.getDomainAxis();
domainAxis.setCategoryLabelPositions(
CategoryLabelPositions.createUpRotationLabelPositi
ons(Math.PI / 6.0)
);
//Esportazione del grafico in un'immagine PNG
ChartUtilities.saveChartAsPNG(new File(nomefile+".png"),
chart,2000,1000);
}
}
Main.java:
package media;
import
import
import
import
import
java.io.FileNotFoundException;
java.io.IOException;
java.sql.SQLException;
java.util.LinkedList;
java.util.TreeMap;
/*
*
* @author Pasquale Catalano
*/
/*
* Classe che gestisce il flusso delle chiamate ai vari
Pasquale Catalano 566/2323
Pagina 110 di 121
* moduli dell'applicazione
*/
public class Main {
/*
* Metodo che prende in input il nome del file su cui
* eseguire il Parser
*/
public static void main(String[] args) throws
FileNotFoundException, IOException, SQLException
{
//Dichiarazione variabili
TreeMap<String,LinkedList<String>> struttura;
struttura=Parse.CaricaFile("Corrispondenze.txt");
if (args[0].contains(“:”))
{
Parse file=new Parse();
file.InsertValori(args[0],struttura);
}
else
{
Grafico chart=new Grafico (args[0], struttura);
}
}
}
Pasquale Catalano 566/2323
Pagina 111 di 121
Appendice B
Nella presente appendice si mostrano i contenuti che vanno a realizzare gli script di shell
e la pagina Html necessari per il funzionamento dell'applicazione quali: Manager.sh e
Grafici.sh e Index.html. Il primo contiene informazioni riguardanti la gestione dell'intera
applicazione; nel secondo sono contenuti i comandi di RRDTool per la generazione del
grafico; nella pagina Html sono inseriti contenuti che mostrano i grafici ottenuti sia dal
progetto java sia dai comandi di RRDTool, di ausilio alla portlet Iframe.
Manager.sh:
#!/bin/bash
# Script che effettua la gestione dell'applicazione
eseguendo su ciascun
# dispositivo l'interrogazione al file.RRD e chiama
l'applicazione per il
# popolamento del database. Inoltre effettua chiamate per
la visualizzazione
# dei grafici degli apparati monitorati
riga=$(cat $1 | awk ' (NR >1) {print $0}')
for i in $riga
do
nome=$(echo $i| awk -F ":" '{print $1}')
servizio=$(echo $i| awk -F ":" '{print $2}')
rrd=$(echo $i| awk -F ":" '{print $3}')
nomecartella=$(echo $1 | sed s/'_'/''/g)
if [ ! -d "/var/www/html/10-12/$nomecartella" ]
then
mkdir $nomecartella
fi
cd
/var/www/html/10-12/$nomecartella
rrdtool fetch /var/lib/centreon/metrics/$rrd AVERAGE -s
Pasquale Catalano 566/2323
Pagina 112 di 121
end-1h -e $(date +%s) >$nome:$servizio
java -jar /var/www/html/10-12/Media/dist/Applicazione.jar
$nome:$servizio
done
cd
/var/www/html/10-12/$nomecartella
java -jar /var/www/html/10-12/Media/dist/Applicazione.jar
$nomecartella
./Grafici.sh
Grafici.sh:
#!/bin/bash
# Comando di shell che attraverso la chiamata della
funzione Graph di RRDTool
# genera il file.PNG rappresentante il grafico del
traffico di input e output
# fornito al Data Center dal GARR
data=$(date +%s)
/usr/bin/rrdtool graph - \
--imgformat=PNG \
--start=-86400 \
--end=-300 \
--title='Quantità di banda fornita dal GARR' \
--rigid \
--base=1000 \
--height=120 \
--width=600 \
--alt-autoscale-max \
--lower-limit=0 \
--vertical-label='bits per second' \
--slope-mode \
--font TITLE:12: \
--font AXIS:8: \
Pasquale Catalano 566/2323
Pagina 113 di 121
--font LEGEND:10: \
--font UNIT:8: \
DEF:a="/var/www/cacti/rra/routeratlas_traffic_in_81.rrd":traffic_in:AVERAGE:start='end1d':end=$data \
DEF:b="/var/www/cacti/rra/routeratlas_traffic_in_81.rrd":traffic_out:AVERAGE:start='end1d':end=$data \
CDEF:cdefa=a,8,* \
CDEF:cdefe=b,8,* \
AREA:cdefa#00CF00FF:"Inbound" \
GPRINT:cdefa:LAST:" Current\:%8.2lf %s" \
GPRINT:cdefa:AVERAGE:"Average\:%8.2lf %s" \
GPRINT:cdefa:MAX:"Maximum\:%8.2lf %s\n" \
LINE1:cdefe#002A97FF:"Outbound" \
GPRINT:cdefe:LAST:"Current\:%8.2lf %s" \
GPRINT:cdefe:AVERAGE:"Average\:%8.2lf %s" \
GPRINT:cdefe:MAX:"Maximum\:%8.2lf %s\n" > Grafico.png
# Comando di shell che attraverso la chiamata della
funzione Graph di RRDTool
# genera il file.PNG rappresentante il grafico del
traffico reale che il
# Data Center riceve
/usr/bin/rrdtool graph - \
--imgformat=PNG \
--start=1299186947 \
--end=1299273047 \
--title='Quantità di banda fornita al Data Center' \
--rigid \
--base=1000 \
--height=120 \
--width=600 \
--alt-autoscale-max \
--lower-limit=0 \
COMMENT:"From 2011/03/03 22\:15\:47 To 2011/03/04
22\:10\:47\c" \
COMMENT:" \n" \
--vertical-label='bits per second' \
--slope-mode \
--font TITLE:12: \
--font AXIS:8: \
--font LEGEND:10: \
Pasquale Catalano 566/2323
Pagina 114 di 121
--font UNIT:8: \
DEF:a="/var/www/cacti/rra/sw3comatlas02_traffic_in_35.rrd":traffic_in:AVERAGE:start='end1d':end=$data \
DEF:b="/var/www/cacti/rra/sw3comatlas02_traffic_in_35.rrd":traffic_out:AVERAGE:start='end1d':end=$data \
CDEF:cdefa=a,8,* \
CDEF:cdeff=b,8,* \
AREA:cdefa#00CF00FF:"Inbound" \
GPRINT:cdefa:LAST:" Current\:%8.2lf %s" \
GPRINT:cdefa:AVERAGE:"Average\:%8.2lf %s" \
GPRINT:cdefa:MAX:"Maximum\:%8.2lf %s\n" \
COMMENT:"Total In\: 1.51 TB\n" \
LINE1:cdeff#002A97FF:"Outbound" \
GPRINT:cdeff:LAST:"Current\:%8.2lf %s" \
GPRINT:cdeff:AVERAGE:"Average\:%8.2lf %s" \
GPRINT:cdeff:MAX:"Maximum\:%8.2lf %s\n" \
COMMENT:"Total Out\: 487.54 GB\n" > Grafico1.png
Index.html:
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=windows1250">
<meta name="generator" content="PSPad editor, www.pspad.com">
<title>Visualizzazione dei Grafici</title>
<style type="text/css">
#img-background{
top: 0px;
left: 0px;
width: 70%;
z-index: 100;
}
</style>
</head>
<body>
<img src="/var/www/html/10-12/workernode/workernode.png" id="imgbackground" />
<br>
<img src="/var/www/html/10-12/storageelement/storageelement.png"
id="img-background"/>
</body>
</html>
Pasquale Catalano 566/2323
Pagina 115 di 121
Index1.html:
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=windows-1250">
<meta name="generator" content="PSPad editor, www.pspad.com">
<title>Visualizzazione dei Grafici</title>
<style type="text/css">
#img-background{
top: 0px;
left: 0px;
width: 70%;
z-index: 100;
}
</style>
</head>
<body>
<img src="/var/www/html/10-12/Grafico.png" id="img-background" />
<br>
<img src="/var/www/html/10-12/Grafico1.png" id="img-background"/>
</body>
</html>
Pasquale Catalano 566/2323
Pagina 116 di 121
Appendice C
Nella successiva figura si mostra il contenuto del crontab della macchina su cui
l'applicazione viene eseguita:
CronTab
Pasquale Catalano 566/2323
Pagina 117 di 121
Sitografia
1. Cacti
http://www.cacti.net/
2. RRDTool
http://oss.oetiker.ch/rrdtool
3. MySql
http://mysql.it/
4. Liferay
http://www.liferay.com/
5. Community Liferay
http://www.liferay.com/community
6. Tier2-Napoli
http://tier2.na.infn.it/
7. Java
http://www.java.sun.com/
8. HTML
http://www.html.it/
9. Nagios
http://www.nagios.org/
10. Site Status Board
http://dashb-ssb-devel.cern.ch/dashboard/
Pasquale Catalano 566/2323
Pagina 118 di 121
11. Job Monitoring
http://dashboard10.cern.ch/dashboard/request.py/jobsummary
12. JFreeChart
http://www.jfree.org/jfreechart/
Pasquale Catalano 566/2323
Pagina 119 di 121
Bibliografia
1. I. Sommerville
Ingegneria del Software
Pearson
2. A. S. Tanenbaum
Reti di Calcolatori
Apogeo
3. P. Sarang
Practical-Liferay
Apress
4. R. A. Elmasri, S. B. Navathe
Sistemi di Basi di Dati, Fondamenti
Pearson
5. Melir Page-Jones
Progettazione a Oggetti con UML
Apogeo
6. C. S. Horstmann, G. Cornell
Core Java 2 Volume I – Fondamenti
Pearson
7. C. S. Horstmann, G. Cornell
Core Java 2 Volume II – Funzioni Avanzate
Pearson
Pasquale Catalano 566/2323
Pagina 120 di 121
8. P. Dobois
MySql
Apogeo
9. Slide di Sargsyan Laura, Convegno CERN luglio 2010
10. Slide di Carlos Borrego, Convegno CERN luglio 2010
11. Slide di Alessandra Doria, Atlas Calcolo 2003
Pasquale Catalano 566/2323
Pagina 121 di 121
