Robitex's Blog

Ideas in the web

Archivi Categorie: Linux

Invito all’autocostruzione del computer


Tempo di cambiamenti nella dotazione hardware casalinga.

Foto della scheda madre nella fase di montaggio iniziale subito dopo aver alloggiato il processore.

Spesso adotto delle soluzioni software ‘fai da te’ in cui vari programmi vengono assemblati per ottenere il risultato finale: formati personalizzati, script ad hoc, fogli di calcolo, LaTeX, database, ecc.

Le soluzioni artigianali danno soddisfazione, e si mantiene il controllo dell’elaborazione dei dati, così ho adottato lo stesso principio per costruire un nuovo computer desktop.

Fino ad ora mi era capitato di montare un nuovo drive o sostituire moduli di memoria RAM, ma non avevo mai realizzato un computer a partire dai componenti, rimaneva un progetto, un sogno, così l’ho realizzato all’improvviso, semplicemente parlando in famiglia del monitor troppo grande sulla scrivania…

Vantaggi

I vantaggi dell’auto-costruzione sono molti. Il primo tra tutti è che è possibile progettare una configurazione che si adatta perfettamente alle proprie necessità, ed inoltre si risparmia circa il 25% (almeno così ho valutato nel mio caso).

Ho scelto di sacrificare la sezione grafica del PC per irrobustire le prestazioni: ottimo processore, ottimi moduli RAM, ottimo drive SSD, così il PC si avvia in circa 10 secondi e le applicazioni sono subito a disposizione per lavorare.
Grande velocità e prontezza.

Svantaggi

Uno solo: serve un po’ di tempo per informarsi, leggere la documentazione tecnica, fare l’ordine dei componenti ed effettuare il montaggio.

Work log assemblaggio

Gli esperti del sito di PCSilenzioso mi hanno dato una mano per progettare la macchina, celermente, con competenza e simpatia.

Ho postato l’intero work-log sia dell’assemblaggio dei componenti sia dell’installazione del sistema operativo, nella sezione Progetti del sito in questo thread.

Buon assemblaggio!
R.

Annunci

Sono passato a Precise…


Improvvisamente ho deciso di fare il passaggio da Ubuntu 10.04 Lucid alla nuova LTS Precise 12.04.

La mia titubanza derivava dal sospetto che il mio vecchio PC non sopportasse la nuova versione soprattutto per le prestazioni lato grafica. Tuttavia ormai in Lucid parecchi pacchetti non ricevevano più aggiornamenti, così ho decido per il salto.

Tutto sommato, Precise ha mantenuto le stesse prestazioni che avevo in Lucid. Più precisamente… l’avvio con Unity delle attività è più lento ma una volta avviati i programmi mi sembrano addirittura più veloci.

Ho riportato una schermata del nuovo Desktop qui sotto…
Alla prossima.
R.

Ubuntu Precise 12.04 Desktop Screenshot

Ubuntu Precise 12.04 Desktop Screenshot

Click and script


Scarica l’articolo nel formato PDF

Sommario

In questo post impareremo come personalizzare il menù contestuale in Nautilus, il gestore di file incorporato in Gnome, fino a compilare al volo sorgenti LaTeX e compiere moltissime altre operazioni che possono essere ripetitive.

Il menù contestuale

Nelle moderne interfacce grafiche il menù contestuale è un efficace idea che presenta all’utente le operazioni effettuabili su uno specifico oggetto. Se per esempio si tratta di un file compresso il click destro sull’icona che lo simboleggia, attiverà un menù contestuale che presenta le apposite voci per l’estrazione del contenuto.

In Linux, nel Desktop Environment Gnome è possibile associare a questi menù piccoli programmi per lanciarli comodamente dopo aver selezionato i file d’interesse.

Nautilus-scripts

Nautilus è il file manager di Gnome. Grazie al supporto per lo scripting, le operazioni per creare una nuova voce di menù contestuale sono davvero semplici, allo stesso modo di quelle da svolgere per creare un nuovo modello di documento come già illustrato in questo post. Basta creare il file con il codice, assegnargli i permessi di esecuzione e spostarlo nella directory nascosta $HOME/.gnome2/nautilus-scripts.

Menù contestuale su un file compresso in Gnome

Menù contestuale su un file compresso in Gnome

Come è naturale sui sistemi Linux, possiamo scrivere script in molti linguaggi, da Bash a Python. Noi utilizzeremo anche Lua pertanto dovrete assicurarvi che sia installato sul vostro sistema.

I nostri comandi personalizzati

Ecco in concreto, alcune idee di personalizzazione del menù. Ciascun nuovo comando contestuale deriva da esigenze della pratica quotidiana.
Molte altre idee possono essere realizzate per rendere più semplice l’utilizzo del pc, per esempio unire più file di testo o spedire documenti ad un indirizzo di posta elettronica…

Mandare in stampa un documento

Se desidero lanciare la stampa di un file PDF lo apro con un visualizzatore ed eseguo il comando di stampa. Se i PDF da stampare sono molti invece, apro il terminale, posiziono la working directory e lancio la stampa di tutti i PDF presenti con il comando:

$ lpr *.pdf

Con qualche conoscenza in più di Bash (il linguaggio standard per l’amministrazione dei sistemi Linux ma anche di quelli Mac OS X ormai), si costruisce un piccolo e semplicissimo script:

#!/bin/bash

for arg do
    lpr "$arg"
done

Salviamone il contenuto in un file di testo chiamato per esempio goToPrinter, assegniamogli i permessi di esecuzione (anche dal menù Proprietà) e spostiamolo nella directory nascosta $HOME/.gnome2/nautilus-scripts. Di seguito la sequenza dei comandi e l’immagine della sessione corrispondente al terminale:

$ chmod +x goToPrinter
$ mv goToPrinter ~/.gnome2/nautilus-scripts
Sessione al terminale per la creazione del Nautilus script

Sessione al terminale per la creazione del Nautilus script

Elencare file

Modificando un poco lo script precedente possiamo ottenere facilmente un file di testo contenente la lista dei file selezionati sostituendo ad lpr il comando echo e reindirizzandone l’output verso un file. Utilizzeremo poi la libreria zenity per mostrare un dialogo che mostri all’utente il numero dei file conteggiati.

#!/bin/bash

for arg do
    echo "$arg"
done >> listoffiles.txt

zenity --info --width=200 --height=100 \
       --title="Conteggio file elencati" \
       --text="Numero di file elencati: $# "

Compilare un sorgente LaTeX

Compilare un sorgente LaTeX non è un problema se ci si avvale di un editor come TeX Works, oppure direttamente del terminale, ma se lo possiamo fare con un semplice click destro sulla selezione di file è davvero elegante.
Il codice in Lua provvede a filtrare i file selezionati al momento dell’apertura del menù contestuale in base all’estensione solitamente assegnata ai sorgenti LaTeX.

#!/usr/bin/lua

-- ottengo la lista dei file selezionati
-- dalla variabile d'ambiente opportuna
--
local s = os.getenv("NAUTILUS_SCRIPT_SELECTED_FILE_PATHS")

-- per ogni file con estensione .tex
-- procedo alla compilazione
--
for path in string.gmatch(s,"(.-)\n") do
   -- estrazione estensione
   local ext = string.match(path,"%.(.-)$")
   
   -- se l'estensione esiste allora compilo
   -- se è un sorgente .tex
   if ext then
   if string.lower(ext) == "tex" then
      local ps = "(.-)%." .. ext .. "$"
      local name = string.match(path,ps)
      
      os.execute('pdflatex -interaction=nonstopmode "'..name..'"')
      os.remove(name..".log")
      os.remove(name..".aux")
   end
   end
end

-- end of Lua script

Ottenere il pdf di file di testo

Con poche modifiche possiamo adattare il codice precedente per ottenere uno script che converte i file di testo in formato PDF utilizzando LaTeX:

#!/usr/bin/lua

local docsource = [[
\documentclass[a4paper]{article}

\usepackage[T1]{fontenc}
\usepackage[utf8]{inputenc}
\usepackage[italian]{babel}

\usepackage[margin=20mm]{geometry}

\usepackage{inconsolata}

\begin{document}
\ttfamily
%s
\end{document}
]]

