Chroot: come creare un ambiente a 32-bit su AMD 64

Mi è capitato pochi giorni fa di dover far fronte a questo problema: eseguire un software basato su perl 5.8.8 sparito ormai dalle più attuali distribuzioni ubuntu per essere precisi. La mia, che non è la ultimissima versione, la lucid, mette a disposizione il pacchetto perl 5.10.x.x, per ovviare avrei dovuto fare il downgrade del pacchetto perl, con tutti i problemi annessi e connessi. Per altro il SW è supportato solo su architetture a 32 bit, praticamente non avevo chance. Come fare a risolvere ? Semplice, creando un ambiente a 32 bit, attraverso il comando chroot. Vediamo come.

Dopo una breve ricerca, ho trovato che il pacchetto perl 5.8.8 è presente nella distro ubuntu hardy quindi ho battezzato quella versione come target del mio ambiente a 32 bit.

#1. Installare il pacchetto debootstrap il quale contiene una serie di script utili:

mulp@devme:~$ apt-get install debootstrap

Per saperne di più del comando vi rimando al seguente link

#2. Installare il pacchetto dchroot il quale contiene una serie di comandi utili alla creazione e all’accesso su diversi ambienti chroot:

mulp@devme:~$ apt-get install dchroot
mulp@devme:~$ mkdir /devme/chroot

Posizionatevi quindi nel punto del file system in cui desiderate creare fisicamente l’ambiente.

#3. Editare il file /etc/dchroot.conf e aggiungere la seguente riga:

hardy_i386 /devme/chroot/hardy_i386

Assicuratevi che il percorso sia corretto.

#4. Ci siamo. Siamo pronti a creare il nuovo ambiente. Eseguire il seguente comando:

mulp@devme:~$ debootstrap --variant=buildd --arch i386 hardy /devme/chroot/hardy_i386 http://archive.ubuntu.com/ubuntu/

Al termine dell’esecuzione avrete il nuovo sistema installato. Per ulteriori dettagli sul comando debootstrap vi rimando al man di sistema, aggiungo solo che il parametro variant indica il tipo di sistema che si vuol creare, in questo buildd. Il nuovo sistema creato avrà installati i pacchetti base-system.

#5. Procediamo ora alla configurazione del nuovo sistema. Eseguire i seguenti comandi:

mulp@devme:~$ cp /etc/resolv.conf /devme/chroot/hardy_i386/etc/resolv.conf
mulp@devme:~$ cp /etc/apt/sources.list /devme/chroot/hardy_i386/etc/apt/
mulp@devme:~$ chroot /devme/chroot/hardy_i386/
mulp@devme:~$ apt-get update
mulp@devme:~$ apt-get install gnupg locales dialog
mulp@devme:~$ apt-get update
mulp@devme:~$ locale-gen it_IT.UTF-8
mulp@devme:~$ tzconfig
mulp@devme:~$ exit

In sostanza si ereditano alcune configurazioni dell’ambiente principale all’interno di quello appena creato. Il primo comando consente di poter navigare dal nuovo ambiente e il secondo mette a disposizione le source list di apt affinché sia possibile aggiornarlo. Vengono installi alcuni comandi fondamentali e impostato il locale corretto. Ricordatevi di modificare il file sources.list se la distro del vostro sistema differisce dall’ambiente creato.

#6. A questo punto per accedere all’ambiente appena creato si utilizza il comando dchroot -d oppure dchroot -d- c hardy_i386 se avete a disposizione più ambienti. Vi accorgerete che il comando di cui sopra richiedono i diritti da superutente. Affinchè sia possibile accedere da utente normale, è necessario copiare alcuni file di configurazione dall’ambiente centrale in quello appena creato:

mulp@devme:~$ cp /etc/passwd /devme/chroot/hardy_i386/etc/
mulp@devme:~$ sed 's/\([^:]*\):[^:]*:/\1:*:/' /etc/shadow | tee /devme/chroot/hardy_i386/etc/shadow
mulp@devme:~$ cp /etc/group /devme/chroot/hardy_i386/etc/
mulp@devme:~$ cp /etc/hosts /devme/chroot/hardy_i386/etc/

Il comando sed rimuove le password criptate dal file shadow. Dal momento che stiamo facendo login in un’ambiente chroot non sono necessarie. In questo modo evitiamo anche di duplicare il file delle password su due ambienti diversi.

#7. Se si vuole poter eseguire il comando sudo è necessario copiare i seguenti file:

mulp@devme:~$ cp /etc/sudoers /devme/chroot/hardy_i386/etc/
mulp@devme:~$ chroot /devme/chroot/hardy_i386
mulp@devme:~$ dpkg-reconfigure passwd
mulp@devme:~$ passwd <username>
mulp@devme:~$ apt-get install sudo

E infine aggiungere la seguente riga nel file /etc/sudoers nell’ambiente chroot.

# Members of the admin group may gain root privileges
%mulp ALL=(ALL) ALL

#8. Procediamo con il mapping di alcune directory che sono utili all’interno dell’ambiente chroot. Editare il file /etc/fstab e aggiungere le seguenti righe:

/home         /devme/chroot/hardy_i386/home        none    bind      0 0
/tmp          /devme/chroot/hardy_i386/tmp         none    bind      0 0
/media/cdrom  /devme/chroot/hardy_i386/media/cdrom none    bind      0 0
/dev          /devme/chroot/hardy_i386/dev         none    bind      0 0 
proc-chroot   /devme/chroot/hardy_i386/proc        proc    defaults  0 0
devpts-chroot /devme/chroot/hardy_i386/dev/pts     devpts  defaults  0 0

