scp

Aggiungo qualche promemoria sull’utilizzo di scp (secure copy).

– Eseguire la copia di un file da host locale a host remoto:

$ scp nome_file utente@IP_ADDRESS_HOST_DESTINAZIONE://percorso/alla/dir/di/destinazione/

per copiare una intera directory aggiungere l’opzione “r” prima della sorgente dati, per esempio:

$ scp -r nome_directory utente@IP_ADDRESS_HOST_DESTINAZIONE://percorso/alla/dir/di/destinazione/

– Eseguire la copia di un file da host remoto a host locale:

$ scp utente@IP_ADDRESS_HOST_REMOTO://percorso/alla/dir/di/origine /percorso/alla/dir/di/destinazione/

linux | qualche tip, qualche trick…

rename

comando per rinominare uno o piu’ file; in particolare mi e’ tornato utile per rinominare una serie di immagini che presentavano alcune lettere maiuscuole, altre minuscole. Per riportare tutto a minuscolo:

$ rename ‘y/A-Z/a-z/’ *

In questo modo tutti i file presenti nella dir corrente vengono trattati e rinominati in lowercase.

Per rinominare una serie di file modificando soltanto una parte:

$ rename ‘s/stringa_vecchia/stringa_nuova/’ *

primo script in python | da gradi sessagesimali a gradi decimali

Pubblico il mio primo timido script “operativo ” in python. E’ frutto di un misto tra studio e tentativi vari spulciando tutorial in rete, un piccolo pocket libro e il famoso “diveintopython” :-).

Il lavoro che presento è l’evoluzione del piccolo script che, attendendo gli input dell’utente, converte i gradi, primi e secondi di un angolo in formato sessagesimale (una coordinata geografica in lat-lon per esempio) in formaro decimale (molto utile per l’elaborazione in molti programmi GIS).

In questo secondo step invece viene letto un file in formato .CSV contenente gli angoli nel formato gradi, primi, secondi (con la virgola come separatore) e viene generato un nuovo file (.CSV) con gli angoli convertiti nella forma decomale. Ecco lo script:

========================

from __future__ import division
angoli= open( “/home/sit/python/angoli.txt”, “r” ) # apre in lettura il file che contiene gli angoli da elaborare
angoli_trasformati=open(“/home/sit/python/angoli_trasformati.txt”, “w”) # genera un nuovo file che conterra’ i risultati
for angolo in angoli:
try:
g, p, s = angolo.strip().split( “,” ) # crea una tupla eliminando eventuali spazi tra valori e separandoli (i valori) con una virgola “,”
res =  float(g), float(p), float(s), (float(g)+(((float(s)/60)+float(p))/60)) # calcola il valore dell’angolo in formato decimale
print res
print>>angoli_trasformati, res # restituisce l’output sul file creato in precedenza
except ValueError:
pass
angoli.close() # chiude lo stat sul file aperto
angoli_trasformati.close() # chiude lo stat sul file generato

========================

ogni commento e’ benvenuto

il primo “hello world” in python

python logo

A distanza di qualche mese mi sono riavvicinato alla programmazione (una espressione “grossa” per me) tentando di rifare un esperimento: convertire un angolo dal formato gradi primi secondi a decimale.

Riporto il codice python:

gradi = input(‘scrivi i gradi: ‘)
primi = input(‘scrivi i primi: ‘)
secondi = input(‘scrivi i secondi: ‘)
print “l’angolo in formato decimale e'”,float(gradi)+(((float(secondi)/60)+float(primi))/60)

[per evitare di dichiarare ogni input come float() si puo’ importare il modulo divisione; ecco il codice modificato:

from __future__ import division
gradi = input(‘scrivi i gradi: ‘)
primi = input(‘scrivi i primi: ‘)
secondi = input(‘scrivi i secondi: ‘)
print “l’angolo in formato decimale e'”,gradi+(((secondi/60)+primi)/60)

il risultato non cambia]

salvandolo in un file che potermmo chiamare dms2dd.py ed eseguendolo otterremo quanto richiesto:

$ python2.7 dms2dd.py
scrivi i gradi: 45
scrivi i primi: 5
scrivi i secondi: 5
l’angolo in formato decimale e’ 45.0847222222

il primo “Hello world” in C

Non sono un programmatore; non conosco nessun linguaggio di programmazione. Per questo, approfittando di una piccola necessita’ lavorativa, mi sono avvicinato al C.

Bazzicando in rete ho trovato alcuni “punti di partenza” molto ben fatti:

introduzione alla programmazione in C;

piccolo corso di programmazione in C;

E da qui ne e’ uscito un piccolo programmino per convertire le coordinate geografiche (lat/long) da DMS (Gradi Primi Secondi) a DD (Gradi decimali).

L’ho scritto usato l’editor “nano” (semplice quanto efficace editor che offre colorazione del testo ben fatta).

Una volta scritto il testo sottostante salvarlo con il nome di “primo_test.c” (i codici sorgente in C vengono contraddistinti dal suffisso .c).

#include <stdio.h>
float a,b,c,d;
main()
{
printf(“inserisci i gradi:  \n”);
scanf(“%f”, &a);
printf(“inserisci i primi: \n”);
scanf(“%f”, &b);
printf(“inserisci i secondi: \n”);
scanf(“%f”, &c);
d=a+(((c/60)+b)/60);
printf(“l’angolo in formato decimale e’ %f \n”, d);
}

Una volta salvato il codice deve essere compilato. Per fare questo ho usato il compilatore “gcc” mediante la seguente sintassi:

$ gcc primo_test.c -o primo_test.out

Viene creato un file eseguibile chiamato primo_test.out (nel caso non avessimo indicato il nome del file di outptu, gcc avrebbe nominato il file “a.out”).

Il programma si lancia con il comando

$ ./primo_test.out