-- ottengo la lista dei file
local s = os.getenv("NAUTILUS_SCRIPT_SELECTED_FILE_PATHS")

for path in string.gmatch(s,"(.-)\n") do
   -- estrazione estensione
   local ext = string.match(path,"%.(.-)$")
   
   -- se l'estensione esiste allora creo il pdf con LaTeX
   if ext then
   if string.lower(ext) == "txt" then
      local ps = "(.-)%." .. ext .. "$"
      local filename = string.match(path,ps)
      
      -- lettura del file
      local textfile = io.open(path,"r")
      local content = string.gsub(textfile:read("*all"),"\n","\n\n")
      local sourcetexfile = string.format(docsource,content)
      textfile:close()
      
      -- creazione sorgente
      local sf = io.open(filename..".tex","w")
      sf:write(sourcetexfile)
      sf:close()
      
      os.execute("pdflatex -interaction=nonstopmode "..filename)
      os.remove(filename..".log")
      os.remove(filename..".aux")
      os.remove(filename..".tex")
   end
   end
end

-- end of Lua script

Conclusioni

Il menù contestuale è davvero comodo. In Linux possiamo utilizzare diversi linguaggi di scripting per creare nuove voci di comandi con cui semplificare il lavoro quotidiano analizzando attentamente le nostre necessità.
Un saluto.

Note tecniche

Sul sistema devono essere installati e correttamente configurati i pacchetti e gli eseguibili di un sistema TeX ed un interprete Lua.
Gli esempi potrebbero richiedere leggere modifiche per distribuzioni Linux diverse da Ubuntu 10.04.

Inviare pdf in modo sicuro


Attenzione: la procedura di messa in sicurezza di un pdf utilizzando la cifratura interna sembra essere non molto sicura.
Provvederò quindi ad aggiornare il post. Grazie.

Scarica l’articolo nel formato pdf per la stampa

Il problema

Con la diffusione di internet lo scambio di documenti avviene sempre più spesso tramite il servizio base della posta elettronica. Tuttavia i messaggi e-mail non sono sicuri ed i documenti che un tempo venivano consegnati o ritirati a mano con la sicurezza della fisicità, oggi possono essere letti da terzi con la violazione dei messaggi digitali che transitano su connessioni internet non protette.

Pensiamo al caso di una piccola azienda od un artigiano che ogni mese riceve nel formato PDF i moduli di pagamento F24 od i cedolini delle buste paga dei propri dipendenti dall’ufficio del commercialista.

Quasi sicuramente il testo del messaggio e-mail conterrà la classica dicitura sulla protezione dei dati personali secondo la legge sulla privacy, ma i documenti PDF allegati saranno invariabilmente in chiaro!!!

Cosa possiamo fare? Tornare a visitare i vari uffici per raccogliere di persona i documenti cartacei? Saremo costretti a prendere l’auto impiegando tempo ed inquinando ulteriormente l’ambiente urbano, anche se ne gioverebbero i rapporti interpersonali (il computer ci fa vivere in un mondo cerebrale…).

Una soluzione

La soluzione più robusta è quella di blindare il messaggio di posta elettronica garantendo non solo l’integrità dell’e-mail ma anche la sicurezza sull’identità del mittente. Ci si può rivolgere per esempio a software come GNUPG che fa esattamente quello che serve e di cui potete trovare una splendida guida in italiano di Mario Pascucci sempre valida e completa sia per Windows che per Linux.

Per usare GNUPG è necessario creare una coppia di chiavi, quella pubblica e quella privata, creare una password phrase per la sicurezza locale del sistema, utilizzare il sistema di server per l’upload della chiave pubblica, ed accertarsi fisicamente che la chiave pubblica del proprio corrispondente appartenga effettivamente a lui. Da quel momento sarà possibile crittografare i messaggi e pure firmarli digitalmente.

Tuttavia questo sistema mi sembra un po’ troppo. Direi quindi di sacrificare un po’ di sicurezza ma di acquistare semplicità concettuale rinunciando alla certezza del mittente del messaggio.

Una soluzione più comoda

Assumendo di voler trasmettere solo file PDF, li blinderemo con l’utility libera pdftk. Ecco quel che dovremo fare: preparare i due PC di mittente e destinatario e costruire una password robusta nota solo ad entrambi e cifrare/decifrare i documenti.

Se solo al mittente ed al destinatario è nota la password e se il destinatario riesce a decifrare correttamente il file pdf contenuto nel messaggio, allora possiamo ragionevolmente supporre che solamente i due soggetti hanno avuto accesso al messaggio (e quindi la comunicazione è sicura), e che il nostro mittente sia effettivamente colui che ha spedito il messaggio.
Diversamente vorrà dire che la password sarà stata violata in qualche modo. Dunque è essenziale che la password sia robusta e nota solo agli interessati, altrimenti tutta la procedura verrà inficiata.

Preparare il PC

Per preparare il PC basta installare pdftk. Assumendo che il sistema sia un pc Ubuntu è sufficiente digitare il comando:

sudo apt-get install pdftk

Anche per gli utenti Windows l’installazione è semplice: è sufficiente seguire la procedura descritta alla pagina ufficiale del pacchetto (si tratta di scaricare un file e scompattarlo in una cartella opportuna).

Scambiarsi la password

Una volta costruita una password robusta, per esempio ‘g456Wsa+dh’, annotatela su un foglio e recatevi di persona dal vostro corrispondente. Questo passaggio è essenziale perché come già detto, dalla sicurezza di questa password dipenderà la sicurezza di tutti i vostri documenti contenuti nei messaggi e-mail.
Se il corrispondente è geograficamente lontano potreste ricorrere al telefono od alla posta, con le modalità fantasiose che si possono inventare divertendosi (per esempio una specie di caccia al tesoro in cui la password viene suddivisa in due o tre tronconi e trasmessa con mezzi fisici diversi assieme alle istruzioni di montaggio, ma solo se il corrispondente mostra spirito goliardico).

Procedura operativa: cifratura

Sia mydoc.pdf il file pdf da trasmettere allora per cifrarlo a 128 bit aprite il Terminale (o la finestra di console di Windows) e digitate il comando:

pdftk mydoc.pdf output cryptmydoc.pdf owner_pw g456Wsa+dh user_pw IlMioNome

Fatto.

Si tratta di una normale sintassi per utility a linea di comando dove gli argomenti separati da spazi seguono il nome del comando da lanciare e sono strutturati in un primo gruppo costituito dal file di input e da un secondo gruppo composto dal nome da dare al file di output con le opzioni, separati dalla con la chiave ‘output’. Volendo elencare la sintassi potremo costruire l’elenco degli argomenti:

1 – il nome del file pdf da cifrare (nel nostro esempio mydoc.pdf);
2 – la chiave ‘output’;
3 – il nome del file cifrato (tipo ‘crypt_mydoc.pdf’) al quale va applicata la protezione con password (opzione owner_pw seguita dalla password) e l’attribuzione all’utente (opzione ‘user_pw’ seguita dal nome utente).

Procedura operativa: decifratura

Dal punto di vista del destinatario, una volta ricevuta l’e-mail con il documento pdf cifrato, potrà o aprirlo direttamente inserendo la password o riportarlo in chiaro per un utilizzo successivo più agevole, con il comando:

pdftk cryptmydoc.pdf input_pw g456Wsa+dh output mydoc.pdf

Finito.

Anche per questo comando un commento: il primo gruppo di argomenti è costituito dal file da decifrare seguito dall’opzione ‘input_pw’ a cui far seguire la password (altrimenti pdftk non potrà operare sul documento), mentre il secondo gruppo sempre separato dal primo con la chiave ‘output’, è semplicemente il nome da dare al pdf decifrato.

Alcuni screenshot dell’operazione

Ecco cosa viene mostrato se apriamo con Evince, il lettore di pdf predefinito in Ubuntu, un file pdf cifrato:

La richiesta della password per aprire il pdf cifrato con pdftk

La richiesta della password per aprire il pdf cifrato con pdftk

Nel seguente screenshot potete osservare una sessione di terminale per la cifratura ed una decifratura di un file pdf in Linux Ubuntu:

pdftk al lavoro nel terminale di Ubuntu

pdftk al lavoro nel terminale di Ubuntu

