JAVASCRIPT – Cambiare una classe di stile CSS dinamicamente

febbraio 20th, 2008 - (4 Comments)


Assegnare una classe ad un elemento HTML è ovviamente una cosa molto semplice, ma spesse volte abbiamo bisogno di variare dinamicamente lo stile di un oggetto HTML, ad esempio a seguito di eventi come “onmouseover” o “onclick” .

Supponiamo ad esempio di voler gestire l’apparizione di due div, creando una sorta di menu. L’esempio che vogliamo realizzare è visibile qui.

Non soffermiamoci su come sono implementate le classi CSS: l’unica istruzione importante da tenere presente per le classi dei div che contenugono il testo è il valore di default display:none; , che appunto di default permette di nacondere il contenuto dei div in questione.

La tecnica per realizzare un menu di questo tipo è in realtà molto semplice: quando con il cursore ci troviamo sopra uno dei due link di menu ( “primo” o “secondo”, per interderci ), viene attivato l’evento javascript “onmouseover“, attraverso il quale richiamiamo la funzione “openDiv“.

Questa funzione non fa altro che settare alcune direttive in base al link menu in cui il cursore si trova: analizziamo il primo caso, il secondo è sostanzialmente uguale.

Nel primo caso, quando cioè il mouse si trova sul link menu “primo”, la funzione javascript “openDiv” setta i seguenti parametri:

document.getElementById(id).className = ‘submenu_sfondo_S’;
document.getElementById(‘submenu_01′).style.display = ‘inline’;
document.getElementById(‘secondo’).className = ‘submenu_S’;
document.getElementById(‘submenu_02′).style.display = ‘none’;

La prima riga è la più importante, perchè è quella che di occupa di cambiare il valore dell’attributo class del div di riferimento, ovvero di cambiare la classe di stile per l’elemento (id) passato come parametro. La successiva riga non fa altro che impostare l’attributo display sul valore ‘inline‘ , in modo da visualizzare il contenuto del div corrispondente al link menu passato come parametro. Le ultime due righe compiono sostanzialmente i passi complementari sull’altro div (si imposta la classe css senza lo sfondo e si nasconde il div), in modo da creare l’effetto di alternanza.

Per chi avesse ancora dubbi, può rivedere il codice dell’esempio seguendo questo link.

, , ,

LINUX – Eseguire in automatico operazioni pianificate

febbraio 16th, 2008 - (2 Comments)


Spesse volte, soprattutto per chi deve gestire server Linux, diventa comodo automatizzare alcune attività: pensate al backup, per esempio. Invece di doversi preoccupare costantemente di salvaguardare i proprio dati, possiamo dimenticarci di questa preoccupazione andando a configurare l’operazione di backup come una operazione automatica che il sistema farà in un determinato momento di tempo, che ovviamente saremo noi a decidere.

Ma come è possibile fare questo? Utilizzando il daemon Cron.

Cron è un demone che appunto può essere utilizzato per eseguire operazioni pianificate in base all’ora, al giorno del mese, al mese, al giorno della settimana.

Ovviamente l’utilizzo di Cron presuppone che il sistema sia sempre accesso: nel caso in cui risulti spento quando una operazione è pianificata, semplicemente questa non verrà eseguita. Per poter utilizzare Cron (che il più delle volte è disponibile già in ogni installazione di Linux) occorre che sia installato il pacchetto RPM vixie-cron e il servizio crond sia in secuzione. Per verificare che il pacchetto sia installato e che il servizio sia in esecuzione è sufficiente digitare i seguenti comandi:

rpm -q vixie-cron
/sbin/service

Ma arriviamo al punto fondamentale, ovvero a come configurare le operazioni con Cron. Il file di configurazione più importante di Cron, /etc/crontab, contiente le seguenti righe:

SHELL=/bin/bash
PATH=/sbin:/bin:/usr/sbin:/usr/bin
MAILTO=root
HOME=/

# run-parts
01 * * * * root run-parts /etc/cron.hourly
02 4 * * * root run-parts /etc/cron.daily
22 4 * * 0 root run-parts /etc/cron.weekly
42 4 1 * * root run-parts /etc/cron.monthly

Nelle prime quattro righe vengono inizializzate alcune variabili utilizzate per configurare l’ambiente in cui vengono eseguiote le operazioni di Cron. La variabile SHELL indica al sistema quale ambiente shell utilizzare (nell’esempio è inidicata la bash shell) mentre la variabile PATH definisce il percorso utilizzato per eseguire le operazioni. L’ouput di ogni operazione Cron viene inviato tramite e-mail al nome utente specificato nella variabile MAILTO: se quest’ultima viene lasciata vuota non viene inviata alcuna mail. La variabile HOME indica la directory home per l’esecuzioni di eventuali script o comandi.

Ogni riga del file /etc/crontab può essere vista come un’operazione e ha il seguente formato:

 

* * * * * command
- - - - -
| | | | |
| | | | ----- giorno della settimana (0 - 6) (domenica=0)
| | | ------- mese (1 - 12)
| | --------- giorno del mese (1 - 31)
| ----------- ora (0 - 23)
------------- minuti (0 - 59)

Come di intuisce facilmente dalla figura sopra, il primo campo si riferisce ai minuti, il secondo all’ora, il terzo al giorno del mese, ecc. : in questo modo possiamo stabilire con esattezza il momento temporale in cui vogliamo che una determinata operazione (nell’esempio command) venga eseguita. Gli intervalli tra parentesi indicano i range di valori possibili, tenendo presente che qualsiasi valore può essere sostituito con il simbolo *, che indica tutti i valori validi. Per esempio, un asterisco per il valore del mese indica di eseguire ilk comando specificato ogni mese in base alle restrizioni degli altri valori.

