Sharp photo by sjarvinen

Today I’ve discovered a simple, little, but extremely useful WordPress plugin that sets your incoming post from Flickr as drafts.

Nothing too complicated, it counts just ten lines of code, but if  you often use Flickr pictures in your posts, like me, you may find this plugin combined with some tricks, very powerful.

Why Flickr?

I love good photos, but I’m not a good photogrpher.
I always wanted to have great images to remark the meaning or the atmosphere of my posts, so I started to search good pictures online.

However when I found a good one it was also difficult to know if I could use it without problems due to potential licences.

Then came Flickr.

On Flickr you can search for Creative Commons licenced pictures, free to be used, even for commercial purposes!

Posting from Flickr: the good, the bad and the ugly.

• The good.
  Posting from Flickr is simple, you choose a photo and, if it’s Creative Commons licenced, you can include it, with right tags, attributes, link to the author, bells and whistles,  just by clicking on the post to blog icon. Just configure it properly and it works.
• The bad.
  Flickr is not meant to be a blogging platform, so the editor that it provide is too stripped and rigid to be really useful.
• The ugly.
  Immediately, as soon as you hit the post button, your article is published. On the fly. No way to save, review or correct what you have just written!

The solution

What if I could create a post from Flickr and then revise it in WordPress editor?

I tried a workaround to do that: I set a special user with permission to create drafts but not publish in my WordPress blog, and then set Flickr to publish using that account, so I could edit the post before publishing, but unfortunately this trick didn’t work out.

Then I found the Flickr Blog This to Draft plugin.

How I use it.

I made the dirty work just one time, when I configured my blog on Flickr, let’s see how:

<a href="{photo_url}" target="_blank">
<img class="foto" title="{photo_title} by {uploader_name}" src="{photo_src}" alt="{photo_title} by {uploader_name}" width="500" height="375" />
</a>
<p class="credits"><a href="{photo_url}" target="_blank">{photo_title}</a> by <a href="{uploader_profile}" target="_blank">{uploader_name}</a></p>
{description}


This is my standard template sent when I post pictures to my blog from Flickr. You can configure yours going on Your Account > Extending Flickr (tab) > Blogs (edit) > Layout.

You may be interested in a complete list of all the special tags in curly braces, those who are dynamically transformed in accordion to the picture posted.

As you can see, in my case, I set a default 500×375 px picture linked back to its page, with title and author cited in alt and title attribute and followed by a paragraph with the original title and the author linked accordingly.

Now each picture I post is properly inserted in a draft, consistently across all my posts and without hassles!

.

Chi ha già provato ad installare Qemu con Kqemu in Ubuntu Gutsy si sarà accorto che la procedura è fondamentalmente la stessa che si usava per Feisty.
Ma la mia vecchia guida, ha decisamente bisogno di una revisione.
Grazie ai vostri commenti ho già avuto modo di estenderla, e sarei felice di poterla rendere ancora migliore.

Indice

1. Passi preliminari
2. Installazione di Qemu + Kqemu
3. Prova su strada
4. Problemi frequenti
   1. Could not open ‘/dev/kqemu’…
   2. You do not have enough space in ‘/dev/shm’…
   3. Problemi di accesso in scrittura
5. Tips & Tricks
   1. Caricare il modulo kqemu all’avvio del sistema.
   2. Impostazione della dimensione di /dev/shm all’avvio
6. Front-end Grafici
   1. Qemu Launcher
   2. Qemuctl
   3. Qemulator

1. Passi preliminari

Prima di iniziare ad installare il necessario è opportuno controllare se l’hardware di cui disponiamo supporta la Kernel Virtualization.
grep -E '^flags.*(vmx|svm)' /proc/cpuinfo
Se ricevete in risposta un output tipo questo
flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe lm constant_tsc pni monitor ds_cpl vmx est tm2 cx16 xtpr lahf_lm
flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe lm constant_tsc pni monitor ds_cpl vmx est tm2 cx16 xtpr lahf_lm

vuol dire che il vostro processore supporta l’accelerazione diretta delle VM.
E’ quindi in grado di usare, oltre al metodo qui descritto, kvm come acceleratore, ampiamente trattato nel wiki di ubuntu.

2. Installazione di Qemu + Kqemu

Qemu (versione 0.9) si trova comodamente nei repository di Ubuntu ed è il programma principale.
Kqemu invece è un modulo del kernel per accelerare le VM.
Quest’ultimo va compilato ed installato, per questo ricorriamo all’aiuto di module-assistant.

Installiamo i pacchetti necessari:
sudo apt-get install qemu kqemu-source module-assistant
Compiliamo kqemu:
sudo module-assistant prepare
sudo module-assistant auto-install kqemu
Ora dobbiamo istruire udev per creare il nodo /dev/kqemu al caricamento di kqemu, perciò creiamo il file /etc/udev/rules.d/60-kqemu.rules:
sudo nano /etc/udev/rules.d/60-kqemu.rules
scriviamo questa riga:
KERNEL=="kqemu", NAME="%k", MODE="0660", GROUP="kqemu"
Salviamo e chiudiamo il file, poi modifichiamo il file /etc/modprobe.d/kqemu
sudo nano /etc/modprobe.d/kqemu
in modo che contenga questa riga:
options kqemu major=0
di solito trovate quel valore impostato a 250 e si tratterà solo di cambiare quello.