Nell’immagine seguente invece vi ho riportato il dialogo di proprietà di Acrobat Reader relativo ad un file cifrato con pdftk dove è chiaramente leggibile che ci troviamo davanti un documento blindato con cifratura a 128bit.

Il pdf è proprio blindato!

Il pdf è proprio blindato!

Evoluzione

Naturalmente vi sono modi di rendere il processo più comodo ed user friendly che convengono solo se si hanno un gran numero di file da gestire con destinatari diversi ognuno con password distinte. Penso per esempio ad un utility di spedizione ad interfaccia grafica che sfrutti un database, cifri i pdf, esegua gli invii dei documenti per e-mail e registri le trasmissioni. Con qualcosa del genere l’intera procedura diventerebbe non solo molto più sicura e professIonale ma anche molto più rapida ed efficiente rispetto alle soluzioni manuali caso per caso in chiaro.

Per approfondimenti sulle opzioni di cifratura offerte da pdftk consultate il suo manuale, mentre per il resto potete commentate il post per riportare esperienze e suggerimenti.
Bene, direi che siamo giunti al termine per cui vi saluto augurandovi buon lavoro!!!

PostgreSQL gestisce i dati, LuaLaTeX li stampa


Scarica l’articolo in formato pdf per la stampa

Argomentare sulla soluzione migliore

Vi sono moltissime situazioni gestionali in cui ricorriamo a fogli di calcolo o alle stesse directory di file per memorizzare dati e stampare report di analisi e di rendicontazione.
Sappiamo però che lo strumento migliore per definizione per gestire i dati è un database ed il migliore tra i DBMS è PostgreSQL, mentre dal lato della stampa, il migliore programma di composizione tipografica è LaTeX.

In questo post illustreremo passo passo come unire i due mondi, gestione dati con PostgreSQL e stampa di report con LaTeX, il modo migliore possibile per svolgere il compito. Non solo, usufruiremo di un altro gioiello del software libero, il sistema operativo Linux Ubuntu 10.04.

Installazione di PostgreSQL 9

Non farò cenno alla procedura per installare una distribuzione TeX, per esempio una TeX Live perché già oggetto di altri post su questo stesso blog, per esempio il post Installare TeX Live 2010 in Ubuntu Lucid Lynx, ne come si installa Ubuntu stesso.
Cominceremo invece installando PostgreSQL nella versione più recente e potente: la 9.0.3 su un sistema della serie LTS 10.04.

Ad oggi, la versione 9 di PostgreSQL non è ancora disponibile nei repository ufficiali di Ubuntu 10.04 (lo sarà per Ubuntu 11.04 Natty Narwhal, quindi per il prossimo mese di aprile), principalmente per le policy di Debian. Noi possiamo installare tranquillamente la versione 8.4 oppure rivolgersi al repository su Launchpad di Martin Pitt, il maintainer Debian per PostgreSQL.
Basterà qualche comando da terminale per portare a termine l’operazione.

Si aggiunge il repository di Martin Pitt tra le sorgenti software disponibili sul nostro sistema:

$ sudo add-apt-repository ppa:pitti/postgresql
$ sudo apt-get update
$ sudo apt-get upgrade

e poi si installa l’intero database server con il comando:

$ sudo apt-get install postgresql-9.0

Creare un nuovo utente

Con quest’ultimo semplice comando vengono eseguite numerose attività tra cui la creazione dell’utente postgres per la gestione in sicurezza del DB, a cui si può accedere soltanto se si è l’amministratore del sistema.

Ma perché si interagisce con PostgreSQL per mezzo di credenziali utente?

PostgreSQL si basa sulla struttura di rete client-server: un programma, detto server, accetta richieste di rete solo se provenienti da utenti autorizzati, mentre un programma, detto client, invia le richieste al recapito del server ed eventualmente riceve la risposta.

Nel nostro caso, il server ed il client girano sullo stesso PC ma, ovviamente, niente vieta che con le dovute impostazioni di sicurezza e di rete, il server con l’intero complesso di dati possa essere contattato da qualsiasi altro computer connesso al web (per di più indipendentemente dal sistema operativo della macchina client). In particolare è diffusissimo il caso in cui la tecnologia client-server venga sfruttata per fornire servizi dati ai PC di una rete locale LAN basata sul protocollo della rete internet.

Dunque creiamo un nuovo utente autorizzato per l’accesso al server di PostgreSQL, figura che ha un ruolo diverso da quello dell’amministratore ovvero il compito di leggere e scrivere dati da una postazione client e non quello di gestire il server.

Sia luke il nome dell’utente, allora apriamo il terminale e per prima cosa diventiamo l’admin postgres (attenzione, si tratta di un particolare account del sistema operativo), l’unico (per il momento) in grado di accedere al DB server:

$ sudo su postgres

e creiamo l’utente con password (-P) da conservare in forma criptata (-E) con un comando scorciatoia (digitate man createuser oppure createuser –help per la spiegazione delle opzioni). Ecco la sessione di lavoro con il comando createuser (confronta anche l’immagine sottostante):

postgres$ createuser -P -E
Inserisci il nome dell'utente da aggiungere:luke
Inserisci la password per il nuovo utente:
Conferma password:
Il nuovo utente dev'essere un superuser? (s/n) n
Il nuovo utente può creare database? (s/n) n
Il nuovo utente può creare altri utenti? (s/n) n
postgres@roberto-desktop:/home/roberto$ exit
$
Adding a new user in PostgreSQL from terminal

Adding a new user in PostgreSQL from terminal

Adesso potete svestire i panni dell’utente ‘postgres’, digitando semplicemente ‘exit’ (se qualcosa va storto, potete eliminare l’utente con il comando dropuser luke e ricominciare da capo).

Il server riceve la richiesta e crea il nuovo utente di lavoro, ma non abbiamo ancora terminato perché al nuovo ruolo dobbiamo assegnare l’autorizzazione necessaria. Per farlo editiamo con i diritti di amministratore il file di configurazione pg_hba.conf:

$ cd /etc/postgres/9.0/main
$ sudo gedit pg_hba.conf

Attenzione, l’operazione di modifica è delicata! Aggiungete, come vedete nella schermata la riga ‘local all luke md5’ sotto la riga già presente per l’utente postgres come segue:

# Database administrative login by UNIX sockets
local   all         postgres                          ident
local   all         luke                              md5

Abbiamo reso possibile le connessioni da rete locale per tutti i database presenti sul server (chiave ‘all’) per l’utente ‘luke’. Inoltre la password transiterà in rete locale in forma criptata con l’algoritmo md5 (consultare la documentazione di PostgreSQL al capitolo Client Authentication disponibile sul sito alla sezione Documentation).

Per far si che abbia effetto la modifica, riavviate il server da utente ‘postgres’ con i comandi (non può certo farlo un utente normale):

$ sudo su postgres
postgres$ /etc/init.d/postgresql restart
postgres$ exit
$
Editing pg_hba.conf

Editing pg_hba.conf

Se le cose, vi sembrano complicate è più che normale, il server di PostgreSQL non è certo un piccolo programma desktop, e porta con se molti nuovi concetti da imparare. In più si crea una certa confusione per il fatto che lavoriamo su un unico computer e con diverse identità utente.

Creare il nostro database

Il server può gestire molti database contemporaneamente. Per crearne uno è sufficiente sceglierne il nome e lanciare il comando seguente come utente ‘postgres’ (‘createdb –help’ per consultare le informazioni di base):

$ sudo su postgres
postgres$ createdb ricDB
postgres$ exit

Il problema

Come esempio, ho scelto una situazione semplice in cui è necessario emettere molti documenti periodici: il rilascio di ricevute di pagamento.
Ogni ricevuta ha un numero progressivo che si riazzera ogni anno, un ammontare, una data di emissione, e la data di scadenza.
Esprimiamo tutto ciò in linguaggio SQL (per documentarsi un po’ ancora la documentazione di PostgreSQL è un ottima fonte, al capitolo Tutorial):

CREATE TABLE receipts (
progrnum      integer,                -- numero mese ricevuta nell'anno
yearnum       integer,                -- anno ricevuta
amount        numeric(16,4) NOT NULL, -- importo (4 decimali e 16 cifre totali)
duedate       date          NOT NULL, -- data di scadenza
paymentdate   date,                   -- data di pagamento
receiptyn     boolean,                -- consegna al cliente avvenuta si/no
PRIMARY KEY (progrnum, yearnum)
);