Con il trattino “-” invece indichiamo un intervallo di valori, metre con la virgola “,” creiamo una lista: con il simbolo “/” indichiamo invece valori che vogliamo escludere. Vediamo alcuni esempi:

1-4 (1,2,3,4)

3,4,5,7,12,56 (lista)

0-45/2 (escludiamo il valore 2 da tutti i valori comresi tra 0 e 45 )

*/4 (utilizzato nel campo del mese, indica che l’operazione verrà effettuata ogni 4 mesi)

 

Vediamo un esempio. Visto che tutti i crontab definiti dall’utente vengono salvati nella directory /var/spool/cron/ ed eseguiti usando il nome utente di chi li ha creati, per creare un crontab con un determinato utente bisogna connettersi al sistema con il nome di questo utente e digitare il seguente comando:

crontab -e

Si aprirà il crontab realtivo pronto per le modifiche e aperto con l’editor specificato nella varibile VISUAL o EDITOR. Una volta modificato il file, lo salviamo e usciamo (se utilizzaimo VI, in modalità comando digitiamo :wq). Una volta salvate la mofidiche al crontab, questo viene salvato in base al nome dell’utente e scritto nel file /var/spool/cron/nomeutente.

Il file /etc/crontab utilizza lo script run-parts per eseguire gli script nelle seguenti directory:

/etc/cron.hourly
/etc/cron.daily
/etc/cron.weekly
/etc/cron.monthly

rispettivamente in base oraria, giornaliera, settimanal, mensile. Nel caso in cui volessimo eseguire un file di cron con una fase oraria diversa, allora dovremmo aggiungerla nella directory /etc/cront.d . Tutti i file di questa directory utilizzano la medesima struttura del file /etc/crontab .

Il deamon Cron controlla il file /etc/crontab, le directory /etc/cront.d e /var/spool/cron ogni minuto per rilevare eventuali modifiche. Nel caso in cui vengano rilevate delle modifiche, il file e le directory vengono ricaricati in memoria. Nota bene: se un file crontab viene modificato, non è necessario riavviare il daemon Cron.

 

LINUX – Installare e configurare ISPConfig, un pannello di controllo hosting open source

febbraio 15th, 2008 - (4 Comments)


ISPConfig è un pannello di controllo hosting opensource per server Linux. Attraverso questo pannello, diventa molto più comodo e semplice gestire la configurazione e la manuntezione del vostro server Linux: è un prodotto veramente interessante, soprattutto perchè complete e assolutamente gratuito.

Prima di procedere con l’installazione, è bene che studiate bene i requisiti presentati al seguente indirizzo.

Vediamo come installarlo e configurarlo correttemente. Dopo averlo scaricato al seguente indirizzo, procediamo con la ‘decomprensione’ del file archivio e sistemandoci nella cartella di installazione:

tar xvfz ISPConfig*.tar.gz
cd install_ispconfig

A questo punto siamo pronti per partire con il processo di installazione, lanciando il comando

./setup

A questo punto l’installatore si preoccuperà di tutto il processo, a noi non resterà che rispondere a delle domande che nella maggior parte dei casi sono semplici e chiare. La prima cosa che farà l’installatore sarà compilare Apache con il modulo PHP5: questa compilazioni non modificherà eventuali precedenti personalizzazioni nella configurazione del server wev

Una volta conclusa questa prima fase, sarà necessario creare un certificato SSL: a questo proposito verranno sottoposte una serie di domande, alle quali si può rispondere accettando i valori di default o inserendone di personali.

Bisogna fare attenzione quando raggiungiamo i seguenti punti :

Encrypting RSA private key of CA with a pass phrase for security [ca.key]

Encrypting RSA private key of SERVER with a pass phrase for security [server.key]

del processo di creazione del certificato, perchè qui possiamo chiedere se vogliamo crittografare la password realativa. E’ importante scegliere no, perchè altrimenti ogni qualvolta intendiamo riavviare il sistema ISPConfig ci verrà chiesta una password, e questo comporta che non è possibile riavviare il sistema senza un intervento umano.

Se ci troviamo di fronte un fallimento della compilazione, il processo di setup viene interrotto e i file finora compilati vengono rimossi. Dal messaggio di errore, dovrebbe essere chiaro il problema: una volta risolto, si può procedere nuovamente con il processo di setup.

In caso di successo, invece, ci verrà chiesto di scegliere una lingua: questa scelta si riferisce al linguaggio dell’interfaccia di ISPConfig. Una volta accetta la licenza, che consigliamo di leggere bene, viene chiesta la modalità di installazione: sarebbe meglio scegliere la modalità expert, perchè permette un maggior controllo sull’installazione. Quindi digitiamo 2 e proseguiamo con il processo di installazione.

Segue il riconscimento del daemon postfix, e la scelta della web-root: se non ci va bene la proposta di default, digitiamo n ed inseriamo la cartella che preferiamo. Inserita la web-root verranno richiesti ulteriori dati di configurazione:

Please enter your MySQL server: localhost
Please enter your MySQL user: root
Please enter your MySQL password: (inserire la pass scelta durante l’installazione del MySQL Server)

Please enter a name for the ISPConfig database (e.g. db_ispconfig): db_ispconfig
Please enter the IP address of the ISPConfig web (e.g. 192.168.0.1): xxx.xxx.xxx.xxx (Inserire il proprio IP)
Please enter the host name (e.g. www): www
Please enter the domain (e.g. xyz.de): tuodominio.com

