Ci sono operazioni che per fortuna o purtroppo non facciamo spesso, editare il file di configurazione del server X ad esempio e’ una di quelle operazioni che, a meno di modifiche hardware, una volta fatte non dobbiamo piu’ ripetere. Puo’ succede quindi che ci dimentichiamo il percorso di questi file, allora o li cerchiamo o chiediamo a Google dove possiamo trovarli. Ma c’e’ un altro sistema, che semplifica le cose, vediamolo.

Si tratta di farci uno script in Bash col quale selezionare quale file vogliamo editare, in questo modo non siamo costretti a ricordarci il percorso di ogni singolo file importante. In questo script sono presenti cinque file molto importanti, con i quali prima o poi tutti (o quasi) abbiamo a che fare, il menu’ di GRUB, la lista delle sorgenti, la tabella dei dispositivi montati, le opzioni dell’interfaccia di rete (che io uso con soddisfazione al posto di NetworkManager) e il file di configurazione del server X.

Ovviamente potete aggiungere i file che volete nell’elenco. Ecco lo script:

---8<---
#!/bin/bash

echo "1) nano /boot/grub/menu.lst"
echo "2) nano /etc/apt/sources.lst"
echo "3) nano /etc/fstab"
echo "4) nano /etc/network/interfaces"
echo "5) nano /etc/X11/xorg.conf"
echo ""
echo -n "seleziona: "
read var1
echo ""
if [ $var1 = 1 ]
then
	echo "modifica del menu di GRUB"
        nano /boot/grub/menu.lst
elif [ $var1 = 2 ]
then
	echo "modifica della lista delle sorgenti"
        nano /etc/apt/sources.list
elif [ $var1 = 3 ]
then
	echo "modifica della tabella dei dispositivi"
        nano /etc/fstab
elif [ $var1 = 4 ]
then
	echo "modifica delle interfacce di rete"
        nano /etc/network/interfaces
elif [ $var1 = 5 ]
then
	echo "modifica del file di configurazione del server X"
        nano /etc/X11/xorg.conf
fi
---8<---

copiatelo e incollatelo in un file vuoto, rinominatelo come volete (ad esempio editpersmemorati) e mettetelo nella directory /bin:
# mv editpersmemorati /bin

A questo punto quando dovete editare uno di quei file vi bastera’ dare questo comando:
# editpersmemorati
selezionare il file che vi interessa e procedere normalmente alla sua modifica.

Essendo comandi da eseguire da root, anche lo script deve essere ovviamente eseguito da root.

[^] torna su | post<li> | 

Avevo gia’ scritto un post su Conky, una piccola applicazione che permette di avere un leggero monitor di sistema ampiamente configurabile integrato sul vostro desktop. Questa volta vi indico una riga che potete aggiungere al vostro file di configurazione di Conky per vedere quando ci sono aggiornamenti dei pacchetti di Ubuntu (ma anche Debian se le integrate sudo).

Prima di tutto dovete aprire il vostro file di configurazione:
$ nano ~/.conkyrc
probabilmente e’ nella vostra home, ma potrebbe anche essere in altro luogo, lo sapete voi, quindi andate prima nella giusta directory.

Ora copiate queste due righe:

---8<---
${color #ffffff}UPDATE ${hr 1}
${color lightgrey}Nuovi pacchetti: ${color #ff0000} ${execi 3600 sudo apt-get update 1> /dev/null && apt-get search "~U" | wc -l | tail}
---8<---

e aggiungetele dove volete e con gli adattamenti grafici che volete.

Fatemi sapere perche’ nella mia Debian non ho nessuna intenzione di mettere sudo quindi non ho potuto testare se Conky effettivamente indica gli aggiornamenti disponibili quando ci sono.

[^] torna su | post<li> | 

Puo’ capitare con computer datati, a cui non abbiamo sostituito ancora l’hard disk, di dover affrontare un serio problema. Fare spazio. La scelta piu’ difficile in questo campo e’ quella di scegliere cosa cancellare e cosa tenere. Per i documenti personali ovviamente la scelta e’ influenzata da sentimenti e ricordi, non puo’ dunque essere un semplice HowTo a risolvere il dilemma. Quindi prendo in considerazione la scelta di quali pacchetti eliminare.

Per poter veramente scegliere quali pacchetti disinstallare abbiamo bisogno di sapere quali sono quelli che occupano piu’ spazio, altrimenti rischiamo di cancellare pacchetti che riteniamo superflui, ma che ai fini della creazione di spazio nel nostro HD sono addirittura inutili.

Questo e’ il comando che ci permette da terminale di conoscere i pacchetti piu’ corposi:
$ dpkg-query --show --showformat='${Package;-50}\t${Installed-Size}\n' | sort -k 2 -n | grep -v deinstall | awk '{printf "%.3f MB \t %s\n", $2/(1024), $1}'

come output ci verra’ mostrato un elenco dei pacchetti installati in ordine crescente dal piu’ piccolo al piu’ grande. Volendo, per semplificare possiamo inserire questo comando in uno script in bash, chiamarlo ad esempio bilancia.sh e poi eseguirlo:
$ ./bilancia.sh

Ma a noi interessano solo i pacchetti veramente ciccioni, ad esempio i 5 piu’ grassi in assoluto. Allora ci viene in aiuto il comando tail, col quale posiamo scegliere che ci vengano mostrati solo gli ultimi (il numero lo indichiamo tra le opzioni) risultati. Ecco come fare:
$ dpkg-query --show --showformat='${Package;-50}\t${Installed-Size}\n' | sort -k 2 -n | grep -v deinstall | awk '{printf "%.3f MB \t %s\n", $2/(1024), $1}' | tail -n 5
il comando e’ sempre piu’ lungo, ecco perche’ avevo consigliato di inserirlo in uno script in bash. Con lo script il comando sarebbe:
$./bilancia.sh | tail -n 5
quanti vederne e’ una nostra scelta, basta modificare il numero 5 e mettere ad esempo 10 (se vogliamo vedere i 10 pacchetti piu’ grandi) oppure 1 (per vedere solo il pacchetto piu’ grande).

Ora leggiamo i 5 pacchetti piu’ grassi:

[...]
58,547 MB 	 inkscape
103,293 MB 	 openoffice.org-core
104,836 MB 	 texlive-latex-extra-doc
110,059 MB 	 texlive-fonts-extra
160,965 MB 	 openclipart-png

e scegliamo quello da rimuovere. Nel mio caso rimuovendo openclipart-png libererei 161MB:
# apt-get --purge remove openclipart-png

Pero’ il mio HD e’ abbastanza grande da permettermi di tenere le inutili clipart che non usero’ mai.

Fonte: Tip: Como saber que paquete de software esta usando mas espacio

[^] torna su | post<li> | 

Creare un .deb partendo da Python
Programmate in Python e non sapete come creare un file .deb per la vostra distro Debian (o derivate come Ubuntu)? La soluzione è semplice e non serve molto per creare il vostro deb da usare oppure da condividere su internet per tutti i debianizzati.
Continua a leggere…

Five Power Tools for Pidgin
Pidgin is a great GTK2-based instant messenger application that supports a bevy of protocols, including ICQ, Yahoo!, MSN, Jabber, and AIM. It’s a terrific app in its own right, but when you add some of these power tools, Pidgin is even better.
Continua a leggere…

Installare e configurare sudo su Debian
Questa breve guida è dedicata all’installazione e alla configurazione base di sudo. Molto semplicemente, sudo è l’acronimo di superuser do. Si intuisce quindi immediatamente il significato di questo comando molto utile: fornire i privilegi di root ad un singolo utente.
Continua a leggere…

Fstab Demystified: How to Add Partitions
In this article, you will learn to understand fstab (File System Table) and its entries. We’ll show you how to add a new hard drive to fstab and mount the partitions automatically on boot. We’ll also explain some of the terminology used in fstab, and we take a look at the fdisk command.
Continua a leggere…

QuickTip: Make life easier with ssh-copy-id
Thanks to bash’s tab completion, I happened upon ssh-copy-id. Instead of all that above, just do this:
$ ssh-copy-id myhost
Continua a leggere…

[^] torna su | post<li> | 

Quando dovete eliminare un’applicazione installata attraverso il comando python setup.py install sorge il problema di come rintracciare i singoli file che setup.py ha sparso per il nostro HD. In questi casi o speriamo che chi ha scritto quell’applicazione abbia fatto anche un file per disinstallarla, oppure ci arrangiamo.

Una soluzione puo’ essere quella di pensarci prima, facendo in modo che venga scritto un elenco di tutti i file creati durante l’installazione. Supponendo di dover installare con Python l’applicazione Caio, lo si puo’ fare in questo modo:
$ python setup.py install --record filecaio.txt

Quando dobbiamo disinstallarla bastera’ indicare il file di testo che contiene l’elenco come input col seguente comando:
$ cat filecaio.txt | xargs rm -rf

Ovviamente prima di cancellare qualsiasi cosa leggete attentamente l’elenco, per evitare di cancellare per sempre file che invece vi servono. Inoltre questo metodo e’ molto grezzo, meglio non usarlo, pero’ l’ho voluto riportare lo stesso, fate voi.

Fonte: There is no setup.py uninstall

[^] torna su | post<li> | 

Appena ho installato CheckGmail e’ sorta l’esigenza di far accendere il LED blu del portatile che notifica la ricezione di una nuova email. Ero abituato a quando il file dove inserire lo zero e l’uno – a seconda si volesse spegnere o accendere il LED – era posizionato in /proc/acpi/asus/mled. Invece e’ cambiato.

Prima bastava inserire in uno script (o nell’apposito form di un programma come nel caso di CheckGmail):

echo 0 > /proc/acpi/asus/mled

per spegnere o:

echo 1 > /proc/acpi/asus/mled

per accendere il LED.

Ho notato invece che ora il percorso e’ /sys/class/leds/asus::mail/ e il file non e’ mled ma brightness. Quindi le due righe di prima diventano:

echo 0 > /sys/class/leds/asus::mail/brightness

e

echo 1 > /sys/class/leds/asus::mail/brightness

State attenti che molto probabilmente il vostro file brightness ha i permessi in scrittura solo per l’utente root, mentre per gli altri ha solo i permessi in lettura. Ovviamente dobbiamo estendere a tutti il permesso in scrittura per poter inserire lo zero o l’uno a seconda del caso. Avevo gia’ scritto come funzionano e come cambiare i permessi ai file e alle directory.

Apriamo un terminale, spostiamoci nella directory giusta:
$ cd /sys/class/leds/asus\:\:mail/
controlliamo i permessi:
$ ls -l

[...]
-rw-r--r-- 1 root root 4096  9 nov 08:48 brightness
[...]

Diamo dunque questo comando:
# chmod a+w brightness
controlliamo se i permessi sono stati assegnati correttamente:
$ ls -l

[...]
-rw-rw-rw- 1 root root 4096  9 nov 08:48 brightness
[...]

Tenete presente che al riavvio del sistema i permessi verranno ripristinati. Quindi, o ripetiamo questa operazione ogni volta, oppure la facciamo fare in automatico. Per farla in automatico apriamo il file rc.local:
# nano /etc/rc.local
e inseriamo questo prima di exit 0:

---8<---
chmod a+w /sys/class/leds/asus::mail/brightness
---8<---

Perfetto.

Ora possiamo utilizzare quel file tranquillamente, facciamo subito una prova dal terminale:
$ echo 1 > /sys/class/leds/asus\:\:mail/brightness
e il LED dovrebbe ora essere acceso.

Spegniamolo con:
$ echo 0 > /sys/class/leds/asus\:\:mail/brightness
e andiamo a sistemarci CheckGmail e visto che ci siamo anche Thunderbird.

CHECKGMAIL – Apriamo le preferenze di CheckGmail e cerchiamo due form, il primo e’ “Comando da eseguire per le nuove mail“, qui ci inseriamo:

echo 1 > /sys/class/leds/asus\:\:mail/brightness

poi il campo subito sotto “Comando da eseguire quando non ci sono mail“, dove invece inseriremo:

echo 0 > /sys/class/leds/asus\:\:mail/brightness

Date l’OK e avete finito. Ogni volta che vi arrivera’ un’email al vostro account Gmail e CheckGmail lo rilevera’, ve lo comunichera’ con l’accensione del LED del vostro portatile oltre alla normale notifica a Desktop.

THUNDERBIRD/ICEDOVE – Adesso vediamo come far fare la stessa cosa anche con Thunderbird. Il modo piu’ semplice e’ quello di scaricarvi l’apposito add-ons. Si chiama Thunderled, scaricatelo e installatelo con la solita procedura di Thunderbird: Strumenti > Componenti aggiuntivi > Installa…

Una volta installato Thunderled dovete cercarlo nel vostro HD. Trovandosi in una directory nascosta, quando aprite il vostro gestore di file e directory (Nautilus, Konqueror, Thunar, o altro) dovete rendere visibili i file e le directory nascoste con [Ctrl] + [h].

Andiamo ora alla ricerca del file che ci serve, solitamente lo trovate in /home/UTENTE/.mozilla-thunderbird/BLABLABLA.default/extensions/

A questo punto vi trovate varie directory {BLABLABLA-BLABLABLA-BLABLABLA} tante quante sono le estensioni del vostro Thunderbird. Se Thunderled e’ stata l’ultima estensione ad essere installata con tutta probabilita’ la directory giusta e’ l’ultima. Per esserne certi apriamo la directory e leggiamo il file chrome.manifest.

Una volta accertato di trovarci nella giusta directory spostiamoci nella sottodirectory chrome. Troveremo il file thunderled.jar, che nonostante l’estensione e’ un semplice file ZIP. Dunque rinominiamolo (thunderled.zip) ed estraiamolo. Otterremo tre directory, entriamo in content/thunderled e apriamo il file overlay.js col nostro editor di testo.

Cerchiamo queste righe:

[...]
else{
        file.initWithPath("/bin/sh");
        if(x==1)
                var args = ["-c","echo 1 \> /proc/acpi/asus/mled"];
        else
                var args = ["-c","echo 0 \> /proc/acpi/asus/mled"];
        }
        var process = Components.classes["@mozilla.org/process/util;1"].createInstance(Components.interfaces.nsIProcess);
        process.init(file);
        process.run(false, args, args.length);
        }
[...]

e sostituiamole con queste:

---8<---
else{
        file.initWithPath("/bin/sh");
        if(x==1)
                var args = ["-c","echo 1 \> /sys/class/leds/asus::mail/brightness"];
        else
                var args = ["-c","echo 0 \> /sys/class/leds/asus::mail/brightness"];
        }
        var process = Components.classes["@mozilla.org/process/util;1"].createInstance(Components.interfaces.nsIProcess);
        process.init(file);
        process.run(false, args, args.length);
        }
---8<---

Salvate ed uscite. Adesso dovete ricreare l’archivio thunderled.zip e rinominarlo in thunderled.jar.

Finito. Da ora in poi ogni volta che Thunderbird scarichera’ una nuova email vi si accendera’ il LED del portatile.

[^] torna su | post<li> | 

Qualche giorno fa stavo pensando tra me e me che per guardare se mi arriva un’email sul mio indirizzo Gmail e’ un po’ scomodo ogni volta dover accedere a Gmail. Mi sono dunque accorto che non avevo ancora un notificatore per Gmail sul mio desktop. Mancanza grave di questi tempi a quanto pare (nonostante si possa benissimo farne a meno).

Comunque ho deciso di installarne uno, ho optato per CheckGmail:
# apt-get install checkgmail

Poi ho impostato la varie opzioni e l’ho subito messo all’opera, ma lui per tutta risposta mi ha scritto:

401 Unauthorized

Ho cercato un po’ in giro per la rete e come soluzione davano questa:
$ checkgmail -update
che aggiorna il file checkgmail,

oppure quest’altra:
$ checkgmail -no_cookies
che avvia il programma con l’opzione no_cookies.

Sono soluzioni che non mi piacciono molto, allora ho cercato un po’ sul sito del programma e ho deciso di fare cosi’. Mi sono scaricato tutti i file e le directory necessarie in una directory:
$ svn co https://checkgmail.svn.sourceforge.net/svnroot/checkgmail checkgmail
poi mi sono spostato dentro quella directory:
$ cd checkgmail
e ho copiato il file eseguibile checkgmail nella directory /usr/bin/:
# sudo cp checkgmail /usr/bin/

Adesso funziona alla perfezione.

[^] torna su | post<li> | 

Accendendo il computer la prima cosa che vediamo con una parvenza grafica e’ GRUB, un boot loader che ci consente di scegliere quale OS avviare e/o con quale versione del Kernel. La sua grafica e’ spartana, anche se e’ comunque possibile abbellirlo (inserendo una immagine). Vediamo come.

Big GRUB, sexy vero?

Adesso dobbiamo scegliere quella che vogliamo noi. Io ho scelto questa (debblue.xpm.gz):

ma ce ne sono altre, e potete anche trovarne di migliori in giro per la rete, o crearvela voi (state solo attenti alle caratteristiche, dimensioni, formato, colori, ecc.).

Comunque abbiate scelto, ora dovete modificare il file menu.lst del GRUB per inserire il percorso della vostra immagine:
# nano /boot/grub/menu.lst

Ora leggete attentamente il file, dovete capire (se non lo sapete) dove si trova il boot, in quale partizione (hd0,0 o hd0,1 o hd1,1 o altro). Inserite quindi queste righe dove volete:

---8<---
# Aggiungi Splash Screen a GRUB
splashimage=(hd0,1)/boot/grub/splashimages/debblue.xpm.gz
---8<---

ad esempio subito dopo l’indicazione del timeout (al posto di hd0,1 mettete quello giusto).

Se avete messo il boot in una partizione tutta per lui (diversa da quella di root per intenderci), la riga da inserire sara’ questa:

---8<---
# Aggiungi Splash Screen a GRUB
splashimage=(hd0,0)/grub/splashimages/debblue.xpm.gz
---8<---

ovviamente come nel caso di prima sostituite a hd0,0 la giusta partizione (se differente).

Se doveste avere il nuovo GRUB2 la procedura cambia leggermente, scarichiamoci il pacchetto con:
# apt-get install grub2-splashimages
che mettera’ le immagini in questa directory: /usr/share/images/grub/.

Una volta scelta l’immagine che ci piace modifichiamo il file 05_debian_theme da terminale col comando:
# nano /etc/grub.d/05_debian_theme
la modifica da fare riguarda questa riga:

[...]
for i in {/boot/grub,/usr/share/images/desktop-base}/moreblue-orbit-grub
[...]

da sostituire con quest’altra:

---8<---
for i in {/boot/grub,/usr/share/images/desktop-base,/usr/share/images/grub}
---8<---

Infine date un:
# update-grub
per completare il tutto.

A cosa serve avere una splashimage nel GRUB? A niente, il timeout generalmente viene fatto durare pochissimo, dai 3 ai 5 secondi e’ il tempo che preferisco. E’ un tempo sufficiente per leggere e scegliere e non dobbiamo attendere troppo se la nostra scelta dovesse ricadere su quella preimpostata. Quindi questo HowTo credo proprio vada messo tra le inutilita’.

Giusto per aggiungere qualche elemento di utilita’ in questo post, indico due procedure che potrebbero rivelarsi utili.

La prima procedura prevede l’utilizzo di un CD contenente una distribuzione Live. Prima di tutto dobbiamo avere un quadro delle partizioni, usiamo (dalla distro Live) questo comando:
fdisk -l
a questo punto dobbiamo montare la partizione di root (e se separata anche quella di boot). Per montare la partizione di root creiamo una directory:
mkdir /mnt/quivaroot
e montiamo:
mount -t ext3 /dev/hda2 /mnt/quivaroot
ovviamente se il vostro root si trova in una partizione diversa da hda2 sostituite con quella giusta nel comando.

Se abbiamo il boot in una partizione a parte dobbiamo montare anche quella. Dunque creiamo la directory per contenere il boot (in una sottodirectory di quella creata per il root):
mkdir /mnt/quivaroot/quivaboot
e montiamo:
mount -t ext3 /dev/hda1 /mnt/quivaroot/quivaboot
anche qui, sostituite la giusta partizione ad hda1.

Adesso col comando chroot dobbiamo far si che la directory quivaroot diventi la nostra directory di root:
chroot /mnt/quivaroot

a) A questo punto qualcuno consiglia questa procedura:
grub-install /dev/hda
shutdown -r now
b) qualcun altro quest’altra:

grub
root (hd0,1)
setup (hd0)
quit

c 1) Se dovessimo avere GRUB2:
mkdir /mnt/boot
mount /dev/hda2 /mnt
mount /dev/hda1 /mnt/boot
e infine:
grub-install --root-directory=/mnt/ /dev/hda
ovviamente sostituite hda? con la giusta partizione (se diversa).

c 2) Se dovessimo aver installato o aggiornato una nuova versione di Windows (o altro SO), dobbiamo aggiornare il file di configurazione di GRUB2:
# os-prober
verranno cosi’ rilevati i SO installati nel computer, a questo punto vi bastera’ dare questo comando:
# update-grub
per rigenerare il file grub.cfg.

c 3) Se non dovessimo avere il file di configurazione di GRUB2 (grub.cfg) dobbiamo procedere in questo modo per ricrearlo:

mount --bind /proc /mnt/proc
mount --bind /dev /mnt/dev
mount --bind /sys /mnt/sys
chroot /mnt update-grub
umount /mnt/sys
umount /mnt/dev
umount /mnt/proc
exit

Fatto.

E’ anche possibile utilizzare Super Grub Disk al posto di una distribuzione live. Oppure e’ anche possibile utilizzare GRUB4DOS. Dovete scaricarlo da qui, poi dipende da quale sistema Windows avete.

- Per Windows XP: nel pacchetto grub4dos c’e’ un file chiamato grldr, dobbiamo prenderlo e copiarlo in C:\.Edit boot.ini aggiungendo questa riga:

---8<---
c:\grldr=”grub4dos”
---8<---

- Windows Vista e Windows 7: copiate il file grldr e il file grldr.mbr in C:\.Create boot.ini e in questo file scrivete queste righe:

---8<---
[boot loader]
timeout=0
default=c:\grldr.mbr
[operating systems]
C:\grldr.mbr=”Grub4Dos”
---8<---

Adesso bisogna creare il file menu.lst con questo contenuto:

---8<---
timeout 0
default 0
title grub2
find --set-root /boot/grub/core.img
kernel /boot/grub/core.img
boot
---8<---

Ora riavviamo e scegliamo il boot da Grub4Dos, scegliamo di avviare la nostra distribuzione GNU/Linux e dopo aver effettuato il login diamo questo comando:
# grub-install /dev/hda
ovviamente sostituite hda con la giusta partizione (se diversa).

Se il vostro GRUB si trova nell’MBR puo’ essere utile fare una copia di sicurezza tramite il comando dd (caso mai per qualche motivo dovesse incasinarsi l’MBR):
# dd if=/dev/sda of=~/mbr.img bs=512 count=1
e quando dovesse servire ripristinarlo con questo comando:
dd if=mbr.img of=/dev/sda bs=512 count=1

Comando di risoluzione universale dei problemi con Microsoft Windows

Se invece in un computer doveste avere solo Windows e vi si rovina l’MBR come fate? Capita con Windows che improvvisamente non si avvia piu’, resta una triste schermata nera e si riavvia, in un loop infinito che per compassione terminate staccando la spina. In questo caso dovete inserire il CD originale di Windows, e dalla console di ripristino digitate:

FIXMBR
FIXBOOT
BOOTCFG /REBUILD
CHKDSK /R

questi comandi sono in ordine di gravita’, a volte basta solo il primo, a volte sono necessari i primi due, a volte i primi tre e spesso sono necessari tutti e quattro.

Se visto che ci siete volete pure convertire la vostra partizione di Windows in NTFS diamo anche questo comando:
CONVERT C: /FS:NTFS
comando che consente la conversione senza perdita dei dati. Il processo inverso (da FAT a NTFS) invece richiede la formattazione con perdita di tutti i dati.

[^] torna su | post<li> | 

Stamattina ho scritto come sia possibile usare le regole di Udev per far si che i dispositivi vengano montati in una directory piuttosto che in un’altra a seconda del dispositivo. Ora vedremo come aggiungere regole a Udev per fargli eseguire un determinato script quando si monta una penna USB (o quando la si smonta).

Prima di tutto dobbiamo ottenere informazioni sull’hardware, quindi diamo questo comando da terminale:
# tail -f /var/log/syslog
e inseriamo la nostra periferica USB (penna, HD esterno). Otterremo un bel po’ di testo come output, segniamoci il percorso della device (ad esempio /dev/sdb).

Ora che sappiamo dove trovare la periferica, possiamo ottenere molte informazioni, facciamolo con questo comando:
$ udevinfo -a -p $(udevinfo -q path -n /dev/sdb)

Anche in questo caso come output otterremo molte righe di testo, ma tra questi, i dati che ci servono non sono molti, segnateveli, perche’ vi serviranno per scrivere la/e regola/e.

Un file di regole per Udev e’ ad esempio questo:

---8<---
BUS=="scsi", SYSFS{model}=="BLAblabla", KERNEL=="sd?1", NAME="pendatilavoro", OWNER="luca"
SUBSYSTEM=="block", ACTION=="add", RUN+="/etc/udev/dev.d/script/mount.dev"
SUBSYSTEM=="block", ACTION=="remove", RUN+="/etc/udev/dev.d/script/umount.dev"
---8<---

da salvare ad esempio su /etc/udev/rules/10-dam.rules (il numero davanti al nome indica la priorita’ di esecuzione, piu’ basso e’ il numero prima verra’ eseguita la regola).

Questo e’ il significato dei valori:

BUS=="scsi" =>                      la penna USB viene riconosciuta come disco scsi
SYSFS{model}=="UMni512MB*IOM2J4" => un modo per riferirsi a quella specifica penna USB
KERNEL=="sd?1" =>                   la prima partizione della penna
NAME="pendatilavoro" =>                  Udev mettera' la nostra penna nel percorso /dev/pendatilavoro (per la prima partizione)
OWNER="luca" =>                    il percorso /dev/pendatilavoro e' dell'utente luca

SUBSYSTEM=="block", ACTION=="add", RUN+="/etc/udev/dev.d/script/mount.dev" => quando la periferica viene inserita viene eseguito lo script RUN+="/etc/udev/dev.d/script/mount.dev"

SUBSYSTEM=="block", ACTION=="remove", RUN+="/etc/udev/dev.d/script/umount.dev" => quando la penna viene estratta viene eseguito lo script RUN+="/etc/udev/dev.d/script/umount.dev"

Aggiungendo script, potete ad esempio fare in modo che la penna si sincronizzi con una directory del vostro hard disk (potete utilizzare rsync) o quando la inserite, o prima di smontarla. Con rsync il comando e’ una cosa del genere:
$ rsync -a -v --delete /dev/pendatilavoro /home/utente/hddatilavoro
quindi con le dovute modifiche fate lo script e inserite il suo percorso nella regola di Udev.

Fonte: Udev – action add – remove

[^] torna su | post<li> | 

Abbiamo visto qualche tempo fa come montare in automatico i dispositivi USB, in quel caso i dispositivi venivano montati in un percorso casuale. Insomma, non proprio casuale, veniva montato nella prima directory libera di un elenco (con usbmount). Ma, come faccio a far montare in automatico un determinato dispositivo rimovibile in una determinata directory? Mi spiego meglio, se abbiamo due penne USB di diversa marca e un HD USB, come facciamo a fare in modo che la penna A venga montata nella directory A, la penna B nella directory B e l’HD esterno C nella directory C? Il modo esiste, vediamolo.

Prima di tutto bisogna conoscere qualcosa di udev, sapere come funziona e come scriverne le regole. Ho capito, non ne avete voglia.

Le regole di udev si trovano nella directory /etc/udev/rules.d/, meglio non modificare le regole gia’ esistenti, creiamo dunque un nuovo file, e siccome le regole vengono lette e processate in ordine alfabetico, il file che andiamo a creare per essere letto per primo lo possiamo nominare:

00_local.rules

Ma prima dobbiamo sapere come vengono identificati i nostri dispositivi. Diamo dunque il seguente comando:
# tail -f /var/log/messages
e inseriamo il dispositivo rimovibile.
Oppure, inseriamo il dispositivo e poi diamo questo comando:
$ dmesg
Possiamo subito notare il posizionamento (sda ad esempio), il tipo di prodotto e il modello (ad esempio External HDD e Western Digital).

Ora diamo il comando:
$ udevinfo -a -p /sys/block/sda
se il dispositivo non si trova in sda, ma sdb, sdc, o quello che e’, inserite il percorso giusto. Esce un output piuttosto lungo, ma non spaventatevi, le cose che ci interessano sono tre, annotatevi:

---8<---
KERNEL=="sda"
---8<---
ATTRS{vendor}=="WD"
---8<---
ATTRS{model}=="5000AAV External"
---8<---

Queste informazioni sono sufficienti per creare una regola. Infatti sono informazioni che possono essere reperite da udev, che le puo’ utilizzare per riconoscere il dispositivo.

Tutto quello che abbiamo visto fin qui e’ propedeutico alla scrittura delle regole. Veniamo ora alla scrittura della/e regola/e. Vogliamo che quando inseriamo il nostro Hard Disk Western Digital, venga montato nella directory /media/hdwd.
Creiamo il nostro file:
# nano /etc/udev/rules.d/00_local.rules
e aggiungiamoci la regola:

---8<---
KERNEL=="sda", ATTRS{vendor}=="WD", ATTRS{model}=="5000AAV External", NAME="%k", SYMLINK+="usbhdwd"
ACTION=="add", KERNEL=="sda", ATTRS{vendor}=="WD", ATTRS{model}=="5000AAV External", RUN+="/bin/mkdir /media/hdwd"
ACTION=="add", KERNEL=="sda", ATTRS{vendor}=="WD", ATTRS{model}=="5000AAV External", RUN+="/bin/mount -t vfat -o sync,flush,uid=1000,gid=100 /dev/usbhdwd /media/hdwd"
ACTION=="remove", KERNEL=="sda", ENV{ID_VENDOR}=="WD", ENV{ID_MODEL}="5000AAV_External", RUN+="/bin/umount /media/hdwd"
ACTION=="remove", KERNEL=="sda", ENV{ID_VENDOR}=="WD", ENV{ID_MODEL}="5000AAV_External", RUN+="/bin/rmdir /media/hdwd"
---8<---

Se fosse un Hard Disk partizionato, allora la regola sarebbe questa:

---8<---
KERNEL=="sd?1", ATTRS{vendor}=="WD", ATTRS{model}=="5000AAV External", NAME="%k", SYMLINK+="usbhdwd"
ACTION=="add", KERNEL=="sd?1", ATTRS{vendor}=="WD", ATTRS{model}=="5000AAV External", RUN+="/bin/mkdir /media/hdwd"
ACTION=="add", KERNEL=="sd?1", ATTRS{vendor}=="WD", ATTRS{model}=="5000AAV External", RUN+="/bin/mount -t vfat -o sync,flush,uid=1000,gid=100 /dev/usbhdwd /media/hdwd"
ACTION=="remove", KERNEL=="sd?1", ENV{ID_VENDOR}=="WD", ENV{ID_MODEL}="5000AAV_External", RUN+="/bin/umount /media/hdwd"
ACTION=="remove", KERNEL=="sd?1", ENV{ID_VENDOR}=="WD", ENV{ID_MODEL}="5000AAV_External", RUN+="/bin/rmdir /media/hdwd"
---8<---

Quando scrivete le vostre regole, state attenti a inserire i dati che corrispondono al vostro dispositivo. Ora potete creare in questo modo anche le regole per la vostra penna USB di marca x e per quella di marca y. Questo sistema e’ molto utile quando dovete usare piu’ dispositivi rimovibili contemporaneamente, venendo montati sempre nella stessa posizione, non rischiate di confondervi tra un dispositivo e l’altro.

[^] torna su | post<li> | 

Molti di voi avranno un account su Twitter, qualcuno di voi (spero) avra’ un account su Identi.ca (che diversamente da Twitter e’ open source), ma quasi tutti useranno i metodi tradizionali per scrivere i messaggi su questi due microblogging.

Ossia, andando sul sito, facendo login e scrivendo il messaggio che si vuole. Magari qualcuno usera’ Pidgin (o un altro programma di messaggistica istantanea), che permette molto semplicemente di inviare i messaggi su Identi.ca tramite Jabber. E’ possibile una cosa simile anche con Twitter, ma non tramite Jabber, bensi’ con un apposito plugin di Pidgin. Ma a noi non interessano tutti questi metodi, noi lo vogliamo fare da terminale, possibilmente con uno script.

Prima di tutto ci occorre cURL, quindi se non lo abbiamo lo dobbiamo installare:
# apt-get install curl
e leggiamoci un po’ il manuale (che non guasta mai):
$ man curl

Vediamo Twitter per primo, poi vedremo Identi.ca (che e’ un po’ piu’ complesso).

TWITTER – Ora dobbiamo aprire un terminale e scrivere un comando molto semplice:
$ curl -u username:password -d status="Il tuo messaggio." http://twitter.com/statuses/update.xml
se avete letto il manuale sapete gia’ cosa fa questo comando. Va alla pagina http://twitter.com/statuses/update.xml e fa login con username e password che gli abbiamo indicato e invia come dati cio’ che e’ contenuto all’interno delle virgolette. Ad esempio:
$ curl -u Turiddu:Brabalonga -d status="Ciao al Mondo." http://twitter.com/statuses/update.xml

Possiamo fare anche uno script per semplificare il tutto, lo facciamo in bash [1]:

---8<---
#!/bin/bash

messaggio=${1}

curl -k --basic --user Turiddu:Brabalonga --data "status=${messaggio}" --output /dev/null http://twitter.com/statuses/update.xml
---8<---

Troppo lungo? Possiamo ridurlo a:

---8<---
#!/bin/bash

curl -u Turiddu:Brabalonga -d status=″$1" http://twitter.com/statuses/update.xml
---8<---

Facile facile. Prendete uno di questi due script, copiateli all’interno di un file di testo vuoto, rinominatelo come twitter.sh (o come volete voi). Rendete il file eseguibile:
$ chmod 777 twitter.sh

e provatelo subito:
$ .twitter.sh "Ciao caro Mondo."

IDENTI.CA – Devo dirvi la verita’, pensavo che con identi.ca fosse uguale il procedimento, pensavo quindi che fosse sufficiente:
$ curl -u Turiddu:Brabalonga -d status="Il tuo messaggio." http://identi.ca/api/statuses/update.xml

Invece in questo modo non riesce ad autenticarsi, e quindi (ovviamente) non manda il messaggio.

Cercando la soluzione ho trovato questa possibilita’, dividere il procedimento in due parti, la prima fa il login, la seconda manda il messaggio (non l’ho provata questa soluzione, quindi non garantisco nulla):

In questo caso e’ quasi d’obbligo lo script:

---8<---
#!/bin/bash

messaggio=${1}

curl --data "nickname=Turiddu" --data "password=Brabalonga" -c ~/.cookies.txt -o /dev/null http://identi.ca/main/login

curl --data "status_textarea=${messaggio}" -b ~/.cookies.txt -c ~/.cookies.txt -o /dev/null http://identi.ca/notice/new
---8<---

Anche in questo caso, copiate il testo dello script in un file vuoto, rinominatelo in identica.sh (o come volete), rendetelo eseguibile:
$ chmod 777 identica.sh
e provatelo subito:
$ .identica.sh "Ciao caro Mondo."

Ovviamente potete modificare gli script come piu’ vi piace, ad esempio per rendere variabili anche username e password, cosi’ potete inserirle a piacere (se doveste avere piu’ di un account). O mettere un controllo per verificare la lunghezza del messaggio (non deve superare i 140 caratteri) prima dell’invio.

[1] Ovviamente al posto di Turiddu (username) e Brabalonga (password) dovete mettere i vostri dati. [^]

[^] torna su | post<li> | 

Leggere file xls con PHP
Esiste infatti un progetto su Sourceforge che tramite la classe ExcelReader rende disponibile tutto ciò che ci occorre.
Continua a leggere…

Mount penna usb senza togliere-reinserire
$ eject /dev/sdg; sleep 1; eject -t /dev/sdg
Continua a leggere…

Useless Linux Terminal Commands
Here are several useless Linux terminal commands: clear, rev, vdir, ul.
Continua a leggere…

Simple gui backup tool backerupper
Backerupper not only does a good job of simple backups, it also adds an icon to the GNOME notification area for quick access.
Continua a leggere…

Scaricare o guardare in un lettore i video di ustream.tv
Su ustream.tv è possibile guardare dei canali in diretta, ma il sito ospita anche delle registrazioni.
Continua a leggere…

[^] torna su | post<li> | 

Quando apriamo un terminale per eseguire un comando, ma non siamo sicuri sulle opzioni da dare o su altri comandi, l’unica cosa da fare e’ cercare nel manuale del comando (o su internet). Puo’ pero’ risultare scomodo (nel primo caso) leggere il manuale sul terminale, potremmo trovare piu’ comodo portare il testo del manuale su di un file txt [1] o su di un file pdf. Vediamo come.

Normalmente per leggere il manuale di un comando scriviamo sul terminale:
$ man COMANDO
soprattutto se l’output e’ “corposo” risulta piuttosto scomodo leggerlo sul terminale. Per una comoda lettura bastano poche righe sul file ~/.bashrc, insomma, una personalizzazione della bash.

MAN SU TXT – Apriamo il file di configurazione della bash che si trova nella nostra home:
$ nano ~/.bashrc
e aggiungete quanto segue:

---8<---
function mansutxt()
{
man --encoding=ascii $1 >  file.txt
mousepad file.txt
rm file.txt
}
---8<---

Ovviamente al posto di mousepad mettete il vostro editor di testo preferito (kwrite, gedit, ecc.). Ora salviamo e proviamo subito il funzionamento del piccolo script:
$ mansutxt COMANDO
ad esempio:
$ mansutxt gpg

Se volete scegliere voi caso per caso l’editor di testo senza dover mettere mano al file .bashrc, basta che al posto di quanto scritto sopra scriviate:

---8<---
function mansutxt()
{
man --encoding=ascii $1 >  file.txt
$2 file.txt
rm file.txt
}
---8<---

in questo caso su terminale dobbiamo specificare oltre al comando di cui vogliamo leggere il manuale anche l’editor di testo:
$ mansutxt COMANDO EDITOR
ad esempio:
$ mansutxt gpg mousepad

MAN SU PDF – Se volessimo invece leggere il manuale su un file pdf, dobbiamo sempre aprire il file .bashrc:
$ nano ~/.bashrc
e questa volta scrivere:

---8<---
function mansupdf()
{
man -t $1 >  file.ps
ps2pdf file.ps && rm -f file.ps
xpdf file.pdf
rm file.txt
}
---8<---

Se al posto di xpdf vogliamo usare un altro programma basta scriverlo al posto di xpdf (ad esempio epdfviewer). Ora salviamo e proviamo subito il funzionamento del piccolo script:
$ mansupdf COMANDO
ad esempio:
$ mansupdf gpg
Possiamo anche inserire queste righe al posto di quelle appena viste:

---8<---
function mansupdf()
{
man -t $1 >  file.ps
ps2pdf file.ps && rm -f file.ps
$2 file.pdf
rm file.txt
}
---8<---

in questo caso dobbiamo specificare il comando del lettore di pdf:
$ mansupdf COMANDO EDITOR
ad esempio:
$ mansupdf gpg epdfviewer

Ovviamente nulla ci vieta di inserire entrambi gli script (mansutxt e mansupdf) sul file .bashrc:

---8<---
function mansutxt()
{
man --encoding=ascii $1 >  file.txt
mousepad file.txt
rm file.txt
}

function mansupdf()
{
man -t $1 >  file.ps
ps2pdf file.ps && rm -f file.ps
xpdf file.pdf
rm file.txt
}
---8<---

Fatto, ora quando dovete controllare il manuale di un comando potete scegliere di leggerlo su terminale:
$ man COMANDO
su un editor di testo:
$ mansutxt COMANDO
o su un lettore di pdf:
$ mansupdf COMANDO

[1]Liberamente tratto da: Strani caratteri reindirizzando file .txt [^]

[^] torna su | post<li> | 

Normalmente il terminale lo utilizziamo in una finestra piccola, oppure la ingrandiamo all’occorrenza (F11). Nel caso ci servisse a tutto schermo al limite usiamo direttamente [Ctrl]+[Alt]+[Fn] per accedere al login senza server grafico.

Tutte valide possibilita’, ma se vogliamo che nel pannello ci sia direttamente un lanciatore per un terminale a pieno schermo dobbiamo aggiungere un elemento nel nostro pannello, e alla voce comando inserire questo:

---8<---
TERMINALE --full-screen
---8<---

Se vogliamo che il terminale occupi tutto lo schermo, senza l’impedimento del pannello (o dei pannelli), dobbiamo invece inserire:

---8<---
TERMINALE --full-screen --hide-menubar
---8<---

Ovviamente al posto di TERMINALE dovete inserire il vostro emulatore di terminale, che sia gnome-terminal, konsole, xfce4-terminal, o qualunque altro. Se ad esempio usiamo Xfce come DE, allora nel lanciatore come comando dobbiamo inserire questo:

---8<---
xfce4-terminal --full-screen --hide-menubar
---8<---

e semplicemente premendo l’icona sul pannello vedremo aprirsi il nostro terminale a pieno schermo.

[^] torna su | post<li> | 

Chissa’ quante volte vi siete trovati per le mani un file pdf da cui volevate togliere alcune pagine, aggiungerne altre spostarlo, girarlo, inclinarlo, mangiarlo. Per tutto questo e tanto altro ancora ci viene in aiuto Pdftk (PDF ToolKit), un potente manipolatore di pdf.

Il martello manipolatore

Proseguiamo leggendo il manuale e la panoramica delle numerose opzioni:
$ man pdftk
$ pdftk --help
Si, e’ lungo e noioso, allora ecco le principali cose che si possono fare con Pdftk e i comandi per eseguirle.

Se avete piu’ file pdf ma volete unirli in un unico file dovete dare questo comando:
$ pdftk cagliari.pdf sassari.pdf oristano.pdf nuoro.pdf cat output sardegna.pdf
in questo modo tramite il comando cat i vari file verranno concatenati in un unico file.

L’ordine col quale i documenti verranno inseriti nel file finale lo decidete voi, sara’ anche possibile assegnare una lettera (handle) ai vari file:
$ pdftk A=cagliari.pdf B=sassari.pdf C=oristano.pdf D=nuoro.pdf cat A B C D output sardegna.pdf
in questo modo cambiare l’ordine sara’ semplice, dovremmo solo spostare quelle quattro lettere:
$ pdftk A=cagliari.pdf B=sassari.pdf C=oristano.pdf D=nuoro.pdf cat C D A B output sardegna.pdf

Grazie agli handle possiamo sbizzarrirci e unire i nostri file pdf nell’ordine che preferiamo, anche le singole pagine di ogni file. Se ad esempio vogliamo che il nostro file finale sardegna.pdf abbia come prima pagina la terza pagina di cagliari.pdf, come seconda pagina la prima pagina di sassari.pdf, come terza quarta e quinta pagina la prima, la seconda e la terza pagina di oristano.pdf poi come sesta, settima, ottava e nona pagina la seconda, terza, quarta e quinta pagina di nuoro.pdf e infine come decima pagina la terza pagina di sassari.pdf daremo questo comando:
$ pdftk A=cagliari.pdf B=sassari.pdf C=oristano.pdf D=nuoro.pdf cat A3 B1 C2-3 D2-5 B3 output sardegna.pdf
fatto.

Con gli handle possiamo anche agire su un singolo file (anche se per un singolo file non e’ obbligatorio utilizzare gli handle), per prendere alcune pagine e con queste creare un altro file. Ecco coma fare, se vogliamo prendere le pagine dalla terza alla ventiduesima del file cagliari.pdf per creare il file storia-di-cagliari.pdf allora diamo questo comando:
$ pdftk A=cagliari.pdf cat A3-22 output storia-di-cagliari.pdf

Possiamo anche usare varie pagine sparse:
$ pdftk A=cagliari.pdf cat A2-5 A9 A23 A 35 output cagliari-in-breve.pdf
in questo caso il nuovo file avra’ solo otto pagine, dalla prima alla quarta sara’ composto delle pagine 2, 3, 4 e 5 del file originale. Per la quinta pagina viene usata la pagina 9 del file originale e cosi’ via.

Se vogliamo usare le pagine dalla trentesima all’ultima (che e’ ad esempio la novantesima) del file nuoro.pdf per creare un nuovo file abbiamo due sistemi:
$ pdftk A=nuoro.pdf cat A30-90 output un-pezzo-di-nuoro.pdf
$ pdftk A=nuoro.pdf cat A30-end output un-pezzo-di-nuoro.pdf

Ora vediamo come ruotare alcune pagine di un documento (o anche tutte se volete). Mettiamo il caso che il file sassari.pdf abbia nove pagine (dalla 10 alla 19) che contengono delle foto che per motivi di grandezza sono state messe nel file originale ruotate di 90 gradi. Noi per poterle guardare senza distruggerci il collo in strane evoluzioni circensi vogliamo ruotarle. Lo facciamo con questo comando:
$ pdftk A=sassari.pdf cat A1-9 A10-19E A20-50 output sassari-dritta.pdf
perfetto, ora le pagine dalla 10 alla 19 sono state ruotate di 90 gradi (E). La rotazione e’ stata eseguita in senso orario, se la rotazione necessaria fosse stata in senso antiorario allora avremmo dovuto sostituire la E con la W:
$ pdftk A=sassari.pdf cat A1-9 A10-19W A20-50 output sassari-dritta.pdf
e se avessimo voluto fare una rotazione di 180 gradi (a testa in giu’) allora avremmo dovuto sostituire E con S:
$ pdftk A=sassari.pdf cat A1-9 A10-19S A20-50 output sassari-dritta.pdf
Queste tre opzioni (E, W e S) mantengono inalterate le dimensioni della pagina, se nella rotazione vogliamo che le dimensioni della pagina si adattino di conseguenza dobbiamo dare questi comandi: L al posto di E, R al posto di W e D al posto di S.

Sarebbe piu’ corretto dire che R e L ruotano il foglio di 90° (rispettivamente in senso orario e antiorario, o se preferite R in senso orario di 90° e L sempre in senso orario, ma di 270°), S posiziona il foglio verticale ma invertito (a testa in giu’), E posiziona il foglio in orizzontale, W posiziona il foglio in orizzontale ma invertito. Poi c’e’ N che posiziona il foglio in verticale. Se notate L=left (sinistra), R=right (destra), N=nord, S=sud, W=west (ovest) e E=est. E’ dunque tutto molto intuitivo.

Se vogliamo creare tanti file pdf (uno per ogni pagina) quante sono le pagine del pdf originale il comando da dare e’ questo:
$ pdftk cagliari.pdf burst output cagliari_%03d.pdf
i cui file saranno cagliari_001.pdf, cagliari_002.pdf, cagliari_003.pdf, ecc. Per una numerazione a due cifre il comando e’ questo:
$ pdftk cagliari.pdf burst output cagliari_%02d.pdf
i cui file saranno cagliari_01.pdf, cagliari_02.pdf, cagliari_03.pdf, ecc.

Se vogliamo creare un file pdf contenente solo le pagine dispari (odd) del file originale, il comando da dare sara’:
$ pdftk oristano.pdf cat 1-35odd output oristano-dispari.pdf
se invece volessimo solo le pagine pari (even) allora:
$ pdftk oristano.pdf cat 1-35even output oristano-pari.pdf

Se vogliamo cifrare i nostri file pdf piu’ segreti dobbiamo dare questo comando:
$ pdftk il-mio-file-segreto.pdf output il-mio-file-segreto-cifrato.pdf user_pw blablabla
Verra’ dunque cifrato usando blablabla come password.
Per decifrarlo basta scrivere:
$ pdftk il-mio-file-segreto-cifrato.pdf input_pw blablabla output il-mio-file-segreto-decifrato.pdf

Per altre opzioni e possibilita’ di altre manipolazioni e usi (ad esempio potete richiamare pdftk in uno script per poterlo utilizzare) guardatevi il manuale.

[^] torna su | post<li> | 

Quando fate doppio ‘click‘ su un file vi si apre con un programma che non vi soddisfa? Siete stanchi di aprire i file con il “tasto destro del mouse > Apri con un’altra applicazione…” ? Allora vi diro’ come fare per aprire i vostri file con un doppio ‘click‘ direttamente col programma che volete voi.

Contenuto di usr/share/applications

Il file in questione si chiama manco a dirlo “defaults.list“, apritelo pure con nano:
$ nano ~/.local/share/applications/defaults.list
o col vostro editor di fiducia (mousepad/kwrite/gedit)
$ mousepad ~/.local/share/applications/defaults.list

Se invece non dovesse esistere allora scrivete:
$ touch ~/.local/share/applications/defaults.list

Il file comincia con questa riga:

[Default Applications]

e nel mio caso prosegue:

image/jpeg=ristretto.desktop
application/x-theme=mousepad.desktop
application/pdf=epdfview.desktop
audio/mpeg=xfmedia.desktop
application/x-7z-compressed=xarchive.desktop
application/x-chm=xchm.desktop
application/zip=xarchive.desktop
video/x-flv=xfmedia.desktop
application/vnd.ms-excel=ooo-calc.desktop

Al posto delle applicazioni di default che avete scritte nel vostro file default.list, potete mettere quelle che volete, o meglio potete scegliere tra quelle presenti nella directory /usr/share/applications/.

Se ad esempio volete associare i file di testo con mousepad/gedit/kwrite/qualunque editor presente nella directory menzionata sopra, non dovete far altro che aggiungere questa riga in fondo al file default.list:

---8<---
text/plain=mousepad.desktop
---8<---

Per i file html:

---8<---
text/html=iceweasel.desktop
---8<---

Se volete cambiare ad esempio il programma col quale aprire le immagini, dovete modificare questa riga:

image/jpeg=ristretto.desktop

per i pdf questa:

application/pdf=epdfview.desktop

e cosi’ via.

Potete anche crearvi una copia di backup del vostro file default.list prima di modificarlo:
$ cp ~/.local/share/applications/defaults.list ~/.local/share/applications/defaults.list.originale
in modo da ripristinare velocemente l’originale:
$ cp ~/.local/share/applications/defaults.list.originale ~/.local/share/applications/defaults.list

[^] torna su | post<li> | 

Sulla nostra Debian abbiamo il nostro bel browser IceWeasel, ma potrebbe non soddisfarci pienamente, o giusto per curiosita’ potremmo essere spinti a provare altri browser. Se installiamo un altro browser, mantenendo anche IceWeasel, puo’ succedere che Icedove/ThunderBird, Pidgin e altri, ci aprano il nuovo browser e non IceWeasel. Come facciamo ad indicare loro di usare il nostro vecchio browser e non il nuovo?

I Browser sono tanti, milioni di milioni... ma non installarne troppi

Comparira’ un messaggio simile a questo:

Ci sono 2 alternative che forniscono `x-www-browser'.

  Selezione    Alternativa
-----------------------------------------------
          1    /usr/bin/iceweasel
*+        2    /usr/bin/opera

Premi invio per mantenere il default[*], o inserisci il numero da selezionare:

Mi sembra chiaro. Se vogliamo che il browser di default resti Opera premiamo invio, se invece vogliamo cambiarlo, premiamo il numero che corrisponde al browser desiderato (in questo caso 1). Premuto 1 i link presenti nelle email su IceDove o nei messaggi su Pidgin si apriranno su IceWeasel.

[^] torna su | post<li> | 

GIMP (GNU Image Manipulation Program) e’ un ottimo software libero di foto-ritocco ed e’ il programma preferito di tanti grafici (anche perche’ e’ gratuito e multi-piattaforma). Inoltre ha tante funzioni, plug-in, filtri, pennelli ecc. Trovate una completa documentazione sia in rete sia assieme al programma. Pur non essendo nato per assomigliare a Photoshop, ad ogni relase, gli assomiglia sempre un po’ di piu’. Ci sono anche una serie di trucchi che possono aiutarci a rendere GIMP piu’ simile a Photoshop.

GIMP (GNU Image Manipulation Program) e' un programma libero di fotoritocco che permette di creare e modificare immagini bitmap

IL PLUG-IN PSPI – Per poter utilizzare i plug-in di Photoshop abbiamo bisogno di PSPI, scarichiamolo dunque, scompattiamo l’archivio e spostiamo il suo contenuto nella directory plug-ins come abbiamo visto prima. Se adesso avviamo GIMP nel menu’ dei filtri in basso vedremo “Photopshop Filters Plug-In Settings“. Adesso possiamo aggiungere tutti i plug-in di Photoshop che vogliamo.

GLI STILI DEI LIVELLI – Passare da Photosho a GIMP e’ reso difficile anche dalla presenza degli stili dei livelli in Photoshop. In GIMP pero’ abbiamo gli effetti (luci, ombre, smussature, sfumature, rilievi, ecc.), basta scaricare allora il plug-in Layer Effects. Ci sono due versioni, quella Script-Fu e quella Python. La versione Python permette di vedere immediatamente un’anteprima degli effetti applicati. Comunque, qualunque versione decidiate di scaricare, dovete posizionarla nella directory /home/UTENTE/.gimp-2.7/scripts) e riavviare GIMP. Ora avviate GIMP, se avete scaricato la versione Python andate in Immagine > Livelli > Effetti, se invece avete scaricato la versione Script-Fu andate in Script-Fu > Effetti.

Miscelazione additiva e miscelazione sottrattiva

IL RIDIMENSIONAMENTO LIQUIDO – Questa tecnica di riscalatura permette di ridimensionare le immagini in modo non uniforme, evitando pero’ di distorcere le parti piu’ importanti. Potete dunque scaricare il plug-in e metterlo nella solita directory. Oppure molto piu’ semplicemente da terminale:
# apt-get install gimp-plugin-registry

Si, installando il pacchetto gimp-plugin-registry avrete sia il ridimensionamento liquido sia la separazione dei colori. Ecco perche’ mi piace Debian con i suoi “millemila” pacchetti.

Per disegnare con GIMP non serve un pennello grande ma tanti grandi e piccoli pennelli

GIMP IN UN’UNICA FINESTRA – Una delle cose piu’ fastidiose in Gimp (soprattutto se avete il compositor abilitato in modo da rendere trasparenti le finestre non in primo piano) e’ la suddivisione di GIMP in tre finestre. A quanto pare in una prossima futura versione GIMP dara’ la possibilita’ di scegliere (per chi vuole) di avere GIMP in un’unica finestra. Fino ad allora posizionate il puntatore del mouse sulla barra del titolo delle finestre di GIMP, premete il tasto destro e selezionate “sempre in primo piano“.

LE ANIMAZIONI – Il GAP (GIMP Animation Package) permette a tutti di fare facilmente delle semplici animazioni con GIMP. Ma consente anche animazioni piu’ elaborate. Pero’ non e’ incluso in GIMP, va installato. Da terminale scrivete allora:
# apt-get install gimp-gap

LA LIBRERIA GRAFICA GEGL – A partire da GIMP 2.6 e’ presente GEGL (Generic Graphical Library). E’ una nuova funzionalita’ che promette miglioramenti sia negli effetti dei livelli, sia nei colori. Per attivare questa funzionalita’ basta andare nel menu’ Colori > Usa GEGL. Poi in Strumenti> Operazioni GEGL si puo’ scegliere tra varie impostazioni predefinite.

A livello professionale non sara’ ancora come Photoshop, ma gli si avvicina sempre di piu’.

[^] torna su | post<li> | 

Dopo aver visto come impostare il completamento automatico dei comandi immessi nella bash, vediamo altre personalizzazioni, alcune inutili, altre piu’ utili.

Nel pianeta GNU/Linux esistono un gran numero di shell, se le dovessimo dividere in due gruppi avremmo le shell compatibili con la shell Bourne e quelle compatibili con le shell C. Comunque in questo post trattero’ la personalizzazione della bash (Bourne Again Shell), e’ quasi sicuramente la shell che usate anche voi, ma per esserne certi aprite un terminale e scrivete:
$ echo $SHELL

Ora che sappiamo che shell stiamo usando, occorre sapere che a sua volta si divide in:

• shell di login, si avvia quando ci loggiamo nel sistema dopo aver inserito username e password;
• shell interattiva, nella quale inseriamo i vari comandi (possiamo anche fare il login);
• shell non interattiva, viene lanciata all’esecuzione di uno script.

Ovviamente ogni shell ha i suoi file di configurazione. Ad esempio, la shell di login ha i suoi file di configurazione in ~/.bash_login e ~/.bash_logout (questo viene letto quando si esce dalla shell). La shell interattiva invece ha il suo file di configurazione in ~/.bashrc. E’ in quest’ultimo file di configurazione che noi apporteremo le modifiche. Per essere certi che queste abbiano effetto se avete il file .bash_profile controllate che al suo interno siano presenti queste righe:

---8<---
if [ -f ~/.bashrc ]; then
source ~/.bashrc
fi
---8<---

Vediamo allora come creare gli alias. Gli alias permettono di assegnare dei nomi ai comandi, in modo da semplificarne la scrittura, o in modo da lanciare un comando con le opzioni con semplicita’. Ad esempio se quando usiamo il comando ls vogliamo vedere sempre anche file e directory nascoste, dobbiamo digitare ls -a, ma se vogliamo che scrivendo semplicemente ls venga lanciato il comando ls -a, bastera’ usare gli alias, in questo modo (da aggiungere nel file .bashrc):

---8<---
alias ls='ls -a'
---8<---

Se vogliamo che ci siano anche i colori per distinguere i file e le directory, bastera’ sostituire con questo:

---8<---
alias ls='ls -a --color=auto'
---8<---

Un altro utile alias (per chi copia file da terminale) e’ l’aggiunta dell’opzione per rendere interattivo il comando di copia:

---8<---
alias cp='cp -i'
---8<---

in questo modo se stiamo sovrascrivendo un file ci viene chiesto se e’ quello che veramente vogliamo fare.

Se veniamo da Windows e’ possibile che qualche comando ci confonda, ad esempio il comando per spostarci nella directory superiore in Windows e’ cd.., mentre in GNU/Linux e’ cd .., basta allora aggiungere questo alias:

---8<---
alias cd..='cd ..'
---8<---

Un altro utile alias e’ quello per installare gli aggiornamenti. Ovviamente dovremo modificare il file .bashrc di root e non quello che si trova nella nostra home utente. Dunque da terminale:
# nano /root/.bashrc
e aggiungiamo:

---8<---
alias aggiorna='apt-get update && apt-get upgrade'
---8<---

In questo modo la prossima volta che dobbiamo aggiornare, nel terminale bastera’ scrivere:
# aggiorna

Gli alias possiamo anche inserirli in un file a parte ~/.bash_aliases, in questo caso pero’, all’interno del file ~/.bashrc dobbiamo de-commentare alcune righe:

---8<---
#if [ -f ~/.bash_aliases ]; then
#    . ~/.bash_aliases
#fi
---8<---

in modo da avere:

---8<---
if [ -f ~/.bash_aliases ]; then
    . ~/.bash_aliases
fi
---8<---

Una volta che abbiamo fatto le nostre aggiunte, da terminale diamo questo comando:
source ~/.bashrc
per abilitare le modifiche.

Quando apriamo un terminale vediamo una scritta simile a questa:
username@hostname:~$
si tratta del prompt. Anche questo puo’ essere personalizzato, nell’esempio sopra riportato, all’interno del file .bashrc ci sarebbe:

---8<---
PS1=`\H@\u:\w$`
export PS1
---8<---

Ci sono anche altre opzioni, e le combinazioni possibili sono tante, trovate tutte le opzioni qui, potete ad esempio mettere l’ora (\t), o la data (\d) o tutte e due. Per avere ad esempio un prompt simile a questo:
username@hostname-HH:MM:SS-giorno mese anno:~$
dovremo scrivere:

---8<---
PS1=`\H@\u:\t-\d\w$`
export PS1
---8<---

Per approfondire e’ utile la lettura del manuale:
$ man bash

Terminale con il logo Debian

---8<---
rosso='\e[1;O1O'
NC='\e[0O'

echo -e "        oOOOOOOo                    OOOOo.";
echo -e "     oo OOOOOOOOOo.            ooOOOOOo  Oo";
echo -e "   O oOOOo OOOOOOOOo           oO  OOOOoOOOO o";
echo -e "  O OOO.Oo                               OOOOOo";
echo -e " O  ooOO         .OOOOOo    OOOOOo        OOOO O";
echo -e " o OOOO         O OOOOOO ooO.OOOO ..       OOO  O";
echo -e "O  oo O       O oooooooooo  O OoooooO      Oooo O";
echo -e "O  oo O     .O.ooooooooooo  O OOooooO.     O.oO O";
echo -e "o  ooOO    O OooOO.       O  O  O OOoO.O   .OoO O";
echo -e " O OooO OO.OoO     OoO   o.  O OoO   ooO.C OoO. O";
echo -e " O oooooOOoo      o O OOO o   ooO o   oooOoooO O";
echo -e "  O .Ooooooo    o.     Ooo O  O.OO    oooooOO O";
echo -e "    O .o.Oo       O  o oOo     OOoo    ooo  O";
echo -e "      OOOO       oo      O      O O      Oo";
echo -e "         O       Oo              OO.O    OO";
echo -e "        O      OO O       OOOO    O   oOOO.";
echo -e "        O    Oo          OO    Oo     O";
echo -e "      O  OOO  O.     oo   oOooo  .    O";
echo -e "          oo  oO        oO    .     oO";
echo -e "          oo   O        O        oOOo";
echo -e "           O   .OO       O           O";
echo -e "           o      o        OOOOOCOOO";
echo -e "           .o    oO                O";
echo -e "            O      Oo      oOOoooAO";
echo -e "              O     o oOO      .o";
echo -e "               O    ooooo.    . O";
echo -e "                 .   .OOooo Ooo.";
echo -e "                     O. OoOooooo";
echo -e "                      . OOooooooOO";
echo -e "                          oOOOOOOo";
echo -e "${rosso}Debian GNU/Linux ${NC}" `cat /etc/debian_version`
---8<---

Si, lo so, e' orribile (dovrebbe essere lo GNU), se volete qualcosa di piu' carino fatevelo voi, non e' difficile, basta convertire un'immagine in testo oppure trasformare una parola in ASCIIart, ci sono vari siti che lo fanno. Insomma, le possibilita' non mancano.

[1] Per avere il terminale come appare nella figura (il logo Debian) seguite questa guida. [^]

Terminale con il logo Debian

[^] torna su | post<li> | 

Oggi e’ sabato, svegliatevi, non poltrite. Scrivero’ di una cosa che non uso, il completamento automatico avanzato dei comandi su terminale. “Ma esiste gia’” direte voi. In effetti, se scrivo $ mpl[TAB] esce fuori $ mplayer, se scrivo $ lspc[TAB] esce fuori $ lspci [certo che per una lettera potevi evitare NdI], ecc. Tuttavia se provate a scrivere # apt-get upda[TAB] non succede nulla. Perche’? Perche’ di default vengono risolti solo i comandi semplici e i pathname (nome che contiene in forma esplicita informazioni sulla posizione del file all’interno del sistema [copincollato da Wikipedia]). Ed e’ qui che entra in gioco questo post (o suppost).

Utilizzatore di personal computer alla ricerca continua e ossessiva di modi per risparmiare tempo e fatica. Ricerca che gli impiega tutto il tempo e le forze.

Abbandonando il “problema” e venendo alla soluzione, si tratta semplicemente di fare alcune modifiche al file di configurazione della bash, da terminale diamo dunque questo comando:
# nano /etc/bash.bashrc
ehh! quante righe, non spaventatevi, cercate queste tre righe:

---8<---
#if [ -f /etc/bash_completion ]; then
#    . /etc/bash_completion
#fi
---8<---

e de-commentatele (togliete il number sign, cancelletto, diesis, scacco matto, insomma questo #) in modo da avere questo risultato:

---8<---
if [ -f /etc/bash_completion ]; then
. /etc/bash_completion
fi
---8<---

Se andate in ~/.bashrc e lo de-commentate da li le impostazioni cambieranno immediatamente al primo avvio di un terminale. Altrimenti o riavviate (e che esagerazione) o caricate la bash_completion dando questo comando da terminale:
$ source /etc/bash_completion
Se de-commentate quelle tre righe su /etc/bash.bashrc, non fatelo su ~/.bashrc.

Esistono anche cose utili da fare su ~/.bashrc per migliorare la vita sul terminale, ad esempio gli alias. Magari la prossima volta pero’.

[1] Sulla continua ricerca di trucchi o metodi vari per velocizzare l’attivita’ al pc (soprattutto in fase di navigazione) ci tornero’, e’ interessante capirne le motivazioni, a mio avviso e’ una paura ancestrale (come la paura di essere attaccati di notte dai predatori), comunque ci tornero’, magari oggi stesso, o domani, cosi’ apro un rubrica “#n il sociologo della domenica”. [^]

[^] torna su | post<li> |