ALTER TABLE receipts ADD
   CONSTRAINT month_great_than_zero
   CHECK (progrnum>0);

ALTER TABLE receipts ADD
   CONSTRAINT year_great_than_zero
   CHECK (yearnum>0);

-- inserimento di alcune ricevute di esempio
INSERT INTO receipts
(prognum, yearnum, duedate, paymentdate, amount, receiptyn)
VALUES
( 1, 2010, '2010-06-15', '2010-06-15',  159.87, 'y'),
( 2, 2010, '2010-06-15', '2010-06-16',  180.30, 'y'),
( 3, 2010, '2010-06-15', '2010-06-20',  780.99, 'y'),
( 4, 2010, '2010-07-10', '2010-08-10',  139.14, 'y'),
( 5, 2010, '2010-07-15', '2010-08-23',  800.90, 'y'),
( 6, 2010, '2010-08-01', '2010-08-01',  111.70, 'y'),
( 7, 2010, '2010-08-28', '2010-08-23',  202.50, 'y'),
( 8, 2010, '2010-09-30', '2010-09-27',  300.41, 'y'),
( 9, 2010, '2010-09-30', '2010-09-27',  100.91, 'y'),
(10, 2010, '2010-10-15', '2010-10-25',   59.87, 'y'),
(11, 2010, '2010-11-10', '2010-11-23', 1059.87, 'y'),
( 1, 2010, '2010-12-01', '2010-12-15',   19.10, 'y'),
( 2, 2011, '2011-01-08', '2011-01-12',   59.80, 'y');

Avremo dovuto in realtà prevedere anche un nominativo con una chiave esterna verso una seconda tabella, ma l’esempio si complicherebbe oltre i nostri obiettivi.

Usare il client psql

Copiate il codice SQL precedente in un file di testo e chiametelo ‘run.sql’. Lo eseguiremo per intero in un colpo solo utilizzando il client a riga di comando fornito da PostgreSQL dal breve nome di psql. Questo è un compito per il nostro luke (la directory di lavoro del terminale deve essere quella contenente il file a meno di non speficiare per intero il path di ‘run.sql’, mentre il siglificato delle opzioni ricavabile da un banale ‘psql –help’ dovrebbe comunque essere chiaro):

$ psql -U luke -d ricDB -f run.sql

Subito qualche analisi sui dati

Il client ‘psql’ può essere anche in modalità interattiva. Dovremo specificare solamente l’utente con cui connettersi al server ed il database su cui vogliamo lavorare:

$ psql -U luke -d ricDB

Una volta entrati in modalità interattiva, possimao impartire direttamente i comandi SQL anche su più righe. Leggiamo subito la versione di PostgreSQL con cui stiamo lavorando digitando (attenzione, se l’output è troppo esteso per le dimensioni della finestra del terminale i risultati sono mostrati in uno speciale modo da cui si esce per tornare al prompt interattivo premendo il tasto ‘q’, inoltre non dimenticatevi il punto e virgola finale):

ricDB=>SELECT version();

Per consultare l’intera tabella

ricDB=> select * from receipts;
  progrnum | yearnum |  amount   |   duedate  | paymentdate | receiptyn
-----------+---------+-----------+------------+-------------+-----------
         1 |    2010 |  159.8700 | 2010-06-15 | 2010-06-15  | t
         2 |    2010 |  180.3000 | 2010-06-15 | 2010-06-16  | t
         3 |    2010 |  780.9900 | 2010-06-15 | 2010-06-20  | t
         4 |    2010 |  139.1400 | 2010-07-10 | 2010-08-10  | t
         5 |    2010 |  800.9000 | 2010-07-15 | 2010-08-23  | t
         6 |    2010 |  111.7000 | 2010-08-01 | 2010-08-01  | t
         7 |    2010 |  202.5000 | 2010-08-28 | 2010-08-23  | t
         8 |    2010 |  300.4100 | 2010-09-30 | 2010-09-27  | t
         9 |    2010 |  100.9100 | 2010-09-30 | 2010-09-27  | t
        10 |    2010 |   59.8700 | 2010-10-15 | 2010-10-25  | t
        11 |    2010 | 1059.8700 | 2010-11-10 | 2010-11-23  | t
         1 |    2010 |   19.1000 | 2010-12-01 | 2010-12-15  | t
         2 |    2011 |   59.8000 | 2011-01-08 | 2011-01-12  | t
(13 rows)
ricDB=>

Per trovare il totale dei pagamenti digitate:

ricDB=> select sum(amount) as totale from receipts;

Per vedere i giorni di ritardo od anticipo rispetto alla data di scadenza, e per calcolarne la media digitare:

ricDB=> select duedate-paymentdate as diff from receipts;
ricDB=> select avg(duedate-paymentdate) as average_diff from receipts;

In ambiente reale, vi sarebbe la necessita di scrivere uno script interattivo per esempio per facilitare l’inserimento dei dati di una ricevuta, piuttosto che utilizzare direttamente il linguaggio SQL.
Bene. Adesso possiamo uscire dal client ‘psql’ digitando \q, e passare al reporting dei dati.

Creare un report con LuaLaTeX

Breve definizione di LuaLaTeX

Nel tempo sono stati sviluppati diversi motori di composizione tipografica a partire dal progenitore TeX. Questi programmi elaborano un file di testo detto sorgente, scritto nella corretta sintassi, in un processo chiamato compilazione per produrre un file di output contenente il risultato tipografico, normalmente in formato PDF. L’ultimo nato in casa TeX ed ancora in fase di sviluppo è LuaTeX che oltre a riconoscere il linguaggio TeX esteso comprende anche la capacità di eseguire codice Lua, un linguaggio di scripting semplice e generale. Ed è proprio questa la caratteristica che ci permette di connetterci al database direttamente da un sorgente come dimostreremo tra poco.

I motori di composizione fin qui citati, TeX, pdfTeX, LuaTeX, contengono istruzioni molto specializzate per compiti tipografici di dettaglio e quindi poco adatti per un uso di produzione, così ben presto sono nati ulteriori linguaggi macro di più alto livello, implementati con le funzioni primitive, il più conosciuto dei quali è senz’altro LaTeX. Ebbene il formato di alto livello equivalente di LaTeX per LuaTeX è stato chiamato LuaLaTeX.
Anche qui, vi faccio notare che se non avete capito bene cosa sono questi motori tipografici, non sorprendetevi poiché vi ho appena condensato più di 32 anni di storia di sviluppo di questi programmi. Per un esposizione pratica potete ulteriormente riferirvi alle due pagine teoria e pratica, del blog, oltre che naturalmente al sito italiano del GuIT.

La regola fondamentale

L’idea di scrivere qualche comando in un file sorgente per LuaLaTeX per eseguire una query verso un database server è molto interessante e di fattibilità tanto recente che non è ancora chiaro quale ne sia il potenziale applicativo. Si deve tuttavia rispettare una regola, la regola che rispettano tutti i programmi di reporting e che in LuaLaTeX si può potenzialmente violare:

Se si sta costruendo un report, eseguire sul database esclusivamente operazioni di lettura!

Rispettate questa regola e avrete molti problemi in meno ed un flusso di lavoro più efficiente.

Installare e configurare LuaSQL

L’accesso al database da LuaLaTeX è possibile perché esiste una libreria che possiamo caricare all’interno del sorgente: LuaSQL, altrimenti dovremo scrivere parecchio codice in C.
Per installarne la versione adatta per PostgreSQL, in Ubuntu c’è il solito immancabile comando da terminale:

$ sudo apt-get install liblua5.1-sql-postgres-2

Avvenuta l’installazione della libreria occorre indicare a LuaTeX, che entra in azione dietro le quinte quando si lancia LuaLaTeX, dove si trova la libreria LuaSQL, modificando (con i diritti di amministratore trovandosi in directory di sistema non modificabili dall’utente ordinario) un file di configurazione chiamato ‘texmf.cnf’. Ipotizzando che sia installata una distribuzione TeX Live 2010 ecco i comandi di console per aprire in modifica il file con l’editor di sistema ‘Gedit’:

$ sudo gedit /usr/local/texlive/2010/texmf/web2c/texmf.cnf