Please select the protocol (http or https (SSL encryption)) to use to access the ISPConfig system:
1) HTTPS
2) HTTP
Your Choice: 1

Se stiamo procedendo ad una installazione di test, il nome host lo possiamo lasciare vuoto, e al posto del nome di dominio possiamo inserire l’indirizzo IP.

Una volta completati tutti i passaggi ISPConfig sarà finalmente installato sul proprio server. Se durante l’installazione abbiamo indicato www come nome host e tuodominio.com come dominio, allora l’interfaccia di ISPConfig sarà raggiungibile al seguente indirizzo:

https://www.tuodominio.com:81 o http://www.tuodominio.com:81

Il primo login andrà fatto inserendo admin come username e password. Ovviamente la prima cosa da fare una volta installato il pannello, è proprio quello di cambiare questi dati, viato che quelli di default non sono mai sicuri.

L’installazione è conclusa, e al seguente indirizzo potete trovare il manuale di utilizzo del pannello. Le istruzioni di installazione dettagliate per ogni sistema operativo linux sono disponibili qui.

, , ,

SITEMAP – Creare e segnalare sitemap per aumentare la visibilità sui motori di ricerca

febbraio 10th, 2008 - (5 Comments)


Riportiamo in questo articolo una versione rivista delle informazioni reperibile su http://www.sitemaps.org , un sito dedicato allo studio e alla spiegazione di utilizzo del protocollo che sta alla base delle sitemap.

Le Sitemap consentono ai webmaster di indicare ai motori di ricerca le pagine dei loro siti disponibili per la scansione. Nella sua forma più semplice, una Sitemap è un file XML contenente gli URL di un sito insieme ai rispettivi metadati aggiuntivi (data dell’ultimo aggiornamento, frequenza tipica delle modifiche, importanza rispetto agli altri URL del sito) che consente ai motori di ricerca di eseguire la scansione del sito in modo più efficiente.

In genere, i crawler web individuano le pagine dai link presenti sul sito e da altri siti. Questi dati vengono aggiunti per consentire ai crawler che supportano Sitemaps di selezionare tutti gli URL nella Sitemap e di ottenere informazioni relative a tali URL tramite i metadati associati. L’utilizzo del Protocollo Sitemap (vedi più avanti) non garantisce l’inclusione delle pagine web nei motori di ricerca, ma facilita il processo di scansione del tuo sito da parte dei crawler web.

Sitemap 0.90 viene regolato dal contratto di licenza Attribution-ShareAlike Creative Commons License e viene adottato a livello generale, compresi Google, Yahoo! e Microsoft.

Formato XML delle Sitemap

Il formato Protocollo Sitemap è composto da tag XML. Tutti i valori dei dati in una Sitemap devono utilizzare i codici di escape. Il file stesso deve utilizzare la codifica UTF-8.

La Sitemap deve:

  • Inizia con un tag di apertura <urlset> e termina con un tag di chiusura </urlset>.
  • Specifica lo spazio dei nomi (standard del protocollo) all’interno del tag <urlset>.
  • Includi una voce <url> per ogni URL come tag XML principale.
  • Includi una voce secondaria <loc> per ogni tag principale <url>.

Tutti gli altri tag sono facoltativi. Il supporto di questi tag facoltativi varia a seconda del motore di ricerca in uso. Consulta la documentazione di ciascun motore di ricerca per maggiori informazioni.

Sitemap XML di esempio

Di seguito viene riportata una Sitemap di esempio che contiene solo un URL e utilizza tutti tag facoltativi. I tag facoltativi vengono riportati in corsivo.

<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
   <url>
      <loc>http://www.example.com/</loc>
      <lastmod>2005-01-01</lastmod>
      <changefreq>monthly</changefreq>
      <priority>0.8</priority>
   </url>
</urlset>

Vedi anche l’esempio con più URL.

Definizioni tag XML

I tag XML disponibili vengono descritti di seguito.

Attributo Descrizione
<urlset> obbligatorio Comprende il file e fa riferimento agli standard del protocollo corrente.
<loc> obbligatorio URL della pagina. L’URL deve iniziare con il protocollo (ad esempio http) e terminare con una barra finale, se richiesto dal server web. Questo valore deve contenere meno di 2048 caratteri.
<changefreq> facoltativo Frequenza con la quale la pagina potrebbe venire modificata. Questo valore fornisce informazioni generiche ai motori di ricerca ed è possibile che non sia esattamente correlato alla frequenza di scansione della pagina. I valori validi sono:

  • always
  • hourly
  • daily
  • weekly
  • monthly
  • yearly
  • never

Il valore “always” deve essere utilizzato per descrivere i documenti che subiscono modifiche ogni volta che vi si accede. Il valore “never” deve essere utilizzato per descrivere gli URL archiviati.

Il valore di questo tag viene considerato un suggerimento e non un comando. Anche se i crawler dei motori di ricerca possono prendere in considerazione questa informazione, è possibile che la scansione di pagine contrassegnate come “hourly” avvenga meno di frequente rispetto alla scansione di pagine contrassegnate come “yearly”. È possibile che i crawler eseguano la scansione periodica di pagine contrassegnate come “never”, in modo da poter gestire modifiche impreviste apportate a tali pagine.

Codici di escape
Il file Sitemap deve utilizzare la codifica UTF-8. In genere, è possibile eseguire questa operazione al momento del salvataggio del file. Analogamente a quanto accade con i file XML, tutti i valori dei dati (inclusi gli URL) devono utilizzare codici di escape per i caratteri elencati nella seguente tabella.

 

 

CarattereE commerciale &

Virgolette ‘

Virgolette doppie ”

Maggiore di >

