Python e le classi astratte

Avevo bisogno di una classe virtuale pura che fornisse ai sottotipi un’implementazione standard di alcuni metodi ma che, al contempo, li obbligasse a fornire delle nuove implementazioni degli stessi. Con questa soluzione sono riuscito a raggiungere il risultato voluto, inoltre i metodi sovraccarichi richiamano la versione fornita dalla classe base virtuale.


class Virtual:

    __metaclass__ = ABCMeta

    @abstractmethod
    def _update(self, *args, **kwargs):

        print "metodo virtuale"

    def _method_template(self, _method, *args, **kwargs):

        getattr(self, _method)(*args, **kwargs)
        getattr(Virtual, _method)(self, *args, **kwargs)

    def __getattr__(self, name):

        _method = "_%s" % name
        if _method in Virtual.__abstractmethods__:
            impl_method = lambda *y, **z: Virtual._method_template (self, _method, *y, **z)
            setattr(self, name, impl_method)
            return impl_method
        else:
            raise AttributeError("'%(class)s' object has no attribute '%(attr)s'" % {'class' : self.__class__.__name__,
                                                                                     'attr' : name})


class Class(Virtual):
    def _update(self):
        print "metodo \"reale\""

if __name__ == "__main__":
    c = Class()
    print c
    c.update()

A proposito di GPGKeyOnUsbDrive

Già da tempo utilizzavo il metodo descritto nella guida GPGKeyOnUsbDrive (qui la guida originale in lingua inglese) e pubblico qui di seguito le versioni migliorate (o, meglio, adattate alle mie esigenze) dei due script mount.sh e umount.sh proposti.

Il primo crea automaticamente i link alle proprie cartelle .gnupg e .ssh, dopo averne creato delle copie di backup, e l’altro ripristina lo stato originale. A voi il codice!

mount.sh

#!/bin/bash

dir=`dirname $0`
loopdev=$(sudo losetup -f)
sudo -p "Password (sudo): " modprobe cryptoloop && \
sudo modprobe dm-crypt && \
sudo modprobe aes_generic && \
sudo mkdir -p /media/encrypted && \
sudo losetup $loopdev $dir/disk.img && \
sudo cryptsetup -c aes -s 256 -h sha256 create usbkey $loopdev && \
sudo mount -t ext3 /dev/mapper/usbkey /media/encrypted && \
sudo chown -R $UID.$UID /media/encrypted/

ask_yesno () {
  REPLY=
  while [ "$REPLY" != "y" ] && [ "$REPLY" != "n" ] ; do
    echo -n "$1 "
    read -N 1
    echo
  done
  if [ "$REPLY" = "y" ]; then
    return 0
  fi
  return 1
}

backup_olddir () {
  directory="$1"
  mv "$HOME"/."$directory" "$HOME"/."$directory".BACKUP
}

create_link () {
  directory="$1"
  ln -s /media/encrypted/."$directory" "$HOME"/."$directory"
}

link_directory () {
  directory="$1"
  if [ -d "$HOME"/."$directory" ]; then
    echo "Moving ~/.$directory to ~/.$directory.BACKUP... "
    if [ -d "$HOME"/."$directory.BACKUP" ]; then
      if ask_yesno "The directory $HOME/.$directory.BACKUP already exists, overwrite? [y/n]"
      then
        rm -rf "$HOME"/."$directory".BACKUP
        backup_olddir "$directory"
        create_link "$directory"
      else
        return 1
      fi
    else
      backup_olddir "$directory"
      create_link "$directory"
    fi
  else
    create_link "$directory"
  fi
}

for dir in gnupg ssh
do
  ask_yesno "Do you want to link your private $dir keys? [y/n]" && link_directory $dir
done

umount.sh

#!/bin/bash

loopdev=$(sudo cryptsetup status usbkey | grep device | sed -e "s/ *device:[ \t]*//")

sync
sudo umount /media/encrypted
sudo cryptsetup remove usbkey
sudo losetup -d $loopdev

restore_olddir () {
  directory="$1"
  mv "$HOME"/."$directory".BACKUP "$HOME"/."$directory"
}

for directory in gnupg ssh
do
  if [ -L "$HOME"/."$directory" ] && \
     [ "`readlink ${HOME}/.${directory}`" = "/media/encrypted/.${directory}" ]
  then
    echo "Restoring ~/.${directory}"
    rm "$HOME"/."$directory"
    restore_olddir "$directory"
  fi
done

 

AGGIORNAMENTO (30/01/2012): Corretto un errore nello script mount.sh.

Procedura di rooting per Toshiba Folio 100

Aggiornamenti:

  • 2011-05-12: Ho aggiornato la guida con le istruzioni necessarie al rooting permanente. Inoltre, ho messo a disposizione un archivio compresso contenente tutto il necessario.

Dopo aver effettuato l’aggiornamento all’ultima versione del software Toshiba vi sarà capitato di notare che il buon vecchio SuperOneClick non é più una soluzione valida per ottenere i privilegi di root.

Sul forum di xda-developers é prontamente comparso un thread che guida l’utente al ripristino di un’immagine precedente all’aggiornamento upstream al fine di aggirare il problema. Ma io, da buon malfidato, ho preferito lasciar andare e cercare una soluzione per conto mio.

Beh, eccola qui, semplice e efficace.

Si comincia installando l’Android SDK e configurando correttamente ADB per il corretto riconoscimento del Toshiba Folio 100 (una buona procedura testata su Ubuntu si trova qui). Poi si passa a scaricare e scompattare questo file.

Dopo aver smontato ogni SD dal Folio, collegato il device e abilitato la modalità di debug, bisogna spostarsi nella cartella contenente l’SDK, copiare psneuter o rageagainstthecage e tutte le utility necessarie dell’archivio compresso nella memoria interna, dunque entrare nella ADB shell. In breve:

cd ~/android-sdk-linux_86/platform-tools
./adb push rageagainstthecage /data/local/tmp
./adb push busybox /data/local/tmp/
./adb push su /data/local/tmp/
./adb push Superuser.apk /data/local/tmp/
./adb shell

Ora siamo nel device, lasciamo compiere all’exploit il suo dovere:

$ cd /data/local/tmp
$ chmod 4755 rageagainstthecage
$ ./rageagainstthecage

Riavviamo adb, montiamo il filesystem in modalità di scrittura e entriamo nuovamente nella shell:

./adb kill-server
./adb start-server
./adb remount
./adb shell

Infine, non resta che installare a manina tutti i tool che ci permetteranno di ottenere nuovamente i privilegi di root dopo il riavvio del device (la presenza del carattere cancelletto ‘#’ indica i nuovi privilegi ottenuti):

# cd /data/local/tmp
# ./busybox cp busybox /system/bin
# chmod 4755 /system/bin/busybox
# busybox cp Superuser.apk /system/app
# busybox cp su /system/bin
# chmod 4755 /system/bin/su

Se tutto é andato a buon fine, root é abilitato e funzionante.
Altrimenti, ripetere la procedura con psneuter.

Riferimenti

Backup e ripristino del Master Boot Record

Mi capita sovente di avere a che fare con persone desiderose di stabilire il primo contatto con un sistema operativo GNU/Linux, a condizione di non sentirsi obbligati a migrare definitivamente, abbandonando una volta per tutte Windows.

Non me ne voglia il buon Agostino Russo ma nove volte su dieci la soluzione che consiglio é il dual boot, configurabile automaticamente al momento dell’installazione e semplicissima da gestire in seguito.

Su una macchina con Windows già installato la questione si sbriga velocemente: terminata l’installazione, al riavvio l’utente può già scegliere quale sistema avviare. Al contrario, quando si procede a installare Windows su un sistema ove si è già precedentemente installato Ubuntu, la procedura non é automatica e diventa necessario reinstallare GRUB.

Ci sono delle procedure note per ovviare a tale problema (qui trovate le più comuni) ma se siete pigri anche solo la metà di quanto lo sono io, allora anche voi probabilmente preferirete procedere nel modo che più mi soddisfa, ovvero creando una copia di backup l’MBR prima di installare il nuovo sistema e effettuando in seguito il ripristino.

Prima di avviare l’installazione, bisogna accedere al sistema già installato e digitare ciò che segue (sostituendo opportunamente /dev/sda):

sudo dd if=/dev/sda of=MBR.bak bs=512 count=1

Il file MBR.bak ora contiene il primo settore del disco e per ripristinarlo, una volta installato l’altro sistema, sarà sufficiente accedere con una live, posizionarsi nella directory dove si è salvato il backup e digitare il seguente comando:

sudo dd if=MBR.bak of=/dev/sda bs=512 count=1

Se non avete un CD live a portata di mano e vi trovate costretti a poter utilizzare solo Windows, vi segnalo la disponibilità di una versione di dd anche per il sistema Microsoft.

Avviso ai naviganti: modem ONDA MT503HSA

L’ho ritrovato (si era perso nel trasloco) ma al momento non ho

  • la reale necessità,
  • il tempo,
  • credito sulla SIM

per smanettare con modem in questione, quindi vi prego di asternervi dal contattarmi attraverso l’apposito form e darmi qualche giorno (settimana?) di tempo per mettere al posto giusto tutti i frammenti della mia vita 🙂

Detto ciò, passiamo alle altre news:

  • è stato inaugurato il ciclo di sviluppo di Ubuntu 10.04 «Lucid Lynx»,
  • ho ricevuto (e accettato) un invito per Google Wave da parte di Aldo Latino (al quale vanno i miei sentiti ringraziamenti),
  • a Ubuntu 9.10 «Karmic Koala» sta piuttosto antipatico il mio MSI Wind U90 (date uno sguardo alle Note di rilascio),
  • ho contratto l’influenza per la seconda volta in 10 giorni.

Jaunty e Alice, insieme sulla cresta dell’Onda

Con questa guida desidero aiutare tutti quei poveri creduloni che, proprio come me, hanno abboccato all’offerta Internet della TIM, comprensiva di hardware 3G (si tratta della ONDA MT503HSA), felici di comprare per la prima volta un dispositivo hardware per il quale venisse fornito il supporto anche per sistemi Linux.

In effetti il supporto c’è, non si può negare, ma per quanto riguarda Ubuntu sussiste un problema: l’installer fornito con il pacchetto non funziona su Ubuntu 9.04 «Jaunty Jackalope».

L’hardware in questione supporta tutte le tecnologie di rete disponibili (GPRS, EDGE, UMTS e HSDPA), nel bundle vengono forniti anche i seguenti elementi:

  • 1 Cavo USB
  • 1 CD (contenente manuali e driver)
  • 1 USIM predisposta per la connessione

Nel caso in cui utilizziate un netbook e non vi sia possibile recuperare un lettore CD esterno, non vi preoccupate: copia dei driver è presente anche nella ROM interna della penna, basta collegarla al computer e il sistema procederà immediatamente al montaggio della stessa (per la cronaca: vedrete diventare disponibile un drive CD virtuale, contenente i driver per tutti i sistemi per cui il produttore fornisce il supporto).

Prima di inserire la penna nella porta USB però vi consiglio di scaricare l’utility usb_modeswitch; dopo aver scompattato il tarball, aprite un terminale all’interno della directory contenente il binario usb_modeswitch e digitate il seguente comando:

sudo install ./usb_modeswitch /usr/local/bin

Ora procediamo con l’installazione del driver fornito dal produttore:

  1. Per installare tutte le dipendenze è sufficiente digitare il seguente comando:
  2. sudo apt-get install build-essential linux-headers-`uname -r` libqt3-mt

  3. Aprite un terminale nella cartella contenente il file install.sh e digitate:
  4. sudo ./install.sh

  5. Terminata la procedura di installazione, proseguire con i seguenti comandi:
  6. sudo -s
    cd /opt/Alice_MOBILE/driver810
    make clean && make
    cp onda.ko /lib/modules/$(uname –r)/kernel/drivers/usb/serial
    depmod -a
    nano /etc/usb_modeswitch.conf

    Incollate all’interno della finestra dell’editor le seguenti righe:

    DefaultVendor= 0x19d2
    DefaultProduct= 0x0053
    TargetVendor= 0x19d2
    TargetProduct= 0x0037
    MessageContent="55534243123456782000000080000c85010101180101010101000000000000"

  7. Una volta salvato il file e chiuso l’editor, digitare:
  8. exit

Bene, il grosso è fatto, ora potete collegare la penna al computer, attendere il montaggio del CD virtuale, quindi digitare:

sudo usb_modeswitch

Il drive CD virtuale verrà smontato, non vi resta che aprire l’applicazione Alice_MOBILE per potervi collegare.

Collegamenti utili:

AspireOne, passare dall’Acer desktop alla vista standard di Xfce

Ci voleva!

Con questo semplice tool ora è possibile effettuare lo switch dalla vista di default di Linpus a quella standard di Xfce con un semplice clic del mouse.

Prima di tutto, scaricate il file:

Download desktop-switch-0.3-1.i386.rpm.gz

Quindi aprite una finestra di terminale e digitate:


cd ~/Downloads
gunzip desktop-switch-0.3-1.i386.rpm.gz
sudo rpm -i desktop-switch-0.3-1.i386.rpm

Dovrebbe comparire una nuova applet nel pannello in basso, proprio accanto all’icona Home, facendo clic su di essa assisterete a una rivoluzione del desktop: niente più barra di ricerca nè macro sezioni, il look sarà quello della vista classica di Xfce.

Nel caso riscontriate qualche problema particolare, potete postare i vostri interrogativi e le richieste nel thread aperto dall’autore del pacchetto in questione.

Netbook Remix su penna USB, come remixare l’Acer Aspire One con Ubuntu 8.10 «Intrepid Ibex»

Gli ingredienti:

  • una penna USB con una capienza minima di 1 GiB (come spesso accade, le dimensioni sono direttamente proporzionali al piacere che si desidera provare);
  • un live CD di Ubuntu 8.10 «Intrepid Ibex» e/o un computer con un sistema desktop già pronto e installato; nel caso si possieda solo il secondo, scaricare l’immagine del CD da qui;
  • una connessione cablata;
  • un pizzico di pazienza.

Preparazione dell’unità USB

Se avete un sistema con Ubuntu già installato, avviatelo; in alternativa, procedete al boot con il CD inserito nel lettore.

Subito dopo l’avvio di GNOME, inserite la periferica in una porta USB libera e seguite la procedura.

Avviare usb-creator:

Specificare il percorso dell’immagine .ISO scaricata in precedenza e le dimensioni dello spazio riservato al filesystem in lettura/scrittura:

Fare clic su «Make startup disk» e attendere che l’applicazione svolga tutte le operazioni:

Continua a leggere

MVC e Python + GTK, seconda parte

Ri-eccomi sull’argomento, prima di cominciare voglio ringraziare l’autore del framework in questione, Roberto Cavada, per aver commentato l’articolo precedente.

Nella prima puntata di questo tutorial avevo promesso di mostrarvi una piccola applicazione di esempio, Todoman, utile per comprendere in modo più approfondito il funzionamento di Pygtkmvc.

L’applicazione gestisce delle liste ToDo e consente all’utente di inserire, modificare e eliminare i task a proprio piacimento.

Continua a leggere

Python e MVC, una storia tutta da scrivere (Prima parte)

Qualche giorno fa, girovagando per l’Universo, ho scoperto un pacchetto fantastico di cui ignoravo completamente l’esistenza: si tratta di python-gtkmvc, contenente un’interessantissima implementazione di MVC per lo sviluppo in Python di applicazioni GTK+.

Prima di illustrarvi le innumerevoli possibilità offerte dai moduli contenuti nel pacchetto in questione, mi sento in dovere di fornirvi perlomeno un’introduzione a MVC: l’acronimo sta per Model-View-Controller (capita sovente di incontrarlo orribilmente tradotto nella lingua di Dante come Modello-Vista-Controllore) e indica uno dei design pattern maggiormente noti e diffusi nello sviluppo di interfacce grafiche, soprattutto negli ambiti della programmazione web (per la quale è nato), basato sul principio di divisione delle responsabilità fra i componenti che interpretano i tre ruoli fondamentali di un sistema software:

Continua a leggere