Cercate la linea che definisce la variabile CLUAINPUTS (dovrebbe essere intorno alla riga 400) e modificatela per aggiungerci il percorso ‘/usr/lib/lua’ (fate attenzione a non modificare il resto della definizione e non dimenticatevi di specificare il doppio slash finale che indica di esplorare anche le subdirectory):

% Lua needs to look for binary lua libraries distributed with packages.
CLUAINPUTS = .;/usr/lib/lua//;$SELFAUTOLOC/lib/{$progname,$engine,}/lua//

Finalmente pronti

Giunti fin qui dopo aver dettagliatamente descritto i passi necessari per la costruzione del sistema, ci dedichiamo finalmente al nostro sorgente LuaLaTeX. Comprendere il linguaggio Lua non è difficile grazie alla bravura e alla lungimiranza dei suoi creatori, il codice è semplice. Per saperne comunque di più non c’è niente di meglio che studiarsi il PiL, acronimo del titolo del libro ‘Programming in Lua’.

Nel listato che segue, un sorgente elementare in LuaLaTeX, lo scopo è quello di creare un unica ricevuta, per esempio la n. 8 del 2010. All’interno del comando \directlua si trova il codice in Lua che per prima cosa si connette al database con le credenziali dell’utente ‘luke’ e poi esegue la query per ricavare i dati della ricevuta. Il risultato della query è una tabella Lua in cui i nomi delle chiavi corrispondono ai nomi dei campi della tabella receipts del database.
L’accesso alla tabella restituita dalla query avviene tramite un oggetto cursor, al cui metodo fetch() è passata una tabella e un parametro che indica di creare le chiavi con i nomi dei campi e non con il loro semplice indice numerico.
Per rendere disponibile a TeX i dati, vengono create con l’ausilio della funzione tex.sprint() interna alla funzione makecmd(), normalissime macro.
Nel sorgente ricordatevi di sostituire alla riga 8 la ‘password’ che avete scelto al momento della creazione dell’utente ‘luke’.

\documentclass{minimal}

% connessione al server PostgreSQL
%
\directlua{
  require "luasql.postgres"
  local env = assert(luasql.postgres())
  local con = assert(env:connect("ricDB","luke","password"))

  local cur = assert(con:execute(
  "SELECT * FROM receipts WHERE prognum=1 AND yearnum=2011"))
  local result = cur:fetch({},"a")

  cur:close()
  con:close()
  env:close()

  local function makecmd( cmd, val)
     local bs = "\string\\"
     tex.sprint(bs.."def"..bs..cmd.."{"..val.."}")
  end

  makecmd("anno",    result.yearnum)
  makecmd("numric",  result.prognum)
  makecmd("importo", result.amount)
  makecmd("dataric", result.paymentdate)
  makecmd("scadenza",result.duedate)
}

\begin{document}
\hspace*{5cm}Ricevuta n. \numric /\anno del \dataric

Si rilascia ricevuta di pagamento per la somma di euro \importo,
avvenuto in data \dataric{} con scadenza in data \scadenza.

Distinti Saluti
\end{document}

Conclusioni

I software utilizzati sono potenti e complessi, e pongono pochi limiti all’utente che, proprio per questo, deve investire parecchie risorse per padroneggiarli ma ciò non esclude un utilizzo della procedura descritta nell’ambito reale, anche se non si è un esperto Database Administrator o un guru di TeX. Vantaggi e limiti risiedono nel completo controllo sulla nostra soluzione.

Nell’ambito di sviluppo invece, il post dimostra come sia possibile implementare un linguaggio specifico per i documenti TeX per consentire all’utente nuove potenti applicazioni in ambito aziendale usufruendo di una gestione centralizzata dei dati sulla rete locale.
Per esempio non è difficile immaginare servizi di gestione documentale, dove il team di colleghi condivide le informazioni producendo documenti PDF di elevata qualità con TeX e con il massimo di disponibilità della fonte dati con PostgreSQL. Efficienza, accuratezza, potenza di analisi e controllo.

Gli strumenti di Linux


Scarica l’articolo in PDF per la stampa

Quanto è immediato sviluppare

Improvvisamente mi sono reso conto che un sistema Linux è una formidabile collezione di strumenti informatici che molte volte sono immediatamente disponibili fin dalla prima installazione e, per di più, si tratta di software rilasciato con licenze libere e gratuite in continuo sviluppo.

Grazie ad internet, pochi minuti sono l’unica cosa che serve per attrezzare il nostro computer. Prendiamo per esempio Ubuntu che appena finita l’installazione offre già tutti i principali linguaggi di scripting come Bash, Python, Lua, Perl, Ruby, e che permette il prelievo dai repository ufficiali di potenti compilatori come gcc. Anche le altre maggiori distribuzioni non sono da meno.
Strumenti con cui siamo liberi di costruire i programmi complessi e le utility per compiti specifici, e che quindi ci mettono a disposizione direttamente l’enorme potenza elaborativa dell’informatica.

In altre parole, un sistema operativo libero offre un eccezionale kit di strumenti liberi per lo sviluppo e, viceversa, che è stato necessario scriverli per poter sviluppare liberamente.

Verificheremo ora quanto sia immediato accedere ad uno di questi strumenti.

Hello World!

E allora apriamolo il terminale per compilare ed eseguire il classico programma Ciao Mondo! in uno dei linguaggi per eccellenza che ha fatto il successo commerciale di Microsoft, Oracle e Google: il C++.

Step 0: gcc

Per installare gcc in Ubuntu date il comando (tranquilli se il compilatore è già installato il gestore di pacchetti vi dirà semplicemente se per esso sono disponibili o no aggiornamenti):

$ sudo apt-get install build-essential

Step 1: scrivere il sorgente C++

Aprite l’editor di testi che preferite per digitare il seguente codice del programma didattico per eccellenza:

#include <iostream>

int main () {
    std::cout << "Hello World!\n";
}

Salvate poi il file con il nome hello.cpp nella cartella cpp posizionata sulla Scrivania.
Diremo dopo qualche spiegazione sul codice perché vorrei concentrarmi per ora sulla procedura pratica di compilazione.

Il sorgente di Hello World! nell'editor

Il sorgente di Hello World! nell'editor

Step 2: compilazione

All’apertura del terminale la directory di lavoro è la /HOME dell’utente indicata anche con il carattere tilde ~ come potete notare nell’immagine quì sotto. Raggiungiamo la nostra directory di lavoro con il comando cd (change dir) usufruendo del completamento automatico dei nomi premendo il tasto Tab, e compiliamo il sorgente con il comando g++:

:~$ cd Scrivania
:~/Scrivania$ cd cpp
:~/Scrivania/cpp$ g++ hello.cpp -o hello

Il compilatore gcc per i programmi in C++ è chiamato appunto g++ e prende come argomenti il nome del file sorgente e il nome del programma risultante detto file oggetto per cui è individuato da quello che segue l’opzione -o.

La sequenza di compilazione ed esecuzione del programma

La sequenza di compilazione ed esecuzione del programma

Step 3: esecuzione

Il compilatore ha dunque prodotto il file oggetto che abbiamo chiamato hello. Si tratta di un file binario contenente le istruzioni eseguibili direttamente dal nostro processore. Eseguiamolo con:

:~/Scrivania/cpp$./hello

Quindi alla riga di comando basta semplicemente scrivere il nome del programma e dare un invio, considerando che il punto rappresenta la directory di lavoro (quindi ~/Scrivania/cpp). Si infatti i comandi digitati al terminale vengono ricercati per l’esecuzione in un set di directory di cui la nostra cpp non fa parte, allora è necessario dare il percorso completo del file oggetto, proprio con quel punto slash.

1.234.567 è un numero primo?

Non ho certo la pretesa di insegnare il C++, ma posso darvi alcune rapide spiegazioni commentando un esempio di programma più complesso: eseguire il test di primalità su un numero.

Si tratta di provare a dividere il numero n per tutti i suoi probabili divisori da 2 all’intero che non supera il valore della radice quadrata di n. Usiamo l’operatore modulo rappresentato dal simbolo di percentuale, che restituisce il resto della divisione intera tra due numeri naturali:

int a = 1234;
int b = 56;

int resto = a % b;

