Utilizzare 'Pepper' Flash Player con Chromium su Fedora

Ispirandomi a questo PKGBUILD per Archlinux ho scritto un file spec per Fedora con la stessa finalità, ovvero creare un pacchetto per utilizzare la nuova generazione di flash player 'Pepper' con Chromium.
Il file spec è aggiornato con le ultime release stabili di Chrome e Chromium disponibili per Fedora alla data in cui sto scrivendo (21/12/12)

Innanzitutto, se non lo avete ancora fatto, occorre abilitare i repo stabili per Chromium, come spiegato in questa pagina del wiki di Fedora.

Fatto questo, copiate&incollate il seguente testo in nuovo file che chiamerete chromium-pepper-flash.spec

%ifarch i686
%define _carch i386
%endif
%ifarch x86_64
%define _carch x86_64
%endif
%define _build 23.0.1271.97-171054

Summary: Google Chrome's Pepper Flash plugin for Chromium
Name:  chromium-pepper-flash
Version: 11.5.31.5
Release: 1%{?dist}
URL:  http://www.google.com/chrome
Source0: http://dl.google.com/linux/chrome/rpm/stable/%{_carch}/google-chrome-stable-%{_build}.%{_carch}.rpm
License: Multiple, see http://chrome.google.com/
Requires: chromium

%description
Google Chrome's Pepper Flash plugin for Chromium

%prep
rpm2cpio %{SOURCE0} | cpio -idmv

%build

%install
mkdir -p %{buildroot}%{_libdir}/PepperFlash
install -m644 opt/google/chrome/PepperFlash/* %{buildroot}%{_libdir}/PepperFlash
mkdir -p %{buildroot}%{_sysconfdir}/profile.d
echo "export CHROMIUM_USER_FLAGS=\"--ppapi-flash-path=%{_libdir}/PepperFlash/libpepflashplayer.so --ppapi-flash-version=%{version}\"" >> %{buildroot}%{_sysconfdir}/profile.d/%{name}.sh

%files
%{_libdir}/PepperFlash/*
%{_sysconfdir}/profile.d/%{name}.sh

%changelog                                                                                                                                              
* Thu Dec 21 2012 Simone Sclavi <darkhado@gmail.com> - 11.5.31.5-1
- Initial build

Per compilare il pacchetto vi consiglio di utilizzare mach, che è l'equivalente del "makepkg -s" di Archlinux (in realtà mach è più completo come strumento)
Se non è presente sulla vostra macchina, installatelo con:

# yum install mach

Dopodichè aggiunte il vostro utente al gruppo mach, con:

# usermod --append -G mach <utente>

Avviate la compilazione con:

$ mach build chromium-pepper-flash.spec

La prima esecuzione di questo comando potrà richiedere un po' di tempo, dal momento che mach ( il cui significato è  "make a chroot" ) creerà inizialmente un ambiente separato e "pulito" all'interno del quale verrà poi eseguita la compilazione.
Al termine, se tutto è andato per il verso giusto, mach vi indicherà la directory contenete gli rpm appena costruiti. Nel mio caso, ad esempio:

2 packages and 0 specfiles checked; 0 errors, 5 warnings.
Results: /var/tmp/mach/fedora-17-i386-updates/chromium-pepper-flash-11.5.31.5-1.fc17
Build done.

[ Attenzione: di default mach crea pacchetti 32 bit anche se state utilizzando una versione di Fedora a 64 bit!
Per cambiare questo comportamento aprite il file /etc/mach/conf e modificate il defaultroot correggendo i386 in x86_64; ad esempio con Fedora 18 troverete fedora-18-i386-updates che dovrà quindi diventare fedora-18-x86_64-updates ]
Spostatevi quindi nella directory indicata ed installate il relativo pacchetto rpm (non il src.rpm). Su un sistema 32 bit, ad esempio, darete:

# yum install chromium-pepper-flash-11.5.31.5-1.fc17.i686.rpm

Purtroppo, a differenza della versione "vanilla" di Chromium, in Fedora il file  /etc/chromium-browser/default non sembra in grado di esportare le variabili d'ambiente necessarie all'abilitazione del plugin; ho quindi inserito tali istruzioni in un file all'intero della directory /etc/profile.d.
Lo svantaggio rispetto al pacchetto per Archlinux è che dovrete chiudere la vostra sessione corrente di lavoro e ripetere il login per fare in modo che le variabili di ambiente vengano esportate correttamente.

Una volta fatto tutto questo, lanciate Chromium e nella barra degli indirizzi, digitate:

  chrome://plugins

 Controllate in questa pagina che il plugin Pepper sia stato riconosciuto e caricato; se sulla vostra macchina è installato anche il "vecchio" flash player NPAPI assicuratevi di disabilitarlo.

Come ultimo test, collegatevi a questa pagina

Potete trovare la versione più recente del file spec qui

---

Aggiornamento 08/05/13: costruzione alternativa del pacchetto con spectool (RACCOMANDATA!)

Quando all'epoca scrissi questa guida non conoscevo ancora il comando spectool, una comoda utility in grado di scaricare automaticamente i file "source" specificati all'interno di un file spec. Grazie a spectool possiamo fare a meno di mach evitando quindi tutta la fase di preparazione della chroot, con un grande guadagno in termini di tempo!
In un terminale diamo in successione i seguenti comandi:

$ rpmdev-setuptree
$ wget https://dl.dropboxusercontent.com/u/7141888/chromium-pepper-flash.spec -P ~/rpmbuild/SPECS
$ spectool -g -R ~/rpmbuild/SPECS/chromium-pepper-flash.spec
$ rpmbuild -ba ~/rpmbuild/SPECS/chromium-pepper-flash.spec

Terminata la compilazione, spostiamoci nella directory contenente il pacchetto appena creato:

$ cd ~/rpmbuild/RPMS/$(uname -p)

e installiamolo con yum, come già visto in precedenza

Chromium e i numeri che non vengono mostrati durante i download: ecco come risolverlo

Questo è un errore che sembra affliggere molti utenti: durante i download anziché mostrare i MB e i minuti mancanti al completamento dell'operazione, Chromium riporta invece un sibillino "NaN/NaN MB, NaN minuti rimanenti".

Se questo problema riguarda anche voi, potete risolverlo con questo workaround: aprite con un editor il file .bashrc nella vostra home e aggiungete la seguente istruzione:

export LC_NUMERIC="POSIX" 

quindi terminate la sessione corrente del vostro DE e riloggatevi nuovamente.
Ho riscontrato però che a causa di questa impostazione alcuni programmi si avviano utilizzando la localizzazione inglese anziché quella italiana (o qualunque altra sia la lingua del vostro sistema Linux).
Ad oggi ho verificato questo comportamento anomalo con SMPlayer e Rosa Media Player, ma potrebbe riguardare anche altri software.
Per fare in modo che i due lettori multimediali di cui sopra continuino ad avviarsi in italiano, senza però rinunciare al nostro fix per Chromium , ho creato due semplicissimi "wrapper".

Per SMPlayer:
Create un file in /usr/local/bin dal nome smplayer e incollate questo contenuto:

#!/bin/sh
export LC_NUMERIC="it_IT.UTF-8"
/bin/smplayer "$@"

Rendete il file eseguibile con:

# chmod 755 /usr/local/bin/smplayer

Per Rosa Media Player:
Come nome del file date stavolta rosa-media-player ( collocatelo sempre in /usr/local/bin ) con questo contenuto:

 #!/bin/sh
export LC_NUMERIC="it_IT.UTF-8"
/bin/rosa-media-player "$@"

Impostate i permessi di esecuzione con:

#  chmod 755 /usr/local/bin/rosa-media-player

 Testato positivamente su Fedora 17.

Installare Stepmania 5 (5-alpha3) su Fedora 17

Ho provveduto personalmente a creare dei pacchetti rpm di Stepmania 5 per Fedora (release attuale 5-alpha3), dal momento che in rete sembrano non esistere; per chi volesse utilizzarli, pubblico qui i relativi link:

stepmania-5_alpha3-1.fc17.x86_64.rpm
stepmania-5_alpha3-1.fc17.i686.rpm
stepmania-5_alpha3-1.fc17.src.rpm

I pacchetti sono stati creati abilitando tutte le opzioni disponibili in fase di compilazione, incluso l'utilizzo di ffmpeg e libmad, quindi per poterli installare con successo sulla vostra macchina dovete aggiungere il repository RPM Fusion free

Il metodo più semplice per installare canzoni è quello di copiarle nella directory /usr/share/stepmania/Songs; per poter fare ciò evitando l'uso dell'account di root, potete aggiungere il vostro utente al gruppo games, in questo modo:

# usermod -a -G games <utente>

quindi disconnettetevi e rifate il login per applicare le modifiche.
Installate il pacchetto adatto alla vostra architettura con yum, ad esempio:

# yum install  stepmania-5_alpha3-1.fc17.x86_64.rpm

così facendo yum elaborerà e installerà automaticamente tutte le dipendenze necessarie.
Se giocate a Stepmania utilizzando un tappetino, vi consiglio inoltre di sospendere il DPMS, per evitare che X dopo qualche minuto  vada a disabilitare lo schermo, non ricevendo alcun input da tastiera e mouse:

$ xset -dpms; xset s off

Youtube: formattare il numero di visualizzazioni con separatore delle migliaia

Vi segnalo questo interessante script per Greasemonkey, chiamato"YouTube Easy Views" che aggiunge, quando necessario, a tutti i numeri del popolare sito (visualizzazioni, iscrizioni, mi piace e non) il separatore delle migliaia, aumentandone notevolmente la leggibilità. Ecco un esempio:

Per installare YouTube Easy Views su Firefox (non ho per il momento verificato con altri browser) occorre prima procurarsi Greasemonkey, scaricabile all'indirizzo: https://addons.mozilla.org/firefox/addon/748
Successivamente installiamo lo script, cliccando questo link: http://userscripts.org/scripts/source/149890.user.js

Archlinux: uno script (in perl) per trovare i file che non appartengono a nessun pacchetto installato

In alternativa ad un comando del tipo:

$ find /usr/bin/ -execdir pacman -Qo {} \;

ho realizzato un script perl che svolge la medesima funzione (ossia analizzare il filesystem alla ricerca dei file non appartenenti a nessun pacchetto installato) con il vantaggio però di essere molto più performante rispetto all'invocazione continua di "pacman -Qo"
Ho chiamato il mio script leftover (in inglese "rimasuglio", "avanzo")

#!/usr/bin/perl
# leftover.pl
use warnings;
use strict;
use File::Find;
use File::Slurp;
use File::Spec;
use feature 'say';
my $dir=$ARGV[0];
die ":: Uso: $0 <directory>\n" unless (scalar @ARGV == 1);
die qq{:: Directory non valida: "$dir"\n} unless -d $dir;
die qq{:: "$dir" non è un percorso assoluto\n"} unless File::Spec->file_name_is_absolute($dir);
my @files;
my @db = qx(pacman -Ql);
say ":: Ricerca in corso dei file non appartenenti a nessun pacchetto ...";
find({ wanted => \&process, follow_skip => 2 }, $dir);
if (@files)
{
    write_file('/tmp/leftover.txt', @files);
    say q{:: Risultati della ricerca salvati in "/tmp/leftover.txt"};
}
else
{
    say ':: Nessun file trovato';
}

sub process{
    return if -d "$File::Find::name";
    my $check;
    my $f = quotemeta($File::Find::name);
    for (@db)
    {
        if ($_ =~ /^\S+\s$f/)
            {
                $check = 1;
                last;
            }
    }
    if (! $check)
    {
        say ">$File::Find::name";
        push @files, "$File::Find::name\n";
    }
}

L'utilizzo è molto semplice, basta dare:

$ leftover.pl <path da analizzare>

Ovviamente avrebbe poco senso passare come path /home o /tmp  oppure directory speciali come /proc o /sys all'interno delle quali nessun pacchetto va a collocare file.
Tenete anche in considerazione che analizzare path contenenti molti file e molti livelli di sottodirectory (come ad esempio /usr) potrebbe richiedere parecchio tempo!
Unica dipendenza richiesta per poter eseguire lo script è perl-file-slurp.
I risultati della ricerca verranno salvati nel file /tmp/leftover.txt per un'agevole consultazione.

Come creare una file di configurazione per GNU Bc

Bc, il noto linguaggio di programmazione usato per calcoli a precisione arbitraria, non supporta direttamente la possibilità di mantenere in un file di configurazione le nostre impostazioni personalizzate.
E' possibile abilitare tale funzionalità tramite la variabile d'ambiente BC_ENV_ARGS in questo modo:

1) creiamo un file nella nostra home dal nome .bc
2) inseriamo nel file le impostazioni che desideriamo cambiare; le variabili che il programma riconosce sono scale (numero di decimali dopo la virgola, default è zero) e ibase/obase (per convertire l'input/output in basi diverse da quella decimale). Se ad esempio volessimo impostare il numero di cifre decimali a due, scriveremmo semplicemente scale=2. É inoltre possibile definire funzioni personalizzate, in modo da averle immediatamente disponibili ad ogni avvio del programma.
3) apriamo il file .bashrc nella nostra home e aggiungiamo la seguente linea:
export BC_ENV_ARGS=~/.bc

Apriamo una nuova istanza del nostro terminale preferito per rendere attive le modifiche al file ~/.bashrc

Concatenare file Vob di un dvd in un unico file

In questo articolo vi spiegherò come unire in maniera veramente semplice i file Vob di un dvd-video in modo da generare un unico file. Il file così ottenuto potrà essere facilmente dato in pasto a tool come mencoder, ffmpeg, ecc. per la conversione in altri formati video.
Il processo in pratica consiste nel passare al comando cat l'elenco ordinato di tutti i Vob del nostro dvd, ad eccezione del file VIDEO_TS.VOB e dei file dal nome VTS_xx_0.VOB (quelli cioè relativi a menu e contenuti riprodotti in automatico all'apertura del dvd).
Possiamo automatizzare il tutto con un piccolo script bash:

# creiamo l'elenco dei file Vob
ls -1 *.VOB > lista
# rimuoviamo VIDEO_TS.VOB e i file VTS_01_0.VOB, VTS_02_0.VOB, ecc
sed -e /VIDEO_TS.VOB/d -e /_0.VOB/d -i lista

Supponiamo che il nostro dvd contenga i seguenti file:
VIDEO_TS.VOB
VTS_01_0.VOB
VTS_01_1.VOB
VTS_01_2.VOB
VTS_01_3.VOB
VTS_02_0.VOB
VTS_02_1.VOB
VTS_02_2.VOB
VTS_02_3.VOB
VTS_02_4.VOB
VTS_03_0.VOB
VTS_03_1.VOB
VTS_04_0.VOB
VTS_04_1.VOB

dopo aver eseguito i precedenti comandi il file lista avrà questo contenuto:
VTS_01_1.VOB
VTS_01_2.VOB
VTS_01_3.VOB
VTS_02_1.VOB
VTS_02_2.VOB
VTS_02_3.VOB
VTS_02_4.VOB
VTS_03_1.VOB
VTS_04_1.VOB

# ultimo passo: concateniamo i VOB in un unico file
cat $(cat lista) > video.vob

Ecco fatto, il nostro file è pronto! Ora, ad esempio, potremmo passarlo a ffmpeg per ottenere un video in formato MPEG4, mantenendo la qualità del filmato originale:

$ ffmpeg -i video.vob -aspect 16:9 -sameq -acodec copy video.mp4

Se siete interessati ad approfondire l'utilizzo di ffmpeg vi suggerisco la relativa pagina dell'ottimo Wiki di Archlinux

Un semplice ed efficiente GMail notifier grazie a Perl e Cron :-)

Esistono vari programmi e applet per GNU/Linux che ci consentono di monitorare la nostra posta su Gmail; tutti però richiedono ovviamente di restare in esecuzione, andando quindi ad impegnare costantemente una parte delle risorse del nostro sistema ... e tutto questo solo per notificarci la presenza di eventuali nuove mail!

In questo articolo vi illustro un piccolo programma che ho scritto in perl  e progettato per essere eseguito tramite cron: il vantaggio rispetto alle implementazioni "classiche" è che il consumo di risorse è veramente minimo dal momento che, come dicevo, il programma viene lanciato all'intervallo prefissato da cron e terminato una volta completato il controllo della nostra posta su gmail. Non c'è quindi un impegno costante di risorse: terminato il controllo, il programma viene chiuso e la memoria completamente rilasciata.

Per chi fosse interessato a provare questa soluzione, riporto qui di seguito le istruzioni per l'installazione e la configurazione, facendo riferimento ad Arch Linux; lo script è comunque utilizzabile su qualunque distro.

Iniziamo con l'installare i moduli perl necessari:

# pacman -S perl-file-slurp perl-lwp-protocol-https
$ yaourt -S perl-gtk2-notify

Dando per scontato che abbiate cron (o una delle sue varianti) e dbus attivi, dovete verificare che il DE/WM che utilizzate fornisca una gestore di notifiche; i progetti maggiori come KDE, GNOME, XFCE, ecc. soddisfano questo requisito, mentre se utilizzate LXDE o WM tipo openbox, fluxbox ecc. molto probabilmente non avrete nessun gestore di notifiche installato.
Se rientrate in quest' ultima categoria potete risolvere il problema installando notification-daemon:

# pacman -S notification-daemon

e piazzarne l'eseguibile ( /usr/lib/notification-daemon-1.0/notification-daemon ) tra i programmi da lanciare all'avvio del vostro desktop.

Occupiamoci ora del programma vero e proprio: copiamo il seguente codice all'interno di un file di testo che chiameremo pgmail.pl e salviamo il file da qualche parte nella nostra home, per esempio in ~/bin :

---

#!/usr/bin/perl
# pgmail - gmail checker in perl

use strict;
use warnings;
use LWP;
use File::Slurp;
use Gtk2::Notify -init, $0;
use autodie;
use Env 'DBUS_SESSION_BUS_ADDRESS';

my $USER = 'user';
my $PASS = 'password';
my $ICON = 'checkgmail';

my $TMP_FILE = "/tmp/tmp_gmail_${USER}";

my $browser = LWP::UserAgent->new();
$browser->timeout(30);

my $req = HTTP::Request->new(GET => 'https://mail.google.com/mail/feed/atom');
$req->authorization_basic($USER, $PASS);
my $resp = $browser->request($req, $TMP_FILE);
die ':: oops, got error <', $resp->status_line, ">, exiting ...\n" unless $resp->is_success;

my @file = read_file( $TMP_FILE );
my ($MESSAGE, $TITLE);

for (@file)
{
        if($_ =~ /<fullcount>(?<mail_count>\d+)/)
        {
                if ($+{mail_count} == 0)
                {
                        unlink $TMP_FILE;
                        exit;
                }
                else{
                        $TITLE = "($+{mail_count}) Nuovi messaggi su GMail!";
                }
        }
        if ($_ =~ /<title>(?<subject>.*)<\/title>/)
        {
                $MESSAGE = $MESSAGE .  "\nOggetto: $+{subject}\n" unless
                ($+{subject} eq "Gmail - Inbox for ${USER}\@gmail.com");
        }
        if ($_ =~ /<email>(?<from>.*)<\/email>/)
        {
                $MESSAGE = $MESSAGE . "Da: $+{from}\n";
        }
}

$DBUS_SESSION_BUS_ADDRESS = get_dbus_address();
if (!$DBUS_SESSION_BUS_ADDRESS)
{
    die ":: Unable to set DBUS_SESSION_BUS_ADDRESS!\n";
}

my $notification = Gtk2::Notify->new($TITLE, $MESSAGE, $ICON) ;
$notification->show;

unlink $TMP_FILE;

sub get_dbus_address
{
    my $PROGRAM = 'kwin';
    my $PIDOF_PATH ='/bin/pidof';

    my $pid = qx[$PIDOF_PATH -s $PROGRAM];
    die qq{:: "${PROGRAM}" isn't running!\n} unless $pid;
    chomp $pid;
    my $environ = read_file("/proc/${pid}/environ");
    my @lines = split( chr(0), $environ );

    for (@lines)
    {
            if ($_ =~ /DBUS_SESSION_BUS_ADDRESS=(.+)/)
            {
                    return $1;
            last;
            }   
    }   
    return undef;
}

---

Come potete vedere, non sono che poche righe di codice; del resto le operazioni che il nostro script deve compiere sono in effetti solo quelle di verificare la presenza di nuovi messaggi e inviarci una notifica in caso positivo :-)

Una volta salvato il file, rendiamolo accessibile unicamente al nostro utente, dal momento che in esso sono conservate le nostre credenziali di accesso a gmail ( dati personali molto importanti che quindi devono restare riservati ) :

$ chmod 700 ~/bin/pgmail.pl

In grassetto blu ho evidenziato le variabili che dovrete andare obbligatoriamente a cambiare per far girare lo script correttamente:

my $USER = 'user';
sostituite 'user' con il vostro "Nome utente" gmail senza '@gmail.com'. Non dimenticatevi gli apici e il punto e virgola finale! 

my $PASS = 'password';

sostituite 'password' con la reale password del vostro account gmail, sempre tra apici; il punto e virgola chiude la riga.

my $ICON = 'checkgmail';

l'icona che verrà mostrata nella notifica; potete utilizzare qualunque file .png, .xpm o .svg presente nelle cartelle ( e relative sottocartelle ) /usr/share/icons e /usr/share/pixmaps.  Nel caso inseriate un nome sbagliato o di un file inesistente, semplicemente la notifica non visualizzerà alcuna immagine. Potete anche specificare l'immagine da utilizzare, scrivendone il percorso completo, ad es:

my $ICON = '/usr/share/icons/hicolor/48x48/apps/firefox.png';

my $PROGRAM = 'kwin'; 

arriviamo alla variabile più problematica; per inviare correttamente la notifica il programma deve conoscere  l'indirizzo della sessione dbus attiva. Il modo più "semplice" per ottenere tale informazione è quella di accedere, tramite il filesystem speciale /proc, al file environ relativo ad un'applicazione grafica in esecuzione. Semplificando ulteriormente, la variabile $PROGRAM deve contenere il nome di un processo grafico che viene lanciato automaticamente ogni qualvolta avviate il vostro DE/WM.

Se siete su KDE potere lasciare tranquillamente impostato 'kwin'; gli utenti LXDE potranno invece utilizzare, ad esempio, 'lxpanel'; 'xfce4-panel' è perfetto per gli utenti XFCE. Se avete dei (comprensibilissimi :-) ) dubbi sul processo da impostare, fate così:

Avviate il vostro desktop, quindi da un terminale lanciate:

$ ps -u <vostro user> 

per ottenere un elenco dei processi in esecuzione. Purtroppo, non tutto quello che vi viene mostrato qui può andare bene per i nostri scopi; dopo aver esaminato l'ultima variabile che ci resta, vi illustrerò come verificare l'idoneità del processo scelto. 

        

my $PIDOF_PATH ='/bin/pidof'; 
Il percorso dell'eseguibile pidof. Se state utilizzando Arch Linux non avete bisogno di modificare niente. In caso contrario dovete verificare l'esatto percorso di pidof che può cambiare da distro a distro; per esempio su Fedora il path è /usr/sbin/pidof. Date semplicemente:

$ which pidof

per localizzare il percorso corretto sulla vostra distro.
Ok, a questo punto abbiamo completato la configurazione, non ci resta che testare il corretto funzionamento del programma.
Assicuriamoci di avere almeno un messaggio non letto nella nostra casella di posta gmail e simuliamo l'avvio dello script tramite cron in questo modo:

$ env -i DISPLAY=:0 /home/<vostro user>/bin/pgmail.pl

Se non sono stati commessi errori nella precedente fase, verrà visualizzata una notifica con il numero di messaggi non letti, mostrando per ciascuno di essi l'oggetto e la mail del destinatario.
Se la notifica non compare e il terminale riporta l'errore:

Unable to set DBUS_SESSION_BUS_ADDRESS!

significa che avete immesso una voce sbagliata in corrispondenza della variabile $PROGRAM.
Se invece il messaggio di errore è il seguente:

Gtk-WARNING **: cannot open display: :0 at /usr/lib/perl5/vendor_perl/Gtk2/Notify.pm line 23.

modificate e ripetete il comando precedente così:

$ env -i DISPLAY=:0 XAUTHORITY=/home/<vostro user>/.Xauthority /home/<vostro user>/bin/pgmail.pl

Una volta corretti eventuali errori, l'ultimo passo è quello di creare un cronjob per automatizzare l'esecuzione del nostro script; digitiamo in un terminale:

$ crontab -e

se è la prima volta che inserite un cronjob vi apparirà  un file del tutto vuoto.
Di default viene utilizzato Vi come editor ma se non lo conoscete potete specificare un programma alternativo settando la variabile EDITOR prima di lanciare il comando 'crontab -e'. Per esempio:

$ export EDITOR="/usr/bin/nano"

Aperto il nostro crontab, inseriamo la seguente regola:

*/15 * * * * env DISPLAY=:0 /home/<vostro user>/bin/pgmail.pl

Salvate e chiudete il file: l'operazione inserita sarà attiva da subito.
"*/15" significa che la posta verrà controllata ogni 15 minuti; siete ovviamente liberi di cambiare questo parametro a vostro piacimento.
Se invece volete, ad esempio, che il controllo venga fatto solo una volta ogni ora potete modificare il cronjob in questo modo:

01 * * * * env DISPLAY=:0 /home/<vostro user>/bin/pgmail.pl

Il programma verrà così avviato al primo minuto di ogni ora: 12:01, 13:01 e così via.

È tutto: se siete riusciti a seguire tutte le istruzioni senza perdervi  avrete ora attivo sul vostro sistema uno strumento super-efficiente per monitorare la vostra casella di posta gmail :-)

Aggiornamento del 17/07/14
Ho riscritto parte del codice utilizzando il modulo XML::Simple, potete prelevare la versione aggiornata da qui 

PCManFM, errore "Operation not supported": come risolverlo su Archlinux

Se PCManFM vi restituisce questo errore, quando tentate di accedere al "Cestino" o ad altre risorse ("Il Mio Computer", "Dispositivi di Rete", ecc.) è perché nel vostro sistema non sono installati alcuni componenti richiesti dal filemanager del progetto LXDE.
Per risolvere il problema è necessario installare gvfs e gamin, in questo modo:

# pacman -S gvfs gamin

Inoltre assicuratevi di aver installato dbus e di averlo inserito nell'array DAEMONS in /etc/rc.conf.
Se siete già passati a systemd, ignorate questo ultimo passaggio: dbus viene attivato automaticamente al boot da systemd.

Terminate la sessione corrente di Xorg e loggatevi nuovamente per rendere effettive le modifiche.

Configurare Xrdp su Archlinux

---

Aggiornamento del 20/08/12
Il pacchetto "xrdp" è recentemente passato nelle mani di un nuovo maintainer, il quale ha provveduto a correggerne i problemi e in più ha aggiunto il supporto per systemd. Quindi, al momento, non c'è più alcun vantaggio nello scegliere xrdp-git rispetto a xrdp. Per avviare xrdp tramite systemd:

# systemctl start xrdp.session

Per abilitare l'avvio automaticamente del demone al boot:

# systemctl enable xrdp.session

Le istruzioni di configurazione scritte in precedenza restano valide e perfettamente funzionanti anche per il pacchetto "xrdp".

---

Breve how-to per configurare al meglio il demone xrdp sulla nostra Archlinux; partiamo ovviamente dall'installazione: preleviamo da AUR il pacchetto xrdp-git  (e non xrdp che è male realizzato e presenta diversi problemi); diamo quindi:

$ yaourt -S --noconfirm xrdp-git

Completata l'installazione, passiamo alla vera e propria configurazione:
Rimuoviamo completamente il file /etc/xrdp/xrdp.ini e sostituiamo con quello presente a questo indirizzo: https://dl.dropbox.com/u/7141888/xrdp.ini

Successivamente dobbiamo istruire xrdp riguardo al DE/WM da utilizzare: apriamo il file /etc/xrdp/startwm.sh ed andiamo ad editare la variabile SESSIONS in base alle nostre esigenze, rimuovendo le voci non necessarie; ad esempio per impostare LXDE come DE di default basta scrivere:

SESSIONS="startlxde"

per KDE:

SESSIONS="startkde"

e cosi via.
A questo punto possiamo avviare il demone xrdp per verificare che tutto funzioni a dovere:

# rc.d start rdpd

proviamo quindi a connetterci al nostro demone, indirizzando le richieste verso la porta 3389, utilizzando un client come freerdp o rdesktop, oppure più comodamente un front-end grafico come remmina o rdpdesk.

Bloccare avvisi pubblicitari con Midori

Analogamente ai browser più blasonati, Midori offre la possibilità di bloccare la visualizzazione di contenuti pubblicitari durante la navigazione, feature al giorno d'oggi quanto mai necessaria. Il meccanismo messo a disposizione da Midori ( e installato di default ) è del tutto simile a quello del celeberrimo addon Adblock Plus, tanto da utilizzarne i medesimi filtri.