Rendiamo ora kqemu utilizzabile dai normali utenti del sistema
sudo addgroup --system kqemu
sudo adduser $USER kqemu
Con questi due comandi abbiamo creato un gruppo chiamato kqemu e inserito l’utente col quale siamo loggati nel gruppo.
Se voleste aggiungere altri utenti al gruppo kqemu basta sostituire a $USER lo username dell’ utente che vogliamo.

E’ ora necessario aggiornare le variabili d’ambiente, il modo più semplice è terminare la sessione e rifare il login.

3. Prova su strada

Proviamo a caricare manualmente il modulo del kernel kqemu, più avanti spiegherò anche come caricare kqemu all’avvio del sistema.
sudo modprobe kqemu
Se non riceviamo messaggi d’errore è perchè non ci sono stati problemi quindi possiamo procedere all’avvio vero e proprio di qemu.

Complimenti! Ora il vostro PC è pronto ad ospitarne un altro.

In questo esempio installeremo Windows XP, che richiede minimo 2Gb di spazio, su un hard disk virtuale di 5Gb.
Creazione dell’immagine disco virtuale:
qemu-img create -f qcow winxp.img 5G
Inseriamo il CD di installazione di Windows e avviamo la nuova VM
qemu -localtime -cdrom /dev/cdrom -m 384 -boot d winxp.img
E’ possibile utilizzare anche solo l’immagine ISO del CD di installazione, avviando la macchina virtuale con
qemu -localtime -cdrom /percorso/alla/iso/nomefile.iso -m 384 -boot d winxp.img
ovviamente sostituendo “/percorso/alla/iso/nomefile.iso” con il percorso e il nome che fanno al caso nostro.

A volte può succedere che il sistema di installazione di Windows XP si blocchi. Se vedete che passa troppo tempo senza che l’installazione sembri andare avanti provate a riavviare la VM, l’installazione riprenderà dal punto in cui era arrivata. Nel mio caso comunque ha proceduto come se fosse su un PC reale.

4. Problemi frequenti

4.1 Could not open ‘/dev/kqemu’…

Se all’avvio della VM dovessimo ricevere questo messaggio d’errore
Could not open '/dev/kqemu' - QEMU acceleration layer not activated
E’ probabile che l’utente corrente non appartiene al gruppo kqemu, da terminale diamo il comando
groups
e controlliamo l’output: tra i vari gruppi a cui siamo associati deve esserci kqemu, in caso contrario
sudo addgroup --system kqemu
sudo adduser $USER kqemu

4.2 You do not have enough space in ‘/dev/shm’…

Altro errore più che frequente:
You do not have enough space in '/dev/shm' for the 384 MB of QEMU virtual RAM.
To have more space available provided you have enough RAM and swap, do as root:
umount /dev/shm
mount -t tmpfs -o size=400m none /dev/shm
Or disable the accelerator module with -no-kqemu
In questo caso seguendo il suggerimento del modulo kqemu:
umount /dev/shm
mount -t tmpfs -o size=400m none /dev/shm
In generale la dimensione di tmpfs deve essere uguale alla memoria della VM + 16 Mb
Se necessario, possiamo modificare la dimensione predefinita di /dev/shm

4.3 Problemi di accesso in scrittura

In caso di problemi di accesso in scrittura all’immagine della VM, assicuriamoci che tale file abbia i permessi adatti e appartenga anche al gruppo kqemu.
chmod 660 winxp.img
sudo chown $USER:kqemu winxp.img

5. Tips & Tricks

5.1 Caricare il modulo kqemu all’avvio del sistema.

Apriamo il file /etc/modules
sudo nano /etc/modules
aggiugiamo al fondo
kqemu

5.2 Impostazione della dimensione di /dev/shm all’avvio.

Ad ogni avvio di sistema, /dev/shm viene reimpostato al valore di default.
Nella vecchia guida consigliavo di aggiungere la nuova dimensione sul file /etc/fstab, ma questo mi causava sporadicamente qualche problemino durante l’arresto del sistema così ho trovato un modo più corretto.

Possiamo invece stabilire un valore per la dimensione massima di /dev/shm in modo che kqemu utilizzi solo quella che gli serve.
Calcolatrice alla mano, apriamo il file /etc/default/tmpfs
sudo nano /etc/default/tmpfs
troviamo una riga con scritto
SHM_SIZE=VALORE
VALORE, espresso in bytes, deve essere pari alla memoria della VM + 16 Mb
(è più difficile a dirsi che a farsi… proviamo con una formuletta!)
1 Mb = 1024 * 1024 bytes = 1048576 bytes, quindi
VALORE = (MEMORIA + 16) * 1048576
ad esempio se volessi assegnare 512Mb alla macchina virtuale avrei
512 + 16 = 528Mb
528 * 1048576 = 553648128 byte

In altre distro questa variabile potrebbe essere impostata altrove, ad esempio in Suse è nel file /etc/sysconfig/kernel, quindi se non state usando Ubuntu questo metodo potrebbe non funzionare.

6. Front-end Grafici

Esistono fondamentalmente 3 programmi che possono renderci più comodo l’uso di Qemu

6.1 Qemu Launcher