Nel precedente frammento di codice C++, si dichiarano gli interi a e b e si assegna ad una terza varibile il valore del resto della loro divisione. Se il resto è zero allora b è un divisore di a, che perciò non è un numero primo (in questo caso il resto vale 2).

Ecco il sorgente completo. Inseritelo in un file chiamato prime.cpp, compilatelo ed eseguitelo alla stesso modo degli step precedenti per conoscere se effettivamente il numero 1234567 è o non è un numero primo.

Potete anche copiare il file oggetto nella cartella ~/bin (la tilde vi ricordo rappresenta la home directory dell’utente), che è un percorso tra quelli del set di ricerca degli eseguibili. Una volta fatto, basterà digitare il nome del programma indipendentemente dalla working directory (veramente molto comodo).

#include <iostream>  // per cout
#include <cmath>     // per floor() e sqrt()

int main() {
    using namespace std;
 
    int n = 1234567;            // numero da testare
    int limit = floor(sqrt(n)); // limite superiore dei divisori
    bool isPrime = true;        // flag di uscita dal ciclo for
    int firstDiv;               // il più piccolo divisore trovato
    
    for (int i=2; i<=limit; i++){
         if (n%i==0){
              isPrime = false;
              firstDiv = i;
              break;
         }
    }
        
    if (isPrime) {
         cout << "The number " << n << " is prime!\n";
    } else {
         cout << "The number " << n << " is not prime, sorry\n";
         cout << "Divider: " << firstDiv << ".\n";
    }
}// end of program>

Le due direttive include del codice, a rigore non fanno parte del linguaggio. Indicano semplicemente che devono essere rese disponibili le funzionalità delle librerie iostream, per le operazioni standard di ingresso/uscita (ovvero input/output), e cmath, per le funzioni matematiche standard. Altra istruzione che ha a che fare con la gestione del codice è l’istruzione using namespace che inserisce i nomi di std nel namespace globale. Ciò significa che i nomi delle funzioni della libreria standard (namespace std) saranno direttamente disponibili senza che sia necessario specificarne il namespace, come invece abbiamo fatto nel primo programma, dove è stato utilizzato il qualificatore :: (la funzione cout, console output della libreria standard si scrive al completo std::cout).

Chi ha progettato il C++ ha fatto di tutto per consentire di strutturare i programmi in ogni maniera, ed il modo più scontato è quello di suddividerli in moduli funzionali. Alcuni particolari file chiamati header contengono appunto le dichiarazioni degli oggetti di un modulo, ne dichiarano in altre parole l’interfaccia, ed è questo che li rende possibili.

La sintassi del C++, che assomiglia volutamente a quella del genitore C, semplice, essenziale, è stata a sua volta ispiratrice di molti altri linguaggi successivi ed altrettanto famosi come Java e C#.

Alla prossima. Ciao.

Leggere la directory corrente con lualatex


Certi compiti difficili…

In LaTeX si sa, certi compiti sono particolarmente difficili, altri, forse, impossibili. Uno di questi è inserire nel documento la directory corrente. Non che sia indispensabile, anzi, direi che leggere il path del file nel documento solo perché si pensa che un giorno possa essere utile per ritrovare il file, penso sia poco elegante. Comunque…

Risolvere con lualatex

Compilare un sorgente LaTeX con lualatex comporta solo lievi modifiche, e la possibilità di far eseguire codice Lua attraverso la nuova primitiva \directlua{}.
Di per se Lua non offre sofisticate librerie per l’accesso al disco, così occorrerebbe installare la Lua File system Library installabile in Ubuntu con il relativo pacchetto nel repository universe chiamato liblua5.1-filesystem0, ed in Windows con il programma LuaRocks.
Tuttavia LuaTeX viene compilata assieme alla libreria Lua Filesystem, così è possibile utilizzarla senza che si debba installare esplicitamente.

Le funzioni della libreria lfs sono riportate nel manuale disponibile on-line su questo sito, e sono tutte memorizzate nella tabella lfs. Per i nostri scopi utilizzeremo la funzione currentdir(), che restituisce il path della directory corrente, sempre che non ci siano errori.

Riporto il codice di un sorgente LaTeX da compilare con lualatex che conterrà il percorso dello stesso file sorgente, ma che funziona solo con Linux come spiegherò fra poco.

% funziona per Linux
\documentclass{minimal}

\newcommand{\curdir}{%
   \directlua{tex.sprint(lfs.currentdir())}
}

\begin{document}
\curdir
\end{document}

Il post non vuole altro che segnalare quanto compiti assai complicati e dispendiosi in termini di tempo per trovare una soluzione, siano semplici ed eleganti con lualatex, che si basa sul nuovo motore di composizione ancora in fase di sviluppo LuaTeX.

Ed è per questo che è stata riportata la soluzione per Linux, perché quella per Windows è leggermente più complicata: occorre sostituire nel percorso del file il carattere backslash perché se il percorso della directory corrente entra così com’è nel flusso di token, verrà interpretata come una serie di comando che produrranno un errore.

Nei file system di tipo Unix, il carattere che separa i nomi è la slash e non ci sono quindi problemi. In Window se per esempio il path della directory di lavoro è “C:\Documenti” corrisponderà ai caratteri C: seguiti dalla macro \Documenti, un bel inconveniente.

Ecco il codice per Windows (e che funziona perfettamente anche in Linux perché il path rimarrà immutato). Nel codice dovendo inserire il carattere di escape del motore di composizione se ne evita l’effetto utilizzando la macro primitiva string.

% funziona anche in Windows
\documentclass{minimal}

\newcommand{\curdir}{%
    \directlua{
    require "lfs"
    local cd = string.gsub(lfs.currentdir(),
              [[\string\]],
	      [[\string\textbackslash ]])
   tex.sprint(cd)}
}

\begin{document}
\curdir
\end{document}

Rovesciare il punto di vista

Il comando \curdir così come l’abbiamo definito ha un difetto di efficienza: ogni volta che lo eseguiamo, con la libreria lfs determina la directory corrente, ovvero qualcosa che in realtà conoscevamo dalla prima chiamata alla macro.
Se per esempio nel documento il percorso del file viene inserito a piè di pagina, avremo tante chiamate a lfs.currentdir() tante quante sono le pagine stesse, ma se rovesciassimo il punto di vista sfruttando proprio il problema del backslash?

Nel seguente codice, completo per la compilazione con lualatex, si esegue la funzione per determinare il path e poi si inserisce nel flusso dei token che saranno “digeriti” dal motore tipografico, la definizione di una macro che espande semplicemente al path stesso.
In questo modo, la funzione di libreria viene chiamata solo una volta, mentre nel documento l’autore si troverà una macro standard, espandibile ed efficiente.
Per prima cosa, ho racchiuso il codice Lua in un blocco do … end, per eliminare dalla memoria qualsiasi variabile, poi ho memorizzato per comodità in una variabile stringa chiamata bs il carattere di backslash.
La definizione di una macro che espande al path è: \def\curdir{valore del path}, così è sufficiente chiamare la funzione tex.sprint() con l’equivalente del comando, utilizzando l’operatore di concatenazione delle stringhe di Lua sintatticamente definito da due punti .. .

\documentclass{minimal}

\directlua{
    do
       require "lfs"
       local bs = "\string\\"
       local cd = string.gsub(lfs.currentdir(),
              bs,
	      bs.."textbackslash ")

       tex.sprint(bs.."def"..bs.."curdir{"..cd.."}")
    end
}

\begin{document}

\texttt{\curdir}

\emph{\curdir}

\curdir

\curdir

\curdir

\end{document}

Saluti ed Auguri di Buon Natale e Felice Anno nuovo!!!

Gli editor che utilizzo


Mi sono accorto che sul pc dell’ufficio ho installato nel tempo un numero consistente di editor, ovvero di quei programmi che permettono di editare file di testo in cui, sostanzialmente, ogni byte corrisponde ad un carattere secondo una codifica.

I file di testo sono essenziali in molte situazioni, dai file di configurazione di sistema, ai file sorgenti dei programmi, dalle pagine web (il formato html è un formato testuale), allo scambio dei dati tra sistemi diversi (database e backup in particolare).

E vediamoli questi editor