Per abilitare il blocco delle pubblicità apriamo le 'Preferenze', quindi la scheda 'Estensioni'; qui abilitiamo la voce 'Blocca avvisi pubblicitari' e clicchiamo il pulsante sulla destra per aprire la finestra di configurazione, dove andremo a inserire gli indirizzi relativi ai filtri che vogliamo utilizzare.

Qui sotto trovate le liste consigliate per gli utenti italiani; vi suggerisco di aggiungerle tutte:

      https://easylist-downloads.adblockplus.org/easylistitaly.txt
      https://easylist-downloads.adblockplus.org/easylist.txt
      http://mozilla.gfsolone.com/filtri.txt
      https://secure.fanboy.co.nz/fanboy-italian.txt
      https://secure.fanboy.co.nz/fanboy-adblock.txt

Premete quindi su 'Chiudi' per terminare la configurazione e per godervi una navigazione del tutto annoyance-free :-)

Kalu: aggiornare Archlinux senza password

In questo secondo articolo dedicato all' upgrade notifier kalu parleremo di un comodo trucchetto per effettuare il system upgrade della nostra Archlinux, saltando la richiesta di immissione password ( similmente a quanto accade in Fedora )
Per fare questo editiamo il file /usr/share/polkit-1/actions/org.jjk.kalu.policy e localizziamo la seguente riga:

<allow_active>auth_admin</allow_active>

sostituiamola con:

<allow_active>yes</allow_active>

Per rendere tali modifiche permanenti (evitando che in seguito all'installazione di un nuova versione di kalu il file da noi editato venga sovrascritto) possiamo utilizzare il pacchetto customizepkg.

Installiamolo con:

$ yaourt -S customizepkg

quindi, come root, diamo:

# echo "add#backup#usr/share/polkit-1/actions/org.jjk.kalu.policy" > /etc/customizepkg.d/kalu

 Buon upgrade :-)

Configurare yaourt per funzionare con i server git tramite proxy

In questo breve how-to illustrerò un semplice trucchetto per permette a yaourt di lavorare correttamente con PKGBUILD che richiedono l'acquisizione dei sorgenti da server remoti git, non raggiungibili nel caso il nostro accesso a internet sia vincolato ad un server proxy.
Arrivando subito al dunque il "trucco" sta nel sostituire all'interno del nostro PKGBUILD ogni riferimento a git:// dopo il comando git clone  in http:// dal momento che tale comando in pratica non fa altro che inviare al server git remoto una serie di GET tramite il protocollo http.
Facciamo un esempio:
innanzitutto istruiamo yaourt relativamente al proxy da utilizzare impostando  la variabile d'ambiente http_proxy, in questo modo:

$  export http_proxy=http://192.168.1.100:8080/

Sostituite indirizzo ip e porta con quelle del vostro proxy.
( Potete inserire tale comando nel vostro .bashrc oppure in uno script nella directory /etc/profile.d/ in modo che venga eseguito per tutti gli utenti di sistema. )

Proseguendo nel nostro esempio procediamo con l'installazione di un pacchetto che richiede git, xfce-theme-bluebird:

$ yaourt -S xfce-theme-bluebird

 quando yaourt vi chiede se volete modificare il file rispondete di sì, quindi cercate la stringa

git clone "git://github.com/shimmerproject/Bluebird.git

e sostituitela in

git clone "http://github.com/shimmerproject/Bluebird.git

avviate la compilazione, yaourt sarà in grado di prelevare i sorgenti e di compilare il pacchetto senza errori e senza mal di testa :-)
É anche possibile impostare yaourt in modo che applichi tali sostituzioni automaticamente al posto nostro ogni qualvolta sia necessario:

installiamo da AUR il pacchetto aggiuntivo customizepkg:

$ yaourt -S customizepkg

spostiamoci ora in /etc/customizepkg.d e, da root, diamo:

# echo "replace#global#git:#http:" > git.example

questo sarà il nostro file di "base", ogni volta che installeremo un pacchetto da git creeremo preventivamente un link a tale file con il nome del pacchetto stesso ( cioè il pkgname );nel nostro esempio daremo:

# ln -s git.example xfce-theme-bluebird

Se a questo punto provate a reinstallare il pacchetto xfce-theme-bluebird, yaourt vi notificherà riguardo le modifiche applicate; l'output sarà simile a questo:

=> removes/replaces 'git:' by 'http:' in global
--- ./PKGBUILD    2012-04-22 02:27:22.000000000 +0200
+++ ./PKGBUILD.custom    2012-04-22 23:59:46.503834220 +0200
@@ -24,7 +24,7 @@
 package() {
    
     # Clone git repository
-    git clone "git://github.com/shimmerproject/Bluebird.git"
+    git clone "http://github.com/shimmerproject/Bluebird.git"

     # Change into source directory
     cd "$_pkgname"

Ripetete la creazione del symlink a git.example per ogni pacchetto che volete scaricare da un server git.

Aggiornare Arch Linux con kalu

Kalu è un interessante "upgrade notifier", ovvero un' utility che verifica la disponibilità di aggiornamenti per la nostra Arch (sia dai repo ufficiali che da AUR) e ce ne consente la relativa installazione tramite una semplice e funzionale interfaccia GTK. Punti di forza di Kalu, che la differenziano da altri simili tool, sono, tra le altre cose,:

• la possibilità di eseguire comandi personalizzati dopo ogni aggiornamento di sistema
• notifiche e visualizzazione delle "latest news" di archlinux.org   
• controllo della disponibilità di aggiornamenti anche per pacchetti non installati

In questo breve tutorial vediamo come installare e configurare kalu in particolare per l'ambiente desktop Xfce, quello che personalmente preferisco.

Iniziamo con l'installare kalu da AUR:

$ yaourt -S kalu

 Oltre alle dipendenze indicate nel PKGBUILD, nel mio caso mi è servito installare anche il pacchetto 'polkit-gnome''  :

# pacman -S polkit-gnome

Nel caso utilizzate slim come display manager potreste inoltre aver bisogno di aggiungere la seguente riga a /etc/pam.d/slim:

session        optional        pam_ck_connector.so 

(non l'ho verificato personalmente, mi limito in questo caso a riportare quanto scritto da un arciere nel forum bbs.archlinux.org)

Questi 'fix' sono necessari qualora avviando il "System upgrade" da kalu viene restituito l'errore "Error: Failed to initialize: Authorization from PolicyKit failed".

Impostiamo kalu per l'avvio automatico al boot (verrà visualizzata un icona nel systray raffigurante il logo di Arch):

$  cp /usr/share/applications/kalu.desktop ~/.config/autostart/

Dopo aver avviato il programma, spulciando tra le preferenze noterete che di default non è prevista nessuna istruzione per l'aggiornamento dei pacchetti da AUR; per avere questa funzionalità ho creato un semplicissimo script dal nome aur_updater.sh che contiene sostanzialmente la seguente riga di codice: 

terminal -H -e "yaourt -S $(cower -uq)"

(se non avete cower installato sulla vostra macchina date un "yaourt -S cower")
Ora non resta che aprire le preferenze di kalu, selezionare la scheda "AUR", abilitare "Show a button 'Update AUR packages' on notifications" e nella casella "When clicking the button, run the following" indicare il percorso del nostro script aur_updater.sh (ricordatevi di renderlo eseguibile, ad esempio con 'chmod 755 aur_updater.sh')
Lo script non fa altro che avviare l'installazione dei nuovi pacchetti tramite yaourt all'interno del terminale di xfce. L'opzione "-H" fa in modo che il terminale non si chiuda automaticamente al termine delle operazioni di aggiornamento ( utile per esaminare comodamente l'output di yaourt )

Non occorre fare altro: ogni 60 minuti (tempo di default aggiustabile) kalu verificherà la presenza di aggiornamenti per la vostra Arch consentendovene l'installazione, quando disponibili, con pochi click :-) 

aggiornamento del 26/07/12

Per rendere ancora più rapido il processo di aggiornamento dei pacchetti AUR, possiamo invocare yaourt con l'opzione --noconfirm, modificando il nostro script in questo modo:

terminal -H -e "yaourt -S --noconfirm $(cower -uq)"

Se preferite utilizzare konsole (o siete utenti KDE) sostituite la precedente istruzione con la seguente:

konsole --hold -e yaourt -S --noconfirm  $(cower -uq)

Estrarre porzioni video con avisplit

Tra i diversi tool che ci offre la suite transcode troviamo anche un'interessante utility chiamata avisplit che ci consente di estrarre con estrema facilità porzioni di video a nostro piacimento da qualunque file avi. L'uso è veramente semplice:

$  avisplit -i  file_avi -t hh/mm/ss da estrarre -o spezzone_video.avi

Col parametro -t andremo a indicare la porzione che ci interessa, passando al programma l'intervallo di tempo relativo, nel formato hh:mm:ss, ad esempio

-t 00:38:41-00:45:50

Se il vostro file di input non è in formato avi (come nel caso dei file Flash .flv) dovrete prima convertirlo nel formato appropriato;  Potete utilizzare lo stesso transcode od altri tool come l'ottimo mencoder, in questo modo:

$ mencoder -ovc lavc -oac mp3lame file.flv -o file.avi