sudo apt-get install qemu-launcher

6.2 Qemuctl

sudo apt-get install qemuctl

6.3 Qemulator

sudo apt-get install qemulator

Personalmente preferisco i primi due:
Qemu Launcher, serve semplicemente a creare o avviare le macchine virtuali, mentre qemuctl è un menu che ci permette di controllare la VM durante l’esecuzione.
Con quemuctl, possiamo ad esempio connettere nuove periferiche, salvare lo stato della macchina, smontare e montare CD-ROM etc.
Tutte cose che, normalmente, dovremmo fare dalla console di Qemu alla quale si accede con la combinazione di tasti Ctrl + Alt + 2
Qemulator è graficamente più piacevole ed include alcune funzioni di qemuctl, ma è ancora poco stabile, necessita di rimanere avviato in background, e a volte rallenta l’esecuzione della VM.

Ma esiste una soluzione ed io l’ho trovata…
Giusto per capirci, i cosiddetti terminali virtuali, sono quelle console che si aprono (se utilizzate un ambiente desktop) con le combinazioni Ctrl + Alt + F1…F6.

Sono chiamati così perché anche se girano fisicamente tutti sulla stessa macchina, sono indipendenti ognuno dall’altro, come se avessimo tanti terminali connessi al nostro PC, per cui per ognuno è necessario effettuare un diverso login.

Infine abbiamo il settimo terminale (Ctrl + Alt + F7) che è quello a cui è connesso il famosissimo X e che di fatto è quello che utilizziamo (spesso senza saperlo) per far funzionare il nostro DE preferito.

Tutti quelli che utilizzano una versione server di Ubuntu oppure coloro che per abitudine vogliono controllare le operazioni effettuate durante l’avvio del sistema, è penalizzante essere costretti ad utilizzare una risoluzione bassissima (640×480 con caratteri 8×16) che tra le altre cose è anche piuttosto bruttina da vedere.

E allora come fare?

Le operazioni che seguiranno sono molto delicate in quanto modificheremo il comportamento del sistema in fase di boot. Inutile dire che errori in questo caso potrebbero rendere il sistema inutilizzabile pertanto assicuratevi che i vostri dati siano al sicuro e di avere un CD live di Ubuntu. In caso di problemi io sono comunque a vostra disposizione

Per questa guida ho utilizzato l’editor di testi nano, se non vi ci trovate bene, vi sta antipatico o non sapete usarlo e ne preferite un altro (chessò vi, emacs o gedit), vi basterà sostituire all’occorenza nano con ciò che preferite. E ora andiamo a sporcarci le mani.

1. Togliamo il nostro modulo per il framebuffer dalla blacklist

sudo vi /etc/modprobe.d/blacklist-framebuffer
Dovreste vedere una cosa tipo questa
# Framebuffer drivers are generally buggy and poorly-supported, and cause
# suspend failures, kernel panics and general mayhem. For this reason we
# never load them automatically.
blacklist aty128fb
blacklist atyfb
blacklist radeonfb
blacklist cirrusfb
...
blacklist nvidiafb
...
blacklist vesafb
blacklist vfb
blacklist vga16fb

Come potete leggere dalle prime righe di questo file sono stati esclusi tutti i moduli per il supporto al framebuffer onde evitare bug.
Cercate il driver relativo alla vostra scheda video e commentate la riga relativa aggiungendo un #, lo si intuisce facilmente dal nome (quale sarà quello per una ATI Radeon? :P), potete tranquillamente scegliere vesafb o (nel caso non dovesse funzionare vga16fb) che sono driver generici, tanto avere il supporto al 3d o a chissà quali mirabolanti features è assolutamente inutile per un terminale di testo.

Se avete una scheda video Nvidia il discorso si complica leggermente:

• Controllate se state utilizzando un driver proprietario o opensource
  cat /etc/X11/xorg.conf | grep Driver
  Il risultato sarà più o meno così
  Driver "kbd"
Driver "mouse"
Driver "wacom"
Driver "wacom"
Driver "wacom"
Driver "nvidia"
Driver "nvidia"
• se tra le ultime righe compare nvidia, state usando i driver proprietari (come me), quindi commentate vesafb
• nvidiafb si usa nel caso stiate utilizzando i driver opensource (nv)

Salviamo e chiudiamo il file.

2. Aggiungiamo i moduli necessari tra quelli caricati all’avvio

Altro file di configurazione da modificare.

sudo nano /etc/initramfs-tools/modules

Aggiungiamo alla fine, uno per riga i moduli fbcon e quello decommentato pocanzi. Nel mio caso ottengo
# List of modules that you want to include in your initramfs.
#
# Syntax: module_name [args ...]
#
# You must run update-initramfs(8) to effect this change.
#
# Examples:
#
# raid1
# sd_mod
fbcon
vesafb

3. Aggiorniamo lo script di avvio (il grande init)

Niente dipiù facile grazie ad un’utility creata solo per questo
sudo update-initramfs -u -k all

4. Modifichiamo la configurazione di Grub

Se non lo abbiamo già fatto, ora possiamo scegliere la risoluzione che preferiamo durante l’avvio, modificando /boot/grub/menu.lst
sudo nano /boot/grub/menu.lst
scorriamo il file fino queste righe
## additional options to use with the default boot option, but not with the
## alternatives
## e.g. defoptions=vga=791 resume=/dev/hda5
# defoptions=vga=795 ro verbose nosplash locale=it_IT

Senza decommentare niente, possiamo ora aggiungere le opzioni che ci interessano separate da spazi. Per saperne di più potete consultare il wiki della comuinità di ubuntu.

Nel mio caso ho utilizzato le opzioni

• vga=795 per avere una risoluzione di 1280×1024 @ 32bit
• ro per accedere al filesystem di avvio in sola lettura (non è obbligatorio, ma è buona norma farlo)
• verbose per visualizzare tutti i messaggi del sistema durante il boot
• nosplash disattiva l’uso di usplash (la barra di caricamento grafica di ubuntu) che volendo ha una sua seppur limitata modalità verbose se lo preferite
• locale=it_IT imposta la localizzazione del sistema in modo da avere (quando possibile) i messaggi in italiano anche durante il boot

Salviamo, chiudiamo ed infine aggiorniamo grub:
sudo update-grub

Controlliamo che non ci abbia dato errori prima di riavviare. Al prossimo riavvio potremo verificare che tutti i cambiamenti abbiano avuto l’effetto sperato.

per vostra comodità aggiungo infine una piccola tabella con elencate tutte le risoluzioni video e i relativi valori da aggiungere all’opzione vga= . Potete indifferentemente mettere il valore decimale o esadecimale (0x…)

Non so per quale strano motivo, ma il pacchetto di Mail Notification presente nei repository di Ubuntu 7.10 è stato compilato senza supporto al protocollo SSL.

Alzino la mano tutti quelli, come me, che utilizzano questo pacchetto e che magari hanno delle caselle di posta (tipo quella di Poste Italiane) che utilizza questo protocollo (ottimo tra l’altro, visto che consente la comunicazione criptata).

Ma non c’è da preoccuparsi, ci basterà seguire pochi semplici passi per ricompilare l’applicazione con i parametri “giusti” e riavere tutte le funzionalità di cui abbiamo bisogno.

E’ solo uno dei tanti vantaggi di usare Linux :)

1. Installare gli strumenti per la compilazione

Semplice come aprire un terminale e digitare
sudo apt-get install devscripts dh-make make build-essential fakeroot

Consiglio anche di creare una cartella /temp nella propria /home e posizionarci all’interno
mkdir ~/temp
cd ~/temp

2. Installare il sorgente e le dipendenze per mail-notification

Prima di procedere assicuriamoci di aver abilitato i repository dei sorgenti.

Nel menu di Gnome andiamo in Sistema -> Amministrazione -> Sorgenti Software e abilitiamo la casella di controllo Codice Sorgente. Oppure possiamo aprire /etc/apt/sources.list e decommentare quelle righe che iniziano con deb-src.

Infine torniamo al terminale e scarichiamo i sorgenti (dovrebbero andare a finire nella famosa /temp)
apt-get source mail-notification
Occhio ad apt che per i sorgenti non viene utilizzato con sudo. Ora scarichiamo le dipendenze per la compilazione
sudo apt-get build-dep mail-notification
e la libreria libssl-dev che non è compresa nelle dipendenze di compilazione, proprio perchè consente di attivare il supporto ad SSL
sudo apt-get install libssl-dev

3. Modificare le regole di compilazione

Entriamo nella directory dei sorgenti
cd mail-notification-4.1.dfsg.1

Modifichiamo le regole di compilazione
gedit debian/rules

Cerchiamo nel file la stringa –disable-ssl (dovrebbe trovarsi nella linea 11) ed eliminiamola, salviamo e ritorniamo al terminale.

4. Ricompilare i sorgenti

Dovremmo ora trovarci nella directory ~/temp/mail-notification-4.1.dfsg.1. Se così non fosse facciamo in modo di posizionarci lì con il terminale e avviamo la compilazione
dpkg-buildpackage -rfakeroot

5. Sostituire il file binario vecchio con quello appena compilato

Ora facciamo una cosa un po’ sporca :P non installiamo regolarmente il pacchetto appena compilato, ma sovrascriviamo semplicemente il binario vecchio con quello nuovo
sudo cp debian/mail-notification/usr/bin/mail-notification /usr/bin/mail-notification

Perchè?

Questione di semplicità. In questo caso era possibile farlo e non è stato necessario andare a creare un intero pacchetto da capo con le varie difficoltà annesse (dipendenze, percorso di installazione, versione etc.).

Inoltre così facendo riceveremmo normalmente eventuali aggiornamenti e se per caso qualcosa fosse andato storto potremmo semplicemente reinstallare mail-notification dai repository per riaverlo come prima.

Spero di esservi stato utile… alla prossima!

Stay tuned!

I programmatori veri a questo punto sono invitati a non proseguire nella lettura, sto per elencare una serie di stupidaggini che potrebbero offenderli anche se non è mia intenzione farlo :P

Tutto iniziò in una giornata di pioggia, ero a lavoro e nella pausa pranzo mi sono trovato “per caso” sul sito di Netbeans.
OOOOOOOOH! 8-)
Ho dato un’occhiata ai tutorial e mi sono fatto prendere dall’entusiasmo, sembrava che chiunque in grado di muovere un mouse potesse creare senza scrivere una riga di codice una bella applicazione java con tanto di finestrelle e bottoni.
Premetto che la programmazione sta a me come il fai-da-te starebbe ad un notaio: in parole povere per me è un hobby e per quanto possano fare schifo le mie opere avranno sempre un posto d’onore :P