SciTE: uno dei migliori è SciTE, Scintilla Text Editor, ed il momento in cui lo installai per la prima volta si perde nella notte dei tempi.

Notepad++: adatto per scrivere codice praticamente in qualsiasi linguaggio di programmazione esistente

PSPad: editor micidiale per leggere file difficili, PSPad è veramente un duro.

LeD: quest’editor aiuta nella stesura di sorgenti LaTeX. Per ora lo tengo ma non lo uso praticamente più a favore di editor più snelli e forse più stabili.

TeXMaker: se devo comporre un sorgente LaTeX d’impegno intermedio uso TeXMaker, o il suo fratellastro TeXMakerX. Sono due coltellini svizzeri giusti per compiti medi.

TeXWorks: progettato per abbassare la soglia d’ingresso al mondo TeX, questo editor è utilissimo nella correzione finale delle bozze di documenti importanti redatti con LaTeX oppure con ConTeXt. Consente infatti la ricerca diretta ed inversa tra pdf e sorgente, rendendo immediate le modifiche di finezza.

Insomma, sul mio sistema Windows sono installati ben sette diversi editor, mentre sulla mia Linux box?

Be’ Linux, come tutti gli altri sistemi derivati da Unix, è la patria degli editor. Magari contare quelli che uso su Ubuntu sarà oggetto di un altro post e non mancherebbero le sorprese…

Alla prossima. Ciao.

Kile e TeX Live 2010 su sistemi Ubuntu


Eleganza d’installazione

La gestione del software su un sistema Linux si avvale di solito di una infrastruttura a pacchetti: il reperimento dei file, l’installazione, l’aggiornamento e la rimozione dei programmi, sono tutte operazioni che si avvalgono di repository (un insieme di server internet) ed un software locale chiamato package manager.

I vantaggi di questo sistema sono molti: dal lato utente tutto il parco software sulla propria macchina è gestibile con la stessa unica semplice procedura compreso l’aggiornamento automatico mentre, dal lato del distributore, i repository consentono di controllare e predisporre opportunamente l’insieme dei programmi e delle librerie impostandone le politiche di sicurezza e di affidabilità.

Questo ordine è sconosciuto agli utenti Windows che si ritrovano i problemi dovuti al Registro di sistema, alle disinstallazioni mai perfette, al download manuale dei file da mille siti diversi e l’assenza di policy di sicurezza per il software…

Una delle migliori implementazioni del sistema dei pacchetti è quella di Debian, e quindi anche di Ubuntu, ma proprio le politiche di sicurezza particolarmente attente di queste distribuzioni, in alcuni casi possono diventare un po’ ingombranti.

Per esempio, se si installa la distribuzione TeX Live dai repository si ottiene una versione non recente e soprattutto un sistema privo dell’utility tlmgr creato per la manutenzione automatica della distro. Di solito quindi gli utenti installano TeX Live direttamente da CTAN, che anch’esso altro non è che un sistema pacchettizzato per il mondo TeX!

Anch’io sulla mia Ubuntu Lucid tengo una fiammante TeX Live 2010 installata con la procedura che ho descritto in questo post, che gestisco brillantemente attraverso il repository multipiattaforma CTAN.

Tutto perfetto ed allora perché ci vieni a raccontare queste banalità? direte voi. Pronto come un fulmine, vi risponderei: Provate ad installare Kile!

Kile è un ottimo editor specializzato per il mondo TeX a cui si accede scrivendo un sorgente in formato testo e quindi appunto con un qualsiasi editor. Ricorrendo ai repository ufficiali basterebbe digitare il comando seguente in una finestra di terminale (apt sta per Advanced Packaging Tool ed è appunto il gestore dei pacchetti di Debian/Ubuntu):

sudo apt-get install kile

Vi accorgereste ben presto che l’installazione di Kile comporta l’installazione automatica ed obbligatoria della TeX Live che risiede nei repository, ops. Infatti i pacchetti di Kile hanno come dipendenza obbligatoria i pacchetti texlive-base-bin e texlive-latex-base, come potete verificare nella pagina descrittiva del pacchetto kile per Lucid.

Eleganza della soluzione

La cosa più semplice per risolvere il problema è non considerarlo un problema, per esempio rinunciando a Kile o procedendo ugualmente all’installazione dell’editor, magari con l’opzione per apt –no-install-recommends, e continuando ad usare la TeX Live 2010 ed ignorando l’altra dei repository.

Non mi pare una modo elegante di procedere, ed allora che fare? Uhmm, si potrebbe scaricare sempre dai repository il codice sorgente di Kile, compilarlo, creare un pacchetto (l’estensione è .deb), ed installarlo sulla propria macchina con apt. Una soluzione che si basa su una sorta di repository locale. Ottimo e geniale. Peccato che serve almeno un pomeriggio intero e che sia una procedura proponibile solo per coraggiosi sperimentatori che vogliono scalare questa vetta dell’Himalaya dei pacchetti.

Altre idee?
Basterebbe imbrogliare il gestore dei pacchetti facendogli credere che i pacchetti ufficiali di TeX Live siano già installati sul sistema!

A parte il fatto che questa soluzione ha un qualcosa della furberia pratica italiana, la cosa strana è che tecnicamente è possibilissima da realizzare ed è quanto andrò ad esporre nella prossima sezione poiché la giudico… sufficientemente elegante!

Eleganza operativa

Useremo l’utility equivs il cui scopo è quello di “Circumvent Debian package dependencies”, cercando di falsare l’installazione del minor numero di pacchetti possibili.

Avvertenze: Per seguire la procedura è sufficiente un minimo di esperienza con il terminale di Linux, ma se non l’avete forse è proprio questa l’occasione di farsela. Ancora, Kile è un editor per l’ambiente KDE non per Gnome, ma si può installare anche per quest’ultimo desktop environment (almeno io non ho mai avuto grossi problemi).

Passo zero: installare equivs
Probabilmente equivs non è installato sul vostro sistema, quindi aprite un terminale e date il classico comando per apt (paradossale installare un pacchetto per imbrogliare il sistema di pacchetti con il sistema di pacchetti stesso, vero?):

sudo apt-get install equivs

Passo uno: costruire il dummy package
L’eleganza della procedura basata su equivs sta nel fatto che è perfettamente reversibile e che l’utente può operare mettendoci un po’ della sua arte e l’arte sta nel trovare il più piccolo insieme di pacchetti da far considerare al sistema come installati.

Tentando di installare Kile senza i pacchetti raccomandati, il package manager ci fornisce l’elenco dei pacchetti la cui installazione è obbligatoria:

roberto@roberto-desktop:~$ sudo apt-get install kile --no-install-recommends
[sudo] password for roberto: 
Lettura elenco dei pacchetti... Fatto
Generazione albero delle dipendenze       
Lettura informazioni sullo stato... Fatto
I seguenti pacchetti saranno inoltre installati:
  kdebase-runtime kdebase-runtime-data kdelibs-bin kdelibs5 kdelibs5-data
  konsole libattica0 libclucene0ldbl libdbusmenu-qt2 libexiv2-6 libiodbc2
  libphonon4 libplasma3 libpolkit-qt-1-0 libqca2 libqt4-designer
  libqt4-network libqt4-opengl libqt4-qt3support libqt4-sql libqt4-webkit
  libqt4-xmlpatterns libsoprano4 libssh-4 libstreamanalyzer0 libstreams0
  libxcb-shape0 libxcb-shm0 libxcb-xv0 libxine1 libxine1-bin libxine1-console
  libxine1-misc-plugins libxine1-x luatex oxygen-icon-theme
  phonon-backend-xine plasma-scriptengine-javascript shared-desktop-ontologies
  soprano-daemon tex-common texlive-base texlive-binaries texlive-common
  texlive-doc-base texlive-latex-base
Pacchetti suggeriti:
  djvulibre-bin hspell kile-doc libqca2-plugin-cyrus-sasl libqca2-plugin-gnupg
  libqca2-plugin-ossl libqca2-plugin-pkcs11 libqt4-dev gxine xine-ui
  libxine1-doc libxine-doc libxine1-ffmpeg kcm-phonon-xine debhelper