Minore di <

 Codice di escape&

'

"

>

<

 

 

Inoltre, tutti gli URL, compreso l’URL della tua Sitemap, devono utilizzare caratteri escape ed essere codificati in modo da consentire la lettura ai server web sui quali sono posizionati. Tuttavia, se utilizzi script, strumenti o file di log per generare gli URL (qualsiasi metodo, ad eccezione dell’inserimento manuale), l’operazione viene in genere eseguita automaticamente. Assicurati che tutti i tuoi URL siano conformi allo standard URI RFC-3986, allo standard IRI RFC-3987 e allo standard XML.

Di seguito, viene riportato un esempio di URL che utilizza caratteri non ASCII (ü) e caratteri che richiedono l’utilizzo di codici di escape (&):

http://www.example.it/ümlat.html&q=name

Di seguito viene riportato l’URL con codifica ISO-8859-1 (per il servizio di hosting su un server che utilizza la stessa codifica) e con codice di escape:

http://www.example.it/%FCmlat.html&q=name

Di seguito viene riportato lo stesso l’URL con codifica UTF-8 (per il servizio di hosting su un server che utilizza la stessa codifica) e con codice di escape:

http://www.example.com/%C3%BCmlat.html&q=name

Di seguito, viene riportato lo stesso URL ma questa volta con codice di escape:

http://www.example.com/%C3%BCmlat.html&q=name

Sitemap XML di esempio

Il seguente esempio illustra una Sitemap in formato XML. La Sitemap dell’esempio contiene un numero ridotto di URL, ognuno dei quali utilizza un insieme diverso di parametri facoltativi.

<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
   <url>
      <loc>http://www.example.com/</loc>
      <lastmod>2005-01-01</lastmod>
      <changefreq>monthly</changefreq>
      <priority>0.8</priority>
   </url>
   <url>
      <loc>http://www.example.com/catalog?item=12&desc=vacation_hawaii</loc>
      <changefreq>weekly</changefreq>
   </url>
   <url>
      <loc>http://www.example.com/catalog?item=73&desc=vacation_new_zealand</loc>
      <lastmod>2004-12-23</lastmod>
      <changefreq>weekly</changefreq>
   </url>
   <url>
      <loc>http://www.example.com/catalog?item=74&desc=vacation_newfoundland</loc>
      <lastmod>2004-12-23T18:00:15+00:00</lastmod>
      <priority>0.3</priority>
   </url>
   <url>
      <loc>http://www.example.com/catalog?item=83&desc=vacation_usa</loc>
      <lastmod>2004-11-23</lastmod>
   </url>
</urlset>

Utilizzo di file dell’indice Sitemap (per raggruppare più file Sitemap)

Puoi creare più file Sitemap, ma ciascuno di essi non può contenere più di 50.000 URL e non può avere una dimensione superiore a 10 MB (10.485.760 byte). Se lo desideri, puoi comprimere i file Sitemap utilizzando gzip per rimanere nei limiti dei 10 MB e ridurre la larghezza di banda richiesta. Se desideri indicare più di 50.000 URL, crea più file Sitemap.

Se fornisci più Sitemap, devi elencare ogni file Sitemap in un file dell’indice Sitemap. I file dell’indice Sitemap non possono contenere più di 1000 Sitemap e non devono avere una dimensione superiore a 10 MB (10.485.760 byte). Il formato XML di un file dell’indice Sitemap è molto simile al formato XML di un file Sitemap.

Il file dell’indice Sitemap deve:

  • Inizia con un tag di apertura <sitemapindex> e termina con un tag di chiusura </sitemapindex>.
  • Includi una voce <sitemap> per ogni Sitemap come tag XML principale.
  • Includi una voce secondaria <loc> per ogni tag principale <sitemap>.

Il tag facoltativo <lastmod> è anche disponibile per i file dell’indice Sitemap.

Nota: un file dell’indice Sitemap può solo specificare le Sitemap che si trovano nel suo stesso sito. Ad esempio, http://www.iltuosito.it/sitemap_index.xml può includere le Sitemap di http://www.iltuosito.it, ma non di http://www.esempio.it o http://iltuohost.iltuosito.it. In modo analogo alle Sitemap, anche il file dell’indice Sitemap deve utilizzare la codifica UTF-8.

Indice Sitemap XML di esempio

Il seguente esempio illustra un indice Sitemap in cui sono elencate due Sitemap:

<?xml version="1.0" encoding="UTF-8"?>
<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
   <sitemap>
      <loc>http://www.example.com/sitemap1.xml.gz</loc>
      <lastmod>2004-10-01T18:23:17+00:00</lastmod>
   </sitemap>
   <sitemap>
      <loc>http://www.example.com/sitemap2.xml.gz</loc>
      <lastmod>2005-01-01</lastmod>
   </sitemap>
</sitemapindex>

Nota: analogamente a tutti i valori dei file XML, gli URL della Sitemap devono utilizzare i codici di escape.

Definizioni dei tag XML dell’indice Sitemap

Attributo Descrizione
<sitemapindex> obbligatorio Comprende informazioni su tutte le Sitemap del file.
<loc> obbligatorio Identifica l’ubicazione della Sitemap.Questo percorso può essere una Sitemap, un file Atom, un file RSS o un semplice file di testo.

Altri formati sitemap

Il Protocollo Sitemap consente di fornire informazioni dettagliate sulle pagine ai motori di ricerca. Ti consigliamo di utilizzarlo per fornire ulteriori informazioni sulle pagine del sito, e non solo gli URL. Tuttavia, oltre al protocollo XML, supportiamo i feed RSS e i file di testo, che forniscono informazioni limitate.