Comunque dopo averlo guardato più che provato a lavoro, sono corso subito a casa a installarlo sulla mia Ubuntu (… no uso ancora Feisty)

Noooooooo!
Vi è mai capitato di avviare un’applicazione Java mentre sta girando Compiz e vedere la finestra tutta bianca?
Beh con Netbeans (installato dai repository) è successo…
Dopo una rapida googleggiata ho scoperto che era un problema noto e risolto nell’update 2 dell’ultimo Java Runtime Enviroment.
Vado a fare un giro in casa Sun e vedo che siamo già all’update 3, mentre Ubuntu sembra non smuoversi dall’ update 1…
Certo potrei stoppare compiz e usare Netbeans lo stesso, ma a me le cose semplici non piacciono per niente e così decido di trovare il sistema per installare l’ultima versione di Java al posto di quella dei repo e visto che ci sono mi scarico anche il nuovo Netbeans che non fa mai male…

Ma ora bando alle ciance e passiamo all’how-to vero e proprio.

@edit: Per conservare il pacchetto ufficiale rilasciato nei repository di Ubuntu, esiste un metodo di installazione alternativo che consiste nell’installare il Jre o il Jdk in una directory (solitamente /opt) per conservare intatto il pacchetto ufficiale e poter beneficiare degli aggiornamenti automatici.

1. Scaricare JDK update 3

http://java.sun.com/javase/downloads/index.jsp
Scegliete il pacchetto per Linux (ovviamente) autoestraente (non l’RPM)
jdk-6u3-linux-i586.bin

2. Installate fakeroot e java-package

sudo apt-get install fakeroot java-package
Quest’ultimo è una serie di script fatti apposta per pacchettizzare le varie JRE o JDK per debian, ma al momento in cui scrivo tale pacchetto non è ancora aggiornato per funzionare con l’ultima versione di java e bisognerà fare un piccolo hack per renderlo utile al nostro scopo.

3. Modifica (eventuale) degli script di java-package

cd /usr/share/java-package
ls

Controlliamo se nell’output è presente la directory
sun-j2sdk1.6
se c’è, vuol dire che nel frattempo hanno aggiornato java-package e possiamo tranquillamente saltare al punto 4

Se non c’è la creiamo copiando sun-j2sdk1.5
sudo cp sun-j2sdk1.5 sun-j2sdk1.6
Entriamo nella directory appena creata e modifichiamo i due file install.sh e sun-j2sdk.sh

cd sun-j2sdk1.6
sudo gedit install.sh
In questo script va cambiata solamente la prima riga. Deve essere così:
suffix=j2sdk1.6-sun
Salviamo e chiudiamo.
sudo gedit sun-j2sdk.sh
Nella prima sezione noterete un blocco che inizia con
case case "${DEB_BUILD_ARCH:-$DEB_BUILD_GNU_TYPE}" in ...
alla fine di quel blocco (prima della parola esac)
aggiungete queste righe:
"jdk-6u3-linux-i586.bin") #Tra virgolette il nome del file scaricato dal sito della Sun
j2se_version=1.6
j2se_expected_min_size=130
found=true
;;

Salvate e chiudete.

4. Pacchettizziamo la JDK

Ora che i nostri script sono pronti possiamo tornare alla nostra home o altra directory in cui abbiamo scaricato la JDK e pacchettizzarla
fakeroot make-jpkg jdk-6u3-linux-i586.bin
Accettiamo la licenza e lasciamo che si crei il pacchetto .deb nella directory attuale

5. Disinstalliamo i vecchi pacchetti Java (se c’erano)

sudo apt-get remove sun-java6-*

6. Installiamo la JDK

sudo dpkg -i sun-j2sdk1.6_1.6_i386.deb

7. Aggiustiamo le variabili d’ambiente per Java

sudo gedit /etc/enviroment
Il file dovrà apparire così:
PATH=".:/usr/lib/j2sdk1.6-sun/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games"
LANG="it_IT.UTF-8"
JAVA_HOME="/usr/lib/j2sdk1.6-sun"
CLASSPATH="/usr/lib/j2sdk1.6-sun/lib:/usr/lib/j2sdk1.6-sun/classes"
LANGUAGE="it_IT:it:en_GB:en"

8. Dulcis in fundo… il plugin per firefox!

sudo ln -sf /usr/lib/j2sdk1.6-sun/jre/plugin/i386/ns7/libjavaplugin_oji.so /usr/lib/firefox/libjavaplugin_oji.so

Ce la siamo… ehm, abbiamo fatta! (spero)

Verifica… he he he

Andiamo a questo link per eseguire il test della jvm.
Se vi appare il coso che balla e la scritta “Congratulations…” significa che tutto è andato a buon fine :)

Ora possiamo goderci delle chicche del calibro di Netbeans 6.0 Beta2 senza dover disattivare Compiz!

Questo è un post dedicato a chi (come me) si interessa di webdesign.

Utilizzare Ubuntu come piattaforma di sviluppo web non è un’idea così malvagia:
Apache + Php + Mysql si installano quattrequattrotto.