Pacchetti raccomandati:
  icoutils kubuntu-debug-installer ttf-dejavu asymptote context dblatex
  dvipdfmx dvipng kbibtex pybliographer gbib jabref latex2html lilypond
  psutils tex4ht texlive-metapost texlive-xetex exiv2 libqt4-sql-mysql
  libqt4-sql-odbc libqt4-sql-psql libqt4-sql-sqlite libqt4-sql-sqlite2
  texlive-luatex virtuoso-nepomuk lmodern texlive-latex-base-doc
I seguenti pacchetti NUOVI saranno installati:
  kdebase-runtime kdebase-runtime-data kdelibs-bin kdelibs5 kdelibs5-data kile
  konsole libattica0 libclucene0ldbl libdbusmenu-qt2 libexiv2-6 libiodbc2
  libphonon4 libplasma3 libpolkit-qt-1-0 libqca2 libqt4-designer
  libqt4-network libqt4-opengl libqt4-qt3support libqt4-sql libqt4-webkit
  libqt4-xmlpatterns libsoprano4 libssh-4 libstreamanalyzer0 libstreams0
  libxcb-shape0 libxcb-shm0 libxcb-xv0 libxine1 libxine1-bin libxine1-console
  libxine1-misc-plugins libxine1-x luatex oxygen-icon-theme
  phonon-backend-xine plasma-scriptengine-javascript shared-desktop-ontologies
  soprano-daemon tex-common texlive-base texlive-binaries texlive-common
  texlive-doc-base texlive-latex-base
0 aggiornati, 47 installati, 0 da rimuovere e 5 non aggiornati.
è necessario scaricare 81,1MB di archivi.
Dopo quest'operazione, verranno occupati 250MB di spazio su disco.
Continuare [S/n]? n
Interrotto.

Ecco che possiamo toccare con mano il problema: tra i pacchetti di libreria troviamo anche luatex, tex-common, texlive-base, texlive-binaries, texlive-common, texlive-doc-base e texlive-latex-base, ovvero tutti pacchetti già “manualmente” installati da CTAN e proprio per questo non notificati al sistema.

Bando agli indugi, prepariamo un file di testo di nome texlive.ctl (l’estensione sta per control) in cui ciascuna riga sia formata dalla sintassi Chiave: lista di valori (attenzione tutti i valori devono essere scritti su un unica riga anche se, per esempio, la lista dei pacchetti fosse molto lunga):

Section: tex
Package: texlive-dummy-essential-for-kile
Provides: luatex, tex-common, texlive, texlive-base, texlive-base-bin, texlive-binaries, texlive-common, texlive-doc-base, texlive-latex-base
Description: texlive dummy essential package. This fake package provides to the package system the information that the texlive essential packages are installed, so you can install kile with a CTAN TeX Live installation.

Mettete la vostra arte nel costruire il file di controllo con l’elenco dei pacchetti misurato secondo le vostre esigenze ma comunque sempre essenziale, e compilatelo con il comando:

equivs-build texlive.ctl

Verrà magicamente costruito il dummy package con il nome texlive-dummy-essential-for-kile_1.0_all.deb.

Passo due: installare il dummy package
Bene, installate il “paccetto” appena nato direttamente con:

sudo dpkg -i texlive-dummy-essential-for-kile_1.0_all.deb

Passo tre: installare Kile
Possiamo adesso rilanciare lo stesso comando precedente per installare Kile con apt (l’opzione –no-install-recommends è importante):

sudo apt-get install kile --no-install-recommends

Un controllo sull’output confermerà che nell’elenco dei pacchetti nuovi da installare non saranno più presenti quelli relativi a TeX Live (altrimenti interrompete l’installazione, rimuovete con il comando sudo apt-get remove texlive-dummy-essential-for-kile_1.0_all, il dummy package e ricostruitene uno adatto modificando il file di controllo).

Giunti fino a qui, Kile sarà installato correttamente perché avrà automaticamente agganciato la TeX Live 2010 (lo vedete in splendida forma nello screenshot sottostante), e sul vostro sistema non vi saranno pacchetti inutili.

Kile in action

Kile in action

Ringraziamenti

Ringrazio il Professor Claudio Beccari che mi ha solleticato questo complemento alla guida all’installazione di TeX Live 2010, e l’utente capitalaslash che con questo post sul forum di GuIT mi ha indicato la strada.

Grazie a tutti ed alla prossima.

Installare TeX Live 2010 in Ubuntu Lucid Lynx


Scarica l’articolo in formato PDF per la stampa

TeX Live 2010

Ebbene si, è uscita la nuova TeX Live 2010. Questo post percorre le tappe dell’installazione su sistemi Debian like, ma credo con piccole modifiche sia la stessa che per le altre distribuzioni Linux.

Step 0: preparare il terreno

Se provenite dalla TeX Live 2009, allora sembra logico cancellare la directory che la contiene con il comando da terminale seguente (l’opzione -r indica la cancellazione ‘ricorsiva’ quindi l’eliminazione riguarda anche le sub directory):

sudo rm -r /usr/local/texlive/2009

A questo punto procuriamoci lo script d’installazione per la piattaforma *nix che si chiama install-tl-unx.tar.gz da uno dei mirror di CTAN (per esempio da questo server universitario olandese a cui di solito mi affido visto che è uno dei più veloci)

Step 1: Setup dell’installazione

Dopo aver scompattato l’archivio in una directory di comodo, da linea di comando spostiamo il prompt con il comando ‘cd’ nella stessa directory ed avviamo lo script con il comando (utilizziamo lo stesso server evitando quello di default italiano, spesso molto lento):

sudo ./install-tl -repository ftp://ftp.snt.utwente.nl/pub/software/tex/systems/texlive/tlnet/

Ben presto il terminale si trasforma nella console di configurazione per l’installazione, in cui in modo interattivo possiamo calibrare secondo le nostre esigenze TeX Live.
Tuttavia consiglio di lasciare le impostazioni di default e procedere con lo scheme-full (2377 MB), tranne nel caso in cui sul vostro sistema lo spazio su disco scarseggi (una configurazione ad-hoc può far scendere l’occupazione di memoria a circa 600 MB sacrificando alcune componenti meno usate).

Digitate quindi senza esitare ‘i’ ed invio per il download dei file necessari… davvero impressionante la mole di pacchetti LaTeX che saranno elencati uno ad uno rigorosamente in ordine alfabetico durante il processo.

Step 2: Ultimi ritocchi

La prima cosa da fare terminata la fase di download e di generazione di mappe e formati è settare i path degli eseguibili. Si è scelto infatti di non attivare i symlink, ovvero piccoli file posizionati nella directory bin di sistema che puntano agli eseguibili installati da TeX Live, proprio per non ‘sporcare’ una directory importante, ma di attivare il percorso dal file .profile nella directory home dell’utente. Diamo quindi il comando sempre da terminale:

echo 'export PATH=/usr/local/texlive/2010/bin/i386-linux:${PATH}' >> .profile

Propongo poi una semplice soluzione per lanciare il programma tlmgr di manutenzione della distribuzione con i diritti di amministratore: creare un alias nel file .bash_aliases rinominando in sutlmgr (super user tlmgr) il comando sudo /usr/local/texlive/2010/bin/i386-linux/tlmgr

echo 'alias sutlmgr="sudo /usr/local/texlive/2010/bin/i386-linux/tlmgr"' >> .bash_aliases

Tenete conto che se la vostra architettura di sistema è a 64 bit la directory contenente i binary sarà leggermente diversa da i386-linux. Controllate giusto per scrupolo il file di sistema /etc/environment se non volendo contenesse ancora qualche traccia di PATH verso l’eventuale vecchia TeX Live 2009.

Bene, adesso siamo pronti per lavorare con la nuova TeX Live 2010!

tlmgr in action

Brevemente, vi riporto i comandi da terminale più comuni dedicati alla manutenzione della TeX Live:

-- per controllare la presenza di aggiornamenti -->
tlmgr update --list

<-- per aggiornare tutto -->
sutlmgr update --all

<-- per controllare se un pacchetto è installato -->
tlmgr show nome_del_pacchetto

<-- per cambiare il repository corrente -->
<-- (occorre controllare il percorso effettivo -->
<--  della directory systems sul mirror) -->
sutlmgr option repository http://nome.del.mirror.org/tex/systems/texlive/tlnet

Saluti a tutti.

%d blogger hanno fatto clic su Mi Piace per questo: