Problemi di rete :(

Si lo so che è da un bel po che non posto ma purtroppo ho problemi con l'Adsl. Sto cambiando gestore e sto aspettando la nuova rete. Intanto mi connetto solo saltuariamente quando posso. Vi aggiornerò presto con le novità su planimo e i soliti suggerimenti su python e tutto il resto non appena possibile.

Tip: mitico vim!

Ogni tanto durante l'uso quotidiano di vim scopro qualcosa di nuovo e molto utile (specie per noi programmatori ;) )

Se siete programmatori anche occasionali ed utilizzate vim per editare i vostri programmi vi sarà sicuramente capitato di imbattervi in errori di compilazione (se no vi adorerò come un dio :) ).

Bene questi errori di solito vengono stampati sul terminale accompagnati da un numero di linea che rappresenta il punto dove si è verificato l'errore.

Vim mette a disposzione un paio di metodi molto comodi per spostarsi automaticamente ad una certa riga:

Primo metodo

vim +50 nomefile.py


Questo metodo lancia l'editor vim con come buffer il file nomefile.py e fa si che il cursore si sposti essattemente alla riga 50.

Secondo metodo

Se invece avete già una istanza di vim attiva e state editando il file interessato basta digitare in modalità comandi:

:50

Questo comando posizionerà il cursore alla cinquantesima riga.

In questo modo diventerà più veloce risolvere i problemi!

Una classe per le notifiche con python e dbus

Ogni tanto trovo un minuto per migliorare il mio progetto planimo ed imparo qualcosa di nuovo su python e le varie estensioni. In un prossimo post vi annuncerò le grandi novità del progetto ma per ora vi voglio presentare un metodo semplice per far apparire le notifiche sul nostro desktop (solo unixes, no Windows). La notifica sarà simile a questa:


La notifica apparirà in basso a destra sul desktop per un periodo di tempo impostabile.
Dbus è un sistema per la comunicazione tra processi. In pratica si sfrutterà dbus per comunicare con il demone delle notifiche.

Il codice python

import dbus

ICON = "file:///home/redgun/python/planimo/data/icons/planimo48.png"

class Notifier:
   def __init__(self):
           self.session_bus = dbus.SessionBus()
           obj = self.session_bus.get_object("org.freedesktop.Notifications",
                                           "/org/freedesktop/Notifications")
           self.notif = dbus.Interface(obj, "org.freedesktop.Notifications")

   def notify(self, title, message, iconfile = ICON, time = 3000):
           try:
                   self.notif.Notify("Notification",
                           dbus.UInt32(0), iconfile, title, message,
                           [], [], dbus.Int32(time), dbus.UInt32(0))
           except:
                   try:
                           self.notif.Notify("Notification",
                                   dbus.UInt32(0), iconfile, title, message,
                                   [], [], dbus.Int32(time))
                   except Exception, detail:
                           print detail

if __name__ == "__main__":
   n = Notifier()
   n.notify("Titolo", "messaggio stile bold", time=5000)

Per far funzionare questo codice è necessario che il pacchetto python-dbus sia installato sul vostro sistema (Ubuntu lo installa per default). Il metodo notify prova ad invocare il metodo self.notif.Notify in due modi diversi a causa di una modifica delle api della libnotify (vedi qui per maggiori info). Il primo metodo infatti funziona su Ubuntu Edgy, il secondo sulla Feisty. Il parametro time server per impostare la durata in millisecondi della notifica.

Comunicazioni sicure: Il tunnell ssh e l'X Forwarding

Molte applicazioni che utilizzano il protocollo TCP per le connessioni, possono essere canalizzate in un tunnel sicuro grazie all'ausilio di OpenSSH.
Ciò significa che tutto il traffico di rete generato da queste applicazioni verrà crittografato e quindi reso sicuro dagli strumenti di OpenSSH. Affinché ciò sia possibile è necessario che sull'host remoto sia in esecuzione il servizio ssh. Su ubuntu basta installare il pacchetto openss-server.

Esempi di connessioni che possono essere canalizzate sono http, smtp, pop3 ed in particolare le connessioni agli X servers.


Esempi

Connessione sicura ad un server di database postgresql

Per default il servizio postgre è in ascolto sulla porta 5432. Supponiamo che il servizio risieda sull'host pippo e che l'utente tizio abbia un account sulla macchina pippo.
Allora è possibile creare un tunnel sicuro in questo modo:

$ ssh -L 5500:pippo:5432 tizio@pippo
$ psql -h localhost -p 5500 utente_postgres

Il primo comando crea il tunnell ssh associando la porta remota 5432 alla porta locale (scelta da noi a piacimento) 5500 utilizzando l'account tizio per effettuare il login sulla macchina pippo. A questo punto si usa il secondo comando per connettersi alla estremità locale del tunnell. psql è il client testuale fornito con l'installazione di postgreSQL.

Connessione remota e X Forwarding

Un altro uso molto utile del tunnell ssh è l'X Forwarding.
L'X Forwarding è un meccanismo che permette di visualizzare una applicazione grafica eseguita su un server remoto, in locale. Per abilitarlo è necessario utilizzare l'opzione -X per ssh. Ad esempio:

$ ssh -X tizio@pippo
$ firefox

Il primo comando ci permette di loggarci sull'host pippo tramite l'account tizio abilitando l'X Forwarding. Il secondo comando lancia il browser firefox che sarà eseguito sull'host pippo ma apparirà sul nostro display come se lo avessimo eseguito in locale.
Attenzione che l'opzione ForwardX11 non sia impostata a no nel file di configurazione del demone ssh sul server remoto (/etc/ssh/ssh_config) altrimenti l'X Forwarding non funzionerà!

Condividere la connesione ad internet con linux

In molti mi chiedono come si fa a condividere la connessione internet del proprio pc linux con altri computer sulla rete locale. L'operazione non è complessa. Si possono scegliere più strade diverse:

1) Installare firestarter un tool per la gestione del firewell che ha tra le sue impostazioni una opzione per condividere la connessione ad internet

2) Procedere manulamente con i tools messi a disposizione dalla distribuzione.

Io sconsiglio la prima soluzione perché si impara poco ed inoltre installare un intero programma solo per condividere la connessione ad internet non è molto conveniente.

Procediamo quindi per la seconda via. Supponiamo che il nostro pc che è connesso ad
internet abbia due interfacce di rete (o comunque una interfaccia ethernet ed una interfaccia PPP che rappresenta la connessione ad internet): la prima eth0 connessa ad internet e la seconda eth1 connessa alla rete locale. Consideriamo sulla eth1 un indirizzo ip 192.168.100.1. (Per impostare questo indirizzo basta usare il comando

$ sudo ifconfig eth1 192.168.100.1 up

)

Per condividere la connessione ad internet è necessario abilitare il forwarding ed il masquerading sull'interfaccia di rete in questo modo:


$ sudo iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
$ sudo sh -c "echo 1 > /proc/sys/net/ipv4/ip_forward"

Naturalmente eth0 va sostituito con il nome dell'interfaccia connessa ad internet.
Ora non resta che aggiungere alla tabella di routing dei clients (gli altri pc della rete che devono accedere ad internet tramite la connessione del computer che abbiamo appena configurato) come default gateway il pc connesso a interntet. Per farlo bisogna usare
i seguenti comandi:

$ sudo ifconfig eth0 192.168.100.x
$ sudo route add default gw 192.168.100.1

Il primo comando assegna un indirizzo ip alla scheda di rete (sostituite la x con un numero diverso su ogni client). Il secondo aggiunge alla tabella di routing l'indirizzo del server come gateway.
Naturalemte i valori potete sostituirli con quelli della vostra rete ;)
Rimane ora solo da aggiungere sui clients gli ip dei server DNS. Potete usare quelli
che ci sono sul server e aggiungerli al file /etc/resolv.conf