Software per sviluppo web ce n’è:

• Bluefish
• Geany
• Cssed
• Screem
• gPHPEdit
• …

E’ vero, non c’è competizione con programmi come Dreamweaver, ma se pensiamo che alla fine un buon sito non deve avere layout complicatissimi (anzi meno markup c’è e meglio è), deve essere scritto da qualcuno che ha una certa dimestichezza col codice (altrimenti siamo solo utenti di un programma, non webdesigner) e soprattutto pensiamo alle nostre tasche, ecco che l’opzione Linux (qualunque distro) ritorna a fare capolino…

Rimane il fatto che una grossa fetta di utenti utilizza ancora MS Internet Explorer.
E allora, come fare?

Lo installiamo sulla nostra amata Ubuntu! (quante volte avete letto questa frase? :P )

Installazione

Armiamoci di terminale e scarichiamo la chiave per autenticare i pacchetti…
wget -q http://wine.budgetdedicated.com/apt/387EE263.gpg -O- | sudo apt-key add -

Aggiungiamo i repository…
sudo wget http://wine.budgetdedicated.com/apt/sources.list.d/feisty.list -O /etc/apt/sources.list.d/winehq.list

NOTA:Con questo comando in realtà aggiungiamo il file winehq.list alla directory /etc/apt/sources.list.d che è come se aggiungessimo le righe in esso contenute al file /etc/apt/sources.list

Installiamo Wine e cabextract…
sudo apt-get update
sudo apt-get install wine cabextract


E, dulcis in fundo, installiamo IEs4Linux…
wget http://www.tatanka.com.br/ies4linux/downloads/ies4linux-latest.tar.gz
tar zxvf ies4linux-latest.tar.gz
cd ies4linux-*
./ies4linux


Note

IEs4Linux installerà Internet explorer 6 per default, e vi chiederà anche di installare le versioni 5.5 e 5. Inoltre potrete decidere, durante l’installazione, le opzioni di localizzazione e l’installazione d Adobe Flash Player (dovrebbe esserci già la versione 9).

Si tratta di software proprietari quindi dovrete accettare le condizioni di utilizzo. Lo so che non lo fa nessuno, ma leggetele prima di accettarle, se non altro vi renderete conto delle restrizioni a cui chi usa tali software è soggetto.

IEs4Linux contiene solo gli strumenti base per un buon test dei siti web o per chi ha bisogno di utilizzare siti disegnati esclusivamente per IE, quindi niente integrazione con la posta nè con il player audio/video.
Sconsiglio vivamente di utilizzarlo per il normale web browsing.

NEW!Ho creato due icone da usare con IEs4linux, se avete seguito questa guida potrebbero servirvi, dategli un’occhiata in questo post

Ho notato che utilizzando qemu è abbastanza comune l’errore qui riportato e di cui ho già avuto modo di parlare.

Spesso e volentieri cerchiamo di virtualizzare macchine che hanno bisogno di molta memoria, per poter utilizzare sistemi operativi recenti.

Onde evitare di avere ad ogni riavvio del sistema il problema di /dev/shm troppo piccolo, possiamo rendere definitive le opzioni che ci suggerisce qemu aggiungendo una riga al file /etc/fstab.

Se guardate la parte evidenziata nella figura qui sopra, noterete una riga che dice che per emulare 384 Mb di ram bisogna assegnare a /dev/shm 400 Mb.

Prendete nota della risposta e aprite /etc/fstab… anzi no fatene prima un backup (non si sa mai)
sudo cp /etc/fstab /etc/fstab.bak
sudo gedit /etc/fstab
Troverete una specie di tabella in cui ogni riga (occhio ai ritorni a capo per le righe troppo lunghe) è una voce relativa ad un supporto o filesystem usato dal sistema (ci sono ottime guide che spiegano meglio ‘sta cosa, ve ne linko una).

Cercate (se c’è) la riga che inizia con “shm”, sulla mia ubuntu non c’era, evidentemente il sistema di installazione non ha ritenuto necessario inserirla, quindi ho dovuto aggiungerla io.
Ad ogni modo quella riga deve essere così
shm /dev/shm tmpfs rw,size=400m 0 0
Attenzione! La riga è composta così:

Nome del filesystem (shm) [spazio] punto di mount (/dev/shm) [spazio] tipo di filesystem (tmpfs) [spazio] opzioni separate da virgola (rw,size=400m) [spazio] zero [spazio] zero.

No non penso che non sappiate leggere, è solo che fstab, in quanto file di configurazione ha una sua precisa sintassi, se doveste per sbaglio (capita… anche a me :P) inserire uno spazio nel posto sbagliato, la riga verrebbe ignorata e potreste poi perderci le notti a cercare di capire il problema oppure più semplicemente potreste inveire nei miei confronti (e questo sarebbe un vero problema).

Fatto questo facciamo una prova, montiamo /dev/shm con le sue opzioni di default (cioè quelle che abbiamo imposto noi pocanzi) e controlliamo l’output (cfr. punto 3 di questo articolo)
sudo umount /dev/shm
sudo mount -v /dev/shm
Con l’opzione -v chiediamo a mount di essere chiacchierone e se abbiamo fatto le cose per bene dovremmo avere un output tipo questo
shm on /dev/shm type tmpfs (rw,size=400m)
Questo ci conferma (visto che non abbiamo specificato nulla nel comando mount) che per default shm sarà montato su /dev/shm, con filesystem tmpfs, in lettura e scrittura, ma soprattutto con una dimensione di 400 Mb. Stessa cosa succederà da ora ad ogni riavvio del sistema.