Feed di diffusione dei contenuti

Puoi fornire un feed RSS (Real Simple Syndication) 2.0 o Atom 0.3 o 1.0. In genere, si utilizza questo formato soltanto se il sito già dispone di un feed di diffusione dei contenuti. È possibile che in questo modo i motori di ricerca non vengano a conoscenza di tutti gli URL del tuo sito, poiché il feed potrebbe fornire informazioni solo sugli URL recenti; tuttavia queste informazioni possono essere utilizzate per ottenere informazioni su altre pagine del tuo sito nel corso dei normali processi di scansione seguendo i link disponibili nella pagina del feed. Assicurati che il feed sia collocato nella directory di livello più elevato di cui desideri venga eseguita la scansione da parte dei motori di ricerca. I motori di ricerca estraggono le informazioni dai feed nel seguente modo:

  • Campo <link> – indica l’URL
  • campo date di modifica (il campo <pubDate> per i feed RSS e il campo <modified> per i feed Atom) – indica la data dell’ultima modifica di ciascun URL. L’utilizzo del campo della data di modifica è opzionale.

File di testo

Puoi fornire un semplice file di testo contenente un URL per riga. Il file di testo deve rispettare le seguenti convenzioni:

  • Il file di testo deve contenere un URL per riga. Gli URL non possono contenere codici di interruzione di riga.
  • È necessario specificare gli URL completi, incluso http.
  • Ogni file di testo può contenere massimo 50.000 URL. Se il tuo sito include più di 50.000 URL, puoi dividere l’elenco in più file di testo e aggiungere ogni file separatamente.
  • È necessario utilizzare la codifica UTF-8 per il file di testo. È possibile specificare la codifica al momento del salvataggio del file, ad esempio, in Notepad, la codifica UTF-8 viene elencata nel menu “Codifica” della finestra di dialogo “Salva con nome”.
  • Il file di testo non deve contenere altri dati che non siano l’elenco degli URL.
  • Il file di testo non deve contenere dati di intestazione o piè di pagina.
  • È possibile assegnare qualsiasi nome al file di testo.
  • Carica il file di testo nella directory di livello superiore di cui i motori di ricerca devono eseguire la scansione e accertarti che gli URL elencati nel file di testo non siano presenti nella directory di livello superiore.

Di seguito sono riportate voci di esempio del file di testo.

http://www.example.it/catalog?item=1

http://www.example.it/catalog?item=11

Ubicazione del file Sitemap

Il percorso di un file Sitemap determina l’insieme di URL che può essere inserito nella Sitemap. Un file Sitemap posizionato in http://esempio.it/catalog/sitemap.xml può includere tutti gli URL che iniziano con http://esempio.it/catalog/ ma non quelli che iniziano con http://esempio.it/images/.

Se hai l’autorizzazione a modificare http://example.org/path/sitemap.xml, si presume che tu abbia anche l’autorizzazione a fornire informazioni relative agli URL con il prefisso http://example.org/path/. Alcuni esempi di URL considerati validi in http://example.com/catalog/sitemap.xml sono:

http://example.com/catalog/show?item=23

http://example.com/catalog/show?item=233&user=3453

Gli URL non considerati validi in http://esempio.it/catalog/sitemap.xml sono:

http://example.com/image/show?item=23

http://example.com/image/show?item=233&user=3453

https://example.com/catalog/page1.html

Questo significa che tutti gli URL elencati nella Sitemap devono utilizzare lo stesso protocollo (in questo esempio, il protocollo http) e risiedere nello stesso host della Sitemap. Ad esempio, una Sitemap che si trova in http://www.esempio.it/sitemap.xml non può includere gli URL di http://sottodominio.esempio.it.

Gli URL non considerati validi vengono ignorati. Ti consigliamo di salvare la Sitemap nella directory principale del tuo server web. Ad esempio, se il server web è su esempio.it, il file dell’indice Sitemap si troverà su http://esempio.it/sitemap.xml. In alcuni casi, potresti dover creare Sitemap diverse per i vari percorsi del tuo sito, ad esempio se le autorizzazione di protezione della tua azienda separano i diritti di accesso in scrittura a directory diverse.

Se invii una Sitemap utilizzando un percorso con un numero di porta, devi includere tale numero nel percorso in ciascun URL riportato nel file Sitemap. Ad esempio, se la tua Sitemap è ubicata in http://www.example.com:100/sitemap.xml, ciascun URL riportato nella Sitemap deve iniziare con http://www.example.com:100.


Convalida della Sitemap

I seguenti schemi XML definiscono gli elementi e gli attributi che possono essere visualizzati nel file Sitemap. Puoi scaricare lo schema dai seguenti link:

Per le Sitemap

http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd

Per i file dell’indice Sitemap

http://www.sitemaps.org/schemas/sitemap/0.9/siteindex.xsd

Sono disponibili diversi strumenti per la convalida della struttura della Sitemap in base a questo schema. Puoi trovare un elenco di strumenti relativi a XML in ognuno dei seguenti percorsi:

http://www.w3.org/XML/Schema#Tools
http://www.xml.com/pub/a/2000/12/13/schematools.html

Per convalidare la Sitemap o il file dell’indice Sitemap in base a uno schema, è necessario che il file XML abbia intestazioni aggiuntive, come mostrato di seguito.

Sitemap:

<?xml version='1.0' encoding='UTF-8'?>
<urlset xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.sitemaps.org/schemas/sitemap/0.9
         http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd"
         xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
   <url>
      ...
   </url>
</urlset>

File dell’indice Sitemap:

<?xml version='1.0' encoding='UTF-8'?>
<sitemapindex xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.sitemaps.org/schemas/sitemap/0.9
         http://www.sitemaps.org/schemas/sitemap/0.9/siteindex.xsd"
         xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
   <sitemap>
      ...
   </sitemap>
</sitemapindex>

Estensione del Protocollo Sitemap

Puoi estendere il Protocollo Sitemap utilizzando il tuo spazio dei nomi. Devi semplicemente specificare questo spazio dei nomi nell’elemento principale. Ad esempio:

<?xml version='1.0' encoding='UTF-8'?>
<urlset xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.sitemaps.org/schemas/sitemap/0.9
         http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd"
         xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
         xmlns:example="http://www.example.com/schemas/example_schema"> <!-- namespace extension -->
   <url>
      <example:example_tag>
         ...
      </example:example_tag>
      ...
   </url>
</urlset>

Invio delle informazioni ai crawler dei motori di ricerca

Dopo aver creato il file sitemap e averlo posizionato sul tuo server web, invialo ai motori di ricerca che supportano questo protocollo. Puoi eseguire questa operazione nel seguente modo:

Nell’elenco sottostante troviamo i link ai motori di ricerca principali per segnalare la propria sitemap:

Yahoo

https://siteexplorer.search.yahoo.com/submit

Google

http://www.google.com/support/webmasters/bin/answer.py?answer=40318

Ask.com

http://submissions.ask.com/ping?sitemap=SitemapUrl

RISORSE

Vi sono diverse risorse disponibile per generare in automatico la sitemap del proprio sito. Ecco alcune tra le principali:

GSite Crawler

GSite Crawler ha saputo conquistare la palma del miglior software gratuito per la creazione di sitemap su Windows. Supporta diversi formati, dai feed alle sitemap, per generare il risultato più adatto alle vostre esigenze.

Il funzionamento si basa su un crawler che, una volta lanciato su un indirizzo, si preoccupa di recuperare le URL di tutte le pagine collegate scandagliando il sito web come se fosse il bot di un motore di ricerca. Al termine è possibile scegliere le impostazioni di ogni singolo indirizzo e generare sia sitemap XML sia archivi compressi.

Rage Google Sitemap Automator

Se lavorate su Mac potreste trovare interessante Google Sitemap Automator, un software a pagamento per generare e segnalare sitemap ai motori di ricerca.

Script online

Sebbene i generatori online di sitemap non offrano, ad oggi, la stessa affidabilità e la stessa qualità di un buon software desktop, in molti casi sono una soluzione utile e chiavi in mano che vi permette in pochi click di generare una sitemap per il vostro sito.

È possibile scegliere tra innumerevoli prodotti come AutoSitemap, Online Sitemap Generator o Google Site Map Generator. Una menzione particolare la merita sitemap.xml.gz Generator, un software scritto in Java e disponibile tramite interfaccia web.

PHP – Creare e modificare immagini dinamicamente

febbraio 7th, 2008 - (3 Comments)


Manipolare le immagini con PHP è davvero divertente: in poche righe di codice si possono creare degli effetti e delle particolarità davvero interessanti. L’esempio che vedremo in questo articolo mostrerà come modificare dinamicamente un’immagine data o passata come parametro: nel dettaglio, andremo a scrivere sull’immagine data una particolare stringa, di cui possiamo modificare colore, posizione, carattere, ecc.

L’esempio di ciò che andremo ad implentare è disposibile a questo indirizzo qui.

Creiamo un file php, figure.php, e analizziamo il codice da inserire.

<?
/*
Innanzittutto comunichiamo a chi utilizzerà questa pagina (ad es. il browser) che il contenuto della stessa deve essere interpretato come un’immagine. In questo modo, se volessimo utilizzare l’immagine creata con questo codice in un tag html <img>, sarà sufficiente scrivere una riga di questo tipo: <img src=”figure.php” />
*/
header(“Content-type: image/jpeg”);

/*
Assegnamo il valore che avrà la prima stringa che scriveremo nell’immagine. Se ad esempio volessimo fare un album di figurine di calcio, che in base alla figura assegna un nome diverso, si potrebbe “giocare” con queste due stringhe per assegnare il nome e il cognome appropriato in base alla figurina che carichiamo o passiamo come parametro.
*/
$string = strtoupper(“FRANCESCO”);

/*
Assegnamo il cognome del giocatore
*/
$string2 = strtoupper(“TOTTI”);

/*
imagecreatefromjpeg è una funzione php che permette di creare un’immagine da un file o da un URL. Nel nostro caso creiamo una figurina da un’immagine di partenza, quella passata come parametro. La funzione restituisce un identificativo ($im) che rappresenta l’immagine create dal nostro file di partenza. Attraverso questo identificativo possiamo modificare l’immagine a nostro piacimento.
*/
$im = imagecreatefromjpeg(“http://www.marcolecce.com/blog/Esempi/esempio7/totti.jpg”);

/*
imagecolorallocate permette di creare ed allocare un colore ad un’immagine. Anche in questo caso viene restituito un identificativo ($color) che rappresenta il colore secondo i componenti RGB passati come parametri.
*/
$color = imagecolorallocate($im, 255, 255, 255);
/*
Attraverso queste due istruzioni ci calcoliamo la posizione in cui verrano stampate sull’immagine le stringhe che passiamo come parametri. Nel nostro caso stampiano nome e cognome del giocatore nel centro dell’immagine che andremo a creare.
*/
$px = (imagesx($im) – 7.5 * strlen($string)) / 2;
$px2 = (imagesx($im) – 7.5 * strlen($string2)) / 2;

/*
imagestring è la funzione che permette di disegnare la stringa sull”immagine: il primo paramettro è l’identificativo dell’immagine, poi c’è le dimensione del carattere, la posizione orizzontale, la posizione verticale, la stringa ed infine il colore.
*/
imagestring($im, 100, $px, 60, $string, $color);
imagestring($im, 100, $px2, 90, $string2, $color);

/*
Infine utilizziamo la funzione imagejpeg che invia in output al browser o ad un file l’immagine che abbiamo creato (nel nostro caso creiamo una jpg, ovviamente vi sono le corrispettive funzioni per gli altri formati come gif, png,ecc; ATTENZIONE: se combiate formato ricordate di far coincidere quest’ultimo con quello dichiarato alla prima di riga di codice, altrimenti non ci sarà corrispondenza e vi saranno problemi di visualizzazione.
)*/
imagejpeg($im);

/*
Una volta visualizzata l’immagine, se non ci serve per altro, possiamo liberare con la funzione imagedestroy() la memoria occupata dall’immagine.
*/
imagedestroy($im);

?>

Ovviamente l’esempio qui presentato è molto semplice, ma il meccanismo di funzionamento rimane pressocchè il medesimo utilizzando le altre funzioni che il PHP mette a disposizione: da questo momento, potete provarle tutte sulla vostra immagine “virtuale”…buon divertimento! ;)

Javascript – Controllare e validare una mail con le espressioni regolari

febbraio 5th, 2008 - (6 Comments)


Vi sono vari modi per controllare i dati che riceviamo da un form html: se stiamo utilizzando PHP possiamo servirci di alcune funzioni messe a disposizione dal motore PHP ( come ad esempio empty() ), ma possiamo anche sceglire un’altra strada, Javascript.

Il controllo di campi numeri e testuali è abbastanza banale, e in rete di trovano migliaia di esempi: ciò che non si trova molto spesso è il controllo delle mail, e soprattutto il controllo da effettuare per verificare la validità di una mail.

Supponiamo di avere un form fatto in questo modo:

<form name=”emailForm” method=”post” action=”">
<p>Inserisci il tuo nome:<br>
<input name=”name” type=”text”>
<br>
<span>Inserisci il tuo indirizzo e-mail:</span><br>
<input name=”email” type=”text”>
<br>

ecc.
<input name=”Submit” type=”submit” value=”Invia” onclick=”return validateForm();”>
</form>

Questo form ha diversi campi, a noi interessa il campo email e il campo Submit : quest’ultimo, una volta cliccato, chiama una funzione Javascript, validateForm(); che si occupa appunto di validare il form. Come abbiamo detto precedentemente, concentriamoci sul controllo e sulla validazione della mail. Le righe di codice da inserire nella funzione di cui sopra per raggiungere il notro obiettivo sono:

/*
Se il valore del campo email del form emailForm è vuoto, salviamo nella variabile errmsg, oltre a possibili errori per controlli precedenti, un messaggio che specifichi la mancanza della mail
*/
if ( !document.emailForm.email.value ) {
errmsg += ‘\nDovete immettere la MAIL’;

} else {

/*
Se il campo mail è stato effettivamente completato, controlliamo però la validità di tale campo: per fare questo utilizziamo le espressioni regolari e alcune funzioni native di Javascript. Quindi creiamo un oggetto “espressione regolare” che salviamo nella varibile “espressione“, recuperiamo il valore della mail inviato tramite il form e lo salviamo nella variabile stringa ; infine facciamo il confronto tra questi due valori.
Se stringa contiente un valore che non rispetta le regole imposte dall’espressione regolare, allora inseriamo un messaggio appropriato, altrimenti non si verificaheranno problemi e la computazione potra proseguire tranquillamente.
*/
var espressione = new RegExp(“^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+[\.]([a-z0-9-]+)*([a-z]{2,3})$”);
var stringa = document.emailForm.email.value;
if ( !espressione.test(stringa) )
errmsg += ‘\nDovete immettere una MAIL VALIDA’;
}

Le espressioni regolari vengono usate particolarmente per manipolare stringhe, e quindi in linguaggi come Perl, che bene si adattano alla gestione e configurazioni di alcune caratteristiche particolari dei server.
L’argomento delle espressioni regolari è molto vasto, e lo rimandiamo ad ulteriori chiarimenti futuri: per chi volesse iniziare ad approfondire questo affascinante studio può dare un’occhiata a questo indirizzo qui.

Linux – Editor VI: i comandi principali per utilizzare al meglio questo editor

febbraio 4th, 2008 - (3 Comments)


Segue l’elenco dei comandi principali per gestire uno tra gli editor più importanti presenti praticamente in ogni versioni di Linux: attraverso questo editor si possono gestire tutti i tipi di file del sistema, e per chi gestisce da remoto un server Linux diventa di vitale importanza conoscere almeno le basi di VI.

Premessa

L’editor VI ha due modalità di funziomento: una per inserire il testo e l’altra per inserire i comandi. Quando apriamoun file con il comando “vi nomefile” la modalità di default è quella di comando: per poter modificare il file inserendo testo dobbiamo passare alla modalità testo premendo il tasto “ i ” : da questo momento in poi qualsiasi carattere o tasto premiamo verrà inserito nel file con il suo valore “testuale”. Per tornare alla modalità comando è sufficiente premere il tasto di “ESC“, digitare il comando che si desidera e premere “invio“.

Comandi Principali : Uscita & Salvataggio

  1. ZZ salvare e uscire
  2. :w salvare
  3. :w <file> salvare in altro file con il nome desiderato
  4. :wq salvare e uscire
  5. :q se non sono state effettuate modifche usce senza salvare
  6. :q! uscita incondizionata