Vediamo il codice. All’inizio del testo viene indicata la libreria da caricare per eseguire le operazioni (#include <stdio.h>).

Poi si passa al processo. Stampa a console la richiesta di inserire i valore dei gradi dell’angolo da convertire; fatto questo cattura il valore inserito e lo memorizza nella prima variabile dichiarata (di tipo float). Poi chiede di inserire il valore del primi e memorizza il valore nella seconda variabile. Infine richiede i secondi e li memorizza nella terza variabile.

Fatto questo esegue l’operazione di conversione e propone in output il valore dell’angolo calcolato.

script per backup periodici di database postgresql/postgis

Una delle cose belle di Linux e’ che ti spinge a curiosare nel suo “mondo”; si scoprono cose davvero fantastiche per quanto semplici.

Per esempio: avevo necessita’ di eseguire un backup di alcuni database potgresql/postgis in maniera continua (su HD removibile HP RDX 320 GB)

Ho creato uno script per fare tutto cio’; in un secondo momento ho modificato il CRONTAB della macchina per fare in modo che questo script venga eseguito ad una certa ora del giorno.

Partiamo dall’inizio:

– con l’editor “nano” creiamo il file “backup.sh” nella directory “/usr/bin/

cd /usr/bin

nano backup.sh

e lo compiliamo nel modo seguente:

#!/bin/bash

export PGPASSWORD=”mia_password_del_db” && pg_dump -h localhost -U user -c -d -R -v nome_database -n nome_schema > /percorso/dove/salvare/il/file.sql

L’istruzione “export PGPASSWORD=”mia_password_del_db” permette di dichiarare la password stessa senza doverla inserire ogni volta che lo script viene lanciato (questo renderebbe inutile un backup notturno in quanto il prompt si aspetterebbe l’immissione della pwd a mano).

Chiudiamo nano e salviamo il file. Rendiamolo eseguibile (da root):
# chmod +x /usr/bin/backup.sh

Modifichiamo il crontab per eseguirlo ad una certa ora del giorno:

@ crontab -e

e inseriamo le seguent righe:

00 04 * * * /usr/bin/backup.sh

In questo modo il backup viene lanciato ogni giorno alle 4 di mattina.

qgis | compilazione in Debian

Mi sono buttato nella compilazione di qgis.
Grazie alle dritte di Paolo Cavallini ho provato per la prima volta su Debian Lenny.

A distanza di qualche mese ho riprovato tutta la procedura di Debian Sid: le istruzioni qui riportate fanno riferimento a questa distribuzione.
Ad oggi (settembre 2011) i sorgenti di QGIS sono reperibili su github e non più su SVN. Pertanto la procedura riportata qualche mese fa (la tengo comunque per memoria e viene indicata in coda al post in grigetto) viene aggiornata.

Tutto quanto segue è spiegato benissimo in questa pagina wiki di QGIS. Unica differenza: il comando per il recupero dei sorgenti da git hub indicato “git clone git://github.com/qgis/Quantum-GIS.git” non funziona. Dopo qualche secondo compare un messaggio di time-out. Sostituendolo con il seguente “git clone https://github.com/qgis/Quantum-GIS.git” (come indicato qui:”http://www.qgis.org/wiki/Using_Git“) tutto funziona a dovere.

Riporto qui i passaggi importanti testati su Debian Sid (unstable).

– Preparazione dell’ambiente installando i pacchetti necessari via apt-get (o synaptic):

# apt-get install build-essential debhelper bison cmake doxygen flex graphviz grass-dev libexpat1-dev libfcgi-dev libgdal1-dev libgeos-dev libgsl0-dev libpq-dev libproj-dev libqt4-dev libqtwebkit-dev libqwt5-qt4-dev libspatialite-dev libsqlite3-dev pkg-config pyqt4-dev-tools python python-dev python-qt4 python-qt4-dev python-sip python-sip-dev txt2tags

– Creiamo le directory necessarie:

$ mkdir -p ${HOME}/dev/cpp

– poi ci spostiamo nella nuova directory “cpp”

cd ${HOME}/dev/cpp

– scarichiamo da github i sorgenti di QGIS con il comando:

$ git clone https://github.com/qgis/Quantum-GIS.git

Questo crea una nuova directory “Quantum-GIS” e vi scarica all’interno i sorgenti.

– Ci spostiamo all’interno:

$ cd Quantum-GIS

– e creiamo una nuova directory “build-master”; al suo interno lanceremo la compilazione:

$ mkdir build-master

– Entriamo

$ cd build-master

e lanciamo ccmake

$ ccmake .. -Wno-dev

il sistema preparerà l’ambiente per la compilazione fornendoci una serie di opzioni.

– abilitare i “global python bindings” schiacciando INVIO (la voce cambia da “OFF” a “ON”)
– dare “c” (sta per “configure”). A questo punto possono presentarsi dei messaggi di errore. Nel mio caso mi avvertiva della mancanza di alcune librerie (libgsl e altro…). Uscire con “e”, poi “q” (quit) e installare i pacchetti necessari (se abbiamo installato come da istruzioni sopra, non dovrebbero comunque esserci problemi).

– dare nuovamente il comando “c” e poi “g” (sta per “generate”). Dovrebbe tornare la console; questo indica che tutto è pronto per la compilazione.

– Impartiamo ora il make. Facendo tesoro di un post di Alessandro Furieri in cui riporta un trucchetto eccezionale per velocizzare il processo di make lanciamo il comando

$ make -j4

il suffisso “j4” indica a make di eseguire la compilazione in 4 thread paralleli. Il risultato è una compilazione molto più veloce che sottopone la CPU ad un carico costante del 100% ca.

– Infine installiamo (da root) con il classico:

# make install

—————————————————————————————————————-

In alternativa alla compilazione diretta è possibile crearsi i pacchetti “.deb”. Per fare questo risaliamo di una posizione con:

$ cd ..

e poi diamo il comando (come root):

# dpkg-buildpackage -us -uc -b

Questo creerà tutti i pacchetti necessari nella directory “Quantum-GIS”.

Risaliamo quindi di una posizione e installiamo tutti i pacchetti con:

# dpkg -i *.deb

Durante l’installazione è comparso un messaggio d’errore: ” Si sono verificati degli errori nell’eleborazione: libqgis-dev”. Verificando le dipendenze di questo pacchetto mi sono accorto della mancanza di “qt4-designer”. Installato questo tutto è andato a posto.

<inizio vecchia procedura>

– Creare una directory di lavoro (es: compila_qgis):
$ mkdir compila_qgis
Spostarsi dentro la directory appena creata:
$ cd compila_qgis
E’ necessario avere installato alcuni pacchetti. Li installiamo:
# apt-get install subversion cmake flex bison libgsl0-dev libboost-python-dev python-eggtrayicon python-foomatic python-gnome2 python-gps python-gtkhtml2 python-gtkmozembed python-qt4-dev python-reportlab python-svn grass-dev libqt4-gui sharutils sip4 libqwt5-qt4-dev libqt4-core pyqt4-dev-tools qt4-qmake libqt4-dev libgdal-dev libncurses5-dev dpkg-dev debhelper libexpat1-dev libxext-devlibfontconfig1-dev proj libxi-dev libxrandr-dev libxrender-dev libice-dev libsm-devcmake-curses-gui

Molto probabilmente non tutti sono necessari ma averli non fa male 🙂
Poi scarichiamo l’svn con:
$ svn co https://svn.osgeo.org/qgis/trunk/qgis qgis_unstable
– creiamo le directory necessarie
$ mkdir qgis_unstable/build/
– ci spostiamo dentro:
$ cd qgis_unstable/build/
– diventare root e poi:
# ccmake .. -Wno-dev
– abilitare i “global python bindings” schiacciando INVIO (la voce cambia da “OFF” a “ON”)
– dare “c” (sta per “configure”). A questo punto possono presentarsi dei messaggi di errore. Nel mio caso mi avvertiva della mancanza di alcune librerie (libgsl e altro…). Uscire con “e”, poi “q” (quit) e installare i pacchetti necessari (se abbiamo installato come da istruzioni sopra, non dovrebbero cmq esserci problemi).
– ritornare in cmake con
# ccmake .. -Wno-dev
In questo modo si apre (sempre nella console) un pannello per impartire comandi di cmake (il compilatore).
– dare ancora il comando “c”, poi “g”: in questo modo si generano gli script necessari. Il pannello di cmake si chiude da se e ci ritroviamo con la console.
A questo punto risalire alla directory superiore con:
# cd ..
– lanciare il comando per la creazione dei .deb
# dpkg-buildpackage -us -uc -b
– vengono visualizzati una serie di log di comandi (nel mio caso, ad un certo punto si e’ fermato perche’ non trovava “grass-dev” e “libqt4-dev”; installato questi e re-impartito il comando di creazione dei pacchetti)
– si risale nuovamente di una posizione:
# cd ..
– si installano i .deb generati:
# dpkg -i *.deb

Se tutto e’ andato a buon fine ritorna la console con #.
Lanciare qgis:
$ qgis [INVIO]

Per le successive compilazioni basta impartire il comando:
$ svn up https://svn.osgeo.org/qgis/trunk/qgis qgis_unstable
in modo da aggiornare la versione SVN scaricata.
Poi continuare nuovamente con i comandi riportati sopra.
Può succedere che durante la fase di creazione del pacchetti “# dpkg-buildpackage -us -uc -b” venga riportato un errore di conflitti con alcuni pacchetti (nel mio caso qgis-dev e libqgis-dev). Rimuovere il pacchetto libqgis1.2.0-dev. Eventualmente (se non si conosce il nome del pacchetto) può essere utile usare il comando:
# dpkg –list | grep qgis
In questo modo troviamo tutti i pacchetti relativi a qgis e possiamo facillmente individuare quelli “scomodi”. Per rimuoverli (compresi i file di configurazione) impartire:

# dpkg –purge nome_pacchetto (p.e.: # dpkg –purge libqgis1.2.0-dev)

Quindi re-impartire il comando di creazione dei pacchetti.

</fine vecchia procedura>