And that’s all, folks!

Trova grande utilità pratica soprattutto mentre si segue ad esempio un how-to:

Quante volte vi è capitatoin queste occasioni di avviare qualche applicazione per desktop dalla console (tipico esempio quando dovete avviare un editor come superutente)?

E quante volte vedendovi invasi da finestre e in vena di pulizie avete chiuso il il terminale dal quale avevate avviato quell’applicazione desktop che vi serviva con conseguente chiusura di quest’ultima e giramento di maroni?

Se vi capita spesso, vi do un piccolo suggerimento:

All’avvio dell’applicazione, se vedete che il terminale sembra “bloccato” perchè in attesa della chiusura di questa, con la combinazione di tasti Ctrl+z la mandate in sospensione liberando il terminale.

A questo punto potete digitare
bg nomeapp
e come per magilla la nostra applicazione riprende vita e possiamo chiudere il terminale o usarlo per altre cose!

Esercizio per casa:

Aprite un terminale.
gedit prova.txt
Ctrl+z
bg gedit
Sorridete!

Ecco una piccola raccolta di suggerimenti e integrazioni che possono tornare utili nel caso abbiate provatro a seguire la “mia” guida (ho solo tradotto e “arricchito” un po’).

1. GUI per Qemu

Se proprio vi sta antipatico il terminale… tornate a Windows ;)
Scherzo, non siete in pochi a desiderare un front-end grafico per qualsiasi cosa, tant’è che qualcuno ha già pensato a creare una GUI per Qemu.

Si chiama Qemu Launcher, ma a dispetto del nome permette non solo di lanciare una VM, ma permette anche di creare le varie unità virtuali (l’immagine dell’hard disk o dei floppy per intenderci), di impostare praticamente tutti i parametri della VM ed eventualmente salvarli in modo da poter gestire diverse VM senza troppi grattacapi.

Per installarlo è sufficiente digitare da terminale
sudo apt-get install qemu-launcher

ma sicuramente preferite usare synaptics :P cercate allora il pacchetto qemu-launcher e installatelo!

2. Permessi e proprietari

Se linux è considerato “sicuro”, “virus-free” etc etc. è, in parte, grazie alla sua profonda integrazione di un sistema di permessi che, se da una parte può sembrare noioso e rompiballe, dall’altra ci permette di lavorare in tutta tranquillità senza la minima preoccupazione per l’integrità del nostro sistema o per i dati di altri utenti.

La mia guida è stata scritta ipotizzando che l’utente che la segue sia poi quello che utilizzerà qemu, si è sottinteso che i file utilizzati in scrittura dalla VM fossero quindi nella home dell’utente in questione.

Nel 90% dei casi l’impossibilità di scrivere o leggere un file, da parte della VM, è a causa dei permessi o del proprietario.
Studiateli, cercate di comprenderli, ogni tanto provate a controllare (con un bel ls -l nomefile, o tramite il nostro file manager preferito) che permessi ha questo o quel file.

Se non assimilate bene questi concetti, rischiate di fare pasticci.

Ad esempio se doveste usare un “sudo” di troppo potreste ritrovarvi con qualche file appartenente a “root” nella vostra home col risultato che l’applicazione che deve usarlo potrebbe non avere i permessi adatti.

3. Attenzione all’output

In generale i programmi opensource, cercano di essere il meno possibile criptici quando segnalano un errore.

E il mio consiglio in caso di errore (che vale sempre, non solo per qemu) è:

1. leggere l’output
2. eventualmente vedere se esiste una modalità “verbose” con descrizione più dettagliata
3. se ancora la cosa rimane incomprensibile, cercare sul web se qualcuno ha già avuto lo stesso problema
4. chiedere direttamente

Se si lavora in questo modo, non solo si giunge più in fretta alla soluzione (se chiedete direttamente senza essere passati dagli altri punti rischiate di avere come risposte delle domande…) ma in più si impara a diventare autosufficienti e si impara effettivamente ad utilizzare i programmi su cui stiamo lavorando.

Addirittura Qemu (anzi è il modulo kqemu a segnalare l’errore) nel caso non abbia sufficiente “shared memory” non solo ci dice cosa è successo, ma ci suggerisce la soluzione!

In questo caso kqemu mi ha avvisato della insufficienza di shared memory e mi ha suggerito i comandi da inserire per ovviare al problema.

Introduzione

Ho trovato questa guida in inglese sul wiki di ubuntu, l’ho provata e funziona tutto al primo colpo.

La trovo molto ben fatta e immediata: mi meraviglia il fatto che nessuno si sia ancora preoccupato di tradurla, perciò ci penso io!

La guida linkata si riferisce specificamente all’installazione di Windows XP, ma nessuno ci impedisce di installare qualsiasi altro sistema opeartivo sulla nostra macchina virtuale, ci sono inoltre alcuni piccoli cambiamenti che ho apportato e testato io.
Mi spiace solo non potervi assicurare la riuscita del tutto poichè non ho la possibilità di provare su diversi PC. Gradirei per l’appunto che mi segnalaste la riuscita o meno dell’”impresa”.

