bits4beatsIdee e pensieri di Roberto Rossi

Chi ha avuto l’esigenza di dover indicizzare il proprio file system in ambiente Linux sicuramente conosce Beagle o Google Desktop Search. Beagle è molto spesso installato nativamente ed è scritto in Mono, Google Desktop Search è invece un’applicativo sviluppato da Google (inventrice degli algoritmi efficienti per l’indicizzazione e il retrieving dei documenti).

Oggi voglio parlarvi di una soluzione alternativa, sempre per il mondo Unix/Linux (anche se esistono dei port per altre piattaforme) e del quale sono rimasto particolarmente soddisfatto.

Recoll, questo il suo nome, consta di una componente di indicizzazione e di una componente di document retrieval (sia tramite interfaccia GUI che via command line). Il bello di Recoll è la sua semplicità di utilizzo e la possibilità di modificare i parametri di configurazione dell’indice nonché la visualizzazione dei risultati forniti. Le impostazioni vengono salvate in un apposito file di configurazione modificabile anche tramite un semplice editor di testo.

Inoltre, potendo lavorare direttamente via console, può essere facilmente installato anche in ambito server (opzione molto utile per interrogare i documenti salvati in un file system remoto).

L’indice di Recoll viene salvato in un database xapiandb.  Recoll è in grado di analizzare file di diverso tipo. I più comuni sono i documenti office, quelli pdf e anche gli html. Ovviamente non mancano i file .txt , gli mp3 (con i relativi tag ID3) e i file di immagini. Infine e’ anche possibile installare delle lingue aggiuntive per la creazione del corpus delle parole e dei termini di ricerca.

Nell’immagine che segue è possibile ammirare la finestra principale dell’applicativo. Quelli che si vedono sono i risultati di un query non banale, con una sintassi Google like. I risultati possono essere ordinati per alcuni importanti criteri e l’output fornito è facilmente customizzabile. Il link “Edit” apre il documento attraverso il client predefinito del nostro PC, il pulsante “Preview” ci permette di navigare al volo all’interno del contenuto testuale del documento stesso. Usando il tasto destro del mouse su ogni riga è possibile anche effettuare altre operazioni come copiare il path completo del file oppure aprire la directory in cui si trova il documento trovato.

Insomma c’è tutto quello di cui abbiamo bisogno.

Cito infine due aspetti che ho trovato decisamente comodi e differenzianti:

1) la possibilità di lanciare Recoll in modalità di indicizzazione continuative in realtime. Avviando infatti l’eseguibile recollindex con il parametro -m , il programma riceve dal kernel le notifiche di tutti i file modificati, creati o cancellati nel sistema, verifica che appartengono alla lista di directory da monitorare e in caso affermativo procede all’indicizzazione selettiva di tali documenti.

2) Recoll fornisce una comoda interfaccia a caratteri per effettuare le stesse operazioni eseguite tramite interfaccia GUI. Invocato in questo modo infatti:

