.Implementazione del Prototipo In questa sezione andremo ad analizzare e descrivere dettagliatamente la realizzazione di un prototipo per la visualizzazione del Documento sull’Architettura OpenDLib “Scholnet

(1)

4

.

Implementazione del Prototipo

In questa sezione andremo ad analizzare e descrivere dettagliatamente la realizzazione di un prototipo per la visualizzazione del Documento sull’Architettura OpenDLib “Scholnet”, sulla base delle considerazioni fatte fin’ora.

4.1 Struttura fisica del servizio

Un Servizio di OpenDLib è completamente implementato in PERL. L’istanza del Web Server Apache tramite il “mod_perl” carica il modulo relativo allo specifico servizio associandolo ad un URL.

Per il Servizio <S00>, ad esempio, tutti i moduli relativi ad esso devono essere posti in un “path” specifico, la cui “Home Directory” ha il nome del Servizio stesso.

All’interno di tale directory, deve essere presente un “package” fondamentale, denominato <S00>Service.pm.

Questi definisce l’intera struttura del Servizio, ed è suddiviso in varie sezioni. Una prima sezione, identifica il nome del package, la versione e gli import necessari al funzionamento del Servizio stesso, ovvero package di default e package personalizzati che implementano specifiche funzionalità del Servizio. Ne riportiamo un esempio di seguito:

package UIService;

use5.008;

use strict;

use warnings;

useopen OUT => ':utf8';

use Embperl; use SessionManager; use LoginManager; use QueryDispatcher; use BrowseDispatcher; use DocumentOverview;

(2)

require Exporter;

our @ISA = qw(Exporter);

our $VERSION = '0.01';

Di fondamentale importanza sono gli import dei due file di inizializzazione del Servizio <S00>_init.pl e <S00>_protocol.pl, anch’essi obbligatori, definiscono tutti i parametri di configurazione e i descrittori dei Verbi oltre che ad invocare alcuni metodi degli altri Servizi di OpenDLib necessari alla preparazione del Servizio stesso. Ne analizzeremo la struttura più avanti.

Una seconda sezione non meno importante definisce tutti i Verbi del Servizio, visti come “metodi” del package. Taluni sono obbligatori, imposti dalla semantica di OpenDLib ed altri sono specifici del Servizio.

Ne riportiamo di seguito un esempio:

sub new { # MANDATORY my $invocant = shift;

my $class = ref($invocant) || $invocant; eval {require "@{[CONFIG_FILE]}"; } ; if ($@) {

#&UIUtils::UILog(ERROR, __FILE__ .' '. __LINE__ .' Failed to execute init file: ' . $@ .' ' .$!); die $@;

}

my $self = {}; bless ($self, $class);

$self->{data_dir} = $UIConfig::service_data_directory; &UIUtils::UILog('Service started');

return $self; }

sub DESTROY {

# MANDATORY: class destructor my $self = shift;

}