Per prima cosa potete verificare se il vostro hardware supporta la Kernel Virtualization, pertanto da terminale digitate:
grep -E '^flags.*(vmx|svm)' /proc/cpuinfo

Nel caso riceveste qualche risultato in risposta potete prendere in considerazione questa ipotesi (link ), nel mio caso non ho avuto risultati, ma andiamo avanti per la nostra strada.

Installazione di Qemu + kqemu

Qemu (versione 0.8.2) si trova comodamente nei repository di Ubuntu ed è il programma principale. Kqemu invece è un acceleratore per qemu, rende le macchine virtualizzate decisamente più veloci e utilizzabili. L’inghippo sta nel fatto che va compilato e installato, ma per questo ricorriamo all’aiuto di module-assistant.

Armiamoci di Terminale e installiamo il necessario:
sudo apt-get install qemu kqemu-source module-assistant
Compiliamo kqemu:
sudo module-assistant prepare
sudo module-assistant auto-install kqemu
Ora dobbiamo istruire udev per creare il nodo /dev/kqemu al caricamento di kqemu, perciò creiamo il file /etc/udev/rules.d/60-kqemu.rules:
sudo nano /etc/udev/rules.d/60-kqemu.rules
scriviamo questa riga:
KERNEL=="kqemu", NAME="%k", MODE="0660", GROUP="kqemu"
Salviamo e chiudiamo il file.
Ora dobbiamo modificare il file /etc/modprobe.d/kqemu
sudo nano /etc/modprobe.d/kqemu
deve contenere questa riga:
options kqemu major=0
di solito trovate quel valore impostato a 250 e si tratterà solo di cambiare quello.

Ci siamo quasi, ora dobbiamo rendere kqemu utilizzabile dai normali utenti del sistema

sudo addgroup --system kqemu
sudo adduser $USER kqemu

Con questi due comandi abbiamo creato un gruppo chiamato kqemu e inserito l’utente col quale siamo loggati nel gruppo.
Se voleste aggiungere altri utenti al gruppo kqemu basta sostituire a $USER lo username dell’ utente che vogliamo.

Prima di andare avanti è opportuno aggiornare le variabili d’ambiente, il modo più semplice è terminare la sessione e rifare il login.

Se dovessimo ricevere questo messaggio d’errore
Could not open '/dev/kqemu' - QEMU acceleration layer not activated
dobbiamo verificare innanzitutto che il nostro utente appartenga al gruppo kqemu, pertanto da terminale
groups
tra i vari gruppi a cui siamo associati deve esserci kqemu ed eventualmente rivedere i passi precedenti.

Ora possiamo provare a caricare manualmente il modulo del kernel kqemu
sudo modprobe kqemu
Se non riceviamo messaggi d’errore è perchè non ci sono stati problemi quindi possiamo procedere all’avvio vero e proprio di qemu.

Prima di iniziare la parte divertente della guida vi do un ultimo suggerimento.
Se prevedete di usare spesso qemu per “giocare” con varie macchine virtuali, potete caricare il modulo kqemu all’avvio del sistema semplicemente aprendo il file /etc/modules
sudo nano /etc/modules
e aggiungendo la voce
kqemu

Uso di qemu

Bene ora che il nostro PC è pronto ad “ospitarne” un altro possiamo provare a creare una nuova macchina virtuale.
Per questo esempio proverò a installare Windows XP pertanto mi serviranno circa 5 Gb di hard disk (per stare un pelino larghi).
qemu-img create -f qcow winxp.img 5G
Con questo comando abbiamo creato l’hard disk virtuale. L’immagine così creata non sarà utilizzabile “dall’esterno” ma sarà di dimensioni ridotte e ridimensionabile. Se avete necessità di montare l’immagine del SO ospitato senza avviare la macchina virtuale corrispondente potete usare un’immagine di tipo raw vi basterà omettere l’opzione “-f qcow”, ma occuperà tutta la dimensione specificata e non sarà ridimensionabile.

Potrebbero sorgere problemi di accesso in scrittura all’immagine della VM (=Virtual Machine).
Per ovviare a ciò assicuriamoci che tale file abbia i permessi adatti e appartenga ANCHE al gruppo kqemu.
chmod 660 winxp.img
sudo chown $USER:kqemu winxp.img

Inseriamo il CD di installazione di Windows e…

qemu -localtime -cdrom /dev/cdrom -m 384 -boot d winxp.img

E’ possibile utilizzare anche solo l’immagine ISO del CD di installazione, avviando la macchina virtuale con
qemu -localtime -cdrom /percorso/alla/iso/nomefile.iso -m 384 -boot d winxp.img
ovviamente sostituendo “/percorso/alla/iso/nomefile.iso” con il percorso e il nome che fanno al caso nostro.

A volte puo’ succedere che il sistema di installazioen di Windows XP si blocchi. Se vedete che passa troppo tempo senza che l’installazione sembri andare avanti provate a riavviare la VM, l’installazione riprenderà dal punto in cui era arrivata. Nel mio caso comunque ha proceduto come se fosse su un PC reale.