Comandi di copia e incolla

  1. yy copia la riga corrente
  2. y2 <giu> copia 2 righe sotto la posizione in cui si trova il cursore
  3. p incolla il testo nel punto dove si trova il cursore

Cancellare righe o caratteri

  1. x cancella il carattere in cui si trova il cursore
  2. X cancella il carattere alla sinistra del cursore
  3. D cancella tutto quello che si trova alla sinistra del cursore fino alla fine della riga
  4. dd cancella la riga in cui si trova il cursore
  5. 3dd cancella 3 righe partendo dalla quella in cui si trova il cursore
  6. dG cancella dalla posizione in cui si trova il cursore fino alla fine del file
  7. d1G cancella dalla posizione in cui si trova il cursore fino all’inizio del file

Spostarsi nel file

  1. ^ inizio della riga corrente
  2. $ fine della riga corrente
  3. G fine del file
  4. 1G inizio del file

Ricerca e sostituzione del testo

  1. /<testo> cerca il testo dalla posizione corrente verso il basso
  2. ?<testo> cerca il testo dalla posizione corrente verso l’alto
  3. u annulla l’ultima modifica effettuata
  4. U annulla l’ultimo annullamento
  5. . ripete l’ultimo comando

PHP – Inserire in un array i nomi dei file contenuti in una directory

febbraio 3rd, 2008 - (1 Comments)


Supponiamo di voler salvare in un array i nomi delle immagini contenute in una determinata directory, in modo da, ad esempio, utilizzarea tale array per la gestione di una gallery.

Vediamo come al solito un esempio pratico commentato per spiegare al meglio tutti i passi necessari:

/*
Creiamo un array $images per contenere i nomi delle immagini che sono salvate nella directory in questione
*/
$images = Array();

/*
mydir è il percorso fisico della directory in cui si trovano le immagini
*/
$dir = ‘mydir’;

/*
photodir è il percorso virtuale della directory in cui si trovano le immagini
*/
$virtual = “photodir”;

/*
Se la direcotry esiste…
*/
if ( file_exists($dir) ) {

/*
Apriamo l’handle della directory
*/
$handle = opendir ( $dir );

/*
readdir restituisce il nomefile del file successivo della directory: in pratica facciamo un ciclo (while) sulla directory finchè ci sono file da leggere, e per ogni iterazione salviamo il nome del file nella variabile $file
*/
while ( false !== ( $file = readdir($handle) ) ) {

/*
Se $dir.$file è un file esistente nel nostro filesystem….
*/
if ( is_file($dir.$file) ) {

/*
..inseriamo il file nell’array images, attraverso il metodo array_push()
*/
array_push($images,$file);

}
}
/*Chiudiamo l’handle precedentemente aperto*/
$handle = closedir($handle);

/*
Se la directory è inesistente, stampiamo un avviso come feedback..
*/
} else echo “Directory Inesistente!”;

Attraverso queste semplici linee di codice, alla fine del ciclo avremo disponibili nell’array $images tutti i nomi dei dile contenuti nella directory mydir .

Windows – Forzare la mappatura degli indirizzi IP ai nomi host

febbraio 1st, 2008 - (2 Comments)


Per chi sviluppa piattaforme web, spesse volte capita la situazione di lavorare ad un aggiornamento del sistema che ovviamente non è online e che magari risiede su una diversa macchina della versione originale che continua a “girare” normalmente.

Ovviamente durante lo sviluppo di una piattaforma da aggiornare, la versione precedente deve continuare ad essere online finchè la nuova versione non è pronta, ma d’altro canto anche chi lavora alla nuova implementazione deve poter testare il nuovo software e quindi mettelo in rete per avere un feedback.

La cosa più veloce da fare in questi casi per chi utilizza come sistema operativo Windows, è quella di aprire il seguente file:

C:\WINDOWS\system32\drivers\etc\hosts

 

Questo file permette di forzare la mappatura degli indirizzi IP: vediamo un esempio. Supponiamo di stare lavorando alla nuova versione del sito www.mysite.com : ovviamente potremmo posizionare la nuova versione in una sottocartella e risolvere il problema, ma se l’applicativo è di una certa dimensione o se la nuova versione risiede su un’altra macchina più nuova e performante ma che è mappata con lo stesso dominio, allora si presenta il problema. Ovviamente finchè non facciamo un reindirizzamento quando scriveremo sul nostro browser www.mysite.com continuerà ad vedersi la vecchia versione, ma allo stesso tempo non possiamo fare il reindirizzamento finchè la nuova versione non è pronta.

Allora possiamo forzare, attraverso alcune mofiche al file di cui sopra, la mappatura del sito, e quando digitiamo nel browser www.mysite.com vedere la versione in sviluppo residente nella macchina che indichiamo: ovviamente questa modifica varrà solo in locale, saremo gli unici a vedere sotto il dominio www.mysite.com la nuova versione, gli altri continueranno a non vedere modifiche.

Vediamo un esempio pratico, supponendo che la versione attuale del dominio www.mysite.com risieda su xxx.xxx.xxx.xxx mentre quella nuova risiede su yyy.yyy.yyy.yyy . Per effettuare la forzatura è sufficiente aggiungere al file hosts la seguente riga:

yyy.yyy.yyy.yyy                www.mysite.com

Una volta salvato il file e aperto il browser, quando andremo a scrivere www.mysite.com ora vedremo la versione in sviluppo, e potremmo lavorare e testare tranquilli. Una volta finito, possiamo o commentare ( aggiungendo davanti alla riga il simbolo # ) o cancellare la riga, e tutto tornerà come prima.