sub ODL_LoadProtocol {

# MANDATORY: load the service protocol my $self = shift;

unless (defined $self->{protocol_loaded}) { if (! do "@{[PROTOCOL_FILE]}" ) {

&UIUtils::UILog(ERROR, __FILE__ .' '. __LINE__ .' Failed to load UI protocol'); return 0; } $self->{protocol_loaded} = 1; &UIUtils::UILog('Protocol loaded'); } 1; } sub ODL_GetIdentifyInfo {

# MANDATORY (if ODL_Identify is defined): used by openlib::server_identify_new_core sub to implement a generic Identify verb return $UIConfig::identity_information;

(3)

sub ODL_Identify { my $self = shift;

my ($optional, $Context) = @_;

&UIUtils::UILog("HTTP Request --> $Context->{'url'}"); &openlib::server_identify_new(@_);

}

sub ODL_ListVerbs { my $self = shift;

my ($optional, $Context) = @_;

&UIUtils::UILog("HTTP Request --> $Context->{'url'}"); &openlib::list_verbs(@_);

}

sub ODL_DescribeVerb { my $self = shift;

my ($verb, $optional, $Context) = @_;

&UIUtils::UILog("HTTP Request --> $Context->{'url'}/$verb"); &openlib::describe_verb(@_);

}

sub ODL_ShowHome {

# home page of ODL user interface my $self = shift;

my ($optional, $Context) = @_; my $outputfile = POSIX::tmpnam();

&UIUtils::UILog("HTTP Request --> $Context->{'url'}"); my $session = new SessionManager();

if ($Context->{'remote_host'} ne '146.48.85.203fdfd' ) { &UIUtils::UILog('Create a new session: ' . $session->getID()); Embperl::Execute({ inputfile => $UIConfig::source_dir .'/epls/main.epl',

#input => \$src,

param => [$self, $session], package => __PACKAGE__, outputfile => $outputfile }); } else {

Embperl::Execute({ inputfile => $UIConfig::source_dir .'/epls/lino.epl', #input => \$src,

param => [$self, $session], package => __PACKAGE__, outputfile => $outputfile }); }

$session->save();

&openlib::xmit_file ($outputfile, 'text/html', 1); unlink $outputfile;

return 0; }

sub ODL_Load { my $self = shift;

my ($resource, $session_id, $optional, $Context) = @_; &UIUtils::UILog("HTTP Request --> $Context->{'url'}"); &UIUtils::UILog("Load session: $session_id");

&UIUtils::UILog("param $_ -> $optional->{$_}") foreach (keys %{$optional}); my $session = new SessionManager($session_id);

my $outputfile = POSIX::tmpnam();

Embperl::Execute({ inputfile => $UIConfig::source_dir .'/epls/' .$resource .'.epl', options => 16,

param => [$self, $session, $optional], package => __PACKAGE__, outputfile => $outputfile }); $session->save();

(4)

Il file <S00>_protocol.pl definisce i descrittori e le versioni dei Verbi del Servizio, in accordo al protocollo di OpenDLib:

use strict;

my $info = {'name' => 'UI', 'software-version' => '1.0', 'type' => 'object',

'description' => 'Implements OpenDLib user interface' };

$openlib::Dispatch->Register_Service_Class ($info); #verb: Identify

my $ref_idenv = {'service-class' => 'UI', 'verb-class' => 'Identify',

'description' => 'User Interface Identification', 'versions' => # used to map remote requests

{ '1.0' => { 'request' => '/OLP/UI/1.0/Identify', 'service' => 'UI', 'verb' => 'Identify', 'version' => '1.0', 'returns' => 'XML', 'handler' => 'ODL_Identify' } } }; $openlib::Dispatch->Register ($ref_idenv); …

Mentre il dile <S00>_init.pl definisce le variabili di configurazione, il descrittore di identificazione del Servizio ed invoca l’esecuzione del file do_init.pl, il quale provvede a completare l’inizializzazione del Servizio eseguendo operazioni specifiche per lo stesso. Ad esempio l’UI Service necessità del caricamento del Reporitory, delle Authorities e dei metodi di ricerca oltre a varie altre specifiche configurazioni: package UIConfig; use 5.008; use strict; #use warnings; use IO::File; # Basic UI configuration $UIConfig::xml_meta_data_directory = "$openlib::data_dir/UI"; $UIConfig::source_dir = "$openlib::source_dir/Services/UI"; $UIConfig::service_data_directory = "$UIConfig::source_dir/Data"; $UIConfig::temp_directory = "$openlib::temp_directory/UI"; $UIConfig::log_file = "$openlib::log_directory/UI.log"; $UIConfig::identity_information = {

'service_name' => 'Experimental ODL UI by manuele', 'textual_description' => '',

(5)

'admin_email' => 'simi@iei.pi.cnr.it',

'submission_procedure_desc'=> 'Submission procedure is not supported by this service',

'submission_olp_url' => '',

'harvest_information_desc' => 'No information is available', 'harvest_olp_url' => '',

'use_restrictions' => 'Terms and conditions are...',

'content_info_file' => "$UIConfig::service_data_directory/identify_config.tmpl", 'xml_meta_data_directory' => $UIConfig::xml_meta_data_directory }; # Enable/Disable (1/0) UI debugging $UIConfig::EnableDebug = 1; # UI region $UIConfig::region = 'EUR';

# default number of documents returned for each page results $UIConfig::default_top_docs = 10;

# default number of documents returned by a browse search $UIConfig::default_browse_docs = 100;

require 'UI_utilities_subs.pl'; require 'UI_tasks.pl';

-e "$UIConfig::source_dir/do_init.pl" && do "$UIConfig::source_dir/do_init.pl" ;

package UIConfig; use 5.008; use strict; #use warnings; use IO::File; use SearchData; use BrowseData;

########global variables section############## $UIConfig::log_fh; # log file handle

$UIConfig::sessions_dir = $UIConfig::temp_directory.'/sessions'; #used to store user sessions

$UIConfig::list_collections_file = $UIConfig::xml_meta_data_directory .'/ListCollections.xml'; #store the results of downloadCollections tasks

$UIConfig::search_methods_file = $UIConfig::xml_meta_data_directory .'/ListSearchMethods.xml'; #store the results of downloadSearchsMethods tasks

$UIConfig::browse_files_prefix = $UIConfig::xml_meta_data_directory .'/BrowsableFields'; #store the results of downloadSearchsMethods tasks

$UIConfig::collections = {};

#########end of global variables section #####

…

#load informations from meta service

&openlib::loadMetaContainer($UIConfig::region, 'networked', \@UIConfig::loadParam); #set classes to load in the ListAuthorities v1.1 verb and load them

$openlib::Authorities2->{$UIConfig::region}->setClasses( [ 'repository' ] ); $openlib::Authorities2->{$UIConfig::region}->loadClasses();

#create two classes manager for search and browse data

$UIConfig::search_data = new SearchData ($UIConfig::search_methods_file);

(6)

Una volta definiti questi File standard, il Servizio è completamente configurato e pronto per essere eseguito. Per arricchirlo di nuove funzionalità bisogna definire nuovi Verbi, se necessario, ovvero definire nuovi sotto-package da caricare come moduli del Servizio (vedi sezione 1 del file <S00>Service.pm).

(7)

4.2 Dettaglio di realizzazione per la visualizzazione del documento

4.2.1 Overview

La visualizzazione del documento è stata implementata come un modulo dell’UI Service di OpenDLib.

Nello specifico tale Servizio adotta un particolare metodo per caricare le schermate dell’Interfaccia definito come “Load”.

Suddetto metodo ha come argomento fisso il nome della schermata da caricare e come argomenti opzionali i parametri da passare alla pagina:

<?xml version="1.0" encoding="UTF-8" ?>

<description>Execute the appropriate UI function</description> <versions>

<fixed>

</arguments>

</versions> </Verb> </DescribeVerb>

(8)

Come si può notare dalla definizione del metodo descritta nel file UIService.pm

sub ODL_Load { my $self = shift;

my ($resource, $session_id, $optional, $Context) = @_; &UIUtils::UILog("HTTP Request --> $Context->{'url'}"); &UIUtils::UILog("Load session: $session_id");

&UIUtils::UILog("param $_ -> $optional->{$_}") foreach (keys %{$optional}); my $session = new SessionManager($session_id);

my $outputfile = POSIX::tmpnam();

Embperl::Execute({ inputfile => $UIConfig::source_dir .'/epls/' .$resource .'.epl', options => 16,

param => [$self, $session, $optional], package => __PACKAGE__, outputfile => $outputfile });

$session->save();

&openlib::xmit_file ($outputfile, 'text/html', 1); unlink $outputfile;

return 0; }

tale metodo carica per mezzo del modulo “Embperl” (Embedded Perl) di Apache la relativa pagina “.epl” nella directory “/epls”.

In conformità a tale struttura, la visualizzazione del documento è composta da un modulo principale definito come /epls/document.epl.

Tale modulo utilizza dei particolari metodi di una classe costruita specificatamente per gestire questa particolare funzionalità dell’UI Service definita nel package DocumentOverview.pm ed è composto da altri due moduli:

1. manifestations.epl necessario per visualizzare la lista delle manifestazioni di una particolare vista del documento

2. manifestation.epl e manifestation_multiple.epl necessari per il rendering del dettaglio della specifica manifestazione rispettivamente di tipo single, ovvero composta da un solo tipo di dato multimediale (xml, text, html, pdf, wmf ...), o multiple, ovvero composta da un insieme di dati multimediali (jpeg, png, tiff, ...).

La mggior parte della logica è eseguita dalla classe DocumentOverview.pm. La classe necessita di due parametri, l’handler e la version del documento. Il costruttore si occupa di interrogare i Servizi preposti di OpenDLib onde ricavare tutte le informazioni riguardanti il documento, in particolare dapprima ricerca fra la lista delle Authorities inizializzate qual’è il Repository Server adatto, ricavandone l’indirizzo e la porta, ed in seguito nè invoca il metodo ‘Disseminate’ per scaricare il descrittore di struttura del Documento.

(9)

sub loadData {

my $self = shift; $self->{handle} = shift; $self->{version} = shift;

#load the content of Repository's Structure in a structure #to use at preview time

&UIUtils::UILog('DocumentOverview::loadData() start');

&UIUtils::UILog('handle: ' . $self->{handle} . ' - version: ' . $self->{version}); my $document_overview_file = POSIX::tmpnam();

#download Document by Handler & Version # calling the verb Structure of the Repository Service

&UIUtils::UILog('...downloading the Document calling the Structure verb of the Repository Service'); #get Authority from Handle and all Repository Hosts

my @auth_list = split(/\//,$self->{handle});

#my $hosts_list = $openlib::Authorities2->{$UIConfig::region}->getHostsFromAuthsAndService('service'=> 'repository', 'authorities'=> [$auth_list[0]]);

my $hosts_list = $openlib::Authorities2->{$UIConfig::region}->getHostsFromClasses( 'service'=>'repository', 'authorities'=> [$auth_list[0]]);

#find the Service host and port my ($best_host, $best_port); if (ref($hosts_list->{$auth_list[0]})) {

$best_host = $hosts_list->{$auth_list[0]}[0]{host}; $best_port = $hosts_list->{$auth_list[0]}[0]{port}; } else {

&UIUtils::UILog(ERROR, __FILE__ .' '. __LINE__ . ' unable to find a repository for ' . $auth_list[0] ); }

&UIUtils::UILog( '__DEBUG__ host '. $best_host . ' port '.$best_port ); my $docStruct = new OLPXMLLoader();

$self->{baseURL} = 'http://' . $best_host . ':' . $best_port . '/OLP/Repository/1.0/Disseminate/'; $self->{baseHOST} = $best_host; $self->{basePORT} = $best_port; $docStruct->setHostAndPort($best_host, $best_port); $docStruct->setService('Repository'); $docStruct->setVerb('Structure'); $docStruct->setVersion('1.0'); $docStruct->setFixedParameters($self->{handle}); $docStruct->setOptionalParameters('version' => $self->{version}); $docStruct->setProperties('no_father'=>'true', 'no_XMLTree'=>'true'); $docStruct->setLocalPath($document_overview_file); $docStruct->refresh;

(10)

Con il DOM di Struttura la classe è in grado di costruire una Hash Table contenente tutto l’albero del documento.

#load XML DOM

my $parser = XML::LibXML->new(); my $doc;

eval { $doc = $parser->parse_file($document_overview_file); }; if ( ($@) || (!ref($doc)) ) {

&UIUtils::UILog(ERROR, __FILE__ .' '. __LINE__ . ' unable to parse ' . $document_overview_file ." $@"); return 0;

}

#get the document root

my $root = $doc->getDocumentElement(); my @rootNodes = $root->findnodes('document'); my $docElement = $rootNodes[0]; $self->{messNum} = 0; $self->{document} = (); $self->{viewd} = (); $self->{manifestation} = (); $self->{document_views} = (); $self->{view_views} = (); $self->{view_manifestations} = ();

#my @tmpArray = ($self->{handle},$self->{version}); #$self->{document}{$self->{messNum}} = \@tmpArray;

push @{$self->{document}{$self->{messNum}}},$self->{handle},$self->{version};

&UIUtils::UILog('__DEBUG__ ' . $self->{document}{$self->{messNum}}[0] . ' ' . $self->{document}{$self->{messNum}}[1]); &UIUtils::UILog('DocumentOverview::buildViewDB -> Start...');

foreach my $view_node ($docElement->childNodes()) { buildViewDB($self,$view_node,0);

}

&UIUtils::UILog('DocumentOverview::buildViewDB -> ...End');

$self->{data_structure} = {"document" => $self->{document}, "viewd" => $self->{viewd}, "manifestation" => $self->{manifestation}, "document_views" => >{document_views}, "view_views" => >{view_views}, "view_manifestations" => $self->{view_manifestations}};

return ($docElement); }

La Hash Table è strutturata come segue:

CHIAVE VALORE DESCRIZIONE

document handle, version

viewd @array Contiene tutte le viste del documento manifestation @array Contiene tutte le manifestazioni del

documento

document_views @hash Contiene gli indici delle viste della root view_views @hash Contiene gli indici delle sottoviste

relative alla specifica vista

view_manifestations @hash Contiene gli indici delle manifestazioni relative alla specifica vista

(11)

Inoltre vi sono altri attributi della classe che consentono di reperire l’URL, l’Host e la porta del Repository selezionato.

Pertanto in base a quanto detto fin’ora, specificando “document” come argomento fisso del metodo Load dell’UI Service e l’handler e la version del documento prescelto come argomenti opzionali, il modulo document.epl verrà caricato. Questi creerà un’istanza della classe DocumentOverview.pm passando al costruttore i due valori handler e version, e recupererà l’Hash strutturale del documento per mezzo del metodo getData().

L’Hash consente di costruire globalmente tutto l’albero del documento, e ciò viene fatto per mezzo di funzioni ricorsive. In realtà il modulo document.epl si occupa solo della costruzione dell’albero delle viste del documento mentre si avvale del modulo manifestations.epl per la costruzione dell’albero delle manifestazioni.

L’uso di DHTML consente la gestione dinamica degli alberi su un Browser internet qualsiasi e consente anche di richiamare il ramo delle manifestazioni relativo alla specifica vista selezionata.

Il metodo getBaseURL() della classe consente al modulo document.epl di conoscere l’indirizzo esatto del Repository del documento, necessario per recuperare il “body” della specifica manifestazione slezionata dall’Utente.

use DocumentOverview; use XML::LibXML;

$docStruct = new DocumentOverview ($param[2]->{handle}, $param[2]->{version}); #disable output auto-escape

$escmode = 0;

use constant color_1 => '#DAE7D1'; use constant color_2 => '';

$resString = ''; my @bgColor = ();

$docElement = $docStruct->getDocElem();

($baseURL,$baseHOST,$basePORT) = $docStruct->getBaseURL(); $data = $docStruct->getData();

(12)

4.2.2 “DocumentOverview.pm” DocumentOverview handle version messNum baseURL baseHOST basePORT document viewd manifestation document_views view_views view_manifestations data_struct doc_elem new() loadData() getDocElem() getBaseURL() getData() buildViewDB()

La classe si occupa di recuperare il Repository Server del documento in base alle Authorities specificate grazie ai Servizi di OpenDLib, salvare l’indirizzo così ottenuto ed infine popolare le Hash Table in memoria a partire dal descrittore di struttura del Documento.

Un esempio tipico di file di struttura per un Documento OpenDLib è il seguente:

<document handle="scholnet.test/1999-isl-21" version="1">

<view ord="2" min="" max="" name="paper" type="body" delivering="no" downloading="yes" transcoding="yes" display=""> <manifestation content-type="application/pdf" name="pdf" type="outside"

uri="http://www.ics.forth.gr/isl/publications/paperlink/MAISTWR.pdf" display=""/> </view>

</document> </Structure>

(13)

In questo esempio molto semplice è possibile osservare un descrittore di struttura di un Documento.

Come si piò notare il nodo principale “document” contiene n nodi “view” ed ognuno di questi può contenere m nodi “view” e p nodi “manifestation”.

Nell’esempio abbiamo una vista denominata “bibdata” di tipo “metadata” accessibile anche ad utenti non autenticati composta da tre diverse manifestazioni “dc”, “dcq” e “olms”, e da una seconda vista denominata “paper” costituita da una manifestazione di tipo “pdf” che riferisce ad un file Acrobat esterno, del quale viene fornito l’URI assoluto.

Come si può notare nella manifestazione della seconda vista, la risorsa ad essa associata è per l’appunto esterna. Questo vale anche per le viste, nel senso che esistono delle particolari viste che possono riferire ad altri documenti. In questo caso viene fornito l’URI della risorsa o l’handler del documento riferito.

Il costruttore di classe si occupa di recuperare tutte le strutture anche di documenti eventualmente correlati e creare una struttura in memoria a liste in cui tutti i path relativi sono trasformati in path assoluti alla risorsa associata per la specifica vista o manifestazione, in quanto tali risorse possono risiedere su Repositories diversi del sistema. Nelle liste vengono memorizzati anche tutti gli attributi delle viste e manifestazioni quali il nome, l’ordinamento, eventuali attributi di accesso e così via.

(14)

La struttura principale è una Hash Table così composta:

data_structure {

“document” => Array contenente tutte le informazioni generali relative al documento, quali ad esempio l’handler e la versione.

“viewd” => Array contenente tutte le Viste del documento. Ogni Vista è associata ad un ID calcolato dalla classe ed è rappresentata da un Array di dimensione fissa contenente tutti gli attributi della Vista quali name, ordinamento, display, size, uri, delivering, downloading, transcoding.

“manifestation” => Array contenente tutte le Manifestazioni del documento. Ogni Manifestazione è associata ad un ID calcolato dalla classe ed è rappresentata da un Array di dimensione fissa contenente tutti gli attributi della Manifestazione quali name, display, type, size, uri, multiple, min, max.

“document_views” => Array contenente tutti gli ID delle viste che siano elementi figli diretti del nodo principale “document”, ovvero che non siano sotto-viste di viste ma viste del documento stesso.

“view_views” => Hash che ha come chiavi gli ID di tutte le viste e sotto-viste del documento e come valore un Array contenente gli ID di tutte le sotto-viste della vista in chiave.

“view_manifestations” => Hash che ha come chiavi gli ID di tutte le viste e sotto-viste del documento e come valore un Array contenente gli ID di tutte le manifestazioni della vista in chiave.

(15)

4.2.3 Esempio di funzionamento

Selezionando un documento da visualizzare dalla lista del resultset viene caricata una finestra di pop-up contenente una pagina in grado di mostrare all’Utente la struttura globale del Documento tramite un’Interfaccia navigabile molto intuitiva e chiara strutturata ad albero.

Nella prima schermata è sempre visualizzabile l’handler e la versione del documento rappresentato. L’albero di struttura ha come rami tutte le viste e le sotto-viste del documento e come foglie le manifestazioni delle viste stesse. A destra vengono in ogni istante mostrati i dettagli della vista o manifestazione selezionata, ovvero quella evidenziata in celeste.

(16)

Le manifestazioni possono essere di molti tipi. Il primo importante distinguo è fra manifestazioni singole ovvero rappresentate da una singola entità e manifestazioni multiple ovvero rappresentate da un insieme di entità la cui dimensione non è nota a priori.

Le manifestazioni singole possono essere di tipo testuale o html, in tal caso esse verranno rappresentate come tali senza alcuna trasformazione ulteriore.

Le manifestazioni rappresentanti i metadati di una vista o manifestazioni di tipo XM in generale vengono trasoformate in HTML da uno stylesheet XSL prima di essere rappresentate.

<dc:cretor>Abiteboul, S.; Hull, R.</dc:creator> <dc:date>1987</dc:date>

<dc:language>en</dc:language> <dc:language>fr</dc:language>

<dc:title><![CDATA[Restructuring hierarchical database objects]]></dc:title> …

</dc> </manifestation>

(17)

Altre manifestazioni di tipo JPEG, GIF, TIFF, PDF, SWF ecc… se nel browser è installato il plug-in corretto per la loro visualizzazione vengono rappresentate direttamente all’interno della finestra di pop-up, altrimenti vengono scaricate come file nel computer locale.

Le manifestazioni multiple vengono rappresentate tramite una particolare interfaccia che ne calcola il numero delle parti e ne consente o lo scaricamento complessivo per mezzo di un file compresso o la visualizzazione selettiva tramite una piccola finestra centrale di preview.