Assicuratevi di effettuare la modifica sul file /etc/fstab dell’ambiente principale e che esistano tutti i mount point. Quindi eseguire il comando:

mulp@devme:~$ mount -a

#9. Infine, se volete che di fianco nel prompt appaia l’indicazione dell’ambiente chroot editate il file /devme/chroot/hardy_i386/etc/debian_chroot e aggiungete la seguente riga:

hardy_i386

Se il file non esiste createlo.

Stay tuned!

Mappa dei click sul proprio sito

Non so voi, ma diverse volte mi sono chiesto quali sono i punti in cui l’utente effettuasse i click su un sito, in particolare sul mio blog. Sono varie le considerazioni che si possono fare da un’analisi del genere, ad esempio capire quali sono gli elementi più cliccati, se un elemento posto in un certo punto della pagina ha più appeal rispetto ad un altro punto, etc etc. In generale queste mappe mostrano i punti caldi di una pagina web per i quali può essere fatta una serie di analisi. Ciò detto passiamo alla pratica. Cercando un po in rete ho trovato una soluzione open-source che voglio condividere. La soluzione usa javascript per il rilevamento dei click e perl per la costruzione della mappa. Sarebbe interessante tradurre lo script in perl in un altro linguaggio, php o Java ad esempio, così da cambiarne il contesto. Ma procediamo per gradi.

Javascript

Non mi soffermerò molto sul codice javascript che realizza la rilevazione dei click, con l’utilizzo di jquery diventa veramente semplice scrivere 2 righe di codice (si fa per dire), dopo che il DOM si è reso disponibile (document.ready()), si aggancia all’evento onclick e registra le coordinate in cui è avvenuto il click assieme ad altri dati aggiuntivi. Supponiamo quindi che i dati rilevati siano:

x709y351
x350y348
x489y294
x655y346
x384y305
x332y288
x399y288
…

In questo modo è possibile rilevare le zone della pagina in cui sono avvenuti più click e associare loro dei valori di intensità tali da rappresentarli correttamente sulla mappa finale. A tal proposito assegnamo come valore di intensità massima 255 e come valore di intensità minima 0.

Perl

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#!/usr/bin/perl
use strict;
my $imgWidth=64;
open (LOG,"log.txt") || die;
my @log=<LOG>;
close (LOG);
my (@x,@y);
my ($xMax,$yMax,$repetitionsMax,$i,$j);
my %repetitions;
foreach my $line(@log){
	(my $coords)=$line;
	$repetitions{$coords}++;
	$coords=~s/x//;
	($x[$i],$y[$i])=split("y",$coords);
	$i++;
}
while ((my $key, my $value)=each(%repetitions)){
	$repetitionsMax=$value if $repetitionsMax<$value;
}
for ($j=0;$j<$i;$j++){
	$xMax=$x[$j] if $xMax<$x[$j];
	$yMax=$y[$j] if $yMax<$y[$j];
}
print $repetitionsMax,"\n$xMax;$yMax\n";

Analizziamo il codice di sopra. Dal file di log contenente le rilevazioni sui click effettuati, vengono lette le coordinate e salvate all’interno di due array $x e $y rispettivamente. Per ciascun valore acquisito viene determinato il valore massimo assoluto e il valore massimo della x e della y. Successivamente si procede con la creazione dell’immagine: 

my $xCanvas=$xMax+int($imgWidth/2);
my $yCanvas=$yMax+int($imgWidth/2);
my $createcanvas="convert -size ". $xCanvas.#//
"x".$yCanvas." pattern:gray100 empty.png";
system ($createcanvas);

impostando le dimensioni calcolate nello step precedente e sfruttando una funzionalità di sistema.
Dopo aver creato l’immagine procediamo col disegnare i punti della nostra mappa, anzi, invece di limitarci a disegnare dei singoli punti, andiamo a creare delle regioni a partire da un file png che ci consente di farlo. Scegliamo come valore di opacità 1 e calcoliamo una formula che ci consenta di determinare il livello di sovrapposizione (overlay) da usare per ciascuna regione. In questo modo le regioni più cliccate saranno sovrapposte e quindi più scure.

my $createNormalizedSpot="convert bolilla.png -fill #//
white -colorize ".int(100/$repetitionsMax)."% bol.png";
system ($createNormalizedSpot);
 
/* Procediamo per ciascuna riga di coordinata */
 
for ($j=0;$j<$i;$j++){
    my ($x,$y);
    $x=$x[$j]-32;
    $y=$y[$j]-32;
    system ("composite -compose multiply -geometry #//
    +$x+$y bol.png empty.png empty.png\n");
    print "used $j of $i clicks\n";
}

Otteniamo quindi un’immagine del genere:

Come piccolo tocco di classe, rendiamo l’immagine creata, in modo tale che abbia il tipico schema di colore delle mappe di calore, in cui i punti più cliccati saranni quelli più caldi e quelli meno cliccati più freddi. Per fare questo usiamo la libreria di Imagemagick, a partire da un file di immagine contenente il gradiente del colore in questione:

convert empty.png -negate full.png
convert full.png colors.png -fx "v.p{0,u*v.h}" final.png

ottenenedo come risultato:

La mappa finale

Bene, come risultato finale, prendiamo un’immagine del nostro sito web, ottenuto attraverso uno screenshot di sistema o qualunque altra cosa adatta a farlo e sovrapponiamo la mappa creata con il seguente comando:

composite -blend 40% final.png blog.png heatmap.png

E’ facile notare che, guardare l’immagine del risultato fa totalmente un’altro effetto rispetto al piatto file di log da cui siamo partiti.
Stay tuned !!