Quindi basta avere un server SSH a cui il cliente possa arrivare con un utente da utilizzare.
Supponendo che il server da raggiungere sia ssh-server.test.com e l’utente test, basta che digiti il comando:

ssh -R 9000:127.0.0.1:22 -p 22 -l test ssh-server.test.com -N

Una volta inserita la password la sua console rimarrà “appesa” e voi, dal vostro server, potrete accedere alla sua macchina con:

ssh utente@127.0.0.1 -p 9000

Chiaramente avrete bisogno di un utente sulla sua macchina.

Et voilà, cliente contento e nessuna crisi di nervi per voi nel tentare di spiegargli dove mettere spazi e slash :)

La cosa perdipiù impedisce anche il corretto funzionamento dello stesso Spotlight. Un esempio: se cerco la parola “App” probabilmente sto cercando App Store. Quel che accade è che viene cercata la definizione di App ma l’applicazione App Store non viene neanche visualizzata.

Mi segno quindi questo utilissimo comando da console per disabilitare le ricerche di Spotlight nel dizionario:

defaults write com.apple.spotlight DictionaryLookupEnabled NO

P.S. Per i più curiosi la definizione di App è:

app |ap|
noun Computing
short for application (sense 5).

Innanzitutto il layout. La mia tastiera è “Internazionale Inglese”, ovvero, oltre alla disposizione USA, ha il tasto `~ a sinistra della z e il tasto §± a sinistra dell’1.
Per ottenere questo layout ho impostato (in Gnome da Sistema > Preferenze > Tastiera) la tastiera USA e creato nella mia home il file .xmodmaprc con questo contenuto:

keycode 94 = grave asciitilde grave asciitilde dead_grave dead_horn
keycode 49 = section plusminus section plusminus section plusminus

Sempre dal menù di configurazione della tastiera , pannello Disposizioni, tasto Opzioni, ho selezionato:

• Comportamento tasto Alt/Win => Control è applicato ai tasti Win
• Opzioni varie di compatibilità => Apple Keyboard alluminio
• Posizione tasto Compose => Alt destro

Quest’ultima cosa è l’unica che veramente mi scoccia dato che su Mac viene usato l’alt sinistro, ma con Linux non sembra essere possibile.

Per terminare ho implementato un piccolo script che modifica la luminosità della tastiera. È composto da 3 file (devono tutti essere eseguibili):

modify_backlight

#!/bin/bash
echo $1 > /sys/devices/platform/applesmc.768/leds/smc\:\:kbd_backlight/brightness

brightness_up

#!/bin/bash
declare -i VAL
declare -i NEW_VAL
declare -i NEW_VAL_PERC
VAL=`cat /sys/devices/platform/applesmc.768/leds/smc\:\:kbd_backlight/brightness`
NEW_VAL=$VAL+50
if [ $VAL -ge 250 ]; then
	NEW_VAL=255
fi
NEW_VAL_PERC=NEW_VAL*100/255
notify-send -u low -t 500 -i /usr/share/icons/gnome-colors-common/scalable/notifications/notification-keyboard-brightness-high.svg "Keyboard brightness" "Increasing keyboard backlight brightness to $NEW_VAL_PERC%"
/usr/bin/sudo /home/tommyblue/bin/modify_backlight $NEW_VAL

brightness_down

#!/bin/bash
declare -i VAL
declare -i NEW_VAL
declare -i NEW_VAL_PERC
VAL=`cat /sys/devices/platform/applesmc.768/leds/smc\:\:kbd_backlight/brightness`
NEW_VAL=$VAL-50
if [ $VAL -le 8 ]; then
	NEW_VAL=0
fi
NEW_VAL_PERC=NEW_VAL*100/255
notify-send -u low -t 500 -i /usr/share/icons/gnome-colors-common/scalable/notifications/notification-keyboard-brightness-low.svg "Keyboard brightness" "Decreasing keyboard backlight brightness to $NEW_VAL_PERC%"
/usr/bin/sudo /home/tommyblue/bin/modify_backlight $NEW_VAL

Quindi per modificare la luminosità con i tasti F5 e F6 basta aprire Sistema > Preferenze > Scorciatoie da tastiera e aggiungere due scorciatoie personalizzate che vadano a richiamare i due script brightness_up e brightness_down. Dato che gli script vanno a modificare dei file di root, bisogna anche inserire in /etc/sudoers la seguente riga:

tommyblue ALL=NOPASSWD:/home/tommyblue/bin/modify_backlight

Ovviamente utente e path devono essere opportunamente modificate.

Il punto è questo: sostituire un disco in un array Raid 1 quando si rompe. Riporto gli appunti presi qualche anno fa sulla wiki del LILiK.

La situazione di un raid 1 con un disco rotto è più o meno questa:

~# cat /proc/mdstat

Personalities : [raid1]
md1 : active raid1 sda2[0] sdb2[1](F)
      1951808 blocks [2/1] [U_]

md2 : active raid1 sda3[0] sdb3[1](F)
      13671232 blocks [2/1] [U_]

md0 : active raid1 sda1[0] sdb1[1](F)
      96256 blocks [2/1] [U_]

unused devices: <none>

Si deve quindi rimuovere il disco dal raid:

mdadm /dev/md0 --fail /dev/hdb1 --remove /dev/hdb1
mdadm /dev/md1 --fail /dev/hdb2 --remove /dev/hdb2
mdadm /dev/md2 --fail /dev/hdb3 --remove /dev/hdb3

La situazione è quindi:

~# cat /proc/mdstat

Personalities : [raid1]
md1 : active raid1 sda2[0]
      1951808 blocks [2/1] [U_]  

md2 : active raid1 sda3[0]
      13671232 blocks [2/1] [U_]  

md0 : active raid1 sda1[0]
      96256 blocks [2/1] [U_]  

unused devices: <none>

Si può quindi spengere la macchina e sostituire il disco.

Al riavvio bisogna creare sul nuovo disco lo stesso schema di partizioni presente su quello esistente. Questa procedura, molto semplice, può diventare rognosa se il nuovo disco è più piccolo (anche di poco) del vecchio. Consiglio quindi, quando si crea un sistema con partizioni in raid 1, di lasciare sempre un po’ di spazio libero alla fine del disco per essere maggiormente sicuri di non moccolare poi in futuro :)

Ricreiamo le partizioni:

sfdisk -d /dev/sda | sfdisk /dev/sdb

e inseriamo le nuove partizioni nel raid:

mdadm /dev/md0 --add /dev/sdb1
mdadm /dev/md1 --add /dev/sdb2
mdadm /dev/md2 --add /dev/sdb3

L’ordine non conta, ma vi consiglio di farlo in ordine crescente di grandezza delle partizioni, cosicchè le partizioni più piccole si riallineino subito.
Adesso basta aspettare:

~# cat /proc/mdstat

Personalities : [raid1]
md1 : active raid1 sdb2[2] sda2[0]
      1951808 blocks [2/1] [U_]
      [=>...................] recovery = 6.2% (123008/1951808) finish=2.4min speed=12300K/sec

md2 : active raid1 sdb3[2] sda3[0]
      13671232 blocks [2/1] [U_]
      resync=DELAYED

md0 : active raid1 sdb1[1] sda1[0]
     96256 blocks [2/2] [UU]

unused devices: <none>

Per finire bisogna reinstallare il grub nell’MBR del nuovo disco. Nei nuovi s.o. dovrebbe bastare:

grub-install /dev/sdb

altrimenti:

grub> root (hd1,0)
grub> setup (hd1)

Con RVM è infatti possibile gestire automagicamente non solo più versioni di Ruby nel sistema, ma anche versioni e ambienti diversi per ogni applicazione!

NB: gran parte di quello che descriverò lo potete trovare qui, lo riprendo per ampliare un po’ il discorso e per avere, come al solito, un memoria ausiliaria a portata di mano.

L’eccezionale strumento che RVM mette a disposizione sono le gemset, ovvero degli ambienti personalizzabili che è non solo possibile usare in ogni momento, ma è anche possibile associarle ad uno specifico progetto utilizzando l’apposito file .rvmrc

Entriamo nel pratico. Una gemset, in questo caso MyProject, si crea con:

rvm gemset create MyProject

e si utilizza con:

rvm use 1.9.2@MyProject

o, in breve:

rvm 1.9.2@MyProject

In questo caso ho creato la gemset avendo prima selezionato ruby 1.9.2 (anch’esso installato con RVM). Si noti che la gemset di default si chiama global e sarà quindi possibile riutilizzarla con:

rvm 1.9.2@global

In questo nuovo ambiente non vi sono gemme installate e si può quindi installarci soltanto quelle necessarie al progetto in questione. La lista di tali gemme potrà poi essere esportata e reimportata:

rvm gemset export MyProject.gems
rvm gemset import MyProject.gems

La procedura è comoda anche per creare un set standard di gemme e importarlo in ogni nuovo progetto creato. Se fosse necessario è possibile eliminare tutte le gemme di un ambiente con:

rvm gemset empty

Esiste anche un comando per creare e usare immediatamente una nuova gemset:

rvm use 1.9.2@MyProject --create

Può essere anche definita la gemset globale e di default. La prima verrà applicata ad ogni nuova versione di ruby installata, la seconda in ogni nuova gemset. I file in questione sono, rispettivamente, ~/.rvm/gemsets/global.gems e ~/.rvm/gemsets/default.gems.

Per finire arriva la vera perla: il file rvmrc.
Ve ne sono tre versioni: quello globale, quello dell’utente e quello del progetto.
Mentre le prime due possono essere utili per la gestione delle opzioni di compilazione di ruby e delle gemme (date un occhio qui per maggiori dettagli), il terzo è sicuramente il più interessante e consiste in un file .rvmrc contenente, ad esempio:

rvm 1.8.6@project

Ogni volta che si entrerà nella cartella contenente il file (con cd da terminale) verrà impostata la gemset selezionata nel file! Vien da sè che si può inserire in un eventuale SCM associato al progetto i file .rvmrc e MyProject.gems per avere la certezza che tutti i collaboratori abbiano lo stesso ambiente di sviluppo.

Esiste anche uno shortcut che crea il file .rvmrc al momento della creazione della gemset:

rvm --create --rvmrc 1.8.6@project

Un’ultima “chicca” è l’autocompletamento del comando RVM, che è attivabile inserendo nel file dell’ambiente di bash (ad esempio .bashrc o .bash_profile):

[[ -r $rvm_path/scripts/completion ]] && . $rvm_path/scripts/completion

ovviamente adeguando $rvm_path alle vostre esigienze. Una spiegazione più accurata la trovate qui: http://rvm.beginrescueend.com/workflow/completion/

La soluzione esiste ed è interessante che comporti l’uso di un terzo software di emulazione: QEMU :-)

L’utility che ci serve è qemu-img che nell’installazione Mac si trova in /Applications/Q.app/Contents/MacOS/qemu-img

La conversione è molto semplice e non richiede troppo tempo:

cd /Applications/Q.app/Contents/MacOS/
./qemu-img convert /path2virtualbox/img2convert.vdi  /path2vmware/converted_img.vmdk

:g/^\s*#.*/d

mi resta da capire perché questa seconda regexp non funziona:

:g/^[# ]+.*/d

Gestire tutto ciò è un gran casino e anche pensare ad un salvataggio di backup non è cosa facile dato che spesso ci si tira dietro indirizzi email che non vogliamo avere (ad esempio, aver scritto una mail ad un professore utilizzando GMail implica che lo abbiamo salvato tra i nostri contatti).

Se, come nel mio caso, si hanno un iPhone, un Mac e un account su Google Apps o GMail, allora è possibile (e consigliabile) unire e tenere sincronizzati tutti i contatti. Erano anni che mi riproponevo di mettere a posto il tutto e con questa procedura finalmente ci sono riuscito, c’ho messo solo 4 giorni…. :s

Alcune osservazioni prima di cominciare

• Delle tre rubriche solo una deve essere mantenuta. Quindi il primo passo (direi il più lungo e noioso) è quello di copiare tutti i dati in una sola rubrica. Io consiglio di utilizzare l’Address Book di Mac OSX data la velocità e la comodità.
• Per rendervi la vita più facile, prima di cominciare la revisione, potete sincronizzare il Mac con l’iPhone (usando iTunes) e inserire in Address Book i contatti esportati da GMail, in questo modo potete selezionare più schede appartenenti alla stessa persona per poi unirle con CMD+Shift+|. Attenzione però: prima di unire le schede controllate che i numeri di telefono e le email abbiano una categoria (“casa”, “cellulare”, “lavoro”) e non “altro”. Infatti durante l’unione più numeri della stessa categoria sono permessi, mentre di quelli segnati come “altro” ne rimane solo uno, gli altri vengono eliminati.
• Esiste un’utility carina che permette di impostare le foto dei contatti direttamente dalle foto del profilo di Facebook (se risultano tra i vostri amici). L’utility è AddressBookSync.
• Per quanto riguarda GMail la sincronizzazione riguarda soltanto i “Contatti personali” e non le altre rubriche.
• Quando andrete a sincronizzare i contatti ricordatevi questa massima: “Delle tre, la più recente vince” (cit. A.C.). Ciò significa che i contatti potranno essere sincronizzati su ognuna delle tre applicazioni (Mac, iPhone, GMail), ma sarà l’ultima modifica fatta ad essere quella definitiva. Vi sembrerà ovvio ma vi faccio un esempio: se vi accorgete di aver fatto casino con la rubrica di GMail e decidete di eliminarla completamente per poi risincronizzarla con quella del Mac, alla prossima sincronizzazione non sarà la rubrica del Mac ad essere esportata su GMail, bensì GMail “dirà” a Mac di eliminare tutti i contatti (dato che l’eliminazione è stata cronologicamente l’ultima operazione). C’è un modo di ovviare a questo, che spiego più avanti.

Sincronizzazione tra Mac e iPhone

Questa è la parte più facile: Mac e iPhone non devono sincronizzare i contatti. Quindi attaccate l’iPhone al Mac, aprite iTunes (se non si apre da solo) e da Dispositivi > iPhone > Info togliete la spunta a Sincronizza contatti di Rubrica Indirizzi

Sincronizzazione tra Mac e Google

Bene, supponiamo che adesso la vostra rubrica su Address Book sia sistemata, la prima cosa da fare è entrare in GMail ed eliminare tutti i contatti personali. Se avete fatto bene il lavoro di unione su Address book non perderete nulla, ma se vi sentite più sicuri effettuate prima un’esportazione di backup da Google. Adesso la rubrica di GMail è vuota e quella del Mac piena, ma ci troviamo nella situazione precedentemente descritta in cui le ultime modifiche modifiche riguardano l’eliminazione. Quindi è fondamentale effettuare il backup della rubrica del Mac. Per farlo aprite Address book e selezionate dal menù: Archivio > Esporta > Archivio rubrica indirizzi. Salvate in un luogo sicuro e andate avanti.

Sempre dal menù di Address book selezionate Preferenze > Account > Informazioni account e mettete la spunta a Sincronizza con Google, inserendo i dati di accesso dopo aver premuto su Configura (nel caso in cui si tratti di Google Apps e non GMail inserite come username l’indirizzo email completo). Una volta terminato vedrete apparire sulla barra del Finder le due freccette circolari della sincronizzazione.

Icona di sincronizzazione nella barra dei menù

Cliccateci e selezionate Sincronizza adesso.Dato che il cambiamento riguarda più del 25% della vostra rubrica vi apparirà un messaggio che chiede la conferma per eliminare i contatti che erano presenti in GMail. Fatelo (tanto avete il backup appena salvato), dopodichè in Address book selezionate tutti i contatti ed eliminateli. Una volta terminato ripristinate il backup da Archivio > Importa e rilanciate la sincronizzazione con GMail. Questa volta il messaggio vi dirà che l’operazione sta per aggiungere i vostri contatti su Google.

Quando le frecce smetteranno di girare andate nella rubrica di GMail e controllate l’effettiva sincronizzazione.

Sincronizzazione tra iPhone e Google

Per la sincronizzazione si utilizza un account configurato per il Push (opzione Microsoft Exchange per l’utilizzo del push con GMail).

Se utilizzate un account Google Apps dovete innanzitutto attivare l’opzione dal pannello di controllo del dominio andando in Impostazioni servizio > Cellulare e mettendo la spunta su Attiva Google Sync.

A questo punto nelle impostazioni dell’iPhone, dal menù E-mail, contatti, calendari > Aggiungi account > Microsoft exchange create il vostro account Google seguendo questa guida. L’importante è che selezioniate l’opzione per sincronizzare i contatti e, quando vi viene chiesto, confermiate la cancellazione dei contatti presenti nell’iPhone (che tanto avete già salvato nel Mac).

Conferma prima di eliminare i contatti dall'iPhone

Una volta terminato attendete qualche minuto affinchè la sincronizzazione sia completa (se siete in WiFi ci metterà meno che non in 3G) e poi verificate andando nella rubrica dell’iPhone.

Se volete che i cambiamenti fatti su GMail o sul Mac siano immediatamente visibili sull’iPhone assicuratevi che i dati vengano scaricati in Push andando in Preferenze > E-mail, contatti, calendari > Scarica nuovi dati e attivando l’opzione Push, quindi in Avanzate e verificando che l’account abbia nuovamente l’opzione Push attiva.
Occhio che il Push consuma un sacco di batteria, io non lo uso ma faccio scaricare via rete ogni 30 minuti: la batteria dura molto di più e non si viene stressati ogni 2 minuti per ogni email che arriva :-)

Test e conclusioni

Per terminare fate un po’ di test cambiando, eliminando e aggiungendo dati da ognuna delle tre posizioni e verificando la corretta modifica nelle altre due. Ricordatevi sempre di fare i backup da Address Book sul Mac. Se riscontrate problemi inserite dei commenti e cercherò di aiutarvi. Anche se avete suggerimenti o miglioramenti vi prego di inserire un commento all’articolo. In particolare credo (e spero) che ci sia un modo migliore per effettuare la prima sincronizzazione senza dover per forza eliminare tutti i contatti e poi reimportarli dal backup, ma io non l’ho trovato :-)

Con l’uscita imminente della versione stabile ho riprovato ad installare Fedora 12 sul MacBook Pro e stavolta è andata. Per chi non lo sapesse fino a poco tempo fa era impossibile avviare una qualsiasi distribuzione desktop (ok, ok, ammetto di non averle provate proprio tutte…), nel senso che al momento dell’avvio di X il pc si freezava (ma proprio di brutto!).

Comunque, adesso che sono riuscito ad installare Fedora ho cercato di sostituire i driver Nouveau con quelli ufficiali Nvidia. Ẽ vero che non sono liberi, ma ancora con la mia scheda (GEFORCE 9400M) i Nouveau non supportano il 3D, quindi mi sento meno in colpa ad usare i driver proprietari :)

Sostituire i driver non dovrebbe essere una cosa troppo complicata, sempre che i suddetti Nouveau non decidano di mettervi i bastoni tra le ruote.

I “semplici” passi sono:

1. Disinstallare il pacchetto xorg-x11-drv-nouveau
2. Installare i driver Nvidia
3. Mettere in blacklist i driver Nouveau

Nello specifico, per rimuovere il driver:

yum remove xorg-x11-drv-nouveau

che si porterà dietro un metapacchetto per dipendenza. L’installazione del driver Nvidia può essere effettuata in 3 modi:

• Installare il driver scaricato dal sito Nvidia
• Installare il driver precompilato kmod-nvidia(.i586|.i686)
• Installare il driver da compilarsi akmod-nvidia(.i586|.i686)

Per le ultime due opzioni è necessario abilitare i repository RPMFusion. Se si decide, come me, di installare la versione da compilarsi (akmod-nvidia(.i586|.i686)) dopo l’installazione del pacchetto bisogna lanciare (come root) il comando akmods che provvederà a compilare il driver.

Per terminare si aggiunge la riga:

blacklist nouveau

nel file /etc/modprobe.d/blacklist-nouveau.conf. (se installate akmod-nvidia(.i586|.i686) sarà già stato creato) e si riavvia (se volete lo splashscreen dovete aggiungere vga=791 alle opzioni del kernel).

Nel mio caso quest’ultimo passaggio non è andato bene, i moduli nouveau continuavano ad essere caricati e non partiva X. Alla fine ho scoperto nel file /etc/modprobe.d/blacklist-nouveau.conf, creato da akmod, questo interessante commento:

# RPM Fusion blacklist for nouveau driver - you need to run as root:
# dracut -f /boot/initramfs-$(uname -r).img $(uname -r)
# if nouveau is loaded despite this file.

quindi basta lanciare il comando:

dracut -f /boot/initramfs-$(uname -r).img $(uname -r)

e al nuovo riavvio finalmente i tenaci nouveau saranno spariti e all’avvio di X un logo full-screen annuncerà la presenza dei driver Nvidia!

Adesso scopro però che dal 16 novembre 2009 Thawte non supporterà più la certificazione delle email. Damn!

Nel cercare quindi una valida alternativa (ci sarebbe anche CAcert ma non mi convince troppo, probabilmente per i soliti motivi) torno con la coda tra le gambe da mamma GNU col suo GPG.
Stavolta però faccio le cose sul serio e, complici Enigmail per Thunderbird 3beta che non funziona un gran che e l’influenza che mi lascia un po’ di tempo per cazzeggiare, ho aperto il manuale di GPG e genererò le mie chiavi manualmente, prendendo appunti in questo articolo.

Let’s go…

Di guide ce ne sono un sacco, io ho usato questa anche se è basata su GPG versione 0.9.4 e io invece uso la 2.0.12

Il primo passo è quello di creare una nuova coppia di chiave (pubblica/privata) con gpg –gen-key:

~$ gpg --gen-key
gpg (GnuPG/MacGPG2) 2.0.12; Copyright (C) 2009 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.
[...]

Nel generare le chiavi ho utilizzato l’algoritmo RSA (non presente nella versione 0.9.4) di 4096 bit e ho impostato 1 anno come durata. Subito dopo aver generato le chiavi è bene anche generare un certificato di revoca. Questo è importante, infatti se si perdesse la chiave privata (o venisse compromessa) il certificato di revoca è l’unica cosa che ci permette di far sapere agli altri che non devono usare la chiave pubblica associata alla chiave compromessa.

Al termine della generazione della coppia di chiavi ci è stato restituito un messaggio del genere:

sub   4096R/6C04473B 2009-10-15 [expires: 2010-10-15]

il numero 6C04473B è l’ID della nostra chiave, che useremo per generare il certificato di revoca. Lo stesso ID lo si può trovare guardando le chiavi installate nel sistema con gpg –list-keys.
Creiamo quindi la revoca:

gpg --output revoke.asc --gen-revoke 6C04473B

Il file revoke.asc contiene il certificato di revoca e va tenuto con molta attenzione, pena la non possibilità di annullare una chiave e confessare con imbarazzo a chi continua a scrivervi email cifrate con la vecchia chiave che non potete leggerle, ovvero che siete un coglione! parlo per esperienza…. :(

Bisogna adesso esportare la chiave pubblica. Si può farlo in due formati: binario e ASCII. Nell’ordine:

gpg --output pub.gpg --export indirizzo_email
gpg --armor --export indirizzo_email > pub_ascii.gpg

La chiave pubblica in formato ASCII può essere più facilmente pubblicata sul web o inviata per email.