bash#roberto@ken 00:29 ~ >recoll -t -a "Linux Appunti blog"
Recoll query: ((linux:(wqf=11) AND appunti:(wqf=11) AND (blog:(wqf=11) OR blogs OR blogging)))
10 results
text/html       [file:///home/roberto/Documenti/Firefox/FEBE 2010 03-24 22.55.45/bookmarks{default}.html]       [Bookmarks]     275349  bytes
text/html       [file:///home/roberto/Documenti/Firefox/FEBE 2010 09-17 12.58.21/bookmarks{default}.html]       [Bookmarks]     296552  bytes
text/html       [file:///home/roberto/Documenti/matrimonio/link/bookmarks.html] [Bookmarks]     148148  bytes
text/html       [file:///home/roberto/Documenti/Firefox/FEBE 2011 03-23 22.19.56/bookmarks{default}.html]       [Bookmarks]     312681  bytes
text/plain      [file:///home/roberto/Documenti/Firefox/FEBE 2010 03-24 22.55.45/bookmarks{default}.json]       [bookmarks{default}.json]       137659  bytes
text/plain      [file:///home/roberto/Documenti/Firefox/FEBE 2010 09-17 12.58.21/bookmarks{default}.json]       [bookmarks{default}.json]       140021  bytes
text/plain      [file:///home/roberto/Documenti/Firefox/FEBE 2011 03-23 22.19.56/bookmarks{default}.json]       [bookmarks{default}.json]       146995  bytes
application/pdf [file:///home/roberto/Desktop/download/pilibri/238.pdf] [238.pdf]       7361925 bytes

application/pdf [file:///home/roberto/Documenti/Manuali/Libri Punto Informatico/238.pdf]        [238.pdf]       7361925 bytes

permette di eseguire query al volo nella nostra base di dati.

Spero che abbia stuzzicato il vostro appetito. Io ancora lo sto mettendo alla prova.
Per chi fosse interessato posso fornire alcuni alias che ho creato per interagire con Recoll in modo veloce.

Ecco la pagina ufficiale del progetto.

Buona notte!

Con te se ne va un pezzo di MotoGP… proteggi gli altri piloti da lassù.

http://www.marcosimoncelli.it/

Ogni sviluppatore sa quanto è importante avere nella propria cassetta degli attrezzi un valido software di interrogazione e gestione delle base di dati.

Generalmente ogni db vendor propone la sua soluzione specifica, console e grafica, per accedere ai propri db e tabelle. Sono poche le soluzioni open in grado di connettersi e lavorare con successo su diverse piattaforme e che nello stesso tempo siano facilmente utilizzabili.

Dopo anni e anni di ricerca quasi per caso ho trovato DBeaver, il castoro dei database (dal suo nome curioso).
DBeaver è un software sviluppato in Java tramite il framework di sviluppo di Eclipse: RCP.
E’ disponibile per moltissime piattaforme (cosa comune a quasi tutti i software scritti in Java) e segue dei cicli di sviluppo molto regolari tanto che in poco più di un anno dalla sua pubblicazione ha raggiunto una maturità e una lista di funzioni veramente invidiabili.

Attualmente è alla versione 1.4.0, rilasciata pochi giorni fa.

I db vendor attualmente supportati sono molti (tutti? ):

• MySQL
• Oracle
• PostgreSQL
• IBM DB2
• Microsoft SQL Server
• Sybase
• ODBC
• Java DB (Derby)
• Firebird (Interbase)
• HSQLDB
• SQLite
• Mimer
• H2
• IBM Informix
• SAP MAX DB
• Cache
• Ingres
• Linter
• Any JDBC compliant data source

Nelle sue ultime versioni permette anche di modificare lo schema dei dati (tabelle e altro) e di visualizzare/salvare degli schemi ER delle tabelle selezionate.

Per me è diventato un indispensabile compagno di viaggio e quando posso cerco anche di segnalare eventuali malfunzionamenti o problemi.

Ecco alcuni screenshot presi direttamente dal sito ufficiale.

Provatelo e datemi il nostro parere!

Per un interessante progetto a cui sto lavorando, ho avuto la necessità di configurare Tomcat per poter autenticare nativamente i client (con browser IE7 e IE8 e Firefox) attraverso il repository Active Directory di Windows 2003 Server.

Per farlo ci sono a disposizione, come spesso avviene, numerose possibilità.
Dopo averne provate un paio alla fine ho scelto la soluzione proposta dalla libreria spnego.

spnego implementa il protocollo Kerberos/SPNEGO invece del classico NTLM per dialogare con i domain controller e, attraverso un filtro inserito nella nostra web application, ci offre la possibilità di verificare l’identità degli utenti (attraverso la chiamata java request.getRemoteUser() ) già autenticati in Windows dopo un logon positivo nel dominio di Active Directory.

La guida offerta dal sito della libreria per il raggiungimento di tale integrazione è molto ben fatta. Qui sotto in breve voglio riassumere i miei passi, che in larga parte seguono appunto tale guida.

• creazione di un utente in Active Directory, che sarà utilizzato dal filtro per loggarsi al dominio e verificare le credenziali degli utenti.
• creazione del file krb5.conf (all’interno della directory di esecuzione di Tomcat, nel mio caso la bin) con tale contenuto:

  [libdefaults]
  	default_realm = <NOME_DOMINIO>
  	default_tkt_enctypes = aes128-cts rc4-hmac des3-cbc-sha1 des-cbc-md5 des-cbc-crc
  	default_tgs_enctypes = aes128-cts rc4-hmac des3-cbc-sha1 des-cbc-md5 des-cbc-crc
  	permitted_enctypes   = aes128-cts rc4-hmac des3-cbc-sha1 des-cbc-md5 des-cbc-crc
  
  [realms]
  	<NOME_DOMINIO>  = {
  		kdc = <DOMAIN_CONTROLLER>
  		default_domain =  <NOME_DOMINIO>
  }
  
  [domain_realm]
  	. <NOME_DOMINIO> =  <NOME_DOMINIO>
  

• creazione del file login.conf (nella stessa posizione del file krb5.conf) con il seguente contenuto

  spnego-client {
  	com.sun.security.auth.module.Krb5LoginModule required;
  };
  
  spnego-server {
  	com.sun.security.auth.module.Krb5LoginModule required
  	storeKey=true
  	isInitiator=false;
  };
  

• creazione di una web application (nel mio caso il suo nome è testad) con dentro solamente la directory WEB-INF con dentro una cartella lib con la libreria jar di spnego (nel mio caso l’ultima versione disponibile era la 7, spnego-r7.jar) e il file web.xml con il seguente contenuto (rimpiazzate opportunamente l’utente e la password dell’utente di Active Directory):

  <?xml version="1.0" encoding="ISO-8859-1"?>
  
  <web-app xmlns="http://java.sun.com/xml/ns/javaee"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
     version="2.5">
  
    <filter>
      <filter-name>SpnegoHttpFilter</filter-name>
      <filter-class>net.sourceforge.spnego.SpnegoHttpFilter</filter-class>
  
      <init-param>
          <param-name>spnego.allow.basic</param-name>
          <param-value>true</param-value>
      </init-param>
  
      <init-param>
          <param-name>spnego.allow.localhost</param-name>
          <param-value>false</param-value>
      </init-param>
  
      <init-param>
          <param-name>spnego.allow.unsecure.basic</param-name>
          <param-value>true</param-value>
      </init-param>
  
      <init-param>
          <param-name>spnego.login.client.module</param-name>
          <param-value>spnego-client</param-value>
      </init-param>
  
      <init-param>
          <param-name>spnego.krb5.conf</param-name>
          <param-value>krb5.conf</param-value>
      </init-param>
  
      <init-param>
          <param-name>spnego.login.conf</param-name>
          <param-value>login.conf</param-value>
      </init-param>
  
      <init-param>
          <param-name>spnego.preauth.username</param-name>
          <param-value>utentead</param-value>
      </init-param>
  
      <init-param>
          <param-name>spnego.preauth.password</param-name>
          <param-value>password_utentead</param-value>
      </init-param>
  
      <init-param>
          <param-name>spnego.login.server.module</param-name>
          <param-value>spnego-server</param-value>
      </init-param>
  
      <init-param>
          <param-name>spnego.prompt.ntlm</param-name>
          <param-value>true</param-value>
      </init-param>
  
      <init-param>
          <param-name>spnego.logger.level</param-name>
          <param-value>1</param-value>
      </init-param>
  </filter>
  
  <filter-mapping>
      <filter-name>SpnegoHttpFilter</filter-name>
      <url-pattern>/*</url-pattern>
  </filter-mapping>
  
  </web-app>
  

  aggiungete anche il file index.jsp nella root della web application con il seguente contenuto:

  <%@page import="java.security.Principal" %>
  <html>
   <head>
    <title>Protected Page for Examples</title>
   </head>
   <body bgcolor="white">
    You are logged in as remote user <b><%= request.getRemoteUser() %></b> in session <b><%= session.getId() %></b>
    <br><br>
    <%
  	if (request.getUserPrincipal() != null) {
    %>
    Your user principal name is <b><%= request.getUserPrincipal().getName() %></b>.
    <br><br>
    <%
     } else {
    %>
     No user principal could be identified.
     <br><br>
    <%
    }
    %>
    <%
    String role = request.getParameter("role");
    if (role == null)
      role = "";
    if (role.length() > 0) {
      if (request.isUserInRole(role)) {
    %>
    You have been granted role <b><%= role %></b>.
    <br><br>
    <%
     } else {
    %>
    You have <i>not</i> been granted role <b><%= role %></b>.
    <br><br>
    <%
     }
    }
    %>
    To check whether your username has been granted a particular role, enter it here:
    <form method="GET" action='<%= response.encodeURL("index.jsp") %>'>
     <input type="text" name="role" value="<%= role %>">
    </form>
    <br><br>
    You can logoff by clicking
    <a href='<%= response.encodeURL("index.jsp?logoff=true") %>'>here</a>.
    This should cause automatic re-logon with Waffle and a new session ID.
    <br>
   </body>
  </html>
  

• a questo punto inserite questa web application nelle applicazioni del vostro Tomcat
• per completare il processo bisogna lanciare nel domain controller un paio di istruzioni per abilitare il tab delegation all’utente Active Directory che effettuerà la verifica dei token del Kerberos.

  setspn.exe -A HTTP/<sito> utentead
  setspn.exe -A HTTP/<sito_con_dominio> utentead
  

  poi aprendo le proprietà dell’utente, nel tab “Delegation”, abilitare la funzione “Trust this user for delegation to any service (Kerberos only)”.

• per permettere al browser di passare le credenziali al server bisognerà, nel caso di IE, inserire il sito all’interno dell’Area Intranet e verificare che sotto la voce Autenticazione Utente (dentro livello personalizzato) sia impostato come “Accesso automatico solo nell’area Internet”, mentre per Firefox (testato con il 3.x) bisogna impostare le seguenti chiavi con il valore del vostro sito web

  network.negotiate-auth.delegation-uris = http://<sito>
  network.negotiate-auth.trusted-uris = http://<sito>
  

• riavviate ora Tomcat e accedete alla root della vostra nuova web application
• il filtro di spnego proteggerà tutti i file della web application e chiederà l’autenticazione nativa (o eventualmente l’autenticazione basic tramite prompt). Se l’autenticazione avverrà correttamente accederete al file index.jsp e leggerete il vostro nome utente nella pagina.

Grazie per l’attenzione e buon lavoro!

Ieri, cercando di risolvere un problema di un sito che si verificava con il browser Safari su Windows, navigando qua e là in cerca di risposte, ho trovato qualcuno che consigliava di installare Fiddler, un web debugging proxy freeware per Windows.

Chi già utilizza l’estensione LiveHttpHeaders per Firefox o Firebug sa già quanto siano importanti tali strumenti per lo sviluppatore web. Essi infatti permettono non solamente di analizzare il codice di una pagina web (html, css, javascript) ma anche di visualizzare tutte le chiamate http effettuate dal browser, con le relative risposte, e di fare debugging del codice Javascript presente nella pagina stessa.

Alcuni browser come Safari, Chrome e altri, pur avendo i propri strumenti di sviluppo, non permettono di scendere  anche nel dettaglio delle singole chiamate http, inoltre non sempre il client delle chiamate web è un browser, in alcuni casi potrebbero essere un software stesso che prova a connettersi a un servizio web per scaricare, ad esempio, gli aggiornamenti.

Per tutti questi casi, ma sicuramente anche per molti altri, Fiddler si offre come valido strumento di analisi, frapponendosi in modo trasparente tra client e server e intercettando tutte le richieste e le risposte http del nostro PC.

Per funzionare ha bisogno del framework .NET che installa autonomamente nel caso non sia già presente. Una volta installato è sufficiente avviarlo e iniziare a navigare con un browser per vedere tutte le nostre chiamate (e anche i nostri dati ) apparire nelle schermate del programma.

Il sito del software è il seguente: http://www.fiddler2.com/

Per il download fate riferimento a quest’altro indirizzo: http://www.fiddler2.com/fiddler2/version.asp

Happy debugging!

Tutti noi conoscono almeno 3 o 4 modi differenti per catturare screenshot di finestre o schermo intero sia su sistemi Windows che in sistemi Linux o Unix.

Oggi voglio proporvi due piccoli script che ho scritto ispirandomi a un interessante articolo su IBM Developer Works.

Entrambi gli script sfruttano i comandi messi a disposizione dai sistemi X11 e tipicamente già installati nelle nostre distribuzioni. Tali comandi sono: xwd e xwininfo .

Per renderli un pò più comodi ho utilizzato anche il comando convert, della suite di ImageMagick, e notify-send per inviare delle notifiche all’utente al termine delle operazioni di salvataggio.

Il primo script, di nome capture_full.sh, può ricevere in ingresso 1 parametro che determina il numero di secondi di attesa prima di catturare il nostro desktop in un file nel nostro Desktop. Se tale parametro non viene passato il valore di attesa di default è 3 secondi.

#!/bin/bash

if [ "$1" != "" ]
   then
     seconds=$1;
   else
     seconds=3;
fi

now=`date "+%Y_%m_%d-%H_%M_%S"`
filepath="${HOME}/screen_full_${now}.png"

sleep ${seconds} ; xwd -root | convert - ${filepath}

notify-send -t 3000 -u low -i gtk-dialog-info "Screenshot" "file saved in ${filepath}";

Il secondo script, di nome capture_window.sh, ci permette invece di catturare una singola finestra (anche se non ci permette di interagire con il mouse nella finestra, per far apparire ad esempio un menu contestuale). Il funzionamento di questo script è il seguente: dopo che viene lanciato attende alcuni secondi (modificabili con il primo parametro opzionale) per permetterci di scegliere una finestra del desktop, quindi salva l’id della finestra e lo usa per memorizzare l’immagine della finestra nel desktop.

#!/bin/bash

if [ "$1" != "" ]
 then
 seconds=$1;
 else
 seconds=3;
fi

sleep ${seconds};
wid=`xwininfo | grep "Window id" | awk '{print $4}'`;

now=`date "+%Y_%m_%d-%H_%M_%S"`
filepath="${HOME}/Desktop/screen_window_${now}.png";

xwd -id ${wid} | convert - ${filepath}

notify-send -t 3000 -u low -i gtk-dialog-info "Screenshot" "file saved in ${filepath}";

Provateli, modificando anche la variabile $filepath se lo ritenete opportuno, e fatemi sapere.

Ecco L’articolo originale di William von Hagen in IBM.

In questi giorni ho avuto la necessità di scaricare la traccia audio di un video caricato su YouTube.

Per farlo conoscevo già diversi servizi online ma, visto la potenza della shell Linux, ho pensato di scrivere un piccolo script che assolvesse al compito e che potesse sfruttare alcune utility scritte proprio per questi scopi.

La mia intenzione era quella di avere a disposizione uno script a cui potessi passare un solo parametro, l’url della pagina, e che mi salvasse il file in formato mp3 possibilmente con un nome abbastanza esplicativo. Per riuscire a tale scopo mi sono avvalso di due soli comandi: youtube-dl e ffmpeg.

youtube-dl è uno script python in grado di estrarre un file in formato .flv semplicemente passando il path HTTP alla pagina del video. Questa utility compie tutto il lavoro “duro” del mio semplice script ed è anche in grado di scaricare il nome del video legato all’url. Nel mio caso youtube-dl è servito a salvare il titolo del video, per rinominare correttamente il file mp3 e successivamente è servito per fare il download del file video in formato .flv.

La separazione della traccia audio da quella video e la successiva codifica nel formato mp3 è stata invece assegnata a ffmpeg, uno dei più apprezzati comandi per la gestione e fruizione dei video in Linux (e non solo).

Per entrambi i software mi sono però avvalso di versioni più aggiornate di quelle presenti nella mia distribuzione Ubuntu 8.04. Nelle versioni disponibili nei miei repository infatti youtube-dl non era in grado di effettuare il download del video mentre ffmpeg non riusciva a gestire i video nel formato .flv . Per aggiornare lo script python è stato sufficiente effettuare il download del nuovo script e metterlo nella mia cartella di binari dentro ~/bin/ . Per quanto riguarda ffmpeg invece ho prima provato a effettuare una compilazione della distribuzione per rigenerare la nuova versione. Dopo alcuni tentativi falliti, ho deciso di optare per un binario precompilato linkato staticamente per Linux 32bit. Una valida compilazione l’ho trovata al seguente indirizzo: http://horsfall.eu/2010/11/27/ffmpeg-full/ . Il file binario contenente ffmpeg è stato quindi salvato, con i corretti permessi di esecuzione, nella cartella ~/bin.Tale cartella è nella prima posizione della variabile $PATH. In questo modo i binari che si trovano in tale cartella hanno la precedenza su quelli presenti nelle altre cartelle di binari del sistema.

Veniamo ora al mio script, salvato con il nome: youtube2mp3.sh :

#!/bin/bash

url=$1
flvfile=/var/tmp/$$.flv

title=`youtube-dl -e ${url}`
mp3file=~/Desktop/${title}.mp3

youtube-dl ${url} -o ${flvfile}

ffmpeg -i ${flvfile} "${mp3file}"

rm ${flvfile}

L’unico parametro gestito dalla script, il primo, è l’url della pagina in cui si trova il video in YouTube. Lo script estra prima l’informazione del titolo del filmato e la memorizza nella variabile “title”.
Quindi effettua il download del video salvandolo in un file temporaneo che ha come nome il pid del processo bash invocato.
Successivamente converte il video nella traccia audio mp3 che viene salvata nel Desktop con il nome del titolo e suffisso .mp3.
Infine il file temporaneo .flv viene cancellato dalla directory temporanea.

Dopo un periodo di silenzio durato più di un mese, torno a farmi sentire per segnalare un’importante opportunità per tutti coloro che vogliono configurare e utilizzare le applicazioni web di Google per il proprio dominio.

Non tutti sanno infatti che Google fornisce tale possibilità, pur con delle limitazioni, a tutti i possessori di un dominio, sia per scopi personali che aziendali.
La differenza con la versione enterprise (a pagamento) consiste principalmente nel numero massimo di utenze attivabili, nella mancanza di alcune specifiche applicazioni (Google Video for Business e Google Groups for Business), nella capacità di storage complessiva offerta, nello SLA fornito e in alcune piccole altre customizzazioni e protezioni.

Dopo aver letto la pagina introduttiva ed esservi fatti un’idea di cosa sia il servizio Google Apps for free, leggete i prossimi paragrafi per capire come impostare la configurazione per essere subito operativi con il vostro dominio “Google managed”.

Passo numero 1: specificare il dominio

Da questa pagina è possibile iniziare la sequenza degli step per la gestione del dominio by Google. Il primo passo consiste nello specificare un dominio esistente sul quale abbiamo la possibilità di effettuare le modifiche alle entry del DNS. Come esempio per questo mini-tutorial userò il dominio di test giuliarossi.com .

Passo numero 2: registrazione al servizio Google Apps

In questo passaggio bisogna specificare i propri dati e quelli della propria organizzazione.

Passo numero 3: creazione dell’account di amministratore

In questo passaggio dobbiamo creare l’account di amministrazione del dominio nonché accettare le condizioni contrattuali del servizio.

Passo numero 4: creazione del record CNAME per verificare la proprietà del dominio

A questo punto Google ci chiede di verificare che siamo veramente nelle condizioni per poter “gestire” il dominio che diciamo di possedere. Per farlo ci suggerisce di creare un record CNAME con un nome particolare che successivamente proverà a risolvere per capire se abbiamo risposto positivamente alla sua richiesta.

Passo numero 5: login nel pannello di configurazione del nostro dominio

Se anche il precedente passaggio è andato a buon fine possiamo entrare nel pannello di configurazione e vedere lo stato di attivazione dei nostri servizi. L’attivazione del servizio di posta elettronica richiede qualche passaggio in più. Per gli altri servizi è invece sufficiente attendere qualche minuto.

Passo numero 6: modifica dei record MX per far gestire la posta entrante per il nostro dominio

Nella successiva schermata, al passo 4, Google ci chiede di creare 7 record MX per il nostro dominio che puntano ai server di Google. In questo modo istruiamo i sistemi di posta worldwide che per lasciare un messaggio nella nostra casella devono contattare direttamente i server di Google.

Passo numero 7: modificare le URL per i vari servizi

Ora, per ogni servizio, possiamo modificare l’url predefinito assegnato da Google con un sottodominio del nostro nuovo dominio. Per farlo è sufficiente andare nel link “modifica URL” di ogni servizio. Vi mostrerò il caso della posta, per gli altri servizi la procedura è analoga.

Passo numero 8: verifica dei nomi DNS e test finale

Ecco come si presenta alla fine la configurazione DNS per il nostro dominio.

Ora non ci resta che provare a inviarci dei messaggi di posta e riceverli. Stessa cosa per tutti gli altri superservizi.

Ah, non dimenticatevi, possiamo agganciare anche i nostri dispositivi mobili e soprattutto il nostro telefono Android!

Spero possa servire a qualcuno… ROb

Ecco un interessante articolo su Sencha Touch pubblicato sul canale degli articoli tecnici di IBM, developerWorks.

Sencha Touch è un framework Javascript, nato dall’evoluzione del potente e popolarissimo ExtJS, e orientato al mondo mobile, principalmente Android e iOS.
Il suo obiettivo è quello di costruire interfacce web evolute per tali dispositivi che assomigliano a delle vere e proprie applicazioni native.
Il framework si basa su Javascript e sul potere espressivo del nuovo linguaggio di markup HTML5.

L’articolo, scritto da Michael Galpin, Software Architect presso eBay, presenta una semplice applicazione testata sia in un dispositivo Android che in un iPhone.

Ecco il link diretto all’articolo per chi volesse approfondire.

Dopo che mi è arrivata la mailing list periodica di box.net, felice del fatto che il servizio ha aumentato il suo spazio di archiviazione a 5Gb anche per gli utenti free, ho deciso di pubblicare questo mini post sulla modalità di accesso webdav per box.net.

Non tutti sanno infatti che box.net offre ai suoi utenti questa possibilità, consentendo, per la gioia di molti, l’accesso via HTTP (webdav è un’estensione di questo).

Vediamo come farlo tramite il nostro amato (almeno da me) Krusader.

Dopo aver avviato Krusader, in un nuovo tab digitando il seguente url:

webdav://box.net/dav/

Vi verranno chieste le credenziali per l’accesso al servizio (al quale, lo davo per scontato, dovete essere iscritti). Potete vedere il seguente screenshot.

Se le credenziali sono corrette vedrete il contenuto della directory principale del vostro account box.net.
Questo è il mio.

Ovviamente box.net non è l’unico servizio per memorizzare e condividere file. Il suo principale concorrente è DropBox, che fornisce un client multipiattaforma funzionale ed efficace.

Dopo un non molto breve periodo di silenzio, è arrivato il momento di un piccolo articolo.

Oggi voglio parlarvi della soluzione che ho trovato per trasformare un pdf in formato A4, generato a partire da un documento ODF (ma vale per qualsiasi pdf A4), in un pdf in formato A5 con l’ordine delle pagine adatto per la creazione di un libretto rilegabile.

Questa particolare esigenza mi è venuta per la preparazione del libretto della liturgia della Festa dell’Immacolata, 8 dicembre 2010, a Macerata, in occasione della visita del Cardinale Tarcisio Bertone.
Avendo intenzione di prepararlo usando Linux e volendo nello stesso tempo trovare un modo per farlo comodamente anche in altre occasioni, ho pensato di documentarmi un pò sui programmi e sui metodi offerti dal pinguino.
In passato infatti, quando ancora utilizzavo Windows, avevo fatto qualche esperimento positivo con il programma Publisher. In Linux, non avendo ancora imparato a usare Scribus (che penso sia lo strumento migliore per tali impaginazioni) non avevo una valida soluzione per la creazione di un tale libretto.

Voglio quindi ora condividere con voi il risultato di questa piccola ricerca.

I comandi che entrano in gioco per tale operazioni sono: pdftops (pacchetto Ubuntu poppler-utils), psbook (psutils), psnup (psutils) e ps2pdf (ghostscript).
Serve inoltre un file pdf in formato A4. Se non ne avete uno a disposizione potete usare questo che è proprio il file della cerimonia, generato con Open Office Writer, e successivamente convertito in formato pdf.

Il primo passo è la generazione del file in formato .ps . Per farlo usiamo il comando:

pdftops libretto_sacerdoti_2010_12_08.pdf

Questo comando genererà il file libretto_sacerdoti_2010_12_08.ps
A questo punto lanciamo:

psbook libretto_sacerdoti_2010_12_08.ps | psnup -pa4 -2 > libretto_sacerdoti_2010_12_08_A5.ps

In questo modo il file .ps viene trasformato nell’impaginazione libretto e successivamente il numero di pagine per facciata viene impostato a 2. L’output finale viene salvato nel file libretto_sacerdoti_2010_12_08_A5.ps .

Ora non ci resta che riconvertire il file in formato pdf :

ps2pdf libretto_sacerdoti_2010_12_08_A5.ps libretto_sacerdoti_2010_12_08_A5.pdf

Potete gustarvi il risultato del vostro lavoro e verificare che la stampa funzioni correttamente.
Per le stampanti fronte-retro basta lanciare la stampa, per le stampanti solo fronte dovete procedere in questo modo:

• stampare le pagine dispari del documento
• se il totale delle pagine è pari estrarre i fogli e rimetterli nella stampante (tipicamente con il lato scritto rivolto verso il basso e nel verso corretto di stampa), se è dispari allora prima di rimetterli dentro dovete togliere l’ultima pagina dispari stampata (quella più in alto nella pila)
• stampare le pagine pari in ordine inverso

Se avete proceduto correttamente il vostro libretto è pronto pronto per essere rilegato.
Questo modo di convertire i pdf A4 può tornare utile per stampare un libro risparmiando carta (sempre che il risultato finale sia ancora ben leggibile).

Altro consiglio: numerate le pagine per non farvi venire inutili mal di testa!

Con questa semplice funzione è possibile generare una stringa in codifica md5 a partire da una stringa di testo.

       /**
	 * Generates the md5sum of the given digest
	 *
	 * @param digest
	 * @return
	 */
	public static String md5sum(String digest) {
		String message = null;

		if (digest != null) {
			try {
				MessageDigest md = MessageDigest.getInstance("MD5");
				md.reset();
				byte[] messageBytes = md.digest(digest.getBytes());
				BigInteger number = new BigInteger(1, messageBytes);
				message = number.toString(16);
			} catch (NoSuchAlgorithmException e) {
				e.printStackTrace();
			}
		}

		return message;
	}

Dopo due anni di utilizzo quotidiano del buon caro Evolution, ho deciso di passare al famoso e diffusissimo client di posta della Mozilla Foundation, Thunderbird.

Tale scelta è stata motivata dal fatto che Thunderbird è un sistema di posta molto più diffuso di Evolution, è più facile da estendere e personalizzare tramite i numerosi plugin e temi a disposizione ed è disponibile per i più diffusi sistemi operativi (oltre che per il nostro affezionato Linux), cosa che in alcuni casi può risultare davvero comoda.

Il processo di migrazione che vi sto per descrivere si compone di una serie di passi alcuni dei quali possono essere saltati perché trattano della mia configurazione particolare. Oltre infatti ad aver migrato le cartelle di posta elettronica ho anche installato e configurato alcune estensioni per la sincronizzazione di rubrica e calendario con i rispettivi applicativi di Google.

I passaggi sono i seguenti:

• Installazione di Mozilla Thunderbird
• Avvio del programma e creazione dell’albero di directory speculare a quello di Evolution
• Copia dei messaggi e delle cartelle
• Installazione dei plugin aggiuntivi per la gestione del calendario e la sincronizzazione con gli applicativi Google
• Configurazione dei plugin per la sincronizzazione

Installazione di Mozilla Thunderbird

Dopo aver scaricato il software all’indirizzo http://www.mozillamessaging.com/it/thunderbird/ è sufficiente scompattarlo nella directory /opt/, con gli opportuni permessi di root.
Essendo un archivio in formato .tar.bz2 dovete lanciare il comando bunzip2 “nomefile” quindi tar xfv “nomefile_senza_estensione.bz2″.

Avvio del programma e creazione dell’albero di directory speculare a quello di Evolution

Se avete scompattato il tutto nella directory /opt/thunderbird , l’avvio del programma avviene nel seguente modo: /opt/thunderbird/thunderbird-bin .

Ora quello che dovete fare, dopo aver configurato il vostro primo account, è ricreare la stessa struttura di cartelle, con lo stesso nome, che avevate in Evolution.
Quest’operazione è importante perché il trasferimento delle cartelle e dei messaggi avviene facendo direttamente la copia dei file tra le cartelle di file system utilizzate dai due programmi.

Copia dei messaggi e delle cartelle

Terminata la creazione delle cartelle, chiudete sia Evolution che Thunderbird e posizionatevi nelle due cartelle: /home/”utente”/.thunderbird/”profilo”.default/Mail/Local Folders/ per Thunderbird , dove utente e profilo dipendono dalle vostre specifiche impostazioni e /home/”utente”/.evolution/mail/local/ per Evolution .

A questo punto, partendo dalla cartella di Evolution, copiate tutti i file senza estensione nella cartella di Thunderbird. Se avete delle sottocartelle nel vostro albero di posta allora dovrete ripetere tale operazione entrando in tutte le cartelle con estensione .sbd .

Completata l’operazione di copia potete riaprire Thunderbird e notare che tutti i messaggi sono correttamente presenti nelle rispettive cartelle. In alcuni casi potrebbe capitare che i messaggi risultano non letti o non sono nello stesso ordine con cui li vedevate in Evolution. Impostate correttamente lo stato di lettura e scegliete l’ordinamento che preferite.

Installazione dei plugin aggiuntivi per la gestione del calendario e la sincronizzazione con gli applicativi Google

Essendo un incallito utilizzatore dei servizi Google, come Calendar e Gmail, ho installato alcuni plugin per aiutarmi nella sincronizzazione di Thunderbird con i dati salvati nei rispettivi servizi.

Per la parte Calendar ho installato Lightning scaricandolo dall’indirizzo http://www.mozilla.org/projects/calendar/lightning/ ma è anche possibile trovarlo e installarlo direttamente dalla gestione componenti aggiuntivi del menu Strumenti del programma.

Per aiutare Lightning nella sincronizzazione però ho aggiunto anche Provider for Google Calendar che permette una comunicazione bidirezionale con i calendari Google. Cioè, sfruttando tale estensione, possiamo anche salvare i nostri appuntamenti in remoto verso Google Calendar.

Infine, ultimo ma non per importanza, ho installato anche il componente Zindus. Zindus permette di sincronizzare a sua volta la Rubrica di Thunderbird con i contatti di Gmail. L’estensione effettua anche la sincronizzazione con un server Zimbra, nel caso abbiate un account gestito da questo importante software di collaborazione open source.
Anche in questo caso la sincronizzazione è in entrambi i versi, potendo quindi modificare e inserire contatti in Thunderbird per poi trovarveli in Gmail.

Una cosa da sapere comunque è che i gruppi di Gmail non vengono gestiti in Thunderbird come mailing list, o gruppi di invio, bensì come ulteriori rubriche, con un nome davvero non molto “simpatico”. Per ogni gruppo in Gmail avrete una corrispettiva rubrica in Thunderbird dal nome zindus/indirizzo@gmail.com/#nomegruppo .

Configurazione dei plugin per la sincronizzazione

La configurazione dei plugin per la sincronizzazione è davvero semplice. Nel caso di Zindus è sufficiente andare nei componenti aggiuntivi e cliccare sulle proprietà dell’estensione stessa. Dalla finestra potrete gestire gli account Gmail o Zimbra e impostarne per ognuno le proprietà di sincronizzazione.
Nella barra di stato troverete inoltre un’icona tramite la quale potrete avviare la sincronizzazione manualmente o modificare le impostazioni.

La configurazione dei calendari Google invece consiste nell’inserire 1 ad 1 tutti i calendari all’interno della lista dei calendari di Lightning.
Entrando nel pannello del calendario, e facendo tasto destro nella lista dei calendari, potrete aggiungere un nuovo calendario di rete e scegliere il Google Calendar.
Nel campo “Luogo” dovete impostare l’indirizzo privato in formato XML del vostro calendario Google.
Dopo averlo correttamente inserito dovete fornire le credenziali di accesso al servizio. In pochi minuti vedrete comparire i vostri appuntamenti nel calendario di Lightning.

Fine

Spero questa guida sia servita a qualcuno, oltre che a me per ricordare tutti i passaggi effettuati.
Fate domande o inserite commenti per eventuali chiarimenti, approfondimenti o qualche screenshot in più.

Alcuni browser supportano un protocollo speciale chiamato view-source:.

Tale protocollo permette al browser di visualizzare il codice della pagina indirizzata dall’url anziché farne il rendering e visualizzarla.

Sfruttando tale protocollo possiamo costruire un link che permette, a chi è interessato, di visualizzare il codice della nostra pagina senza passare per la relativa funzione browser-specific (tipicamente attivabile con la sequenza di tasti CTRL+u)

Ecco una semplice pagina html che mostra tale possibilità:

<html>
<body>
   <h1> Roberto Rossi from Macerata! Hello! </h1>
   <a class="button" onClick='window.location="view-source:" + window.location.href' href="javascript:;;">Visualizza Codice</a>
</body>
</html>

Cliccando sul link “Visualizza Codice” il browser aprirà una pagina che visualizzerà tale codice.

Nel seguente articolo in inglese vengono presentati 20 punti che spiegano come rendere più sicuro e protetto il server web Apache.

Si parte ovviamente da quelli più importanti e semplici fino ad arrivare alle configurazioni più onerose ma pur sempre fondamentali per raggiungere un elevato livello di protezione.

http://www.petefreitag.com/item/505.cfm

L’articolo è stato scritto da Pete Freitag.

Personalmente ho provato al volo le due direttive che “limitano” le informazioni sulla versione e i moduli in uso nel server.
Eccole qua:

ServerSignature Off
ServerTokens Prod

Nella seconda direttiva al posto di Prod ho messo Minor, presentando cioè anche il minor number della versione di Apache.

In sistemi Ubuntu e Debian like è sufficiente modificarli o inserirli nel file /etc/apache2/apache2.conf e ricaricare la configurazione usando il comando: /etc/init.d/apache2 reload (con i permessi di root).

Abbiamo già parlato di Jsoup in questo precedente post.
In due parole Jsoup è una potente libreria di parsing html/xml che permette di leggere e manipolare facilmente stringhe e porzioni anche grandi di codice html/xml.

Oggi voglio farvi vedere come possiamo sfruttarla per pulire del codice html (proveniente ad esempio dal campo di un web form) mantenendo solamente i tag che vogliamo.

Questa opzione è infatti molto utile nel caso in cui si voglia permettere agli utenti di arricchire il dato con la formattazione classica dei testi: bold, italico, … senza però rischiare di esporci al pericoloso XSS attack che consiste nell’inserire codice Javascript malevolo che punta verso qualche altro sito.

Con poche righe di codice Jsoup ci permette di definire la nostro lista di tag partendo da alcuni set predefiniti.

        ...
        String unsafe = "<p><a href='http://www.bits4beats.com/' onclick='stealCookies()'>Benvenuto <b>Roberto Rossi</b></a> lo so che che sei di Macerata! <br/>... sei proprio un <i>impiastro</i>!</p>";

		Whitelist myWL = Whitelist.simpleText();
		myWL.addTags("br", "hr");

		String safe = Jsoup.clean(unsafe, myWL);
		System.out.println("stringa sicura: " + safe);
        ...

Se lo eseguiamo otterremo la seguente stringa:

stringa sicura: Benvenuto <b>Roberto Rossi</b> lo sei che sei di Macerata! <br /> sei proprio un <i>impiastro</i>!

In pratica abbiamo detto a Jsoup di partire dalla lista accettata simpleText() che contiene i tag essenziali della formattazione a cui abbiamo aggiunto il tag br e il tag hr.

Ecco come è possibile ottenere in un oggetto di tipo Properties contenente le variabili di ambiente della nostra Linux box.

       /**
	 * Legge le variabili di ambiente e popola un oggetto di tipo Properties
	 */
	public static Properties getEnvironment() throws java.io.IOException {
	    Properties env = new Properties();
	    env.load(Runtime.getRuntime().exec("env").getInputStream());
	    return env;
	}

A questo punto con il seguente codice possiamo conoscere, ad esempio, il valore della variabile LANG che determina la codifica dei file.

       ...
       Properties env = Utils.getEnvironment();
       String lang = (String) env.get("LANG");
       ...

Qualche volta può tornarci utile conoscere con esattezza tutti i file che vengono creati, modificati e cancellati in una specifica cartella.

Un modo semplice per farlo è sfruttando il comodissimo pacchetto inotify-tools che include al suo interno il comando inotitywait.

Il seguente script si mette in attesa e segnala in output gli eventi accaduti per la directory specificata:

#!/bin/bash

directory=$1

inotifywait -q -m --format '%f %e' -e modify -e move -e create -e delete ${directory} | while read line

do
	echo "doing something with: $line";

	# for example:
	# java -jar compiler.jar --js=in1.js --js=in2.js ... --js_output_file=out.js
done

Può essere invocato in questo modo, passando come primo e unico parametro la directory da monitorare:

./inotify.sh ~/Desktop/download/

ed emette ouput di questo tipo:

doing something with: Stack Overflow_screenshot.png MOVED_FROM
doing something with: printecdisplay.pdf DELETE
doing something with: ecommerce_03.html CREATE
doing something with: ecommerce_03.html MODIFY
doing something with: avatar_908.png CREATE
doing something with: avatar_908.png MODIFY

Ovviamente il tutto può essere modificato a proprio piacimento per eseguire operazione o avere notifiche via mail (o qualsiasi altra cosa creativa vi venga in mente).

Quando avevo bisogno di informazioni tecniche e mi affidavo a Google per le mie care ricerche, spesso capitavo in un sito decisamente simpatico dove trovavo quasi sempre le risposte alle mie domande.

Sinceramente non ho mai approfondito la natura del sito, né tantomeno quale fossero gli argomenti prelaventi. Mi limitavo a provare le soluzioni proposte e se funzionavano me ne andavo per sempre dal sito.

Qualche giorno fa, mosso da uno strano spirito di curiosità (non è vero ce l’ho sempre solo che spesso è soffocato dalla voglia di concludere le attività) mi sono soffermato a studiarlo un pò.

Il sito si chiama StackOverflow, un nome decisamente per programmatori, e in realtà unisce un gruppo numerosissimo di sviluppatori in tutto il mondo.
Il suo funzionamento è di una banalità imbarazzante ma forse è anche il motivo del suo successo. Se hai qualche dubbio, problema, richiesta, fai prima una ricerca nel sito e se non trovi niente scrivilo direttamente su StackOverflow.
Troverai sicuramente qualcuno che ha già avuto il tuo stesso dubbio oppure ha già risolto il tuo stesso problema. Se così non fosse magari troverai allora qualcuno disposto ad aiutarti e “perdere” un pò del suo tempo prezioso per rispondere in modo efficace alla tua domanda.

StackOverflow è un sito di programmatori per programmatori. Chiunque comunque può accedere al sito, non sono richiesti particolari prerequisiti, e chiunque può aiutare o rispondere.
In realtà non è sempre così, nel senso che il sistema di StackOverflow è autopremiante e automoderato.
Rispondendo, commentando e risolvendo le domande ogni iscritto riceve dei punti che gli permettono oltre che di guadagnare reputazione e stima dagli altri anche di acquisire facoltà operative.
Non tutti cioè possono fare tutto. Ad esempio chi ha un punteggio pari a 0 non può inserire più di 2 link in una risposta, probabilmente per allontanare gli spammer o chi vuole fare solamente pubblicità.

Se avete voglia di diventare dei guru di StackOverflow, se avete delle forti spinte filantropiche oppure se semplicemente avete bisogno di aiuto in uno dei moltissimi argomenti trattati, di programmazione e non solo, rivolgetevi allora a StackOverflow, iscrivetevi e partecipate a questa grandissima community.

Per chi mi dovesse cercare, io sono impiastro e, come potete vedere, il mio punteggio è ancora veramente molto basso.

Qui sotto trovate il codice javascript che potete inserire all’interno del vostro sito per segnalare la vostra situazione StackOverflow. Questo è il mio.

Qualche giorno fa mi è capitato di dover disabilitare un plugin nel mio profilo Firefox perché in conflitto con un altro plugin.

Il problema è che non riuscivo ad accedere alla maschera dei plugin aggiuntivi in quanto il Javascript Firefox che visualizza tale pagina rimaneva bloccato.

Cercando qua e là ho scovato il modo per disattivare i plugin, entrando in modalità provvisoria in Firefox.
Per farlo è sufficiente chiuderlo e riaprirlo con questo comando:

firefox -safe-mode

I plugin vengono tutti disattivati e possiamo quindi scegliere quale bloccare e quale disinstallare definitivamente.

Comodo no? Come al solito gli sviluppatori Mozilla hanno pensato proprio a tutto.